Annotation of libaitrpc/src/lists.c, revision 1.1.2.2
1.1.2.1 misho 1: #include "global.h"
2:
3:
1.1.2.2 ! misho 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:
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