| /* |
| * (C) Copyright 2012 |
| * Joe Hershberger, National Instruments, joe.hershberger@ni.com |
| * |
| * SPDX-License-Identifier: GPL-2.0+ |
| */ |
| |
| #ifdef USE_HOSTCC /* Eliminate "ANSI does not permit..." warnings */ |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <linux/linux_string.h> |
| #else |
| #include <common.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)) |
| { |
| 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); |
| if (retval) { |
| free(entry_cpy); |
| return retval; |
| } |
| } |
| } |
| |
| free(entry_cpy); |
| entry = entry_end + 1; |
| } while (entry_end != NULL); |
| |
| return 0; |
| } |
| |
| /* |
| * 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; |
| } |