nam_a_grp.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Name lists, alternates and groups: aliases, mailing lists, shortcuts.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  *      The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE nam_a_grp
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 enum group_type {
  43    /* Main types (bits not values for easier testing only) */
  44    GT_ALIAS       = 1<< 0,
  45    GT_MLIST       = 1<< 1,
  46    GT_SHORTCUT    = 1<< 2,
  47    GT_CUSTOMHDR   = 1<< 3,
  48    GT_MASK        = GT_ALIAS | GT_MLIST | GT_SHORTCUT | GT_CUSTOMHDR,
  49
  50    /* Subtype bits and flags */
  51    GT_SUBSCRIBE   = 1<< 4,
  52    GT_REGEX       = 1<< 5,
  53
  54    /* Extended type mask to be able to reflect what we really have; i.e., mlist
  55     * can have GT_REGEX if they are subscribed or not, but `mlsubscribe' should
  56     * print out only GT_MLIST which have the GT_SUBSCRIBE attribute set */
  57    GT_PRINT_MASK  = GT_MASK | GT_SUBSCRIBE
  58 };
  59
  60 struct group {
  61    struct group   *g_next;
  62    size_t         g_subclass_off;   /* of "subclass" in .g_id (if any) */
  63    ui8_t          g_type;           /* enum group_type */
  64    /* Identifying name, of variable size.  Dependent on actual "subtype" more
  65     * data follows thereafter, but note this is always used (i.e., for regular
  66     * expression entries this is still set to the plain string) */
  67    char           g_id[VFIELD_SIZE(-1)];
  68 };
  69 #define GP_TO_SUBCLASS(X,G) \
  70 do {\
  71    union __group_subclass {void *gs_vp; char *gs_cp;} __gs__;\
  72    __gs__.gs_cp = (char*)UNCONST(G) + (G)->g_subclass_off;\
  73    (X) = __gs__.gs_vp;\
  74 } while (0)
  75
  76 struct grp_names_head {
  77    struct grp_names  *gnh_head;
  78 };
  79
  80 struct grp_names {
  81    struct grp_names  *gn_next;
  82    char              gn_id[VFIELD_SIZE(0)];
  83 };
  84
  85 #ifdef HAVE_REGEX
  86 struct grp_regex {
  87    struct grp_regex  *gr_last;
  88    struct grp_regex  *gr_next;
  89    struct group      *gr_mygroup;   /* xxx because lists use grp_regex*! ?? */
  90    size_t            gr_hits;       /* Number of times this group matched */
  91    regex_t           gr_regex;
  92 };
  93 #endif
  94
  95 struct group_lookup {
  96    struct group   **gl_htable;
  97    struct group   **gl_slot;
  98    struct group   *gl_slot_last;
  99    struct group   *gl_group;
 100 };
 101
 102 /* List of alternate names of user */
 103 static char             **_altnames;
 104
 105 /* `alias' */
 106 static struct group     *_alias_heads[HSHSIZE]; /* TODO dynamic hash */
 107
 108 /* `mlist', `mlsubscribe'.  Anything is stored in the hashmap.. */
 109 static struct group     *_mlist_heads[HSHSIZE]; /* TODO dynamic hash */
 110
 111 /* ..but entries which have GT_REGEX set are false lookups and will really be
 112  * accessed via sequential lists instead, which are type-specific for better
 113  * performance, but also to make it possible to have ".*@xy.org" as a mlist
 114  * and "(one|two)@xy.org" as a mlsubscription.
 115  * These lists use a bit of QOS optimization in that a matching group will
 116  * become relinked as the new list head if its hit count is
 117  *    (>= ((xy_hits / _xy_size) >> 2))
 118  * Note that the hit counts only count currently linked in nodes.. */
 119 #ifdef HAVE_REGEX
 120 static struct grp_regex *_mlist_regex, *_mlsub_regex;
 121 static size_t           _mlist_size, _mlist_hits, _mlsub_size, _mlsub_hits;
 122 #endif
 123
 124 /* `shortcut' */
 125 static struct group     *_shortcut_heads[HSHSIZE]; /* TODO dynamic hash */
 126
 127 /* `customhdr' */
 128 static struct group     *_customhdr_heads[HSHSIZE]; /* TODO dynamic hash */
 129
 130 /* Same name, while taking care for *allnet*? */
 131 static bool_t        _same_name(char const *n1, char const *n2);
 132
 133 /* Delete the given name from a namelist */
 134 static struct name * delname(struct name *np, char const *name);
 135
 136 /* Put another node onto a list of names and return the list */
 137 static struct name * put(struct name *list, struct name *node);
 138
 139 /* Grab a single name (liberal name) */
 140 static char const *  yankname(char const *ap, char *wbuf,
 141                         char const *separators, int keepcomms);
 142
 143 /* Extraction multiplexer that splits an input line to names */
 144 static struct name * _extract1(char const *line, enum gfield ntype,
 145                         char const *separators, bool_t keepcomms);
 146
 147 /* Recursively expand a alias name.  Limit expansion to some fixed level.
 148  * Direct recursion is not expanded for convenience */
 149 static struct name * _gexpand(size_t level, struct name *nlist,
 150                         struct group *gp, bool_t metoo, int ntype);
 151
 152 /* Lookup a group, return it or NULL, fill in glp anyway */
 153 static struct group * _group_lookup(enum group_type gt,
 154                         struct group_lookup *glp, char const *id);
 155
 156 /* Easier-to-use wrapper around _group_lookup() */
 157 static struct group * _group_find(enum group_type gt, char const *id);
 158
 159 /* Iteration: go to the first group, which also inits the iterator.  A valid
 160  * iterator can be stepped via _next().  A NULL return means no (more) groups
 161  * to be iterated exist, in which case only glp->gl_group is set (NULL) */
 162 static struct group * _group_go_first(enum group_type gt,
 163                         struct group_lookup *glp);
 164 static struct group * _group_go_next(struct group_lookup *glp);
 165
 166 /* Fetch the group id, create it as necessary */
 167 static struct group * _group_fetch(enum group_type gt, char const *id,
 168                         size_t addsz);
 169
 170 /* "Intelligent" delete which handles a "*" id, too;
 171  * returns a true boolean if a group was deleted, and always succeeds for "*" */
 172 static bool_t        _group_del(enum group_type gt, char const *id);
 173
 174 static struct group * __group_del(struct group_lookup *glp);
 175 static void          __names_del(struct group *gp);
 176
 177 /* Print all groups of the given type, alphasorted */
 178 static void          _group_print_all(enum group_type gt);
 179
 180 static int           __group_print_qsorter(void const *a, void const *b);
 181
 182 /* Really print a group, actually.  Return number of written lines */
 183 static size_t        _group_print(struct group const *gp, FILE *fo);
 184
 185 /* Multiplexers for list and subscribe commands */
 186 static int           _mlmux(enum group_type gt, char **argv);
 187 static int           _unmlmux(enum group_type gt, char **argv);
 188
 189 /* Relinkers for the sequential match lists */
 190 #ifdef HAVE_REGEX
 191 static void          _mlmux_linkin(struct group *gp);
 192 static void          _mlmux_linkout(struct group *gp);
 193 # define _MLMUX_LINKIN(GP) \
 194    do if ((GP)->g_type & GT_REGEX) _mlmux_linkin(GP); while (0)
 195 # define _MLMUX_LINKOUT(GP) \
 196    do if ((GP)->g_type & GT_REGEX) _mlmux_linkout(GP); while (0)
 197 #else
 198 # define _MLMUX_LINKIN(GP)
 199 # define _MLMUX_LINKOUT(GP)
 200 #endif
 201
 202 static bool_t
 203 _same_name(char const *n1, char const *n2)
 204 {
 205    bool_t rv = FAL0;
 206    char c1, c2;
 207    NYD_ENTER;
 208
 209    if (ok_blook(allnet)) {
 210       do {
 211          c1 = *n1++;
 212          c2 = *n2++;
 213          c1 = lowerconv(c1);
 214          c2 = lowerconv(c2);
 215          if (c1 != c2)
 216             goto jleave;
 217       } while (c1 != '\0' && c2 != '\0' && c1 != '@' && c2 != '@');
 218       rv = 1;
 219    } else
 220       rv = !asccasecmp(n1, n2);
 221 jleave:
 222    NYD_LEAVE;
 223    return rv;
 224 }
 225
 226 static struct name *
 227 delname(struct name *np, char const *name)
 228 {
 229    struct name *p;
 230    NYD_ENTER;
 231
 232    for (p = np; p != NULL; p = p->n_flink)
 233       if (_same_name(p->n_name, name)) {
 234          if (p->n_blink == NULL) {
 235             if (p->n_flink != NULL)
 236                p->n_flink->n_blink = NULL;
 237             np = p->n_flink;
 238             continue;
 239          }
 240          if (p->n_flink == NULL) {
 241             if (p->n_blink != NULL)
 242                p->n_blink->n_flink = NULL;
 243             continue;
 244          }
 245          p->n_blink->n_flink = p->n_flink;
 246          p->n_flink->n_blink = p->n_blink;
 247       }
 248    NYD_LEAVE;
 249    return np;
 250 }
 251
 252 static struct name *
 253 put(struct name *list, struct name *node)
 254 {
 255    NYD_ENTER;
 256    node->n_flink = list;
 257    node->n_blink = NULL;
 258    if (list != NULL)
 259       list->n_blink = node;
 260    NYD_LEAVE;
 261    return node;
 262 }
 263
 264 static char const *
 265 yankname(char const *ap, char *wbuf, char const *separators, int keepcomms)
 266 {
 267    char const *cp;
 268    char *wp, c, inquote, lc, lastsp;
 269    NYD_ENTER;
 270
 271    *(wp = wbuf) = '\0';
 272
 273    /* Skip over intermediate list trash, as in ".org>  ,  <xy@zz.org>" */
 274    for (c = *ap; blankchar(c) || c == ','; c = *++ap)
 275       ;
 276    if (c == '\0') {
 277       cp = NULL;
 278       goto jleave;
 279    }
 280
 281    /* Parse a full name: TODO RFC 5322
 282     * - Keep everything in quotes, liberal handle *quoted-pair*s therein
 283     * - Skip entire (nested) comments
 284     * - In non-quote, non-comment, join adjacent space to a single SP
 285     * - Understand separators only in non-quote, non-comment context,
 286     *   and only if not part of a *quoted-pair* (XXX too liberal) */
 287    cp = ap;
 288    for (inquote = lc = lastsp = 0;; lc = c, ++cp) {
 289       c = *cp;
 290       if (c == '\0')
 291          break;
 292       if (c == '\\') {
 293          lastsp = 0;
 294          continue;
 295       }
 296       if (c == '"') {
 297          if (lc != '\\')
 298             inquote = !inquote;
 299 #if 0 /* TODO when doing real RFC 5322 parsers - why have i done this? */
 300          else
 301             --wp;
 302 #endif
 303          goto jwpwc;
 304       }
 305       if (inquote || lc == '\\') {
 306 jwpwc:
 307          *wp++ = c;
 308          lastsp = 0;
 309          continue;
 310       }
 311       if (c == '(') {
 312          ap = cp;
 313          cp = skip_comment(cp + 1);
 314          if (keepcomms)
 315             while (ap < cp)
 316                *wp++ = *ap++;
 317          --cp;
 318          lastsp = 0;
 319          continue;
 320       }
 321       if (strchr(separators, c) != NULL)
 322          break;
 323
 324       lc = lastsp;
 325       lastsp = blankchar(c);
 326       if (!lastsp || !lc)
 327          *wp++ = c;
 328    }
 329    if (blankchar(lc))
 330       --wp;
 331
 332    *wp = '\0';
 333 jleave:
 334    NYD_LEAVE;
 335    return cp;
 336 }
 337
 338 static struct name *
 339 _extract1(char const *line, enum gfield ntype, char const *separators,
 340    bool_t keepcomms)
 341 {
 342    struct name *topp, *np, *t;
 343    char const *cp;
 344    char *nbuf;
 345    NYD_ENTER;
 346
 347    topp = NULL;
 348    if (line == NULL || *line == '\0')
 349       goto jleave;
 350
 351    np = NULL;
 352    cp = line;
 353    nbuf = smalloc(strlen(line) +1);
 354    while ((cp = yankname(cp, nbuf, separators, keepcomms)) != NULL) {
 355       t = nalloc(nbuf, ntype);
 356       if (topp == NULL)
 357          topp = t;
 358       else
 359          np->n_flink = t;
 360       t->n_blink = np;
 361       np = t;
 362    }
 363    free(nbuf);
 364 jleave:
 365    NYD_LEAVE;
 366    return topp;
 367 }
 368
 369 static struct name *
 370 _gexpand(size_t level, struct name *nlist, struct group *gp, bool_t metoo,
 371    int ntype)
 372 {
 373    struct grp_names_head *gnhp;
 374    struct grp_names *gnp;
 375    NYD_ENTER;
 376
 377    if (UICMP(z, level++, >, MAXEXP)) {
 378       n_err(_("Expanding alias to depth larger than %d\n"), MAXEXP);
 379       goto jleave;
 380    }
 381
 382    GP_TO_SUBCLASS(gnhp, gp);
 383    for (gnp = gnhp->gnh_head; gnp != NULL; gnp = gnp->gn_next) {
 384       char *cp;
 385       struct group *ngp;
 386
 387       /* FIXME we do not really support leading backslash quoting do we??? */
 388       if (*(cp = gnp->gn_id) == '\\' || !strcmp(cp, gp->g_id))
 389          goto jquote;
 390
 391       if ((ngp = _group_find(GT_ALIAS, cp)) != NULL) {
 392          /* For S-nail(1), the "alias" may *be* the sender in that a name maps
 393           * to a full address specification; aliases cannot be empty */
 394          struct grp_names_head *ngnhp;
 395          GP_TO_SUBCLASS(ngnhp, ngp);
 396
 397          assert(ngnhp->gnh_head != NULL);
 398          if (metoo || ngnhp->gnh_head->gn_next != NULL ||
 399                !_same_name(cp, myname))
 400             nlist = _gexpand(level, nlist, ngp, metoo, ntype);
 401          continue;
 402       }
 403
 404       /* Here we should allow to expand to itself if only person in alias */
 405 jquote:
 406       if (metoo || gnhp->gnh_head->gn_next == NULL || !_same_name(cp, myname))
 407          nlist = put(nlist, nalloc(cp, ntype | GFULL));
 408    }
 409 jleave:
 410    NYD_LEAVE;
 411    return nlist;
 412 }
 413
 414 static struct group *
 415 _group_lookup(enum group_type gt, struct group_lookup *glp, char const *id)
 416 {
 417    struct group *lgp, *gp;
 418    NYD_ENTER;
 419
 420    gt &= GT_MASK;
 421    lgp = NULL;
 422    gp = *(glp->gl_htable = glp->gl_slot =
 423           ((gt & GT_ALIAS ? _alias_heads :
 424             (gt & GT_MLIST ? _mlist_heads :
 425             (gt & GT_SHORTCUT ? _shortcut_heads : _customhdr_heads))) +
 426            torek_hash(id) % HSHSIZE));
 427
 428    for (; gp != NULL; lgp = gp, gp = gp->g_next)
 429       if ((gp->g_type & gt) && *gp->g_id == *id && !strcmp(gp->g_id, id))
 430          break;
 431
 432    glp->gl_slot_last = lgp;
 433    glp->gl_group = gp;
 434    NYD_LEAVE;
 435    return gp;
 436 }
 437
 438 static struct group *
 439 _group_find(enum group_type gt, char const *id)
 440 {
 441    struct group_lookup gl;
 442    struct group *gp;
 443    NYD_ENTER;
 444
 445    gp = _group_lookup(gt, &gl, id);
 446    NYD_LEAVE;
 447    return gp;
 448 }
 449
 450 static struct group *
 451 _group_go_first(enum group_type gt, struct group_lookup *glp)
 452 {
 453    struct group **gpa, *gp;
 454    size_t i;
 455    NYD_ENTER;
 456
 457    for (glp->gl_htable = gpa = (gt & GT_ALIAS ? _alias_heads :
 458             (gt & GT_MLIST ? _mlist_heads :
 459             (gt & GT_SHORTCUT ? _shortcut_heads : _customhdr_heads))), i = 0;
 460          i < HSHSIZE; ++gpa, ++i)
 461       if ((gp = *gpa) != NULL) {
 462          glp->gl_slot = gpa;
 463          glp->gl_group = gp;
 464          goto jleave;
 465       }
 466
 467    glp->gl_group = gp = NULL;
 468 jleave:
 469    glp->gl_slot_last = NULL;
 470    NYD_LEAVE;
 471    return gp;
 472 }
 473
 474 static struct group *
 475 _group_go_next(struct group_lookup *glp)
 476 {
 477    struct group *gp, **gpa;
 478    NYD_ENTER;
 479
 480    if ((gp = glp->gl_group->g_next) != NULL)
 481       glp->gl_slot_last = glp->gl_group;
 482    else {
 483       glp->gl_slot_last = NULL;
 484       for (gpa = glp->gl_htable + HSHSIZE; ++glp->gl_slot < gpa;)
 485          if ((gp = *glp->gl_slot) != NULL)
 486             break;
 487    }
 488    glp->gl_group = gp;
 489    NYD_LEAVE;
 490    return gp;
 491 }
 492
 493 static struct group *
 494 _group_fetch(enum group_type gt, char const *id, size_t addsz)
 495 {
 496    struct group_lookup gl;
 497    struct group *gp;
 498    size_t l, i;
 499    NYD_ENTER;
 500
 501    if ((gp = _group_lookup(gt, &gl, id)) != NULL)
 502       goto jleave;
 503
 504    l = strlen(id) +1;
 505    i = n_ALIGN(sizeof(*gp) - VFIELD_SIZEOF(struct group, g_id) + l);
 506    switch (gt & GT_MASK) {
 507    case GT_ALIAS:
 508       addsz = sizeof(struct grp_names_head);
 509       break;
 510    case GT_MLIST:
 511 #ifdef HAVE_REGEX
 512       if (is_maybe_regex(id)) {
 513          addsz = sizeof(struct grp_regex);
 514          gt |= GT_REGEX;
 515       } else
 516 #endif
 517    case GT_SHORTCUT:
 518    default:
 519       break;
 520    }
 521
 522    gp = smalloc(i + addsz);
 523    gp->g_subclass_off = i;
 524    gp->g_type = gt;
 525    memcpy(gp->g_id, id, l);
 526
 527    if (gt & GT_ALIAS) {
 528       struct grp_names_head *gnhp;
 529       GP_TO_SUBCLASS(gnhp, gp);
 530       gnhp->gnh_head = NULL;
 531    }
 532 #ifdef HAVE_REGEX
 533    else if (/*(gt & GT_MLIST) &&*/ gt & GT_REGEX) {
 534       struct grp_regex *grp;
 535       GP_TO_SUBCLASS(grp, gp);
 536
 537       if (regcomp(&grp->gr_regex, id, REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
 538          n_err(_("Invalid regular expression: \"%s\"\n"), id);
 539          free(gp);
 540          gp = NULL;
 541          goto jleave;
 542       }
 543       grp->gr_mygroup = gp;
 544       _mlmux_linkin(gp);
 545    }
 546 #endif
 547
 548    gp->g_next = *gl.gl_slot;
 549    *gl.gl_slot = gp;
 550 jleave:
 551    NYD_LEAVE;
 552    return gp;
 553 }
 554
 555 static bool_t
 556 _group_del(enum group_type gt, char const *id)
 557 {
 558    enum group_type xgt = gt & GT_MASK;
 559    struct group_lookup gl;
 560    struct group *gp;
 561    NYD_ENTER;
 562
 563    /* Delete 'em all? */
 564    if (id[0] == '*' && id[1] == '\0') {
 565       for (gp = _group_go_first(gt, &gl); gp != NULL;)
 566          gp = (gp->g_type & xgt) ? __group_del(&gl) : _group_go_next(&gl);
 567       gp = (struct group*)TRU1;
 568    } else if ((gp = _group_lookup(gt, &gl, id)) != NULL) {
 569       if (gp->g_type & xgt)
 570          __group_del(&gl);
 571       else
 572          gp = NULL;
 573    }
 574    NYD_LEAVE;
 575    return (gp != NULL);
 576 }
 577
 578 static struct group *
 579 __group_del(struct group_lookup *glp)
 580 {
 581    struct group *x, *gp;
 582    NYD_ENTER;
 583
 584    /* Overly complicated: link off this node, step ahead to next.. */
 585    x = glp->gl_group;
 586    if ((gp = glp->gl_slot_last) != NULL) {
 587       gp = (gp->g_next = x->g_next);
 588    } else {
 589       glp->gl_slot_last = NULL;
 590       gp = (*glp->gl_slot = x->g_next);
 591
 592       if (gp == NULL) {
 593          struct group **gpa = glp->gl_htable + HSHSIZE;
 594
 595          while (++glp->gl_slot < gpa)
 596             if ((gp = *glp->gl_slot) != NULL)
 597                break;
 598       }
 599    }
 600    glp->gl_group = gp;
 601
 602    if (x->g_type & GT_ALIAS)
 603       __names_del(x);
 604 #ifdef HAVE_REGEX
 605    else if (/*(x->g_type & GT_MLIST) &&*/ x->g_type & GT_REGEX) {
 606       struct grp_regex *grp;
 607       GP_TO_SUBCLASS(grp, x);
 608
 609       regfree(&grp->gr_regex);
 610       _mlmux_linkout(x);
 611    }
 612 #endif
 613
 614    free(x);
 615    NYD_LEAVE;
 616    return gp;
 617 }
 618
 619 static void
 620 __names_del(struct group *gp)
 621 {
 622    struct grp_names_head *gnhp;
 623    struct grp_names *gnp;
 624    NYD_ENTER;
 625
 626    GP_TO_SUBCLASS(gnhp, gp);
 627    for (gnp = gnhp->gnh_head; gnp != NULL;) {
 628       struct grp_names *x = gnp;
 629       gnp = gnp->gn_next;
 630       free(x);
 631    }
 632    NYD_LEAVE;
 633 }
 634
 635 static void
 636 _group_print_all(enum group_type gt)
 637 {
 638    enum group_type xgt;
 639    struct group **gpa;
 640    struct group const *gp;
 641    ui32_t h, i;
 642    char const **ida;
 643    FILE *fp;
 644    size_t lines;
 645    NYD_ENTER;
 646
 647    xgt = gt & GT_PRINT_MASK;
 648    gpa = (xgt & GT_ALIAS ? _alias_heads
 649          : (xgt & GT_MLIST ? _mlist_heads
 650          : (xgt & GT_SHORTCUT ? _shortcut_heads : _customhdr_heads)));
 651
 652    for (h = 0, i = 1; h < HSHSIZE; ++h)
 653       for (gp = gpa[h]; gp != NULL; gp = gp->g_next)
 654          if ((gp->g_type & xgt) == xgt)
 655             ++i;
 656    ida = salloc(i * sizeof *ida);
 657
 658    for (i = h = 0; h < HSHSIZE; ++h)
 659       for (gp = gpa[h]; gp != NULL; gp = gp->g_next)
 660          if ((gp->g_type & xgt) == xgt)
 661             ida[i++] = gp->g_id;
 662    ida[i] = NULL;
 663
 664    if (i > 1)
 665       qsort(ida, i, sizeof *ida, &__group_print_qsorter);
 666
 667    if ((fp = Ftmp(NULL, "prgroup", OF_RDWR | OF_UNLINK | OF_REGISTER)) == NULL)
 668       fp = stdout;
 669    lines = 0;
 670
 671    for (i = 0; ida[i] != NULL; ++i)
 672       lines += _group_print(_group_find(gt, ida[i]), fp);
 673 #ifdef HAVE_REGEX
 674    if (gt & GT_MLIST) {
 675       if (gt & GT_SUBSCRIBE)
 676          i = (ui32_t)_mlsub_size, h = (ui32_t)_mlsub_hits;
 677       else
 678          i = (ui32_t)_mlist_size, h = (ui32_t)_mlist_hits;
 679       if (i > 0)
 680          fprintf(fp, _("# %s list regex(7) total: %u entries, %u hits\n"),
 681             (gt & GT_SUBSCRIBE ? _("Subscribed") : _("Non-subscribed")),
 682             i, h);
 683    }
 684 #endif
 685
 686    if (fp != stdout) {
 687       page_or_print(fp, lines);
 688       Fclose(fp);
 689    }
 690    NYD_LEAVE;
 691 }
 692
 693 static int
 694 __group_print_qsorter(void const *a, void const *b)
 695 {
 696    int rv;
 697    NYD_ENTER;
 698
 699    rv = strcmp(*(char**)UNCONST(a), *(char**)UNCONST(b));
 700    NYD_LEAVE;
 701    return rv;
 702 }
 703
 704 static size_t
 705 _group_print(struct group const *gp, FILE *fo)
 706 {
 707    char const *cp;
 708    size_t rv;
 709    NYD_ENTER;
 710
 711    rv = 1;
 712
 713    if (gp->g_type & GT_ALIAS) {
 714       struct grp_names_head *gnhp;
 715       struct grp_names *gnp;
 716
 717       fprintf(fo, "alias %s", gp->g_id);
 718
 719       GP_TO_SUBCLASS(gnhp, gp);
 720       if ((gnp = gnhp->gnh_head) != NULL) { /* xxx always 1+ entries */
 721          do {
 722             struct grp_names *x = gnp;
 723             gnp = gnp->gn_next;
 724             fprintf(fo, " \"%s\"", string_quote(x->gn_id));
 725          } while (gnp != NULL);
 726       }
 727    } else if (gp->g_type & GT_MLIST) {
 728 #ifdef HAVE_REGEX
 729       if (gp->g_type & GT_REGEX) {
 730          size_t i;
 731          struct grp_regex *grp,
 732             *lp = (gp->g_type & GT_SUBSCRIBE ? _mlsub_regex : _mlist_regex);
 733
 734          GP_TO_SUBCLASS(grp, gp);
 735          for (i = 1; lp != grp; lp = lp->gr_next)
 736             ++i;
 737          fprintf(fo, "# regex(7): hits %" PRIuZ ", sort %" PRIuZ ".\n  ",
 738             grp->gr_hits, i);
 739          ++rv;
 740       }
 741 #endif
 742
 743       fprintf(fo, "%s %s",
 744          (gp->g_type & GT_SUBSCRIBE ? "mlsubscribe" : "mlist"), gp->g_id);
 745    } else if (gp->g_type & GT_SHORTCUT) {
 746       GP_TO_SUBCLASS(cp, gp);
 747       fprintf(fo, "shortcut %s \"%s\"", gp->g_id, string_quote(cp));
 748    } else if (gp->g_type & GT_CUSTOMHDR) {
 749       GP_TO_SUBCLASS(cp, gp);
 750       fprintf(fo, "customhdr %s \"%s\"", gp->g_id, string_quote(cp));
 751    }
 752
 753    putc('\n', fo);
 754    NYD_LEAVE;
 755    return rv;
 756 }
 757
 758 static int
 759 _mlmux(enum group_type gt, char **argv)
 760 {
 761    struct group *gp;
 762    int rv = 0;
 763    NYD_ENTER;
 764
 765    if (*argv == NULL)
 766       _group_print_all(gt);
 767    else do {
 768       if ((gp = _group_find(gt, *argv)) != NULL) {
 769          if (gt & GT_SUBSCRIBE) {
 770             if (!(gp->g_type & GT_SUBSCRIBE)) {
 771                _MLMUX_LINKOUT(gp);
 772                gp->g_type |= GT_SUBSCRIBE;
 773                _MLMUX_LINKIN(gp);
 774             } else {
 775                n_err(_("Mailing-list already `mlsubscribe'd: %s\n"),
 776                   *argv);
 777                rv = 1;
 778             }
 779          } else {
 780             n_err(_("Mailing-list already `mlist'ed: %s\n"), *argv);
 781             rv = 1;
 782          }
 783       } else
 784          _group_fetch(gt, *argv, 0);
 785    } while (*++argv != NULL);
 786
 787    NYD_LEAVE;
 788    return rv;
 789 }
 790
 791 static int
 792 _unmlmux(enum group_type gt, char **argv)
 793 {
 794    struct group *gp;
 795    int rv = 0;
 796    NYD_ENTER;
 797
 798    for (; *argv != NULL; ++argv) {
 799       if (gt & GT_SUBSCRIBE) {
 800          struct group_lookup gl;
 801          bool_t isaster;
 802
 803          if (!(isaster = (**argv == '*')))
 804             gp = _group_find(gt, *argv);
 805          else if ((gp = _group_go_first(gt, &gl)) == NULL)
 806             continue;
 807          else if (gp != NULL && !(gp->g_type & GT_SUBSCRIBE))
 808             goto jaster_entry;
 809
 810          if (gp != NULL) {
 811 jaster_redo:
 812             if (gp->g_type & GT_SUBSCRIBE) {
 813                _MLMUX_LINKOUT(gp);
 814                gp->g_type &= ~GT_SUBSCRIBE;
 815                _MLMUX_LINKIN(gp);
 816                if (isaster) {
 817 jaster_entry:
 818                   while ((gp = _group_go_next(&gl)) != NULL &&
 819                         !(gp->g_type & GT_SUBSCRIBE))
 820                      ;
 821                   if (gp != NULL)
 822                      goto jaster_redo;
 823                }
 824             } else {
 825                n_err(_("Mailing-list not `mlsubscribe'd: \"%s\"\n"), *argv);
 826                rv = 1;
 827             }
 828             continue;
 829          }
 830       } else if (_group_del(gt, *argv))
 831          continue;
 832       n_err(_("No such mailing-list: \"%s\"\n"), *argv);
 833       rv = 1;
 834    }
 835    NYD_LEAVE;
 836    return rv;
 837 }
 838
 839 #ifdef HAVE_REGEX
 840 static void
 841 _mlmux_linkin(struct group *gp)
 842 {
 843    struct grp_regex **lpp, *grp, *lhp;
 844    NYD_ENTER;
 845
 846    if (gp->g_type & GT_SUBSCRIBE) {
 847       lpp = &_mlsub_regex;
 848       ++_mlsub_size;
 849    } else {
 850       lpp = &_mlist_regex;
 851       ++_mlist_size;
 852    }
 853
 854    GP_TO_SUBCLASS(grp, gp);
 855    if ((lhp = *lpp) != NULL) {
 856       (grp->gr_last = lhp->gr_last)->gr_next = grp;
 857       (grp->gr_next = lhp)->gr_last = grp;
 858    } else
 859       *lpp = grp->gr_last = grp->gr_next = grp;
 860    grp->gr_hits = 0;
 861    NYD_LEAVE;
 862 }
 863
 864 static void
 865 _mlmux_linkout(struct group *gp)
 866 {
 867    struct grp_regex *grp, **lpp;
 868    NYD_ENTER;
 869
 870    GP_TO_SUBCLASS(grp, gp);
 871
 872    if (gp->g_type & GT_SUBSCRIBE) {
 873       lpp = &_mlsub_regex;
 874       --_mlsub_size;
 875       _mlsub_hits -= grp->gr_hits;
 876    } else {
 877       lpp = &_mlist_regex;
 878       --_mlist_size;
 879       _mlist_hits -= grp->gr_hits;
 880    }
 881
 882    if (grp->gr_next == grp)
 883       *lpp = NULL;
 884    else {
 885       (grp->gr_last->gr_next = grp->gr_next)->gr_last = grp->gr_last;
 886       if (*lpp == grp)
 887          *lpp = grp->gr_next;
 888    }
 889    NYD_LEAVE;
 890 }
 891 #endif /* HAVE_REGEX */
 892
 893 FL struct name *
 894 nalloc(char *str, enum gfield ntype)
 895 {
 896    struct addrguts ag;
 897    struct str in, out;
 898    struct name *np;
 899    NYD_ENTER;
 900    assert(!(ntype & GFULLEXTRA) || (ntype & GFULL) != 0);
 901
 902    addrspec_with_guts(((ntype & (GFULL | GSKIN | GREF)) != 0), str, &ag);
 903    if (!(ag.ag_n_flags & NAME_NAME_SALLOC)) {
 904       ag.ag_n_flags |= NAME_NAME_SALLOC;
 905       np = salloc(sizeof(*np) + ag.ag_slen +1);
 906       memcpy(np + 1, ag.ag_skinned, ag.ag_slen +1);
 907       ag.ag_skinned = (char*)(np + 1);
 908    } else
 909       np = salloc(sizeof *np);
 910
 911    np->n_flink = NULL;
 912    np->n_blink = NULL;
 913    np->n_type = ntype;
 914    np->n_flags = 0;
 915
 916    np->n_fullname = np->n_name = ag.ag_skinned;
 917    np->n_fullextra = NULL;
 918    np->n_flags = ag.ag_n_flags;
 919
 920    if (ntype & GFULL) {
 921       if (ag.ag_ilen == ag.ag_slen
 922 #ifdef HAVE_IDNA
 923             && !(ag.ag_n_flags & NAME_IDNA)
 924 #endif
 925       )
 926          goto jleave;
 927       if (ag.ag_n_flags & NAME_ADDRSPEC_ISFILEORPIPE)
 928          goto jleave;
 929
 930       /* n_fullextra is only the complete name part without address.
 931        * Beware of "-r '<abc@def>'", don't treat that as FULLEXTRA */
 932       if ((ntype & GFULLEXTRA) && ag.ag_ilen > ag.ag_slen + 2) {
 933          size_t s = ag.ag_iaddr_start, e = ag.ag_iaddr_aend, i;
 934          char const *cp;
 935
 936          if (s == 0 || str[--s] != '<' || str[e++] != '>')
 937             goto jskipfullextra;
 938          i = ag.ag_ilen - e;
 939          in.s = ac_alloc(s + i +1);
 940          memcpy(in.s, str, s);
 941          if (i > 0)
 942             memcpy(in.s + s, str + e, i);
 943          s += i;
 944          in.s[in.l = s] = '\0';
 945          mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
 946
 947          for (cp = out.s, i = out.l; i > 0 && spacechar(*cp); --i, ++cp)
 948             ;
 949          while (i > 0 && spacechar(cp[i - 1]))
 950             --i;
 951          np->n_fullextra = savestrbuf(cp, i);
 952
 953          free(out.s);
 954          ac_free(in.s);
 955       }
 956 jskipfullextra:
 957
 958       /* n_fullname depends on IDNA conversion */
 959 #ifdef HAVE_IDNA
 960       if (!(ag.ag_n_flags & NAME_IDNA)) {
 961 #endif
 962          in.s = str;
 963          in.l = ag.ag_ilen;
 964 #ifdef HAVE_IDNA
 965       } else {
 966          /* The domain name was IDNA and has been converted.  We also have to
 967           * ensure that the domain name in .n_fullname is replaced with the
 968           * converted version, since MIME doesn't perform encoding of addrs */
 969          size_t l = ag.ag_iaddr_start,
 970             lsuff = ag.ag_ilen - ag.ag_iaddr_aend;
 971          in.s = ac_alloc(l + ag.ag_slen + lsuff +1);
 972          memcpy(in.s, str, l);
 973          memcpy(in.s + l, ag.ag_skinned, ag.ag_slen);
 974          l += ag.ag_slen;
 975          memcpy(in.s + l, str + ag.ag_iaddr_aend, lsuff);
 976          l += lsuff;
 977          in.s[l] = '\0';
 978          in.l = l;
 979       }
 980 #endif
 981       mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
 982       np->n_fullname = savestr(out.s);
 983       free(out.s);
 984 #ifdef HAVE_IDNA
 985       if (ag.ag_n_flags & NAME_IDNA)
 986          ac_free(in.s);
 987 #endif
 988       np->n_flags |= NAME_FULLNAME_SALLOC;
 989    }
 990 jleave:
 991    NYD_LEAVE;
 992    return np;
 993 }
 994
 995 FL struct name *
 996 ndup(struct name *np, enum gfield ntype)
 997 {
 998    struct name *nnp;
 999    NYD_ENTER;
1000
1001    if ((ntype & (GFULL | GSKIN)) && !(np->n_flags & NAME_SKINNED)) {
1002       nnp = nalloc(np->n_name, ntype);
1003       goto jleave;
1004    }
1005
1006    nnp = salloc(sizeof *np);
1007    nnp->n_flink = nnp->n_blink = NULL;
1008    nnp->n_type = ntype;
1009    nnp->n_flags = (np->n_flags & ~(NAME_NAME_SALLOC | NAME_FULLNAME_SALLOC)) |
1010          NAME_NAME_SALLOC;
1011    nnp->n_name = savestr(np->n_name);
1012    if (np->n_name == np->n_fullname || !(ntype & (GFULL | GSKIN))) {
1013       nnp->n_fullname = nnp->n_name;
1014       nnp->n_fullextra = NULL;
1015    } else {
1016       nnp->n_flags |= NAME_FULLNAME_SALLOC;
1017       nnp->n_fullname = savestr(np->n_fullname);
1018       nnp->n_fullextra = (np->n_fullextra == NULL) ? NULL
1019             : savestr(np->n_fullextra);
1020    }
1021 jleave:
1022    NYD_LEAVE;
1023    return nnp;
1024 }
1025
1026 FL struct name *
1027 cat(struct name *n1, struct name *n2)
1028 {
1029    struct name *tail;
1030    NYD_ENTER;
1031
1032    tail = n2;
1033    if (n1 == NULL)
1034       goto jleave;
1035    tail = n1;
1036    if (n2 == NULL)
1037       goto jleave;
1038
1039    while (tail->n_flink != NULL)
1040       tail = tail->n_flink;
1041    tail->n_flink = n2;
1042    n2->n_blink = tail;
1043    tail = n1;
1044 jleave:
1045    NYD_LEAVE;
1046    return tail;
1047 }
1048
1049 FL struct name *
1050 namelist_dup(struct name const *np, enum gfield ntype)
1051 {
1052    struct name *nnp;
1053    NYD_ENTER;
1054
1055    for (nnp = NULL; np != NULL; np = np->n_flink) {
1056       struct name *x = ndup(UNCONST(np), (np->n_type & ~GMASK) | ntype);
1057       x->n_flink = nnp;
1058       nnp = x;
1059    }
1060    NYD_LEAVE;
1061    return nnp;
1062 }
1063
1064 FL ui32_t
1065 count(struct name const *np)
1066 {
1067    ui32_t c;
1068    NYD_ENTER;
1069
1070    for (c = 0; np != NULL; np = np->n_flink)
1071       if (!(np->n_type & GDEL))
1072          ++c;
1073    NYD_LEAVE;
1074    return c;
1075 }
1076
1077 FL ui32_t
1078 count_nonlocal(struct name const *np)
1079 {
1080    ui32_t c;
1081    NYD_ENTER;
1082
1083    for (c = 0; np != NULL; np = np->n_flink)
1084       if (!(np->n_type & GDEL) && !(np->n_flags & NAME_ADDRSPEC_ISFILEORPIPE))
1085          ++c;
1086    NYD_LEAVE;
1087    return c;
1088 }
1089
1090 FL struct name *
1091 extract(char const *line, enum gfield ntype)
1092 {
1093    struct name *rv;
1094    NYD_ENTER;
1095
1096    rv = _extract1(line, ntype, " \t,", 0);
1097    NYD_LEAVE;
1098    return rv;
1099 }
1100
1101 FL struct name *
1102 lextract(char const *line, enum gfield ntype)
1103 {
1104    struct name *rv;
1105    NYD_ENTER;
1106
1107    rv = ((line != NULL && strpbrk(line, ",\"\\(<|"))
1108          ? _extract1(line, ntype, ",", 1) : extract(line, ntype));
1109    NYD_LEAVE;
1110    return rv;
1111 }
1112
1113 FL char *
1114 detract(struct name *np, enum gfield ntype)
1115 {
1116    char *topp, *cp;
1117    struct name *p;
1118    int flags, s;
1119    NYD_ENTER;
1120
1121    topp = NULL;
1122    if (np == NULL)
1123       goto jleave;
1124
1125    flags = ntype & (GCOMMA | GNAMEONLY);
1126    ntype &= ~(GCOMMA | GNAMEONLY);
1127    s = 0;
1128
1129    for (p = np; p != NULL; p = p->n_flink) {
1130       if (ntype && (p->n_type & GMASK) != ntype)
1131          continue;
1132       s += strlen(flags & GNAMEONLY ? p->n_name : p->n_fullname) +1;
1133       if (flags & GCOMMA)
1134          ++s;
1135    }
1136    if (s == 0)
1137       goto jleave;
1138
1139    s += 2;
1140    topp = salloc(s);
1141    cp = topp;
1142    for (p = np; p != NULL; p = p->n_flink) {
1143       if (ntype && (p->n_type & GMASK) != ntype)
1144          continue;
1145       cp = sstpcpy(cp, (flags & GNAMEONLY ? p->n_name : p->n_fullname));
1146       if ((flags & GCOMMA) && p->n_flink != NULL)
1147          *cp++ = ',';
1148       *cp++ = ' ';
1149    }
1150    *--cp = 0;
1151    if ((flags & GCOMMA) && *--cp == ',')
1152       *cp = 0;
1153 jleave:
1154    NYD_LEAVE;
1155    return topp;
1156 }
1157
1158 FL struct name *
1159 grab_names(char const *field, struct name *np, int comma, enum gfield gflags)
1160 {
1161    struct name *nq;
1162    NYD_ENTER;
1163
1164 jloop:
1165    np = lextract(n_lex_input_cp_addhist(field, detract(np, comma), TRU1),
1166          gflags);
1167    for (nq = np; nq != NULL; nq = nq->n_flink)
1168       if (is_addr_invalid(nq, EACM_NONE))
1169          goto jloop;
1170    NYD_LEAVE;
1171    return np;
1172 }
1173
1174 FL bool_t
1175 name_is_same_domain(struct name const *n1, struct name const *n2)
1176 {
1177    char const *d1, *d2;
1178    bool_t rv;
1179    NYD_ENTER;
1180
1181    d1 = strrchr(n1->n_name, '@');
1182    d2 = strrchr(n2->n_name, '@');
1183
1184    rv = (d1 != NULL && d2 != NULL) ? !asccasecmp(++d1, ++d2) : FAL0;
1185
1186    NYD_LEAVE;
1187    return rv;
1188 }
1189
1190 FL struct name *
1191 checkaddrs(struct name *np, enum expand_addr_check_mode eacm,
1192    si8_t *set_on_error)
1193 {
1194    struct name *n;
1195    NYD_ENTER;
1196
1197    for (n = np; n != NULL;) {
1198       si8_t rv;
1199
1200       if ((rv = is_addr_invalid(n, eacm)) != 0) {
1201          if (set_on_error != NULL)
1202             *set_on_error |= rv; /* don't loose -1! */
1203          if (n->n_blink)
1204             n->n_blink->n_flink = n->n_flink;
1205          if (n->n_flink)
1206             n->n_flink->n_blink = n->n_blink;
1207          if (n == np)
1208             np = n->n_flink;
1209       }
1210       n = n->n_flink;
1211    }
1212    NYD_LEAVE;
1213    return np;
1214 }
1215
1216 FL struct name *
1217 namelist_vaporise_head(struct header *hp, enum expand_addr_check_mode eacm,
1218    bool_t metoo, si8_t *set_on_error)
1219 {
1220    struct name *tolist, *np, **npp;
1221    NYD_ENTER;
1222
1223    tolist = usermap(cat(hp->h_to, cat(hp->h_cc, hp->h_bcc)), metoo);
1224    hp->h_to = hp->h_cc = hp->h_bcc = NULL;
1225
1226    tolist = elide(checkaddrs(tolist, eacm, set_on_error));
1227
1228    for (np = tolist; np != NULL; np = np->n_flink) {
1229       switch (np->n_type & (GDEL | GMASK)) {
1230       case GTO:   npp = &hp->h_to; break;
1231       case GCC:   npp = &hp->h_cc; break;
1232       case GBCC:  npp = &hp->h_bcc; break;
1233       default:    continue;
1234       }
1235       *npp = cat(*npp, ndup(np, np->n_type | GFULL));
1236    }
1237    NYD_LEAVE;
1238    return tolist;
1239 }
1240
1241 FL struct name *
1242 usermap(struct name *names, bool_t force_metoo)
1243 {
1244    struct name *new, *np, *cp;
1245    struct group *gp;
1246    int metoo;
1247    NYD_ENTER;
1248
1249    new = NULL;
1250    np = names;
1251    metoo = (force_metoo || ok_blook(metoo));
1252    while (np != NULL) {
1253       assert(!(np->n_type & GDEL)); /* TODO legacy */
1254       if (is_fileorpipe_addr(np) || np->n_name[0] == '\\') {
1255          cp = np->n_flink;
1256          new = put(new, np);
1257          np = cp;
1258          continue;
1259       }
1260       gp = _group_find(GT_ALIAS, np->n_name);
1261       cp = np->n_flink;
1262       if (gp != NULL)
1263          new = _gexpand(0, new, gp, metoo, np->n_type);
1264       else
1265          new = put(new, np);
1266       np = cp;
1267    }
1268    NYD_LEAVE;
1269    return new;
1270 }
1271
1272 FL struct name *
1273 elide(struct name *names)
1274 {
1275    struct name *np, *t, *newn, *x;
1276    NYD_ENTER;
1277
1278    newn = NULL;
1279    if (names == NULL)
1280       goto jleave;
1281
1282    /* Throw away all deleted nodes (XXX merge with plain sort below?) */
1283    for (np = NULL; names != NULL; names = names->n_flink)
1284       if  (!(names->n_type & GDEL)) {
1285          names->n_blink = np;
1286          if (np)
1287             np->n_flink = names;
1288          else
1289             newn = names;
1290          np = names;
1291       }
1292    if (newn == NULL)
1293       goto jleave;
1294
1295    np = newn->n_flink;
1296    if (np != NULL)
1297       np->n_blink = NULL;
1298    newn->n_flink = NULL;
1299
1300    while (np != NULL) {
1301       int cmpres;
1302
1303       t = newn;
1304       while ((cmpres = asccasecmp(t->n_name, np->n_name)) < 0) {
1305          if (t->n_flink == NULL)
1306             break;
1307          t = t->n_flink;
1308       }
1309
1310       /* If we ran out of t's, put new entry after the current value of t */
1311       if (cmpres < 0) {
1312          t->n_flink = np;
1313          np->n_blink = t;
1314          t = np;
1315          np = np->n_flink;
1316          t->n_flink = NULL;
1317          continue;
1318       }
1319
1320       /* Otherwise, put the new entry in front of the current t.  If at the
1321        * front of the list, the new guy becomes the new head of the list */
1322       if (t == newn) {
1323          t = np;
1324          np = np->n_flink;
1325          t->n_flink = newn;
1326          newn->n_blink = t;
1327          t->n_blink = NULL;
1328          newn = t;
1329          continue;
1330       }
1331
1332       /* The normal case -- we are inserting into the middle of the list */
1333       x = np;
1334       np = np->n_flink;
1335       x->n_flink = t;
1336       x->n_blink = t->n_blink;
1337       t->n_blink->n_flink = x;
1338       t->n_blink = x;
1339    }
1340
1341    /* Now the list headed up by new is sorted.  Remove duplicates */
1342    np = newn;
1343    while (np != NULL) {
1344       t = np;
1345       while (t->n_flink != NULL && !asccasecmp(np->n_name, t->n_flink->n_name))
1346          t = t->n_flink;
1347       if (t == np) {
1348          np = np->n_flink;
1349          continue;
1350       }
1351
1352       /* Now t points to the last entry with the same name as np.
1353        * Make np point beyond t */
1354       np->n_flink = t->n_flink;
1355       if (t->n_flink != NULL)
1356          t->n_flink->n_blink = np;
1357       np = np->n_flink;
1358    }
1359 jleave:
1360    NYD_LEAVE;
1361    return newn;
1362 }
1363
1364 FL int
1365 c_alternates(void *v)
1366 {
1367    size_t l;
1368    char **namelist = v, **ap, **ap2, *cp;
1369    NYD_ENTER;
1370
1371    l = argcount(namelist) +1;
1372
1373    if (l == 1) {
1374       if (_altnames != NULL) {
1375          printf("alternates ");
1376          for (ap = _altnames; *ap != NULL; ++ap)
1377             printf("%s ", *ap);
1378          printf("\n");
1379       }
1380       goto jleave;
1381    }
1382
1383    if (_altnames != NULL) {
1384       for (ap = _altnames; *ap != NULL; ++ap)
1385          free(*ap);
1386       free(_altnames);
1387    }
1388
1389    _altnames = smalloc(l * sizeof(*_altnames));
1390    for (ap = namelist, ap2 = _altnames; *ap != NULL; ++ap, ++ap2) {
1391       l = strlen(*ap) +1;
1392       cp = smalloc(l);
1393       memcpy(cp, *ap, l);
1394       *ap2 = cp;
1395    }
1396    *ap2 = NULL;
1397 jleave:
1398    NYD_LEAVE;
1399    return 0;
1400 }
1401
1402 FL struct name *
1403 delete_alternates(struct name *np)
1404 {
1405    struct name *xp;
1406    char **ap;
1407    NYD_ENTER;
1408
1409    np = delname(np, myname);
1410    if (_altnames != NULL)
1411       for (ap = _altnames; *ap != '\0'; ++ap)
1412          np = delname(np, *ap);
1413
1414    if ((xp = lextract(ok_vlook(from), GEXTRA | GSKIN)) != NULL)
1415       while (xp != NULL) {
1416          np = delname(np, xp->n_name);
1417          xp = xp->n_flink;
1418       }
1419
1420    if ((xp = lextract(ok_vlook(replyto), GEXTRA | GSKIN)) != NULL)
1421       while (xp != NULL) {
1422          np = delname(np, xp->n_name);
1423          xp = xp->n_flink;
1424       }
1425
1426    if ((xp = extract(ok_vlook(sender), GEXTRA | GSKIN)) != NULL)
1427       while (xp != NULL) {
1428          np = delname(np, xp->n_name);
1429          xp = xp->n_flink;
1430       }
1431    NYD_LEAVE;
1432    return np;
1433 }
1434
1435 FL int
1436 is_myname(char const *name)
1437 {
1438    int rv = 1;
1439    struct name *xp;
1440    char **ap;
1441    NYD_ENTER;
1442
1443    if (_same_name(myname, name))
1444       goto jleave;
1445    if (_altnames != NULL)
1446       for (ap = _altnames; *ap != NULL; ++ap)
1447          if (_same_name(*ap, name))
1448             goto jleave;
1449
1450    if ((xp = lextract(ok_vlook(from), GEXTRA | GSKIN)) != NULL)
1451       while (xp != NULL) {
1452          if (_same_name(xp->n_name, name))
1453             goto jleave;
1454          xp = xp->n_flink;
1455       }
1456
1457    if ((xp = lextract(ok_vlook(replyto), GEXTRA | GSKIN)) != NULL)
1458       while (xp != NULL) {
1459          if (_same_name(xp->n_name, name))
1460             goto jleave;
1461          xp = xp->n_flink;
1462       }
1463
1464    if ((xp = extract(ok_vlook(sender), GEXTRA | GSKIN)) != NULL)
1465       while (xp != NULL) {
1466          if (_same_name(xp->n_name, name))
1467             goto jleave;
1468          xp = xp->n_flink;
1469       }
1470    rv = 0;
1471 jleave:
1472    NYD_LEAVE;
1473    return rv;
1474 }
1475
1476 FL int
1477 c_alias(void *v)
1478 {
1479    char **argv = v;
1480    struct group *gp;
1481    int rv = 0;
1482    NYD_ENTER;
1483
1484    if (*argv == NULL)
1485       _group_print_all(GT_ALIAS);
1486    else if (argv[1] == NULL) {
1487       if ((gp = _group_find(GT_ALIAS, *argv)) != NULL)
1488          _group_print(gp, stdout);
1489       else {
1490          n_err(_("No such alias: \"%s\"\n"), *argv);
1491          rv = 1;
1492       }
1493    } else {
1494       struct grp_names_head *gnhp;
1495
1496       gp = _group_fetch(GT_ALIAS, *argv, 0);
1497       GP_TO_SUBCLASS(gnhp, gp);
1498
1499       for (++argv; *argv != NULL; ++argv) {
1500          size_t l = strlen(*argv) +1;
1501          struct grp_names *gnp = smalloc(sizeof(*gnp) -
1502                VFIELD_SIZEOF(struct grp_names, gn_id) + l);
1503          gnp->gn_next = gnhp->gnh_head;
1504          gnhp->gnh_head = gnp;
1505          memcpy(gnp->gn_id, *argv, l);
1506       }
1507       assert(gnhp->gnh_head != NULL);
1508    }
1509    NYD_LEAVE;
1510    return rv;
1511 }
1512
1513 FL int
1514 c_unalias(void *v)
1515 {
1516    char **argv = v;
1517    int rv = 0;
1518    NYD_ENTER;
1519
1520    do if (!_group_del(GT_ALIAS, *argv)) {
1521       n_err(_("No such alias: \"%s\"\n"), *argv);
1522       rv = 1;
1523    } while (*++argv != NULL);
1524    NYD_LEAVE;
1525    return rv;
1526 }
1527
1528 FL int
1529 c_mlist(void *v)
1530 {
1531    int rv;
1532    NYD_ENTER;
1533
1534    rv = _mlmux(GT_MLIST, v);
1535    NYD_LEAVE;
1536    return rv;
1537 }
1538
1539 FL int
1540 c_unmlist(void *v)
1541 {
1542    int rv;
1543    NYD_ENTER;
1544
1545    rv = _unmlmux(GT_MLIST, v);
1546    NYD_LEAVE;
1547    return rv;
1548 }
1549
1550 FL int
1551 c_mlsubscribe(void *v)
1552 {
1553    int rv;
1554    NYD_ENTER;
1555
1556    rv = _mlmux(GT_MLIST | GT_SUBSCRIBE, v);
1557    NYD_LEAVE;
1558    return rv;
1559 }
1560
1561 FL int
1562 c_unmlsubscribe(void *v)
1563 {
1564    int rv;
1565    NYD_ENTER;
1566
1567    rv = _unmlmux(GT_MLIST | GT_SUBSCRIBE, v);
1568    NYD_LEAVE;
1569    return rv;
1570 }
1571
1572 FL enum mlist_state
1573 is_mlist(char const *name, bool_t subscribed_only)
1574 {
1575    struct group *gp;
1576 #ifdef HAVE_REGEX
1577    struct grp_regex **lpp, *grp;
1578    bool_t re2;
1579 #endif
1580    enum mlist_state rv;
1581    NYD_ENTER;
1582
1583    gp = _group_find(GT_MLIST, name);
1584    rv = (gp != NULL) ? MLIST_KNOWN : MLIST_OTHER;
1585    if (rv == MLIST_KNOWN) {
1586       if (gp->g_type & GT_SUBSCRIBE)
1587          rv = MLIST_SUBSCRIBED;
1588       else if (subscribed_only)
1589          rv = MLIST_OTHER;
1590       /* Of course, if that is a regular expression it doesn't mean a thing */
1591 #ifdef HAVE_REGEX
1592       if (gp->g_type & GT_REGEX)
1593          rv = MLIST_OTHER;
1594       else
1595 #endif
1596          goto jleave;
1597    }
1598
1599    /* Not in the hashmap (as something matchable), walk the lists */
1600 #ifdef HAVE_REGEX
1601    re2 = FAL0;
1602    lpp = &_mlsub_regex;
1603 jregex_redo:
1604    if ((grp = *lpp) != NULL) {
1605       do if (regexec(&grp->gr_regex, name, 0,NULL, 0) != REG_NOMATCH) {
1606          /* Relink as the head of this list if the hit count of this group is
1607           * >= 25% of the average hit count */
1608          size_t i;
1609          if (!re2)
1610             i = ++_mlsub_hits / _mlsub_size;
1611          else
1612             i = ++_mlist_hits / _mlist_size;
1613          i >>= 2;
1614
1615          if (++grp->gr_hits >= i && *lpp != grp && grp->gr_next != grp) {
1616             grp->gr_last->gr_next = grp->gr_next;
1617             grp->gr_next->gr_last = grp->gr_last;
1618             (grp->gr_last = (*lpp)->gr_last)->gr_next = grp;
1619             (grp->gr_next = *lpp)->gr_last = grp;
1620             *lpp = grp;
1621          }
1622          rv = !re2 ? MLIST_SUBSCRIBED : MLIST_KNOWN;
1623          goto jleave;
1624       } while ((grp = grp->gr_next) != *lpp);
1625    }
1626    if (!re2 && !subscribed_only) {
1627       re2 = TRU1;
1628       lpp = &_mlist_regex;
1629       goto jregex_redo;
1630    }
1631    assert(rv == MLIST_OTHER);
1632 #endif
1633
1634 jleave:
1635    NYD_LEAVE;
1636    return rv;
1637 }
1638
1639 FL int
1640 c_shortcut(void *v)
1641 {
1642    char **argv = v;
1643    int rv = 0;
1644    NYD_ENTER;
1645
1646    if (*argv == NULL)
1647       _group_print_all(GT_SHORTCUT);
1648    else for (; *argv != NULL; argv += 2) {
1649       /* Because one hardly ever redefines, anything is stored in one chunk */
1650       size_t l;
1651       struct group *gp;
1652       char *cp;
1653
1654       if (argv[1] == NULL) {
1655          n_err(_("Shortcut expansion is missing: \"%s\"\n"), *argv);
1656          rv = 1;
1657          break;
1658       }
1659       if (_group_find(GT_SHORTCUT, *argv) != NULL)
1660          _group_del(GT_SHORTCUT, *argv);
1661
1662       l = strlen(argv[1]) +1;
1663       gp = _group_fetch(GT_SHORTCUT, *argv, l);
1664       GP_TO_SUBCLASS(cp, gp);
1665       memcpy(cp, argv[1], l);
1666    }
1667    NYD_LEAVE;
1668    return rv;
1669 }
1670
1671 FL int
1672 c_unshortcut(void *v)
1673 {
1674    char **argv = v;
1675    int rv = 0;
1676    NYD_ENTER;
1677
1678    do if (!_group_del(GT_SHORTCUT, *argv)) {
1679       n_err(_("No such shortcut: \"%s\"\n"), *argv);
1680       rv = 1;
1681    } while (*++argv != NULL);
1682    NYD_LEAVE;
1683    return rv;
1684 }
1685
1686 FL char const *
1687 shortcut_expand(char const *str)
1688 {
1689    struct group *gp;
1690    NYD_ENTER;
1691
1692    if ((gp = _group_find(GT_SHORTCUT, str)) != NULL)
1693       GP_TO_SUBCLASS(str, gp);
1694    else
1695       str = NULL;
1696    NYD_LEAVE;
1697    return str;
1698 }
1699
1700 FL int
1701 c_customhdr(void *v){
1702    struct group *gp;
1703    char const **argv, *hcp;
1704    int rv;
1705    NYD_ENTER;
1706
1707    rv = 0;
1708
1709    if((hcp = *(argv = v)) == NULL){
1710       _group_print_all(GT_CUSTOMHDR);
1711       goto jleave;
1712    }
1713
1714    /* Verify the header field name */
1715    for(rv = 1;; ++hcp){
1716       if(fieldnamechar(*hcp))
1717          continue;
1718       if(*hcp == '\0'){
1719          if(hcp == *argv){
1720             n_err(_("Cannot use nameless custom header\n"));
1721             goto jleave;
1722          }
1723          hcp = *argv;
1724          break;
1725       }
1726       n_err(_("Invalid custom header name: \"%s\"\n"), *argv);
1727       goto jleave;
1728    }
1729    rv = 0;
1730
1731    if(*++argv == NULL){
1732       if((gp = _group_find(GT_CUSTOMHDR, hcp)) != NULL)
1733          _group_print(gp, stdout);
1734       else{
1735          n_err(_("No such custom header: \"%s\"\n"), hcp);
1736          rv = 1;
1737       }
1738    }else{
1739       /* Because one hardly ever redefines, anything is stored in one chunk */
1740       size_t i, l;
1741       char *cp;
1742
1743       if(_group_find(GT_CUSTOMHDR, hcp) != NULL)
1744          _group_del(GT_CUSTOMHDR, hcp);
1745
1746       for(l = i = 0; argv[i] != NULL; ++i)
1747          l += strlen(argv[i]) + 1;
1748       gp = _group_fetch(GT_CUSTOMHDR, hcp, l +1);
1749       GP_TO_SUBCLASS(cp, gp);
1750       for(i = 0; argv[i] != NULL; ++i){
1751          if(i > 0)
1752             *cp++ = ' ';
1753          l = strlen(argv[i]);
1754          memcpy(cp, argv[i], l);
1755          cp += l;
1756       }
1757       *cp = '\0';
1758    }
1759 jleave:
1760    NYD_LEAVE;
1761    return rv;
1762 }
1763
1764 FL int
1765 c_uncustomhdr(void *v){
1766    int rv;
1767    char **argv;
1768    NYD_ENTER;
1769
1770    rv = 0;
1771
1772    argv = v;
1773    do{
1774       if(!_group_del(GT_CUSTOMHDR, *argv)){
1775          n_err(_("No such custom header: \"%s\"\n"), *argv);
1776          rv = 1;
1777       }
1778    }while(*++argv != NULL);
1779    NYD_LEAVE;
1780    return rv;
1781 }
1782
1783 FL struct n_header_field *
1784 n_customhdr_query(void){ /* XXX Uses salloc()! */
1785    struct group const *gp;
1786    ui32_t h;
1787    struct n_header_field *rv, **tail, *hfp;
1788    NYD_ENTER;
1789
1790    rv = NULL;
1791    tail = &rv;
1792
1793    for(h = 0; h < HSHSIZE; ++h)
1794       for(gp = _customhdr_heads[h]; gp != NULL; gp = gp->g_next){
1795          char const *cp;
1796          ui32_t nl, bl;
1797
1798          GP_TO_SUBCLASS(cp, gp);
1799          nl = (ui32_t)strlen(gp->g_id) +1;
1800          bl = (ui32_t)strlen(cp) +1;
1801
1802          *tail = hfp = salloc(VSTRUCT_SIZEOF(struct n_header_field, hf_dat) +
1803                nl + bl);
1804             tail = &hfp->hf_next;
1805          hfp->hf_next = NULL;
1806          hfp->hf_nl = nl - 1;
1807          hfp->hf_bl = bl - 1;
1808          memcpy(hfp->hf_dat, gp->g_id, nl);
1809             memcpy(hfp->hf_dat + nl, cp, bl);
1810       }
1811
1812    /* TODO We have no copy-on-write environments yet, and since custom headers
1813     * TODO are a perfect subject for localization, add the OBSOLETE variable
1814     * TODO *customhdr*, too */
1815    {
1816       char const *vp = ok_vlook(customhdr);
1817
1818       if(vp != NULL){
1819          char *buf = savestr(vp);
1820 jch_outer:
1821          while((vp = n_strescsep(&buf, ',', TRU1)) != NULL){
1822             ui32_t nl, bl;
1823             char const *nstart, *cp;
1824
1825             for(nstart = cp = vp;; ++cp){
1826                if(fieldnamechar(*cp))
1827                   continue;
1828                if(*cp == '\0'){
1829                   if(cp == nstart){
1830                      n_err(_("Invalid nameless *customhdr* entry\n"));
1831                      goto jch_outer;
1832                   }
1833                }else if(*cp != ':' && !blankchar(*cp)){
1834 jch_badent:
1835                   n_err(_("Invalid *customhdr* entry: \"%s\"\n"), vp);
1836                   goto jch_outer;
1837                }
1838                break;
1839             }
1840             nl = (ui32_t)PTR2SIZE(cp - nstart);
1841
1842             while(blankchar(*cp))
1843                ++cp;
1844             if(*cp++ != ':')
1845                goto jch_badent;
1846             while(blankchar(*cp))
1847                ++cp;
1848             bl = (ui32_t)strlen(cp) +1;
1849
1850             *tail = hfp = salloc(VSTRUCT_SIZEOF(struct n_header_field, hf_dat) +
1851                   nl +1 + bl);
1852                tail = &hfp->hf_next;
1853             hfp->hf_next = NULL;
1854             hfp->hf_nl = nl;
1855             hfp->hf_bl = bl - 1;
1856             memcpy(hfp->hf_dat, nstart, nl);
1857                hfp->hf_dat[nl++] = '\0';
1858                memcpy(hfp->hf_dat + nl, cp, bl);
1859          }
1860       }
1861    }
1862    NYD_LEAVE;
1863    return rv;
1864 }
1865
1866 /* s-it-mode */