[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.9 and 1.9.2.2

version 1.9, 2012/05/14 08:39:06 version 1.9.2.2, 2012/05/16 07:54:49
Line 47  SUCH DAMAGE. Line 47  SUCH DAMAGE.
   
   
 /*  /*
  * rpc_srv_allocVars() - Allocate array for call variables  
  *  
  * @call = RPC function call  
  * @varnum = Number of variables, if ==0 return already allocated variables number  
  * return: -1 error, !=-1 return varnum value  
  */  
 static inline int  
 rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)  
 {  
         if (!call || varnum < 0) {  
                 rpc_SetErr(EINVAL, "Invalid parameter can`t allocate variables for RPC call");  
                 return -1;  
         }  
   
         if (varnum) {  
                 call->func_vars = io_allocVars(varnum);  
                 if (!call->func_vars)  
                         return -1;  
         }  
   
         return io_arraySize(call->func_vars);  
 }  
   
 /*  
  * rpc_srv_getVars() - Get variables array for RPC call  
  *  
  * @call = RPC function call  
  * @vars = Returned variables array, may be NULL  
  * return: -1 error, !=-1 Number of returned variables  
  */  
 inline int  
 rpc_srv_getVars(rpc_func_t * __restrict call, array_t ** __restrict vars)  
 {  
         if (!call) {  
                 rpc_SetErr(EINVAL, "Invalid parameter can`t get variables");  
                 return -1;  
         }  
   
         if (vars)  
                 *vars = call->func_vars;  
         return io_arraySize(call->func_vars);  
 }  
   
 /* --------------------------------------------------------- */  
   
 /*  
  * rpc_srv_registerCall() - Register call to RPC server   * rpc_srv_registerCall() - Register call to RPC server
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
 * @csModule = Module name, if NULL self binary * @tag = Function tag
 * @csFunc = Function name * @funcaddr = Function address
 * @args = Number of return function arguments, use for restriction case! * @args = Number of return function arguments
 * return: -1 error or 0 register ok * return: -1 error, 0 already registered tag or 1 register ok
  */   */
 int  int
rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, rpc_srv_registerCall(rpc_srv_t * __restrict srv, u_short tag, void *funcaddr, u_short args)
                const char *csFunc, u_short args) 
 {  {
         rpc_func_t *func;          rpc_func_t *func;
   
        if (!srv || !csFunc) {        if (!srv || !funcaddr) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t register function");                  rpc_SetErr(EINVAL, "Invalid parameter can`t register function");
                 return -1;                  return -1;
           } else {
                   /* search for duplicate */
                   TAILQ_FOREACH(func, &srv->srv_funcs, func_node)
                           if (AIT_KEY(&func->func_name) == tag)
                                   return 0;
         }          }
   
         if (!(func = malloc(sizeof(rpc_func_t)))) {          if (!(func = malloc(sizeof(rpc_func_t)))) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
        } else        } else {
                 memset(func, 0, sizeof(rpc_func_t));                  memset(func, 0, sizeof(rpc_func_t));
                func->func_parent = srv;
        /* calculate hashes */ 
        if (rpc_calcHashes(func, csModule, csFunc) == -1) { 
                AIT_FREE_VAL(&func->func_name); 
                AIT_FREE_VAL(&func->func_file); 
                free(func); 
                return -1; 
         }          }
   
        func->func_parent = srv;        AIT_KEY(&func->func_name) = tag;
         AIT_SET_PTR(&func->func_name, funcaddr, 0);
   
         /* allocate return variables */          /* allocate return variables */
        if (args > 0 && rpc_srv_allocVars(func, args) == -1) {        if (args > 0 && !(func->func_vars = io_allocVars(args))) {
                 AIT_FREE_VAL(&func->func_name);                  AIT_FREE_VAL(&func->func_name);
                 AIT_FREE_VAL(&func->func_file);  
                 free(func);                  free(func);
                 return -1;                  return -1;
         }          }
   
         /* add to list of functions */          /* add to list of functions */
        func->func_next = srv->srv_funcs;        TAILQ_INSERT_TAIL(&srv->srv_funcs, func, func_node);
        srv->srv_funcs = func;        return 1;
        return 0; 
 }  }
   
 /*  /*
  * rpc_srv_unregisterCall() - Unregister call from RPC server   * rpc_srv_unregisterCall() - Unregister call from RPC server
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
 * @csModule = Module name, if NULL self binary * @tag = Function tag
 * @csFunc = Function name 
  * return: -1 error, 0 not found call, 1 unregister ok   * return: -1 error, 0 not found call, 1 unregister ok
  */   */
 int  int
rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc)rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_short tag)
 {  {
        rpc_func_t func, *f, *curr;        rpc_func_t *f;
   
        if (!srv || !csFunc) {        if (!srv) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t unregister function");                  rpc_SetErr(EINVAL, "Invalid parameter can`t unregister function");
                 return -1;                  return -1;
        } else        }
                memset(&func, 0, sizeof func); 
   
        /* calculate hashes */        f = rpc_srv_getCall(srv, tag);
        if (rpc_calcHashes(&func, csModule, csFunc) == -1) 
                return -1; 
 
        f = rpc_srv_getCall(srv, func.func_tag, func.func_hash); 
        AIT_FREE_VAL(&func.func_name); 
        AIT_FREE_VAL(&func.func_file); 
         if (!f)                 /* not found element for unregister */          if (!f)                 /* not found element for unregister */
                 return 0;                  return 0;
   
        /* remove from list of functions */        TAILQ_REMOVE(&srv->srv_funcs, f, func_node);
        if (srv->srv_funcs == f)   /* if is 1st element */
                srv->srv_funcs = srv->srv_funcs->func_next; 
        else { 
                for (curr = srv->srv_funcs; curr->func_next != f; curr = curr->func_next); 
                curr->func_next = curr->func_next->func_next; 
        } 
         io_freeVars(&f->func_vars);          io_freeVars(&f->func_vars);
         AIT_FREE_VAL(&f->func_name);          AIT_FREE_VAL(&f->func_name);
         AIT_FREE_VAL(&f->func_file);  
         free(f);          free(f);
   
         return 1;          return 1;
 }  }
   
Line 190  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con Line 127  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, con
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @tag = tag for function   * @tag = tag for function
  * @hash = hash for function  
  * return: NULL not found call, !=NULL return call   * return: NULL not found call, !=NULL return call
  */   */
 inline rpc_func_t *  inline rpc_func_t *
rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag, uint32_t hash)rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag)
 {  {
        rpc_func_t *f;        rpc_func_t *f, *tmp;
   
         if (!srv) {          if (!srv) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t get function");                  rpc_SetErr(EINVAL, "Invalid parameter can`t get function");
                 return NULL;                  return NULL;
         }          }
   
        for (f = srv->srv_funcs; f; f = f->func_next)        TAILQ_FOREACH_SAFE(f, &srv->srv_funcs, func_node, tmp)
                if (f->func_tag == tag && f->func_hash == hash)                if (AIT_KEY(&f->func_name) == tag)
                         break;                          break;
   
         return f;          return f;
 }  }
   
/*/* --------------------------------------------------------- */
 * rpc_srv_getFunc() - Get registered call from RPC server by Name 
 * 
 * @srv = RPC Server instance 
 * @csModule = Module name, if NULL self binary 
 * @csFunc = Function name 
 * return: NULL not found call, !=NULL return call 
 */ 
rpc_func_t * 
rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc) 
{ 
        rpc_func_t func, *f = NULL; 
   
        if (!srv || !csFunc) {#if 0
                rpc_SetErr(EINVAL, "Invalid parameter can`t get function"); 
                return NULL; 
        } else 
                memset(&func, 0, sizeof(rpc_func_t)); 
 
        /* calculate hashes */ 
        if (rpc_calcHashes(&func, csModule, csFunc) == -1) 
                return NULL; 
 
        f = rpc_srv_getCall(srv, func.func_tag, func.func_hash); 
 
        AIT_FREE_VAL(&func.func_name); 
        AIT_FREE_VAL(&func.func_file); 
        return f; 
} 
 
// --------------------------------------------------------- 
 
 /*  /*
  * rpc_srv_getBLOB() - Get registered BLOB    * rpc_srv_getBLOB() - Get registered BLOB 
  *   *
Line 328  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin Line 235  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin
   
         return 1;          return 1;
 }  }
#endif
/* 
 * rpc_calcHashes() - Calculate hashes for RPC call 
 * 
 * @func = function 
 * @csModule = Module name, if NULL self binary 
 * @csFunc = Function name 
 * return: -1 error or 0 ok 
 */ 
int 
rpc_calcHashes(rpc_func_t * __restrict func, const char *csModule, const char *csFunc) 
{ 
        char *str = NULL; 
        int len = 0; 
 
        assert(func && csFunc); 
 
        /* set function name */ 
        AIT_SET_STR(&func->func_name, csFunc); 
        len = strlen(csFunc) + 3;       /* extra 3 bytes, because add string "__" and 0 */ 
        /* set module name if exists */ 
        if (csModule) { 
                AIT_SET_STR(&func->func_file, csModule); 
                len += strlen(csModule); 
        } 
        /* align len to 2 */ 
        len = io_align(len, 1); 
 
        /* prepare hash source string */ 
        str = malloc(len); 
        if (!str) { 
                LOGERR; 
                return -1; 
        } else { 
                memset(str, 0, len); 
                if (csModule) 
                        strlcpy((char*) str, csModule, len); 
                strlcat((char*) str, "__", len); 
                strlcat((char*) str, csFunc, len); 
        } 
 
        func->func_tag = crcFletcher16((u_short*) str, len / 2); 
        func->func_hash = hash_fnv((char*) str, len); 
 
        free(str); 
        return len; 
} 
 
Removed from v.1.9  
changed lines
  Added in v.1.9.2.2

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