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

version 1.2.2.1, 2011/07/14 01:31:00 version 1.5.2.3, 2011/11/03 15:28:36
Line 47  SUCH DAMAGE. Line 47  SUCH DAMAGE.
   
   
 /*  /*
 * rpc_srv_retValsCall() Declare return variables for RPC call and zeroed values * rpc_srv_allocVars() Allocate array for call variables
                                        (for safe handling return values, use this!) 
  * @call = RPC function call   * @call = RPC function call
 * @return_vals = Number of return variables * @varnum = Number of variables, if ==0 return already allocated variables number
 * return: NULL error, !=NULL array with return values for RPC call with return_vals items * return: -1 error, !=-1 return varnum value
  */   */
inline rpc_val_t *static inline int
rpc_srv_retValsCall(rpc_func_t * __restrict call, int return_vals)rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)
 {  {
        rpc_val_t *v = NULL;        if (!call || varnum < 0) {
                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t allocate variables for RPC call...\n");
        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 
 * @call = RPC function call 
 * return: none 
 */ 
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 
rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals) 
{ 
        void *ptr; 
 
        if (!call || return_vals < 0) { 
                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t declare return variables for RPC call...\n"); 
                 return -1;                  return -1;
        } else        }
                call->func_args = return_vals; 
   
        if (!return_vals) {        if (varnum) {
                if (call->func_vals) {                call->func_vars = io_allocVars(varnum);
                        free(call->func_vals);                if (!call->func_vars)
                        call->func_vals = NULL; 
                } 
        } else { 
                ptr = realloc(call->func_vals, return_vals * sizeof(rpc_val_t)); 
                if (!ptr) { 
                        LOGERR; 
                        call->func_args = 0; 
                         return -1;                          return -1;
                 } else  
                         call->func_vals = ptr;  
         }          }
   
        return return_vals;        return io_arraySize(call->func_vars);
 }  }
   
 /*  /*
 * rpc_srv_zeroValsCall() Clean values from return variables of RPC call * rpc_srv_copyVars() Copy variables for RPC call to new variable array
  * @call = RPC function call   * @call = RPC function call
 * return: -1 error, !=-1 Returned number of cleaned RPC variables * @newvars = New allocated variables array, must be free after use
 */ 
inline int 
rpc_srv_zeroValsCall(rpc_func_t * __restrict call) 
{ 
        if (!call) { 
                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete return variables ...\n"); 
                return -1; 
        } 
 
        memset(call->func_vals, 0, call->func_args * sizeof(rpc_val_t)); 
        return call->func_args; 
} 
 
/* 
 * rpc_srv_copyValsCall() Copy return variables for RPC call to new variable 
 * @call = RPC function call 
 * @newvals = 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, array_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));        if (io_arrayCopy(newvars, call->func_vars) == -1)
        if (!*newvals) { 
                LOGERR; 
                 return -1;                  return -1;
         } else  
                 memcpy(*newvals, call->func_vals, call->func_args * sizeof(rpc_val_t));  
   
        return call->func_args;        return io_arraySize(*newvars);
 }  }
   
 /*  /*
 * 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, array_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 io_arraySize(call->func_vars);
 }  }
   
 // ---------------------------------------------------------  // ---------------------------------------------------------
Line 187  rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_ Line 119  rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_
  * 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];
   
        memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);        memset(str, 0, sizeof str);
         if (!srv || !csFunc) {          if (!srv || !csFunc) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t register function to RPC server ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t register function to RPC server ...\n");
                 return -1;                  return -1;
Line 202  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const Line 134  rpc_srv_registerCall(rpc_srv_t * __restrict srv, const
                 return -1;                  return -1;
         } else {          } else {
                 memset(func, 0, sizeof(rpc_func_t));                  memset(func, 0, sizeof(rpc_func_t));
                strlcpy((char*) func->func_name, csFunc, UCHAR_MAX + 1);                strlcpy((char*) func->func_name, csFunc, sizeof func->func_name);
         }          }
         if (csModule) {          if (csModule) {
                strlcpy((char*) func->func_file, csModule, MAXPATHLEN);                strlcpy((char*) func->func_file, csModule, sizeof func->func_file);
                strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);                strlcpy((char*) str, csModule, sizeof str);
         }          }
        strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);        strlcat((char*) str, "__", sizeof str);
        strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);        strlcat((char*) str, csFunc, sizeof str);
   
        func->func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);        func->func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
        func->func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);        func->func_hash = hash_fnv((char*) str, sizeof str);
   
         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 242  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con Line 174  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
         u_char str[MAXPATHLEN + UCHAR_MAX + 1];          u_char str[MAXPATHLEN + UCHAR_MAX + 1];
   
         memset(&func, 0, sizeof(rpc_func_t));          memset(&func, 0, sizeof(rpc_func_t));
        memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);        memset(str, 0, sizeof str);
         if (!srv || !csFunc) {          if (!srv || !csFunc) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t unregister function from RPC server ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t unregister function from RPC server ...\n");
                 return -1;                  return -1;
         } else          } else
                strlcpy((char*) func.func_name, csFunc, UCHAR_MAX + 1);                strlcpy((char*) func.func_name, csFunc, sizeof func.func_name);
         if (csModule) {          if (csModule) {
                strlcpy((char*) func.func_file, csModule, MAXPATHLEN);                strlcpy((char*) func.func_file, csModule, sizeof func.func_file);
                strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);                strlcpy((char*) str, csModule, sizeof str);
         }          }
        strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);        strlcat((char*) str, "__", sizeof str);
        strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);        strlcat((char*) str, csFunc, sizeof str);
   
        func.func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);        func.func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
        func.func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);        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_vals) 
                        free(f->func_vals); 
                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_vals)  
                         free(f->func_vals);  
                 free(f);  
         }          }
           io_freeVars(&f->func_vars);
           free(f);
         pthread_mutex_unlock(&srv->srv_mtx);          pthread_mutex_unlock(&srv->srv_mtx);
   
         return 1;          return 1;
Line 320  rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char Line 246  rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char
         u_char str[MAXPATHLEN + UCHAR_MAX + 1];          u_char str[MAXPATHLEN + UCHAR_MAX + 1];
   
         memset(&func, 0, sizeof(rpc_func_t));          memset(&func, 0, sizeof(rpc_func_t));
        memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);        memset(str, 0, sizeof str);
         if (!srv || !csFunc) {          if (!srv || !csFunc) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get function from RPC server ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get function from RPC server ...\n");
                 return NULL;                  return NULL;
         } else          } else
                strlcpy((char*) func.func_name, csFunc, UCHAR_MAX + 1);                strlcpy((char*) func.func_name, csFunc, sizeof func.func_name);
         if (csModule) {          if (csModule) {
                strlcpy((char*) func.func_file, csModule, MAXPATHLEN);                strlcpy((char*) func.func_file, csModule, sizeof func.func_file);
                strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);                strlcpy((char*) str, csModule, sizeof str);
         }          }
        strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);        strlcat((char*) str, "__", sizeof str);
        strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);        strlcat((char*) str, csFunc, sizeof str);
   
        func.func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);        func.func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
        func.func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);        func.func_hash = hash_fnv((char*) str, sizeof str);
   
         return rpc_srv_getCall(srv, func.func_tag, func.func_hash);          return rpc_srv_getCall(srv, func.func_tag, func.func_hash);
 }  }
Line 357  rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t v Line 283  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 413  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin Line 337  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 421  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.2.2.1  
changed lines
  Added in v.1.5.2.3

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