[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.14 and 1.17

version 1.14, 2013/03/07 23:10:50 version 1.17, 2013/07/16 13:04:20
Line 67  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = { Line 67  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = {
 };  };
   
   
inline voidvoid
 rpc_freeCli(rpc_cli_t * __restrict c)  rpc_freeCli(rpc_cli_t * __restrict c)
 {  {
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
Line 193  txPacket(sched_task_t *task) Line 193  txPacket(sched_task_t *task)
   
         rpc->call_len = htons(wlen);          rpc->call_len = htons(wlen);
   
   #if 0
         /* calculate CRC */          /* calculate CRC */
         rpc->call_crc ^= rpc->call_crc;          rpc->call_crc ^= rpc->call_crc;
         rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));          rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
   #endif
   
         /* send reply */          /* send reply */
         ret = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL);          ret = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL);
Line 269  rxPacket(sched_task_t *task) Line 271  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;
        u_short crc, off = TASK_DATLEN(task);        u_short off = TASK_DATLEN(task);
 #if 0
         u_short crc;
 #endif
         u_char *buf = AIT_GET_BUF(&c->cli_buf);          u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
   
Line 308  rxPacket(sched_task_t *task) Line 313  rxPacket(sched_task_t *task)
                         break;                          break;
                 }                  }
   
   #if 0
                 /* 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;
Line 318  rxPacket(sched_task_t *task) Line 324  rxPacket(sched_task_t *task)
                         /* try next packet remaining into buffer */                          /* try next packet remaining into buffer */
                         continue;                          continue;
                 }                  }
   #endif
   
                 noreply = RPC_CHK_NOREPLY(rpc);                  noreply = RPC_CHK_NOREPLY(rpc);
   
Line 522  end: Line 529  end:
   
 /* ------------------------------------------------------ */  /* ------------------------------------------------------ */
   
inline voidvoid
 rpc_freeBLOBCli(rpc_cli_t * __restrict c)  rpc_freeBLOBCli(rpc_cli_t * __restrict c)
 {  {
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
Line 556  txBLOB(sched_task_t *task) Line 563  txBLOB(sched_task_t *task)
 {  {
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
         u_char *buf = AIT_GET_BUF(&c->cli_buf);          u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf;  
         int wlen = sizeof(struct tagBLOBHdr);          int wlen = sizeof(struct tagBLOBHdr);
   
         /* calculate CRC */  
         blob->hdr_crc ^= blob->hdr_crc;  
         blob->hdr_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));  
   
         /* send reply */          /* send reply */
         wlen = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL);          wlen = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL);
         if (wlen == -1 || wlen != sizeof(struct tagBLOBHdr)) {          if (wlen == -1 || wlen != sizeof(struct tagBLOBHdr)) {
Line 581  rxBLOB(sched_task_t *task) Line 583  rxBLOB(sched_task_t *task)
         rpc_blob_t *b;          rpc_blob_t *b;
         struct tagBLOBHdr blob;          struct tagBLOBHdr blob;
         int rlen;          int rlen;
         u_short crc;  
   
         memset(&blob, 0, sizeof blob);          memset(&blob, 0, sizeof blob);
         rlen = recv(TASK_FD(task), &blob, sizeof blob, 0);          rlen = recv(TASK_FD(task), &blob, sizeof blob, 0);
Line 599  rxBLOB(sched_task_t *task) Line 600  rxBLOB(sched_task_t *task)
                 return NULL;                  return NULL;
         }          }
   
         /* check integrity of packet */  
         crc = ntohs(blob.hdr_crc);  
         blob.hdr_crc ^= blob.hdr_crc;  
         if (crc != crcFletcher16((u_short*) &blob, rlen / 2)) {  
                 rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");  
   
                 schedReadSelf(task);  
                 return NULL;  
         }  
   
         /* check RPC packet session info */          /* check RPC packet session info */
        if ((crc = rpc_chkPktSession(&blob.hdr_session, &s->srv_session))) {        if (rpc_chkPktSession(&blob.hdr_session, &s->srv_session)) {
                 rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");                  rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
                 blob.hdr_cmd = error;                  blob.hdr_cmd = error;
                 goto end;                  goto end;
Line 637  rxBLOB(sched_task_t *task) Line 628  rxBLOB(sched_task_t *task)
                         }                          }
                         break;                          break;
                 case set:                  case set:
                        if ((b = rpc_srv_registerBLOB(s, ntohl(blob.hdr_len)))) {                        if ((b = rpc_srv_registerBLOB(s, ntohl(blob.hdr_len), 
                                                         ntohl(blob.hdr_ret)))) {
                                 /* set new BLOB variable for reply :) */                                  /* set new BLOB variable for reply :) */
                                 blob.hdr_var = htonl(b->blob_var);                                  blob.hdr_var = htonl(b->blob_var);
   
Line 669  end: Line 661  end:
 }  }
   
 static void *  static void *
   flushBLOB(sched_task_t *task)
   {
           rpc_srv_t *srv = TASK_ARG(task);
           rpc_blob_t *b, *tmp;
   
           TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp) {
                   TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);
   
                   rpc_srv_blobFree(srv, b);
                   e_free(b);
           }
   
           schedSignalSelf(task);
           return NULL;
   }
   
   static void *
 acceptBLOBClients(sched_task_t *task)  acceptBLOBClients(sched_task_t *task)
 {  {
         rpc_srv_t *srv = TASK_ARG(task);          rpc_srv_t *srv = TASK_ARG(task);
Line 835  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 844  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * return: none   * return: none
  */   */
inline voidvoid
 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
 {  {
         if (!srv)          if (!srv)
                 return;                  return;
   
         srv->srv_blob.kill = 1;          srv->srv_blob.kill = 1;
   
           schedEnd(&srv->srv_blob.root);
 }  }
   
 /*  /*
Line 868  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 879  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
           schedSignal(srv->srv_blob.root, flushBLOB, srv, SIGFBLOB, NULL, 0);
         if (!schedRead(srv->srv_blob.root, acceptBLOBClients, srv,           if (!schedRead(srv->srv_blob.root, acceptBLOBClients, srv, 
                                 srv->srv_blob.server.cli_sock, NULL, 0)) {                                  srv->srv_blob.server.cli_sock, NULL, 0)) {
                 rpc_SetErr(sched_GetErrno(), "%s", sched_GetError());                  rpc_SetErr(sched_GetErrno(), "%s", sched_GetError());
Line 878  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 890  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
         /* main rpc loop */          /* main rpc loop */
         schedRun(srv->srv_blob.root, &srv->srv_blob.kill);          schedRun(srv->srv_blob.root, &srv->srv_blob.kill);
   
           /* detach blobs */
           TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp) {
                   TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);
   
                   rpc_srv_blobFree(srv, b);
                   e_free(b);
           }
   
         /* close all clients connections & server socket */          /* close all clients connections & server socket */
         for (i = 0; i < array_Size(srv->srv_blob.clients); i++) {          for (i = 0; i < array_Size(srv->srv_blob.clients); i++) {
                 c = array(srv->srv_blob.clients, i, rpc_cli_t*);                  c = array(srv->srv_blob.clients, i, rpc_cli_t*);
Line 894  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 914  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
   
         close(srv->srv_blob.server.cli_sock);          close(srv->srv_blob.server.cli_sock);
   
         /* detach blobs */  
         TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp) {  
                 TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);  
   
                 rpc_srv_blobFree(srv, b);  
                 e_free(b);  
         }  
   
         schedEnd(&srv->srv_blob.root);  
         AIT_FREE_VAL(&srv->srv_blob.dir);          AIT_FREE_VAL(&srv->srv_blob.dir);
         return 0;          return 0;
 }  }
Line 911  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 922  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
 /*  /*
  * rpc_srv_initServer() - Init & create RPC Server   * rpc_srv_initServer() - Init & create RPC Server
  *   *
 * @regProgID = ProgramID for authentication & recognition * @InstID = Instance for authentication & recognition
 * @regProcID = ProcessID for authentication & recognition 
  * @concurentClients = Concurent clients at same time to this server   * @concurentClients = Concurent clients at same time to this server
  * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)   * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
  * @csHost = Host name or address for bind server, if NULL any address   * @csHost = Host name or address for bind server, if NULL any address
Line 921  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 931  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
  * return: NULL == error or !=NULL bind and created RPC server instance   * return: NULL == error or !=NULL bind and created RPC server instance
  */   */
 rpc_srv_t *  rpc_srv_t *
rpc_srv_initServer(u_int regProgID, u_char regProcID, int concurentClients, rpc_srv_initServer(u_char InstID, int concurentClients, int netBuf, 
                int netBuf, const char *csHost, u_short Port, int proto)                const char *csHost, u_short Port, int proto)
 {  {
         int n = 1;          int n = 1;
         rpc_srv_t *srv = NULL;          rpc_srv_t *srv = NULL;
         sockaddr_t sa = E_SOCKADDR_INIT;          sockaddr_t sa = E_SOCKADDR_INIT;
   
        if (!concurentClients || !regProgID || (proto < 0 || proto > SOCK_DGRAM)) {        if (!concurentClients || (proto < 0 || proto > SOCK_DGRAM)) {
                 rpc_SetErr(EINVAL, "Invalid parameters can`t init RPC server");                  rpc_SetErr(EINVAL, "Invalid parameters can`t init RPC server");
                 return NULL;                  return NULL;
         }          }
Line 961  rpc_srv_initServer(u_int regProgID, u_char regProcID,  Line 971  rpc_srv_initServer(u_int regProgID, u_char regProcID, 
         srv->srv_proto = proto;          srv->srv_proto = proto;
         srv->srv_netbuf = netBuf;          srv->srv_netbuf = netBuf;
         srv->srv_session.sess_version = RPC_VERSION;          srv->srv_session.sess_version = RPC_VERSION;
        srv->srv_session.sess_program = regProgID;        srv->srv_session.sess_instance = InstID;
        srv->srv_session.sess_process = regProcID; 
   
         srv->srv_server.cli_parent = srv;          srv->srv_server.cli_parent = srv;
         memcpy(&srv->srv_server.cli_sa, &sa, sizeof srv->srv_server.cli_sa);          memcpy(&srv->srv_server.cli_sa, &sa, sizeof srv->srv_server.cli_sa);
Line 1040  err: /* error condition */ Line 1049  err: /* error condition */
  * @psrv = RPC Server instance   * @psrv = RPC Server instance
  * return: none   * return: none
  */   */
inline voidvoid
 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
 {  {
         if (!psrv || !*psrv)          if (!psrv || !*psrv)
                 return;                  return;
   
         /* if send kill to blob server */          /* if send kill to blob server */
        if (!(*psrv)->srv_blob.kill)        rpc_srv_endBLOBServer(*psrv);
                rpc_srv_endBLOBServer(*psrv); 
   
         (*psrv)->srv_kill = 1;          (*psrv)->srv_kill = 1;
         sleep(RPC_SCHED_POLLING);          sleep(RPC_SCHED_POLLING);
   
           schedEnd(&(*psrv)->srv_root);
   
         pthread_mutex_destroy(&(*psrv)->srv_funcs.mtx);          pthread_mutex_destroy(&(*psrv)->srv_funcs.mtx);
         e_free(*psrv);          e_free(*psrv);
         *psrv = NULL;          *psrv = NULL;
Line 1121  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 1131  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
         srv->srv_funcs.avlh_root = NULL;          srv->srv_funcs.avlh_root = NULL;
         RPC_FUNCS_UNLOCK(&srv->srv_funcs);          RPC_FUNCS_UNLOCK(&srv->srv_funcs);
   
         schedEnd(&srv->srv_root);  
         return 0;          return 0;
 }  }
   
Removed from v.1.14  
changed lines
  Added in v.1.17

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