[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.6 and 1.22.2.1

version 1.6, 2012/03/15 01:55:32 version 1.22.2.1, 2014/01/28 14:04:56
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, 2012Copyright 2004 - 2014
         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 57  SUCH DAMAGE. Line 57  SUCH DAMAGE.
 #include <sys/limits.h>  #include <sys/limits.h>
 #endif  #endif
 #include <sys/socket.h>  #include <sys/socket.h>
#include <aitio.h>#include <sys/queue.h>
 #include <elwix.h>
 #include <aitsched.h>  #include <aitsched.h>
   
   
#define RPC_VERSION             3#define RPC_VERSION             7
 #define RPC_DEFPORT             2611  #define RPC_DEFPORT             2611
   
 /* RPC call request flags */  /* RPC call request flags */
Line 71  SUCH DAMAGE. Line 72  SUCH DAMAGE.
   
 /* RPC builtin registed calls */  /* RPC builtin registed calls */
   
#define CALL_BLOBSHUTDOWN    "rpcBLOBServerShutdown"#define CALL_TAG_MAX         65535
#define CALL_BLOBCLIENTS        "rpcBLOBServerClients" 
#define CALL_BLOBVARS           "rpcBLOBServerVars" 
#define CALL_BLOBSTATE          "rpcBLOBServerState" 
   
#define CALL_SRVSHUTDOWN        "rpcServerShutdown"#define CALL_SRVPING            65534
#define CALL_SRVCLIENTS         "rpcServerClients" 
#define CALL_SRVCALLS           "rpcServerCalls" 
#define CALL_SRVSESSIONS        "rpcServerSessions" 
   
   #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 */  /* RPC types */
   
 typedef enum {  typedef enum {
         disable, enable, running, kill,         /* for blob.state */  
         ok, error, no,                          /* for blob reply */          ok, error, no,                          /* for blob reply */
         get, set, unset                         /* for blob request */          get, set, unset                         /* for blob request */
} cmd_type_t;} blob_cmd_type_t;
   
   
#define RPC_CALLBACK_CHECK_INPUT(_f)       do { \#define RPC_CALLBACK_CHECK_INPUT(x)       do { \
                                                assert((_f)); \                                                assert((x)); \
                                                if (!(_f)) { \                                                if (!(x)) { \
                                                         rpc_SetErr(EINVAL, \                                                          rpc_SetErr(EINVAL, \
                                                                         "Invalid callback parameters ..."); \                                                                          "Invalid callback parameters ..."); \
                                                         return -1; \                                                          return -1; \
                                                 } \                                                  } \
                                         } while (0)                                          } 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(EINVAL, \  
                                                                         "Not enough number of arguments!"); \  
                                                         return -1; \  
                                                 } \  
                                         } while (0)  
   
   
 /* RPC session identification */  /* RPC session identification */
   
 typedef struct {  typedef struct {
        uint8_t             sess_version;#if BYTE_ORDER == LITTLE_ENDIAN
        uint8_t             sess_timeout;        uint16_t    sess_instance:8;
        uint32_t      sess_program;        uint16_t        sess_version:8;
        uint32_t      sess_process;#endif
} __packed rpc_sess_t;#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 ... */  /* Server managment RPC functions ... */
   
 /* RPC function registration element! */  
 typedef struct tagRPCFunc {  
         uint16_t                func_tag;  
         uint32_t                func_hash;  
         ait_val_t               func_file;  
         ait_val_t               func_name;  
   
         array_t                 *func_vars;  
   
         void                    *func_parent;  
         struct tagRPCFunc       *func_next;  
 } rpc_func_t;  
   
   
 /* Network RPC packet - Client request */  /* Network RPC packet - Client request */
   
 struct tagRPCCall {  struct tagRPCCall {
         rpc_sess_t      call_session;          rpc_sess_t      call_session;
   
        uint16_t        call_tag;        uint32_t        call_len;
        uint32_t        call_hash;        uint16_t        call_crc;
        uint16_t        call_argc; 
   
         union {          union {
                 struct {                  struct {
Line 154  struct tagRPCCall { Line 140  struct tagRPCCall {
                 }       call_rep;                  }       call_rep;
         };          };
   
        uint16_t        call_crc;        uint16_t        call_tag;
} __packed;        uint16_t        call_argc;
         ait_val_t       call_argv[0];
 } __packed;                     /* size == 20 bytes */
 #define RPC_CHK_NOREPLY(x)      (ntohl((u_long) (x)->call_req.flags) & RPC_NOREPLY)
 #define RPC_SET_ERRNO(x, _v)    ((x)->call_rep.eno = htonl((_v)))
   
 /* Network BLOB packet - Header */  /* Network BLOB packet - Header */
   
Line 165  struct tagBLOBHdr { Line 155  struct tagBLOBHdr {
         uint32_t        hdr_var;          uint32_t        hdr_var;
         uint32_t        hdr_len;          uint32_t        hdr_len;
         uint32_t        hdr_ret;          uint32_t        hdr_ret;
         uint16_t        hdr_crc;  
         uint8_t         hdr_pad;          uint8_t         hdr_pad;
} __packed;} __packed;                     /* size == 16 bytes */
   
 /* Network RPC client & server elements */  /* Network RPC client & server elements */
   
typedef struct {/* RPC function registration element! */
        io_sockaddr_t   cli_sa;         // host infotypedef struct tagRPCFunc {
        int             cli_sock;       // socket fd        ait_val_t               func_name;
        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                    *func_parent;
        int             cli_netbuf;     // size of network buffer size 
} rpc_cli_t; 
   
           SLIST_ENTRY(tagRPCFunc) func_next;
           AVL_ENTRY(tagRPCFunc)   func_node;
   } rpc_func_t;
   #define RPC_FUNC_SERVER(x)      ((rpc_srv_t*) (x)->func_parent)
   
/* BLOB registration element! *//* Tree root node */
 typedef struct tagRPCFuncs {
         pthread_mutex_t         mtx;
 
         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))
 
 
 /* BLOB register element */
 typedef struct tagBLOB {  typedef struct tagBLOB {
        uint32_t        blob_var;        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        int             cli_id;         /* slot id */
        int                     srv_numcli;     // maximum concurent client connections        int             cli_sock;       /* socket fd */
        int                     srv_netbuf;    // size of network buffer size        sockaddr_t      cli_sa;         /* host address */
         ait_val_t       cli_buf;    /* network buffer */
   
        rpc_cli_t               srv_server;     // RPC server socket        array_t              *cli_vars;      /* function return variables */
        rpc_cli_t              *srv_clients;      // connected rpc client sockets 
   
        rpc_func_t          *srv_funcs;  // registered functions list        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)
   
        pthread_mutex_t                srv_mtx;typedef struct {
        cmd_type_t                srv_kill;        rpc_sess_t                      srv_ses        rpc_sess_t                      srv_session;   /* RPC session registration info */
         int                             srv_netbuf; /* size of network buffer */
         int                             srv_proto;      /* Server protocol */
   
           pthread_t                       srv_tid;        /* RPC exec pthread */
           sched_root_task_t               *srv_root;      /* RPC server scheduler */
           intptr_t                        srv_kill;       /* Scheduler condition variable */
   
           rpc_cli_t                       srv_server;     /* RPC server socket */
           array_t                         *srv_clients;   /* connected rpc client sockets */
   
           rpc_funcs_t                     srv_funcs;      /* RPC functions */
   
         struct {          struct {
                cmd_type_t      state;               // BLOB server state: ==0 disable | !=0 enable                pthread_t                       tid;               /* BLOB exec pthread */
                ait_val_t       dir;                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;
   
   
 /*   /* 
  * (*rpc_callback_t)() - Callback type definition for RPC call in server process   * (*rpc_callback_t)() - Callback type definition for RPC call in server process
  *   *
 * @arg1 = current execution RPC call function * @arg1 = RPC client
 * @arg2 = number of items in input array from call request * @arg2 = RPC packet header
  * @arg3 = input array with values from RPC call execution request   * @arg3 = input array with values from RPC call execution request
  * return: -1 error or >-1 success execution   * return: -1 error or >-1 success execution
  */   */
typedef int (*rpc_callback_t)(rpc_func_t *, int, array_t *);typedef int (*rpc_callback_t)(rpc_cli_t *, struct tagRPCCall *, array_t *);
   
   
// -----------------------------------------------------------------------/* ----------------------------------------------------------------------- */
   
 /* Error support functions */  /* Error support functions */
   
 // rpc_GetErrno() Get error code of last operation  // rpc_GetErrno() Get error code of last operation
inline int rpc_GetErrno();int rpc_GetErrno();
 // rpc_GetError() Get error text of last operation  // rpc_GetError() Get error text of last operation
inline const char *rpc_GetError();const char *rpc_GetError();
 // rpc_SetErr() Set error to variables for internal use!!!
 void rpc_SetErr(int eno, char *estr, ...);
   
   
   
 /*  /*
 * rpc_chkPktSession() - Check session in RPC packet * rpc_Read() - RPC read operation
  *   *
    * @sock = socket
    * @type = type of socket
    * @flags = receive flags
    * @sa = check client address, if you use udp protocol
    * @buf = buffer
    * @blen = buffer length
    * return: -1 error, 0 EOF or or >0 readed bytes into buffer
    */
   ssize_t rpc_Read(int sock, int type, int flags, sockaddr_t * __restrict sa, 
                   unsigned char * __restrict buf, size_t blen);
   /*
    * rpc_Write() - RPC write operation
    *
    * @sock = socket
    * @type = type of socket
    * @flags = send flags
    * @sa = send to client address, if you use udp protocol
    * @buf = buffer
    * @blen = buffer length
    * return: -1 error, 0 EOF or >0 written bytes into buffer
    */
   ssize_t rpc_Write(int sock, int type, int flags, sockaddr_t * __restrict sa, 
                   unsigned char * __restrict buf, size_t blen);
   
   /*
    * rpc_chkPktSession() - Check RPC session
    *
  * @p = packet session   * @p = packet session
  * @s = active session   * @s = active session
 * return: -1 error or 0 ok * return: -1, 1, 2, 3 are errors or 0 ok
  */   */
inline int rpc_chkPktSession(rpc_sess_t *p, rpc_sess_t *s);int rpc_chkPktSession(rpc_sess_t *p, rpc_sess_t *s);
 /*  /*
 * rpc_addPktSession() - Add session into RPC packet * rpc_addPktSession() - Prepare session into network format
  *   *
  * @p = packet session   * @p = packet session
 * @s = active session * @s = host session
  * return: -1 error or 0 ok   * return: -1 error or 0 ok
  */   */
inline int rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s);int rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s);
 /*
  * rpc_register_srvPing() - Register ping service function
  *
  * @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 */
Line 262  inline int rpc_addPktSession(rpc_sess_t *p, rpc_sess_t Line 332  inline int rpc_addPktSession(rpc_sess_t *p, rpc_sess_t
 /*  /*
  * rpc_srv_initServer() - Init & create RPC Server   * rpc_srv_initServer() - Init & create RPC Server
  *   *
 * @regProgID = ProgramID for authentication & recognition * @InstID = Instance 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
 * @netBuf = Network buffer length, if =0 == BUFSIZ (also meaning max RPC packet) * @netBuf = Network buffer length (min:512 bytes), 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   * @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, 
                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
  *   *
Line 287  void rpc_srv_endServer(rpc_srv_t ** __restrict psrv); Line 356  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)); pthread_t __tid; \#define rpc_srv_execServer(_srv, _sync) do { assert((_srv)); \
                                                pthread_create(&__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(__tid, (void**) (_sync)); \                                                        if ((_sync)) \
                                                else \                                                                pthread_join((_srv)->srv_tid, (void**) (_sync)); \
                                                        pthread_detach(__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 304  int rpc_srv_loopServer(rpc_srv_t * __restrict srv); Line 375  int rpc_srv_loopServer(rpc_srv_t * __restrict srv);
  * @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, 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
  *   *
Line 318  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 389  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
  * @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_loopBLOB(rpc_srv_t * __restrict srv);int rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv);
#define rpc_srv_execBLOBServer(_srv)    do { assert((_srv)); pthread_t __tid; \#define rpc_srv_execBLOBServer(_srv)    do { assert((_srv)); \
                                                if ((_srv)->srv_blob.state == enable) { \                                                if (!(_srv)->srv_kill && !(_srv)->srv_blob.kill) { \
                                                        pthread_create(&__tid, NULL, (void*(*)(void*)) \                                                        pthread_create(&(_srv)->srv_blob.tid, NULL, \
                                                                        rpc_srv_loopBLOB, (_srv)); \                                                                        (void*(*)(void*)) \
                                                        pthread_detach(__tid); \                                                                        rpc_srv_loopBLOBServer, (_srv)); \
                                                        (_srv)->srv_blob.state = running; \                                                        pthread_detach((_srv)->srv_blob.tid); \
                                                 } \                                                  } \
                                         } while (0)                                          } while (0)
   
Line 332  int rpc_srv_loopBLOB(rpc_srv_t * __restrict srv); Line 403  int rpc_srv_loopBLOB(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 * @tag = Function tag
 * @csFunc = Function name * @funcaddr = Function address
 * @args = Number of return function arguments, use for restriction case! * return: -1 error, 0 already registered tag or 1 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, unsigned short tag, void *funcaddr);
                unsigned short args); 
 /*  /*
  * rpc_srv_unregisterCall() - Unregister call from RPC server   * 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: -1 error, 0 not found call, 1 unregister ok
  */   */
int rpc_srv_unregisterCall(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_getFunc() - Get registered call from RPC server by Name * rpc_srv_getCall()  - Get registered call from RPC server
  *   *
  * @srv = RPC Server instance   * @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   * @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
  *   *
 * @call = Register RPC call * @cli = RPC client
  * @rpc = IN RPC call structure   * @rpc = IN RPC call structure
    * @funcname = Execute RPC function
  * @args = IN RPC calling arguments from RPC client   * @args = IN RPC calling arguments from RPC client
  * return: -1 error, !=-1 ok   * return: -1 error, !=-1 ok
  */   */
int rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc, int rpc_srv_execCall(rpc_cli_t * __restrict cli, struct tagRPCCall * __restrict rpc, 
                array_t * __restrict args);                ait_val_t funcname, array_t * __restrict args);
   
   
 /*  /*
 * rpc_srv_getVars() - Get variables array for RPC call * rpc_srv_blobCreate() - Create and map blob to memory region and return object
  *   *
  * @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   * @srv = RPC Server instance
  * @len = BLOB length object   * @len = BLOB length object
    * @tout = BLOB live timeout in seconds
  * return: NULL error or !=NULL allocated BLOB object   * return: NULL error or !=NULL allocated BLOB object
  */   */
inline rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len);rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len, int tout);
 /*  /*
  * rpc_srv_blobMap() - Map blob to memory region    * rpc_srv_blobMap() - Map blob to memory region 
  *   *
Line 403  inline rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __re Line 453  inline rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __re
  * @blob = Map to this BLOB element   * @blob = Map to this BLOB element
  * return: -1 error or 0 ok   * return: -1 error or 0 ok
  */   */
inline int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
 /*  /*
  * rpc_srv_blobUnmap() - Unmap blob memory region    * rpc_srv_blobUnmap() - Unmap blob memory region 
  *   *
  * @blob = Mapped BLOB element   * @blob = Mapped BLOB element
  * return: none   * return: none
  */   */
inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob);void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob);
 /*  /*
  * rpc_srv_blobFree() - Free blob from disk & memory   * rpc_srv_blobFree() - Free blob from disk & memory
  *   *
Line 418  inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict  Line 468  inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict 
  * @blob = Mapped BLOB element   * @blob = Mapped BLOB element
  * return: -1 error or 0 ok   * return: -1 error or 0 ok
  */   */
inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
   
 /*  /*
  * 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
    * @tout = BLOB live timeout in seconds
  * return: NULL error or new registered BLOB   * 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, int tout);
 /*  /*
  * rpc_srv_unregisterBLOB() - Unregister BLOB from server   * rpc_srv_unregisterBLOB() - Unregister BLOB from server
  *   *
Line 443  int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, Line 494  int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv,
  * @var = hash for variable   * @var = hash for variable
  * return: NULL not found, !=NULL return blob var   * return: NULL not found, !=NULL return blob var
  */   */
inline rpc_blob_t *rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var);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 470  int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_b Line 521  int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_b
  * @cli = Client instance   * @cli = Client instance
  * @var = BLOB variable   * @var = BLOB variable
  * @data = BLOB data   * @data = BLOB data
    * @tout = BLOB live on server timeout in seconds, if =0 default timeout
  * return: -1 error, 0 ok, 1 remote error   * 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);int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, 
                 void * __restrict data, int tout);
 /*  /*
  * rpc_cli_recvBLOB() - Receive BLOB from server   * rpc_cli_recvBLOB() - Receive BLOB from server
  *   *
  * @cli = Client instance   * @cli = Client instance
  * @var = BLOB variable   * @var = BLOB variable
 * @data = BLOB data, must be free after use! * @data = BLOB data, must be e_free after use!
  * return: -1 error, 0 ok, 1 remote error   * 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);  int rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void ** __restrict data);
Line 495  int rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_va Line 548  int rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_va
  *   *
  * @cli = Client instance   * @cli = Client instance
  * @var = BLOB variable   * @var = BLOB variable
 * @data = BLOB data, must be free after use! * @data = BLOB data, must be e_free after use!
  * return: -1 error, 0 ok, >0 remote error   * return: -1 error, 0 ok, >0 remote error
  */   */
inline int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, 
                 void ** __restrict data);                  void ** __restrict data);
   
   
 /*  
  * rpc_calcHashes() - Calculate hashes for RPC call  
  *  
  * @func = function  
  * @csModule = Module name, if NULL self binary  
  * @csFunc = Function name  
  * return: -1 error or 0 ok  
  */  
 int rpc_calcHashes(rpc_func_t * __restrict func, const char *csModule, const char *csFunc);  
   
   
 /* RPC Client side functions */  /* RPC Client side functions */
   
 /*  /*
  * rpc_cli_openClient() - Connect to RPC Server   * rpc_cli_openClient() - Connect to RPC Server
  *   *
 * @ProgID = ProgramID for RPC session request * @InstID = InstID for RPC session request
 * @ProcID = ProcessID for RPC session request * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
 * @netBuf = Network buffer length, if =0 == BUFSIZ (also meaning max RPC packet) 
 * @Timeout = RPC timeout in seconds, if =0 set default RPC timeout 
 * @family = Family socket type, AF_INET or AF_INET6 
  * @csHost = Host name or IP address for bind server   * @csHost = Host name or IP address for bind server
  * @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 connection to RPC server established   * return: NULL == error or !=NULL connection to RPC server established
  */   */
rpc_cli_t *rpc_cli_openClient(unsigned int ProgID, unsigned int ProcID, int netBuf, rpc_cli_t *rpc_cli_openClient(unsigned char InstID, int netBuf, 
                unsigned char Timeout, unsigned short family,                 const char *csHost, unsigned short Port, int proto);
                const char *csHost, unsigned short Port); 
 /*  /*
    * rpc_cli_reconnectClient() - Reconnecting client to RPC server
    *
    * @cli = RPC Client session
    * return: -1 error or 0 ok
    */
   int rpc_cli_reconnectClient(rpc_cli_t * __restrict cli);
   /*
  * 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
  * return: none   * return: none
  */   */
void rpc_cli_closeClient(rpc_cli_t * __restrict cli);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, 0  EOF or >0 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, 0 EOF or >0 received 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   * rpc_cli_execCall() - Execute RPC call
  *   *
  * @cli = RPC Client session   * @cli = RPC Client session
 * @csModule = Module name, if NULL self binary * @noreply = We not want RPC reply
 * @csFunc = Function name for execute * @tag = Function tag for execution
 * @in_vars = IN RPC call array of rpc values * @in_vars = IN function argument array of values, may be NULL
 * @out_vars = OUT returned array of rpc values, must be free after use with rpc_cli_freeVals() * @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 * return: -1 error, 0 ok result or 1 closed rpc connection
  */   */
int rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, const char *csFunc, int rpc_cli_execCall(rpc_cli_t *cli, int noreply, unsigned short tag, 
                 array_t * __restrict in_vars, array_t ** __restrict out_vars);                  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);
   
   
 /*  /*
Line 558  int rpc_cli_execCall(rpc_cli_t *cli, const char *csMod Line 666  int rpc_cli_execCall(rpc_cli_t *cli, const char *csMod
  * @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 BLOB server established   * 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_t *rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, unsigned short Port);
 /*  /*
  * rpc_cli_closeBLOBClient() - Close connection to BLOB server and free resources   * rpc_cli_closeBLOBClient() - Close connection to BLOB server and free resources
  *   *
  * @cli = BLOB Client session   * @cli = BLOB Client session
  * return: none   * return: none
  */   */
void rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli);void rpc_cli_closeBLOBClient(rpc_cli_t ** __restrict cli);
   
   
 #endif  #endif
Removed from v.1.6  
changed lines
  Added in v.1.22.2.1

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