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

Diff for /libaitrpc/src/blob.c between versions 1.5 and 1.7.2.4

version 1.5, 2012/03/15 01:55:33 version 1.7.2.4, 2012/05/16 13:17:51
Line 47  SUCH DAMAGE. Line 47  SUCH DAMAGE.
   
   
 /*  /*
 * rpc_srv_blobCreate() - Create map blob to memory region and return object * rpc_srv_blobCreate() - Create and map blob to memory region and return object
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @len = BLOB length object   * @len = BLOB length object
Line 61  rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len Line 61  rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len
         int f;          int f;
         u_int rnd;          u_int rnd;
   
 #ifdef HAVE_SRANDOMDEV  
         srandomdev();  
 #else  
         time_t tim;  
   
         srandom((time(&tim) ^ getpid()));  
 #endif  
 again:  again:
         rnd = random() % UINT_MAX;          rnd = random() % UINT_MAX;
   
Line 81  again: Line 74  again:
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
         }          }
        if (lseek(f, len - 1, SEEK_SET) == -1) {        if (ftruncate(f, len) == -1) {
                 LOGERR;                  LOGERR;
                 close(f);                  close(f);
                 unlink(szFName);                  unlink(szFName);
                 return NULL;                  return NULL;
        } else        }
                write(f, "", 1); 
   
         blob = malloc(sizeof(rpc_blob_t));          blob = malloc(sizeof(rpc_blob_t));
         if (!blob) {          if (!blob) {
Line 166  rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t Line 158  rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t
 inline void  inline void
 rpc_srv_blobUnmap(rpc_blob_t * __restrict blob)  rpc_srv_blobUnmap(rpc_blob_t * __restrict blob)
 {  {
        if (!blob || !blob->blob_data)        if (blob && blob->blob_data) {
                rpc_SetErr(EINVAL, "Invalid arguments"); 
        else { 
                 munmap(blob->blob_data, blob->blob_len);                  munmap(blob->blob_data, blob->blob_len);
                 blob->blob_data = NULL;                  blob->blob_data = NULL;
         }          }
Line 189  rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_ Line 179  rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_
         if (!blob) {          if (!blob) {
                 rpc_SetErr(EINVAL, "Invalid argument BLOB");                  rpc_SetErr(EINVAL, "Invalid argument BLOB");
                 return -1;                  return -1;
        }        } else
 
        if (blob->blob_data) 
                 rpc_srv_blobUnmap(blob);                  rpc_srv_blobUnmap(blob);
   
         memset(szFName, 0, sizeof szFName);          memset(szFName, 0, sizeof szFName);
Line 204  rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_ Line 192  rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_
         return 0;          return 0;
 }  }
   
// ------------------------------------------------------------/* ------------------------------------------------------------ */
   
 /*  /*
  * rpc_srv_sendBLOB() - Send mapped BLOB to client   * rpc_srv_sendBLOB() - Send mapped BLOB to client
Line 225  rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_ Line 213  rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_
         }          }
   
         for (ret = blob->blob_len, pos = blob->blob_data; ret > 0; ret -= len, pos += len) {          for (ret = blob->blob_len, pos = blob->blob_data; ret > 0; ret -= len, pos += len) {
                len = send(cli->cli_sock, pos, ret, 0);                len = send(cli->cli_sock, pos, ret, MSG_NOSIGNAL);
                 if (len == -1) {                  if (len == -1) {
                         LOGERR;                          LOGERR;
                         return -1;                          return -1;
Line 247  rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_ Line 235  rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_
 {  {
         int ret, len;          int ret, len;
         uint8_t *pos;          uint8_t *pos;
        fd_set fds;        struct pollfd pfd;
        struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; 
   
         if (!cli || !blob || !blob->blob_data) {          if (!cli || !blob || !blob->blob_data) {
                 rpc_SetErr(EINVAL, "Invalid arguments");                  rpc_SetErr(EINVAL, "Invalid arguments");
                 return -1;                  return -1;
        } else        }
                tv.tv_sec = ((rpc_sess_t*) cli->cli_parent)->sess_timeout; 
   
           pfd.fd = cli->cli_sock;
           pfd.events = POLLIN | POLLPRI;
         for (ret = blob->blob_len, pos = blob->blob_data; ret > 0; ret -= len, pos += len) {          for (ret = blob->blob_len, pos = blob->blob_data; ret > 0; ret -= len, pos += len) {
                FD_ZERO(&fds);                if ((len = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                FD_SET(cli->cli_sock, &fds);                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                len = select(cli->cli_sock + 1, &fds, NULL, NULL, &tv); 
                if (len < 1) { 
                         LOGERR;                          LOGERR;
                         return -1;                          return -1;
                 }                  }
Line 275  rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_ Line 261  rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_
         return ret;          return ret;
 }  }
   
// ------------------------------------------------------------/* ------------------------------------------------------------ */
   
 /*  /*
  * rpc_cli_sendBLOB() - Send BLOB to server   * rpc_cli_sendBLOB() - Send BLOB to server
Line 291  rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 277  rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t
         int ret, len;          int ret, len;
         uint8_t *pos;          uint8_t *pos;
         struct tagBLOBHdr hdr;          struct tagBLOBHdr hdr;
        fd_set fds;        struct pollfd pfd;
        struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; 
   
         if (!cli || !var || !data) {          if (!cli || !var || !data) {
                 rpc_SetErr(EINVAL, "Invalid arguments");                  rpc_SetErr(EINVAL, "Invalid arguments");
                 return -1;                  return -1;
        } else        }
                tv.tv_sec = ((rpc_sess_t*) cli->cli_parent)->sess_timeout; 
   
         rpc_addPktSession(&hdr.hdr_session, cli->cli_parent);          rpc_addPktSession(&hdr.hdr_session, cli->cli_parent);
         hdr.hdr_cmd = set;          hdr.hdr_cmd = set;
Line 307  rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 291  rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t
         hdr.hdr_len = htonl(AIT_LEN(var));          hdr.hdr_len = htonl(AIT_LEN(var));
         /* calculate CRC */          /* calculate CRC */
         hdr.hdr_crc ^= hdr.hdr_crc;          hdr.hdr_crc ^= hdr.hdr_crc;
        hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, io_align(sizeof hdr, 1) / 2));        hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, sizeof hdr / 2));
   
         /* send SET request */          /* send SET request */
         if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {          if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
Line 323  rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 307  rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t
                 }                  }
   
         /* wait for reply */          /* wait for reply */
        FD_ZERO(&fds);        pfd.fd = cli->cli_sock;
        FD_SET(cli->cli_sock, &fds);        pfd.events = POLLIN | POLLPRI;
        switch (select(cli->cli_sock + 1, &fds, NULL, NULL, &tv)) {        if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                case -1:                        pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                 if (ret)
                         LOGERR;                          LOGERR;
                        return 1;                else
                case 0:                        rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
                        rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not responde");                return -1;
                        return 1; 
         }          }
         if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {          if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
                 LOGERR;                  LOGERR;
Line 340  rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 324  rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t
         /* check CRC */          /* check CRC */
         ret = ntohs(hdr.hdr_crc);          ret = ntohs(hdr.hdr_crc);
         hdr.hdr_crc ^= hdr.hdr_crc;          hdr.hdr_crc ^= hdr.hdr_crc;
        if (ret != crcFletcher16((u_short*) &hdr, io_align(sizeof hdr, 1) / 2)) {        if (ret != crcFletcher16((u_short*) &hdr, sizeof hdr / 2)) {
                 rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");                  rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");
                 return 1;                  return 1;
         }          }
Line 370  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 354  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t
 {  {
         int ret, len;          int ret, len;
         uint8_t *pos;          uint8_t *pos;
        fd_set fds;        struct pollfd pfd;
        struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; 
         struct tagBLOBHdr hdr;          struct tagBLOBHdr hdr;
   
         if (!cli || !var || !data) {          if (!cli || !var || !data) {
                 rpc_SetErr(EINVAL, "Invalid arguments");                  rpc_SetErr(EINVAL, "Invalid arguments");
                 return -1;                  return -1;
        } else        }
                tv.tv_sec = ((rpc_sess_t*) cli->cli_parent)->sess_timeout; 
   
         *data = malloc(AIT_LEN(var));          *data = malloc(AIT_LEN(var));
         if (!*data) {          if (!*data) {
Line 394  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 376  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t
         hdr.hdr_len = 0;          hdr.hdr_len = 0;
         /* calculate CRC */          /* calculate CRC */
         hdr.hdr_crc ^= hdr.hdr_crc;          hdr.hdr_crc ^= hdr.hdr_crc;
        hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, io_align(sizeof hdr, 1) / 2));        hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, sizeof hdr / 2));
   
         /* send GET request */          /* send GET request */
         if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {          if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
Line 405  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 387  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t
         }          }
   
         /* receive BLOB from server */          /* receive BLOB from server */
           pfd.fd = cli->cli_sock;
           pfd.events = POLLIN | POLLPRI;
         for (ret = AIT_LEN(var), pos = *data; ret > 0; ret -= len, pos += len) {          for (ret = AIT_LEN(var), pos = *data; ret > 0; ret -= len, pos += len) {
                FD_ZERO(&fds);                if ((len = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                FD_SET(cli->cli_sock, &fds);                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                len = select(cli->cli_sock + 1, &fds, NULL, NULL, &tv); 
                if (len < 1) { 
                         LOGERR;                          LOGERR;
                         free(*data);                          free(*data);
                         *data = NULL;                          *data = NULL;
Line 425  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 407  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t
         }          }
   
         /* wait for reply */          /* wait for reply */
        FD_ZERO(&fds);        if ((len = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
        FD_SET(cli->cli_sock, &fds);                        pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
        switch (select(cli->cli_sock + 1, &fds, NULL, NULL, &tv)) {                if (len)
                case -1: 
                         LOGERR;                          LOGERR;
                        free(*data);                else
                        *data = NULL;                        rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
                        return 1;                free(*data);
                case 0:                *data = NULL;
                        rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not responde");                return 1;
                        free(*data); 
                        *data = NULL; 
                        return 1; 
         }          }
         if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {          if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
                 LOGERR;                  LOGERR;
Line 448  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t Line 426  rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t
         /* check CRC */          /* check CRC */
         ret = ntohs(hdr.hdr_crc);          ret = ntohs(hdr.hdr_crc);
         hdr.hdr_crc ^= hdr.hdr_crc;          hdr.hdr_crc ^= hdr.hdr_crc;
        if (ret != crcFletcher16((u_short*) &hdr, io_align(sizeof hdr, 1) / 2)) {        if (ret != crcFletcher16((u_short*) &hdr, sizeof hdr / 2)) {
                 rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");                  rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");
                 free(*data);                  free(*data);
                 *data = NULL;                  *data = NULL;
Line 477  int Line 455  int
 rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var)  rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var)
 {  {
         struct tagBLOBHdr hdr;          struct tagBLOBHdr hdr;
        fd_set fds;        struct pollfd pfd;
        struct timeval tv = { DEF_RPC_TIMEOUT, 0 }; 
         int ret;          int ret;
   
         if (!cli || !var) {          if (!cli || !var) {
                 rpc_SetErr(EINVAL, "Invalid arguments");                  rpc_SetErr(EINVAL, "Invalid arguments");
                 return -1;                  return -1;
        } else        }
                tv.tv_sec = ((rpc_sess_t*) cli->cli_parent)->sess_timeout; 
   
         rpc_addPktSession(&hdr.hdr_session, cli->cli_parent);          rpc_addPktSession(&hdr.hdr_session, cli->cli_parent);
         hdr.hdr_cmd = unset;          hdr.hdr_cmd = unset;
Line 494  rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t  Line 470  rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t 
         hdr.hdr_len = 0;          hdr.hdr_len = 0;
         /* calculate CRC */          /* calculate CRC */
         hdr.hdr_crc ^= hdr.hdr_crc;          hdr.hdr_crc ^= hdr.hdr_crc;
        hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, io_align(sizeof hdr, 1) / 2));        hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, sizeof hdr / 2));
   
         /* send UNSET request */          /* send UNSET request */
         if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {          if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
Line 503  rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t  Line 479  rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t 
         }          }
   
         /* wait for reply */          /* wait for reply */
        FD_ZERO(&fds);        pfd.fd = cli->cli_sock;
        FD_SET(cli->cli_sock, &fds);        pfd.events = POLLIN | POLLPRI;
        switch (select(cli->cli_sock + 1, &fds, NULL, NULL, &tv)) {        if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                case -1:                        pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                 if (ret)
                         LOGERR;                          LOGERR;
                        return 1;                else
                case 0:                        rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
                        rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not responde");                return 1;
                        return 1; 
         }          }
         if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {          if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
                 LOGERR;                  LOGERR;
Line 520  rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t  Line 496  rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t 
         /* check CRC */          /* check CRC */
         ret = ntohs(hdr.hdr_crc);          ret = ntohs(hdr.hdr_crc);
         hdr.hdr_crc ^= hdr.hdr_crc;          hdr.hdr_crc ^= hdr.hdr_crc;
        if (ret != crcFletcher16((u_short*) &hdr, io_align(sizeof hdr, 1) / 2)) {        if (ret != crcFletcher16((u_short*) &hdr, sizeof hdr / 2)) {
                 rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");                  rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");
                 return 1;                  return 1;
         }          }
Removed from v.1.5  
changed lines
  Added in v.1.7.2.4

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