libaitcfg/src/queue.c - diff

Return to queue.c CVS log

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

Diff for /libaitcfg/src/queue.c between versions 1.6.4.1 and 1.20

version 1.6.4.1, 2012/04/02 14:39:03	version 1.20, 2025/01/31 00:03:15
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	Copyright 2004 - 2024
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 49 SUCH DAMAGE.	Line 49 SUCH DAMAGE.
static inline struct tagCfg *	static inline struct tagCfg *
_selectAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)	_selectAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)
{	{
struct tagCfg fav;	struct tagCfg fav, c, n;
struct tagCfg *av;

if (!cfg)	if (!cfg)
return NULL;	return NULL;
Line 59 _selectAttribute(cfg_root_t * __restrict cfg, const ch	Line 58 _selectAttribute(cfg_root_t * __restrict cfg, const ch

if (csSec && *csSec)	if (csSec && *csSec)
AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec,	AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec,
io_align(strlen(csSec), 1) / 2);	E_ALIGN(strlen(csSec), 2) / 2);
if (csAttr)	if (csAttr)
AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr,	AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr,
io_align(strlen(csAttr), 1) / 2);	E_ALIGN(strlen(csAttr), 2) / 2);

/*	if (!csAttr) {
RB_FOREACH(av, tagRC, cfg) {	c = RB_NFIND(tagRC, cfg, &fav);
printf("sec=%s(%d) attr=%s(%d) val=%s\n", AIT_GET_LIKE(&av->cfg_sec, char*), AIT_KEY(&av->cfg_sec),	if (!c)
AIT_GET_LIKE(&av->cfg_attr, char*), AIT_KEY(&av->cfg_attr), AIT_GET_STR(&av->cfg_val));	return NULL; /* not found */
	if (csSec && !AIT_ISEMPTY(&c->cfg_sec) &&
	strcmp(csSec, AIT_GET_STR(&c->cfg_sec)))
	TAILQ_FOREACH_SAFE(c, cfg, cfg_next, n) {
	if (!AIT_ISEMPTY(&c->cfg_sec) &&
	!strcmp(csSec, AIT_GET_STR(&c->cfg_sec)))
	break;
	}
	return c;
	} else {
	c = RB_FIND(tagRC, cfg, &fav);
	if (!c)
	return NULL; /* not found */
	/* if cannot find right section */
	if (csSec && !AIT_ISEMPTY(&c->cfg_sec) &&
	strcmp(csSec, AIT_GET_STR(&c->cfg_sec))) {
	TAILQ_FOREACH_SAFE(c, cfg, cfg_next, n) {
	if (!AIT_ISEMPTY(&c->cfg_sec) && csAttr &&
	!strcmp(csSec, AIT_GET_STR(&c->cfg_sec)) &&
	!strcmp(csAttr, AIT_GET_STR(&c->cfg_attr)))
	return c; /* FOUND! */
	}
	return NULL; /* not found */
	}
	do {
	if (!strcmp(AIT_GET_STR(&c->cfg_attr), csAttr))
	return c; /* FOUND! */
	} while ((c = RB_NEXT(tagRC, cfg, c)) && c && !cfg_tree_cmp(c, &fav));
	/* if cannot find right attribute */
	TAILQ_FOREACH_SAFE(c, cfg, cfg_next, n) {
	if ((!csSec && AIT_ISEMPTY(&c->cfg_sec)) \|\|
	(csSec && !AIT_ISEMPTY(&c->cfg_sec) &&
	!strcmp(csSec, AIT_GET_STR(&c->cfg_sec))))
	if (!AIT_ISEMPTY(&c->cfg_attr) && csAttr &&
	!strcmp(csAttr, AIT_GET_STR(&c->cfg_attr)))
	return c; /* FOUND! */
	}
	return NULL; /* not found */
}	}

printf("ssss=%d aaaa=%d\n", AIT_KEY(&fav.cfg_sec), AIT_KEY(&fav.cfg_attr));
*/
if (!csAttr)
return RB_NFIND(tagRC, cfg, &fav);
else
return RB_FIND(tagRC, cfg, &fav);
}	}

static inline void	/* --------------------------------------------------------------- */
_destroyAttribute(struct tagCfg *av)
	/*
	* cfg_dumpCfg() - dump config data
	*
	* @cfg = Config root
	* return: none
	*/
	void
	cfg_dumpCfg(cfg_root_t * __restrict cfg)
{	{
if (!av)	struct tagCfg r, c, ctmp, q, *qtmp;
return;	int syn = 0;

AIT_FREE_VAL(&av->cfg_val);	r = RB_ROOT(cfg);
AIT_FREE_VAL(&av->cfg_attr);	printf("ROOT:: KEY=%.8x [%s] %s=%s\n", ((AIT_KEY(&r->cfg_sec) << 15) \| AIT_KEY(&r->cfg_attr)),
AIT_FREE_VAL(&av->cfg_sec);	AIT_ADDR(&r->cfg_sec), AIT_ADDR(&r->cfg_attr), AIT_ADDR(&r->cfg_val));
free(av);
}

// ----------------------------------------------	RB_FOREACH_SAFE(c, tagRC, cfg, ctmp) {
	syn ^= syn;
	TAILQ_FOREACH_SAFE(q, cfg, cfg_next, qtmp) {
	if (c == q) {
	syn = 42;
	break;
	}
	}

	printf("%s KEY=%.8x [%s] %s=%s sync=%d\n", c == r ? "*" : "",
	((AIT_KEY(&c->cfg_sec) << 15) \| AIT_KEY(&c->cfg_attr)),
	AIT_ADDR(&c->cfg_sec), AIT_ADDR(&c->cfg_attr), AIT_ADDR(&c->cfg_val), syn);
	}
	}

/*	/*
* cfg_findAttribute() - Find attribute position in config file	* cfg_getSection() - Get entire section attributes into array
*	*
* @cfg = Config root	* @cfg = Config root
* @csSec = Config section //[{csSec}]	* @csSec = Config section //[{csSec}]
* @csAttr = Config attribute //{csAttr} = ...	* return: NULL not found or !=NULL allocated array, must free with array_Destroy() after use!
* return: 0 not found item; -1 error: null parameters; >0 position in list
*/	*/
inline int	array_t *
cfg_findAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)	cfg_getSection(cfg_root_t * __restrict cfg, const char *csSec)
{	{
	array_t *arr = NULL;
struct tagCfg *av, fav;	struct tagCfg *av, fav;
register int cx = 0;

if (!cfg \|\| !csAttr) {	if (!cfg) {
cfg_SetErr(EINVAL, "Invalid argument(s)");	cfg_SetErr(EINVAL, "Invalid argument(s)");
return -1;	return NULL;
} else	} else
memset(&fav, 0, sizeof fav);	memset(&fav, 0, sizeof fav);
	if (csSec && !*csSec)
	csSec = NULL;

if (csSec && *csSec)	if (csSec && *csSec)
AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec,	AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec,
io_align(strlen(csSec), 1) / 2);	E_ALIGN(strlen(csSec), 2) / 2);
if (csAttr)
AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr,
io_align(strlen(csAttr), 1) / 2);

SLIST_FOREACH(av, cfg, cfg_next) {	arr = array_Init(0);
	if (!arr) {
	cfg_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
	return NULL;
	}

	TAILQ_FOREACH(av, cfg, cfg_next)
	if (AIT_KEY(&av->cfg_sec) == AIT_KEY(&fav.cfg_sec)) {
	if (!csSec) {
	if (AIT_ISEMPTY(&av->cfg_sec))
	array_Push(arr, av, 0);
	} else {
	if (!AIT_ISEMPTY(&av->cfg_sec) &&
	!strcmp(AIT_GET_STR(&av->cfg_sec), csSec))
	array_Push(arr, av, 0);
	}
	}

	if (!array_Size(arr))
	array_Destroy(&arr);

	return arr;
	}

	/*
	* cfg_findAttribute() - Find attribute position in config file
	*
	* @cfg = Config root
	* @csSec = Config section //[{csSec}]
	* @csAttr = Config attribute //{csAttr} = ...
	* return: 0 not found item, -1 error or >0 position in list
	*/
	int
	cfg_findAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)
	{
	struct tagCfg av, n;
	register int cx = 0;

	if (!cfg) {
	cfg_SetErr(EINVAL, "Invalid argument(s)");
	return -1;
	}

	TAILQ_FOREACH_SAFE(av, cfg, cfg_next, n) {
++cx;	++cx;
if (!cfg_tree_cmp(&fav, av))
return cx;	if ((!csSec && AIT_ISEMPTY(&av->cfg_sec)) \|\|
	(csSec && !AIT_ISEMPTY(&av->cfg_sec) &&
	!strcmp(csSec, AIT_GET_STR(&av->cfg_sec))))
	if (!AIT_ISEMPTY(&av->cfg_attr) && csAttr &&
	!strcmp(csAttr, AIT_GET_STR(&av->cfg_attr)))
	return cx;
}	}

return 0;	return 0;
}	}
#if 0
/*	/*
* cfg_UnsetAttribute() Unset item from config list and free resources	* cfg_unsetAttribute() - Unset item from config and free resources
* @cfg = Head list element	*
	* @cfg = Config root
* @csSec = Config section //[{csSec}], if NULL unset in default section	* @csSec = Config section //[{csSec}], if NULL unset in default section
* @csAttr = Config attribute //{csAttr} = ..., if NULL unset as any attribute	* @csAttr = Config attribute //{csAttr} = ...
* return: 0 item not found, -1 error: null parameters; >0 position in list	* return: 0 item not found, -1 error or 1 removed item
*/	*/
int cfg_UnsetAttribute(sl_config * __restrict cfg, const u_char csSec, const u_char csAttr)	int
	cfg_unsetAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)
{	{
struct tagPair av, curr;	struct tagCfg *av;
register int cx = 0;

if (!cfg \|\| !csAttr)	if (!cfg)
return -1;	return -1;

av = SelectAttribute(cfg, csSec, csAttr);	av = _selectAttribute(cfg, csSec, csAttr);
if (!av)	if (!av)
return 0;	return 0;

// remove element	CFG_RC_LOCK(cfg);
// remove element when is first!	RB_REMOVE(tagRC, cfg, av);
if (cfg->slh_first == av) {	TAILQ_REMOVE(cfg, av, cfg_next);
cfg->slh_first = cfg->slh_first->sle_next;	CFG_RC_UNLOCK(cfg);

DestroyAttribute(av);	AIT_FREE_VAL(&av->cfg_val);
return 1;	AIT_FREE_VAL(&av->cfg_attr);
}	AIT_FREE_VAL(&av->cfg_sec);
// remove element in other cases...	e_free(av);
curr = cfg->slh_first;	return 1;
while (curr->sle_next != av) {
++cx;
curr = curr->sle_next;
}
curr->sle_next = curr->sle_next->sle_next;

DestroyAttribute(av);
return cx;
}	}

/*	/*
* cfg_SetAttribute() Set item in config list or add new item if not exists	* cfg_setAttribute() - Set item in config or adding new item if not exists
* @cfg = Head list element	*
	* @cfg = Config root
* @csSec = Config section //[{csSec}], if NULL set in default section	* @csSec = Config section //[{csSec}], if NULL set in default section
* @csAttr = Config attribute //{csAttr} = ..., if NULL set as any attribute	* @csAttr = Config attribute //{csAttr} = ...
* @csVal = Config value //... = {csVal} to setup	* @csVal = Config value //... = {csVal} to setup
* return: 0 nothing changed, -1 error: not enough memory; 1 find and update item; 2 added new item	* return: 0 nothing changed, -1 error, 1 found and updated item or 2 added new item
*/	*/
int cfg_SetAttribute(sl_config * __restrict cfg, const u_char csSec, const u_char csAttr, const u_char *csVal)	int
	cfg_setAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr, const char *csVal)
{	{
struct tagPair av, section;	struct tagCfg av, section;
int len;

if (!cfg \|\| !csAttr)	if (!cfg \|\| !csAttr)
return -1;	return -1;

av = SelectAttribute(cfg, csSec, csAttr);	av = _selectAttribute(cfg, csSec, csAttr);
if (!av) {	if (!av) {
section = SelectAttribute(cfg, csSec, NULL);	/* adding new element */
	section = _selectAttribute(cfg, csSec, NULL);

av = malloc(sizeof(struct tagPair));	av = e_malloc(sizeof(struct tagCfg));
if (!av) {	if (!av) {
LOGERR;	LOGERR;
return -1;	return -1;
} else {	} else {
memset(av, 0, sizeof(struct tagPair));	memset(av, 0, sizeof(struct tagCfg));

if (!section) {	CFG_RC_LOCK(cfg);
// add new element	if (!section)
av->sle_next = cfg->slh_first;	TAILQ_INSERT_TAIL(cfg, av, cfg_next);
cfg->slh_first = av;	else
} else {	TAILQ_INSERT_BEFORE(section, av, cfg_next);
// add new element in existing section	CFG_RC_UNLOCK(cfg);
av->sle_next = section->sle_next;
section->sle_next = av;
}
}	}
// added section name to element
if (csSec && *csSec) {
len = strlen((char*) csSec) + 1;
av->psSection = malloc(len);
if (!av->psSection) {
LOGERR;
free(av);
return -1;
} else {
strlcpy((char) av->psSection, (char) csSec, len);
}
} else
av->psSection = NULL;

// added attribute to element	if (csSec && *csSec) {
len = strlen((char*) csAttr) + 1;	AIT_SET_STR(&av->cfg_sec, csSec);
av->psAttribute = malloc(len);	AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*),
if (!av->psAttribute) {	E_ALIGN(AIT_LEN(&av->cfg_sec) - 1, 2) / 2);
LOGERR;
free(av->psSection);
free(av);
return -1;
} else {
strlcpy((char) av->psAttribute, (char) csAttr, len);
}	}
// added value to element	AIT_SET_STR(&av->cfg_val, csVal ? csVal : "");
if (csVal && *csVal) {	AIT_SET_STR(&av->cfg_attr, csAttr);
len = strlen((char*) csVal) + 1;	AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*),
av->psValue = malloc(len);	E_ALIGN(AIT_LEN(&av->cfg_attr) - 1, 2) / 2);
if (!av->psValue) {
LOGERR;
free(av->psAttribute);
free(av->psSection);
free(av);
return -1;
} else {
strlcpy((char) av->psValue, (char) csVal, len);
}
} else {
av->psValue = malloc(1);
*av->psValue = 0;
}

// Added new element	CFG_RC_LOCK(cfg);
	RB_INSERT(tagRC, cfg, av);
	CFG_RC_UNLOCK(cfg);
return 2;	return 2;
}	}

if (strcmp((char) csVal, (char) av->psValue)) {	if (csVal && AIT_ADDR(&av->cfg_val) &&
len = strlen((char*) csVal) + 1;	strcmp((char) csVal, (char) AIT_GET_STR(&av->cfg_val))) {
av->psValue = realloc(av->psValue, len);	/* Update element */
strlcpy((char) av->psValue, (char) csVal, len);	AIT_FREE_VAL(&av->cfg_val);
	AIT_SET_STR(&av->cfg_val, csVal);
// Update element
return 1;	return 1;
}	}

// Nothing happens ... finded & values is equal!	/* Nothing happens ... found & values is equal! */
return 0;	return 0;
}	}

#endif

/*	/*
* cfg_getAttribute() - Get item from config and return value from it	* cfg_getAttribute() - Get item from config and return value from it
*	*
* @cfg = Config root	* @cfg = Config root
* @csSec = Config section //[{csSec}], if NULL unset in default section	* @csSec = Config section //[{csSec}], if NULL unset in default section
* @csAttr = Config attribute //{csAttr} = ..., if NULL unset as any attribute	* @csAttr = Config attribute //{csAttr} = ...
* return: NULL item not found or null parameters; !=NULL value const string	* return: NULL item not found or null parameters, !=NULL value const string
*/	*/
inline const char *	const char *
cfg_getAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)	cfg_getAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)
{	{
struct tagCfg *av;	struct tagCfg *av;

if (!cfg \|\| !csAttr)	if (!cfg)
return NULL;	return NULL;

av = _selectAttribute(cfg, csSec, csAttr);	av = _selectAttribute(cfg, csSec, csAttr);
Line 288 cfg_getAttribute(cfg_root_t * __restrict cfg, const ch	Line 341 cfg_getAttribute(cfg_root_t * __restrict cfg, const ch

return AIT_GET_STR(&av->cfg_val);	return AIT_GET_STR(&av->cfg_val);
}	}
#if 0
// --------------------------------------------------------------

/*	/*
* cfg_LoadAttribute() Extended get attribute, if not found item return default value	* cfg_getAttributeLong() - Get item as long from config and return value from it
* @cfg = Head list element	*
	* @cfg = Config root
* @csSec = Config section //[{csSec}], if NULL unset in default section	* @csSec = Config section //[{csSec}], if NULL unset in default section
* @csAttr = Config attribute //{csAttr} = ..., if NULL unset as any attribute	* @csAttr = Config attribute //{csAttr} = ...
* @psVal = Return buffer for item Value //... = {psVal}	* return: value
* @ValLen = Length of buffer //{psVal} for return	*/
* @csDefValue = Default Value for return in //{psVal}, if not found item in config list	long
* return: 0 item not found, -1 error: null parameters; >0 number of copied bytes in //{psVal}	cfg_getAttributeLong(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)
*/
int cfg_LoadAttribute(sl_config * __restrict cfg, const u_char csSec, const u_char csAttr,
u_char * __restrict psVal, int ValLen, const char *csDefValue)
{	{
struct tagPair *av;	const char *str = NULL;

	str = cfg_getAttribute(cfg, csSec, csAttr);
	return strtol(str ? str : "", NULL, 0);
	}

	/*
	* cfg_getAttributeLLong() - Get item as long long from config and return value from it
	*
	* @cfg = Config root
	* @csSec = Config section //[{csSec}], if NULL unset in default section
	* @csAttr = Config attribute //{csAttr} = ...
	* return: value
	*/
	long long
	cfg_getAttributeLLong(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)
	{
	const char *str = NULL;

	str = cfg_getAttribute(cfg, csSec, csAttr);
	return strtoll(str ? str : "", NULL, 0);
	}

	/*
	* cfg_getAttributeDouble() - Get item as double from config and return value from it
	*
	* @cfg = Config root
	* @csSec = Config section //[{csSec}], if NULL unset in default section
	* @csAttr = Config attribute //{csAttr} = ...
	* return: value
	*/
	double
	cfg_getAttributeDouble(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)
	{
	const char *str = NULL;

	str = cfg_getAttribute(cfg, csSec, csAttr);
	return strtod(str ? str : "", NULL);
	}

	/*
	* cfg_getAttributeLDouble() - Get item as long double from config and return value from it
	*
	* @cfg = Config root
	* @csSec = Config section //[{csSec}], if NULL unset in default section
	* @csAttr = Config attribute //{csAttr} = ...
	* return: value
	*/
	long double
	cfg_getAttributeLDouble(cfg_root_t * __restrict cfg, const char csSec, const char csAttr)
	{
	const char *str = NULL;

	str = cfg_getAttribute(cfg, csSec, csAttr);
	return strtold(str ? str : "", NULL);
	}

	/*
	* cfg_loadAttribute() - Get guarded attribute, if not found item return default value
	*
	* @cfg = Config root
	* @csSec = Config section //[{csSec}], if NULL unset in default section
	* @csAttr = Config attribute //{csAttr} = ...
	* @val = Return buffer for item Value //... = {val}
	* @csDefValue = Default Value for return in //{val}, if not found item in config
	* return: 0 item not found, -1 error or >0 number of copied bytes in //{val}
	*/
	int
	cfg_loadAttribute(cfg_root_t * __restrict cfg, const char csSec, const char csAttr,
	ait_val_t * __restrict val, const char *csDefValue)
	{
	struct tagCfg *av;
int ret = 0;	int ret = 0;

if (!cfg \|\| !csAttr \|\| !ValLen \|\| !psVal)	if (!cfg \|\| !val) {
	cfg_SetErr(EINVAL, "Invalid argument(s)");
return -1;	return -1;
	}

av = SelectAttribute(cfg, csSec, csAttr);	AIT_INIT_VAL(val);
	av = _selectAttribute(cfg, csSec, csAttr);
if (!av) {	if (!av) {
	/* not found item */
if (csDefValue) {	if (csDefValue) {
strlcpy((char*) psVal, csDefValue, ValLen);	AIT_SET_STR(val, csDefValue);
ret = strlen((char*) psVal);	ret = AIT_LEN(val);
}	} else
	AIT_INIT_VAL(val);
return ret;	return ret;
}	}

if (!av->psValue \|\| !*av->psValue) {	if (AIT_ISEMPTY(&av->cfg_val) \|\| !AIT_ADDR(&av->cfg_val) \|\|
	!AIT_GET_LIKE(&av->cfg_val, char)) {
	/* empty value */
if (csDefValue) {	if (csDefValue) {
strlcpy((char*) psVal, csDefValue, ValLen);	AIT_SET_STR(val, csDefValue);
ret = strlen((char*) psVal);	ret = AIT_LEN(val);
}	} else
	AIT_INIT_VAL(val);
} else {	} else {
strlcpy((char) psVal, (char) av->psValue, ValLen);	/* copy value */
ret = strlen((char*) psVal);	AIT_SET_STR(val, AIT_GET_STR(&av->cfg_val));
	ret = AIT_LEN(val);
}	}

return ret;	return ret;
}	}
#endif

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

Removed from v.1.6.4.1
changed lines
	Added in v.1.20