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 and 1.3

version 1.1, 2010/06/18 01:48:06	version 1.3, 2011/08/29 22:37:06
Line 5	Line 5
* $Author$	* $Author$
* $Id$	* $Id$
*	*
*************************************************************************/	**************************************************************************
	The ELWIX and AITNET software is distributed under the following
	terms:

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

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

	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.

	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	#ifndef __AITRPC_H
#define __AITRPC_H	#define __AITRPC_H

Line 15	Line 52
#include <string.h>	#include <string.h>
#include <sys/types.h>	#include <sys/types.h>
#include <sys/param.h>	#include <sys/param.h>
	#if !defined(__NetBSD__)
#include <sys/limits.h>	#include <sys/limits.h>
	#endif
#include <sys/socket.h>	#include <sys/socket.h>


#define STRSIZ 256

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


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

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

	#define CALL_SRVSHUTDOWN "rpcServerShutdown"
#define CALL_SRVCLIENTS "rpcServerClients"	#define CALL_SRVCLIENTS "rpcServerClients"
#define CALL_SRVCALLS "rpcServerCalls"	#define CALL_SRVCALLS "rpcServerCalls"
#define CALL_SRVSESSIONS "rpcServerSessions"	#define CALL_SRVSESSIONS "rpcServerSessions"
Line 36	Line 79

typedef enum {	typedef enum {
empty, // empty -> variable is not set	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;	size, offset, datetime, // size -> size_t; offset -> off_t; datetime -> time_t;
real, bigreal, // real -> float; bigreal -> double;	real, bigreal, // real -> float; bigreal -> double;
u8, u16, u32, u64, // unsigned integers ...	u8, u16, u32, u64, // unsigned integers ...
i8, i16, i32, i64 // integers ...	i8, i16, i32, i64 // integers ...
} rpc_type_t;	} rpc_type_t;

	typedef enum {
	disable, enable, kill, // for blob.state
	ok, error, // for blob reply
	get, set, unset // for blob request
	} cmd_type_t;

/* RPC value */	/* RPC value */

typedef struct {	typedef struct {
Line 51 typedef struct {	Line 100 typedef struct {
union {	union {
uint8_t *buffer;	uint8_t *buffer;
int8_t *string;	int8_t *string;
int8_t **array;	uint32_t blob;
size_t size;	size_t size;
off_t offset;	off_t offset;
time_t datetime;	time_t datetime;
Line 70 typedef struct {	Line 119 typedef struct {

#define RPC_TYPE_VAL(vl) ((vl)->val_type)	#define RPC_TYPE_VAL(vl) ((vl)->val_type)
#define RPC_LEN_VAL(vl) ((vl)->val_len)	#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_EMPTY_VAL(vl) ((vl)->val_type == empty)

#define RPC_GET_BUF(vl) (assert((vl)->val_type == buffer), (vl)->val.buffer)	#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_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_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_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_TIME(vl) (assert((vl)->val_type == datetime), (vl)->val.datetime)
Line 98 typedef struct {	Line 148 typedef struct {
if (val->val.string) { \	if (val->val.string) { \
val->val_type = string; val->val_len = strlen(v) + 1; \	val->val_type = string; val->val_len = strlen(v) + 1; \
} } while (0)	} } while (0)
#define RPC_SET_ARRAY(vl, v, n, l) do { rpc_val_t *val = (vl); assert(val); val->val.array = calloc(n, l); \	#define RPC_SET_BLOB(vl, v, l) do { rpc_val_t *val = (vl); assert(val); val->val_type = blob; \
if (val->val.array) { \	val->val.blob = v; val->val_len = l; } while (0)
val->val_type = array; val->val_len = n * l; \	#define RPC_SET_BLOB2(vl, b) do { rpc_val_t *val = (vl); assert(val); assert(b); val->val_type = blob; \
memcpy(val->val.array, v, val->val_len); \	val->val.blob = b->blob_var; val->val_len = b->blob_len; } while (0)
} } while (0)
#define RPC_SET_SIZE(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = size; val->val.size = v; \	#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)	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; \	#define RPC_SET_OFF(vl, v) do { rpc_val_t *val = (vl); assert(val); val->val_type = offset; val->val.offset = v; \
Line 139 typedef struct {	Line 188 typedef struct {
free(val->val.string); \	free(val->val.string); \
val->val.string = NULL; \	val->val.string = NULL; \
} \	} \
if (val->val_type == array && val->val.array) { \
free(val->val.array); \
val->val.array = NULL; \
} \
val->val_type = val->val_len = 0; \	val->val_type = val->val_len = 0; \
} while (0)	} while (0)


#define RPC_CALLBACK_CHECK_ARGS(f, n) do { \	#define RPC_CALLBACK_CHECK_INPUT(x) do { \
if (f->func_args != n) { \	if (!x) { \
	rpc_SetErr(22, "Error:: invalid callback parameters ...\n"); \
	return -1; \
	} \
	} 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"); \	rpc_SetErr(22, "Error:: different number of arguments!\n"); \
return -1; \	return -1; \
} \	} \
} while(0)	} while (0)


/* RPC session identification */	/* RPC session identification */
Line 174 typedef struct tagRPCFunc {	Line 226 typedef struct tagRPCFunc {
int8_t func_name[UCHAR_MAX + 1];	int8_t func_name[UCHAR_MAX + 1];

int8_t func_args;	int8_t func_args;
rpc_val_t *func_vals;	rpc_val_t *func_vars;

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

Line 200 struct tagRPCRet {	Line 253 struct tagRPCRet {
uint8_t ret_argc;	uint8_t ret_argc;
} __packed;	} __packed;

	/* Network BLOB packet - Header */

	struct tagBLOBHdr {
	rpc_sess_t hdr_session;
	uint8_t hdr_cmd;
	uint32_t hdr_var;
	uint32_t hdr_len;
	uint32_t hdr_ret;
	} __packed;

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

typedef struct {	typedef struct {
struct sockaddr cli_sa; // host info	struct sockaddr cli_sa; // host info
int cli_sock; // socket	int cli_sock; // socket fd
pthread_t cli_tid; // TID of thread	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 *cli_parent; // pointer to parent rpc_srv_t for server or to rpc_sess_t for client
} rpc_cli_t;	} 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 {	typedef struct {
	rpc_sess_t srv_session; // RPC session registration info
int srv_numcli; // maximum concurent client connections	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	rpc_func_t *srv_funcs; // registered functions list

	pthread_mutex_t srv_mtx;
	cmd_type_t srv_kill;

	struct {
	cmd_type_t 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;	} 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 = current execution RPC call function
	* @arg2 = number of items in input array from call request
	* @arg3 = input array with values from RPC call execution request
	* return: -1 error or >-1 success execution
	*/
	typedef int (rpc_callback_t)(rpc_func_t , int, rpc_val_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 Server side functions */	/* RPC Server side functions */
Line 242 inline const char *cli_GetError();	Line 337 inline const char *cli_GetError();
* @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
* @family = Family socket type, AF_INET or AF_INET6	* @family = Family type, AF_INET, AF_INET6 or AF_LOCAL
* @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
* return: NULL == error or !=NULL bind and created RPC server instance	* return: NULL == error or !=NULL bind and created RPC server instance
*/	*/
Line 263 void rpc_srv_endServer(rpc_srv_t * __restrict srv);	Line 358 void rpc_srv_endServer(rpc_srv_t * __restrict srv);
int rpc_srv_execServer(rpc_srv_t * __restrict srv);	int rpc_srv_execServer(rpc_srv_t * __restrict srv);

/*	/*
	* rpc_srv_initBLOBServer() Init & create BLOB Server
	* @srv = RPC server instance
	* @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_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	* @csModule = Module name, if NULL self binary
* @csFunc = Function name	* @csFunc = Function name
* @args = Number of function arguments	* @args = Number of return function arguments, use for restriction case!
* return: -1 error or 0 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, const char csModule, const char csFunc,
Line 298 rpc_func_t rpc_srv_getFunc(rpc_srv_t __restrict srv	Line 414 rpc_func_t rpc_srv_getFunc(rpc_srv_t __restrict srv
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, uint32_t hash);
/*	/*
* 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	* @call = Register RPC call
* @rpc = IN RPC call structure	* @rpc = IN RPC call structure
* @args = IN RPC call array of rpc values	* @args = IN RPC call array of rpc values
* 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_func_t * __restrict call, struct tagRPCCall * __restrict rpc,
struct tagRPCCall * __restrict rpc, rpc_val_t * __restrict args);	rpc_val_t * __restrict args);


/*	/*
* rpc_srv_declValsCall() Declare return variables for RPC call	* rpc_srv_returnVars() Init return variables for RPC call and zeroed values
	(for safe handling return values, use this!)
* @call = RPC function call	* @call = RPC function call
* @return_vals = Number of return variables	* @varnum = Number of return variables
* return: -1 error, !=-1 ok	* return: NULL error, !=NULL array with return values for RPC call with varnum items
*/	*/
inline int rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals);	inline rpc_val_t rpc_srv_returnVars(rpc_func_t __restrict call, int varnum);
/*	/*
* rpc_srv_freeValsCall() Free return variables for RPC call	* rpc_srv_allocVars() Allocate array for call variables,
	if already allocated memory for RPC call reallocate used space
* @call = RPC function call	* @call = RPC function call
* return: none	* @varnum = Number of variables, if ==0 free previous allocated variables
	* return: -1 error, !=-1 return varnum value
*/	*/
inline void rpc_srv_freeValsCall(rpc_func_t * __restrict call);	inline int rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum);
	#define rpc_srv_freeVars(_call) (assert((_call)), rpc_srv_allocVars((_call), 0))
/*	/*
* rpc_srv_copyValsCall() Copy return variables for RPC call to new variable	* rpc_srv_zeroVars() Clean values from variables of RPC call
* @call = RPC function call	* @call = RPC function call
* @newvals = New allocated variables array, must be free after use	* return: -1 error, !=-1 Returned number of cleaned RPC variables
* 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);	inline int rpc_srv_zeroVars(rpc_func_t * __restrict call);
/*	/*
* rpc_srv_delValsCall() Clean values from return variables of RPC call	* rpc_srv_copyVars() Copy variables for RPC call to new variable array
* @call = RPC function call	* @call = RPC function call
* return: -1 error, !=-1 Returned number of cleaned RPC variables	* @newvars = New allocated variables array, must be free after use
	* return: -1 error, !=-1 Returned number of copied RPC variables
*/	*/
inline int rpc_srv_delValsCall(rpc_func_t * __restrict call);	inline int rpc_srv_copyVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvars);
/*	/*
* rpc_srv_getValsCall() Get return variables for RPC call	* rpc_srv_getVars() Get variables array for RPC call
* @call = RPC function call	* @call = RPC function call
* @vals = Returned variables, may be NULL	* @vars = Returned variables array, may be NULL
* return: -1 error, !=-1 Number of returned variables	* return: -1 error, !=-1 Number of returned variables
*/	*/
inline int rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict vals);	inline int rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict vars);


	/*
	* rpc_srv_blobCreate() Create map blob to memory region and return object
	* @srv = RPC Server instance
	* @len = BLOB length object
	* return: NULL error or !=NULL allocated BLOB object
	*/
	inline rpc_blob_t rpc_srv_blobCreate(rpc_srv_t __restrict srv, int len);
	/*
	* 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_srv_registerBLOB() Register new BLOB to server
	* @srv = RPC Server instance
	* @len = BLOB length
	* return: NULL error or new registered BLOB
	*/
	rpc_blob_t rpc_srv_registerBLOB(rpc_srv_t __restrict srv, size_t len);
	/*
	* rpc_srv_unregisterBLOB() Unregister BLOB from server
	* @srv = RPC Server instance
	* @var = BLOB Variable for unregister
	* return: -1 error, 0 not found call, 1 unregister ok
	*/
	int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var);
	/*
	* 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_sendBLOB() Send mapped BLOB to client
	* @cli = Client instance
	* @blob = Mapped BLOB element
	* return: -1 error, 0 ok
	*/
	int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);
	/*
	* rpc_srv_recvBLOB() Receive BLOB from client
	* @cli = Client instance
	* @blob = Mapped BLOB element
	* 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);

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



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

/*	/*
Line 354 inline int rpc_srv_getValsCall(rpc_func_t * __restrict	Line 572 inline int rpc_srv_getValsCall(rpc_func_t * __restrict
* @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(u_int ProgID, u_int ProcID,
const char *csHost, u_short Port);	u_short family, const char *csHost, u_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
Line 368 void rpc_cli_closeClient(rpc_cli_t * __restrict cli);	Line 586 void rpc_cli_closeClient(rpc_cli_t * __restrict cli);
* @csModule = Module name, if NULL self binary	* @csModule = Module name, if NULL self binary
* @csFunc = Function name for execute	* @csFunc = Function name for execute
* @in_argc = IN count of arguments	* @in_argc = IN count of arguments
* @in_vals = IN RPC call array of rpc values	* @in_vars = IN RPC call array of rpc values
* @out_argc = OUT returned count of arguments	* @out_argc = OUT returned count of arguments
* @out_vals = OUT returned array of rpc values, must be free after use (see rpc_cli_freeVals())	* @out_vars = 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, const char csModule, const char *csFunc, int in_argc,
rpc_val_t * __restrict in_vals, int out_argc, rpc_val_t * __restrict out_vals);	rpc_val_t * __restrict in_vars, int out_argc, rpc_val_t * __restrict out_vars);
/*	/*
* rpc_cli_freeVals() Free rpc_val_t array returned from RPC call	* rpc_cli_freeVals() Free rpc_val_t array returned from RPC call
* @args = Number of arguments in array	* @args = Number of arguments in array
* @vals = Value elements	* @vars = Value elements
* return: none	* return: none
*/	*/
inline void rpc_cli_freeVals(int args, rpc_val_t *vals);	inline void rpc_cli_freeVals(int args, rpc_val_t *vars);


	/*
	* rpc_cli_openBLOBClient() Connect to BLOB Server
	* @rpccli = RPC Client session
	* @Port = Port for bind server, if Port == 0 default port is selected
	* 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_closeBLOBClient() Close connection to BLOB server and free resources
	* @cli = BLOB Client session
	* return: none
	*/
	void rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli);


#endif	#endif

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

Removed from v.1.1
changed lines
	Added in v.1.3