strings.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Auto-reclaimed string allocation and support routines that build on top of
   3  *@ them.  Strings handed out by those are reclaimed at the top of the command
   4  *@ loop each time, so they need not be freed.
   5  *@ And below this series we do collect all other plain string support routines
   6  *@ in here, including those which use normal heap memory.
   7  *
   8  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   9  * Copyright (c) 2012 - 2014 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
  10  */
  11 /*
  12  * Copyright (c) 1980, 1993
  13  * The Regents of the University of California.  All rights reserved.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  * 3. All advertising materials mentioning features or use of this software
  24  *    must display the following acknowledgement:
  25  *    This product includes software developed by the University of
  26  *    California, Berkeley and its contributors.
  27  * 4. Neither the name of the University nor the names of its contributors
  28  *    may be used to endorse or promote products derived from this software
  29  *    without specific prior written permission.
  30  *
  31  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  32  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  35  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  39  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  40  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  41  * SUCH DAMAGE.
  42  */
  43
  44 #ifndef HAVE_AMALGAMATION
  45 # include "nail.h"
  46 #endif
  47
  48 #include <ctype.h>
  49
  50 /* Allocate SBUFFER_SIZE chunks and keep them in a singly linked list, but
  51  * release all except the first two in sreset(), because other allocations are
  52  * performed and the underlaying allocator should have the possibility to
  53  * reorder stuff and possibly even madvise(2), so that S-nail(1) integrates
  54  * neatly into the system.
  55  * To relax stuff further, especially in non-interactive, i.e., send mode, do
  56  * not even allocate the first buffer, but let that be a builtin DATA section
  57  * one that is rather small, yet sufficient for send mode to *never* even
  58  * perform a single dynamic allocation (from our stringdope point of view).
  59  * Encapsulate user chunks with canaries if HAVE_DEBUG */
  60
  61 #ifdef HAVE_DEBUG
  62 # define _SHOPE_SIZE       (2u * 8 * sizeof(char) + sizeof(struct schunk))
  63
  64 CTA(sizeof(char) == sizeof(ui8_t));
  65
  66 struct schunk {
  67    char const     *file;
  68    ui32_t         line;
  69    ui16_t         usr_size;
  70    ui16_t         full_size;
  71 };
  72
  73 union sptr {
  74    void           *p;
  75    struct schunk  *c;
  76    char           *cp;
  77    ui8_t          *ui8p;
  78 };
  79 #endif /* HAVE_DEBUG */
  80
  81 union __align__ {
  82    char     *cp;
  83    size_t   sz;
  84    ul_it    ul;
  85 };
  86 #define SALIGN    (sizeof(union __align__) - 1)
  87
  88 CTA(ISPOW2(SALIGN + 1));
  89
  90 struct b_base {
  91    struct buffer  *_next;
  92    char           *_bot;      /* For spreserve() */
  93    char           *_relax;    /* If !NULL, used by srelax() instead of ._bot */
  94    char           *_max;      /* Max usable byte */
  95    char           *_caster;   /* NULL if full */
  96 };
  97
  98 /* Single instance builtin buffer, DATA */
  99 struct b_bltin {
 100    struct b_base  b_base;
 101    char           b_buf[SBUFFER_BUILTIN - sizeof(struct b_base)];
 102 };
 103 #define SBLTIN_SIZE  SIZEOF_FIELD(struct b_bltin, b_buf)
 104
 105 /* Dynamically allocated buffers */
 106 struct b_dyn {
 107    struct b_base  b_base;
 108    char           b_buf[SBUFFER_SIZE - sizeof(struct b_base)];
 109 };
 110 #define SDYN_SIZE SIZEOF_FIELD(struct b_dyn, b_buf)
 111
 112 struct buffer {
 113    struct b_base  b;
 114    char           b_buf[VFIELD_SIZE(SALIGN + 1)];
 115 };
 116
 117 static struct b_bltin   _builtin_buf;
 118 static struct buffer    *_buf_head, *_buf_list, *_buf_server, *_buf_relax;
 119 #ifdef HAVE_DEBUG
 120 static size_t           _all_cnt, _all_cycnt, _all_cycnt_max,
 121                         _all_size, _all_cysize, _all_cysize_max, _all_min,
 122                            _all_max, _all_wast,
 123                         _all_bufcnt, _all_cybufcnt, _all_cybufcnt_max,
 124                         _all_resetreqs, _all_resets;
 125 #endif
 126
 127 /* sreset() / srelax() release a buffer, check the canaries of all chunks */
 128 #ifdef HAVE_DEBUG
 129 static void    _salloc_bcheck(struct buffer *b);
 130 #endif
 131
 132 #ifdef HAVE_DEBUG
 133 static void
 134 _salloc_bcheck(struct buffer *b)
 135 {
 136    union sptr pmax, pp;
 137    /*NYD2_ENTER;*/
 138
 139    pmax.cp = (b->b._caster == NULL) ? b->b._max : b->b._caster;
 140    pp.cp = b->b._bot;
 141
 142    while (pp.cp < pmax.cp) {
 143       struct schunk *c;
 144       union sptr x;
 145       void *ux;
 146       ui8_t i;
 147
 148       c = pp.c;
 149       pp.cp += c->full_size;
 150       x.p = c + 1;
 151       ux = x.cp + 8;
 152
 153       i = 0;
 154       if (x.ui8p[0] != 0xDE) i |= 1<<0;
 155       if (x.ui8p[1] != 0xAA) i |= 1<<1;
 156       if (x.ui8p[2] != 0x55) i |= 1<<2;
 157       if (x.ui8p[3] != 0xAD) i |= 1<<3;
 158       if (x.ui8p[4] != 0xBE) i |= 1<<4;
 159       if (x.ui8p[5] != 0x55) i |= 1<<5;
 160       if (x.ui8p[6] != 0xAA) i |= 1<<6;
 161       if (x.ui8p[7] != 0xEF) i |= 1<<7;
 162       if (i != 0)
 163          alert("sdope %p: corrupt lower canary: 0x%02X, size %u: %s, line %u",
 164             ux, i, c->usr_size, c->file, c->line);
 165       x.cp += 8 + c->usr_size;
 166
 167       i = 0;
 168       if (x.ui8p[0] != 0xDE) i |= 1<<0;
 169       if (x.ui8p[1] != 0xAA) i |= 1<<1;
 170       if (x.ui8p[2] != 0x55) i |= 1<<2;
 171       if (x.ui8p[3] != 0xAD) i |= 1<<3;
 172       if (x.ui8p[4] != 0xBE) i |= 1<<4;
 173       if (x.ui8p[5] != 0x55) i |= 1<<5;
 174       if (x.ui8p[6] != 0xAA) i |= 1<<6;
 175       if (x.ui8p[7] != 0xEF) i |= 1<<7;
 176       if (i != 0)
 177          alert("sdope %p: corrupt upper canary: 0x%02X, size %u: %s, line %u",
 178             ux, i, c->usr_size, c->file, c->line);
 179    }
 180    /*NYD2_LEAVE;*/
 181 }
 182 #endif
 183
 184 FL void *
 185 (salloc)(size_t size SALLOC_DEBUG_ARGS)
 186 {
 187    DBG( size_t orig_size = size; )
 188    union {struct buffer *b; char *cp;} u;
 189    char *x, *y, *z;
 190    NYD2_ENTER;
 191
 192    if (size == 0)
 193       ++size;
 194    size += SALIGN;
 195    size &= ~SALIGN;
 196
 197 #ifdef HAVE_DEBUG
 198    ++_all_cnt;
 199    ++_all_cycnt;
 200    _all_cycnt_max = MAX(_all_cycnt_max, _all_cycnt);
 201    _all_size += size;
 202    _all_cysize += size;
 203    _all_cysize_max = MAX(_all_cysize_max, _all_cysize);
 204    _all_min = (_all_max == 0) ? size : MIN(_all_min, size);
 205    _all_max = MAX(_all_max, size);
 206    _all_wast += size - orig_size;
 207
 208    size += _SHOPE_SIZE;
 209
 210    if (size >= 2048)
 211       alert("salloc() of %" ZFMT " bytes from `%s', line %u\n",
 212          size, mdbg_file, mdbg_line);
 213 #endif
 214
 215    /* Search for a buffer with enough free space to serve request */
 216    if ((u.b = _buf_server) != NULL)
 217       goto jumpin;
 218 jredo:
 219    for (u.b = _buf_head; u.b != NULL; u.b = u.b->b._next) {
 220 jumpin:
 221       x = u.b->b._caster;
 222       if (x == NULL) {
 223          if (u.b == _buf_server) {
 224             if (u.b == _buf_head && (u.b = _buf_head->b._next) != NULL) {
 225                _buf_server = u.b;
 226                goto jumpin;
 227             }
 228             _buf_server = NULL;
 229             goto jredo;
 230          }
 231          continue;
 232       }
 233       y = x + size;
 234       z = u.b->b._max;
 235       if (PTRCMP(y, <=, z)) {
 236          /* Alignment is the one thing, the other is what is usually allocated,
 237           * and here about 40 bytes seems to be a good cut to avoid non-usable
 238           * non-NULL casters.  However, because of _salloc_bcheck(), we may not
 239           * set ._caster to NULL because then it would check all chunks up to
 240           * ._max, which surely doesn't work; speed is no issue with DEBUG */
 241          u.b->b._caster = NDBG( PTRCMP(y + 42 + 16, >=, z) ? NULL : ) y;
 242          u.cp = x;
 243          goto jleave;
 244       }
 245    }
 246
 247    /* Need a new buffer */
 248    if (_buf_head == NULL) {
 249       struct b_bltin *b = &_builtin_buf;
 250       b->b_base._max = b->b_buf + sizeof(b->b_buf) - 1;
 251       _buf_head = (struct buffer*)b;
 252       u.b = _buf_head;
 253    } else {
 254 #ifdef HAVE_DEBUG
 255       ++_all_bufcnt;
 256       ++_all_cybufcnt;
 257       _all_cybufcnt_max = MAX(_all_cybufcnt_max, _all_cybufcnt);
 258 #endif
 259       u.b = smalloc(sizeof(struct b_dyn));
 260       u.b->b._max = u.b->b_buf + SDYN_SIZE - 1;
 261    }
 262    if (_buf_list != NULL)
 263       _buf_list->b._next = u.b;
 264    _buf_server = _buf_list = u.b;
 265    u.b->b._next = NULL;
 266    u.b->b._caster = (u.b->b._bot = u.b->b_buf) + size;
 267    u.b->b._relax = NULL;
 268    u.cp = u.b->b._bot;
 269
 270 jleave:
 271    /* Encapsulate user chunk in debug canaries */
 272 #ifdef HAVE_DEBUG
 273    {
 274       union sptr xl, xu;
 275       struct schunk *xc;
 276
 277       xl.p = u.cp;
 278       xc = xl.c;
 279       xc->file = mdbg_file;
 280       xc->line = mdbg_line;
 281       xc->usr_size = (ui16_t)orig_size;
 282       xc->full_size = (ui16_t)size;
 283       xl.p = xc + 1;
 284       xl.ui8p[0]=0xDE; xl.ui8p[1]=0xAA; xl.ui8p[2]=0x55; xl.ui8p[3]=0xAD;
 285       xl.ui8p[4]=0xBE; xl.ui8p[5]=0x55; xl.ui8p[6]=0xAA; xl.ui8p[7]=0xEF;
 286       u.cp = xl.cp + 8;
 287       xu.p = u.cp;
 288       xu.cp += orig_size;
 289       xu.ui8p[0]=0xDE; xu.ui8p[1]=0xAA; xu.ui8p[2]=0x55; xu.ui8p[3]=0xAD;
 290       xu.ui8p[4]=0xBE; xu.ui8p[5]=0x55; xu.ui8p[6]=0xAA; xu.ui8p[7]=0xEF;
 291    }
 292 #endif
 293    NYD2_LEAVE;
 294    return u.cp;
 295 }
 296
 297 FL void *
 298 (csalloc)(size_t nmemb, size_t size SALLOC_DEBUG_ARGS)
 299 {
 300    void *vp;
 301    NYD2_ENTER;
 302
 303    size *= nmemb;
 304    vp = (salloc)(size SALLOC_DEBUG_ARGSCALL);
 305    memset(vp, 0, size);
 306    NYD2_LEAVE;
 307    return vp;
 308 }
 309
 310 FL void
 311 sreset(bool_t only_if_relaxed)
 312 {
 313    struct buffer *bh;
 314    NYD_ENTER;
 315
 316    DBG( ++_all_resetreqs; )
 317    if (noreset || (only_if_relaxed && _buf_relax == NULL))
 318       goto jleave;
 319
 320 #ifdef HAVE_DEBUG
 321    _all_cycnt = _all_cysize = 0;
 322    _all_cybufcnt = (_buf_head != NULL && _buf_head->b._next != NULL);
 323    ++_all_resets;
 324 #endif
 325
 326    if ((bh = _buf_head) != NULL) {
 327       struct buffer *b = bh;
 328       DBG( _salloc_bcheck(b); )
 329       b->b._caster = b->b._bot;
 330       b->b._relax = NULL;
 331       DBG( memset(b->b._caster, 0377, PTR2SIZE(b->b._max - b->b._caster)); )
 332       _buf_server = b;
 333
 334       if ((bh = bh->b._next) != NULL) {
 335          b = bh;
 336          DBG( _salloc_bcheck(b); )
 337          b->b._caster = b->b._bot;
 338          b->b._relax = NULL;
 339          DBG( memset(b->b._caster, 0377, PTR2SIZE(b->b._max - b->b._caster)); )
 340
 341          for (bh = bh->b._next; bh != NULL;) {
 342             struct buffer *b2 = bh->b._next;
 343             DBG( _salloc_bcheck(bh); )
 344             free(bh);
 345             bh = b2;
 346          }
 347       }
 348       _buf_list = b;
 349       b->b._next = NULL;
 350       _buf_relax = NULL;
 351    }
 352
 353    DBG( smemreset(); )
 354 jleave:
 355    NYD_LEAVE;
 356 }
 357
 358 FL void
 359 srelax_hold(void)
 360 {
 361    struct buffer *b;
 362    NYD_ENTER;
 363
 364    assert(_buf_relax == NULL);
 365
 366    for (b = _buf_head; b != NULL; b = b->b._next)
 367       b->b._relax = b->b._caster;
 368    _buf_relax = _buf_server;
 369    assert(_buf_relax != NULL);
 370    NYD_LEAVE;
 371 }
 372
 373 FL void
 374 srelax_rele(void)
 375 {
 376    struct buffer *b;
 377    NYD_ENTER;
 378
 379    assert(_buf_relax != NULL);
 380
 381    for (b = _buf_relax; b != NULL; b = b->b._next) {
 382       DBG( _salloc_bcheck(b); )
 383       b->b._caster = (b->b._relax != NULL) ? b->b._relax : b->b._bot;
 384       b->b._relax = NULL;
 385    }
 386    _buf_relax = NULL;
 387    NYD_LEAVE;
 388 }
 389
 390 FL void
 391 srelax(void)
 392 {
 393    /* The purpose of relaxation is only that it is possible to reset the
 394     * casters, *not* to give back memory to the system.  We are presumably in
 395     * an iteration over all messages of a mailbox, and it'd be quite
 396     * counterproductive to give the system allocator a chance to waste time */
 397    struct buffer *b;
 398    NYD_ENTER;
 399
 400    assert(_buf_relax != NULL);
 401
 402    for (b = _buf_relax; b != NULL; b = b->b._next) {
 403       DBG( _salloc_bcheck(b); )
 404       b->b._caster = (b->b._relax != NULL) ? b->b._relax : b->b._bot;
 405       DBG( memset(b->b._caster, 0377, PTR2SIZE(b->b._max - b->b._caster)); )
 406    }
 407    NYD_LEAVE;
 408 }
 409
 410 FL void
 411 spreserve(void)
 412 {
 413    struct buffer *b;
 414    NYD_ENTER;
 415
 416    for (b = _buf_head; b != NULL; b = b->b._next)
 417       b->b._bot = b->b._caster;
 418    NYD_LEAVE;
 419 }
 420
 421 #ifdef HAVE_DEBUG
 422 FL int
 423 c_sstats(void *v)
 424 {
 425    size_t excess;
 426    NYD_ENTER;
 427    UNUSED(v);
 428
 429    excess = (_all_cybufcnt_max * SDYN_SIZE) + SBLTIN_SIZE;
 430    excess = (excess >= _all_cysize_max) ? 0 : _all_cysize_max - excess;
 431
 432    printf("String usage statistics (cycle means one sreset() cycle):\n"
 433       "  Buffer allocs ever/max simultan. : %lu/%lu\n"
 434       "  Buffer size of builtin(1)/dynamic: %lu/%lu\n"
 435       "  Overall alloc count/bytes        : %lu/%lu\n"
 436       "  Alloc bytes min/max/align wastage: %lu/%lu/%lu\n"
 437       "  sreset() cycles                  : %lu (%lu performed)\n"
 438       "  Cycle maximums: alloc count/bytes: %lu/%lu+%lu\n",
 439       (ul_it)_all_bufcnt, (ul_it)_all_cybufcnt_max,
 440       (ul_it)SBLTIN_SIZE, (ul_it)SDYN_SIZE,
 441       (ul_it)_all_cnt, (ul_it)_all_size,
 442       (ul_it)_all_min, (ul_it)_all_max, (ul_it)_all_wast,
 443       (ul_it)_all_resetreqs, (ul_it)_all_resets,
 444       (ul_it)_all_cycnt_max, (ul_it)_all_cysize_max, (ul_it)excess);
 445    NYD_LEAVE;
 446    return 0;
 447 }
 448 #endif
 449
 450 FL char *
 451 (savestr)(char const *str SALLOC_DEBUG_ARGS)
 452 {
 453    size_t size;
 454    char *news;
 455    NYD_ENTER;
 456
 457    size = strlen(str) +1;
 458    news = (salloc)(size SALLOC_DEBUG_ARGSCALL);
 459    memcpy(news, str, size);
 460    NYD_LEAVE;
 461    return news;
 462 }
 463
 464 FL char *
 465 (savestrbuf)(char const *sbuf, size_t sbuf_len SALLOC_DEBUG_ARGS)
 466 {
 467    char *news;
 468    NYD_ENTER;
 469
 470    news = (salloc)(sbuf_len +1 SALLOC_DEBUG_ARGSCALL);
 471    memcpy(news, sbuf, sbuf_len);
 472    news[sbuf_len] = 0;
 473    NYD_LEAVE;
 474    return news;
 475 }
 476
 477 FL char *
 478 (save2str)(char const *str, char const *old SALLOC_DEBUG_ARGS)
 479 {
 480    size_t newsize, oldsize;
 481    char *news;
 482    NYD_ENTER;
 483
 484    newsize = strlen(str) +1;
 485    oldsize = (old != NULL) ? strlen(old) + 1 : 0;
 486    news = (salloc)(newsize + oldsize SALLOC_DEBUG_ARGSCALL);
 487    if (oldsize) {
 488       memcpy(news, old, oldsize);
 489       news[oldsize - 1] = ' ';
 490    }
 491    memcpy(news + oldsize, str, newsize);
 492    NYD_LEAVE;
 493    return news;
 494 }
 495
 496 FL char *
 497 (savecat)(char const *s1, char const *s2 SALLOC_DEBUG_ARGS)
 498 {
 499    size_t l1, l2;
 500    char *news;
 501    NYD_ENTER;
 502
 503    l1 = strlen(s1);
 504    l2 = strlen(s2);
 505    news = (salloc)(l1 + l2 +1 SALLOC_DEBUG_ARGSCALL);
 506    memcpy(news + 0, s1, l1);
 507    memcpy(news + l1, s2, l2);
 508    news[l1 + l2] = '\0';
 509    NYD_LEAVE;
 510    return news;
 511 }
 512
 513 /*
 514  * Support routines, auto-reclaimed storage
 515  */
 516
 517 FL char *
 518 (i_strdup)(char const *src SALLOC_DEBUG_ARGS)
 519 {
 520    size_t sz;
 521    char *dest;
 522    NYD_ENTER;
 523
 524    sz = strlen(src) +1;
 525    dest = (salloc)(sz SALLOC_DEBUG_ARGSCALL);
 526    i_strcpy(dest, src, sz);
 527    NYD_LEAVE;
 528    return dest;
 529 }
 530
 531 FL char *
 532 (protbase)(char const *cp SALLOC_DEBUG_ARGS) /* TODO obsolete */
 533 {
 534    char *n, *np;
 535    NYD_ENTER;
 536
 537    np = n = (salloc)(strlen(cp) +1 SALLOC_DEBUG_ARGSCALL);
 538
 539    /* Just ignore the `is-system-mailbox' prefix XXX */
 540    if (cp[0] == '%' && cp[1] == ':')
 541       cp += 2;
 542
 543    while (*cp != '\0') {
 544       if (cp[0] == ':' && cp[1] == '/' && cp[2] == '/') {
 545          *np++ = *cp++;
 546          *np++ = *cp++;
 547          *np++ = *cp++;
 548       } else if (cp[0] == '/')
 549          break;
 550       else
 551          *np++ = *cp++;
 552    }
 553    *np = '\0';
 554    NYD_LEAVE;
 555    return n;
 556 }
 557
 558 FL struct str *
 559 str_concat_csvl(struct str *self, ...) /* XXX onepass maybe better here */
 560 {
 561    va_list vl;
 562    size_t l;
 563    char const *cs;
 564    NYD_ENTER;
 565
 566    va_start(vl, self);
 567    for (l = 0; (cs = va_arg(vl, char const*)) != NULL;)
 568       l += strlen(cs);
 569    va_end(vl);
 570
 571    self->l = l;
 572    self->s = salloc(l +1);
 573
 574    va_start(vl, self);
 575    for (l = 0; (cs = va_arg(vl, char const*)) != NULL;) {
 576       size_t i = strlen(cs);
 577       memcpy(self->s + l, cs, i);
 578       l += i;
 579    }
 580    self->s[l] = '\0';
 581    va_end(vl);
 582    NYD_LEAVE;
 583    return self;
 584 }
 585
 586 #ifdef HAVE_SPAM
 587 FL struct str *
 588 (str_concat_cpa)(struct str *self, char const * const *cpa,
 589    char const *sep_o_null SALLOC_DEBUG_ARGS)
 590 {
 591    size_t sonl, l;
 592    char const * const *xcpa;
 593    NYD_ENTER;
 594
 595    sonl = (sep_o_null != NULL) ? strlen(sep_o_null) : 0;
 596
 597    for (l = 0, xcpa = cpa; *xcpa != NULL; ++xcpa)
 598       l += strlen(*xcpa) + sonl;
 599
 600    self->l = l;
 601    self->s = (salloc)(l +1 SALLOC_DEBUG_ARGSCALL);
 602
 603    for (l = 0, xcpa = cpa; *xcpa != NULL; ++xcpa) {
 604       size_t i = strlen(*xcpa);
 605       memcpy(self->s + l, *xcpa, i);
 606       l += i;
 607       if (sonl > 0) {
 608          memcpy(self->s + l, sep_o_null, sonl);
 609          l += sonl;
 610       }
 611    }
 612    self->s[l] = '\0';
 613    NYD_LEAVE;
 614    return self;
 615 }
 616 #endif
 617
 618 /*
 619  * Routines that are not related to auto-reclaimed storage follow.
 620  */
 621
 622 FL int
 623 anyof(char const *s1, char const *s2)
 624 {
 625    NYD2_ENTER;
 626    for (; *s1 != '\0'; ++s1)
 627       if (strchr(s2, *s1) != NULL)
 628          break;
 629    NYD2_LEAVE;
 630    return (*s1 != '\0');
 631 }
 632
 633 FL char *
 634 n_strsep(char **iolist, char sep, bool_t ignore_empty)
 635 {
 636    char *base, *cp;
 637    NYD2_ENTER;
 638
 639    for (base = *iolist; base != NULL; base = *iolist) {
 640       while (*base != '\0' && blankspacechar(*base))
 641          ++base;
 642       cp = strchr(base, sep);
 643       if (cp != NULL)
 644          *iolist = cp + 1;
 645       else {
 646          *iolist = NULL;
 647          cp = base + strlen(base);
 648       }
 649       while (cp > base && blankspacechar(cp[-1]))
 650          --cp;
 651       *cp = '\0';
 652       if (*base != '\0' || !ignore_empty)
 653          break;
 654    }
 655    NYD2_LEAVE;
 656    return base;
 657 }
 658
 659 FL void
 660 i_strcpy(char *dest, char const *src, size_t size)
 661 {
 662    NYD2_ENTER;
 663    if (size > 0) {
 664       for (;; ++dest, ++src)
 665          if ((*dest = lowerconv(*src)) == '\0') {
 666             break;
 667          } else if (--size == 0) {
 668             *dest = '\0';
 669             break;
 670          }
 671    }
 672    NYD2_LEAVE;
 673 }
 674
 675 FL int
 676 is_prefix(char const *as1, char const *as2)
 677 {
 678    char c;
 679    NYD2_ENTER;
 680
 681    for (; (c = *as1) == *as2 && c != '\0'; ++as1, ++as2)
 682       if (*as2 == '\0')
 683          break;
 684    NYD2_LEAVE;
 685    return (c == '\0');
 686 }
 687
 688 FL char *
 689 laststring(char *linebuf, bool_t *needs_list, bool_t strip)
 690 {
 691    char *cp, *p, quoted;
 692    NYD_ENTER;
 693
 694    /* Anything to do at all? */
 695    if (*(cp = linebuf) == '\0')
 696       goto jnull;
 697    cp += strlen(linebuf) -1;
 698
 699    /* Strip away trailing blanks */
 700    while (whitechar(*cp) && cp > linebuf)
 701       --cp;
 702    cp[1] = '\0';
 703    if (cp == linebuf)
 704       goto jleave;
 705
 706    /* Now search for the BOS of the "last string" */
 707    quoted = *cp;
 708    if (quoted == '\'' || quoted == '"') {
 709       if (strip)
 710          *cp = '\0';
 711    } else
 712       quoted = ' ';
 713
 714    while (cp > linebuf) {
 715       --cp;
 716       if (quoted != ' ') {
 717          if (*cp != quoted)
 718             continue;
 719       } else if (!whitechar(*cp))
 720          continue;
 721       if (cp == linebuf || cp[-1] != '\\') {
 722          /* When in whitespace mode, WS prefix doesn't belong */
 723          if (quoted == ' ')
 724             ++cp;
 725          break;
 726       }
 727       /* Expand the escaped quote character */
 728       for (p = --cp; (p[0] = p[1]) != '\0'; ++p)
 729          ;
 730    }
 731    if (strip && quoted != ' ' && *cp == quoted)
 732       for (p = cp; (p[0] = p[1]) != '\0'; ++p)
 733          ;
 734
 735    /* The "last string" has been skipped over, but still, try to step backwards
 736     * until we are at BOS or see whitespace, so as to make possible things like
 737     * "? copy +'x y.mbox'" or even "? copy +x\ y.mbox" */
 738    while (cp > linebuf) {
 739       --cp;
 740       if (whitechar(*cp)) {
 741          p = cp;
 742          *cp++ = '\0';
 743          /* We can furtherly release our callees if we now decide wether the
 744           * remaining non-"last string" line content contains non-WS */
 745          while (--p >= linebuf)
 746             if (!whitechar(*p))
 747                goto jleave;
 748          linebuf = cp;
 749          break;
 750       }
 751    }
 752
 753 jleave:
 754    if (cp != NULL && *cp == '\0')
 755       goto jnull;
 756    *needs_list = (cp != linebuf && *linebuf != '\0');
 757 j_leave:
 758    NYD_LEAVE;
 759    return cp;
 760 jnull:
 761    *needs_list = FAL0;
 762    cp = NULL;
 763    goto j_leave;
 764 }
 765
 766 FL void
 767 makelow(char *cp) /* TODO isn't that crap? --> */
 768 {
 769       NYD_ENTER;
 770 #ifdef HAVE_C90AMEND1
 771    if (mb_cur_max > 1) {
 772       char *tp = cp;
 773       wchar_t wc;
 774       int len;
 775
 776       while (*cp != '\0') {
 777          len = mbtowc(&wc, cp, mb_cur_max);
 778          if (len < 0)
 779             *tp++ = *cp++;
 780          else {
 781             wc = towlower(wc);
 782             if (wctomb(tp, wc) == len)
 783                tp += len, cp += len;
 784             else
 785                *tp++ = *cp++; /* <-- at least here */
 786          }
 787       }
 788    } else
 789 #endif
 790    {
 791       do
 792          *cp = tolower((uc_it)*cp);
 793       while (*cp++ != '\0');
 794    }
 795    NYD_LEAVE;
 796 }
 797
 798 FL bool_t
 799 substr(char const *str, char const *sub)
 800 {
 801    char const *cp, *backup;
 802    NYD_ENTER;
 803
 804    cp = sub;
 805    backup = str;
 806    while (*str != '\0' && *cp != '\0') {
 807 #ifdef HAVE_C90AMEND1
 808       if (mb_cur_max > 1) {
 809          wchar_t c, c2;
 810          int sz;
 811
 812          if ((sz = mbtowc(&c, cp, mb_cur_max)) == -1)
 813             goto Jsinglebyte;
 814          cp += sz;
 815          if ((sz = mbtowc(&c2, str, mb_cur_max)) == -1)
 816             goto Jsinglebyte;
 817          str += sz;
 818          c = towupper(c);
 819          c2 = towupper(c2);
 820          if (c != c2) {
 821             if ((sz = mbtowc(&c, backup, mb_cur_max)) > 0) {
 822                backup += sz;
 823                str = backup;
 824             } else
 825                str = ++backup;
 826             cp = sub;
 827          }
 828       } else
 829 Jsinglebyte:
 830 #endif
 831       {
 832          int c, c2;
 833
 834          c = *cp++ & 0377;
 835          if (islower(c))
 836             c = toupper(c);
 837          c2 = *str++ & 0377;
 838          if (islower(c2))
 839             c2 = toupper(c2);
 840          if (c != c2) {
 841             str = ++backup;
 842             cp = sub;
 843          }
 844       }
 845    }
 846    NYD_LEAVE;
 847    return (*cp == '\0');
 848 }
 849
 850 #ifndef HAVE_SNPRINTF
 851 FL int
 852 snprintf(char *str, size_t size, char const *format, ...) /* XXX DANGER! */
 853 {
 854    va_list ap;
 855    int ret;
 856    NYD2_ENTER;
 857
 858    va_start(ap, format);
 859    ret = vsprintf(str, format, ap);
 860    va_end(ap);
 861    if (ret < 0)
 862       ret = strlen(str);
 863    NYD2_LEAVE;
 864    return ret;
 865 }
 866 #endif
 867
 868 FL char *
 869 sstpcpy(char *dst, char const *src)
 870 {
 871    NYD2_ENTER;
 872    while ((*dst = *src++) != '\0')
 873       ++dst;
 874    NYD2_LEAVE;
 875    return dst;
 876 }
 877
 878 FL char *
 879 (sstrdup)(char const *cp SMALLOC_DEBUG_ARGS)
 880 {
 881    char *dp;
 882    NYD2_ENTER;
 883
 884    dp = (cp == NULL) ? NULL : (sbufdup)(cp, strlen(cp) SMALLOC_DEBUG_ARGSCALL);
 885    NYD2_LEAVE;
 886    return dp;
 887 }
 888
 889 FL char *
 890 (sbufdup)(char const *cp, size_t len SMALLOC_DEBUG_ARGS)
 891 {
 892    char *dp = NULL;
 893    NYD2_ENTER;
 894
 895    dp = (smalloc)(len +1 SMALLOC_DEBUG_ARGSCALL);
 896    if (cp != NULL)
 897       memcpy(dp, cp, len);
 898    dp[len] = '\0';
 899    NYD2_LEAVE;
 900    return dp;
 901 }
 902
 903 FL char *
 904 n_strlcpy(char *dst, char const *src, size_t len)
 905 {
 906    NYD2_ENTER;
 907
 908    assert(len > 0);
 909
 910    dst = strncpy(dst, src, len);
 911    dst[len -1] = '\0';
 912    NYD2_LEAVE;
 913    return dst;
 914 }
 915
 916 FL int
 917 asccasecmp(char const *s1, char const *s2)
 918 {
 919    int cmp;
 920    NYD2_ENTER;
 921
 922    for (;;) {
 923       char c1 = *s1++, c2 = *s2++;
 924       if ((cmp = lowerconv(c1) - lowerconv(c2)) != 0 || c1 == '\0')
 925          break;
 926    }
 927    NYD2_LEAVE;
 928    return cmp;
 929 }
 930
 931 FL int
 932 ascncasecmp(char const *s1, char const *s2, size_t sz)
 933 {
 934    int cmp = 0;
 935    NYD2_ENTER;
 936
 937    while (sz-- > 0) {
 938       char c1 = *s1++, c2 = *s2++;
 939       cmp = (ui8_t)lowerconv(c1);
 940       cmp -= (ui8_t)lowerconv(c2);
 941       if (cmp != 0 || c1 == '\0')
 942          break;
 943    }
 944    NYD2_LEAVE;
 945    return cmp;
 946 }
 947
 948 FL bool_t
 949 is_asccaseprefix(char const *as1, char const *as2)
 950 {
 951    bool_t rv = FAL0;
 952    NYD2_ENTER;
 953
 954    for (;; ++as1, ++as2) {
 955       char c1 = lowerconv(*as1), c2 = lowerconv(*as2);
 956       if ((rv = (c1 == '\0')))
 957          break;
 958       if (c1 != c2 || c2 == '\0')
 959          break;
 960    }
 961    NYD2_LEAVE;
 962    return rv;
 963 }
 964
 965 #ifdef HAVE_IMAP
 966 FL char const *
 967 asccasestr(char const *haystack, char const *xneedle)
 968 {
 969    char *needle = NULL, *NEEDLE;
 970    size_t i, sz;
 971    NYD2_ENTER;
 972
 973    sz = strlen(xneedle);
 974    if (sz == 0)
 975       goto jleave;
 976
 977    needle = ac_alloc(sz);
 978    NEEDLE = ac_alloc(sz);
 979    for (i = 0; i < sz; i++) {
 980       needle[i] = lowerconv(xneedle[i]);
 981       NEEDLE[i] = upperconv(xneedle[i]);
 982    }
 983
 984    while (*haystack != '\0') {
 985       if (*haystack == *needle || *haystack == *NEEDLE) {
 986          for (i = 1; i < sz; ++i)
 987             if (haystack[i] != needle[i] && haystack[i] != NEEDLE[i])
 988                break;
 989          if (i == sz)
 990             goto jleave;
 991       }
 992       ++haystack;
 993    }
 994    haystack = NULL;
 995 jleave:
 996    if (needle != NULL) {
 997       ac_free(NEEDLE);
 998       ac_free(needle);
 999    }
1000    NYD2_LEAVE;
1001    return haystack;
1002 }
1003 #endif
1004
1005 FL struct str *
1006 (n_str_dup)(struct str *self, struct str const *t SMALLOC_DEBUG_ARGS)
1007 {
1008    NYD_ENTER;
1009    if (t != NULL && t->l > 0) {
1010       self->l = t->l;
1011       self->s = (srealloc)(self->s, t->l +1 SMALLOC_DEBUG_ARGSCALL);
1012       memcpy(self->s, t->s, t->l +1);
1013    } else
1014       self->l = 0;
1015    NYD_LEAVE;
1016    return self;
1017 }
1018
1019 FL struct str *
1020 (n_str_add_buf)(struct str *self, char const *buf, size_t buflen
1021    SMALLOC_DEBUG_ARGS)
1022 {
1023    NYD_ENTER;
1024    if (buflen != 0) {
1025       size_t sl = self->l;
1026       self->l = sl + buflen;
1027       self->s = (srealloc)(self->s, self->l +1 SMALLOC_DEBUG_ARGSCALL);
1028       memcpy(self->s + sl, buf, buflen);
1029       self->s[self->l] = '\0';
1030    }
1031    NYD_LEAVE;
1032    return self;
1033 }
1034
1035 /*
1036  * Our iconv(3) wrapper
1037  */
1038 #ifdef HAVE_ICONV
1039
1040 static void _ic_toupper(char *dest, char const *src);
1041 static void _ic_stripdash(char *p);
1042
1043 static void
1044 _ic_toupper(char *dest, char const *src)
1045 {
1046    NYD2_ENTER;
1047    do
1048       *dest++ = upperconv(*src);
1049    while (*src++ != '\0');
1050    NYD2_LEAVE;
1051 }
1052
1053 static void
1054 _ic_stripdash(char *p)
1055 {
1056    char *q = p;
1057    NYD2_ENTER;
1058
1059    do
1060       if (*(q = p) != '-')
1061          ++q;
1062    while (*p++ != '\0');
1063    NYD2_LEAVE;
1064 }
1065
1066 FL iconv_t
1067 n_iconv_open(char const *tocode, char const *fromcode)
1068 {
1069    iconv_t id;
1070    char *t, *f;
1071    NYD_ENTER;
1072
1073    if ((id = iconv_open(tocode, fromcode)) != (iconv_t)-1)
1074       goto jleave;
1075
1076    /* Remove the "iso-" prefixes for Solaris */
1077    if (!ascncasecmp(tocode, "iso-", 4))
1078       tocode += 4;
1079    else if (!ascncasecmp(tocode, "iso", 3))
1080       tocode += 3;
1081    if (!ascncasecmp(fromcode, "iso-", 4))
1082       fromcode += 4;
1083    else if (!ascncasecmp(fromcode, "iso", 3))
1084       fromcode += 3;
1085    if (*tocode == '\0' || *fromcode == '\0') {
1086       id = (iconv_t)-1;
1087       goto jleave;
1088    }
1089    if ((id = iconv_open(tocode, fromcode)) != (iconv_t)-1)
1090       goto jleave;
1091
1092    /* Solaris prefers upper-case charset names. Don't ask... */
1093    t = salloc(strlen(tocode) +1);
1094    _ic_toupper(t, tocode);
1095    f = salloc(strlen(fromcode) +1);
1096    _ic_toupper(f, fromcode);
1097    if ((id = iconv_open(t, f)) != (iconv_t)-1)
1098       goto jleave;
1099
1100    /* Strip dashes for UnixWare */
1101    _ic_stripdash(t);
1102    _ic_stripdash(f);
1103    if ((id = iconv_open(t, f)) != (iconv_t)-1)
1104       goto jleave;
1105
1106    /* Add your vendor's sillynesses here */
1107
1108    /* If the encoding names are equal at this point, they are just not
1109     * understood by iconv(), and we cannot sensibly use it in any way.  We do
1110     * not perform this as an optimization above since iconv() can otherwise be
1111     * used to check the validity of the input even with identical encoding
1112     * names */
1113    if (!strcmp(t, f))
1114       errno = 0;
1115 jleave:
1116    NYD_LEAVE;
1117    return id;
1118 }
1119
1120 FL void
1121 n_iconv_close(iconv_t cd)
1122 {
1123    NYD_ENTER;
1124    iconv_close(cd);
1125    if (cd == iconvd)
1126       iconvd = (iconv_t)-1;
1127    NYD_LEAVE;
1128 }
1129
1130 #ifdef notyet
1131 FL void
1132 n_iconv_reset(iconv_t cd)
1133 {
1134    NYD_ENTER;
1135    iconv(cd, NULL, NULL, NULL, NULL);
1136    NYD_LEAVE;
1137 }
1138 #endif
1139
1140 /* (2012-09-24: export and use it exclusively to isolate prototype problems
1141  * (*inb* is 'char const **' except in POSIX) in a single place.
1142  * GNU libiconv even allows for configuration time const/non-const..
1143  * In the end it's an ugly guess, but we can't do better since make(1) doesn't
1144  * support compiler invocations which bail on error, so no -Werror */
1145 /* Citrus project? */
1146 # if defined _ICONV_H_ && defined __ICONV_F_HIDE_INVALID
1147   /* DragonFly 3.2.1 is special TODO newer DragonFly too, but different */
1148 #  ifdef __DragonFly__
1149 #   define __INBCAST(S) (char ** __restrict__)UNCONST(S)
1150 #  else
1151 #   define __INBCAST(S) (char const **)UNCONST(S)
1152 #  endif
1153 # endif
1154 # ifndef __INBCAST
1155 #  define __INBCAST(S)  (char **)UNCONST(S)
1156 # endif
1157
1158 FL int
1159 n_iconv_buf(iconv_t cd, char const **inb, size_t *inbleft,/*XXX redo iconv use*/
1160    char **outb, size_t *outbleft, bool_t skipilseq)
1161 {
1162    int err = 0;
1163    NYD2_ENTER;
1164
1165    for (;;) {
1166       size_t sz = iconv(cd, __INBCAST(inb), inbleft, outb, outbleft);
1167       if (sz != (size_t)-1)
1168          break;
1169       err = errno;
1170       if (!skipilseq || err != EILSEQ)
1171          break;
1172       if (*inbleft > 0) {
1173          ++(*inb);
1174          --(*inbleft);
1175       } else if (*outbleft > 0) {
1176          **outb = '\0';
1177          break;
1178       }
1179       if (*outbleft > 0/* TODO 0xFFFD 2*/) {
1180          /* TODO 0xFFFD (*outb)[0] = '[';
1181           * TODO (*outb)[1] = '?';
1182           * TODO 0xFFFD (*outb)[2] = ']';
1183           * TODO (*outb) += 3;
1184           * TODO (*outbleft) -= 3; */
1185           *(*outb)++ = '?';
1186           --*outbleft;
1187       } else {
1188          err = E2BIG;
1189          break;
1190       }
1191       err = 0;
1192    }
1193    NYD2_LEAVE;
1194    return err;
1195 }
1196 # undef __INBCAST
1197
1198 FL int
1199 n_iconv_str(iconv_t cd, struct str *out, struct str const *in,
1200    struct str *in_rest_or_null, bool_t skipilseq)
1201 {
1202    int err;
1203    char *obb, *ob;
1204    char const *ib;
1205    size_t olb, ol, il;
1206    NYD2_ENTER;
1207
1208    err = 0;
1209    obb = out->s;
1210    olb = out->l;
1211    ol = in->l;
1212
1213    ol = (ol << 1) - (ol >> 4);
1214    if (olb < ol) {
1215       olb = ol;
1216       goto jrealloc;
1217    }
1218
1219    for (;;) {
1220       ib = in->s;
1221       il = in->l;
1222       ob = obb;
1223       ol = olb;
1224       err = n_iconv_buf(cd, &ib, &il, &ob, &ol, skipilseq);
1225       if (err == 0 || err != E2BIG)
1226          break;
1227       err = 0;
1228       olb += in->l;
1229 jrealloc:
1230       obb = srealloc(obb, olb);
1231    }
1232
1233    if (in_rest_or_null != NULL) {
1234       in_rest_or_null->s = UNCONST(ib);
1235       in_rest_or_null->l = il;
1236    }
1237    out->s = obb;
1238    out->l = olb - ol;
1239    NYD2_LEAVE;
1240    return err;
1241 }
1242 #endif /* HAVE_ICONV */
1243
1244 /* s-it-mode */