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

version 1.18, 2013/08/22 15:31:09 version 1.21, 2013/11/14 21:44:14
Line 164  txPacket(sched_task_t *task) Line 164  txPacket(sched_task_t *task)
         u_char *buf = AIT_GET_BUF(&c->cli_buf);          u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
         int ret, estlen, wlen = sizeof(struct tagRPCCall);          int ret, estlen, wlen = sizeof(struct tagRPCCall);
           struct pollfd pfd;
   #ifdef TCP_SESSION_TIMEOUT
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
           schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
           schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                            TASK_ARG(task), ts, TASK_ARG(task), 0);
   #endif
   
         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 179  txPacket(sched_task_t *task) Line 187  txPacket(sched_task_t *task)
                         if (estlen > AIT_LEN(&c->cli_buf))                          if (estlen > AIT_LEN(&c->cli_buf))
                                 AIT_RE_BUF(&c->cli_buf, estlen);                                  AIT_RE_BUF(&c->cli_buf, estlen);
                         buf = AIT_GET_BUF(&c->cli_buf);                          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 */
Line 188  txPacket(sched_task_t *task) Line 197  txPacket(sched_task_t *task)
                         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 205  txPacket(sched_task_t *task) Line 215  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 252  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 282  rxPacket(sched_task_t *task) Line 311  rxPacket(sched_task_t *task)
 #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*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
           struct pollfd pfd;
   #ifdef TCP_SESSION_TIMEOUT
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
           schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
           schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                            TASK_ARG(task), ts, TASK_ARG(task), 0);
   #endif
   
         memset(buf, 0, sizeof(struct tagRPCCall));          memset(buf, 0, sizeof(struct tagRPCCall));
        rlen = recv(TASK_FD(task), rpc, sizeof(struct tagRPCCall), 0);        rlen = recv(TASK_FD(task), rpc, sizeof(struct tagRPCCall), MSG_PEEK);
         if (rlen < sizeof(struct tagRPCCall)) {          if (rlen < 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], 
Line 295  rxPacket(sched_task_t *task) Line 332  rxPacket(sched_task_t *task)
                 if (estlen > AIT_LEN(&c->cli_buf))                  if (estlen > AIT_LEN(&c->cli_buf))
                         AIT_RE_BUF(&c->cli_buf, estlen);                          AIT_RE_BUF(&c->cli_buf, estlen);
                 rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);                  rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
                buf = AIT_GET_BUF(&c->cli_buf) + sizeof(struct tagRPCCall);                buf = AIT_GET_BUF(&c->cli_buf);
                len = estlen - sizeof(struct tagRPCCall);                len = estlen;
         }          }
   
        if (len) {        /* get next part of packet */
                /* get next part of packet */        memset(buf, 0, len);
                memset(buf, 0, len);        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);                  rlen = recv(TASK_FD(task), buf, len, 0);
                 if (rlen == -1) {                  if (rlen == -1) {
                         /* close connection */                          /* close connection */
Line 351  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);
Line 366  acceptClients(sched_task_t *task) Line 425  acceptClients(sched_task_t *task)
         } 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 677  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 684  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;
Removed from v.1.18  
changed lines
  Added in v.1.21

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