Diff for /libaitrpc/inc/aitrpc.h between versions 1.4.2.7 and 1.29

version 1.4.2.7, 2011/11/03 14:57:56 version 1.29, 2024/03/20 17:32:30
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, 2011Copyright 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 <sys/queue.h>
#include <sys/types.h>#include <aitrpc_pkt.h>
#include <sys/param.h>#include <aitrpc_cli.h>
#if !defined(__NetBSD__)#include <aitsched.h>
#include <sys/limits.h> 
#endif 
#include <sys/socket.h> 
#include <aitio.h> 
   
   
#define RPC_VERSION             2#define RPC_CALLBACK_CHECK_INPUT(x)       do { \
#define RPC_DEFPORT             2611                                                assert((x)); \
                                                if (!(x)) { \
                                                        rpc_SetErr(EINVAL, \
/* RPC builtin registed calls */                                                                        "Invalid callback parameters ..."); \
 
#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; \                                                          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(22, "Error:: not enough number of arguments!\n"); \  
                                                         return -1; \  
                                                 } \  
                                         } while (0)  
   
   
/* RPC session identification *//* Network RPC server elements */
   
typedef struct {/* RPC function registration element! */
        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 {  typedef struct tagRPCFunc {
        uint16_t                func_tag;        ait_val_t                func_name;
        uint32_t                func_hash; 
        char                    func_file[MAXPATHLEN]; 
        char                    func_name[UCHAR_MAX + 1]; 
   
         array_t                 *func_vars;  
   
         void                    *func_parent;          void                    *func_parent;
        struct tagRPCFunc     *func_next;
         SLIST_ENTRY(tagRPCFunc)        func_next;
         AVL_ENTRY(tagRPCFunc)   func_node;
 } rpc_func_t;  } rpc_func_t;
   #define RPC_FUNC_SERVER(x)      ((rpc_srv_t*) (x)->func_parent)
   
   /* Tree root node */
   typedef struct tagRPCFuncs {
           pthread_mutex_t         mtx;
   
/* Network RPC packet - Client request */        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))
   
 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 *//* BLOB register element */
 
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 { 
        io_sockaddr_t   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 {  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        rpc_sess_t                      srv_session;    /* RPC session registration info */
        int             srv_numcli;     // maximum concurent client connections        int                             srv_netbuf;     /* size of network buffer */
        int                srv_netbuf;     // size of network buffer size        int                             srv_proto;      /* Server protocol */
   
        rpc_cli_t        srv_server; // RPC server socket        pthread_t                       srv_tid;        /* RPC exec pthread */
        rpc_cli_t       *srv_clients;        // connected rpc client sockets        sched_root_task_t               *srv_root;    /* RPC server scheduler */
         intptr_t                        srv_kill;       /* Scheduler condition variable */
   
        rpc_func_t        *srv_funcs;      // registered functions list        rpc_cli_t                   srv_server;     /* RPC server socket */
         array_t                         *srv_clients;      /* connected rpc client sockets */
   
        pthread_mutex_t        srv_mtx;        rpc_funcs_t                     srv_funcs;  /* RPC functions */
        cmd_type_t      srv_kill; 
   
         struct {          struct {
                cmd_type_t      state;               // BLOB server state: ==0 disable | !=0 enable                pthread_t                       tid;               /* BLOB exec pthread */
                char            dir[UCHAR_MAX + 1];                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 *
 * @arg2 = number of items in input array from call request * @arg1 = RPC client
  * @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 *);
   
   #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_srv_DispatchSignal() - Enable/Disable Signal dispatcher for RPC scheduler
  *
  * @x = RPC server instance
  * @y = Enable or =0 Disable
  * return: 0 enabled signal dispatcher. See schedSignalDispatch() in libaitsched
  */
 #define rpc_srv_DispatchSignal(x, y)    schedSignalDispatch((x)->srv_root, (y))
   
// 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_chkPktSession() Check session in RPC packet * rpc_register_srvPing() - Register ping service function
 * @p = packet session *
 * @s = active session * @srv = RPC server instance
  * return: -1 error or 0 ok   * return: -1 error or 0 ok
  */   */
inline int rpc_chkPktSession(rpc_sess_t *p, rpc_sess_t *s);int rpc_register_srvPing(rpc_srv_t * __restrict srv);
 /*  /*
 * rpc_addPktSession() Add session into RPC packet * rpc_register_srvServices() - Register internal service functions
 * @p = packet session *
 * @s = active session * @srv = RPC server instance
  * 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_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 */
   
 /*  /*
 * rpc_srv_initServer() Init & create RPC Server * rpc_srv_initServer() - Init & create RPC Server
 * @regProgID = ProgramID for authentication & recognition *
 * @regProcID = ProcessID for authentication & recognition * @InstID = Instance 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
  *
  * @psrv = RPC Server instance   * @psrv = RPC Server instance
  * return: none   * return: none
  */   */
 void rpc_srv_endServer(rpc_srv_t ** __restrict psrv);  void rpc_srv_endServer(rpc_srv_t ** __restrict psrv);
 /*  /*
 * rpc_srv_loopServer() Execute Main server loop and wait for clients requests * rpc_srv_loopServer() - Execute Main server loop and wait for clients requests
  *
  * @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_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) \
                                                pthread_create(&__tid, NULL, (void*(*)(void*)) \        do { assert((_srv)); \
                                                                rpc_srv_loopServer, (_srv)); \                if (!(_srv)->srv_kill) { \
                                                if ((_sync)) \                        pthread_create(&(_srv)->srv_tid, NULL, (void*(*)(void*)) \
                                                        pthread_join(__tid, (void**) (_sync)); \                                        rpc_srv_loopServer, (_srv)); \
                                                else \                        if ((_sync)) \
                                                        pthread_detach(__tid); \                                pthread_join((_srv)->srv_tid, (void**) (_sync)); \
                                        } while (0)                        else \
                                 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
  *
  * @srv = RPC server instance   * @srv = RPC server instance
  * @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, 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
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * return: none   * return: none
  */   */
 void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv);  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv);
 /*  /*
 * rpc_srv_loopBLOB() Execute Main BLOB server loop and wait for clients requests * rpc_srv_loopBLOB() - Execute Main BLOB server loop and wait for clients requests
  *
  * @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) \
                                                if ((_srv)->srv_blob.state == enable) { \        do { assert((_srv)); \
                                                        pthread_create(&__tid, NULL, (void*(*)(void*)) \                if (!(_srv)->srv_kill && !(_srv)->srv_blob.kill) { \
                                                                        rpc_srv_loopBLOB, (_srv)); \                        pthread_create(&(_srv)->srv_blob.tid, NULL, \
                                                        pthread_detach(__tid); \                                        (void*(*)(void*)) rpc_srv_loopBLOBServer, (_srv)); \
                                                        (_srv)->srv_blob.state = running; \                        pthread_detach((_srv)->srv_blob.tid); \
                                                } \                } \
                                        } while (0)        } while (0)
   
 /*  /*
 * rpc_srv_registerCall() Register call to RPC server * rpc_srv_initServer2() - Init & create layer2 RPC Server
 * @srv = RPC Server instance *
 * @csModule = Module name, if NULL self binary * @InstID = Instance for authentication & recognition
 * @csFunc = Function name * @concurentClients = Concurent clients at same time to this server
 * @args = Number of return function arguments, use for restriction case! * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
 * return: -1 error or 0 register ok * @csIface = Interface name for bind server, if NULL first interface on host
  * return: NULL == error or !=NULL bind and created RPC server instance
  */   */
int rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, rpc_srv_t *rpc_srv_initServer2(u_char InstID, int concurentClients, int netBuf, 
                unsigned short args);                const char *csIface);
 
 /*  /*
 * rpc_srv_unregisterCall() Unregister call from RPC server * 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
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
 * @csModule = Module name, if NULL self binary * @tag = Function tag
 * @csFunc = Function name * @funcaddr = Function address
 * return: -1 error, 0 not found call, 1 unregister ok * return: -1 error, 0 already registered tag or 1 register ok
  */   */
int rpc_srv_unregisterCall(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);
 /*  /*
 * rpc_srv_getFunc() Get registered call from RPC server by Name * 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: NULL not found call, !=NULL return call 
  */   */
rpc_func_t *rpc_srv_getFunc(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_getCall() Get registered call from RPC server * rpc_srv_getCall()  - Get registered call from RPC server
  *
  * @srv = RPC Server instance   * @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_allocVars() Allocate array for call variables * rpc_srv_blobCreate() - Create and map blob to memory region and return object
 * @call = RPC function call *
 * @varnum = Number of variables, if ==0 return already allocated variables number 
 * return: -1 error, !=-1 return varnum value 
 */ 
inline int rpc_srv_allocVars(rpc_func_t * __restrict call, int varnum); 
/* 
 * rpc_srv_freeVars() Clean values from variables of array 
 * @call = RPC function call 
 * return: -1 error, !=-1 Returned number of cleaned variables 
 */ 
inline int rpc_srv_freeVars(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   * @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 
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @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
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @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
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @var = BLOB Variable for unregister   * @var = BLOB Variable for unregister
  * 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  * rpc_srv_getBLOB() - Get registered BLOB 
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @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
  *
  * @cli = Client instance   * @cli = Client instance
  * @blob = Mapped BLOB element   * @blob = Mapped BLOB element
  * return: -1 error, 0 ok   * return: -1 error, 0 ok
  */   */
 int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);  int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);
 /*  /*
 * rpc_srv_recvBLOB() Receive BLOB from client * rpc_srv_recvBLOB() - Receive BLOB from client
  *
  * @cli = Client instance   * @cli = Client instance
  * @blob = Mapped BLOB element   * @blob = Mapped BLOB element
  * return: -1 error, 0 ok, >0 unreceived data from client, may be error?   * 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);  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 *
 * @var = BLOB variable * @c = RPC client 
 * @data = BLOB data * return: number of arguments in response
 * 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_srv_Return(rpc_cli_t *c);
/* 
 * 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 ** __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 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 ** __restrict 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_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

Removed from v.1.4.2.7  
changed lines
  Added in v.1.29


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