[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.3 and 1.3.2.1

version 1.3, 2011/08/18 15:08:03 version 1.3.2.1, 2011/08/19 08:24:13
Line 47  SUCH DAMAGE. Line 47  SUCH DAMAGE.
   
   
 /*  /*
 * rpc_srv_retValsCall() Declare return variables for RPC call and zeroed values * rpc_srv_returnVars() Init return variables for RPC call and zeroed values
                                         (for safe handling return values, use this!)                                          (for safe handling return values, use this!)
  * @call = RPC function call   * @call = RPC function call
 * @return_vals = Number of return variables * @varnum = Number of return variables
 * return: NULL error, !=NULL array with return values for RPC call with return_vals items * return: NULL error, !=NULL array with return values for RPC call with varnum items
  */   */
 inline rpc_val_t *  inline rpc_val_t *
rpc_srv_retValsCall(rpc_func_t * __restrict call, int return_vals)rpc_srv_returnVars(rpc_func_t * __restrict call, int varnum)
 {  {
         rpc_val_t *v = NULL;          rpc_val_t *v = NULL;
   
        if (rpc_srv_declValsCall(call, return_vals) == -1)        if (rpc_srv_allocVars(call, varnum) == -1)
                 return NULL;                  return NULL;
         else          else
                rpc_srv_zeroValsCall(call);                rpc_srv_zeroVars(call);
        if (rpc_srv_getValsCall(call, &v) == -1)        if (rpc_srv_getVars(call, &v) == -1)
                 return NULL;                  return NULL;
   
         return v;          return v;
 }  }
   
 /*  /*
 * rpc_srv_freeValsCall() Free return variables for RPC call * 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
 * return: none * @varnum = Number of variables, if ==0 free previous allocated variables
  * return: -1 error, !=-1 return varnum value
  */   */
 inline void  
 rpc_srv_freeValsCall(rpc_func_t * __restrict call)  
 {  
         rpc_srv_declValsCall(call, 0);  
 }  
   
 /*  
  * rpc_srv_declValsCall() Declare return variables for RPC call,   
                                 if already allocated memory for RPC call return values   
                                 function reallocate used space with return_vals count elements  
  * @call = RPC function call  
  * @return_vals = Number of return variables  
  * return: -1 error, !=-1 ok  
  */  
 inline int  inline int
rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals)rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)
 {  {
         void *ptr;          void *ptr;
   
        if (!call || return_vals < 0) {        if (!call || varnum < 0) {
                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t declare return variables for RPC call...\n");                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t allocate variables for RPC call...\n");
                 return -1;                  return -1;
         } else          } else
                call->func_args = return_vals;                call->func_args = varnum;
   
        if (!return_vals) {        if (!varnum) {
                if (call->func_vals) {                if (call->func_vars) {
                        free(call->func_vals);                        free(call->func_vars);
                        call->func_vals = NULL;                        call->func_vars = NULL;
                 }                  }
         } else {          } else {
                ptr = realloc(call->func_vals, return_vals * sizeof(rpc_val_t));                ptr = realloc(call->func_vars, varnum * sizeof(rpc_val_t));
                 if (!ptr) {                  if (!ptr) {
                         LOGERR;                          LOGERR;
                         call->func_args = 0;                          call->func_args = 0;
                         return -1;                          return -1;
                 } else                  } else
                        call->func_vals = ptr;                        call->func_vars = ptr;
         }          }
   
        return return_vals;        return varnum;
 }  }
   
 /*  /*
 * rpc_srv_zeroValsCall() Clean values from return variables of RPC call * rpc_srv_zeroVars() Clean values from variables of RPC call
  * @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 RPC variables
  */   */
 inline int  inline int
rpc_srv_zeroValsCall(rpc_func_t * __restrict call)rpc_srv_zeroVars(rpc_func_t * __restrict call)
 {  {
         if (!call) {          if (!call) {
                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete return variables ...\n");                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete variables ...\n");
                 return -1;                  return -1;
         }          }
   
        memset(call->func_vals, 0, call->func_args * sizeof(rpc_val_t));        memset(call->func_vars, 0, call->func_args * sizeof(rpc_val_t));
         return call->func_args;          return call->func_args;
 }  }
   
 /*  /*
 * rpc_srv_copyValsCall() Copy return variables for RPC call to new variable * rpc_srv_copyVars() Copy variables for RPC call to new variable array
  * @call = RPC function call   * @call = RPC function call
 * @newvals = 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_copyValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvals)rpc_srv_copyVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvars)
 {  {
        if (!call || !newvals) {        if (!call || !newvars) {
                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t copy return variables to new array\n");                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t copy variables to new array\n");
                 return -1;                  return -1;
         }          }
   
        *newvals = calloc(call->func_args, sizeof(rpc_val_t));        *newvars = calloc(call->func_args, sizeof(rpc_val_t));
        if (!*newvals) {        if (!*newvars) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
         } else          } else
                memcpy(*newvals, call->func_vals, call->func_args * sizeof(rpc_val_t));                memcpy(*newvars, call->func_vars, call->func_args * sizeof(rpc_val_t));
   
         return call->func_args;          return call->func_args;
 }  }
   
 /*  /*
 * rpc_srv_getValsCall() Get return variables for RPC call * rpc_srv_getVars() Get variables array for RPC call
  * @call = RPC function call   * @call = RPC function call
 * @vals = Returned variables, may be NULL * @vars = Returned variables array, may be NULL
  * return: -1 error, !=-1 Number of returned variables   * return: -1 error, !=-1 Number of returned variables
  */   */
 inline int  inline int
rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict vals)rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict vars)
 {  {
         if (!call) {          if (!call) {
                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get return variables ...\n");                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get variables ...\n");
                 return -1;                  return -1;
         }          }
   
        if (vals)        if (vars)
                *vals = call->func_vals;                *vars = call->func_vars;
         return call->func_args;          return call->func_args;
 }  }
   
Line 216  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const Line 204  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const
   
         func->func_parent = srv;          func->func_parent = srv;
   
        if (args > 0 && rpc_srv_declValsCall(func, args) == -1) {        if (args > 0 && rpc_srv_allocVars(func, args) == -1) {
                 free(func);                  free(func);
                 return -1;                  return -1;
         }          }
Line 266  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con Line 254  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_vals)                if (f->func_args && f->func_vars)
                        free(f->func_vals);                        free(f->func_vars);
                 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_vals)                if (f->func_args && f->func_vars)
                        free(f->func_vals);                        free(f->func_vars);
                 free(f);                  free(f);
         }          }
         pthread_mutex_unlock(&srv->srv_mtx);          pthread_mutex_unlock(&srv->srv_mtx);
Removed from v.1.3  
changed lines
  Added in v.1.3.2.1

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