[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.28.2.3 and 1.32

version 1.28.2.3, 2016/08/02 12:00:39 version 1.32, 2024/10/29 01:33:17
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 - 2016Copyright 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 87  rpc_freeCli(rpc_cli_t * __restrict c) Line 87  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 146  _allocClient(rpc_srv_t * __restrict srv, sockaddr_t *  Line 147  _allocClient(rpc_srv_t * __restrict srv, sockaddr_t * 
   
                 /* alloc empty buffer */                  /* alloc empty buffer */
                 AIT_SET_BUFSIZ(&c->cli_buf, 0, srv->srv_netbuf);                  AIT_SET_BUFSIZ(&c->cli_buf, 0, srv->srv_netbuf);
                   if (!AIT_GET_BUF(&c->cli_buf)) {
                           array_Del(srv->srv_clients, n, 0);
                           e_free(c);
                           c = NULL;
                   }
         }          }
   
         return c;          return c;
Line 291  execCall(sched_task_t *task) Line 297  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 307  rxPacket(sched_task_t *task) Line 313  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, noreply = 0, rlen = AIT_LEN(&c->cli_buf);        int len, noreply = 0, rlen;
 #if 0  #if 0
         u_short crc;          u_short crc;
 #endif  #endif
Line 323  rxPacket(sched_task_t *task) Line 329  rxPacket(sched_task_t *task)
   
         /* 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) {
                 /* 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);                  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 387  rxPacket(sched_task_t *task) Line 400  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 424  acceptClients(sched_task_t *task) Line 437  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 498  txUDPPacket(sched_task_t *task) Line 513  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, sizeof c->cli_sa.sa);                        &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 528  rxUDPPacket(sched_task_t *task) Line 543  rxUDPPacket(sched_task_t *task)
 #endif  #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 (!rpc || rlen < sizeof(struct tagRPCCall))
                 goto end;                  goto end;
         else          else
                 len = ntohl(rpc->call_len);                  len = ntohl(rpc->call_len);
Line 542  rxUDPPacket(sched_task_t *task) Line 557  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 551  rxUDPPacket(sched_task_t *task) Line 566  rxUDPPacket(sched_task_t *task)
   
         c = _allocClient(srv, &sa);          c = _allocClient(srv, &sa);
         if (!c) {          if (!c) {
                EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");                EVERBOSE(1, "RPC client quota exceeded!");
                 usleep(2000);   /* blocked client delay */                  usleep(2000);   /* blocked client delay */
                 goto end;                  goto end;
         } else {          } else {
Line 573  rxUDPPacket(sched_task_t *task) Line 588  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 640  txRAWPacket(sched_task_t *task) Line 655  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, sizeof c->cli_sa.sa);                        &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 672  rxRAWPacket(sched_task_t *task) Line 687  rxRAWPacket(sched_task_t *task)
         if (sa.sa.sa_family == AF_INET) {          if (sa.sa.sa_family == AF_INET) {
                 struct ip *h;                  struct ip *h;
                 h = (struct ip*) AIT_GET_BUF(&b);                  h = (struct ip*) AIT_GET_BUF(&b);
                if (rlen < ntohs(h->ip_len) || h->ip_p != IPPROTO_ERPC)                if (!h || rlen < ntohs(h->ip_len) || h->ip_p != IPPROTO_ERPC)
                         goto end;                          goto end;
                 else {                  else {
                         rlen -= sizeof(struct ip);                          rlen -= sizeof(struct ip);
                         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 (!h || 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 (!rpc || rlen < sizeof(struct tagRPCCall))
                 goto end;                  goto end;
         else          else
                 len = ntohl(rpc->call_len);                  len = ntohl(rpc->call_len);
Line 703  rxRAWPacket(sched_task_t *task) Line 721  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 734  rxRAWPacket(sched_task_t *task) Line 752  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 904  rxBPFPacket(sched_task_t *task) Line 922  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:
Line 985  rxEXTPacket(sched_task_t *task) Line 1003  rxEXTPacket(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, noreply = 0, rlen = AIT_LEN(&c->cli_buf);        int len, noreply = 0, rlen;
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
         sockaddr_t sa;          sockaddr_t sa;
Line 996  rxEXTPacket(sched_task_t *task) Line 1014  rxEXTPacket(sched_task_t *task)
         AIT_SET_BUF(&b, NULL, srv->srv_netbuf);          AIT_SET_BUF(&b, NULL, srv->srv_netbuf);
         rlen = read(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b));          rlen = read(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b));
         rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);          rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);
        if (rlen < sizeof(struct tagRPCCall))        if (!rpc || rlen < sizeof(struct tagRPCCall))
                 goto end;                  goto end;
         else          else
                 len = ntohl(rpc->call_len);                  len = ntohl(rpc->call_len);
Line 1034  rxEXTPacket(sched_task_t *task) Line 1052  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 1194  flushBLOB(sched_task_t *task) Line 1212  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 1203  flushBLOB(sched_task_t *task) Line 1221  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 1259  acceptBLOBClients(sched_task_t *task) Line 1279  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 1300  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 1321  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 = 
Line 1946  rpc_srv_initServerExt(u_char InstID, int netBuf, int f Line 1967  rpc_srv_initServerExt(u_char InstID, int netBuf, int f
         rpc_register_srvPing(srv);          rpc_register_srvPing(srv);
   
         return srv;          return srv;
   }
   
   /*
    * rpc_srv_Return() - Prepare IPC return answer to RPC client
    *
    * @c = RPC client 
    * return: number of arguments in response
    */
   int
   rpc_srv_Return(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(s->srv_root, cbProto[s->srv_proto][CB_TXPACKET], c, c->cli_sock, rpc, 0);
           } else
                   rpc->call_argc ^= rpc->call_argc;
   
           return rpc->call_argc;
 }  }
Removed from v.1.28.2.3  
changed lines
  Added in v.1.32

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