[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.2.1 and 1.26.2.3

version 1.25.2.1, 2015/01/28 00:06:22 version 1.26.2.3, 2015/06/24 22:44:24
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 };
   
           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 */
           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;
           u_short crc;
           struct tagRPCCall *rpc;
           sockaddr_t sa;
           socklen_t salen;
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
           ait_val_t b = AIT_VAL_INIT;
   
           /* receive connect packet */
           AIT_SET_BUF(&b, NULL, srv->srv_netbuf);
           salen = sa.ss.ss_len = sizeof(sockaddr_t);
           rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen);
           if (sa.sa.sa_family == AF_INET) {
                   struct ip *h;
                   h = (struct ip*) AIT_GET_BUF(&b);
                   if (rlen < ntohs(h->ip_len) || h->ip_p != IPPROTO_ERPC)
                           goto end;
                   else {
                           rlen -= sizeof(struct ip);
                           rpc = (struct tagRPCCall*) 
                                   (AIT_GET_BUF(&b) + sizeof(struct ip));
                   }
           } else {
                   struct ip6_hdr *h;
                   h = (struct ip6_hdr*) AIT_GET_BUF(&b);
                   if (rlen < (ntohs(h->ip6_plen) + sizeof(struct ip6_hdr)) || 
                                   h->ip6_nxt != IPPROTO_ERPC)
                           goto end;
                   else {
                           rlen -= sizeof(struct ip6_hdr);
                           rpc = (struct tagRPCCall*) 
                                   (AIT_GET_BUF(&b) + sizeof(struct ip6_hdr));
                   }
           }
           if (rlen < sizeof(struct tagRPCCall)) {
                   rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
                   goto end;
           }
   
           /* skip loop packet */
           if (rpc->call_io & RPC_ACK)
                   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 {
                   len = ntohl(rpc->call_len);
                   if (len > AIT_LEN(&c->cli_buf))
                           AIT_RE_BUF(&c->cli_buf, len);
                   memcpy(AIT_GET_BUF(&c->cli_buf), rpc, len);
                   rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
   
                   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);
           }
   
           /* 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:
           AIT_FREE_VAL(&b);
           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 781  rxBPFPacket(sched_task_t *task) Line 954  rxBPFPacket(sched_task_t *task)
                 len = ntohl(rpc->call_len);                  len = ntohl(rpc->call_len);
                 if (len > AIT_LEN(&c->cli_buf))                  if (len > AIT_LEN(&c->cli_buf))
                         AIT_RE_BUF(&c->cli_buf, len);                          AIT_RE_BUF(&c->cli_buf, len);
                memcpy(AIT_GET_BUF(&c->cli_buf), rpc, AIT_LEN(&c->cli_buf));                memcpy(AIT_GET_BUF(&c->cli_buf), rpc, len);
                 rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);                  rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
   
                 c->cli_sock = TASK_FD(task);                  c->cli_sock = TASK_FD(task);
Line 1406  rpc_srv_initServer(u_char InstID, int concurentClients Line 1579  rpc_srv_initServer(u_char InstID, int concurentClients
                 rpc_SetErr(EINVAL, "Invalid parameters can`t init RPC server");                  rpc_SetErr(EINVAL, "Invalid parameters can`t init RPC server");
                 return NULL;                  return NULL;
         }          }
           if (!Port && proto < SOCK_RAW)
                   Port = RPC_DEFPORT;
         if (!e_gethostbyname(csHost, Port, &sa))          if (!e_gethostbyname(csHost, Port, &sa))
                 return NULL;                  return NULL;
         if (!Port)  
                 Port = RPC_DEFPORT;  
         if (!proto)          if (!proto)
                 proto = SOCK_STREAM;                  proto = SOCK_STREAM;
         if (netBuf < RPC_MIN_BUFSIZ)          if (netBuf < RPC_MIN_BUFSIZ)
Removed from v.1.25.2.1  
changed lines
  Added in v.1.26.2.3

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