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] %.25s (%.16s:%u)\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    NYD2_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    NYD2_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    NYD2_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    NYD2_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    NYD2_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    NYD2_LEAVE;
 282    return rv;
 283 }
 284
 285 FL void
 286 hold_all_sigs(void)
 287 {
 288    NYD2_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    NYD2_LEAVE;
 304 }
 305
 306 FL void
 307 rele_all_sigs(void)
 308 {
 309    NYD2_ENTER;
 310    if (--_alls_depth == 0)
 311       sigprocmask(SIG_SETMASK, &_alls_oset, (sigset_t*)NULL);
 312    NYD2_LEAVE;
 313 }
 314
 315 FL void
 316 hold_sigs(void)
 317 {
 318    NYD2_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    NYD2_LEAVE;
 327 }
 328
 329 FL void
 330 rele_sigs(void)
 331 {
 332    NYD2_ENTER;
 333    if (--_hold_sigdepth == 0)
 334       sigprocmask(SIG_SETMASK, &_hold_oset, NULL);
 335    NYD2_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       *env_addon = NULL;
 444       if (strstr(cp, "less") != NULL) {
 445          if (getenv("LESS") == NULL)
 446             *env_addon = "LESS=FRSXi";
 447       } else if (strstr(cp, "lv") != NULL) {
 448          if (getenv("LV") == NULL)
 449             *env_addon = "LV=-c";
 450       }
 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    NYD2_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    NYD2_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
 875    /* Base64 includes + and /, replace them with _ and - */
 876    for (data = b64.s; length-- > 0; ++data)
 877       if (*data == '+')
 878          *data = '_';
 879       else if (*data == '/')
 880          *data = '-';
 881    NYD_LEAVE;
 882    return b64.s;
 883 }
 884
 885 FL enum okay
 886 makedir(char const *name)
 887 {
 888    struct stat st;
 889    enum okay rv = STOP;
 890    NYD_ENTER;
 891
 892    if (!mkdir(name, 0700))
 893       rv = OKAY;
 894    else {
 895       int e = errno;
 896       if ((e == EEXIST || e == ENOSYS) && !stat(name, &st) &&
 897             S_ISDIR(st.st_mode))
 898          rv = OKAY;
 899    }
 900    NYD_LEAVE;
 901    return rv;
 902 }
 903
 904 #ifdef HAVE_FCHDIR
 905 FL enum okay
 906 cwget(struct cw *cw)
 907 {
 908    enum okay rv = STOP;
 909    NYD_ENTER;
 910
 911    if ((cw->cw_fd = open(".", O_RDONLY)) == -1)
 912       goto jleave;
 913    if (fchdir(cw->cw_fd) == -1) {
 914       close(cw->cw_fd);
 915       goto jleave;
 916    }
 917    rv = OKAY;
 918 jleave:
 919    NYD_LEAVE;
 920    return rv;
 921 }
 922
 923 FL enum okay
 924 cwret(struct cw *cw)
 925 {
 926    enum okay rv = STOP;
 927    NYD_ENTER;
 928
 929    if (!fchdir(cw->cw_fd))
 930       rv = OKAY;
 931    NYD_LEAVE;
 932    return rv;
 933 }
 934
 935 FL void
 936 cwrelse(struct cw *cw)
 937 {
 938    NYD_ENTER;
 939    close(cw->cw_fd);
 940    NYD_LEAVE;
 941 }
 942
 943 #else /* !HAVE_FCHDIR */
 944 FL enum okay
 945 cwget(struct cw *cw)
 946 {
 947    enum okay rv = STOP;
 948    NYD_ENTER;
 949
 950    if (getcwd(cw->cw_wd, sizeof cw->cw_wd) != NULL && !chdir(cw->cw_wd))
 951       rv = OKAY;
 952    NYD_LEAVE;
 953    return rv;
 954 }
 955
 956 FL enum okay
 957 cwret(struct cw *cw)
 958 {
 959    enum okay rv = STOP;
 960    NYD_ENTER;
 961
 962    if (!chdir(cw->cw_wd))
 963       rv = OKAY;
 964    NYD_LEAVE;
 965    return rv;
 966 }
 967
 968 FL void
 969 cwrelse(struct cw *cw)
 970 {
 971    NYD_ENTER;
 972    UNUSED(cw);
 973    NYD_LEAVE;
 974 }
 975 #endif /* !HAVE_FCHDIR */
 976
 977 FL size_t
 978 field_detect_clip(size_t maxlen, char const *buf, size_t blen)/*TODO mbrtowc()*/
 979 {
 980    size_t rv;
 981    NYD_ENTER;
 982
 983 #ifdef HAVE_NATCH_CHAR
 984    maxlen = MIN(maxlen, blen);
 985    for (rv = 0; maxlen > 0;) {
 986       int ml = mblen(buf, maxlen);
 987       if (ml <= 0) {
 988          mblen(NULL, 0);
 989          break;
 990       }
 991       buf += ml;
 992       rv += ml;
 993       maxlen -= ml;
 994    }
 995 #else
 996    rv = MIN(blen, maxlen);
 997 #endif
 998    NYD_LEAVE;
 999    return rv;
1000 }
1001
1002 FL size_t
1003 field_put_bidi_clip(char *store, size_t maxlen, char const *buf, size_t blen)
1004 {
1005    NATCH_CHAR( struct bidi_info bi; )
1006    size_t rv NATCH_CHAR( COMMA i );
1007    NYD_ENTER;
1008
1009    rv = 0;
1010    if (maxlen-- == 0)
1011       goto j_leave;
1012
1013 #ifdef HAVE_NATCH_CHAR
1014    bidi_info_create(&bi);
1015    if (bi.bi_start.l == 0 || !bidi_info_needed(buf, blen)) {
1016       bi.bi_end.l = 0;
1017       goto jnobidi;
1018    }
1019
1020    if (maxlen >= (i = bi.bi_pad + bi.bi_end.l + bi.bi_start.l))
1021       maxlen -= i;
1022    else
1023       goto jleave;
1024
1025    if ((i = bi.bi_start.l) > 0) {
1026       memcpy(store, bi.bi_start.s, i);
1027       store += i;
1028       rv += i;
1029    }
1030
1031 jnobidi:
1032    while (maxlen > 0) {
1033       int ml = mblen(buf, blen);
1034       if (ml <= 0) {
1035          mblen(NULL, 0);
1036          break;
1037       }
1038       if (UICMP(z, maxlen, <, ml))
1039          break;
1040       if (ml == 1)
1041          *store = *buf;
1042       else
1043          memcpy(store, buf, ml);
1044       store += ml;
1045       buf += ml;
1046       rv += ml;
1047       maxlen -= ml;
1048    }
1049
1050    if ((i = bi.bi_end.l) > 0) {
1051       memcpy(store, bi.bi_end.s, i);
1052       store += i;
1053       rv += i;
1054    }
1055 jleave:
1056    *store = '\0';
1057
1058 #else
1059    rv = MIN(blen, maxlen);
1060    memcpy(store, buf, rv);
1061    store[rv] = '\0';
1062 #endif
1063 j_leave:
1064    NYD_LEAVE;
1065    return rv;
1066 }
1067
1068 FL char *
1069 colalign(char const *cp, int col, int fill, int *cols_decr_used_or_null)
1070 {
1071    NATCH_CHAR( struct bidi_info bi; )
1072    int col_orig = col, n, sz;
1073    bool_t isbidi, isuni, istab, isrepl;
1074    char *nb, *np;
1075    NYD_ENTER;
1076
1077    /* Bidi only on request and when there is 8-bit data */
1078    isbidi = isuni = FAL0;
1079 #ifdef HAVE_NATCH_CHAR
1080    isuni = ((options & OPT_UNICODE) != 0);
1081    bidi_info_create(&bi);
1082    if (bi.bi_start.l == 0)
1083       goto jnobidi;
1084    if (!(isbidi = bidi_info_needed(cp, strlen(cp))))
1085       goto jnobidi;
1086
1087    if ((size_t)col >= bi.bi_pad)
1088       col -= bi.bi_pad;
1089    else
1090       col = 0;
1091 jnobidi:
1092 #endif
1093
1094    np = nb = salloc(mb_cur_max * strlen(cp) +
1095          ((fill ? col : 0)
1096          NATCH_CHAR( + (isbidi ? bi.bi_start.l + bi.bi_end.l : 0) )
1097          +1));
1098
1099 #ifdef HAVE_NATCH_CHAR
1100    if (isbidi) {
1101       memcpy(np, bi.bi_start.s, bi.bi_start.l);
1102       np += bi.bi_start.l;
1103    }
1104 #endif
1105
1106    while (*cp != '\0') {
1107       istab = FAL0;
1108 #ifdef HAVE_C90AMEND1
1109       if (mb_cur_max > 1) {
1110          wchar_t  wc;
1111
1112          n = 1;
1113          isrepl = TRU1;
1114          if ((sz = mbtowc(&wc, cp, mb_cur_max)) == -1)
1115             sz = 1;
1116          else if (wc == L'\t') {
1117             cp += sz - 1; /* Silly, no such charset known (.. until S-Ctext) */
1118             isrepl = FAL0;
1119             istab = TRU1;
1120          } else if (iswprint(wc)) {
1121 # ifndef HAVE_WCWIDTH
1122             n = 1 + (wc >= 0x1100u); /* TODO use S-CText isfullwidth() */
1123 # else
1124             if ((n = wcwidth(wc)) == -1)
1125                n = 1;
1126             else
1127 # endif
1128                isrepl = FAL0;
1129          }
1130       } else
1131 #endif
1132       {
1133          n = sz = 1;
1134          istab = (*cp == '\t');
1135          isrepl = !(istab || isprint(*cp));
1136       }
1137
1138       if (n > col)
1139          break;
1140       col -= n;
1141
1142       if (isrepl) {
1143          if (isuni) {
1144             np[0] = (char)0xEFu;
1145             np[1] = (char)0xBFu;
1146             np[2] = (char)0xBDu;
1147             np += 3;
1148          } else
1149             *np++ = '?';
1150          cp += sz;
1151       } else if (istab || (sz == 1 && spacechar(*cp))) {
1152          *np++ = ' ';
1153          ++cp;
1154       } else
1155          while (sz--)
1156             *np++ = *cp++;
1157    }
1158
1159    if (fill && col != 0) {
1160       if (fill > 0) {
1161          memmove(nb + col, nb, PTR2SIZE(np - nb));
1162          memset(nb, ' ', col);
1163       } else
1164          memset(np, ' ', col);
1165       np += col;
1166       col = 0;
1167    }
1168
1169 #ifdef HAVE_NATCH_CHAR
1170    if (isbidi) {
1171       memcpy(np, bi.bi_end.s, bi.bi_end.l);
1172       np += bi.bi_end.l;
1173    }
1174 #endif
1175
1176    *np = '\0';
1177    if (cols_decr_used_or_null != NULL)
1178       *cols_decr_used_or_null -= col_orig - col;
1179    NYD_LEAVE;
1180    return nb;
1181 }
1182
1183 FL void
1184 makeprint(struct str const *in, struct str *out)
1185 {
1186    static int print_all_chars = -1;
1187
1188    char const *inp, *maxp;
1189    char *outp;
1190    DBG( size_t msz; )
1191    NYD_ENTER;
1192
1193    if (print_all_chars == -1)
1194       print_all_chars = ok_blook(print_all_chars);
1195
1196    out->s = outp = smalloc(DBG( msz = ) in->l*mb_cur_max + 2u*mb_cur_max);
1197    inp = in->s;
1198    maxp = inp + in->l;
1199
1200    if (print_all_chars) {
1201       out->l = in->l;
1202       memcpy(outp, inp, out->l);
1203       goto jleave;
1204    }
1205
1206 #ifdef HAVE_NATCH_CHAR
1207    if (mb_cur_max > 1) {
1208       char mbb[MB_LEN_MAX + 1];
1209       wchar_t wc;
1210       int i, n;
1211       bool_t isuni = ((options & OPT_UNICODE) != 0);
1212
1213       out->l = 0;
1214       while (inp < maxp) {
1215          if (*inp & 0200)
1216             n = mbtowc(&wc, inp, PTR2SIZE(maxp - inp));
1217          else {
1218             wc = *inp;
1219             n = 1;
1220          }
1221          if (n == -1) {
1222             /* FIXME Why mbtowc() resetting here?
1223              * FIXME what about ISO 2022-JP plus -- those
1224              * FIXME will loose shifts, then!
1225              * FIXME THUS - we'd need special "known points"
1226              * FIXME to do so - say, after a newline!!
1227              * FIXME WE NEED TO CHANGE ALL USES +MBLEN! */
1228             mbtowc(&wc, NULL, mb_cur_max);
1229             wc = isuni ? 0xFFFD : '?';
1230             n = 1;
1231          } else if (n == 0)
1232             n = 1;
1233          inp += n;
1234          if (!iswprint(wc) && wc != '\n' && wc != '\r' && wc != '\b' &&
1235                wc != '\t') {
1236             if ((wc & ~(wchar_t)037) == 0)
1237                wc = isuni ? 0x2400 | wc : '?';
1238             else if (wc == 0177)
1239                wc = isuni ? 0x2421 : '?';
1240             else
1241                wc = isuni ? 0x2426 : '?';
1242          }
1243          if ((n = wctomb(mbb, wc)) <= 0)
1244             continue;
1245          out->l += n;
1246          assert(out->l < msz);
1247          for (i = 0; i < n; ++i)
1248             *outp++ = mbb[i];
1249       }
1250    } else
1251 #endif /* NATCH_CHAR */
1252    {
1253       int c;
1254       while (inp < maxp) {
1255          c = *inp++ & 0377;
1256          if (!isprint(c) && c != '\n' && c != '\r' && c != '\b' && c != '\t')
1257             c = '?';
1258          *outp++ = c;
1259       }
1260       out->l = in->l;
1261    }
1262 jleave:
1263    out->s[out->l] = '\0';
1264    NYD_LEAVE;
1265 }
1266
1267 FL char *
1268 prstr(char const *s)
1269 {
1270    struct str in, out;
1271    char *rp;
1272    NYD_ENTER;
1273
1274    in.s = UNCONST(s);
1275    in.l = strlen(s);
1276    makeprint(&in, &out);
1277    rp = savestrbuf(out.s, out.l);
1278    free(out.s);
1279    NYD_LEAVE;
1280    return rp;
1281 }
1282
1283 FL int
1284 prout(char const *s, size_t sz, FILE *fp)
1285 {
1286    struct str in, out;
1287    int n;
1288    NYD_ENTER;
1289
1290    in.s = UNCONST(s);
1291    in.l = sz;
1292    makeprint(&in, &out);
1293    n = fwrite(out.s, 1, out.l, fp);
1294    free(out.s);
1295    NYD_LEAVE;
1296    return n;
1297 }
1298
1299 FL size_t
1300 putuc(int u, int c, FILE *fp)
1301 {
1302    size_t rv;
1303    NYD_ENTER;
1304    UNUSED(u);
1305
1306 #ifdef HAVE_NATCH_CHAR
1307    if ((options & OPT_UNICODE) && (u & ~(wchar_t)0177)) {
1308       char mbb[MB_LEN_MAX];
1309       int i, n;
1310
1311       if ((n = wctomb(mbb, u)) > 0) {
1312          rv = wcwidth(u);
1313          for (i = 0; i < n; ++i)
1314             if (putc(mbb[i] & 0377, fp) == EOF) {
1315                rv = 0;
1316                break;
1317             }
1318       } else if (n == 0)
1319          rv = (putc('\0', fp) != EOF);
1320       else
1321          rv = 0;
1322    } else
1323 #endif
1324       rv = (putc(c, fp) != EOF);
1325    NYD_LEAVE;
1326    return rv;
1327 }
1328
1329 FL bool_t
1330 bidi_info_needed(char const *bdat, size_t blen)
1331 {
1332    bool_t rv = FAL0;
1333    NYD_ENTER;
1334
1335 #ifdef HAVE_NATCH_CHAR
1336    if (options & OPT_UNICODE)
1337       for (; blen > 0; ++bdat, --blen) {
1338          if ((ui8_t)*bdat > 0x7F) {
1339             /* TODO Checking for BIDI character: use S-CText fromutf8
1340              * TODO plus isrighttoleft (or whatever there will be)! */
1341             ui32_t c, x = (ui8_t)*bdat;
1342
1343             if ((x & 0xE0) == 0xC0) {
1344                if (blen < 2)
1345                   break;
1346                blen -= 1;
1347                c = x & ~0xC0;
1348             } else if ((x & 0xF0) == 0xE0) {
1349                if (blen < 3)
1350                   break;
1351                blen -= 2;
1352                c = x & ~0xE0;
1353                c <<= 6;
1354                x = (ui8_t)*++bdat;
1355                c |= x & 0x7F;
1356             } else {
1357                if (blen < 4)
1358                   break;
1359                blen -= 3;
1360                c = x & ~0xF0;
1361                c <<= 6;
1362                x = (ui8_t)*++bdat;
1363                c |= x & 0x7F;
1364                c <<= 6;
1365                x = (ui8_t)*++bdat;
1366                c |= x & 0x7F;
1367             }
1368             c <<= 6;
1369             x = (ui8_t)*++bdat;
1370             c |= x & 0x7F;
1371
1372             /* (Very very fuzzy, awaiting S-CText for good) */
1373             if ((c >= 0x05BE && c <= 0x08E3) ||
1374                   (c >= 0xFB1D && c <= 0xFEFC) ||
1375                   (c >= 0x10800 && c <= 0x10C48) ||
1376                   (c >= 0x1EE00 && c <= 0x1EEF1)) {
1377                rv = TRU1;
1378                break;
1379             }
1380          }
1381       }
1382 #endif /* HAVE_NATCH_CHAR */
1383    NYD_LEAVE;
1384    return rv;
1385 }
1386
1387 FL void
1388 bidi_info_create(struct bidi_info *bip)
1389 {
1390    /* Unicode: how to isolate RIGHT-TO-LEFT scripts via *headline-bidi*
1391     * 1.1 (Jun 1993): U+200E (E2 80 8E) LEFT-TO-RIGHT MARK
1392     * 6.3 (Sep 2013): U+2068 (E2 81 A8) FIRST STRONG ISOLATE,
1393     *                 U+2069 (E2 81 A9) POP DIRECTIONAL ISOLATE
1394     * Worse results seen for: U+202D "\xE2\x80\xAD" U+202C "\xE2\x80\xAC" */
1395    NATCH_CHAR( char const *hb; )
1396    NYD_ENTER;
1397
1398    memset(bip, 0, sizeof *bip);
1399    bip->bi_start.s = bip->bi_end.s = UNCONST("");
1400
1401 #ifdef HAVE_NATCH_CHAR
1402    if ((options & OPT_UNICODE) && (hb = ok_vlook(headline_bidi)) != NULL) {
1403       switch (*hb) {
1404       case '3':
1405          bip->bi_pad = 2;
1406          /* FALLTHRU */
1407       case '2':
1408          bip->bi_start.s = bip->bi_end.s = UNCONST("\xE2\x80\x8E");
1409          break;
1410       case '1':
1411          bip->bi_pad = 2;
1412          /* FALLTHRU */
1413       default:
1414          bip->bi_start.s = UNCONST("\xE2\x81\xA8");
1415          bip->bi_end.s = UNCONST("\xE2\x81\xA9");
1416          break;
1417       }
1418       bip->bi_start.l = bip->bi_end.l = 3;
1419    }
1420 #endif
1421    NYD_LEAVE;
1422 }
1423
1424 #ifdef HAVE_COLOUR
1425 FL void
1426 colour_table_create(bool_t pager_used)
1427 {
1428    union {char *cp; char const *ccp; void *vp; struct colour_table *ctp;} u;
1429    size_t i;
1430    struct colour_table *ct;
1431    NYD_ENTER;
1432
1433    if (ok_blook(colour_disable) || (pager_used && !ok_blook(colour_pager)))
1434       goto jleave;
1435    else {
1436       char *term, *okterms;
1437
1438       /* Don't use getenv(), but force copy-in into our own tables.. */
1439       if ((term = _var_voklook("TERM")) == NULL)
1440          goto jleave;
1441       /* terminfo rocks: if we find "color", assume it's right */
1442       if (strstr(term, "color") != NULL)
1443          goto jok;
1444       if ((okterms = ok_vlook(colour_terms)) == NULL)
1445          okterms = UNCONST(COLOUR_TERMS);
1446       okterms = savestr(okterms);
1447
1448       i = strlen(term);
1449       while ((u.cp = n_strsep(&okterms, ',', TRU1)) != NULL)
1450          if (!strncmp(u.cp, term, i))
1451             goto jok;
1452       goto jleave;
1453    }
1454
1455 jok:
1456    colour_table = ct = salloc(sizeof *ct); /* XXX lex.c yet resets (FILTER!) */
1457    {  static struct {
1458          enum okeys        okey;
1459          enum colourspec   cspec;
1460          char const        *defval;
1461       } const map[] = {
1462          {ok_v_colour_msginfo,  COLOURSPEC_MSGINFO,  COLOUR_MSGINFO},
1463          {ok_v_colour_partinfo, COLOURSPEC_PARTINFO, COLOUR_PARTINFO},
1464          {ok_v_colour_from_,    COLOURSPEC_FROM_,    COLOUR_FROM_},
1465          {ok_v_colour_header,   COLOURSPEC_HEADER,   COLOUR_HEADER},
1466          {ok_v_colour_uheader,  COLOURSPEC_UHEADER,  COLOUR_UHEADER}
1467       };
1468
1469       for (i = 0; i < NELEM(map); ++i) {
1470          if ((u.cp = _var_oklook(map[i].okey)) == NULL)
1471             u.ccp = map[i].defval;
1472          u.cp = _colour_iso6429(u.ccp);
1473          ct->ct_csinfo[map[i].cspec].l = strlen(u.cp);
1474          ct->ct_csinfo[map[i].cspec].s = u.cp;
1475       }
1476    }
1477    ct->ct_csinfo[COLOURSPEC_RESET].l = sizeof("\033[0m") -1;
1478    ct->ct_csinfo[COLOURSPEC_RESET].s = UNCONST("\033[0m");
1479
1480    if ((u.cp = ok_vlook(colour_user_headers)) == NULL)
1481       u.ccp = COLOUR_USER_HEADERS;
1482    ct->ct_csinfo[COLOURSPEC_RESET + 1].l = i = strlen(u.ccp);
1483    ct->ct_csinfo[COLOURSPEC_RESET + 1].s = (i == 0) ? NULL : savestr(u.ccp);
1484 jleave:
1485    NYD_LEAVE;
1486 }
1487
1488 FL void
1489 colour_put(FILE *fp, enum colourspec cs)
1490 {
1491    NYD_ENTER;
1492    if (colour_table != NULL) {
1493       struct str const *cp = colour_get(cs);
1494
1495       fwrite(cp->s, cp->l, 1, fp);
1496    }
1497    NYD_LEAVE;
1498 }
1499
1500 FL void
1501 colour_put_header(FILE *fp, char const *name)
1502 {
1503    enum colourspec cs = COLOURSPEC_HEADER;
1504    struct str const *uheads;
1505    char *cp, *cp_base, *x;
1506    size_t namelen;
1507    NYD_ENTER;
1508
1509    if (colour_table == NULL)
1510       goto j_leave;
1511    /* Normal header colours if there are no user headers */
1512    uheads = colour_table->ct_csinfo + COLOURSPEC_RESET + 1;
1513    if (uheads->s == NULL)
1514       goto jleave;
1515
1516    /* Iterate over all entries in the *colour-user-headers* list */
1517    cp = ac_alloc(uheads->l +1);
1518    memcpy(cp, uheads->s, uheads->l +1);
1519    cp_base = cp;
1520    namelen = strlen(name);
1521    while ((x = n_strsep(&cp, ',', TRU1)) != NULL) {
1522       size_t l = (cp != NULL) ? PTR2SIZE(cp - x) - 1 : strlen(x);
1523       if (l == namelen && !ascncasecmp(x, name, namelen)) {
1524          cs = COLOURSPEC_UHEADER;
1525          break;
1526       }
1527    }
1528    ac_free(cp_base);
1529 jleave:
1530    colour_put(fp, cs);
1531 j_leave:
1532    NYD_LEAVE;
1533 }
1534
1535 FL void
1536 colour_reset(FILE *fp)
1537 {
1538    NYD_ENTER;
1539    if (colour_table != NULL)
1540       fwrite("\033[0m", 4, 1, fp);
1541    NYD_LEAVE;
1542 }
1543
1544 FL struct str const *
1545 colour_get(enum colourspec cs)
1546 {
1547    struct str const *rv = NULL;
1548    NYD_ENTER;
1549
1550    if (colour_table != NULL)
1551       if ((rv = colour_table->ct_csinfo + cs)->s == NULL)
1552          rv = NULL;
1553    NYD_LEAVE;
1554    return rv;
1555 }
1556 #endif /* HAVE_COLOUR */
1557
1558 FL void
1559 time_current_update(struct time_current *tc, bool_t full_update)
1560 {
1561    NYD_ENTER;
1562    tc->tc_time = time(NULL);
1563    if (full_update) {
1564       memcpy(&tc->tc_gm, gmtime(&tc->tc_time), sizeof tc->tc_gm);
1565       memcpy(&tc->tc_local, localtime(&tc->tc_time), sizeof tc->tc_local);
1566       sstpcpy(tc->tc_ctime, ctime(&tc->tc_time));
1567    }
1568    NYD_LEAVE;
1569 }
1570
1571 static void
1572 _out_of_memory(void)
1573 {
1574    panic("no memory");
1575 }
1576
1577 #ifndef HAVE_DEBUG
1578 FL void *
1579 smalloc(size_t s SMALLOC_DEBUG_ARGS)
1580 {
1581    void *rv;
1582    NYD2_ENTER;
1583
1584    if (s == 0)
1585       s = 1;
1586    if ((rv = malloc(s)) == NULL)
1587       _out_of_memory();
1588    NYD2_LEAVE;
1589    return rv;
1590 }
1591
1592 FL void *
1593 srealloc(void *v, size_t s SMALLOC_DEBUG_ARGS)
1594 {
1595    void *rv;
1596    NYD2_ENTER;
1597
1598    if (s == 0)
1599       s = 1;
1600    if (v == NULL)
1601       rv = smalloc(s);
1602    else if ((rv = realloc(v, s)) == NULL)
1603       _out_of_memory();
1604    NYD2_LEAVE;
1605    return rv;
1606 }
1607
1608 FL void *
1609 scalloc(size_t nmemb, size_t size SMALLOC_DEBUG_ARGS)
1610 {
1611    void *rv;
1612    NYD2_ENTER;
1613
1614    if (size == 0)
1615       size = 1;
1616    if ((rv = calloc(nmemb, size)) == NULL)
1617       _out_of_memory();
1618    NYD2_LEAVE;
1619    return rv;
1620 }
1621
1622 #else /* !HAVE_DEBUG */
1623 CTA(sizeof(char) == sizeof(ui8_t));
1624
1625 # define _HOPE_SIZE        (2 * 8 * sizeof(char))
1626 # define _HOPE_SET(C)   \
1627 do {\
1628    union mem_ptr __xl, __xu;\
1629    struct mem_chunk *__xc;\
1630    __xl.p_p = (C).p_p;\
1631    __xc = __xl.p_c - 1;\
1632    __xu.p_p = __xc;\
1633    (C).p_cp += 8;\
1634    __xl.p_ui8p[0]=0xDE; __xl.p_ui8p[1]=0xAA;\
1635    __xl.p_ui8p[2]=0x55; __xl.p_ui8p[3]=0xAD;\
1636    __xl.p_ui8p[4]=0xBE; __xl.p_ui8p[5]=0x55;\
1637    __xl.p_ui8p[6]=0xAA; __xl.p_ui8p[7]=0xEF;\
1638    __xu.p_ui8p += __xc->mc_size - 8;\
1639    __xu.p_ui8p[0]=0xDE; __xu.p_ui8p[1]=0xAA;\
1640    __xu.p_ui8p[2]=0x55; __xu.p_ui8p[3]=0xAD;\
1641    __xu.p_ui8p[4]=0xBE; __xu.p_ui8p[5]=0x55;\
1642    __xu.p_ui8p[6]=0xAA; __xu.p_ui8p[7]=0xEF;\
1643 } while (0)
1644 # define _HOPE_GET_TRACE(C,BAD) \
1645 do {\
1646    (C).p_cp += 8;\
1647    _HOPE_GET(C, BAD);\
1648    (C).p_cp += 8;\
1649 } while(0)
1650 # define _HOPE_GET(C,BAD) \
1651 do {\
1652    union mem_ptr __xl, __xu;\
1653    struct mem_chunk *__xc;\
1654    ui32_t __i;\
1655    __xl.p_p = (C).p_p;\
1656    __xl.p_cp -= 8;\
1657    (C).p_cp = __xl.p_cp;\
1658    __xc = __xl.p_c - 1;\
1659    (BAD) = FAL0;\
1660    __i = 0;\
1661    if (__xl.p_ui8p[0] != 0xDE) __i |= 1<<0;\
1662    if (__xl.p_ui8p[1] != 0xAA) __i |= 1<<1;\
1663    if (__xl.p_ui8p[2] != 0x55) __i |= 1<<2;\
1664    if (__xl.p_ui8p[3] != 0xAD) __i |= 1<<3;\
1665    if (__xl.p_ui8p[4] != 0xBE) __i |= 1<<4;\
1666    if (__xl.p_ui8p[5] != 0x55) __i |= 1<<5;\
1667    if (__xl.p_ui8p[6] != 0xAA) __i |= 1<<6;\
1668    if (__xl.p_ui8p[7] != 0xEF) __i |= 1<<7;\
1669    if (__i != 0) {\
1670       (BAD) = TRU1;\
1671       alert("%p: corrupt lower canary: 0x%02X: %s, line %u",\
1672          __xl.p_p, __i, mdbg_file, mdbg_line);\
1673    }\
1674    __xu.p_p = __xc;\
1675    __xu.p_ui8p += __xc->mc_size - 8;\
1676    __i = 0;\
1677    if (__xu.p_ui8p[0] != 0xDE) __i |= 1<<0;\
1678    if (__xu.p_ui8p[1] != 0xAA) __i |= 1<<1;\
1679    if (__xu.p_ui8p[2] != 0x55) __i |= 1<<2;\
1680    if (__xu.p_ui8p[3] != 0xAD) __i |= 1<<3;\
1681    if (__xu.p_ui8p[4] != 0xBE) __i |= 1<<4;\
1682    if (__xu.p_ui8p[5] != 0x55) __i |= 1<<5;\
1683    if (__xu.p_ui8p[6] != 0xAA) __i |= 1<<6;\
1684    if (__xu.p_ui8p[7] != 0xEF) __i |= 1<<7;\
1685    if (__i != 0) {\
1686       (BAD) = TRU1;\
1687       alert("%p: corrupt upper canary: 0x%02X: %s, line %u",\
1688          __xl.p_p, __i, mdbg_file, mdbg_line);\
1689    }\
1690    if (BAD)\
1691       alert("   ..canary last seen: %s, line %u",\
1692          __xc->mc_file, __xc->mc_line);\
1693 } while (0)
1694
1695 FL void *
1696 (smalloc)(size_t s SMALLOC_DEBUG_ARGS)
1697 {
1698    union mem_ptr p;
1699    NYD2_ENTER;
1700
1701    if (s == 0)
1702       s = 1;
1703    s += sizeof(struct mem_chunk) + _HOPE_SIZE;
1704
1705    if ((p.p_p = (malloc)(s)) == NULL)
1706       _out_of_memory();
1707    p.p_c->mc_prev = NULL;
1708    if ((p.p_c->mc_next = _mem_list) != NULL)
1709       _mem_list->mc_prev = p.p_c;
1710    p.p_c->mc_file = mdbg_file;
1711    p.p_c->mc_line = (ui16_t)mdbg_line;
1712    p.p_c->mc_isfree = FAL0;
1713    p.p_c->mc_size = (ui32_t)s;
1714    _mem_list = p.p_c++;
1715    _HOPE_SET(p);
1716
1717    ++_mem_aall;
1718    ++_mem_acur;
1719    _mem_amax = MAX(_mem_amax, _mem_acur);
1720    _mem_mall += s;
1721    _mem_mcur += s;
1722    _mem_mmax = MAX(_mem_mmax, _mem_mcur);
1723    NYD2_LEAVE;
1724    return p.p_p;
1725 }
1726
1727 FL void *
1728 (srealloc)(void *v, size_t s SMALLOC_DEBUG_ARGS)
1729 {
1730    union mem_ptr p;
1731    bool_t isbad;
1732    NYD2_ENTER;
1733
1734    if ((p.p_p = v) == NULL) {
1735       p.p_p = (smalloc)(s, mdbg_file, mdbg_line);
1736       goto jleave;
1737    }
1738
1739    _HOPE_GET(p, isbad);
1740    --p.p_c;
1741    if (p.p_c->mc_isfree) {
1742       fprintf(stderr, "srealloc(): region freed!  At %s, line %d\n"
1743          "\tLast seen: %s, line %d\n",
1744          mdbg_file, mdbg_line, p.p_c->mc_file, p.p_c->mc_line);
1745       goto jforce;
1746    }
1747
1748    if (p.p_c == _mem_list)
1749       _mem_list = p.p_c->mc_next;
1750    else
1751       p.p_c->mc_prev->mc_next = p.p_c->mc_next;
1752    if (p.p_c->mc_next != NULL)
1753       p.p_c->mc_next->mc_prev = p.p_c->mc_prev;
1754
1755    --_mem_acur;
1756    _mem_mcur -= p.p_c->mc_size;
1757 jforce:
1758    if (s == 0)
1759       s = 1;
1760    s += sizeof(struct mem_chunk) + _HOPE_SIZE;
1761
1762    if ((p.p_p = (realloc)(p.p_c, s)) == NULL)
1763       _out_of_memory();
1764    p.p_c->mc_prev = NULL;
1765    if ((p.p_c->mc_next = _mem_list) != NULL)
1766       _mem_list->mc_prev = p.p_c;
1767    p.p_c->mc_file = mdbg_file;
1768    p.p_c->mc_line = (ui16_t)mdbg_line;
1769    p.p_c->mc_isfree = FAL0;
1770    p.p_c->mc_size = (ui32_t)s;
1771    _mem_list = p.p_c++;
1772    _HOPE_SET(p);
1773
1774    ++_mem_aall;
1775    ++_mem_acur;
1776    _mem_amax = MAX(_mem_amax, _mem_acur);
1777    _mem_mall += s;
1778    _mem_mcur += s;
1779    _mem_mmax = MAX(_mem_mmax, _mem_mcur);
1780 jleave:
1781    NYD2_LEAVE;
1782    return p.p_p;
1783 }
1784
1785 FL void *
1786 (scalloc)(size_t nmemb, size_t size SMALLOC_DEBUG_ARGS)
1787 {
1788    union mem_ptr p;
1789    NYD2_ENTER;
1790
1791    if (size == 0)
1792       size = 1;
1793    if (nmemb == 0)
1794       nmemb = 1;
1795    size *= nmemb;
1796    size += sizeof(struct mem_chunk) + _HOPE_SIZE;
1797
1798    if ((p.p_p = (malloc)(size)) == NULL)
1799       _out_of_memory();
1800    memset(p.p_p, 0, size);
1801    p.p_c->mc_prev = NULL;
1802    if ((p.p_c->mc_next = _mem_list) != NULL)
1803       _mem_list->mc_prev = p.p_c;
1804    p.p_c->mc_file = mdbg_file;
1805    p.p_c->mc_line = (ui16_t)mdbg_line;
1806    p.p_c->mc_isfree = FAL0;
1807    p.p_c->mc_size = (ui32_t)size;
1808    _mem_list = p.p_c++;
1809    _HOPE_SET(p);
1810
1811    ++_mem_aall;
1812    ++_mem_acur;
1813    _mem_amax = MAX(_mem_amax, _mem_acur);
1814    _mem_mall += size;
1815    _mem_mcur += size;
1816    _mem_mmax = MAX(_mem_mmax, _mem_mcur);
1817    NYD2_LEAVE;
1818    return p.p_p;
1819 }
1820
1821 FL void
1822 (sfree)(void *v SMALLOC_DEBUG_ARGS)
1823 {
1824    union mem_ptr p;
1825    bool_t isbad;
1826    NYD2_ENTER;
1827
1828    if ((p.p_p = v) == NULL) {
1829       fprintf(stderr, "sfree(NULL) from %s, line %d\n", mdbg_file, mdbg_line);
1830       goto jleave;
1831    }
1832
1833    _HOPE_GET(p, isbad);
1834    --p.p_c;
1835    if (p.p_c->mc_isfree) {
1836       fprintf(stderr, "sfree(): double-free avoided at %s, line %d\n"
1837          "\tLast seen: %s, line %d\n",
1838          mdbg_file, mdbg_line, p.p_c->mc_file, p.p_c->mc_line);
1839       goto jleave;
1840    }
1841
1842    if (p.p_c == _mem_list)
1843       _mem_list = p.p_c->mc_next;
1844    else
1845       p.p_c->mc_prev->mc_next = p.p_c->mc_next;
1846    if (p.p_c->mc_next != NULL)
1847       p.p_c->mc_next->mc_prev = p.p_c->mc_prev;
1848    p.p_c->mc_isfree = TRU1;
1849
1850    --_mem_acur;
1851    _mem_mcur -= p.p_c->mc_size;
1852
1853    if (options & OPT_DEBUG) {
1854       p.p_c->mc_next = _mem_free;
1855       _mem_free = p.p_c;
1856    } else
1857       (free)(p.p_c);
1858 jleave:
1859    NYD2_LEAVE;
1860 }
1861
1862 FL void
1863 smemreset(void)
1864 {
1865    union mem_ptr p;
1866    size_t c = 0, s = 0;
1867    NYD_ENTER;
1868
1869    for (p.p_c = _mem_free; p.p_c != NULL;) {
1870       void *vp = p.p_c;
1871       ++c;
1872       s += p.p_c->mc_size;
1873       p.p_c = p.p_c->mc_next;
1874       (free)(vp);
1875    }
1876    _mem_free = NULL;
1877
1878    if (options & OPT_DEBUG)
1879       fprintf(stderr, "smemreset(): freed %" ZFMT " chunks/%" ZFMT " bytes\n",
1880          c, s);
1881    NYD_LEAVE;
1882 }
1883
1884 FL int
1885 c_smemtrace(void *v)
1886 {
1887    /* For _HOPE_GET() */
1888    char const * const mdbg_file = "smemtrace()";
1889    int const mdbg_line = -1;
1890    FILE *fp;
1891    union mem_ptr p, xp;
1892    bool_t isbad;
1893    size_t lines;
1894    NYD_ENTER;
1895
1896    v = (void*)0x1;
1897    if ((fp = Ftmp(NULL, "memtr", OF_RDWR | OF_UNLINK | OF_REGISTER, 0600)) ==
1898          NULL) {
1899       perror("tmpfile");
1900       goto jleave;
1901    }
1902
1903    fprintf(fp, "Memory statistics:\n"
1904       "  Count cur/peek/all: %7" ZFMT "/%7" ZFMT "/%10" ZFMT "\n"
1905       "  Bytes cur/peek/all: %7" ZFMT "/%7" ZFMT "/%10" ZFMT "\n\n",
1906       _mem_acur, _mem_amax, _mem_aall, _mem_mcur, _mem_mmax, _mem_mall);
1907
1908    fprintf(fp, "Currently allocated memory chunks:\n");
1909    for (lines = 0, p.p_c = _mem_list; p.p_c != NULL;
1910          ++lines, p.p_c = p.p_c->mc_next) {
1911       xp = p;
1912       ++xp.p_c;
1913       _HOPE_GET_TRACE(xp, isbad);
1914       fprintf(fp, "%s%p (%5" ZFMT " bytes): %s, line %u\n",
1915          (isbad ? "! CANARY ERROR: " : ""), xp.p_p,
1916          (size_t)(p.p_c->mc_size - sizeof(struct mem_chunk)), p.p_c->mc_file,
1917          p.p_c->mc_line);
1918    }
1919
1920    if (options & OPT_DEBUG) {
1921       fprintf(fp, "sfree()d memory chunks awaiting free():\n");
1922       for (p.p_c = _mem_free; p.p_c != NULL; ++lines, p.p_c = p.p_c->mc_next) {
1923          xp = p;
1924          ++xp.p_c;
1925          _HOPE_GET_TRACE(xp, isbad);
1926          fprintf(fp, "%s%p (%5" ZFMT " bytes): %s, line %u\n",
1927             (isbad ? "! CANARY ERROR: " : ""), xp.p_p,
1928             (size_t)(p.p_c->mc_size - sizeof(struct mem_chunk)),
1929             p.p_c->mc_file, p.p_c->mc_line);
1930       }
1931    }
1932
1933    page_or_print(fp, lines);
1934    Fclose(fp);
1935    v = NULL;
1936 jleave:
1937    NYD_LEAVE;
1938    return (v != NULL);
1939 }
1940
1941 # ifdef _HAVE_MEMCHECK
1942 FL bool_t
1943 _smemcheck(char const *mdbg_file, int mdbg_line)
1944 {
1945    union mem_ptr p, xp;
1946    bool_t anybad = FAL0, isbad;
1947    size_t lines;
1948    NYD_ENTER;
1949
1950    for (lines = 0, p.p_c = _mem_list; p.p_c != NULL;
1951          ++lines, p.p_c = p.p_c->mc_next) {
1952       xp = p;
1953       ++xp.p_c;
1954       _HOPE_GET_TRACE(xp, isbad);
1955       if (isbad) {
1956          anybad = TRU1;
1957          fprintf(stderr,
1958             "! CANARY ERROR: %p (%5" ZFMT " bytes): %s, line %u\n",
1959             xp.p_p, (size_t)(p.p_c->mc_size - sizeof(struct mem_chunk)),
1960             p.p_c->mc_file, p.p_c->mc_line);
1961       }
1962    }
1963
1964    if (options & OPT_DEBUG) {
1965       for (p.p_c = _mem_free; p.p_c != NULL; ++lines, p.p_c = p.p_c->mc_next) {
1966          xp = p;
1967          ++xp.p_c;
1968          _HOPE_GET_TRACE(xp, isbad);
1969          if (isbad) {
1970             anybad = TRU1;
1971             fprintf(stderr,
1972                "! CANARY ERROR: %p (%5" ZFMT " bytes): %s, line %u\n",
1973                xp.p_p, (size_t)(p.p_c->mc_size - sizeof(struct mem_chunk)),
1974                p.p_c->mc_file, p.p_c->mc_line);
1975          }
1976       }
1977    }
1978    NYD_LEAVE;
1979    return anybad;
1980 }
1981 # endif /* _HAVE_MEMCHECK */
1982
1983 # undef _HOPE_SIZE
1984 # undef _HOPE_SET
1985 # undef _HOPE_GET_TRACE
1986 # undef _HOPE_GET
1987 #endif /* HAVE_DEBUG */
1988
1989 /* vim:set fenc=utf-8:s-it-mode */