version 1.3, 2013/03/07 23:04:48
|
version 1.12, 2022/02/01 20:46:57
|
Line 12 terms:
|
Line 12 terms:
|
All of the documentation and software included in the ELWIX and AITNET |
All of the documentation and software included in the ELWIX and AITNET |
Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org> |
Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org> |
|
|
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 | Copyright 2004 - 2022 |
by Michael Pounov <misho@elwix.org>. All rights reserved. |
by Michael Pounov <misho@elwix.org>. All rights reserved. |
|
|
Redistribution and use in source and binary forms, with or without |
Redistribution and use in source and binary forms, with or without |
Line 46 SUCH DAMAGE.
|
Line 46 SUCH DAMAGE.
|
#include "global.h" |
#include "global.h" |
|
|
|
|
static int | static inline int |
vars2buffer(u_char * __restrict buf, int buflen, int be, array_t * __restrict vars) |
vars2buffer(u_char * __restrict buf, int buflen, int be, array_t * __restrict vars) |
{ |
{ |
int Limit = 0; |
int Limit = 0; |
Line 123 vars2buffer(u_char * __restrict buf, int buflen, int b
|
Line 123 vars2buffer(u_char * __restrict buf, int buflen, int b
|
break; |
break; |
case buffer: |
case buffer: |
case string: |
case string: |
|
case ptr: |
if (AIT_LEN(val) > buflen - Limit) { |
if (AIT_LEN(val) > buflen - Limit) { |
elwix_SetErr(EMSGSIZE, "Short buffer buflen=%d " |
elwix_SetErr(EMSGSIZE, "Short buffer buflen=%d " |
"needed min %d", buflen, Limit + AIT_LEN(val)); |
"needed min %d", buflen, Limit + AIT_LEN(val)); |
Line 145 vars2buffer(u_char * __restrict buf, int buflen, int b
|
Line 146 vars2buffer(u_char * __restrict buf, int buflen, int b
|
return Limit; |
return Limit; |
} |
} |
|
|
static array_t * | static inline array_t * |
buffer2vars(u_char * __restrict buf, int buflen, int vnum, int zcpy) |
buffer2vars(u_char * __restrict buf, int buflen, int vnum, int zcpy) |
{ |
{ |
array_t *vars; |
array_t *vars; |
Line 218 buffer2vars(u_char * __restrict buf, int buflen, int v
|
Line 219 buffer2vars(u_char * __restrict buf, int buflen, int v
|
val->val.net = le64toh(v[i].val.net); |
val->val.net = le64toh(v[i].val.net); |
break; |
break; |
case data: |
case data: |
/* WARNING:: remap data type to buffer */ | case ptr: |
| /* WARNING:: remap data and ptr type to buffer! */ |
val->val_type = buffer; |
val->val_type = buffer; |
case buffer: |
case buffer: |
case string: |
case string: |
Line 247 buffer2vars(u_char * __restrict buf, int buflen, int v
|
Line 249 buffer2vars(u_char * __restrict buf, int buflen, int v
|
return vars; |
return vars; |
} |
} |
|
|
|
/* |
|
* ait_var2tlv() - Marshaling data from variable to TLV buffer |
|
* |
|
* @buf = Buffer, If =NULL then we return only needed buffer size |
|
* @buflen = Size of buffer |
|
* @var = Variable |
|
* return: -1 error, 0 nothing done or >0 size of marshaled data |
|
*/ |
|
int |
|
ait_var2tlv(u_char * __restrict buf, int buflen, ait_val_t * __restrict v) |
|
{ |
|
int Limit = 0; |
|
u_char *dat; |
|
|
|
assert(v); |
|
if (!v) |
|
return -1; |
|
if (AIT_TYPE(v) == empty) |
|
return 0; |
|
|
|
/* calculate amount of data into buffer */ |
|
Limit = 5 + AIT_LEN(v); |
|
/* check only needed buffer size */ |
|
if (!buf) |
|
return Limit; |
|
else |
|
dat = buf; |
|
|
|
if (Limit > buflen) { |
|
elwix_SetErr(EMSGSIZE, "Short buffer buflen=%d needed min %d", |
|
buflen, Limit); |
|
return -1; |
|
} else |
|
memset(buf, 0, buflen); |
|
|
|
/* marshaling */ |
|
*dat++ = AIT_TYPE(v); |
|
|
|
*((uint32_t*) dat) = htonl(AIT_LEN(v)); |
|
dat += sizeof(uint32_t); |
|
|
|
switch (AIT_TYPE(v)) { |
|
case i8: |
|
*((int8_t*) dat) = AIT_GET_I8(v); |
|
break; |
|
case u8: |
|
*((uint8_t*) dat) = AIT_GET_U8(v); |
|
break; |
|
case i16: |
|
*((int16_t*) dat) = AIT_GET_I16(v); |
|
break; |
|
case u16: |
|
*((uint16_t*) dat) = AIT_GET_U16(v); |
|
break; |
|
case i32: |
|
*((int32_t*) dat) = AIT_GET_I32(v); |
|
break; |
|
case blob: |
|
case u32: |
|
*((uint32_t*) dat) = AIT_GET_U32(v); |
|
break; |
|
case i64: |
|
*((int64_t*) dat) = AIT_GET_I64(v); |
|
break; |
|
case u64: |
|
*((uint64_t*) dat) = AIT_GET_U64(v); |
|
break; |
|
case f32: |
|
*((float*) dat) = AIT_GET_F32(v); |
|
break; |
|
case f64: |
|
*((double*) dat) = AIT_GET_F64(v); |
|
break; |
|
case data: |
|
memcpy(dat, AIT_GET_DATA(v), AIT_LEN(v)); |
|
break; |
|
case buffer: |
|
memcpy(dat, AIT_GET_BUF(v), AIT_LEN(v)); |
|
break; |
|
case string: |
|
memcpy(dat, AIT_GET_STR(v), AIT_LEN(v)); |
|
break; |
|
case ptr: |
|
memcpy(dat, AIT_GET_PTR(v), AIT_LEN(v)); |
|
break; |
|
default: |
|
elwix_SetErr(EINVAL, "Unsupported variable type=%d", AIT_TYPE(v)); |
|
return -1; |
|
} |
|
|
|
return Limit; |
|
} |
|
|
|
/* |
|
* ait_vars2tlv() - Marshaling data from array with variables to TLV buffer |
|
* |
|
* @buf = Buffer, If =NULL then we return only needed buffer size |
|
* @buflen = Size of buffer |
|
* @vars = Variable array |
|
* return: -1 error, 0 nothing done or >0 size of marshaled data |
|
*/ |
|
int |
|
ait_vars2tlv(u_char * __restrict buf, int buflen, array_t * __restrict vars) |
|
{ |
|
int Limit = 0; |
|
register int i; |
|
ait_val_t *val; |
|
u_char *dat; |
|
|
|
assert(vars); |
|
if (!vars) |
|
return -1; |
|
if (!array_Size(vars)) |
|
return 0; |
|
|
|
/* calculate amount of data into buffer */ |
|
for (i = 0, Limit = 0; i < array_Size(vars); |
|
Limit += 5 + AIT_LEN(array(vars, i, ait_val_t*)), i++); |
|
/* check only needed buffer size */ |
|
if (!buf) |
|
return Limit; |
|
|
|
if (Limit > buflen) { |
|
elwix_SetErr(EMSGSIZE, "Short buffer buflen=%d needed min %d", |
|
buflen, Limit); |
|
return -1; |
|
} else |
|
memset(buf, 0, buflen); |
|
|
|
/* marshaling */ |
|
for (i = 0, dat = buf; i < array_Size(vars) && dat < (buf + Limit); i++) { |
|
val = array(vars, i, ait_val_t*); |
|
|
|
*dat++ = AIT_TYPE(val); |
|
|
|
*((uint32_t*) dat) = htonl(AIT_LEN(val)); |
|
dat += sizeof(uint32_t); |
|
|
|
switch (AIT_TYPE(val)) { |
|
case i8: |
|
*((int8_t*) dat) = AIT_GET_I8(val); |
|
break; |
|
case u8: |
|
*((uint8_t*) dat) = AIT_GET_U8(val); |
|
break; |
|
case i16: |
|
*((int16_t*) dat) = AIT_GET_I16(val); |
|
break; |
|
case u16: |
|
*((uint16_t*) dat) = AIT_GET_U16(val); |
|
break; |
|
case i32: |
|
*((int32_t*) dat) = AIT_GET_I32(val); |
|
break; |
|
case blob: |
|
case u32: |
|
*((uint32_t*) dat) = AIT_GET_U32(val); |
|
break; |
|
case i64: |
|
*((int64_t*) dat) = AIT_GET_I64(val); |
|
break; |
|
case u64: |
|
*((uint64_t*) dat) = AIT_GET_U64(val); |
|
break; |
|
case f32: |
|
*((float*) dat) = AIT_GET_F32(val); |
|
break; |
|
case f64: |
|
*((double*) dat) = AIT_GET_F64(val); |
|
break; |
|
case data: |
|
memcpy(dat, AIT_GET_DATA(val), AIT_LEN(val)); |
|
break; |
|
case buffer: |
|
memcpy(dat, AIT_GET_BUF(val), AIT_LEN(val)); |
|
break; |
|
case string: |
|
memcpy(dat, AIT_GET_STR(val), AIT_LEN(val)); |
|
break; |
|
case ptr: |
|
memcpy(dat, AIT_GET_PTR(val), AIT_LEN(val)); |
|
break; |
|
default: |
|
elwix_SetErr(EINVAL, "Unsupported variable type=%d at element #%d", |
|
AIT_TYPE(val), i); |
|
return -1; |
|
} |
|
dat += AIT_LEN(val); |
|
} |
|
|
|
return Limit; |
|
} |
|
|
|
/* |
|
* ait_tlv2var() - De-marshaling data from TLV buffer to variable |
|
* |
|
* @buf = Buffer |
|
* @buflen = Size of buffer |
|
* @next_tlv = Next TLV position, if it is !=NULL |
|
* return: =NULL error, !=NULL allocated variable array, after use must free with ait_freeVar() |
|
*/ |
|
ait_val_t * |
|
ait_tlv2var(u_char * __restrict buf, int buflen, off_t *next_tlv) |
|
{ |
|
ait_val_t *val; |
|
u_char *dat; |
|
|
|
assert(buf); |
|
if (!buf || !buflen) |
|
return NULL; |
|
|
|
if (!(val = ait_allocVar())) |
|
return NULL; |
|
else |
|
dat = buf; |
|
|
|
/* de-marshaling */ |
|
if (*dat != empty) { |
|
val->val_type = *dat++; |
|
AIT_LEN(val) = ntohl(*((uint32_t*) dat)); |
|
dat += sizeof(uint32_t); |
|
|
|
switch (AIT_TYPE(val)) { |
|
case f32: |
|
AIT_SET_F32(val, *((float*) dat)); |
|
break; |
|
case f64: |
|
AIT_SET_F64(val, *((double*) dat)); |
|
break; |
|
case i8: |
|
AIT_SET_I8(val, *((int8_t*) dat)); |
|
break; |
|
case i16: |
|
AIT_SET_I16(val, *((int16_t*) dat)); |
|
break; |
|
case i32: |
|
AIT_SET_I32(val, *((int32_t*) dat)); |
|
break; |
|
case i64: |
|
AIT_SET_I64(val, *((int64_t*) dat)); |
|
break; |
|
case u8: |
|
AIT_SET_U8(val, *((uint8_t*) dat)); |
|
break; |
|
case u16: |
|
AIT_SET_U16(val, *((uint16_t*) dat)); |
|
break; |
|
case blob: |
|
case u32: |
|
AIT_SET_U32(val, *((uint32_t*) dat)); |
|
break; |
|
case u64: |
|
AIT_SET_U64(val, *((uint64_t*) dat)); |
|
break; |
|
case data: |
|
AIT_SET_DATA(val, dat, AIT_LEN(val)); |
|
break; |
|
case ptr: |
|
case buffer: |
|
AIT_SET_BUF(val, dat, AIT_LEN(val)); |
|
break; |
|
case string: |
|
AIT_SET_STR(val, (char*) dat); |
|
break; |
|
default: |
|
elwix_SetErr(EINVAL, "Unsupported variable type=%d", AIT_TYPE(val)); |
|
ait_freeVar(&val); |
|
return NULL; |
|
} |
|
dat += AIT_LEN(val); |
|
} |
|
|
|
if (next_tlv) |
|
*next_tlv = dat - buf; |
|
|
|
return val; |
|
} |
|
|
|
/* |
|
* ait_tlv2vars() - De-marshaling data from TLV buffer to array with variables |
|
* |
|
* @buf = Buffer |
|
* @buflen = Size of buffer |
|
* return: =NULL error, !=NULL allocated variable array, after use must free with ait_freeVars() |
|
*/ |
|
array_t * |
|
ait_tlv2vars(u_char * __restrict buf, int buflen) |
|
{ |
|
array_t *vars; |
|
register int i; |
|
ait_val_t *val; |
|
u_char *dat; |
|
|
|
assert(buf); |
|
if (!buf || !buflen) |
|
return NULL; |
|
|
|
if (!(vars = ait_allocVars(1))) |
|
return NULL; |
|
|
|
/* de-marshaling */ |
|
for (i = 0, dat = buf; *dat != empty && dat < (buf + buflen); i++) { |
|
val = ait_getVars(&vars, i); |
|
if (!val) { |
|
ait_freeVars(&vars); |
|
return NULL; |
|
} |
|
|
|
val->val_type = *dat++; |
|
AIT_LEN(val) = ntohl(*((uint32_t*) dat)); |
|
dat += sizeof(uint32_t); |
|
|
|
switch (AIT_TYPE(val)) { |
|
case f32: |
|
AIT_SET_F32(val, *((float*) dat)); |
|
break; |
|
case f64: |
|
AIT_SET_F64(val, *((double*) dat)); |
|
break; |
|
case i8: |
|
AIT_SET_I8(val, *((int8_t*) dat)); |
|
break; |
|
case i16: |
|
AIT_SET_I16(val, *((int16_t*) dat)); |
|
break; |
|
case i32: |
|
AIT_SET_I32(val, *((int32_t*) dat)); |
|
break; |
|
case i64: |
|
AIT_SET_I64(val, *((int64_t*) dat)); |
|
break; |
|
case u8: |
|
AIT_SET_U8(val, *((uint8_t*) dat)); |
|
break; |
|
case u16: |
|
AIT_SET_U16(val, *((uint16_t*) dat)); |
|
break; |
|
case blob: |
|
case u32: |
|
AIT_SET_U32(val, *((uint32_t*) dat)); |
|
break; |
|
case u64: |
|
AIT_SET_U64(val, *((uint64_t*) dat)); |
|
break; |
|
case data: |
|
AIT_SET_DATA(val, dat, AIT_LEN(val)); |
|
break; |
|
case ptr: |
|
case buffer: |
|
AIT_SET_BUF(val, dat, AIT_LEN(val)); |
|
break; |
|
case string: |
|
AIT_SET_STR(val, (char*) dat); |
|
break; |
|
default: |
|
elwix_SetErr(EINVAL, "Unsupported variable type=%d at element #%d", |
|
AIT_TYPE(val), i); |
|
ait_freeVars(&vars); |
|
return NULL; |
|
} |
|
dat += AIT_LEN(val); |
|
} |
|
|
|
return vars; |
|
} |
|
|
/* buffer marshaling with swapping bytes to network order */ |
/* buffer marshaling with swapping bytes to network order */ |
|
|
/* |
/* |
Line 258 buffer2vars(u_char * __restrict buf, int buflen, int v
|
Line 625 buffer2vars(u_char * __restrict buf, int buflen, int v
|
* @vars = Variable array |
* @vars = Variable array |
* return: -1 error, 0 nothing done or >0 size of marshaled data |
* return: -1 error, 0 nothing done or >0 size of marshaled data |
*/ |
*/ |
inline int | int |
ait_vars2buffer(u_char * __restrict buf, int buflen, array_t * __restrict vars) |
ait_vars2buffer(u_char * __restrict buf, int buflen, array_t * __restrict vars) |
{ |
{ |
return vars2buffer(buf, buflen, 42, vars); |
return vars2buffer(buf, buflen, 42, vars); |
Line 274 ait_vars2buffer(u_char * __restrict buf, int buflen, a
|
Line 641 ait_vars2buffer(u_char * __restrict buf, int buflen, a
|
*DON'T MODIFY OR DESTROY BUFFER*. =0 call array_Free() before array_Destroy() |
*DON'T MODIFY OR DESTROY BUFFER*. =0 call array_Free() before array_Destroy() |
* return: =NULL error, !=NULL allocated variable array, after use must free with array_Destroy() |
* return: =NULL error, !=NULL allocated variable array, after use must free with array_Destroy() |
*/ |
*/ |
inline array_t * | array_t * |
ait_buffer2vars(u_char * __restrict buf, int buflen, int vnum, int zcpy) |
ait_buffer2vars(u_char * __restrict buf, int buflen, int vnum, int zcpy) |
{ |
{ |
return buffer2vars(buf, buflen, vnum, zcpy); |
return buffer2vars(buf, buflen, vnum, zcpy); |
Line 290 ait_buffer2vars(u_char * __restrict buf, int buflen, i
|
Line 657 ait_buffer2vars(u_char * __restrict buf, int buflen, i
|
* @vars = Variable array |
* @vars = Variable array |
* return: -1 error, 0 nothing done or >0 size of marshaled data |
* return: -1 error, 0 nothing done or >0 size of marshaled data |
*/ |
*/ |
inline int | int |
ait_vars2map(u_char *buf, int buflen, array_t *vars) |
ait_vars2map(u_char *buf, int buflen, array_t *vars) |
{ |
{ |
return vars2buffer(buf, buflen, 0, vars); |
return vars2buffer(buf, buflen, 0, vars); |
Line 306 ait_vars2map(u_char *buf, int buflen, array_t *vars)
|
Line 673 ait_vars2map(u_char *buf, int buflen, array_t *vars)
|
*DON'T MODIFY OR DESTROY BUFFER*. =0 call array_Free() before array_Destroy() |
*DON'T MODIFY OR DESTROY BUFFER*. =0 call array_Free() before array_Destroy() |
* return: =NULL error, !=NULL allocated variable array, after use must free with array_Destroy() |
* return: =NULL error, !=NULL allocated variable array, after use must free with array_Destroy() |
*/ |
*/ |
inline array_t * | array_t * |
ait_map2vars(u_char *buf, int buflen, int vnum, int zcpy) |
ait_map2vars(u_char *buf, int buflen, int vnum, int zcpy) |
{ |
{ |
return buffer2vars(buf, buflen, vnum, zcpy); |
return buffer2vars(buf, buflen, vnum, zcpy); |
} |
} |
|
|
|
/* |
|
* ait_array2vars() - Build array with variables from Null Terminated String Array |
|
* |
|
* @args = Null-terminated array with strings |
|
* @dn = Convert numbers from strings to numbers into variables |
|
* return: =NULL error, !=NULL allocated variable array, after use must free with ait_freeVars() |
|
*/ |
|
array_t * |
|
ait_array2vars(const char **args, int dn) |
|
{ |
|
array_t *vars; |
|
ait_val_t *val; |
|
register int i; |
|
long n; |
|
double d; |
|
char *str; |
|
|
|
if (!args) |
|
return NULL; |
|
|
|
vars = ait_allocVars(0); |
|
if (!vars) |
|
return NULL; |
|
|
|
for (i = 0; *args; i++, args++) { |
|
val = ait_getVars(&vars, i); |
|
if (!val) { |
|
ait_freeVars(&vars); |
|
return NULL; |
|
} |
|
|
|
if (dn) { |
|
n = strtol(*args, &str, 0); |
|
if (!str || !*str) { |
|
AIT_SET_I64(val, (int64_t) n); |
|
continue; |
|
} |
|
d = strtod(*args, &str); |
|
if (!str || !*str) { |
|
AIT_SET_F64(val, d); |
|
continue; |
|
} |
|
AIT_SET_STR(val, *args); |
|
} else |
|
AIT_SET_STR(val, *args); |
|
} |
|
|
|
return vars; |
|
} |
|
|
/* variables array */ |
/* variables array */ |
|
|
/* |
/* |
Line 321 ait_map2vars(u_char *buf, int buflen, int vnum, int zc
|
Line 737 ait_map2vars(u_char *buf, int buflen, int vnum, int zc
|
* @varnum = Number of variables |
* @varnum = Number of variables |
* return: =NULL error or !=NULL allocated array |
* return: =NULL error or !=NULL allocated array |
*/ |
*/ |
inline array_t * | array_t * |
ait_allocVars(int varnum) |
ait_allocVars(int varnum) |
{ |
{ |
array_t *arr; |
array_t *arr; |
Line 349 ait_allocVars(int varnum)
|
Line 765 ait_allocVars(int varnum)
|
* @n = index of variable into array |
* @n = index of variable into array |
* return: NULL error or !=NULL ait_val_t element |
* return: NULL error or !=NULL ait_val_t element |
*/ |
*/ |
inline ait_val_t * | ait_val_t * |
ait_getVars(array_t ** __restrict vars, int n) |
ait_getVars(array_t ** __restrict vars, int n) |
{ |
{ |
register int i; |
register int i; |
Line 382 ait_getVars(array_t ** __restrict vars, int n)
|
Line 798 ait_getVars(array_t ** __restrict vars, int n)
|
* @vars = Variable array |
* @vars = Variable array |
* return: -1 error or size of array |
* return: -1 error or size of array |
*/ |
*/ |
inline int | int |
ait_clrVars(array_t * __restrict vars) |
ait_clrVars(array_t * __restrict vars) |
{ |
{ |
register int i; |
register int i; |
Line 404 ait_clrVars(array_t * __restrict vars)
|
Line 820 ait_clrVars(array_t * __restrict vars)
|
* @vars = Variable array |
* @vars = Variable array |
* return: none |
* return: none |
*/ |
*/ |
inline void | void |
ait_freeVars(array_t ** __restrict vars) |
ait_freeVars(array_t ** __restrict vars) |
{ |
{ |
|
register int i; |
|
ait_val_t *v; |
|
|
if (!vars || !*vars) |
if (!vars || !*vars) |
return; |
return; |
|
|
ait_clrVars(*vars); | for (i = 0; i < array_Size(*vars); i++) |
array_Free(*vars); | if ((v = array(*vars, i, ait_val_t*))) { |
| /* free memory if isn't zero copy */ |
| if (!AIT_IN(v)) { |
| AIT_FREE_VAL(v); |
| if ((*vars)->arr_data[i]) |
| e_free((*vars)->arr_data[i]); |
| } else |
| AIT_FREE_VAL(v); |
| (*vars)->arr_data[i] = NULL; |
| } |
| (*vars)->arr_last = -1; |
| |
array_Destroy(vars); |
array_Destroy(vars); |
} |
} |
|
|
|
/* |
|
* ait_resideVars() - Calculate footprint of resided variables into array |
|
* |
|
* @vars = Variable array |
|
* return: bytes for whole array |
|
*/ |
|
size_t |
|
ait_resideVars(array_t * __restrict vars) |
|
{ |
|
size_t ret = 0; |
|
register int i; |
|
|
|
if (vars) { |
|
ret = array_Size(vars) * sizeof(ait_val_t); |
|
for (i = 0; i < array_Size(vars); i++) |
|
switch (AIT_TYPE(array(vars, i, ait_val_t*))) { |
|
case buffer: |
|
case string: |
|
case data: |
|
case ptr: |
|
ret += AIT_LEN(array(vars, i, ait_val_t*)); |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
|
/* |
/* |
* ait_allocVar() - Allocate memory for variable |
* ait_allocVar() - Allocate memory for variable |
* |
* |
* return: NULL error or new variable, after use free variable with ait_freeVar() |
* return: NULL error or new variable, after use free variable with ait_freeVar() |
*/ |
*/ |
inline ait_val_t * | ait_val_t * |
ait_allocVar(void) |
ait_allocVar(void) |
{ |
{ |
ait_val_t *v = NULL; |
ait_val_t *v = NULL; |
Line 442 ait_allocVar(void)
|
Line 902 ait_allocVar(void)
|
* @val = Variable |
* @val = Variable |
* return: none |
* return: none |
*/ |
*/ |
inline void | void |
ait_freeVar(ait_val_t ** __restrict val) |
ait_freeVar(ait_val_t ** __restrict val) |
{ |
{ |
if (val && *val) { |
if (val && *val) { |
Line 570 _cmp_arr_val_desc(const void *a, const void *b)
|
Line 1030 _cmp_arr_val_desc(const void *a, const void *b)
|
* @cmp = Custom compare function for sorting. If =NULL compare by value |
* @cmp = Custom compare function for sorting. If =NULL compare by value |
* return: none |
* return: none |
*/ |
*/ |
inline void | void |
ait_sortVarsByVal(array_t * __restrict vars, int order, int (*cmp)(const void*, const void*)) |
ait_sortVarsByVal(array_t * __restrict vars, int order, int (*cmp)(const void*, const void*)) |
{ |
{ |
if (!vars) |
if (!vars) |
Line 591 ait_sortVarsByVal(array_t * __restrict vars, int order
|
Line 1051 ait_sortVarsByVal(array_t * __restrict vars, int order
|
* @order = Sort order. If =0 ascend or !=0 descend |
* @order = Sort order. If =0 ascend or !=0 descend |
* return: none |
* return: none |
*/ |
*/ |
inline void | void |
ait_sortVarsByKey(array_t * __restrict vars, int order) |
ait_sortVarsByKey(array_t * __restrict vars, int order) |
{ |
{ |
if (!vars) |
if (!vars) |
Line 702 ait_hashVar(ait_val_t * __restrict v, const char * __r
|
Line 1162 ait_hashVar(ait_val_t * __restrict v, const char * __r
|
* @vars = Variables |
* @vars = Variables |
* return -1 error or 0 ok |
* return -1 error or 0 ok |
*/ |
*/ |
inline int | int |
ait_hashKeyVars(array_t * __restrict vars) |
ait_hashKeyVars(array_t * __restrict vars) |
{ |
{ |
register int i; |
register int i; |
Line 723 ait_hashKeyVars(array_t * __restrict vars)
|
Line 1183 ait_hashKeyVars(array_t * __restrict vars)
|
* @key = Search string |
* @key = Search string |
* return: NULL error or not found, !=NULL valid element |
* return: NULL error or not found, !=NULL valid element |
*/ |
*/ |
inline ait_val_t * | ait_val_t * |
ait_findKeyHash(array_t * __restrict vars, const char * __restrict key) |
ait_findKeyHash(array_t * __restrict vars, const char * __restrict key) |
{ |
{ |
u_short k = 0; |
u_short k = 0; |
Line 748 ait_sprintfVar(ait_val_t * __restrict v, const char *f
|
Line 1208 ait_sprintfVar(ait_val_t * __restrict v, const char *f
|
{ |
{ |
int ret = 0; |
int ret = 0; |
va_list lst; |
va_list lst; |
char *str = NULL; | char str[STRSIZ] = { [0 ... STRSIZ - 1] = 0 }; |
|
|
if (!v || !fmt) |
if (!v || !fmt) |
return -1; |
return -1; |
|
|
va_start(lst, fmt); |
va_start(lst, fmt); |
ret = vasprintf(&str, fmt, lst); | ret = vsnprintf(str, sizeof str - 1, fmt, lst); |
va_end(lst); |
va_end(lst); |
|
|
if (str && ret > -1) { | if (ret > -1) { |
AIT_FREE_VAL(v); |
AIT_FREE_VAL(v); |
AIT_SET_STR(v, str); |
AIT_SET_STR(v, str); |
} else |
} else |
LOGERR; |
LOGERR; |
|
|
if (str) |
|
free(str); |
|
return ret; |
return ret; |
} |
} |
|
|
Line 777 ait_sprintfVar(ait_val_t * __restrict v, const char *f
|
Line 1235 ait_sprintfVar(ait_val_t * __restrict v, const char *f
|
* @... = data |
* @... = data |
* return: -1 error or 0 ok |
* return: -1 error or 0 ok |
*/ |
*/ |
inline int | int |
ait_setlikeVar(ait_val_t * __restrict v, ait_type_t t, u_int l, ...) |
ait_setlikeVar(ait_val_t * __restrict v, ait_type_t t, u_int l, ...) |
{ |
{ |
va_list lst; |
va_list lst; |
Line 812 ait_setlikeVar(ait_val_t * __restrict v, ait_type_t t,
|
Line 1270 ait_setlikeVar(ait_val_t * __restrict v, ait_type_t t,
|
* @v = variable |
* @v = variable |
* return: return raw data |
* return: return raw data |
*/ |
*/ |
inline uint64_t | uint64_t |
ait_getlikeVar(ait_val_t * __restrict v) |
ait_getlikeVar(ait_val_t * __restrict v) |
{ |
{ |
if (!v) |
if (!v) |
Line 828 ait_getlikeVar(ait_val_t * __restrict v)
|
Line 1286 ait_getlikeVar(ait_val_t * __restrict v)
|
* @b = 2nd variable |
* @b = 2nd variable |
* return: 0 is equal or !=0 is different |
* return: 0 is equal or !=0 is different |
*/ |
*/ |
inline int | int |
ait_cmpVar(ait_val_t * __restrict a, ait_val_t * __restrict b) |
ait_cmpVar(ait_val_t * __restrict a, ait_val_t * __restrict b) |
{ |
{ |
intptr_t ret; |
intptr_t ret; |