[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.16 and 1.9.2.22

version 1.9.2.16, 2012/05/16 13:17:51 version 1.9.2.22, 2012/05/17 12:52:30
Line 52  closeClient(sched_task_t *task) Line 52  closeClient(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;
   
        schedCancelby(s->srv_root, taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);        schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);
   
         /* close client socket */          /* close client socket */
         if (TASK_VAL(task))          if (TASK_VAL(task))
Line 82  txPacket(sched_task_t *task) Line 82  txPacket(sched_task_t *task)
         if (rpc->call_argc) {          if (rpc->call_argc) {
                 f = rpc_srv_getCall(s, ntohs(rpc->call_tag));                  f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
                 if (!f) {                  if (!f) {
                           rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                         rpc->call_rep.ret = RPC_ERROR(-1);                          rpc->call_rep.ret = RPC_ERROR(-1);
                         rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                          rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
Line 177  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 195  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 203  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 237  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 293  closeBLOBClient(sched_task_t *task) Line 304  closeBLOBClient(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;
   
        schedCancelby(s->srv_blob.root, taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);        schedCancelby(TASK_ROOT(task), taskMAX, CRITERIA_ARG, TASK_ARG(task), NULL);
   
         /* close client socket */          /* close client socket */
         if (TASK_VAL(task))          if (TASK_VAL(task))
Line 591  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 602  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
         if (!srv)          if (!srv)
                 return;                  return;
   
           if (srv->srv_blob.tid) {
                   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++) {
                 c = io_array(srv->srv_blob.clients, i, rpc_cli_t*);                  c = io_array(srv->srv_blob.clients, i, rpc_cli_t*);
Line 598  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 614  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
                         shutdown(c->cli_sock, SHUT_RDWR);                          shutdown(c->cli_sock, SHUT_RDWR);
                         close(c->cli_sock);                          close(c->cli_sock);
   
                        io_arrayDel(srv->srv_blob.clients, i, 42);                        schedCancelby(srv->srv_blob.root, taskMAX, CRITERIA_ARG, c, NULL);
                         AIT_FREE_VAL(&c->cli_buf);
                 }                  }
                   io_arrayDel(srv->srv_blob.clients, i, 42);
         }          }
         io_arrayDestroy(&srv->srv_blob.clients);          io_arrayDestroy(&srv->srv_blob.clients);
   
Line 615  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 633  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
   
         schedEnd(&srv->srv_blob.root);          schedEnd(&srv->srv_blob.root);
         AIT_FREE_VAL(&srv->srv_blob.dir);          AIT_FREE_VAL(&srv->srv_blob.dir);
   
         srv->srv_blob.kill = 1;  
 }  }
   
 /*  /*
Line 647  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv) Line 663  rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
 #if 0  
                 for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++)  
                         if (!c->cli_sa.sa.sa_family)  
                                 break;  
                 if (i >= srv->srv_numcli) {  
 #ifdef HAVE_PTHREAD_YIELD  
                         pthread_yield();  
 #endif  
                         usleep(1000000);  
                         continue;  
                 }  
   
                 c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa.sa, &salen);  
                 if (c->cli_sock == -1) {  
                         LOGERR;  
                         continue;  
                 } else  
                         c->cli_parent = srv;  
         }  
 #endif  
   
         /* main rpc loop */          /* main rpc loop */
         schedRun(srv->srv_blob.root, &srv->srv_blob.kill);          schedRun(srv->srv_blob.root, &srv->srv_blob.kill);
         return 0;          return 0;
Line 777  rpc_srv_initServer(u_int regProgID, u_char regProcID,  Line 772  rpc_srv_initServer(u_int regProgID, u_char regProcID, 
                 goto err;                  goto err;
         }          }
   
           rpc_register_srvPing(srv);
   
         return srv;          return srv;
 err:    /* error condition */  err:    /* error condition */
         close(srv->srv_server.cli_sock);          close(srv->srv_server.cli_sock);
Line 812  rpc_srv_endServer(rpc_srv_t ** __restrict psrv) Line 809  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
                         shutdown(c->cli_sock, SHUT_RDWR);                          shutdown(c->cli_sock, SHUT_RDWR);
                         close(c->cli_sock);                          close(c->cli_sock);
   
                        io_arrayDel((*psrv)->srv_clients, i, 42);                        schedCancelby((*psrv)->srv_root, taskMAX, CRITERIA_ARG, c, NULL);
                         AIT_FREE_VAL(&c->cli_buf);
                 }                  }
                   io_arrayDel((*psrv)->srv_clients, i, 42);
         }          }
         io_arrayDestroy(&(*psrv)->srv_clients);          io_arrayDestroy(&(*psrv)->srv_clients);
   
Line 886  rpc_srv_execCall(rpc_func_t * __restrict call, struct  Line 885  rpc_srv_execCall(rpc_func_t * __restrict call, struct 
         }          }
   
         func = AIT_GET_LIKE(&call->func_name, rpc_callback_t);          func = AIT_GET_LIKE(&call->func_name, rpc_callback_t);
        return func(call, ntohs(rpc->call_argc), args);        return func(call, rpc, args);
 }  }
Removed from v.1.9.2.16  
changed lines
  Added in v.1.9.2.22

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