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.3 and 1.21

version 1.6.4.3, 2012/04/02 15:39:55	version 1.21, 2025/10/09 16:43:05
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;

if (!cfg)	if (!cfg)
return NULL;	return NULL;
Line 58 _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) {
struct tagCfg *av;	c = RB_NFIND(tagRC, cfg, &fav);
	if (!c)
RB_FOREACH(av, tagRC, cfg) {	return NULL; /* not found */
printf("sec=%s(%d) attr=%s(%d) val=%s\n", AIT_GET_LIKE(&av->cfg_sec, char*), AIT_KEY(&av->cfg_sec),	if (csSec && !AIT_ISEMPTY(&c->cfg_sec) &&
AIT_GET_LIKE(&av->cfg_attr, char*), AIT_KEY(&av->cfg_attr), AIT_GET_STR(&av->cfg_val));	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);	* cfg_dumpCfg() - dump config data
else	*
return RB_FIND(tagRC, cfg, &fav);	* @cfg = Config root
	* return: none
	*/
	void
	cfg_dumpCfg(cfg_root_t * __restrict cfg)
	{
	struct tagCfg r, c, ctmp, q, *qtmp;
	int syn = 0;

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

	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);
	}
}	}

static inline void	/*
_destroyAttribute(struct tagCfg *av)	* cfg_getSection() - Get entire section attributes into array
	*
	* @cfg = Config root
	* @csSec = Config section //[{csSec}]
	* return: NULL not found or !=NULL allocated array, must free with array_Destroy() after use!
	*/
	array_t *
	cfg_getSection(cfg_root_t * __restrict cfg, const char *csSec)
{	{
if (!av)	array_t *arr = NULL;
return;	struct tagCfg *av, fav;

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

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

	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_delSection() - Delete entire section
	*
	* @cfg = Config root
	* @csSec = Config section //[{csSec}]
	* return: -1 error, 0 nothing deleted or >0 deleted attributes
	*/
	int
	cfg_delSection(cfg_root_t * __restrict cfg, const char *csSec)
	{
	int ret = 0;
	array_t *arr = NULL;
	struct tagCfg *av;
	register int i;

	if (!cfg) {
	cfg_SetErr(EINVAL, "Invalid argument(s)");
	return -1;
	}
	if (csSec && !*csSec)
	csSec = NULL;

	arr = cfg_getSection(cfg, csSec);
	if (!arr)
	return ret;
	for (i = 0; i < array_Size(arr); i++)
	if ((av = array(arr, i, struct tagCfg*)) && AIT_ADDR(&av->cfg_attr))
	if (cfg_unsetAttribute(cfg, csSec, AIT_GET_STR(&av->cfg_attr)) > 0)
	ret++;
	array_Destroy(&arr);
	return ret;
	}

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

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

if (csSec && *csSec)	TAILQ_FOREACH_SAFE(av, cfg, cfg_next, n) {
AIT_KEY(&fav.cfg_sec) = crcFletcher16((u_short*) csSec,
io_align(strlen(csSec), 1) / 2);
if (csAttr)
AIT_KEY(&fav.cfg_attr) = crcFletcher16((u_short*) csAttr,
io_align(strlen(csAttr), 1) / 2);

SLIST_FOREACH(av, cfg, cfg_next) {
++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;
Line 138 cfg_unsetAttribute(cfg_root_t * __restrict cfg, const	Line 268 cfg_unsetAttribute(cfg_root_t * __restrict cfg, const
{	{
struct tagCfg *av;	struct tagCfg *av;

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

av = _selectAttribute(cfg, csSec, csAttr);	av = _selectAttribute(cfg, csSec, csAttr);
Line 147 cfg_unsetAttribute(cfg_root_t * __restrict cfg, const	Line 277 cfg_unsetAttribute(cfg_root_t * __restrict cfg, const

CFG_RC_LOCK(cfg);	CFG_RC_LOCK(cfg);
RB_REMOVE(tagRC, cfg, av);	RB_REMOVE(tagRC, cfg, av);
SLIST_REMOVE(cfg, av, tagCfg, cfg_next);	TAILQ_REMOVE(cfg, av, cfg_next);
CFG_RC_UNLOCK(cfg);	CFG_RC_UNLOCK(cfg);

AIT_FREE_VAL(&av->cfg_val);	AIT_FREE_VAL(&av->cfg_val);
AIT_FREE_VAL(&av->cfg_attr);	AIT_FREE_VAL(&av->cfg_attr);
AIT_FREE_VAL(&av->cfg_sec);	AIT_FREE_VAL(&av->cfg_sec);
free(av);	e_free(av);
return 1;	return 1;
}	}

Line 171 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch	Line 301 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
{	{
struct tagCfg av, section;	struct tagCfg av, section;

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

av = _selectAttribute(cfg, csSec, csAttr);	av = _selectAttribute(cfg, csSec, csAttr);
Line 179 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch	Line 309 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
/* adding new element */	/* adding new element */
section = _selectAttribute(cfg, csSec, NULL);	section = _selectAttribute(cfg, csSec, NULL);

av = malloc(sizeof(struct tagCfg));	av = e_malloc(sizeof(struct tagCfg));
if (!av) {	if (!av) {
LOGERR;	LOGERR;
return -1;	return -1;
Line 188 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch	Line 318 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch

CFG_RC_LOCK(cfg);	CFG_RC_LOCK(cfg);
if (!section)	if (!section)
SLIST_INSERT_HEAD(cfg, av, cfg_next);	TAILQ_INSERT_TAIL(cfg, av, cfg_next);
else	else
SLIST_INSERT_AFTER(section, av, cfg_next);	TAILQ_INSERT_BEFORE(section, av, cfg_next);
CFG_RC_UNLOCK(cfg);	CFG_RC_UNLOCK(cfg);
}	}

if (csSec && *csSec) {	if (csSec && *csSec) {
AIT_SET_STR(&av->cfg_sec, csSec);	AIT_SET_STR(&av->cfg_sec, csSec);
AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*),	AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*),
io_align(AIT_LEN(&av->cfg_sec) - 1, 1) / 2);	E_ALIGN(AIT_LEN(&av->cfg_sec) - 1, 2) / 2);
}	}
AIT_SET_STR(&av->cfg_val, csVal);	AIT_SET_STR(&av->cfg_val, csVal ? csVal : "");
AIT_SET_STR(&av->cfg_attr, csAttr);	AIT_SET_STR(&av->cfg_attr, csAttr);
AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*),	AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*),
io_align(AIT_LEN(&av->cfg_attr) - 1, 1) / 2);	E_ALIGN(AIT_LEN(&av->cfg_attr) - 1, 2) / 2);

CFG_RC_LOCK(cfg);	CFG_RC_LOCK(cfg);
RB_INSERT(tagRC, cfg, av);	RB_INSERT(tagRC, cfg, av);
Line 210 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch	Line 340 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
return 2;	return 2;
}	}

if (strcmp((char) csVal, (char) AIT_GET_STR(&av->cfg_val))) {	if (csVal && AIT_ADDR(&av->cfg_val) &&
	strcmp((char) csVal, (char) AIT_GET_STR(&av->cfg_val))) {
/* Update element */	/* Update element */
AIT_FREE_VAL(&av->cfg_val);	AIT_FREE_VAL(&av->cfg_val);
AIT_SET_STR(&av->cfg_val, csVal);	AIT_SET_STR(&av->cfg_val, csVal);
Line 226 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch	Line 357 cfg_setAttribute(cfg_root_t * __restrict cfg, const ch
*	*
* @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 243 cfg_getAttribute(cfg_root_t * __restrict cfg, const ch	Line 374 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.3
changed lines
	Added in v.1.21