Return to lists.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / src

version 5.3

    1: /*************************************************************************
    2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
    3: *  by Michael Pounov <misho@openbsd-bg.org>
    4: *
    5: * $Author: misho $
    6: * $Id: lists.c,v 1.15 2013/07/16 13:04:20 misho Exp $
    7: *
    8: **************************************************************************
    9: The ELWIX and AITNET software is distributed under the following
   10: terms:
   11: 
   12: All of the documentation and software included in the ELWIX and AITNET
   13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   14: 
   15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
   16: 	by Michael Pounov <misho@elwix.org>.  All rights reserved.
   17: 
   18: Redistribution and use in source and binary forms, with or without
   19: modification, are permitted provided that the following conditions
   20: are met:
   21: 1. Redistributions of source code must retain the above copyright
   22:    notice, this list of conditions and the following disclaimer.
   23: 2. Redistributions in binary form must reproduce the above copyright
   24:    notice, this list of conditions and the following disclaimer in the
   25:    documentation and/or other materials provided with the distribution.
   26: 3. All advertising materials mentioning features or use of this software
   27:    must display the following acknowledgement:
   28: This product includes software developed by Michael Pounov <misho@elwix.org>
   29: ELWIX - Embedded LightWeight unIX and its contributors.
   30: 4. Neither the name of AITNET nor the names of its contributors
   31:    may be used to endorse or promote products derived from this software
   32:    without specific prior written permission.
   33: 
   34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
   35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   37: ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   44: SUCH DAMAGE.
   45: */
   46: #include "global.h"
   47: 
   48: 
   49: /*
   50:  * rpc_srv_registerCall() - Register call to RPC server
   51:  *
   52:  * @srv = RPC Server instance
   53:  * @tag = Function tag
   54:  * @funcaddr = Function address
   55:  * return: -1 error, 0 already registered tag or 1 register ok
   56:  */
   57: int
   58: rpc_srv_registerCall(rpc_srv_t * __restrict srv, u_short tag, void *funcaddr)
   59: {
   60: 	rpc_func_t *func;
   61: 
   62: 	if (!srv || !funcaddr) {
   63: 		rpc_SetErr(EINVAL, "Invalid parameter can`t register function");
   64: 		return -1;
   65: 	}
   66: 
   67: 	if (!(func = e_malloc(sizeof(rpc_func_t)))) {
   68: 		LOGERR;
   69: 		return -1;
   70: 	} else {
   71: 		memset(func, 0, sizeof(rpc_func_t));
   72: 		AIT_KEY(&func->func_name) = tag;
   73: 	}
   74: 
   75: 	/* search for duplicate */
   76: 	if (AVL_FIND(tagRPCFuncs, &srv->srv_funcs, func)) {
   77: 		e_free(func);
   78: 		return 0;
   79: 	}
   80: 
   81: 	func->func_parent = srv;
   82: 	AIT_SET_PTR(&func->func_name, funcaddr, 0);
   83: 
   84: 	/* add to list of functions */
   85: 	RPC_FUNCS_LOCK(&srv->srv_funcs);
   86: 	SLIST_INSERT_HEAD(&srv->srv_funcs, func, func_next);
   87: 	AVL_INSERT(tagRPCFuncs, &srv->srv_funcs, func);
   88: 	RPC_FUNCS_UNLOCK(&srv->srv_funcs);
   89: 	return 1;
   90: }
   91: 
   92: /*
   93:  * rpc_srv_unregisterCall() - Unregister call from RPC server
   94:  *
   95:  * @srv = RPC Server instance
   96:  * @tag = Function tag
   97:  * return: -1 error, 0 not found call, 1 unregister ok
   98:  */
   99: int
  100: rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, u_short tag)
  101: {
  102: 	rpc_func_t *f;
  103: 
  104: 	if (!srv) {
  105: 		rpc_SetErr(EINVAL, "Invalid parameter can`t unregister function");
  106: 		return -1;
  107: 	}
  108: 
  109: 	f = rpc_srv_getCall(srv, tag);
  110: 	if (!f) 		/* not found element for unregister */
  111: 		return 0;
  112: 
  113: 	RPC_FUNCS_LOCK(&srv->srv_funcs);
  114: 	AVL_REMOVE(tagRPCFuncs, &srv->srv_funcs, f);
  115: 	SLIST_REMOVE(&srv->srv_funcs, f, tagRPCFunc, func_next);
  116: 	RPC_FUNCS_UNLOCK(&srv->srv_funcs);
  117: 
  118: 	AIT_FREE_VAL(&f->func_name);
  119: 	e_free(f);
  120: 	return 1;
  121: }
  122: 
  123: /*
  124:  * rpc_srv_getCall()  - Get registered call from RPC server
  125:  *
  126:  * @srv = RPC Server instance
  127:  * @tag = tag for function
  128:  * return: NULL not found call, !=NULL return call
  129:  */
  130: rpc_func_t *
  131: rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag)
  132: {
  133: 	rpc_func_t tmp;
  134: 
  135: 	if (!srv) {
  136: 		rpc_SetErr(EINVAL, "Invalid parameter can`t get function");
  137: 		return NULL;
  138: 	} else
  139: 		memset(&tmp, 0, sizeof tmp);
  140: 
  141: 	AIT_KEY(&tmp.func_name) = tag;
  142: 	return AVL_FIND(tagRPCFuncs, &srv->srv_funcs, &tmp);
  143: }
  144: 
  145: /* --------------------------------------------------------- */
  146: 
  147: /*
  148:  * rpc_srv_getBLOB() - Get registered BLOB 
  149:  *
  150:  * @srv = RPC Server instance
  151:  * @var = hash for variable
  152:  * return: NULL not found, !=NULL return blob var
  153:  */
  154: rpc_blob_t *
  155: rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var)
  156: {
  157: 	rpc_blob_t *b, *tmp;
  158: 
  159: 	if (!srv) {
  160: 		rpc_SetErr(EINVAL, "Invalid parameter can`t get BLOB variable");
  161: 		return NULL;
  162: 	}
  163: 
  164: 	TAILQ_FOREACH_SAFE(b, &srv->srv_blob.blobs, blob_node, tmp)
  165: 		if (b->blob_var == var)
  166: 			break;
  167: 
  168: 	return b;
  169: }
  170: 
  171: /*
  172:  * rpc_srv_registerBLOB() - Register new BLOB to server
  173:  *
  174:  * @srv = RPC Server instance
  175:  * @len = BLOB length
  176:  * @tout = BLOB live timeout in seconds
  177:  * return: NULL error or new registered BLOB
  178:  */
  179: rpc_blob_t *
  180: rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len, int tout)
  181: {
  182: 	rpc_blob_t *blob = NULL;
  183: 
  184: 	if (!srv || !len) {
  185: 		rpc_SetErr(EINVAL, "Invalid parameter can`t register BLOB variable");
  186: 		return blob;
  187: 	}
  188: 
  189: 	blob = rpc_srv_blobCreate(srv, len, tout);
  190: 
  191: 	TAILQ_INSERT_TAIL(&srv->srv_blob.blobs, blob, blob_node);
  192: 
  193: 	return blob;
  194: }
  195: 
  196: /*
  197:  * rpc_srv_unregisterBLOB() - Unregister BLOB from server
  198:  *
  199:  * @srv = RPC Server instance
  200:  * @var = BLOB Variable for unregister
  201:  * return: -1 error, 0 not found call, 1 unregister ok
  202:  */
  203: int
  204: rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var)
  205: {
  206: 	rpc_blob_t *b;
  207: 
  208: 	if (!srv) {
  209: 		rpc_SetErr(EINVAL, "Invalid parameter can`t unregister BLOB variable");
  210: 		return -1;
  211: 	}
  212: 
  213: 	b = rpc_srv_getBLOB(srv, var);
  214: 	if (!b)				/* not found element for unregister */
  215: 		return 0;
  216: 
  217: 	TAILQ_REMOVE(&srv->srv_blob.blobs, b, blob_node);
  218: 
  219: 	rpc_srv_blobFree(srv, b);
  220: 	e_free(b);
  221: 	return 1;
  222: }