[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.2 and 1.4.2.3

version 1.4.2.2, 2011/08/31 17:11:58 version 1.4.2.3, 2011/09/01 11:39:26
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 array_t *  
 rpc_srv_returnVars(rpc_func_t * __restrict call, int varnum)  
 {  
         array_t *v = NULL;  
   
         if (rpc_srv_allocVars(call, varnum) == -1)  
                 return NULL;  
         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 84  rpc_srv_allocVars(rpc_func_t * __restrict call, int va Line 64  rpc_srv_allocVars(rpc_func_t * __restrict call, int va
                 return -1;                  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*));  
         io_arrayFree(call->func_vars);  
         io_arrayDestroy(&call->func_vars);  
   
         if (varnum) {          if (varnum) {
                if (!(call->func_vars = io_arrayInit(varnum)))                call->func_vars = io_arrayInit(varnum);
                 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++) {                  for (i = 0; i < io_arraySize(call->func_vars); i++) {
                         v = malloc(sizeof(ait_val_t));                          v = malloc(sizeof(ait_val_t));
                         if (!v) {                          if (!v) {
                                 LOGERR;                                  LOGERR;
                                rpc_srv_freeVars(call);                                rpc_srv_destroyVars(call);
                                 return -1;                                  return -1;
                         } else {                          } else {
                                 memset(v, 0, sizeof(ait_val_t));                                  memset(v, 0, sizeof(ait_val_t));
                                 io_arraySet(call->func_vars, i, v);                                  io_arraySet(call->func_vars, i, v);
                         }                          }
                 }                  }
           }
   
                varnum = 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;
         }          }
   
        return varnum;        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_zeroVars() Clean values from variables of RPC call * rpc_srv_freeVals() Clean values from variables of array
  * @call = RPC function call   * @call = RPC function call
 * return: -1 error, !=-1 Returned number of cleaned RPC variables * return: -1 error, !=-1 Returned number of cleaned variables
  */   */
 inline int  inline int
rpc_srv_zeroVars(rpc_func_t * __restrict call)rpc_srv_freeVals(rpc_func_t * __restrict call)
 {  {
           register int i;
   
         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;
         }          }
   
        io_arrayFree(call->func_vars);        if (call->func_vars) {
        io_arrayZero(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);          return io_arraySize(call->func_vars);
 }  }
   
Line 167  rpc_srv_getVars(rpc_func_t * __restrict call, array_t  Line 169  rpc_srv_getVars(rpc_func_t * __restrict call, array_t 
   
         if (vars)          if (vars)
                 *vars = call->func_vars;                  *vars = call->func_vars;
        return (call->func_vars ? io_arraySize(call->func_vars) : 0);        return io_arraySize(call->func_vars);
 }  }
   
 // ---------------------------------------------------------  // ---------------------------------------------------------
Line 260  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con Line 262  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
         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;
   
                if (f->func_args && f->func_vars)                if (f->func_vars)
                        free(f->func_vars);                        rpc_srv_destroyVars(f);
                 free(f);                  free(f);
         } else {          } 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)                if (f->func_vars)
                        free(f->func_vars);                        rpc_srv_destroyVars(f);
                 free(f);                  free(f);
         }          }
         pthread_mutex_unlock(&srv->srv_mtx);          pthread_mutex_unlock(&srv->srv_mtx);
Removed from v.1.4.2.2  
changed lines
  Added in v.1.4.2.3

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