sloop公共函数之添加信号，定时器及socket

1：添加信号

　　1.1 原型：sloop_handle sloop_register_signal(int sig, sloop_signal_handler handler, void * param)

 /* register a signal handler */
 sloop_handle sloop_register_signal(int sig, sloop_signal_handler handler, void * param)
 {
     struct sloop_signal * entry;
     struct sigaction sa;

     sa.sa_handler = sloop_signals_handler;
     sigemptyset(&sa.sa_mask);
     sa.sa_flags = SA_RESTART;

     /* allocate a new structure sloop_signal */
     entry = get_signal();
     if (entry == NULL)
         return NULL;

     /* setup structure and insert into list. */
     entry->sig = sig;
     entry->param = param;
     entry->handler = handler;
     dlist_add(&entry->list, &sloop.signals);
     SLOOPDBG(d_dbg("sloop: sloop_register_signal(%d)\n", sig));
     if (sigaction(sig, &sa, NULL) < ) {
         dlist_del(&entry->list);
         free_signal(entry);
         d_error("sigaction %d error %s\n", sig, strerror(errno));
         return NULL;
     }

     return entry;
 }

　　这个函数提供给使用sloop模块的第三方，只需要传入要监听的信号、信号处理函数、参数，就可以将此信号登记到sloop_data结构体中的struct dlist_head signals链表中，在sloop_run函数中进行监听。get_signal函数是从初始化时的struct dlist_head free_signals链表中取出一个可用的节点挂在struct dlist_head signals链表中。具体实现如下：

 /* get signal from pool */
 static struct sloop_signal * get_signal(void)
 {
     struct dlist_head * entry;
     struct sloop_signal * target;

     if (dlist_empty(&sloop.free_signals)) {
         d_error("sloop: no sloop_signal available !!!\n");
         return NULL;
     }
     entry = sloop.free_signals.next;
     dlist_del(entry);
     target = dlist_entry(entry, struct sloop_signal, list);
     target->flags = SLOOP_INUSED | SLOOP_TYPE_SIGNAL;
     return target;
 }

　　flags参数主要是为了标识此节点的类型，有三种类型，SLOOP_TYPE_SOCKET、SLOOP_TYPE_TIMEOUT、SLOOP_TYPE_SIGNAL。

　　1.2 一般使用方法

　　    sloop_register_signal(SIGTERM, sig_term,    NULL)；登记SIGTERM信号的处理函数是sig_term，没有要传递的参数。

2：添加定时器

　　2.1 原型：sloop_handle sloop_register_timeout(unsigned int secs, unsigned int usecs, sloop_timeout_handler handler, void * param)

　　同添加信号的实现思路是一样的，需要传递的参数是定时器的秒和微妙参数。

 /* register a timer  */
 sloop_handle sloop_register_timeout(unsigned int secs, unsigned int usecs, sloop_timeout_handler handler, void * param)
 {
     struct sloop_timeout * timeout, * tmp;
     struct dlist_head * entry;

     /* allocate a new struct sloop_timeout. */
     timeout = get_timeout();
     if (timeout == NULL) return NULL;

     /* get current time */
     gettimeofday(&timeout->time, NULL);
     timeout->time.tv_sec += secs;
     timeout->time.tv_usec += usecs;

     while (timeout->time.tv_usec >= ) {
         timeout->time.tv_sec++;
         timeout->time.tv_usec -= ;
     }
     timeout->handler = handler;
     timeout->param = param;
     INIT_DLIST_HEAD(&timeout->list);

     /* put into the list */
     if (dlist_empty(&sloop.timeout)) {
         dlist_add(&timeout->list, &sloop.timeout);
         SLOOPDBG(d_dbg("sloop: timeout(0x%x) added !\n", timeout));
         return timeout;
     }

     entry = sloop.timeout.next;
     while (entry != &sloop.timeout) {
         tmp = dlist_entry(entry, struct sloop_timeout, list);
         if (timercmp(&timeout->time, &tmp->time, < )) break;
         entry = entry->next;
     }
     dlist_add_tail(&timeout->list, entry);
     SLOOPDBG(d_dbg("sloop: timeout(0x%x) added !!\n", timeout));
     return timeout;
 }

　　2.2 一般使用方法

　　sloop_register_timeout(1, 0, wan_handler, param)；在登记之后的1秒执行函数wan_handler。

3：添加套接字

　　3.1 原型：套接字分为监听可读或可写两种

/* register a read socket */
sloop_handle sloop_register_read_sock(int sock, sloop_socket_handler handler, void * param)
{
    return register_socket(sock, handler, param, &sloop.readers);
}

/* register a write socket */
sloop_handle sloop_register_write_sock(int sock, sloop_socket_handler handler, void * param)
{
    return register_socket(sock, handler, param, &sloop.writers);
}

　　　分别挂载到sloop.readers和sloop.writers链表上。

 static struct sloop_socket * register_socket(int sock,
         sloop_socket_handler handler, void * param, struct dlist_head * head)
 {
     struct sloop_socket * entry;

     /* allocate a new structure sloop_socket */
     entry = get_socket();
     if (entry == NULL) return NULL;

     /* setup structure and insert into list. */
     entry->sock = sock;
     entry->param = param;
     entry->handler = handler;
     dlist_add(&entry->list, head);
     SLOOPDBG(d_dbg("sloop: new socket : 0x%x (fd=%d)\n", (unsigned int)entry, entry->sock));
     return entry;
 }

　　get_socket实现：

 /* get socket from pool */
 static struct sloop_socket * get_socket(void)
 {
     struct dlist_head * entry;
     struct sloop_socket * target;

     if (dlist_empty(&sloop.free_sockets)) {
         d_error("sloop: no sloop_socket available !!!\n");
         return NULL;
     }
     entry = sloop.free_sockets.next;
     SLOOPDBG(daig_printf("%s: get socket sd=[%x],\n", __FILE__, entry));
     dlist_del(entry);
     target = dlist_entry(entry, struct sloop_socket, list);
     target->flags = SLOOP_INUSED | SLOOP_TYPE_SOCKET;
     return target;
 }

综上：

　　这就是这四种功能的实现思路及使用方式。