[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.17.4.5 and 1.21

version 1.17.4.5, 2013/08/21 12:59:12 version 1.21, 2013/11/14 21:44:14
Line 67  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = { Line 67  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = {
 };  };
   
   
 static inline u_char *  
 getBuffer(rpc_cli_t * __restrict c)  
 {  
         u_char *b = NULL;  
   
         assert(c);  
   
         if (RPC_ISNEXTBUF(c))  
                 b = AIT_GET_BUF(array(c->cli_buf, 1, ait_val_t*));  
         else  
                 b = AIT_GET_BUF(array(c->cli_buf, 0, ait_val_t*)) +   
                         sizeof(struct tagRPCCall);  
   
         return b;  
 }  
   
 static inline struct tagRPCCall *  
 getHeader(rpc_cli_t * __restrict c)  
 {  
         assert(c);  
   
         return (struct tagRPCCall*) AIT_GET_BUF(array(c->cli_buf, 0, ait_val_t*));  
 }  
   
 void  void
 rpc_freeCli(rpc_cli_t * __restrict c)  rpc_freeCli(rpc_cli_t * __restrict c)
 {  {
Line 98  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(s) */        /* free buffer */
        ait_freeVars(&c->cli_buf);        AIT_FREE_VAL(&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 150  _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;
                 }                  }
   
                /* init buffer(s) */                /* alloc empty buffer */
                c->cli_buf = ait_allocVars(2);                AIT_SET_BUFSIZ(&c->cli_buf, 0, srv->srv_netbuf);
                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 191  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;        u_char *buf = AIT_GET_BUF(&c->cli_buf);
        struct tagRPCCall *rpc = (struct tagRPCCall*) TASK_DATA(task);        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
        int ret, wlen = sizeof(struct tagRPCCall);        int ret, estlen, wlen = sizeof(struct tagRPCCall);
        int len = sizeof(struct tagRPCCall) + ntohl(rpc->call_len);        struct pollfd pfd;
 #ifdef TCP_SESSION_TIMEOUT
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
        buf = e_malloc(len);        schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
        if (!buf) {        schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                rpc_SetErr(elwix_GetErrno(), "%s", elwix_GetError());                         TASK_ARG(task), ts, TASK_ARG(task), 0);
                /* close connection */#endif
                schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],  
                                TASK_ARG(task), 0, NULL, 0); 
                return NULL; 
        } else { 
                /* copy RPC header */ 
                memcpy(buf, rpc, wlen); 
                rpc = (struct tagRPCCall*) buf; 
        } 
   
         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));
Line 218  txPacket(sched_task_t *task) Line 182  txPacket(sched_task_t *task)
                         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, len - 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 236  txPacket(sched_task_t *task) Line 208  txPacket(sched_task_t *task)
   
         rpc->call_len = htonl(wlen);          rpc->call_len = htonl(wlen);
   
   #if 0
           /* calculate CRC */
           rpc->call_crc ^= rpc->call_crc;
           rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
   #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;
                 }
         }          }
   
         e_free(buf);  
         return NULL;          return NULL;
 }  }
   
Line 255  execCall(sched_task_t *task) Line 248  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 = getBuffer(c);        u_char *buf = AIT_GET_BUF(&c->cli_buf);
        struct tagRPCCall *rpc = getHeader(c);        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, ntohl(rpc->call_len), argc, 42);                arr = ait_buffer2vars(buf + sizeof(struct tagRPCCall), 
                                 AIT_LEN(&c->cli_buf) - sizeof(struct tagRPCCall), argc, 42);
                 if (!arr) {                  if (!arr) {
                         rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError());                          rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError());
   
Line 284  execCall(sched_task_t *task) Line 278  execCall(sched_task_t *task)
                 argc = RPC_CHK_NOREPLY(rpc);                  argc = RPC_CHK_NOREPLY(rpc);
                 rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(c, rpc, f->func_name, arr));                  rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(c, rpc, f->func_name, arr));
                 if (rpc->call_rep.ret == htonl(-1)) {                  if (rpc->call_rep.ret == htonl(-1)) {
                        rpc->call_rep.eno = RPC_ERROR(errno);                        if (!rpc->call_rep.eno) {
                                 LOGERR;
                                 rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                         }
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                 } else {                  } else {
                         rpc->call_rep.eno ^= rpc->call_rep.eno;                          rpc->call_rep.eno ^= rpc->call_rep.eno;
Line 308  rxPacket(sched_task_t *task) Line 305  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;
        ait_val_t *bufz = array(c->cli_buf, 0, ait_val_t*);#if 0
        u_char *buf = (u_char*) AIT_GET_BUF(bufz);        u_short crc;
 #endif
         u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
           struct pollfd pfd;
   #ifdef TCP_SESSION_TIMEOUT
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
        memset(buf, 0, AIT_LEN(bufz));        schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
        /* 1st buffer is last */        schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
        RPC_CLR_NEXTBUF(c);                         TASK_ARG(task), ts, TASK_ARG(task), 0);
 #endif
   
        /* read rpc header */        memset(buf, 0, sizeof(struct tagRPCCall));
        rlen = recv(TASK_FD(task), rpc, MIN(sizeof(struct tagRPCCall), AIT_LEN(bufz)), 0);        rlen = recv(TASK_FD(task), rpc, sizeof(struct tagRPCCall), MSG_PEEK);
        if (rlen < sizeof(struct tagRPCCall) ||         if (rlen < sizeof(struct tagRPCCall)) {
                        ntohl(rpc->call_len) < sizeof(struct tagRPCCall)) { 
                 /* 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 {
                buf += sizeof(struct tagRPCCall);                estlen = ntohl(rpc->call_len);
                len = ntohl(rpc->call_len);                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;
         }          }
   
        if (len > (AIT_LEN(bufz) - sizeof(struct tagRPCCall))) {        /* get next part of packet */
                /* add extra buffer */        memset(buf, 0, len);
                if (!(bufz = ait_getVars(&c->cli_buf, 1))) {        pfd.fd = TASK_FD(task);
         pfd.events = POLLIN | POLLPRI;
         for (; len > 0; len -= rlen, buf += rlen) {
                 if ((rlen = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                                 pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                         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;
                 }
                 rlen = recv(TASK_FD(task), buf, len, 0);
                 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 {  
                         AIT_FREE_VAL(bufz);  
                         AIT_SET_BUFSIZ(bufz, 0, len);  
                         buf = AIT_GET_BUF(bufz);  
                 }                  }
                 /* buffer isnt last */  
                 RPC_SET_NEXTBUF(c);  
         }          }
   
        /* read payload */#if 0
        rlen = recv(TASK_FD(task), buf, len, 0);        /* check integrity of packet */
        if (rlen < len) {        crc = ntohs(rpc->call_crc);
                /* close connection */        rpc->call_crc ^= rpc->call_crc;
                schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],         if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
                                TASK_ARG(task), 0, NULL, 0);                rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
                 return NULL;                  return NULL;
         }          }
   #endif
   
         noreply = RPC_CHK_NOREPLY(rpc);          noreply = RPC_CHK_NOREPLY(rpc);
   
Line 366  rxPacket(sched_task_t *task) Line 381  rxPacket(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), noreply, rpc, len);                schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), (int) noreply, rpc, len);
         }          }
   
         /* send RPC reply */          /* send RPC reply */
Line 385  acceptClients(sched_task_t *task) Line 400  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 = sizeof(sockaddr_t);
           int sock;
   #ifdef TCP_SESSION_TIMEOUT
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   #endif
   
         c = _allocClient(srv, NULL);          c = _allocClient(srv, NULL);
        if (!c)        if (!c) {
                 EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");
                 if ((sock = accept(TASK_FD(task), NULL, NULL)) != -1) {
                         shutdown(sock, SHUT_RDWR);
                         close(sock);
                 }
                 goto end;                  goto end;
           }
   
         /* 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_freeVars(&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);
   
   #ifdef TCP_SESSION_TIMEOUT
           /* armed timer for close stateless connection */
           schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, c, NULL);
           schedTimer(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], c, 
                           ts, c, 0);
   #endif
         schedRead(TASK_ROOT(task), cbProto[srv->srv_proto][CB_RXPACKET], c,           schedRead(TASK_ROOT(task), cbProto[srv->srv_proto][CB_RXPACKET], c, 
                         c->cli_sock, NULL, 0);                          c->cli_sock, NULL, 0);
 end:  end:
Line 414  txUDPPacket(sched_task_t *task) Line 445  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;        u_char *buf = AIT_GET_BUF(&c->cli_buf);
        struct tagRPCCall *rpc = (struct tagRPCCall*) TASK_DATA(task);        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
         int ret, wlen = sizeof(struct tagRPCCall);          int ret, wlen = sizeof(struct tagRPCCall);
         int len = sizeof(struct tagRPCCall) + ntohl(rpc->call_len);  
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
         schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), 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], 
                          TASK_ARG(task), ts, TASK_ARG(task), 0);                           TASK_ARG(task), ts, TASK_ARG(task), 0);
   
         buf = e_malloc(len);  
         if (!buf) {  
                 rpc_SetErr(elwix_GetErrno(), "%s", elwix_GetError());  
                 /* close connection */  
                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],   
                                  TASK_ARG(task), 0, NULL, 0);  
                 return NULL;  
         } else {  
                 /* copy RPC header */  
                 memcpy(buf, rpc, wlen);  
                 rpc = (struct tagRPCCall*) buf;  
         }  
   
         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 {
                         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, len - 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 477  txUDPPacket(sched_task_t *task) Line 493  txUDPPacket(sched_task_t *task)
                                  TASK_ARG(task), 0, NULL, 0);                                   TASK_ARG(task), 0, NULL, 0);
         }          }
   
         e_free(buf);  
         return NULL;          return NULL;
 }  }
   
Line 487  rxUDPPacket(sched_task_t *task) Line 502  rxUDPPacket(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;
         int len, rlen, noreply;          int len, rlen, noreply;
        ait_val_t *bufz;        u_short crc, off = 0;
        u_char *buf = NULL;        u_char buf[USHRT_MAX + 1];
        struct tagRPCCall rpcbuf, *rpc;        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
        sockaddr_t sa[2];        sockaddr_t sa;
         socklen_t salen;          socklen_t salen;
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
         memset(buf, 0, AIT_LEN(bufz));  
         memset(&rpcbuf, 0, sizeof rpcbuf);  
   
         /* receive connect packet */          /* receive connect packet */
        salen = sa[0].ss.ss_len = sizeof(sockaddr_t);        salen = sa.ss.ss_len = sizeof(sockaddr_t);
        rlen = recvfrom(TASK_FD(task), &rpcbuf, sizeof rpcbuf, 0, &sa[0].sa, &salen);        rlen = recvfrom(TASK_FD(task), buf, sizeof buf, 0, &sa.sa, &salen);
        if (rlen < sizeof(struct tagRPCCall) || ntohl(rpcbuf.call_len) < sizeof(struct tagRPCCall))        if (rlen < 1)
                 goto end;                  goto end;
         else  
                 len = ntohl(rpcbuf.call_len);  
   
        buf = e_malloc(len);        c = _allocClient(srv, &sa);
        if (!buf) 
                goto end; 
        else 
                memset(buf, 0, len); 
 
        /* read payload */ 
        salen = sa[1].ss.ss_len = sizeof(sockaddr_t); 
        rlen = recvfrom(TASK_FD(task), buf, len, 0, &sa[1].sa, &salen); 
        if (rlen < len || memcmp(&sa[0], &sa[1], sizeof sa[0])) 
                goto end; 
 
        c = _allocClient(srv, sa); 
         if (!c)          if (!c)
                 goto end;                  goto end;
         else {          else {
                 /* add extra buffer */  
                 if (!(bufz = ait_getVars(&c->cli_buf, 1)))  
                         goto end;  
                 else {  
                         AIT_FREE_VAL(bufz);  
                         AIT_SET_BUFSIZ(bufz, 0, len);  
                         /* buffer isnt last */  
                         RPC_SET_NEXTBUF(c);  
                 }  
   
                 rpc = getHeader(c);  
                 memcpy(rpc, &rpcbuf, sizeof(struct tagRPCCall));  
                 memcpy(getBuffer(c), buf, len);  
   
                 c->cli_sock = TASK_FD(task);                  c->cli_sock = TASK_FD(task);
                memcpy(&c->cli_sa, sa, sizeof c->cli_sa);                memcpy(&c->cli_sa, &sa, sizeof c->cli_sa);
                 memcpy(AIT_GET_BUF(&c->cli_buf), buf, AIT_LEN(&c->cli_buf));
                 /* armed timer for close stateless connection */                  /* 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);
         }          }
   
        /* check integrity of packet */        do {
        if (ntohs(rpc->call_crc) != crcFletcher16((u_short*) buf, len / 2)) {                /* check RPC packet */
                rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");                if (rlen < sizeof(struct tagRPCCall)) {
                goto end;                        rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
        }                        break;
                 } else
                         rpc = (struct tagRPCCall*) (AIT_GET_BUF(&c->cli_buf) + off);
   
        noreply = RPC_CHK_NOREPLY(rpc);                len = ntohl(rpc->call_len);
                 rlen -= len;
   
        /* check RPC packet session info */                /* check RPC packet lengths */
        if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {                if (rlen < 0 || len < sizeof(struct tagRPCCall)) {
                rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");                        rpc_SetErr(ERPCMISMATCH, "Broken RPC packet length");
                         /* skip entire packet */
                         break;
                 }
   
                rpc->call_argc ^= rpc->call_argc;                /* check integrity of packet */
                rpc->call_rep.ret = RPC_ERROR(-1);                crc = ntohs(rpc->call_crc);
                rpc->call_rep.eno = RPC_ERROR(errno);                rpc->call_crc ^= rpc->call_crc;
        } else {                if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
                /* execute RPC call */                        rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
                schedEvent(TASK_ROOT(task), execCall, c, noreply, rpc, len); 
        } 
   
        /* send RPC reply */                        off += len;
        if (!noreply)                        /* try next packet remaining into buffer */
                schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET],                         continue;
                                c, TASK_FD(task), rpc, len);                }
 
                 noreply = RPC_CHK_NOREPLY(rpc);
 
                 /* check RPC packet session info */
                 if (rpc_chkPktSession(&rpc->call_session, &srv->srv_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, c, 
                                         (int) noreply, rpc, len);
                 }
 
                 /* send RPC reply */
                 if (!noreply)
                         schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                                         c, TASK_FD(task), rpc, len);
 
                 off += len;
         } while (rlen > 0);
 
 end:  end:
         if (buf)  
                 e_free(buf);  
         schedReadSelf(task);          schedReadSelf(task);
         return NULL;          return NULL;
 }  }
Line 583  rpc_freeBLOBCli(rpc_cli_t * __restrict c) Line 594  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(s) */        /* free buffer */
        ait_freeVars(&c->cli_buf);        AIT_FREE_VAL(&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 731  acceptBLOBClients(sched_task_t *task) Line 742  acceptBLOBClients(sched_task_t *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 = sizeof(sockaddr_t);
           int sock;
 #ifdef TCP_NOPUSH  #ifdef TCP_NOPUSH
         int n = 1;          int n = 1;
 #endif  #endif
Line 738  acceptBLOBClients(sched_task_t *task) Line 750  acceptBLOBClients(sched_task_t *task)
         /* check free slots for connect */          /* check free slots for connect */
         for (i = 0; i < array_Size(srv->srv_blob.clients) &&           for (i = 0; i < array_Size(srv->srv_blob.clients) && 
                         (c = array(srv->srv_blob.clients, i, rpc_cli_t*)); i++);                          (c = array(srv->srv_blob.clients, i, rpc_cli_t*)); i++);
        if (c)  /* no more free slots! */        if (c) {        /* no more free slots! */
                 EVERBOSE(1, "BLOB client quota exceeded! Connection will be shutdown!\n");
                 if ((sock = accept(TASK_FD(task), NULL, NULL)) != -1) {
                         shutdown(sock, SHUT_RDWR);
                         close(sock);
                 }
                 goto end;                  goto end;
           }
   
         c = e_malloc(sizeof(rpc_cli_t));          c = e_malloc(sizeof(rpc_cli_t));
         if (!c) {          if (!c) {
                 LOGERR;                  LOGERR;
Line 752  acceptBLOBClients(sched_task_t *task) Line 771  acceptBLOBClients(sched_task_t *task)
                 c->cli_parent = srv;                  c->cli_parent = srv;
         }          }
   
        /* init buffer(s) */        /* alloc empty buffer */
        c->cli_buf = ait_allocVars(1);        AIT_SET_BUFSIZ(&c->cli_buf, 0, srv->srv_netbuf);
        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_freeVars(&c->cli_buf);                AIT_FREE_VAL(&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 959  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 972  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_freeVars(&c->cli_buf);                        AIT_FREE_VAL(&c->cli_buf);
                 }                  }
                 array_Del(srv->srv_blob.clients, i, 42);                  array_Del(srv->srv_blob.clients, i, 42);
         }          }
Line 1165  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 1178  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_freeVars(&c->cli_buf);                        AIT_FREE_VAL(&c->cli_buf);
                 }                  }
                 array_Del(srv->srv_clients, i, 42);                  array_Del(srv->srv_clients, i, 42);
         }          }
Removed from v.1.17.4.5  
changed lines
  Added in v.1.21

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