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

version 1.12.2.3, 2012/11/16 10:20:55 version 1.12.2.4, 2012/11/16 13:30:05
Line 66  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = { Line 66  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = {
 };  };
   
   
static rpc_cli_t *static inline int
_allocClient(rpc_srv_t * __restrict srv)_check4freeslot(rpc_srv_t * __restrict srv, io_sockaddr_t * __restrict sa)
 {  {
         rpc_cli_t *c = NULL;          rpc_cli_t *c = NULL;
         register int i;          register int i;
   
         /* check free slots for connect */          /* check free slots for connect */
         for (i = 0; i < io_arraySize(srv->srv_clients) &&           for (i = 0; i < io_arraySize(srv->srv_clients) && 
                        (c = io_array(srv->srv_clients, i, rpc_cli_t*)); i++);                        (c = io_array(srv->srv_clients, i, rpc_cli_t*)); i++)
        if (c)        /* no more free slots! */                /* 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;                  return NULL;
           else
                   c = io_array(srv->srv_clients, n, rpc_cli_t*);
   
         c = io_malloc(sizeof(rpc_cli_t));  
         if (!c) {          if (!c) {
                LOGERR;                c = io_malloc(sizeof(rpc_cli_t));
                srv->srv_kill = 1;                if (!c) {
                return NULL;                        LOGERR;
        } else {                        srv->srv_kill = 1;
                memset(c, 0, sizeof(rpc_cli_t));                        return NULL;
                io_arraySet(srv->srv_clients, i, c);                } else {
                c->cli_id = i;                        memset(c, 0, sizeof(rpc_cli_t));
                c->cli_parent = srv;                        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);
         }          }
   
         /* alloc empty buffer */  
         AIT_SET_BUF2(&c->cli_buf, 0, srv->srv_netbuf);  
   
         return c;          return c;
 }  }
   
Line 103  connectClients(sched_task_t *task) Line 123  connectClients(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;
         socklen_t salen = sizeof(io_sockaddr_t);          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);          c = _allocClient(srv);
        if (!c)        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;                  goto end;
   
        /* accept client */        /* check RPC packet */
        c->cli_sock = accept(TASK_FD(task), &c->cli_sa.sa, &salen);        if (rlen < sizeof(struct tagRPCCall)) {
        if (c->cli_sock == -1) {                rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
                LOGERR; 
                AIT_FREE_VAL(&c->cli_buf); 
                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);                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;
         }
   
        schedRead(TASK_ROOT(task), cbProto[srv->srv_proto][CB_RXPACKET], c,         /* check integrity of packet */
                        c->cli_sock, NULL, 0);        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:  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);          schedReadSelf(task);
         return NULL;          return NULL;
 }  }
Line 133  disconnectClient(sched_task_t *task) Line 202  disconnectClient(sched_task_t *task)
   
         schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);          schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);
   
           if (!TASK_DATLEN(task)) {
                   /* TODO: send disconnect packet */
           }
   
         /* free buffer */          /* free buffer */
         AIT_FREE_VAL(&c->cli_buf);          AIT_FREE_VAL(&c->cli_buf);
   
Line 361  acceptClients(sched_task_t *task) Line 434  acceptClients(sched_task_t *task)
         rpc_cli_t *c = NULL;          rpc_cli_t *c = NULL;
         socklen_t salen = sizeof(io_sockaddr_t);          socklen_t salen = sizeof(io_sockaddr_t);
   
        c = _allocClient(srv);        c = _allocClient(srv, NULL);
         if (!c)          if (!c)
                 goto end;                  goto end;
   
Line 657  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 715  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 873  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 933  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.3  
changed lines
  Added in v.1.12.2.4

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