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

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

version 1.14, 2013/04/02 15:50:14 version 1.28.8.2, 2024/03/20 17:06:10
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013Copyright 2004 - 2024
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 48  SUCH DAMAGE. Line 48  SUCH DAMAGE.
   
   
 #include <assert.h>  #include <assert.h>
#include <stdlib.h>#include <pthread.h>
#include <string.h> 
#include <errno.h> 
#include <sys/types.h> 
#include <sys/param.h> 
#if !defined(__NetBSD__) 
#include <sys/limits.h> 
#endif 
#include <sys/socket.h> 
 #include <sys/queue.h>  #include <sys/queue.h>
#include <elwix.h>#include <aitrpc_pkt.h>
 #include <aitrpc_cli.h>
 #include <aitsched.h>  #include <aitsched.h>
   
   
 #define RPC_VERSION             6  
 #define RPC_DEFPORT             2611  
   
 /* RPC call request flags */  
   
 #define RPC_REPLY               0x0  
 #define RPC_NOREPLY             0x1  
   
 /* RPC builtin registed calls */  
   
 #define CALL_TAG_MAX            65535  
   
 #define CALL_SRVPING            65534  
   
 #define CALL_SRVSHUTDOWN        65533  
 #define CALL_SRVCLIENTS         65532  
 #define CALL_SRVCALLS           65531  
 #define CALL_SRVSESSIONS        65530  
   
 #define CALL_BLOBSHUTDOWN       65529  
 #define CALL_BLOBCLIENTS        65528  
 #define CALL_BLOBVARS           65527  
   
   
 /* RPC types */  
   
 typedef enum {  
         ok, error, no,                          /* for blob reply */  
         get, set, unset                         /* for blob request */  
 } blob_cmd_type_t;  
   
   
 #define RPC_CALLBACK_CHECK_INPUT(x)     do { \  #define RPC_CALLBACK_CHECK_INPUT(x)     do { \
                                                 assert((x)); \                                                  assert((x)); \
                                                 if (!(x)) { \                                                  if (!(x)) { \
Line 104  typedef enum { Line 65  typedef enum {
                                         } while (0)                                          } while (0)
   
   
/* RPC session identification *//* Network RPC server elements */
   
 typedef struct {  
 #if BYTE_ORDER == LITTLE_ENDIAN  
         uint16_t        sess_instance:8;  
         uint16_t        sess_version:8;  
 #endif  
 #if BYTE_ORDER == BIG_ENDIAN  
         uint16_t        sess_version:8;  
         uint16_t        sess_instance:8;  
 #endif  
 } __packed rpc_sess_t;  /* size == 2 bytes */  
   
   
 /* Server managment RPC functions ... */  
   
 /* Network RPC packet - Client request */  
   
 struct tagRPCCall {  
         rpc_sess_t      call_session;  
   
         uint16_t        call_seq;  
         uint16_t        call_len;  
         uint16_t        call_crc;  
   
         union {  
                 struct {  
                         uint64_t        flags;  
                 }       call_req;  
                 struct {  
                         int32_t         ret;  
                         int32_t         eno;  
                 }       call_rep;  
         };  
   
         uint16_t        call_tag;  
         uint16_t        call_argc;  
         ait_val_t       call_argv[0];  
 } __packed;                     /* size == 20 bytes */  
 #define RPC_CHK_NOREPLY(x)      ((x)->call_req.flags & RPC_NOREPLY)  
   
 /* Network BLOB packet - Header */  
   
 struct tagBLOBHdr {  
         rpc_sess_t      hdr_session;  
         uint8_t         hdr_cmd;  
         uint32_t        hdr_var;  
         uint32_t        hdr_len;  
         uint32_t        hdr_ret;  
         uint8_t         hdr_pad;  
 } __packed;                     /* size == 16 bytes */  
   
 /* Network RPC client & server elements */  
   
 /* RPC function registration element! */  /* RPC function registration element! */
 typedef struct tagRPCFunc {  typedef struct tagRPCFunc {
         ait_val_t               func_name;          ait_val_t               func_name;
Line 193  typedef struct tagBLOB { Line 102  typedef struct tagBLOB {
   
   
 typedef struct {  typedef struct {
         int             cli_id;         /* slot id */  
         int             cli_sock;       /* socket fd */  
         sockaddr_t      cli_sa;         /* host address */  
         ait_val_t       cli_buf;        /* network buffer */  
   
         array_t         *cli_vars;      /* function return variables */  
   
         void            *cli_parent;    /* pointer to parent rpc_srv_t for server or to rpc_sess_t for client */  
 } rpc_cli_t;  
 #define RPC_RETVARS(x)          ((x)->cli_vars)  
 #define RPC_SRV_SERVER(x)       ((rpc_srv_t*) (x)->cli_parent)  
 #define RPC_CLI_SESSION(x)      ((rpc_sess_t*) (x)->cli_parent)  
   
 typedef struct {  
         rpc_sess_t                      srv_session;    /* RPC session registration info */          rpc_sess_t                      srv_session;    /* RPC session registration info */
         int                             srv_netbuf;     /* size of network buffer */          int                             srv_netbuf;     /* size of network buffer */
         int                             srv_proto;      /* Server protocol */          int                             srv_proto;      /* Server protocol */
Line 245  typedef struct { Line 140  typedef struct {
  */   */
 typedef int (*rpc_callback_t)(rpc_cli_t *, struct tagRPCCall *, array_t *);  typedef int (*rpc_callback_t)(rpc_cli_t *, struct tagRPCCall *, array_t *);
   
   #define RPC_CALL_DEFINE(x)      int (x)(rpc_cli_t*, struct tagRPCCall*, array_t*)
   #define RPC_CALL_ARGS(arg1, arg2, arg3) rpc_cli_t* arg1, struct tagRPCCall* arg2, array_t* arg3
   #define RPC_CALL_STDARGS        RPC_CALL_ARGS(cli, rpc, iv)
   
 /* ----------------------------------------------------------------------- */  
   
 /* Error support functions */  
   
 // rpc_GetErrno() Get error code of last operation  
 inline int rpc_GetErrno();  
 // rpc_GetError() Get error text of last operation  
 inline const char *rpc_GetError();  
   
   
 /*  /*
 * rpc_chkPktSession() - Check RPC session * rpc_srv_DispatchSignal() - Enable/Disable Signal dispatcher for RPC scheduler
  *   *
 * @p = packet session * @x = RPC server instance
 * @s = active session * @y = Enable or =0 Disable
 * return: -1, 1, 2, 3 are errors or 0 ok * return: 0 enabled signal dispatcher. See schedSignalDispatch() in libaitsched
  */   */
inline int rpc_chkPktSession(rpc_sess_t *p, rpc_sess_t *s);#define rpc_srv_DispatchSignal(x, y) schedSignalDispatch((x)->srv_root, (y))
 
 /* ----------------------------------------------------------------------- */
 
 /*  /*
  * rpc_addPktSession() - Prepare session into network format  
  *  
  * @p = packet session  
  * @s = host session  
  * return: -1 error or 0 ok  
  */  
 inline int rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s);  
 /*  
  * rpc_register_srvPing() - Register ping service function   * rpc_register_srvPing() - Register ping service function
  *   *
  * @srv = RPC server instance   * @srv = RPC server instance
  * return: -1 error or 0 ok   * return: -1 error or 0 ok
  */   */
inline int rpc_register_srvPing(rpc_srv_t * __restrict srv);int rpc_register_srvPing(rpc_srv_t * __restrict srv);
 /*  /*
  * rpc_register_srvServices() - Register internal service functions   * rpc_register_srvServices() - Register internal service functions
  *   *
Line 316  rpc_srv_t *rpc_srv_initServer(unsigned char InstID, in Line 200  rpc_srv_t *rpc_srv_initServer(unsigned char InstID, in
  * @psrv = RPC Server instance   * @psrv = RPC Server instance
  * return: none   * return: none
  */   */
inline 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
  *   *
Line 324  inline void rpc_srv_endServer(rpc_srv_t ** __restrict  Line 208  inline void rpc_srv_endServer(rpc_srv_t ** __restrict 
  * return: -1 error or 0 ok, infinite loop ...   * return: -1 error or 0 ok, infinite loop ...
  */   */
 int rpc_srv_loopServer(rpc_srv_t * __restrict srv);  int rpc_srv_loopServer(rpc_srv_t * __restrict srv);
#define rpc_srv_execServer(_srv, _sync) do { assert((_srv)); \#define rpc_srv_execServer(_srv, _sync) \
                                                if (!(_srv)->srv_kill) { \        do { assert((_srv)); \
                                                        pthread_create(&(_srv)->srv_tid, NULL, (void*(*)(void*)) \                if (!(_srv)->srv_kill) { \
                                                                        rpc_srv_loopServer, (_srv)); \                        pthread_create(&(_srv)->srv_tid, NULL, (void*(*)(void*)) \
                                                        if ((_sync)) \                                        rpc_srv_loopServer, (_srv)); \
                                                                pthread_join((_srv)->srv_tid, (void**) (_sync)); \                        if ((_sync)) \
                                                        else \                                pthread_join((_srv)->srv_tid, (void**) (_sync)); \
                                                                pthread_detach((_srv)->srv_tid); \                        else \
                                                } } while (0)                                pthread_detach((_srv)->srv_tid); \
         } } while (0)
 #define rpc_srv_killServer(_srv) \
         (assert((_srv)), (_srv)->srv_blob.kill = 1, (_srv)->srv_kill = 1)
   
 /*  /*
  * rpc_srv_initBLOBServer() - Init & create BLOB Server   * rpc_srv_initBLOBServer() - Init & create BLOB Server
Line 349  int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, Line 236  int rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv,
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * return: none   * return: none
  */   */
inline 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
  *   *
Line 357  inline void rpc_srv_endBLOBServer(rpc_srv_t * __restri Line 244  inline void rpc_srv_endBLOBServer(rpc_srv_t * __restri
  * return: -1 error or 0 ok, infinite loop ...   * return: -1 error or 0 ok, infinite loop ...
  */   */
 int rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv);  int rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv);
#define rpc_srv_execBLOBServer(_srv)    do { assert((_srv)); \#define rpc_srv_execBLOBServer(_srv) \
                                                if (!(_srv)->srv_kill && !(_srv)->srv_blob.kill) { \        do { assert((_srv)); \
                                                        pthread_create(&(_srv)->srv_blob.tid, NULL, \                if (!(_srv)->srv_kill && !(_srv)->srv_blob.kill) { \
                                                                        (void*(*)(void*)) \                        pthread_create(&(_srv)->srv_blob.tid, NULL, \
                                                                        rpc_srv_loopBLOBServer, (_srv)); \                                        (void*(*)(void*)) rpc_srv_loopBLOBServer, (_srv)); \
                                                        pthread_detach((_srv)->srv_blob.tid); \                        pthread_detach((_srv)->srv_blob.tid); \
                                                } \                } \
                                        } while (0)        } while (0)
   
 /*  /*
    * rpc_srv_initServer2() - Init & create layer2 RPC Server
    *
    * @InstID = Instance for authentication & recognition
    * @concurentClients = Concurent clients at same time to this server
    * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
    * @csIface = Interface name for bind server, if NULL first interface on host
    * return: NULL == error or !=NULL bind and created RPC server instance
    */
   rpc_srv_t *rpc_srv_initServer2(u_char InstID, int concurentClients, int netBuf, 
                   const char *csIface);
   
   /*
    * rpc_srv_initServerExt() - Init & create pipe RPC Server
    *
    * @InstID = Instance for authentication & recognition
    * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet)
    * @fd = File descriptor
    * return: NULL == error or !=NULL bind and created RPC server instance
    */
   rpc_srv_t *rpc_srv_initServerExt(u_char InstID, int netBuf, int fd);
   
   /*
  * rpc_srv_registerCall() - Register call to RPC server   * rpc_srv_registerCall() - Register call to RPC server
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
Line 390  int rpc_srv_unregisterCall(rpc_srv_t * __restrict srv, Line 299  int rpc_srv_unregisterCall(rpc_srv_t * __restrict srv,
  * @tag = tag for function   * @tag = tag 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);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
  *   *
Line 409  int rpc_srv_execCall(rpc_cli_t * __restrict cli, struc Line 318  int rpc_srv_execCall(rpc_cli_t * __restrict cli, struc
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @len = BLOB length object   * @len = BLOB length object
    * @tout = BLOB live timeout in seconds
  * return: NULL error or !=NULL allocated BLOB object   * return: NULL error or !=NULL allocated BLOB object
  */   */
inline rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len);rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len, int tout);
 /*  /*
  * rpc_srv_blobMap() - Map blob to memory region    * rpc_srv_blobMap() - Map blob to memory region 
  *   *
Line 419  inline rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __re Line 329  inline rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __re
  * @blob = Map to this BLOB element   * @blob = Map to this BLOB element
  * return: -1 error or 0 ok   * return: -1 error or 0 ok
  */   */
inline int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);int rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
 /*  /*
  * rpc_srv_blobUnmap() - Unmap blob memory region    * rpc_srv_blobUnmap() - Unmap blob memory region 
  *   *
  * @blob = Mapped BLOB element   * @blob = Mapped BLOB element
  * return: none   * return: none
  */   */
inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob);void rpc_srv_blobUnmap(rpc_blob_t * __restrict blob);
 /*  /*
  * rpc_srv_blobFree() - Free blob from disk & memory   * rpc_srv_blobFree() - Free blob from disk & memory
  *   *
Line 434  inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict  Line 344  inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict 
  * @blob = Mapped BLOB element   * @blob = Mapped BLOB element
  * return: -1 error or 0 ok   * return: -1 error or 0 ok
  */   */
inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
   
 /*  /*
  * rpc_srv_registerBLOB() - Register new BLOB to server   * rpc_srv_registerBLOB() - Register new BLOB to server
  *   *
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @len = BLOB length   * @len = BLOB length
    * @tout = BLOB live timeout in seconds
  * return: NULL error or new registered BLOB   * return: NULL error or new registered BLOB
  */   */
rpc_blob_t *rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len);rpc_blob_t *rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len, int tout);
 /*  /*
  * rpc_srv_unregisterBLOB() - Unregister BLOB from server   * rpc_srv_unregisterBLOB() - Unregister BLOB from server
  *   *
Line 459  int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, Line 370  int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv,
  * @var = hash for variable   * @var = hash for variable
  * return: NULL not found, !=NULL return blob var   * return: NULL not found, !=NULL return blob var
  */   */
inline rpc_blob_t *rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var);rpc_blob_t *rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var);
   
 /*  /*
  * rpc_srv_sendBLOB() - Send mapped BLOB to client   * rpc_srv_sendBLOB() - Send mapped BLOB to client
Line 478  int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_b Line 389  int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_b
  */   */
 int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);  int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);
   
 /* CLIENT part of functions */  
   
 /*  /*
 * rpc_cli_sendBLOB() - Send BLOB to server * rpc_srv_Return() - Prepare IPC return answer to RPC client
  *   *
 * @cli = Client instance * @c = RPC client 
 * @var = BLOB variable * return: number of arguments in response
 * @data = BLOB data 
 * 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 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 
 */ 
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 
 * 
 * @InstID = InstID for RPC session request 
 * @netBuf = Network buffer length (min:512 bytes), if =0 == BUFSIZ (also meaning max RPC packet) 
 * @csHost = Host name or IP address for bind server 
 * @Port = Port for bind server, if Port == 0 default port is selected 
 * @proto = Protocol, if == 0 choose SOCK_STREAM 
 * return: NULL == error or !=NULL connection to RPC server established 
 */ 
rpc_cli_t *rpc_cli_openClient(unsigned char InstID, int netBuf,  
                const char *csHost, unsigned short Port, int proto); 
/* 
 * rpc_cli_closeClient() - Close connection to RPC server and free resources 
 * 
 * @cli = RPC Client session 
 * return: none 
 */ 
void rpc_cli_closeClient(rpc_cli_t ** __restrict cli); 
/* 
 * rpc_pkt_Send() - Send RPC packet 
 * 
 * @sock = Socket 
 * @type = Type of socket 
 * @sa = Server address 
 * @pkt = RPC packet 
 * @len = Length of packet 
 * return: -1 error or !=-1 sended bytes 
 */ 
int rpc_pkt_Send(int sock, int type, sockaddr_t * __restrict sa,  
                ait_val_t * __restrict pkt, int len); 
/* 
 * rpc_pkt_Receive() - Receive RPC packet 
 * 
 * @sock = Socket 
 * @type = Type of socket 
 * @sa = Server address 
 * @pkt = RPC packet 
 * return: -1 error or !=-1 sended bytes 
 */ 
int rpc_pkt_Receive(int sock, int type, sockaddr_t * __restrict sa,  
                ait_val_t * __restrict pkt); 
/* 
 * rpc_pkt_Request() - Build RPC Request packet 
 * 
 * @pkt = Packet buffer 
 * @sess = RPC session info 
 * @tag = Function tag for execution 
 * @vars = Function argument array of values, may be NULL 
 * @noreply = We not want RPC reply 
 * @nocrc = Without CRC calculation 
 * return: -1 error or != -1 prepared bytes into packet 
 */ 
int rpc_pkt_Request(ait_val_t * __restrict pkt, rpc_sess_t * __restrict sess,  
                unsigned short tag, array_t * __restrict vars, int noreply, int nocrc); 
/* 
 * rpc_pkt_Replay() - Decode RPC Replay packet 
 * 
 * @pkt = Packet buffer 
 * @sess = RPC session info 
 * @tag = Function tag 
 * @vars = Function argument array of values, may be NULL 
 * @nocrc = Without CRC calculation 
 * return: -1 error or != -1 return value from function 
 */ 
int rpc_pkt_Replay(ait_val_t * __restrict pkt, rpc_sess_t * __restrict sess,  
                unsigned short tag, array_t ** __restrict vars, int nocrc); 
/* 
 * rpc_cli_execCall() - Execute RPC call 
 * 
 * @cli = RPC Client session 
 * @noreply = We not want RPC reply 
 * @tag = Function tag for execution 
 * @in_vars = IN function argument array of values, may be NULL 
 * @out_vars = OUT returned array of rpc values, if !=NULL must be free after use with ait_freeVars() 
 * return: -1 error or != -1 ok result 
 */ 
int rpc_cli_execCall(rpc_cli_t *cli, int noreply, unsigned short tag,  
                array_t * __restrict in_vars, array_t ** __restrict out_vars); 
/* 
 * rpc_cli_freeCall() - Free resouce allocated by RPC call 
 * 
 * @out_vars = Returned array with variables from RPC call 
 * return: none 
 */ 
inline 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 
 */ 
inline int rpc_cli_ping(rpc_cli_t *cli); 
 
 
/* 
 * rpc_cli_openBLOBClient() - Connect to BLOB Server 
 * 
 * @rpccli = RPC Client session 
 * @Port = Port for bind server, if Port == 0 default port is selected 
 * return: NULL == error or !=NULL connection to BLOB server established 
 */ 
rpc_cli_t *rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, unsigned short Port); 
/* 
 * rpc_cli_closeBLOBClient() - Close connection to BLOB server and free resources 
 * 
 * @cli = BLOB Client session 
 * return: none 
 */ 
void rpc_cli_closeBLOBClient(rpc_cli_t ** __restrict cli); 
   
   
 #endif  #endif
Removed from v.1.14  
changed lines
  Added in v.1.28.8.2

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