[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.6 and 1.12.2.9

version 1.12.2.6, 2012/11/19 12:43:21 version 1.12.2.9, 2012/11/19 15:54:47
Line 67  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = { Line 67  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = {
 };  };
   
   
   inline void
   rpc_freeCli(rpc_cli_t * __restrict c)
   {
           rpc_srv_t *s = c->cli_parent;
           ait_val_t v;
   
           printf("_t_1=%p t_e=%p so=%d c=%p %s:%hu\n", s->srv_root->root_timer.tqh_first, *s->srv_root->root_timer.tqh_last, c->cli_sock, c, io_n2addr(&c->cli_sa, &v), io_n2port(&c->cli_sa));
   AIT_FREE_VAL(&v);
           schedCancelby(s->srv_root, taskMAX, CRITERIA_ARG, c, NULL);
           printf("+t_1=%p t_e=%p so=%d c=%p\n", s->srv_root->root_timer.tqh_first, *s->srv_root->root_timer.tqh_last, c->cli_sock, c);
   
           /* free buffer */
           AIT_FREE_VAL(&c->cli_buf);
   
           io_arrayDel(s->srv_clients, c->cli_id, 0);
           if (c)
                   io_free(c);
   }
   
   
 static inline int  static inline int
 _check4freeslot(rpc_srv_t * __restrict srv, io_sockaddr_t * __restrict sa)  _check4freeslot(rpc_srv_t * __restrict srv, io_sockaddr_t * __restrict sa)
 {  {
Line 121  _allocClient(rpc_srv_t * __restrict srv, io_sockaddr_t Line 141  _allocClient(rpc_srv_t * __restrict srv, io_sockaddr_t
 static void *  static void *
 freeClient(sched_task_t *task)  freeClient(sched_task_t *task)
 {  {
        rpc_cli_t *c = TASK_ARG(task);        rpc_freeCli(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;          return NULL;
 }  }
   
 static void *  static void *
 closeClient(sched_task_t *task)  closeClient(sched_task_t *task)
 {  {
        rpc_cli_t *c = TASK_ARG(task);        int sock = ((rpc_cli_t*) TASK_ARG(task))->cli_sock;
        rpc_srv_t *s = c->cli_parent; 
   
        schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);        rpc_freeCli(TASK_ARG(task));
   
         /* close client socket */          /* close client socket */
        if (TASK_VAL(task))        shutdown(sock, SHUT_RDWR);
                shutdown(c->cli_sock, SHUT_RDWR);        close(sock);
        close(c->cli_sock); 
 
        /* free buffer */ 
        AIT_FREE_VAL(&c->cli_buf); 
 
        io_arrayDel(s->srv_clients, c->cli_id, 0); 
        if (c) 
                io_free(c); 
         return NULL;          return NULL;
 }  }
   
Line 204  txPacket(sched_task_t *task) Line 206  txPacket(sched_task_t *task)
         if (ret == -1 || ret != wlen) {          if (ret == -1 || ret != wlen) {
                 /* close connection */                  /* close connection */
                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],                   schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                c, 42, NULL, 0);                                TASK_ARG(task), 0, NULL, 0);
         }          }
   
         return NULL;          return NULL;
Line 281  rxPacket(sched_task_t *task) Line 283  rxPacket(sched_task_t *task)
         if (rlen < 1) {          if (rlen < 1) {
                 /* close connection */                  /* close connection */
                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],                   schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                c, 42, NULL, 0);                                TASK_ARG(task), 0, NULL, 0);
                 return NULL;                  return NULL;
         } else {          } else {
                 rlen += off;    /* add reminded bytes from previous rxPacket, if exists! */                  rlen += off;    /* add reminded bytes from previous rxPacket, if exists! */
Line 387  txUDPPacket(sched_task_t *task) Line 389  txUDPPacket(sched_task_t *task)
         int ret, wlen = sizeof(struct tagRPCCall);          int ret, wlen = sizeof(struct tagRPCCall);
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
        schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, c, NULL);        schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
         schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],           schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                        c, ts, c, 0);                         TASK_ARG(task), ts, TASK_ARG(task), 0);
   
         /* copy RPC header */          /* copy RPC header */
         memcpy(buf, TASK_DATA(task), wlen);          memcpy(buf, TASK_DATA(task), wlen);
Line 429  txUDPPacket(sched_task_t *task) Line 431  txUDPPacket(sched_task_t *task)
         if (ret == -1 || ret != wlen) {          if (ret == -1 || ret != wlen) {
                 /* close connection */                  /* close connection */
                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],                   schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                c, 42, NULL, 0);                                 TASK_ARG(task), 0, NULL, 0);
         }          }
   
         return NULL;          return NULL;
Line 457  rxUDPPacket(sched_task_t *task) Line 459  rxUDPPacket(sched_task_t *task)
         if (!c)          if (!c)
                 goto end;                  goto end;
         else {          else {
                /* armed timer for close stateless connection */                c->cli_sock = TASK_FD(task);
                 memcpy(&c->cli_sa, &sa, sizeof c->cli_sa);
                 memcpy(AIT_GET_BUF(&c->cli_buf), buf, AIT_LEN(&c->cli_buf));                  memcpy(AIT_GET_BUF(&c->cli_buf), buf, AIT_LEN(&c->cli_buf));
                   /* armed timer for close stateless connection */
                 schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, c, NULL);                  schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, c, NULL);
                 schedTimer(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT],                   schedTimer(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                                 c, ts, c, 0);                                  c, ts, c, 0);
Line 503  rxUDPPacket(sched_task_t *task) Line 507  rxUDPPacket(sched_task_t *task)
                         rpc->call_rep.eno = RPC_ERROR(errno);                          rpc->call_rep.eno = RPC_ERROR(errno);
                 } else {                  } else {
                         /* execute RPC call */                          /* execute RPC call */
                        schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), off, NULL, 0);                        schedEvent(TASK_ROOT(task), execCall, c, off, NULL, 0);
                 }                  }
   
                 /* send RPC reply */                  /* send RPC reply */
                 if (!noreply)                  if (!noreply)
                         schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET],                           schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                                        TASK_ARG(task), TASK_FD(task), rpc, len);                                        c, TASK_FD(task), rpc, len);
   
                 off += len;                  off += len;
         } while (rlen > 0);          } while (rlen > 0);
Line 521  end: Line 525  end:
   
 /* ------------------------------------------------------ */  /* ------------------------------------------------------ */
   
static void *inline void
closeBLOBClient(sched_task_t *task)rpc_freeBLOBCli(rpc_cli_t * __restrict c)
 {  {
         rpc_cli_t *c = TASK_ARG(task);  
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
   
        schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);        schedCancelby(s->srv_blob.root, taskMAX, CRITERIA_ARG, c, NULL);
   
         /* close client socket */  
         if (TASK_VAL(task))  
                 shutdown(c->cli_sock, SHUT_RDWR);  
         close(c->cli_sock);  
   
         /* free buffer */          /* free buffer */
         AIT_FREE_VAL(&c->cli_buf);          AIT_FREE_VAL(&c->cli_buf);
   
         io_arrayDel(s->srv_blob.clients, c->cli_id, 0);          io_arrayDel(s->srv_blob.clients, c->cli_id, 0);
         if (c)          if (c)
                 io_free(c);                  io_free(c);
   }
   
   
   static void *
   closeBLOBClient(sched_task_t *task)
   {
           int sock = ((rpc_cli_t*) TASK_ARG(task))->cli_sock;
   
           rpc_freeBLOBCli(TASK_ARG(task));
   
           /* close client socket */
           shutdown(sock, SHUT_RDWR);
           close(sock);
         return NULL;          return NULL;
 }  }
   
Line 855  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 866  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
        if (srv->srv_proto == SOCK_STREAM)        if (listen(srv->srv_blob.server.cli_sock, io_arraySize(srv->srv_blob.clients)) == -1) {
                if (listen(srv->srv_blob.server.cli_sock,                 LOGERR;
                                        io_arraySize(srv->srv_blob.clients)) == -1) {                return -1;
                        LOGERR;        }
                        return -1; 
                } 
   
         if (!schedRead(srv->srv_blob.root, acceptBLOBClients, srv,           if (!schedRead(srv->srv_blob.root, acceptBLOBClients, srv, 
                                 srv->srv_blob.server.cli_sock, NULL, 0)) {                                  srv->srv_blob.server.cli_sock, NULL, 0)) {
Line 1071  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 1080  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
        if (listen(srv->srv_server.cli_sock, io_arraySize(srv->srv_clients)) == -1) {        if (srv->srv_proto == SOCK_STREAM)
                LOGERR;                if (listen(srv->srv_server.cli_sock, 
                return -1;                                        io_arraySize(srv->srv_clients)) == -1) {
        }                        LOGERR;
                         return -1;
                 }
   
         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.6  
changed lines
  Added in v.1.12.2.9

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