1: /*************************************************************************
2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
4: *
5: * $Author: misho $
6: * $Id: aitio.h,v 1.11.2.1 2011/08/29 14:57:53 misho Exp $
7: *
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: */
46: #ifndef __AITIO_H
47: #define __AITIO_H
48:
49:
50: #include <assert.h>
51: #include <openssl/evp.h>
52:
53:
54: #define VACUUM_LEFT 1
55: #define VACUUM_BETWEEN 2
56:
57: /* AIT arrays */
58:
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:
67: typedef struct _tagArray {
68: int arr_num;
69: void **arr_data;
70: } array_t;
71:
72: /* URL staff ... */
73:
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:
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:
106: /* RPC variables and managment */
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)); \
174: } while (0)
175:
176: #define AIT_SET_U8(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
177: AIT_TYPE(__val) = u8; __val->val.u8 = _n; \
178: AIT_LEN(__val) = sizeof(uint8_t); } while (0)
179: #define AIT_SET_U16(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
180: AIT_TYPE(__val) = u16; __val->val.u16 = _n; \
181: AIT_LEN(__val) = sizeof(uint16_t); } while (0)
182: #define AIT_SET_U32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
183: AIT_TYPE(__val) = u32; __val->val.u32 = _n; \
184: AIT_LEN(__val) = sizeof(uint32_t); } while (0)
185: #define AIT_SET_U64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
186: AIT_TYPE(__val) = u64; __val->val.u64 = _n; \
187: AIT_LEN(__val) = sizeof(uint64_t); } while (0)
188: #define AIT_SET_I8(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
189: AIT_TYPE(__val) = i8; __val->val.i8 = _n; \
190: AIT_LEN(__val) = sizeof(int8_t); } while (0)
191: #define AIT_SET_I16(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
192: AIT_TYPE(__val) = i16; __val->val.i16 = _n; \
193: AIT_LEN(__val) = sizeof(int16_t); } while (0)
194: #define AIT_SET_I32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
195: AIT_TYPE(__val) = i32; __val->val.i32 = _n; \
196: AIT_LEN(__val) = sizeof(int32_t); } while (0)
197: #define AIT_SET_I64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
198: AIT_TYPE(__val) = i64; __val->val.i64 = _n; \
199: AIT_LEN(__val) = sizeof(int64_t); } while (0)
200:
201: #define AIT_FREE_VAL(_vl) do { ait_val_t *__val = (_vl); assert(__val); \
202: switch (AIT_TYPE(__val)) { \
203: case buffer: \
204: if (__val->val.buffer) { \
205: free(__val->val.buffer); \
206: __val->val.buffer = NULL; \
207: } \
208: break; \
209: case string: \
210: if (__val->val.string) { \
211: free(__val->val.string); \
212: __val->val.string = NULL; \
213: } \
214: break; \
215: case array: \
216: io_arrayDestroy(&AIT_GET_ARRAY(__val)); \
217: break; \
218: } \
219: AIT_TYPE(__val) = empty; \
220: AIT_LEN(__val) = 0; \
221: } while (0)
222:
223:
224: // io_GetErrno() Get error code of last operation
225: inline int io_GetErrno();
226: // io_GetError() Get error text of last operation
227: inline const char *io_GetError();
228:
229:
230: /*
231: * ioPromptRead() Read data from input h[0] with prompt to output h[1]
232: * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout
233: * @csPrompt = Prompt before input, may be NULL
234: * @psData = Readed data
235: * @dataLen = Length of data
236: * return: 0 EOF; -1 error:: can`t read; >0 count of readed chars
237: */
238: int ioPromptRead(int *h, const char *csPrompt, char * __restrict psData, int dataLen);
239: /*
240: * ioPromptPassword() Read password from input h[0] with prompt to output h[1]
241: * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout
242: * @csPrompt = Prompt before input, may be NULL
243: * @psPass = Readed password
244: * @passLen = Length of password
245: * @confirm = Confirm password, 0 - get password, !=0 Ask for confirmation
246: * return: 0 EOF; -1 error:: can`t read; >0 count of readed chars
247: */
248: int ioPromptPassword(int *h, const char *csPrompt, char * __restrict psPass, int passLen, int confirm);
249:
250: /*
251: * ioRegexVerify() Function for verify data match in regex expression
252: * @csRegex = Regulare expression pattern
253: * @csData = Data for check and verify
254: * @startPos = Return start positions
255: * @endPos = Return end positions
256: * return: NULL not match or error; !=NULL begin of matched data
257: */
258: const char *ioRegexVerify(const char *csRegex, const char *csData, int *startPos, int *endPos);
259: /*
260: * ioRegexGet() Function for get data match in regex expression
261: * @csRegex = Regulare expression pattern
262: * @csData = Data from get
263: * @psString = Returned string if match
264: * @strLen = Length of string
265: * return: 0 not match; >0 count of returned chars
266: */
267: int ioRegexGet(const char *csRegex, const char *csData, char * __restrict psString, int strLen);
268: /*
269: * ioRegexReplace() Function for replace data match in regex expression with newdata
270: * @csRegex = Regulare expression pattern
271: * @csData = Source data
272: * @csNew = Data for replace
273: * return: NULL not match or error; !=NULL allocated new string, must be free after use!
274: */
275: char *ioRegexReplace(const char *csRegex, const char *csData, const char *csNew);
276:
277: /*
278: * ioVarAst() Function for evaluate string like asterisk variable "{text[:[-]#[:#]]}"
279: * @csString = Input string
280: * return: NULL error, !=NULL Allocated new string evaluated from input string, must be free()
281: */
282: char *ioVarAst(const char *csString);
283:
284: /*
285: * io_Path2File() Parse and make path/filename pair
286: * @csArgs = Input argument line
287: * @psPath = Output Path, if ==NULL path not returned
288: * @pathLen = Size of path array
289: * @psFile = Output File
290: * @fileLen = Size of file array
291: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
292: */
293: inline int io_Path2File(const char * __restrict csArgs, char * __restrict psPath, int pathLen,
294: char * __restrict psFile, int fileLen);
295:
296: /*
297: * io_UnquotStr() Remove quots from input text string
298: * @psLine = Text string
299: * return: 0 nothing to do; 1 successful unquoted string
300: */
301: inline int io_UnquotStr(unsigned char * __restrict psLine);
302: /*
303: * io_LTrimStr() Remove left whitespaces from text string
304: * @psLine = Text string
305: * return: 0 nothing to do; !=0 Removed bytes
306: */
307: inline int io_LTrimStr(unsigned char * __restrict psLine);
308: /*
309: * io_RTrimStr() Remove right whitespaces from text string
310: * @psLine = Text string
311: * return: 0 nothing to do; !=0 Removed bytes
312: */
313: inline int io_RTrimStr(unsigned char * __restrict psLine);
314: /*
315: * io_TrimStr() Remove left and right whitespaces from text string
316: * @psLine = Text string
317: * return: 0 nothing to do; !=0 Removed bytes
318: */
319: inline int io_TrimStr(unsigned char * __restrict psLine);
320: /*
321: * io_Ch2Hex() Convert from Char string to Hex string
322: * @psLine = Text string
323: * @lineLen = Length of Text string
324: * return: NULL nothing to do or error; !=0 Allocated new converted data without term\0 (must be free)
325: */
326: inline unsigned char *io_Ch2Hex(unsigned char *psLine, int lineLen);
327: /*
328: * io_Hex2Ch() Convert from Hex string to Char string
329: * @psLine = Text string
330: * @lineLen = Length of Text string
331: * return: NULL nothing to do or error; !=0 Allocated new converted string(must be free)
332: */
333: inline char *io_Hex2Ch(unsigned char *psLine, int lineLen);
334:
335: /*
336: * io_arrayInit() - Create and initialize dynamic array
337: * @numItems = Number of Items
338: * return: NULL error, != NULL allocated memory for array
339: */
340: inline array_t *io_arrayInit(int numItems);
341: /*
342: * io_arrayDestroy() - Free and destroy dynamic array
343: * @parr = Array
344: * return: none
345: */
346: inline void io_arrayDestroy(array_t ** __restrict parr);
347: /*
348: * io_arrayFree() - Free all data in dynamic array items
349: * (WARNING! If assign static array dont use this!!!)
350: * @arr = Array
351: * return: none
352: */
353: inline void io_arrayFree(array_t * __restrict arr);
354: /*
355: * io_arrayFrom() - Create and fill array from array with pointers
356: * @pargv = Array with pointers
357: * @argc = Number of Items, if 0 walk through argv and stop when reach NULL item
358: * return: NULL error, != NULL allocated new array
359: */
360: inline array_t *io_arrayFrom(const char *** __restrict pargv, int argc);
361: /*
362: * io_arrayTo() - Create and fill array with pointers from dynamic array
363: * @arr = Array
364: * return: NULL error, != NULL allocated memory for array, NULL terminated
365: */
366: inline char **io_arrayTo(array_t * __restrict arr);
367: /*
368: * io_arrayLen() - Get last used element in dynamic array (array Length)
369: * @arr = Array
370: * return: -1 error, 0 empty or >0 position of last used element
371: */
372: inline int io_arrayLen(array_t * __restrict arr);
373: /*
374: * io_arrayConcat() Concat source array to destination array
375: * @dest = Destination array
376: * @src = Source array
377: * return: -1 error; >0 new count of destination array
378: */
379: int io_arrayConcat(array_t * __restrict dest, array_t * __restrict src);
380: /*
381: * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!
382: * @arr = Array
383: * @newNumItems = Number of Items
384: * return: -1 error, 0 ok
385: */
386: int io_arrayGrow(array_t * __restrict arr, int newNumItems);
387: /*
388: * io_arrayVacuum() - Vacuum dynamic array, empty elements will be deleted
389: * @arr = Array
390: * @fromWhere = 1 begin, 2 ALL empty elements
391: * return: -1 error, 0 ok
392: */
393: int io_arrayVacuum(array_t * __restrict arr, int fromWhere);
394:
395: #define io_arraySize(_arr) (assert((_arr)), (_arr)->arr_num)
396:
397: #define io_arrayGet(_arr, _d) (assert((_arr) && (_arr)->arr_num > _d), *((_arr)->arr_data + _d))
398: #define io_array(_arr, _d, _type) (assert((_arr) && (_arr)->arr_num > _d), \
399: ((_type) *((_arr)->arr_data + _d)))
400: #define io_arraySet(_arr, _d, _ptr) do { \
401: assert((_arr) && (_arr)->arr_num > _d); \
402: *((_arr)->arr_data + _d) = (void*) (_ptr); \
403: } while (0)
404: #define io_arrayDel(_arr, _d, _fri) do { \
405: assert((_arr) && (_arr)->arr_num > _d); \
406: if (_fri) \
407: free(*((_arr)->arr_data + _d)); \
408: *((_arr)->arr_data + _d) = NULL; \
409: } while (0)
410:
411: /*
412: * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position
413: * @arr = Array
414: * @data = Element, if set NULL return only first empty position
415: * return: -1 not found empty position, array is full!, >-1 return position of stored element into array
416: */
417: inline int io_arrayPush(array_t * __restrict arr, void **data);
418: /*
419: * io_arrayPop() - Pop element from dynamic array like stack manner, last used position
420: * @arr = Array
421: * @data = Element, if set NULL return only last used position
422: * @delAfter = Delete after Pop element, !=0 delete element from array after return data
423: * return: -1 not found used position, array is empty!, >-1 return element position
424: */
425: inline int io_arrayPop(array_t * __restrict arr, void ** __restrict data, int delAfter);
426:
427: /*
428: * io_argsNum() Parse and calculate number of arguments
429: * @csArgs = Input arguments line
430: * @csDelim = Delimiter(s) for separate
431: * return: 0 error format; -1 error:: can`t read; >0 ok, number of items
432: */
433: inline int io_argsNum(const char *csArgs, const char *csDelim);
434:
435: /*
436: * io_arrayMake() Parse and make array from arguments ... (input string will be modified!!!
437: * and output array must be free with io_arrayDestroy() after use!)
438: * @psArgs = Input arguments line, after execute string is modified!!!
439: * @nargs = Maximum requested count of arguments from input string psArgs, if 0 all psArgs
440: * @csDelim = Delimiter(s) for separate
441: * @parr = Output array of arguments ... (must be free with io_arrayDestroy() after use!)
442: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
443: */
444: int io_arrayMake(char * __restrict psArgs, int nargs, const char *csDelim,
445: array_t ** __restrict parr);
446:
447: /*
448: * io_MakeAV() Parse and make attribute/value pair
449: * @csArgs = Input argument line
450: * @csDelim = Delimiter for separate
451: * @psAttr = Output Attribute
452: * @attrLen = Size of attribute array
453: * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
454: * @valLen = Size of value array
455: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
456: */
457: int io_MakeAV(const char * __restrict csArgs, const char *csDelim,
458: char * __restrict psAttr, int attrLen, char * __restrict psValue, int valLen);
459:
460: /*
461: * io_sarrInit() - Create and initialize dynamic split-order array
462: * @numItems = Number of Items
463: * @segLen = Length of segment
464: * return: NULL error, != NULL allocated memory for array
465: */
466: inline sarr_t *io_sarrInit(int numItems, int segLen);
467: /*
468: * io_sarrDestroy() - Free all data in dynamic split-order array and Destroy array
469: * @parr = Array
470: * return: none
471: */
472: inline void io_sarrDestroy(sarr_t ** __restrict parr);
473: /*
474: * io_sarrGrow() - Grow/Shrink dynamic split-order array, Use with care when it shrink!!!
475: * @arr = Array
476: * @newNumItems = Number of Items
477: * return: -1 error, 0 ok
478: */
479: int io_sarrGrow(sarr_t * __restrict arr, int newNumItems);
480: /*
481: * io_sarrVacuum() - Vacuum dynamic split-order array, empty segments will be freed
482: * @arr = Array
483: * return: -1 error, >-1 freed segments
484: */
485: inline int io_sarrVacuum(sarr_t * __restrict arr);
486: #define io_sarrSize(_arr) (assert((_arr)), (_arr)->sarr_num)
487: /*
488: * io_sarrGet() - Get element from dynamic split-order array
489: * @arr = Array
490: * @idx = Index (warning 1st element is at position 1)
491: * return: NULL not found, !=NULL element
492: */
493: inline void *io_sarrGet(sarr_t * __restrict arr, unsigned int idx);
494: /*
495: * io_sarrGet2() - Always get element from dynamic split-order array
496: * Function automatic grow array. Good use for Hash tables!
497: * @arr = Array
498: * @idx = Index (warning 1st element is at position 1)
499: * return: NULL not found, !=NULL element
500: */
501: void *io_sarrGet2(sarr_t * __restrict arr, unsigned int idx);
502: /*
503: * io_sarrSet() - Set element to dynamic split-order array
504: * @arr = Array
505: * @idx = Index (warning 1st element is at position 1)
506: * @data = Value
507: * return: NULL error or empty, !=NULL old value in element
508: */
509: inline void *io_sarrSet(sarr_t * __restrict arr, unsigned int idx, void *data);
510: #define io_sarrDel(_arr, _idx) io_sarrSet((_arr), _idx, NULL)
511: #define io_sarr(_arr, _idx, _type) (_type)io_sarrGet((_arr), _idx)
512: /*
513: * io_sarr2array() - Convert from split-order array to dynamic array
514: * @sa = split array
515: * @sarrFree = after convert split array !=0 will be destroyed sarray
516: * return: NULL error or != NULL new array
517: */
518: array_t *io_sarr2array(sarr_t ** __restrict sa, int sarrFree);
519: /*
520: * io_array2sarr() - Convert from dynamic array to split-order array
521: * @a = array
522: * @segLen = Length of segment
523: * @arrFree = after convert array !=0 will be destroyed
524: * return: NULL error or != NULL new sarr
525: */
526: sarr_t *io_array2sarr(array_t ** __restrict a, int segLen, int arrFree);
527:
528: /*
529: * io_CopyEnv() Copy environment to new environment array;
530: * @oldenv = Environment array
531: * return: NULL error; !=NULL Allocated new environment array(must be free)
532: */
533: char **io_CopyEnv(const char **oldenv);
534: /*
535: * io_ExecArgs() Build exec arguments from other array
536: * @psProg = Program name for execute
537: * @oldarg = Arguments array
538: * return: NULL error; !=NULL Allocated execution array(must be free)
539: */
540: char **io_ExecArgs(const char *psProg, const char **oldarg);
541: /*
542: * io_FreeNullTerm() Free dynamic allocated null terminated array with strings
543: * @arr = Pointer to array for free
544: * return: none
545: */
546: inline void io_FreeNullTerm(char *** __restrict arr);
547:
548: /*
549: * ioURLGet() Parse and get data from input URL
550: * @csURL = Input URL line
551: * @url = Output parsed URL
552: * return: 0 error format not find tech:// and return URL like path;
553: -1 error:: can`t read; >0 ok, up bits for known elements
554: */
555: int ioURLGet(const char *csURL, struct tagIOURL *url);
556: /*
557: * ioURLGetValue() Get value from parsed URL
558: * @url = Input parsed URL
559: * @csAttr = Attribute for search
560: * @psValue = Return value of attribute, if ==NULL only check for existence of attribute
561: * @valLen = Size of psValue array
562: * return: 0 error attribute not find; -1 error:: can`t read; >0 ok, find at position
563: */
564: int ioURLGetValue(struct tagIOURL *url, const char *csAttr, char * __restrict psValue, int valLen);
565: /*
566: * ioURLGetFile() Get file from parsed URL
567: * @url = Input parsed URL
568: * @psValue = Return filename, if not specified file in url path, replace with /
569: * @valLen = Size of psValue array
570: * return: -1 error:: can`t read; 0 ok
571: */
572: int ioURLGetFile(struct tagIOURL *url, char * __restrict psValue, int valLen);
573:
574:
575: /*
576: * ioXMLGet() Parse and get data from input XML request string [ns:]container[|attribute[=value]][?data]
577: * @csXML = Input XML request line
578: * @xml = Output parsed XML request
579: * return: 0 error format incorrect, -1 error:: can`t read; >0 ok readed elements bits
580: */
581: int ioXMLGet(const char *csXML, struct tagReqXML *xml);
582:
583:
584: /*
585: * ioMkDir() Function for racursive directory creation and validation
586: * @csDir = Full directory path
587: * @mode = Mode for directory creation if missing dir
588: * return: -1 error, 0 directory path exist, >0 created missing dirs
589: */
590: int ioMkDir(const char *csDir, int mode);
591:
592: /*
593: * ioWatchDirLoop() Function for watching changes in directory and fire callback
594: * @csDir = Full directory path
595: * @callback = Callback if raise event! nOp -1 delete, 0 change/move, 1 create
596: * return: -1 error, !=-1 ok, number of total signaled events
597: */
598: int ioWatchDirLoop(const char *csDir, int (*callback)(const char *csName, int nOp));
599:
600:
601: /*
602: * io_rread() Raw VFS read function
603: * @fd = File handle
604: * @buf = Read buffer
605: * @nbytes = Read buffer size
606: * @offset = Read from position, if -1 read nbytes from current position
607: * @update = Update file handle position !0
608: * return: -1 error or !=-1 readed bytes
609: */
610: inline int io_rread(int fd, void * __restrict buf, size_t nbytes, off_t offset, int update);
611: /*
612: * io_rwrite() Raw VFS write function
613: * @fd = File handle
614: * @buf = Write buffer
615: * @nbytes = Write bytes from buffer
616: * @offset = Write at position, if -1 write nbytes from current position
617: * @update = Update file handle position !0
618: * return: -1 error or !=-1 writed bytes
619: */
620: inline int io_rwrite(int fd, void * __restrict buf, size_t nbytes, off_t offset, int update);
621:
622: /* Disk I/O helper macros */
623: #define io_read(f, b, n) io_rread(f, b, n, -1, 1)
624: #define io_write(f, b, n) io_rwrite(f, b, n, -1, 1)
625:
626:
627: /* Debug helper macros */
628: extern int io_Debug;
629:
630: #define io_initDebug(x) io_Debug = (x);
631: #define io_addDebug io_Debug++
632: #define ioDEBUG(x, fmt, ...) do { \
633: assert((fmt)); \
634: char str[STRSIZ] = { 0 }; \
635: snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
636: if ((x) <= io_Debug) \
637: syslog(LOG_DEBUG, "ioDebug(%d):%s(%d): %s\n", \
638: (x), __func__, __LINE__, str); \
639: } while (0)
640:
641: #define ioERROR(x, fmt, ...) do { \
642: assert((fmt)); \
643: char str[STRSIZ] = { 0 }; \
644: snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
645: syslog(LOG_ERR, "ioError():%s(%d): #%d - %s\n", \
646: __func__, __LINE__, (x), str); \
647: } while (0)
648: #define io_sysERROR(x) do { \
649: if (x > 0 || errno) \
650: syslog(LOG_ERR, "ioError(sys):%s(%d): #%d - %s\n", \
651: __func__, __LINE__, x > 0 ? x : errno, \
652: strerror(x > 0 ? x : errno)); \
653: } while (0)
654: #define io_aitERROR(ait) do { \
655: if (ait##_GetErrno()) \
656: syslog(LOG_ERR, "ioError(ait):%s(%d): #%d - %s\n", \
657: __func__, __LINE__, ait##_GetErrno(), \
658: ait##_GetError()); \
659: } while (0)
660:
661:
662: /* Crypto framework */
663:
664: /*
665: * ioCipher() Cipher wrapper for all supported crypto algorythms
666: * @pInput = input buffer
667: * @inLen = input buffer len
668: * @ppOutput = output allocated buffe, must be free after use
669: * @Cipher = cipher engine, like EVP_bf_cbc() or etc...
670: * @pKey = key
671: * @pIV = IV, salt (8 bytes)
672: * @nMode = Mode 0 - decrypting or 1 - encrypting
673: * return: 0 not present data or error!; >0 number of processed and returned bytes into ppOutput
674: */
675: int ioCipher(unsigned char *pInput, int inLen, unsigned char **ppOutput, const EVP_CIPHER *Cipher,
676: unsigned char *pKey, unsigned char *pIV, int nMode);
677:
678: /*
679: * io_Blowfish() Blowfish cipher algorythm, work with ASCII hex strings
680: * @pInput = input buffer
681: * @inLen = input buffer len
682: * @ppOutput = output allocated buffe, must be free after use
683: * @pKey = key
684: * @pIV = IV, salt (8 bytes)
685: * @nMode = Mode 0 - decrypting or 1 - encrypting
686: * return: 0 not present data or error!; >0 number of processed and returned bytes into ppOutput
687: */
688: int io_Blowfish(unsigned char *pInput, int inLen, unsigned char **ppOutput,
689: unsigned char *pKey, unsigned char *pIV, int nMode);
690:
691:
692: #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