libaitrpc/inc/aitrpc.h - diff

Return to aitrpc.h CVS log

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

Diff for /libaitrpc/inc/aitrpc.h between versions 1.2.4.3 and 1.11

version 1.2.4.3, 2011/08/18 21:20:54	version 1.11, 2012/11/13 09:22:10
Line 12 terms:	Line 12 terms:
All of the documentation and software included in the ELWIX and AITNET	All of the documentation and software included in the ELWIX and AITNET
Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>	Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>

Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011	Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
by Michael Pounov <misho@elwix.org>. All rights reserved.	by Michael Pounov <misho@elwix.org>. All rights reserved.

Redistribution and use in source and binary forms, with or without	Redistribution and use in source and binary forms, with or without
Line 50 SUCH DAMAGE.	Line 50 SUCH DAMAGE.
#include <assert.h>	#include <assert.h>
#include <stdlib.h>	#include <stdlib.h>
#include <string.h>	#include <string.h>
	#include <errno.h>
#include <sys/types.h>	#include <sys/types.h>
#include <sys/param.h>	#include <sys/param.h>
#if !defined(__NetBSD__)	#if !defined(__NetBSD__)
#include <sys/limits.h>	#include <sys/limits.h>
#endif	#endif
#include <sys/socket.h>	#include <sys/socket.h>
	#include <sys/queue.h>
	#include <aitio.h>
	#include <aitsched.h>


#define RPC_VERSION 1	#define RPC_VERSION 4
#define RPC_DEFPORT 2611	#define RPC_DEFPORT 2611

	/* RPC call request flags */

	#define RPC_REPLY 0x0
	#define RPC_NOREPLY 0x1

/* RPC builtin registed calls */	/* RPC builtin registed calls */

#define CALL_BLOBSHUTDOWN "rpcBLOBServerShutdown"	#define CALL_TAG_MAX 65535
#define CALL_BLOBCLIENTS "rpcBLOBServerClients"
#define CALL_BLOBVARS "rpcBLOBServerVars"
#define CALL_BLOBSTATE "rpcBLOBServerState"

#define CALL_SRVSHUTDOWN "rpcServerShutdown"	#define CALL_SRVPING 65534
#define CALL_SRVCLIENTS "rpcServerClients"
#define CALL_SRVCALLS "rpcServerCalls"
#define CALL_SRVSESSIONS "rpcServerSessions"

	#define CALL_SRVSHUTDOWN 65533
	#define CALL_SRVCLIENTS 65532
	#define CALL_SRVCALLS 65531
	#define CALL_SRVSESSIONS 65530

	#define CALL_BLOBSHUTDOWN 65529
	#define CALL_BLOBCLIENTS 65528
	#define CALL_BLOBVARS 65527


/* RPC types */	/* RPC types */

typedef enum {	typedef enum {
empty, // empty -> variable is not set	ok, error, no, /* for blob reply */
buffer, string, blob, // buffer -> uint8_t; string -> int8_t; blob -> void*(+socket);	get, set, unset /* for blob request */
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;	} cmd_type_t;

/* RPC value */

typedef struct {
rpc_type_t val_type;
size_t val_len;
union {
uint8_t *buffer;
int8_t *string;
uint32_t blob;
size_t size;
off_t offset;
time_t datetime;
float real;
double bigreal;
uint8_t u8;
uint16_t u16;
uint32_t u32;
uint64_t u64;
int8_t i8;
int16_t i16;
int32_t i32;
int64_t i64;
} val;
} __packed rpc_val_t;

#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_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)
#define RPC_GET_REAL(vl) (assert((vl)->val_type == real), (vl)->val.real)
#define RPC_GET_BREAL(vl) (assert((vl)->val_type == bigreal), (vl)->val.bigreal)
#define RPC_GET_U8(vl) (assert((vl)->val_type == u8), (vl)->val.u8)
#define RPC_GET_U16(vl) (assert((vl)->val_type == u16), (vl)->val.u16)
#define RPC_GET_U32(vl) (assert((vl)->val_type == u32), (vl)->val.u32)
#define RPC_GET_U64(vl) (assert((vl)->val_type == u64), (vl)->val.u64)
#define RPC_GET_I8(vl) (assert((vl)->val_type == i8), (vl)->val.i8)
#define RPC_GET_I16(vl) (assert((vl)->val_type == i16), (vl)->val.i16)
#define RPC_GET_I32(vl) (assert((vl)->val_type == i32), (vl)->val.i32)
#define RPC_GET_I64(vl) (assert((vl)->val_type == i64), (vl)->val.i64)

#define RPC_SET_BUF(vl, v, l) do { rpc_val_t *val = (vl); assert(val); val->val.buffer = malloc(l); \
if (val->val.buffer) { \
val->val_type = buffer; val->val_len = l; \
memcpy(val->val.buffer, v, l); \
} } while (0)
#define RPC_SET_STR(vl, v) do { rpc_val_t val = (vl); assert(val); val->val.string = (int8_t) strdup(v); \
if (val->val.string) { \
val->val_type = string; val->val_len = strlen(v) + 1; \
} } while (0)
#define RPC_SET_BLOB(vl, v, l) do { rpc_val_t *val = (vl); assert(val); val->val_type = blob; \
val->val.blob = v; val->val_len = l; } while (0)
#define RPC_SET_BLOB2(vl, b) do { rpc_val_t *val = (vl); assert(val); assert(b); val->val_type = blob; \
val->val.blob = b->blob_var; val->val_len = b->blob_len; } 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)
#define RPC_SET_OFF(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = offset; val->val.offset = v; \
val->val_len = sizeof(off_t); } while (0)
#define RPC_SET_TIME(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = datetime; val->val.datetime = v; \
val->val_len = sizeof(time_t); } while (0)
#define RPC_SET_REAL(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = real; val->val.real = v; \
val->val_len = sizeof(float); } while (0)
#define RPC_SET_BREAL(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = bigreal; val->val.bigreal = v; \
val->val_len = sizeof(double); } while (0)
#define RPC_SET_U8(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = u8; val->val.u8 = v; \
val->val_len = sizeof(uint8_t); } while (0)
#define RPC_SET_U16(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = u16; val->val.u16 = v; \
val->val_len = sizeof(uint16_t); } while (0)
#define RPC_SET_U32(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = u32; val->val.u32 = v; \
val->val_len = sizeof(uint32_t); } while (0)
#define RPC_SET_U64(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = u64; val->val.u64 = v; \
val->val_len = sizeof(uint64_t); } while (0)
#define RPC_SET_I8(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = i8; val->val.i8 = v; \
val->val_len = sizeof(int8_t); } while (0)
#define RPC_SET_I16(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = i16; val->val.i16 = v; \
val->val_len = sizeof(int16_t); } while (0)
#define RPC_SET_I32(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = i32; val->val.i32 = v; \
val->val_len = sizeof(int32_t); } while (0)
#define RPC_SET_I64(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = i64; val->val.i64 = v; \
val->val_len = sizeof(int64_t); } while (0)

#define RPC_FREE_VAL(vl) do { rpc_val_t *val = (vl); assert(val); \
if (val->val_type == buffer && val->val.buffer) { \
free(val->val.buffer); \
val->val.buffer = NULL; \
} \
if (val->val_type == string && val->val.string) { \
free(val->val.string); \
val->val.string = NULL; \
} \
val->val_type = val->val_len = 0; \
} while (0)


#define RPC_CALLBACK_CHECK_INPUT(x) do { \	#define RPC_CALLBACK_CHECK_INPUT(x) do { \
if (!x) { \	assert((x)); \
rpc_SetErr(22, "Error:: invalid callback parameters ...\n"); \	if (!(x)) { \
	rpc_SetErr(EINVAL, \
	"Invalid callback parameters ..."); \
return -1; \	return -1; \
} \	} \
} while (0)	} while (0)
#define RPC_CALLBACK_CHK_ARGS(f, n) do { \
RPC_CALLBACK_CHECK_INPUT(f); \
if (f && f->func_args != n) { \
rpc_SetErr(22, "Error:: different number of arguments!\n"); \
return -1; \
} \
} while (0)


/* RPC session identification */	/* RPC session identification */
Line 212 typedef struct {	Line 109 typedef struct {
typedef struct {	typedef struct {
uint8_t sess_version;	uint8_t sess_version;
uint32_t sess_program;	uint32_t sess_program;
uint32_t sess_process;	uint8_t sess_process;
} __packed rpc_sess_t;	} __packed rpc_sess_t; /* size == 6 bytes */


/* Server managment RPC functions ... */	/* Server managment RPC functions ... */

// RPC function registration element!
typedef struct tagRPCFunc {
uint16_t func_tag;
uint32_t func_hash;
int8_t func_file[MAXPATHLEN];
int8_t func_name[UCHAR_MAX + 1];

int8_t func_args;
rpc_val_t *func_vals;

void *func_parent;
struct tagRPCFunc *func_next;
} rpc_func_t;


/* Network RPC packet - Client request */	/* Network RPC packet - Client request */

struct tagRPCCall {	struct tagRPCCall {
rpc_sess_t call_session;	rpc_sess_t call_session;
uint16_t call_tag;
uint32_t call_hash;
uint8_t call_argc;
} __packed;

/* Network RPC packet - Server response */	uint16_t call_seq;
	uint16_t call_len;
	uint16_t call_crc;

struct tagRPCRet {	union {
rpc_sess_t ret_session;	struct {
uint16_t ret_tag;	uint64_t flags;
uint32_t ret_hash;	} call_req;
int32_t ret_retcode;	struct {
int32_t ret_errno;	int32_t ret;
uint8_t ret_argc;	int32_t eno;
} __packed;	} call_rep;
	};

	uint16_t call_tag;
	uint16_t call_argc;
	ait_val_t call_argv[0];
	} __packed; /* size == 24 bytes */
	#define RPC_CHK_NOREPLY(x) ((x)->call_req.flags & RPC_NOREPLY)

/* Network BLOB packet - Header */	/* Network BLOB packet - Header */

struct tagBLOBHdr {	struct tagBLOBHdr {
Line 261 struct tagBLOBHdr {	Line 148 struct tagBLOBHdr {
uint32_t hdr_var;	uint32_t hdr_var;
uint32_t hdr_len;	uint32_t hdr_len;
uint32_t hdr_ret;	uint32_t hdr_ret;
} __packed;	uint16_t hdr_crc;
	uint8_t hdr_pad;
	} __packed; /* size == 22 bytes */

/* Network RPC client & server elements */	/* Network RPC client & server elements */

typedef struct {	/* RPC function registration element! */
struct sockaddr cli_sa; // host info	typedef struct tagRPCFunc {
int cli_sock; // socket fd	ait_val_t func_name;
int cli_type; // socket type
pthread_t cli_tid; // TID of thread

void *cli_parent; // pointer to parent rpc_srv_t for server or to rpc_sess_t for client	void *func_parent;
} rpc_cli_t;

	SLIST_ENTRY(tagRPCFunc) func_next;
	AVL_ENTRY(tagRPCFunc) func_node;
	} rpc_func_t;
	#define RPC_FUNC_SERVER(x) ((rpc_srv_t*) (x)->func_parent)

// BLOB registration element!	/* Tree root node */
	typedef struct tagRPCFuncs {
	pthread_mutex_t mtx;

	struct tagRPCFunc *slh_first;
	struct tagRPCFunc *avlh_root;
	} rpc_funcs_t;
	#define RPC_FUNCS_LOCK(x) pthread_mutex_lock(&(x)->mtx)
	#define RPC_FUNCS_UNLOCK(x) pthread_mutex_unlock(&(x)->mtx)
	#define RPC_FUNCS_ISEMPTY(x) AVL_EMPTY((x))


	/* BLOB register element */
typedef struct tagBLOB {	typedef struct tagBLOB {
uint32_t blob_var;	uint32_t blob_var; /* BLOB id */

size_t blob_len; // size of allocated BLOB data	size_t blob_len; /* size of allocated BLOB data */
void *blob_data; // BLOB data	void blob_data; / mapped BLOB data */

struct tagBLOB *blob_next;	TAILQ_ENTRY(tagBLOB) blob_node;
} rpc_blob_t;	} rpc_blob_t;


typedef struct {	typedef struct {
rpc_sess_t srv_session; // RPC session registration info	int cli_id; /* slot id */
int srv_numcli; // maximum concurent client connections	int cli_sock; /* socket fd */
	io_sockaddr_t cli_sa; /* host address */
	ait_val_t cli_buf; /* network buffer */

rpc_cli_t srv_server; // RPC server socket	array_t cli_vars; / function return variables */
rpc_cli_t *srv_clients; // connected rpc client sockets

rpc_func_t *srv_funcs; // registered functions list	void cli_parent; / pointer to parent rpc_srv_t for server or to rpc_sess_t for client */
	} rpc_cli_t;
	#define RPC_RETVARS(x) ((x)->cli_vars)
	#define RPC_SRV_SERVER(x) ((rpc_srv_t*) (x)->cli_parent)
	#define RPC_CLI_SESSION(x) ((rpc_sess_t*) (x)->cli_parent)

pthread_mutex_t srv_mtx;	typedef struct {
	rpc_sess_t srv_session; /* RPC session registration info */
	int srv_netbuf; /* size of network buffer */

	pthread_t srv_tid; /* RPC exec pthread */
	sched_root_task_t srv_root; / RPC server scheduler */
	intptr_t srv_kill; /* Scheduler condition variable */

	rpc_cli_t srv_server; /* RPC server socket */
	array_t srv_clients; / connected rpc client sockets */

	rpc_funcs_t srv_funcs; /* RPC functions */

struct {	struct {
int state; // BLOB server state: ==0 disable \| !=0 enable	pthread_t tid; /* BLOB exec pthread */
char dir[UCHAR_MAX + 1];	sched_root_task_t root; / BLOB server scheduler */
	intptr_t kill; /* BLOB server state: ==0 disable \| !=0 enable */

rpc_cli_t server; // BLOB server socket	ait_val_t dir; /* BLOB states directory */
rpc_cli_t *clients; // connected blob client sockets

rpc_blob_t *blobs; // registered blob variables list	rpc_cli_t server; /* BLOB server socket */
	array_t clients; / connected blob client sockets */

pthread_mutex_t mtx;	TAILQ_HEAD(, tagBLOB) blobs; /* registered blob variables list */
} srv_blob;	} srv_blob;
} rpc_srv_t;	} rpc_srv_t;


/*	/*
* (*rpc_callback_t)() Callback type definition for RPC call in server process	* (*rpc_callback_t)() - Callback type definition for RPC call in server process
* @arg1 = current execution RPC call function	*
* @arg2 = number of items in input array from call request	* @arg1 = RPC client
	* @arg2 = RPC packet header
* @arg3 = input array with values from RPC call execution request	* @arg3 = input array with values from RPC call execution request
* return: -1 error or >-1 success execution	* return: -1 error or >-1 success execution
*/	*/
typedef int (rpc_callback_t)(rpc_func_t , int, rpc_val_t *);	typedef int (rpc_callback_t)(rpc_cli_t , struct tagRPCCall , array_t );


// -----------------------------------------------------------------------	/* ----------------------------------------------------------------------- */

/* Error support functions */	/* Error support functions */

// cli_GetErrno() Get error code of last operation	// rpc_GetErrno() Get error code of last operation
inline int cli_GetErrno();	inline int rpc_GetErrno();
// cli_GetError() Get error text of last operation	// rpc_GetError() Get error text of last operation
inline const char *cli_GetError();	inline const char *rpc_GetError();


	/*
	* rpc_chkPktSession() - Check RPC session
	*
	* @p = packet session
	* @s = active session
	* return: -1, 1, 2, 3 are errors or 0 ok
	*/
	inline int rpc_chkPktSession(rpc_sess_t p, rpc_sess_t s);
	/*
	* rpc_addPktSession() - Prepare session into network format
	*
	* @p = packet session
	* @s = host session
	* return: -1 error or 0 ok
	*/
	inline int rpc_addPktSession(rpc_sess_t p, rpc_sess_t s);
	/*
	* rpc_register_srvPing() - Register ping service function
	*
	* @srv = RPC server instance
	* return: -1 error or 0 ok
	*/
	inline int rpc_register_srvPing(rpc_srv_t * __restrict srv);
	/*
	* rpc_register_srvServices() - Register internal service functions
	*
	* @srv = RPC server instance
	* return: -1 error or 0 ok
	*/
	int rpc_register_srvServices(rpc_srv_t * __restrict srv);
	/*
	* rpc_register_blobServices() - Register internal service functions
	*
	* @srv = RPC server instance
	* return: -1 error or 0 ok
	*/
	int rpc_register_blobServices(rpc_srv_t * __restrict srv);


/* RPC Server side functions */	/* RPC Server side functions */

/*	/*
* rpc_srv_initServer() Init & create RPC Server	* rpc_srv_initServer() - Init & create RPC Server
	*
* @regProgID = ProgramID for authentication & recognition	* @regProgID = ProgramID for authentication & recognition
* @regProcID = ProcessID for authentication & recognition	* @regProcID = ProcessID for authentication & recognition
* @concurentClients = Concurent clients at same time to this server	* @concurentClients = Concurent clients at same time to this server
* @sockType = Socket type, like SOCK_STREAM, SOCK_DGRAM or SOCK_RAW	* @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
* @family = Family type, AF_INET, AF_INET6 or AF_LOCAL
* @csHost = Host name or address for bind server, if NULL any address	* @csHost = Host name or address for bind server, if NULL any address
* @Port = Port for bind server, if Port == 0 default port is selected	* @Port = Port for bind server, if Port == 0 default port is selected
* return: NULL == error or !=NULL bind and created RPC server instance	* return: NULL == error or !=NULL bind and created RPC server instance
*/	*/
rpc_srv_t *rpc_srv_initServer(u_int regProgID, u_int regProcID, int concurentClients,	rpc_srv_t *rpc_srv_initServer(unsigned int regProgID, unsigned char regProcID,
int sockType, u_short family, const char *csHost, u_short Port);	int concurentClients, int netBuf,
	const char *csHost, unsigned short Port);
/*	/*
* rpc_srv_endServer() Destroy RPC server, close all opened sockets and free resources	* rpc_srv_endServer() - Destroy RPC server, close all opened sockets and free resources
* @srv = RPC Server instance	*
	* @psrv = RPC Server instance
* return: none	* return: none
*/	*/
void rpc_srv_endServer(rpc_srv_t * __restrict srv);	inline void rpc_srv_endServer(rpc_srv_t ** __restrict psrv);
/*	/*
* rpc_srv_execServer() Execute Main server loop and wait for clients requests	* rpc_srv_loopServer() - Execute Main server loop and wait for clients requests
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* return: -1 error or 0 ok, infinite loop ...	* return: -1 error or 0 ok, infinite loop ...
*/	*/
int rpc_srv_execServer(rpc_srv_t * __restrict srv);	int rpc_srv_loopServer(rpc_srv_t * __restrict srv);
	#define rpc_srv_execServer(_srv, _sync) do { assert((_srv)); \
	if (!(_srv)->srv_kill) { \
	pthread_create(&(_srv)->srv_tid, NULL, (void()(void*)) \
	rpc_srv_loopServer, (_srv)); \
	if ((_sync)) \
	pthread_join((_srv)->srv_tid, (void**) (_sync)); \
	else \
	pthread_detach((_srv)->srv_tid); \
	} } while (0)

/*	/*
* rpc_srv_initBLOBServer() Init & create BLOB Server	* rpc_srv_initBLOBServer() - Init & create BLOB Server
	*
* @srv = RPC server instance	* @srv = RPC server instance
* @sockType = Socket type, like SOCK_STREAM, SOCK_DGRAM or SOCK_RAW
* @Port = Port for bind server, if Port == 0 default port is selected	* @Port = Port for bind server, if Port == 0 default port is selected
* @diskDir = Disk place for BLOB file objects	* @diskDir = Disk place for BLOB file objects
* return: -1 == error or 0 bind and created BLOB server instance	* return: -1 == error or 0 bind and created BLOB server instance
*/	*/
int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int sockType, u_short Port, const char *diskDir);	int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, unsigned short Port, const char *diskDir);
/*	/*
* rpc_srv_endBLOBServer() Destroy BLOB server, close all opened sockets and free resources	* rpc_srv_endBLOBServer() - Destroy BLOB server, close all opened sockets and free resources
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* return: none	* return: none
*/	*/
void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv);	inline void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv);
/*	/*
* rpc_srv_execBLOBServer() Execute Main BLOB server loop and wait for clients requests	* rpc_srv_loopBLOB() - Execute Main BLOB server loop and wait for clients requests
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* return: -1 error or 0 ok, infinite loop ...	* return: -1 error or 0 ok, infinite loop ...
*/	*/
int rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv);	int rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv);
	#define rpc_srv_execBLOBServer(_srv) do { assert((_srv)); \
	if (!(_srv)->srv_kill && !(_srv)->srv_blob.kill) { \
	pthread_create(&(_srv)->srv_blob.tid, NULL, \
	(void()(void*)) \
	rpc_srv_loopBLOBServer, (_srv)); \
	pthread_detach((_srv)->srv_blob.tid); \
	} \
	} while (0)

/*	/*
* rpc_srv_registerCall() Register call to RPC server	* rpc_srv_registerCall() - Register call to RPC server
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* @csModule = Module name, if NULL self binary	* @tag = Function tag
* @csFunc = Function name	* @funcaddr = Function address
* @args = Number of return function arguments, use for restriction case!	* return: -1 error, 0 already registered tag or 1 register ok
* return: -1 error or 0 register ok
*/	*/
int rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char csModule, const char csFunc,	int rpc_srv_registerCall(rpc_srv_t * __restrict srv, unsigned short tag, void *funcaddr);
unsigned char args);
/*	/*
* rpc_srv_unregisterCall() Unregister call from RPC server	* rpc_srv_unregisterCall() - Unregister call from RPC server
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* @csModule = Module name, if NULL self binary	* @tag = Function tag
* @csFunc = Function name
* return: -1 error, 0 not found call, 1 unregister ok	* return: -1 error, 0 not found call, 1 unregister ok
*/	*/
int rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, const char csModule, const char csFunc);	int rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, unsigned short tag);
/*	/*
* rpc_srv_getFunc() Get registered call from RPC server by Name	* rpc_srv_getCall() - Get registered call from RPC server
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* @csModule = Module name, if NULL self binary
* @csFunc = Function name
* return: NULL not found call, !=NULL return call
*/
rpc_func_t rpc_srv_getFunc(rpc_srv_t __restrict srv, const char csModule, const char csFunc);
/*
* rpc_srv_getCall() Get registered call from RPC server
* @srv = RPC Server instance
* @tag = tag for function	* @tag = tag for function
* @hash = hash for function
* return: NULL not found call, !=NULL return call	* return: NULL not found call, !=NULL return call
*/	*/
inline rpc_func_t rpc_srv_getCall(rpc_srv_t __restrict srv, uint16_t tag, uint32_t hash);	inline rpc_func_t rpc_srv_getCall(rpc_srv_t __restrict srv, uint16_t tag);
/*	/*
* rpc_srv_execCall() Execute registered call from RPC server	* rpc_srv_execCall() Execute registered call from RPC server
* @call = Register RPC call	*
	* @cli = RPC client
* @rpc = IN RPC call structure	* @rpc = IN RPC call structure
* @args = IN RPC call array of rpc values	* @funcname = Execute RPC function
	* @args = IN RPC calling arguments from RPC client
* return: -1 error, !=-1 ok	* return: -1 error, !=-1 ok
*/	*/
int rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc,	int rpc_srv_execCall(rpc_cli_t * __restrict cli, struct tagRPCCall * __restrict rpc,
rpc_val_t * __restrict args);	ait_val_t funcname, array_t * __restrict args);


/*	/*
* rpc_srv_retValsCall() Declare return variables for RPC call and zeroed values	* rpc_srv_blobCreate() - Create and map blob to memory region and return object
(for safe handling return values, use this!)	*
* @call = RPC function call
* @return_vals = Number of return variables
* return: NULL error, !=NULL array with return values for RPC call with return_vals items
*/
inline rpc_val_t rpc_srv_retValsCall(rpc_func_t __restrict call, int return_vals);
/*
* rpc_srv_declValsCall() Declare return variables for RPC call,
if already allocated memory for RPC call return values
function reallocate used space with return_vals count elements
* @call = RPC function call
* @return_vals = Number of return variables
* return: -1 error, !=-1 ok
*/
inline int rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals);
/*
* rpc_srv_freeValsCall() Free return variables for RPC call
* @call = RPC function call
* return: none
*/
inline void rpc_srv_freeValsCall(rpc_func_t * __restrict call);
/*
* rpc_srv_copyValsCall() Copy return variables for RPC call to new variable
* @call = RPC function call
* @newvals = New allocated variables array, must be free after use
* return: -1 error, !=-1 Returned number of copied RPC variables
*/
inline int rpc_srv_copyValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvals);
/*
* rpc_srv_zeroValsCall() Clean values from return variables of RPC call
* @call = RPC function call
* return: -1 error, !=-1 Returned number of cleaned RPC variables
*/
inline int rpc_srv_zeroValsCall(rpc_func_t * __restrict call);
/*
* rpc_srv_getValsCall() Get return variables for RPC call
* @call = RPC function call
* @vals = Returned variables, may be NULL
* 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_blobCreate() Create map blob to memory region and return object
* @srv = RPC Server instance	* @srv = RPC Server instance
* @len = BLOB length object	* @len = BLOB length object
* return: NULL error or !=NULL allocated BLOB object	* return: NULL error or !=NULL allocated BLOB object
*/	*/
inline rpc_blob_t rpc_srv_blobCreate(rpc_srv_t __restrict srv, int len);	inline rpc_blob_t rpc_srv_blobCreate(rpc_srv_t __restrict srv, int len);
/*	/*
* rpc_srv_blobMap() Map blob to memory region	* rpc_srv_blobMap() - Map blob to memory region
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* @blob = Map to this BLOB element	* @blob = Map to this BLOB element
* return: -1 error or 0 ok	* return: -1 error or 0 ok
*/	*/
inline int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);	inline int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
/*	/*
* rpc_srv_blobUnmap() Unmap blob memory region	* rpc_srv_blobUnmap() - Unmap blob memory region
	*
* @blob = Mapped BLOB element	* @blob = Mapped BLOB element
* return: none	* return: none
*/	*/
inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob);	inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob);
/*	/*
* rpc_srv_blobFree() Free blob from disk & memory	* rpc_srv_blobFree() - Free blob from disk & memory
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* @blob = Mapped BLOB element	* @blob = Mapped BLOB element
* return: -1 error or 0 ok	* return: -1 error or 0 ok
Line 499 inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict	Line 433 inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict
inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);	inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);

/*	/*
* rpc_srv_registerBLOB() Register new BLOB to server	* rpc_srv_registerBLOB() - Register new BLOB to server
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* @len = BLOB length	* @len = BLOB length
* return: NULL error or new registered BLOB	* return: NULL error or new registered BLOB
*/	*/
rpc_blob_t rpc_srv_registerBLOB(rpc_srv_t __restrict srv, size_t len);	rpc_blob_t rpc_srv_registerBLOB(rpc_srv_t __restrict srv, size_t len);
/*	/*
* rpc_srv_unregisterBLOB() Unregister BLOB from server	* rpc_srv_unregisterBLOB() - Unregister BLOB from server
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* @var = BLOB Variable for unregister	* @var = BLOB Variable for unregister
* return: -1 error, 0 not found call, 1 unregister ok	* return: -1 error, 0 not found call, 1 unregister ok
*/	*/
int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var);	int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var);
/*	/*
* rpc_srv_getBLOB() Get registered BLOB	* rpc_srv_getBLOB() - Get registered BLOB
	*
* @srv = RPC Server instance	* @srv = RPC Server instance
* @var = hash for variable	* @var = hash for variable
* return: NULL not found, !=NULL return blob var	* return: NULL not found, !=NULL return blob var
Line 521 int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv,	Line 458 int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv,
inline rpc_blob_t rpc_srv_getBLOB(rpc_srv_t __restrict srv, uint32_t var);	inline rpc_blob_t rpc_srv_getBLOB(rpc_srv_t __restrict srv, uint32_t var);

/*	/*
* rpc_srv_sendBLOB() Send mapped BLOB to client	* rpc_srv_sendBLOB() - Send mapped BLOB to client
	*
* @cli = Client instance	* @cli = Client instance
* @blob = Mapped BLOB element	* @blob = Mapped BLOB element
* return: -1 error, 0 ok	* return: -1 error, 0 ok
*/	*/
int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);	int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);
/*	/*
* rpc_srv_recvBLOB() Receive BLOB from client	* rpc_srv_recvBLOB() - Receive BLOB from client
	*
* @cli = Client instance	* @cli = Client instance
* @blob = Mapped BLOB element	* @blob = Mapped BLOB element
* return: -1 error, 0 ok, >0 unreceived data from client, may be error?	* return: -1 error, 0 ok, >0 unreceived data from client, may be error?
*/	*/
int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);	int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);

	/* CLIENT part of functions */

/*	/*
* rpc_cli_sendBLOB() Send BLOB to server	* rpc_cli_sendBLOB() - Send BLOB to server
	*
* @cli = Client instance	* @cli = Client instance
* @var = BLOB variable	* @var = BLOB variable
* @data = BLOB data	* @data = BLOB data
* return: -1 error, 0 ok, 1 remote error	* return: -1 error, 0 ok, 1 remote error
*/	*/
int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, rpc_val_t * __restrict var, void * __restrict data);	int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void * __restrict data);
/*	/*
* rpc_cli_recvBLOB() Receive BLOB from server	* rpc_cli_recvBLOB() - Receive BLOB from server
	*
* @cli = Client instance	* @cli = Client instance
* @var = BLOB variable	* @var = BLOB variable
* @data = BLOB data, must be free after use!	* @data = BLOB data, must be io_free after use!
* return: -1 error, 0 ok, 1 remote error	* return: -1 error, 0 ok, 1 remote error
*/	*/
int rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, rpc_val_t * __restrict var, void ** data);	int rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void ** __restrict data);
/*	/*
* rpc_cli_delBLOB() Delete BLOB from server	* rpc_cli_delBLOB() - Delete BLOB from server
	*
* @cli = Client instance	* @cli = Client instance
* @var = BLOB variable	* @var = BLOB variable
* return: -1 error, 0 ok, 1 remote error	* return: -1 error, 0 ok, 1 remote error
*/	*/
int rpc_cli_delBLOB(rpc_cli_t * __restrict cli, rpc_val_t * __restrict var);	int rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var);
/*	/*
* rpc_cli_getBLOB() Receive BLOB from server and Delete after that.	* rpc_cli_getBLOB() - Receive BLOB from server and Delete after that.
	*
* @cli = Client instance	* @cli = Client instance
* @var = BLOB variable	* @var = BLOB variable
* @data = BLOB data, must be free after use!	* @data = BLOB data, must be io_free after use!
* return: -1 error, 0 ok, >0 remote error	* return: -1 error, 0 ok, >0 remote error
*/	*/
inline int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, rpc_val_t * __restrict var, void ** data);	inline int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var,
	void ** __restrict data);



/* RPC Client side functions */	/* RPC Client side functions */

/*	/*
* rpc_cli_openClient() Connect to RPC Server	* rpc_cli_openClient() - Connect to RPC Server
	*
* @ProgID = ProgramID for RPC session request	* @ProgID = ProgramID for RPC session request
* @ProcID = ProcessID for RPC session request	* @ProcID = ProcessID for RPC session request
* @family = Family socket type, AF_INET or AF_INET6	* @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
* @csHost = Host name or IP address for bind server	* @csHost = Host name or IP address for bind server
* @Port = Port for bind server, if Port == 0 default port is selected	* @Port = Port for bind server, if Port == 0 default port is selected
* return: NULL == error or !=NULL connection to RPC server established	* return: NULL == error or !=NULL connection to RPC server established
*/	*/
rpc_cli_t *rpc_cli_openClient(u_int ProgID, u_int ProcID, u_short family,	rpc_cli_t *rpc_cli_openClient(unsigned int ProgID, unsigned char ProcID, int netBuf,
const char *csHost, u_short Port);	const char *csHost, unsigned short Port);
/*	/*
* rpc_cli_closeClient() Close connection to RPC server and free resources	* rpc_cli_closeClient() - Close connection to RPC server and free resources
	*
* @cli = RPC Client session	* @cli = RPC Client session
* return: none	* return: none
*/	*/
void rpc_cli_closeClient(rpc_cli_t * __restrict cli);	void rpc_cli_closeClient(rpc_cli_t ** __restrict cli);
/*	/*
* rpc_cli_execCall() Execute RPC call	* rpc_cli_execCall() - Execute RPC call
	*
* @cli = RPC Client session	* @cli = RPC Client session
* @csModule = Module name, if NULL self binary	* @noreply = We not want RPC reply
* @csFunc = Function name for execute	* @tag = Function tag for execution
* @in_argc = IN count of arguments	* @in_vars = IN RPC call array of rpc values, may be NULL
* @in_vals = IN RPC call array of rpc values	* @out_vars = OUT returned array of rpc values, if !=NULL must be free after use with io_freeVars()
* @out_argc = OUT returned count of arguments
* @out_vals = OUT returned array of rpc values, must be free after use (see rpc_cli_freeVals())
* return: -1 error or != -1 ok result	* return: -1 error or != -1 ok result
*/	*/
int rpc_cli_execCall(rpc_cli_t cli, const char csModule, const char *csFunc, int in_argc,	int rpc_cli_execCall(rpc_cli_t *cli, int noreply, unsigned short tag,
rpc_val_t * __restrict in_vals, int out_argc, rpc_val_t * __restrict out_vals);	array_t * __restrict in_vars, array_t ** __restrict out_vars);
/*	/*
* rpc_cli_freeVals() Free rpc_val_t array returned from RPC call	* rpc_cli_freeCall() - Free resouce allocated by RPC call
* @args = Number of arguments in array	*
* @vals = Value elements	* @out_vars = Returned array with variables from RPC call
* return: none	* return: none
*/	*/
inline void rpc_cli_freeVals(int args, rpc_val_t *vals);	inline void rpc_cli_freeCall(array_t ** __restrict out_vars);
	/*
	* rpc_cli_ping() - Ping RPC server
	*
	* @cli = connected client
	* return: -1 error or !=-1 ping seq id
	*/
	inline int rpc_cli_ping(rpc_cli_t *cli);


/*	/*
* rpc_cli_openBLOBClient() Connect to BLOB Server	* rpc_cli_openBLOBClient() - Connect to BLOB Server
	*
* @rpccli = RPC Client session	* @rpccli = RPC Client session
* @Port = Port for bind server, if Port == 0 default port is selected	* @Port = Port for bind server, if Port == 0 default port is selected
* return: NULL == error or !=NULL connection to BLOB server established	* return: NULL == error or !=NULL connection to BLOB server established
*/	*/
rpc_cli_t rpc_cli_openBLOBClient(rpc_cli_t __restrict rpccli, u_short Port);	rpc_cli_t rpc_cli_openBLOBClient(rpc_cli_t __restrict rpccli, unsigned short Port);
/*	/*
* rpc_cli_closeBLOBClient() Close connection to BLOB server and free resources	* rpc_cli_closeBLOBClient() - Close connection to BLOB server and free resources
	*
* @cli = BLOB Client session	* @cli = BLOB Client session
* return: none	* return: none
*/	*/
void rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli);	void rpc_cli_closeBLOBClient(rpc_cli_t ** __restrict cli);


#endif	#endif

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.2.4.3
changed lines
	Added in v.1.11