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