cmd/setexpr.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2008 Freescale Semiconductor, Inc.
   4  * Copyright 2013 Wolfgang Denk <wd@denx.de>
   5  */
   6
   7 /*
   8  * This file provides a shell like 'expr' function to return.
   9  */
  10
  11 #include <common.h>
  12 #include <config.h>
  13 #include <command.h>
  14 #include <mapmem.h>
  15
  16 static ulong get_arg(char *s, int w)
  17 {
  18         /*
  19          * If the parameter starts with a '*' then assume it is a pointer to
  20          * the value we want.
  21          */
  22         if (s[0] == '*') {
  23                 ulong *p;
  24                 ulong addr;
  25                 ulong val;
  26
  27                 addr = simple_strtoul(&s[1], NULL, 16);
  28                 switch (w) {
  29                 case 1:
  30                         p = map_sysmem(addr, sizeof(uchar));
  31                         val = (ulong)*(uchar *)p;
  32                         unmap_sysmem(p);
  33                         return val;
  34                 case 2:
  35                         p = map_sysmem(addr, sizeof(ushort));
  36                         val = (ulong)*(ushort *)p;
  37                         unmap_sysmem(p);
  38                         return val;
  39                 case 4:
  40                 default:
  41                         p = map_sysmem(addr, sizeof(ulong));
  42                         val = *p;
  43                         unmap_sysmem(p);
  44                         return val;
  45                 }
  46         } else {
  47                 return simple_strtoul(s, NULL, 16);
  48         }
  49 }
  50
  51 #ifdef CONFIG_REGEX
  52
  53 #include <slre.h>
  54
  55 #define SLRE_BUFSZ      16384
  56 #define SLRE_PATSZ      4096
  57
  58 /*
  59  * memstr - Find the first substring in memory
  60  * @s1: The string to be searched
  61  * @s2: The string to search for
  62  *
  63  * Similar to and based on strstr(),
  64  * but strings do not need to be NUL terminated.
  65  */
  66 static char *memstr(const char *s1, int l1, const char *s2, int l2)
  67 {
  68         if (!l2)
  69                 return (char *)s1;
  70
  71         while (l1 >= l2) {
  72                 l1--;
  73                 if (!memcmp(s1, s2, l2))
  74                         return (char *)s1;
  75                 s1++;
  76         }
  77         return NULL;
  78 }
  79
  80 static char *substitute(char *string,   /* string buffer */
  81                         int *slen,      /* current string length */
  82                         int ssize,      /* string bufer size */
  83                         const char *old,/* old (replaced) string */
  84                         int olen,       /* length of old string */
  85                         const char *new,/* new (replacement) string */
  86                         int nlen)       /* length of new string */
  87 {
  88         char *p = memstr(string, *slen, old, olen);
  89
  90         if (p == NULL)
  91                 return NULL;
  92
  93         debug("## Match at pos %ld: match len %d, subst len %d\n",
  94                 (long)(p - string), olen, nlen);
  95
  96         /* make sure replacement matches */
  97         if (*slen + nlen - olen > ssize) {
  98                 printf("## error: substitution buffer overflow\n");
  99                 return NULL;
 100         }
 101
 102         /* move tail if needed */
 103         if (olen != nlen) {
 104                 int tail, len;
 105
 106                 len = (olen > nlen) ? olen : nlen;
 107
 108                 tail = ssize - (p + len - string);
 109
 110                 debug("## tail len %d\n", tail);
 111
 112                 memmove(p + nlen, p + olen, tail);
 113         }
 114
 115         /* insert substitue */
 116         memcpy(p, new, nlen);
 117
 118         *slen += nlen - olen;
 119
 120         return p + nlen;
 121 }
 122
 123 /*
 124  * Perform regex operations on a environment variable
 125  *
 126  * Returns 0 if OK, 1 in case of errors.
 127  */
 128 static int regex_sub(const char *name,
 129         const char *r, const char *s, const char *t,
 130         int global)
 131 {
 132         struct slre slre;
 133         char data[SLRE_BUFSZ];
 134         char *datap = data;
 135         const char *value;
 136         int res, len, nlen, loop;
 137
 138         if (name == NULL)
 139                 return 1;
 140
 141         if (slre_compile(&slre, r) == 0) {
 142                 printf("Error compiling regex: %s\n", slre.err_str);
 143                 return 1;
 144         }
 145
 146         if (t == NULL) {
 147                 value = env_get(name);
 148
 149                 if (value == NULL) {
 150                         printf("## Error: variable \"%s\" not defined\n", name);
 151                         return 1;
 152                 }
 153                 t = value;
 154         }
 155
 156         debug("REGEX on %s=%s\n", name, t);
 157         debug("REGEX=\"%s\", SUBST=\"%s\", GLOBAL=%d\n",
 158                 r, s ? s : "<NULL>", global);
 159
 160         len = strlen(t);
 161         if (len + 1 > SLRE_BUFSZ) {
 162                 printf("## error: subst buffer overflow: have %d, need %d\n",
 163                         SLRE_BUFSZ, len + 1);
 164                 return 1;
 165         }
 166
 167         strcpy(data, t);
 168
 169         if (s == NULL)
 170                 nlen = 0;
 171         else
 172                 nlen = strlen(s);
 173
 174         for (loop = 0;; loop++) {
 175                 struct cap caps[slre.num_caps + 2];
 176                 char nbuf[SLRE_PATSZ];
 177                 const char *old;
 178                 char *np;
 179                 int i, olen;
 180
 181                 (void) memset(caps, 0, sizeof(caps));
 182
 183                 res = slre_match(&slre, datap, len, caps);
 184
 185                 debug("Result: %d\n", res);
 186
 187                 for (i = 0; i < slre.num_caps; i++) {
 188                         if (caps[i].len > 0) {
 189                                 debug("Substring %d: [%.*s]\n", i,
 190                                         caps[i].len, caps[i].ptr);
 191                         }
 192                 }
 193
 194                 if (res == 0) {
 195                         if (loop == 0) {
 196                                 printf("%s: No match\n", t);
 197                                 return 1;
 198                         } else {
 199                                 break;
 200                         }
 201                 }
 202
 203                 debug("## MATCH ## %s\n", data);
 204
 205                 if (s == NULL) {
 206                         printf("%s=%s\n", name, t);
 207                         return 1;
 208                 }
 209
 210                 old = caps[0].ptr;
 211                 olen = caps[0].len;
 212
 213                 if (nlen + 1 >= SLRE_PATSZ) {
 214                         printf("## error: pattern buffer overflow: have %d, need %d\n",
 215                                 SLRE_BUFSZ, nlen + 1);
 216                         return 1;
 217                 }
 218                 strcpy(nbuf, s);
 219
 220                 debug("## SUBST(1) ## %s\n", nbuf);
 221
 222                 /*
 223                  * Handle back references
 224                  *
 225                  * Support for \0 ... \9, where \0 is the
 226                  * whole matched pattern (similar to &).
 227                  *
 228                  * Implementation is a bit simpleminded as
 229                  * backrefs are substituted sequentially, one
 230                  * by one.  This will lead to somewhat
 231                  * unexpected results if the replacement
 232                  * strings contain any \N strings then then
 233                  * may get substitued, too.  We accept this
 234                  * restriction for the sake of simplicity.
 235                  */
 236                 for (i = 0; i < 10; ++i) {
 237                         char backref[2] = {
 238                                 '\\',
 239                                 '0',
 240                         };
 241
 242                         if (caps[i].len == 0)
 243                                 break;
 244
 245                         backref[1] += i;
 246
 247                         debug("## BACKREF %d: replace \"%.*s\" by \"%.*s\" in \"%s\"\n",
 248                                 i,
 249                                 2, backref,
 250                                 caps[i].len, caps[i].ptr,
 251                                 nbuf);
 252
 253                         for (np = nbuf;;) {
 254                                 char *p = memstr(np, nlen, backref, 2);
 255
 256                                 if (p == NULL)
 257                                         break;
 258
 259                                 np = substitute(np, &nlen,
 260                                         SLRE_PATSZ,
 261                                         backref, 2,
 262                                         caps[i].ptr, caps[i].len);
 263
 264                                 if (np == NULL)
 265                                         return 1;
 266                         }
 267                 }
 268                 debug("## SUBST(2) ## %s\n", nbuf);
 269
 270                 datap = substitute(datap, &len, SLRE_BUFSZ,
 271                                 old, olen,
 272                                 nbuf, nlen);
 273
 274                 if (datap == NULL)
 275                         return 1;
 276
 277                 debug("## REMAINDER: %s\n", datap);
 278
 279                 debug("## RESULT: %s\n", data);
 280
 281                 if (!global)
 282                         break;
 283         }
 284         debug("## FINAL (now env_set()) :  %s\n", data);
 285
 286         printf("%s=%s\n", name, data);
 287
 288         return env_set(name, data);
 289 }
 290 #endif
 291
 292 static int do_setexpr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 293 {
 294         ulong a, b;
 295         ulong value;
 296         int w;
 297
 298         /*
 299          * We take 3, 5, or 6 arguments:
 300          * 3 : setexpr name value
 301          * 5 : setexpr name val1 op val2
 302          *     setexpr name [g]sub r s
 303          * 6 : setexpr name [g]sub r s t
 304          */
 305
 306         /* > 6 already tested by max command args */
 307         if ((argc < 3) || (argc == 4))
 308                 return CMD_RET_USAGE;
 309
 310         w = cmd_get_data_size(argv[0], 4);
 311
 312         a = get_arg(argv[2], w);
 313
 314         /* plain assignment: "setexpr name value" */
 315         if (argc == 3) {
 316                 env_set_hex(argv[1], a);
 317                 return 0;
 318         }
 319
 320         /* 5 or 6 args (6 args only with [g]sub) */
 321 #ifdef CONFIG_REGEX
 322         /*
 323          * rexep handling: "setexpr name [g]sub r s [t]"
 324          * with 5 args, "t" will be NULL
 325          */
 326         if (strcmp(argv[2], "gsub") == 0)
 327                 return regex_sub(argv[1], argv[3], argv[4], argv[5], 1);
 328
 329         if (strcmp(argv[2], "sub") == 0)
 330                 return regex_sub(argv[1], argv[3], argv[4], argv[5], 0);
 331 #endif
 332
 333         /* standard operators: "setexpr name val1 op val2" */
 334         if (argc != 5)
 335                 return CMD_RET_USAGE;
 336
 337         if (strlen(argv[3]) != 1)
 338                 return CMD_RET_USAGE;
 339
 340         b = get_arg(argv[4], w);
 341
 342         switch (argv[3][0]) {
 343         case '|':
 344                 value = a | b;
 345                 break;
 346         case '&':
 347                 value = a & b;
 348                 break;
 349         case '+':
 350                 value = a + b;
 351                 break;
 352         case '^':
 353                 value = a ^ b;
 354                 break;
 355         case '-':
 356                 value = a - b;
 357                 break;
 358         case '*':
 359                 value = a * b;
 360                 break;
 361         case '/':
 362                 value = a / b;
 363                 break;
 364         case '%':
 365                 value = a % b;
 366                 break;
 367         default:
 368                 printf("invalid op\n");
 369                 return 1;
 370         }
 371
 372         env_set_hex(argv[1], value);
 373
 374         return 0;
 375 }
 376
 377 U_BOOT_CMD(
 378         setexpr, 6, 0, do_setexpr,
 379         "set environment variable as the result of eval expression",
 380         "[.b, .w, .l] name [*]value1 <op> [*]value2\n"
 381         "    - set environment variable 'name' to the result of the evaluated\n"
 382         "      expression specified by <op>.  <op> can be &, |, ^, +, -, *, /, %\n"
 383         "      size argument is only meaningful if value1 and/or value2 are\n"
 384         "      memory addresses (*)\n"
 385         "setexpr[.b, .w, .l] name [*]value\n"
 386         "    - load a value into a variable"
 387 #ifdef CONFIG_REGEX
 388         "\n"
 389         "setexpr name gsub r s [t]\n"
 390         "    - For each substring matching the regular expression <r> in the\n"
 391         "      string <t>, substitute the string <s>.  The result is\n"
 392         "      assigned to <name>.  If <t> is not supplied, use the old\n"
 393         "      value of <name>\n"
 394         "setexpr name sub r s [t]\n"
 395         "    - Just like gsub(), but replace only the first matching substring"
 396 #endif
 397 );