1: #include "global.h"
2:
3:
4: /*
5: * rpc_srv_freeValsCall() Free return variables for RPC call
6: * @call = RPC function call
7: * return: none
8: */
9: inline void
10: rpc_srv_freeValsCall(rpc_func_t * __restrict call)
11: {
12: rpc_srv_declValsCall(call, 0);
13: }
14:
15: /*
16: * rpc_srv_declValsCall() Declare return variables for RPC call
17: * @call = RPC function call
18: * @return_vals = Number of return variables
19: * return: -1 error, !=-1 ok
20: */
21: inline int
22: rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals)
23: {
24: void *ptr;
25:
26: if (!call || return_vals < 0) {
27: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t declare return variables for RPC call...\n");
28: return -1;
29: } else
30: call->func_args = return_vals;
31:
32: if (!return_vals) {
33: if (call->func_vals) {
34: free(call->func_vals);
35: call->func_vals = NULL;
36: }
37: } else {
38: ptr = realloc(call->func_vals, return_vals * sizeof(rpc_val_t));
39: if (!ptr) {
40: LOGERR;
41: return -1;
42: } else
43: call->func_vals = ptr;
44: }
45:
46: return call->func_args;
47: }
48:
49: /*
50: * rpc_srv_delValsCall() Clean values from return variables of RPC call
51: * @call = RPC function call
52: * return: -1 error, !=-1 Returned number of cleaned RPC variables
53: */
54: inline int
55: rpc_srv_delValsCall(rpc_func_t * __restrict call)
56: {
57: if (!call) {
58: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t delete return variables ...\n");
59: return -1;
60: }
61:
62: memset(call->func_vals, 0, call->func_args * sizeof(rpc_val_t));
63: return call->func_args;
64: }
65:
66: /*
67: * rpc_srv_copyValsCall() Copy return variables for RPC call to new variable
68: * @call = RPC function call
69: * @newvals = New allocated variables array, must be free after use
70: * return: -1 error, !=-1 Returned number of copied RPC variables
71: */
72: inline int
73: rpc_srv_copyValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvals)
74: {
75: if (!call || !newvals) {
76: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t copy return variables to new array\n");
77: return -1;
78: }
79:
80: *newvals = calloc(call->func_args, sizeof(rpc_val_t));
81: if (!*newvals) {
82: LOGERR;
83: return -1;
84: } else
85: memcpy(*newvals, call->func_vals, call->func_args * sizeof(rpc_val_t));
86:
87: return call->func_args;
88: }
89:
90: /*
91: * rpc_srv_getValsCall() Get return variables for RPC call
92: * @call = RPC function call
93: * @vals = Returned variables, may be NULL
94: * return: -1 error, !=-1 Number of returned variables
95: */
96: inline int
97: rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict vals)
98: {
99: if (!call) {
100: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get return variables ...\n");
101: return -1;
102: }
103:
104: if (vals)
105: *vals = call->func_vals;
106: return call->func_args;
107: }
108:
109: // ---------------------------------------------------------
110:
111: /*
112: * rpc_srv_registerCall() Register call to RPC server
113: * @srv = RPC Server instance
114: * @csModule = Module name, if NULL self binary
115: * @csFunc = Function name
116: * @args = Number of function arguments
117: * return: -1 error or 0 register ok
118: */
119: int
120: rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, u_char args)
121: {
122: rpc_func_t *func;
123: u_char str[MAXPATHLEN + UCHAR_MAX + 1];
124:
125: memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);
126: if (!srv || !csFunc) {
127: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t register function to RPC server ...\n");
128: return -1;
129: }
130: if (!(func = malloc(sizeof(rpc_func_t)))) {
131: LOGERR;
132: return -1;
133: } else {
134: memset(func, 0, sizeof(rpc_func_t));
135: strlcpy((char*) func->func_name, csFunc, UCHAR_MAX + 1);
136: }
137: if (csModule) {
138: strlcpy((char*) func->func_file, csModule, MAXPATHLEN);
139: strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);
140: }
141: strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);
142: strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);
143:
144: func->func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);
145: func->func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);
146:
147: if (rpc_srv_declValsCall(func, args) == -1) {
148: free(func);
149: return -1;
150: }
151:
152: pthread_mutex_lock(&srv->srv_mtx);
153: func->func_next = srv->srv_funcs;
154: srv->srv_funcs = func;
155: pthread_mutex_unlock(&srv->srv_mtx);
156: return 0;
157: }
158:
159: /*
160: * rpc_srv_unregisterCall() Unregister call from RPC server
161: * @srv = RPC Server instance
162: * @csModule = Module name, if NULL self binary
163: * @csFunc = Function name
164: * return: -1 error, 0 not found call, 1 unregister ok
165: */
166: int
167: rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc)
168: {
169: rpc_func_t func, *f, *curr;
170: u_char str[MAXPATHLEN + UCHAR_MAX + 1];
171:
172: memset(&func, 0, sizeof(rpc_func_t));
173: memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);
174: if (!srv || !csFunc) {
175: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t unregister function from RPC server ...\n");
176: return -1;
177: } else
178: strlcpy((char*) func.func_name, csFunc, UCHAR_MAX + 1);
179: if (csModule) {
180: strlcpy((char*) func.func_file, csModule, MAXPATHLEN);
181: strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);
182: }
183: strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);
184: strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);
185:
186: func.func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);
187: func.func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);
188:
189: f = rpc_srv_getCall(srv, func.func_tag, func.func_hash);
190: if (!f) // not found element for unregister
191: return 0;
192:
193: pthread_mutex_lock(&srv->srv_mtx);
194: if (srv->srv_funcs == f) { // if is 1st element
195: srv->srv_funcs = srv->srv_funcs->func_next;
196:
197: if (f->func_args && f->func_vals)
198: free(f->func_vals);
199: free(f);
200: } else {
201: for (curr = srv->srv_funcs; curr->func_next != f; curr = curr->func_next);
202: curr->func_next = curr->func_next->func_next;
203:
204: if (f->func_args && f->func_vals)
205: free(f->func_vals);
206: free(f);
207: }
208: pthread_mutex_unlock(&srv->srv_mtx);
209:
210: return 1;
211: }
212:
213: /*
214: * rpc_srv_getCall() Get registered call from RPC server
215: * @srv = RPC Server instance
216: * @tag = tag for function
217: * @hash = hash for function
218: * return: NULL not found call, !=NULL return call
219: */
220: inline rpc_func_t *
221: rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag, uint32_t hash)
222: {
223: rpc_func_t *f;
224:
225: if (!srv) {
226: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get function from RPC server ...\n");
227: return NULL;
228: }
229:
230: for (f = srv->srv_funcs; f; f = f->func_next)
231: if (f->func_tag == tag && f->func_hash == hash)
232: break;
233:
234: return f;
235: }
236:
237: /*
238: * rpc_srv_getFunc() Get registered call from RPC server by Name
239: * @srv = RPC Server instance
240: * @csModule = Module name, if NULL self binary
241: * @csFunc = Function name
242: * return: NULL not found call, !=NULL return call
243: */
244: rpc_func_t *
245: rpc_srv_getFunc(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc)
246: {
247: rpc_func_t func;
248: u_char str[MAXPATHLEN + UCHAR_MAX + 1];
249:
250: memset(&func, 0, sizeof(rpc_func_t));
251: memset(str, 0, MAXPATHLEN + UCHAR_MAX + 1);
252: if (!srv || !csFunc) {
253: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get function from RPC server ...\n");
254: return NULL;
255: } else
256: strlcpy((char*) func.func_name, csFunc, UCHAR_MAX + 1);
257: if (csModule) {
258: strlcpy((char*) func.func_file, csModule, MAXPATHLEN);
259: strlcpy((char*) str, csModule, MAXPATHLEN + UCHAR_MAX + 1);
260: }
261: strlcat((char*) str, "__", MAXPATHLEN + UCHAR_MAX + 1);
262: strlcat((char*) str, csFunc, MAXPATHLEN + UCHAR_MAX + 1);
263:
264: func.func_tag = crcFletcher16((u_short*) str, (MAXPATHLEN + UCHAR_MAX + 1) / 2);
265: func.func_hash = hash_fnv((char*) str, MAXPATHLEN + UCHAR_MAX + 1);
266:
267: return rpc_srv_getCall(srv, func.func_tag, func.func_hash);
268: }
269:
270: // ---------------------------------------------------------
271:
272: /*
273: * rpc_srv_getBLOB() Get registered BLOB
274: * @srv = RPC Server instance
275: * @var = hash for variable
276: * return: NULL not found, !=NULL return blob var
277: */
278: inline rpc_blob_t *
279: rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var)
280: {
281: rpc_blob_t *b;
282:
283: if (!srv) {
284: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t get variable from BLOB server ...\n");
285: return NULL;
286: }
287:
288: for (b = srv->srv_blob.blobs; b; b = b->blob_next)
289: if (b->blob_var == var)
290: break;
291:
292: return b;
293: }
294:
295: /*
296: * rpc_srv_registerBLOB() Register new BLOB to server
297: * @srv = RPC Server instance
298: * @len = BLOB length
299: * return: -1 error or 0 register ok
300: */
301: rpc_blob_t *
302: rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len)
303: {
304: rpc_blob_t *blob = NULL;
305:
306: if (!srv || !len) {
307: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t register BLOB to server ...\n");
308: return blob;
309: }
310:
311: blob = rpc_srv_blobCreate(srv, len);
312: if (blob) {
313: pthread_mutex_lock(&srv->srv_blob.mtx);
314: blob->blob_next = srv->srv_blob.blobs;
315: srv->srv_blob.blobs = blob;
316: pthread_mutex_unlock(&srv->srv_blob.mtx);
317: }
318:
319: return blob;
320: }
321:
322: /*
323: * rpc_srv_unregisterBLOB() Unregister BLOB from server
324: * @srv = RPC Server instance
325: * @var = BLOB Variable for unregister
326: * return: -1 error, 0 not found call, 1 unregister ok
327: */
328: int
329: rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var)
330: {
331: rpc_blob_t *b, *curr;
332:
333: if (!srv) {
334: rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t unregister BLOB from server ...\n");
335: return -1;
336: }
337:
338: b = rpc_srv_getBLOB(srv, var);
339: if (!b) // not found element for unregister
340: return 0;
341:
342: pthread_mutex_lock(&srv->srv_blob.mtx);
343: if (srv->srv_blob.blobs == b) { // if is 1st element
344: srv->srv_blob.blobs = srv->srv_blob.blobs->blob_next;
345: } else {
346: for (curr = srv->srv_blob.blobs; curr->blob_next != b; curr = curr->blob_next);
347: curr->blob_next = curr->blob_next->blob_next;
348: }
349: rpc_srv_blobFree(srv, b);
350: free(b);
351: pthread_mutex_unlock(&srv->srv_blob.mtx);
352:
353: return 1;
354: }
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