[thirdparty/u-boot.git] / env / attr.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2012
 * Joe Hershberger, National Instruments, joe.hershberger@ni.com
 */

#ifdef USE_HOSTCC /* Eliminate "ANSI does not permit..." warnings */
#include <stdint.h>
#include <stdio.h>
#include <linux/linux_string.h>
#else
#include <common.h>
#include <slre.h>
#endif

#include <env_attr.h>
#include <errno.h>
#include <linux/string.h>
#include <malloc.h>

/*
 * Iterate through the whole list calling the callback for each found element.
 * "attr_list" takes the form:
 *	attributes = [^,:\s]*
 *	entry = name[:attributes]
 *	list = entry[,list]
 */
int env_attr_walk(const char *attr_list,
	int (*callback)(const char *name, const char *attributes, void *priv),
	void *priv)
{
	const char *entry, *entry_end;
	char *name, *attributes;

	if (!attr_list)
		/* list not found */
		return 1;

	entry = attr_list;
	do {
		char *entry_cpy = NULL;

		entry_end = strchr(entry, ENV_ATTR_LIST_DELIM);
		/* check if this is the last entry in the list */
		if (entry_end == NULL) {
			int entry_len = strlen(entry);

			if (entry_len) {
				/*
				 * allocate memory to copy the entry into since
				 * we will need to inject '\0' chars and squash
				 * white-space before calling the callback
				 */
				entry_cpy = malloc(entry_len + 1);
				if (entry_cpy)
					/* copy the rest of the list */
					strcpy(entry_cpy, entry);
				else
					return -ENOMEM;
			}
		} else {
			int entry_len = entry_end - entry;

			if (entry_len) {
				/*
				 * allocate memory to copy the entry into since
				 * we will need to inject '\0' chars and squash
				 * white-space before calling the callback
				 */
				entry_cpy = malloc(entry_len + 1);
				if (entry_cpy) {
					/* copy just this entry and null term */
					strncpy(entry_cpy, entry, entry_len);
					entry_cpy[entry_len] = '\0';
				} else
					return -ENOMEM;
			}
		}

		/* check if there is anything to process (e.g. not ",,,") */
		if (entry_cpy != NULL) {
			attributes = strchr(entry_cpy, ENV_ATTR_SEP);
			/* check if there is a ':' */
			if (attributes != NULL) {
				/* replace the ':' with '\0' to term name */
				*attributes++ = '\0';
				/* remove white-space from attributes */
				attributes = strim(attributes);
			}
			/* remove white-space from name */
			name = strim(entry_cpy);

			/* only call the callback if there is a name */
			if (strlen(name) != 0) {
				int retval = 0;

				retval = callback(name, attributes, priv);
				if (retval) {
					free(entry_cpy);
					return retval;
				}
			}
		}

		free(entry_cpy);
		entry = entry_end + 1;
	} while (entry_end != NULL);

	return 0;
}

#if defined(CONFIG_REGEX)
struct regex_callback_priv {
	const char *searched_for;
	char *regex;
	char *attributes;
};

static int regex_callback(const char *name, const char *attributes, void *priv)
{
	int retval = 0;
	struct regex_callback_priv *cbp = (struct regex_callback_priv *)priv;
	struct slre slre;
	char regex[strlen(name) + 3];

	/* Require the whole string to be described by the regex */
	sprintf(regex, "^%s$", name);
	if (slre_compile(&slre, regex)) {
		struct cap caps[slre.num_caps + 2];

		if (slre_match(&slre, cbp->searched_for,
			       strlen(cbp->searched_for), caps)) {
			free(cbp->regex);
			if (!attributes) {
				retval = -EINVAL;
				goto done;
			}
			cbp->regex = malloc(strlen(regex) + 1);
			if (cbp->regex) {
				strcpy(cbp->regex, regex);
			} else {
				retval = -ENOMEM;
				goto done;
			}

			free(cbp->attributes);
			cbp->attributes = malloc(strlen(attributes) + 1);
			if (cbp->attributes) {
				strcpy(cbp->attributes, attributes);
			} else {
				retval = -ENOMEM;
				free(cbp->regex);
				cbp->regex = NULL;
				goto done;
			}
		}
	} else {
		printf("Error compiling regex: %s\n", slre.err_str);
		retval = -EINVAL;
	}
done:
	return retval;
}

/*
 * Retrieve the attributes string associated with a single name in the list
 * There is no protection on attributes being too small for the value
 */
int env_attr_lookup(const char *attr_list, const char *name, char *attributes)
{
	if (!attributes)
		/* bad parameter */
		return -EINVAL;
	if (!attr_list)
		/* list not found */
		return -EINVAL;

	struct regex_callback_priv priv;
	int retval;

	priv.searched_for = name;
	priv.regex = NULL;
	priv.attributes = NULL;
	retval = env_attr_walk(attr_list, regex_callback, &priv);
	if (retval)
		return retval; /* error */

	if (priv.regex) {
		strcpy(attributes, priv.attributes);
		free(priv.attributes);
		free(priv.regex);
		/* success */
		return 0;
	}
	return -ENOENT; /* not found in list */
}
#else

/*
 * Search for the last exactly matching name in an attribute list
 */
static int reverse_name_search(const char *searched, const char *search_for,
	const char **result)
{
	int result_size = 0;
	const char *cur_searched = searched;

	if (result)
		*result = NULL;

	if (*search_for == '\0') {
		if (result)
			*result = searched;
		return strlen(searched);
	}

	for (;;) {
		const char *match = strstr(cur_searched, search_for);
		const char *prevch;
		const char *nextch;

		/* Stop looking if no new match is found */
		if (match == NULL)
			break;

		prevch = match - 1;
		nextch = match + strlen(search_for);

		/* Skip spaces */
		while (*prevch == ' ' && prevch >= searched)
			prevch--;
		while (*nextch == ' ')
			nextch++;

		/* Start looking past the current match so last is found */
		cur_searched = match + 1;
		/* Check for an exact match */
		if (match != searched &&
		    *prevch != ENV_ATTR_LIST_DELIM &&
		    prevch != searched - 1)
			continue;
		if (*nextch != ENV_ATTR_SEP &&
		    *nextch != ENV_ATTR_LIST_DELIM &&
		    *nextch != '\0')
			continue;

		if (result)
			*result = match;
		result_size = strlen(search_for);
	}

	return result_size;
}

/*
 * Retrieve the attributes string associated with a single name in the list
 * There is no protection on attributes being too small for the value
 */
int env_attr_lookup(const char *attr_list, const char *name, char *attributes)
{
	const char *entry = NULL;
	int entry_len;

	if (!attributes)
		/* bad parameter */
		return -EINVAL;
	if (!attr_list)
		/* list not found */
		return -EINVAL;

	entry_len = reverse_name_search(attr_list, name, &entry);
	if (entry != NULL) {
		int len;

		/* skip the name */
		entry += entry_len;
		/* skip spaces */
		while (*entry == ' ')
			entry++;
		if (*entry != ENV_ATTR_SEP)
			len = 0;
		else {
			const char *delim;
			static const char delims[] = {
				ENV_ATTR_LIST_DELIM, ' ', '\0'};

			/* skip the attr sep */
			entry += 1;
			/* skip spaces */
			while (*entry == ' ')
				entry++;

			delim = strpbrk(entry, delims);
			if (delim == NULL)
				len = strlen(entry);
			else
				len = delim - entry;
			memcpy(attributes, entry, len);
		}
		attributes[len] = '\0';

		/* success */
		return 0;
	}

	/* not found in list */
	return -ENOENT;
}
#endif
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
170ab110 JH	2	/*
	3	* (C) Copyright 2012
	4	* Joe Hershberger, National Instruments, joe.hershberger@ni.com
170ab110 JH	5	*/
170ab110 JH	6
30fd4fad JH	7	#ifdef USE_HOSTCC /* Eliminate "ANSI does not permit..." warnings */
	8	#include <stdint.h>
	9	#include <stdio.h>
	10	#include <linux/linux_string.h>
	11	#else
170ab110	12	#include <common.h>
bdf1fe4e	13	#include <slre.h>
30fd4fad JH	14	#endif
30fd4fad JH	15
170ab110 JH	16	#include <env_attr.h>
	17	#include <errno.h>
	18	#include <linux/string.h>
	19	#include <malloc.h>
	20
	21	/*
	22	* Iterate through the whole list calling the callback for each found element.
	23	* "attr_list" takes the form:
	24	* attributes = [^,:\s]*
	25	* entry = name[:attributes]
	26	* list = entry[,list]
	27	*/
	28	int env_attr_walk(const char *attr_list,
cca98fd6 JH	29	int (callback)(const char name, const char attributes, void priv),
cca98fd6 JH	30	void *priv)
170ab110 JH	31	{
	32	const char entry, entry_end;
	33	char name, attributes;
	34
	35	if (!attr_list)
	36	/* list not found */
	37	return 1;
	38
	39	entry = attr_list;
	40	do {
	41	char *entry_cpy = NULL;
	42
	43	entry_end = strchr(entry, ENV_ATTR_LIST_DELIM);
	44	/* check if this is the last entry in the list */
	45	if (entry_end == NULL) {
	46	int entry_len = strlen(entry);
	47
	48	if (entry_len) {
	49	/*
	50	* allocate memory to copy the entry into since
	51	* we will need to inject '\0' chars and squash
	52	* white-space before calling the callback
	53	*/
	54	entry_cpy = malloc(entry_len + 1);
	55	if (entry_cpy)
	56	/* copy the rest of the list */
	57	strcpy(entry_cpy, entry);
	58	else
	59	return -ENOMEM;
	60	}
	61	} else {
	62	int entry_len = entry_end - entry;
	63
	64	if (entry_len) {
	65	/*
	66	* allocate memory to copy the entry into since
	67	* we will need to inject '\0' chars and squash
	68	* white-space before calling the callback
	69	*/
	70	entry_cpy = malloc(entry_len + 1);
	71	if (entry_cpy) {
	72	/* copy just this entry and null term */
	73	strncpy(entry_cpy, entry, entry_len);
	74	entry_cpy[entry_len] = '\0';
	75	} else
	76	return -ENOMEM;
	77	}
	78	}
	79
	80	/* check if there is anything to process (e.g. not ",,,") */
	81	if (entry_cpy != NULL) {
	82	attributes = strchr(entry_cpy, ENV_ATTR_SEP);
	83	/* check if there is a ':' */
	84	if (attributes != NULL) {
	85	/* replace the ':' with '\0' to term name */
	86	*attributes++ = '\0';
	87	/* remove white-space from attributes */
	88	attributes = strim(attributes);
	89	}
	90	/* remove white-space from name */
	91	name = strim(entry_cpy);
	92
	93	/* only call the callback if there is a name */
	94	if (strlen(name) != 0) {
95	int retval = 0;
96
cca98fd6	97	retval = callback(name, attributes, priv);
170ab110 JH	98	if (retval) {
	99	free(entry_cpy);
	100	return retval;
	101	}
	102	}
	103	}
	104
	105	free(entry_cpy);
	106	entry = entry_end + 1;
	107	} while (entry_end != NULL);
	108
	109	return 0;
	110	}
	111
bdf1fe4e JH	112	#if defined(CONFIG_REGEX)
	113	struct regex_callback_priv {
	114	const char *searched_for;
	115	char *regex;
	116	char *attributes;
	117	};
	118
	119	static int regex_callback(const char name, const char attributes, void *priv)
	120	{
	121	int retval = 0;
	122	struct regex_callback_priv cbp = (struct regex_callback_priv )priv;
	123	struct slre slre;
	124	char regex[strlen(name) + 3];
	125
	126	/* Require the whole string to be described by the regex */
	127	sprintf(regex, "^%s$", name);
	128	if (slre_compile(&slre, regex)) {
	129	struct cap caps[slre.num_caps + 2];
	130
	131	if (slre_match(&slre, cbp->searched_for,
	132	strlen(cbp->searched_for), caps)) {
	133	free(cbp->regex);
902f5bcf HS	134	if (!attributes) {
	135	retval = -EINVAL;
	136	goto done;
	137	}
bdf1fe4e JH	138	cbp->regex = malloc(strlen(regex) + 1);
	139	if (cbp->regex) {
	140	strcpy(cbp->regex, regex);
	141	} else {
	142	retval = -ENOMEM;
	143	goto done;
	144	}
	145
	146	free(cbp->attributes);
	147	cbp->attributes = malloc(strlen(attributes) + 1);
	148	if (cbp->attributes) {
	149	strcpy(cbp->attributes, attributes);
	150	} else {
	151	retval = -ENOMEM;
	152	free(cbp->regex);
	153	cbp->regex = NULL;
	154	goto done;
	155	}
	156	}
	157	} else {
	158	printf("Error compiling regex: %s\n", slre.err_str);
9b57e252	159	retval = -EINVAL;
bdf1fe4e JH	160	}
	161	done:
	162	return retval;
	163	}
	164
	165	/*
	166	* Retrieve the attributes string associated with a single name in the list
	167	* There is no protection on attributes being too small for the value
	168	*/
	169	int env_attr_lookup(const char attr_list, const char name, char *attributes)
	170	{
	171	if (!attributes)
	172	/* bad parameter */
	173	return -EINVAL;
	174	if (!attr_list)
	175	/* list not found */
	176	return -EINVAL;
	177
	178	struct regex_callback_priv priv;
	179	int retval;
	180
	181	priv.searched_for = name;
	182	priv.regex = NULL;
	183	priv.attributes = NULL;
	184	retval = env_attr_walk(attr_list, regex_callback, &priv);
	185	if (retval)
	186	return retval; /* error */
	187
	188	if (priv.regex) {
	189	strcpy(attributes, priv.attributes);
	190	free(priv.attributes);
	191	free(priv.regex);
	192	/* success */
	193	return 0;
	194	}
	195	return -ENOENT; /* not found in list */
	196	}
	197	#else
	198
170ab110	199	/*
032ea185	200	* Search for the last exactly matching name in an attribute list
170ab110	201	*/
032ea185 JH	202	static int reverse_name_search(const char searched, const char search_for,
032ea185 JH	203	const char **result)
170ab110	204	{
032ea185 JH	205	int result_size = 0;
032ea185 JH	206	const char *cur_searched = searched;
170ab110	207
032ea185 JH	208	if (result)
	209	*result = NULL;
	210
	211	if (*search_for == '\0') {
	212	if (result)
	213	*result = searched;
	214	return strlen(searched);
	215	}
170ab110 JH	216
170ab110 JH	217	for (;;) {
032ea185 JH	218	const char *match = strstr(cur_searched, search_for);
	219	const char *prevch;
	220	const char *nextch;
	221
	222	/* Stop looking if no new match is found */
	223	if (match == NULL)
170ab110 JH	224	break;
170ab110 JH	225
032ea185 JH	226	prevch = match - 1;
	227	nextch = match + strlen(search_for);
	228
	229	/* Skip spaces */
	230	while (*prevch == ' ' && prevch >= searched)
	231	prevch--;
	232	while (*nextch == ' ')
	233	nextch++;
	234
	235	/* Start looking past the current match so last is found */
	236	cur_searched = match + 1;
	237	/* Check for an exact match */
	238	if (match != searched &&
	239	*prevch != ENV_ATTR_LIST_DELIM &&
	240	prevch != searched - 1)
	241	continue;
	242	if (*nextch != ENV_ATTR_SEP &&
	243	*nextch != ENV_ATTR_LIST_DELIM &&
	244	*nextch != '\0')
	245	continue;
	246
	247	if (result)
	248	*result = match;
	249	result_size = strlen(search_for);
170ab110 JH	250	}
170ab110 JH	251
032ea185	252	return result_size;
170ab110 JH	253	}
	254
	255	/*
	256	* Retrieve the attributes string associated with a single name in the list
	257	* There is no protection on attributes being too small for the value
	258	*/
	259	int env_attr_lookup(const char attr_list, const char name, char *attributes)
	260	{
	261	const char *entry = NULL;
032ea185	262	int entry_len;
170ab110 JH	263
	264	if (!attributes)
	265	/* bad parameter */
7a0ad2cc	266	return -EINVAL;
170ab110 JH	267	if (!attr_list)
170ab110 JH	268	/* list not found */
7a0ad2cc	269	return -EINVAL;
170ab110	270
032ea185	271	entry_len = reverse_name_search(attr_list, name, &entry);
170ab110 JH	272	if (entry != NULL) {
	273	int len;
	274
	275	/* skip the name */
032ea185	276	entry += entry_len;
170ab110 JH	277	/* skip spaces */
	278	while (*entry == ' ')
	279	entry++;
	280	if (*entry != ENV_ATTR_SEP)
	281	len = 0;
	282	else {
	283	const char *delim;
	284	static const char delims[] = {
	285	ENV_ATTR_LIST_DELIM, ' ', '\0'};
	286
	287	/* skip the attr sep */
	288	entry += 1;
	289	/* skip spaces */
	290	while (*entry == ' ')
	291	entry++;
	292
	293	delim = strpbrk(entry, delims);
	294	if (delim == NULL)
	295	len = strlen(entry);
	296	else
	297	len = delim - entry;
	298	memcpy(attributes, entry, len);
	299	}
	300	attributes[len] = '\0';
	301
	302	/* success */
	303	return 0;
	304	}
	305
	306	/* not found in list */
7a0ad2cc	307	return -ENOENT;
170ab110	308	}
bdf1fe4e	309	#endif