[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.1.2.2 and 1.1.2.7

version 1.1.2.2, 2010/06/23 15:07:15 version 1.1.2.7, 2010/07/08 07:16:36
Line 2 Line 2
   
   
 /*  /*
    * rpc_srv_retValsCall() Declare return variables for RPC call and zeroed values
                                           (for safe handling return values, use this!)
    * @call = RPC function call
    * @return_vals = Number of return variables
    * return: NULL error, !=NULL array with return values for RPC call with return_vals items
    */
   inline rpc_val_t *
   rpc_srv_retValsCall(rpc_func_t * __restrict call, int return_vals)
   {
           rpc_val_t *v = NULL;
   
           if (rpc_srv_declValsCall(call, return_vals) == -1)
                   return NULL;
           else
                   rpc_srv_zeroValsCall(call);
           if (rpc_srv_getValsCall(call, &v) == -1)
                   return NULL;
   
           return v;
   }
   
   /*
  * rpc_srv_freeValsCall() Free return variables for RPC call   * rpc_srv_freeValsCall() Free return variables for RPC call
  * @call = RPC function call   * @call = RPC function call
  * return: none   * return: none
Line 13  rpc_srv_freeValsCall(rpc_func_t * __restrict call) Line 35  rpc_srv_freeValsCall(rpc_func_t * __restrict call)
 }  }
   
 /*  /*
 * rpc_srv_declValsCall() Declare return variables for RPC call * 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   * @call = RPC function call
  * @return_vals = Number of return variables   * @return_vals = Number of return variables
  * return: -1 error, !=-1 ok   * return: -1 error, !=-1 ok
Line 43  rpc_srv_declValsCall(rpc_func_t * __restrict call, int Line 67  rpc_srv_declValsCall(rpc_func_t * __restrict call, int
                         call->func_vals = ptr;                          call->func_vals = ptr;
         }          }
   
        return call->func_args;        return return_vals;
 }  }
   
 /*  /*
 * rpc_srv_delValsCall() Clean values from return variables of RPC call * rpc_srv_zeroValsCall() Clean values from return 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_delValsCall(rpc_func_t * __restrict call)rpc_srv_zeroValsCall(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 return variables ...\n");
Line 113  rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_ Line 137  rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @csModule = Module name, if NULL self binary   * @csModule = Module name, if NULL self binary
  * @csFunc = Function name   * @csFunc = Function name
 * @args = Number of function arguments * @args = Number of return function arguments, use for restriction case!
  * return: -1 error or 0 register ok   * return: -1 error or 0 register ok
  */   */
 int  int
Line 144  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const Line 168  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const
         func->func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);          func->func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);
         func->func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);          func->func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);
   
        if (rpc_srv_declValsCall(func, args) == -1) {        func->func_parent = srv;
 
         if (args > 0 && rpc_srv_declValsCall(func, args) == -1) {
                 free(func);                  free(func);
                 return -1;                  return -1;
         }          }
Line 285  rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t v Line 311  rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t v
                 return NULL;                  return NULL;
         }          }
   
        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;
           }
   
         return b;          return b;
 }  }
   
   /*
    * rpc_srv_registerBLOB() Register new BLOB to server
    * @srv = RPC Server instance
    * @len = BLOB length
    * return: NULL error or new registered BLOB
    */
   rpc_blob_t *
   rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len)
   {
           rpc_blob_t *blob = NULL;
   
           if (!srv || !len) {
                   rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t register BLOB to server ...\n");
                   return blob;
           }
   
           blob = rpc_srv_blobCreate(srv, len);
           if (blob) {
                   pthread_mutex_lock(&srv->srv_blob.mtx);
                   blob->blob_next = srv->srv_blob.blobs;
                   srv->srv_blob.blobs = blob;
                   pthread_mutex_unlock(&srv->srv_blob.mtx);
           }
   
           return blob;
   }
   
   /*
    * rpc_srv_unregisterBLOB() Unregister BLOB from server
    * @srv = RPC Server instance
    * @var = BLOB Variable for unregister
    * return: -1 error, 0 not found call, 1 unregister ok
    */
   int
   rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var)
   {
           rpc_blob_t *b, *curr;
   
           if (!srv) {
                   rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t unregister BLOB from server ...\n");
                   return -1;
           }
   
           b = rpc_srv_getBLOB(srv, var);
           if (!b)         // not found element for unregister
                   return 0;
   
           pthread_mutex_lock(&srv->srv_blob.mtx);
           if (srv->srv_blob.blobs == b) { // if is 1st element
                   srv->srv_blob.blobs = srv->srv_blob.blobs->blob_next;
           } else {
                   for (curr = srv->srv_blob.blobs; curr->blob_next != b; curr = curr->blob_next);
                   curr->blob_next = curr->blob_next->blob_next;
           }
           rpc_srv_blobFree(srv, b);
           free(b);
           pthread_mutex_unlock(&srv->srv_blob.mtx);
   
           return 1;
   }
Removed from v.1.1.2.2  
changed lines
  Added in v.1.1.2.7

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