[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.11.2.10 and 1.14.2.5

version 1.11.2.10, 2011/09/01 08:13:10 version 1.14.2.5, 2012/03/13 16:40:12
Line 47  SUCH DAMAGE. Line 47  SUCH DAMAGE.
 #define __AITIO_H  #define __AITIO_H
   
   
   #define COMPAT_43TTY
   
 #include <assert.h>  #include <assert.h>
 #include <openssl/evp.h>  #include <openssl/evp.h>
   #include <openssl/aes.h>
   #include <sys/tty.h>
   #include <sys/ioctl_compat.h>
   #include <sys/socket.h>
   #include <sys/un.h>
   #include <net/if_dl.h>
   #include <netinet/in.h>
   
   
 #define VACUUM_LEFT     1  #define VACUUM_LEFT     1
Line 69  typedef struct _tagArray { Line 78  typedef struct _tagArray {
         void    **arr_data;          void    **arr_data;
 } array_t;  } array_t;
   
 /* URL staff ... */  
   
 typedef struct _tagURLItem {  
         int     vallen;  
         char    *value;  
 } url_Item_t;  
   
 struct tagIOURL {  
         unsigned char   url_line[BUFSIZ];  
   
         url_Item_t      url_tech;  
         url_Item_t      url_user;  
         url_Item_t      url_pass;  
         url_Item_t      url_host;  
         url_Item_t      url_port;  
         url_Item_t      url_path;  
         url_Item_t      url_args;  
   
         char            *url_reserved;  
 };  
   
 struct tagReqXML {  
         unsigned char   xml_line[BUFSIZ];  
   
         url_Item_t      xml_namespace;  
         union {  
                 url_Item_t      container;  
                 url_Item_t      path;  
         }               xml_node;  
         url_Item_t      xml_data;  
         url_Item_t      xml_attribute;  
         url_Item_t      xml_value;  
 };  
   
 /* 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 115  typedef enum { Line 90  typedef enum {
   
 typedef struct {  typedef struct {
         uint8_t         val_type;          uint8_t         val_type;
           uint8_t         val_pad[3];
         uint32_t        val_len;          uint32_t        val_len;
         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 137  typedef struct { Line 114  typedef struct {
   
 #define AIT_TYPE(_vl)                   ((ait_type_t) (_vl)->val_type)  #define AIT_TYPE(_vl)                   ((ait_type_t) (_vl)->val_type)
 #define AIT_LEN(_vl)                    (_vl)->val_len  #define AIT_LEN(_vl)                    (_vl)->val_len
   #define AIT_RAW(_vl)                    (_vl)->val.net
   #define AIT_VOID(_vl)                   (_vl)->val.ptr
 #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_LIKE(_vl, _type)        (assert((_vl)), (_type) (_vl)->val.net)
   
   #define AIT_GET_PTR(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == ptr), (_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 154  typedef struct { Line 136  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; \
Line 166  typedef struct { Line 151  typedef struct {
                                                         __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)
 #define AIT_SET_BLOB2(_vl, _bv)         do { ait_val_t *__val = (_vl); assert(__val); assert((_bv)); \  #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_type = blob; AIT_LEN(__val) = (_bv)->blob_len; \
                                                 __val->val.blob = (_bv)->blob_var; } while (0)                                                  __val->val.blob = (_bv)->blob_var; } while (0)
   #define AIT_NEW_BLOB(_vl, _len)         AIT_SET_BLOB((_vl), 0, _len)
   
 #define AIT_SET_U8(_vl, _n)             do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_U8(_vl, _n)             do { ait_val_t *__val = (_vl); assert(__val); \
                                                 __val->val_type = u8; __val->val.u8 = _n; \                                                  __val->val_type = u8; __val->val.u8 = _n; \
Line 205  typedef struct { Line 199  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 226  typedef struct { Line 220  typedef struct {
                                                 AIT_LEN(__val) = 0; \                                                  AIT_LEN(__val) = 0; \
                                         } while (0)                                          } while (0)
   
   struct io_ether_addr {
           u_int8_t ether_addr_octet[6];
   };
   typedef struct io_ether_addr io_ether_addr_t;
   
   typedef union {
           struct sockaddr_storage ss;
           struct sockaddr         sa;
           struct sockaddr_un      sun;
           struct sockaddr_in      sin;
           struct sockaddr_in6     sin6;
           struct sockaddr_dl      sdl;
   } io_sockaddr_t;
   
   
 // io_GetErrno() Get error code of last operation  // io_GetErrno() Get error code of last operation
 inline int io_GetErrno();  inline int io_GetErrno();
 // io_GetError() Get error text of last operation  // io_GetError() Get error text of last operation
Line 234  inline const char *io_GetError(); Line 242  inline const char *io_GetError();
   
   
 /*  /*
 * io_vals2buffer() Marshaling data from array with variables to buffer * io_ether_ntoa() Convert ethernet address to string
  * @n = ethernet address structure, like struct ether_addr
  * @a = string
  * @len = string length
  * return: NULL error or !=NULL string a
  */
 inline char *io_ether_ntoa(const struct io_ether_addr *n, char * __restrict a, int len);
 /*
  * io_ether_aton() Convert string to ethernet address
  * @a = string
  * @e = ethernet address structure, like struct ether_addr
  * return: NULL error or !=NULL ethernet address structure
  */
 inline struct io_ether_addr *io_ether_aton(const char *a, struct io_ether_addr *e);
 /*
  * io_n2port() Extract port from network structure
  * @addr = Address
  * return: 0 not supported family type or port number
  */
 inline u_short io_n2port(io_sockaddr_t * __restrict addr);
 /*
  * io_n2addr() Extract address from network structure
  * @addr = Address
  * @val = Value for store string address
  * return: NULL error or !=NULL string address from val
  */
 const char *io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t * __restrict val);
 /*
  * io_gethostbyname() Get host and port and make network structure
  * @psHost = Hostname
  * @port = Port
  * @addr = Network address structure
  * return: NULL error or !=NULL network structure
  */
 io_sockaddr_t *io_gethostbyname(const char *psHost, unsigned short port, 
                 io_sockaddr_t * __restrict addr);
 
 /*
  * io_vars2buffer() Marshaling data from array with variables to buffer
  * @buf = Buffer   * @buf = Buffer
  * @buflen = Size of buffer   * @buflen = Size of buffer
  * @vars = Variable array   * @vars = Variable array
  * return: -1 error, 0 nothing done or >0 size of marshaled data   * return: -1 error, 0 nothing done or >0 size of marshaled data
  */   */
int io_vals2buffer(unsigned char *buf, int buflen, array_t *vars);int io_vars2buffer(unsigned char *buf, int buflen, array_t *vars);
 /*  /*
 * io_buffer2vals() De-marshaling data from buffer to array with variables * io_buffer2vars() De-marshaling data from buffer to array with variables
  * @buf = Buffer   * @buf = Buffer
  * @buflen = Size of buffer   * @buflen = Size of buffer
  * @vnum = Number of variables into buffer   * @vnum = Number of variables into buffer
Line 250  int io_vals2buffer(unsigned char *buf, int buflen, arr Line 296  int io_vals2buffer(unsigned char *buf, int buflen, arr
                 *DON'T MODIFY OR DESTROY BUFFER*. =0 call io_arrayFree() before io_arrayDestroy()                  *DON'T MODIFY OR DESTROY BUFFER*. =0 call io_arrayFree() before io_arrayDestroy()
  * return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()   * return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()
  */   */
array_t *io_buffer2vals(unsigned char *buf, int buflen, int vnum, int zcpy);array_t *io_buffer2vars(unsigned char *buf, int buflen, int vnum, int zcpy);
 /*
  * io_vars2map() Marshaling data from array with variables to memory map
  * @buf = Buffer
  * @buflen = Size of buffer
  * @vars = Variable array
  * return: -1 error, 0 nothing done or >0 size of marshaled data
  */
 int io_vars2map(unsigned char *buf, int buflen, array_t *vars);
 /*
  * io_map2vars() De-marshaling data from memory map to array with variables
  * @buf = Buffer
  * @buflen = Size of buffer
  * @vnum = Number of variables into buffer
  * @zcpy = Zero-copy for variables, if !=0 don't use io_arrayFree() for free variables and 
                 *DON'T MODIFY OR DESTROY BUFFER*. =0 call io_arrayFree() before io_arrayDestroy()
  * return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()
  */
 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
    * @varnum = Number of variables
    * return: =NULL error or !=NULL allocated array
    */
   inline array_t *io_allocVars(int varnum);
   /*
    * io_clrVars() Clear ait_val_t elements from array
    * @vars = Variable array
    * return: -1 error or size of array
    */
   inline int io_clrVars(array_t * __restrict vars);
   /*
    * io_freeVars() Free ait_val_t array
    * @vars = Variable array
    * return: none
    */
   inline void io_freeVars(array_t ** __restrict vars);
   
   
   /*
  * ioPromptRead() Read data from input h[0] with prompt to output h[1]   * ioPromptRead() Read data from input h[0] with prompt to output h[1]
  * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout   * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout
  * @csPrompt = Prompt before input, may be NULL   * @csPrompt = Prompt before input, may be NULL
Line 300  int ioRegexGet(const char *csRegex, const char *csData Line 395  int ioRegexGet(const char *csRegex, const char *csData
 char *ioRegexReplace(const char *csRegex, const char *csData, const char *csNew);  char *ioRegexReplace(const char *csRegex, const char *csData, const char *csNew);
   
 /*  /*
 * ioVarAst() Function for evaluate string like asterisk variable "{text[:[-]#[:#]]}" * ioStrAst() Function for evaluate string like asterisk variable "{text[:[-]#[:#]]}"
  * @csString = Input string   * @csString = Input string
  * return: NULL error, !=NULL Allocated new string evaluated from input string, must be free()   * return: NULL error, !=NULL Allocated new string evaluated from input string, must be free()
 */  */
char *ioVarAst(const char *csString);char *ioStrAst(const char *csString);
   
 /*  /*
  * io_Path2File() Parse and make path/filename pair  
  * @csArgs = Input argument line  
  * @psPath = Output Path, if ==NULL path not returned  
  * @pathLen = Size of path array  
  * @psFile = Output File  
  * @fileLen = Size of file array  
  * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items  
 */  
 inline int io_Path2File(const char * __restrict csArgs, char * __restrict psPath, int pathLen,   
                 char * __restrict psFile, int fileLen);  
   
 /*  
  * io_UnquotStr() Remove quots from input text string    * io_UnquotStr() Remove quots from input text string 
  * @psLine = Text string   * @psLine = Text string
  * return: 0 nothing to do; 1 successful unquoted string   * return: 0 nothing to do; 1 successful unquoted string
Line 358  inline unsigned char *io_Ch2Hex(unsigned char *psLine, Line 441  inline unsigned char *io_Ch2Hex(unsigned char *psLine,
 inline char *io_Hex2Ch(unsigned char *psLine, int lineLen);  inline char *io_Hex2Ch(unsigned char *psLine, int lineLen);
   
 /*  /*
    * io_Path2File() - Parse and make path/filename pair
    *
    * @csArgs = Input argument line
    * @psPath = Output Path, if ==NULL path not returned
    * @pathLen = Size of path array
    * @psFile = Output File
    * @fileLen = Size of file array
    * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
    */
   inline int
   io_Path2File(const char * __restrict csArgs, char * __restrict psPath, 
                   int pathLen, char * __restrict psFile, int fileLen);
   
   /*
  * io_arrayInit() - Create and initialize dynamic array   * io_arrayInit() - Create and initialize dynamic array
  * @numItems = Number of Items   * @numItems = Number of Items
  * return: NULL error, != NULL allocated memory for array   * return: NULL error, != NULL allocated memory for array
Line 444  int io_arrayVacuum(array_t * __restrict arr, int fromW Line 541  int io_arrayVacuum(array_t * __restrict arr, int fromW
                                         } while (0)                                          } while (0)
   
 /*  /*
    * io_arrayElem() - Always GET/PUT element into dynamic array, if not enough elements grow array
    * @arr = Array
    * @n = 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
    */
   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
  * @data = Element, if set NULL return only first empty position   * @data = Element, if set NULL return only first empty position
Line 589  char **io_ExecArgs(const char *psProg, const char **ol Line 694  char **io_ExecArgs(const char *psProg, const char **ol
 inline void io_FreeNullTerm(char *** __restrict arr);  inline void io_FreeNullTerm(char *** __restrict arr);
   
 /*  /*
  * ioURLGet() Parse and get data from input URL  
  * @csURL = Input URL line  
  * @url = Output parsed URL  
  * return: 0 error format not find tech:// and return URL like path;   
                 -1 error:: can`t read; >0 ok, up bits for known elements  
 */  
 int ioURLGet(const char *csURL, struct tagIOURL *url);  
 /*  
  * ioURLGetValue() Get value from parsed URL  
  * @url = Input parsed URL  
  * @csAttr = Attribute for search  
  * @psValue = Return value of attribute, if ==NULL only check for existence of attribute  
  * @valLen = Size of psValue array  
  * return: 0 error attribute not find; -1 error:: can`t read; >0 ok, find at position  
 */  
 int ioURLGetValue(struct tagIOURL *url, const char *csAttr, char * __restrict psValue, int valLen);  
 /*  
  * ioURLGetFile() Get file from parsed URL  
  * @url = Input parsed URL  
  * @psValue = Return filename, if not specified file in url path, replace with /  
  * @valLen = Size of psValue array  
  * return: -1 error:: can`t read; 0 ok  
 */  
 int ioURLGetFile(struct tagIOURL *url, char * __restrict psValue, int valLen);  
   
   
 /*  
  * ioXMLGet() Parse and get data from input XML request string [ns:]container[|attribute[=value]][?data]  
  * @csXML = Input XML request line  
  * @xml = Output parsed XML request  
  * return: 0 error format incorrect, -1 error:: can`t read; >0 ok readed elements bits  
 */  
 int ioXMLGet(const char *csXML, struct tagReqXML *xml);  
   
   
 /*  
  * ioMkDir() Function for racursive directory creation and validation   * ioMkDir() Function for racursive directory creation and validation
  * @csDir = Full directory path   * @csDir = Full directory path
  * @mode = Mode for directory creation if missing dir   * @mode = Mode for directory creation if missing dir
Line 670  inline int io_rwrite(int fd, void * __restrict buf, si Line 739  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 ioSYSERR(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)
Line 730  int ioCipher(unsigned char *pInput, int inLen, unsigne Line 816  int ioCipher(unsigned char *pInput, int inLen, unsigne
 */  */
 int io_Blowfish(unsigned char *pInput, int inLen, unsigned char **ppOutput,   int io_Blowfish(unsigned char *pInput, int inLen, unsigned char **ppOutput, 
                 unsigned char *pKey, unsigned char *pIV, int nMode);                  unsigned char *pKey, unsigned char *pIV, int nMode);
   /*
    * io_ctr_AES() Encrypt/Decrypt stream cipher CTR_AES
    * @pInput = Input buffer with ASCII
    * @inLen = Input buffer data length
    * @ppOutput = Output buffer with cipher data, must be free after use
    * @pKey = Key
    * @IV = IVector/Nonce/Counter, Warning: IV must be variable, because we write there!!!
    * return: -1 error or >-1 how many cipher blocks proceeded
    */
   int io_ctr_AES(unsigned char *pInput, int inLen, unsigned char **ppOutput, 
                   unsigned char *pKey, unsigned char IV[AES_BLOCK_SIZE]);
   
   
   /*
    * ioAllocPTY() Allocate new PTY and TTY
    * @ptyfd = master fd, pty
    * @ttyfd = slave fd, tty
    * @name = tty device name if not null
    * @namesiz = name length, must be above 63 bytes.
    * @term = termios for terminal
    * @winz = winsize for terminal
    * return: -1 error or 0 ok
    */
   inline int ioAllocPTY(int *ptyfd, int *ttyfd, char * __restrict name, int namesiz, 
                   struct termios * __restrict term, struct winsize * __restrict winz);
   /*
    * ioFreePTY() Release PTY and TTY device
    * @ptyfd = master fd, pty (==-1 skip closing pty)
    * @ttyname = tty filename
    * return: none
    */
   inline void ioFreePTY(int ptyfd, const char *ttyname);
   /*
    * ioChgWinPTY() Change window size of PTY
    * @ptyfd = master fd, pty
    * @row = row
    * @col = col
    * @xpxl = x pixels
    * @ypxl = y pixels
    * return: -1 error or 0 ok
    */
   inline int ioChgWinPTY(int ptyfd, unsigned short row, unsigned short col, 
                   unsigned short xpxl, unsigned short ypxl);
   /*
    * ioSetOwnerTTY() Set owner to TTY
    * @ttyname = tty filename
    * @UID = uid
    * @GID = gid
    * return: -1 error or 0 ok
    */
   int ioSetOwnerTTY(const char *ttyname, uid_t UID, gid_t GID);
   /*
    * ioSetSidTTY() Makes the process's controlling TTY and sets it to sane modes.
    * @ttyfd = slave fd, tty
    * @ttyname = tty filename
    * return: -1 error or 0 ok
    */
   int ioSetSidTTY(int *ttyfd, const char *ttyname);
   /*
    * ioSetRAWMode() Enter into RAW mode
    * @fd = tty fd
    * @otio = saved old termios for later restore if !=NULL
    * return: -1 error or 0 ok
    */
   inline int ioSetRAWMode(int fd, struct termios *otio);
   /*
    * ioRestoreMode() Restore termios to tty fd
    * @fd = tty fd
    * @tio = termios structure for restore
    * return: -1 error or 0 ok
    */
   inline int ioRestoreMode(int fd, struct termios tio);
   /*
    * ioForkPTY() Fork new process with session leader and new TTY
    * @ptyfd = master fd, pty
    * @name = tty device name if not null
    * @namesiz = name length, must be above 63 bytes.
    * @term = termios for terminal
    * @winz = winsize for terminal
    * @otio = old termios structure for restore
    * return: -1 error, 0 child process or >0 parent: pid of child
    */
   pid_t ioForkPTY(int *ptyfd, char * __restrict name, int namesiz, struct termios * __restrict term, 
                   struct winsize * __restrict winz, struct termios * __restrict otio);
   
   /*
    * ioCreatePIDFile() Create PID file
    * @csName = PID filename
    * @ifExists = !=0 if filename exists return error
    * return: -1 error or 0 ok
    */
   inline int ioCreatePIDFile(const char *csName, int ifExists);
   
   /*
    * ioSendFile() AITNET sendfile() userland implementation, not dependant from OS
    * @s = socket
    * @csFile = file for send
    * @sendLen = bytes to send, if 0 send all data
    * @offset = start file offset
    * @sndbuf = SO_SNDBUF value, if 0 use default
    * return: 0 error, >0 ok, sended bytes
    */
   size_t ioSendFile(int s, const char *csFile, size_t sendLen, off_t offset, int sndbuf);
   /*
    * ioRecvFile() Receive file from socket, fastest (zero-copy) way
    * @s = socket
    * @csFile = file for receive
    * @recvLen = receive bytes
    * @over = overwrite file if exists with mode like 0644
    * @rcvbuf = SO_RCVBUF value, if 0 use default
    * return: 0 error, >0 ok, received bytes
    */
   size_t ioRecvFile(int s, const char *csFile, size_t recvLen, int over, int rcvbuf);
   
   
   /* Buffered file access over memory block */
   
   /*
    * io_fmemopen() File buffered stream operations over memory block
    *
    * @base = Base address of memory block, if =NULL Infinit length(auto-grow)
    * @basesize = Size of memory block
    * return: NULL error or !=NULL Opened file resource
    */
   FILE *io_fmemopen(void ** __restrict base, off_t basesize);
   /*
    * io_fmapopen() File buffered stream operations over MMAP block
    *
    * @csFile = Filename for MMAP, if =NULL private MMAP block
    * @mode = File open mode
    * @perm = If file not exists will be created with this access permissions
    * @prot = MMAP protection
    * @flags = MMAP mode flags
    * @offset = Map from file offset, if csFile==NULL then this is size of MMAP private block
    * return: NULL error or !=NULL Opened file resource
    */
   FILE *io_fmapopen(const char *csFile, int mode, int perm, int prot, int flags, off_t offset);
   /*
    * io_fd2buf() Convert open file handle to buffered file I/O
    *
    * @fd = File handle
    * @mode = Permissions for new buffered file I/O
    * return: NULL error or open buffered file
    */
   inline FILE *io_fd2buf(int fd, const char *mode);
   /*
    * io_dumbFile() Create empry or dumb file with fixed size
    *
    * @csFile = Filename for create
    * @mode = File access permissions
    * @size = File size
    * return: -1 error or open file handle
    */
   int io_dumbFile(const char *csFile, int mode, off_t size);
   
   
 #endif  #endif
Removed from v.1.11.2.10  
changed lines
  Added in v.1.14.2.5

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