--- libaitrpc/inc/aitrpc.h 2010/06/18 01:48:06 1.1.1.1 +++ libaitrpc/inc/aitrpc.h 2010/06/23 16:44:24 1.1.1.1.2.8 @@ -3,7 +3,7 @@ * by Michael Pounov * * $Author: misho $ -* $Id: aitrpc.h,v 1.1.1.1 2010/06/18 01:48:06 misho Exp $ +* $Id: aitrpc.h,v 1.1.1.1.2.8 2010/06/23 16:44:24 misho Exp $ * *************************************************************************/ #ifndef __AITRPC_H @@ -19,14 +19,17 @@ #include -#define STRSIZ 256 - #define RPC_VERSION 1 #define RPC_DEFPORT 2611 /* RPC builtin registed calls */ +#define CALL_BLOBSHUTDOWN "rpcBLOBServerShutdown" +#define CALL_BLOBCLIENTS "rpcBLOBServerClients" +#define CALL_BLOBVARS "rpcBLOBServerVars" + +#define CALL_SRVSHUTDOWN "rpcServerShutdown" #define CALL_SRVCLIENTS "rpcServerClients" #define CALL_SRVCALLS "rpcServerCalls" #define CALL_SRVSESSIONS "rpcServerSessions" @@ -36,13 +39,19 @@ typedef enum { empty, // empty -> variable is not set - buffer, string, array, // buffer -> uint8_t*; string -> int8_t*; array -> char**; + buffer, string, blob, // buffer -> uint8_t*; string -> int8_t*; blob -> void*(+socket); size, offset, datetime, // size -> size_t; offset -> off_t; datetime -> time_t; real, bigreal, // real -> float; bigreal -> double; u8, u16, u32, u64, // unsigned integers ... i8, i16, i32, i64 // integers ... } rpc_type_t; +typedef enum { + disable, enable, // for blob.state + ok, error, // for blob reply + get, set, unset // for blob request +} cmd_type_t; + /* RPC value */ typedef struct { @@ -51,7 +60,7 @@ typedef struct { union { uint8_t *buffer; int8_t *string; - int8_t **array; + void *blob; size_t size; off_t offset; time_t datetime; @@ -70,11 +79,12 @@ typedef struct { #define RPC_TYPE_VAL(vl) ((vl)->val_type) #define RPC_LEN_VAL(vl) ((vl)->val_len) +#define RPC_BLOB_CHUNKS(vl, n) ((vl)->val_len / (n) + ((vl)->val_len % (n)) ? 1 : 0) #define RPC_EMPTY_VAL(vl) ((vl)->val_type == empty) #define RPC_GET_BUF(vl) (assert((vl)->val_type == buffer), (vl)->val.buffer) #define RPC_GET_STR(vl) (assert((vl)->val_type == string), (vl)->val.string) -#define RPC_GET_ARRAY(vl) (assert((vl)->val_type == array), (vl)->val.array) +#define RPC_GET_BLOB(vl) (assert((vl)->val_type == blob), (vl)->val.blob) #define RPC_GET_SIZE(vl) (assert((vl)->val_type == size), (vl)->val.size) #define RPC_GET_OFF(vl) (assert((vl)->val_type == offset), (vl)->val.offset) #define RPC_GET_TIME(vl) (assert((vl)->val_type == datetime), (vl)->val.datetime) @@ -98,10 +108,10 @@ typedef struct { if (val->val.string) { \ val->val_type = string; val->val_len = strlen(v) + 1; \ } } while (0) -#define RPC_SET_ARRAY(vl, v, n, l) do { rpc_val_t *val = (vl); assert(val); val->val.array = calloc(n, l); \ - if (val->val.array) { \ - val->val_type = array; val->val_len = n * l; \ - memcpy(val->val.array, v, val->val_len); \ +#define RPC_SET_BLOB(vl, v, l) do { rpc_val_t *val = (vl); assert(val); val->val.blob = realloc(val->val.blob, l); \ + if (val->val.blob) { \ + val->val_type = blob; val->val_len = l; \ + memcpy(val->val.blob, v, l); \ } } while (0) #define RPC_SET_SIZE(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = size; val->val.size = v; \ val->val_len = sizeof(size_t); } while (0) @@ -139,20 +149,26 @@ typedef struct { free(val->val.string); \ val->val.string = NULL; \ } \ - if (val->val_type == array && val->val.array) { \ - free(val->val.array); \ - val->val.array = NULL; \ + if (val->val_type == blob && val->val.blob) { \ + free(val->val.blob); \ + val->val.blob = NULL; \ } \ val->val_type = val->val_len = 0; \ } while (0) -#define RPC_CALLBACK_CHECK_ARGS(f, n) do { \ +#define RPC_CALLBACK_CHK_NUM_ARGS(f, n) do { \ if (f->func_args != n) { \ rpc_SetErr(22, "Error:: different number of arguments!\n"); \ return -1; \ } \ - } while(0) + } while (0) +#define RPC_CALLBACK_CHECK_INPUT(s, f) do { \ + if (!s || !f) { \ + rpc_SetErr(22, "Error:: invalid callback parameters ...\n"); \ + return -1; \ + } \ + } while (0) /* RPC session identification */ @@ -200,6 +216,16 @@ struct tagRPCRet { uint8_t ret_argc; } __packed; +/* Network BLOB packet - Header */ + +struct tagBLOBHdr { + rpc_sess_t hdr_session; + uint8_t hdr_cmd; + uint32_t hdr_var; + uint32_t hdr_seq; + uint32_t hdr_len; +} __packed; + /* Network RPC client & server elements */ typedef struct { @@ -210,15 +236,39 @@ typedef struct { void *cli_parent; // pointer to parent rpc_srv_t for server or to rpc_sess_t for client } rpc_cli_t; + +// BLOB registration element! +typedef struct tagBLOB { + uint32_t blob_var; + + size_t blob_len; // size of allocated BLOB data + void *blob_data; // BLOB data + + struct tagBLOB *blob_next; +} rpc_blob_t; + typedef struct { + rpc_sess_t srv_session; // RPC session registration info int srv_numcli; // maximum concurent client connections - rpc_cli_t srv_server; // server socket - rpc_sess_t srv_session; // RPC session registration info + rpc_cli_t srv_server; // RPC server socket + rpc_cli_t *srv_clients; // connected rpc client sockets - rpc_cli_t *srv_clients; // connected client sockets - rpc_func_t *srv_funcs; // registered functions list + + pthread_mutex_t srv_mtx; + + struct { + int state; // BLOB server state: ==0 disable | !=0 enable + char dir[UCHAR_MAX + 1]; + + rpc_cli_t server; // BLOB server socket + rpc_cli_t *clients; // connected blob client sockets + + rpc_blob_t *blobs; // registered blob variables list + + pthread_mutex_t mtx; + } srv_blob; } rpc_srv_t; @@ -263,6 +313,34 @@ void rpc_srv_endServer(rpc_srv_t * __restrict srv); int rpc_srv_execServer(rpc_srv_t * __restrict srv); /* + * rpc_srv_initBLOBServer() Init & create BLOB Server + * @Port = Port for bind server, if Port == 0 default port is selected + * @diskDir = Disk place for BLOB file objects + * return: -1 == error or 0 bind and created BLOB server instance + */ +int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_short Port, const char *diskDir); +/* + * rpc_srv_endBLOBServer() Destroy BLOB server, close all opened sockets and free resources + * @srv = RPC Server instance + * return: none + */ +void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv); +/* + * rpc_srv_execBLOBServer() Execute Main BLOB server loop and wait for clients requests + * @srv = RPC Server instance + * return: -1 error or 0 ok, infinite loop ... + */ +int rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv); + +/* + * rpc_srv_getBLOB() Get registered BLOB + * @srv = RPC Server instance + * @var = hash for variable + * return: NULL not found, !=NULL return blob var + */ +inline rpc_blob_t *rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var); + +/* * rpc_srv_registerCall() Register call to RPC server * @srv = RPC Server instance * @csModule = Module name, if NULL self binary @@ -341,6 +419,28 @@ inline int rpc_srv_delValsCall(rpc_func_t * __restrict * return: -1 error, !=-1 Number of returned variables */ inline int rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict vals); + + +/* + * rpc_srv_blobMap() Map blob to memory region + * @srv = RPC Server instance + * @blob = Map to this BLOB element + * return: -1 error or 0 ok + */ +inline int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob); +/* + * rpc_srv_blobUnmap() Unmap blob memory region + * @blob = Mapped BLOB element + * return: none + */ +inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob); +/* + * rpc_srv_blobFree() Free blob from disk & memory + * @srv = RPC Server instance + * @blob = Mapped BLOB element + * return: -1 error or 0 ok + */ +inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob); /* RPC Client side functions */