--- libaitio/inc/aitio.h 2011/08/29 12:00:57 1.11 +++ libaitio/inc/aitio.h 2011/08/29 23:10:51 1.11.2.3 @@ -3,7 +3,7 @@ * by Michael Pounov * * $Author: misho $ -* $Id: aitio.h,v 1.11 2011/08/29 12:00:57 misho Exp $ +* $Id: aitio.h,v 1.11.2.3 2011/08/29 23:10:51 misho Exp $ * ************************************************************************** The ELWIX and AITNET software is distributed under the following @@ -54,6 +54,7 @@ SUCH DAMAGE. #define VACUUM_LEFT 1 #define VACUUM_BETWEEN 2 +/* AIT arrays */ typedef void ** sarr_seg_t; typedef struct _tagSplitArray { @@ -68,6 +69,8 @@ typedef struct _tagArray { void **arr_data; } array_t; +/* URL staff ... */ + typedef struct _tagURLItem { int vallen; char *value; @@ -99,6 +102,123 @@ struct tagReqXML { url_Item_t xml_attribute; url_Item_t xml_value; }; + +/* AIT RPC variables and managment */ + +typedef enum { + empty, /* empty -> variable is not set */ + buffer, string, blob, array, /* buffer -> uint8_t*; string -> int8_t*; + blob -> void*(+socket); array -> array_t* */ + u8, u16, u32, u64, /* unsigned integers ... */ + i8, i16, i32, i64 /* integers ... */ +} ait_type_t; + +typedef struct { + uint8_t val_type; + uint32_t val_len; + union { + uint8_t *buffer, + *array; + int8_t *string; + uint32_t blob; + 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 ait_val_t; + +#define AIT_TYPE(_vl) ((ait_type_t) (_vl)->val_type) +#define AIT_LEN(_vl) (_vl)->val_len +#define AIT_BLOB_CHUNKS(_vl, _n) (assert((_vl)), (_vl)->val_len / _n + ((_vl)->val_len % _n) ? 1 : 0) +#define AIT_ISEMPTY(_vl) (assert((_vl)), (_vl)->val_type == empty) + +#define AIT_GET_ARRAY(_vl) (assert((_vl)), assert((_vl)->val_type == array), \ + ((array_t*) (_vl)->val.array)) +#define AIT_GET_BUF(_vl) (assert((_vl)), assert((_vl)->val_type == buffer), (_vl)->val.buffer) +#define AIT_GET_STR(_vl) (assert((_vl)), assert((_vl)->val_type == string), (_vl)->val.string) +#define AIT_GET_BLOB(_vl) (assert((_vl)), assert((_vl)->val_type == blob), (_vl)->val.blob) +#define AIT_GET_U8(_vl) (assert((_vl)), assert((_vl)->val_type == u8), (_vl)->val.u8) +#define AIT_GET_U16(_vl) (assert((_vl)), assert((_vl)->val_type == u16), (_vl)->val.u16) +#define AIT_GET_U32(_vl) (assert((_vl)), assert((_vl)->val_type == u32), (_vl)->val.u32) +#define AIT_GET_U64(_vl) (assert((_vl)), assert((_vl)->val_type == u64), (_vl)->val.u64) +#define AIT_GET_I8(_vl) (assert((_vl)), assert((_vl)->val_type == i8), (_vl)->val.i8) +#define AIT_GET_I16(_vl) (assert((_vl)), assert((_vl)->val_type == i16), (_vl)->val.i16) +#define AIT_GET_I32(_vl) (assert((_vl)), assert((_vl)->val_type == i32), (_vl)->val.i32) +#define AIT_GET_I64(_vl) (assert((_vl)), assert((_vl)->val_type == i64), (_vl)->val.i64) + +#define AIT_SET_BUF(_vl, _v, _len) do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \ + __val->val.buffer = malloc(_len); \ + if (__val->val.buffer) { \ + __val->val_type = buffer; AIT_LEN(__val) = _len; \ + memcpy(__val->val.buffer, (_v), _len); \ + } } while (0) +#define AIT_SET_STR(_vl, _v) do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \ + __val->val.string = (int8_t*) strdup((_v)); \ + if (__val->val.string) { \ + __val->val_type = string; \ + AIT_LEN(__val) = strlen((_v)) + 1; \ + } } while (0) +#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.blob = _n; } while (0) +#define AIT_SET_BLOB2(_vl, _bv) do { ait_val_t *__val = (_vl); assert(__val); assert((_bv)); \ + __val->val_type = blob; AIT_LEN(__val) = (_bv)->blob_len; \ + __val->val.blob = (_bv)->blob_var; } while (0) +#define AIT_SET_ARRAY(_vl, _arr) do { ait_val_t *__val = (_vl); assert(__val); assert((_arr)); \ + __val->val_type = array; AIT_LEN(__val) = io_arraySize((_arr)); \ + __val->val.array = (uint8_t*) (_arr); \ + } while (0) + +#define AIT_SET_U8(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \ + __val->val_type = u8; __val->val.u8 = _n; \ + AIT_LEN(__val) = sizeof(uint8_t); } while (0) +#define AIT_SET_U16(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \ + __val->val_type = u16; __val->val.u16 = _n; \ + AIT_LEN(__val) = sizeof(uint16_t); } while (0) +#define AIT_SET_U32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \ + __val->val_type = u32; __val->val.u32 = _n; \ + AIT_LEN(__val) = sizeof(uint32_t); } while (0) +#define AIT_SET_U64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \ + __val->val_type = u64; __val->val.u64 = _n; \ + AIT_LEN(__val) = sizeof(uint64_t); } while (0) +#define AIT_SET_I8(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \ + __val->val_type = i8; __val->val.i8 = _n; \ + AIT_LEN(__val) = sizeof(int8_t); } while (0) +#define AIT_SET_I16(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \ + __val->val_type = i16; __val->val.i16 = _n; \ + AIT_LEN(__val) = sizeof(int16_t); } while (0) +#define AIT_SET_I32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \ + __val->val_type = i32; __val->val.i32 = _n; \ + AIT_LEN(__val) = sizeof(int32_t); } while (0) +#define AIT_SET_I64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \ + __val->val_type = i64; __val->val.i64 = _n; \ + AIT_LEN(__val) = sizeof(int64_t); } while (0) + +#define AIT_FREE_VAL(_vl) do { ait_val_t *__val = (_vl); assert(__val); \ + switch (__val->val_type) { \ + case buffer: \ + if (__val->val.buffer) { \ + free(__val->val.buffer); \ + __val->val.buffer = NULL; \ + } \ + break; \ + case string: \ + if (__val->val.string) { \ + free(__val->val.string); \ + __val->val.string = NULL; \ + } \ + break; \ + default: \ + break; \ + } \ + __val->val_type = empty; \ + AIT_LEN(__val) = 0; \ + } while (0) // io_GetErrno() Get error code of last operation