1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2012 4 * Joe Hershberger, National Instruments, joe.hershberger@ni.com 5 */ 6 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 12 #include <common.h> 13 #include <slre.h> 14 #endif 15 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, 29 int (*callback)(const char *name, const char *attributes, void *priv), 30 void *priv) 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 97 retval = callback(name, attributes, priv); 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 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); 134 if (!attributes) { 135 retval = -EINVAL; 136 goto done; 137 } 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); 159 retval = -EINVAL; 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 199 /* 200 * Search for the last exactly matching name in an attribute list 201 */ 202 static int reverse_name_search(const char *searched, const char *search_for, 203 const char **result) 204 { 205 int result_size = 0; 206 const char *cur_searched = searched; 207 208 if (result) 209 *result = NULL; 210 211 if (*search_for == '\0') { 212 if (result) 213 *result = searched; 214 return strlen(searched); 215 } 216 217 for (;;) { 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) 224 break; 225 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); 250 } 251 252 return result_size; 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; 262 int entry_len; 263 264 if (!attributes) 265 /* bad parameter */ 266 return -EINVAL; 267 if (!attr_list) 268 /* list not found */ 269 return -EINVAL; 270 271 entry_len = reverse_name_search(attr_list, name, &entry); 272 if (entry != NULL) { 273 int len; 274 275 /* skip the name */ 276 entry += entry_len; 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 */ 307 return -ENOENT; 308 } 309 #endif 310