[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.1.1.1.2.9 and 1.2.4.2

version 1.1.1.1.2.9, 2010/06/23 17:29:07 version 1.2.4.2, 2011/08/18 19:04:10
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, 2005, 2006, 2007, 2008, 2009, 2010, 2011
         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 15 Line 52
 #include <string.h>  #include <string.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>
   
   
Line 28 Line 67
 #define CALL_BLOBSHUTDOWN       "rpcBLOBServerShutdown"  #define CALL_BLOBSHUTDOWN       "rpcBLOBServerShutdown"
 #define CALL_BLOBCLIENTS        "rpcBLOBServerClients"  #define CALL_BLOBCLIENTS        "rpcBLOBServerClients"
 #define CALL_BLOBVARS           "rpcBLOBServerVars"  #define CALL_BLOBVARS           "rpcBLOBServerVars"
   #define CALL_BLOBSTATE          "rpcBLOBServerState"
   
 #define CALL_SRVSHUTDOWN        "rpcServerShutdown"  #define CALL_SRVSHUTDOWN        "rpcServerShutdown"
 #define CALL_SRVCLIENTS         "rpcServerClients"  #define CALL_SRVCLIENTS         "rpcServerClients"
Line 60  typedef struct { Line 100  typedef struct {
         union {          union {
                 uint8_t         *buffer;                  uint8_t         *buffer;
                 int8_t          *string;                  int8_t          *string;
                void            *blob;                uint32_t        blob;
                 size_t          size;                  size_t          size;
                 off_t           offset;                  off_t           offset;
                 time_t          datetime;                  time_t          datetime;
Line 108  typedef struct { Line 148  typedef struct {
                                                 if (val->val.string) { \                                                  if (val->val.string) { \
                                                         val->val_type = string; val->val_len = strlen(v) + 1; \                                                          val->val_type = string; val->val_len = strlen(v) + 1; \
                                                 } } while (0)                                                  } } while (0)
#define RPC_SET_BLOB(vl, v, l)          do { rpc_val_t *val = (vl); assert(val); val->val.blob = realloc(val->val.blob, l); \#define RPC_SET_BLOB(vl, v, l)          do { rpc_val_t *val = (vl); assert(val); val->val_type = blob; \
                                                if (val->val.blob) { \                                                val->val.blob = v; val->val_len = l; } while (0)
                                                        val->val_type = blob; val->val_len = l; \#define RPC_SET_BLOB2(vl, b)            do { rpc_val_t *val = (vl); assert(val); assert(b); val->val_type = blob; \
                                                        memcpy(val->val.blob, v, l); \                                                val->val.blob = b->blob_var; val->val_len = b->blob_len; } while (0)
                                                } } while (0) 
 #define RPC_SET_SIZE(vl, v)             do { rpc_val_t *val = (vl); assert(val); val->val_type = size; val->val.size = v; \  #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)                                                  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; \  #define RPC_SET_OFF(vl, v)              do { rpc_val_t *val = (vl); assert(val); val->val_type = offset; val->val.offset = v; \
Line 149  typedef struct { Line 188  typedef struct {
                                                         free(val->val.string); \                                                          free(val->val.string); \
                                                         val->val.string = NULL; \                                                          val->val.string = NULL; \
                                                 } \                                                  } \
                                                 if (val->val_type == blob && val->val.blob) { \  
                                                         free(val->val.blob); \  
                                                         val->val.blob = NULL; \  
                                                 } \  
                                                 val->val_type = val->val_len = 0; \                                                  val->val_type = val->val_len = 0; \
                                         } while (0)                                          } while (0)
   
   
#define RPC_CALLBACK_CHK_NUM_ARGS(f, n)       do { \#define RPC_CALLBACK_CHECK_INPUT(x)       do { \
                                                if (f->func_args != n) { \                                                if (!x) { \
                                                        rpc_SetErr(22, "Error:: different number of arguments!\n"); \                                                        rpc_SetErr(22, "Error:: invalid callback parameters ...\n"); \
                                                         return -1; \                                                          return -1; \
                                                 } \                                                  } \
                                         } while (0)                                          } while (0)
#define RPC_CALLBACK_CHECK_INPUT(s, f)   do { \#define RPC_CALLBACK_CHK_ARGS(f, n)     do { \
                                                if (!s || !f) { \                                                RPC_CALLBACK_CHECK_INPUT(f); \
                                                        rpc_SetErr(22, "Error:: invalid callback parameters ...\n"); \                                                if (f && f->func_args != n) { \
                                                         rpc_SetErr(22, "Error:: different number of arguments!\n"); \
                                                         return -1; \                                                          return -1; \
                                                 } \                                                  } \
                                         } while (0)                                          } while (0)
Line 192  typedef struct tagRPCFunc { Line 228  typedef struct tagRPCFunc {
         int8_t                  func_args;          int8_t                  func_args;
         rpc_val_t               *func_vals;          rpc_val_t               *func_vals;
   
           void                    *func_parent;
         struct tagRPCFunc       *func_next;          struct tagRPCFunc       *func_next;
 } rpc_func_t;  } rpc_func_t;
   
Line 222  struct tagBLOBHdr { Line 259  struct tagBLOBHdr {
         rpc_sess_t      hdr_session;          rpc_sess_t      hdr_session;
         uint8_t         hdr_cmd;          uint8_t         hdr_cmd;
         uint32_t        hdr_var;          uint32_t        hdr_var;
         uint32_t        hdr_seq;  
         uint32_t        hdr_len;          uint32_t        hdr_len;
           uint32_t        hdr_ret;
 } __packed;  } __packed;
   
 /* Network RPC client & server elements */  /* Network RPC client & server elements */
   
 typedef struct {  typedef struct {
         struct sockaddr cli_sa;         // host info          struct sockaddr cli_sa;         // host info
        int             cli_sock;       // socket        int             cli_sock;       // socket fd
         int             cli_type;       // socket type
         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
Line 272  typedef struct { Line 310  typedef struct {
 } 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 = current execution RPC call function
  * @arg2 = number of items in input array from call request
  * @arg3 = input array with values from RPC call execution request
  * return: -1 error or >-1 success execution
  */
 typedef int (*rpc_callback_t)(rpc_func_t *, int, rpc_val_t *);
   
   
 // -----------------------------------------------------------------------  // -----------------------------------------------------------------------
Line 292  inline const char *cli_GetError(); Line 337  inline const char *cli_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
 * @family = Family socket type, AF_INET or AF_INET6 * @sockType = Socket type, like SOCK_STREAM, SOCK_DGRAM or SOCK_RAW
 * @csHost = Host name or IP address for bind server, if NULL any address * @family = Family type, AF_INET, AF_INET6 or AF_LOCAL
  * @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 sockType, 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   * @srv = RPC Server instance
Line 333  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 379  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
 int rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv);  int rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv);
   
 /*  /*
  * rpc_srv_getBLOB() Get registered BLOB   
  * @srv = RPC Server instance  
  * @var = hash for variable  
  * return: NULL not found, !=NULL return blob var  
  */  
 inline rpc_blob_t *rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var);  
   
 /*  
  * rpc_srv_registerCall() Register call to RPC server   * rpc_srv_registerCall() Register call to RPC server
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @csModule = Module name, if NULL self binary   * @csModule = Module name, if NULL self binary
  * @csFunc = Function name   * @csFunc = Function name
 * @args = Number of function arguments * @args = Number of return function arguments, use for restriction case!
  * 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, 
Line 376  rpc_func_t *rpc_srv_getFunc(rpc_srv_t * __restrict srv Line 414  rpc_func_t *rpc_srv_getFunc(rpc_srv_t * __restrict srv
 inline rpc_func_t *rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag, uint32_t hash);  inline rpc_func_t *rpc_srv_getCall(rpc_srv_t * __restrict srv, uint16_t tag, uint32_t hash);
 /*  /*
  * 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   * @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 call array of rpc values
  * 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_func_t * __restrict call, struct tagRPCCall * __restrict rpc, 
                struct tagRPCCall * __restrict rpc, rpc_val_t * __restrict args);                rpc_val_t * __restrict args);
   
   
 /*  /*
 * rpc_srv_declValsCall() Declare return variables for RPC call * rpc_srv_retValsCall() Declare return variables for RPC call and zeroed values
                                         (for safe handling return values, use this!)
  * @call = RPC function call   * @call = RPC function call
  * @return_vals = Number of return variables   * @return_vals = Number of return variables
    * return: NULL error, !=NULL array with return values for RPC call with return_vals items
    */
   inline rpc_val_t *rpc_srv_retValsCall(rpc_func_t * __restrict call, int return_vals);
   /*
    * rpc_srv_declValsCall() Declare return variables for RPC call, 
                                   if already allocated memory for RPC call return values 
                                   function reallocate used space with return_vals count elements
    * @call = RPC function call
    * @return_vals = Number of return variables
  * return: -1 error, !=-1 ok   * return: -1 error, !=-1 ok
  */   */
 inline int rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals);  inline int rpc_srv_declValsCall(rpc_func_t * __restrict call, int return_vals);
Line 407  inline void rpc_srv_freeValsCall(rpc_func_t * __restri Line 454  inline void rpc_srv_freeValsCall(rpc_func_t * __restri
  */   */
 inline int rpc_srv_copyValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvals);  inline int rpc_srv_copyValsCall(rpc_func_t * __restrict call, rpc_val_t ** __restrict newvals);
 /*  /*
 * rpc_srv_delValsCall() Clean values from return variables of RPC call * rpc_srv_zeroValsCall() Clean values from return variables of RPC call
  * @call = RPC function call   * @call = RPC function call
  * return: -1 error, !=-1 Returned number of cleaned RPC variables   * return: -1 error, !=-1 Returned number of cleaned RPC variables
  */   */
inline int rpc_srv_delValsCall(rpc_func_t * __restrict call);inline int rpc_srv_zeroValsCall(rpc_func_t * __restrict call);
 /*  /*
  * rpc_srv_getValsCall() Get return variables for RPC call   * rpc_srv_getValsCall() Get return variables for RPC call
  * @call = RPC function call   * @call = RPC function call
Line 422  inline int rpc_srv_getValsCall(rpc_func_t * __restrict Line 469  inline int rpc_srv_getValsCall(rpc_func_t * __restrict
   
   
 /*  /*
    * rpc_srv_blobCreate() Create map blob to memory region and return object
    * @srv = RPC Server instance
    * @len = BLOB length object
    * return: NULL error or !=NULL allocated BLOB object
    */
   inline rpc_blob_t *rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len);
   /*
  * rpc_srv_blobMap() Map blob to memory region    * rpc_srv_blobMap() Map blob to memory region 
  * @srv = RPC Server instance   * @srv = RPC Server instance
  * @blob = Map to this BLOB element   * @blob = Map to this BLOB element
Line 443  inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict  Line 497  inline void rpc_srv_blobUnmap(rpc_blob_t * __restrict 
 inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);  inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob);
   
 /*  /*
    * rpc_srv_registerBLOB() Register new BLOB to server
    * @srv = RPC Server instance
    * @len = BLOB length
    * return: NULL error or new registered BLOB
    */
   rpc_blob_t *rpc_srv_registerBLOB(rpc_srv_t * __restrict srv, size_t len);
   /*
    * rpc_srv_unregisterBLOB() Unregister BLOB from server
    * @srv = RPC Server instance
    * @var = BLOB Variable for unregister
    * return: -1 error, 0 not found call, 1 unregister ok
    */
   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
    */
   inline rpc_blob_t *rpc_srv_getBLOB(rpc_srv_t * __restrict srv, uint32_t var);
   
   /*
  * rpc_srv_sendBLOB() Send mapped BLOB to client   * rpc_srv_sendBLOB() Send mapped BLOB to client
  * @cli = Client instance   * @cli = Client instance
  * @blob = Mapped BLOB element   * @blob = Mapped BLOB element
Line 452  int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_b Line 528  int rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_b
 /*  /*
  * rpc_srv_recvBLOB() Receive BLOB from client   * rpc_srv_recvBLOB() Receive BLOB from client
  * @cli = Client instance   * @cli = Client instance
 * return: -1 error, 0 ok * @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);int rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob);
   
   /*
    * rpc_cli_sendBLOB() Send BLOB to server
    * @cli = Client instance
    * @var = BLOB variable
    * @data = BLOB data
    * 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);
   /*
    * rpc_cli_recvBLOB() Receive BLOB from server
    * @cli = Client instance
    * @var = BLOB variable
    * @data = BLOB data, must be free after use!
    * return: -1 error, 0 ok, 1 remote error
    */
   int rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, rpc_val_t * __restrict var, void ** 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, rpc_val_t * __restrict var);
   /*
    * rpc_cli_getBLOB() Receive BLOB from server and Delete after that.
    * @cli = Client instance
    * @var = BLOB variable
    * @data = BLOB data, must be free after use!
    * return: -1 error, 0 ok, >0 remote error
    */
   inline int rpc_cli_getBLOB(rpc_cli_t * __restrict cli, rpc_val_t * __restrict var, void ** data);
   
   
   
 /* RPC Client side functions */  /* RPC Client side functions */
   
 /*  /*
Line 496  int rpc_cli_execCall(rpc_cli_t *cli, const char *csMod Line 606  int rpc_cli_execCall(rpc_cli_t *cli, const char *csMod
  * return: none   * return: none
  */   */
 inline void rpc_cli_freeVals(int args, rpc_val_t *vals);  inline void rpc_cli_freeVals(int args, rpc_val_t *vals);
   
   
   /*
    * rpc_cli_openBLOBClient() Connect to BLOB Server
    * @rpccli = RPC Client session
    * @Port = Port for bind server, if Port == 0 default port is selected
    * return: NULL == error or !=NULL connection to BLOB server established
    */
   rpc_cli_t *rpc_cli_openBLOBClient(rpc_cli_t * __restrict rpccli, u_short Port);
   /*
    * rpc_cli_closeBLOBClient() Close connection to BLOB server and free resources
    * @cli = BLOB Client session
    * return: none
    */
   void rpc_cli_closeBLOBClient(rpc_cli_t * __restrict cli);
   
   
 #endif  #endif
Removed from v.1.1.1.1.2.9  
changed lines
  Added in v.1.2.4.2

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