Annotation of libaitio/inc/aitio.h, revision 1.14.2.1
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.14.2.1! misho 6: * $Id: aitio.h,v 1.14 2012/02/02 21:32:42 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.12 misho 50: #define COMPAT_43TTY
51:
1.8 misho 52: #include <assert.h>
1.7 misho 53: #include <openssl/evp.h>
1.12 misho 54: #include <openssl/aes.h>
55: #include <sys/tty.h>
56: #include <sys/ioctl_compat.h>
1.13 misho 57: #include <sys/socket.h>
58: #include <sys/un.h>
59: #include <net/if_dl.h>
60: #include <netinet/in.h>
1.7 misho 61:
62:
1.8 misho 63: #define VACUUM_LEFT 1
64: #define VACUUM_BETWEEN 2
65:
1.12 misho 66: /* AIT arrays */
1.8 misho 67:
1.9 misho 68: typedef void ** sarr_seg_t;
69: typedef struct _tagSplitArray {
70: int sarr_num;
71: int sarr_seg;
72: int sarr_siz;
73: sarr_seg_t *sarr_data;
74: } sarr_t;
75:
1.8 misho 76: typedef struct _tagArray {
77: int arr_num;
78: void **arr_data;
79: } array_t;
80:
1.14.2.1! misho 81: /* Memory pool */
! 82:
! 83: struct tagAlloc {
! 84: char *alloc_name;
! 85: unsigned int *alloc_mem;
! 86: SLIST_ENTRY(tagAlloc) alloc_node;
! 87: };
! 88: typedef SLIST_HEAD(, tagAlloc) mpool_bucket_t;
! 89: #define io_memory(x, _type) (assert((x)), (_type) ((x)->alloc_mem ? ((x)->alloc_mem + 2) : NULL))
! 90: #define io_memorySize(x) (assert((x)), (x)->alloc_mem ? *(x)->alloc_mem : 0)
! 91: #define io_memoryZero(x) do { assert((x)); \
! 92: if ((x)->alloc_mem) \
! 93: memset((void*) ((x)->alloc_mem + 2), 0, *(x)->alloc_mem); \
! 94: } while (0)
! 95:
! 96: typedef struct _tagMPool {
! 97: pthread_mutex_t pool_mtx;
! 98:
! 99: struct {
! 100: unsigned long alloc;
! 101: unsigned long free;
! 102: } pool_calls;
! 103: struct {
! 104: unsigned long alloc;
! 105: unsigned long free;
! 106: } pool_bytes;
! 107: struct {
! 108: unsigned int max;
! 109: unsigned int curr;
! 110: } pool_res;
! 111:
! 112: /* pool buckets start from 4k block == 0 position in array */
! 113: mpool_bucket_t pool_bucks[20];
! 114: } mpool_t;
! 115:
1.12 misho 116: /* URL staff ... */
117:
1.2 misho 118: typedef struct _tagURLItem {
119: int vallen;
120: char *value;
121: } url_Item_t;
122:
123: struct tagIOURL {
124: unsigned char url_line[BUFSIZ];
125:
126: url_Item_t url_tech;
127: url_Item_t url_user;
128: url_Item_t url_pass;
129: url_Item_t url_host;
130: url_Item_t url_port;
131: url_Item_t url_path;
132: url_Item_t url_args;
133:
134: char *url_reserved;
135: };
136:
1.6 misho 137: struct tagReqXML {
138: unsigned char xml_line[BUFSIZ];
139:
140: url_Item_t xml_namespace;
141: union {
142: url_Item_t container;
143: url_Item_t path;
144: } xml_node;
145: url_Item_t xml_data;
146: url_Item_t xml_attribute;
147: url_Item_t xml_value;
148: };
149:
1.12 misho 150: /* AIT RPC variables and managment */
151:
152: typedef enum {
1.14 misho 153: empty, ptr, /* empty -> variable is not set; ptr -> void* */
154: buffer, string, blob, /* buffer -> uint8_t*; string -> int8_t*; blob -> uint32_t blobID(+socket); */
1.12 misho 155: f32, f64, /* float -> f32; double -> f64 */
156: u8, u16, u32, u64, /* unsigned integers ... */
157: i8, i16, i32, i64, /* integers ... */
158: } ait_type_t;
159:
160: typedef struct {
161: uint8_t val_type;
1.13 misho 162: uint8_t val_pad[3];
1.12 misho 163: uint32_t val_len;
164: union {
165: uint64_t net;
166:
1.14 misho 167: void *ptr;
1.12 misho 168: uint8_t *buffer;
169: int8_t *string;
170: uint32_t blob;
171: float f32;
172: double f64;
173: uint8_t u8;
174: uint16_t u16;
175: uint32_t u32;
176: uint64_t u64;
177: int8_t i8;
178: int16_t i16;
179: int32_t i32;
180: int64_t i64;
181: } val;
182: } __packed ait_val_t;
183:
184: #define AIT_TYPE(_vl) ((ait_type_t) (_vl)->val_type)
185: #define AIT_LEN(_vl) (_vl)->val_len
1.14 misho 186: #define AIT_RAW(_vl) (_vl)->val.net
1.12 misho 187: #define AIT_BLOB_CHUNKS(_vl, _n) (assert((_vl)), AIT_LEN((_vl)) / _n + (AIT_LEN((_vl)) % _n) ? 1 : 0)
188: #define AIT_ISEMPTY(_vl) (assert((_vl)), AIT_TYPE((_vl)) == empty)
189:
1.14 misho 190: #define AIT_GET_LIKE(_vl, _type) (assert((_vl)), (_type) (_vl)->val.net)
191:
192: #define AIT_GET_PTR(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == ptr), (_vl)->val.ptr)
193: #define AIT_GET_PTR2(_vl) (assert((_vl)), (_vl)->val.ptr)
1.12 misho 194: #define AIT_GET_BUF(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == buffer), (_vl)->val.buffer)
195: #define AIT_GET_STR(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == string), (_vl)->val.string)
196: #define AIT_GET_BLOB(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == blob), (_vl)->val.blob)
197: #define AIT_GET_U8(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == u8), (_vl)->val.u8)
198: #define AIT_GET_U16(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == u16), (_vl)->val.u16)
199: #define AIT_GET_U32(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == u32), (_vl)->val.u32)
200: #define AIT_GET_U64(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == u64), (_vl)->val.u64)
201: #define AIT_GET_I8(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == i8), (_vl)->val.i8)
202: #define AIT_GET_I16(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == i16), (_vl)->val.i16)
203: #define AIT_GET_I32(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == i32), (_vl)->val.i32)
204: #define AIT_GET_I64(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == i64), (_vl)->val.i64)
205: #define AIT_GET_F32(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == f32), (_vl)->val.f32)
206: #define AIT_GET_F64(_vl) (assert((_vl)), assert(AIT_TYPE((_vl)) == f64), (_vl)->val.f64)
207:
1.14 misho 208: #define AIT_SET_PTR(_vl, _p, _len) do { ait_val_t *__val = (_vl); assert(__val); \
209: __val->val_type = ptr; AIT_LEN(__val) = _len; \
210: __val->val.ptr = _p; } while (0)
211: #define AIT_SET_BUF(_vl, _v, _len) do { ait_val_t *__val = (_vl); assert(__val); \
1.12 misho 212: __val->val.buffer = malloc(_len); \
213: if (__val->val.buffer) { \
214: __val->val_type = buffer; AIT_LEN(__val) = _len; \
215: memcpy(__val->val.buffer, (_v), _len); \
216: } } while (0)
1.14 misho 217: #define AIT_SET_STR(_vl, _v) do { ait_val_t *__val = (_vl); assert(__val); \
1.12 misho 218: __val->val.string = (int8_t*) strdup((_v)); \
219: if (__val->val.string) { \
220: __val->val_type = string; \
221: AIT_LEN(__val) = strlen((_v)) + 1; \
222: } } while (0)
1.14 misho 223: #define AIT_SET_STRCAT(_vl, _v) do { ait_val_t *__val = (_vl); assert(__val); \
224: assert(AIT_TYPE(__val) == string); \
225: void *__p = realloc(AIT_LEN(__val) + strlen((_v))); \
226: if (__p) { \
227: __val->val.string = __p; \
228: AIT_LEN(__val) += strlen((_v)); \
229: strlcat(__val->val.string, (_v), AIT_LEN(__val)); \
230: } } while (0)
1.12 misho 231: #define AIT_SET_BLOB(_vl, _n, _len) do { ait_val_t *__val = (_vl); assert(__val); \
232: __val->val_type = blob; AIT_LEN(__val) = _len; \
233: __val->val.blob = _n; } while (0)
234: #define AIT_SET_BLOB2(_vl, _bv) do { ait_val_t *__val = (_vl); assert(__val); assert((_bv)); \
235: __val->val_type = blob; AIT_LEN(__val) = (_bv)->blob_len; \
236: __val->val.blob = (_bv)->blob_var; } while (0)
237: #define AIT_NEW_BLOB(_vl, _len) AIT_SET_BLOB((_vl), 0, _len)
238:
239: #define AIT_SET_U8(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
240: __val->val_type = u8; __val->val.u8 = _n; \
241: AIT_LEN(__val) = sizeof(uint8_t); } while (0)
242: #define AIT_SET_U16(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
243: __val->val_type = u16; __val->val.u16 = _n; \
244: AIT_LEN(__val) = sizeof(uint16_t); } while (0)
245: #define AIT_SET_U32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
246: __val->val_type = u32; __val->val.u32 = _n; \
247: AIT_LEN(__val) = sizeof(uint32_t); } while (0)
248: #define AIT_SET_U64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
249: __val->val_type = u64; __val->val.u64 = _n; \
250: AIT_LEN(__val) = sizeof(uint64_t); } while (0)
251: #define AIT_SET_I8(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
252: __val->val_type = i8; __val->val.i8 = _n; \
253: AIT_LEN(__val) = sizeof(int8_t); } while (0)
254: #define AIT_SET_I16(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
255: __val->val_type = i16; __val->val.i16 = _n; \
256: AIT_LEN(__val) = sizeof(int16_t); } while (0)
257: #define AIT_SET_I32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
258: __val->val_type = i32; __val->val.i32 = _n; \
259: AIT_LEN(__val) = sizeof(int32_t); } while (0)
260: #define AIT_SET_I64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
261: __val->val_type = i64; __val->val.i64 = _n; \
262: AIT_LEN(__val) = sizeof(int64_t); } while (0)
263: #define AIT_SET_F32(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
264: __val->val_type = f32; __val->val.f32 = _n; \
265: AIT_LEN(__val) = sizeof(float); } while (0)
266: #define AIT_SET_F64(_vl, _n) do { ait_val_t *__val = (_vl); assert(__val); \
267: __val->val_type = f64; __val->val.f64 = _n; \
268: AIT_LEN(__val) = sizeof(double); } while (0)
269:
270: /* if attribute zeroCopy is set not execute free() */
1.14 misho 271: #define AIT_FREE_VAL(_vl) do { ait_val_t *__val = (ait_val_t*) (_vl); assert(__val); \
1.12 misho 272: switch (__val->val_type) { \
273: case buffer: \
274: if (__val->val.buffer) { \
275: free(__val->val.buffer); \
276: __val->val.buffer = NULL; \
277: } \
278: break; \
279: case string: \
280: if (__val->val.string) { \
281: free(__val->val.string); \
282: __val->val.string = NULL; \
283: } \
284: break; \
285: default: \
286: break; \
287: } \
288: __val->val_type = empty; \
289: AIT_LEN(__val) = 0; \
290: } while (0)
291:
292: struct io_ether_addr {
293: u_int8_t ether_addr_octet[6];
294: };
1.13 misho 295: typedef struct io_ether_addr io_ether_addr_t;
296:
297: typedef union {
298: struct sockaddr_storage ss;
299: struct sockaddr sa;
300: struct sockaddr_un sun;
301: struct sockaddr_in sin;
302: struct sockaddr_in6 sin6;
303: struct sockaddr_dl sdl;
304: } io_sockaddr_t;
1.12 misho 305:
1.3 misho 306:
1.1 misho 307: // io_GetErrno() Get error code of last operation
308: inline int io_GetErrno();
309: // io_GetError() Get error text of last operation
310: inline const char *io_GetError();
311:
312:
313: /*
1.12 misho 314: * io_ether_ntoa() Convert ethernet address to string
315: * @n = ethernet address structure, like struct ether_addr
316: * @a = string
317: * @len = string length
318: * return: NULL error or !=NULL string a
319: */
320: inline char *io_ether_ntoa(const struct io_ether_addr *n, char * __restrict a, int len);
321: /*
322: * io_ether_aton() Convert string to ethernet address
323: * @a = string
324: * @e = ethernet address structure, like struct ether_addr
325: * return: NULL error or !=NULL ethernet address structure
326: */
327: inline struct io_ether_addr *io_ether_aton(const char *a, struct io_ether_addr *e);
1.13 misho 328: /*
329: * io_n2port() Extract port from network structure
330: * @addr = Address
331: * return: 0 not supported family type or port number
332: */
333: inline u_short io_n2port(io_sockaddr_t * __restrict addr);
334: /*
335: * io_n2addr() Extract address from network structure
336: * @addr = Address
337: * @val = Value for store string address
338: * return: NULL error or !=NULL string address from val
339: */
340: const char *io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t * __restrict val);
341: /*
342: * io_gethostbyname() Get host and port and make network structure
343: * @psHost = Hostname
344: * @port = Port
345: * @addr = Network address structure
346: * return: NULL error or !=NULL network structure
347: */
348: io_sockaddr_t *io_gethostbyname(const char *psHost, unsigned short port,
349: io_sockaddr_t * __restrict addr);
1.12 misho 350:
351: /*
1.13 misho 352: * io_vars2buffer() Marshaling data from array with variables to buffer
1.12 misho 353: * @buf = Buffer
354: * @buflen = Size of buffer
355: * @vars = Variable array
356: * return: -1 error, 0 nothing done or >0 size of marshaled data
357: */
1.13 misho 358: int io_vars2buffer(unsigned char *buf, int buflen, array_t *vars);
1.12 misho 359: /*
1.13 misho 360: * io_buffer2vars() De-marshaling data from buffer to array with variables
1.12 misho 361: * @buf = Buffer
362: * @buflen = Size of buffer
363: * @vnum = Number of variables into buffer
364: * @zcpy = Zero-copy for variables, if !=0 don't use io_arrayFree() for free variables and
365: *DON'T MODIFY OR DESTROY BUFFER*. =0 call io_arrayFree() before io_arrayDestroy()
366: * return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()
367: */
1.13 misho 368: array_t *io_buffer2vars(unsigned char *buf, int buflen, int vnum, int zcpy);
1.12 misho 369: /*
1.13 misho 370: * io_vars2map() Marshaling data from array with variables to memory map
1.12 misho 371: * @buf = Buffer
372: * @buflen = Size of buffer
373: * @vars = Variable array
374: * return: -1 error, 0 nothing done or >0 size of marshaled data
375: */
1.13 misho 376: int io_vars2map(unsigned char *buf, int buflen, array_t *vars);
1.12 misho 377: /*
1.13 misho 378: * io_map2vars() De-marshaling data from memory map to array with variables
1.12 misho 379: * @buf = Buffer
380: * @buflen = Size of buffer
381: * @vnum = Number of variables into buffer
382: * @zcpy = Zero-copy for variables, if !=0 don't use io_arrayFree() for free variables and
383: *DON'T MODIFY OR DESTROY BUFFER*. =0 call io_arrayFree() before io_arrayDestroy()
384: * return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()
385: */
1.13 misho 386: array_t *io_map2vars(unsigned char *buf, int buflen, int vnum, int zcpy);
387:
388: /*
1.14 misho 389: * io_allocVar() Allocate memory for variable
390: * return: NULL error or new variable, after use free variable with io_freeVar()
391: */
392: inline ait_val_t *io_allocVar(void);
393: /*
394: * io_freeVar() Free allocated memory for variable
395: * @val = Variable
396: * return: none
397: */
398: inline void io_freeVar(ait_val_t * __restrict val);
399: /*
1.13 misho 400: * io_allocVars() Allocate ait_val_t array
401: * @varnum = Number of variables
402: * return: =NULL error or !=NULL allocated array
403: */
404: inline array_t *io_allocVars(int varnum);
405: /*
406: * io_clrVars() Clear ait_val_t elements from array
407: * @vars = Variable array
408: * return: -1 error or size of array
409: */
410: inline int io_clrVars(array_t * __restrict vars);
411: /*
412: * io_freeVars() Free ait_val_t array
413: * @vars = Variable array
414: * return: none
415: */
416: inline void io_freeVars(array_t ** __restrict vars);
417:
1.12 misho 418:
419: /*
1.1 misho 420: * ioPromptRead() Read data from input h[0] with prompt to output h[1]
421: * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout
422: * @csPrompt = Prompt before input, may be NULL
423: * @psData = Readed data
424: * @dataLen = Length of data
425: * return: 0 EOF; -1 error:: can`t read; >0 count of readed chars
426: */
427: int ioPromptRead(int *h, const char *csPrompt, char * __restrict psData, int dataLen);
428: /*
429: * ioPromptPassword() Read password from input h[0] with prompt to output h[1]
430: * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout
431: * @csPrompt = Prompt before input, may be NULL
432: * @psPass = Readed password
433: * @passLen = Length of password
434: * @confirm = Confirm password, 0 - get password, !=0 Ask for confirmation
435: * return: 0 EOF; -1 error:: can`t read; >0 count of readed chars
436: */
437: int ioPromptPassword(int *h, const char *csPrompt, char * __restrict psPass, int passLen, int confirm);
438:
439: /*
440: * ioRegexVerify() Function for verify data match in regex expression
441: * @csRegex = Regulare expression pattern
442: * @csData = Data for check and verify
443: * @startPos = Return start positions
444: * @endPos = Return end positions
445: * return: NULL not match or error; !=NULL begin of matched data
446: */
447: const char *ioRegexVerify(const char *csRegex, const char *csData, int *startPos, int *endPos);
448: /*
449: * ioRegexGet() Function for get data match in regex expression
450: * @csRegex = Regulare expression pattern
451: * @csData = Data from get
452: * @psString = Returned string if match
453: * @strLen = Length of string
454: * return: 0 not match; >0 count of returned chars
455: */
456: int ioRegexGet(const char *csRegex, const char *csData, char * __restrict psString, int strLen);
457: /*
458: * ioRegexReplace() Function for replace data match in regex expression with newdata
459: * @csRegex = Regulare expression pattern
460: * @csData = Source data
461: * @csNew = Data for replace
462: * return: NULL not match or error; !=NULL allocated new string, must be free after use!
463: */
464: char *ioRegexReplace(const char *csRegex, const char *csData, const char *csNew);
465:
1.2 misho 466: /*
1.13 misho 467: * ioStrAst() Function for evaluate string like asterisk variable "{text[:[-]#[:#]]}"
1.6 misho 468: * @csString = Input string
469: * return: NULL error, !=NULL Allocated new string evaluated from input string, must be free()
470: */
1.13 misho 471: char *ioStrAst(const char *csString);
1.6 misho 472:
473: /*
1.2 misho 474: * io_Path2File() Parse and make path/filename pair
475: * @csArgs = Input argument line
476: * @psPath = Output Path, if ==NULL path not returned
477: * @pathLen = Size of path array
478: * @psFile = Output File
479: * @fileLen = Size of file array
480: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
481: */
482: inline int io_Path2File(const char * __restrict csArgs, char * __restrict psPath, int pathLen,
483: char * __restrict psFile, int fileLen);
484:
485: /*
1.4 misho 486: * io_UnquotStr() Remove quots from input text string
487: * @psLine = Text string
488: * return: 0 nothing to do; 1 successful unquoted string
489: */
1.5 misho 490: inline int io_UnquotStr(unsigned char * __restrict psLine);
1.4 misho 491: /*
492: * io_LTrimStr() Remove left whitespaces from text string
493: * @psLine = Text string
494: * return: 0 nothing to do; !=0 Removed bytes
495: */
1.5 misho 496: inline int io_LTrimStr(unsigned char * __restrict psLine);
1.4 misho 497: /*
498: * io_RTrimStr() Remove right whitespaces from text string
499: * @psLine = Text string
500: * return: 0 nothing to do; !=0 Removed bytes
501: */
1.5 misho 502: inline int io_RTrimStr(unsigned char * __restrict psLine);
1.4 misho 503: /*
504: * io_TrimStr() Remove left and right whitespaces from text string
505: * @psLine = Text string
506: * return: 0 nothing to do; !=0 Removed bytes
507: */
1.5 misho 508: inline int io_TrimStr(unsigned char * __restrict psLine);
1.4 misho 509: /*
1.5 misho 510: * io_Ch2Hex() Convert from Char string to Hex string
1.4 misho 511: * @psLine = Text string
512: * @lineLen = Length of Text string
1.5 misho 513: * return: NULL nothing to do or error; !=0 Allocated new converted data without term\0 (must be free)
1.4 misho 514: */
1.5 misho 515: inline unsigned char *io_Ch2Hex(unsigned char *psLine, int lineLen);
1.4 misho 516: /*
1.5 misho 517: * io_Hex2Ch() Convert from Hex string to Char string
1.4 misho 518: * @psLine = Text string
519: * @lineLen = Length of Text string
520: * return: NULL nothing to do or error; !=0 Allocated new converted string(must be free)
521: */
1.5 misho 522: inline char *io_Hex2Ch(unsigned char *psLine, int lineLen);
1.4 misho 523:
524: /*
1.8 misho 525: * io_arrayInit() - Create and initialize dynamic array
526: * @numItems = Number of Items
527: * return: NULL error, != NULL allocated memory for array
528: */
529: inline array_t *io_arrayInit(int numItems);
530: /*
1.10 misho 531: * io_arrayDestroy() - Free and destroy dynamic array
1.8 misho 532: * @parr = Array
533: * return: none
534: */
535: inline void io_arrayDestroy(array_t ** __restrict parr);
536: /*
1.10 misho 537: * io_arrayFree() - Free all data in dynamic array items
1.8 misho 538: * (WARNING! If assign static array dont use this!!!)
539: * @arr = Array
540: * return: none
541: */
542: inline void io_arrayFree(array_t * __restrict arr);
543: /*
1.10 misho 544: * io_arrayFrom() - Create and fill array from array with pointers
1.11 misho 545: * @pargv = Array with pointers
1.10 misho 546: * @argc = Number of Items, if 0 walk through argv and stop when reach NULL item
1.11 misho 547: * return: NULL error, != NULL allocated new array
1.10 misho 548: */
1.11 misho 549: inline array_t *io_arrayFrom(const char *** __restrict pargv, int argc);
1.10 misho 550: /*
551: * io_arrayTo() - Create and fill array with pointers from dynamic array
552: * @arr = Array
1.11 misho 553: * return: NULL error, != NULL allocated memory for array, NULL terminated
1.10 misho 554: */
555: inline char **io_arrayTo(array_t * __restrict arr);
556: /*
1.8 misho 557: * io_arrayLen() - Get last used element in dynamic array (array Length)
558: * @arr = Array
559: * return: -1 error, 0 empty or >0 position of last used element
560: */
561: inline int io_arrayLen(array_t * __restrict arr);
562: /*
1.10 misho 563: * io_arrayConcat() Concat source array to destination array
564: * @dest = Destination array
565: * @src = Source array
566: * return: -1 error; >0 new count of destination array
567: */
568: int io_arrayConcat(array_t * __restrict dest, array_t * __restrict src);
569: /*
1.12 misho 570: * io_arrayCopy() Copy source array to destination array
571: * @dest = Destination array, after use free with io_arrayDestroy()
572: * @src = Source array
573: * return: -1 error; >0 count of destination array
574: */
575: int io_arrayCopy(array_t ** __restrict dest, array_t * __restrict src);
576: /*
1.8 misho 577: * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!
578: * @arr = Array
579: * @newNumItems = Number of Items
1.12 misho 580: * @freeShrink = Free elements before shrink array
1.8 misho 581: * return: -1 error, 0 ok
582: */
1.12 misho 583: int io_arrayGrow(array_t * __restrict arr, int newNumItems, int freeShrink);
1.8 misho 584: /*
585: * io_arrayVacuum() - Vacuum dynamic array, empty elements will be deleted
586: * @arr = Array
587: * @fromWhere = 1 begin, 2 ALL empty elements
588: * return: -1 error, 0 ok
589: */
590: int io_arrayVacuum(array_t * __restrict arr, int fromWhere);
591:
1.12 misho 592: #define io_arraySize(_arr) ((_arr) ? (_arr)->arr_num : 0)
593: #define io_arrayZero(_arr) (assert((_arr)), memset((_arr)->arr_data, 0, \
594: io_arraySize((_arr)) * sizeof(void*)))
1.8 misho 595:
1.11 misho 596: #define io_arrayGet(_arr, _d) (assert((_arr) && (_arr)->arr_num > _d), *((_arr)->arr_data + _d))
597: #define io_array(_arr, _d, _type) (assert((_arr) && (_arr)->arr_num > _d), \
598: ((_type) *((_arr)->arr_data + _d)))
1.8 misho 599: #define io_arraySet(_arr, _d, _ptr) do { \
1.11 misho 600: assert((_arr) && (_arr)->arr_num > _d); \
601: *((_arr)->arr_data + _d) = (void*) (_ptr); \
1.8 misho 602: } while (0)
1.11 misho 603: #define io_arrayDel(_arr, _d, _fri) do { \
604: assert((_arr) && (_arr)->arr_num > _d); \
605: if (_fri) \
606: free(*((_arr)->arr_data + _d)); \
607: *((_arr)->arr_data + _d) = NULL; \
1.9 misho 608: } while (0)
1.8 misho 609:
610: /*
1.13 misho 611: * io_arrayElem() - Always GET/PUT element into dynamic array, if not enough elements grow array
612: * @arr = Array
613: * @n = Position
614: * @data = Element, if set NULL GET element at position or !=NULL PUT element at position
615: * return: -1 error or !=-1 return element at position
616: */
1.14 misho 617: inline void *io_arrayElem(array_t * __restrict arr, int n, void *data);
1.13 misho 618: /*
1.8 misho 619: * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position
620: * @arr = Array
621: * @data = Element, if set NULL return only first empty position
622: * return: -1 not found empty position, array is full!, >-1 return position of stored element into array
623: */
624: inline int io_arrayPush(array_t * __restrict arr, void **data);
625: /*
626: * io_arrayPop() - Pop element from dynamic array like stack manner, last used position
627: * @arr = Array
1.11 misho 628: * @data = Element, if set NULL return only last used position
1.8 misho 629: * @delAfter = Delete after Pop element, !=0 delete element from array after return data
630: * return: -1 not found used position, array is empty!, >-1 return element position
631: */
632: inline int io_arrayPop(array_t * __restrict arr, void ** __restrict data, int delAfter);
633:
634: /*
635: * io_argsNum() Parse and calculate number of arguments
636: * @csArgs = Input arguments line
637: * @csDelim = Delimiter(s) for separate
638: * return: 0 error format; -1 error:: can`t read; >0 ok, number of items
639: */
640: inline int io_argsNum(const char *csArgs, const char *csDelim);
641:
642: /*
643: * io_arrayMake() Parse and make array from arguments ... (input string will be modified!!!
644: * and output array must be free with io_arrayDestroy() after use!)
645: * @psArgs = Input arguments line, after execute string is modified!!!
646: * @nargs = Maximum requested count of arguments from input string psArgs, if 0 all psArgs
647: * @csDelim = Delimiter(s) for separate
648: * @parr = Output array of arguments ... (must be free with io_arrayDestroy() after use!)
649: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
650: */
651: int io_arrayMake(char * __restrict psArgs, int nargs, const char *csDelim,
652: array_t ** __restrict parr);
653:
654: /*
655: * io_MakeAV() Parse and make attribute/value pair
656: * @csArgs = Input argument line
657: * @csDelim = Delimiter for separate
658: * @psAttr = Output Attribute
659: * @attrLen = Size of attribute array
660: * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
661: * @valLen = Size of value array
662: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
663: */
664: int io_MakeAV(const char * __restrict csArgs, const char *csDelim,
665: char * __restrict psAttr, int attrLen, char * __restrict psValue, int valLen);
666:
1.9 misho 667: /*
668: * io_sarrInit() - Create and initialize dynamic split-order array
669: * @numItems = Number of Items
670: * @segLen = Length of segment
671: * return: NULL error, != NULL allocated memory for array
672: */
673: inline sarr_t *io_sarrInit(int numItems, int segLen);
674: /*
675: * io_sarrDestroy() - Free all data in dynamic split-order array and Destroy array
676: * @parr = Array
677: * return: none
678: */
679: inline void io_sarrDestroy(sarr_t ** __restrict parr);
680: /*
681: * io_sarrGrow() - Grow/Shrink dynamic split-order array, Use with care when it shrink!!!
682: * @arr = Array
683: * @newNumItems = Number of Items
684: * return: -1 error, 0 ok
685: */
686: int io_sarrGrow(sarr_t * __restrict arr, int newNumItems);
687: /*
688: * io_sarrVacuum() - Vacuum dynamic split-order array, empty segments will be freed
689: * @arr = Array
690: * return: -1 error, >-1 freed segments
691: */
692: inline int io_sarrVacuum(sarr_t * __restrict arr);
1.12 misho 693: #define io_sarrSize(_arr) ((_arr) ? (_arr)->sarr_num : 0)
694: #define io_sarrSeg(_arr) (assert((_arr)), (_arr)->sarr_seg)
695: /*
696: * io_sarrCopy() Copy source split array to destination split array
697: * @dest = Destination split array, after use free with io_sarrDestroy()
698: * @src = Source split array
699: * return: -1 error; >0 count of destination split array
700: */
701: int io_sarrCopy(sarr_t ** __restrict dest, sarr_t * __restrict src);
1.9 misho 702: /*
703: * io_sarrGet() - Get element from dynamic split-order array
704: * @arr = Array
705: * @idx = Index (warning 1st element is at position 1)
706: * return: NULL not found, !=NULL element
707: */
708: inline void *io_sarrGet(sarr_t * __restrict arr, unsigned int idx);
709: /*
710: * io_sarrGet2() - Always get element from dynamic split-order array
711: * Function automatic grow array. Good use for Hash tables!
712: * @arr = Array
713: * @idx = Index (warning 1st element is at position 1)
714: * return: NULL not found, !=NULL element
715: */
716: void *io_sarrGet2(sarr_t * __restrict arr, unsigned int idx);
717: /*
718: * io_sarrSet() - Set element to dynamic split-order array
719: * @arr = Array
720: * @idx = Index (warning 1st element is at position 1)
721: * @data = Value
722: * return: NULL error or empty, !=NULL old value in element
723: */
724: inline void *io_sarrSet(sarr_t * __restrict arr, unsigned int idx, void *data);
1.11 misho 725: #define io_sarrDel(_arr, _idx) io_sarrSet((_arr), _idx, NULL)
726: #define io_sarr(_arr, _idx, _type) (_type)io_sarrGet((_arr), _idx)
727: /*
728: * io_sarr2array() - Convert from split-order array to dynamic array
729: * @sa = split array
730: * @sarrFree = after convert split array !=0 will be destroyed sarray
731: * return: NULL error or != NULL new array
732: */
733: array_t *io_sarr2array(sarr_t ** __restrict sa, int sarrFree);
734: /*
735: * io_array2sarr() - Convert from dynamic array to split-order array
736: * @a = array
737: * @segLen = Length of segment
738: * @arrFree = after convert array !=0 will be destroyed
739: * return: NULL error or != NULL new sarr
740: */
741: sarr_t *io_array2sarr(array_t ** __restrict a, int segLen, int arrFree);
1.8 misho 742:
743: /*
1.10 misho 744: * io_CopyEnv() Copy environment to new environment array;
745: * @oldenv = Environment array
746: * return: NULL error; !=NULL Allocated new environment array(must be free)
747: */
748: char **io_CopyEnv(const char **oldenv);
749: /*
750: * io_ExecArgs() Build exec arguments from other array
751: * @psProg = Program name for execute
752: * @oldarg = Arguments array
753: * return: NULL error; !=NULL Allocated execution array(must be free)
754: */
755: char **io_ExecArgs(const char *psProg, const char **oldarg);
756: /*
757: * io_FreeNullTerm() Free dynamic allocated null terminated array with strings
758: * @arr = Pointer to array for free
759: * return: none
760: */
761: inline void io_FreeNullTerm(char *** __restrict arr);
762:
763: /*
1.2 misho 764: * ioURLGet() Parse and get data from input URL
765: * @csURL = Input URL line
766: * @url = Output parsed URL
767: * return: 0 error format not find tech:// and return URL like path;
768: -1 error:: can`t read; >0 ok, up bits for known elements
769: */
770: int ioURLGet(const char *csURL, struct tagIOURL *url);
771: /*
772: * ioURLGetValue() Get value from parsed URL
773: * @url = Input parsed URL
774: * @csAttr = Attribute for search
775: * @psValue = Return value of attribute, if ==NULL only check for existence of attribute
776: * @valLen = Size of psValue array
777: * return: 0 error attribute not find; -1 error:: can`t read; >0 ok, find at position
778: */
779: int ioURLGetValue(struct tagIOURL *url, const char *csAttr, char * __restrict psValue, int valLen);
780: /*
781: * ioURLGetFile() Get file from parsed URL
782: * @url = Input parsed URL
783: * @psValue = Return filename, if not specified file in url path, replace with /
784: * @valLen = Size of psValue array
785: * return: -1 error:: can`t read; 0 ok
786: */
787: int ioURLGetFile(struct tagIOURL *url, char * __restrict psValue, int valLen);
788:
1.3 misho 789:
790: /*
1.6 misho 791: * ioXMLGet() Parse and get data from input XML request string [ns:]container[|attribute[=value]][?data]
792: * @csXML = Input XML request line
793: * @xml = Output parsed XML request
794: * return: 0 error format incorrect, -1 error:: can`t read; >0 ok readed elements bits
795: */
796: int ioXMLGet(const char *csXML, struct tagReqXML *xml);
797:
798:
799: /*
1.5 misho 800: * ioMkDir() Function for racursive directory creation and validation
801: * @csDir = Full directory path
802: * @mode = Mode for directory creation if missing dir
803: * return: -1 error, 0 directory path exist, >0 created missing dirs
804: */
805: int ioMkDir(const char *csDir, int mode);
806:
1.6 misho 807: /*
808: * ioWatchDirLoop() Function for watching changes in directory and fire callback
809: * @csDir = Full directory path
810: * @callback = Callback if raise event! nOp -1 delete, 0 change/move, 1 create
811: * return: -1 error, !=-1 ok, number of total signaled events
812: */
813: int ioWatchDirLoop(const char *csDir, int (*callback)(const char *csName, int nOp));
814:
1.5 misho 815:
816: /*
817: * io_rread() Raw VFS read function
818: * @fd = File handle
819: * @buf = Read buffer
820: * @nbytes = Read buffer size
821: * @offset = Read from position, if -1 read nbytes from current position
822: * @update = Update file handle position !0
823: * return: -1 error or !=-1 readed bytes
824: */
825: inline int io_rread(int fd, void * __restrict buf, size_t nbytes, off_t offset, int update);
826: /*
827: * io_rwrite() Raw VFS write function
828: * @fd = File handle
829: * @buf = Write buffer
830: * @nbytes = Write bytes from buffer
831: * @offset = Write at position, if -1 write nbytes from current position
832: * @update = Update file handle position !0
833: * return: -1 error or !=-1 writed bytes
834: */
835: inline int io_rwrite(int fd, void * __restrict buf, size_t nbytes, off_t offset, int update);
836:
837: /* Disk I/O helper macros */
838: #define io_read(f, b, n) io_rread(f, b, n, -1, 1)
839: #define io_write(f, b, n) io_rwrite(f, b, n, -1, 1)
840:
841:
842: /* Debug helper macros */
843: extern int io_Debug;
844:
1.14 misho 845: #define io_enableDEBUG int io_Debug
846: #define io_initDebug(x) (io_Debug = (x))
847: #define io_incDebug (io_Debug++)
848: #define io_decDebug (io_Debug--)
849:
850: /* Debug macros */
851: #define ioVERBOSE(x) if ((x) <= io_Debug)
852: #define ioTRACE(x) if ((x) <= io_Debug) \
853: syslog(LOG_DEBUG, "I'm in %s(%d)", __func__, __LINE__)
1.5 misho 854: #define ioDEBUG(x, fmt, ...) do { \
855: assert((fmt)); \
856: char str[STRSIZ] = { 0 }; \
1.11 misho 857: snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
1.5 misho 858: if ((x) <= io_Debug) \
1.14 misho 859: syslog(LOG_DEBUG, "Debug(%d):%s(%d): %s\n", \
1.5 misho 860: (x), __func__, __LINE__, str); \
861: } while (0)
862:
1.14 misho 863: /* Logger macro */
864: #define ioLOGGER(x, fmt, ...) do { \
865: assert((fmt)); \
866: char str[STRSIZ] = { 0 }; \
867: snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
868: syslog((x), "Logger:%s(%d): %s\n", \
869: __func__, __LINE__, str); \
870: } while (0)
871:
872: /* Error state macros */
1.5 misho 873: #define ioERROR(x, fmt, ...) do { \
874: assert((fmt)); \
875: char str[STRSIZ] = { 0 }; \
1.11 misho 876: snprintf(str, sizeof str, (fmt), ##__VA_ARGS__); \
1.14 misho 877: syslog(LOG_ERR, "Error:%s(%d): #%d - %s\n", \
1.5 misho 878: __func__, __LINE__, (x), str); \
879: } while (0)
1.14 misho 880: #define ioSYSERR(x) do { \
1.5 misho 881: if (x > 0 || errno) \
1.14 misho 882: syslog(LOG_ERR, "Error(sys):%s(%d): #%d - %s\n", \
1.5 misho 883: __func__, __LINE__, x > 0 ? x : errno, \
884: strerror(x > 0 ? x : errno)); \
885: } while (0)
1.14 misho 886: #define ioLIBERR(ait) do { \
1.5 misho 887: if (ait##_GetErrno()) \
1.14 misho 888: syslog(LOG_ERR, "Error(lib):%s(%d): #%d - %s\n", \
1.5 misho 889: __func__, __LINE__, ait##_GetErrno(), \
890: ait##_GetError()); \
891: } while (0)
1.3 misho 892:
1.1 misho 893:
1.7 misho 894: /* Crypto framework */
895:
896: /*
897: * ioCipher() Cipher wrapper for all supported crypto algorythms
898: * @pInput = input buffer
899: * @inLen = input buffer len
900: * @ppOutput = output allocated buffe, must be free after use
901: * @Cipher = cipher engine, like EVP_bf_cbc() or etc...
902: * @pKey = key
903: * @pIV = IV, salt (8 bytes)
904: * @nMode = Mode 0 - decrypting or 1 - encrypting
905: * return: 0 not present data or error!; >0 number of processed and returned bytes into ppOutput
906: */
907: int ioCipher(unsigned char *pInput, int inLen, unsigned char **ppOutput, const EVP_CIPHER *Cipher,
908: unsigned char *pKey, unsigned char *pIV, int nMode);
909:
910: /*
911: * io_Blowfish() Blowfish cipher algorythm, work with ASCII hex strings
912: * @pInput = input buffer
913: * @inLen = input buffer len
914: * @ppOutput = output allocated buffe, must be free after use
915: * @pKey = key
916: * @pIV = IV, salt (8 bytes)
917: * @nMode = Mode 0 - decrypting or 1 - encrypting
918: * return: 0 not present data or error!; >0 number of processed and returned bytes into ppOutput
919: */
1.8 misho 920: int io_Blowfish(unsigned char *pInput, int inLen, unsigned char **ppOutput,
921: unsigned char *pKey, unsigned char *pIV, int nMode);
1.12 misho 922: /*
923: * io_ctr_AES() Encrypt/Decrypt stream cipher CTR_AES
924: * @pInput = Input buffer with ASCII
925: * @inLen = Input buffer data length
926: * @ppOutput = Output buffer with cipher data, must be free after use
927: * @pKey = Key
928: * @IV = IVector/Nonce/Counter, Warning: IV must be variable, because we write there!!!
929: * return: -1 error or >-1 how many cipher blocks proceeded
930: */
931: int io_ctr_AES(unsigned char *pInput, int inLen, unsigned char **ppOutput,
932: unsigned char *pKey, unsigned char IV[AES_BLOCK_SIZE]);
933:
934:
935: /*
936: * ioAllocPTY() Allocate new PTY and TTY
937: * @ptyfd = master fd, pty
938: * @ttyfd = slave fd, tty
939: * @name = tty device name if not null
940: * @namesiz = name length, must be above 63 bytes.
941: * @term = termios for terminal
942: * @winz = winsize for terminal
943: * return: -1 error or 0 ok
944: */
945: inline int ioAllocPTY(int *ptyfd, int *ttyfd, char * __restrict name, int namesiz,
946: struct termios * __restrict term, struct winsize * __restrict winz);
947: /*
948: * ioFreePTY() Release PTY and TTY device
949: * @ptyfd = master fd, pty (==-1 skip closing pty)
950: * @ttyname = tty filename
951: * return: none
952: */
953: inline void ioFreePTY(int ptyfd, const char *ttyname);
954: /*
955: * ioChgWinPTY() Change window size of PTY
956: * @ptyfd = master fd, pty
957: * @row = row
958: * @col = col
959: * @xpxl = x pixels
960: * @ypxl = y pixels
961: * return: -1 error or 0 ok
962: */
963: inline int ioChgWinPTY(int ptyfd, unsigned short row, unsigned short col,
964: unsigned short xpxl, unsigned short ypxl);
965: /*
966: * ioSetOwnerTTY() Set owner to TTY
967: * @ttyname = tty filename
968: * @UID = uid
969: * @GID = gid
970: * return: -1 error or 0 ok
971: */
972: int ioSetOwnerTTY(const char *ttyname, uid_t UID, gid_t GID);
973: /*
974: * ioSetSidTTY() Makes the process's controlling TTY and sets it to sane modes.
975: * @ttyfd = slave fd, tty
976: * @ttyname = tty filename
977: * return: -1 error or 0 ok
978: */
979: int ioSetSidTTY(int *ttyfd, const char *ttyname);
980: /*
981: * ioSetRAWMode() Enter into RAW mode
982: * @fd = tty fd
983: * @otio = saved old termios for later restore if !=NULL
984: * return: -1 error or 0 ok
985: */
986: inline int ioSetRAWMode(int fd, struct termios *otio);
987: /*
988: * ioRestoreMode() Restore termios to tty fd
989: * @fd = tty fd
990: * @tio = termios structure for restore
991: * return: -1 error or 0 ok
992: */
993: inline int ioRestoreMode(int fd, struct termios tio);
994: /*
995: * ioForkPTY() Fork new process with session leader and new TTY
996: * @ptyfd = master fd, pty
997: * @name = tty device name if not null
998: * @namesiz = name length, must be above 63 bytes.
999: * @term = termios for terminal
1000: * @winz = winsize for terminal
1001: * @otio = old termios structure for restore
1002: * return: -1 error, 0 child process or >0 parent: pid of child
1003: */
1004: pid_t ioForkPTY(int *ptyfd, char * __restrict name, int namesiz, struct termios * __restrict term,
1005: struct winsize * __restrict winz, struct termios * __restrict otio);
1006:
1007: /*
1008: * ioCreatePIDFile() Create PID file
1009: * @csName = PID filename
1010: * @ifExists = !=0 if filename exists return error
1011: * return: -1 error or 0 ok
1012: */
1013: inline int ioCreatePIDFile(const char *csName, int ifExists);
1.7 misho 1014:
1.13 misho 1015: /*
1016: * ioSendFile() AITNET sendfile() userland implementation, not dependant from OS
1017: * @s = socket
1018: * @csFile = file for send
1019: * @sendLen = bytes to send, if 0 send all data
1020: * @offset = start file offset
1021: * @sndbuf = SO_SNDBUF value, if 0 use default
1022: * return: 0 error, >0 ok, sended bytes
1023: */
1024: size_t ioSendFile(int s, const char *csFile, size_t sendLen, off_t offset, int sndbuf);
1025: /*
1026: * ioRecvFile() Receive file from socket, fastest (zero-copy) way
1027: * @s = socket
1028: * @csFile = file for receive
1029: * @recvLen = receive bytes
1030: * @over = overwrite file if exists with mode like 0644
1031: * @rcvbuf = SO_RCVBUF value, if 0 use default
1032: * return: 0 error, >0 ok, received bytes
1033: */
1034: size_t ioRecvFile(int s, const char *csFile, size_t recvLen, int over, int rcvbuf);
1035:
1.7 misho 1036:
1.14 misho 1037: /* Buffered file access over memory block */
1038:
1039: /*
1040: * io_fmemopen() File buffered stream operations over memory block
1041: *
1042: * @base = Base address of memory block, if =NULL Infinit length(auto-grow)
1043: * @basesize = Size of memory block
1044: * return: NULL error or !=NULL Opened file resource
1045: */
1046: FILE *io_fmemopen(void ** __restrict base, off_t basesize);
1047: /*
1048: * io_fmapopen() File buffered stream operations over MMAP block
1049: *
1050: * @csFile = Filename for MMAP, if =NULL private MMAP block
1051: * @mode = File open mode
1052: * @perm = If file not exists will be created with this access permissions
1053: * @prot = MMAP protection
1054: * @flags = MMAP mode flags
1055: * @offset = Map from file offset, if csFile==NULL then this is size of MMAP private block
1056: * return: NULL error or !=NULL Opened file resource
1057: */
1058: FILE *io_fmapopen(const char *csFile, int mode, int perm, int prot, int flags, off_t offset);
1059: /*
1060: * io_fd2buf() Convert open file handle to buffered file I/O
1061: *
1062: * @fd = File handle
1063: * @mode = Permissions for new buffered file I/O
1064: * return: NULL error or open buffered file
1065: */
1066: inline FILE *io_fd2buf(int fd, const char *mode);
1067: /*
1068: * io_dumbFile() Create empry or dumb file with fixed size
1069: *
1070: * @csFile = Filename for create
1071: * @mode = File access permissions
1072: * @size = File size
1073: * return: -1 error or open file handle
1074: */
1075: int io_dumbFile(const char *csFile, int mode, off_t size);
1076:
1077:
1.1 misho 1078: #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