// 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
  ", 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