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.12 and 1.2.4.4

version 1.1.1.1.2.12, 2010/06/28 15:18:43	version 1.2.4.4, 2011/08/19 07:19:08
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>


Line 61 typedef struct {	Line 100 typedef struct {
union {	union {
uint8_t *buffer;	uint8_t *buffer;
int8_t *string;	int8_t *string;
void *blob;	uint32_t blob;
size_t size;	size_t size;
off_t offset;	off_t offset;
time_t datetime;	time_t datetime;
Line 110 typedef struct {	Line 149 typedef struct {
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_BLOB(vl, v, l) do { rpc_val_t *val = (vl); assert(val); val->val_type = blob; \	#define RPC_SET_BLOB(vl, v, l) do { rpc_val_t *val = (vl); assert(val); val->val_type = blob; \
val->val.blob = (void*) v; val->val_len = l; } while (0)	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; \	#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 151 typedef struct {	Line 192 typedef struct {
} while (0)	} while (0)


#define RPC_CALLBACK_CHK_NUM_ARGS(f, n) do { \	#define RPC_CALLBACK_CHECK_INPUT(x) do { \
if (f->func_args != n) { \	if (!x) { \
rpc_SetErr(22, "Error:: different number of arguments!\n"); \	rpc_SetErr(22, "Error:: invalid callback parameters ...\n"); \
return -1; \	return -1; \
} \	} \
} while (0)	} while (0)
#define RPC_CALLBACK_CHECK_INPUT(f) do { \	#define RPC_CALLBACK_CHK_ARGS(f, n) do { \
if (!f) { \	RPC_CALLBACK_CHECK_INPUT(f); \
rpc_SetErr(22, "Error:: invalid callback parameters ...\n"); \	if (f && f->func_args != n) { \
	rpc_SetErr(22, "Error:: different number of arguments!\n"); \
return -1; \	return -1; \
} \	} \
} while (0)	} while (0)
Line 217 struct tagBLOBHdr {	Line 259 struct tagBLOBHdr {
rpc_sess_t hdr_session;	rpc_sess_t hdr_session;
uint8_t hdr_cmd;	uint8_t hdr_cmd;
uint32_t hdr_var;	uint32_t hdr_var;
uint32_t hdr_seq;
uint32_t hdr_len;	uint32_t hdr_len;
	uint32_t hdr_ret;
} __packed;	} __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
	int cli_type; // socket type
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
Line 281 typedef int (rpc_callback_t)(rpc_func_t , int, rpc_v	Line 324 typedef int (rpc_callback_t)(rpc_func_t , int, rpc_v

/* 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 294 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	* @sockType = Socket type, like SOCK_STREAM, SOCK_DGRAM or SOCK_RAW
* @csHost = Host name or IP address for bind server, if NULL any address	* @family = Family type, AF_INET, AF_INET6 or AF_LOCAL
	* @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(u_int regProgID, u_int regProcID, int concurentClients,
u_short family, const char *csHost, u_short Port);	int sockType, u_short family, const char *csHost, u_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	* @srv = RPC Server instance
Line 316 int rpc_srv_execServer(rpc_srv_t * __restrict srv);	Line 360 int rpc_srv_execServer(rpc_srv_t * __restrict srv);

/*	/*
* rpc_srv_initBLOBServer() Init & create BLOB Server	* rpc_srv_initBLOBServer() Init & create BLOB Server
	* @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, u_short Port, const char *diskDir);	int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int sockType, u_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
Line 335 void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)	Line 381 void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
int rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv);	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	* 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 464 inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv	Line 502 inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv
* 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: -1 error or 0 register ok	* 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);
/*	/*
Line 474 rpc_blob_t rpc_srv_registerBLOB(rpc_srv_t __restric	Line 512 rpc_blob_t rpc_srv_registerBLOB(rpc_srv_t __restric
* 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
	* @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	* rpc_srv_sendBLOB() Send mapped BLOB to client
Line 490 int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_b	Line 535 int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_b
*/	*/
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);

	/*
	* 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 530 int rpc_cli_execCall(rpc_cli_t cli, const char csMod	Line 608 int rpc_cli_execCall(rpc_cli_t cli, const char csMod
* 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 *vals);


	/*
	* 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.1.1.2.12
changed lines
	Added in v.1.2.4.4