Annotation of libaitrpc/src/lists.c, revision 1.4.2.1
1.2 misho 1: /*************************************************************************
2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
3: * by Michael Pounov <misho@openbsd-bg.org>
4: *
5: * $Author: misho $
1.4.2.1 ! misho 6: * $Id: lists.c,v 1.4 2011/08/29 22:37:06 misho Exp $
1.2 misho 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
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: /*
1.4 misho 50: * rpc_srv_returnVars() Init return variables for RPC call and zeroed values
1.2 misho 51: (for safe handling return values, use this!)
52: * @call = RPC function call
1.4 misho 53: * @varnum = Number of return variables
54: * return: NULL error, !=NULL array with return values for RPC call with varnum items
1.2 misho 55: */
1.4.2.1 ! misho 56: inline ait_val_t *
1.4 misho 57: rpc_srv_returnVars(rpc_func_t * __restrict call, int varnum)
1.2 misho 58: {
1.4.2.1 ! misho 59: ait_val_t *v = NULL;
1.2 misho 60:
1.4 misho 61: if (rpc_srv_allocVars(call, varnum) == -1)
1.2 misho 62: return NULL;
63: else
1.4 misho 64: rpc_srv_zeroVars(call);
65: if (rpc_srv_getVars(call, &v) == -1)
1.2 misho 66: return NULL;
67:
68: return v;
69: }
70:
71: /*
1.4 misho 72: * rpc_srv_allocVars() Allocate array for call variables,
73: if already allocated memory for RPC call reallocate used space
1.2 misho 74: * @call = RPC function call
1.4 misho 75: * @varnum = Number of variables, if ==0 free previous allocated variables
76: * return: -1 error, !=-1 return varnum value
1.2 misho 77: */
78: inline int
1.4 misho 79: rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum)
1.2 misho 80: {
81: void *ptr;
82:
1.4 misho 83: if (!call || varnum < 0) {
84: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t allocate variables for RPC call...\n");
1.2 misho 85: return -1;
86: } else
1.4 misho 87: call->func_args = varnum;
1.2 misho 88:
1.4 misho 89: if (!varnum) {
90: if (call->func_vars) {
91: free(call->func_vars);
92: call->func_vars = NULL;
1.2 misho 93: }
94: } else {
1.4.2.1 ! misho 95: ptr = realloc(call->func_vars, varnum * sizeof(ait_val_t));
1.2 misho 96: if (!ptr) {
97: LOGERR;
98: call->func_args = 0;
99: return -1;
100: } else
1.4 misho 101: call->func_vars = ptr;
1.2 misho 102: }
103:
1.4 misho 104: return varnum;
1.2 misho 105: }
106:
107: /*
1.4 misho 108: * rpc_srv_zeroVars() Clean values from variables of RPC call
1.2 misho 109: * @call = RPC function call
110: * return: -1 error, !=-1 Returned number of cleaned RPC variables
111: */
112: inline int
1.4 misho 113: rpc_srv_zeroVars(rpc_func_t * __restrict call)
1.2 misho 114: {
115: if (!call) {
1.4 misho 116: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete variables ...\n");
1.2 misho 117: return -1;
118: }
119:
1.4.2.1 ! misho 120: memset(call->func_vars, 0, call->func_args * sizeof(ait_val_t));
1.2 misho 121: return call->func_args;
122: }
123:
124: /*
1.4 misho 125: * rpc_srv_copyVars() Copy variables for RPC call to new variable array
1.2 misho 126: * @call = RPC function call
1.4 misho 127: * @newvars = New allocated variables array, must be free after use
1.2 misho 128: * return: -1 error, !=-1 Returned number of copied RPC variables
129: */
130: inline int
1.4.2.1 ! misho 131: rpc_srv_copyVars(rpc_func_t * __restrict call, ait_val_t ** __restrict newvars)
1.2 misho 132: {
1.4 misho 133: if (!call || !newvars) {
134: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t copy variables to new array\n");
1.2 misho 135: return -1;
136: }
137:
1.4.2.1 ! misho 138: *newvars = calloc(call->func_args, sizeof(ait_val_t));
1.4 misho 139: if (!*newvars) {
1.2 misho 140: LOGERR;
141: return -1;
142: } else
1.4.2.1 ! misho 143: memcpy(*newvars, call->func_vars, call->func_args * sizeof(ait_val_t));
1.2 misho 144:
145: return call->func_args;
146: }
147:
148: /*
1.4 misho 149: * rpc_srv_getVars() Get variables array for RPC call
1.2 misho 150: * @call = RPC function call
1.4 misho 151: * @vars = Returned variables array, may be NULL
1.2 misho 152: * return: -1 error, !=-1 Number of returned variables
153: */
154: inline int
1.4.2.1 ! misho 155: rpc_srv_getVars(rpc_func_t * __restrict call, ait_val_t ** __restrict vars)
1.2 misho 156: {
157: if (!call) {
1.4 misho 158: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get variables ...\n");
1.2 misho 159: return -1;
160: }
161:
1.4 misho 162: if (vars)
163: *vars = call->func_vars;
1.2 misho 164: return call->func_args;
165: }
166:
167: // ---------------------------------------------------------
168:
169: /*
170: * rpc_srv_registerCall() Register call to RPC server
171: * @srv = RPC Server instance
172: * @csModule = Module name, if NULL self binary
173: * @csFunc = Function name
174: * @args = Number of return function arguments, use for restriction case!
175: * return: -1 error or 0 register ok
176: */
177: int
178: rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, u_char args)
179: {
180: rpc_func_t *func;
181: u_char str[MAXPATHLEN + UCHAR_MAX + 1];
182:
1.4 misho 183: memset(str, 0, sizeof str);
1.2 misho 184: if (!srv || !csFunc) {
185: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t register function to RPC server ...\n");
186: return -1;
187: }
188: if (!(func = malloc(sizeof(rpc_func_t)))) {
189: LOGERR;
190: return -1;
191: } else {
192: memset(func, 0, sizeof(rpc_func_t));
1.4 misho 193: strlcpy((char*) func->func_name, csFunc, sizeof func->func_name);
1.2 misho 194: }
195: if (csModule) {
1.4 misho 196: strlcpy((char*) func->func_file, csModule, sizeof func->func_file);
197: strlcpy((char*) str, csModule, sizeof str);
1.2 misho 198: }
1.4 misho 199: strlcat((char*) str, "__", sizeof str);
200: strlcat((char*) str, csFunc, sizeof str);
1.2 misho 201:
1.4 misho 202: func->func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
203: func->func_hash = hash_fnv((char*) str, sizeof str);
1.2 misho 204:
205: func->func_parent = srv;
206:
1.4 misho 207: if (args > 0 && rpc_srv_allocVars(func, args) == -1) {
1.2 misho 208: free(func);
209: return -1;
210: }
211:
212: pthread_mutex_lock(&srv->srv_mtx);
213: func->func_next = srv->srv_funcs;
214: srv->srv_funcs = func;
215: pthread_mutex_unlock(&srv->srv_mtx);
216: return 0;
217: }
218:
219: /*
220: * rpc_srv_unregisterCall() Unregister call from RPC server
221: * @srv = RPC Server instance
222: * @csModule = Module name, if NULL self binary
223: * @csFunc = Function name
224: * return: -1 error, 0 not found call, 1 unregister ok
225: */
226: int
227: rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc)
228: {
229: rpc_func_t func, *f, *curr;
230: u_char str[MAXPATHLEN + UCHAR_MAX + 1];
231:
232: memset(&func, 0, sizeof(rpc_func_t));
1.4 misho 233: memset(str, 0, sizeof str);
1.2 misho 234: if (!srv || !csFunc) {
235: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t unregister function from RPC server ...\n");
236: return -1;
237: } else
1.4 misho 238: strlcpy((char*) func.func_name, csFunc, sizeof func.func_name);
1.2 misho 239: if (csModule) {
1.4 misho 240: strlcpy((char*) func.func_file, csModule, sizeof func.func_file);
241: strlcpy((char*) str, csModule, sizeof str);
1.2 misho 242: }
1.4 misho 243: strlcat((char*) str, "__", sizeof str);
244: strlcat((char*) str, csFunc, sizeof str);
1.2 misho 245:
1.4 misho 246: func.func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
247: func.func_hash = hash_fnv((char*) str, sizeof str);
1.2 misho 248:
249: f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);
1.3 misho 250: if (!f) /* not found element for unregister */
1.2 misho 251: return 0;
252:
253: pthread_mutex_lock(&srv->srv_mtx);
1.3 misho 254: if (srv->srv_funcs == f) { /* if is 1st element */
1.2 misho 255: srv->srv_funcs = srv->srv_funcs->func_next;
256:
1.4 misho 257: if (f->func_args && f->func_vars)
258: free(f->func_vars);
1.2 misho 259: free(f);
260: } else {
261: for (curr = srv->srv_funcs; curr->func_next != f; curr = curr->func_next);
262: curr->func_next = curr->func_next->func_next;
263:
1.4 misho 264: if (f->func_args && f->func_vars)
265: free(f->func_vars);
1.2 misho 266: free(f);
267: }
268: pthread_mutex_unlock(&srv->srv_mtx);
269:
270: return 1;
271: }
272:
273: /*
274: * rpc_srv_getCall() Get registered call from RPC server
275: * @srv = RPC Server instance
276: * @tag = tag for function
277: * @hash = hash for function
278: * return: NULL not found call, !=NULL return call
279: */
280: inline rpc_func_t *
281: rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag, uint32_t hash)
282: {
283: rpc_func_t *f;
284:
285: if (!srv) {
286: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get function from RPC server ...\n");
287: return NULL;
288: }
289:
290: for (f = srv->srv_funcs; f; f = f->func_next)
291: if (f->func_tag == tag && f->func_hash == hash)
292: break;
293:
294: return f;
295: }
296:
297: /*
298: * rpc_srv_getFunc() Get registered call from RPC server by Name
299: * @srv = RPC Server instance
300: * @csModule = Module name, if NULL self binary
301: * @csFunc = Function name
302: * return: NULL not found call, !=NULL return call
303: */
304: rpc_func_t *
305: rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc)
306: {
307: rpc_func_t func;
308: u_char str[MAXPATHLEN + UCHAR_MAX + 1];
309:
310: memset(&func, 0, sizeof(rpc_func_t));
1.4 misho 311: memset(str, 0, sizeof str);
1.2 misho 312: if (!srv || !csFunc) {
313: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get function from RPC server ...\n");
314: return NULL;
315: } else
1.4 misho 316: strlcpy((char*) func.func_name, csFunc, sizeof func.func_name);
1.2 misho 317: if (csModule) {
1.4 misho 318: strlcpy((char*) func.func_file, csModule, sizeof func.func_file);
319: strlcpy((char*) str, csModule, sizeof str);
1.2 misho 320: }
1.4 misho 321: strlcat((char*) str, "__", sizeof str);
322: strlcat((char*) str, csFunc, sizeof str);
1.2 misho 323:
1.4 misho 324: func.func_tag = crcFletcher16((u_short*) str, sizeof str / 2);
325: func.func_hash = hash_fnv((char*) str, sizeof str);
1.2 misho 326:
327: return rpc_srv_getCall(srv, func.func_tag, func.func_hash);
328: }
329:
330: // ---------------------------------------------------------
331:
332: /*
333: * rpc_srv_getBLOB() Get registered BLOB
334: * @srv = RPC Server instance
335: * @var = hash for variable
336: * return: NULL not found, !=NULL return blob var
337: */
338: inline rpc_blob_t *
339: rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var)
340: {
341: rpc_blob_t *b;
342:
343: if (!srv) {
344: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get variable from BLOB server ...\n");
345: return NULL;
346: }
347:
348: pthread_mutex_lock(&srv->srv_blob.mtx);
349: for (b = srv->srv_blob.blobs; b; b = b->blob_next) {
350: if (b->blob_var == var)
351: break;
352: }
353: pthread_mutex_unlock(&srv->srv_blob.mtx);
354:
355: return b;
356: }
357:
358: /*
359: * rpc_srv_registerBLOB() Register new BLOB to server
360: * @srv = RPC Server instance
361: * @len = BLOB length
362: * return: NULL error or new registered BLOB
363: */
364: rpc_blob_t *
365: rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len)
366: {
367: rpc_blob_t *blob = NULL;
368:
369: if (!srv || !len) {
370: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t register BLOB to server ...\n");
371: return blob;
372: }
373:
374: blob = rpc_srv_blobCreate(srv, len);
375: if (blob) {
376: pthread_mutex_lock(&srv->srv_blob.mtx);
377: blob->blob_next = srv->srv_blob.blobs;
378: srv->srv_blob.blobs = blob;
379: pthread_mutex_unlock(&srv->srv_blob.mtx);
380: }
381:
382: return blob;
383: }
384:
385: /*
386: * rpc_srv_unregisterBLOB() Unregister BLOB from server
387: * @srv = RPC Server instance
388: * @var = BLOB Variable for unregister
389: * return: -1 error, 0 not found call, 1 unregister ok
390: */
391: int
392: rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var)
393: {
394: rpc_blob_t *b, *curr;
395:
396: if (!srv) {
397: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t unregister BLOB from server ...\n");
398: return -1;
399: }
400:
401: b = rpc_srv_getBLOB(srv, var);
1.3 misho 402: if (!b) /* not found element for unregister */
1.2 misho 403: return 0;
404:
405: pthread_mutex_lock(&srv->srv_blob.mtx);
1.3 misho 406: if (srv->srv_blob.blobs == b) { /* if is 1st element */
1.2 misho 407: srv->srv_blob.blobs = srv->srv_blob.blobs->blob_next;
408: } else {
409: for (curr = srv->srv_blob.blobs; curr->blob_next != b; curr = curr->blob_next);
410: curr->blob_next = curr->blob_next->blob_next;
411: }
412: rpc_srv_blobFree(srv, b);
413: free(b);
414: pthread_mutex_unlock(&srv->srv_blob.mtx);
415:
416: return 1;
417: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lists.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / src