[BACK]Return to aitrpc.h CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / inc

Diff for /libaitrpc/inc/aitrpc.h between versions 1.18 and 1.28.8.2

version 1.18, 2013/08/22 15:31:09 version 1.28.8.2, 2024/03/20 17:06: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, 2012, 2013Copyright 2004 - 2024
         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 48  SUCH DAMAGE. Line 48  SUCH DAMAGE.
   
   
 #include <assert.h>  #include <assert.h>
#include <stdlib.h>#include <pthread.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 <sys/queue.h>  #include <sys/queue.h>
#include <elwix.h>#include <aitrpc_pkt.h>
 #include <aitrpc_cli.h>
 #include <aitsched.h>  #include <aitsched.h>
   
   
 #define RPC_VERSION             7  
 #define RPC_DEFPORT             2611  
   
 /* RPC call request flags */  
   
 #define RPC_REPLY               0x0  
 #define RPC_NOREPLY             0x1  
   
 /* RPC builtin registed calls */  
   
 #define CALL_TAG_MAX            65535  
   
 #define CALL_SRVPING            65534  
   
 #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 signals */  
 #define SIGFBLOB                54  
   
 /* RPC types */  
   
 typedef enum {  
         ok, error, no,                          /* for blob reply */  
         get, set, unset                         /* for blob request */  
 } blob_cmd_type_t;  
   
   
 #define RPC_CALLBACK_CHECK_INPUT(x)     do { \  #define RPC_CALLBACK_CHECK_INPUT(x)     do { \
                                                 assert((x)); \                                                  assert((x)); \
                                                 if (!(x)) { \                                                  if (!(x)) { \
Line 106  typedef enum { Line 65  typedef enum {
                                         } while (0)                                          } while (0)
   
   
/* RPC session identification *//* Network RPC server elements */
   
 typedef struct {  
 #if BYTE_ORDER == LITTLE_ENDIAN  
         uint16_t        sess_instance:8;  
         uint16_t        sess_version:8;  
 #endif  
 #if BYTE_ORDER == BIG_ENDIAN  
         uint16_t        sess_version:8;  
         uint16_t        sess_instance:8;  
 #endif  
 } __packed rpc_sess_t;  /* size == 2 bytes */  
   
   
 /* Server managment RPC functions ... */  
   
 /* Network RPC packet - Client request */  
   
 struct tagRPCCall {  
         rpc_sess_t      call_session;  
   
         uint32_t        call_len;  
         uint16_t        call_crc;  
   
         union {  
                 struct {  
                         uint64_t        flags;  
                 }       call_req;  
                 struct {  
                         int32_t         ret;  
                         int32_t         eno;  
                 }       call_rep;  
         };  
   
         uint16_t        call_tag;  
         uint16_t        call_argc;  
         ait_val_t       call_argv[0];  
 } __packed;                     /* size == 20 bytes */  
 #define RPC_CHK_NOREPLY(x)      ((x)->call_req.flags & RPC_NOREPLY)  
   
 /* 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;  
         uint8_t         hdr_pad;  
 } __packed;                     /* size == 16 bytes */  
   
 /* Network RPC client & server elements */  
   
 /* RPC function registration element! */  /* RPC function registration element! */
 typedef struct tagRPCFunc {  typedef struct tagRPCFunc {
         ait_val_t               func_name;          ait_val_t               func_name;
Line 194  typedef struct tagBLOB { Line 102  typedef struct tagBLOB {
   
   
 typedef struct {  typedef struct {
         int             cli_id;         /* slot id */  
         int             cli_sock;       /* socket fd */  
         sockaddr_t      cli_sa;         /* host address */  
         ait_val_t       cli_buf;        /* network buffer */  
   
         array_t         *cli_vars;      /* function return variables */  
   
         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)  
   
 typedef struct {  
         rpc_sess_t                      srv_session;    /* RPC session registration info */          rpc_sess_t                      srv_session;    /* RPC session registration info */
         int                             srv_netbuf;     /* size of network buffer */          int                             srv_netbuf;     /* size of network buffer */
         int                             srv_proto;      /* Server protocol */          int                             srv_proto;      /* Server protocol */
Line 246  typedef struct { Line 140  typedef struct {
  */   */
 typedef int (*rpc_callback_t)(rpc_cli_t *, struct tagRPCCall *, array_t *);  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 */  
   
 // rpc_GetErrno() Get error code of last operation  
 int rpc_GetErrno();  
 // rpc_GetError() Get error text of last operation  
 const char *rpc_GetError();  
 // rpc_SetErr() Set error to variables for internal use!!!  
 void rpc_SetErr(int eno, char *estr, ...);  
   
   
   
 /*  /*
 * rpc_chkPktSession() - Check RPC session * rpc_srv_DispatchSignal() - Enable/Disable Signal dispatcher for RPC scheduler
  *   *
 * @p = packet session * @x = RPC server instance
 * @s = active session * @y = Enable or =0 Disable
 * return: -1, 1, 2, 3 are errors or 0 ok * return: 0 enabled signal dispatcher. See schedSignalDispatch() in libaitsched
  */   */
int rpc_chkPktSession(rpc_sess_t *p, rpc_sess_t *s);#define rpc_srv_DispatchSignal(x, y) schedSignalDispatch((x)->srv_root, (y))
 
 /* ----------------------------------------------------------------------- */
 
 /*  /*
  * rpc_addPktSession() - Prepare session into network format  
  *  
  * @p = packet session  
  * @s = host session  
  * return: -1 error or 0 ok  
  */  
 int rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s);  
 /*  
  * rpc_register_srvPing() - Register ping service function   * rpc_register_srvPing() - Register ping service function
  *   *
  * @srv = RPC server instance   * @srv = RPC server instance
Line 328  void rpc_srv_endServer(rpc_srv_t ** __restrict psrv); Line 208  void rpc_srv_endServer(rpc_srv_t ** __restrict psrv);
  * return: -1 error or 0 ok, infinite loop ...   * return: -1 error or 0 ok, infinite loop ...
  */   */
 int rpc_srv_loopServer(rpc_srv_t * __restrict srv);  int rpc_srv_loopServer(rpc_srv_t * __restrict srv);
#define rpc_srv_execServer(_srv, _sync) do { assert((_srv)); \#define rpc_srv_execServer(_srv, _sync) \
                                                if (!(_srv)->srv_kill) { \        do { assert((_srv)); \
                                                        pthread_create(&(_srv)->srv_tid, NULL, (void*(*)(void*)) \                if (!(_srv)->srv_kill) { \
                                                                        rpc_srv_loopServer, (_srv)); \                        pthread_create(&(_srv)->srv_tid, NULL, (void*(*)(void*)) \
                                                        if ((_sync)) \                                        rpc_srv_loopServer, (_srv)); \
                                                                pthread_join((_srv)->srv_tid, (void**) (_sync)); \                        if ((_sync)) \
                                                        else \                                pthread_join((_srv)->srv_tid, (void**) (_sync)); \
                                                                pthread_detach((_srv)->srv_tid); \                        else \
                                                } } while (0)                                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
Line 361  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 244  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
  * return: -1 error or 0 ok, infinite loop ...   * return: -1 error or 0 ok, infinite loop ...
  */   */
 int rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv);  int rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv);
#define rpc_srv_execBLOBServer(_srv)    do { assert((_srv)); \#define rpc_srv_execBLOBServer(_srv) \
                                                if (!(_srv)->srv_kill && !(_srv)->srv_blob.kill) { \        do { assert((_srv)); \
                                                        pthread_create(&(_srv)->srv_blob.tid, NULL, \                if (!(_srv)->srv_kill && !(_srv)->srv_blob.kill) { \
                                                                        (void*(*)(void*)) \                        pthread_create(&(_srv)->srv_blob.tid, NULL, \
                                                                        rpc_srv_loopBLOBServer, (_srv)); \                                        (void*(*)(void*)) rpc_srv_loopBLOBServer, (_srv)); \
                                                        pthread_detach((_srv)->srv_blob.tid); \                        pthread_detach((_srv)->srv_blob.tid); \
                                                } \                } \
                                        } while (0)        } while (0)
   
 /*  /*
    * rpc_srv_initServer2() - Init & create layer2 RPC Server
    *
    * @InstID = Instance for authentication & recognition
    * @concurentClients = Concurent clients at same time to this server
    * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
    * @csIface = Interface name for bind server, if NULL first interface on host
    * return: NULL == error or !=NULL bind and created RPC server instance
    */
   rpc_srv_t *rpc_srv_initServer2(u_char InstID, int concurentClients, int netBuf, 
                   const char *csIface);
   
   /*
    * 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   * rpc_srv_registerCall() - Register call to RPC server
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
Line 484  int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_b Line 389  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);
   
 /* CLIENT part of functions */  
   
 /*  /*
 * rpc_cli_sendBLOB() - Send BLOB to server * rpc_srv_Return() - Prepare IPC return answer to RPC client
  *   *
 * @cli = Client instance * @c = RPC client 
 * @var = BLOB variable * return: number of arguments in response
 * @data = BLOB data 
 * @tout = BLOB live on server timeout in seconds, if =0 default timeout 
 * return: -1 error, 0 ok, 1 remote error 
  */   */
int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, int rpc_srv_Return(rpc_cli_t *c);
                void * __restrict data, int tout); 
/* 
 * rpc_cli_recvBLOB() - Receive BLOB from server 
 * 
 * @cli = Client instance 
 * @var = BLOB variable 
 * @data = BLOB data, must be e_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 ** __restrict 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 e_free after use! 
 * return: -1 error, 0 ok, >0 remote error 
 */ 
int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var,  
                void ** __restrict data); 
 
 
/* RPC Client side functions */ 
 
/* 
 * rpc_cli_openClient() - Connect to RPC Server 
 * 
 * @InstID = InstID for RPC session request 
 * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet) 
 * @csHost = Host name or IP address for bind server 
 * @Port = Port for bind server, if Port == 0 default port is selected 
 * @proto = Protocol, if == 0 choose SOCK_STREAM 
 * return: NULL == error or !=NULL connection to RPC server established 
 */ 
rpc_cli_t *rpc_cli_openClient(unsigned char InstID, int netBuf,  
                const char *csHost, unsigned short Port, int proto); 
/* 
 * 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_pkt_Send() - Send RPC packet 
 * 
 * @sock = Socket 
 * @type = Type of socket 
 * @sa = Server address 
 * @pkt = RPC packet 
 * @len = Length of packet 
 * return: -1 error or !=-1 sended bytes 
 */ 
int rpc_pkt_Send(int sock, int type, sockaddr_t * __restrict sa,  
                ait_val_t * __restrict pkt, int len); 
/* 
 * rpc_pkt_Receive() - Receive RPC packet 
 * 
 * @sock = Socket 
 * @type = Type of socket 
 * @sa = Server address 
 * @pkt = RPC packet 
 * return: -1 error or !=-1 sended bytes 
 */ 
int rpc_pkt_Receive(int sock, int type, sockaddr_t * __restrict sa,  
                ait_val_t * __restrict pkt); 
/* 
 * rpc_pkt_Request() - Build RPC Request packet 
 * 
 * @pkt = Packet buffer 
 * @sess = RPC session info 
 * @tag = Function tag for execution 
 * @vars = Function argument array of values, may be NULL 
 * @noreply = We not want RPC reply 
 * @nocrc = Without CRC calculation 
 * return: -1 error or != -1 prepared bytes into packet 
 */ 
int rpc_pkt_Request(ait_val_t * __restrict pkt, rpc_sess_t * __restrict sess,  
                unsigned short tag, array_t * __restrict vars, int noreply, int nocrc); 
/* 
 * rpc_pkt_Replay() - Decode RPC Replay packet 
 * 
 * @pkt = Packet buffer 
 * @sess = RPC session info 
 * @tag = Function tag 
 * @vars = Function argument array of values, may be NULL 
 * @nocrc = Without CRC calculation 
 * return: -1 error or != -1 return value from function 
 */ 
int rpc_pkt_Replay(ait_val_t * __restrict pkt, rpc_sess_t * __restrict sess,  
                unsigned short tag, array_t ** __restrict vars, int nocrc); 
/* 
 * rpc_cli_execCall() - Execute RPC call 
 * 
 * @cli = RPC Client session 
 * @noreply = We not want RPC reply 
 * @tag = Function tag for execution 
 * @in_vars = IN function argument array of values, may be NULL 
 * @out_vars = OUT returned array of rpc values, if !=NULL must be free after use with ait_freeVars() 
 * return: -1 error or != -1 ok result 
 */ 
int rpc_cli_execCall(rpc_cli_t *cli, int noreply, unsigned short tag,  
                array_t * __restrict in_vars, array_t ** __restrict out_vars); 
/* 
 * rpc_cli_freeCall() - Free resouce allocated by RPC call 
 * 
 * @out_vars = Returned array with variables from RPC call 
 * return: none 
 */ 
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 
 */ 
int rpc_cli_ping(rpc_cli_t *cli); 
 
 
/* 
 * 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, unsigned 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
Removed from v.1.18  
changed lines
  Added in v.1.28.8.2

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