eventserver.c

linux的事件机制

#include "eventLib.h"
#include "eventServer.h"
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <signal.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <sys/types.h>

void
dispatch_signal_to_clients(events_t events){
	/* the operation of this function is travel through the list.
	   these code thinked confused,that is because the same node
	   can be occur in differnts lists,many codes just to supply
	   this attribute.
	 */
    struct list_node *p_head = NULL;
    struct list_node *p_next = NULL;
    struct client_node *p_client = NULL;
    events_t check_complete;
    int i;
    clear_occur_events(events);
    ETYPE2INDEX_START(events, i)
    p_head = &g_event_table[i].head;
    p_next = get_next(p_head);
    for ( ; NULL != p_next; p_next = get_next(p_next)){
         p_client = container_of(p_next,\
                                 struct client_node,\
                                 list[i]\
                                 );
          /* set client status */
          p_client->occur_events |= (1<<i);
          check_complete = (p_client->related_events & events);
          if (check_complete == p_client->occur_events){
              /* check error */
              if (!p_client->req_ignore\
            	   && (p_client->status != CLI_REQUESTED)){
                    ++p_client->num_error;
              }
              kill(p_client->pid, p_client->sig);
              if (p_client->req_ignore){
                  p_client->status = CLI_REQUESTED;
              } else{
                  p_client->status = CLI_DISPATCHED;
              }
          }/* do once in last event */
    }/* for list through */
    ETYPE2INDEX_END
}

int 
handle_inform(struct event_frame *p_frame){
    events_t events;
    events = p_frame->body.inform.inf_events;
    if (is_events_invalid(events)){
        debug_printf("handle_inform error\n");
        return -1;
    }
    inc_inform_counts(events);
    
    debug_printf("Inf: events = %d\n", events);
    debug_printf_event_table();
    dispatch_signal_to_clients(events);
}

int
handle_register(SOCKET s_client, struct event_frame *p_frame){
    debug_printf("handle_register\n");
    int reg_ok;
    reg_ok = new_entry(p_frame->body.reg.reg_pid,\
                       p_frame->body.reg.reg_name,\
                       p_frame->body.reg.reg_events,\
                       p_frame->body.reg.reg_sig,\
                       p_frame->body.reg.reg_ignore\
                      );
    if (reg_ok == -1){
        debug_printf("%s: register failure\n");
        send_ack(s_client, 0);
        return -1;
    } else{
        debug_printf("%s: register success\n");
        send_ack(s_client, 1);
        debug_printf_list(EVENTS_MASK);
        return 0;
    }
}

int
handle_unregister(struct event_frame *p_frame){
	 char *p_name = p_frame->body.unreg.unreg_name;
	 if (-1 == delete_entry(p_name)){
       debug_printf("handle_unregister error\n");
       return -1;
	 }
	 debug_printf_list(EVENTS_MASK);
	 return 0;
}

int 
handle_request(SOCKET s_req, struct event_frame *p_frame){
    int index;
    char *p_name = p_frame->body.request.request_name;
		if (!check_exist(p_name, &index)){
		    return -1;
		}

    events_t e_rep;
    e_rep = g_client_table[index].occur_events;
    g_client_table[index].status = CLI_REQUESTED;
    g_client_table[index].num_error = 0;
    struct event_frame f_resp;
		f_resp.type = FRAME_REPONSE;
		f_resp.body.reponse.reponse_events = e_rep;
		return _send_frame(s_req, &f_resp);
}

void 
handle_recv_frame(SOCKET s_recv, struct event_frame *p_frame){
    switch(p_frame->type){
    case FRAME_INFORM:
        handle_inform(p_frame);
        break;
    case FRAME_REGISTER:
        handle_register(s_recv, p_frame);
        break;
#if defined UNREGISTER_SUPPORTED
    case FRAME_UNREGISTER:
        handle_unregister(p_frame);
        break;
#endif
    case FRAME_REQUEST:
        handle_request(s_recv, p_frame);
        break;
    default:
        debug_printf("unknown frame type\n");
	  }
}

static void
monitor_server(SOCKET s_monitor){
    struct sockaddr_in sock_remote = {0};
    SOCKET s_remote = INVALID_SOCKET;
    int i_addr_size = sizeof(sock_remote);

    struct timeval timeout = {0};
    timeout.tv_sec = 0;
    timeout.tv_usec = 10000;
    fd_set monitor_fdset;
    FD_ZERO(&monitor_fdset);
    FD_SET(s_monitor, &monitor_fdset);
		
    select(s_monitor + 1, &monitor_fdset, NULL, NULL, &timeout);
    if (FD_ISSET(s_monitor, &monitor_fdset)){
        /* inform or register */
        s_remote = accept(s_monitor,\
                          (struct sockaddr*)&sock_remote,\
                          &i_addr_size\
                          );
        if (INVALID_SOCKET == s_remote){
            perror("call to accept:");
            return;
        }
        struct event_frame recv_frame;
        if (-1 == _receive_frame(s_remote, &recv_frame)){
            debug_printf("receive frame error\n");
            close_socket(&s_remote);
            return;
        }
        handle_recv_frame(s_remote, &recv_frame);
    } 
    close_socket(&s_remote);
}

static int 
setup_server(SOCKET *s_server, struct sockaddr *p_sock){
    *s_server = socket(AF_INET, SOCK_STREAM, 0);

    if (INVALID_SOCKET == *s_server){
        perror("call to socket:");
        return -1;
    }
    struct linger m_sLinger;
    m_sLinger.l_onoff = 1; 
    m_sLinger.l_linger = 0;
    setsockopt(*s_server, SOL_SOCKET, SO_LINGER,\
		       &m_sLinger, sizeof(m_sLinger));

    int sock_len = sizeof(struct sockaddr);
    if (-1 == bind(*s_server, p_sock, sock_len)){
        perror("call to bind");
        return -1;
    }

    if (-1 == listen(*s_server, MAX_PENDING)){
        perror("call to listen");
        return -1;
    }
    return 0;
}

static int
before_monitor(SOCKET *p_monitor){
    *p_monitor = INVALID_SOCKET;
    struct sockaddr_in sock_monitor = {0};
    sock_monitor.sin_family = AF_INET;
    sock_monitor.sin_port = htons(EVENT_MONITOR_PORT);
    sock_monitor.sin_addr.s_addr = inet_addr(EVENT_MONITOR_ADDR);
    if (-1 == setup_server(p_monitor, &sock_monitor)){
        return -1;
    }
    return 0;
}

int main(int argc, char *argv[]){
    daemon(0, 1);
    initial_client_table();
    initial_event_table();

    SOCKET s_monitor = INVALID_SOCKET;
    int setup_ok;
    setup_ok = before_monitor(&s_monitor);
    if (-1 == setup_ok){
        close_socket(&s_monitor);
        exit(EXIT_FAILURE);
    }
    debug_printf("start up ok\n");

    while (1){
        monitor_server(s_monitor);
        //other check....s_server..
    }
}