[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.2.2 and 1.13.4.1

version 1.9.2.2, 2012/05/16 07:54:49 version 1.13.4.1, 2013/05/26 20:24:52
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, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
         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 52  SUCH DAMAGE. Line 52  SUCH DAMAGE.
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @tag = Function tag   * @tag = Function tag
  * @funcaddr = Function address   * @funcaddr = Function address
  * @args = Number of return function arguments  
  * return: -1 error, 0 already registered tag or 1 register ok   * return: -1 error, 0 already registered tag or 1 register ok
  */   */
 int  int
rpc_srv_registerCall(rpc_srv_t * __restrict srv, u_short tag, void *funcaddr, u_short args)rpc_srv_registerCall(rpc_srv_t * __restrict srv, u_short tag, void *funcaddr)
 {  {
         rpc_func_t *func;          rpc_func_t *func;
   
         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 = 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 */
        AIT_SET_PTR(&func->func_name, funcaddr, 0);        if (AVL_FIND(tagRPCFuncs, &srv->srv_funcs, func)) {
                e_free(func);
        /* allocate return variables */                return 0;
        if (args > 0 && !(func->func_vars = io_allocVars(args))) { 
                AIT_FREE_VAL(&func->func_name); 
                free(func); 
                return -1; 
         }          }
   
           func->func_parent = srv;
           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 114  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_s Line 110  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);
   
         io_freeVars(&f->func_vars);  
         AIT_FREE_VAL(&f->func_name);          AIT_FREE_VAL(&f->func_name);
        free(f);        e_free(f);
         return 1;          return 1;
 }  }
   
Line 129  rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_s Line 127  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; 
 }  }
   
 /* --------------------------------------------------------- */  /* --------------------------------------------------------- */
   
 #if 0  
 /*  /*
  * rpc_srv_getBLOB() - Get registered BLOB    * rpc_srv_getBLOB() - Get registered BLOB 
  *   *
Line 156  rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t t Line 151  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;        rpc_blob_t *b, *tmp;
   
         if (!srv) {          if (!srv) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t get BLOB variable");                  rpc_SetErr(EINVAL, "Invalid parameter can`t get BLOB variable");
                 return NULL;                  return NULL;
         }          }
   
        for (b = srv->srv_blob.blobs; b; b = b->blob_next) {        TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp)
                 if (b->blob_var == var)                  if (b->blob_var == var)
                         break;                          break;
         }  
   
         return b;          return b;
 }  }
Line 192  rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_ Line 186  rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_
         }          }
   
         blob = rpc_srv_blobCreate(srv, len);          blob = rpc_srv_blobCreate(srv, len);
         if (blob) {  
                 blob->blob_next = srv->srv_blob.blobs;  
                 srv->srv_blob.blobs = blob;  
         }  
   
           TAILQ_INSERT_TAIL(&srv->srv_blob.blobs, blob, blob_node);
         return blob;          return blob;
 }  }
   
Line 210  rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_ Line 201  rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_
 int  int
 rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var)  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var)
 {  {
        rpc_blob_t *b, *curr;        rpc_blob_t *b;
   
         if (!srv) {          if (!srv) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t unregister BLOB variable");                  rpc_SetErr(EINVAL, "Invalid parameter can`t unregister BLOB variable");
Line 220  rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uin Line 211  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);  
   
        if (srv->srv_blob.blobs == b) { /* if is 1st element */        TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);
                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); 
   
           rpc_srv_blobFree(srv, b);
           e_free(b);
         return 1;          return 1;
 }  }
 #endif  
Removed from v.1.9.2.2  
changed lines
  Added in v.1.13.4.1

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