[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.14 and 1.2

version 1.1.1.1.2.14, 2010/06/28 17:10:39 version 1.2, 2011/05/02 23:12:08
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 61  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 110  typedef struct { Line 149  typedef struct {
                                                         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_type = blob; \  #define RPC_SET_BLOB(vl, v, l)          do { rpc_val_t *val = (vl); assert(val); val->val_type = blob; \
                                                val->val.blob = (void*) v; val->val_len = l; } while (0)                                                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; \  #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 151  typedef struct { Line 192  typedef struct {
                                         } 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(f)     do { \#define RPC_CALLBACK_CHK_ARGS(f, n)     do { \
                                                if (!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 217  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 */
Line 335  void rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 377  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 464  inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv Line 498  inline int rpc_srv_blobFree(rpc_srv_t * __restrict srv
  * 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
 * return: -1 error or 0 register ok * 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);
 /*  /*
Line 474  rpc_blob_t *rpc_srv_registerBLOB(rpc_srv_t * __restric Line 508  rpc_blob_t *rpc_srv_registerBLOB(rpc_srv_t * __restric
  * return: -1 error, 0 not found call, 1 unregister ok   * return: -1 error, 0 not found call, 1 unregister ok
  */   */
 int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var);  int rpc_srv_unregisterBLOB(rpc_srv_t * __restrict srv, uint32_t var);
   /*
    * rpc_srv_getBLOB() Get registered BLOB 
    * @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
Line 503  int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, rpc_v Line 544  int rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, rpc_v
  * @cli = Client instance   * @cli = Client instance
  * @var = BLOB variable   * @var = BLOB variable
  * @data = BLOB data, must be free after use!   * @data = BLOB data, must be free after use!
 * return: -1 error, 0 ok, >0 unreceived data from server, may be 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, 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 */
Removed from v.1.1.1.1.2.14  
changed lines
  Added in v.1.2

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