Annotation of libaitio/inc/aitio.h, revision 1.11.2.2
1.1 misho 1: /*************************************************************************
1.8 misho 2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
1.1 misho 4: *
5: * $Author: misho $
1.11.2.2! misho 6: * $Id: aitio.h,v 1.11.2.1 2011/08/29 14:57:53 misho Exp $
1.1 misho 7: *
1.8 misho 8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
1.1 misho 46: #ifndef __AITIO_H
47: #define __AITIO_H
48:
49:
1.8 misho 50: #include <assert.h>
1.7 misho 51: #include <openssl/evp.h>
52:
53:
1.8 misho 54: #define VACUUM_LEFT 1
55: #define VACUUM_BETWEEN 2
56:
1.11.2.1 misho 57: /* AIT arrays */
1.8 misho 58:
1.9 misho 59: typedef void ** sarr_seg_t;
60: typedef struct _tagSplitArray {
61: int sarr_num;
62: int sarr_seg;
63: int sarr_siz;
64: sarr_seg_t *sarr_data;
65: } sarr_t;
66:
1.8 misho 67: typedef struct _tagArray {
68: int arr_num;
69: void **arr_data;
70: } array_t;
71:
1.11.2.1 misho 72: /* URL staff ... */
73:
1.2 misho 74: typedef struct _tagURLItem {
75: int vallen;
76: char *value;
77: } url_Item_t;
78:
79: struct tagIOURL {
80: unsigned char url_line[BUFSIZ];
81:
82: url_Item_t url_tech;
83: url_Item_t url_user;
84: url_Item_t url_pass;
85: url_Item_t url_host;
86: url_Item_t url_port;
87: url_Item_t url_path;
88: url_Item_t url_args;
89:
90: char *url_reserved;
91: };
92:
1.6 misho 93: struct tagReqXML {
94: unsigned char xml_line[BUFSIZ];
95:
96: url_Item_t xml_namespace;
97: union {
98: url_Item_t container;
99: url_Item_t path;
100: } xml_node;
101: url_Item_t xml_data;
102: url_Item_t xml_attribute;
103: url_Item_t xml_value;
104: };
105:
1.11.2.2! misho 106: /* AIT RPC variables and managment */
1.11.2.1 misho 107:
108: typedef enum {
109: empty, /* empty -> variable is not set */
110: buffer, string, blob, array, /* buffer -> uint8_t*; string -> int8_t*;
111: blob -> void*(+socket); array -> array_t* */
112: u8, u16, u32, u64, /* unsigned integers ... */
113: i8, i16, i32, i64 /* integers ... */
114: } ait_type_t;
115:
116: typedef struct {
117: uint8_t val_type;
118: uint32_t val_len;
119: union {
120: uint8_t *buffer,
121: *array;
122: int8_t *string;
123: uint32_t blob;
124: uint8_t u8;
125: uint16_t u16;
126: uint32_t u32;
127: uint64_t u64;
128: int8_t i8;
129: int16_t i16;
130: int32_t i32;
131: int64_t i64;
132: } val;
133: } __packed ait_val_t;
134:
135: #define AIT_TYPE(_vl) (assert((_vl)), ((ait_type_t) (_vl)->val_type))
136: #define AIT_LEN(_vl) (assert((_vl)), (_vl)->val_len)
137: #define AIT_BLOB_CHUNKS(_vl, _n) (assert((_vl)), (_vl)->val_len / _n + ((_vl)->val_len % _n) ? 1 : 0)
138: #define AIT_ISEMPTY(_vl) (assert((_vl)), (_vl)->val_type == empty)
139:
140: #define AIT_GET_ARRAY(_vl) (assert((_vl)), assert((_vl)->val_type == array), \
141: ((array_t*) (_vl)->val.array))
142: #define AIT_GET_BUF(_vl) (assert((_vl)), assert((_vl)->val_type == buffer), (_vl)->val.buffer)
143: #define AIT_GET_STR(_vl) (assert((_vl)), assert((_vl)->val_type == string), (_vl)->val.string)
144: #define AIT_GET_BLOB(_vl) (assert((_vl)), assert((_vl)->val_type == blob), (_vl)->val.blob)
145: #define AIT_GET_U8(_vl) (assert((_vl)), assert((_vl)->val_type == u8), (_vl)->val.u8)
146: #define AIT_GET_U16(_vl) (assert((_vl)), assert((_vl)->val_type == u16), (_vl)->val.u16)
147: #define AIT_GET_U32(_vl) (assert((_vl)), assert((_vl)->val_type == u32), (_vl)->val.u32)
148: #define AIT_GET_U64(_vl) (assert((_vl)), assert((_vl)->val_type == u64), (_vl)->val.u64)
149: #define AIT_GET_I8(_vl) (assert((_vl)), assert((_vl)->val_type == i8), (_vl)->val.i8)
150: #define AIT_GET_I16(_vl) (assert((_vl)), assert((_vl)->val_type == i16), (_vl)->val.i16)
151: #define AIT_GET_I32(_vl) (assert((_vl)), assert((_vl)->val_type == i32), (_vl)->val.i32)
152: #define AIT_GET_I64(_vl) (assert((_vl)), assert((_vl)->val_type == i64), (_vl)->val.i64)
153:
154: #define AIT_SET_BUF(_vl, _v, _len) do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \
155: __val->val.buffer = malloc(_len); \
156: if (__val->val.buffer) { \
157: AIT_TYPE(__val) = buffer; AIT_LEN(__val) = _len; \
158: memcpy(__val->val.buffer, (_v), _len); \
159: } } while (0)
160: #define AIT_SET_STR(_vl, _v) do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \
161: __val->val.string = (int8_t*) strdup((_v)); \
162: if (__val->val.string) { \
163: AIT_TYPE(__val) = string; \
164: AIT_LEN(__val) = strlen((_v)) + 1; \
165: } } while (0)
166: #define AIT_SET_BLOB(_vl, _n, _len) do { ait_val_t *__val = (_vl); assert(__val); \
167: AIT_TYPE(__val) = blob; AIT_LEN(__val) = _len; \
168: __val->val.blob = _n; } while (0)
169: #define AIT_SET_BLOB2(_vl, _bv) do { ait_val_t *__val = (_vl); assert(__val); assert((_bv)); \
170: AIT_TYPE(__val) = blob; AIT_LEN(__val) = (_bv)->blob_len; \
171: __val->val.blob = (_bv)->blob_var; } while (0)
172: #define AIT_SET_ARRAY(_vl, _arr) do { ait_val_t *__val = (_vl); assert(__val); assert((_arr)); \
173: AIT_TYPE(__val) = array; AIT_LEN(__val) = io_arraySize((_arr)); \
1.11.2.2! misho 174: __val->val.array = (uint8_t*) (_arr); \
1.11.2.1 misho 175: } while (0)
176:
177: #define AIT_SET_U8(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
178: AIT_TYPE(__val) = u8; __val->val.u8 = _n; \
179: AIT_LEN(__val) = sizeof(uint8_t); } while (0)
180: #define AIT_SET_U16(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
181: AIT_TYPE(__val) = u16; __val->val.u16 = _n; \
182: AIT_LEN(__val) = sizeof(uint16_t); } while (0)
183: #define AIT_SET_U32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
184: AIT_TYPE(__val) = u32; __val->val.u32 = _n; \
185: AIT_LEN(__val) = sizeof(uint32_t); } while (0)
186: #define AIT_SET_U64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
187: AIT_TYPE(__val) = u64; __val->val.u64 = _n; \
188: AIT_LEN(__val) = sizeof(uint64_t); } while (0)
189: #define AIT_SET_I8(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
190: AIT_TYPE(__val) = i8; __val->val.i8 = _n; \
191: AIT_LEN(__val) = sizeof(int8_t); } while (0)
192: #define AIT_SET_I16(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
193: AIT_TYPE(__val) = i16; __val->val.i16 = _n; \
194: AIT_LEN(__val) = sizeof(int16_t); } while (0)
195: #define AIT_SET_I32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
196: AIT_TYPE(__val) = i32; __val->val.i32 = _n; \
197: AIT_LEN(__val) = sizeof(int32_t); } while (0)
198: #define AIT_SET_I64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
199: AIT_TYPE(__val) = i64; __val->val.i64 = _n; \
200: AIT_LEN(__val) = sizeof(int64_t); } while (0)
201:
202: #define AIT_FREE_VAL(_vl) do { ait_val_t *__val = (_vl); assert(__val); \
203: switch (AIT_TYPE(__val)) { \
204: case buffer: \
205: if (__val->val.buffer) { \
206: free(__val->val.buffer); \
207: __val->val.buffer = NULL; \
208: } \
209: break; \
210: case string: \
211: if (__val->val.string) { \
212: free(__val->val.string); \
213: __val->val.string = NULL; \
214: } \
215: break; \
216: } \
217: AIT_TYPE(__val) = empty; \
218: AIT_LEN(__val) = 0; \
219: } while (0)
220:
1.3 misho 221:
1.1 misho 222: // io_GetErrno() Get error code of last operation
223: inline int io_GetErrno();
224: // io_GetError() Get error text of last operation
225: inline const char *io_GetError();
226:
227:
228: /*
229: * ioPromptRead() Read data from input h[0] with prompt to output h[1]
230: * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout
231: * @csPrompt = Prompt before input, may be NULL
232: * @psData = Readed data
233: * @dataLen = Length of data
234: * return: 0 EOF; -1 error:: can`t read; >0 count of readed chars
235: */
236: int ioPromptRead(int *h, const char *csPrompt, char * __restrict psData, int dataLen);
237: /*
238: * ioPromptPassword() Read password from input h[0] with prompt to output h[1]
239: * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout
240: * @csPrompt = Prompt before input, may be NULL
241: * @psPass = Readed password
242: * @passLen = Length of password
243: * @confirm = Confirm password, 0 - get password, !=0 Ask for confirmation
244: * return: 0 EOF; -1 error:: can`t read; >0 count of readed chars
245: */
246: int ioPromptPassword(int *h, const char *csPrompt, char * __restrict psPass, int passLen, int confirm);
247:
248: /*
249: * ioRegexVerify() Function for verify data match in regex expression
250: * @csRegex = Regulare expression pattern
251: * @csData = Data for check and verify
252: * @startPos = Return start positions
253: * @endPos = Return end positions
254: * return: NULL not match or error; !=NULL begin of matched data
255: */
256: const char *ioRegexVerify(const char *csRegex, const char *csData, int *startPos, int *endPos);
257: /*
258: * ioRegexGet() Function for get data match in regex expression
259: * @csRegex = Regulare expression pattern
260: * @csData = Data from get
261: * @psString = Returned string if match
262: * @strLen = Length of string
263: * return: 0 not match; >0 count of returned chars
264: */
265: int ioRegexGet(const char *csRegex, const char *csData, char * __restrict psString, int strLen);
266: /*
267: * ioRegexReplace() Function for replace data match in regex expression with newdata
268: * @csRegex = Regulare expression pattern
269: * @csData = Source data
270: * @csNew = Data for replace
271: * return: NULL not match or error; !=NULL allocated new string, must be free after use!
272: */
273: char *ioRegexReplace(const char *csRegex, const char *csData, const char *csNew);
274:
1.2 misho 275: /*
1.6 misho 276: * ioVarAst() Function for evaluate string like asterisk variable "{text[:[-]#[:#]]}"
277: * @csString = Input string
278: * return: NULL error, !=NULL Allocated new string evaluated from input string, must be free()
279: */
280: char *ioVarAst(const char *csString);
281:
282: /*
1.2 misho 283: * io_Path2File() Parse and make path/filename pair
284: * @csArgs = Input argument line
285: * @psPath = Output Path, if ==NULL path not returned
286: * @pathLen = Size of path array
287: * @psFile = Output File
288: * @fileLen = Size of file array
289: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
290: */
291: inline int io_Path2File(const char * __restrict csArgs, char * __restrict psPath, int pathLen,
292: char * __restrict psFile, int fileLen);
293:
294: /*
1.4 misho 295: * io_UnquotStr() Remove quots from input text string
296: * @psLine = Text string
297: * return: 0 nothing to do; 1 successful unquoted string
298: */
1.5 misho 299: inline int io_UnquotStr(unsigned char * __restrict psLine);
1.4 misho 300: /*
301: * io_LTrimStr() Remove left whitespaces from text string
302: * @psLine = Text string
303: * return: 0 nothing to do; !=0 Removed bytes
304: */
1.5 misho 305: inline int io_LTrimStr(unsigned char * __restrict psLine);
1.4 misho 306: /*
307: * io_RTrimStr() Remove right whitespaces from text string
308: * @psLine = Text string
309: * return: 0 nothing to do; !=0 Removed bytes
310: */
1.5 misho 311: inline int io_RTrimStr(unsigned char * __restrict psLine);
1.4 misho 312: /*
313: * io_TrimStr() Remove left and right whitespaces from text string
314: * @psLine = Text string
315: * return: 0 nothing to do; !=0 Removed bytes
316: */
1.5 misho 317: inline int io_TrimStr(unsigned char * __restrict psLine);
1.4 misho 318: /*
1.5 misho 319: * io_Ch2Hex() Convert from Char string to Hex string
1.4 misho 320: * @psLine = Text string
321: * @lineLen = Length of Text string
1.5 misho 322: * return: NULL nothing to do or error; !=0 Allocated new converted data without term\0 (must be free)
1.4 misho 323: */
1.5 misho 324: inline unsigned char *io_Ch2Hex(unsigned char *psLine, int lineLen);
1.4 misho 325: /*
1.5 misho 326: * io_Hex2Ch() Convert from Hex string to Char string
1.4 misho 327: * @psLine = Text string
328: * @lineLen = Length of Text string
329: * return: NULL nothing to do or error; !=0 Allocated new converted string(must be free)
330: */
1.5 misho 331: inline char *io_Hex2Ch(unsigned char *psLine, int lineLen);
1.4 misho 332:
333: /*
1.8 misho 334: * io_arrayInit() - Create and initialize dynamic array
335: * @numItems = Number of Items
336: * return: NULL error, != NULL allocated memory for array
337: */
338: inline array_t *io_arrayInit(int numItems);
339: /*
1.10 misho 340: * io_arrayDestroy() - Free and destroy dynamic array
1.8 misho 341: * @parr = Array
342: * return: none
343: */
344: inline void io_arrayDestroy(array_t ** __restrict parr);
345: /*
1.10 misho 346: * io_arrayFree() - Free all data in dynamic array items
1.8 misho 347: * (WARNING! If assign static array dont use this!!!)
348: * @arr = Array
349: * return: none
350: */
351: inline void io_arrayFree(array_t * __restrict arr);
352: /*
1.10 misho 353: * io_arrayFrom() - Create and fill array from array with pointers
1.11 misho 354: * @pargv = Array with pointers
1.10 misho 355: * @argc = Number of Items, if 0 walk through argv and stop when reach NULL item
1.11 misho 356: * return: NULL error, != NULL allocated new array
1.10 misho 357: */
1.11 misho 358: inline array_t *io_arrayFrom(const char *** __restrict pargv, int argc);
1.10 misho 359: /*
360: * io_arrayTo() - Create and fill array with pointers from dynamic array
361: * @arr = Array
1.11 misho 362: * return: NULL error, != NULL allocated memory for array, NULL terminated
1.10 misho 363: */
364: inline char **io_arrayTo(array_t * __restrict arr);
365: /*
1.8 misho 366: * io_arrayLen() - Get last used element in dynamic array (array Length)
367: * @arr = Array
368: * return: -1 error, 0 empty or >0 position of last used element
369: */
370: inline int io_arrayLen(array_t * __restrict arr);
371: /*
1.10 misho 372: * io_arrayConcat() Concat source array to destination array
373: * @dest = Destination array
374: * @src = Source array
375: * return: -1 error; >0 new count of destination array
376: */
377: int io_arrayConcat(array_t * __restrict dest, array_t * __restrict src);
378: /*
1.8 misho 379: * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!
380: * @arr = Array
381: * @newNumItems = Number of Items
382: * return: -1 error, 0 ok
383: */
384: int io_arrayGrow(array_t * __restrict arr, int newNumItems);
385: /*
386: * io_arrayVacuum() - Vacuum dynamic array, empty elements will be deleted
387: * @arr = Array
388: * @fromWhere = 1 begin, 2 ALL empty elements
389: * return: -1 error, 0 ok
390: */
391: int io_arrayVacuum(array_t * __restrict arr, int fromWhere);
392:
1.11 misho 393: #define io_arraySize(_arr) (assert((_arr)), (_arr)->arr_num)
1.8 misho 394:
1.11 misho 395: #define io_arrayGet(_arr, _d) (assert((_arr) && (_arr)->arr_num > _d), *((_arr)->arr_data + _d))
396: #define io_array(_arr, _d, _type) (assert((_arr) && (_arr)->arr_num > _d), \
397: ((_type) *((_arr)->arr_data + _d)))
1.8 misho 398: #define io_arraySet(_arr, _d, _ptr) do { \
1.11 misho 399: assert((_arr) && (_arr)->arr_num > _d); \
400: *((_arr)->arr_data + _d) = (void*) (_ptr); \
1.8 misho 401: } while (0)
1.11 misho 402: #define io_arrayDel(_arr, _d, _fri) do { \
403: assert((_arr) && (_arr)->arr_num > _d); \
404: if (_fri) \
405: free(*((_arr)->arr_data + _d)); \
406: *((_arr)->arr_data + _d) = NULL; \
1.9 misho 407: } while (0)
1.8 misho 408:
409: /*
410: * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position
411: * @arr = Array
412: * @data = Element, if set NULL return only first empty position
413: * return: -1 not found empty position, array is full!, >-1 return position of stored element into array
414: */
415: inline int io_arrayPush(array_t * __restrict arr, void **data);
416: /*
417: * io_arrayPop() - Pop element from dynamic array like stack manner, last used position
418: * @arr = Array
1.11 misho 419: * @data = Element, if set NULL return only last used position
1.8 misho 420: * @delAfter = Delete after Pop element, !=0 delete element from array after return data
421: * return: -1 not found used position, array is empty!, >-1 return element position
422: */
423: inline int io_arrayPop(array_t * __restrict arr, void ** __restrict data, int delAfter);
424:
425: /*
426: * io_argsNum() Parse and calculate number of arguments
427: * @csArgs = Input arguments line
428: * @csDelim = Delimiter(s) for separate
429: * return: 0 error format; -1 error:: can`t read; >0 ok, number of items
430: */
431: inline int io_argsNum(const char *csArgs, const char *csDelim);
432:
433: /*
434: * io_arrayMake() Parse and make array from arguments ... (input string will be modified!!!
435: * and output array must be free with io_arrayDestroy() after use!)
436: * @psArgs = Input arguments line, after execute string is modified!!!
437: * @nargs = Maximum requested count of arguments from input string psArgs, if 0 all psArgs
438: * @csDelim = Delimiter(s) for separate
439: * @parr = Output array of arguments ... (must be free with io_arrayDestroy() after use!)
440: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
441: */
442: int io_arrayMake(char * __restrict psArgs, int nargs, const char *csDelim,
443: array_t ** __restrict parr);
444:
445: /*
446: * io_MakeAV() Parse and make attribute/value pair
447: * @csArgs = Input argument line
448: * @csDelim = Delimiter for separate
449: * @psAttr = Output Attribute
450: * @attrLen = Size of attribute array
451: * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
452: * @valLen = Size of value array
453: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
454: */
455: int io_MakeAV(const char * __restrict csArgs, const char *csDelim,
456: char * __restrict psAttr, int attrLen, char * __restrict psValue, int valLen);
457:
1.9 misho 458: /*
459: * io_sarrInit() - Create and initialize dynamic split-order array
460: * @numItems = Number of Items
461: * @segLen = Length of segment
462: * return: NULL error, != NULL allocated memory for array
463: */
464: inline sarr_t *io_sarrInit(int numItems, int segLen);
465: /*
466: * io_sarrDestroy() - Free all data in dynamic split-order array and Destroy array
467: * @parr = Array
468: * return: none
469: */
470: inline void io_sarrDestroy(sarr_t ** __restrict parr);
471: /*
472: * io_sarrGrow() - Grow/Shrink dynamic split-order array, Use with care when it shrink!!!
473: * @arr = Array
474: * @newNumItems = Number of Items
475: * return: -1 error, 0 ok
476: */
477: int io_sarrGrow(sarr_t * __restrict arr, int newNumItems);
478: /*
479: * io_sarrVacuum() - Vacuum dynamic split-order array, empty segments will be freed
480: * @arr = Array
481: * return: -1 error, >-1 freed segments
482: */
483: inline int io_sarrVacuum(sarr_t * __restrict arr);
1.11 misho 484: #define io_sarrSize(_arr) (assert((_arr)), (_arr)->sarr_num)
1.9 misho 485: /*
486: * io_sarrGet() - Get element from dynamic split-order array
487: * @arr = Array
488: * @idx = Index (warning 1st element is at position 1)
489: * return: NULL not found, !=NULL element
490: */
491: inline void *io_sarrGet(sarr_t * __restrict arr, unsigned int idx);
492: /*
493: * io_sarrGet2() - Always get element from dynamic split-order array
494: * Function automatic grow array. Good use for Hash tables!
495: * @arr = Array
496: * @idx = Index (warning 1st element is at position 1)
497: * return: NULL not found, !=NULL element
498: */
499: void *io_sarrGet2(sarr_t * __restrict arr, unsigned int idx);
500: /*
501: * io_sarrSet() - Set element to dynamic split-order array
502: * @arr = Array
503: * @idx = Index (warning 1st element is at position 1)
504: * @data = Value
505: * return: NULL error or empty, !=NULL old value in element
506: */
507: inline void *io_sarrSet(sarr_t * __restrict arr, unsigned int idx, void *data);
1.11 misho 508: #define io_sarrDel(_arr, _idx) io_sarrSet((_arr), _idx, NULL)
509: #define io_sarr(_arr, _idx, _type) (_type)io_sarrGet((_arr), _idx)
510: /*
511: * io_sarr2array() - Convert from split-order array to dynamic array
512: * @sa = split array
513: * @sarrFree = after convert split array !=0 will be destroyed sarray
514: * return: NULL error or != NULL new array
515: */
516: array_t *io_sarr2array(sarr_t ** __restrict sa, int sarrFree);
517: /*
518: * io_array2sarr() - Convert from dynamic array to split-order array
519: * @a = array
520: * @segLen = Length of segment
521: * @arrFree = after convert array !=0 will be destroyed
522: * return: NULL error or != NULL new sarr
523: */
524: sarr_t *io_array2sarr(array_t ** __restrict a, int segLen, int arrFree);
1.8 misho 525:
526: /*
1.10 misho 527: * io_CopyEnv() Copy environment to new environment array;
528: * @oldenv = Environment array
529: * return: NULL error; !=NULL Allocated new environment array(must be free)
530: */
531: char **io_CopyEnv(const char **oldenv);
532: /*
533: * io_ExecArgs() Build exec arguments from other array
534: * @psProg = Program name for execute
535: * @oldarg = Arguments array
536: * return: NULL error; !=NULL Allocated execution array(must be free)
537: */
538: char **io_ExecArgs(const char *psProg, const char **oldarg);
539: /*
540: * io_FreeNullTerm() Free dynamic allocated null terminated array with strings
541: * @arr = Pointer to array for free
542: * return: none
543: */
544: inline void io_FreeNullTerm(char *** __restrict arr);
545:
546: /*
1.2 misho 547: * ioURLGet() Parse and get data from input URL
548: * @csURL = Input URL line
549: * @url = Output parsed URL
550: * return: 0 error format not find tech:// and return URL like path;
551: -1 error:: can`t read; >0 ok, up bits for known elements
552: */
553: int ioURLGet(const char *csURL, struct tagIOURL *url);
554: /*
555: * ioURLGetValue() Get value from parsed URL
556: * @url = Input parsed URL
557: * @csAttr = Attribute for search
558: * @psValue = Return value of attribute, if ==NULL only check for existence of attribute
559: * @valLen = Size of psValue array
560: * return: 0 error attribute not find; -1 error:: can`t read; >0 ok, find at position
561: */
562: int ioURLGetValue(struct tagIOURL *url, const char *csAttr, char * __restrict psValue, int valLen);
563: /*
564: * ioURLGetFile() Get file from parsed URL
565: * @url = Input parsed URL
566: * @psValue = Return filename, if not specified file in url path, replace with /
567: * @valLen = Size of psValue array
568: * return: -1 error:: can`t read; 0 ok
569: */
570: int ioURLGetFile(struct tagIOURL *url, char * __restrict psValue, int valLen);
571:
1.3 misho 572:
573: /*
1.6 misho 574: * ioXMLGet() Parse and get data from input XML request string [ns:]container[|attribute[=value]][?data]
575: * @csXML = Input XML request line
576: * @xml = Output parsed XML request
577: * return: 0 error format incorrect, -1 error:: can`t read; >0 ok readed elements bits
578: */
579: int ioXMLGet(const char *csXML, struct tagReqXML *xml);
580:
581:
582: /*
1.5 misho 583: * ioMkDir() Function for racursive directory creation and validation
584: * @csDir = Full directory path
585: * @mode = Mode for directory creation if missing dir
586: * return: -1 error, 0 directory path exist, >0 created missing dirs
587: */
588: int ioMkDir(const char *csDir, int mode);
589:
1.6 misho 590: /*
591: * ioWatchDirLoop() Function for watching changes in directory and fire callback
592: * @csDir = Full directory path
593: * @callback = Callback if raise event! nOp -1 delete, 0 change/move, 1 create
594: * return: -1 error, !=-1 ok, number of total signaled events
595: */
596: int ioWatchDirLoop(const char *csDir, int (*callback)(const char *csName, int nOp));
597:
1.5 misho 598:
599: /*
600: * io_rread() Raw VFS read function
601: * @fd = File handle
602: * @buf = Read buffer
603: * @nbytes = Read buffer size
604: * @offset = Read from position, if -1 read nbytes from current position
605: * @update = Update file handle position !0
606: * return: -1 error or !=-1 readed bytes
607: */
608: inline int io_rread(int fd, void * __restrict buf, size_t nbytes, off_t offset, int update);
609: /*
610: * io_rwrite() Raw VFS write function
611: * @fd = File handle
612: * @buf = Write buffer
613: * @nbytes = Write bytes from buffer
614: * @offset = Write at position, if -1 write nbytes from current position
615: * @update = Update file handle position !0
616: * return: -1 error or !=-1 writed bytes
617: */
618: inline int io_rwrite(int fd, void * __restrict buf, size_t nbytes, off_t offset, int update);
619:
620: /* Disk I/O helper macros */
621: #define io_read(f, b, n) io_rread(f, b, n, -1, 1)
622: #define io_write(f, b, n) io_rwrite(f, b, n, -1, 1)
623:
624:
625: /* Debug helper macros */
626: extern int io_Debug;
627:
628: #define io_initDebug(x) io_Debug = (x);
629: #define io_addDebug io_Debug++
630: #define ioDEBUG(x, fmt, ...) do { \
631: assert((fmt)); \
632: char str[STRSIZ] = { 0 }; \
1.11 misho 633: snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
1.5 misho 634: if ((x) <= io_Debug) \
635: syslog(LOG_DEBUG, "ioDebug(%d):%s(%d): %s\n", \
636: (x), __func__, __LINE__, str); \
637: } while (0)
638:
639: #define ioERROR(x, fmt, ...) do { \
640: assert((fmt)); \
641: char str[STRSIZ] = { 0 }; \
1.11 misho 642: snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
1.5 misho 643: syslog(LOG_ERR, "ioError():%s(%d): #%d - %s\n", \
644: __func__, __LINE__, (x), str); \
645: } while (0)
646: #define io_sysERROR(x) do { \
647: if (x > 0 || errno) \
648: syslog(LOG_ERR, "ioError(sys):%s(%d): #%d - %s\n", \
649: __func__, __LINE__, x > 0 ? x : errno, \
650: strerror(x > 0 ? x : errno)); \
651: } while (0)
652: #define io_aitERROR(ait) do { \
653: if (ait##_GetErrno()) \
654: syslog(LOG_ERR, "ioError(ait):%s(%d): #%d - %s\n", \
655: __func__, __LINE__, ait##_GetErrno(), \
656: ait##_GetError()); \
657: } while (0)
1.3 misho 658:
1.1 misho 659:
1.7 misho 660: /* Crypto framework */
661:
662: /*
663: * ioCipher() Cipher wrapper for all supported crypto algorythms
664: * @pInput = input buffer
665: * @inLen = input buffer len
666: * @ppOutput = output allocated buffe, must be free after use
667: * @Cipher = cipher engine, like EVP_bf_cbc() or etc...
668: * @pKey = key
669: * @pIV = IV, salt (8 bytes)
670: * @nMode = Mode 0 - decrypting or 1 - encrypting
671: * return: 0 not present data or error!; >0 number of processed and returned bytes into ppOutput
672: */
673: int ioCipher(unsigned char *pInput, int inLen, unsigned char **ppOutput, const EVP_CIPHER *Cipher,
674: unsigned char *pKey, unsigned char *pIV, int nMode);
675:
676: /*
677: * io_Blowfish() Blowfish cipher algorythm, work with ASCII hex strings
678: * @pInput = input buffer
679: * @inLen = input buffer len
680: * @ppOutput = output allocated buffe, must be free after use
681: * @pKey = key
682: * @pIV = IV, salt (8 bytes)
683: * @nMode = Mode 0 - decrypting or 1 - encrypting
684: * return: 0 not present data or error!; >0 number of processed and returned bytes into ppOutput
685: */
1.8 misho 686: int io_Blowfish(unsigned char *pInput, int inLen, unsigned char **ppOutput,
687: unsigned char *pKey, unsigned char *pIV, int nMode);
1.7 misho 688:
689:
1.1 misho 690: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to aitio.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / inc