Diff for /libaitrpc/inc/aitrpc.h between versions 1.2.4.8 and 1.5.2.2

version 1.2.4.8, 2011/08/19 12:51:50 version 1.5.2.2, 2012/03/12 14:53:07
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, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
         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 50  SUCH DAMAGE. Line 50  SUCH DAMAGE.
 #include <assert.h>  #include <assert.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   #include <errno.h>
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/param.h>  #include <sys/param.h>
 #if !defined(__NetBSD__)  #if !defined(__NetBSD__)
 #include <sys/limits.h>  #include <sys/limits.h>
 #endif  #endif
 #include <sys/socket.h>  #include <sys/socket.h>
   #include <aitio.h>
   #include <aitsched.h>
   
   
#define RPC_VERSION             1#define RPC_VERSION             3
 #define RPC_DEFPORT             2611  #define RPC_DEFPORT             2611
   
   
Line 78  SUCH DAMAGE. Line 81  SUCH DAMAGE.
 /* RPC types */  /* RPC types */
   
 typedef enum {  typedef enum {
        empty,                          // empty -> variable is not set        disable, enable, running, kill,  /* for blob.state */
        buffer, string, blob,           // buffer -> uint8_t*; string -> int8_t*; blob -> void*(+socket);        ok, error,                              /* for blob reply */
        size, offset, datetime,         // size -> size_t; offset -> off_t; datetime -> time_t;        get, set, unset                         /* for blob request */
        real, bigreal,                  // real -> float; bigreal -> double; 
        u8, u16, u32, u64,              // unsigned integers ... 
        i8, i16, i32, i64               // integers ... 
} rpc_type_t; 
 
typedef enum { 
        disable, enable, kill,           // for blob.state 
        ok, error,                      // for blob reply 
        get, set, unset                 // for blob request 
 } cmd_type_t;  } cmd_type_t;
   
 /* RPC value */  
   
typedef struct {#define RPC_CALLBACK_CHECK_INPUT(_f)       do { \
        rpc_type_t      val_type;                                                assert((_f)); \
        size_t          val_len;                                                if (!(_f)) { \
        union {                                                        rpc_SetErr(EINVAL, \
                uint8_t         *buffer;                                                                        "Invalid callback parameters ..."); \
                int8_t          *string; 
                uint32_t        blob; 
                size_t          size; 
                off_t           offset; 
                time_t          datetime; 
                float           real; 
                double          bigreal; 
                uint8_t         u8; 
                uint16_t        u16; 
                uint32_t        u32; 
                uint64_t        u64; 
                int8_t          i8; 
                int16_t         i16; 
                int32_t         i32; 
                int64_t         i64; 
        } val; 
} __packed rpc_val_t; 
 
#define RPC_TYPE_VAL(vl)                ((vl)->val_type) 
#define RPC_LEN_VAL(vl)                 ((vl)->val_len) 
#define RPC_BLOB_CHUNKS(vl, n)          ((vl)->val_len / (n) + ((vl)->val_len % (n)) ? 1 : 0) 
#define RPC_EMPTY_VAL(vl)               ((vl)->val_type == empty) 
 
#define RPC_GET_BUF(vl)                 (assert((vl)->val_type == buffer), (vl)->val.buffer) 
#define RPC_GET_STR(vl)                 (assert((vl)->val_type == string), (vl)->val.string) 
#define RPC_GET_BLOB(vl)                (assert((vl)->val_type == blob), (vl)->val.blob) 
#define RPC_GET_SIZE(vl)                (assert((vl)->val_type == size), (vl)->val.size) 
#define RPC_GET_OFF(vl)                 (assert((vl)->val_type == offset), (vl)->val.offset) 
#define RPC_GET_TIME(vl)                (assert((vl)->val_type == datetime), (vl)->val.datetime) 
#define RPC_GET_REAL(vl)                (assert((vl)->val_type == real), (vl)->val.real) 
#define RPC_GET_BREAL(vl)               (assert((vl)->val_type == bigreal), (vl)->val.bigreal) 
#define RPC_GET_U8(vl)                  (assert((vl)->val_type == u8), (vl)->val.u8) 
#define RPC_GET_U16(vl)                 (assert((vl)->val_type == u16), (vl)->val.u16) 
#define RPC_GET_U32(vl)                 (assert((vl)->val_type == u32), (vl)->val.u32) 
#define RPC_GET_U64(vl)                 (assert((vl)->val_type == u64), (vl)->val.u64) 
#define RPC_GET_I8(vl)                  (assert((vl)->val_type == i8), (vl)->val.i8) 
#define RPC_GET_I16(vl)                 (assert((vl)->val_type == i16), (vl)->val.i16) 
#define RPC_GET_I32(vl)                 (assert((vl)->val_type == i32), (vl)->val.i32) 
#define RPC_GET_I64(vl)                 (assert((vl)->val_type == i64), (vl)->val.i64) 
 
#define RPC_SET_BUF(vl, v, l)           do { rpc_val_t *val = (vl); assert(val); val->val.buffer = malloc(l); \ 
                                                if (val->val.buffer) { \ 
                                                        val->val_type = buffer; val->val_len = l; \ 
                                                        memcpy(val->val.buffer, v, l); \ 
                                                } } while (0) 
#define RPC_SET_STR(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val.string = (int8_t*) strdup(v); \ 
                                                if (val->val.string) { \ 
                                                        val->val_type = string; val->val_len = strlen(v) + 1; \ 
                                                } } while (0) 
#define RPC_SET_BLOB(vl, v, l)          do { rpc_val_t *val = (vl); assert(val); val->val_type = blob; \ 
                                                val->val.blob = v; val->val_len = l; } while (0) 
#define RPC_SET_BLOB2(vl, b)            do { rpc_val_t *val = (vl); assert(val); assert(b); val->val_type = blob; \ 
                                                val->val.blob = b->blob_var; val->val_len = b->blob_len; } while (0) 
#define RPC_SET_SIZE(vl, v)             do { rpc_val_t *val = (vl); assert(val); val->val_type = size; val->val.size = v; \ 
                                                val->val_len = sizeof(size_t); } while (0) 
#define RPC_SET_OFF(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val_type = offset; val->val.offset = v; \ 
                                                val->val_len = sizeof(off_t); } while (0) 
#define RPC_SET_TIME(vl, v)             do { rpc_val_t *val = (vl); assert(val); val->val_type = datetime; val->val.datetime = v; \ 
                                                val->val_len = sizeof(time_t); } while (0) 
#define RPC_SET_REAL(vl, v)             do { rpc_val_t *val = (vl); assert(val); val->val_type = real; val->val.real = v; \ 
                                                val->val_len = sizeof(float); } while (0) 
#define RPC_SET_BREAL(vl, v)            do { rpc_val_t *val = (vl); assert(val); val->val_type = bigreal; val->val.bigreal = v; \ 
                                                val->val_len = sizeof(double); } while (0) 
#define RPC_SET_U8(vl, v)               do { rpc_val_t *val = (vl); assert(val); val->val_type = u8; val->val.u8 = v; \ 
                                                val->val_len = sizeof(uint8_t); } while (0) 
#define RPC_SET_U16(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val_type = u16; val->val.u16 = v; \ 
                                                val->val_len = sizeof(uint16_t); } while (0) 
#define RPC_SET_U32(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val_type = u32; val->val.u32 = v; \ 
                                                val->val_len = sizeof(uint32_t); } while (0) 
#define RPC_SET_U64(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val_type = u64; val->val.u64 = v; \ 
                                                val->val_len = sizeof(uint64_t); } while (0) 
#define RPC_SET_I8(vl, v)               do { rpc_val_t *val = (vl); assert(val); val->val_type = i8; val->val.i8 = v; \ 
                                                val->val_len = sizeof(int8_t); } while (0) 
#define RPC_SET_I16(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val_type = i16; val->val.i16 = v; \ 
                                                val->val_len = sizeof(int16_t); } while (0) 
#define RPC_SET_I32(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val_type = i32; val->val.i32 = v; \ 
                                                val->val_len = sizeof(int32_t); } while (0) 
#define RPC_SET_I64(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val_type = i64; val->val.i64 = v; \ 
                                                val->val_len = sizeof(int64_t); } while (0) 
 
#define RPC_FREE_VAL(vl)                do { rpc_val_t *val = (vl); assert(val); \ 
                                                if (val->val_type == buffer && val->val.buffer) { \ 
                                                        free(val->val.buffer); \ 
                                                        val->val.buffer = NULL; \ 
                                                } \ 
                                                if (val->val_type == string && val->val.string) { \ 
                                                        free(val->val.string); \ 
                                                        val->val.string = NULL; \ 
                                                } \ 
                                                val->val_type = val->val_len = 0; \ 
                                        } while (0) 
 
 
#define RPC_CALLBACK_CHECK_INPUT(x)       do { \ 
                                                if (!x) { \ 
                                                        rpc_SetErr(22, "Error:: invalid callback parameters ...\n"); \ 
                                                         return -1; \                                                          return -1; \
                                                 } \                                                  } \
                                         } while (0)                                          } while (0)
#define RPC_CALLBACK_CHK_ARGS(f, n)     do { \#define RPC_CALLBACK_CHK_ARGS(_f, _n)      do { \
                                                RPC_CALLBACK_CHECK_INPUT(f); \                                                RPC_CALLBACK_CHECK_INPUT((_f)); \
                                                if (f && f->func_args != n) { \                                                if ((_f) && io_arraySize((_f)->func_vars) < _n) { \
                                                        rpc_SetErr(22, "Error:: different number of arguments!\n"); \                                                        rpc_SetErr(EINVAL, \
                                                                         "Not enough number of arguments!"); \
                                                         return -1; \                                                          return -1; \
                                                 } \                                                  } \
                                         } while (0)                                          } while (0)
Line 211  typedef struct { Line 109  typedef struct {
   
 typedef struct {  typedef struct {
         uint8_t         sess_version;          uint8_t         sess_version;
           uint8_t         sess_timeout;
         uint32_t        sess_program;          uint32_t        sess_program;
         uint32_t        sess_process;          uint32_t        sess_process;
 } __packed rpc_sess_t;  } __packed rpc_sess_t;
Line 218  typedef struct { Line 117  typedef struct {
   
 /* Server managment RPC functions ... */  /* Server managment RPC functions ... */
   
// RPC function registration element!/* RPC function registration element! */
 typedef struct tagRPCFunc {  typedef struct tagRPCFunc {
         uint16_t                func_tag;          uint16_t                func_tag;
         uint32_t                func_hash;          uint32_t                func_hash;
        int8_t                        func_file[MAXPATHLEN];        char                        func_file[MAXPATHLEN];
        int8_t                        func_name[UCHAR_MAX + 1];        char                        func_name[UCHAR_MAX + 1];
   
        int8_t                  func_args;        array_t                 *func_vars;
        rpc_val_t                *func_vars; 
   
         void                    *func_parent;          void                    *func_parent;
         struct tagRPCFunc       *func_next;          struct tagRPCFunc       *func_next;
Line 239  struct tagRPCCall { Line 137  struct tagRPCCall {
         rpc_sess_t      call_session;          rpc_sess_t      call_session;
         uint16_t        call_tag;          uint16_t        call_tag;
         uint32_t        call_hash;          uint32_t        call_hash;
        uint8_t             call_argc;        uint16_t        call_argc;
 } __packed;  } __packed;
   
 /* Network RPC packet - Server response */  /* Network RPC packet - Server response */
Line 250  struct tagRPCRet { Line 148  struct tagRPCRet {
         uint32_t        ret_hash;          uint32_t        ret_hash;
         int32_t         ret_retcode;          int32_t         ret_retcode;
         int32_t         ret_errno;          int32_t         ret_errno;
        uint8_t             ret_argc;        uint16_t        ret_argc;
 } __packed;  } __packed;
   
 /* Network BLOB packet - Header */  /* Network BLOB packet - Header */
Line 266  struct tagBLOBHdr { Line 164  struct tagBLOBHdr {
 /* Network RPC client & server elements */  /* Network RPC client & server elements */
   
 typedef struct {  typedef struct {
        struct sockaddr       cli_sa;         // host info        io_sockaddr_t        cli_sa;         // host info
         int             cli_sock;       // socket fd          int             cli_sock;       // socket fd
         pthread_t       cli_tid;        // TID of thread          pthread_t       cli_tid;        // TID of thread
   
         void            *cli_parent;    // pointer to parent rpc_srv_t for server or to rpc_sess_t for client          void            *cli_parent;    // pointer to parent rpc_srv_t for server or to rpc_sess_t for client
           int             cli_netbuf;     // size of network buffer size
 } rpc_cli_t;  } rpc_cli_t;
   
   
// BLOB registration element!/* BLOB registration element! */
 typedef struct tagBLOB {  typedef struct tagBLOB {
         uint32_t        blob_var;          uint32_t        blob_var;
   
Line 285  typedef struct tagBLOB { Line 184  typedef struct tagBLOB {
 } 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_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_server;     // RPC server socket
        rpc_cli_t       *srv_clients;   // connected rpc client sockets        rpc_cli_t               *srv_clients;   // connected rpc client sockets
   
        rpc_func_t      *srv_funcs;     // registered functions list        rpc_func_t              *srv_funcs;     // registered functions list
   
        pthread_mutex_t srv_mtx;        pthread_mutex_t         srv_mtx;
        cmd_type_t      srv_kill;        cmd_type_t              srv_kill;
   
         struct {          struct {
                 cmd_type_t      state;          // BLOB server state: ==0 disable | !=0 enable                  cmd_type_t      state;          // BLOB server state: ==0 disable | !=0 enable
                char            dir[UCHAR_MAX + 1];                char            *dir;
   
                 rpc_cli_t       server;         // BLOB server socket                  rpc_cli_t       server;         // BLOB server socket
                 rpc_cli_t       *clients;       // connected blob client sockets                  rpc_cli_t       *clients;       // connected blob client sockets
Line 306  typedef struct { Line 206  typedef struct {
                 rpc_blob_t      *blobs;         // registered blob variables list                  rpc_blob_t      *blobs;         // registered blob variables list
   
                 pthread_mutex_t mtx;                  pthread_mutex_t mtx;
        }               srv_blob;        }                       srv_blob;
 
         sched_root_task_t       *srv_sched;
 } rpc_srv_t;  } rpc_srv_t;
   
   
Line 317  typedef struct { Line 219  typedef struct {
  * @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, rpc_val_t *);typedef int (*rpc_callback_t)(rpc_func_t *, int, array_t *);
   
   
 // -----------------------------------------------------------------------  // -----------------------------------------------------------------------
Line 330  inline int rpc_GetErrno(); Line 232  inline int rpc_GetErrno();
 inline const char *rpc_GetError();  inline const char *rpc_GetError();
   
   
   /*
    * rpc_chkPktSession() Check session in RPC packet
    * @p = packet session
    * @s = active session
    * return: -1 error or 0 ok
    */
   inline int rpc_chkPktSession(rpc_sess_t *p, rpc_sess_t *s);
   /*
    * rpc_addPktSession() Add session into RPC packet
    * @p = packet session
    * @s = active session
    * return: -1 error or 0 ok
    */
   inline int rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s);
   
   
 /* RPC Server side functions */  /* RPC Server side functions */
   
 /*  /*
Line 337  inline const char *rpc_GetError(); Line 255  inline const char *rpc_GetError();
  * @regProgID = ProgramID for authentication & recognition   * @regProgID = ProgramID for authentication & recognition
  * @regProcID = ProcessID for authentication & recognition   * @regProcID = ProcessID for authentication & recognition
  * @concurentClients = Concurent clients at same time to this server   * @concurentClients = Concurent clients at same time to this server
    * @netBuf = Network buffer length, if =0 == BUFSIZ (also meaning max RPC packet)
  * @family = Family type, AF_INET, AF_INET6 or AF_LOCAL   * @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
  * return: NULL == error or !=NULL bind and created RPC server instance   * return: NULL == error or !=NULL bind and created RPC server instance
  */   */
 rpc_srv_t *rpc_srv_initServer(u_int regProgID, u_int regProcID, int concurentClients,   rpc_srv_t *rpc_srv_initServer(u_int regProgID, u_int regProcID, int concurentClients, 
                u_short family, const char *csHost, u_short Port);                int netBuf, u_short family, const char *csHost, u_short Port);
 /*  /*
  * rpc_srv_endServer() Destroy RPC server, close all opened sockets and free resources   * rpc_srv_endServer() Destroy RPC server, close all opened sockets and free resources
 * @srv = RPC Server instance * @psrv = RPC Server instance
  * return: none   * return: none
  */   */
void rpc_srv_endServer(rpc_srv_t * __restrict srv);void rpc_srv_endServer(rpc_srv_t ** __restrict psrv);
 /*  /*
 * rpc_srv_execServer() 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_execServer(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; \
                                                 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   * rpc_srv_initBLOBServer() Init & create BLOB Server
Line 372  int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, Line 299  int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv,
  */   */
 void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv);  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv);
 /*  /*
 * rpc_srv_execBLOBServer() 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_execBLOBServer(rpc_srv_t * __restrict srv);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   * rpc_srv_registerCall() Register call to RPC server
Line 387  int rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 322  int rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
  * return: -1 error or 0 register ok   * return: -1 error or 0 register ok
  */   */
 int rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc,   int rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, 
                unsigned char args);                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
Line 416  inline rpc_func_t *rpc_srv_getCall(rpc_srv_t * __restr Line 351  inline rpc_func_t *rpc_srv_getCall(rpc_srv_t * __restr
  * rpc_srv_execCall() Execute registered call from RPC server   * rpc_srv_execCall() Execute registered call from RPC server
  * @call = Register RPC call   * @call = Register RPC call
  * @rpc = IN RPC call structure   * @rpc = IN RPC call structure
 * @args = IN RPC call array of rpc values * @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_func_t * __restrict call, struct tagRPCCall * __restrict rpc, 
                rpc_val_t * __restrict args);                array_t * __restrict args);
   
   
 /*  /*
  * rpc_srv_returnVars() Init return variables for RPC call and zeroed values  
                                         (for safe handling return values, use this!)  
  * @call = RPC function call  
  * @varnum = Number of return variables  
  * return: NULL error, !=NULL array with return values for RPC call with varnum items  
  */  
 inline rpc_val_t *rpc_srv_returnVars(rpc_func_t * __restrict call, int varnum);  
 /*  
  * 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);  
 #define rpc_srv_freeVars(_call) (assert((_call)), rpc_srv_allocVars((_call), 0))  
 /*  
  * rpc_srv_zeroVars() Clean values from variables of RPC call  
  * @call = RPC function call  
  * return: -1 error, !=-1 Returned number of cleaned RPC variables  
  */  
 inline int rpc_srv_zeroVars(rpc_func_t * __restrict call);  
 /*  
  * rpc_srv_copyVars() Copy variables for RPC call to new variable array   * rpc_srv_copyVars() Copy variables for RPC call to new variable array
  * @call = RPC function call   * @call = RPC function call
  * @newvars = New allocated variables array, must be free after use   * @newvars = New allocated variables array, must be free after use
  * return: -1 error, !=-1 Returned number of copied RPC variables   * return: -1 error, !=-1 Returned number of copied RPC variables
  */   */
inline int rpc_srv_copyVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvars);inline int rpc_srv_copyVars(rpc_func_t * __restrict call, array_t ** __restrict newvars);
 /*  /*
  * rpc_srv_getVars() Get variables array for RPC call   * rpc_srv_getVars() Get variables array for RPC call
  * @call = RPC function call   * @call = RPC function call
  * @vars = Returned variables array, may be NULL   * @vars = Returned variables array, may be NULL
  * return: -1 error, !=-1 Number of returned variables   * return: -1 error, !=-1 Number of returned variables
  */   */
inline int rpc_srv_getVars(rpc_func_t * __restrict call, rpc_val_t ** __restrict vars);inline int rpc_srv_getVars(rpc_func_t * __restrict call, array_t ** __restrict vars);
   
   
 /*  /*
Line 527  int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_b Line 439  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_cli_sendBLOB() Send BLOB to server
  * @cli = Client instance   * @cli = Client instance
Line 534  int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_b Line 448  int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_b
  * @data = BLOB data   * @data = BLOB data
  * 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, rpc_val_t * __restrict var, void * __restrict data);int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void * __restrict data);
 /*  /*
  * rpc_cli_recvBLOB() Receive BLOB from server   * rpc_cli_recvBLOB() Receive BLOB from server
  * @cli = Client instance   * @cli = Client instance
Line 542  int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, rpc_v Line 456  int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, rpc_v
  * @data = BLOB data, must be free after use!   * @data = BLOB data, must be 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, rpc_val_t * __restrict var, void ** data);int rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void ** __restrict data);
 /*  /*
  * rpc_cli_delBLOB() Delete BLOB from server   * rpc_cli_delBLOB() Delete BLOB from server
  * @cli = Client instance   * @cli = Client instance
  * @var = BLOB variable   * @var = BLOB variable
  * return: -1 error, 0 ok, 1 remote error   * return: -1 error, 0 ok, 1 remote error
  */   */
int rpc_cli_delBLOB(rpc_cli_t * __restrict cli, rpc_val_t * __restrict var);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.   * rpc_cli_getBLOB() Receive BLOB from server and Delete after that.
  * @cli = Client instance   * @cli = Client instance
Line 557  int rpc_cli_delBLOB(rpc_cli_t * __restrict cli, rpc_va Line 471  int rpc_cli_delBLOB(rpc_cli_t * __restrict cli, rpc_va
  * @data = BLOB data, must be free after use!   * @data = BLOB data, must be 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, rpc_val_t * __restrict var, void ** data);inline int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void ** __restrict data);
   
   
   
Line 567  inline int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, Line 481  inline int rpc_cli_getBLOB(rpc_cli_t * __restrict cli,
  * rpc_cli_openClient() Connect to RPC Server   * rpc_cli_openClient() Connect to RPC Server
  * @ProgID = ProgramID for RPC session request   * @ProgID = ProgramID for RPC session request
  * @ProcID = ProcessID 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   * @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
  * 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(u_int ProgID, u_int ProcID, rpc_cli_t *rpc_cli_openClient(u_int ProgID, u_int ProcID, int netBuf, 
                 u_short family, const char *csHost, u_short Port);                  u_short family, const char *csHost, u_short Port);
 /*  /*
  * rpc_cli_closeClient() Close connection to RPC server and free resources   * rpc_cli_closeClient() Close connection to RPC server and free resources
Line 585  void rpc_cli_closeClient(rpc_cli_t * __restrict cli); Line 500  void rpc_cli_closeClient(rpc_cli_t * __restrict cli);
  * @cli = RPC Client session   * @cli = RPC Client session
  * @csModule = Module name, if NULL self binary   * @csModule = Module name, if NULL self binary
  * @csFunc = Function name for execute   * @csFunc = Function name for execute
 * @in_argc = IN count of arguments * @in_vars = IN RPC call array of rpc values
 * @in_vals = IN RPC call array of rpc values * @out_vars = OUT returned array of rpc values, must be free after use with rpc_cli_freeVals()
 * @out_argc = OUT returned count of arguments 
 * @out_vals = OUT returned array of rpc values, must be free after use (see rpc_cli_freeVals()) 
  * return: -1 error or != -1 ok result   * return: -1 error or != -1 ok result
  */   */
int rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, const char *csFunc, int in_argc, int rpc_cli_execCall(rpc_cli_t *cli, const char *csModule, const char *csFunc, 
                rpc_val_t * __restrict in_vals, int *out_argc, rpc_val_t ** __restrict out_vals);                array_t * __restrict in_vars, array_t ** __restrict out_vars);
/* 
 * rpc_cli_freeVals() Free rpc_val_t array returned from RPC call 
 * @args = Number of arguments in array 
 * @vals = Value elements 
 * return: none 
 */ 
inline void rpc_cli_freeVals(int args, rpc_val_t *vals); 
   
   
 /*  /*

Removed from v.1.2.4.8  
changed lines
  Added in v.1.5.2.2


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