Diff for /libaitrpc/inc/aitrpc.h between versions 1.1 and 1.25.2.5

version 1.1, 2010/06/18 01:48:06 version 1.25.2.5, 2015/01/21 00:37:03
Line 5 Line 5
 * $Author$  * $Author$
 * $Id$  * $Id$
 *  *
*************************************************************************/**************************************************************************
 The ELWIX and AITNET software is distributed under the following
 terms:
 
 All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
 
 Copyright 2004 - 2015
         by Michael Pounov <misho@elwix.org>.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
 3. All advertising materials mentioning features or use of this software
    must display the following acknowledgement:
 This product includes software developed by Michael Pounov <misho@elwix.org>
 ELWIX - Embedded LightWeight unIX and its contributors.
 4. Neither the name of AITNET nor the names of its contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.
 */
 #ifndef __AITRPC_H  #ifndef __AITRPC_H
 #define __AITRPC_H  #define __AITRPC_H
   
Line 13 Line 50
 #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__)
 #include <sys/limits.h>  #include <sys/limits.h>
   #endif
 #include <sys/socket.h>  #include <sys/socket.h>
   #include <sys/queue.h>
   #include <elwix.h>
   #include <aitsched.h>
   
   
#define STRSIZ                  256#define RPC_VERSION             8
 
#define RPC_VERSION             1 
 #define RPC_DEFPORT             2611  #define RPC_DEFPORT             2611
   
   /* Additional ELWIX RPC supporting protocols */
   #ifndef SOCK_STREAM
   #define SOCK_STREAM             1       /* stream socket */
   #endif
   #ifndef SOCK_DGRAM
   #define SOCK_DGRAM              2       /* datagram socket */
   #endif
   #ifndef SOCK_RAW
   #define SOCK_RAW                3       /* raw-protocol interface */
   #endif
   #define SOCK_BPF                4       /* ethernet interface */
   #define SOCK_EXT                5       /* bi-directional pipe interface */
   
/* RPC builtin registed calls *//* RPC call request flags */
   
#define CALL_SRVCLIENTS         "rpcServerClients"#define RPC_REPLY               0x0
#define CALL_SRVCALLS           "rpcServerCalls"#define RPC_NOREPLY             0x1
#define CALL_SRVSESSIONS        "rpcServerSessions" 
   
   /* RPC call I/O direction */
   
/* RPC types */#define RPC_REQ                    0x0
 #define RPC_ACK                 0x1
   
typedef enum {/* RPC builtin registed calls */
        empty,                          // empty -> variable is not set 
        buffer, string, array,          // buffer -> uint8_t*; string -> int8_t*; array -> char**; 
        size, offset, datetime,         // size -> size_t; offset -> off_t; datetime -> time_t; 
        real, bigreal,                  // real -> float; bigreal -> double; 
        u8, u16, u32, u64,              // unsigned integers ... 
        i8, i16, i32, i64               // integers ... 
} rpc_type_t; 
   
/* RPC value */#define CALL_TAG_MAX            65535
   
typedef struct {#define CALL_SRVPING            65534
        rpc_type_t      val_type; 
        size_t          val_len; 
        union { 
                uint8_t         *buffer; 
                int8_t          *string; 
                int8_t          **array; 
                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 CALL_SRVSHUTDOWN        65533
#define RPC_LEN_VAL(vl)                 ((vl)->val_len)#define CALL_SRVCLIENTS         65532
#define RPC_EMPTY_VAL(vl)               ((vl)->val_type == empty)#define CALL_SRVCALLS           65531
 #define CALL_SRVSESSIONS        65530
   
#define RPC_GET_BUF(vl)                 (assert((vl)->val_type == buffer), (vl)->val.buffer)#define CALL_BLOBSHUTDOWN       65529
#define RPC_GET_STR(vl)                 (assert((vl)->val_type == string), (vl)->val.string)#define CALL_BLOBCLIENTS        65528
#define RPC_GET_ARRAY(vl)               (assert((vl)->val_type == array), (vl)->val.array)#define CALL_BLOBVARS           65527
#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); \/* RPC signals */
                                                if (val->val.buffer) { \#define SIGFBLOB                54
                                                        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_ARRAY(vl, v, n, l)      do { rpc_val_t *val = (vl); assert(val); val->val.array = calloc(n, l); \ 
                                                if (val->val.array) { \ 
                                                        val->val_type = array; val->val_len = n * l; \ 
                                                        memcpy(val->val.array, v, val->val_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); \/* RPC types */
                                                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; \ 
                                                } \ 
                                                if (val->val_type == array && val->val.array) { \ 
                                                        free(val->val.array); \ 
                                                        val->val.array = NULL; \ 
                                                } \ 
                                                val->val_type = val->val_len = 0; \ 
                                        } while (0) 
   
   typedef enum {
           ok, error, no,                          /* for blob reply */
           get, set, unset                         /* for blob request */
   } blob_cmd_type_t;
   
#define RPC_CALLBACK_CHECK_ARGS(f, n)       do { \
                                                if (f->func_args != n) { \#define RPC_CALLBACK_CHECK_INPUT(x)       do { \
                                                        rpc_SetErr(22, "Error:: different number of arguments!\n"); \                                                assert((x)); \
                                                 if (!(x)) { \
                                                         rpc_SetErr(EINVAL, \
                                                                         "Invalid callback parameters ..."); \
                                                         return -1; \                                                          return -1; \
                                                 } \                                                  } \
                                        } while(0)                                        } while (0)
   
   
 /* RPC session identification */  /* RPC session identification */
   
 typedef struct {  typedef struct {
        uint8_t             sess_version;#if BYTE_ORDER == LITTLE_ENDIAN
        uint32_t      sess_program;        uint16_t    sess_instance:8;
        uint32_t      sess_process;        uint16_t        sess_version:8;
} __packed rpc_sess_t;#endif
 #if BYTE_ORDER == BIG_ENDIAN
         uint16_t      sess_version:8;
         uint16_t      sess_instance:8;
 #endif
 } __packed rpc_sess_t;  /* size == 2 bytes */
   
   
 /* Server managment RPC functions ... */  /* Server managment RPC functions ... */
   
 // RPC function registration element!  
 typedef struct tagRPCFunc {  
         uint16_t                func_tag;  
         uint32_t                func_hash;  
         int8_t                  func_file[MAXPATHLEN];  
         int8_t                  func_name[UCHAR_MAX + 1];  
   
         int8_t                  func_args;  
         rpc_val_t               *func_vals;  
   
         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;
   
           uint32_t        call_len;
           uint16_t        call_crc;
   
           union {
                   struct {
                           uint64_t        flags;
                   }       call_req;
                   struct {
                           int32_t         ret;
                           int32_t         eno;
                   }       call_rep;
           };
   
         uint16_t        call_tag;          uint16_t        call_tag;
        uint32_t        call_hash;        uint8_t             call_io;
         uint8_t         call_argc;          uint8_t         call_argc;
} __packed;        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 RPC packet - Server response *//* Network BLOB packet - Header */
   
struct tagRPCRet {struct tagBLOBHdr {
        rpc_sess_t      ret_session;        rpc_sess_t      hdr_session;
        uint16_t    ret_tag;        uint8_t             hdr_cmd;
        uint32_t        ret_hash;        uint32_t        hdr_var;
        int32_t         ret_retcode;        uint32_t hdr_len;
        int32_t         ret_errno;        uint32_t hdr_ret;
        uint8_t         ret_argc;        uint8_t         hdr_pad;
} __packed;} __packed;                     /* size == 16 bytes */
   
 /* Network RPC client & server elements */  /* Network RPC client & server elements */
   
   /* RPC function registration element! */
   typedef struct tagRPCFunc {
           ait_val_t               func_name;
   
           void                    *func_parent;
   
           SLIST_ENTRY(tagRPCFunc) func_next;
           AVL_ENTRY(tagRPCFunc)   func_node;
   } rpc_func_t;
   #define RPC_FUNC_SERVER(x)      ((rpc_srv_t*) (x)->func_parent)
   
   /* 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 {
           uint32_t                blob_var;       /* BLOB id */
   
           size_t                  blob_len;       /* size of allocated BLOB data */
           void                    *blob_data;     /* mapped BLOB data */
   
           TAILQ_ENTRY(tagBLOB)    blob_node;
   } rpc_blob_t;
   
   
 typedef struct {  typedef struct {
        struct sockaddr        cli_sa;               // host info        int             cli_id;         /* slot id */
        int             cli_sock;       // socket        int             cli_sock;       /* socket fd */
        pthread_t      cli_tid;    // TID of thread        sockaddr_t      cli_sa;         /* host address */
         ait_val_t       cli_buf;        /* network buffer */
   
        void            *cli_parent;    // pointer to parent rpc_srv_t for server or to rpc_sess_t for client        array_t         *cli_vars;      /* function return variables */
 
         void            *cli_parent;    /* pointer to parent rpc_srv_t for server or to rpc_sess_t for client */
 } rpc_cli_t;  } rpc_cli_t;
   #define RPC_RETVARS(x)          ((x)->cli_vars)
   #define RPC_SRV_SERVER(x)       ((rpc_srv_t*) (x)->cli_parent)
   #define RPC_CLI_SESSION(x)      ((rpc_sess_t*) (x)->cli_parent)
   
 typedef struct {  typedef struct {
        int                srv_numcli;  // maximum concurent client connections        rpc_sess_t                      srv_session;    /* RPC session registration info */
        rpc_cli_t        srv_server; // server socket        int                             srv_netbuf;     /*        int                             srv_netbuf;     /* size of network buffer */
         int                             srv_proto;  /* Server protocol */
   
        rpc_sess_t        srv_session;        // RPC session registration info  
         sched_root_task_t               *srv_root;      /* RPC server scheduler */
         intptr_t                        srv_kill;       /* Scheduler condition variable */
   
        rpc_cli_t       *srv_clients;   // connected client sockets        rpc_cli_t                       srv_server;     /* RPC server socket */
         array_t                         *srv_clients;   /* connected rpc client sockets */
   
        rpc_func_t      *srv_funcs;      // registered functions list        rpc_funcs_t                        srv_funcs;      /* RPC functions */
 
         struct {
                 pthread_t                       tid;            /* BLOB exec pthread */
                 sched_root_task_t               *root;          /* BLOB server scheduler */
                 intptr_t                        kill;           /* BLOB server state: ==0 disable | !=0 enable */
 
                 ait_val_t                       dir;            /* BLOB states directory */
 
                 rpc_cli_t                       server;         /* BLOB server socket */
                 array_t                         *clients;       /* connected blob client sockets */
 
                 TAILQ_HEAD(, tagBLOB)           blobs;          /* registered blob variables list */
         }                               srv_blob;
 } rpc_srv_t;  } rpc_srv_t;
   
   
typedef int (*rpc_callback_t)(void * const, rpc_func_t *, int, rpc_val_t *);/* 
  * (*rpc_callback_t)() - Callback type definition for RPC call in server process
  *
  * @arg1 = RPC client
  * @arg2 = RPC packet header
  * @arg3 = input array with values from RPC call execution request
  * return: -1 error or >-1 success execution
  */
 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 */  /* Error support functions */
   
// cli_GetErrno() Get error code of last operation// rpc_GetErrno() Get error code of last operation
inline int cli_GetErrno();int rpc_GetErrno();
// cli_GetError() Get error text of last operation// rpc_GetError() Get error text of last operation
inline const char *cli_GetError();const char *rpc_GetError();
 // rpc_SetErr() Set error to variables for internal use!!!
 void rpc_SetErr(int eno, char *estr, ...);
   
   
   
   /*
    * 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
    * @s = active session
    * return: -1, 1, 2, 3 are errors or 0 ok
    */
   int rpc_chkPktSession(rpc_sess_t *p, rpc_sess_t *s);
   /*
    * rpc_addPktSession() - Prepare session into network format
    *
    * @p = packet session
    * @s = host session
    * return: -1 error or 0 ok
    */
   int rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s);
   /*
    * rpc_register_srvPing() - Register ping service function
    *
    * @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 */
   
 /*  /*
 * 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
 * @family = Family socket type, AF_INET or AF_INET6 * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
 * @csHost = Host name or IP 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, 
                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
 * @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)); \
                 if (!(_srv)->srv_kill) { \
                         pthread_create(&(_srv)->srv_tid, NULL, (void*(*)(void*)) \
                                         rpc_srv_loopServer, (_srv)); \
                         if ((_sync)) \
                                 pthread_join((_srv)->srv_tid, (void**) (_sync)); \
                         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_registerCall() Register call to RPC server * rpc_srv_initBLOBServer() - Init & create BLOB Server
  *
  * @srv = RPC server instance
  * @Port = Port for bind server, if Port == 0 default port is selected
  * @diskDir = Disk place for BLOB file objects
  * return: -1 == error or 0 bind and created BLOB server instance
  */
 int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, unsigned short Port, const char *diskDir);
 /*
  * rpc_srv_endBLOBServer() - Destroy BLOB server, close all opened sockets and free resources
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
 * @csModule = Module name, if NULL self binary * return: none
 * @csFunc = Function name 
 * @args = Number of function arguments 
 * return: -1 error or 0 register ok 
  */   */
int rpc_srv_registerCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc, void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv);
                unsigned char args); 
 /*  /*
 * rpc_srv_unregisterCall() Unregister call from RPC server * rpc_srv_loopBLOB() - Execute Main BLOB server loop and wait for clients requests
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
 * @csModule = Module name, if NULL self binary * return: -1 error or 0 ok, infinite loop ...
 * @csFunc = Function name 
 * return: -1 error, 0 not found call, 1 unregister ok 
  */   */
int rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, const char *csModule, const char *csFunc);int rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv);
 #define rpc_srv_execBLOBServer(_srv) \
         do { assert((_srv)); \
                 if (!(_srv)->srv_kill && !(_srv)->srv_blob.kill) { \
                         pthread_create(&(_srv)->srv_blob.tid, NULL, \
                                         (void*(*)(void*)) rpc_srv_loopBLOBServer, (_srv)); \
                         pthread_detach((_srv)->srv_blob.tid); \
                 } \
         } while (0)
 
 /*  /*
 * rpc_srv_getFunc() Get registered call from RPC server by Name * rpc_srv_initServer2() - Init & create layer2 RPC Server
  *
  * @InstID = Instance for authentication & recognition
  * @concurentClients = Concurent clients at same time to this server
  * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
  * @csIface = Interface name for bind server, if NULL first interface on host
  * return: NULL == error or !=NULL bind and created RPC server instance
  */
 rpc_srv_t *rpc_srv_initServer2(u_char InstID, int concurentClients, int netBuf, 
                 const char *csIface);
 
 /*
  * rpc_srv_initServerExt() - Init & create pipe RPC Server
  *
  * @InstID = Instance for authentication & recognition
  * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
  * @fd = File descriptor
  * return: NULL == error or !=NULL bind and created RPC server instance
  */
 rpc_srv_t *rpc_srv_initServerExt(u_char InstID, int netBuf, int fd);
 
 /*
  * rpc_srv_registerCall() - Register call to RPC server
  *
  * @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: NULL not found call, !=NULL return call * return: -1 error, 0 already registered tag or 1 register ok
  */   */
rpc_func_t *rpc_srv_getFunc(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_getCall() Get registered call from RPC server * rpc_srv_unregisterCall() - Unregister call from RPC server
  *
  * @srv = RPC Server instance   * @srv = RPC Server instance
    * @tag = Function tag
    * return: -1 error, 0 not found call, 1 unregister ok
    */
   int rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, unsigned short tag);
   /*
    * 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
 * @data = RPC const data *
 * @call = Register RPC call * @cli = RPC client
  * @rpc = IN RPC call structure   * @rpc = IN RPC call structure
 * @args = IN RPC call array of rpc values * @funcname = Execute RPC function
  * @args = IN RPC calling arguments from RPC client
  * return: -1 error, !=-1 ok   * return: -1 error, !=-1 ok
  */   */
int rpc_srv_execCall(void * const data, rpc_func_t * __restrict call, int rpc_srv_execCall(rpc_cli_t * __restrict cli, struct tagRPCCall * __restrict rpc, 
                struct tagRPCCall * __restrict rpc, rpc_val_t * __restrict args);                ait_val_t funcname, array_t * __restrict args);
   
   
 /*  /*
 * rpc_srv_declValsCall() Declare return variables for RPC call * rpc_srv_blobCreate() - Create and map blob to memory region and return object
 * @call = RPC function call *
 * @return_vals = Number of return variables * @srv = RPC Server instance
 * return: -1 error, !=-1 ok * @len = BLOB length object
  * @tout = BLOB live timeout in seconds
  * return: NULL error or !=NULL allocated BLOB object
  */   */
inline int rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals);rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len, int tout);
 /*  /*
 * rpc_srv_freeValsCall() Free return variables for RPC call * rpc_srv_blobMap() - Map blob to memory region 
 * @call = RPC function call *
  * @srv = RPC Server instance
  * @blob = Map to this BLOB element
  * return: -1 error or 0 ok
  */
 int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
 /*
  * rpc_srv_blobUnmap() - Unmap blob memory region 
  *
  * @blob = Mapped BLOB element
  * return: none   * return: none
  */   */
inline void rpc_srv_freeValsCall(rpc_func_t * __restrict call);void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob);
 /*  /*
 * rpc_srv_copyValsCall() Copy return variables for RPC call to new variable * rpc_srv_blobFree() - Free blob from disk & memory
 * @call = RPC function call *
 * @newvals = New allocated variables array, must be free after use * @srv = RPC Server instance
 * return: -1 error, !=-1 Returned number of copied RPC variables * @blob = Mapped BLOB element
  * return: -1 error or 0 ok
  */   */
inline int rpc_srv_copyValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvals);int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
 
 /*  /*
 * rpc_srv_delValsCall() Clean values from return variables of RPC call * rpc_srv_registerBLOB() - Register new BLOB to server
 * @call = RPC function call *
 * return: -1 error, !=-1 Returned number of cleaned RPC variables * @srv = RPC Server instance
  * @len = BLOB length
  * @tout = BLOB live timeout in seconds
  * return: NULL error or new registered BLOB
  */   */
inline int rpc_srv_delValsCall(rpc_func_t * __restrict call);rpc_blob_t *rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len, int tout);
 /*  /*
 * rpc_srv_getValsCall() Get return variables for RPC call * rpc_srv_unregisterBLOB() - Unregister BLOB from server
 * @call = RPC function call *
 * @vals = Returned variables, may be NULL * @srv = RPC Server instance
 * return: -1 error, !=-1 Number of returned variables * @var = BLOB Variable for unregister
  * return: -1 error, 0 not found call, 1 unregister ok
  */   */
inline int rpc_srv_getValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict vals);int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var);
 /*
  * rpc_srv_getBLOB() - Get registered BLOB 
  *
  * @srv = RPC Server instance
  * @var = hash for variable
  * return: NULL not found, !=NULL return blob var
  */
 rpc_blob_t *rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var);
   
   /*
    * rpc_srv_sendBLOB() - Send mapped BLOB to client
    *
    * @cli = Client instance
    * @blob = Mapped BLOB element
    * return: -1 error, 0 ok
    */
   int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);
   /*
    * rpc_srv_recvBLOB() - Receive BLOB from client
    *
    * @cli = Client instance
    * @blob = Mapped BLOB element
    * return: -1 error, 0 ok, >0 unreceived data from client, may be error?
    */
   int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);
   
   /* CLIENT part of functions */
   
   /*
    * rpc_cli_sendBLOB() - Send BLOB to server
    *
    * @cli = Client instance
    * @var = BLOB variable
    * @data = BLOB data
    * @tout = BLOB live on server timeout in seconds, if =0 default timeout
    * return: -1 error, 0 ok, 1 remote error
    */
   int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, 
                   void * __restrict data, int tout);
   /*
    * rpc_cli_recvBLOB() - Receive BLOB from server
    *
    * @cli = Client instance
    * @var = BLOB variable
    * @data = BLOB data, must be e_free after use!
    * return: -1 error, 0 ok, 1 remote error
    */
   int rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void ** __restrict data);
   /*
    * rpc_cli_delBLOB() - Delete BLOB from server
    *
    * @cli = Client instance
    * @var = BLOB variable
    * return: -1 error, 0 ok, 1 remote error
    */
   int rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var);
   /*
    * rpc_cli_getBLOB() - Receive BLOB from server and Delete after that.
    *
    * @cli = Client instance
    * @var = BLOB variable
    * @data = BLOB data, must be e_free after use!
    * return: -1 error, 0 ok, >0 remote error
    */
   int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, 
                   void ** __restrict data);
   
   
 /* RPC Client side functions */  /* RPC Client side functions */
   
 /*  /*
 * rpc_cli_openClient() Connect to RPC Server * rpc_cli_openClient() - Connect to RPC Server
 * @ProgID = ProgramID for RPC session request *
 * @ProcID = ProcessID for RPC session request * @InstID = InstID for RPC session request
 * @family = Family socket type, AF_INET or AF_INET6 * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
  * @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(u_int ProgID, u_int ProcID, u_short familyrpc_cli_t *rpc_cli_openClient(unsigned char InstID, int netBuf
                const char *csHost, u_short Port);                const char *csHost, unsigned short Port, int proto);
 /*  /*
 * rpc_cli_closeClient() Close connection to RPC server and free resources * rpc_cli_reconnectClient() - Reconnecting client to RPC server
  *
  * @cli = RPC Client session   * @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
    *
    * @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_cli_execCall() Execute RPC call * 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, if =NULL don't check session
  * @tag = Function tag
  * @vars = Function argument array of values, may be NULL
  * @nocrc = Without CRC calculation
  * return: -1 error or != -1 return value from function
  */
 int rpc_pkt_Replay(ait_val_t * __restrict pkt, rpc_sess_t * __restrict sess, 
                 unsigned short tag, array_t ** __restrict vars, int nocrc);
 /*
  * rpc_cli_execCall() - Execute RPC call
  *
  * @cli = RPC Client session   * @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_argc = IN count of arguments * @in_vars = IN function argument array of values, may be NULL
 * @in_vals = IN RPC call array of rpc values * @out_vars = OUT returned array of rpc values, if !=NULL must be free after use with ait_freeVars()
 * @out_argc = OUT returned count of arguments * return: -1 error, 0 ok result or 1 closed rpc connection
 * @out_vals = OUT returned array of rpc values, must be free after use (see rpc_cli_freeVals()) 
 * 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, int noreply, unsigned short tag, 
                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 * rpc_cli_freeCall() - Free resouce allocated by RPC call
 * @args = Number of arguments in array *
 * @vals = Value elements * @out_vars = Returned array with variables from RPC call
  * return: none   * return: none
  */   */
inline void rpc_cli_freeVals(int args, rpc_val_t *vals);void rpc_cli_freeCall(array_t ** __restrict out_vars);
 /*
  * rpc_cli_ping() - Ping RPC server
  *
  * @cli = connected client
  * return: -1 error or !=-1 ping seq id
  */
 int rpc_cli_ping(rpc_cli_t *cli);
 
 
 /*
  * rpc_cli_openBLOBClient() - Connect to BLOB Server
  *
  * @rpccli = RPC Client session
  * @Port = Port for bind server, if Port == 0 default port is selected
  * return: NULL == error or !=NULL connection to BLOB server established
  */
 rpc_cli_t *rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, unsigned short Port);
 /*
  * rpc_cli_closeBLOBClient() - Close connection to BLOB server and free resources
  *
  * @cli = BLOB Client session
  * return: none
  */
 void rpc_cli_closeBLOBClient(rpc_cli_t ** __restrict cli);
 
 
 /*
  * rpc_cli_openClient2() - Connect to layer2 RPC Server
  *
  * @InstID = InstID for RPC session request
  * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
  * @csIface = Interface name for bind client, if NULL first interface on host
  * @csHost = Host ethernet address
  * return: NULL == error or !=NULL connection to RPC server established
  */
 rpc_cli_t *rpc_cli_openClient2(u_char InstID, int netBuf, 
                 const char *csIface, const char *csHost);
 /*
  * rpc_cli_closeClient2() - Close layer2 connection to RPC server and free resources
  *
  * @cli = RPC Client session
  * return: none
  */
 void rpc_cli_closeClient2(rpc_cli_t ** __restrict cli);
 
 
 /*
  * rpc_cli_openClientExt() - Connect to pipe RPC Server
  *
  * @InstID = InstID for RPC session request
  * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
  * @fd = File descriptor
  * return: NULL == error or !=NULL connection to RPC server established
  */
 rpc_cli_t *rpc_cli_openClientExt(u_char InstID, int netBuf, int fd);
 /*
  * rpc_cli_closeClientExt() - Close pipe connection to RPC server and free resources
  *
  * @cli = RPC Client session
  * return: none
  */
 void rpc_cli_closeClientExt(rpc_cli_t ** __restrict cli);
   
   
 #endif  #endif

Removed from v.1.1  
changed lines
  Added in v.1.25.2.5


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