[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.25 and 1.25.2.3

version 1.25, 2015/01/21 21:17:05 version 1.25.2.3, 2015/03/09 22:14:52
Line 58  static void *rxUDPPacket(sched_task_t *); Line 58  static void *rxUDPPacket(sched_task_t *);
 static void *txUDPPacket(sched_task_t *);  static void *txUDPPacket(sched_task_t *);
   
 /* SOCK_RAW */  /* SOCK_RAW */
   static void *rxRAWPacket(sched_task_t *);
   static void *txRAWPacket(sched_task_t *);
   
 /* SOCK_BPF */  /* SOCK_BPF */
 static void *rxBPFPacket(sched_task_t *);  static void *rxBPFPacket(sched_task_t *);
Line 71  static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4]  Line 73  static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4] 
         { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */          { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */
         { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */          { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */
         { rxUDPPacket, freeClient, rxUDPPacket, txUDPPacket },  /* SOCK_DGRAM */          { rxUDPPacket, freeClient, rxUDPPacket, txUDPPacket },  /* SOCK_DGRAM */
        { NULL, NULL, NULL, NULL },                             /* SOCK_RAW */        { rxRAWPacket, freeClient, rxRAWPacket, txRAWPacket },        /* SOCK_RAW */
         { rxBPFPacket, freeClient, rxBPFPacket, txBPFPacket },  /* SOCK_BPF */          { rxBPFPacket, freeClient, rxBPFPacket, txBPFPacket },  /* SOCK_BPF */
         { rxEXTPacket, freeClient, rxEXTPacket, txEXTPacket }   /* SOCK_EXT */          { rxEXTPacket, freeClient, rxEXTPacket, txEXTPacket }   /* SOCK_EXT */
 };  };
Line 658  end: Line 660  end:
   
   
 static void *  static void *
   txRAWPacket(sched_task_t *task)
   {
           rpc_cli_t *c = TASK_ARG(task);
           rpc_srv_t *s = c->cli_parent;
           rpc_func_t *f = NULL;
           u_char *buf = AIT_GET_BUF(&c->cli_buf);
           struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
           int ret, estlen, wlen = sizeof(struct tagRPCCall);
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
           struct pollfd pfd;
   
           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);
   
           if (rpc->call_argc) {
                   f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
                   if (!f) {
                           rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
                           rpc->call_argc ^= rpc->call_argc;
                           rpc->call_rep.ret = RPC_ERROR(-1);
                           rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                   } 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 = (u_char) array_Size(RPC_RETVARS(c));
                           /* Go Encapsulate variables */
                           ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
                                           RPC_RETVARS(c));
                           /* Free return values */
                           ait_freeVars(&c->cli_vars);
                           if (ret == -1) {
                                   rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
                                   rpc->call_argc ^= rpc->call_argc;
                                   rpc->call_rep.ret = RPC_ERROR(-1);
                                   rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                           } else
                                   wlen += ret;
                   }
           }
   
           rpc->call_len = htonl(wlen);
           rpc->call_io = RPC_ACK;
   
           /* calculate CRC */
           rpc->call_crc ^= rpc->call_crc;
           rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
   
           /* send reply */
           pfd.fd = TASK_FD(task);
           pfd.events = POLLOUT;
           for (; wlen > 0; wlen -= ret, buf += ret) {
                   if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                                   pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                           if (ret)
                                   LOGERR;
                           else
                                   rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond");
                           /* close connection */
                           schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                           TASK_ARG(task), 0, NULL, 0);
                           return NULL;
                   }
                   ret = sendto(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf), MSG_NOSIGNAL, 
                                   &c->cli_sa.sa, c->cli_sa.sa.sa_len);
                   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;
   }
   
   static void *
   rxRAWPacket(sched_task_t *task)
   {
           rpc_srv_t *srv = TASK_ARG(task);
           rpc_cli_t *c = NULL;
           int len, rlen, noreply, estlen;
           u_short crc;
           u_char *buf, b[sizeof(struct ip6_hdr) + sizeof(struct tagRPCCall)];
           struct tagRPCCall *rpc;
           sockaddr_t sa;
           socklen_t salen;
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
           struct pollfd pfd;
   
           /* receive connect packet */
           salen = sa.ss.ss_len = sizeof(sockaddr_t);
           rlen = recvfrom(TASK_FD(task), b, sizeof b, MSG_PEEK, &sa.sa, &salen);
           if (rlen < sizeof(struct ip) + sizeof(struct tagRPCCall)) {
                   rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
                   goto end;
           }
   
           c = _allocClient(srv, &sa);
           if (!c) {
                   EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");
                   usleep(2000);   /* blocked client delay */
                   goto end;
           } else {
                   estlen = sa.sa.sa_family == AF_INET ? 
                           sizeof(struct ip) : sizeof(struct ip6_hdr);
                   rpc = (struct tagRPCCall*) (b + estlen);
                   estlen += 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) + 
                           (sa.sa.sa_family == AF_INET ? 
                           sizeof(struct ip) : sizeof(struct ip6_hdr)));
                   buf = AIT_GET_BUF(&c->cli_buf);
                   len = estlen;
   
                   c->cli_sock = TASK_FD(task);
                   memcpy(&c->cli_sa, &sa, sizeof c->cli_sa);
   
                   /* 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);
           }
   
           /* get next part of packet */
           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! Client not respond");
                           schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                                           c, 0, NULL, 0);
                           goto end;
                   }
                   salen = sa.ss.ss_len = sizeof(sockaddr_t);
                   rlen = recvfrom(TASK_FD(task), buf, len, 0, &sa.sa, &salen);
                   if (rlen == -1) {
                           /* close connection */
                           schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                                           c, 0, NULL, 0);
                           goto end;
                   }
                   if (e_addrcmp(&c->cli_sa, &sa, 42))
                           rlen ^= rlen;   /* skip if arrive from different address */
           }
           len = estlen;
           len -= sa.sa.sa_family == AF_INET ? 
                   sizeof(struct ip) : sizeof(struct ip6_hdr);
   
           /* skip loop packet */
           if (rpc->call_io & RPC_ACK)
                   goto end;
   
           /* check integrity of packet */
           crc = ntohs(rpc->call_crc);
           rpc->call_crc ^= rpc->call_crc;
           if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
                   rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
                   /* close connection */
                   schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                                   c, 0, NULL, 0);
                   goto end;
           }
   
           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);
   end:
           schedReadSelf(task);
           return NULL;
   }
   
   
   static void *
 txBPFPacket(sched_task_t *task)  txBPFPacket(sched_task_t *task)
 {  {
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
Line 1465  rpc_srv_initServer(u_char InstID, int concurentClients Line 1667  rpc_srv_initServer(u_char InstID, int concurentClients
         }          }
   
         /* create server socket */          /* create server socket */
        srv->srv_server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, srv->srv_proto, 0);        srv->srv_server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, 
                         srv->srv_proto, srv->srv_proto == SOCK_RAW ? IPPROTO_ERPC : 0);
         if (srv->srv_server.cli_sock == -1) {          if (srv->srv_server.cli_sock == -1) {
                 LOGERR;                  LOGERR;
                 array_Destroy(&srv->srv_clients);                  array_Destroy(&srv->srv_clients);
Removed from v.1.25  
changed lines
  Added in v.1.25.2.3

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