[BACK]Return to srv.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / src

Diff for /libaitrpc/src/srv.c between versions 1.12.2.1 and 1.12.2.3

version 1.12.2.1, 2012/11/16 08:33:06 version 1.12.2.3, 2012/11/16 10:20:55
Line 46  SUCH DAMAGE. Line 46  SUCH DAMAGE.
 #include "global.h"  #include "global.h"
   
   
   /* SOCK_STREAM */
 static void *acceptClients(sched_task_t *);  static void *acceptClients(sched_task_t *);
 static void *closeClient(sched_task_t *);  static void *closeClient(sched_task_t *);
static sched_task_func_t cbProto[SOCK_RAW][2] = {static void *rxPacket(sched_task_t *);
        { acceptClients, closeClient }, static void *txPacket(sched_task_t *);
        { acceptClients, closeClient }, 
        { NULL, NULL }/* SOCK_DGRAM */
 static void *connectClients(sched_task_t *);
 static void *disconnectClient(sched_task_t *);
 
 /* SOCK_RAW */
 
 static sched_task_func_t cbProto[SOCK_RAW + 1][4] = {
         { acceptClients, closeClient, rxPacket, txPacket }, /* SOCK_STREAM */
         { acceptClients, closeClient, rxPacket, txPacket }, /* SOCK_STREAM */
         { connectClients, disconnectClient, NULL, NULL }, 
         { NULL, NULL, NULL, NULL }                          /* SOCK_RAW */
 };  };
   
   
   static rpc_cli_t *
   _allocClient(rpc_srv_t * __restrict srv)
   {
           rpc_cli_t *c = NULL;
           register int i;
   
           /* check free slots for connect */
           for (i = 0; i < io_arraySize(srv->srv_clients) && 
                           (c = io_array(srv->srv_clients, i, rpc_cli_t*)); i++);
           if (c)  /* no more free slots! */
                   return NULL;
   
           c = io_malloc(sizeof(rpc_cli_t));
           if (!c) {
                   LOGERR;
                   srv->srv_kill = 1;
                   return NULL;
           } else {
                   memset(c, 0, sizeof(rpc_cli_t));
                   io_arraySet(srv->srv_clients, i, c);
                   c->cli_id = i;
                   c->cli_parent = srv;
           }
   
           /* alloc empty buffer */
           AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf);
   
           return c;
   }
   
   
 static void *  static void *
   connectClients(sched_task_t *task)
   {
           rpc_srv_t *srv = TASK_ARG(task);
           rpc_cli_t *c = NULL;
           socklen_t salen = sizeof(io_sockaddr_t);
   
           c = _allocClient(srv);
           if (!c)
                   goto end;
   
           /* accept client */
           c->cli_sock = accept(TASK_FD(task), &c->cli_sa.sa, &salen);
           if (c->cli_sock == -1) {
                   LOGERR;
                   AIT_FREE_VAL(&c->cli_buf);
                   io_arrayDel(srv->srv_clients, c->cli_id, 42);
                   goto end;
           } else
                   fcntl(c->cli_sock, F_SETFL, fcntl(c->cli_sock, F_GETFL) | O_NONBLOCK);
   
           schedRead(TASK_ROOT(task), cbProto[srv->srv_proto][CB_RXPACKET], c, 
                           c->cli_sock, NULL, 0);
   end:
           schedReadSelf(task);
           return NULL;
   }
   
   static void *
   disconnectClient(sched_task_t *task)
   {
           rpc_cli_t *c = TASK_ARG(task);
           rpc_srv_t *s = c->cli_parent;
   
           schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);
   
           /* free buffer */
           AIT_FREE_VAL(&c->cli_buf);
   
           io_arrayDel(s->srv_clients, c->cli_id, 0);
           if (c)
                   io_free(c);
           return NULL;
   }
   
   static void *
 closeClient(sched_task_t *task)  closeClient(sched_task_t *task)
 {  {
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
Line 197  rxPacket(sched_task_t *task) Line 284  rxPacket(sched_task_t *task)
   
         if (!off)          if (!off)
                 memset(buf, 0, AIT_LEN(&c->cli_buf));                  memset(buf, 0, AIT_LEN(&c->cli_buf));
         else  
                 memmove(buf, buf + off, AIT_LEN(&c->cli_buf) - off);  
         rlen = recv(TASK_FD(task), buf + off, AIT_LEN(&c->cli_buf) - off, 0);          rlen = recv(TASK_FD(task), buf + off, AIT_LEN(&c->cli_buf) - off, 0);
         if (rlen < 1) {          if (rlen < 1) {
                 /* close connection */                  /* close connection */
Line 258  rxPacket(sched_task_t *task) Line 343  rxPacket(sched_task_t *task)
   
                 /* send RPC reply */                  /* send RPC reply */
                 if (!noreply)                  if (!noreply)
                        schedWrite(TASK_ROOT(task), txPacket, TASK_ARG(task), TASK_FD(task), rpc, len);                        schedWrite(TASK_ROOT(task), cbProto[s->srv_proto][CB_TXPACKET], 
                                         TASK_ARG(task), TASK_FD(task), rpc, len);
   
                 off += len;                  off += len;
         } while (rlen > 0);          } while (rlen > 0);
Line 273  acceptClients(sched_task_t *task) Line 359  acceptClients(sched_task_t *task)
 {  {
         rpc_srv_t *srv = TASK_ARG(task);          rpc_srv_t *srv = TASK_ARG(task);
         rpc_cli_t *c = NULL;          rpc_cli_t *c = NULL;
         register int i;  
         socklen_t salen = sizeof(io_sockaddr_t);          socklen_t salen = sizeof(io_sockaddr_t);
   
        /* check free slots for connect */        c = _allocClient(srv);
        for (i = 0; i < io_arraySize(srv->srv_clients) &&         if (!c)
                        (c = io_array(srv->srv_clients, i, rpc_cli_t*)); i++); 
        if (c)      /* no more free slots! */ 
                 goto end;                  goto end;
         c = io_malloc(sizeof(rpc_cli_t));  
         if (!c) {  
                 LOGERR;  
                 srv->srv_kill = 1;  
                 return NULL;  
         } else {  
                 memset(c, 0, sizeof(rpc_cli_t));  
                 io_arraySet(srv->srv_clients, i, c);  
                 c->cli_id = i;  
                 c->cli_parent = srv;  
         }  
   
         /* alloc empty buffer */  
         AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf);  
   
         /* accept client */          /* accept client */
         c->cli_sock = accept(TASK_FD(task), &c->cli_sa.sa, &salen);          c->cli_sock = accept(TASK_FD(task), &c->cli_sa.sa, &salen);
         if (c->cli_sock == -1) {          if (c->cli_sock == -1) {
                 LOGERR;                  LOGERR;
                 AIT_FREE_VAL(&c->cli_buf);                  AIT_FREE_VAL(&c->cli_buf);
                io_arrayDel(srv->srv_clients, i, 42);                io_arrayDel(srv->srv_clients, c->cli_id, 42);
                 goto end;                  goto end;
         } else          } else
                 fcntl(c->cli_sock, F_SETFL, fcntl(c->cli_sock, F_GETFL) | O_NONBLOCK);                  fcntl(c->cli_sock, F_SETFL, fcntl(c->cli_sock, F_GETFL) | O_NONBLOCK);
   
        schedRead(TASK_ROOT(task), rxPacket, c, c->cli_sock, NULL, 0);        schedRead(TASK_ROOT(task), cbProto[srv->srv_proto][CB_RXPACKET], c, 
                         c->cli_sock, NULL, 0);
 end:  end:
         schedReadSelf(task);          schedReadSelf(task);
         return NULL;          return NULL;
Removed from v.1.12.2.1  
changed lines
  Added in v.1.12.2.3

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>