[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.2.7 and 1.5.2.3

version 1.4.2.7, 2011/09/06 23:58:48 version 1.5.2.3, 2011/11/03 15:28:36
Line 47  SUCH DAMAGE. Line 47  SUCH DAMAGE.
   
   
 /*  /*
 * 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 
  * @call = RPC function call   * @call = RPC function call
 * @varnum = Number of variables, if ==0 free previous allocated variables * @varnum = Number of variables, if ==0 return already allocated variables number
  * return: -1 error, !=-1 return varnum value   * return: -1 error, !=-1 return varnum value
  */   */
inline intstatic inline int
 rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)  rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)
 {  {
         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;
         }          }
   
         if (varnum) {          if (varnum) {
                call->func_vars = io_arrayInit(varnum);                call->func_vars = io_allocVars(varnum);
                 if (!call->func_vars)                  if (!call->func_vars)
                         return -1;                          return -1;
   
                 /* 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 io_arraySize(call->func_vars);          return io_arraySize(call->func_vars);
 }  }
   
 /*  /*
  * rpc_srv_destroyVars() Destroy variables of array & array  
  * @call = RPC function call  
  * return: -1 error, !=-1 Returne remained variables  
  */  
 inline int  
 rpc_srv_destroyVars(rpc_func_t * __restrict call)  
 {  
         if (!call) {  
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete variables ...\n");  
                 return -1;  
         }  
   
         if (call->func_vars) {  
                 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
Line 265  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con Line 201  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
                 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;
         }          }
        rpc_srv_destroyVars(f);        io_freeVars(&f->func_vars);
         free(f);          free(f);
         pthread_mutex_unlock(&srv->srv_mtx);          pthread_mutex_unlock(&srv->srv_mtx);
   
Line 412  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin Line 348  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.2.7  
changed lines
  Added in v.1.5.2.3

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