/*************************************************************************
* (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
* by Michael Pounov <misho@openbsd-bg.org>
*
* $Author: misho $
* $Id: aitrpc.h,v 1.3.2.6 2011/09/03 12:39:27 misho Exp $
*
**************************************************************************
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
#define __AITRPC_H
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/param.h>
#if !defined(__NetBSD__)
#include <sys/limits.h>
#endif
#include <sys/socket.h>
#include <aitio.h>
#define RPC_VERSION 1
#define RPC_DEFPORT 2611
/* RPC builtin registed calls */
#define CALL_BLOBSHUTDOWN "rpcBLOBServerShutdown"
#define CALL_BLOBCLIENTS "rpcBLOBServerClients"
#define CALL_BLOBVARS "rpcBLOBServerVars"
#define CALL_BLOBSTATE "rpcBLOBServerState"
#define CALL_SRVSHUTDOWN "rpcServerShutdown"
#define CALL_SRVCLIENTS "rpcServerClients"
#define CALL_SRVCALLS "rpcServerCalls"
#define CALL_SRVSESSIONS "rpcServerSessions"
/* RPC types */
typedef enum {
disable, enable, running, kill, /* for blob.state */
ok, error, /* for blob reply */
get, set, unset /* for blob request */
} cmd_type_t;
#define RPC_CALLBACK_CHECK_INPUT(_f) do { \
assert((_f)); \
if (!(_f)) { \
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) && io_arraySize((_f)->func_vars) != _n) { \
rpc_SetErr(22, "Error:: different number of arguments!\n"); \
return -1; \
} \
} while (0)
/* RPC session identification */
typedef struct {
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 {
uint16_t func_tag;
uint32_t func_hash;
int8_t func_file[MAXPATHLEN];
int8_t func_name[UCHAR_MAX + 1];
array_t *func_vars;
void *func_parent;
struct tagRPCFunc *func_next;
} rpc_func_t;
/* Network RPC packet - Client request */
struct tagRPCCall {
rpc_sess_t call_session;
uint16_t call_tag;
uint32_t call_hash;
uint16_t call_argc;
} __packed;
/* Network RPC packet - Server response */
struct tagRPCRet {
rpc_sess_t ret_session;
uint16_t ret_tag;
uint32_t ret_hash;
int32_t ret_retcode;
int32_t ret_errno;
uint16_t ret_argc;
} __packed;
/* Network BLOB packet - Header */
struct tagBLOBHdr {
rpc_sess_t hdr_session;
uint8_t hdr_cmd;
uint32_t hdr_var;
uint32_t hdr_len;
uint32_t hdr_ret;
} __packed;
/* Network RPC client & server elements */
typedef struct {
struct sockaddr cli_sa; // host info
int cli_sock; // socket fd
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
int cli_netbuf; // size of network buffer size
} rpc_cli_t;
// BLOB registration element!
typedef struct tagBLOB {
uint32_t blob_var;
size_t blob_len; // size of allocated BLOB data
void *blob_data; // BLOB data
struct tagBLOB *blob_next;
} rpc_blob_t;
typedef struct {
rpc_sess_t srv_session; // RPC session registration info
int srv_numcli; // maximum concurent client connections
int srv_netbuf; // size of network buffer size
rpc_cli_t srv_server; // RPC server socket
rpc_cli_t *srv_clients; // connected rpc client sockets
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_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, array_t *);
// -----------------------------------------------------------------------
/* Error support functions */
// rpc_GetErrno() Get error code of last operation
inline int rpc_GetErrno();
// rpc_GetError() Get error text of last operation
inline const char *rpc_GetError();
/* RPC Server side functions */
/*
* rpc_srv_initServer() Init & create RPC Server
* @regProgID = ProgramID for authentication & recognition
* @regProcID = ProcessID for authentication & recognition
* @concurentClients = Concurent clients at same time to this server
* @netBuf = Network buffer length, 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
* @Port = Port for bind server, if Port == 0 default port is selected
* 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,
int netBuf, u_short family, const char *csHost, u_short Port);
/*
* rpc_srv_endServer() Destroy RPC server, close all opened sockets and free resources
* @srv = RPC Server instance
* return: none
*/
void rpc_srv_endServer(rpc_srv_t * __restrict srv);
/*
* rpc_srv_loopServer() Execute Main server loop and wait for clients requests
* @srv = RPC Server instance
* return: -1 error or 0 ok, infinite loop ...
*/
int rpc_srv_loopServer(rpc_srv_t * __restrict srv);
#define rpc_srv_execServer(_srv, _sync) do { assert((_srv)); pthread_t __tid; \
pthread_create(&__tid, NULL, (void*(*)(void*)) \
rpc_srv_loopServer, (_srv)); \
if ((_sync)) \
pthread_join(__tid, (void**) (_sync)); \
else \
pthread_detach(__tid); \
} while (0)
/*
* 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_loopBLOB() 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_loopBLOB(rpc_srv_t * __restrict srv);
#define rpc_srv_execBLOBServer(_srv) do { assert((_srv)); pthread_t __tid; \
if ((_srv)->srv_blob.state == enable) { \
pthread_create(&__tid, NULL, (void*(*)(void*)) \
rpc_srv_loopBLOB, (_srv)); \
pthread_detach(__tid); \
(_srv)->srv_blob.state = running; \
} \
} while (0)
/*
* rpc_srv_registerCall() Register call to RPC server
* @srv = RPC Server instance
* @csModule = Module name, if NULL self binary
* @csFunc = Function name
* @args = Number of return function arguments, use for restriction case!
* return: -1 error or 0 register ok
*/
int rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc,
unsigned short args);
/*
* rpc_srv_unregisterCall() Unregister call from RPC server
* @srv = RPC Server instance
* @csModule = Module name, if NULL self binary
* @csFunc = Function name
* 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);
/*
* rpc_srv_getFunc() Get registered call from RPC server by Name
* @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
* @hash = hash for function
* 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_srv_execCall() Execute registered call from RPC server
* @call = Register RPC call
* @rpc = IN RPC call structure
* @args = IN RPC calling arguments from RPC client
* return: -1 error, !=-1 ok
*/
int rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc,
array_t * __restrict args);
/*
* rpc_srv_allocVars() Allocate array for call variables,
if already allocated memory for RPC call reallocate used space
* @call = RPC function call
* @varnum = Number of variables, if ==0 free previous allocated variables
* return: -1 error, !=-1 return varnum value
*/
inline int rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum);
/*
* rpc_srv_destroyVars() Destroy variables of array & array
* @call = RPC function call
* return: -1 error, !=-1 Returne remained variables
*/
inline int rpc_srv_destroyVars(rpc_func_t * __restrict call);
/*
* rpc_srv_freeVals() Clean values from variables of array
* @call = RPC function call
* return: -1 error, !=-1 Returned number of cleaned variables
*/
inline int rpc_srv_freeVals(rpc_func_t * __restrict call);
/*
* rpc_srv_copyVars() Copy variables for RPC call to new variable array
* @call = RPC function call
* @newvars = New allocated variables array, must be free after use
* return: -1 error, !=-1 Returned number of copied RPC variables
*/
inline int rpc_srv_copyVars(rpc_func_t * __restrict call, array_t ** __restrict newvars);
/*
* rpc_srv_getVars() Get variables array for RPC call
* @call = RPC function call
* @vars = Returned variables array, may be NULL
* return: -1 error, !=-1 Number of returned variables
*/
inline int rpc_srv_getVars(rpc_func_t * __restrict call, array_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);
/* CLIENT part of functions */
/*
* 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, ait_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, ait_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, ait_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, ait_val_t * __restrict var, void ** data);
/* RPC Client side functions */
/*
* rpc_cli_openClient() Connect to RPC Server
* @ProgID = ProgramID for RPC session request
* @ProcID = ProcessID for RPC session request
* @netBuf = Network buffer length, if =0 == BUFSIZ (also meaning max RPC packet)
* @family = Family socket type, AF_INET or AF_INET6
* @csHost = Host name or IP address for bind server
* @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, int netBuf,
u_short family, const char *csHost, u_short Port);
/*
* rpc_cli_closeClient() Close connection to RPC server and free resources
* @cli = RPC Client session
* return: none
*/
void rpc_cli_closeClient(rpc_cli_t * __restrict cli);
/*
* rpc_cli_execCall() Execute RPC call
* @cli = RPC Client session
* @csModule = Module name, if NULL self binary
* @csFunc = Function name for execute
* @in_vars = IN RPC call array of rpc values
* @out_vars = OUT returned array of rpc values, must be free after use with rpc_cli_freeVals()
* return: -1 error or != -1 ok result
*/
int rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, const char *csFunc,
array_t * __restrict in_vars, array_t ** __restrict out_vars);
/*
* rpc_cli_freeVals() Free ait_val_t array returned from RPC call
* @vars = Variable array
* return: none
*/
inline void rpc_cli_freeVals(array_t ** __restrict vars);
/*
* rpc_cli_allocVals() Allocate ait_val_t array for RPC call
* @args = Number of arguments
* return: =NULL error or !=NULL allocated array
*/
inline array_t *rpc_cli_allocVals(unsigned short args);
/*
* 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to aitrpc.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / inc