libaitio/src/vars.c - diff

Return to vars.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src

Diff for /libaitio/src/Attic/vars.c between versions 1.5 and 1.10.2.1

version 1.5, 2012/03/29 01:31:34	version 1.10.2.1, 2012/07/22 12:23:04
Line 46 SUCH DAMAGE.	Line 46 SUCH DAMAGE.
#include "global.h"	#include "global.h"


/*	static int
* io_vars2buffer() Marshaling data from array with variables to buffer	vars2buffer(u_char * __restrict buf, int buflen, int be, array_t * __restrict vars)
*
* @buf = Buffer
* @buflen = Size of buffer
* @vars = Variable array
* return: -1 error, 0 nothing done or >0 size of marshaled data
*/
int
io_vars2buffer(u_char buf, int buflen, array_t vars)
{	{
int Limit = 0;	int Limit = 0;
register int i;	register int i;
Line 68 io_vars2buffer(u_char buf, int buflen, array_t vars)	Line 60 io_vars2buffer(u_char buf, int buflen, array_t vars)
return -1;	return -1;
if (!buflen \|\| !io_arraySize(vars))	if (!buflen \|\| !io_arraySize(vars))
return 0;	return 0;
	be = !!be;

Limit = sizeof(ait_val_t) * io_arraySize(vars);	Limit = sizeof(ait_val_t) * io_arraySize(vars);
if (Limit > buflen) {	if (Limit > buflen) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d needed min %d ...\n",	io_SetErr(EMSGSIZE, "Short buffer buflen=%d needed min %d",
buflen, Limit);	buflen, Limit);
return -1;	return -1;
} else {	} else {
Line 86 io_vars2buffer(u_char buf, int buflen, array_t vars)	Line 79 io_vars2buffer(u_char buf, int buflen, array_t vars)
val = io_array(vars, i, ait_val_t*);	val = io_array(vars, i, ait_val_t*);

v[i].val_type = val->val_type;	v[i].val_type = val->val_type;
AIT_HASH(&v[i]) = htobe16(AIT_HASH(val));	AIT_IN(&v[i]) = 1;
AIT_LEN(&v[i]) = htobe32(AIT_LEN(val));	AIT_BE(&v[i]) = be;
	AIT_LE(&v[i]) = !be;
	if (AIT_BE(&v[i])) {
	AIT_KEY(&v[i]) = htobe16(AIT_KEY(val));
	AIT_LEN(&v[i]) = htobe32(AIT_LEN(val));
	}
	if (AIT_LE(&v[i])) {
	AIT_KEY(&v[i]) = htole16(AIT_KEY(val));
	AIT_LEN(&v[i]) = htole32(AIT_LEN(val));
	}

switch (AIT_TYPE(val)) {	switch (AIT_TYPE(val)) {
case blob:	case blob:
Line 101 io_vars2buffer(u_char buf, int buflen, array_t vars)	Line 103 io_vars2buffer(u_char buf, int buflen, array_t vars)
case u16:	case u16:
case u32:	case u32:
case u64:	case u64:
v[i].val.net = htobe64(val->val.net);	if (AIT_BE(&v[i]))
	v[i].val.net = htobe64(val->val.net);
	if (AIT_LE(&v[i]))
	v[i].val.net = htole64(val->val.net);
break;	break;
case data:	case data:
if (AIT_LEN(val) > buflen - Limit) {	if (AIT_LEN(val) > buflen - Limit) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d "	io_SetErr(EMSGSIZE, "Short buffer buflen=%d "
"needed min %d ...\n", buflen, Limit + AIT_LEN(val));	"needed min %d", buflen, Limit + AIT_LEN(val));
return -1;	return -1;
} else	} else
Limit += AIT_LEN(val);	Limit += AIT_LEN(val);
Line 119 io_vars2buffer(u_char buf, int buflen, array_t vars)	Line 124 io_vars2buffer(u_char buf, int buflen, array_t vars)
case buffer:	case buffer:
case string:	case string:
if (AIT_LEN(val) > buflen - Limit) {	if (AIT_LEN(val) > buflen - Limit) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d "	io_SetErr(EMSGSIZE, "Short buffer buflen=%d "
"needed min %d ...\n", buflen, Limit + AIT_LEN(val));	"needed min %d", buflen, Limit + AIT_LEN(val));
return -1;	return -1;
} else	} else
Limit += AIT_LEN(val);	Limit += AIT_LEN(val);
Line 131 io_vars2buffer(u_char buf, int buflen, array_t vars)	Line 136 io_vars2buffer(u_char buf, int buflen, array_t vars)
dat += AIT_LEN(val);	dat += AIT_LEN(val);
break;	break;
default:	default:
io_SetErr(EINVAL, "Error:: unsupported variable type=%d at element #%d ...\n",	io_SetErr(EINVAL, "Unsupported variable type=%d at element #%d",
AIT_TYPE(val), i);	AIT_TYPE(val), i);
return -1;	return -1;
}	}
Line 140 io_vars2buffer(u_char buf, int buflen, array_t vars)	Line 145 io_vars2buffer(u_char buf, int buflen, array_t vars)
return Limit;	return Limit;
}	}

/*	static array_t *
* io_buffer2vars() De-marshaling data from buffer to array with variables	buffer2vars(u_char * __restrict buf, int buflen, int vnum, int zcpy)
*
* @buf = Buffer
* @buflen = Size of buffer
* @vnum = Number of variables into buffer
* @zcpy = Zero-copy for variables, if !=0 don't use io_arrayFree() for free variables and
DON'T MODIFY OR DESTROY BUFFER. =0 call io_arrayFree() before io_arrayDestroy()
* return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()
*/
array_t *
io_buffer2vars(u_char *buf, int buflen, int vnum, int zcpy)
{	{
array_t *vars;	array_t *vars;
int Limit = 0;	int Limit = 0;
Line 165 io_buffer2vars(u_char *buf, int buflen, int vnum, int	Line 160 io_buffer2vars(u_char *buf, int buflen, int vnum, int

Limit = sizeof(ait_val_t) * vnum;	Limit = sizeof(ait_val_t) * vnum;
if (Limit > buflen) {	if (Limit > buflen) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d needed min %d ...\n",	io_SetErr(EMSGSIZE, "Short buffer buflen=%d needed min %d",
buflen, Limit);	buflen, Limit);
return NULL;	return NULL;
} else {	} else {
Line 179 io_buffer2vars(u_char *buf, int buflen, int vnum, int	Line 174 io_buffer2vars(u_char *buf, int buflen, int vnum, int
/* de-marshaling */	/* de-marshaling */
for (i = 0; i < io_arraySize(vars); i++) {	for (i = 0; i < io_arraySize(vars); i++) {
if (!zcpy) {	if (!zcpy) {
val = malloc(sizeof(ait_val_t));	val = io_malloc(sizeof(ait_val_t));
if (!val) {	if (!val) {
LOGERR;	LOGERR;
io_arrayFree(vars);	io_arrayFree(vars);
io_arrayDestroy(&vars);	io_arrayDestroy(&vars);
return NULL;	return NULL;
}	}
} else	AIT_IN(val) = 0;
	} else {
val = v + i;	val = v + i;
	AIT_IN(val) = 1;
	}
io_arraySet(vars, i, val);	io_arraySet(vars, i, val);

val->val_type = v[i].val_type;	val->val_type = v[i].val_type;
#if defined(__OpenBSD__)	AIT_BE(val) = AIT_BE(&v[i]);
AIT_LEN(val) = betoh32(AIT_LEN(&v[i]));	AIT_LE(val) = AIT_LE(&v[i]);
AIT_HASH(val) = betoh16(AIT_HASH(&v[i]));	if (AIT_BE(val)) {
#else	AIT_LEN(val) = be32toh(AIT_LEN(&v[i]));
AIT_LEN(val) = be32toh(AIT_LEN(&v[i]));	AIT_KEY(val) = be16toh(AIT_KEY(&v[i]));
AIT_HASH(val) = be16toh(AIT_HASH(&v[i]));	}
#endif	if (AIT_LE(val)) {
	AIT_LEN(val) = le32toh(AIT_LEN(&v[i]));
	AIT_KEY(val) = le16toh(AIT_KEY(&v[i]));
	}

switch (AIT_TYPE(val)) {	switch (AIT_TYPE(val)) {
case blob:	case blob:
Line 211 io_buffer2vars(u_char *buf, int buflen, int vnum, int	Line 212 io_buffer2vars(u_char *buf, int buflen, int vnum, int
case u16:	case u16:
case u32:	case u32:
case u64:	case u64:
#if defined(__OpenBSD__)	if (AIT_BE(val))
val->val.net = betoh64(v[i].val.net);	val->val.net = be64toh(v[i].val.net);
#else	if (AIT_LE(val))
val->val.net = be64toh(v[i].val.net);	val->val.net = le64toh(v[i].val.net);
#endif
break;	break;
case data:	case data:
/* WARNING:: remap data type to buffer */	/* WARNING:: remap data type to buffer */
Line 223 io_buffer2vars(u_char *buf, int buflen, int vnum, int	Line 223 io_buffer2vars(u_char *buf, int buflen, int vnum, int
case buffer:	case buffer:
case string:	case string:
if (AIT_LEN(val) > buflen - Limit) {	if (AIT_LEN(val) > buflen - Limit) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d "	io_SetErr(EMSGSIZE, "Short buffer buflen=%d "
"needed min %d ...\n", buflen, Limit + AIT_LEN(val));	"needed min %d", buflen, Limit + AIT_LEN(val));
if (!zcpy)	if (!zcpy)
io_arrayFree(vars);	io_arrayFree(vars);
io_arrayDestroy(&vars);	io_arrayDestroy(&vars);
Line 233 io_buffer2vars(u_char *buf, int buflen, int vnum, int	Line 233 io_buffer2vars(u_char *buf, int buflen, int vnum, int
Limit += AIT_LEN(val);	Limit += AIT_LEN(val);

if (!zcpy) {	if (!zcpy) {
val->val.buffer = malloc(AIT_LEN(val));	val->val.buffer = io_malloc(AIT_LEN(val));
if (!val->val.buffer) {	if (!val->val.buffer) {
LOGERR;	LOGERR;
io_arrayFree(vars);	io_arrayFree(vars);
Line 246 io_buffer2vars(u_char *buf, int buflen, int vnum, int	Line 246 io_buffer2vars(u_char *buf, int buflen, int vnum, int
dat += AIT_LEN(val);	dat += AIT_LEN(val);
break;	break;
default:	default:
io_SetErr(EINVAL, "Error:: unsupported variable type=%d at element #%d ...\n",	io_SetErr(EINVAL, "Unsupported variable type=%d at element #%d",
AIT_TYPE(val), i);	AIT_TYPE(val), i);
if (!zcpy)	if (!zcpy)
io_arrayFree(vars);	io_arrayFree(vars);
Line 258 io_buffer2vars(u_char *buf, int buflen, int vnum, int	Line 258 io_buffer2vars(u_char *buf, int buflen, int vnum, int
return vars;	return vars;
}	}

/* buffer marshaling without swapping bytes to network order */

	/* buffer marshaling with swapping bytes to network order */

/*	/*
* io_vars2map() Marshaling data from array with variables to memory map	* io_vars2buffer() - Marshaling data from array with variables to buffer
*	*
* @buf = Buffer	* @buf = Buffer
* @buflen = Size of buffer	* @buflen = Size of buffer
* @vars = Variable array	* @vars = Variable array
* return: -1 error, 0 nothing done or >0 size of marshaled data	* return: -1 error, 0 nothing done or >0 size of marshaled data
*/	*/
int	inline int
io_vars2map(u_char buf, int buflen, array_t vars)	io_vars2buffer(u_char * __restrict buf, int buflen, array_t * __restrict vars)
{	{
int Limit = 0;	return vars2buffer(buf, buflen, 42, vars);
register int i;	}
ait_val_t v, val;
u_char *dat;

assert(buf);	/*
assert(vars);	* io_buffer2vars() - De-marshaling data from buffer to array with variables
if (!buf \|\| !vars)	*
return -1;	* @buf = Buffer
if (!buflen \|\| !io_arraySize(vars))	* @buflen = Size of buffer
return 0;	* @vnum = Number of variables into buffer
	* @zcpy = Zero-copy for variables, if !=0 don't use io_arrayFree() for free variables and
	DON'T MODIFY OR DESTROY BUFFER. =0 call io_arrayFree() before io_arrayDestroy()
	* return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()
	*/
	inline array_t *
	io_buffer2vars(u_char * __restrict buf, int buflen, int vnum, int zcpy)
	{
	return buffer2vars(buf, buflen, vnum, zcpy);
	}

Limit = sizeof(ait_val_t) * io_arraySize(vars);	/* buffer marshaling without swapping bytes to network order */
if (Limit > buflen) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d needed min %d ...\n",
buflen, Limit);
return -1;
} else {
memset(buf, 0, buflen);

v = (ait_val_t*) buf;	/*
dat = buf + Limit;	* io_vars2map() - Marshaling data from array with variables to memory map
}	*
	* @buf = Buffer
/* marshaling */	* @buflen = Size of buffer
for (i = 0; i < io_arraySize(vars); i++) {	* @vars = Variable array
val = io_array(vars, i, ait_val_t*);	* return: -1 error, 0 nothing done or >0 size of marshaled data
	*/
v[i].val_type = val->val_type;	inline int
AIT_HASH(&v[i]) = AIT_HASH(val);	io_vars2map(u_char buf, int buflen, array_t vars)
AIT_LEN(&v[i]) = AIT_LEN(val);	{
	return vars2buffer(buf, buflen, 0, vars);
switch (AIT_TYPE(val)) {
case blob:
case f32:
case f64:
case i8:
case i16:
case i32:
case i64:
case u8:
case u16:
case u32:
case u64:
v[i].val.net = val->val.net;
break;
case data:
if (AIT_LEN(val) > buflen - Limit) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d "
"needed min %d ...\n", buflen, Limit + AIT_LEN(val));
return -1;
} else
Limit += AIT_LEN(val);

memcpy(dat, val->val_data, AIT_LEN(val));
/* Debug:: data offset in packet, not matter for anything! */
v[i].val.net = dat - buf;
dat += AIT_LEN(val);
break;
case buffer:
case string:
if (AIT_LEN(val) > buflen - Limit) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d "
"needed min %d ...\n", buflen, Limit + AIT_LEN(val));
return -1;
} else
Limit += AIT_LEN(val);

memcpy(dat, val->val.buffer, AIT_LEN(val));
/* Debug:: data offset in packet, not matter for anything! */
v[i].val.net = dat - buf;
dat += AIT_LEN(val);
break;
default:
io_SetErr(EINVAL, "Error:: unsupported variable type=%d at element #%d ...\n",
AIT_TYPE(val), i);
return -1;
}
}

return Limit;
}	}

/*	/*
* io_map2vars() De-marshaling data from memory map to array with variables	* io_map2vars() - De-marshaling data from memory map to array with variables
*	*
* @buf = Buffer	* @buf = Buffer
* @buflen = Size of buffer	* @buflen = Size of buffer
Line 364 io_vars2map(u_char buf, int buflen, array_t vars)	Line 317 io_vars2map(u_char buf, int buflen, array_t vars)
DON'T MODIFY OR DESTROY BUFFER. =0 call io_arrayFree() before io_arrayDestroy()	DON'T MODIFY OR DESTROY BUFFER. =0 call io_arrayFree() before io_arrayDestroy()
* return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()	* return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()
*/	*/
array_t *	inline array_t *
io_map2vars(u_char *buf, int buflen, int vnum, int zcpy)	io_map2vars(u_char *buf, int buflen, int vnum, int zcpy)
{	{
array_t *vars;	return buffer2vars(buf, buflen, vnum, zcpy);
int Limit = 0;
register int i;
ait_val_t v, val;
u_char *dat;

assert(buf);
if (!buf \|\| !buflen \|\| !vnum)
return NULL;

Limit = sizeof(ait_val_t) * vnum;
if (Limit > buflen) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d needed min %d ...\n",
buflen, Limit);
return NULL;
} else {
if (!(vars = io_arrayInit(vnum)))
return NULL;

v = (ait_val_t*) buf;
dat = buf + Limit;
}

/* de-marshaling */
for (i = 0; i < io_arraySize(vars); i++) {
if (!zcpy) {
val = malloc(sizeof(ait_val_t));
if (!val) {
LOGERR;
io_arrayFree(vars);
io_arrayDestroy(&vars);
return NULL;
}
} else
val = v + i;
io_arraySet(vars, i, val);

val->val_type = v[i].val_type;
AIT_HASH(val) = AIT_HASH(&v[i]);
AIT_LEN(val) = AIT_LEN(&v[i]);

switch (AIT_TYPE(val)) {
case blob:
case f32:
case f64:
case i8:
case i16:
case i32:
case i64:
case u8:
case u16:
case u32:
case u64:
val->val.net = v[i].val.net;
break;
case data:
/* WARNING:: remap data type to buffer */
val->val_type = buffer;
case buffer:
case string:
if (AIT_LEN(val) > buflen - Limit) {
io_SetErr(EMSGSIZE, "Error:: too short buffer buflen=%d "
"needed min %d ...\n", buflen, Limit + AIT_LEN(val));
if (!zcpy)
io_arrayFree(vars);
io_arrayDestroy(&vars);
return NULL;
} else
Limit += AIT_LEN(val);

if (!zcpy) {
val->val.buffer = malloc(AIT_LEN(val));
if (!val->val.buffer) {
LOGERR;
io_arrayFree(vars);
io_arrayDestroy(&vars);
return NULL;
} else
memcpy(val->val.buffer, dat, AIT_LEN(val));
} else
val->val.buffer = dat;
dat += AIT_LEN(val);
break;
default:
io_SetErr(EINVAL, "Error:: unsupported variable type=%d at element #%d ...\n",
AIT_TYPE(val), i);
if (!zcpy)
io_arrayFree(vars);
io_arrayDestroy(&vars);
return NULL;
}
}

return vars;
}	}


/*	/*
* io_allocVars() Allocate ait_val_t array	* io_allocVars() - Allocate ait_val_t array
*	*
* @varnum = Number of variables	* @varnum = Number of variables
* return: =NULL error or !=NULL allocated array	* return: =NULL error or !=NULL allocated array
Line 477 io_allocVars(int varnum)	Line 337 io_allocVars(int varnum)
register int i;	register int i;
ait_val_t *v;	ait_val_t *v;

if (!varnum \|\| !(arr = io_arrayInit(varnum)))	if (!(arr = io_arrayInit(varnum)))
return NULL;	return NULL;

for (i = 0; i < io_arraySize(arr); i++) {	for (i = 0; i < io_arraySize(arr); i++) {
v = malloc(sizeof(ait_val_t));	if (!(v = io_allocVar())) {
if (!v) {
LOGERR;
io_freeVars(&arr);	io_freeVars(&arr);
return NULL;	return NULL;
} else {	} else
memset(v, 0, sizeof(ait_val_t));
io_arraySet(arr, i, v);	io_arraySet(arr, i, v);
}
}	}

return arr;	return arr;
}	}

/*	/*
* io_clrVars() Clear ait_val_t elements from array	* io_getVars() - Get ait_val_t element from array and if not exists allocate it
*	*
* @vars = Variable array	* @vars = Variable array
	* @n = index of variable into array
	* return: NULL error or !=NULL ait_val_t element
	*/
	inline ait_val_t *
	io_getVars(array_t ** __restrict vars, int n)
	{
	register int i;
	ait_val_t *v;

	if (!vars)
	return NULL;

	if (!*vars) {
	if (!(*vars = io_allocVars(n + 1)))
	return NULL;
	} else {
	if (n >= (i = io_arraySize(*vars))) {
	if (io_arrayGrow(*vars, n + 1, 0))
	return NULL;
	for (; i < io_arraySize(*vars); i++)
	if (!io_arrayGet(*vars, i)) {
	if (!(v = io_allocVar()))
	return NULL;
	else
	io_arraySet(*vars, n, v);
	}
	}
	}

	return io_array(vars, n, ait_val_t);
	}

	/*
	* io_clrVars() - Clear ait_val_t elements from array
	*
	* @vars = Variable array
* return: -1 error or size of array	* return: -1 error or size of array
*/	*/
inline int	inline int
Line 518 io_clrVars(array_t * __restrict vars)	Line 410 io_clrVars(array_t * __restrict vars)
}	}

/*	/*
* io_freeVars() Free ait_val_t array	* io_freeVars() - Free ait_val_t array
*	*
* @vars = Variable array	* @vars = Variable array
* return: none	* return: none
Line 535 io_freeVars(array_t ** __restrict vars)	Line 427 io_freeVars(array_t ** __restrict vars)
}	}

/*	/*
* io_allocVar() Allocate memory for variable	* io_allocVar() - Allocate memory for variable
*	*
* return: NULL error or new variable, after use free variable with io_freeVar()	* return: NULL error or new variable, after use free variable with io_freeVar()
*/	*/
Line 544 io_allocVar(void)	Line 436 io_allocVar(void)
{	{
ait_val_t *v = NULL;	ait_val_t *v = NULL;

v = malloc(sizeof(ait_val_t));	v = io_malloc(sizeof(ait_val_t));
if (!v) {	if (!v) {
LOGERR;	LOGERR;
return NULL;	return NULL;
Line 556 io_allocVar(void)	Line 448 io_allocVar(void)
}	}

/*	/*
* io_freeVar() Free allocated memory for variable	* io_freeVar() - Free allocated memory for variable
*	*
* @val = Variable	* @val = Variable
* return: none	* return: none
*/	*/
inline void	inline void
io_freeVar(ait_val_t * __restrict val)	io_freeVar(ait_val_t ** __restrict val)
{	{
if (val) {	if (val && *val) {
AIT_FREE_VAL(val);	AIT_FREE_VAL(*val);
free(val);	io_free(*val);
val = NULL;	*val = NULL;
}	}
	}

	static int
	_cmp_arr_key_asc(const void a, const void b)
	{
	return AIT_KEY((ait_val_t) a) - AIT_KEY((ait_val_t**) b);
	}

	static int
	_cmp_arr_key_desc(const void a, const void b)
	{
	return AIT_KEY((ait_val_t) b) - AIT_KEY((ait_val_t**) a);
	}

	static int
	_cmp_arr_val_asc(const void a, const void b)
	{
	return AIT_RAW((ait_val_t) a) - AIT_RAW((ait_val_t**) b);
	}

	static int
	_cmp_arr_val_desc(const void a, const void b)
	{
	return AIT_RAW((ait_val_t) b) - AIT_RAW((ait_val_t**) a);
	}

	/*
	* io_sortVarsByVal() - Sorting array with variables by value
	*
	* @vars = Variable array
	* @order = Sort order. If =0 ascend or !=0 descend
	* @cmp = Custom compare function for sorting. If =NULL compare by value
	* return: none
	*/
	inline void
	io_sortVarsByVal(array_t * __restrict vars, int order, int (cmp)(const void, const void*))
	{
	if (!vars)
	return;

	if (cmp)
	qsort(vars->arr_data, vars->arr_num, sizeof(void*), cmp);
	else if (order)
	qsort(vars->arr_data, vars->arr_num, sizeof(void*), _cmp_arr_val_desc);
	else
	qsort(vars->arr_data, vars->arr_num, sizeof(void*), _cmp_arr_val_asc);
	}

	/*
	* io_sortVarsByKey() - Sorting array with variables by key
	*
	* @vars = Variable array
	* @order = Sort order. If =0 ascend or !=0 descend
	* return: none
	*/
	inline void
	io_sortVarsByKey(array_t * __restrict vars, int order)
	{
	if (!vars)
	return;

	if (order)
	qsort(vars->arr_data, vars->arr_num, sizeof(void*), _cmp_arr_key_desc);
	else
	qsort(vars->arr_data, vars->arr_num, sizeof(void*), _cmp_arr_key_asc);
	}

	/*
	* io_findKeyVars() - Find variable by key from array
	*
	* @vars = Variables
	* @key = Search key
	* return: NULL error or not found, !=NULL valid element
	*/
	ait_val_t *
	io_findKeyVars(array_t * __restrict vars, u_short key)
	{
	array_t *tmp;
	ait_val_t *vv, v = NULL;
	register int i;
	const u_char *p;

	if (!vars)
	return NULL;

	if (io_arrayCopy(&tmp, vars) == -1)
	return NULL;
	else
	qsort(tmp->arr_data, tmp->arr_num, sizeof(void*), _cmp_arr_key_asc);

	/* binary search */
	for (p = (const u_char*) tmp->arr_data, i = io_arraySize(tmp); i; i >>= 1) {
	vv = (ait_val_t*) (p + (i >> 1) sizeof(void*));
	if (!(key - AIT_KEY(vv))) { / found! */
	v = *vv;
	break;
	}
	if ((key - AIT_KEY(vv)) > 0) { / move right key > current */
	p = (const u_char) vv + sizeof(void);
	i--;
	} /* else move left */
	}

	io_arrayDestroy(&tmp);
	return v;
}	}

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

Removed from v.1.5
changed lines
	Added in v.1.10.2.1