[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.9.2.20 and 1.9.2.24

version 1.9.2.20, 2012/05/17 11:01:30 version 1.9.2.24, 2012/05/17 15:18:48
Line 178  rxPacket(sched_task_t *task) Line 178  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;
         u_char *buf = AIT_GET_BUF(&c->cli_buf);  
         int len, rlen, noreply;          int len, rlen, noreply;
        u_short crc, off = 0;        u_short crc, off = TASK_DATLEN(task);
         u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
   
         memset(buf, 0, AIT_LEN(&c->cli_buf));          memset(buf, 0, AIT_LEN(&c->cli_buf));
        rlen = recv(TASK_FD(task), buf, AIT_LEN(&c->cli_buf), 0);        rlen = recv(TASK_FD(task), buf + off, AIT_LEN(&c->cli_buf) - off, 0);
         if (rlen < 1) {          if (rlen < 1) {
                 /* close connection */                  /* close connection */
                 schedEvent(TASK_ROOT(task), closeClient, c, 42, NULL, 0);                  schedEvent(TASK_ROOT(task), closeClient, c, 42, NULL, 0);
                 return NULL;                  return NULL;
           } else {
                   rlen += off;    /* add reminded bytes from previous rxPacket, if exists! */
                   off = 0;        /* process buffer from start offset == 0 */
         }          }
   
         do {          do {
Line 196  rxPacket(sched_task_t *task) Line 199  rxPacket(sched_task_t *task)
                 if (rlen < sizeof(struct tagRPCCall)) {                  if (rlen < sizeof(struct tagRPCCall)) {
                         rpc_SetErr(ERPCMISMATCH, "Short RPC packet");                          rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
   
                        schedReadSelf(task);                        /* reminder received previous bytes ;) */
                         schedRead(TASK_ROOT(task), TASK_FUNC(task), TASK_ARG(task), 
                                         TASK_FD(task), TASK_DATA(task), rlen);
                         return NULL;                          return NULL;
                 } else                  } else
                         rpc = (struct tagRPCCall*) (buf + off);                          rpc = (struct tagRPCCall*) (buf + off);
Line 204  rxPacket(sched_task_t *task) Line 209  rxPacket(sched_task_t *task)
                 len = ntohs(rpc->call_len);                  len = ntohs(rpc->call_len);
                 rlen -= len;                  rlen -= len;
   
                   /* check RPC packet lengths */
                   if (rlen < 0 || len < sizeof(struct tagRPCCall)) {
                           rpc_SetErr(ERPCMISMATCH, "Broken RPC packet length");
                           /* skip entire packet */
                           break;
                   }
   
                 /* 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*) (buf + off), len / 2)) {                if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
                         rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");                          rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
   
                         off += len;                          off += len;
                        if (rlen < 1)                        /* try next packet remaining into buffer */
                                break;                        continue;
                        else 
                                continue; 
                 }                  }
   
                 noreply = rpc->call_req.flags & RPC_NOREPLY;                  noreply = rpc->call_req.flags & RPC_NOREPLY;
Line 238  rxPacket(sched_task_t *task) Line 248  rxPacket(sched_task_t *task)
         } while (rlen > 0);          } while (rlen > 0);
   
         /* lets get next packet */          /* lets get next packet */
        schedReadSelf(task);        schedRead(TASK_ROOT(task), TASK_FUNC(task), TASK_ARG(task), TASK_FD(task), TASK_DATA(task), 0);
         return NULL;          return NULL;
 }  }
   
Line 336  rxBLOB(sched_task_t *task) Line 346  rxBLOB(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;
         rpc_blob_t *b;          rpc_blob_t *b;
        u_char *buf = AIT_GET_BUF(&c->cli_buf);        struct tagBLOBHdr blob;
        struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf; 
         int rlen;          int rlen;
         u_short crc;          u_short crc;
   
        memset(buf, 0, AIT_LEN(&c->cli_buf));        memset(&blob, 0, sizeof blob);
        rlen = recv(TASK_FD(task), buf, AIT_LEN(&c->cli_buf), 0);        rlen = recv(TASK_FD(task), &blob, sizeof blob, 0);
         if (rlen < 1) {          if (rlen < 1) {
                 /* close blob connection */                  /* close blob connection */
                 schedEvent(TASK_ROOT(task), closeBLOBClient, c, 42, NULL, 0);                  schedEvent(TASK_ROOT(task), closeBLOBClient, c, 42, NULL, 0);
Line 358  rxBLOB(sched_task_t *task) Line 367  rxBLOB(sched_task_t *task)
         }          }
   
         /* check integrity of packet */          /* check integrity of packet */
        crc = ntohs(blob->hdr_crc);        crc = ntohs(blob.hdr_crc);
        blob->hdr_crc ^= blob->hdr_crc;        blob.hdr_crc ^= blob.hdr_crc;
        if (crc != crcFletcher16((u_short*) buf, rlen / 2)) {        if (crc != crcFletcher16((u_short*) &blob, rlen / 2)) {
                 rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");                  rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");
   
                 schedReadSelf(task);                  schedReadSelf(task);
Line 368  rxBLOB(sched_task_t *task) Line 377  rxBLOB(sched_task_t *task)
         }          }
   
         /* check RPC packet session info */          /* check RPC packet session info */
        if ((crc = rpc_chkPktSession(&blob->hdr_session, &s->srv_session))) {        if ((crc = 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;
         }          }
   
         /* Go to proceed packet ... */          /* Go to proceed packet ... */
        switch (blob->hdr_cmd) {        switch (blob.hdr_cmd) {
                 case get:                  case get:
                        if (!(b = rpc_srv_getBLOB(s, ntohl(blob->hdr_var)))) {                        if (!(b = rpc_srv_getBLOB(s, ntohl(blob.hdr_var)))) {
                                rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob->hdr_var));                                rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob.hdr_var));
                                blob->hdr_cmd = no;                                blob.hdr_cmd = no;
                                blob->hdr_ret = RPC_ERROR(-1);                                blob.hdr_ret = RPC_ERROR(-1);
                                 break;                                  break;
                         } else                          } else
                                blob->hdr_len = htonl(b->blob_len);                                blob.hdr_len = htonl(b->blob_len);
   
                         if (rpc_srv_blobMap(s, b) != -1) {                          if (rpc_srv_blobMap(s, b) != -1) {
                                 /* deliver BLOB variable to client */                                  /* deliver BLOB variable to client */
                                blob->hdr_ret = htonl(rpc_srv_sendBLOB(c, b));                                blob.hdr_ret = htonl(rpc_srv_sendBLOB(c, b));
                                 rpc_srv_blobUnmap(b);                                  rpc_srv_blobUnmap(b);
                         } else {                          } else {
                                blob->hdr_cmd = error;                                blob.hdr_cmd = error;
                                blob->hdr_ret = RPC_ERROR(-1);                                blob.hdr_ret = RPC_ERROR(-1);
                         }                          }
                         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)))) {
                                 /* 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);
   
                                 /* receive BLOB from client */                                  /* receive BLOB from client */
                                blob->hdr_ret = htonl(rpc_srv_recvBLOB(c, b));                                blob.hdr_ret = htonl(rpc_srv_recvBLOB(c, b));
                                 rpc_srv_blobUnmap(b);                                  rpc_srv_blobUnmap(b);
                         } else {                          } else {
                                blob->hdr_cmd = error;                                blob.hdr_cmd = error;
                                blob->hdr_ret = RPC_ERROR(-1);                                blob.hdr_ret = RPC_ERROR(-1);
                         }                          }
                         break;                          break;
                 case unset:                  case unset:
                        if (rpc_srv_unregisterBLOB(s, blob->hdr_var) == -1) {                        if (rpc_srv_unregisterBLOB(s, blob.hdr_var) == -1) {
                                blob->hdr_cmd = error;                                blob.hdr_cmd = error;
                                blob->hdr_ret = RPC_ERROR(-1);                                blob.hdr_ret = RPC_ERROR(-1);
                         }                          }
                         break;                          break;
                 default:                  default:
                        rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob->hdr_cmd);                        rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob.hdr_cmd);
                        blob->hdr_cmd = error;                        blob.hdr_cmd = error;
                        blob->hdr_ret = RPC_ERROR(-1);                        blob.hdr_ret = RPC_ERROR(-1);
         }          }
   
 end:  end:
           memcpy(AIT_ADDR(&c->cli_buf), &blob, sizeof blob);
         schedWrite(TASK_ROOT(task), txBLOB, TASK_ARG(task), TASK_FD(task), NULL, 0);          schedWrite(TASK_ROOT(task), txBLOB, TASK_ARG(task), TASK_FD(task), NULL, 0);
         schedReadSelf(task);          schedReadSelf(task);
         return NULL;          return NULL;
Line 592  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 602  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
         if (!srv)          if (!srv)
                 return;                  return;
   
        pthread_cancel(srv->srv_blob.tid);        if (srv->srv_blob.tid) {
        pthread_join(srv->srv_blob.tid, NULL);                pthread_cancel(srv->srv_blob.tid);
                 pthread_join(srv->srv_blob.tid, NULL);
         }
   
         /* close all clients connections & server socket */          /* close all clients connections & server socket */
         for (i = 0; i < io_arraySize(srv->srv_blob.clients); i++) {          for (i = 0; i < io_arraySize(srv->srv_blob.clients); i++) {
Line 663  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 675  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
  * @regProgID = ProgramID for authentication & recognition   * @regProgID = ProgramID for authentication & recognition
  * @regProcID = ProcessID 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, 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
  * @Port = Port for bind server, if Port == 0 default port is selected   * @Port = Port for bind server, if Port == 0 default port is selected
  * return: NULL == error or !=NULL bind and created RPC server instance   * return: NULL == error or !=NULL bind and created RPC server instance
Line 684  rpc_srv_initServer(u_int regProgID, u_char regProcID,  Line 696  rpc_srv_initServer(u_int regProgID, u_char regProcID, 
                 return NULL;                  return NULL;
         if (!Port)          if (!Port)
                 Port = RPC_DEFPORT;                  Port = RPC_DEFPORT;
        if (!netBuf)        if (netBuf < RPC_MIN_BUFSIZ)
                 netBuf = BUFSIZ;                  netBuf = BUFSIZ;
         else          else
                 netBuf = io_align(netBuf, 1);   /* align netBuf length */                  netBuf = io_align(netBuf, 1);   /* align netBuf length */
Removed from v.1.9.2.20  
changed lines
  Added in v.1.9.2.24

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