[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.4 and 1.5

version 1.4, 2011/08/29 22:37:06 version 1.5, 2011/09/07 07:24:21
Line 47  SUCH DAMAGE. Line 47  SUCH DAMAGE.
   
   
 /*  /*
  * rpc_srv_returnVars() Init return variables for RPC call and zeroed values  
                                         (for safe handling return values, use this!)  
  * @call = RPC function call  
  * @varnum = Number of return variables  
  * return: NULL error, !=NULL array with return values for RPC call with varnum items  
  */  
 inline rpc_val_t *  
 rpc_srv_returnVars(rpc_func_t * __restrict call, int varnum)  
 {  
         rpc_val_t *v = NULL;  
   
         if (rpc_srv_allocVars(call, varnum) == -1)  
                 return NULL;  
         else  
                 rpc_srv_zeroVars(call);  
         if (rpc_srv_getVars(call, &v) == -1)  
                 return NULL;  
   
         return v;  
 }  
   
 /*  
  * rpc_srv_allocVars() Allocate array for call variables,    * rpc_srv_allocVars() Allocate array for call variables, 
                                 if already allocated memory for RPC call reallocate used space                                  if already allocated memory for RPC call reallocate used space
  * @call = RPC function call   * @call = RPC function call
Line 78  rpc_srv_returnVars(rpc_func_t * __restrict call, int v Line 56  rpc_srv_returnVars(rpc_func_t * __restrict call, int v
 inline int  inline int
 rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)  rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)
 {  {
        void *ptr;        register int i;
         ait_val_t *v;
   
         if (!call || varnum < 0) {          if (!call || varnum < 0) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t allocate variables for RPC call...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t allocate variables for RPC call...\n");
                 return -1;                  return -1;
        } else        }
                call->func_args = varnum; 
   
        if (!varnum) {        if (varnum) {
                if (call->func_vars) {                call->func_vars = io_arrayInit(varnum);
                        free(call->func_vars);                if (!call->func_vars)
                        call->func_vars = NULL; 
                } 
        } else { 
                ptr = realloc(call->func_vars, varnum * sizeof(rpc_val_t)); 
                if (!ptr) { 
                        LOGERR; 
                        call->func_args = 0; 
                         return -1;                          return -1;
                } else
                        call->func_vars = ptr;                /* allocate ait_val_t elements & add to array */
                 for (i = 0; i < io_arraySize(call->func_vars); i++) {
                         v = malloc(sizeof(ait_val_t));
                         if (!v) {
                                 LOGERR;
                                 rpc_srv_destroyVars(call);
                                 return -1;
                         } else {
                                 memset(v, 0, sizeof(ait_val_t));
                                 io_arraySet(call->func_vars, i, v);
                         }
                 }
         }          }
   
        return varnum;        return io_arraySize(call->func_vars);
 }  }
   
 /*  /*
 * rpc_srv_zeroVars() Clean values from variables of RPC call * rpc_srv_destroyVars() Destroy variables of array & array
  * @call = RPC function call   * @call = RPC function call
 * return: -1 error, !=-1 Returned number of cleaned RPC variables * return: -1 error, !=-1 Returne remained variables
  */   */
 inline int  inline int
rpc_srv_zeroVars(rpc_func_t * __restrict call)rpc_srv_destroyVars(rpc_func_t * __restrict call)
 {  {
         if (!call) {          if (!call) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete variables ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete variables ...\n");
                 return -1;                  return -1;
         }          }
   
        memset(call->func_vars, 0, call->func_args * sizeof(rpc_val_t));        if (call->func_vars) {
        return call->func_args;                rpc_srv_freeVals(call);
 
                 io_arrayFree(call->func_vars);
                 io_arrayDestroy(&call->func_vars);
         }
 
         return io_arraySize(call->func_vars);
 }  }
   
 /*  /*
    * rpc_srv_freeVals() Clean values from variables of array
    * @call = RPC function call
    * return: -1 error, !=-1 Returned number of cleaned variables
    */
   inline int
   rpc_srv_freeVals(rpc_func_t * __restrict call)
   {
           register int i;
   
           if (!call) {
                   rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete variables ...\n");
                   return -1;
           }
   
           if (call->func_vars) {
                   for (i = 0; i < io_arraySize(call->func_vars); i++)
                           if (io_arrayGet(call->func_vars, i))
                                   AIT_FREE_VAL(io_array(call->func_vars, i, ait_val_t*));
           }
   
           return io_arraySize(call->func_vars);
   }
   
   /*
  * rpc_srv_copyVars() Copy variables for RPC call to new variable array   * rpc_srv_copyVars() Copy variables for RPC call to new variable array
  * @call = RPC function call   * @call = RPC function call
  * @newvars = New allocated variables array, must be free after use   * @newvars = New allocated variables array, must be free after use
  * return: -1 error, !=-1 Returned number of copied RPC variables   * return: -1 error, !=-1 Returned number of copied RPC variables
  */   */
 inline int  inline int
rpc_srv_copyVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvars)rpc_srv_copyVars(rpc_func_t * __restrict call, array_t ** __restrict newvars)
 {  {
         if (!call || !newvars) {          if (!call || !newvars) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t copy variables to new array\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t copy variables to new array\n");
                 return -1;                  return -1;
         }          }
   
        *newvars = calloc(call->func_args, sizeof(rpc_val_t));        if (io_arrayCopy(newvars, call->func_vars) == -1)
        if (!*newvars) { 
                LOGERR; 
                 return -1;                  return -1;
         } else  
                 memcpy(*newvars, call->func_vars, call->func_args * sizeof(rpc_val_t));  
   
        return call->func_args;        return io_arraySize(*newvars);
 }  }
   
 /*  /*
Line 152  rpc_srv_copyVars(rpc_func_t * __restrict call, rpc_val Line 160  rpc_srv_copyVars(rpc_func_t * __restrict call, rpc_val
  * return: -1 error, !=-1 Number of returned variables   * return: -1 error, !=-1 Number of returned variables
  */   */
 inline int  inline int
rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict vars)rpc_srv_getVars(rpc_func_t * __restrict call, array_t ** __restrict vars)
 {  {
         if (!call) {          if (!call) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get variables ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get variables ...\n");
Line 161  rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_ Line 169  rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_
   
         if (vars)          if (vars)
                 *vars = call->func_vars;                  *vars = call->func_vars;
        return call->func_args;        return io_arraySize(call->func_vars);
 }  }
   
 // ---------------------------------------------------------  // ---------------------------------------------------------
Line 175  rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_ Line 183  rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_
  * return: -1 error or 0 register ok   * return: -1 error or 0 register ok
  */   */
 int  int
rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, u_char args)rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, u_short args)
 {  {
         rpc_func_t *func;          rpc_func_t *func;
         u_char str[MAXPATHLEN + UCHAR_MAX + 1];          u_char str[MAXPATHLEN + UCHAR_MAX + 1];
Line 246  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con Line 254  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
         func.func_tag = crcFletcher16((u_short*) str, sizeof str / 2);          func.func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
         func.func_hash = hash_fnv((char*) str, sizeof str);          func.func_hash = hash_fnv((char*) str, sizeof str);
   
           pthread_mutex_lock(&srv->srv_mtx);
         f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);          f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);
         if (!f)                         /* not found element for unregister */          if (!f)                         /* not found element for unregister */
                 return 0;                  return 0;
   
        pthread_mutex_lock(&srv->srv_mtx);        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;
        else {
                if (f->func_args && f->func_vars) 
                        free(f->func_vars); 
                free(f); 
        } else { 
                 for (curr = srv->srv_funcs; curr->func_next != f; curr = curr->func_next);                  for (curr = srv->srv_funcs; curr->func_next != f; curr = curr->func_next);
                 curr->func_next = curr->func_next->func_next;                  curr->func_next = curr->func_next->func_next;
   
                 if (f->func_args && f->func_vars)  
                         free(f->func_vars);  
                 free(f);  
         }          }
           rpc_srv_destroyVars(f);
           free(f);
         pthread_mutex_unlock(&srv->srv_mtx);          pthread_mutex_unlock(&srv->srv_mtx);
   
         return 1;          return 1;
Line 345  rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t v Line 347  rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t v
                 return NULL;                  return NULL;
         }          }
   
         pthread_mutex_lock(&srv->srv_blob.mtx);  
         for (b = srv->srv_blob.blobs; b; b = b->blob_next) {          for (b = srv->srv_blob.blobs; b; b = b->blob_next) {
                 if (b->blob_var == var)                  if (b->blob_var == var)
                         break;                          break;
         }          }
         pthread_mutex_unlock(&srv->srv_blob.mtx);  
   
         return b;          return b;
 }  }
Line 401  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin Line 401  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin
         b = rpc_srv_getBLOB(srv, var);          b = rpc_srv_getBLOB(srv, var);
         if (!b)                         /* not found element for unregister */          if (!b)                         /* not found element for unregister */
                 return 0;                  return 0;
           /* if BLOB is unmapped force to unmap object */
           if (b->blob_data)
                   rpc_srv_blobUnmap(b);
   
         pthread_mutex_lock(&srv->srv_blob.mtx);          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 */
Line 409  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin Line 412  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin
                 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);
         pthread_mutex_unlock(&srv->srv_blob.mtx);  
   
         return 1;          return 1;
 }  }
Removed from v.1.4  
changed lines
  Added in v.1.5

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