[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.26.2.10 and 1.30.2.8

version 1.26.2.10, 2015/06/30 14:11:55 version 1.30.2.8, 2024/02/26 17:52:41
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004 - 2015Copyright 2004 - 2024
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 82  static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4]  Line 82  static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4] 
   
 static volatile uintptr_t _glSigArg = 0;  static volatile uintptr_t _glSigArg = 0;
   
   
 void  void
 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;
   
        schedCancelby(s->srv_root, taskMAX, CRITERIA_ARG, c, NULL);        if (s->srv_proto == SOCK_STREAM)
                 schedCancelby(s->srv_root, taskMAX, CRITERIA_ARG, c, NULL);
   
         /* free buffer */          /* free buffer */
         AIT_FREE_VAL(&c->cli_buf);          AIT_FREE_VAL(&c->cli_buf);
Line 197  txPacket(sched_task_t *task) Line 197  txPacket(sched_task_t *task)
                         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_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 214  txPacket(sched_task_t *task) Line 214  txPacket(sched_task_t *task)
                                 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_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 263  execCall(sched_task_t *task) Line 263  execCall(sched_task_t *task)
                         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_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                         taskExit(task, NULL);                          taskExit(task, NULL);
                 }                  }
         } else          } else
Line 274  execCall(sched_task_t *task) Line 274  execCall(sched_task_t *task)
                 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_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
         } else {          } else {
                 /* if client doesn't want reply */                  /* if client doesn't want reply */
                rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(c, rpc, f->func_name, arr));                RPC_SET_RETURN(rpc, rpc_srv_execCall(c, rpc, f->func_name, arr));
                 if (rpc->call_rep.ret == htonl(-1)) {                  if (rpc->call_rep.ret == htonl(-1)) {
                         if (!rpc->call_rep.eno) {                          if (!rpc->call_rep.eno) {
                                 LOGERR;                                  LOGERR;
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         }                          }
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                         ait_freeVars(&c->cli_vars);                          ait_freeVars(&c->cli_vars);
Line 292  execCall(sched_task_t *task) Line 292  execCall(sched_task_t *task)
                         if (TASK_VAL(task)) {                          if (TASK_VAL(task)) {
                                 /* without reply */                                  /* without reply */
                                 ait_freeVars(&c->cli_vars);                                  ait_freeVars(&c->cli_vars);
                        } else {                        } else if (rpc->call_io & RPC_REQ) {
                                 /* reply */                                  /* reply */
                                 rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                                  rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         }                          }
Line 303  execCall(sched_task_t *task) Line 303  execCall(sched_task_t *task)
         taskExit(task, NULL);          taskExit(task, NULL);
 }  }
   
   int
   rpc_srv_Return(sched_root_task_t *root, rpc_cli_t *c)
   {
           rpc_srv_t *s = c->cli_parent;
           u_char *buf = AIT_GET_BUF(&c->cli_buf);
           struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
   
           if (!RPC_CHK_NOREPLY(rpc)) {
                   rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                   schedWrite(root, cbProto[s->srv_proto][CB_TXPACKET], c, c->cli_sock, rpc, 0);
           }
   
           return rpc->call_argc;
   }
   
 static void *  static void *
 rxPacket(sched_task_t *task)  rxPacket(sched_task_t *task)
 {  {
Line 313  rxPacket(sched_task_t *task) Line 328  rxPacket(sched_task_t *task)
         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);
        u_char b[sizeof(struct tagRPCCall)];        struct tagRPCCall b, *rpc = (struct tagRPCCall*) buf;
        struct tagRPCCall *rpc = (struct tagRPCCall*) buf; 
 #ifdef TCP_SESSION_TIMEOUT  #ifdef TCP_SESSION_TIMEOUT
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
Line 324  rxPacket(sched_task_t *task) Line 338  rxPacket(sched_task_t *task)
 #endif  #endif
   
         /* prepare rx */          /* prepare rx */
        len = recv(TASK_FD(task), b, sizeof b, MSG_PEEK);        len = recv(TASK_FD(task), &b, sizeof b, MSG_PEEK);
        if (len == sizeof b)        if (len < 1) {
                rlen = ntohl(((struct tagRPCCall*) b)->call_len);                /* close connection */
                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                 TASK_ARG(task), 0, NULL, 0);
                 taskExit(task, NULL);
         } else if (len == sizeof b)
                 rlen = ntohl(b.call_len);
         else
                 goto end;
   
         rlen = recv(TASK_FD(task), buf, rlen, 0);          rlen = recv(TASK_FD(task), buf, rlen, 0);
         if (rlen == -1) {          if (rlen == -1) {
Line 339  rxPacket(sched_task_t *task) Line 360  rxPacket(sched_task_t *task)
                 rpc_SetErr(ERPCMISMATCH, "Short RPC packet");                  rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                rpc->call_rep.ret = RPC_ERROR(-1);                RPC_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
                 goto err;                  goto err;
         } else          } else
                 len = ntohl(rpc->call_len);                  len = ntohl(rpc->call_len);
Line 348  rxPacket(sched_task_t *task) Line 369  rxPacket(sched_task_t *task)
                 rpc_SetErr(ERPCMISMATCH, "Short RPC packet");                  rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                rpc->call_rep.ret = RPC_ERROR(-1);                RPC_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
                 goto err;                  goto err;
         }          }
   
Line 367  rxPacket(sched_task_t *task) Line 388  rxPacket(sched_task_t *task)
                 rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");                  rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                rpc->call_rep.ret = RPC_ERROR(-1);                RPC_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
                 goto err;                  goto err;
         }          }
 #endif  #endif
Line 378  rxPacket(sched_task_t *task) Line 399  rxPacket(sched_task_t *task)
                 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_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
                 goto err;                  goto err;
         }          }
   
Line 389  rxPacket(sched_task_t *task) Line 410  rxPacket(sched_task_t *task)
         schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), (int) noreply, rpc, len);          schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), (int) noreply, rpc, len);
 err:  err:
         /* send RPC reply */          /* send RPC reply */
        if (!noreply)        if (!noreply && (rpc->call_io & RPC_REQ))
                 schedWrite(TASK_ROOT(task), cbProto[s->srv_proto][CB_TXPACKET],                   schedWrite(TASK_ROOT(task), cbProto[s->srv_proto][CB_TXPACKET], 
                                 TASK_ARG(task), TASK_FD(task), rpc, len);                                  TASK_ARG(task), TASK_FD(task), rpc, len);
end:
         /* lets get next packet */          /* lets get next packet */
         schedReadSelf(task);          schedReadSelf(task);
         taskExit(task, NULL);          taskExit(task, NULL);
Line 403  acceptClients(sched_task_t *task) Line 424  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;
        socklen_t salen = sizeof(sockaddr_t);        socklen_t salen = E_SOCKADDR_MAX;
         int sock;          int sock;
 #ifdef TCP_SESSION_TIMEOUT  #ifdef TCP_SESSION_TIMEOUT
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
Line 426  acceptClients(sched_task_t *task) Line 447  acceptClients(sched_task_t *task)
                 AIT_FREE_VAL(&c->cli_buf);                  AIT_FREE_VAL(&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 {
                 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);
                   fcntl(c->cli_sock, F_SETFD, FD_CLOEXEC);
           }
   
 #ifdef TCP_SESSION_TIMEOUT  #ifdef TCP_SESSION_TIMEOUT
         /* armed timer for close stateless connection */          /* armed timer for close stateless connection */
Line 464  txUDPPacket(sched_task_t *task) Line 487  txUDPPacket(sched_task_t *task)
                         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_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 481  txUDPPacket(sched_task_t *task) Line 504  txUDPPacket(sched_task_t *task)
                                 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_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 500  txUDPPacket(sched_task_t *task) Line 523  txUDPPacket(sched_task_t *task)
   
         /* send reply */          /* send reply */
         ret = sendto(TASK_FD(task), buf, wlen, MSG_NOSIGNAL,           ret = sendto(TASK_FD(task), buf, wlen, MSG_NOSIGNAL, 
                        &c->cli_sa.sa, c->cli_sa.sa.sa_len);                        &c->cli_sa.sa, e_addrlen(&c->cli_sa));
         if (ret == -1) {          if (ret == -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], 
Line 519  rxUDPPacket(sched_task_t *task) Line 542  rxUDPPacket(sched_task_t *task)
         u_short crc;          u_short crc;
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
         sockaddr_t sa;          sockaddr_t sa;
        socklen_t salen;        socklen_t salen = E_SOCKADDR_MAX;
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
         ait_val_t b = AIT_VAL_INIT;          ait_val_t b = AIT_VAL_INIT;
   
         /* receive connect packet */          /* receive connect packet */
         AIT_SET_BUF(&b, NULL, srv->srv_netbuf);          AIT_SET_BUF(&b, NULL, srv->srv_netbuf);
        salen = sa.ss.ss_len = sizeof(sockaddr_t);#ifndef __linux__
         sa.ss.ss_len = salen;
 #endif
         rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen);          rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen);
         rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);          rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);
         if (rlen < sizeof(struct tagRPCCall))          if (rlen < sizeof(struct tagRPCCall))
Line 542  rxUDPPacket(sched_task_t *task) Line 567  rxUDPPacket(sched_task_t *task)
         /* 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*) AIT_GET_BUF(&b), len / 2))
                 goto end;                  goto end;
   
         /* check RPC packet session info */          /* check RPC packet session info */
Line 573  rxUDPPacket(sched_task_t *task) Line 598  rxUDPPacket(sched_task_t *task)
         schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);          schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
   
         /* send RPC reply */          /* send RPC reply */
        if (!noreply)        if (!noreply && (rpc->call_io & RPC_REQ))
                 schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET],                   schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                                 c, TASK_FD(task), rpc, len);                                  c, TASK_FD(task), rpc, len);
 end:  end:
Line 604  txRAWPacket(sched_task_t *task) Line 629  txRAWPacket(sched_task_t *task)
                         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_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 621  txRAWPacket(sched_task_t *task) Line 646  txRAWPacket(sched_task_t *task)
                                 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_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 640  txRAWPacket(sched_task_t *task) Line 665  txRAWPacket(sched_task_t *task)
   
         /* send reply */          /* send reply */
         ret = sendto(TASK_FD(task), buf, wlen, MSG_NOSIGNAL,           ret = sendto(TASK_FD(task), buf, wlen, MSG_NOSIGNAL, 
                        &c->cli_sa.sa, c->cli_sa.sa.sa_len);                        &c->cli_sa.sa, e_addrlen(&c->cli_sa));
         if (ret == -1) {          if (ret == -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], 
Line 659  rxRAWPacket(sched_task_t *task) Line 684  rxRAWPacket(sched_task_t *task)
         u_short crc;          u_short crc;
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
         sockaddr_t sa;          sockaddr_t sa;
        socklen_t salen;        socklen_t salen = E_SOCKADDR_MAX;
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
         ait_val_t b = AIT_VAL_INIT;          ait_val_t b = AIT_VAL_INIT;
   
         /* receive connect packet */          /* receive connect packet */
         AIT_SET_BUF(&b, NULL, srv->srv_netbuf);          AIT_SET_BUF(&b, NULL, srv->srv_netbuf);
        salen = sa.ss.ss_len = sizeof(sockaddr_t);#ifndef __linux__
         sa.ss.ss_len = salen;
 #endif
         rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen);          rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen);
         if (sa.sa.sa_family == AF_INET) {          if (sa.sa.sa_family == AF_INET) {
                 struct ip *h;                  struct ip *h;
Line 677  rxRAWPacket(sched_task_t *task) Line 704  rxRAWPacket(sched_task_t *task)
                         rpc = (struct tagRPCCall*) (h + 1);                          rpc = (struct tagRPCCall*) (h + 1);
                 }                  }
         } else {          } else {
   #ifdef IPV6_REMOVE_HEADER
                 struct ip6_hdr *h;                  struct ip6_hdr *h;
                 h = (struct ip6_hdr*) AIT_GET_BUF(&b);                  h = (struct ip6_hdr*) AIT_GET_BUF(&b);
                if (rlen < (ntohs(h->ip6_plen) + sizeof(struct ip6_hdr)) ||                 if (rlen < ntohs(h->ip6_plen) || h->ip6_nxt != IPPROTO_ERPC)
                                h->ip6_nxt != IPPROTO_ERPC) 
                         goto end;                          goto end;
                 else {                  else {
                         rlen -= sizeof(struct ip6_hdr);                          rlen -= sizeof(struct ip6_hdr);
                         rpc = (struct tagRPCCall*) (h + 1);                          rpc = (struct tagRPCCall*) (h + 1);
                 }                  }
   #else
                   rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);
   #endif
         }          }
         if (rlen < sizeof(struct tagRPCCall))          if (rlen < sizeof(struct tagRPCCall))
                 goto end;                  goto end;
Line 701  rxRAWPacket(sched_task_t *task) Line 731  rxRAWPacket(sched_task_t *task)
         /* 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*) AIT_GET_BUF(&b), len / 2))
                 goto end;                  goto end;
   
         /* check RPC packet session info */          /* check RPC packet session info */
Line 732  rxRAWPacket(sched_task_t *task) Line 762  rxRAWPacket(sched_task_t *task)
         schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);          schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
   
         /* send RPC reply */          /* send RPC reply */
        if (!noreply)        if (!noreply && (rpc->call_io & RPC_REQ))
                 schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET],                   schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                                 c, TASK_FD(task), rpc, len);                                  c, TASK_FD(task), rpc, len);
 end:  end:
Line 745  end: Line 775  end:
 static void *  static void *
 txBPFPacket(sched_task_t *task)  txBPFPacket(sched_task_t *task)
 {  {
   #ifndef __linux__
         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;
Line 765  txBPFPacket(sched_task_t *task) Line 796  txBPFPacket(sched_task_t *task)
                         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_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 782  txBPFPacket(sched_task_t *task) Line 813  txBPFPacket(sched_task_t *task)
                                 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_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 813  txBPFPacket(sched_task_t *task) Line 844  txBPFPacket(sched_task_t *task)
                 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);
         }          }
   #else
           rpc_SetErr(ENOTSUP, "Feature isn't supported on Linux!");
   #endif
   
         taskExit(task, NULL);          taskExit(task, NULL);
 }  }
Line 820  txBPFPacket(sched_task_t *task) Line 854  txBPFPacket(sched_task_t *task)
 static void *  static void *
 rxBPFPacket(sched_task_t *task)  rxBPFPacket(sched_task_t *task)
 {  {
   #ifndef __linux__
         rpc_srv_t *srv = TASK_ARG(task);          rpc_srv_t *srv = TASK_ARG(task);
         rpc_cli_t *c = NULL;          rpc_cli_t *c = NULL;
         int len, rlen, noreply;          int len, rlen, noreply;
Line 897  rxBPFPacket(sched_task_t *task) Line 932  rxBPFPacket(sched_task_t *task)
         schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);          schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
   
         /* send RPC reply */          /* send RPC reply */
        if (!noreply)        if (!noreply && (rpc->call_io & RPC_REQ))
                 schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET],                   schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                                 c, TASK_FD(task), rpc, len);                                  c, TASK_FD(task), rpc, len);
 end:  end:
         AIT_FREE_VAL(&b);          AIT_FREE_VAL(&b);
         schedReadSelf(task);          schedReadSelf(task);
   #else
           rpc_SetErr(ENOTSUP, "Feature isn't supported on Linux!");
   #endif
   
         taskExit(task, NULL);          taskExit(task, NULL);
 }  }
   
Line 928  txEXTPacket(sched_task_t *task) Line 967  txEXTPacket(sched_task_t *task)
                         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_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 945  txEXTPacket(sched_task_t *task) Line 984  txEXTPacket(sched_task_t *task)
                                 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_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 1023  rxEXTPacket(sched_task_t *task) Line 1062  rxEXTPacket(sched_task_t *task)
         schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);          schedEvent(TASK_ROOT(task), execCall, c, (int) noreply, rpc, len);
   
         /* send RPC reply */          /* send RPC reply */
        if (!noreply)        if (!noreply && (rpc->call_io & RPC_REQ))
                 schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET],                   schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                                 c, TASK_FD(task), rpc, len);                                  c, TASK_FD(task), rpc, len);
 end:  end:
Line 1118  rxBLOB(sched_task_t *task) Line 1157  rxBLOB(sched_task_t *task)
                         if (!(b = rpc_srv_getBLOB(s, ntohl(blob.hdr_var)))) {                          if (!(b = rpc_srv_getBLOB(s, ntohl(blob.hdr_var)))) {
                                 rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob.hdr_var));                                  rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob.hdr_var));
                                 blob.hdr_cmd = no;                                  blob.hdr_cmd = no;
                                blob.hdr_ret = RPC_ERROR(-1);                                RPC_SET_BLOB_RET(&blob, -1);
                                 break;                                  break;
                         } else                          } else
                                 blob.hdr_len = htonl(b->blob_len);                                  blob.hdr_len = htonl(b->blob_len);
Line 1129  rxBLOB(sched_task_t *task) Line 1168  rxBLOB(sched_task_t *task)
                                 rpc_srv_blobUnmap(b);                                  rpc_srv_blobUnmap(b);
                         } else {                          } else {
                                 blob.hdr_cmd = error;                                  blob.hdr_cmd = error;
                                blob.hdr_ret = RPC_ERROR(-1);                                RPC_SET_BLOB_RET(&blob, -1);
                         }                          }
                         break;                          break;
                 case set:                  case set:
Line 1143  rxBLOB(sched_task_t *task) Line 1182  rxBLOB(sched_task_t *task)
                                 rpc_srv_blobUnmap(b);                                  rpc_srv_blobUnmap(b);
                         } else {                          } else {
                                 blob.hdr_cmd = error;                                  blob.hdr_cmd = error;
                                blob.hdr_ret = RPC_ERROR(-1);                                RPC_SET_BLOB_RET(&blob, -1);
                         }                          }
                         break;                          break;
                 case unset:                  case unset:
                         if (rpc_srv_unregisterBLOB(s, ntohl(blob.hdr_var)) == -1) {                          if (rpc_srv_unregisterBLOB(s, ntohl(blob.hdr_var)) == -1) {
                                 blob.hdr_cmd = error;                                  blob.hdr_cmd = error;
                                blob.hdr_ret = RPC_ERROR(-1);                                RPC_SET_BLOB_RET(&blob, -1);
                         }                          }
                         break;                          break;
                 default:                  default:
                         rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob.hdr_cmd);                          rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob.hdr_cmd);
                         blob.hdr_cmd = error;                          blob.hdr_cmd = error;
                        blob.hdr_ret = RPC_ERROR(-1);                        RPC_SET_BLOB_RET(&blob, -1);
         }          }
   
 end:  end:
Line 1168  end: Line 1207  end:
 static void *  static void *
 flushBLOB(sched_task_t *task)  flushBLOB(sched_task_t *task)
 {  {
   #ifdef atomic_load_acq_ptr
         uintptr_t sigArg = atomic_load_acq_ptr(&_glSigArg);          uintptr_t sigArg = atomic_load_acq_ptr(&_glSigArg);
   #else
           uintptr_t sigArg = *((volatile uintptr_t*) &_glSigArg);
   #endif
         rpc_srv_t *srv = sigArg ? (void*) sigArg : TASK_ARG(task);          rpc_srv_t *srv = sigArg ? (void*) sigArg : TASK_ARG(task);
         rpc_blob_t *b, *tmp;          rpc_blob_t *b, *tmp;
   
Line 1179  flushBLOB(sched_task_t *task) Line 1222  flushBLOB(sched_task_t *task)
                 e_free(b);                  e_free(b);
         }          }
   
        if (!schedSignalSelf(task)) {        if (sigArg) {
                 /* disabled kqueue support in libaitsched */                  /* disabled kqueue support in libaitsched */
                 struct sigaction sa;                  struct sigaction sa;
   
Line 1188  flushBLOB(sched_task_t *task) Line 1231  flushBLOB(sched_task_t *task)
                 sa.sa_handler = (void (*)(int)) flushBLOB;                  sa.sa_handler = (void (*)(int)) flushBLOB;
                 sa.sa_flags = SA_RESTART | SA_RESETHAND;                  sa.sa_flags = SA_RESTART | SA_RESETHAND;
                 sigaction(SIGFBLOB, &sa, NULL);                  sigaction(SIGFBLOB, &sa, NULL);
                   return NULL;
           } else {
                   schedSignalSelf(task);
                   taskExit(task, NULL);
         }          }
   
         taskExit(task, NULL);  
 }  }
   
 static void *  static void *
Line 1199  acceptBLOBClients(sched_task_t *task) Line 1244  acceptBLOBClients(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;          register int i;
        socklen_t salen = sizeof(sockaddr_t);        socklen_t salen = E_SOCKADDR_MAX;
         int sock;          int sock;
 #ifdef TCP_NOPUSH  #ifdef TCP_NOPUSH
         int n = 1;          int n = 1;
Line 1244  acceptBLOBClients(sched_task_t *task) Line 1289  acceptBLOBClients(sched_task_t *task)
                 setsockopt(c->cli_sock, IPPROTO_TCP, TCP_NOPUSH, &n, sizeof n);                  setsockopt(c->cli_sock, IPPROTO_TCP, TCP_NOPUSH, &n, sizeof n);
 #endif  #endif
                 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);
                   fcntl(c->cli_sock, F_SETFD, FD_CLOEXEC);
         }          }
   
         schedRead(TASK_ROOT(task), rxBLOB, c, c->cli_sock, NULL, 0);          schedRead(TASK_ROOT(task), rxBLOB, c, c->cli_sock, NULL, 0);
Line 1266  int Line 1312  int
 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_short Port, const char *diskDir)  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_short Port, const char *diskDir)
 {  {
         int n = 1;          int n = 1;
           socklen_t salen;
   
         if (!srv || srv->srv_kill) {          if (!srv || srv->srv_kill) {
                 rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server");                  rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server");
Line 1284  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 1331  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
   
         srv->srv_blob.server.cli_parent = srv;          srv->srv_blob.server.cli_parent = srv;
   
        memcpy(&srv->srv_blob.server.cli_sa, &srv->srv_server.cli_sa, sizeof(sockaddr_t));        memcpy(&srv->srv_blob.server.cli_sa, &srv->srv_server.cli_sa, sizeof srv->srv_blob.server.cli_sa);
         switch (srv->srv_blob.server.cli_sa.sa.sa_family) {          switch (srv->srv_blob.server.cli_sa.sa.sa_family) {
                 case AF_INET:                  case AF_INET:
                         srv->srv_blob.server.cli_sa.sin.sin_port =                           srv->srv_blob.server.cli_sa.sin.sin_port = 
                                 htons(Port ? Port : ntohs(srv->srv_blob.server.cli_sa.sin.sin_port) + 1);                                  htons(Port ? Port : ntohs(srv->srv_blob.server.cli_sa.sin.sin_port) + 1);
                           salen = sizeof srv->srv_blob.server.cli_sa.sin;
                         break;                          break;
                 case AF_INET6:                  case AF_INET6:
                         srv->srv_blob.server.cli_sa.sin6.sin6_port =                           srv->srv_blob.server.cli_sa.sin6.sin6_port = 
                                 htons(Port ? Port : ntohs(srv->srv_blob.server.cli_sa.sin6.sin6_port) + 1);                                  htons(Port ? Port : ntohs(srv->srv_blob.server.cli_sa.sin6.sin6_port) + 1);
                           salen = sizeof srv->srv_blob.server.cli_sa.sin6;
                         break;                          break;
                 case AF_LOCAL:                  case AF_LOCAL:
                         strlcat(srv->srv_blob.server.cli_sa.sun.sun_path, ".blob",                           strlcat(srv->srv_blob.server.cli_sa.sun.sun_path, ".blob", 
                                         sizeof srv->srv_blob.server.cli_sa.sun.sun_path);                                          sizeof srv->srv_blob.server.cli_sa.sun.sun_path);
                           salen = sizeof srv->srv_blob.server.cli_sa.sun;
                         break;                          break;
                 default:                  default:
                         AIT_FREE_VAL(&srv->srv_blob.dir);                          AIT_FREE_VAL(&srv->srv_blob.dir);
Line 1329  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 1379  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
                 AIT_FREE_VAL(&srv->srv_blob.dir);                  AIT_FREE_VAL(&srv->srv_blob.dir);
                 return -1;                  return -1;
         }          }
        if (bind(srv->srv_blob.server.cli_sock, &srv->srv_blob.server.cli_sa.sa,         if (bind(srv->srv_blob.server.cli_sock, &srv->srv_blob.server.cli_sa.sa, salen) == -1) {
                                srv->srv_blob.server.cli_sa.sa.sa_len) == -1) { 
                 LOGERR;                  LOGERR;
                 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);
Line 1376  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 1425  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
   
         srv->srv_blob.kill = 1;          srv->srv_blob.kill = 1;
   
         schedEnd(&srv->srv_blob.root);  
   
         if (srv->srv_blob.server.cli_sa.sa.sa_family == AF_LOCAL)          if (srv->srv_blob.server.cli_sa.sa.sa_family == AF_LOCAL)
                 unlink(srv->srv_blob.server.cli_sa.sun.sun_path);                  unlink(srv->srv_blob.server.cli_sa.sun.sun_path);
   
           schedEnd(&srv->srv_blob.root);
 }  }
   
 /*  /*
Line 1410  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 1459  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
                 /* disabled kqueue support in libaitsched */                  /* disabled kqueue support in libaitsched */
                 struct sigaction sa;                  struct sigaction sa;
   
   #ifdef atomic_store_rel_ptr
                 atomic_store_rel_ptr(&_glSigArg, (uintptr_t) srv);                  atomic_store_rel_ptr(&_glSigArg, (uintptr_t) srv);
   #else
                   *((volatile uintptr_t*) &_glSigArg) = (uintptr_t) srv;
   #endif
   
                 memset(&sa, 0, sizeof sa);                  memset(&sa, 0, sizeof sa);
                 sigemptyset(&sa.sa_mask);                  sigemptyset(&sa.sa_mask);
Line 1476  rpc_srv_initServer(u_char InstID, int concurentClients Line 1529  rpc_srv_initServer(u_char InstID, int concurentClients
         int n = 1;          int n = 1;
         rpc_srv_t *srv = NULL;          rpc_srv_t *srv = NULL;
         sockaddr_t sa = E_SOCKADDR_INIT;          sockaddr_t sa = E_SOCKADDR_INIT;
           socklen_t salen;
   
         if (!concurentClients || (proto < 0 || proto > SOCK_RAW)) {          if (!concurentClients || (proto < 0 || proto > SOCK_RAW)) {
                 rpc_SetErr(EINVAL, "Invalid parameters can`t init RPC server");                  rpc_SetErr(EINVAL, "Invalid parameters can`t init RPC server");
Line 1483  rpc_srv_initServer(u_char InstID, int concurentClients Line 1537  rpc_srv_initServer(u_char InstID, int concurentClients
         }          }
         if (!Port && proto < SOCK_RAW)          if (!Port && proto < SOCK_RAW)
                 Port = RPC_DEFPORT;                  Port = RPC_DEFPORT;
        if (!e_gethostbyname(csHost, Port, &sa))        if (!(salen = e_gethostbyname(csHost, Port, &sa)))
                 return NULL;                  return NULL;
         if (!proto)          if (!proto)
                 proto = SOCK_STREAM;                  proto = SOCK_STREAM;
Line 1527  rpc_srv_initServer(u_char InstID, int concurentClients Line 1581  rpc_srv_initServer(u_char InstID, int concurentClients
                 pthread_mutex_destroy(&srv->srv_funcs.mtx);                  pthread_mutex_destroy(&srv->srv_funcs.mtx);
                 e_free(srv);                  e_free(srv);
                 return NULL;                  return NULL;
        }        } else
                 schedSignalDispatch(srv->srv_root, 42);
   
         /* init pool for clients */          /* init pool for clients */
         srv->srv_clients = array_Init(concurentClients);          srv->srv_clients = array_Init(concurentClients);
Line 1565  rpc_srv_initServer(u_char InstID, int concurentClients Line 1620  rpc_srv_initServer(u_char InstID, int concurentClients
                 LOGERR;                  LOGERR;
                 goto err;                  goto err;
         }          }
        if (bind(srv->srv_server.cli_sock, &srv->srv_server.cli_sa.sa,         if (bind(srv->srv_server.cli_sock, &srv->srv_server.cli_sa.sa, salen) == -1) {
                                srv->srv_server.cli_sa.sa.sa_len) == -1) { 
                 LOGERR;                  LOGERR;
                 goto err;                  goto err;
         } else          } else
Line 1599  rpc_srv_endServer(rpc_srv_t ** __restrict psrv) Line 1653  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
   
         /* if send kill to blob server */          /* if send kill to blob server */
         rpc_srv_endBLOBServer(*psrv);          rpc_srv_endBLOBServer(*psrv);
           /* wait for BLOB server done */
           while (*(&(*psrv)->srv_blob.root))
                   usleep(1000);
   
         (*psrv)->srv_kill = 1;          (*psrv)->srv_kill = 1;
         sleep(RPC_SCHED_POLLING);          sleep(RPC_SCHED_POLLING);
   
         schedEnd(&(*psrv)->srv_root);  
   
         if ((*psrv)->srv_server.cli_sa.sa.sa_family == AF_LOCAL)          if ((*psrv)->srv_server.cli_sa.sa.sa_family == AF_LOCAL)
                 unlink((*psrv)->srv_server.cli_sa.sun.sun_path);                  unlink((*psrv)->srv_server.cli_sa.sun.sun_path);
   
           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 1647  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 1704  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
         schedPolling(srv->srv_root, &ts, NULL);          schedPolling(srv->srv_root, &ts, NULL);
         /* main rpc loop */          /* main rpc loop */
         schedRun(srv->srv_root, &srv->srv_kill);          schedRun(srv->srv_root, &srv->srv_kill);
           schedSignalDispatch(srv->srv_root, 0);
   
         /* close all clients connections & server socket */          /* close all clients connections & server socket */
         for (i = 0; i < array_Size(srv->srv_clients); i++) {          for (i = 0; i < array_Size(srv->srv_clients); i++) {
Line 1720  rpc_srv_execCall(rpc_cli_t * __restrict cli, struct ta Line 1778  rpc_srv_execCall(rpc_cli_t * __restrict cli, struct ta
 rpc_srv_t *  rpc_srv_t *
 rpc_srv_initServer2(u_char InstID, int concurentClients, int netBuf, const char *csIface)  rpc_srv_initServer2(u_char InstID, int concurentClients, int netBuf, const char *csIface)
 {  {
   #ifndef __linux__
         int n = 1;          int n = 1;
         rpc_srv_t *srv = NULL;          rpc_srv_t *srv = NULL;
         sockaddr_t sa = E_SOCKADDR_INIT;          sockaddr_t sa = E_SOCKADDR_INIT;
Line 1784  rpc_srv_initServer2(u_char InstID, int concurentClient Line 1843  rpc_srv_initServer2(u_char InstID, int concurentClient
                 pthread_mutex_destroy(&srv->srv_funcs.mtx);                  pthread_mutex_destroy(&srv->srv_funcs.mtx);
                 e_free(srv);                  e_free(srv);
                 return NULL;                  return NULL;
        }        } else
                 schedSignalDispatch(srv->srv_root, 42);
   
         /* init pool for clients */          /* init pool for clients */
         srv->srv_clients = array_Init(concurentClients);          srv->srv_clients = array_Init(concurentClients);
Line 1846  err: /* error condition */ Line 1906  err: /* error condition */
         schedEnd(&srv->srv_root);          schedEnd(&srv->srv_root);
         pthread_mutex_destroy(&srv->srv_funcs.mtx);          pthread_mutex_destroy(&srv->srv_funcs.mtx);
         e_free(srv);          e_free(srv);
   #else
           rpc_SetErr(ENOTSUP, "Feature isn't supported on Linux!");
   #endif
   
         return NULL;          return NULL;
 }  }
   
Line 1898  rpc_srv_initServerExt(u_char InstID, int netBuf, int f Line 1962  rpc_srv_initServerExt(u_char InstID, int netBuf, int f
                 pthread_mutex_destroy(&srv->srv_funcs.mtx);                  pthread_mutex_destroy(&srv->srv_funcs.mtx);
                 e_free(srv);                  e_free(srv);
                 return NULL;                  return NULL;
        }        } else
                 schedSignalDispatch(srv->srv_root, 42);
   
         /* init pool for clients */          /* init pool for clients */
         srv->srv_clients = array_Init(1);          srv->srv_clients = array_Init(1);
Removed from v.1.26.2.10  
changed lines
  Added in v.1.30.2.8

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