[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.2 and 1.12.2.4

version 1.12.2.2, 2012/11/16 08:51:36 version 1.12.2.4, 2012/11/16 13:30:05
Line 53  static void *rxPacket(sched_task_t *); Line 53  static void *rxPacket(sched_task_t *);
 static void *txPacket(sched_task_t *);  static void *txPacket(sched_task_t *);
   
 /* SOCK_DGRAM */  /* SOCK_DGRAM */
   static void *connectClients(sched_task_t *);
   static void *disconnectClient(sched_task_t *);
   
 /* SOCK_RAW */  /* SOCK_RAW */
   
 static sched_task_func_t cbProto[SOCK_RAW + 1][4] = {  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = {
         { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */          { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */
         { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */          { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */
        { NULL, NULL, NULL, NULL },         { connectClients, disconnectClient, NULL, NULL }, 
         { NULL, NULL, NULL, NULL }                              /* SOCK_RAW */          { NULL, NULL, NULL, NULL }                              /* SOCK_RAW */
 };  };
   
   
   static inline int
   _check4freeslot(rpc_srv_t * __restrict srv, io_sockaddr_t * __restrict sa)
   {
           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++)
                   /* check for duplicates */
                   if (sa && !io_addrcmp(&c->cli_sa, sa, 42))
                           break;
           if (i >= io_arraySize(srv->srv_clients))
                   return -1;      /* no more free slots! */
   
           return i;
   }
   
   static rpc_cli_t *
   _allocClient(rpc_srv_t * __restrict srv, io_sockaddr_t * __restrict sa)
   {
           rpc_cli_t *c = NULL;
           int n;
   
           n = _check4freeslot(srv, sa);
           if (n == -1)
                   return NULL;
           else
                   c = io_array(srv->srv_clients, n, rpc_cli_t*);
   
           if (!c) {
                   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, n, c);
                           c->cli_id = n;
                           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);
           int len, rlen;
           u_short crc;
           u_char buf[USHRT_MAX + 1];
           struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
           io_sockaddr_t sa;
   
   #if 0
           c = _allocClient(srv);
           if (!c) {
                   schedReadSelf(task);
                   return NULL;
           } else
                   buf = AIT_GET_BUF(&c->cli_buf);
   #endif
   
           /* receive connect packet */
           rlen = recvfrom(TASK_FD(task), buf, sizeof buf, 0, &sa.sa, &salen);
           if (rlen < 1)
                   goto end;
   
           /* check RPC packet */
           if (rlen < sizeof(struct tagRPCCall)) {
                   rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
                   goto end;
           } else {
                   len = ntohs(rpc->call_len);
                   rlen -= len;
           }
           /* check RPC packet lengths */
           if (rlen < 0 || len < sizeof(struct tagRPCCall)) {
                   rpc_SetErr(ERPCMISMATCH, "Broken RPC packet length");
                   goto end;
           }
   
           /* check integrity of packet */
           crc = ntohs(rpc->call_crc);
           rpc->call_crc ^= rpc->call_crc;
           if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
                   rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
                   goto end;
           }
   
           /* check RPC packet session info */
           if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {
                   rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
                   goto end;
           }
   
           /* RPC packet is OK */
   
           c = _allocClient(srv, &sa);
           if (!c)
                   goto end;
   
           if (0) {
                   schedRead(TASK_ROOT(task), cbProto[srv->srv_proto][CB_RXPACKET], c, 
                                   c->cli_sock, NULL, 0);
                   schedReadSelf(task);
                   return NULL;
           }
   
   end:
   #if 0
           /* close connection & dont send disconnect */
           schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                           c, 42, NULL, 42);
   #endif
           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);
   
           if (!TASK_DATLEN(task)) {
                   /* TODO: send disconnect packet */
           }
   
           /* 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 206  rxPacket(sched_task_t *task) Line 357  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 283  acceptClients(sched_task_t *task) Line 432  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, NULL);
        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);
Line 598  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 730  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
                 close(srv->srv_blob.server.cli_sock);                  close(srv->srv_blob.server.cli_sock);
                 AIT_FREE_VAL(&srv->srv_blob.dir);                  AIT_FREE_VAL(&srv->srv_blob.dir);
                 return -1;                  return -1;
        }        } else
                 fcntl(srv->srv_blob.server.cli_sock, F_SETFL, 
                                 fcntl(srv->srv_blob.server.cli_sock, F_GETFL) | O_NONBLOCK);
   
   
         /* allocate pool for concurent blob clients */          /* allocate pool for concurent blob clients */
         srv->srv_blob.clients = io_arrayInit(io_arraySize(srv->srv_clients));          srv->srv_blob.clients = io_arrayInit(io_arraySize(srv->srv_clients));
         if (!srv->srv_blob.clients) {          if (!srv->srv_blob.clients) {
Line 656  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 791  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
         fcntl(srv->srv_blob.server.cli_sock, F_SETFL,   
                         fcntl(srv->srv_blob.server.cli_sock, F_GETFL) | O_NONBLOCK);  
   
         if (listen(srv->srv_blob.server.cli_sock, io_arraySize(srv->srv_blob.clients)) == -1) {          if (listen(srv->srv_blob.server.cli_sock, io_arraySize(srv->srv_blob.clients)) == -1) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 814  rpc_srv_initServer(u_int regProgID, u_char regProcID,  Line 946  rpc_srv_initServer(u_int regProgID, u_char regProcID, 
                                 srv->srv_server.cli_sa.sa.sa_len) == -1) {                                  srv->srv_server.cli_sa.sa.sa_len) == -1) {
                 LOGERR;                  LOGERR;
                 goto err;                  goto err;
        }        } else
                 fcntl(srv->srv_server.cli_sock, F_SETFL, 
                                 fcntl(srv->srv_server.cli_sock, F_GETFL) | O_NONBLOCK);
   
         rpc_register_srvPing(srv);          rpc_register_srvPing(srv);
   
Line 874  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 1008  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
         if (listen(srv->srv_server.cli_sock, io_arraySize(srv->srv_clients)) == -1) {          if (listen(srv->srv_server.cli_sock, io_arraySize(srv->srv_clients)) == -1) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
        } else        }
                fcntl(srv->srv_server.cli_sock, F_SETFL,  
                                fcntl(srv->srv_server.cli_sock, F_GETFL) | O_NONBLOCK); 
   
         if (!schedRead(srv->srv_root, cbProto[srv->srv_proto][CB_ACCEPTCLIENT], srv,           if (!schedRead(srv->srv_root, cbProto[srv->srv_proto][CB_ACCEPTCLIENT], srv, 
                                 srv->srv_server.cli_sock, NULL, 0)) {                                  srv->srv_server.cli_sock, NULL, 0)) {
Removed from v.1.12.2.2  
changed lines
  Added in v.1.12.2.4

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