timeout(1): fix the acceptable range values for parse_signal()

[alex_kaworu.ch]

Summary

Before this patch, both 0 and sys_nsig would be successfully returned by parse_signal() although being invalid signal numbers.

Test Plan

none

[alex_kaworu.ch]

strtonum(3) says that minval and maxval are inclusive:

      int iterations;
      const char *errstr;

      iterations = strtonum(optarg, 1, 64, &errstr);
      if (errstr != NULL)
              errx(1, "number of iterations is %s: %s", errstr, optarg);

The above example will guarantee that the value of iterations is between
1 and 64 (inclusive).

head/usr.bin/timeout/timeout.c

 void
 load_config(void)
 {
         struct cfjails wild;
         struct cfparams opp;
         struct cfjail *j, *tj, *wj;
         struct cfparam *p, *vp, *tp;
         struct cfstring *s, *vs, *ns;
-        struct cfvar *v;
+        struct cfvar *v, *vv;
         char *ep;
-        size_t varoff;
         int did_self, jseq, pgen;
 
         if (!strcmp(cfname, "-")) {
                 cfname = "STDIN";
                 yyin = stdin;
         } else {
                 yyin = fopen(cfname, "r");
                 if (!yyin)
if (!did_self)
                                 add_param(j, p, 0, NULL);
 
                 /* Resolve any variable substitutions. */
                 pgen = 0;
                 TAILQ_FOREACH(p, &j->params, tq) {
                     p->gen = ++pgen;
                 find_vars:
                     TAILQ_FOREACH(s, &p->val, tq) {
-                        varoff = 0;
                         while ((v = STAILQ_FIRST(&s->vars))) {
                                 TAILQ_FOREACH(vp, &j->params, tq)
                                         if (!strcmp(vp->name, v->name))
                                                 break;
                                 if (!vp) {
                                         jail_warnx(j,
                                             "%s: variable \"%s\" not found",
                                             p->name, v->name);
find_vars:
                                     (s->s[0] != '\0' ||
                                      STAILQ_NEXT(v, tq))) {
                                         jail_warnx(j, "%s: array cannot be "
                                             "substituted inline",
                                             p->name);
                                         goto bad_var;
                                 }
                                 s->s = erealloc(s->s, s->len + vs->len + 1);
-                                memmove(s->s + v->pos + varoff + vs->len,
-                                    s->s + v->pos + varoff,
-                                    s->len - (v->pos + varoff) + 1);
-                                memcpy(s->s + v->pos + varoff, vs->s, vs->len);
-                                varoff += vs->len;
+                                memmove(s->s + v->pos + vs->len,
+                                    s->s + v->pos,
+                                    s->len - v->pos + 1);
+                                memcpy(s->s + v->pos, vs->s, vs->len);
+                                vv = v;
+                                while ((vv = STAILQ_NEXT(vv, tq)))
+                                        vv->pos += vs->len;
                                 s->len += vs->len;
                                 while ((vs = TAILQ_NEXT(vs, tq))) {
                                         ns = emalloc(sizeof(struct cfstring));
                                         ns->s = estrdup(vs->s);
                                         ns->len = vs->len;
                                         STAILQ_INIT(&ns->vars);
                                         TAILQ_INSERT_AFTER(&p->val, s, ns, tq);
                                         s = ns;