[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.15 and 1.19

version 1.15, 2013/04/02 15:50:14 version 1.19, 2013/08/23 13:53:15
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 voidvoid
 rpc_freeCli(rpc_cli_t * __restrict c)  rpc_freeCli(rpc_cli_t * __restrict c)
 {  {
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
Line 161  txPacket(sched_task_t *task) Line 161  txPacket(sched_task_t *task)
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
        u_char buf[USHRT_MAX] = { 0 };        u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
        int ret, wlen = sizeof(struct tagRPCCall);        int ret, estlen, wlen = sizeof(struct tagRPCCall);
         struct pollfd pfd;
   
         /* copy RPC header */  
         memcpy(buf, TASK_DATA(task), wlen);  
   
         if (rpc->call_argc) {          if (rpc->call_argc) {
                 f = rpc_srv_getCall(s, ntohs(rpc->call_tag));                  f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
                 if (!f) {                  if (!f) {
                         rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");                          rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                         rpc->call_rep.ret = RPC_ERROR(-1);                          rpc->call_rep.ret = RPC_ERROR(-1);
                         rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                          rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                 } else {                  } else {
                           /* calc estimated length */
                           estlen = ait_resideVars(RPC_RETVARS(c)) + wlen;
                           if (estlen > AIT_LEN(&c->cli_buf))
                                   AIT_RE_BUF(&c->cli_buf, estlen);
                           buf = AIT_GET_BUF(&c->cli_buf);
                           rpc = (struct tagRPCCall*) buf;
   
                         rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                          rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
                        ret = ait_vars2buffer(buf + wlen, sizeof buf - wlen, RPC_RETVARS(c));                        ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
                                         RPC_RETVARS(c));
                         /* Free return values */                          /* Free return values */
                         ait_freeVars(&c->cli_vars);                          ait_freeVars(&c->cli_vars);
                         if (ret == -1) {                          if (ret == -1) {
                                 rpc_SetErr(EBADRPC, "Prepare RPC packet failed");                                  rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
   
                                 rpc->call_argc ^= rpc->call_argc;                                  rpc->call_argc ^= rpc->call_argc;
                                 rpc->call_rep.ret = RPC_ERROR(-1);                                  rpc->call_rep.ret = RPC_ERROR(-1);
                                 rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                  rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
Line 191  txPacket(sched_task_t *task) Line 199  txPacket(sched_task_t *task)
                 }                  }
         }          }
   
        rpc->call_len = htons(wlen);        rpc->call_len = htonl(wlen);
   
 #if 0  #if 0
         /* calculate CRC */          /* calculate CRC */
Line 200  txPacket(sched_task_t *task) Line 208  txPacket(sched_task_t *task)
 #endif  #endif
   
         /* send reply */          /* send reply */
        ret = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL);        pfd.fd = TASK_FD(task);
        if (ret == -1 || ret != wlen) {        pfd.events = POLLOUT;
                /* close connection */        for (; wlen > 0; wlen -= ret, buf += ret) {
                schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],                 if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                                TASK_ARG(task), 0, NULL, 0);                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                         if (ret)
                                 LOGERR;
                         else
                                 rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
                         /* close connection */
                         schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                         TASK_ARG(task), 0, NULL, 0);
                         return NULL;
                 }
                 ret = send(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf), MSG_NOSIGNAL);
                 if (ret == -1) {
                         /* close connection */
                         schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                         TASK_ARG(task), 0, NULL, 0);
                         return NULL;
                 }
         }          }
   
         return NULL;          return NULL;
Line 217  execCall(sched_task_t *task) Line 241  execCall(sched_task_t *task)
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
         array_t *arr = NULL;          array_t *arr = NULL;
        u_char *buf = AIT_GET_BUF(&c->cli_buf) + TASK_VAL(task);        u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
         int argc = ntohs(rpc->call_argc);          int argc = ntohs(rpc->call_argc);
   
         /* Go decapsulate variables ... */          /* Go decapsulate variables ... */
         if (argc) {          if (argc) {
                 arr = ait_buffer2vars(buf + sizeof(struct tagRPCCall),                   arr = ait_buffer2vars(buf + sizeof(struct tagRPCCall), 
                                AIT_LEN(&c->cli_buf) - TASK_VAL(task) - sizeof(struct tagRPCCall),                                 AIT_LEN(&c->cli_buf) - sizeof(struct tagRPCCall), argc, 42);
                                argc, 42); 
                 if (!arr) {                  if (!arr) {
                         rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError());                          rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError());
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                         rpc->call_rep.ret = RPC_ERROR(-1);                          rpc->call_rep.ret = RPC_ERROR(-1);
                         rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                          rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
Line 238  execCall(sched_task_t *task) Line 262  execCall(sched_task_t *task)
   
         if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag)))) {          if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag)))) {
                 rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");                  rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                 rpc->call_rep.ret = RPC_ERROR(-1);                  rpc->call_rep.ret = RPC_ERROR(-1);
                 rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                  rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
Line 270  rxPacket(sched_task_t *task) Line 295  rxPacket(sched_task_t *task)
 {  {
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
        int len, rlen, noreply;        int len, rlen, noreply, estlen;
        u_short off = TASK_DATLEN(task); 
 #if 0  #if 0
         u_short crc;          u_short crc;
 #endif  #endif
         u_char *buf = AIT_GET_BUF(&c->cli_buf);          u_char *buf = AIT_GET_BUF(&c->cli_buf);
        struct tagRPCCall *rpc;        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
         struct pollfd pfd;
   
        if (!off)        memset(buf, 0, sizeof(struct tagRPCCall));
                memset(buf, 0, AIT_LEN(&c->cli_buf));        rlen = recv(TASK_FD(task), rpc, sizeof(struct tagRPCCall), MSG_PEEK);
        rlen = recv(TASK_FD(task), buf + off, AIT_LEN(&c->cli_buf) - off, 0);        if (rlen < sizeof(struct tagRPCCall)) {
        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], 
                                 TASK_ARG(task), 0, NULL, 0);                                  TASK_ARG(task), 0, NULL, 0);
                 return NULL;                  return NULL;
         } else {          } else {
                rlen += off; /* add reminded bytes from previous rxPacket, if exists! */                estlen = ntohl(rpc->call_len);
                off = 0;      /* process buffer from start offset == 0 */                if (estlen > AIT_LEN(&c->cli_buf))
                         AIT_RE_BUF(&c->cli_buf, estlen);
                 rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
                 buf = AIT_GET_BUF(&c->cli_buf);
                 len = estlen;
         }          }
   
        do {        /* get next part of packet */
                /* check RPC packet */        memset(buf, 0, len);
                if (rlen < sizeof(struct tagRPCCall)) {        pfd.fd = TASK_FD(task);
                        rpc_SetErr(ERPCMISMATCH, "Short RPC packet");        pfd.events = POLLIN | POLLPRI;
        for (; len > 0; len -= rlen, buf += rlen) {
                        /* reminder received previous bytes ;) */                if ((rlen = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                        schedRead(TASK_ROOT(task), TASK_FUNC(task), TASK_ARG(task),                                 pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                                        TASK_FD(task), TASK_DATA(task), rlen);                        if (rlen)
                                 LOGERR;
                         else
                                 rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
                         schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                         TASK_ARG(task), 0, NULL, 0);
                         return NULL;                          return NULL;
                 } else  
                         rpc = (struct tagRPCCall*) (buf + off);  
   
                 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");  
                         /* skip entire packet */  
                         break;  
                 }                  }
                   rlen = recv(TASK_FD(task), buf, len, 0);
                   if (rlen == -1) {
                           /* close connection */
                           schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                           TASK_ARG(task), 0, NULL, 0);
                           return NULL;
                   }
           }
   
 #if 0  #if 0
                /* check integrity of packet */        /* check integrity of packet */
                crc = ntohs(rpc->call_crc);        crc = ntohs(rpc->call_crc);
                rpc->call_crc ^= rpc->call_crc;        rpc->call_crc ^= rpc->call_crc;
                if (crc != crcFletcher16((u_short*) rpc, len / 2)) {        if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
                        rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");                rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
                return NULL;
                        off += len;        }
                        /* try next packet remaining into buffer */ 
                        continue; 
                } 
 #endif  #endif
   
                noreply = RPC_CHK_NOREPLY(rpc);        noreply = RPC_CHK_NOREPLY(rpc);
   
                /* check RPC packet session info */        /* check RPC packet session info */
                if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) {        if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) {
                        rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");                rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
                        rpc->call_argc ^= rpc->call_argc; 
                        rpc->call_rep.ret = RPC_ERROR(-1); 
                        rpc->call_rep.eno = RPC_ERROR(errno); 
                } else { 
                        /* execute RPC call */ 
                        schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), off, NULL, 0); 
                } 
   
                /* send RPC reply */                rpc->call_argc ^= rpc->call_argc;
                if (!noreply)                rpc->call_rep.ret = RPC_ERROR(-1);
                        schedWrite(TASK_ROOT(task), cbProto[s->srv_proto][CB_TXPACKET],                 rpc->call_rep.eno = RPC_ERROR(errno);
                                        TASK_ARG(task), TASK_FD(task), rpc, len);        } else {
                 /* execute RPC call */
                 schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), (int) noreply, rpc, len);
         }
   
                off += len;        /* send RPC reply */
        } while (rlen > 0);        if (!noreply)
                 schedWrite(TASK_ROOT(task), cbProto[s->srv_proto][CB_TXPACKET], 
                                 TASK_ARG(task), TASK_FD(task), rpc, len);
   
         /* lets get next packet */          /* lets get next packet */
        schedRead(TASK_ROOT(task), TASK_FUNC(task), TASK_ARG(task), TASK_FD(task), TASK_DATA(task), 0);        schedReadSelf(task);
         return NULL;          return NULL;
 }  }
   
Line 387  txUDPPacket(sched_task_t *task) Line 412  txUDPPacket(sched_task_t *task)
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
        u_char buf[USHRT_MAX] = { 0 };        u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
         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 };
Line 396  txUDPPacket(sched_task_t *task) Line 421  txUDPPacket(sched_task_t *task)
         schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],           schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                          TASK_ARG(task), ts, TASK_ARG(task), 0);                           TASK_ARG(task), ts, TASK_ARG(task), 0);
   
         /* copy RPC header */  
         memcpy(buf, TASK_DATA(task), wlen);  
   
         if (rpc->call_argc) {          if (rpc->call_argc) {
                 f = rpc_srv_getCall(s, ntohs(rpc->call_tag));                  f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
                 if (!f) {                  if (!f) {
Line 409  txUDPPacket(sched_task_t *task) Line 431  txUDPPacket(sched_task_t *task)
                 } else {                  } else {
                         rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                          rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
                        ret = ait_vars2buffer(buf + wlen, sizeof buf - wlen, RPC_RETVARS(c));                        ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
                                         RPC_RETVARS(c));
                         /* Free return values */                          /* Free return values */
                         ait_freeVars(&c->cli_vars);                          ait_freeVars(&c->cli_vars);
                         if (ret == -1) {                          if (ret == -1) {
Line 422  txUDPPacket(sched_task_t *task) Line 445  txUDPPacket(sched_task_t *task)
                 }                  }
         }          }
   
        rpc->call_len = htons(wlen);        rpc->call_len = htonl(wlen);
   
         /* calculate CRC */          /* calculate CRC */
         rpc->call_crc ^= rpc->call_crc;          rpc->call_crc ^= rpc->call_crc;
Line 480  rxUDPPacket(sched_task_t *task) Line 503  rxUDPPacket(sched_task_t *task)
                 } else                  } else
                         rpc = (struct tagRPCCall*) (AIT_GET_BUF(&c->cli_buf) + off);                          rpc = (struct tagRPCCall*) (AIT_GET_BUF(&c->cli_buf) + off);
   
                len = ntohs(rpc->call_len);                len = ntohl(rpc->call_len);
                 rlen -= len;                  rlen -= len;
   
                 /* check RPC packet lengths */                  /* check RPC packet lengths */
Line 506  rxUDPPacket(sched_task_t *task) Line 529  rxUDPPacket(sched_task_t *task)
                 /* check RPC packet session info */                  /* check RPC packet session info */
                 if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {                  if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {
                         rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");                          rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                         rpc->call_rep.ret = RPC_ERROR(-1);                          rpc->call_rep.ret = RPC_ERROR(-1);
                         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, c, off, NULL, 0);                        schedEvent(TASK_ROOT(task), execCall, c, 
                                         (int) noreply, rpc, len);
                 }                  }
   
                 /* send RPC reply */                  /* send RPC reply */
Line 529  end: Line 554  end:
   
 /* ------------------------------------------------------ */  /* ------------------------------------------------------ */
   
inline voidvoid
 rpc_freeBLOBCli(rpc_cli_t * __restrict c)  rpc_freeBLOBCli(rpc_cli_t * __restrict c)
 {  {
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
Line 628  rxBLOB(sched_task_t *task) Line 653  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)))) {
                                 /* 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 660  end: Line 686  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 826  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 869  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * return: none   * return: none
  */   */
inline voidvoid
 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
 {  {
         if (!srv)          if (!srv)
                 return;                  return;
   
         srv->srv_blob.kill = 1;          srv->srv_blob.kill = 1;
   
           schedEnd(&srv->srv_blob.root);
 }  }
   
 /*  /*
Line 859  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 904  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 869  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 915  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 885  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 939  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_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 1029  err: /* error condition */ Line 1074  err: /* error condition */
  * @psrv = RPC Server instance   * @psrv = RPC Server instance
  * return: none   * return: none
  */   */
inline voidvoid
 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
 {  {
         if (!psrv || !*psrv)          if (!psrv || !*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 1110  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 1156  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.15  
changed lines
  Added in v.1.19

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