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

Diff for /libaitrpc/src/lists.c between versions 1.6.2.2 and 1.8.2.2

version 1.6.2.2, 2012/03/13 17:10:13 version 1.8.2.2, 2012/05/11 08:49:43
Line 90  rpc_srv_getVars(rpc_func_t * __restrict call, array_t  Line 90  rpc_srv_getVars(rpc_func_t * __restrict call, array_t 
         return io_arraySize(call->func_vars);          return io_arraySize(call->func_vars);
 }  }
   
static inline int/* --------------------------------------------------------- */
calcHashes(rpc_func_t * __restrict func, const char *csModule, const char *csFunc) 
{ 
        char *str = NULL; 
        int len = 0; 
   
         assert(func && csFunc);  
   
         /* set function name */  
         AIT_SET_STR(&func->func_name, csFunc);  
         len = strlen(csFunc) + 3;       /* extra 3 bytes, because add string "__" and 0 */  
         /* set module name if exists */  
         if (csModule) {  
                 AIT_SET_STR(&func->func_file, csModule);  
                 len += strlen(csModule);  
         }  
         /* align len to 2 */  
         len = (len + 1) & ~1;  
   
         /* prepare hash source string */  
         str = malloc(len);  
         if (!str) {  
                 LOGERR;  
                 return -1;  
         } else {  
                 memset(str, 0, len);  
                 if (csModule)  
                         strlcpy((char*) str, csModule, len);  
                 strlcat((char*) str, "__", len);  
                 strlcat((char*) str, csFunc, len);  
         }  
   
         func->func_tag = crcFletcher16((u_short*) str, len / 2);  
         func->func_hash = hash_fnv((char*) str, len);  
   
         free(str);  
         return len;  
 }  
   
 // ---------------------------------------------------------  
   
 /*  /*
  * rpc_srv_registerCall() - Register call to RPC server   * rpc_srv_registerCall() - Register call to RPC server
  *   *
Line 157  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const Line 118  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const
                 memset(func, 0, sizeof(rpc_func_t));                  memset(func, 0, sizeof(rpc_func_t));
   
         /* calculate hashes */          /* calculate hashes */
        if (calcHashes(func, csModule, csFunc) == -1) {        if (rpc_calcHashes(func, csModule, csFunc) == -1) {
                 AIT_FREE_VAL(&func->func_name);                  AIT_FREE_VAL(&func->func_name);
                 AIT_FREE_VAL(&func->func_file);                  AIT_FREE_VAL(&func->func_file);
                 free(func);                  free(func);
Line 175  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const Line 136  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const
         }          }
   
         /* add to list of functions */          /* add to list of functions */
         pthread_mutex_lock(&srv->srv_mtx);  
         func->func_next = srv->srv_funcs;          func->func_next = srv->srv_funcs;
         srv->srv_funcs = func;          srv->srv_funcs = func;
         pthread_mutex_unlock(&srv->srv_mtx);  
         return 0;          return 0;
 }  }
   
Line 202  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con Line 161  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
                 memset(&func, 0, sizeof func);                  memset(&func, 0, sizeof func);
   
         /* calculate hashes */          /* calculate hashes */
        if (calcHashes(&func, csModule, csFunc) == -1)        if (rpc_calcHashes(&func, csModule, csFunc) == -1)
                 return -1;                  return -1;
   
         f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);          f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);
         AIT_FREE_VAL(&func.func_name);          AIT_FREE_VAL(&func.func_name);
         AIT_FREE_VAL(&func.func_file);          AIT_FREE_VAL(&func.func_file);
        if (!f)                         /* not found element for unregister */        if (!f)                 /* not found element for unregister */
                 return 0;                  return 0;
   
         pthread_mutex_lock(&srv->srv_mtx);  
         /* remove from list of functions */          /* remove from list of functions */
         if (srv->srv_funcs == f)        /* if is 1st element */          if (srv->srv_funcs == f)        /* if is 1st element */
                 srv->srv_funcs = srv->srv_funcs->func_next;                  srv->srv_funcs = srv->srv_funcs->func_next;
Line 223  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con Line 181  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
         AIT_FREE_VAL(&f->func_name);          AIT_FREE_VAL(&f->func_name);
         AIT_FREE_VAL(&f->func_file);          AIT_FREE_VAL(&f->func_file);
         free(f);          free(f);
         pthread_mutex_unlock(&srv->srv_mtx);  
   
         return 1;          return 1;
 }  }
Line 273  rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char Line 230  rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char
                 memset(&func, 0, sizeof(rpc_func_t));                  memset(&func, 0, sizeof(rpc_func_t));
   
         /* calculate hashes */          /* calculate hashes */
        if (calcHashes(&func, csModule, csFunc) == -1)        if (rpc_calcHashes(&func, csModule, csFunc) == -1)
                 return NULL;                  return NULL;
   
         f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);          f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);
Line 329  rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_ Line 286  rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_
   
         blob = rpc_srv_blobCreate(srv, len);          blob = rpc_srv_blobCreate(srv, len);
         if (blob) {          if (blob) {
                 pthread_mutex_lock(&srv->srv_blob.mtx);  
                 blob->blob_next = srv->srv_blob.blobs;                  blob->blob_next = srv->srv_blob.blobs;
                 srv->srv_blob.blobs = blob;                  srv->srv_blob.blobs = blob;
                 pthread_mutex_unlock(&srv->srv_blob.mtx);  
         }          }
   
         return blob;          return blob;
Line 362  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin Line 317  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin
         if (b->blob_data)          if (b->blob_data)
                 rpc_srv_blobUnmap(b);                  rpc_srv_blobUnmap(b);
   
         pthread_mutex_lock(&srv->srv_blob.mtx);  
         if (srv->srv_blob.blobs == b) { /* if is 1st element */          if (srv->srv_blob.blobs == b) { /* if is 1st element */
                 srv->srv_blob.blobs = srv->srv_blob.blobs->blob_next;                  srv->srv_blob.blobs = srv->srv_blob.blobs->blob_next;
         } else {          } else {
                 for (curr = srv->srv_blob.blobs; curr->blob_next != b; curr = curr->blob_next);                  for (curr = srv->srv_blob.blobs; curr->blob_next != b; curr = curr->blob_next);
                 curr->blob_next = curr->blob_next->blob_next;                  curr->blob_next = curr->blob_next->blob_next;
         }          }
         pthread_mutex_unlock(&srv->srv_blob.mtx);  
         rpc_srv_blobFree(srv, b);          rpc_srv_blobFree(srv, b);
         free(b);          free(b);
   
         return 1;          return 1;
 }  }
   
   /*
    * rpc_calcHashes() - Calculate hashes for RPC call
    *
    * @func = function
    * @csModule = Module name, if NULL self binary
    * @csFunc = Function name
    * return: -1 error or 0 ok
    */
   int
   rpc_calcHashes(rpc_func_t * __restrict func, const char *csModule, const char *csFunc)
   {
           char *str = NULL;
           int len = 0;
   
           assert(func && csFunc);
   
           /* set function name */
           AIT_SET_STR(&func->func_name, csFunc);
           len = strlen(csFunc) + 3;       /* extra 3 bytes, because add string "__" and 0 */
           /* set module name if exists */
           if (csModule) {
                   AIT_SET_STR(&func->func_file, csModule);
                   len += strlen(csModule);
           }
           /* align len to 2 */
           len = io_align(len, 1);
   
           /* prepare hash source string */
           str = malloc(len);
           if (!str) {
                   LOGERR;
                   return -1;
           } else {
                   memset(str, 0, len);
                   if (csModule)
                           strlcpy((char*) str, csModule, len);
                   strlcat((char*) str, "__", len);
                   strlcat((char*) str, csFunc, len);
           }
   
           func->func_tag = crcFletcher16((u_short*) str, len / 2);
           func->func_hash = hash_fnv((char*) str, len);
   
           free(str);
           return len;
   }
   
Removed from v.1.6.2.2  
changed lines
  Added in v.1.8.2.2

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