blob: 233471f6cb7550203419ca257a75d24544194078 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Kumar Galad0586982008-02-14 20:44:42 -06002/*
3 * Copyright 2008 Freescale Semiconductor, Inc.
Wolfgang Denk855f18e2013-03-23 23:50:34 +00004 * Copyright 2013 Wolfgang Denk <wd@denx.de>
Kumar Galad0586982008-02-14 20:44:42 -06005 */
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>
Roland Gaudigf4f8d8b2021-07-23 12:29:21 +000014#include <ctype.h>
Simon Glassc7694dd2019-08-01 09:46:46 -060015#include <env.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060016#include <log.h>
Simon Glass2c021522020-11-01 14:15:44 -070017#include <malloc.h>
Joe Hershberger2068cea2015-05-11 13:53:13 -050018#include <mapmem.h>
Simon Glass2c021522020-11-01 14:15:44 -070019#include <linux/sizes.h>
Roland Gaudigf4f8d8b2021-07-23 12:29:21 +000020#include "printf.h"
21
22#define MAX_STR_LEN 128
Kumar Galad0586982008-02-14 20:44:42 -060023
Simon Glassf66bee42020-11-01 14:15:43 -070024/**
25 * struct expr_arg: Holds an argument to an expression
26 *
27 * @ival: Integer value (if width is not CMD_DATA_SIZE_STR)
Simon Glass2c021522020-11-01 14:15:44 -070028 * @sval: String value (if width is CMD_DATA_SIZE_STR)
Simon Glassf66bee42020-11-01 14:15:43 -070029 */
30struct expr_arg {
Simon Glass2c021522020-11-01 14:15:44 -070031 union {
32 ulong ival;
33 char *sval;
34 };
Simon Glassf66bee42020-11-01 14:15:43 -070035};
36
37static int get_arg(char *s, int w, struct expr_arg *argp)
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010038{
Simon Glassf66bee42020-11-01 14:15:43 -070039 struct expr_arg arg;
40
Wolfgang Denk482126e2010-06-23 20:50:54 +020041 /*
Joe Hershberger2068cea2015-05-11 13:53:13 -050042 * If the parameter starts with a '*' then assume it is a pointer to
43 * the value we want.
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010044 */
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010045 if (s[0] == '*') {
Joe Hershberger2068cea2015-05-11 13:53:13 -050046 ulong *p;
47 ulong addr;
48 ulong val;
Simon Glass2c021522020-11-01 14:15:44 -070049 int len;
50 char *str;
Joe Hershberger2068cea2015-05-11 13:53:13 -050051
Simon Glass7e5f4602021-07-24 09:03:29 -060052 addr = hextoul(&s[1], NULL);
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010053 switch (w) {
Joe Hershberger2068cea2015-05-11 13:53:13 -050054 case 1:
55 p = map_sysmem(addr, sizeof(uchar));
56 val = (ulong)*(uchar *)p;
57 unmap_sysmem(p);
Simon Glassf66bee42020-11-01 14:15:43 -070058 arg.ival = val;
59 break;
Joe Hershberger2068cea2015-05-11 13:53:13 -050060 case 2:
61 p = map_sysmem(addr, sizeof(ushort));
62 val = (ulong)*(ushort *)p;
63 unmap_sysmem(p);
Simon Glassf66bee42020-11-01 14:15:43 -070064 arg.ival = val;
65 break;
Simon Glass2c021522020-11-01 14:15:44 -070066 case CMD_DATA_SIZE_STR:
67 p = map_sysmem(addr, SZ_64K);
68
69 /* Maximum string length of 64KB plus terminator */
70 len = strnlen((char *)p, SZ_64K) + 1;
71 str = malloc(len);
72 if (!str) {
73 printf("Out of memory\n");
74 return -ENOMEM;
75 }
76 memcpy(str, p, len);
77 str[len - 1] = '\0';
78 unmap_sysmem(p);
79 arg.sval = str;
80 break;
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010081 case 4:
Simon Glass25a43ac2020-11-01 14:15:37 -070082 p = map_sysmem(addr, sizeof(u32));
83 val = *(u32 *)p;
84 unmap_sysmem(p);
Simon Glassf66bee42020-11-01 14:15:43 -070085 arg.ival = val;
86 break;
Joe Hershberger2068cea2015-05-11 13:53:13 -050087 default:
88 p = map_sysmem(addr, sizeof(ulong));
89 val = *p;
90 unmap_sysmem(p);
Simon Glassf66bee42020-11-01 14:15:43 -070091 arg.ival = val;
92 break;
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010093 }
94 } else {
Simon Glass2c021522020-11-01 14:15:44 -070095 if (w == CMD_DATA_SIZE_STR)
96 return -EINVAL;
Simon Glass7e5f4602021-07-24 09:03:29 -060097 arg.ival = hextoul(s, NULL);
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010098 }
Simon Glassf66bee42020-11-01 14:15:43 -070099 *argp = arg;
100
101 return 0;
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +0100102}
103
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000104#ifdef CONFIG_REGEX
105
106#include <slre.h>
107
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000108/*
109 * memstr - Find the first substring in memory
110 * @s1: The string to be searched
111 * @s2: The string to search for
112 *
113 * Similar to and based on strstr(),
114 * but strings do not need to be NUL terminated.
115 */
116static char *memstr(const char *s1, int l1, const char *s2, int l2)
117{
118 if (!l2)
119 return (char *)s1;
120
121 while (l1 >= l2) {
122 l1--;
123 if (!memcmp(s1, s2, l2))
124 return (char *)s1;
125 s1++;
126 }
127 return NULL;
128}
129
Simon Glass56331b22020-11-01 14:15:39 -0700130/**
131 * substitute() - Substitute part of one string with another
132 *
133 * This updates @string so that the first occurrence of @old is replaced with
134 * @new
135 *
136 * @string: String buffer containing string to update at the start
137 * @slen: Pointer to current string length, updated on success
138 * @ssize: Size of string buffer
139 * @old: Old string to find in the buffer (no terminator needed)
140 * @olen: Length of @old excluding terminator
141 * @new: New string to replace @old with
142 * @nlen: Length of @new excluding terminator
Heinrich Schuchardt185f8122022-01-19 18:05:50 +0100143 * Return: pointer to immediately after the copied @new in @string, or NULL if
Simon Glass56331b22020-11-01 14:15:39 -0700144 * no replacement took place
145 */
146static char *substitute(char *string, int *slen, int ssize,
147 const char *old, int olen, const char *new, int nlen)
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000148{
149 char *p = memstr(string, *slen, old, olen);
150
151 if (p == NULL)
152 return NULL;
153
154 debug("## Match at pos %ld: match len %d, subst len %d\n",
155 (long)(p - string), olen, nlen);
156
157 /* make sure replacement matches */
158 if (*slen + nlen - olen > ssize) {
159 printf("## error: substitution buffer overflow\n");
160 return NULL;
161 }
162
163 /* move tail if needed */
164 if (olen != nlen) {
165 int tail, len;
166
167 len = (olen > nlen) ? olen : nlen;
168
169 tail = ssize - (p + len - string);
170
171 debug("## tail len %d\n", tail);
172
173 memmove(p + nlen, p + olen, tail);
174 }
175
Simon Glass56331b22020-11-01 14:15:39 -0700176 /* insert substitute */
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000177 memcpy(p, new, nlen);
178
179 *slen += nlen - olen;
180
181 return p + nlen;
182}
183
Simon Glassd422c772020-11-01 14:15:40 -0700184int setexpr_regex_sub(char *data, uint data_size, char *nbuf, uint nbuf_size,
185 const char *r, const char *s, bool global)
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000186{
187 struct slre slre;
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000188 char *datap = data;
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000189 int res, len, nlen, loop;
190
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000191 if (slre_compile(&slre, r) == 0) {
192 printf("Error compiling regex: %s\n", slre.err_str);
193 return 1;
194 }
195
Simon Glass56331b22020-11-01 14:15:39 -0700196 len = strlen(data);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000197 for (loop = 0;; loop++) {
198 struct cap caps[slre.num_caps + 2];
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000199 const char *old;
200 char *np;
201 int i, olen;
202
203 (void) memset(caps, 0, sizeof(caps));
204
Simon Glass8f4aa7d2020-11-01 14:15:42 -0700205 res = slre_match(&slre, datap, len - (datap - data), caps);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000206
207 debug("Result: %d\n", res);
208
Simon Glass8f4aa7d2020-11-01 14:15:42 -0700209 for (i = 0; i <= slre.num_caps; i++) {
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000210 if (caps[i].len > 0) {
211 debug("Substring %d: [%.*s]\n", i,
212 caps[i].len, caps[i].ptr);
213 }
214 }
215
216 if (res == 0) {
217 if (loop == 0) {
Łukasz Stelmach36b900e2023-08-24 08:10:25 +0200218 debug("%s: No match\n", data);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000219 return 1;
220 } else {
221 break;
222 }
223 }
224
225 debug("## MATCH ## %s\n", data);
226
Simon Glass56331b22020-11-01 14:15:39 -0700227 if (!s)
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000228 return 1;
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000229
230 old = caps[0].ptr;
231 olen = caps[0].len;
Simon Glass95282292020-11-01 14:15:41 -0700232 nlen = strlen(s);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000233
Simon Glass56331b22020-11-01 14:15:39 -0700234 if (nlen + 1 >= nbuf_size) {
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000235 printf("## error: pattern buffer overflow: have %d, need %d\n",
Simon Glass56331b22020-11-01 14:15:39 -0700236 nbuf_size, nlen + 1);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000237 return 1;
238 }
239 strcpy(nbuf, s);
240
241 debug("## SUBST(1) ## %s\n", nbuf);
242
243 /*
244 * Handle back references
245 *
246 * Support for \0 ... \9, where \0 is the
247 * whole matched pattern (similar to &).
248 *
249 * Implementation is a bit simpleminded as
250 * backrefs are substituted sequentially, one
251 * by one. This will lead to somewhat
252 * unexpected results if the replacement
253 * strings contain any \N strings then then
254 * may get substitued, too. We accept this
255 * restriction for the sake of simplicity.
256 */
257 for (i = 0; i < 10; ++i) {
258 char backref[2] = {
259 '\\',
260 '0',
261 };
262
263 if (caps[i].len == 0)
264 break;
265
266 backref[1] += i;
267
268 debug("## BACKREF %d: replace \"%.*s\" by \"%.*s\" in \"%s\"\n",
269 i,
270 2, backref,
271 caps[i].len, caps[i].ptr,
272 nbuf);
273
274 for (np = nbuf;;) {
275 char *p = memstr(np, nlen, backref, 2);
276
277 if (p == NULL)
278 break;
279
280 np = substitute(np, &nlen,
Simon Glass8f4aa7d2020-11-01 14:15:42 -0700281 nbuf_size - (np - nbuf),
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000282 backref, 2,
283 caps[i].ptr, caps[i].len);
284
285 if (np == NULL)
286 return 1;
287 }
288 }
289 debug("## SUBST(2) ## %s\n", nbuf);
290
Simon Glass8f4aa7d2020-11-01 14:15:42 -0700291 datap = substitute(datap, &len, data_size - (datap - data),
292 old, olen, nbuf, nlen);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000293
294 if (datap == NULL)
295 return 1;
296
297 debug("## REMAINDER: %s\n", datap);
298
299 debug("## RESULT: %s\n", data);
300
301 if (!global)
302 break;
303 }
Simon Glass382bee52017-08-03 12:22:09 -0600304 debug("## FINAL (now env_set()) : %s\n", data);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000305
Simon Glass56331b22020-11-01 14:15:39 -0700306 return 0;
307}
308
309#define SLRE_BUFSZ 16384
310#define SLRE_PATSZ 4096
311
312/*
313 * Perform regex operations on a environment variable
314 *
315 * Returns 0 if OK, 1 in case of errors.
316 */
317static int regex_sub_var(const char *name, const char *r, const char *s,
318 const char *t, int global)
319{
320 struct slre slre;
321 char data[SLRE_BUFSZ];
322 char nbuf[SLRE_PATSZ];
323 const char *value;
324 int len;
325 int ret;
326
327 if (!name)
328 return 1;
329
330 if (slre_compile(&slre, r) == 0) {
331 printf("Error compiling regex: %s\n", slre.err_str);
332 return 1;
333 }
334
335 if (!t) {
336 value = env_get(name);
337 if (!value) {
338 printf("## Error: variable \"%s\" not defined\n", name);
339 return 1;
340 }
341 t = value;
342 }
343
344 debug("REGEX on %s=%s\n", name, t);
345 debug("REGEX=\"%s\", SUBST=\"%s\", GLOBAL=%d\n", r, s ? s : "<NULL>",
346 global);
347
348 len = strlen(t);
349 if (len + 1 > SLRE_BUFSZ) {
350 printf("## error: subst buffer overflow: have %d, need %d\n",
351 SLRE_BUFSZ, len + 1);
352 return 1;
353 }
354
355 strcpy(data, t);
356
Simon Glassd422c772020-11-01 14:15:40 -0700357 ret = setexpr_regex_sub(data, SLRE_BUFSZ, nbuf, SLRE_PATSZ, r, s,
358 global);
Simon Glass56331b22020-11-01 14:15:39 -0700359 if (ret)
360 return 1;
361
Łukasz Stelmach36b900e2023-08-24 08:10:25 +0200362 debug("%s=%s\n", name, data);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000363
Simon Glass382bee52017-08-03 12:22:09 -0600364 return env_set(name, data);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000365}
366#endif
367
Simon Glass09140112020-05-10 11:40:03 -0600368static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc,
369 char *const argv[])
Kumar Galad0586982008-02-14 20:44:42 -0600370{
Simon Glassf66bee42020-11-01 14:15:43 -0700371 struct expr_arg aval, bval;
Simon Glass41ef3722013-02-24 17:33:22 +0000372 ulong value;
Simon Glass2c021522020-11-01 14:15:44 -0700373 int ret = 0;
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +0100374 int w;
Kumar Galad0586982008-02-14 20:44:42 -0600375
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000376 /*
Roland Gaudigf4f8d8b2021-07-23 12:29:21 +0000377 * We take 3, 5, or 6 arguments, except fmt operation, which
378 * takes 4 to 8 arguments (limited by _maxargs):
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000379 * 3 : setexpr name value
380 * 5 : setexpr name val1 op val2
381 * setexpr name [g]sub r s
382 * 6 : setexpr name [g]sub r s t
Roland Gaudigf4f8d8b2021-07-23 12:29:21 +0000383 * setexpr name fmt format [val1] [val2] [val3] [val4]
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000384 */
385
Roland Gaudigf4f8d8b2021-07-23 12:29:21 +0000386 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000387 return CMD_RET_USAGE;
Kumar Galad0586982008-02-14 20:44:42 -0600388
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +0100389 w = cmd_get_data_size(argv[0], 4);
390
Simon Glassf66bee42020-11-01 14:15:43 -0700391 if (get_arg(argv[2], w, &aval))
392 return CMD_RET_FAILURE;
Joe Hershberger4823b452012-11-01 16:21:14 +0000393
Roland Gaudigf4f8d8b2021-07-23 12:29:21 +0000394 /* format string assignment: "setexpr name fmt %d value" */
395 if (strcmp(argv[2], "fmt") == 0 && IS_ENABLED(CONFIG_CMD_SETEXPR_FMT)) {
396 char str[MAX_STR_LEN];
397 int result;
398
399 if (argc == 3)
400 return CMD_RET_USAGE;
401
402 result = printf_setexpr(str, sizeof(str), argc - 3, &argv[3]);
403 if (result)
404 return result;
405
406 return env_set(argv[1], str);
407 }
408
409 if (argc == 4 || argc > 6)
410 return CMD_RET_USAGE;
411
Wolfgang Denk103c94b2013-03-23 23:50:33 +0000412 /* plain assignment: "setexpr name value" */
Simon Glass2c021522020-11-01 14:15:44 -0700413 if (argc == 3) {
414 if (w == CMD_DATA_SIZE_STR) {
415 ret = env_set(argv[1], aval.sval);
416 free(aval.sval);
417 } else {
418 ret = env_set_hex(argv[1], aval.ival);
419 }
420
421 return ret;
422 }
Joe Hershberger4823b452012-11-01 16:21:14 +0000423
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000424 /* 5 or 6 args (6 args only with [g]sub) */
425#ifdef CONFIG_REGEX
426 /*
427 * rexep handling: "setexpr name [g]sub r s [t]"
428 * with 5 args, "t" will be NULL
429 */
430 if (strcmp(argv[2], "gsub") == 0)
Simon Glass56331b22020-11-01 14:15:39 -0700431 return regex_sub_var(argv[1], argv[3], argv[4], argv[5], 1);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000432
433 if (strcmp(argv[2], "sub") == 0)
Simon Glass56331b22020-11-01 14:15:39 -0700434 return regex_sub_var(argv[1], argv[3], argv[4], argv[5], 0);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000435#endif
436
Wolfgang Denk103c94b2013-03-23 23:50:33 +0000437 /* standard operators: "setexpr name val1 op val2" */
438 if (argc != 5)
439 return CMD_RET_USAGE;
440
441 if (strlen(argv[3]) != 1)
442 return CMD_RET_USAGE;
443
Simon Glass2c021522020-11-01 14:15:44 -0700444 if (get_arg(argv[4], w, &bval)) {
445 if (w == CMD_DATA_SIZE_STR)
446 free(aval.sval);
Simon Glassf66bee42020-11-01 14:15:43 -0700447 return CMD_RET_FAILURE;
Simon Glass2c021522020-11-01 14:15:44 -0700448 }
Kumar Galad0586982008-02-14 20:44:42 -0600449
Simon Glass2c021522020-11-01 14:15:44 -0700450 if (w == CMD_DATA_SIZE_STR) {
451 int len;
452 char *str;
453
454 switch (argv[3][0]) {
455 case '+':
456 len = strlen(aval.sval) + strlen(bval.sval) + 1;
457 str = malloc(len);
458 if (!str) {
459 printf("Out of memory\n");
460 ret = CMD_RET_FAILURE;
461 } else {
462 /* These were copied out and checked earlier */
463 strcpy(str, aval.sval);
464 strcat(str, bval.sval);
465 ret = env_set(argv[1], str);
466 if (ret)
467 printf("Could not set var\n");
468 free(str);
469 }
470 break;
471 default:
472 printf("invalid op\n");
473 ret = 1;
474 }
475 } else {
Simon Glassf66bee42020-11-01 14:15:43 -0700476 ulong a = aval.ival;
477 ulong b = bval.ival;
478
479 switch (argv[3][0]) {
480 case '|':
481 value = a | b;
482 break;
483 case '&':
484 value = a & b;
485 break;
486 case '+':
487 value = a + b;
488 break;
489 case '^':
490 value = a ^ b;
491 break;
492 case '-':
493 value = a - b;
494 break;
495 case '*':
496 value = a * b;
497 break;
498 case '/':
499 value = a / b;
500 break;
501 case '%':
502 value = a % b;
503 break;
504 default:
505 printf("invalid op\n");
506 return 1;
507 }
508
509 env_set_hex(argv[1], value);
Kumar Galad0586982008-02-14 20:44:42 -0600510 }
511
Simon Glass2c021522020-11-01 14:15:44 -0700512 if (w == CMD_DATA_SIZE_STR) {
513 free(aval.sval);
514 free(bval.sval);
515 }
516
517 return ret;
Kumar Galad0586982008-02-14 20:44:42 -0600518}
519
520U_BOOT_CMD(
Roland Gaudigf4f8d8b2021-07-23 12:29:21 +0000521 setexpr, 8, 0, do_setexpr,
Peter Tyser2fb26042009-01-27 18:03:12 -0600522 "set environment variable as the result of eval expression",
Simon Glass2c021522020-11-01 14:15:44 -0700523 "[.b, .w, .l, .s] name [*]value1 <op> [*]value2\n"
Kumar Galad0586982008-02-14 20:44:42 -0600524 " - set environment variable 'name' to the result of the evaluated\n"
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000525 " expression specified by <op>. <op> can be &, |, ^, +, -, *, /, %\n"
Simon Glass2c021522020-11-01 14:15:44 -0700526 " (for strings only + is supported)\n"
Joe Hershberger4823b452012-11-01 16:21:14 +0000527 " size argument is only meaningful if value1 and/or value2 are\n"
528 " memory addresses (*)\n"
Wolfgang Denk103c94b2013-03-23 23:50:33 +0000529 "setexpr[.b, .w, .l] name [*]value\n"
530 " - load a value into a variable"
Roland Gaudigf4f8d8b2021-07-23 12:29:21 +0000531#ifdef CONFIG_CMD_SETEXPR_FMT
532 "\n"
533 "setexpr name fmt <format> [value1] [value2] [value3] [value4]\n"
534 " - set environment variable 'name' to the result of the bash like\n"
535 " format string evaluation of value."
536#endif
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000537#ifdef CONFIG_REGEX
538 "\n"
539 "setexpr name gsub r s [t]\n"
540 " - For each substring matching the regular expression <r> in the\n"
541 " string <t>, substitute the string <s>. The result is\n"
542 " assigned to <name>. If <t> is not supplied, use the old\n"
543 " value of <name>\n"
544 "setexpr name sub r s [t]\n"
545 " - Just like gsub(), but replace only the first matching substring"
546#endif
Kumar Galad0586982008-02-14 20:44:42 -0600547);