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') ||
 659             !ascncasecmp(inbuf, "true", inlen) ||
 660             !ascncasecmp(inbuf, "yes", inlen) ||
 661             !ascncasecmp(inbuf, "on", inlen))
 662          rv = 1;
 663       else if ((inlen == 1 && *inbuf == '0') ||
 664             !ascncasecmp(inbuf, "false", inlen) ||
 665             !ascncasecmp(inbuf, "no", inlen) ||
 666             !ascncasecmp(inbuf, "off", inlen))
 667          rv = 0;
 668       else {
 669          dat = ac_alloc(inlen +1);
 670          memcpy(dat, inbuf, inlen);
 671          dat[inlen] = '\0';
 672
 673          sli = strtol(dat, &eptr, 0);
 674          if (*dat != '\0' && *eptr == '\0')
 675             rv = (sli != 0);
 676          else
 677             rv = -1;
 678
 679          ac_free(dat);
 680       }
 681    }
 682    NYD_LEAVE;
 683    return rv;
 684 }
 685
 686 FL si8_t
 687 quadify(char const *inbuf, uiz_t inlen, char const *prompt, si8_t emptyrv)
 688 {
 689    si8_t rv;
 690    NYD_ENTER;
 691
 692    assert(inlen == 0 || inbuf != NULL);
 693
 694    if (inlen == UIZ_MAX)
 695       inlen = strlen(inbuf);
 696
 697    if (inlen == 0)
 698       rv = (emptyrv >= 0) ? (emptyrv == 0 ? 0 : 1) : -1;
 699    else if ((rv = boolify(inbuf, inlen, -1)) < 0 &&
 700          !ascncasecmp(inbuf, "ask-", 4) &&
 701          (rv = boolify(inbuf + 4, inlen - 4, -1)) >= 0 &&
 702          (options & OPT_INTERACTIVE))
 703       rv = getapproval(prompt, rv);
 704    NYD_LEAVE;
 705    return rv;
 706 }
 707
 708 FL bool_t
 709 n_is_all_or_aster(char const *name){
 710    bool_t rv;
 711    NYD_ENTER;
 712
 713    rv = ((name[0] == '*' && name[1] == '\0') || !asccasecmp(name, "all"));
 714    NYD_LEAVE;
 715    return rv;
 716 }
 717
 718 FL time_t
 719 n_time_epoch(void)
 720 {
 721 #ifdef HAVE_CLOCK_GETTIME
 722    struct timespec ts;
 723 #elif defined HAVE_GETTIMEOFDAY
 724    struct timeval ts;
 725 #endif
 726    time_t rv;
 727    NYD2_ENTER;
 728
 729 #ifdef HAVE_CLOCK_GETTIME
 730    clock_gettime(CLOCK_REALTIME, &ts);
 731    rv = (time_t)ts.tv_sec;
 732 #elif defined HAVE_GETTIMEOFDAY
 733    gettimeofday(&ts, NULL);
 734    rv = (time_t)ts.tv_sec;
 735 #else
 736    rv = time(NULL);
 737 #endif
 738    NYD2_LEAVE;
 739    return rv;
 740 }
 741
 742 FL void
 743 time_current_update(struct time_current *tc, bool_t full_update)
 744 {
 745    NYD_ENTER;
 746    tc->tc_time = n_time_epoch();
 747    if (full_update) {
 748       memcpy(&tc->tc_gm, gmtime(&tc->tc_time), sizeof tc->tc_gm);
 749       memcpy(&tc->tc_local, localtime(&tc->tc_time), sizeof tc->tc_local);
 750       sstpcpy(tc->tc_ctime, ctime(&tc->tc_time));
 751    }
 752    NYD_LEAVE;
 753 }
 754
 755 FL uiz_t
 756 n_msleep(uiz_t millis, bool_t ignint){
 757    uiz_t rv;
 758    NYD2_ENTER;
 759
 760 #ifdef HAVE_NANOSLEEP
 761    /* C99 */{
 762       struct timespec ts, trem;
 763       int i;
 764
 765       ts.tv_sec = millis / 1000;
 766       ts.tv_nsec = (millis %= 1000) * 1000 * 1000;
 767
 768       while((i = nanosleep(&ts, &trem)) != 0 && ignint)
 769          ts = trem;
 770       rv = (i == 0) ? 0 : (trem.tv_sec * 1000) + (trem.tv_nsec / (1000 * 1000));
 771    }
 772
 773 #elif defined HAVE_SLEEP
 774    if((millis /= 1000) == 0)
 775       millis = 1;
 776    while((rv = sleep((unsigned int)millis)) != 0 && ignint)
 777       millis = rv;
 778 #else
 779 # error Configuration should have detected a function for sleeping.
 780 #endif
 781
 782    NYD2_LEAVE;
 783    return rv;
 784 }
 785
 786 FL void
 787 n_err(char const *format, ...){
 788    va_list ap;
 789    NYD2_ENTER;
 790
 791    va_start(ap, format);
 792 #ifdef HAVE_ERRORS
 793    if(options & OPT_INTERACTIVE)
 794       n_verr(format, ap);
 795    else
 796 #endif
 797    {
 798       size_t len;
 799       bool_t doname, doflush;
 800
 801       doflush = FAL0;
 802       while(*format == '\n'){
 803          doflush = TRU1;
 804          putc('\n', stderr);
 805          ++format;
 806       }
 807
 808       if((doname = doflush))
 809          a_aux_err_linelen = 0;
 810
 811       if((len = strlen(format)) > 0){
 812          if(doname || a_aux_err_linelen == 0)
 813             fputs(UAGENT ": ", stderr);
 814          vfprintf(stderr, format, ap);
 815
 816          /* C99 */{
 817             size_t i = len;
 818             do{
 819                if(format[--len] == '\n'){
 820                   a_aux_err_linelen = (i -= ++len);
 821                   break;
 822                }
 823                ++a_aux_err_linelen;
 824             }while(len > 0);
 825          }
 826       }
 827
 828       if(doflush)
 829          fflush(stderr);
 830    }
 831    va_end(ap);
 832    NYD2_LEAVE;
 833 }
 834
 835 FL void
 836 n_verr(char const *format, va_list ap){
 837    /* Check use cases of PS_ERRORS_NOTED, too! */
 838 #ifdef HAVE_ERRORS
 839    struct a_aux_err_node *enp;
 840 #endif
 841    bool_t doname, doflush;
 842    size_t len;
 843    NYD2_ENTER;
 844
 845    doflush = FAL0;
 846    while(*format == '\n'){
 847       doflush = TRU1;
 848       putc('\n', stderr);
 849       ++format;
 850    }
 851
 852    if((doname = doflush)){
 853       a_aux_err_linelen = 0;
 854 #ifdef HAVE_ERRORS
 855       if(options & OPT_INTERACTIVE){
 856          if((enp = a_aux_err_tail) != NULL &&
 857                (enp->ae_str.s_len > 0 &&
 858                 enp->ae_str.s_dat[enp->ae_str.s_len - 1] != '\n'))
 859             n_string_push_c(&enp->ae_str, '\n');
 860       }
 861 #endif
 862    }
 863
 864    if((len = strlen(format)) == 0)
 865       goto jleave;
 866
 867    if(doname || a_aux_err_linelen == 0)
 868       fputs(UAGENT ": ", stderr);
 869
 870    /* C99 */{
 871       size_t i = len;
 872       do{
 873          if(format[--len] == '\n'){
 874             a_aux_err_linelen = (i -= ++len);
 875             break;
 876          }
 877          ++a_aux_err_linelen;
 878       }while(len > 0);
 879    }
 880
 881 #ifdef HAVE_ERRORS
 882    if(!(options & OPT_INTERACTIVE))
 883 #endif
 884       vfprintf(stderr, format, ap);
 885 #ifdef HAVE_ERRORS
 886    else{
 887       int imax, i;
 888       LCTA(ERRORS_MAX > 3);
 889
 890       /* Link it into the `errors' message ring */
 891       if((enp = a_aux_err_tail) == NULL){
 892 jcreat:
 893          enp = smalloc(sizeof *enp);
 894          enp->ae_next = NULL;
 895          n_string_creat(&enp->ae_str);
 896          if(a_aux_err_tail != NULL)
 897             a_aux_err_tail->ae_next = enp;
 898          else
 899             a_aux_err_head = enp;
 900          a_aux_err_tail = enp;
 901          ++a_aux_err_cnt;
 902       }else if(doname ||
 903             (enp->ae_str.s_len > 0 &&
 904              enp->ae_str.s_dat[enp->ae_str.s_len - 1] == '\n')){
 905          if(a_aux_err_cnt < ERRORS_MAX)
 906             goto jcreat;
 907
 908          a_aux_err_head = (enp = a_aux_err_head)->ae_next;
 909          a_aux_err_tail->ae_next = enp;
 910          a_aux_err_tail = enp;
 911          enp->ae_next = NULL;
 912          n_string_trunc(&enp->ae_str, 0);
 913       }
 914
 915 # ifdef HAVE_VA_COPY
 916       imax = 64;
 917 # else
 918       imax = LINESIZE;
 919 # endif
 920       for(i = imax;; imax = ++i /* xxx could wrap, maybe */){
 921 # ifdef HAVE_VA_COPY
 922          va_list vac;
 923
 924          va_copy(vac, ap);
 925 # else
 926 #  define vac ap
 927 # endif
 928          n_string_resize(&enp->ae_str, (len = enp->ae_str.s_len) + (size_t)i);
 929          i = vsnprintf(&enp->ae_str.s_dat[len], (size_t)i, format, vac);
 930 # ifdef HAVE_VA_COPY
 931          va_end(vac);
 932 # else
 933 #  undef vac
 934 # endif
 935          if(i <= 0)
 936             goto jleave;
 937          if(UICMP(z, i, >=, imax)){
 938 # ifdef HAVE_VA_COPY
 939             /* XXX Check overflow for upcoming LEN+++i! */
 940             n_string_trunc(&enp->ae_str, len);
 941             continue;
 942 # else
 943             i = (int)strlen(&enp->ae_str.s_dat[len]);
 944 # endif
 945          }
 946          break;
 947       }
 948       n_string_trunc(&enp->ae_str, len + (size_t)i);
 949
 950       fwrite(&enp->ae_str.s_dat[len], 1, (size_t)i, stderr);
 951    }
 952 #endif /* HAVE_ERRORS */
 953
 954 jleave:
 955    if(doflush)
 956       fflush(stderr);
 957    NYD2_LEAVE;
 958 }
 959
 960 FL void
 961 n_err_sighdl(char const *format, ...){ /* TODO sigsafe; obsolete! */
 962    va_list ap;
 963    NYD_X;
 964
 965    va_start(ap, format);
 966    vfprintf(stderr, format, ap);
 967    va_end(ap);
 968    fflush(stderr);
 969 }
 970
 971 FL void
 972 n_perr(char const *msg, int errval){
 973    char const *fmt;
 974    NYD2_ENTER;
 975
 976    if(msg == NULL){
 977       fmt = "%s%s\n";
 978       msg = "";
 979    }else
 980       fmt = "%s: %s\n";
 981
 982    if(errval == 0)
 983       errval = errno;
 984
 985    n_err(fmt, msg, strerror(errval));
 986    NYD2_LEAVE;
 987 }
 988
 989 FL void
 990 n_alert(char const *format, ...){
 991    va_list ap;
 992    NYD2_ENTER;
 993
 994    n_err(a_aux_err_linelen > 0 ? _("\nAlert: ") : _("Alert: "));
 995
 996    va_start(ap, format);
 997    n_verr(format, ap);
 998    va_end(ap);
 999
1000    n_err("\n");
1001    NYD2_LEAVE;
1002 }
1003
1004 FL void
1005 n_panic(char const *format, ...){
1006    va_list ap;
1007    NYD2_ENTER;
1008
1009    if(a_aux_err_linelen > 0){
1010       putc('\n', stderr);
1011       a_aux_err_linelen = 0;
1012    }
1013    fprintf(stderr, UAGENT ": Panic: ");
1014
1015    va_start(ap, format);
1016    vfprintf(stderr, format, ap);
1017    va_end(ap);
1018
1019    putc('\n', stderr);
1020    fflush(stderr);
1021    NYD2_LEAVE;
1022    abort(); /* Was exit(EXIT_ERR); for a while, but no */
1023 }
1024
1025 #ifdef HAVE_ERRORS
1026 FL int
1027 c_errors(void *v){
1028    char **argv = v;
1029    struct a_aux_err_node *enp;
1030    NYD_ENTER;
1031
1032    if(*argv == NULL)
1033       goto jlist;
1034    if(argv[1] != NULL)
1035       goto jerr;
1036    if(!asccasecmp(*argv, "show"))
1037       goto jlist;
1038    if(!asccasecmp(*argv, "clear"))
1039       goto jclear;
1040 jerr:
1041    fprintf(stderr, _("Synopsis: errors: (<show> or) <clear> the error ring\n"));
1042    v = NULL;
1043 jleave:
1044    NYD_LEAVE;
1045    return (v == NULL) ? !STOP : !OKAY; /* xxx 1:bad 0:good -- do some */
1046
1047 jlist:{
1048       FILE *fp;
1049       size_t i;
1050
1051       if(a_aux_err_head == NULL){
1052          fprintf(stderr, _("The error ring is empty\n"));
1053          goto jleave;
1054       }
1055
1056       if((fp = Ftmp(NULL, "errors", OF_RDWR | OF_UNLINK | OF_REGISTER)) ==
1057             NULL){
1058          fprintf(stderr, _("tmpfile"));
1059          v = NULL;
1060          goto jleave;
1061       }
1062
1063       for(i = 0, enp = a_aux_err_head; enp != NULL; enp = enp->ae_next)
1064          fprintf(fp, "%4" PRIuZ ". %u B: %s",
1065             ++i, enp->ae_str.s_len, n_string_cp(&enp->ae_str));
1066       /* We don't know wether last string ended with NL; be simple */
1067       putc('\n', fp);
1068
1069       page_or_print(fp, 0);
1070       Fclose(fp);
1071    }
1072    /* FALLTHRU */
1073
1074 jclear:
1075    a_aux_err_tail = NULL;
1076    a_aux_err_cnt = a_aux_err_cnt_noted = 0;
1077    a_aux_err_linelen = 0;
1078    while((enp = a_aux_err_head) != NULL){
1079       a_aux_err_head = enp->ae_next;
1080       n_string_gut(&enp->ae_str);
1081       free(enp);
1082    }
1083    goto jleave;
1084 }
1085 #endif /* HAVE_ERRORS */
1086
1087 /* s-it-mode */