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 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   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_SOCKETS
  45 # ifdef HAVE_GETADDRINFO
  46 #  include <sys/socket.h>
  47 # endif
  48
  49 # include <netdb.h>
  50 #endif
  51
  52 #ifndef HAVE_POSIX_RANDOM
  53 union rand_state {
  54    struct rand_arc4 {
  55       ui8_t    __pad[6];
  56       ui8_t    _i;
  57       ui8_t    _j;
  58       ui8_t    _dat[256];
  59    }        a;
  60    ui8_t    b8[sizeof(struct rand_arc4)];
  61    ui32_t   b32[sizeof(struct rand_arc4) / sizeof(ui32_t)];
  62 };
  63 #endif
  64
  65 #ifdef HAVE_ERRORS
  66 struct a_aux_err_node{
  67    struct a_aux_err_node *ae_next;
  68    struct n_string ae_str;
  69 };
  70 #endif
  71
  72 #ifndef HAVE_POSIX_RANDOM
  73 static union rand_state *_rand;
  74 #endif
  75
  76 /* Error ring, for `errors' */
  77 #ifdef HAVE_ERRORS
  78 static struct a_aux_err_node *a_aux_err_head, *a_aux_err_tail;
  79 static size_t a_aux_err_cnt, a_aux_err_cnt_noted;
  80 #endif
  81 static size_t a_aux_err_linelen;
  82
  83 /* Our ARC4 random generator with its completely unacademical pseudo
  84  * initialization (shall /dev/urandom fail) */
  85 #ifndef HAVE_POSIX_RANDOM
  86 static void    _rand_init(void);
  87 static ui32_t  _rand_weak(ui32_t seed);
  88 SINLINE ui8_t  _rand_get8(void);
  89 #endif
  90
  91 #ifndef HAVE_POSIX_RANDOM
  92 static void
  93 _rand_init(void)
  94 {
  95 # ifdef HAVE_CLOCK_GETTIME
  96    struct timespec ts;
  97 # else
  98    struct timeval ts;
  99 # endif
 100    union {int fd; size_t i;} u;
 101    ui32_t seed, rnd;
 102    NYD2_ENTER;
 103
 104    _rand = smalloc(sizeof *_rand);
 105
 106    if ((u.fd = open("/dev/urandom", O_RDONLY)) != -1) {
 107       bool_t ok = (sizeof *_rand == (size_t)read(u.fd, _rand, sizeof *_rand));
 108
 109       close(u.fd);
 110       if (ok)
 111          goto jleave;
 112    }
 113
 114    for (seed = (uintptr_t)_rand & UI32_MAX, rnd = 21; rnd != 0; --rnd) {
 115       for (u.i = NELEM(_rand->b32); u.i-- != 0;) {
 116          size_t t, k;
 117
 118 # ifdef HAVE_CLOCK_GETTIME
 119          clock_gettime(CLOCK_REALTIME, &ts);
 120          t = (ui32_t)ts.tv_nsec;
 121 # else
 122          gettimeofday(&ts, NULL);
 123          t = (ui32_t)ts.tv_usec;
 124 # endif
 125          if (rnd & 1)
 126             t = (t >> 16) | (t << 16);
 127          _rand->b32[u.i] ^= _rand_weak(seed ^ t);
 128          _rand->b32[t % NELEM(_rand->b32)] ^= seed;
 129          if (rnd == 7 || rnd == 17)
 130             _rand->b32[u.i] ^= _rand_weak(seed ^ (ui32_t)ts.tv_sec);
 131          k = _rand->b32[u.i] % NELEM(_rand->b32);
 132          _rand->b32[k] ^= _rand->b32[u.i];
 133          seed ^= _rand_weak(_rand->b32[k]);
 134          if ((rnd & 3) == 3)
 135             seed ^= nextprime(seed);
 136       }
 137    }
 138
 139    for (u.i = 5 * sizeof(_rand->b8); u.i != 0; --u.i)
 140       _rand_get8();
 141 jleave:
 142    NYD2_LEAVE;
 143 }
 144
 145 static ui32_t
 146 _rand_weak(ui32_t seed)
 147 {
 148    /* From "Random number generators: good ones are hard to find",
 149     * Park and Miller, Communications of the ACM, vol. 31, no. 10,
 150     * October 1988, p. 1195.
 151     * (In fact: FreeBSD 4.7, /usr/src/lib/libc/stdlib/random.c.) */
 152    ui32_t hi;
 153
 154    if (seed == 0)
 155       seed = 123459876;
 156    hi =  seed /  127773;
 157          seed %= 127773;
 158    seed = (seed * 16807) - (hi * 2836);
 159    if ((si32_t)seed < 0)
 160       seed += SI32_MAX;
 161    return seed;
 162 }
 163
 164 SINLINE ui8_t
 165 _rand_get8(void)
 166 {
 167    ui8_t si, sj;
 168
 169    si = _rand->a._dat[++_rand->a._i];
 170    sj = _rand->a._dat[_rand->a._j += si];
 171    _rand->a._dat[_rand->a._i] = sj;
 172    _rand->a._dat[_rand->a._j] = si;
 173    return _rand->a._dat[(ui8_t)(si + sj)];
 174 }
 175 #endif /* HAVE_POSIX_RANDOM */
 176
 177 FL int
 178 screensize(void){
 179    ul_i s;
 180    char *cp;
 181    NYD2_ENTER;
 182
 183    if((cp = ok_vlook(screen)) == NULL || (s = strtoul(cp, NULL, 0)) == 0)
 184       s = scrnheight;
 185    s -= 2; /* XXX no magics */
 186    if(s > INT_MAX) /* TODO function should return unsigned */
 187       s = INT_MAX;
 188    NYD2_LEAVE;
 189    return (int)s;
 190 }
 191
 192 FL char const *
 193 n_pager_get(char const **env_addon){
 194    char const *rv;
 195    NYD_ENTER;
 196
 197    rv = ok_vlook(PAGER);
 198
 199    if(env_addon != NULL){
 200       *env_addon = NULL;
 201       /* Update the manual upon any changes:
 202        *    *colour-pager*, $PAGER */
 203       if(strstr(rv, "less") != NULL){
 204          if(getenv("LESS") == NULL)
 205             *env_addon =
 206 #ifdef HAVE_TERMCAP
 207                   (pstate & PS_TERMCAP_CA_MODE) ? "LESS=Ri"
 208                      : !(pstate & PS_TERMCAP_DISABLE) ? "LESS=FRi" :
 209 #endif
 210                         "LESS=FRXi";
 211       }else if(strstr(rv, "lv") != NULL){
 212          if(getenv("LV") == NULL)
 213             *env_addon = "LV=-c";
 214       }
 215    }
 216    NYD_LEAVE;
 217    return rv;
 218 }
 219
 220 FL void
 221 page_or_print(FILE *fp, size_t lines)
 222 {
 223    int c;
 224    char const *cp;
 225    NYD_ENTER;
 226
 227    fflush_rewind(fp);
 228
 229    if (n_source_may_yield_control() && (cp = ok_vlook(crt)) != NULL) {
 230       size_t rows;
 231
 232       rows = (*cp == '\0') ? (size_t)scrnheight : strtoul(cp, NULL, 0);
 233
 234       if (rows > 0 && lines == 0) {
 235          while ((c = getc(fp)) != EOF)
 236             if (c == '\n' && ++lines >= rows)
 237                break;
 238          really_rewind(fp);
 239       }
 240
 241       if (lines >= rows) {
 242          char const *env_add[2], *pager;
 243
 244          pager = n_pager_get(&env_add[0]);
 245          env_add[1] = NULL;
 246          run_command(pager, NULL, fileno(fp), COMMAND_FD_PASS, NULL,NULL,NULL,
 247             env_add);
 248          goto jleave;
 249       }
 250    }
 251
 252    while ((c = getc(fp)) != EOF)
 253       putchar(c);
 254 jleave:
 255    NYD_LEAVE;
 256 }
 257
 258 FL enum protocol
 259 which_protocol(char const *name) /* XXX (->URL (yet auxlily.c)) */
 260 {
 261    struct stat st;
 262    char const *cp;
 263    char *np;
 264    size_t sz;
 265    enum protocol rv = PROTO_UNKNOWN;
 266    NYD_ENTER;
 267
 268    temporary_protocol_ext = NULL;
 269
 270    if (name[0] == '%' && name[1] == ':')
 271       name += 2;
 272    for (cp = name; *cp && *cp != ':'; cp++)
 273       if (!alnumchar(*cp))
 274          goto jfile;
 275
 276    if (cp[0] == ':' && cp[1] == '/' && cp[2] == '/') {
 277       if (!strncmp(name, "pop3://", 7)) {
 278 #ifdef HAVE_POP3
 279          rv = PROTO_POP3;
 280 #else
 281          n_err(_("No POP3 support compiled in\n"));
 282 #endif
 283       } else if (!strncmp(name, "pop3s://", 8)) {
 284 #if defined HAVE_POP3 && defined HAVE_SSL
 285          rv = PROTO_POP3;
 286 #else
 287 # ifndef HAVE_POP3
 288          n_err(_("No POP3 support compiled in\n"));
 289 # endif
 290 # ifndef HAVE_SSL
 291          n_err(_("No SSL support compiled in\n"));
 292 # endif
 293 #endif
 294       }
 295       goto jleave;
 296    }
 297
 298    /* TODO This is the de facto maildir code and thus belongs into there!
 299     * TODO and: we should have maildir:// and mbox:// pseudo-protos, instead of
 300     * TODO or (more likely) in addition to *newfolders*) */
 301 jfile:
 302    rv = PROTO_FILE;
 303    np = ac_alloc((sz = strlen(name)) + 4 +1);
 304    memcpy(np, name, sz + 1);
 305    if (!stat(name, &st)) {
 306       if (S_ISDIR(st.st_mode) &&
 307             (memcpy(np+sz, "/tmp", 5), !stat(np, &st) && S_ISDIR(st.st_mode)) &&
 308             (memcpy(np+sz, "/new", 5), !stat(np, &st) && S_ISDIR(st.st_mode)) &&
 309             (memcpy(np+sz, "/cur", 5), !stat(np, &st) && S_ISDIR(st.st_mode)))
 310           rv = PROTO_MAILDIR;
 311    } else {
 312       if ((memcpy(np+sz, cp=".gz", 4), !stat(np, &st) && S_ISREG(st.st_mode)) ||
 313             (memcpy(np+sz, cp=".xz",4), !stat(np,&st) && S_ISREG(st.st_mode)) ||
 314             (memcpy(np+sz, cp=".bz2",5), !stat(np, &st) && S_ISREG(st.st_mode)))
 315          temporary_protocol_ext = cp;
 316       else if ((cp = ok_vlook(newfolders)) != NULL &&
 317             !asccasecmp(cp, "maildir"))
 318          rv = PROTO_MAILDIR;
 319    }
 320    ac_free(np);
 321 jleave:
 322    NYD_LEAVE;
 323    return rv;
 324 }
 325
 326 FL char *
 327 n_c_to_hex_base16(char store[3], char c){
 328    static char const itoa16[] = "0123456789ABCDEF";
 329    NYD2_ENTER;
 330
 331    store[2] = '\0';
 332    store[1] = itoa16[(ui8_t)c & 0x0F];
 333    c = ((ui8_t)c >> 4) & 0x0F;
 334    store[0] = itoa16[(ui8_t)c];
 335    NYD2_LEAVE;
 336    return store;
 337 }
 338
 339 FL si32_t
 340 n_c_from_hex_base16(char const hex[2]){
 341    static ui8_t const atoi16[] = {
 342       0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* 0x30-0x37 */
 343       0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 0x38-0x3F */
 344       0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, /* 0x40-0x47 */
 345       0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 0x48-0x4f */
 346       0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 0x50-0x57 */
 347       0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 0x58-0x5f */
 348       0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF  /* 0x60-0x67 */
 349    };
 350    ui8_t i1, i2;
 351    si32_t rv;
 352    NYD2_ENTER;
 353
 354    if ((i1 = (ui8_t)hex[0] - '0') >= NELEM(atoi16) ||
 355          (i2 = (ui8_t)hex[1] - '0') >= NELEM(atoi16))
 356       goto jerr;
 357    i1 = atoi16[i1];
 358    i2 = atoi16[i2];
 359    if ((i1 | i2) & 0xF0u)
 360       goto jerr;
 361    rv = i1;
 362    rv <<= 4;
 363    rv += i2;
 364 jleave:
 365    NYD2_LEAVE;
 366    return rv;
 367 jerr:
 368    rv = -1;
 369    goto jleave;
 370 }
 371
 372 FL ui32_t
 373 torek_hash(char const *name)
 374 {
 375    /* Chris Torek's hash.
 376     * NOTE: need to change *at least* mk-okey-map.pl when changing the
 377     * algorithm!! */
 378    ui32_t h = 0;
 379    NYD_ENTER;
 380
 381    while (*name != '\0') {
 382       h *= 33;
 383       h += *name++;
 384    }
 385    NYD_LEAVE;
 386    return h;
 387 }
 388
 389 FL ui32_t
 390 torek_ihashn(char const *dat, size_t len){
 391    /* See torek_hash() */
 392    char c;
 393    ui32_t h;
 394    NYD_ENTER;
 395
 396    for(h = 0; len > 0 && (c = *dat++) != '\0'; --len)
 397       h = (h * 33) + lowerconv(c);
 398    NYD_LEAVE;
 399    return h;
 400 }
 401
 402 FL ui32_t
 403 nextprime(ui32_t n)
 404 {
 405    static ui32_t const primes[] = {
 406       5, 11, 23, 47, 97, 157, 283,
 407       509, 1021, 2039, 4093, 8191, 16381, 32749, 65521,
 408       131071, 262139, 524287, 1048573, 2097143, 4194301,
 409       8388593, 16777213, 33554393, 67108859, 134217689,
 410       268435399, 536870909, 1073741789, 2147483647
 411    };
 412
 413    ui32_t i, mprime;
 414    NYD_ENTER;
 415
 416    i = (n < primes[NELEM(primes) / 4] ? 0
 417          : (n < primes[NELEM(primes) / 2] ? NELEM(primes) / 4
 418          : NELEM(primes) / 2));
 419    do
 420       if ((mprime = primes[i]) > n)
 421          break;
 422    while (++i < NELEM(primes));
 423    if (i == NELEM(primes) && mprime < n)
 424       mprime = n;
 425    NYD_LEAVE;
 426    return mprime;
 427 }
 428
 429 FL char *
 430 getprompt(void) /* TODO evaluate only as necessary (needs a bit) PART OF UI! */
 431 { /* FIXME getprompt must mb->wc->mb+reset seq! */
 432    static char buf[PROMPT_BUFFER_SIZE];
 433
 434    char *cp;
 435    char const *ccp_base, *ccp;
 436    size_t NATCH_CHAR( cclen_base COMMA cclen COMMA ) maxlen, dfmaxlen;
 437    bool_t trigger; /* 1.: `errors' ring note?  2.: first loop tick done */
 438    NYD_ENTER;
 439
 440    /* No other place to place this */
 441 #ifdef HAVE_ERRORS
 442    if (options & OPT_INTERACTIVE) {
 443       if (!(pstate & PS_ERRORS_NOTED) && a_aux_err_head != NULL) {
 444          pstate |= PS_ERRORS_NOTED;
 445          fprintf(stderr, _("There are new messages in the error message ring "
 446                "(denoted by #ERR#)\n"
 447             "  The `errors' command manages this message ring\n"));
 448       }
 449
 450       if ((trigger = (a_aux_err_cnt_noted != a_aux_err_cnt)))
 451          a_aux_err_cnt_noted = a_aux_err_cnt;
 452    } else
 453       trigger = FAL0;
 454 #endif
 455
 456    cp = buf;
 457    if ((ccp_base = ok_vlook(prompt)) == NULL || *ccp_base == '\0') {
 458 #ifdef HAVE_ERRORS
 459       if (trigger)
 460          ccp_base = "";
 461       else
 462 #endif
 463          goto jleave;
 464    }
 465 #ifdef HAVE_ERRORS
 466    if (trigger)
 467       ccp_base = savecatsep(_("#ERR#"), '\0', ccp_base);
 468 #endif
 469    NATCH_CHAR( cclen_base = strlen(ccp_base); )
 470
 471    dfmaxlen = 0; /* keep CC happy */
 472    trigger = FAL0;
 473 jredo:
 474    ccp = ccp_base;
 475    NATCH_CHAR( cclen = cclen_base; )
 476    maxlen = sizeof(buf) -1;
 477
 478    for (;;) {
 479       size_t l;
 480       int c;
 481
 482       if (maxlen == 0)
 483          goto jleave;
 484 #ifdef HAVE_NATCH_CHAR
 485       c = mblen(ccp, cclen); /* TODO use mbrtowc() */
 486       if (c <= 0) {
 487          mblen(NULL, 0);
 488          if (c < 0) {
 489             *buf = '?';
 490             cp = buf + 1;
 491             goto jleave;
 492          }
 493          break;
 494       } else if ((l = c) > 1) {
 495          if (trigger) {
 496             memcpy(cp, ccp, l);
 497             cp += l;
 498          }
 499          ccp += l;
 500          maxlen -= l;
 501          continue;
 502       } else
 503 #endif
 504       if ((c = n_shell_expand_escape(&ccp, TRU1)) > 0) {
 505             if (trigger)
 506                *cp++ = (char)c;
 507             --maxlen;
 508             continue;
 509       }
 510       if (c == 0 || c == PROMPT_STOP)
 511          break;
 512
 513       if (trigger) {
 514          char const *a = (c == PROMPT_DOLLAR) ? account_name : displayname;
 515          if (a == NULL)
 516             a = "";
 517          if ((l = field_put_bidi_clip(cp, dfmaxlen, a, strlen(a))) > 0) {
 518             cp += l;
 519             maxlen -= l;
 520             dfmaxlen -= l;
 521          }
 522       }
 523    }
 524
 525    if (!trigger) {
 526       trigger = TRU1;
 527       dfmaxlen = maxlen;
 528       goto jredo;
 529    }
 530 jleave:
 531    *cp = '\0';
 532    NYD_LEAVE;
 533    return buf;
 534 }
 535
 536 FL char *
 537 nodename(int mayoverride)
 538 {
 539    static char *sys_hostname, *hostname; /* XXX free-at-exit */
 540
 541    struct utsname ut;
 542    char *hn;
 543 #ifdef HAVE_SOCKETS
 544 # ifdef HAVE_GETADDRINFO
 545    struct addrinfo hints, *res;
 546 # else
 547    struct hostent *hent;
 548 # endif
 549 #endif
 550    NYD_ENTER;
 551
 552    if (mayoverride && (hn = ok_vlook(hostname)) != NULL && *hn != '\0') {
 553       ;
 554    } else if ((hn = sys_hostname) == NULL) {
 555       uname(&ut);
 556       hn = ut.nodename;
 557 #ifdef HAVE_SOCKETS
 558 # ifdef HAVE_GETADDRINFO
 559       memset(&hints, 0, sizeof hints);
 560       hints.ai_family = AF_UNSPEC;
 561       hints.ai_flags = AI_CANONNAME;
 562       if (getaddrinfo(hn, NULL, &hints, &res) == 0) {
 563          if (res->ai_canonname != NULL) {
 564             size_t l = strlen(res->ai_canonname) +1;
 565
 566             hn = ac_alloc(l);
 567             memcpy(hn, res->ai_canonname, l);
 568          }
 569          freeaddrinfo(res);
 570       }
 571 # else
 572       hent = gethostbyname(hn);
 573       if (hent != NULL)
 574          hn = hent->h_name;
 575 # endif
 576 #endif
 577       sys_hostname = sstrdup(hn);
 578 #if defined HAVE_SOCKETS && defined HAVE_GETADDRINFO
 579       if (hn != ut.nodename)
 580          ac_free(hn);
 581 #endif
 582       hn = sys_hostname;
 583    }
 584
 585    if (hostname != NULL && hostname != sys_hostname)
 586       free(hostname);
 587    hostname = sstrdup(hn);
 588    NYD_LEAVE;
 589    return hostname;
 590 }
 591
 592 FL char *
 593 getrandstring(size_t length)
 594 {
 595    struct str b64;
 596    char *data;
 597    size_t i;
 598    NYD_ENTER;
 599
 600 #ifndef HAVE_POSIX_RANDOM
 601    if (_rand == NULL)
 602       _rand_init();
 603 #endif
 604
 605    /* We use our base64 encoder with _NOPAD set, so ensure the encoded result
 606     * with PAD stripped is still longer than what the user requests, easy way */
 607    data = ac_alloc(i = length + 3);
 608
 609 #ifndef HAVE_POSIX_RANDOM
 610    while (i-- > 0)
 611       data[i] = (char)_rand_get8();
 612 #else
 613    {  char *cp = data;
 614
 615       while (i > 0) {
 616          union {ui32_t i4; char c[4];} r;
 617          size_t j;
 618
 619          r.i4 = (ui32_t)arc4random();
 620          switch ((j = i & 3)) {
 621          case 0:  cp[3] = r.c[3]; j = 4;
 622          case 3:  cp[2] = r.c[2];
 623          case 2:  cp[1] = r.c[1];
 624          default: cp[0] = r.c[0]; break;
 625          }
 626          cp += j;
 627          i -= j;
 628       }
 629    }
 630 #endif
 631
 632    b64_encode_buf(&b64, data, length + 3,
 633       B64_SALLOC | B64_RFC4648URL | B64_NOPAD);
 634    ac_free(data);
 635
 636    assert(b64.l >= length);
 637    b64.s[length] = '\0';
 638    NYD_LEAVE;
 639    return b64.s;
 640 }
 641
 642 FL si8_t
 643 boolify(char const *inbuf, uiz_t inlen, si8_t emptyrv)
 644 {
 645    char *dat, *eptr;
 646    sl_i sli;
 647    si8_t rv;
 648    NYD_ENTER;
 649
 650    assert(inlen == 0 || inbuf != NULL);
 651
 652    if (inlen == UIZ_MAX)
 653       inlen = strlen(inbuf);
 654
 655    if (inlen == 0)
 656       rv = (emptyrv >= 0) ? (emptyrv == 0 ? 0 : 1) : -1;
 657    else {
 658       if ((inlen == 1 && (*inbuf == '1' || *inbuf == 'y' || *inbuf == 'Y')) ||
 659             !ascncasecmp(inbuf, "true", inlen) ||
 660             !ascncasecmp(inbuf, "yes", inlen) ||
 661             !ascncasecmp(inbuf, "on", inlen))
 662          rv = 1;
 663       else if ((inlen == 1 &&
 664                (*inbuf == '0' || *inbuf == 'n' || *inbuf == 'N')) ||
 665             !ascncasecmp(inbuf, "false", inlen) ||
 666             !ascncasecmp(inbuf, "no", inlen) ||
 667             !ascncasecmp(inbuf, "off", inlen))
 668          rv = 0;
 669       else {
 670          dat = ac_alloc(inlen +1);
 671          memcpy(dat, inbuf, inlen);
 672          dat[inlen] = '\0';
 673
 674          sli = strtol(dat, &eptr, 0);
 675          if (*dat != '\0' && *eptr == '\0')
 676             rv = (sli != 0);
 677          else
 678             rv = -1;
 679
 680          ac_free(dat);
 681       }
 682    }
 683    NYD_LEAVE;
 684    return rv;
 685 }
 686
 687 FL si8_t
 688 quadify(char const *inbuf, uiz_t inlen, char const *prompt, si8_t emptyrv)
 689 {
 690    si8_t rv;
 691    NYD_ENTER;
 692
 693    assert(inlen == 0 || inbuf != NULL);
 694
 695    if (inlen == UIZ_MAX)
 696       inlen = strlen(inbuf);
 697
 698    if (inlen == 0)
 699       rv = (emptyrv >= 0) ? (emptyrv == 0 ? 0 : 1) : -1;
 700    else if ((rv = boolify(inbuf, inlen, -1)) < 0 &&
 701          !ascncasecmp(inbuf, "ask-", 4) &&
 702          (rv = boolify(inbuf + 4, inlen - 4, -1)) >= 0 &&
 703          (options & OPT_INTERACTIVE))
 704       rv = getapproval(prompt, rv);
 705    NYD_LEAVE;
 706    return rv;
 707 }
 708
 709 FL bool_t
 710 n_is_all_or_aster(char const *name){
 711    bool_t rv;
 712    NYD_ENTER;
 713
 714    rv = ((name[0] == '*' && name[1] == '\0') || !asccasecmp(name, "all"));
 715    NYD_LEAVE;
 716    return rv;
 717 }
 718
 719 FL time_t
 720 n_time_epoch(void)
 721 {
 722 #ifdef HAVE_CLOCK_GETTIME
 723    struct timespec ts;
 724 #elif defined HAVE_GETTIMEOFDAY
 725    struct timeval ts;
 726 #endif
 727    time_t rv;
 728    char const *cp;
 729    NYD2_ENTER;
 730
 731    if((cp = ok_vlook(SOURCE_DATE_EPOCH)) != NULL){ /* TODO */
 732       /* TODO This is marked "posnum", b and therefore 0<=X<=UINT_MAX.
 733        * TODO This means we have a Sun, 07 Feb 2106 07:28:15 +0100 problem.
 734        * TODO Therefore we need a num_ui64= type in v15 */
 735       rv = (time_t)strtoul(cp, NULL, 0);
 736    }else{
 737 #ifdef HAVE_CLOCK_GETTIME
 738       clock_gettime(CLOCK_REALTIME, &ts);
 739       rv = (time_t)ts.tv_sec;
 740 #elif defined HAVE_GETTIMEOFDAY
 741       gettimeofday(&ts, NULL);
 742       rv = (time_t)ts.tv_sec;
 743 #else
 744       rv = time(NULL);
 745 #endif
 746    }
 747    NYD2_LEAVE;
 748    return rv;
 749 }
 750
 751 FL void
 752 time_current_update(struct time_current *tc, bool_t full_update)
 753 {
 754    NYD_ENTER;
 755    tc->tc_time = n_time_epoch();
 756    if (full_update) {
 757       memcpy(&tc->tc_gm, gmtime(&tc->tc_time), sizeof tc->tc_gm);
 758       memcpy(&tc->tc_local, localtime(&tc->tc_time), sizeof tc->tc_local);
 759       sstpcpy(tc->tc_ctime, ctime(&tc->tc_time));
 760    }
 761    NYD_LEAVE;
 762 }
 763
 764 FL uiz_t
 765 n_msleep(uiz_t millis, bool_t ignint){
 766    uiz_t rv;
 767    NYD2_ENTER;
 768
 769 #ifdef HAVE_NANOSLEEP
 770    /* C99 */{
 771       struct timespec ts, trem;
 772       int i;
 773
 774       ts.tv_sec = millis / 1000;
 775       ts.tv_nsec = (millis %= 1000) * 1000 * 1000;
 776
 777       while((i = nanosleep(&ts, &trem)) != 0 && ignint)
 778          ts = trem;
 779       rv = (i == 0) ? 0 : (trem.tv_sec * 1000) + (trem.tv_nsec / (1000 * 1000));
 780    }
 781
 782 #elif defined HAVE_SLEEP
 783    if((millis /= 1000) == 0)
 784       millis = 1;
 785    while((rv = sleep((unsigned int)millis)) != 0 && ignint)
 786       millis = rv;
 787 #else
 788 # error Configuration should have detected a function for sleeping.
 789 #endif
 790
 791    NYD2_LEAVE;
 792    return rv;
 793 }
 794
 795 FL void
 796 n_err(char const *format, ...){
 797    va_list ap;
 798    NYD2_ENTER;
 799
 800    va_start(ap, format);
 801 #ifdef HAVE_ERRORS
 802    if(options & OPT_INTERACTIVE)
 803       n_verr(format, ap);
 804    else
 805 #endif
 806    {
 807       size_t len;
 808       bool_t doname, doflush;
 809
 810       doflush = FAL0;
 811       while(*format == '\n'){
 812          doflush = TRU1;
 813          putc('\n', stderr);
 814          ++format;
 815       }
 816
 817       if((doname = doflush))
 818          a_aux_err_linelen = 0;
 819
 820       if((len = strlen(format)) > 0){
 821          if(doname || a_aux_err_linelen == 0)
 822             fputs(VAL_UAGENT ": ", stderr);
 823          vfprintf(stderr, format, ap);
 824
 825          /* C99 */{
 826             size_t i = len;
 827             do{
 828                if(format[--len] == '\n'){
 829                   a_aux_err_linelen = (i -= ++len);
 830                   break;
 831                }
 832                ++a_aux_err_linelen;
 833             }while(len > 0);
 834          }
 835       }
 836
 837       if(doflush)
 838          fflush(stderr);
 839    }
 840    va_end(ap);
 841    NYD2_LEAVE;
 842 }
 843
 844 FL void
 845 n_verr(char const *format, va_list ap){
 846    /* Check use cases of PS_ERRORS_NOTED, too! */
 847 #ifdef HAVE_ERRORS
 848    struct a_aux_err_node *enp;
 849 #endif
 850    bool_t doname, doflush;
 851    size_t len;
 852    NYD2_ENTER;
 853
 854    doflush = FAL0;
 855    while(*format == '\n'){
 856       doflush = TRU1;
 857       putc('\n', stderr);
 858       ++format;
 859    }
 860
 861    if((doname = doflush)){
 862       a_aux_err_linelen = 0;
 863 #ifdef HAVE_ERRORS
 864       if(options & OPT_INTERACTIVE){
 865          if((enp = a_aux_err_tail) != NULL &&
 866                (enp->ae_str.s_len > 0 &&
 867                 enp->ae_str.s_dat[enp->ae_str.s_len - 1] != '\n'))
 868             n_string_push_c(&enp->ae_str, '\n');
 869       }
 870 #endif
 871    }
 872
 873    if((len = strlen(format)) == 0)
 874       goto jleave;
 875
 876    if(doname || a_aux_err_linelen == 0)
 877       fputs(VAL_UAGENT ": ", stderr);
 878
 879    /* C99 */{
 880       size_t i = len;
 881       do{
 882          if(format[--len] == '\n'){
 883             a_aux_err_linelen = (i -= ++len);
 884             break;
 885          }
 886          ++a_aux_err_linelen;
 887       }while(len > 0);
 888    }
 889
 890 #ifdef HAVE_ERRORS
 891    if(!(options & OPT_INTERACTIVE))
 892 #endif
 893       vfprintf(stderr, format, ap);
 894 #ifdef HAVE_ERRORS
 895    else{
 896       int imax, i;
 897       LCTA(ERRORS_MAX > 3);
 898
 899       /* Link it into the `errors' message ring */
 900       if((enp = a_aux_err_tail) == NULL){
 901 jcreat:
 902          enp = smalloc(sizeof *enp);
 903          enp->ae_next = NULL;
 904          n_string_creat(&enp->ae_str);
 905          if(a_aux_err_tail != NULL)
 906             a_aux_err_tail->ae_next = enp;
 907          else
 908             a_aux_err_head = enp;
 909          a_aux_err_tail = enp;
 910          ++a_aux_err_cnt;
 911       }else if(doname ||
 912             (enp->ae_str.s_len > 0 &&
 913              enp->ae_str.s_dat[enp->ae_str.s_len - 1] == '\n')){
 914          if(a_aux_err_cnt < ERRORS_MAX)
 915             goto jcreat;
 916
 917          a_aux_err_head = (enp = a_aux_err_head)->ae_next;
 918          a_aux_err_tail->ae_next = enp;
 919          a_aux_err_tail = enp;
 920          enp->ae_next = NULL;
 921          n_string_trunc(&enp->ae_str, 0);
 922       }
 923
 924 # ifdef HAVE_VA_COPY
 925       imax = 64;
 926 # else
 927       imax = LINESIZE;
 928 # endif
 929       for(i = imax;; imax = ++i /* xxx could wrap, maybe */){
 930 # ifdef HAVE_VA_COPY
 931          va_list vac;
 932
 933          va_copy(vac, ap);
 934 # else
 935 #  define vac ap
 936 # endif
 937          n_string_resize(&enp->ae_str, (len = enp->ae_str.s_len) + (size_t)i);
 938          i = vsnprintf(&enp->ae_str.s_dat[len], (size_t)i, format, vac);
 939 # ifdef HAVE_VA_COPY
 940          va_end(vac);
 941 # else
 942 #  undef vac
 943 # endif
 944          if(i <= 0)
 945             goto jleave;
 946          if(UICMP(z, i, >=, imax)){
 947 # ifdef HAVE_VA_COPY
 948             /* XXX Check overflow for upcoming LEN+++i! */
 949             n_string_trunc(&enp->ae_str, len);
 950             continue;
 951 # else
 952             i = (int)strlen(&enp->ae_str.s_dat[len]);
 953 # endif
 954          }
 955          break;
 956       }
 957       n_string_trunc(&enp->ae_str, len + (size_t)i);
 958
 959       fwrite(&enp->ae_str.s_dat[len], 1, (size_t)i, stderr);
 960    }
 961 #endif /* HAVE_ERRORS */
 962
 963 jleave:
 964    if(doflush)
 965       fflush(stderr);
 966    NYD2_LEAVE;
 967 }
 968
 969 FL void
 970 n_err_sighdl(char const *format, ...){ /* TODO sigsafe; obsolete! */
 971    va_list ap;
 972    NYD_X;
 973
 974    va_start(ap, format);
 975    vfprintf(stderr, format, ap);
 976    va_end(ap);
 977    fflush(stderr);
 978 }
 979
 980 FL void
 981 n_perr(char const *msg, int errval){
 982    char const *fmt;
 983    NYD2_ENTER;
 984
 985    if(msg == NULL){
 986       fmt = "%s%s\n";
 987       msg = "";
 988    }else
 989       fmt = "%s: %s\n";
 990
 991    if(errval == 0)
 992       errval = errno;
 993
 994    n_err(fmt, msg, strerror(errval));
 995    NYD2_LEAVE;
 996 }
 997
 998 FL void
 999 n_alert(char const *format, ...){
1000    va_list ap;
1001    NYD2_ENTER;
1002
1003    n_err(a_aux_err_linelen > 0 ? _("\nAlert: ") : _("Alert: "));
1004
1005    va_start(ap, format);
1006    n_verr(format, ap);
1007    va_end(ap);
1008
1009    n_err("\n");
1010    NYD2_LEAVE;
1011 }
1012
1013 FL void
1014 n_panic(char const *format, ...){
1015    va_list ap;
1016    NYD2_ENTER;
1017
1018    if(a_aux_err_linelen > 0){
1019       putc('\n', stderr);
1020       a_aux_err_linelen = 0;
1021    }
1022    fprintf(stderr, VAL_UAGENT ": Panic: ");
1023
1024    va_start(ap, format);
1025    vfprintf(stderr, format, ap);
1026    va_end(ap);
1027
1028    putc('\n', stderr);
1029    fflush(stderr);
1030    NYD2_LEAVE;
1031    abort(); /* Was exit(EXIT_ERR); for a while, but no */
1032 }
1033
1034 #ifdef HAVE_ERRORS
1035 FL int
1036 c_errors(void *v){
1037    char **argv = v;
1038    struct a_aux_err_node *enp;
1039    NYD_ENTER;
1040
1041    if(*argv == NULL)
1042       goto jlist;
1043    if(argv[1] != NULL)
1044       goto jerr;
1045    if(!asccasecmp(*argv, "show"))
1046       goto jlist;
1047    if(!asccasecmp(*argv, "clear"))
1048       goto jclear;
1049 jerr:
1050    fprintf(stderr, _("Synopsis: errors: (<show> or) <clear> the error ring\n"));
1051    v = NULL;
1052 jleave:
1053    NYD_LEAVE;
1054    return (v == NULL) ? !STOP : !OKAY; /* xxx 1:bad 0:good -- do some */
1055
1056 jlist:{
1057       FILE *fp;
1058       size_t i;
1059
1060       if(a_aux_err_head == NULL){
1061          fprintf(stderr, _("The error ring is empty\n"));
1062          goto jleave;
1063       }
1064
1065       if((fp = Ftmp(NULL, "errors", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1066             NULL){
1067          fprintf(stderr, _("tmpfile"));
1068          v = NULL;
1069          goto jleave;
1070       }
1071
1072       for(i = 0, enp = a_aux_err_head; enp != NULL; enp = enp->ae_next)
1073          fprintf(fp, "%4" PRIuZ ". %u B: %s",
1074             ++i, enp->ae_str.s_len, n_string_cp(&enp->ae_str));
1075       /* We don't know whether last string ended with NL; be simple */
1076       putc('\n', fp);
1077
1078       page_or_print(fp, 0);
1079       Fclose(fp);
1080    }
1081    /* FALLTHRU */
1082
1083 jclear:
1084    a_aux_err_tail = NULL;
1085    a_aux_err_cnt = a_aux_err_cnt_noted = 0;
1086    a_aux_err_linelen = 0;
1087    while((enp = a_aux_err_head) != NULL){
1088       a_aux_err_head = enp->ae_next;
1089       n_string_gut(&enp->ae_str);
1090       free(enp);
1091    }
1092    goto jleave;
1093 }
1094 #endif /* HAVE_ERRORS */
1095
1096 /* s-it-mode */