eventserver.h

linux的事件机制

#ifndef _EVENT_SERVER_DEF
#define _EVENT_SERVER_DEF

#include "eventLib.h"	
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#define MAX_CLIENTS 20
#define MAX_ERROR 10
#define MAX_PENDING 30

/* management struct */
typedef struct list_node{
    struct list_node *pnext; 
}list_node;

enum events_status{
    CLI_INITIAL = 0,
    CLI_DISPATCHED,
    CLI_REQUESTED,
    CLI_ERROR
};

typedef struct client_node{
    char client_name[MAX_LEN_NAME+1];
    pid_t pid;
    int sig;
    BOOL req_ignore;
    events_t related_events;
    events_t occur_events;
    enum events_status status;
    int num_error;
    struct list_node list[MAX_EVENTS];
}client_node;

typedef struct event_node{
    struct list_node head;
    long num_inform;
}event_node;

struct event_node g_event_table[MAX_EVENTS];

struct client_node g_client_table[MAX_CLIENTS];

#define is_client_index_invalid(index)\
            ((0 <= index && index < MAX_CLIENTS)? 0 : 1)

#define evaluate_entry(i, element, value)\
            g_client_table[i].element = value

/* list operation */
void 
list_node_initial(struct list_node *pnode){
    pnode->pnext = NULL;
}

struct list_node * 
get_next(struct list_node *pnode){
    return pnode->pnext;
}

void 
list_insert(struct list_node *pnew, struct list_node *pprev){
    pnew->pnext = pprev->pnext;
    pprev->pnext = pnew;
}

void 
_list_delete(struct list_node *pdel, struct list_node *pprev){
    pprev->pnext = pdel->pnext;
    pdel->pnext = NULL;
}

int 
list_delete(struct list_node *pdel, struct list_node *phead){
    struct list_node **p_trace = &(phead->pnext);
    for ( ; (*p_trace != pdel) && (*p_trace != NULL);\
        p_trace = &((*p_trace)->pnext)){
    }
    if (NULL == *p_trace){
        return -1;
    }
		
    (*p_trace) = pdel->pnext;
    pdel->pnext = NULL;
    return 0;			
}

#define offsetof(TYPE, MEMBER) ((unsigned int) &((TYPE *)0)->MEMBER)
#define container_of(ptr, type, member) ({\
	    const typeof( ((type *)0)->member ) *__mptr = (ptr);\
        (type *)( (char *)__mptr - offsetof(type,member));})

void 
debug_printf_list(events_t types){
    if (is_events_invalid(types)){
        return;
    }
    struct list_node *p_trace = NULL;
    struct client_node *p_node = NULL;
    int i;
    ETYPE2INDEX_START(types, i)
    p_trace = &g_event_table[i].head;
    p_trace = p_trace->pnext;
    for ( ; p_trace != NULL; p_trace = p_trace->pnext){
        p_node = container_of(p_trace,\
                              struct client_node,\
                              list[i]\
                              );
        debug_printf("pid = %d, name = %s|",\
                     p_node->pid,\
                     p_node->client_name\
                     );
    }
    debug_printf("\n");
    ETYPE2INDEX_END
}

/* event_table operation */
void
initial_event_table(void){
    int i;
    for (i = 0; i < MAX_EVENTS; i++){
         g_event_table[i].head.pnext = NULL;
         g_event_table[i].num_inform = 0;
    }
}

int 
inc_inform_counts(events_t types){
    if (is_events_invalid(types)){
        return -1;
	  }
    int i;
    ETYPE2INDEX_START(types, i)
    ++g_event_table[i].num_inform;
    ETYPE2INDEX_END
    return 0;
}

void
debug_printf_event_table(void){ 
    int i;
    ETYPE2INDEX_START(EVENTS_MASK, i)
    debug_printf("event = %d, num = %d\n",\
                 i+1, g_event_table[i].num_inform);
    ETYPE2INDEX_END
}

/* client_table operation */
void 
initial_client_table(void){
    int i;
    for (i = 0; i < MAX_CLIENTS; i++){
         memset(&g_client_table[i],\
                0,\
                sizeof(g_client_table[i])\
                );
    }
}

static int
name_safe_copy(char *dest, const char *src){
    if ((src == NULL) || (dest == NULL)){
        return -1;
	  }
    int str_len = 0;
    str_len = strlen(src);
    memset(dest, 0, MAX_LEN_NAME+1);
    memcpy(dest,\
           src,\
           (str_len > MAX_LEN_NAME)? MAX_LEN_NAME: str_len\
           );
    return 0;
}

BOOL  
check_exist(const char *p_name, int *p_index){
	  char name_cp[MAX_LEN_NAME+1];
	  name_safe_copy(name_cp, p_name); 
	  int i;
    for (i = 0; i < MAX_CLIENTS; i++){
         if ((g_client_table[i].pid != 0)
             && !strcmp(name_cp, g_client_table[i].client_name)){
             if (NULL != p_index)
                 *p_index = i;
        	   return 1;
         }
    }
	  return 0;
}

int 
get_unused_client_entry(void){
    int i;
    for (i = 0; i < MAX_CLIENTS; i++){
        if (0 == g_client_table[i].pid){
            return i;
        }
    }
    return -1;
}

int 
new_entry(pid_t pid,  char *p_name, events_t related_events,\
          int num_sig, BOOL req_ignore){
    if ((pid <= 0) || (p_name == NULL)\
        || is_events_invalid(related_events)){
        return -1;
	  }
    if (check_exist(p_name, NULL)){
        debug_printf("NEW ENTER: name has been exist\n");
        return -1;
    }
    int new_index;
    new_index = get_unused_client_entry();
    if (-1 == new_index)
        return -1;
   
    memset(&g_client_table[new_index],\
           0,\
           sizeof(g_client_table[new_index])\
           );
    name_safe_copy(g_client_table[new_index].client_name, p_name);
    evaluate_entry(new_index, pid, pid);
    evaluate_entry(new_index, related_events, related_events);
    evaluate_entry(new_index, sig, num_sig);
    evaluate_entry(new_index, req_ignore, req_ignore);
    /* insert to the list */
    int i;
    ETYPE2INDEX_START(related_events, i)
    list_insert(&g_client_table[new_index].list[i],\
                &g_event_table[i].head);
    ETYPE2INDEX_END
    return 0;
}

int
delete_entry(const char *p_name){
    int index;
    if (!check_exist(p_name, &index)){
        return -1;
    }
    /* change the list struct */
    int i;
    ETYPE2INDEX_START(g_client_table[index].related_events, i)
    list_delete(&g_client_table[index].list[i],\
                &g_event_table[i].head);
    ETYPE2INDEX_END
    memset(&g_client_table[index],\
           0,\
           sizeof(g_client_table[index])\
           );
    return 0;
}

void 
clear_occur_events(events_t events){
    struct list_node *p_head = NULL;
    struct list_node *p_next = NULL;
    struct client_node *p_client = NULL;
    int i;
    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 = 0;
    }
    ETYPE2INDEX_END
}

int 
inc_error_count(int entry_index){
    ++g_client_table[entry_index].num_error;
    return 0;
}

int
clear_error_count(int entry_index, events_t types){
    g_client_table[entry_index].num_error = 0;
    return 0;
}

void 
debug_printf_client_table(void){
    int i;
    for (i = 0; i < MAX_CLIENTS; i++){
         debug_printf("name = %s, pid = %d, events = %d |",\
                      g_client_table[i].client_name,\
                      g_client_table[i].pid,\
                      g_client_table[i].related_events\
                     );
	  }
    debug_printf("\n");
}

#endif