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

Diff for /libaitio/inc/aitio.h between versions 1.13.2.1 and 1.13.2.9

version 1.13.2.1, 2011/12/13 09:57:27 version 1.13.2.9, 2012/01/05 09:03:06
Line 115  struct tagReqXML { Line 115  struct tagReqXML {
 /* AIT RPC variables and managment */  /* AIT RPC variables and managment */
   
 typedef enum {  typedef enum {
        empty,                          /* empty -> variable is not set */        empty, ptr,                    /* empty -> variable is not set; ptr -> void* */
        buffer, string, blob,           /* buffer -> uint8_t*; string -> int8_t*; blob -> void*(+socket); */        buffer, string, blob,           /* buffer -> uint8_t*; string -> int8_t*; blob -> uint32_t blobID(+socket); */
         f32, f64,                       /* float -> f32; double -> f64 */          f32, f64,                       /* float -> f32; double -> f64 */
         u8, u16, u32, u64,              /* unsigned integers ... */          u8, u16, u32, u64,              /* unsigned integers ... */
         i8, i16, i32, i64,              /* integers ... */          i8, i16, i32, i64,              /* integers ... */
Line 129  typedef struct { Line 129  typedef struct {
         union {          union {
                 uint64_t        net;                  uint64_t        net;
   
                   void            *ptr;
                 uint8_t         *buffer;                  uint8_t         *buffer;
                 int8_t          *string;                  int8_t          *string;
                 uint32_t        blob;                  uint32_t        blob;
Line 150  typedef struct { Line 151  typedef struct {
 #define AIT_BLOB_CHUNKS(_vl, _n)        (assert((_vl)), AIT_LEN((_vl)) / _n + (AIT_LEN((_vl)) % _n) ? 1 : 0)  #define AIT_BLOB_CHUNKS(_vl, _n)        (assert((_vl)), AIT_LEN((_vl)) / _n + (AIT_LEN((_vl)) % _n) ? 1 : 0)
 #define AIT_ISEMPTY(_vl)                (assert((_vl)), AIT_TYPE((_vl)) == empty)  #define AIT_ISEMPTY(_vl)                (assert((_vl)), AIT_TYPE((_vl)) == empty)
   
   #define AIT_GET_PTR(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == ptr), (_vl)->val.ptr)
   #define AIT_GET_PTR2(_vl)               (assert((_vl)), (_vl)->val.ptr)
 #define AIT_GET_BUF(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == buffer), (_vl)->val.buffer)  #define AIT_GET_BUF(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == buffer), (_vl)->val.buffer)
 #define AIT_GET_STR(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == string), (_vl)->val.string)  #define AIT_GET_STR(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == string), (_vl)->val.string)
 #define AIT_GET_BLOB(_vl)               (assert((_vl)), assert(AIT_TYPE((_vl)) == blob), (_vl)->val.blob)  #define AIT_GET_BLOB(_vl)               (assert((_vl)), assert(AIT_TYPE((_vl)) == blob), (_vl)->val.blob)
Line 164  typedef struct { Line 167  typedef struct {
 #define AIT_GET_F32(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == f32), (_vl)->val.f32)  #define AIT_GET_F32(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == f32), (_vl)->val.f32)
 #define AIT_GET_F64(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == f64), (_vl)->val.f64)  #define AIT_GET_F64(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == f64), (_vl)->val.f64)
   
#define AIT_SET_BUF(_vl, _v, _len)      do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \#define AIT_SET_PTR(_vl, _p, _len)      do { ait_val_t *__val = (_vl); assert(__val); \
                                                 __val->val_type = ptr; AIT_LEN(__val) = _len; \
                                                 __val->val.ptr = _p; } while (0)
 #define AIT_SET_BUF(_vl, _v, _len)      do { ait_val_t *__val = (_vl); assert(__val); \
                                                 __val->val.buffer = malloc(_len); \                                                  __val->val.buffer = malloc(_len); \
                                                 if (__val->val.buffer) { \                                                  if (__val->val.buffer) { \
                                                         __val->val_type = buffer; AIT_LEN(__val) = _len; \                                                          __val->val_type = buffer; AIT_LEN(__val) = _len; \
                                                         memcpy(__val->val.buffer, (_v), _len); \                                                          memcpy(__val->val.buffer, (_v), _len); \
                                                 } } while (0)                                                  } } while (0)
#define AIT_SET_STR(_vl, _v)            do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \#define AIT_SET_STR(_vl, _v)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                 __val->val.string = (int8_t*) strdup((_v)); \                                                  __val->val.string = (int8_t*) strdup((_v)); \
                                                 if (__val->val.string) { \                                                  if (__val->val.string) { \
                                                         __val->val_type = string; \                                                          __val->val_type = string; \
                                                         AIT_LEN(__val) = strlen((_v)) + 1; \                                                          AIT_LEN(__val) = strlen((_v)) + 1; \
                                                 } } while (0)                                                  } } while (0)
   #define AIT_SET_STRCAT(_vl, _v)         do { ait_val_t *__val = (_vl); assert(__val); \
                                                   assert(AIT_TYPE(__val) == string); \
                                                   void *__p = realloc(AIT_LEN(__val) + strlen((_v))); \
                                                   if (__p) { \
                                                           __val->val.string = __p; \
                                                           AIT_LEN(__val) += strlen((_v)); \
                                                           strlcat(__val->val.string, (_v), AIT_LEN(__val)); \
                                                   } } while (0)
 #define AIT_SET_BLOB(_vl, _n, _len)     do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_BLOB(_vl, _n, _len)     do { ait_val_t *__val = (_vl); assert(__val); \
                                                 __val->val_type = blob; AIT_LEN(__val) = _len; \                                                  __val->val_type = blob; AIT_LEN(__val) = _len; \
                                                 __val->val.blob = _n; } while (0)                                                  __val->val.blob = _n; } while (0)
Line 216  typedef struct { Line 230  typedef struct {
                                                 AIT_LEN(__val) = sizeof(double); } while (0)                                                  AIT_LEN(__val) = sizeof(double); } while (0)
   
                                         /* if attribute zeroCopy is set not execute free() */                                          /* if attribute zeroCopy is set not execute free() */
#define AIT_FREE_VAL(_vl)               do { ait_val_t *__val = (_vl); assert(__val); \#define AIT_FREE_VAL(_vl)               do { ait_val_t *__val = (ait_val_t*) (_vl); assert(__val); \
                                                 switch (__val->val_type) { \                                                  switch (__val->val_type) { \
                                                         case buffer: \                                                          case buffer: \
                                                                 if (__val->val.buffer) { \                                                                  if (__val->val.buffer) { \
Line 334  int io_vars2map(unsigned char *buf, int buflen, array_ Line 348  int io_vars2map(unsigned char *buf, int buflen, array_
 array_t *io_map2vars(unsigned char *buf, int buflen, int vnum, int zcpy);  array_t *io_map2vars(unsigned char *buf, int buflen, int vnum, int zcpy);
   
 /*  /*
    * io_allocVar() Allocate memory for variable
    * return: NULL error or new variable, after use free variable with io_freeVar()
    */
   inline ait_val_t *io_allocVar(void);
   /*
    * io_freeVar() Free allocated memory for variable
    * @val = Variable
    * return: none
    */
   inline void io_freeVar(ait_val_t * __restrict val);
   /*
  * io_allocVars() Allocate ait_val_t array   * io_allocVars() Allocate ait_val_t array
  * @varnum = Number of variables   * @varnum = Number of variables
  * return: =NULL error or !=NULL allocated array   * return: =NULL error or !=NULL allocated array
Line 551  int io_arrayVacuum(array_t * __restrict arr, int fromW Line 576  int io_arrayVacuum(array_t * __restrict arr, int fromW
  * @data = Element, if set NULL GET element at position or !=NULL PUT element at position   * @data = Element, if set NULL GET element at position or !=NULL PUT element at position
  * return: -1 error or !=-1 return element at position   * return: -1 error or !=-1 return element at position
  */   */
inline void *io_arrayElem(array_t * __restrict arr, int n, void **data);inline void *io_arrayElem(array_t * __restrict arr, int n, void *data);
 /*  /*
  * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position   * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position
  * @arr = Array   * @arr = Array
Line 779  inline int io_rwrite(int fd, void * __restrict buf, si Line 804  inline int io_rwrite(int fd, void * __restrict buf, si
 /* Debug helper macros */  /* Debug helper macros */
 extern int io_Debug;  extern int io_Debug;
   
#define io_initDebug(x)         io_Debug = (x);#define io_enableDEBUG          int io_Debug
#define io_addDebug           io_Debug++#define io_initDebug(x)         (io_Debug = (x))
 #define io_incDebug           (io_Debug++)
 #define io_decDebug             (io_Debug--)
 
 /* Debug macros */
 #define ioVERBOSE(x)            if ((x) <= io_Debug)
 #define ioTRACE(x)              if ((x) <= io_Debug) \
                                            syslog(LOG_DEBUG, "I'm in %s(%d)", __func__, __LINE__)
 #define ioDEBUG(x, fmt, ...)    do { \  #define ioDEBUG(x, fmt, ...)    do { \
                                         assert((fmt)); \                                          assert((fmt)); \
                                         char str[STRSIZ] = { 0 }; \                                          char str[STRSIZ] = { 0 }; \
                                         snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \                                          snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
                                         if ((x) <= io_Debug) \                                          if ((x) <= io_Debug) \
                                                syslog(LOG_DEBUG, "ioDebug(%d):%s(%d): %s\n", \                                                syslog(LOG_DEBUG, "Debug(%d):%s(%d): %s\n", \
                                                                 (x), __func__, __LINE__, str); \                                                                  (x), __func__, __LINE__, str); \
                                 } while (0)                                  } while (0)
   
   /* Logger macro */
   #define ioLOGGER(x, fmt, ...)   do { \
                                           assert((fmt)); \
                                           char str[STRSIZ] = { 0 }; \
                                           snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
                                           syslog((x), "Logger:%s(%d): %s\n", \
                                                                   __func__, __LINE__, str); \
                                   } while (0)
   
   /* Error state macros */
 #define ioERROR(x, fmt, ...)    do { \  #define ioERROR(x, fmt, ...)    do { \
                                         assert((fmt)); \                                          assert((fmt)); \
                                         char str[STRSIZ] = { 0 }; \                                          char str[STRSIZ] = { 0 }; \
                                         snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \                                          snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
                                        syslog(LOG_ERR, "ioError():%s(%d): #%d - %s\n", \                                        syslog(LOG_ERR, "Error:%s(%d): #%d - %s\n", \
                                                          __func__, __LINE__, (x), str); \                                                           __func__, __LINE__, (x), str); \
                                 } while (0)                                  } while (0)
#define io_sysERROR(x)            do { \#define ioLOGERR(x)            do { \
                                         if (x > 0 || errno) \                                          if (x > 0 || errno) \
                                                syslog(LOG_ERR, "ioError(sys):%s(%d): #%d - %s\n", \                                                syslog(LOG_ERR, "Error(sys):%s(%d): #%d - %s\n", \
                                                                 __func__, __LINE__, x > 0 ? x : errno, \                                                                  __func__, __LINE__, x > 0 ? x : errno, \
                                                                 strerror(x > 0 ? x : errno)); \                                                                  strerror(x > 0 ? x : errno)); \
                                 } while (0)                                  } while (0)
#define io_aitERROR(ait)  do { \#define ioLIBERR(ait)          do { \
                                         if (ait##_GetErrno()) \                                          if (ait##_GetErrno()) \
                                                syslog(LOG_ERR, "ioError(ait):%s(%d): #%d - %s\n", \                                                syslog(LOG_ERR, "Error(lib):%s(%d): #%d - %s\n", \
                                                                 __func__, __LINE__, ait##_GetErrno(), \                                                                  __func__, __LINE__, ait##_GetErrno(), \
                                                                 ait##_GetError()); \                                                                  ait##_GetError()); \
                                 } while (0)                                  } while (0)
Removed from v.1.13.2.1  
changed lines
  Added in v.1.13.2.9

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