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.1.1.1.2.5 and 1.28

version 1.1.1.1.2.5, 2010/06/23 11:33:38	version 1.28, 2015/07/02 22:28:14
Line 5	Line 5
* $Author$	* $Author$
* $Id$	* $Id$
*	*
*************************************************************************/	**************************************************************************
#ifndef __AITRPC_H	The ELWIX and AITNET software is distributed under the following
#define __AITRPC_H	terms:

	All of the documentation and software included in the ELWIX and AITNET
	Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>

#include <assert.h>	Copyright 2004 - 2015
#include <stdlib.h>	by Michael Pounov <misho@elwix.org>. All rights reserved.
#include <string.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/limits.h>
#include <sys/socket.h>

	Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions
	are met:
	1. Redistributions of source code must retain the above copyright
	notice, this list of conditions and the following disclaimer.
	2. Redistributions in binary form must reproduce the above copyright
	notice, this list of conditions and the following disclaimer in the
	documentation and/or other materials provided with the distribution.
	3. All advertising materials mentioning features or use of this software
	must display the following acknowledgement:
	This product includes software developed by Michael Pounov <misho@elwix.org>
	ELWIX - Embedded LightWeight unIX and its contributors.
	4. Neither the name of AITNET nor the names of its contributors
	may be used to endorse or promote products derived from this software
	without specific prior written permission.

#define STRSIZ 256	THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	SUCH DAMAGE.
	*/
	#ifndef __AITRPC_H
	#define __AITRPC_H

#define RPC_VERSION 1
#define RPC_DEFPORT 2611

	#include <assert.h>
	//#include <stdlib.h>
	//#include <string.h>
	//#include <errno.h>
	//#include <sys/types.h>
	//#include <sys/param.h>
	//#if !defined(__NetBSD__)
	//#include <sys/limits.h>
	//#endif
	//#include <sys/socket.h>
	#include <pthread.h>
	#include <sys/queue.h>
	#include <aitrpc_pkt.h>
	#include <aitrpc_cli.h>
	#include <aitsched.h>

/* RPC builtin registed calls */

#define CALL_BLOBSHUTDOWN "rpcBLOBServerShutdown"	#define RPC_CALLBACK_CHECK_INPUT(x) do { \
#define CALL_BLOBCLIENTS "rpcBLOBServerClients"	assert((x)); \
#define CALL_BLOBVARS "rpcBLOBServerVars"	if (!(x)) { \
	rpc_SetErr(EINVAL, \
#define CALL_SRVSHUTDOWN "rpcServerShutdown"	"Invalid callback parameters ..."); \
#define CALL_SRVCLIENTS "rpcServerClients"
#define CALL_SRVCALLS "rpcServerCalls"
#define CALL_SRVSESSIONS "rpcServerSessions"


/* RPC types */

typedef enum {
empty, // empty -> variable is not set
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;

/* RPC value */

typedef struct {
rpc_type_t val_type;
size_t val_len;
union {
uint8_t *buffer;
int8_t *string;
void *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.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)
#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; \
} \
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_CHK_NUM_ARGS(f, n) do { \
if (f->func_args != n) { \
rpc_SetErr(22, "Error:: different number of arguments!\n"); \
return -1; \	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 */	/* Network RPC server elements */

typedef struct {	/* RPC function registration element! */
uint8_t sess_version;
uint32_t sess_program;
uint32_t sess_process;
} __packed rpc_sess_t;


/* Server managment RPC functions ... */

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

int8_t func_args;	void *func_parent;
rpc_val_t *func_vals;

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

	/* Tree root node */
	typedef struct tagRPCFuncs {
	pthread_mutex_t mtx;

/* Network RPC packet - Client request */	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))

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

/* Network RPC packet - Server response */	/* BLOB register element */

struct tagRPCRet {
rpc_sess_t ret_session;
uint16_t ret_tag;
uint32_t ret_hash;
int32_t ret_retcode;
int32_t ret_errno;
uint8_t ret_argc;
} __packed;

/* Network RPC client & server elements */

typedef struct {
struct sockaddr cli_sa; // host info
int cli_sock; // socket
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
} rpc_cli_t;


// BLOB registration element!
typedef struct tagBLOB {	typedef struct tagBLOB {
rpc_cli_t *blob_cli; // from RPC client	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	rpc_sess_t srv_session; /* RPC session registration info */
int srv_numcli; // maximum concurent client connections	int srv_netbuf; /* size of network buffer */
	int srv_proto; /* Server protocol */

rpc_cli_t srv_server; // RPC server socket	pthread_t srv_tid; /* RPC exec pthread */
rpc_cli_t *srv_clients; // connected rpc client sockets	sched_root_task_t srv_root; / RPC server scheduler */
	intptr_t srv_kill; /* Scheduler condition variable */

rpc_func_t *srv_funcs; // registered functions list	rpc_cli_t srv_server; /* RPC server socket */
	array_t srv_clients; / connected rpc client sockets */

pthread_mutex_t srv_mtx;	rpc_funcs_t srv_funcs; /* RPC functions */

struct {	struct {
int state; // BLOB server state: ==0 disable \| !=0 enable	pthread_t tid; /* BLOB exec pthread */
	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;


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

	#define RPC_CALL_DEFINE(x) int (x)(rpc_cli_t, struct tagRPCCall, array_t*)
	#define RPC_CALL_ARGS(arg1, arg2, arg3) rpc_cli_t* arg1, struct tagRPCCall* arg2, array_t* arg3
	#define RPC_CALL_STDARGS RPC_CALL_ARGS(cli, rpc, iv)

// -----------------------------------------------------------------------

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

// cli_GetErrno() Get error code of last operation	/*
inline int cli_GetErrno();	* rpc_register_srvPing() - Register ping service function
// cli_GetError() Get error text of last operation	*
inline const char *cli_GetError();	* @srv = RPC server instance
	* return: -1 error or 0 ok
	*/
	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	*
* @regProcID = ProcessID for authentication & recognition	* @InstID = Instance for authentication & recognition
* @concurentClients = Concurent clients at same time to this server	* @concurentClients = Concurent clients at same time to this server
* @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, 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
	* @proto = Protocol, if == 0 choose SOCK_STREAM
* 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 char InstID, int concurentClients, int netBuf,
u_short family, const char *csHost, u_short Port);	const char *csHost, unsigned short Port, int proto);
/*	/*
* 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);	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)
	#define rpc_srv_killServer(_srv) \
	(assert((_srv)), (_srv)->srv_blob.kill = 1, (_srv)->srv_kill = 1)

/*	/*
* rpc_srv_initBLOBServer() Init & create BLOB Server	* rpc_srv_initBLOBServer() - Init & create BLOB Server
	*
	* @srv = RPC server instance
* @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
* 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, u_short Port);	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);	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_initServer2() - Init & create layer2 RPC Server
* @srv = RPC Server instance	*
* @csModule = Module name, if NULL self binary	* @InstID = Instance for authentication & recognition
* @csFunc = Function name	* @concurentClients = Concurent clients at same time to this server
* @args = Number of function arguments	* @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
* return: -1 error or 0 register ok	* @csIface = Interface name for bind server, if NULL first interface on host
	* return: NULL == error or !=NULL bind and created RPC server instance
*/	*/
int rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char csModule, const char csFunc,	rpc_srv_t *rpc_srv_initServer2(u_char InstID, int concurentClients, int netBuf,
unsigned char args);	const char *csIface);

/*	/*
* rpc_srv_unregisterCall() Unregister call from RPC server	* rpc_srv_initServerExt() - Init & create pipe RPC Server
	*
	* @InstID = Instance for authentication & recognition
	* @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
	* @fd = File descriptor
	* return: NULL == error or !=NULL bind and created RPC server instance
	*/
	rpc_srv_t *rpc_srv_initServerExt(u_char InstID, int netBuf, int fd);

	/*
	* 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
* return: -1 error, 0 not found call, 1 unregister ok	* return: -1 error, 0 already registered tag or 1 register ok
*/	*/
int rpc_srv_unregisterCall(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);
/*	/*
* rpc_srv_getFunc() Get registered call from RPC server by Name	* 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: NULL not found call, !=NULL return call
*/	*/
rpc_func_t rpc_srv_getFunc(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_getCall() Get registered call from RPC server	* rpc_srv_getCall() - Get registered call from RPC server
	*
* @srv = RPC Server instance	* @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);	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
* @data = RPC const data	*
* @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(void * const data, rpc_func_t * __restrict call,	int rpc_srv_execCall(rpc_cli_t * __restrict cli, struct tagRPCCall * __restrict rpc,
struct tagRPCCall * __restrict rpc, rpc_val_t * __restrict args);	ait_val_t funcname, array_t * __restrict args);


/*	/*
* rpc_srv_declValsCall() Declare return variables for RPC call	* rpc_srv_blobCreate() - Create and map blob to memory region and return object
* @call = RPC function call	*
* @return_vals = Number of return variables	* @srv = RPC Server instance
* return: -1 error, !=-1 ok	* @len = BLOB length object
	* @tout = BLOB live timeout in seconds
	* return: NULL error or !=NULL allocated BLOB object
*/	*/
inline int rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals);	rpc_blob_t rpc_srv_blobCreate(rpc_srv_t __restrict srv, int len, int tout);
/*	/*
* rpc_srv_freeValsCall() Free return variables for RPC call	* rpc_srv_blobMap() - Map blob to memory region
* @call = RPC function call	*
* return: none	* @srv = RPC Server instance
	* @blob = Map to this BLOB element
	* return: -1 error or 0 ok
*/	*/
inline void rpc_srv_freeValsCall(rpc_func_t * __restrict call);	int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
/*	/*
* rpc_srv_copyValsCall() Copy return variables for RPC call to new variable	* rpc_srv_blobUnmap() - Unmap blob memory region
* @call = RPC function call	*
* @newvals = New allocated variables array, must be free after use	* @blob = Mapped BLOB element
* return: -1 error, !=-1 Returned number of copied RPC variables	* return: none
*/	*/
inline int rpc_srv_copyValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvals);	void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob);
/*	/*
* rpc_srv_delValsCall() Clean values from return variables of RPC call	* rpc_srv_blobFree() - Free blob from disk & memory
* @call = RPC function call	*
* return: -1 error, !=-1 Returned number of cleaned RPC variables	* @srv = RPC Server instance
	* @blob = Mapped BLOB element
	* return: -1 error or 0 ok
*/	*/
inline int rpc_srv_delValsCall(rpc_func_t * __restrict call);	int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);

/*	/*
* rpc_srv_getValsCall() Get return variables for RPC call	* rpc_srv_registerBLOB() - Register new BLOB to server
* @call = RPC function call	*
* @vals = Returned variables, may be NULL	* @srv = RPC Server instance
* return: -1 error, !=-1 Number of returned variables	* @len = BLOB length
	* @tout = BLOB live timeout in seconds
	* return: NULL error or new registered BLOB
*/	*/
inline int rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict vals);	rpc_blob_t rpc_srv_registerBLOB(rpc_srv_t __restrict srv, size_t len, int tout);


/* RPC Client side functions */

/*	/*
* rpc_cli_openClient() Connect to RPC Server	* rpc_srv_unregisterBLOB() - Unregister BLOB from server
* @ProgID = ProgramID for RPC session request	*
* @ProcID = ProcessID for RPC session request	* @srv = RPC Server instance
* @family = Family socket type, AF_INET or AF_INET6	* @var = BLOB Variable for unregister
* @csHost = Host name or IP address for bind server	* return: -1 error, 0 not found call, 1 unregister ok
* @Port = Port for bind server, if Port == 0 default port is selected
* 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,	int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var);
const char *csHost, u_short Port);
/*	/*
* rpc_cli_closeClient() Close connection to RPC server and free resources	* rpc_srv_getBLOB() - Get registered BLOB
* @cli = RPC Client session	*
* return: none	* @srv = RPC Server instance
	* @var = hash for variable
	* return: NULL not found, !=NULL return blob var
*/	*/
void rpc_cli_closeClient(rpc_cli_t * __restrict cli);	rpc_blob_t rpc_srv_getBLOB(rpc_srv_t __restrict srv, uint32_t var);

/*	/*
* rpc_cli_execCall() Execute RPC call	* rpc_srv_sendBLOB() - Send mapped BLOB to client
* @cli = RPC Client session	*
* @csModule = Module name, if NULL self binary	* @cli = Client instance
* @csFunc = Function name for execute	* @blob = Mapped BLOB element
* @in_argc = IN count of arguments	* return: -1 error, 0 ok
* @in_vals = IN RPC call array of rpc values
* @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
*/	*/
int rpc_cli_execCall(rpc_cli_t cli, const char csModule, const char *csFunc, int in_argc,	int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);
rpc_val_t * __restrict in_vals, int out_argc, rpc_val_t * __restrict out_vals);
/*	/*
* rpc_cli_freeVals() Free rpc_val_t array returned from RPC call	* rpc_srv_recvBLOB() - Receive BLOB from client
* @args = Number of arguments in array	*
* @vals = Value elements	* @cli = Client instance
* return: none	* @blob = Mapped BLOB element
	* return: -1 error, 0 ok, >0 unreceived data from client, may be error?
*/	*/
inline void rpc_cli_freeVals(int args, rpc_val_t *vals);	int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);


#endif	#endif

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

Removed from v.1.1.1.1.2.5
changed lines
	Added in v.1.28