auxlily.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Auxiliary functions that don't fit anywhere else.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  *      The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE auxlily
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 #include <sys/utsname.h>
  43
  44 #ifdef HAVE_GETRANDOM
  45 # include HAVE_GETRANDOM_HEADER
  46 #endif
  47
  48 #ifdef HAVE_SOCKETS
  49 # ifdef HAVE_GETADDRINFO
  50 #  include <sys/socket.h>
  51 # endif
  52
  53 # include <netdb.h>
  54 #endif
  55
  56 #ifndef HAVE_POSIX_RANDOM
  57 union rand_state{
  58    struct rand_arc4{
  59       ui8_t _dat[256];
  60       ui8_t _i;
  61       ui8_t _j;
  62       ui8_t __pad[6];
  63    } a;
  64    ui8_t b8[sizeof(struct rand_arc4)];
  65    ui32_t b32[sizeof(struct rand_arc4) / sizeof(ui32_t)];
  66 };
  67 #endif
  68
  69 #ifdef HAVE_ERRORS
  70 struct a_aux_err_node{
  71    struct a_aux_err_node *ae_next;
  72    struct n_string ae_str;
  73 };
  74 #endif
  75
  76 static ui8_t a_aux_idec_atoi[256] = {
  77    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  78    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  79    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  80    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  81    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x01,
  82    0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0xFF,0xFF,
  83    0xFF,0xFF,0xFF,0xFF,0xFF,0x0A,0x0B,0x0C,0x0D,0x0E,
  84    0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
  85    0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,
  86    0x23,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x0A,0x0B,0x0C,
  87    0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
  88    0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,
  89    0x21,0x22,0x23,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  90    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  91    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  92    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  93    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  94    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  95    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  96    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  97    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  98    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  99    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
 100    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
 101    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
 102    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
 103 };
 104
 105 #define a_X(X) ((ui64_t)-1 / (X))
 106 static ui64_t const a_aux_idec_cutlimit[35] = {
 107    a_X( 2), a_X( 3), a_X( 4), a_X( 5), a_X( 6), a_X( 7), a_X( 8),
 108    a_X( 9), a_X(10), a_X(11), a_X(12), a_X(13), a_X(14), a_X(15),
 109    a_X(16), a_X(17), a_X(18), a_X(19), a_X(20), a_X(21), a_X(22),
 110    a_X(23), a_X(24), a_X(25), a_X(26), a_X(27), a_X(28), a_X(29),
 111    a_X(30), a_X(31), a_X(32), a_X(33), a_X(34), a_X(35), a_X(36)
 112 };
 113 #undef a_X
 114
 115 #ifndef HAVE_POSIX_RANDOM
 116 static union rand_state *a_aux_rand;
 117 #endif
 118
 119 /* Error ring, for `errors' */
 120 #ifdef HAVE_ERRORS
 121 static struct a_aux_err_node *a_aux_err_head, *a_aux_err_tail;
 122 static size_t a_aux_err_cnt, a_aux_err_cnt_noted;
 123 #endif
 124 static size_t a_aux_err_linelen;
 125
 126 /* Our ARC4 random generator with its completely unacademical pseudo
 127  * initialization (shall /dev/urandom fail) */
 128 #ifndef HAVE_POSIX_RANDOM
 129 static void a_aux_rand_init(void);
 130 SINLINE ui8_t a_aux_rand_get8(void);
 131 # ifndef HAVE_GETRANDOM
 132 static ui32_t a_aux_rand_weak(ui32_t seed);
 133 # endif
 134 #endif
 135
 136 #ifndef HAVE_POSIX_RANDOM
 137 static void
 138 a_aux_rand_init(void){
 139 # ifndef HAVE_GETRANDOM
 140 #  ifdef HAVE_CLOCK_GETTIME
 141    struct timespec ts;
 142 #  else
 143    struct timeval ts;
 144 #  endif
 145    union {int fd; size_t i;} u;
 146    ui32_t seed, rnd;
 147 # endif
 148    NYD2_ENTER;
 149
 150    a_aux_rand = smalloc(sizeof *a_aux_rand);
 151
 152 # ifdef HAVE_GETRANDOM
 153    /* getrandom(2) guarantees 256 without EINTR.. */
 154    n_LCTA(sizeof(a_aux_rand->a._dat) <= 256,
 155       "Buffer to large to be served without EINTR error");
 156    for(;;){
 157       ssize_t gr;
 158
 159       gr = HAVE_GETRANDOM(a_aux_rand->a._dat, sizeof a_aux_rand->a._dat);
 160       a_aux_rand->a._i = a_aux_rand->a._dat[a_aux_rand->a._dat[1] ^
 161             a_aux_rand->a._dat[84]];
 162       a_aux_rand->a._j = a_aux_rand->a._dat[a_aux_rand->a._dat[65] ^
 163             a_aux_rand->a._dat[42]];
 164       /* ..but be on the safe side */
 165       if(UICMP(z, gr, ==, sizeof(a_aux_rand->a._dat)))
 166          break;
 167       n_msleep(250, FAL0);
 168    }
 169
 170 # else
 171    if((u.fd = open("/dev/urandom", O_RDONLY)) != -1){
 172       bool_t ok;
 173
 174       ok = (sizeof(a_aux_rand->a._dat) == (size_t)read(u.fd, a_aux_rand->a._dat,
 175             sizeof(a_aux_rand->a._dat)));
 176       close(u.fd);
 177
 178       a_aux_rand->a._i = a_aux_rand->a._dat[a_aux_rand->a._dat[1] ^
 179             a_aux_rand->a._dat[84]];
 180       a_aux_rand->a._j = a_aux_rand->a._dat[a_aux_rand->a._dat[65] ^
 181             a_aux_rand->a._dat[42]];
 182       if(ok)
 183          goto jleave;
 184    }
 185
 186    for(seed = (uintptr_t)a_aux_rand & UI32_MAX, rnd = 21; rnd != 0; --rnd){
 187       for(u.i = n_NELEM(a_aux_rand->b32); u.i-- != 0;){
 188          ui32_t t, k;
 189
 190 #  ifdef HAVE_CLOCK_GETTIME
 191          clock_gettime(CLOCK_REALTIME, &ts);
 192          t = (ui32_t)ts.tv_nsec;
 193 #  else
 194          gettimeofday(&ts, NULL);
 195          t = (ui32_t)ts.tv_usec;
 196 #  endif
 197          if(rnd & 1)
 198             t = (t >> 16) | (t << 16);
 199          a_aux_rand->b32[u.i] ^= a_aux_rand_weak(seed ^ t);
 200          a_aux_rand->b32[t % n_NELEM(a_aux_rand->b32)] ^= seed;
 201          if(rnd == 7 || rnd == 17)
 202             a_aux_rand->b32[u.i] ^= a_aux_rand_weak(seed ^ (ui32_t)ts.tv_sec);
 203          k = a_aux_rand->b32[u.i] % n_NELEM(a_aux_rand->b32);
 204          a_aux_rand->b32[k] ^= a_aux_rand->b32[u.i];
 205          seed ^= a_aux_rand_weak(a_aux_rand->b32[k]);
 206          if((rnd & 3) == 3)
 207             seed ^= nextprime(seed);
 208       }
 209    }
 210
 211    for(u.i = 5 * sizeof(a_aux_rand->b8); u.i != 0; --u.i)
 212       a_aux_rand_get8();
 213 jleave:
 214 # endif /* !HAVE_GETRANDOM */
 215    NYD2_LEAVE;
 216 }
 217
 218 SINLINE ui8_t
 219 a_aux_rand_get8(void){
 220    ui8_t si, sj;
 221
 222    si = a_aux_rand->a._dat[++a_aux_rand->a._i];
 223    sj = a_aux_rand->a._dat[a_aux_rand->a._j += si];
 224    a_aux_rand->a._dat[a_aux_rand->a._i] = sj;
 225    a_aux_rand->a._dat[a_aux_rand->a._j] = si;
 226    return a_aux_rand->a._dat[(ui8_t)(si + sj)];
 227 }
 228
 229 # ifndef HAVE_GETRANDOM
 230 static ui32_t
 231 a_aux_rand_weak(ui32_t seed){
 232    /* From "Random number generators: good ones are hard to find",
 233     * Park and Miller, Communications of the ACM, vol. 31, no. 10,
 234     * October 1988, p. 1195.
 235     * (In fact: FreeBSD 4.7, /usr/src/lib/libc/stdlib/random.c.) */
 236    ui32_t hi;
 237
 238    if(seed == 0)
 239       seed = 123459876;
 240    hi =  seed /  127773;
 241          seed %= 127773;
 242    seed = (seed * 16807) - (hi * 2836);
 243    if((si32_t)seed < 0)
 244       seed += SI32_MAX;
 245    return seed;
 246 }
 247 # endif /* HAVE_GETRANDOM */
 248 #endif /* !HAVE_POSIX_RANDOM */
 249
 250 FL size_t
 251 n_screensize(void){
 252    char const *cp;
 253    uiz_t rv;
 254    NYD2_ENTER;
 255
 256    if((cp = ok_vlook(screen)) != NULL){
 257       n_idec_uiz_cp(&rv, cp, 0, NULL);
 258       if(rv == 0)
 259          rv = n_scrnheight;
 260    }else
 261       rv = n_scrnheight;
 262
 263    if(rv > 2)
 264       rv -= 2;
 265    NYD2_LEAVE;
 266    return rv;
 267 }
 268
 269 FL char const *
 270 n_pager_get(char const **env_addon){
 271    char const *rv;
 272    NYD_ENTER;
 273
 274    rv = ok_vlook(PAGER);
 275
 276    if(env_addon != NULL){
 277       *env_addon = NULL;
 278       /* Update the manual upon any changes:
 279        *    *colour-pager*, $PAGER */
 280       if(strstr(rv, "less") != NULL){
 281          if(getenv("LESS") == NULL)
 282             *env_addon =
 283 #ifdef HAVE_TERMCAP
 284                   (n_psonce & n_PSO_TERMCAP_CA_MODE) ? "LESS=Ri"
 285                      : !(n_psonce & n_PSO_TERMCAP_DISABLE) ? "LESS=FRi" :
 286 #endif
 287                         "LESS=FRXi";
 288       }else if(strstr(rv, "lv") != NULL){
 289          if(getenv("LV") == NULL)
 290             *env_addon = "LV=-c";
 291       }
 292    }
 293    NYD_LEAVE;
 294    return rv;
 295 }
 296
 297 FL void
 298 page_or_print(FILE *fp, size_t lines)
 299 {
 300    int c;
 301    char const *cp;
 302    NYD_ENTER;
 303
 304    fflush_rewind(fp);
 305
 306    if (n_source_may_yield_control() && (cp = ok_vlook(crt)) != NULL) {
 307       size_t rows;
 308
 309       if(*cp == '\0')
 310          rows = (size_t)n_scrnheight;
 311       else
 312          n_idec_uiz_cp(&rows, cp, 0, NULL);
 313
 314       if (rows > 0 && lines == 0) {
 315          while ((c = getc(fp)) != EOF)
 316             if (c == '\n' && ++lines >= rows)
 317                break;
 318          really_rewind(fp);
 319       }
 320
 321       if (lines >= rows) {
 322          char const *env_add[2], *pager;
 323
 324          pager = n_pager_get(&env_add[0]);
 325          env_add[1] = NULL;
 326          run_command(pager, NULL, fileno(fp), COMMAND_FD_PASS, NULL,NULL,NULL,
 327             env_add);
 328          goto jleave;
 329       }
 330    }
 331
 332    while ((c = getc(fp)) != EOF)
 333       putc(c, n_stdout);
 334 jleave:
 335    NYD_LEAVE;
 336 }
 337
 338 FL enum protocol
 339 which_protocol(char const *name) /* XXX (->URL (yet auxlily.c)) */
 340 {
 341    struct stat st;
 342    char const *cp;
 343    char *np;
 344    size_t sz;
 345    enum protocol rv = PROTO_UNKNOWN;
 346    NYD_ENTER;
 347
 348    temporary_protocol_ext = NULL;
 349
 350    if (name[0] == '%' && name[1] == ':')
 351       name += 2;
 352    for (cp = name; *cp && *cp != ':'; cp++)
 353       if (!alnumchar(*cp))
 354          goto jfile;
 355
 356    if (cp[0] == ':' && cp[1] == '/' && cp[2] == '/') {
 357       if (!strncmp(name, "pop3://", 7)) {
 358 #ifdef HAVE_POP3
 359          rv = PROTO_POP3;
 360 #else
 361          n_err(_("No POP3 support compiled in\n"));
 362 #endif
 363       } else if (!strncmp(name, "pop3s://", 8)) {
 364 #if defined HAVE_POP3 && defined HAVE_SSL
 365          rv = PROTO_POP3;
 366 #else
 367 # ifndef HAVE_POP3
 368          n_err(_("No POP3 support compiled in\n"));
 369 # endif
 370 # ifndef HAVE_SSL
 371          n_err(_("No SSL support compiled in\n"));
 372 # endif
 373 #endif
 374       }
 375       goto jleave;
 376    }
 377
 378    /* TODO This is the de facto maildir code and thus belongs into there!
 379     * TODO and: we should have maildir:// and mbox:// pseudo-protos, instead of
 380     * TODO or (more likely) in addition to *newfolders*) */
 381 jfile:
 382    rv = PROTO_FILE;
 383    np = ac_alloc((sz = strlen(name)) + 4 +1);
 384    memcpy(np, name, sz + 1);
 385    if (!stat(name, &st)) {
 386       if (S_ISDIR(st.st_mode) &&
 387             (memcpy(np+sz, "/tmp", 5), !stat(np, &st) && S_ISDIR(st.st_mode)) &&
 388             (memcpy(np+sz, "/new", 5), !stat(np, &st) && S_ISDIR(st.st_mode)) &&
 389             (memcpy(np+sz, "/cur", 5), !stat(np, &st) && S_ISDIR(st.st_mode)))
 390           rv = PROTO_MAILDIR;
 391    } else {
 392       if ((memcpy(np+sz, cp=".gz", 4), !stat(np, &st) && S_ISREG(st.st_mode)) ||
 393             (memcpy(np+sz, cp=".xz",4), !stat(np,&st) && S_ISREG(st.st_mode)) ||
 394             (memcpy(np+sz, cp=".bz2",5), !stat(np, &st) && S_ISREG(st.st_mode)))
 395          temporary_protocol_ext = cp;
 396       else if ((cp = ok_vlook(newfolders)) != NULL &&
 397             !asccasecmp(cp, "maildir"))
 398          rv = PROTO_MAILDIR;
 399    }
 400    ac_free(np);
 401 jleave:
 402    NYD_LEAVE;
 403    return rv;
 404 }
 405
 406 FL char *
 407 n_c_to_hex_base16(char store[3], char c){
 408    static char const itoa16[] = "0123456789ABCDEF";
 409    NYD2_ENTER;
 410
 411    store[2] = '\0';
 412    store[1] = itoa16[(ui8_t)c & 0x0F];
 413    c = ((ui8_t)c >> 4) & 0x0F;
 414    store[0] = itoa16[(ui8_t)c];
 415    NYD2_LEAVE;
 416    return store;
 417 }
 418
 419 FL si32_t
 420 n_c_from_hex_base16(char const hex[2]){
 421    static ui8_t const atoi16[] = {
 422       0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* 0x30-0x37 */
 423       0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 0x38-0x3F */
 424       0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, /* 0x40-0x47 */
 425       0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 0x48-0x4f */
 426       0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 0x50-0x57 */
 427       0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 0x58-0x5f */
 428       0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF  /* 0x60-0x67 */
 429    };
 430    ui8_t i1, i2;
 431    si32_t rv;
 432    NYD2_ENTER;
 433
 434    if ((i1 = (ui8_t)hex[0] - '0') >= n_NELEM(atoi16) ||
 435          (i2 = (ui8_t)hex[1] - '0') >= n_NELEM(atoi16))
 436       goto jerr;
 437    i1 = atoi16[i1];
 438    i2 = atoi16[i2];
 439    if ((i1 | i2) & 0xF0u)
 440       goto jerr;
 441    rv = i1;
 442    rv <<= 4;
 443    rv += i2;
 444 jleave:
 445    NYD2_LEAVE;
 446    return rv;
 447 jerr:
 448    rv = -1;
 449    goto jleave;
 450 }
 451
 452 FL enum n_idec_state
 453 n_idec_buf(void *resp, char const *cbuf, uiz_t clen, ui8_t base,
 454       enum n_idec_mode idm, char const **endptr_or_null){
 455    /* XXX Brute simple and */
 456    ui8_t currc;
 457    ui64_t res, cut;
 458    enum n_idec_state rv;
 459    NYD_ENTER;
 460
 461    idm &= n__IDEC_MODE_MASK;
 462    rv = n_IDEC_STATE_NONE | idm;
 463    res = 0;
 464
 465    if(clen == UIZ_MAX){
 466       if(*cbuf == '\0')
 467          goto jeinval;
 468    }else if(clen == 0)
 469       goto jeinval;
 470
 471    /* Leading WS */
 472    while(spacechar(*cbuf))
 473       if(*++cbuf == '\0' || --clen == 0)
 474          goto jeinval;
 475
 476    /* Check sign */
 477    switch(*cbuf){
 478    case '-':
 479       rv |= n_IDEC_STATE_SEEN_MINUS;
 480       /* FALLTHROUGH */
 481    case '+':
 482       if(*++cbuf == '\0' || --clen == 0)
 483          goto jeinval;
 484       break;
 485    }
 486
 487    /* Base detection/skip */
 488    if(*cbuf != '0'){
 489       if(base == 0)
 490          base = 10;
 491       /* Character must be valid for base */
 492       currc = a_aux_idec_atoi[(ui8_t)*cbuf];
 493       if(currc >= base)
 494          goto jeinval;
 495    }else{
 496       /* 0 always valid as is, fallback base 10 */
 497       if(*++cbuf == '\0' || --clen == 0)
 498          goto jleave;
 499
 500       /* Base "detection" */
 501       if(base == 0 || base == 2 || base == 16){
 502          switch(*cbuf){
 503          case 'x':
 504          case 'X':
 505             if((base & 2) == 0){
 506                base = 0x10;
 507                goto jprefix_skip;
 508             }
 509             break;
 510          case 'b':
 511          case 'B':
 512             if((base & 16) == 0){
 513                base = 2; /* 0b10 */
 514                /* Char after prefix must be valid */
 515 jprefix_skip:
 516                if(*++cbuf == '\0' || --clen == 0)
 517                   goto jeinval;
 518
 519                /* Character must be valid for base, invalid otherwise */
 520                currc = a_aux_idec_atoi[(ui8_t)*cbuf];
 521                if(currc >= base)
 522                   goto jeinval;
 523             }
 524             break;
 525          default:
 526             if(base == 0)
 527                base = 010;
 528             break;
 529          }
 530       }
 531
 532       /* Character must be valid for base, EBASE otherwise */
 533       currc = a_aux_idec_atoi[(ui8_t)*cbuf];
 534       if(currc >= base)
 535          goto jebase;
 536    }
 537
 538    for(cut = a_aux_idec_cutlimit[base - 2];;){
 539       if(res >= cut){
 540          if(res == cut){
 541             res *= base;
 542             if(res > UI64_MAX - currc)
 543                goto jeover;
 544             res += currc;
 545          }else
 546             goto jeover;
 547       }else{
 548          res *= base;
 549          res += currc;
 550       }
 551
 552       if(*++cbuf == '\0' || --clen == 0)
 553          break;
 554
 555       currc = a_aux_idec_atoi[(ui8_t)*cbuf];
 556       if(currc >= base)
 557          goto jebase;
 558    }
 559
 560 jleave:
 561    do{
 562       ui64_t uimask;
 563
 564       switch(rv & n__IDEC_MODE_LIMIT_MASK){
 565       case n_IDEC_MODE_LIMIT_8BIT: uimask = UI8_MAX; break;
 566       case n_IDEC_MODE_LIMIT_16BIT: uimask = UI16_MAX; break;
 567       case n_IDEC_MODE_LIMIT_32BIT: uimask = UI32_MAX; break;
 568       default: uimask = UI64_MAX; break;
 569       }
 570       if(rv & n_IDEC_MODE_SIGNED_TYPE)
 571          uimask >>= 1;
 572
 573       if(res & ~uimask){
 574          if((rv & (n_IDEC_MODE_SIGNED_TYPE | n_IDEC_STATE_SEEN_MINUS)
 575                ) == (n_IDEC_MODE_SIGNED_TYPE | n_IDEC_STATE_SEEN_MINUS)){
 576             if(res > uimask + 1){
 577                res = uimask << 1;
 578                res &= ~uimask;
 579             }else{
 580                res = -res;
 581                break;
 582             }
 583          }else
 584             res = uimask;
 585          if(!(rv & n_IDEC_MODE_LIMIT_NOERROR))
 586             rv |= n_IDEC_STATE_EOVERFLOW;
 587       }else if(rv & n_IDEC_STATE_SEEN_MINUS)
 588          res = -res;
 589    }while(0);
 590
 591    switch(rv & n__IDEC_MODE_LIMIT_MASK){
 592    case n_IDEC_MODE_LIMIT_8BIT:
 593       if(rv & n_IDEC_MODE_SIGNED_TYPE)
 594          *(si8_t*)resp = (si8_t)res;
 595       else
 596          *(ui8_t*)resp = (ui8_t)res;
 597       break;
 598    case n_IDEC_MODE_LIMIT_16BIT:
 599       if(rv & n_IDEC_MODE_SIGNED_TYPE)
 600          *(si16_t*)resp = (si16_t)res;
 601       else
 602          *(ui16_t*)resp = (ui16_t)res;
 603       break;
 604    case n_IDEC_MODE_LIMIT_32BIT:
 605       if(rv & n_IDEC_MODE_SIGNED_TYPE)
 606          *(si32_t*)resp = (si32_t)res;
 607       else
 608          *(ui32_t*)resp = (ui32_t)res;
 609       break;
 610    default:
 611       if(rv & n_IDEC_MODE_SIGNED_TYPE)
 612          *(si64_t*)resp = (si64_t)res;
 613       else
 614          *(ui64_t*)resp = (ui64_t)res;
 615       break;
 616    }
 617
 618    if(endptr_or_null != NULL)
 619       *endptr_or_null = cbuf;
 620    if(*cbuf == '\0' || clen == 0)
 621       rv |= n_IDEC_STATE_CONSUMED;
 622    NYD_LEAVE;
 623    return rv;
 624
 625 jeinval:
 626    rv |= n_IDEC_STATE_EINVAL;
 627    goto j_maxval;
 628 jebase:
 629    /* Not a base error for terminator and whitespace! */
 630    if(*cbuf != '\0' && !spacechar(*cbuf))
 631       rv |= n_IDEC_STATE_EBASE;
 632    goto jleave;
 633
 634 jeover:
 635    /* Overflow error: consume input until bad character or length out */
 636    for(;;){
 637       if(*++cbuf == '\0' || --clen == 0)
 638          break;
 639       currc = a_aux_idec_atoi[(ui8_t)*cbuf];
 640       if(currc >= base)
 641          break;
 642    }
 643
 644    rv |= n_IDEC_STATE_EOVERFLOW;
 645 j_maxval:
 646    if(rv & n_IDEC_MODE_SIGNED_TYPE)
 647       res = (rv & n_IDEC_STATE_SEEN_MINUS) ? (ui64_t)SI64_MIN
 648          : (ui64_t)SI64_MAX;
 649    else
 650       res = UI64_MAX;
 651    rv &= ~n_IDEC_STATE_SEEN_MINUS;
 652    goto jleave;
 653 }
 654
 655 FL ui32_t
 656 torek_hash(char const *name)
 657 {
 658    /* Chris Torek's hash.
 659     * NOTE: need to change *at least* mk-okey-map.pl when changing the
 660     * algorithm!! */
 661    ui32_t h = 0;
 662    NYD_ENTER;
 663
 664    while (*name != '\0') {
 665       h *= 33;
 666       h += *name++;
 667    }
 668    NYD_LEAVE;
 669    return h;
 670 }
 671
 672 FL ui32_t
 673 torek_ihashn(char const *dat, size_t len){
 674    /* See torek_hash() */
 675    char c;
 676    ui32_t h;
 677    NYD_ENTER;
 678
 679    for(h = 0; len > 0 && (c = *dat++) != '\0'; --len)
 680       h = (h * 33) + lowerconv(c);
 681    NYD_LEAVE;
 682    return h;
 683 }
 684
 685 FL ui32_t
 686 nextprime(ui32_t n)
 687 {
 688    static ui32_t const primes[] = {
 689       5, 11, 23, 47, 97, 157, 283,
 690       509, 1021, 2039, 4093, 8191, 16381, 32749, 65521,
 691       131071, 262139, 524287, 1048573, 2097143, 4194301,
 692       8388593, 16777213, 33554393, 67108859, 134217689,
 693       268435399, 536870909, 1073741789, 2147483647
 694    };
 695
 696    ui32_t i, mprime;
 697    NYD_ENTER;
 698
 699    i = (n < primes[n_NELEM(primes) / 4] ? 0
 700          : (n < primes[n_NELEM(primes) / 2] ? n_NELEM(primes) / 4
 701          : n_NELEM(primes) / 2));
 702    do
 703       if ((mprime = primes[i]) > n)
 704          break;
 705    while (++i < n_NELEM(primes));
 706    if (i == n_NELEM(primes) && mprime < n)
 707       mprime = n;
 708    NYD_LEAVE;
 709    return mprime;
 710 }
 711
 712 FL char const *
 713 n_getdeadletter(void){
 714    char const *cp_base, *cp;
 715    NYD_ENTER;
 716
 717    cp_base = NULL;
 718 jredo:
 719    cp = fexpand(ok_vlook(DEAD), FEXP_LOCAL | FEXP_NSHELL);
 720    if(cp == NULL || strlen(cp) >= PATH_MAX){
 721       if(cp_base == NULL){
 722          n_err(_("Failed to expand *DEAD*, setting default (%s): %s\n"),
 723             VAL_DEAD, n_shexp_quote_cp(cp, FAL0));
 724          ok_vclear(DEAD);
 725          goto jredo;
 726       }else{
 727          cp = savecatsep(ok_vlook(TMPDIR), '/', VAL_DEAD_BASENAME);
 728          n_err(_("Cannot expand *DEAD*, using: %s\n"), cp);
 729       }
 730    }
 731    NYD_LEAVE;
 732    return cp;
 733 }
 734
 735 FL char *
 736 nodename(int mayoverride)
 737 {
 738    static char *sys_hostname, *hostname; /* XXX free-at-exit */
 739
 740    struct utsname ut;
 741    char *hn;
 742 #ifdef HAVE_SOCKETS
 743 # ifdef HAVE_GETADDRINFO
 744    struct addrinfo hints, *res;
 745 # else
 746    struct hostent *hent;
 747 # endif
 748 #endif
 749    NYD_ENTER;
 750
 751    if (mayoverride && (hn = ok_vlook(hostname)) != NULL && *hn != '\0') {
 752       ;
 753    } else if ((hn = sys_hostname) == NULL) {
 754       uname(&ut);
 755       hn = ut.nodename;
 756 #ifdef HAVE_SOCKETS
 757 # ifdef HAVE_GETADDRINFO
 758       memset(&hints, 0, sizeof hints);
 759       hints.ai_family = AF_UNSPEC;
 760       hints.ai_flags = AI_CANONNAME;
 761       if (getaddrinfo(hn, NULL, &hints, &res) == 0) {
 762          if (res->ai_canonname != NULL) {
 763             size_t l = strlen(res->ai_canonname) +1;
 764
 765             hn = ac_alloc(l);
 766             memcpy(hn, res->ai_canonname, l);
 767          }
 768          freeaddrinfo(res);
 769       }
 770 # else
 771       hent = gethostbyname(hn);
 772       if (hent != NULL)
 773          hn = hent->h_name;
 774 # endif
 775 #endif
 776       sys_hostname = sstrdup(hn);
 777 #if defined HAVE_SOCKETS && defined HAVE_GETADDRINFO
 778       if (hn != ut.nodename)
 779          ac_free(hn);
 780 #endif
 781       hn = sys_hostname;
 782    }
 783
 784    if (hostname != NULL && hostname != sys_hostname)
 785       free(hostname);
 786    hostname = sstrdup(hn);
 787    NYD_LEAVE;
 788    return hostname;
 789 }
 790
 791 FL char *
 792 getrandstring(size_t length){
 793    struct str b64;
 794    char *data;
 795    size_t i;
 796    NYD_ENTER;
 797
 798 #ifndef HAVE_POSIX_RANDOM
 799    if(a_aux_rand == NULL)
 800       a_aux_rand_init();
 801 #endif
 802
 803    /* We use our base64 encoder with _NOPAD set, so ensure the encoded result
 804     * with PAD stripped is still longer than what the user requests, easy way */
 805    data = n_lofi_alloc(i = length + 3);
 806
 807 #ifndef HAVE_POSIX_RANDOM
 808    while(i-- > 0)
 809       data[i] = (char)a_aux_rand_get8();
 810 #else
 811    {  char *cp;
 812
 813       for(cp = data; i > 0;){
 814          union {ui32_t i4; char c[4];} r;
 815          size_t j;
 816
 817          r.i4 = (ui32_t)arc4random();
 818          switch((j = i & 3)){
 819          case 0:  cp[3] = r.c[3]; j = 4;
 820          case 3:  cp[2] = r.c[2];
 821          case 2:  cp[1] = r.c[1];
 822          default: cp[0] = r.c[0]; break;
 823          }
 824          cp += j;
 825          i -= j;
 826       }
 827    }
 828 #endif
 829
 830    assert(length + 3 < UIZ_MAX / 4);
 831    b64_encode_buf(&b64, data, length + 3,
 832       B64_SALLOC | B64_RFC4648URL | B64_NOPAD);
 833    ac_free(data);
 834
 835    assert(b64.l >= length);
 836    b64.s[length] = '\0';
 837    NYD_LEAVE;
 838    return b64.s;
 839 }
 840
 841 FL si8_t
 842 boolify(char const *inbuf, uiz_t inlen, si8_t emptyrv)
 843 {
 844    si8_t rv;
 845    NYD_ENTER;
 846
 847    assert(inlen == 0 || inbuf != NULL);
 848
 849    if (inlen == UIZ_MAX)
 850       inlen = strlen(inbuf);
 851
 852    if (inlen == 0)
 853       rv = (emptyrv >= 0) ? (emptyrv == 0 ? 0 : 1) : -1;
 854    else {
 855       if ((inlen == 1 && (*inbuf == '1' || *inbuf == 'y' || *inbuf == 'Y')) ||
 856             !ascncasecmp(inbuf, "true", inlen) ||
 857             !ascncasecmp(inbuf, "yes", inlen) ||
 858             !ascncasecmp(inbuf, "on", inlen))
 859          rv = 1;
 860       else if ((inlen == 1 &&
 861                (*inbuf == '0' || *inbuf == 'n' || *inbuf == 'N')) ||
 862             !ascncasecmp(inbuf, "false", inlen) ||
 863             !ascncasecmp(inbuf, "no", inlen) ||
 864             !ascncasecmp(inbuf, "off", inlen))
 865          rv = 0;
 866       else {
 867          ui64_t ib;
 868
 869          if((n_idec_buf(&ib, inbuf, inlen, 0, 0, NULL
 870                   ) & (n_IDEC_STATE_EMASK | n_IDEC_STATE_CONSUMED)
 871                ) != n_IDEC_STATE_CONSUMED)
 872             rv = -1;
 873          else
 874             rv = (ib != 0);
 875       }
 876    }
 877    NYD_LEAVE;
 878    return rv;
 879 }
 880
 881 FL si8_t
 882 quadify(char const *inbuf, uiz_t inlen, char const *prompt, si8_t emptyrv)
 883 {
 884    si8_t rv;
 885    NYD_ENTER;
 886
 887    assert(inlen == 0 || inbuf != NULL);
 888
 889    if (inlen == UIZ_MAX)
 890       inlen = strlen(inbuf);
 891
 892    if (inlen == 0)
 893       rv = (emptyrv >= 0) ? (emptyrv == 0 ? 0 : 1) : -1;
 894    else if ((rv = boolify(inbuf, inlen, -1)) < 0 &&
 895          !ascncasecmp(inbuf, "ask-", 4) &&
 896          (rv = boolify(inbuf + 4, inlen - 4, -1)) >= 0 &&
 897          (n_psonce & n_PSO_INTERACTIVE))
 898       rv = getapproval(prompt, rv);
 899    NYD_LEAVE;
 900    return rv;
 901 }
 902
 903 FL bool_t
 904 n_is_all_or_aster(char const *name){
 905    bool_t rv;
 906    NYD_ENTER;
 907
 908    rv = ((name[0] == '*' && name[1] == '\0') || !asccasecmp(name, "all"));
 909    NYD_LEAVE;
 910    return rv;
 911 }
 912
 913 FL time_t
 914 n_time_epoch(void)
 915 {
 916 #ifdef HAVE_CLOCK_GETTIME
 917    struct timespec ts;
 918 #elif defined HAVE_GETTIMEOFDAY
 919    struct timeval ts;
 920 #endif
 921    time_t rv;
 922    char const *cp;
 923    NYD2_ENTER;
 924
 925    if((cp = ok_vlook(SOURCE_DATE_EPOCH)) != NULL){
 926       ui64_t tib;
 927
 928       (void)/* XXX ?? posnum= */n_idec_ui64_cp(&tib, cp, 0, NULL);
 929       rv = (time_t)tib;
 930       goto jleave;
 931    }
 932
 933 #ifdef HAVE_CLOCK_GETTIME
 934    clock_gettime(CLOCK_REALTIME, &ts);
 935    rv = (time_t)ts.tv_sec;
 936 #elif defined HAVE_GETTIMEOFDAY
 937    gettimeofday(&ts, NULL);
 938    rv = (time_t)ts.tv_sec;
 939 #else
 940    rv = time(NULL);
 941 #endif
 942 jleave:
 943    NYD2_LEAVE;
 944    return rv;
 945 }
 946
 947 FL void
 948 time_current_update(struct time_current *tc, bool_t full_update)
 949 {
 950    NYD_ENTER;
 951    tc->tc_time = n_time_epoch();
 952    if (full_update) {
 953       memcpy(&tc->tc_gm, gmtime(&tc->tc_time), sizeof tc->tc_gm);
 954       memcpy(&tc->tc_local, localtime(&tc->tc_time), sizeof tc->tc_local);
 955       sstpcpy(tc->tc_ctime, ctime(&tc->tc_time));
 956    }
 957    NYD_LEAVE;
 958 }
 959
 960 FL uiz_t
 961 n_msleep(uiz_t millis, bool_t ignint){
 962    uiz_t rv;
 963    NYD2_ENTER;
 964
 965 #ifdef HAVE_NANOSLEEP
 966    /* C99 */{
 967       struct timespec ts, trem;
 968       int i;
 969
 970       ts.tv_sec = millis / 1000;
 971       ts.tv_nsec = (millis %= 1000) * 1000 * 1000;
 972
 973       while((i = nanosleep(&ts, &trem)) != 0 && ignint)
 974          ts = trem;
 975       rv = (i == 0) ? 0 : (trem.tv_sec * 1000) + (trem.tv_nsec / (1000 * 1000));
 976    }
 977
 978 #elif defined HAVE_SLEEP
 979    if((millis /= 1000) == 0)
 980       millis = 1;
 981    while((rv = sleep((unsigned int)millis)) != 0 && ignint)
 982       millis = rv;
 983 #else
 984 # error Configuration should have detected a function for sleeping.
 985 #endif
 986
 987    NYD2_LEAVE;
 988    return rv;
 989 }
 990
 991 FL void
 992 n_err(char const *format, ...){
 993    va_list ap;
 994    NYD2_ENTER;
 995
 996    va_start(ap, format);
 997 #ifdef HAVE_ERRORS
 998    if(n_psonce & n_PSO_INTERACTIVE)
 999       n_verr(format, ap);
1000    else
1001 #endif
1002    {
1003       size_t len;
1004       bool_t doname, doflush;
1005
1006       doflush = FAL0;
1007       while(*format == '\n'){
1008          doflush = TRU1;
1009          putc('\n', n_stderr);
1010          ++format;
1011       }
1012
1013       if((doname = doflush))
1014          a_aux_err_linelen = 0;
1015
1016       if((len = strlen(format)) > 0){
1017          if(doname || a_aux_err_linelen == 0)
1018             fputs(VAL_UAGENT ": ", n_stderr);
1019          vfprintf(n_stderr, format, ap);
1020
1021          /* C99 */{
1022             size_t i = len;
1023             do{
1024                if(format[--len] == '\n'){
1025                   a_aux_err_linelen = (i -= ++len);
1026                   break;
1027                }
1028                ++a_aux_err_linelen;
1029             }while(len > 0);
1030          }
1031       }
1032
1033       if(doflush)
1034          fflush(n_stderr);
1035    }
1036    va_end(ap);
1037    NYD2_LEAVE;
1038 }
1039
1040 FL void
1041 n_verr(char const *format, va_list ap){
1042 #ifdef HAVE_ERRORS
1043    struct a_aux_err_node *enp;
1044 #endif
1045    bool_t doname;
1046    size_t len;
1047    NYD2_ENTER;
1048
1049    doname = FAL0;
1050
1051    while(*format == '\n'){
1052       putc('\n', n_stderr);
1053       doname = TRU1;
1054       ++format;
1055    }
1056
1057    if(doname){
1058       a_aux_err_linelen = 0;
1059 #ifdef HAVE_ERRORS
1060       if(n_psonce & n_PSO_INTERACTIVE){
1061          if((enp = a_aux_err_tail) != NULL &&
1062                (enp->ae_str.s_len > 0 &&
1063                 enp->ae_str.s_dat[enp->ae_str.s_len - 1] != '\n'))
1064             n_string_push_c(&enp->ae_str, '\n');
1065       }
1066 #endif
1067    }
1068
1069    if((len = strlen(format)) == 0)
1070       goto jleave;
1071 #ifdef HAVE_ERRORS
1072    n_pstate |= n_PS_ERRORS_PROMPT;
1073 #endif
1074
1075    if(doname || a_aux_err_linelen == 0)
1076       fputs(VAL_UAGENT ": ", n_stderr);
1077
1078    /* C99 */{
1079       size_t i = len;
1080       do{
1081          if(format[--len] == '\n'){
1082             a_aux_err_linelen = (i -= ++len);
1083             break;
1084          }
1085          ++a_aux_err_linelen;
1086       }while(len > 0);
1087    }
1088
1089 #ifdef HAVE_ERRORS
1090    if(!(n_psonce & n_PSO_INTERACTIVE))
1091 #endif
1092       vfprintf(n_stderr, format, ap);
1093 #ifdef HAVE_ERRORS
1094    else{
1095       int imax, i;
1096       n_LCTAV(ERRORS_MAX > 3);
1097
1098       /* Link it into the `errors' message ring */
1099       if((enp = a_aux_err_tail) == NULL){
1100 jcreat:
1101          enp = smalloc(sizeof *enp);
1102          enp->ae_next = NULL;
1103          n_string_creat(&enp->ae_str);
1104          if(a_aux_err_tail != NULL)
1105             a_aux_err_tail->ae_next = enp;
1106          else
1107             a_aux_err_head = enp;
1108          a_aux_err_tail = enp;
1109          ++a_aux_err_cnt;
1110       }else if(doname ||
1111             (enp->ae_str.s_len > 0 &&
1112              enp->ae_str.s_dat[enp->ae_str.s_len - 1] == '\n')){
1113          if(a_aux_err_cnt < ERRORS_MAX)
1114             goto jcreat;
1115
1116          a_aux_err_head = (enp = a_aux_err_head)->ae_next;
1117          a_aux_err_tail->ae_next = enp;
1118          a_aux_err_tail = enp;
1119          enp->ae_next = NULL;
1120          n_string_trunc(&enp->ae_str, 0);
1121       }
1122
1123 # ifdef HAVE_N_VA_COPY
1124       imax = 64;
1125 # else
1126       imax = n_MIN(LINESIZE, 1024);
1127 # endif
1128       for(i = imax;; imax = ++i /* xxx could wrap, maybe */){
1129 # ifdef HAVE_N_VA_COPY
1130          va_list vac;
1131
1132          n_va_copy(vac, ap);
1133 # else
1134 #  define vac ap
1135 # endif
1136
1137          n_string_resize(&enp->ae_str, (len = enp->ae_str.s_len) + (size_t)i);
1138          i = vsnprintf(&enp->ae_str.s_dat[len], (size_t)i, format, vac);
1139 # ifdef HAVE_N_VA_COPY
1140          va_end(vac);
1141 # else
1142 #  undef vac
1143 # endif
1144          if(i <= 0)
1145             goto jleave;
1146          if(UICMP(z, i, >=, imax)){
1147 # ifdef HAVE_N_VA_COPY
1148             /* XXX Check overflow for upcoming LEN+++i! */
1149             n_string_trunc(&enp->ae_str, len);
1150             continue;
1151 # else
1152             i = (int)strlen(&enp->ae_str.s_dat[len]);
1153 # endif
1154          }
1155          break;
1156       }
1157       n_string_trunc(&enp->ae_str, len + (size_t)i);
1158
1159       fwrite(&enp->ae_str.s_dat[len], 1, (size_t)i, n_stderr);
1160    }
1161 #endif /* HAVE_ERRORS */
1162
1163 jleave:
1164    fflush(n_stderr);
1165    NYD2_LEAVE;
1166 }
1167
1168 FL void
1169 n_err_sighdl(char const *format, ...){ /* TODO sigsafe; obsolete! */
1170    va_list ap;
1171    NYD_X;
1172
1173    va_start(ap, format);
1174    vfprintf(n_stderr, format, ap);
1175    va_end(ap);
1176    fflush(n_stderr);
1177 }
1178
1179 FL void
1180 n_perr(char const *msg, int errval){
1181    int e;
1182    char const *fmt;
1183    NYD2_ENTER;
1184
1185    if(msg == NULL){
1186       fmt = "%s%s\n";
1187       msg = n_empty;
1188    }else
1189       fmt = "%s: %s\n";
1190
1191    e = (errval == 0) ? errno : errval;
1192    n_err(fmt, msg, strerror(e));
1193    if(errval == 0)
1194       errno = e;
1195    NYD2_LEAVE;
1196 }
1197
1198 FL void
1199 n_alert(char const *format, ...){
1200    va_list ap;
1201    NYD2_ENTER;
1202
1203    n_err(a_aux_err_linelen > 0 ? _("\nAlert: ") : _("Alert: "));
1204
1205    va_start(ap, format);
1206    n_verr(format, ap);
1207    va_end(ap);
1208
1209    n_err("\n");
1210    NYD2_LEAVE;
1211 }
1212
1213 FL void
1214 n_panic(char const *format, ...){
1215    va_list ap;
1216    NYD2_ENTER;
1217
1218    if(a_aux_err_linelen > 0){
1219       putc('\n', n_stderr);
1220       a_aux_err_linelen = 0;
1221    }
1222    fprintf(n_stderr, VAL_UAGENT ": Panic: ");
1223
1224    va_start(ap, format);
1225    vfprintf(n_stderr, format, ap);
1226    va_end(ap);
1227
1228    putc('\n', n_stderr);
1229    fflush(n_stderr);
1230    NYD2_LEAVE;
1231    abort(); /* Was exit(n_EXIT_ERR); for a while, but no */
1232 }
1233
1234 #ifdef HAVE_ERRORS
1235 FL int
1236 c_errors(void *v){
1237    char **argv = v;
1238    struct a_aux_err_node *enp;
1239    NYD_ENTER;
1240
1241    if(*argv == NULL)
1242       goto jlist;
1243    if(argv[1] != NULL)
1244       goto jerr;
1245    if(!asccasecmp(*argv, "show"))
1246       goto jlist;
1247    if(!asccasecmp(*argv, "clear"))
1248       goto jclear;
1249 jerr:
1250    fprintf(n_stderr,
1251       _("Synopsis: errors: (<show> or) <clear> the error ring\n"));
1252    v = NULL;
1253 jleave:
1254    NYD_LEAVE;
1255    return (v == NULL) ? !STOP : !OKAY; /* xxx 1:bad 0:good -- do some */
1256
1257 jlist:{
1258       FILE *fp;
1259       size_t i;
1260
1261       if(a_aux_err_head == NULL){
1262          fprintf(n_stderr, _("The error ring is empty\n"));
1263          goto jleave;
1264       }
1265
1266       if((fp = Ftmp(NULL, "errors", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1267             NULL){
1268          fprintf(n_stderr, _("tmpfile"));
1269          v = NULL;
1270          goto jleave;
1271       }
1272
1273       for(i = 0, enp = a_aux_err_head; enp != NULL; enp = enp->ae_next)
1274          fprintf(fp, "%4" PRIuZ ". %s", ++i, n_string_cp(&enp->ae_str));
1275       /* We don't know whether last string ended with NL; be simple XXX */
1276       putc('\n', fp);
1277
1278       page_or_print(fp, 0);
1279       Fclose(fp);
1280    }
1281    /* FALLTHRU */
1282
1283 jclear:
1284    a_aux_err_tail = NULL;
1285    a_aux_err_cnt = a_aux_err_cnt_noted = 0;
1286    a_aux_err_linelen = 0;
1287    while((enp = a_aux_err_head) != NULL){
1288       a_aux_err_head = enp->ae_next;
1289       n_string_gut(&enp->ae_str);
1290       free(enp);
1291    }
1292    goto jleave;
1293 }
1294 #endif /* HAVE_ERRORS */
1295
1296 #ifdef HAVE_REGEX
1297 FL char const *
1298 n_regex_err_to_str(const regex_t *rep, int e){
1299    char *cp;
1300    size_t i;
1301    NYD2_ENTER;
1302
1303    i = regerror(e, rep, NULL, 0) +1;
1304    cp = salloc(i);
1305    regerror(e, rep, cp, i);
1306    NYD2_LEAVE;
1307    return cp;
1308 }
1309 #endif
1310
1311 /* s-it-mode */