git.sur5r.net Git - u-boot/blob - env/attr.c

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