[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.11 and 1.18

version 1.11, 2012/07/22 20:44:13 version 1.18, 2015/07/02 22:28:15
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012Copyright 2004 - 2015
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 46  SUCH DAMAGE. Line 46  SUCH DAMAGE.
 #include "global.h"  #include "global.h"
   
   
   #pragma GCC visibility push(hidden)
   
   static int
   rpc_funcs_cmp(struct tagRPCFunc *a, struct tagRPCFunc *b)
   {
           int ret;
   
           assert(a && b);
   
           ret = AIT_KEY(&a->func_name) - AIT_KEY(&b->func_name);
   
           if (ret < 0)
                   return -1;
           else if (ret > 0)
                   return 1;
   
           return ret;
   }
   
   AVL_GENERATE(tagRPCFuncs, tagRPCFunc, func_node, rpc_funcs_cmp);
   
   #pragma GCC visibility pop
   
 /*  /*
  * rpc_srv_registerCall() - Register call to RPC server   * rpc_srv_registerCall() - Register call to RPC server
  *   *
Line 62  rpc_srv_registerCall(rpc_srv_t * __restrict srv, u_sho Line 85  rpc_srv_registerCall(rpc_srv_t * __restrict srv, u_sho
         if (!srv || !funcaddr) {          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 = io_malloc(sizeof(rpc_func_t)))) {        if (!(func = e_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;                AIT_KEY(&func->func_name) = tag;
         }          }
   
        AIT_KEY(&func->func_name) = tag;        /* search for duplicate */
         if (AVL_FIND(tagRPCFuncs, &srv->srv_funcs, func)) {
                 e_free(func);
                 return 0;
         }
 
         func->func_parent = srv;
         AIT_SET_PTR(&func->func_name, funcaddr, 0);          AIT_SET_PTR(&func->func_name, funcaddr, 0);
   
         /* add to list of functions */          /* add to list of functions */
        TAILQ_INSERT_TAIL(&srv->srv_funcs, func, func_node);        RPC_FUNCS_LOCK(&srv->srv_funcs);
         SLIST_INSERT_HEAD(&srv->srv_funcs, func, func_next);
         AVL_INSERT(tagRPCFuncs, &srv->srv_funcs, func);
         RPC_FUNCS_UNLOCK(&srv->srv_funcs);
         return 1;          return 1;
 }  }
   
Line 106  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_s Line 133  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_s
         if (!f)                 /* not found element for unregister */          if (!f)                 /* not found element for unregister */
                 return 0;                  return 0;
   
        TAILQ_REMOVE(&srv->srv_funcs, f, func_node);        RPC_FUNCS_LOCK(&srv->srv_funcs);
         AVL_REMOVE(tagRPCFuncs, &srv->srv_funcs, f);
         SLIST_REMOVE(&srv->srv_funcs, f, tagRPCFunc, func_next);
         RPC_FUNCS_UNLOCK(&srv->srv_funcs);
   
         AIT_FREE_VAL(&f->func_name);          AIT_FREE_VAL(&f->func_name);
        io_free(f);        e_free(f);
         return 1;          return 1;
 }  }
   
Line 120  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_s Line 150  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_s
  * @tag = tag for function   * @tag = tag for function
  * return: NULL not found call, !=NULL return call   * return: NULL not found call, !=NULL return call
  */   */
inline rpc_func_t *rpc_func_t *
 rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag)  rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag)
 {  {
        rpc_func_t *f, *tmp;        rpc_func_t 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;
        }        } else
                 memset(&tmp, 0, sizeof tmp);
   
        TAILQ_FOREACH_SAFE(f, &srv->srv_funcs, func_node, tmp)        AIT_KEY(&tmp.func_name) = tag;
                if (AIT_KEY(&f->func_name) == tag)        return AVL_FIND(tagRPCFuncs, &srv->srv_funcs, &tmp);
                        break; 
 
        return f; 
 }  }
   
 /* --------------------------------------------------------- */  /* --------------------------------------------------------- */
Line 146  rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t t Line 174  rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t t
  * @var = hash for variable   * @var = hash for variable
  * return: NULL not found, !=NULL return blob var   * return: NULL not found, !=NULL return blob var
  */   */
inline rpc_blob_t *rpc_blob_t *
 rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var)  rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var)
 {  {
         rpc_blob_t *b, *tmp;          rpc_blob_t *b, *tmp;
Line 168  rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t v Line 196  rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t v
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @len = BLOB length   * @len = BLOB length
    * @tout = BLOB live timeout in seconds
  * return: NULL error or new registered BLOB   * return: NULL error or new registered BLOB
  */   */
 rpc_blob_t *  rpc_blob_t *
rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len)rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len, int tout)
 {  {
         rpc_blob_t *blob = NULL;          rpc_blob_t *blob = NULL;
   
Line 180  rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_ Line 209  rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_
                 return blob;                  return blob;
         }          }
   
        blob = rpc_srv_blobCreate(srv, len);        blob = rpc_srv_blobCreate(srv, len, tout);
   
         TAILQ_INSERT_TAIL(&srv->srv_blob.blobs, blob, blob_node);          TAILQ_INSERT_TAIL(&srv->srv_blob.blobs, blob, blob_node);
   
         return blob;          return blob;
 }  }
   
Line 210  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin Line 240  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin
         TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);          TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);
   
         rpc_srv_blobFree(srv, b);          rpc_srv_blobFree(srv, b);
        io_free(b);        e_free(b);
         return 1;          return 1;
 }  }
Removed from v.1.11  
changed lines
  Added in v.1.18

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