[BACK]Return to cli.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / src

Diff for /libaitrpc/src/cli.c between versions 1.1.1.1 and 1.1.1.1.2.4

version 1.1.1.1, 2010/06/18 01:48:06 version 1.1.1.1.2.4, 2010/06/28 17:10:39
Line 10 Line 10
   
   
 /*  /*
    * rpc_cli_openBLOBClient() Connect to BLOB Server
    * @rpccli = RPC Client session
    * @Port = Port for bind server, if Port == 0 default port is selected
    * return: NULL == error or !=NULL connection to BLOB server established
    */
   rpc_cli_t *
   rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, u_short Port)
   {
           rpc_cli_t *cli = NULL;
           struct sockaddr_in sin;
           struct sockaddr_in6 sin6;
   
           if (!rpccli || (rpccli->cli_sa.sa_family != AF_INET && rpccli->cli_sa.sa_family != AF_INET6)) {
                   rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t connect to BLOB server ...\n");
                   return NULL;
           }
           if (!Port)
                   Port = RPC_DEFPORT + 1;
   
           cli = malloc(sizeof(rpc_cli_t));
           if (!cli) {
                   LOGERR;
                   return NULL;
           } else
                   memcpy(cli, rpccli, sizeof(rpc_cli_t));
   
           if (rpccli->cli_sa.sa_family == AF_INET) {
                   memcpy(&sin, &rpccli->cli_sa, sizeof sin);
                   sin.sin_port = htons(Port);
                   memcpy(&cli->cli_sa, &sin, sizeof(struct sockaddr));
           } else {
                   memcpy(&sin6, &rpccli->cli_sa, sizeof sin6);
                   sin6.sin6_port = htons(Port);
                   memcpy(&cli->cli_sa, &sin6, sizeof(struct sockaddr));
           }
   
           cli->cli_sock = socket(cli->cli_sa.sa_family, SOCK_STREAM, 0);
           if (cli->cli_sock == -1) {
                   LOGERR;
                   free(cli);
                   return NULL;
           }
           if (connect(cli->cli_sock, &cli->cli_sa, sizeof cli->cli_sa) == -1) {
                   LOGERR;
                   free(cli);
                   return NULL;
           }
   
           return cli;
   }
   
   /*
    * rpc_cli_closeBLOBClient() Close connection to BLOB server and free resources
    * @cli = BLOB Client session
    * return: none
    */
   void
   rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli)
   {
           if (!cli) {
                   rpc_SetErr(EINVAL, "Error:: Can`t close connection because parameter is null!\n");
                   return;
           }
   
           shutdown(cli->cli_sock, SHUT_RDWR);
           close(cli->cli_sock);
   
           free(cli);
           cli = NULL;
   }
   
   // --------------------------------------------------------------
   
   /*
  * rpc_cli_openClient() Connect to RPC Server   * rpc_cli_openClient() Connect to RPC Server
  * @ProgID = ProgramID for RPC session request   * @ProgID = ProgramID for RPC session request
  * @ProcID = ProcessID for RPC session request   * @ProcID = ProcessID for RPC session request
Line 144  rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, Line 218  rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
         int ret = 0, Limit = 0;          int ret = 0, Limit = 0;
         register int i;          register int i;
         rpc_val_t *v;          rpc_val_t *v;
        struct timeval tv = { DEF_CLI_TIMEOUT, 0 };        struct timeval tv = { DEF_RPC_TIMEOUT, 0 };
   
         FD_ZERO(&fds);          FD_ZERO(&fds);
         memset(buf, 0, BUFSIZ);          memset(buf, 0, BUFSIZ);
Line 192  rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, Line 266  rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
                                         data += in_vals[i].val_len;                                          data += in_vals[i].val_len;
                                         Limit += in_vals[i].val_len;                                          Limit += in_vals[i].val_len;
                                         break;                                          break;
                                 case array:  
                                         if (Limit + in_vals[i].val_len > BUFSIZ) {  
                                                 ret = -7;  
                                                 break;  
                                         }  
   
                                         memcpy(data, in_vals[i].val.array, in_vals[i].val_len);  
                                         v[i].val.array = (int8_t**) ((void*) data - (void*) v);  
                                         data += in_vals[i].val_len;  
                                         Limit += in_vals[i].val_len;  
                                         break;  
                                 default:                                  default:
                                         break;                                          break;
                         }                          }
Line 289  rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, Line 352  rpc_cli_execCall(rpc_cli_t *cli, const char *csModule,
                                         }                                          }
                                         data += (*out_vals)[i].val_len + 1;                                          data += (*out_vals)[i].val_len + 1;
                                         break;                                          break;
                                 case array:  
                                         (*out_vals)[i].val.array = malloc((*out_vals)[i].val_len);  
                                         if (!(*out_vals)[i].val.array) {  
                                                 rpc_SetErr(errno, "Error:: in prepare RPC reply ...\n");  
                                                 free(*out_vals);  
                                                 *out_vals = NULL;  
                                                 *out_argc = 0;  
                                                 return -1;  
                                         } else  
                                                 memcpy((*out_vals)[i].val.array, data, (*out_vals)[i].val_len);  
                                         data += (*out_vals)[i].val_len;  
                                         break;  
                                 default:                                  default:
                                         break;                                          break;
                         }                          }
         } else {          } else {
                *out_argc = 0;                if (out_argc)
                *out_vals = NULL;                        *out_argc = 0;
                 if (out_vals)
                         *out_vals = NULL;
         }          }
   
         return rrpc->ret_retcode;          return rrpc->ret_retcode;
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.1.2.4

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