[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.16.2.5 and 1.17.4.2

version 1.16.2.5, 2013/07/16 08:25:55 version 1.17.4.2, 2013/08/20 23:49:54
Line 74  rpc_freeCli(rpc_cli_t * __restrict c) Line 74  rpc_freeCli(rpc_cli_t * __restrict c)
   
         schedCancelby(s->srv_root, taskMAX, CRITERIA_ARG, c, NULL);          schedCancelby(s->srv_root, taskMAX, CRITERIA_ARG, c, NULL);
   
        /* free buffer */        /* free buffer(s) */
        AIT_FREE_VAL(&c->cli_buf);        ait_freeVars(&c->cli_buf);
   
         array_Del(s->srv_clients, c->cli_id, 0);          array_Del(s->srv_clients, c->cli_id, 0);
         if (c)          if (c)
Line 126  _allocClient(rpc_srv_t * __restrict srv, sockaddr_t *  Line 126  _allocClient(rpc_srv_t * __restrict srv, sockaddr_t * 
                         c->cli_parent = srv;                          c->cli_parent = srv;
                 }                  }
   
                /* alloc empty buffer */                /* init buffer(s) */
                AIT_SET_BUFSIZ(&c->cli_buf, 0, srv->srv_netbuf);                c->cli_buf = ait_allocVars(1);
                 if (!c->cli_buf) {
                         rpc_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                         array_Del(srv->srv_clients, n, 42);
                         return NULL;
                 } else
                         AIT_SET_BUFSIZ(array(c->cli_buf, 0, ait_val_t*), 0, srv->srv_netbuf);
         }          }
   
         return c;          return c;
Line 367  acceptClients(sched_task_t *task) Line 373  acceptClients(sched_task_t *task)
         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_freeVars(&c->cli_buf);
                 array_Del(srv->srv_clients, c->cli_id, 42);                  array_Del(srv->srv_clients, c->cli_id, 42);
                 goto end;                  goto end;
         } else          } else
Line 536  rpc_freeBLOBCli(rpc_cli_t * __restrict c) Line 542  rpc_freeBLOBCli(rpc_cli_t * __restrict c)
   
         schedCancelby(s->srv_blob.root, taskMAX, CRITERIA_ARG, c, NULL);          schedCancelby(s->srv_blob.root, taskMAX, CRITERIA_ARG, c, NULL);
   
        /* free buffer */        /* free buffer(s) */
        AIT_FREE_VAL(&c->cli_buf);        ait_freeVars(&c->cli_buf);
   
         array_Del(s->srv_blob.clients, c->cli_id, 0);          array_Del(s->srv_blob.clients, c->cli_id, 0);
         if (c)          if (c)
Line 629  rxBLOB(sched_task_t *task) Line 635  rxBLOB(sched_task_t *task)
                         break;                          break;
                 case set:                  case set:
                         if ((b = rpc_srv_registerBLOB(s, ntohl(blob.hdr_len),                           if ((b = rpc_srv_registerBLOB(s, ntohl(blob.hdr_len), 
                                                        ntohl(blob.hdr_ret), c))) {                                                        ntohl(blob.hdr_ret)))) {
                                 /* set new BLOB variable for reply :) */                                  /* set new BLOB variable for reply :) */
                                 blob.hdr_var = htonl(b->blob_var);                                  blob.hdr_var = htonl(b->blob_var);
   
Line 661  end: Line 667  end:
 }  }
   
 static void *  static void *
   flushBLOB(sched_task_t *task)
   {
           rpc_srv_t *srv = TASK_ARG(task);
           rpc_blob_t *b, *tmp;
   
           TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp) {
                   TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);
   
                   rpc_srv_blobFree(srv, b);
                   e_free(b);
           }
   
           schedSignalSelf(task);
           return NULL;
   }
   
   static void *
 acceptBLOBClients(sched_task_t *task)  acceptBLOBClients(sched_task_t *task)
 {  {
         rpc_srv_t *srv = TASK_ARG(task);          rpc_srv_t *srv = TASK_ARG(task);
Line 688  acceptBLOBClients(sched_task_t *task) Line 711  acceptBLOBClients(sched_task_t *task)
                 c->cli_parent = srv;                  c->cli_parent = srv;
         }          }
   
        /* alloc empty buffer */        /* init buffer(s) */
        AIT_SET_BUFSIZ(&c->cli_buf, 0, srv->srv_netbuf);        c->cli_buf = ait_allocVars(1);
         if (!c->cli_buf) {
                 rpc_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                 array_Del(srv->srv_blob.clients, i, 42);
                 goto end;
         } else
                 AIT_SET_BUFSIZ(array(c->cli_buf, 0, ait_val_t*), 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_freeVars(&c->cli_buf);
                 array_Del(srv->srv_blob.clients, i, 42);                  array_Del(srv->srv_blob.clients, i, 42);
                 goto end;                  goto end;
         } else {          } else {
Line 834  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 863  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
                 return;                  return;
   
         srv->srv_blob.kill = 1;          srv->srv_blob.kill = 1;
   
           schedEnd(&srv->srv_blob.root);
 }  }
   
 /*  /*
Line 860  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 891  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
           schedSignal(srv->srv_blob.root, flushBLOB, srv, SIGFBLOB, NULL, 0);
         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)) {
                 rpc_SetErr(sched_GetErrno(), "%s", sched_GetError());                  rpc_SetErr(sched_GetErrno(), "%s", sched_GetError());
Line 870  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 902  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
         /* main rpc loop */          /* main rpc loop */
         schedRun(srv->srv_blob.root, &srv->srv_blob.kill);          schedRun(srv->srv_blob.root, &srv->srv_blob.kill);
   
           /* detach blobs */
           TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp) {
                   TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);
   
                   rpc_srv_blobFree(srv, b);
                   e_free(b);
           }
   
         /* close all clients connections & server socket */          /* close all clients connections & server socket */
         for (i = 0; i < array_Size(srv->srv_blob.clients); i++) {          for (i = 0; i < array_Size(srv->srv_blob.clients); i++) {
                 c = array(srv->srv_blob.clients, i, rpc_cli_t*);                  c = array(srv->srv_blob.clients, i, rpc_cli_t*);
Line 878  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 918  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
                         close(c->cli_sock);                          close(c->cli_sock);
   
                         schedCancelby(srv->srv_blob.root, taskMAX, CRITERIA_ARG, c, NULL);                          schedCancelby(srv->srv_blob.root, taskMAX, CRITERIA_ARG, c, NULL);
                        AIT_FREE_VAL(&c->cli_buf);                        ait_freeVars(&c->cli_buf);
                 }                  }
                 array_Del(srv->srv_blob.clients, i, 42);                  array_Del(srv->srv_blob.clients, i, 42);
         }          }
Line 886  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 926  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
   
         close(srv->srv_blob.server.cli_sock);          close(srv->srv_blob.server.cli_sock);
   
         /* detach blobs */  
         TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp) {  
                 TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);  
   
                 rpc_srv_unregisterBLOB(srv, b->blob_var);  
   
                 rpc_srv_blobFree(srv, b);  
                 e_free(b);  
         }  
   
         schedEnd(&srv->srv_blob.root);  
         AIT_FREE_VAL(&srv->srv_blob.dir);          AIT_FREE_VAL(&srv->srv_blob.dir);
         return 0;          return 0;
 }  }
Line 1039  rpc_srv_endServer(rpc_srv_t ** __restrict psrv) Line 1068  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
                 return;                  return;
   
         /* if send kill to blob server */          /* if send kill to blob server */
        if (!(*psrv)->srv_blob.kill)        rpc_srv_endBLOBServer(*psrv);
                rpc_srv_endBLOBServer(*psrv); 
   
         (*psrv)->srv_kill = 1;          (*psrv)->srv_kill = 1;
         sleep(RPC_SCHED_POLLING);          sleep(RPC_SCHED_POLLING);
   
           schedEnd(&(*psrv)->srv_root);
   
         pthread_mutex_destroy(&(*psrv)->srv_funcs.mtx);          pthread_mutex_destroy(&(*psrv)->srv_funcs.mtx);
         e_free(*psrv);          e_free(*psrv);
         *psrv = NULL;          *psrv = NULL;
Line 1094  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 1124  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
   
                         schedCancelby(srv->srv_root, taskMAX, CRITERIA_ARG, c, NULL);                          schedCancelby(srv->srv_root, taskMAX, CRITERIA_ARG, c, NULL);
                         ait_freeVars(&RPC_RETVARS(c));                          ait_freeVars(&RPC_RETVARS(c));
                        AIT_FREE_VAL(&c->cli_buf);                        ait_freeVars(&c->cli_buf);
                 }                  }
                 array_Del(srv->srv_clients, i, 42);                  array_Del(srv->srv_clients, i, 42);
         }          }
Line 1113  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 1143  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
         srv->srv_funcs.avlh_root = NULL;          srv->srv_funcs.avlh_root = NULL;
         RPC_FUNCS_UNLOCK(&srv->srv_funcs);          RPC_FUNCS_UNLOCK(&srv->srv_funcs);
   
         schedEnd(&srv->srv_root);  
         return 0;          return 0;
 }  }
   
Removed from v.1.16.2.5  
changed lines
  Added in v.1.17.4.2

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