auxlily.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Auxiliary functions.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2014 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. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *    This product includes software developed by the University of
  22  *    California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  */
  39
  40 #ifndef HAVE_AMALGAMATION
  41 # include "nail.h"
  42 #endif
  43
  44 #include <sys/utsname.h>
  45
  46 #include <ctype.h>
  47 #include <dirent.h>
  48 #include <fcntl.h>
  49
  50 #ifdef HAVE_SOCKETS
  51 # ifdef HAVE_IPV6
  52 #  include <sys/socket.h>
  53 # endif
  54
  55 # include <netdb.h>
  56 #endif
  57
  58 #ifdef HAVE_NYD
  59 struct nyd_info {
  60    char const  *ni_file;
  61    char const  *ni_fun;
  62    ui32_t      ni_chirp_line;
  63    ui32_t      ni_level;
  64 };
  65 #endif
  66
  67 #ifdef HAVE_DEBUG
  68 struct mem_chunk {
  69    struct mem_chunk  *mc_prev;
  70    struct mem_chunk  *mc_next;
  71    char const        *mc_file;
  72    ui16_t            mc_line;
  73    ui8_t             mc_isfree;
  74    ui8_t             __dummy;
  75    ui32_t            mc_size;
  76 };
  77
  78 union mem_ptr {
  79    void              *p_p;
  80    struct mem_chunk  *p_c;
  81    char              *p_cp;
  82    ui8_t             *p_ui8p;
  83 };
  84 #endif
  85
  86 /* NYD, memory pool debug */
  87 #ifdef HAVE_NYD
  88 static ui32_t           _nyd_curr, _nyd_level;
  89 static struct nyd_info  _nyd_infos[NYD_CALLS_MAX];
  90 #endif
  91
  92 #ifdef HAVE_DEBUG
  93 static size_t           _mem_aall, _mem_acur, _mem_amax,
  94                         _mem_mall, _mem_mcur, _mem_mmax;
  95
  96 static struct mem_chunk *_mem_list, *_mem_free;
  97 #endif
  98
  99 /* {hold,rele}_all_sigs() */
 100 static size_t           _alls_depth;
 101 static sigset_t         _alls_nset, _alls_oset;
 102
 103 /* {hold,rele}_sigs() */
 104 static size_t           _hold_sigdepth;
 105 static sigset_t         _hold_nset, _hold_oset;
 106
 107 /* Create an ISO 6429 (ECMA-48/ANSI) terminal control escape sequence */
 108 #ifdef HAVE_COLOUR
 109 static char *  _colour_iso6429(char const *wish);
 110 #endif
 111
 112 #ifdef HAVE_NYD
 113 static void    _nyd_print(struct nyd_info *nip);
 114 #endif
 115
 116 #ifdef HAVE_COLOUR
 117 static char *
 118 _colour_iso6429(char const *wish)
 119 {
 120    char const * const wish_orig = wish;
 121    char *xwish, *cp, cfg[3] = {0, 0, 0};
 122    NYD_ENTER;
 123
 124    /* Since we use salloc(), reuse the n_strsep() buffer also for the return
 125     * value, ensure we have enough room for that */
 126    {
 127       size_t i = strlen(wish) +1;
 128       xwish = salloc(MAX(i, sizeof("\033[1;30;40m")));
 129       memcpy(xwish, wish, i);
 130       wish = xwish;
 131    }
 132
 133    /* Iterate over the colour spec */
 134    while ((cp = n_strsep(&xwish, ',', TRU1)) != NULL) {
 135       char *y, *x = strchr(cp, '=');
 136       if (x == NULL) {
 137 jbail:
 138          fprintf(stderr, _(
 139             "Invalid colour specification \"%s\": >>> %s <<<\n"),
 140             wish_orig, cp);
 141          continue;
 142       }
 143       *x++ = '\0';
 144
 145       /* TODO convert the ft/fg/bg parser into a table-based one! */
 146       if (!asccasecmp(cp, "ft")) {
 147          if (!asccasecmp(x, "bold"))
 148             cfg[0] = '1';
 149          else if (!asccasecmp(x, "inverse"))
 150             cfg[0] = '7';
 151          else if (!asccasecmp(x, "underline"))
 152             cfg[0] = '4';
 153          else
 154             goto jbail;
 155       } else if (!asccasecmp(cp, "fg")) {
 156          y = cfg + 1;
 157          goto jiter_colour;
 158       } else if (!asccasecmp(cp, "bg")) {
 159          y = cfg + 2;
 160 jiter_colour:
 161          if (!asccasecmp(x, "black"))
 162             *y = '0';
 163          else if (!asccasecmp(x, "blue"))
 164             *y = '4';
 165          else if (!asccasecmp(x, "green"))
 166             *y = '2';
 167          else if (!asccasecmp(x, "red"))
 168             *y = '1';
 169          else if (!asccasecmp(x, "brown"))
 170             *y = '3';
 171          else if (!asccasecmp(x, "magenta"))
 172             *y = '5';
 173          else if (!asccasecmp(x, "cyan"))
 174             *y = '6';
 175          else if (!asccasecmp(x, "white"))
 176             *y = '7';
 177          else
 178             goto jbail;
 179       } else
 180          goto jbail;
 181    }
 182
 183    /* Restore our salloc() buffer, create return value */
 184    xwish = UNCONST(wish);
 185    if (cfg[0] || cfg[1] || cfg[2]) {
 186       xwish[0] = '\033';
 187       xwish[1] = '[';
 188       xwish += 2;
 189       if (cfg[0])
 190          *xwish++ = cfg[0];
 191       if (cfg[1]) {
 192          if (cfg[0])
 193             *xwish++ = ';';
 194          xwish[0] = '3';
 195          xwish[1] = cfg[1];
 196          xwish += 2;
 197       }
 198       if (cfg[2]) {
 199          if (cfg[0] || cfg[1])
 200             *xwish++ = ';';
 201          xwish[0] = '4';
 202          xwish[1] = cfg[2];
 203          xwish += 2;
 204       }
 205       *xwish++ = 'm';
 206    }
 207    *xwish = '\0';
 208    NYD_LEAVE;
 209    return UNCONST(wish);
 210 }
 211 #endif /* HAVE_COLOUR */
 212
 213 #ifdef HAVE_NYD
 214 static void
 215 _nyd_print(struct nyd_info *nip) /* XXX like SFSYS;no magics;jumps:lvl wrong */
 216 {
 217    char buf[80];
 218    union {int i; size_t z;} u;
 219
 220    u.i = snprintf(buf, sizeof buf, "%c [%2u] %-25.25s %.16s:%-5u\n",
 221          "=><"[(nip->ni_chirp_line >> 29) & 0x3], nip->ni_level, nip->ni_fun,
 222          nip->ni_file, (nip->ni_chirp_line & 0x1FFFFFFFu));
 223    if (u.i > 0) {
 224       u.z = u.i;
 225       if (u.z > sizeof buf)
 226          u.z = sizeof buf - 1; /* (Skip \0) */
 227       write(STDERR_FILENO, buf, u.z);
 228    }
 229 }
 230 #endif
 231
 232 FL void
 233 panic(char const *format, ...)
 234 {
 235    va_list ap;
 236    NYD_ENTER;
 237
 238    fprintf(stderr, _("Panic: "));
 239
 240    va_start(ap, format);
 241    vfprintf(stderr, format, ap);
 242    va_end(ap);
 243
 244    fputs("\n", stderr);
 245    fflush(stderr);
 246    NYD_LEAVE;
 247    abort(); /* Was exit(EXIT_ERR); for a while, but no */
 248 }
 249
 250 FL void
 251 alert(char const *format, ...)
 252 {
 253    va_list ap;
 254    NYD_ENTER;
 255
 256    fprintf(stderr, _("Panic: "));
 257
 258    va_start(ap, format);
 259    vfprintf(stderr, format, ap);
 260    va_end(ap);
 261
 262    fputs("\n", stderr);
 263    fflush(stderr);
 264    NYD_LEAVE;
 265 }
 266
 267 FL sighandler_type
 268 safe_signal(int signum, sighandler_type handler)
 269 {
 270    struct sigaction nact, oact;
 271    sighandler_type rv;
 272    NYD_ENTER;
 273
 274    nact.sa_handler = handler;
 275    sigemptyset(&nact.sa_mask);
 276    nact.sa_flags = 0;
 277 #ifdef SA_RESTART
 278    nact.sa_flags |= SA_RESTART;
 279 #endif
 280    rv = (sigaction(signum, &nact, &oact) != 0) ? SIG_ERR : oact.sa_handler;
 281    NYD_LEAVE;
 282    return rv;
 283 }
 284
 285 FL void
 286 hold_all_sigs(void)
 287 {
 288    NYD_ENTER;
 289    if (_alls_depth++ == 0) {
 290       sigfillset(&_alls_nset);
 291       sigdelset(&_alls_nset, SIGABRT);
 292 #ifdef SIGBUS
 293       sigdelset(&_alls_nset, SIGBUS);
 294 #endif
 295       sigdelset(&_alls_nset, SIGCHLD);
 296       sigdelset(&_alls_nset, SIGFPE);
 297       sigdelset(&_alls_nset, SIGILL);
 298       sigdelset(&_alls_nset, SIGKILL);
 299       sigdelset(&_alls_nset, SIGSEGV);
 300       sigdelset(&_alls_nset, SIGSTOP);
 301       sigprocmask(SIG_BLOCK, &_alls_nset, &_alls_oset);
 302    }
 303    NYD_LEAVE;
 304 }
 305
 306 FL void
 307 rele_all_sigs(void)
 308 {
 309    NYD_ENTER;
 310    if (--_alls_depth == 0)
 311       sigprocmask(SIG_SETMASK, &_alls_oset, (sigset_t*)NULL);
 312    NYD_LEAVE;
 313 }
 314
 315 FL void
 316 hold_sigs(void)
 317 {
 318    NYD_ENTER;
 319    if (_hold_sigdepth++ == 0) {
 320       sigemptyset(&_hold_nset);
 321       sigaddset(&_hold_nset, SIGHUP);
 322       sigaddset(&_hold_nset, SIGINT);
 323       sigaddset(&_hold_nset, SIGQUIT);
 324       sigprocmask(SIG_BLOCK, &_hold_nset, &_hold_oset);
 325    }
 326    NYD_LEAVE;
 327 }
 328
 329 FL void
 330 rele_sigs(void)
 331 {
 332    NYD_ENTER;
 333    if (--_hold_sigdepth == 0)
 334       sigprocmask(SIG_SETMASK, &_hold_oset, NULL);
 335    NYD_LEAVE;
 336 }
 337
 338 #ifdef HAVE_NYD
 339 FL void
 340 _nyd_chirp(ui8_t act, char const *file, ui32_t line, char const *fun)
 341 {
 342    struct nyd_info *nip = _nyd_infos;
 343
 344    if (_nyd_curr != NELEM(_nyd_infos))
 345       nip += _nyd_curr++;
 346    else
 347       _nyd_curr = 1;
 348    nip->ni_file = file;
 349    nip->ni_fun = fun;
 350    nip->ni_chirp_line = ((ui32_t)(act & 0x3) << 29) | (line & 0x1FFFFFFFu);
 351    nip->ni_level = ((act == 0) ? _nyd_level
 352          : (act == 1) ? ++_nyd_level : _nyd_level--);
 353 }
 354
 355 FL void
 356 _nyd_oncrash(int signo)
 357 {
 358    struct sigaction xact;
 359    sigset_t xset;
 360    struct nyd_info *nip;
 361    size_t i;
 362
 363    xact.sa_handler = SIG_DFL;
 364    sigemptyset(&xact.sa_mask);
 365    xact.sa_flags = 0;
 366    sigaction(signo, &xact, NULL);
 367
 368    fprintf(stderr, "\n\nNYD: program dying due to signal %d:\n", signo);
 369    if (_nyd_infos[NELEM(_nyd_infos) - 1].ni_file != NULL)
 370       for (i = _nyd_curr, nip = _nyd_infos + i; i < NELEM(_nyd_infos); ++i)
 371          _nyd_print(nip++);
 372    for (i = 0, nip = _nyd_infos; i < _nyd_curr; ++i)
 373       _nyd_print(nip++);
 374
 375    sigemptyset(&xset);
 376    sigaddset(&xset, signo);
 377    sigprocmask(SIG_UNBLOCK, &xset, NULL);
 378    kill(0, signo);
 379    for (;;)
 380       _exit(EXIT_ERR);
 381 }
 382 #endif /* HAVE_NYD */
 383
 384 FL void
 385 touch(struct message *mp)
 386 {
 387    NYD_ENTER;
 388    mp->m_flag |= MTOUCH;
 389    if (!(mp->m_flag & MREAD))
 390       mp->m_flag |= MREAD | MSTATUS;
 391    NYD_LEAVE;
 392 }
 393
 394 FL bool_t
 395 is_dir(char const *name)
 396 {
 397    struct stat sbuf;
 398    bool_t rv = FAL0;
 399    NYD_ENTER;
 400
 401    if (!stat(name, &sbuf))
 402       rv = (S_ISDIR(sbuf.st_mode) != 0);
 403    NYD_LEAVE;
 404    return rv;
 405 }
 406
 407 FL int
 408 argcount(char **argv)
 409 {
 410    char **ap;
 411    NYD_ENTER;
 412
 413    for (ap = argv; *ap++ != NULL;)
 414       ;
 415    NYD_LEAVE;
 416    return (int)PTR2SIZE(ap - argv - 1);
 417 }
 418
 419 FL int
 420 screensize(void)
 421 {
 422    int s;
 423    char *cp;
 424    NYD_ENTER;
 425
 426    if ((cp = ok_vlook(screen)) == NULL || (s = atoi(cp)) <= 0)
 427       s = scrnheight - 4; /* XXX no magics */
 428    NYD_LEAVE;
 429    return s;
 430 }
 431
 432 FL char const *
 433 get_pager(char const **env_addon)
 434 {
 435    char const *cp;
 436    NYD_ENTER;
 437
 438    cp = ok_vlook(PAGER);
 439    if (cp == NULL || *cp == '\0')
 440       cp = XPAGER;
 441
 442    if (env_addon != NULL) {
 443       if (strstr(cp, "less") != NULL) {
 444          if (getenv("LESS") == NULL)
 445             *env_addon = "LESS=FRSXi";
 446       } else if (strstr(cp, "lv") != NULL) {
 447          if (getenv("LV") == NULL)
 448             *env_addon = "LV=-c";
 449       } else
 450          *env_addon = NULL;
 451    }
 452    NYD_LEAVE;
 453    return cp;
 454 }
 455
 456 FL size_t
 457 paging_seems_sensible(void)
 458 {
 459    size_t rv = 0;
 460    char const *cp;
 461    NYD_ENTER;
 462
 463    if (IS_TTY_SESSION() && (cp = ok_vlook(crt)) != NULL)
 464       rv = (*cp != '\0') ? (size_t)atol(cp) : (size_t)scrnheight;
 465    NYD_LEAVE;
 466    return rv;
 467 }
 468
 469 FL void
 470 page_or_print(FILE *fp, size_t lines)
 471 {
 472    size_t rows;
 473    int c;
 474    NYD_ENTER;
 475
 476    fflush_rewind(fp);
 477
 478    if ((rows = paging_seems_sensible()) != 0 && lines == 0) {
 479       while ((c = getc(fp)) != EOF)
 480          if (c == '\n' && ++lines > rows)
 481             break;
 482       really_rewind(fp);
 483    }
 484
 485    if (rows != 0 && lines >= rows)
 486       run_command(get_pager(NULL), 0, fileno(fp), -1, NULL, NULL, NULL);
 487    else
 488       while ((c = getc(fp)) != EOF)
 489          putchar(c);
 490    NYD_LEAVE;
 491 }
 492
 493 FL enum protocol
 494 which_protocol(char const *name) /* XXX (->URL (yet auxlily.c)) */
 495 {
 496    struct stat st;
 497    char const *cp;
 498    char *np;
 499    size_t sz;
 500    enum protocol rv = PROTO_UNKNOWN;
 501    NYD_ENTER;
 502
 503    if (name[0] == '%' && name[1] == ':')
 504       name += 2;
 505    for (cp = name; *cp && *cp != ':'; cp++)
 506       if (!alnumchar(*cp))
 507          goto jfile;
 508
 509    if (cp[0] == ':' && cp[1] == '/' && cp[2] == '/') {
 510       if (!strncmp(name, "pop3://", 7)) {
 511 #ifdef HAVE_POP3
 512          rv = PROTO_POP3;
 513 #else
 514          fprintf(stderr, _("No POP3 support compiled in.\n"));
 515 #endif
 516       } else if (!strncmp(name, "pop3s://", 8)) {
 517 #if defined HAVE_POP3 && defined HAVE_SSL
 518          rv = PROTO_POP3;
 519 #else
 520 # ifndef HAVE_POP3
 521          fprintf(stderr, _("No POP3 support compiled in.\n"));
 522 # endif
 523 # ifndef HAVE_SSL
 524          fprintf(stderr, _("No SSL support compiled in.\n"));
 525 # endif
 526 #endif
 527       } else if (!strncmp(name, "imap://", 7)) {
 528 #ifdef HAVE_IMAP
 529          rv = PROTO_IMAP;
 530 #else
 531          fprintf(stderr, _("No IMAP support compiled in.\n"));
 532 #endif
 533       } else if (!strncmp(name, "imaps://", 8)) {
 534 #if defined HAVE_IMAP && defined HAVE_SSL
 535          rv = PROTO_IMAP;
 536 #else
 537 # ifndef HAVE_IMAP
 538          fprintf(stderr, _("No IMAP support compiled in.\n"));
 539 # endif
 540 # ifndef HAVE_SSL
 541          fprintf(stderr, _("No SSL support compiled in.\n"));
 542 # endif
 543 #endif
 544       }
 545       goto jleave;
 546    }
 547
 548    /* TODO This is the de facto maildir code and thus belongs into there!
 549     * TODO and: we should have maildir:// and mbox:// pseudo-protos, instead of
 550     * TODO or (more likely) in addition to *newfolders*) */
 551 jfile:
 552    rv = PROTO_FILE;
 553    np = ac_alloc((sz = strlen(name)) + 4 +1);
 554    memcpy(np, name, sz + 1);
 555    if (!stat(name, &st)) {
 556       if (S_ISDIR(st.st_mode) &&
 557             (memcpy(np+sz, "/tmp", 4), !stat(np, &st) && S_ISDIR(st.st_mode)) &&
 558             (memcpy(np+sz, "/new", 4), !stat(np, &st) && S_ISDIR(st.st_mode)) &&
 559             (memcpy(np+sz, "/cur", 4), !stat(np, &st) && S_ISDIR(st.st_mode)))
 560           rv = PROTO_MAILDIR;
 561    } else if ((cp = ok_vlook(newfolders)) != NULL && !strcmp(cp, "maildir"))
 562       rv = PROTO_MAILDIR;
 563    ac_free(np);
 564 jleave:
 565    NYD_LEAVE;
 566    return rv;
 567 }
 568
 569 FL ui32_t
 570 torek_hash(char const *name)
 571 {
 572    /* Chris Torek's hash.
 573     * NOTE: need to change *at least* create-okey-map.pl when changing the
 574     * algorithm!! */
 575    ui32_t h = 0;
 576    NYD_ENTER;
 577
 578    while (*name != '\0') {
 579       h *= 33;
 580       h += *name++;
 581    }
 582    NYD_LEAVE;
 583    return h;
 584 }
 585
 586 FL unsigned
 587 pjw(char const *cp) /* TODO obsolete that -> torek_hash */
 588 {
 589    unsigned h = 0, g;
 590    NYD_ENTER;
 591
 592    cp--;
 593    while (*++cp) {
 594       h = (h << 4 & 0xffffffff) + (*cp&0377);
 595       if ((g = h & 0xf0000000) != 0) {
 596          h = h ^ g >> 24;
 597          h = h ^ g;
 598       }
 599    }
 600    NYD_LEAVE;
 601    return h;
 602 }
 603
 604 FL ui32_t
 605 nextprime(ui32_t n)
 606 {
 607    static ui32_t const primes[] = {
 608       509, 1021, 2039, 4093, 8191, 16381, 32749, 65521,
 609       131071, 262139, 524287, 1048573, 2097143, 4194301,
 610       8388593, 16777213, 33554393, 67108859, 134217689,
 611       268435399, 536870909, 1073741789, 2147483647
 612    };
 613
 614    ui32_t mprime = 7, cutlim;
 615    size_t i;
 616    NYD_ENTER;
 617
 618    cutlim = (n < 65536 ? n << 2 : (n < 262144 ? n << 1 : n));
 619
 620    for (i = 0; i < NELEM(primes); i++)
 621       if ((mprime = primes[i]) >= cutlim)
 622          break;
 623    if (i == NELEM(primes) && mprime < n)
 624       mprime = n;
 625    NYD_LEAVE;
 626    return mprime;
 627 }
 628
 629 FL int
 630 expand_shell_escape(char const **s, bool_t use_nail_extensions)
 631 {
 632    char const *xs;
 633    int c, n;
 634    NYD_ENTER;
 635
 636    xs = *s;
 637
 638    if ((c = *xs & 0xFF) == '\0')
 639       goto jleave;
 640    ++xs;
 641    if (c != '\\')
 642       goto jleave;
 643
 644    switch ((c = *xs & 0xFF)) {
 645    case '\\':                    break;
 646    case 'a':   c = '\a';         break;
 647    case 'b':   c = '\b';         break;
 648    case 'c':   c = PROMPT_STOP;  break;
 649    case 'f':   c = '\f';         break;
 650    case 'n':   c = '\n';         break;
 651    case 'r':   c = '\r';         break;
 652    case 't':   c = '\t';         break;
 653    case 'v':   c = '\v';         break;
 654    case '0':
 655       for (++xs, c = 0, n = 4; --n > 0 && octalchar(*xs); ++xs) {
 656          c <<= 3;
 657          c |= *xs - '0';
 658       }
 659       goto jleave;
 660    /* S-nail extension for nice (get)prompt(()) support */
 661    case '&':
 662    case '?':
 663    case '$':
 664    case '@':
 665       if (use_nail_extensions) {
 666          switch (c) {
 667          case '&':   c = ok_blook(bsdcompat) ? '&' : '?';   break;
 668          case '?':   c = exec_last_comm_error ? '1' : '0';  break;
 669          case '$':   c = PROMPT_DOLLAR;                     break;
 670          case '@':   c = PROMPT_AT;                         break;
 671          }
 672          break;
 673       }
 674       /* FALLTHRU */
 675    case '\0':
 676       /* A sole <backslash> at EOS is treated as-is! */
 677       /* FALLTHRU */
 678    default:
 679       c = '\\';
 680       goto jleave;
 681    }
 682    ++xs;
 683 jleave:
 684    *s = xs;
 685    NYD_LEAVE;
 686    return c;
 687 }
 688
 689 FL char *
 690 getprompt(void) /* TODO evaluate only as necessary (needs a bit) */
 691 {
 692    static char buf[PROMPT_BUFFER_SIZE];
 693
 694    char *cp;
 695    char const *ccp_base, *ccp;
 696    size_t NATCH_CHAR( cclen_base COMMA cclen COMMA ) maxlen, dfmaxlen;
 697    bool_t run2;
 698    NYD_ENTER;
 699
 700    cp = buf;
 701    if ((ccp_base = ok_vlook(prompt)) == NULL || *ccp_base == '\0')
 702       goto jleave;
 703    NATCH_CHAR( cclen_base = strlen(ccp_base); )
 704
 705    dfmaxlen = 0; /* keep CC happy */
 706    run2 = FAL0;
 707 jredo:
 708    ccp = ccp_base;
 709    NATCH_CHAR( cclen = cclen_base; )
 710    maxlen = sizeof(buf) -1;
 711
 712    for (;;) {
 713       size_t l;
 714       int c;
 715
 716       if (maxlen == 0)
 717          goto jleave;
 718 #ifdef HAVE_NATCH_CHAR
 719       c = mblen(ccp, cclen); /* TODO use mbrtowc() */
 720       if (c <= 0) {
 721          mblen(NULL, 0);
 722          if (c < 0) {
 723             *buf = '?';
 724             cp = buf + 1;
 725             goto jleave;
 726          }
 727          break;
 728       } else if ((l = c) > 1) {
 729          if (run2) {
 730             memcpy(cp, ccp, l);
 731             cp += l;
 732          }
 733          ccp += l;
 734          maxlen -= l;
 735          continue;
 736       } else
 737 #endif
 738       if ((c = expand_shell_escape(&ccp, TRU1)) > 0) {
 739             if (run2)
 740                *cp++ = (char)c;
 741             --maxlen;
 742             continue;
 743       }
 744       if (c == 0 || c == PROMPT_STOP)
 745          break;
 746
 747       if (run2) {
 748          char const *a = (c == PROMPT_DOLLAR) ? account_name : displayname;
 749          if (a == NULL)
 750             a = "";
 751          if ((l = field_put_bidi_clip(cp, dfmaxlen, a, strlen(a))) > 0) {
 752             cp += l;
 753             maxlen -= l;
 754             dfmaxlen -= l;
 755          }
 756       }
 757    }
 758
 759    if (!run2) {
 760       run2 = TRU1;
 761       dfmaxlen = maxlen;
 762       goto jredo;
 763    }
 764 jleave:
 765    *cp = '\0';
 766    NYD_LEAVE;
 767    return buf;
 768 }
 769
 770 FL char *
 771 nodename(int mayoverride)
 772 {
 773    static char *sys_hostname, *hostname; /* XXX free-at-exit */
 774
 775    struct utsname ut;
 776    char *hn;
 777 #ifdef HAVE_SOCKETS
 778 # ifdef HAVE_IPV6
 779    struct addrinfo hints, *res;
 780 # else
 781    struct hostent *hent;
 782 # endif
 783 #endif
 784    NYD_ENTER;
 785
 786    if (mayoverride && (hn = ok_vlook(hostname)) != NULL && *hn != '\0') {
 787       ;
 788    } else if ((hn = sys_hostname) == NULL) {
 789       uname(&ut);
 790       hn = ut.nodename;
 791 #ifdef HAVE_SOCKETS
 792 # ifdef HAVE_IPV6
 793       memset(&hints, 0, sizeof hints);
 794       hints.ai_family = AF_UNSPEC;
 795       hints.ai_socktype = SOCK_DGRAM; /* (dummy) */
 796       hints.ai_flags = AI_CANONNAME;
 797       if (getaddrinfo(hn, "0", &hints, &res) == 0) {
 798          if (res->ai_canonname != NULL) {
 799             size_t l = strlen(res->ai_canonname) +1;
 800             hn = ac_alloc(l);
 801             memcpy(hn, res->ai_canonname, l);
 802          }
 803          freeaddrinfo(res);
 804       }
 805 # else
 806       hent = gethostbyname(hn);
 807       if (hent != NULL)
 808          hn = hent->h_name;
 809 # endif
 810 #endif
 811       sys_hostname = sstrdup(hn);
 812 #if defined HAVE_SOCKETS && defined HAVE_IPV6
 813       if (hn != ut.nodename)
 814          ac_free(hn);
 815 #endif
 816       hn = sys_hostname;
 817    }
 818
 819    if (hostname != NULL && hostname != sys_hostname)
 820       free(hostname);
 821    hostname = sstrdup(hn);
 822    NYD_LEAVE;
 823    return hostname;
 824 }
 825
 826 FL char *
 827 getrandstring(size_t length)
 828 {
 829    static unsigned char nodedigest[16];
 830    static pid_t pid;
 831
 832    struct str b64;
 833    char *data, *cp;
 834    size_t i;
 835    int fd = -1;
 836 #ifdef HAVE_MD5
 837    md5_ctx ctx;
 838 #else
 839    size_t j;
 840 #endif
 841    NYD_ENTER;
 842
 843    data = ac_alloc(length);
 844
 845    if ((fd = open("/dev/urandom", O_RDONLY)) == -1 ||
 846          length != (size_t)read(fd, data, length)) {
 847       if (pid == 0) {
 848          pid = getpid();
 849          srand(pid);
 850          cp = nodename(0);
 851 #ifdef HAVE_MD5
 852          md5_init(&ctx);
 853          md5_update(&ctx, (unsigned char*)cp, strlen(cp));
 854          md5_final(nodedigest, &ctx);
 855 #else
 856          /* In that case it's only used for boundaries and Message-Id:s so that
 857           * srand(3) should suffice */
 858          j = strlen(cp) + 1;
 859          for (i = 0; i < sizeof(nodedigest); ++i)
 860             nodedigest[i] = (unsigned char)(cp[i % j] ^ rand());
 861 #endif
 862       }
 863       for (i = 0; i < length; i++)
 864          data[i] = (char)((int)(255 * (rand() / (RAND_MAX + 1.0))) ^
 865                nodedigest[i % sizeof nodedigest]);
 866    }
 867    if (fd >= 0)
 868       close(fd);
 869
 870    b64_encode_buf(&b64, data, length, B64_SALLOC);
 871    ac_free(data);
 872    assert(length < b64.l);
 873    b64.s[length] = '\0';
 874    NYD_LEAVE;
 875    return b64.s;
 876 }
 877
 878 FL enum okay
 879 makedir(char const *name)
 880 {
 881    struct stat st;
 882    enum okay rv = STOP;
 883    NYD_ENTER;
 884
 885    if (!mkdir(name, 0700))
 886       rv = OKAY;
 887    else {
 888       int e = errno;
 889       if ((e == EEXIST || e == ENOSYS) && !stat(name, &st) &&
 890             S_ISDIR(st.st_mode))
 891          rv = OKAY;
 892    }
 893    NYD_LEAVE;
 894    return rv;
 895 }
 896
 897 #ifdef HAVE_FCHDIR
 898 FL enum okay
 899 cwget(struct cw *cw)
 900 {
 901    enum okay rv = STOP;
 902    NYD_ENTER;
 903
 904    if ((cw->cw_fd = open(".", O_RDONLY)) == -1)
 905       goto jleave;
 906    if (fchdir(cw->cw_fd) == -1) {
 907       close(cw->cw_fd);
 908       goto jleave;
 909    }
 910    rv = OKAY;
 911 jleave:
 912    NYD_LEAVE;
 913    return rv;
 914 }
 915
 916 FL enum okay
 917 cwret(struct cw *cw)
 918 {
 919    enum okay rv = STOP;
 920    NYD_ENTER;
 921
 922    if (!fchdir(cw->cw_fd))
 923       rv = OKAY;
 924    NYD_LEAVE;
 925    return rv;
 926 }
 927
 928 FL void
 929 cwrelse(struct cw *cw)
 930 {
 931    NYD_ENTER;
 932    close(cw->cw_fd);
 933    NYD_LEAVE;
 934 }
 935
 936 #else /* !HAVE_FCHDIR */
 937 FL enum okay
 938 cwget(struct cw *cw)
 939 {
 940    enum okay rv = STOP;
 941    NYD_ENTER;
 942
 943    if (getcwd(cw->cw_wd, sizeof cw->cw_wd) != NULL && !chdir(cw->cw_wd))
 944       rv = OKAY;
 945    NYD_LEAVE;
 946    return rv;
 947 }
 948
 949 FL enum okay
 950 cwret(struct cw *cw)
 951 {
 952    enum okay rv = STOP;
 953    NYD_ENTER;
 954
 955    if (!chdir(cw->cw_wd))
 956       rv = OKAY;
 957    NYD_LEAVE;
 958    return rv;
 959 }
 960
 961 FL void
 962 cwrelse(struct cw *cw)
 963 {
 964    NYD_ENTER;
 965    UNUSED(cw);
 966    NYD_LEAVE;
 967 }
 968 #endif /* !HAVE_FCHDIR */
 969
 970 FL size_t
 971 field_detect_clip(size_t maxlen, char const *buf, size_t blen)/*TODO mbrtowc()*/
 972 {
 973    size_t rv;
 974    NYD_ENTER;
 975
 976 #ifdef HAVE_NATCH_CHAR
 977    maxlen = MIN(maxlen, blen);
 978    for (rv = 0; maxlen > 0;) {
 979       int ml = mblen(buf, maxlen);
 980       if (ml <= 0) {
 981          mblen(NULL, 0);
 982          break;
 983       }
 984       buf += ml;
 985       rv += ml;
 986       maxlen -= ml;
 987    }
 988 #else
 989    rv = MIN(blen, maxlen);
 990 #endif
 991    NYD_LEAVE;
 992    return rv;
 993 }
 994
 995 FL size_t
 996 field_put_bidi_clip(char *store, size_t maxlen, char const *buf, size_t blen)
 997 {
 998    NATCH_CHAR( struct bidi_info bi; )
 999    size_t rv NATCH_CHAR( COMMA i );
1000    NYD_ENTER;
1001
1002    rv = 0;
1003    if (maxlen-- == 0)
1004       goto j_leave;
1005
1006 #ifdef HAVE_NATCH_CHAR
1007    bidi_info_create(&bi);
1008    if (bi.bi_start.l == 0 || !bidi_info_needed(buf, blen)) {
1009       bi.bi_end.l = 0;
1010       goto jnobidi;
1011    }
1012
1013    if (maxlen >= (i = bi.bi_pad + bi.bi_end.l + bi.bi_start.l))
1014       maxlen -= i;
1015    else
1016       goto jleave;
1017
1018    if ((i = bi.bi_start.l) > 0) {
1019       memcpy(store, bi.bi_start.s, i);
1020       store += i;
1021       rv += i;
1022    }
1023
1024 jnobidi:
1025    while (maxlen > 0) {
1026       int ml = mblen(buf, blen);
1027       if (ml <= 0) {
1028          mblen(NULL, 0);
1029          break;
1030       }
1031       if (UICMP(z, maxlen, <, ml))
1032          break;
1033       if (ml == 1)
1034          *store = *buf;
1035       else
1036          memcpy(store, buf, ml);
1037       store += ml;
1038       buf += ml;
1039       rv += ml;
1040       maxlen -= ml;
1041    }
1042
1043    if ((i = bi.bi_end.l) > 0) {
1044       memcpy(store, bi.bi_end.s, i);
1045       store += i;
1046       rv += i;
1047    }
1048 jleave:
1049    *store = '\0';
1050
1051 #else
1052    rv = MIN(blen, maxlen);
1053    memcpy(store, buf, rv);
1054    store[rv] = '\0';
1055 #endif
1056 j_leave:
1057    NYD_LEAVE;
1058    return rv;
1059 }
1060
1061 FL char *
1062 colalign(char const *cp, int col, int fill, int *cols_decr_used_or_null)
1063 {
1064    NATCH_CHAR( struct bidi_info bi; )
1065    int col_orig = col, n, sz;
1066    bool_t isbidi, isuni, isrepl;
1067    char *nb, *np;
1068    NYD_ENTER;
1069
1070    /* Bidi only on request and when there is 8-bit data */
1071    isbidi = isuni = FAL0;
1072 #ifdef HAVE_NATCH_CHAR
1073    isuni = ((options & OPT_UNICODE) != 0);
1074    bidi_info_create(&bi);
1075    if (bi.bi_start.l == 0)
1076       goto jnobidi;
1077    if (!(isbidi = bidi_info_needed(cp, strlen(cp))))
1078       goto jnobidi;
1079
1080    if ((size_t)col >= bi.bi_pad)
1081       col -= bi.bi_pad;
1082    else
1083       col = 0;
1084 jnobidi:
1085 #endif
1086
1087    np = nb = salloc(mb_cur_max * strlen(cp) +
1088          ((fill ? col : 0)
1089          NATCH_CHAR( + (isbidi ? bi.bi_start.l + bi.bi_end.l : 0) )
1090          +1));
1091
1092 #ifdef HAVE_NATCH_CHAR
1093    if (isbidi) {
1094       memcpy(np, bi.bi_start.s, bi.bi_start.l);
1095       np += bi.bi_start.l;
1096    }
1097 #endif
1098
1099    while (*cp != '\0') {
1100 #ifdef HAVE_C90AMEND1
1101       if (mb_cur_max > 1) {
1102          wchar_t  wc;
1103
1104          n = 1;
1105          isrepl = TRU1;
1106          if ((sz = mbtowc(&wc, cp, mb_cur_max)) == -1)
1107             sz = 1;
1108          else if (iswprint(wc)) {
1109 # ifndef HAVE_WCWIDTH
1110             n = 1 + (wc >= 0x1100u); /* TODO use S-CText isfullwidth() */
1111 # else
1112             if ((n = wcwidth(wc)) == -1)
1113                n = 1;
1114             else
1115 # endif
1116                isrepl = FAL0;
1117          }
1118       } else
1119 #endif
1120          n = sz = 1,
1121          isrepl = !isprint(*cp);
1122
1123       if (n > col)
1124          break;
1125       col -= n;
1126
1127       if (isrepl) {
1128          if (isuni) {
1129             np[0] = (char)0xEFu;
1130             np[1] = (char)0xBFu;
1131             np[2] = (char)0xBDu;
1132             np += 3;
1133          } else
1134             *np++ = '?';
1135          cp += sz;
1136       } else if (sz == 1 && spacechar(*cp)) {
1137          *np++ = ' ';
1138          ++cp;
1139       } else
1140          while (sz--)
1141             *np++ = *cp++;
1142    }
1143
1144    if (fill && col != 0) {
1145       if (fill > 0) {
1146          memmove(nb + col, nb, PTR2SIZE(np - nb));
1147          memset(nb, ' ', col);
1148       } else
1149          memset(np, ' ', col);
1150       np += col;
1151       col = 0;
1152    }
1153
1154 #ifdef HAVE_NATCH_CHAR
1155    if (isbidi) {
1156       memcpy(np, bi.bi_end.s, bi.bi_end.l);
1157       np += bi.bi_end.l;
1158    }
1159 #endif
1160
1161    *np = '\0';
1162    if (cols_decr_used_or_null != NULL)
1163       *cols_decr_used_or_null -= col_orig - col;
1164    NYD_LEAVE;
1165    return nb;
1166 }
1167
1168 FL void
1169 makeprint(struct str const *in, struct str *out)
1170 {
1171    static int print_all_chars = -1;
1172
1173    char const *inp, *maxp;
1174    char *outp;
1175    DBG( size_t msz; )
1176    NYD_ENTER;
1177
1178    if (print_all_chars == -1)
1179       print_all_chars = ok_blook(print_all_chars);
1180
1181    out->s = outp = smalloc(DBG( msz = ) in->l*mb_cur_max + 2u*mb_cur_max);
1182    inp = in->s;
1183    maxp = inp + in->l;
1184
1185    if (print_all_chars) {
1186       out->l = in->l;
1187       memcpy(outp, inp, out->l);
1188       goto jleave;
1189    }
1190
1191 #ifdef HAVE_NATCH_CHAR
1192    if (mb_cur_max > 1) {
1193       char mbb[MB_LEN_MAX + 1];
1194       wchar_t wc;
1195       int i, n;
1196       bool_t isuni = ((options & OPT_UNICODE) != 0);
1197
1198       out->l = 0;
1199       while (inp < maxp) {
1200          if (*inp & 0200)
1201             n = mbtowc(&wc, inp, PTR2SIZE(maxp - inp));
1202          else {
1203             wc = *inp;
1204             n = 1;
1205          }
1206          if (n == -1) {
1207             /* FIXME Why mbtowc() resetting here?
1208              * FIXME what about ISO 2022-JP plus -- those
1209              * FIXME will loose shifts, then!
1210              * FIXME THUS - we'd need special "known points"
1211              * FIXME to do so - say, after a newline!!
1212              * FIXME WE NEED TO CHANGE ALL USES +MBLEN! */
1213             mbtowc(&wc, NULL, mb_cur_max);
1214             wc = isuni ? 0xFFFD : '?';
1215             n = 1;
1216          } else if (n == 0)
1217             n = 1;
1218          inp += n;
1219          if (!iswprint(wc) && wc != '\n' && wc != '\r' && wc != '\b' &&
1220                wc != '\t') {
1221             if ((wc & ~(wchar_t)037) == 0)
1222                wc = isuni ? 0x2400 | wc : '?';
1223             else if (wc == 0177)
1224                wc = isuni ? 0x2421 : '?';
1225             else
1226                wc = isuni ? 0x2426 : '?';
1227          }
1228          if ((n = wctomb(mbb, wc)) <= 0)
1229             continue;
1230          out->l += n;
1231          assert(out->l < msz);
1232          for (i = 0; i < n; ++i)
1233             *outp++ = mbb[i];
1234       }
1235    } else
1236 #endif /* NATCH_CHAR */
1237    {
1238       int c;
1239       while (inp < maxp) {
1240          c = *inp++ & 0377;
1241          if (!isprint(c) && c != '\n' && c != '\r' && c != '\b' && c != '\t')
1242             c = '?';
1243          *outp++ = c;
1244       }
1245       out->l = in->l;
1246    }
1247 jleave:
1248    out->s[out->l] = '\0';
1249    NYD_LEAVE;
1250 }
1251
1252 FL char *
1253 prstr(char const *s)
1254 {
1255    struct str in, out;
1256    char *rp;
1257    NYD_ENTER;
1258
1259    in.s = UNCONST(s);
1260    in.l = strlen(s);
1261    makeprint(&in, &out);
1262    rp = savestrbuf(out.s, out.l);
1263    free(out.s);
1264    NYD_LEAVE;
1265    return rp;
1266 }
1267
1268 FL int
1269 prout(char const *s, size_t sz, FILE *fp)
1270 {
1271    struct str in, out;
1272    int n;
1273    NYD_ENTER;
1274
1275    in.s = UNCONST(s);
1276    in.l = sz;
1277    makeprint(&in, &out);
1278    n = fwrite(out.s, 1, out.l, fp);
1279    free(out.s);
1280    NYD_LEAVE;
1281    return n;
1282 }
1283
1284 FL size_t
1285 putuc(int u, int c, FILE *fp)
1286 {
1287    size_t rv;
1288    NYD_ENTER;
1289    UNUSED(u);
1290
1291 #ifdef HAVE_NATCH_CHAR
1292    if ((options & OPT_UNICODE) && (u & ~(wchar_t)0177)) {
1293       char mbb[MB_LEN_MAX];
1294       int i, n;
1295
1296       if ((n = wctomb(mbb, u)) > 0) {
1297          rv = wcwidth(u);
1298          for (i = 0; i < n; ++i)
1299             if (putc(mbb[i] & 0377, fp) == EOF) {
1300                rv = 0;
1301                break;
1302             }
1303       } else if (n == 0)
1304          rv = (putc('\0', fp) != EOF);
1305       else
1306          rv = 0;
1307    } else
1308 #endif
1309       rv = (putc(c, fp) != EOF);
1310    NYD_LEAVE;
1311    return rv;
1312 }
1313
1314 FL bool_t
1315 bidi_info_needed(char const *bdat, size_t blen)
1316 {
1317    bool_t rv = FAL0;
1318    NYD_ENTER;
1319
1320 #ifdef HAVE_NATCH_CHAR
1321    if (options & OPT_UNICODE)
1322       for (; blen > 0; ++bdat, --blen) {
1323          if ((ui8_t)*bdat > 0x7F) {
1324             /* TODO Checking for BIDI character: use S-CText fromutf8
1325              * TODO plus isrighttoleft (or whatever there will be)! */
1326             ui32_t c, x = (ui8_t)*bdat;
1327
1328             if ((x & 0xE0) == 0xC0) {
1329                if (blen < 2)
1330                   break;
1331                blen -= 1;
1332                c = x & ~0xC0;
1333             } else if ((x & 0xF0) == 0xE0) {
1334                if (blen < 3)
1335                   break;
1336                blen -= 2;
1337                c = x & ~0xE0;
1338                c <<= 6;
1339                x = (ui8_t)*++bdat;
1340                c |= x & 0x7F;
1341             } else {
1342                if (blen < 4)
1343                   break;
1344                blen -= 3;
1345                c = x & ~0xF0;
1346                c <<= 6;
1347                x = (ui8_t)*++bdat;
1348                c |= x & 0x7F;
1349                c <<= 6;
1350                x = (ui8_t)*++bdat;
1351                c |= x & 0x7F;
1352             }
1353             c <<= 6;
1354             x = (ui8_t)*++bdat;
1355             c |= x & 0x7F;
1356
1357             /* (Very very fuzzy, awaiting S-CText for good) */
1358             if ((c >= 0x05BE && c <= 0x08E3) ||
1359                   (c >= 0xFB1D && c <= 0xFEFC) ||
1360                   (c >= 0x10800 && c <= 0x10C48) ||
1361                   (c >= 0x1EE00 && c <= 0x1EEF1)) {
1362                rv = TRU1;
1363                break;
1364             }
1365          }
1366       }
1367 #endif /* HAVE_NATCH_CHAR */
1368    NYD_LEAVE;
1369    return rv;
1370 }
1371
1372 FL void
1373 bidi_info_create(struct bidi_info *bip)
1374 {
1375    /* Unicode: how to isolate RIGHT-TO-LEFT scripts via *headline-bidi*
1376     * 1.1 (Jun 1993): U+200E (E2 80 8E) LEFT-TO-RIGHT MARK
1377     * 6.3 (Sep 2013): U+2068 (E2 81 A8) FIRST STRONG ISOLATE,
1378     *                 U+2069 (E2 81 A9) POP DIRECTIONAL ISOLATE
1379     * Worse results seen for: U+202D "\xE2\x80\xAD" U+202C "\xE2\x80\xAC" */
1380    NATCH_CHAR( char const *hb; )
1381    NYD_ENTER;
1382
1383    memset(bip, 0, sizeof *bip);
1384    bip->bi_start.s = bip->bi_end.s = UNCONST("");
1385
1386 #ifdef HAVE_NATCH_CHAR
1387    if ((options & OPT_UNICODE) && (hb = ok_vlook(headline_bidi)) != NULL) {
1388       switch (*hb) {
1389       case '3':
1390          bip->bi_pad = 2;
1391          /* FALLTHRU */
1392       case '2':
1393          bip->bi_start.s = bip->bi_end.s = UNCONST("\xE2\x80\x8E");
1394          break;
1395       case '1':
1396          bip->bi_pad = 2;
1397          /* FALLTHRU */
1398       default:
1399          bip->bi_start.s = UNCONST("\xE2\x81\xA8");
1400          bip->bi_end.s = UNCONST("\xE2\x81\xA9");
1401          break;
1402       }
1403       bip->bi_start.l = bip->bi_end.l = 3;
1404    }
1405 #endif
1406    NYD_LEAVE;
1407 }
1408
1409 #ifdef HAVE_COLOUR
1410 FL void
1411 colour_table_create(bool_t pager_used)
1412 {
1413    union {char *cp; char const *ccp; void *vp; struct colour_table *ctp;} u;
1414    size_t i;
1415    struct colour_table *ct;
1416    NYD_ENTER;
1417
1418    if (ok_blook(colour_disable) || (pager_used && !ok_blook(colour_pager)))
1419       goto jleave;
1420    else {
1421       char *term, *okterms;
1422
1423       /* Don't use getenv(), but force copy-in into our own tables.. */
1424       if ((term = _var_voklook("TERM")) == NULL)
1425          goto jleave;
1426       /* terminfo rocks: if we find "color", assume it's right */
1427       if (strstr(term, "color") != NULL)
1428          goto jok;
1429       if ((okterms = ok_vlook(colour_terms)) == NULL)
1430          okterms = UNCONST(COLOUR_TERMS);
1431       okterms = savestr(okterms);
1432
1433       i = strlen(term);
1434       while ((u.cp = n_strsep(&okterms, ',', TRU1)) != NULL)
1435          if (!strncmp(u.cp, term, i))
1436             goto jok;
1437       goto jleave;
1438    }
1439
1440 jok:
1441    colour_table = ct = salloc(sizeof *ct); /* XXX lex.c yet resets (FILTER!) */
1442    {  static struct {
1443          enum okeys        okey;
1444          enum colourspec   cspec;
1445          char const        *defval;
1446       } const map[] = {
1447          {ok_v_colour_msginfo,  COLOURSPEC_MSGINFO,  COLOUR_MSGINFO},
1448          {ok_v_colour_partinfo, COLOURSPEC_PARTINFO, COLOUR_PARTINFO},
1449          {ok_v_colour_from_,    COLOURSPEC_FROM_,    COLOUR_FROM_},
1450          {ok_v_colour_header,   COLOURSPEC_HEADER,   COLOUR_HEADER},
1451          {ok_v_colour_uheader,  COLOURSPEC_UHEADER,  COLOUR_UHEADER}
1452       };
1453
1454       for (i = 0; i < NELEM(map); ++i) {
1455          if ((u.cp = _var_oklook(map[i].okey)) == NULL)
1456             u.ccp = map[i].defval;
1457          u.cp = _colour_iso6429(u.ccp);
1458          ct->ct_csinfo[map[i].cspec].l = strlen(u.cp);
1459          ct->ct_csinfo[map[i].cspec].s = u.cp;
1460       }
1461    }
1462    ct->ct_csinfo[COLOURSPEC_RESET].l = sizeof("\033[0m") -1;
1463    ct->ct_csinfo[COLOURSPEC_RESET].s = UNCONST("\033[0m");
1464
1465    if ((u.cp = ok_vlook(colour_user_headers)) == NULL)
1466       u.ccp = COLOUR_USER_HEADERS;
1467    ct->ct_csinfo[COLOURSPEC_RESET + 1].l = i = strlen(u.ccp);
1468    ct->ct_csinfo[COLOURSPEC_RESET + 1].s = (i == 0) ? NULL : savestr(u.ccp);
1469 jleave:
1470    NYD_LEAVE;
1471 }
1472
1473 FL void
1474 colour_put(FILE *fp, enum colourspec cs)
1475 {
1476    NYD_ENTER;
1477    if (colour_table != NULL) {
1478       struct str const *cp = colour_get(cs);
1479
1480       fwrite(cp->s, cp->l, 1, fp);
1481    }
1482    NYD_LEAVE;
1483 }
1484
1485 FL void
1486 colour_put_header(FILE *fp, char const *name)
1487 {
1488    enum colourspec cs = COLOURSPEC_HEADER;
1489    struct str const *uheads;
1490    char *cp, *cp_base, *x;
1491    size_t namelen;
1492    NYD_ENTER;
1493
1494    if (colour_table == NULL)
1495       goto j_leave;
1496    /* Normal header colours if there are no user headers */
1497    uheads = colour_table->ct_csinfo + COLOURSPEC_RESET + 1;
1498    if (uheads->s == NULL)
1499       goto jleave;
1500
1501    /* Iterate over all entries in the *colour-user-headers* list */
1502    cp = ac_alloc(uheads->l +1);
1503    memcpy(cp, uheads->s, uheads->l +1);
1504    cp_base = cp;
1505    namelen = strlen(name);
1506    while ((x = n_strsep(&cp, ',', TRU1)) != NULL) {
1507       size_t l = (cp != NULL) ? PTR2SIZE(cp - x) - 1 : strlen(x);
1508       if (l == namelen && !ascncasecmp(x, name, namelen)) {
1509          cs = COLOURSPEC_UHEADER;
1510          break;
1511       }
1512    }
1513    ac_free(cp_base);
1514 jleave:
1515    colour_put(fp, cs);
1516 j_leave:
1517    NYD_LEAVE;
1518 }
1519
1520 FL void
1521 colour_reset(FILE *fp)
1522 {
1523    NYD_ENTER;
1524    if (colour_table != NULL)
1525       fwrite("\033[0m", 4, 1, fp);
1526    NYD_LEAVE;
1527 }
1528
1529 FL struct str const *
1530 colour_get(enum colourspec cs)
1531 {
1532    struct str const *rv = NULL;
1533    NYD_ENTER;
1534
1535    if (colour_table != NULL)
1536       if ((rv = colour_table->ct_csinfo + cs)->s == NULL)
1537          rv = NULL;
1538    NYD_LEAVE;
1539    return rv;
1540 }
1541 #endif /* HAVE_COLOUR */
1542
1543 FL void
1544 time_current_update(struct time_current *tc, bool_t full_update)
1545 {
1546    NYD_ENTER;
1547    tc->tc_time = time(NULL);
1548    if (full_update) {
1549       memcpy(&tc->tc_gm, gmtime(&tc->tc_time), sizeof tc->tc_gm);
1550       memcpy(&tc->tc_local, localtime(&tc->tc_time), sizeof tc->tc_local);
1551       sstpcpy(tc->tc_ctime, ctime(&tc->tc_time));
1552    }
1553    NYD_LEAVE;
1554 }
1555
1556 static void
1557 _out_of_memory(void)
1558 {
1559    panic("no memory");
1560 }
1561
1562 #ifndef HAVE_DEBUG
1563 FL void *
1564 smalloc(size_t s SMALLOC_DEBUG_ARGS)
1565 {
1566    void *rv;
1567    NYD_ENTER;
1568
1569    if (s == 0)
1570       s = 1;
1571    if ((rv = malloc(s)) == NULL)
1572       _out_of_memory();
1573    NYD_LEAVE;
1574    return rv;
1575 }
1576
1577 FL void *
1578 srealloc(void *v, size_t s SMALLOC_DEBUG_ARGS)
1579 {
1580    void *rv;
1581    NYD_ENTER;
1582
1583    if (s == 0)
1584       s = 1;
1585    if (v == NULL)
1586       rv = smalloc(s);
1587    else if ((rv = realloc(v, s)) == NULL)
1588       _out_of_memory();
1589    NYD_LEAVE;
1590    return rv;
1591 }
1592
1593 FL void *
1594 scalloc(size_t nmemb, size_t size SMALLOC_DEBUG_ARGS)
1595 {
1596    void *rv;
1597    NYD_ENTER;
1598
1599    if (size == 0)
1600       size = 1;
1601    if ((rv = calloc(nmemb, size)) == NULL)
1602       _out_of_memory();
1603    NYD_LEAVE;
1604    return rv;
1605 }
1606
1607 #else /* !HAVE_DEBUG */
1608 CTA(sizeof(char) == sizeof(ui8_t));
1609
1610 # define _HOPE_SIZE        (2 * 8 * sizeof(char))
1611 # define _HOPE_SET(C)   \
1612 do {\
1613    union mem_ptr __xl, __xu;\
1614    struct mem_chunk *__xc;\
1615    __xl.p_p = (C).p_p;\
1616    __xc = __xl.p_c - 1;\
1617    __xu.p_p = __xc;\
1618    (C).p_cp += 8;\
1619    __xl.p_ui8p[0]=0xDE; __xl.p_ui8p[1]=0xAA;\
1620    __xl.p_ui8p[2]=0x55; __xl.p_ui8p[3]=0xAD;\
1621    __xl.p_ui8p[4]=0xBE; __xl.p_ui8p[5]=0x55;\
1622    __xl.p_ui8p[6]=0xAA; __xl.p_ui8p[7]=0xEF;\
1623    __xu.p_ui8p += __xc->mc_size - 8;\
1624    __xu.p_ui8p[0]=0xDE; __xu.p_ui8p[1]=0xAA;\
1625    __xu.p_ui8p[2]=0x55; __xu.p_ui8p[3]=0xAD;\
1626    __xu.p_ui8p[4]=0xBE; __xu.p_ui8p[5]=0x55;\
1627    __xu.p_ui8p[6]=0xAA; __xu.p_ui8p[7]=0xEF;\
1628 } while (0)
1629 # define _HOPE_GET_TRACE(C,BAD) \
1630 do {\
1631    (C).p_cp += 8;\
1632    _HOPE_GET(C, BAD);\
1633    (C).p_cp += 8;\
1634 } while(0)
1635 # define _HOPE_GET(C,BAD) \
1636 do {\
1637    union mem_ptr __xl, __xu;\
1638    struct mem_chunk *__xc;\
1639    ui32_t __i;\
1640    __xl.p_p = (C).p_p;\
1641    __xl.p_cp -= 8;\
1642    (C).p_cp = __xl.p_cp;\
1643    __xc = __xl.p_c - 1;\
1644    (BAD) = FAL0;\
1645    __i = 0;\
1646    if (__xl.p_ui8p[0] != 0xDE) __i |= 1<<0;\
1647    if (__xl.p_ui8p[1] != 0xAA) __i |= 1<<1;\
1648    if (__xl.p_ui8p[2] != 0x55) __i |= 1<<2;\
1649    if (__xl.p_ui8p[3] != 0xAD) __i |= 1<<3;\
1650    if (__xl.p_ui8p[4] != 0xBE) __i |= 1<<4;\
1651    if (__xl.p_ui8p[5] != 0x55) __i |= 1<<5;\
1652    if (__xl.p_ui8p[6] != 0xAA) __i |= 1<<6;\
1653    if (__xl.p_ui8p[7] != 0xEF) __i |= 1<<7;\
1654    if (__i != 0) {\
1655       (BAD) = TRU1;\
1656       alert("%p: corrupt lower canary: 0x%02X: %s, line %u",\
1657          __xl.p_p, __i, mdbg_file, mdbg_line);\
1658    }\
1659    __xu.p_p = __xc;\
1660    __xu.p_ui8p += __xc->mc_size - 8;\
1661    __i = 0;\
1662    if (__xu.p_ui8p[0] != 0xDE) __i |= 1<<0;\
1663    if (__xu.p_ui8p[1] != 0xAA) __i |= 1<<1;\
1664    if (__xu.p_ui8p[2] != 0x55) __i |= 1<<2;\
1665    if (__xu.p_ui8p[3] != 0xAD) __i |= 1<<3;\
1666    if (__xu.p_ui8p[4] != 0xBE) __i |= 1<<4;\
1667    if (__xu.p_ui8p[5] != 0x55) __i |= 1<<5;\
1668    if (__xu.p_ui8p[6] != 0xAA) __i |= 1<<6;\
1669    if (__xu.p_ui8p[7] != 0xEF) __i |= 1<<7;\
1670    if (__i != 0) {\
1671       (BAD) = TRU1;\
1672       alert("%p: corrupt upper canary: 0x%02X: %s, line %u",\
1673          __xl.p_p, __i, mdbg_file, mdbg_line);\
1674    }\
1675    if (BAD)\
1676       alert("   ..canary last seen: %s, line %u",\
1677          __xc->mc_file, __xc->mc_line);\
1678 } while (0)
1679
1680 FL void *
1681 (smalloc)(size_t s SMALLOC_DEBUG_ARGS)
1682 {
1683    union mem_ptr p;
1684    NYD_ENTER;
1685
1686    if (s == 0)
1687       s = 1;
1688    s += sizeof(struct mem_chunk) + _HOPE_SIZE;
1689
1690    if ((p.p_p = (malloc)(s)) == NULL)
1691       _out_of_memory();
1692    p.p_c->mc_prev = NULL;
1693    if ((p.p_c->mc_next = _mem_list) != NULL)
1694       _mem_list->mc_prev = p.p_c;
1695    p.p_c->mc_file = mdbg_file;
1696    p.p_c->mc_line = (ui16_t)mdbg_line;
1697    p.p_c->mc_isfree = FAL0;
1698    p.p_c->mc_size = (ui32_t)s;
1699    _mem_list = p.p_c++;
1700    _HOPE_SET(p);
1701
1702    ++_mem_aall;
1703    ++_mem_acur;
1704    _mem_amax = MAX(_mem_amax, _mem_acur);
1705    _mem_mall += s;
1706    _mem_mcur += s;
1707    _mem_mmax = MAX(_mem_mmax, _mem_mcur);
1708    NYD_LEAVE;
1709    return p.p_p;
1710 }
1711
1712 FL void *
1713 (srealloc)(void *v, size_t s SMALLOC_DEBUG_ARGS)
1714 {
1715    union mem_ptr p;
1716    bool_t isbad;
1717    NYD_ENTER;
1718
1719    if ((p.p_p = v) == NULL) {
1720       p.p_p = (smalloc)(s, mdbg_file, mdbg_line);
1721       goto jleave;
1722    }
1723
1724    _HOPE_GET(p, isbad);
1725    --p.p_c;
1726    if (p.p_c->mc_isfree) {
1727       fprintf(stderr, "srealloc(): region freed!  At %s, line %d\n"
1728          "\tLast seen: %s, line %d\n",
1729          mdbg_file, mdbg_line, p.p_c->mc_file, p.p_c->mc_line);
1730       goto jforce;
1731    }
1732
1733    if (p.p_c == _mem_list)
1734       _mem_list = p.p_c->mc_next;
1735    else
1736       p.p_c->mc_prev->mc_next = p.p_c->mc_next;
1737    if (p.p_c->mc_next != NULL)
1738       p.p_c->mc_next->mc_prev = p.p_c->mc_prev;
1739
1740    --_mem_acur;
1741    _mem_mcur -= p.p_c->mc_size;
1742 jforce:
1743    if (s == 0)
1744       s = 1;
1745    s += sizeof(struct mem_chunk) + _HOPE_SIZE;
1746
1747    if ((p.p_p = (realloc)(p.p_c, s)) == NULL)
1748       _out_of_memory();
1749    p.p_c->mc_prev = NULL;
1750    if ((p.p_c->mc_next = _mem_list) != NULL)
1751       _mem_list->mc_prev = p.p_c;
1752    p.p_c->mc_file = mdbg_file;
1753    p.p_c->mc_line = (ui16_t)mdbg_line;
1754    p.p_c->mc_isfree = FAL0;
1755    p.p_c->mc_size = (ui32_t)s;
1756    _mem_list = p.p_c++;
1757    _HOPE_SET(p);
1758
1759    ++_mem_aall;
1760    ++_mem_acur;
1761    _mem_amax = MAX(_mem_amax, _mem_acur);
1762    _mem_mall += s;
1763    _mem_mcur += s;
1764    _mem_mmax = MAX(_mem_mmax, _mem_mcur);
1765 jleave:
1766    NYD_LEAVE;
1767    return p.p_p;
1768 }
1769
1770 FL void *
1771 (scalloc)(size_t nmemb, size_t size SMALLOC_DEBUG_ARGS)
1772 {
1773    union mem_ptr p;
1774    NYD_ENTER;
1775
1776    if (size == 0)
1777       size = 1;
1778    if (nmemb == 0)
1779       nmemb = 1;
1780    size *= nmemb;
1781    size += sizeof(struct mem_chunk) + _HOPE_SIZE;
1782
1783    if ((p.p_p = (malloc)(size)) == NULL)
1784       _out_of_memory();
1785    memset(p.p_p, 0, size);
1786    p.p_c->mc_prev = NULL;
1787    if ((p.p_c->mc_next = _mem_list) != NULL)
1788       _mem_list->mc_prev = p.p_c;
1789    p.p_c->mc_file = mdbg_file;
1790    p.p_c->mc_line = (ui16_t)mdbg_line;
1791    p.p_c->mc_isfree = FAL0;
1792    p.p_c->mc_size = (ui32_t)size;
1793    _mem_list = p.p_c++;
1794    _HOPE_SET(p);
1795
1796    ++_mem_aall;
1797    ++_mem_acur;
1798    _mem_amax = MAX(_mem_amax, _mem_acur);
1799    _mem_mall += size;
1800    _mem_mcur += size;
1801    _mem_mmax = MAX(_mem_mmax, _mem_mcur);
1802    NYD_LEAVE;
1803    return p.p_p;
1804 }
1805
1806 FL void
1807 (sfree)(void *v SMALLOC_DEBUG_ARGS)
1808 {
1809    union mem_ptr p;
1810    bool_t isbad;
1811    NYD_ENTER;
1812
1813    if ((p.p_p = v) == NULL) {
1814       fprintf(stderr, "sfree(NULL) from %s, line %d\n", mdbg_file, mdbg_line);
1815       goto jleave;
1816    }
1817
1818    _HOPE_GET(p, isbad);
1819    --p.p_c;
1820    if (p.p_c->mc_isfree) {
1821       fprintf(stderr, "sfree(): double-free avoided at %s, line %d\n"
1822          "\tLast seen: %s, line %d\n",
1823          mdbg_file, mdbg_line, p.p_c->mc_file, p.p_c->mc_line);
1824       goto jleave;
1825    }
1826
1827    if (p.p_c == _mem_list)
1828       _mem_list = p.p_c->mc_next;
1829    else
1830       p.p_c->mc_prev->mc_next = p.p_c->mc_next;
1831    if (p.p_c->mc_next != NULL)
1832       p.p_c->mc_next->mc_prev = p.p_c->mc_prev;
1833    p.p_c->mc_isfree = TRU1;
1834
1835    --_mem_acur;
1836    _mem_mcur -= p.p_c->mc_size;
1837
1838    if (options & OPT_DEBUG) {
1839       p.p_c->mc_next = _mem_free;
1840       _mem_free = p.p_c;
1841    } else
1842       (free)(p.p_c);
1843 jleave:
1844    NYD_LEAVE;
1845 }
1846
1847 FL void
1848 smemreset(void)
1849 {
1850    union mem_ptr p;
1851    size_t c = 0, s = 0;
1852    NYD_ENTER;
1853
1854    for (p.p_c = _mem_free; p.p_c != NULL;) {
1855       void *vp = p.p_c;
1856       ++c;
1857       s += p.p_c->mc_size;
1858       p.p_c = p.p_c->mc_next;
1859       (free)(vp);
1860    }
1861    _mem_free = NULL;
1862
1863    if (options & OPT_DEBUG)
1864       fprintf(stderr, "smemreset(): freed %" ZFMT " chunks/%" ZFMT " bytes\n",
1865          c, s);
1866    NYD_LEAVE;
1867 }
1868
1869 FL int
1870 c_smemtrace(void *v)
1871 {
1872    /* For _HOPE_GET() */
1873    char const * const mdbg_file = "smemtrace()";
1874    int const mdbg_line = -1;
1875    FILE *fp;
1876    union mem_ptr p, xp;
1877    bool_t isbad;
1878    size_t lines;
1879    NYD_ENTER;
1880
1881    v = (void*)0x1;
1882    if ((fp = Ftmp(NULL, "memtr", OF_RDWR | OF_UNLINK | OF_REGISTER, 0600)) ==
1883          NULL) {
1884       perror("tmpfile");
1885       goto jleave;
1886    }
1887
1888    fprintf(fp, "Memory statistics:\n"
1889       "  Count cur/peek/all: %7" ZFMT "/%7" ZFMT "/%10" ZFMT "\n"
1890       "  Bytes cur/peek/all: %7" ZFMT "/%7" ZFMT "/%10" ZFMT "\n\n",
1891       _mem_acur, _mem_amax, _mem_aall, _mem_mcur, _mem_mmax, _mem_mall);
1892
1893    fprintf(fp, "Currently allocated memory chunks:\n");
1894    for (lines = 0, p.p_c = _mem_list; p.p_c != NULL;
1895          ++lines, p.p_c = p.p_c->mc_next) {
1896       xp = p;
1897       ++xp.p_c;
1898       _HOPE_GET_TRACE(xp, isbad);
1899       fprintf(fp, "%s%p (%5" ZFMT " bytes): %s, line %u\n",
1900          (isbad ? "! CANARY ERROR: " : ""), xp.p_p,
1901          (size_t)(p.p_c->mc_size - sizeof(struct mem_chunk)), p.p_c->mc_file,
1902          p.p_c->mc_line);
1903    }
1904
1905    if (options & OPT_DEBUG) {
1906       fprintf(fp, "sfree()d memory chunks awaiting free():\n");
1907       for (p.p_c = _mem_free; p.p_c != NULL; ++lines, p.p_c = p.p_c->mc_next) {
1908          xp = p;
1909          ++xp.p_c;
1910          _HOPE_GET_TRACE(xp, isbad);
1911          fprintf(fp, "%s%p (%5" ZFMT " bytes): %s, line %u\n",
1912             (isbad ? "! CANARY ERROR: " : ""), xp.p_p,
1913             (size_t)(p.p_c->mc_size - sizeof(struct mem_chunk)),
1914             p.p_c->mc_file, p.p_c->mc_line);
1915       }
1916    }
1917
1918    page_or_print(fp, lines);
1919    Fclose(fp);
1920    v = NULL;
1921 jleave:
1922    NYD_LEAVE;
1923    return (v != NULL);
1924 }
1925
1926 # ifdef _HAVE_MEMCHECK
1927 FL bool_t
1928 _smemcheck(char const *mdbg_file, int mdbg_line)
1929 {
1930    union mem_ptr p, xp;
1931    bool_t anybad = FAL0, isbad;
1932    size_t lines;
1933    NYD_ENTER;
1934
1935    for (lines = 0, p.p_c = _mem_list; p.p_c != NULL;
1936          ++lines, p.p_c = p.p_c->mc_next) {
1937       xp = p;
1938       ++xp.p_c;
1939       _HOPE_GET_TRACE(xp, isbad);
1940       if (isbad) {
1941          anybad = TRU1;
1942          fprintf(stderr,
1943             "! CANARY ERROR: %p (%5" ZFMT " bytes): %s, line %u\n",
1944             xp.p_p, (size_t)(p.p_c->mc_size - sizeof(struct mem_chunk)),
1945             p.p_c->mc_file, p.p_c->mc_line);
1946       }
1947    }
1948
1949    if (options & OPT_DEBUG) {
1950       for (p.p_c = _mem_free; p.p_c != NULL; ++lines, p.p_c = p.p_c->mc_next) {
1951          xp = p;
1952          ++xp.p_c;
1953          _HOPE_GET_TRACE(xp, isbad);
1954          if (isbad) {
1955             anybad = TRU1;
1956             fprintf(stderr,
1957                "! CANARY ERROR: %p (%5" ZFMT " bytes): %s, line %u\n",
1958                xp.p_p, (size_t)(p.p_c->mc_size - sizeof(struct mem_chunk)),
1959                p.p_c->mc_file, p.p_c->mc_line);
1960          }
1961       }
1962    }
1963    NYD_LEAVE;
1964    return anybad;
1965 }
1966 # endif /* _HAVE_MEMCHECK */
1967
1968 # undef _HOPE_SIZE
1969 # undef _HOPE_SET
1970 # undef _HOPE_GET_TRACE
1971 # undef _HOPE_GET
1972 #endif /* HAVE_DEBUG */
1973
1974 /* vim:set fenc=utf-8:s-it-mode */