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 */
 183 static void          _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; ++lines, ++i)
 672       _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 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 void
 705 _group_print(struct group const *gp, FILE *fo)
 706 {
 707    char const *sep;
 708    NYD_ENTER;
 709
 710    if (gp->g_type & GT_ALIAS) {
 711       struct grp_names_head *gnhp;
 712       struct grp_names *gnp;
 713
 714       fprintf(fo, "alias %s", gp->g_id);
 715
 716       GP_TO_SUBCLASS(gnhp, gp);
 717       if ((gnp = gnhp->gnh_head) != NULL) { /* xxx always 1+ entries */
 718          do {
 719             struct grp_names *x = gnp;
 720             gnp = gnp->gn_next;
 721             fprintf(fo, " \"%s\"", string_quote(x->gn_id));
 722          } while (gnp != NULL);
 723       }
 724    } else if (gp->g_type & GT_MLIST) {
 725       fprintf(fo, "%-42s", gp->g_id);
 726
 727       sep = " [";
 728       if (gp->g_type & GT_SUBSCRIBE) {
 729          fprintf(fo, "%ssub", sep);
 730          sep = NULL;
 731       }
 732 #ifdef HAVE_REGEX
 733       if (gp->g_type & GT_REGEX) {
 734          size_t i;
 735          struct grp_regex *grp,
 736             *lp = (gp->g_type & GT_SUBSCRIBE ? _mlsub_regex : _mlist_regex);
 737
 738          GP_TO_SUBCLASS(grp, gp);
 739          for (i = 1; lp != grp; lp = lp->gr_next)
 740             ++i;
 741
 742          fprintf(fo, "%srx: %" PRIuZ "/%" PRIuZ ". hits/sort",
 743             (sep != NULL ? sep : ", "), grp->gr_hits, i);
 744          sep = NULL;
 745       }
 746 #endif
 747       if (sep == NULL)
 748          putc(']', fo);
 749    } else if (gp->g_type & GT_SHORTCUT) {
 750       char const *cp;
 751       GP_TO_SUBCLASS(cp, gp);
 752       fprintf(fo, "shortcut %s \"%s\"", gp->g_id, string_quote(cp));
 753    } else if (gp->g_type & GT_CUSTOMHDR) {
 754       char const *cp;
 755       GP_TO_SUBCLASS(cp, gp);
 756       fprintf(fo, "customhdr %s \"%s\"", gp->g_id, string_quote(cp));
 757    }
 758
 759    putc('\n', fo);
 760    NYD_LEAVE;
 761 }
 762
 763 static int
 764 _mlmux(enum group_type gt, char **argv)
 765 {
 766    struct group *gp;
 767    int rv = 0;
 768    NYD_ENTER;
 769
 770    if (*argv == NULL)
 771       _group_print_all(gt);
 772    else do {
 773       if ((gp = _group_find(gt, *argv)) != NULL) {
 774          if (gt & GT_SUBSCRIBE) {
 775             if (!(gp->g_type & GT_SUBSCRIBE)) {
 776                _MLMUX_LINKOUT(gp);
 777                gp->g_type |= GT_SUBSCRIBE;
 778                _MLMUX_LINKIN(gp);
 779             } else {
 780                n_err(_("Mailing-list already `mlsubscribe'd: %s\n"),
 781                   *argv);
 782                rv = 1;
 783             }
 784          } else {
 785             n_err(_("Mailing-list already `mlist'ed: %s\n"), *argv);
 786             rv = 1;
 787          }
 788       } else
 789          _group_fetch(gt, *argv, 0);
 790    } while (*++argv != NULL);
 791
 792    NYD_LEAVE;
 793    return rv;
 794 }
 795
 796 static int
 797 _unmlmux(enum group_type gt, char **argv)
 798 {
 799    struct group *gp;
 800    int rv = 0;
 801    NYD_ENTER;
 802
 803    for (; *argv != NULL; ++argv) {
 804       if (gt & GT_SUBSCRIBE) {
 805          struct group_lookup gl;
 806          bool_t isaster;
 807
 808          if (!(isaster = (**argv == '*')))
 809             gp = _group_find(gt, *argv);
 810          else if ((gp = _group_go_first(gt, &gl)) == NULL)
 811             continue;
 812          else if (gp != NULL && !(gp->g_type & GT_SUBSCRIBE))
 813             goto jaster_entry;
 814
 815          if (gp != NULL) {
 816 jaster_redo:
 817             if (gp->g_type & GT_SUBSCRIBE) {
 818                _MLMUX_LINKOUT(gp);
 819                gp->g_type &= ~GT_SUBSCRIBE;
 820                _MLMUX_LINKIN(gp);
 821                if (isaster) {
 822 jaster_entry:
 823                   while ((gp = _group_go_next(&gl)) != NULL &&
 824                         !(gp->g_type & GT_SUBSCRIBE))
 825                      ;
 826                   if (gp != NULL)
 827                      goto jaster_redo;
 828                }
 829             } else {
 830                n_err(_("Mailing-list not `mlsubscribe'd: \"%s\"\n"), *argv);
 831                rv = 1;
 832             }
 833             continue;
 834          }
 835       } else if (_group_del(gt, *argv))
 836          continue;
 837       n_err(_("No such mailing-list: \"%s\"\n"), *argv);
 838       rv = 1;
 839    }
 840    NYD_LEAVE;
 841    return rv;
 842 }
 843
 844 #ifdef HAVE_REGEX
 845 static void
 846 _mlmux_linkin(struct group *gp)
 847 {
 848    struct grp_regex **lpp, *grp, *lhp;
 849    NYD_ENTER;
 850
 851    if (gp->g_type & GT_SUBSCRIBE) {
 852       lpp = &_mlsub_regex;
 853       ++_mlsub_size;
 854    } else {
 855       lpp = &_mlist_regex;
 856       ++_mlist_size;
 857    }
 858
 859    GP_TO_SUBCLASS(grp, gp);
 860    if ((lhp = *lpp) != NULL) {
 861       (grp->gr_last = lhp->gr_last)->gr_next = grp;
 862       (grp->gr_next = lhp)->gr_last = grp;
 863    } else
 864       *lpp = grp->gr_last = grp->gr_next = grp;
 865    grp->gr_hits = 0;
 866    NYD_LEAVE;
 867 }
 868
 869 static void
 870 _mlmux_linkout(struct group *gp)
 871 {
 872    struct grp_regex *grp, **lpp;
 873    NYD_ENTER;
 874
 875    GP_TO_SUBCLASS(grp, gp);
 876
 877    if (gp->g_type & GT_SUBSCRIBE) {
 878       lpp = &_mlsub_regex;
 879       --_mlsub_size;
 880       _mlsub_hits -= grp->gr_hits;
 881    } else {
 882       lpp = &_mlist_regex;
 883       --_mlist_size;
 884       _mlist_hits -= grp->gr_hits;
 885    }
 886
 887    if (grp->gr_next == grp)
 888       *lpp = NULL;
 889    else {
 890       (grp->gr_last->gr_next = grp->gr_next)->gr_last = grp->gr_last;
 891       if (*lpp == grp)
 892          *lpp = grp->gr_next;
 893    }
 894    NYD_LEAVE;
 895 }
 896 #endif /* HAVE_REGEX */
 897
 898 FL struct name *
 899 nalloc(char *str, enum gfield ntype)
 900 {
 901    struct addrguts ag;
 902    struct str in, out;
 903    struct name *np;
 904    NYD_ENTER;
 905    assert(!(ntype & GFULLEXTRA) || (ntype & GFULL) != 0);
 906
 907    addrspec_with_guts(((ntype & (GFULL | GSKIN | GREF)) != 0), str, &ag);
 908    if (!(ag.ag_n_flags & NAME_NAME_SALLOC)) {
 909       ag.ag_n_flags |= NAME_NAME_SALLOC;
 910       np = salloc(sizeof(*np) + ag.ag_slen +1);
 911       memcpy(np + 1, ag.ag_skinned, ag.ag_slen +1);
 912       ag.ag_skinned = (char*)(np + 1);
 913    } else
 914       np = salloc(sizeof *np);
 915
 916    np->n_flink = NULL;
 917    np->n_blink = NULL;
 918    np->n_type = ntype;
 919    np->n_flags = 0;
 920
 921    np->n_fullname = np->n_name = ag.ag_skinned;
 922    np->n_fullextra = NULL;
 923    np->n_flags = ag.ag_n_flags;
 924
 925    if (ntype & GFULL) {
 926       if (ag.ag_ilen == ag.ag_slen
 927 #ifdef HAVE_IDNA
 928             && !(ag.ag_n_flags & NAME_IDNA)
 929 #endif
 930       )
 931          goto jleave;
 932       if (ag.ag_n_flags & NAME_ADDRSPEC_ISFILEORPIPE)
 933          goto jleave;
 934
 935       /* n_fullextra is only the complete name part without address.
 936        * Beware of "-r '<abc@def>'", don't treat that as FULLEXTRA */
 937       if ((ntype & GFULLEXTRA) && ag.ag_ilen > ag.ag_slen + 2) {
 938          size_t s = ag.ag_iaddr_start, e = ag.ag_iaddr_aend, i;
 939          char const *cp;
 940
 941          if (s == 0 || str[--s] != '<' || str[e++] != '>')
 942             goto jskipfullextra;
 943          i = ag.ag_ilen - e;
 944          in.s = ac_alloc(s + i +1);
 945          memcpy(in.s, str, s);
 946          if (i > 0)
 947             memcpy(in.s + s, str + e, i);
 948          s += i;
 949          in.s[in.l = s] = '\0';
 950          mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
 951
 952          for (cp = out.s, i = out.l; i > 0 && spacechar(*cp); --i, ++cp)
 953             ;
 954          while (i > 0 && spacechar(cp[i - 1]))
 955             --i;
 956          np->n_fullextra = savestrbuf(cp, i);
 957
 958          free(out.s);
 959          ac_free(in.s);
 960       }
 961 jskipfullextra:
 962
 963       /* n_fullname depends on IDNA conversion */
 964 #ifdef HAVE_IDNA
 965       if (!(ag.ag_n_flags & NAME_IDNA)) {
 966 #endif
 967          in.s = str;
 968          in.l = ag.ag_ilen;
 969 #ifdef HAVE_IDNA
 970       } else {
 971          /* The domain name was IDNA and has been converted.  We also have to
 972           * ensure that the domain name in .n_fullname is replaced with the
 973           * converted version, since MIME doesn't perform encoding of addrs */
 974          size_t l = ag.ag_iaddr_start,
 975             lsuff = ag.ag_ilen - ag.ag_iaddr_aend;
 976          in.s = ac_alloc(l + ag.ag_slen + lsuff +1);
 977          memcpy(in.s, str, l);
 978          memcpy(in.s + l, ag.ag_skinned, ag.ag_slen);
 979          l += ag.ag_slen;
 980          memcpy(in.s + l, str + ag.ag_iaddr_aend, lsuff);
 981          l += lsuff;
 982          in.s[l] = '\0';
 983          in.l = l;
 984       }
 985 #endif
 986       mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
 987       np->n_fullname = savestr(out.s);
 988       free(out.s);
 989 #ifdef HAVE_IDNA
 990       if (ag.ag_n_flags & NAME_IDNA)
 991          ac_free(in.s);
 992 #endif
 993       np->n_flags |= NAME_FULLNAME_SALLOC;
 994    }
 995 jleave:
 996    NYD_LEAVE;
 997    return np;
 998 }
 999
1000 FL struct name *
1001 ndup(struct name *np, enum gfield ntype)
1002 {
1003    struct name *nnp;
1004    NYD_ENTER;
1005
1006    if ((ntype & (GFULL | GSKIN)) && !(np->n_flags & NAME_SKINNED)) {
1007       nnp = nalloc(np->n_name, ntype);
1008       goto jleave;
1009    }
1010
1011    nnp = salloc(sizeof *np);
1012    nnp->n_flink = nnp->n_blink = NULL;
1013    nnp->n_type = ntype;
1014    nnp->n_flags = (np->n_flags & ~(NAME_NAME_SALLOC | NAME_FULLNAME_SALLOC)) |
1015          NAME_NAME_SALLOC;
1016    nnp->n_name = savestr(np->n_name);
1017    if (np->n_name == np->n_fullname || !(ntype & (GFULL | GSKIN))) {
1018       nnp->n_fullname = nnp->n_name;
1019       nnp->n_fullextra = NULL;
1020    } else {
1021       nnp->n_flags |= NAME_FULLNAME_SALLOC;
1022       nnp->n_fullname = savestr(np->n_fullname);
1023       nnp->n_fullextra = (np->n_fullextra == NULL) ? NULL
1024             : savestr(np->n_fullextra);
1025    }
1026 jleave:
1027    NYD_LEAVE;
1028    return nnp;
1029 }
1030
1031 FL struct name *
1032 cat(struct name *n1, struct name *n2)
1033 {
1034    struct name *tail;
1035    NYD_ENTER;
1036
1037    tail = n2;
1038    if (n1 == NULL)
1039       goto jleave;
1040    tail = n1;
1041    if (n2 == NULL)
1042       goto jleave;
1043
1044    while (tail->n_flink != NULL)
1045       tail = tail->n_flink;
1046    tail->n_flink = n2;
1047    n2->n_blink = tail;
1048    tail = n1;
1049 jleave:
1050    NYD_LEAVE;
1051    return tail;
1052 }
1053
1054 FL struct name *
1055 namelist_dup(struct name const *np, enum gfield ntype)
1056 {
1057    struct name *nnp;
1058    NYD_ENTER;
1059
1060    for (nnp = NULL; np != NULL; np = np->n_flink) {
1061       struct name *x = ndup(UNCONST(np), (np->n_type & ~GMASK) | ntype);
1062       x->n_flink = nnp;
1063       nnp = x;
1064    }
1065    NYD_LEAVE;
1066    return nnp;
1067 }
1068
1069 FL ui32_t
1070 count(struct name const *np)
1071 {
1072    ui32_t c;
1073    NYD_ENTER;
1074
1075    for (c = 0; np != NULL; np = np->n_flink)
1076       if (!(np->n_type & GDEL))
1077          ++c;
1078    NYD_LEAVE;
1079    return c;
1080 }
1081
1082 FL ui32_t
1083 count_nonlocal(struct name const *np)
1084 {
1085    ui32_t c;
1086    NYD_ENTER;
1087
1088    for (c = 0; np != NULL; np = np->n_flink)
1089       if (!(np->n_type & GDEL) && !(np->n_flags & NAME_ADDRSPEC_ISFILEORPIPE))
1090          ++c;
1091    NYD_LEAVE;
1092    return c;
1093 }
1094
1095 FL struct name *
1096 extract(char const *line, enum gfield ntype)
1097 {
1098    struct name *rv;
1099    NYD_ENTER;
1100
1101    rv = _extract1(line, ntype, " \t,", 0);
1102    NYD_LEAVE;
1103    return rv;
1104 }
1105
1106 FL struct name *
1107 lextract(char const *line, enum gfield ntype)
1108 {
1109    struct name *rv;
1110    NYD_ENTER;
1111
1112    rv = ((line != NULL && strpbrk(line, ",\"\\(<|"))
1113          ? _extract1(line, ntype, ",", 1) : extract(line, ntype));
1114    NYD_LEAVE;
1115    return rv;
1116 }
1117
1118 FL char *
1119 detract(struct name *np, enum gfield ntype)
1120 {
1121    char *topp, *cp;
1122    struct name *p;
1123    int comma, s;
1124    NYD_ENTER;
1125
1126    topp = NULL;
1127    if (np == NULL)
1128       goto jleave;
1129
1130    comma = ntype & GCOMMA;
1131    ntype &= ~GCOMMA;
1132    s = 0;
1133    if ((options & OPT_DEBUG) && comma)
1134       n_err(_("detract() asked to insert commas\n"));
1135    for (p = np; p != NULL; p = p->n_flink) {
1136       if (ntype && (p->n_type & GMASK) != ntype)
1137          continue;
1138       s += strlen(p->n_fullname) +1;
1139       if (comma)
1140          s++;
1141    }
1142    if (s == 0)
1143       goto jleave;
1144
1145    s += 2;
1146    topp = salloc(s);
1147    cp = topp;
1148    for (p = np; p != NULL; p = p->n_flink) {
1149       if (ntype && (p->n_type & GMASK) != ntype)
1150          continue;
1151       cp = sstpcpy(cp, p->n_fullname);
1152       if (comma && p->n_flink != NULL)
1153          *cp++ = ',';
1154       *cp++ = ' ';
1155    }
1156    *--cp = 0;
1157    if (comma && *--cp == ',')
1158       *cp = 0;
1159 jleave:
1160    NYD_LEAVE;
1161    return topp;
1162 }
1163
1164 FL struct name *
1165 grab_names(char const *field, struct name *np, int comma, enum gfield gflags)
1166 {
1167    struct name *nq;
1168    NYD_ENTER;
1169
1170 jloop:
1171    np = lextract(n_input_cp_addhist(field, detract(np, comma), TRU1), gflags);
1172    for (nq = np; nq != NULL; nq = nq->n_flink)
1173       if (is_addr_invalid(nq, EACM_NONE))
1174          goto jloop;
1175    NYD_LEAVE;
1176    return np;
1177 }
1178
1179 FL bool_t
1180 name_is_same_domain(struct name const *n1, struct name const *n2)
1181 {
1182    char const *d1, *d2;
1183    bool_t rv;
1184    NYD_ENTER;
1185
1186    d1 = strrchr(n1->n_name, '@');
1187    d2 = strrchr(n2->n_name, '@');
1188
1189    rv = (d1 != NULL && d2 != NULL) ? !asccasecmp(++d1, ++d2) : FAL0;
1190
1191    NYD_LEAVE;
1192    return rv;
1193 }
1194
1195 FL struct name *
1196 checkaddrs(struct name *np, enum expand_addr_check_mode eacm,
1197    si8_t *set_on_error)
1198 {
1199    struct name *n;
1200    NYD_ENTER;
1201
1202    for (n = np; n != NULL;) {
1203       si8_t rv;
1204
1205       if ((rv = is_addr_invalid(n, eacm)) != 0) {
1206          if (set_on_error != NULL)
1207             *set_on_error |= rv; /* don't loose -1! */
1208          if (n->n_blink)
1209             n->n_blink->n_flink = n->n_flink;
1210          if (n->n_flink)
1211             n->n_flink->n_blink = n->n_blink;
1212          if (n == np)
1213             np = n->n_flink;
1214       }
1215       n = n->n_flink;
1216    }
1217    NYD_LEAVE;
1218    return np;
1219 }
1220
1221 FL struct name *
1222 namelist_vaporise_head(struct header *hp, enum expand_addr_check_mode eacm,
1223    bool_t metoo, si8_t *set_on_error)
1224 {
1225    struct name *tolist, *np, **npp;
1226    NYD_ENTER;
1227
1228    tolist = usermap(cat(hp->h_to, cat(hp->h_cc, hp->h_bcc)), metoo);
1229    hp->h_to = hp->h_cc = hp->h_bcc = NULL;
1230
1231    tolist = elide(checkaddrs(tolist, eacm, set_on_error));
1232
1233    for (np = tolist; np != NULL; np = np->n_flink) {
1234       switch (np->n_type & (GDEL | GMASK)) {
1235       case GTO:   npp = &hp->h_to; break;
1236       case GCC:   npp = &hp->h_cc; break;
1237       case GBCC:  npp = &hp->h_bcc; break;
1238       default:    continue;
1239       }
1240       *npp = cat(*npp, ndup(np, np->n_type | GFULL));
1241    }
1242    NYD_LEAVE;
1243    return tolist;
1244 }
1245
1246 FL struct name *
1247 usermap(struct name *names, bool_t force_metoo)
1248 {
1249    struct name *new, *np, *cp;
1250    struct group *gp;
1251    int metoo;
1252    NYD_ENTER;
1253
1254    new = NULL;
1255    np = names;
1256    metoo = (force_metoo || ok_blook(metoo));
1257    while (np != NULL) {
1258       assert(!(np->n_type & GDEL)); /* TODO legacy */
1259       if (is_fileorpipe_addr(np) || np->n_name[0] == '\\') {
1260          cp = np->n_flink;
1261          new = put(new, np);
1262          np = cp;
1263          continue;
1264       }
1265       gp = _group_find(GT_ALIAS, np->n_name);
1266       cp = np->n_flink;
1267       if (gp != NULL)
1268          new = _gexpand(0, new, gp, metoo, np->n_type);
1269       else
1270          new = put(new, np);
1271       np = cp;
1272    }
1273    NYD_LEAVE;
1274    return new;
1275 }
1276
1277 FL struct name *
1278 elide(struct name *names)
1279 {
1280    struct name *np, *t, *newn, *x;
1281    NYD_ENTER;
1282
1283    newn = NULL;
1284    if (names == NULL)
1285       goto jleave;
1286
1287    /* Throw away all deleted nodes (XXX merge with plain sort below?) */
1288    for (np = NULL; names != NULL; names = names->n_flink)
1289       if  (!(names->n_type & GDEL)) {
1290          names->n_blink = np;
1291          if (np)
1292             np->n_flink = names;
1293          else
1294             newn = names;
1295          np = names;
1296       }
1297    if (newn == NULL)
1298       goto jleave;
1299
1300    np = newn->n_flink;
1301    if (np != NULL)
1302       np->n_blink = NULL;
1303    newn->n_flink = NULL;
1304
1305    while (np != NULL) {
1306       int cmpres;
1307
1308       t = newn;
1309       while ((cmpres = asccasecmp(t->n_name, np->n_name)) < 0) {
1310          if (t->n_flink == NULL)
1311             break;
1312          t = t->n_flink;
1313       }
1314
1315       /* If we ran out of t's, put new entry after the current value of t */
1316       if (cmpres < 0) {
1317          t->n_flink = np;
1318          np->n_blink = t;
1319          t = np;
1320          np = np->n_flink;
1321          t->n_flink = NULL;
1322          continue;
1323       }
1324
1325       /* Otherwise, put the new entry in front of the current t.  If at the
1326        * front of the list, the new guy becomes the new head of the list */
1327       if (t == newn) {
1328          t = np;
1329          np = np->n_flink;
1330          t->n_flink = newn;
1331          newn->n_blink = t;
1332          t->n_blink = NULL;
1333          newn = t;
1334          continue;
1335       }
1336
1337       /* The normal case -- we are inserting into the middle of the list */
1338       x = np;
1339       np = np->n_flink;
1340       x->n_flink = t;
1341       x->n_blink = t->n_blink;
1342       t->n_blink->n_flink = x;
1343       t->n_blink = x;
1344    }
1345
1346    /* Now the list headed up by new is sorted.  Remove duplicates */
1347    np = newn;
1348    while (np != NULL) {
1349       t = np;
1350       while (t->n_flink != NULL && !asccasecmp(np->n_name, t->n_flink->n_name))
1351          t = t->n_flink;
1352       if (t == np) {
1353          np = np->n_flink;
1354          continue;
1355       }
1356
1357       /* Now t points to the last entry with the same name as np.
1358        * Make np point beyond t */
1359       np->n_flink = t->n_flink;
1360       if (t->n_flink != NULL)
1361          t->n_flink->n_blink = np;
1362       np = np->n_flink;
1363    }
1364 jleave:
1365    NYD_LEAVE;
1366    return newn;
1367 }
1368
1369 FL int
1370 c_alternates(void *v)
1371 {
1372    size_t l;
1373    char **namelist = v, **ap, **ap2, *cp;
1374    NYD_ENTER;
1375
1376    l = argcount(namelist) +1;
1377
1378    if (l == 1) {
1379       if (_altnames != NULL) {
1380          printf("alternates ");
1381          for (ap = _altnames; *ap != NULL; ++ap)
1382             printf("%s ", *ap);
1383          printf("\n");
1384       }
1385       goto jleave;
1386    }
1387
1388    if (_altnames != NULL) {
1389       for (ap = _altnames; *ap != NULL; ++ap)
1390          free(*ap);
1391       free(_altnames);
1392    }
1393
1394    _altnames = smalloc(l * sizeof(*_altnames));
1395    for (ap = namelist, ap2 = _altnames; *ap != NULL; ++ap, ++ap2) {
1396       l = strlen(*ap) +1;
1397       cp = smalloc(l);
1398       memcpy(cp, *ap, l);
1399       *ap2 = cp;
1400    }
1401    *ap2 = NULL;
1402 jleave:
1403    NYD_LEAVE;
1404    return 0;
1405 }
1406
1407 FL struct name *
1408 delete_alternates(struct name *np)
1409 {
1410    struct name *xp;
1411    char **ap;
1412    NYD_ENTER;
1413
1414    np = delname(np, myname);
1415    if (_altnames != NULL)
1416       for (ap = _altnames; *ap != '\0'; ++ap)
1417          np = delname(np, *ap);
1418
1419    if ((xp = lextract(ok_vlook(from), GEXTRA | GSKIN)) != NULL)
1420       while (xp != NULL) {
1421          np = delname(np, xp->n_name);
1422          xp = xp->n_flink;
1423       }
1424
1425    if ((xp = lextract(ok_vlook(replyto), GEXTRA | GSKIN)) != NULL)
1426       while (xp != NULL) {
1427          np = delname(np, xp->n_name);
1428          xp = xp->n_flink;
1429       }
1430
1431    if ((xp = extract(ok_vlook(sender), GEXTRA | GSKIN)) != NULL)
1432       while (xp != NULL) {
1433          np = delname(np, xp->n_name);
1434          xp = xp->n_flink;
1435       }
1436    NYD_LEAVE;
1437    return np;
1438 }
1439
1440 FL int
1441 is_myname(char const *name)
1442 {
1443    int rv = 1;
1444    struct name *xp;
1445    char **ap;
1446    NYD_ENTER;
1447
1448    if (_same_name(myname, name))
1449       goto jleave;
1450    if (_altnames != NULL)
1451       for (ap = _altnames; *ap != NULL; ++ap)
1452          if (_same_name(*ap, name))
1453             goto jleave;
1454
1455    if ((xp = lextract(ok_vlook(from), GEXTRA | GSKIN)) != NULL)
1456       while (xp != NULL) {
1457          if (_same_name(xp->n_name, name))
1458             goto jleave;
1459          xp = xp->n_flink;
1460       }
1461
1462    if ((xp = lextract(ok_vlook(replyto), GEXTRA | GSKIN)) != NULL)
1463       while (xp != NULL) {
1464          if (_same_name(xp->n_name, name))
1465             goto jleave;
1466          xp = xp->n_flink;
1467       }
1468
1469    if ((xp = extract(ok_vlook(sender), GEXTRA | GSKIN)) != NULL)
1470       while (xp != NULL) {
1471          if (_same_name(xp->n_name, name))
1472             goto jleave;
1473          xp = xp->n_flink;
1474       }
1475    rv = 0;
1476 jleave:
1477    NYD_LEAVE;
1478    return rv;
1479 }
1480
1481 FL int
1482 c_alias(void *v)
1483 {
1484    char **argv = v;
1485    struct group *gp;
1486    int rv = 0;
1487    NYD_ENTER;
1488
1489    if (*argv == NULL)
1490       _group_print_all(GT_ALIAS);
1491    else if (argv[1] == NULL) {
1492       if ((gp = _group_find(GT_ALIAS, *argv)) != NULL)
1493          _group_print(gp, stdout);
1494       else {
1495          n_err(_("No such alias: \"%s\"\n"), *argv);
1496          rv = 1;
1497       }
1498    } else {
1499       struct grp_names_head *gnhp;
1500
1501       gp = _group_fetch(GT_ALIAS, *argv, 0);
1502       GP_TO_SUBCLASS(gnhp, gp);
1503
1504       for (++argv; *argv != NULL; ++argv) {
1505          size_t l = strlen(*argv) +1;
1506          struct grp_names *gnp = smalloc(sizeof(*gnp) -
1507                VFIELD_SIZEOF(struct grp_names, gn_id) + l);
1508          gnp->gn_next = gnhp->gnh_head;
1509          gnhp->gnh_head = gnp;
1510          memcpy(gnp->gn_id, *argv, l);
1511       }
1512       assert(gnhp->gnh_head != NULL);
1513    }
1514    NYD_LEAVE;
1515    return rv;
1516 }
1517
1518 FL int
1519 c_unalias(void *v)
1520 {
1521    char **argv = v;
1522    int rv = 0;
1523    NYD_ENTER;
1524
1525    do if (!_group_del(GT_ALIAS, *argv)) {
1526       n_err(_("No such alias: \"%s\"\n"), *argv);
1527       rv = 1;
1528    } while (*++argv != NULL);
1529    NYD_LEAVE;
1530    return rv;
1531 }
1532
1533 FL int
1534 c_mlist(void *v)
1535 {
1536    int rv;
1537    NYD_ENTER;
1538
1539    rv = _mlmux(GT_MLIST, v);
1540    NYD_LEAVE;
1541    return rv;
1542 }
1543
1544 FL int
1545 c_unmlist(void *v)
1546 {
1547    int rv;
1548    NYD_ENTER;
1549
1550    rv = _unmlmux(GT_MLIST, v);
1551    NYD_LEAVE;
1552    return rv;
1553 }
1554
1555 FL int
1556 c_mlsubscribe(void *v)
1557 {
1558    int rv;
1559    NYD_ENTER;
1560
1561    rv = _mlmux(GT_MLIST | GT_SUBSCRIBE, v);
1562    NYD_LEAVE;
1563    return rv;
1564 }
1565
1566 FL int
1567 c_unmlsubscribe(void *v)
1568 {
1569    int rv;
1570    NYD_ENTER;
1571
1572    rv = _unmlmux(GT_MLIST | GT_SUBSCRIBE, v);
1573    NYD_LEAVE;
1574    return rv;
1575 }
1576
1577 FL enum mlist_state
1578 is_mlist(char const *name, bool_t subscribed_only)
1579 {
1580    struct group *gp;
1581 #ifdef HAVE_REGEX
1582    struct grp_regex **lpp, *grp;
1583    bool_t re2;
1584 #endif
1585    enum mlist_state rv;
1586    NYD_ENTER;
1587
1588    gp = _group_find(GT_MLIST, name);
1589    rv = (gp != NULL) ? MLIST_KNOWN : MLIST_OTHER;
1590    if (rv == MLIST_KNOWN) {
1591       if (gp->g_type & GT_SUBSCRIBE)
1592          rv = MLIST_SUBSCRIBED;
1593       else if (subscribed_only)
1594          rv = MLIST_OTHER;
1595       /* Of course, if that is a regular expression it doesn't mean a thing */
1596 #ifdef HAVE_REGEX
1597       if (gp->g_type & GT_REGEX)
1598          rv = MLIST_OTHER;
1599       else
1600 #endif
1601          goto jleave;
1602    }
1603
1604    /* Not in the hashmap (as something matchable), walk the lists */
1605 #ifdef HAVE_REGEX
1606    re2 = FAL0;
1607    lpp = &_mlsub_regex;
1608 jregex_redo:
1609    if ((grp = *lpp) != NULL) {
1610       do if (regexec(&grp->gr_regex, name, 0,NULL, 0) != REG_NOMATCH) {
1611          /* Relink as the head of this list if the hit count of this group is
1612           * >= 25% of the average hit count */
1613          size_t i;
1614          if (!re2)
1615             i = ++_mlsub_hits / _mlsub_size;
1616          else
1617             i = ++_mlist_hits / _mlist_size;
1618          i >>= 2;
1619
1620          if (++grp->gr_hits >= i && *lpp != grp && grp->gr_next != grp) {
1621             grp->gr_last->gr_next = grp->gr_next;
1622             grp->gr_next->gr_last = grp->gr_last;
1623             (grp->gr_last = (*lpp)->gr_last)->gr_next = grp;
1624             (grp->gr_next = *lpp)->gr_last = grp;
1625             *lpp = grp;
1626          }
1627          rv = !re2 ? MLIST_SUBSCRIBED : MLIST_KNOWN;
1628          goto jleave;
1629       } while ((grp = grp->gr_next) != *lpp);
1630    }
1631    if (!re2 && !subscribed_only) {
1632       re2 = TRU1;
1633       lpp = &_mlist_regex;
1634       goto jregex_redo;
1635    }
1636    assert(rv == MLIST_OTHER);
1637 #endif
1638
1639 jleave:
1640    NYD_LEAVE;
1641    return rv;
1642 }
1643
1644 FL int
1645 c_shortcut(void *v)
1646 {
1647    char **argv = v;
1648    int rv = 0;
1649    NYD_ENTER;
1650
1651    if (*argv == NULL)
1652       _group_print_all(GT_SHORTCUT);
1653    else for (; *argv != NULL; argv += 2) {
1654       /* Because one hardly ever redefines, anything is stored in one chunk */
1655       size_t l;
1656       struct group *gp;
1657       char *cp;
1658
1659       if (argv[1] == NULL) {
1660          n_err(_("Shortcut expansion is missing: \"%s\"\n"), *argv);
1661          rv = 1;
1662          break;
1663       }
1664       if (_group_find(GT_SHORTCUT, *argv) != NULL)
1665          _group_del(GT_SHORTCUT, *argv);
1666
1667       l = strlen(argv[1]) +1;
1668       gp = _group_fetch(GT_SHORTCUT, *argv, l);
1669       GP_TO_SUBCLASS(cp, gp);
1670       memcpy(cp, argv[1], l);
1671    }
1672    NYD_LEAVE;
1673    return rv;
1674 }
1675
1676 FL int
1677 c_unshortcut(void *v)
1678 {
1679    char **argv = v;
1680    int rv = 0;
1681    NYD_ENTER;
1682
1683    do if (!_group_del(GT_SHORTCUT, *argv)) {
1684       n_err(_("No such shortcut: \"%s\"\n"), *argv);
1685       rv = 1;
1686    } while (*++argv != NULL);
1687    NYD_LEAVE;
1688    return rv;
1689 }
1690
1691 FL char const *
1692 shortcut_expand(char const *str)
1693 {
1694    struct group *gp;
1695    NYD_ENTER;
1696
1697    if ((gp = _group_find(GT_SHORTCUT, str)) != NULL)
1698       GP_TO_SUBCLASS(str, gp);
1699    else
1700       str = NULL;
1701    NYD_LEAVE;
1702    return str;
1703 }
1704
1705 FL int
1706 c_customhdr(void *v){
1707    struct group *gp;
1708    char const **argv, *hcp;
1709    int rv;
1710    NYD_ENTER;
1711
1712    rv = 0;
1713
1714    if((hcp = *(argv = v)) == NULL){
1715       _group_print_all(GT_CUSTOMHDR);
1716       goto jleave;
1717    }
1718
1719    /* Verify the header field name */
1720    for(rv = 1;; ++hcp){
1721       if(fieldnamechar(*hcp))
1722          continue;
1723       if(*hcp == '\0'){
1724          if(hcp == *argv){
1725             n_err(_("Cannot use nameless custom header\n"));
1726             goto jleave;
1727          }
1728          hcp = *argv;
1729          break;
1730       }
1731       n_err(_("Invalid custom header name: \"%s\"\n"), *argv);
1732       goto jleave;
1733    }
1734    rv = 0;
1735
1736    if(*++argv == NULL){
1737       if((gp = _group_find(GT_CUSTOMHDR, hcp)) != NULL)
1738          _group_print(gp, stdout);
1739       else{
1740          n_err(_("No such custom header: \"%s\"\n"), hcp);
1741          rv = 1;
1742       }
1743    }else{
1744       /* Because one hardly ever redefines, anything is stored in one chunk */
1745       size_t i, l;
1746       char *cp;
1747
1748       if(_group_find(GT_CUSTOMHDR, hcp) != NULL)
1749          _group_del(GT_CUSTOMHDR, hcp);
1750
1751       for(l = i = 0; argv[i] != NULL; ++i)
1752          l += strlen(argv[i]) + 1;
1753       gp = _group_fetch(GT_CUSTOMHDR, hcp, l +1);
1754       GP_TO_SUBCLASS(cp, gp);
1755       for(i = 0; argv[i] != NULL; ++i){
1756          if(i > 0)
1757             *cp++ = ' ';
1758          l = strlen(argv[i]);
1759          memcpy(cp, argv[i], l);
1760          cp += l;
1761       }
1762       *cp = '\0';
1763    }
1764 jleave:
1765    NYD_LEAVE;
1766    return rv;
1767 }
1768
1769 FL int
1770 c_uncustomhdr(void *v){
1771    int rv;
1772    char **argv;
1773    NYD_ENTER;
1774
1775    rv = 0;
1776
1777    argv = v;
1778    do{
1779       if(!_group_del(GT_CUSTOMHDR, *argv)){
1780          n_err(_("No such custom header: \"%s\"\n"), *argv);
1781          rv = 1;
1782       }
1783    }while(*++argv != NULL);
1784    NYD_LEAVE;
1785    return rv;
1786 }
1787
1788 FL struct n_header_field *
1789 n_customhdr_query(void){ /* XXX Uses salloc()! */
1790    struct group const *gp;
1791    ui32_t h;
1792    struct n_header_field *rv, **tail, *hfp;
1793    NYD_ENTER;
1794
1795    rv = NULL;
1796    tail = &rv;
1797
1798    for(h = 0; h < HSHSIZE; ++h)
1799       for(gp = _customhdr_heads[h]; gp != NULL; gp = gp->g_next){
1800          char const *cp;
1801          ui32_t nl, bl;
1802
1803          GP_TO_SUBCLASS(cp, gp);
1804          nl = (ui32_t)strlen(gp->g_id) +1;
1805          bl = (ui32_t)strlen(cp) +1;
1806
1807          *tail = hfp = salloc(VSTRUCT_SIZEOF(struct n_header_field, hf_dat) +
1808                nl + bl);
1809             tail = &hfp->hf_next;
1810          hfp->hf_next = NULL;
1811          hfp->hf_nl = nl - 1;
1812          hfp->hf_bl = bl - 1;
1813          memcpy(hfp->hf_dat, gp->g_id, nl);
1814             memcpy(hfp->hf_dat + nl, cp, bl);
1815       }
1816
1817    /* TODO We have no copy-on-write environments yet, and since custom headers
1818     * TODO are a perfect subject for localization, add the OBSOLETE variable
1819     * TODO *customhdr*, too */
1820    {
1821       char const *vp = ok_vlook(customhdr);
1822
1823       if(vp != NULL){
1824          char *buf = savestr(vp);
1825 jch_outer:
1826          while((vp = n_strescsep(&buf, ',', TRU1)) != NULL){
1827             ui32_t nl, bl;
1828             char const *nstart, *cp;
1829
1830             for(nstart = cp = vp;; ++cp){
1831                if(fieldnamechar(*cp))
1832                   continue;
1833                if(*cp == '\0'){
1834                   if(cp == nstart){
1835                      n_err(_("Invalid nameless *customhdr* entry\n"));
1836                      goto jch_outer;
1837                   }
1838                }else if(*cp != ':' && !blankchar(*cp)){
1839 jch_badent:
1840                   n_err(_("Invalid *customhdr* entry: \"%s\"\n"), vp);
1841                   goto jch_outer;
1842                }
1843                break;
1844             }
1845             nl = (ui32_t)PTR2SIZE(cp - nstart);
1846
1847             while(blankchar(*cp))
1848                ++cp;
1849             if(*cp++ != ':')
1850                goto jch_badent;
1851             while(blankchar(*cp))
1852                ++cp;
1853             bl = (ui32_t)strlen(cp) +1;
1854
1855             *tail = hfp = salloc(VSTRUCT_SIZEOF(struct n_header_field, hf_dat) +
1856                   nl +1 + bl);
1857                tail = &hfp->hf_next;
1858             hfp->hf_next = NULL;
1859             hfp->hf_nl = nl;
1860             hfp->hf_bl = bl - 1;
1861             memcpy(hfp->hf_dat, nstart, nl);
1862                hfp->hf_dat[nl++] = '\0';
1863                memcpy(hfp->hf_dat + nl, cp, bl);
1864          }
1865       }
1866    }
1867    NYD_LEAVE;
1868    return rv;
1869 }
1870
1871 /* s-it-mode */