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 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   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[n_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*)n_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[n_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.  Return number of written lines */
 179 static size_t        _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          goto jwpwc;
 290       if (c == '"') {
 291          if (lc != '\\')
 292             inquote = !inquote;
 293 #if 0 /* TODO when doing real RFC 5322 parsers - why have i done this? */
 294          else
 295             --wp;
 296 #endif
 297          goto jwpwc;
 298       }
 299       if (inquote || lc == '\\') {
 300 jwpwc:
 301          *wp++ = c;
 302          lastsp = 0;
 303          continue;
 304       }
 305       if (c == '(') {
 306          ap = cp;
 307          cp = skip_comment(cp + 1);
 308          if (keepcomms)
 309             while (ap < cp)
 310                *wp++ = *ap++;
 311          --cp;
 312          lastsp = 0;
 313          continue;
 314       }
 315       if (strchr(separators, c) != NULL)
 316          break;
 317
 318       lc = lastsp;
 319       lastsp = blankchar(c);
 320       if (!lastsp || !lc)
 321          *wp++ = c;
 322    }
 323    if (blankchar(lc))
 324       --wp;
 325
 326    *wp = '\0';
 327 jleave:
 328    NYD_LEAVE;
 329    return cp;
 330 }
 331
 332 static struct name *
 333 _extract1(char const *line, enum gfield ntype, char const *separators,
 334    bool_t keepcomms)
 335 {
 336    struct name *topp, *np, *t;
 337    char const *cp;
 338    char *nbuf;
 339    NYD_ENTER;
 340
 341    topp = NULL;
 342    if (line == NULL || *line == '\0')
 343       goto jleave;
 344
 345    np = NULL;
 346    cp = line;
 347    nbuf = smalloc(strlen(line) +1);
 348    while ((cp = yankname(cp, nbuf, separators, keepcomms)) != NULL) {
 349       t = nalloc(nbuf, ntype);
 350       if (topp == NULL)
 351          topp = t;
 352       else
 353          np->n_flink = t;
 354       t->n_blink = np;
 355       np = t;
 356    }
 357    free(nbuf);
 358 jleave:
 359    NYD_LEAVE;
 360    return topp;
 361 }
 362
 363 static struct name *
 364 _gexpand(size_t level, struct name *nlist, struct group *gp, bool_t metoo,
 365    int ntype)
 366 {
 367    char const *logname;
 368    struct grp_names_head *gnhp;
 369    struct grp_names *gnp;
 370    NYD_ENTER;
 371
 372    if (UICMP(z, level++, >, MAXEXP)) {
 373       n_err(_("Expanding alias to depth larger than %d\n"), MAXEXP);
 374       goto jleave;
 375    }
 376
 377    GP_TO_SUBCLASS(gnhp, gp);
 378    logname = ok_vlook(LOGNAME);
 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, logname))
 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, logname))
 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 :
 421             (/*gt & GT_SHORTCUT ?*/ _shortcut_heads /*: NULL */))) +
 422            torek_hash(id) % HSHSIZE));
 423
 424    for (; gp != NULL; lgp = gp, gp = gp->g_next)
 425       if ((gp->g_type & gt) && *gp->g_id == *id && !strcmp(gp->g_id, id))
 426          break;
 427
 428    glp->gl_slot_last = lgp;
 429    glp->gl_group = gp;
 430    NYD_LEAVE;
 431    return gp;
 432 }
 433
 434 static struct group *
 435 _group_find(enum group_type gt, char const *id)
 436 {
 437    struct group_lookup gl;
 438    struct group *gp;
 439    NYD_ENTER;
 440
 441    gp = _group_lookup(gt, &gl, id);
 442    NYD_LEAVE;
 443    return gp;
 444 }
 445
 446 static struct group *
 447 _group_go_first(enum group_type gt, struct group_lookup *glp)
 448 {
 449    struct group **gpa, *gp;
 450    size_t i;
 451    NYD_ENTER;
 452
 453    for (glp->gl_htable = gpa = (gt & GT_ALIAS ? _alias_heads :
 454             (gt & GT_MLIST ? _mlist_heads :
 455             (/*gt & GT_SHORTCUT ?*/ _shortcut_heads /*: NULL */))), i = 0;
 456          i < HSHSIZE; ++gpa, ++i)
 457       if ((gp = *gpa) != NULL) {
 458          glp->gl_slot = gpa;
 459          glp->gl_group = gp;
 460          goto jleave;
 461       }
 462
 463    glp->gl_group = gp = NULL;
 464 jleave:
 465    glp->gl_slot_last = NULL;
 466    NYD_LEAVE;
 467    return gp;
 468 }
 469
 470 static struct group *
 471 _group_go_next(struct group_lookup *glp)
 472 {
 473    struct group *gp, **gpa;
 474    NYD_ENTER;
 475
 476    if ((gp = glp->gl_group->g_next) != NULL)
 477       glp->gl_slot_last = glp->gl_group;
 478    else {
 479       glp->gl_slot_last = NULL;
 480       for (gpa = glp->gl_htable + HSHSIZE; ++glp->gl_slot < gpa;)
 481          if ((gp = *glp->gl_slot) != NULL)
 482             break;
 483    }
 484    glp->gl_group = gp;
 485    NYD_LEAVE;
 486    return gp;
 487 }
 488
 489 static struct group *
 490 _group_fetch(enum group_type gt, char const *id, size_t addsz)
 491 {
 492    struct group_lookup gl;
 493    struct group *gp;
 494    size_t l, i;
 495    NYD_ENTER;
 496
 497    if ((gp = _group_lookup(gt, &gl, id)) != NULL)
 498       goto jleave;
 499
 500    l = strlen(id) +1;
 501    i = n_ALIGN(n_VSTRUCT_SIZEOF(struct group, g_id) + l);
 502    switch (gt & GT_MASK) {
 503    case GT_ALIAS:
 504       addsz = sizeof(struct grp_names_head);
 505       break;
 506    case GT_MLIST:
 507 #ifdef HAVE_REGEX
 508       if (n_is_maybe_regex(id)) {
 509          addsz = sizeof(struct grp_regex);
 510          gt |= GT_REGEX;
 511       }
 512 #endif
 513    case GT_SHORTCUT:
 514    default:
 515       break;
 516    }
 517
 518    gp = smalloc(i + addsz);
 519    gp->g_subclass_off = i;
 520    gp->g_type = gt;
 521    memcpy(gp->g_id, id, l);
 522
 523    if (gt & GT_ALIAS) {
 524       struct grp_names_head *gnhp;
 525
 526       GP_TO_SUBCLASS(gnhp, gp);
 527       gnhp->gnh_head = NULL;
 528    }
 529 #ifdef HAVE_REGEX
 530    else if (/*(gt & GT_MLIST) &&*/ gt & GT_REGEX) {
 531       struct grp_regex *grp;
 532       GP_TO_SUBCLASS(grp, gp);
 533
 534       if (regcomp(&grp->gr_regex, id, REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
 535          n_err(_("Invalid regular expression: %s\n"), id);
 536          free(gp);
 537          gp = NULL;
 538          goto jleave;
 539       }
 540       grp->gr_mygroup = gp;
 541       _mlmux_linkin(gp);
 542    }
 543 #endif
 544
 545    gp->g_next = *gl.gl_slot;
 546    *gl.gl_slot = gp;
 547 jleave:
 548    NYD_LEAVE;
 549    return gp;
 550 }
 551
 552 static bool_t
 553 _group_del(enum group_type gt, char const *id)
 554 {
 555    enum group_type xgt = gt & GT_MASK;
 556    struct group_lookup gl;
 557    struct group *gp;
 558    NYD_ENTER;
 559
 560    /* Delete 'em all? */
 561    if (id[0] == '*' && id[1] == '\0') {
 562       for (gp = _group_go_first(gt, &gl); gp != NULL;)
 563          gp = (gp->g_type & xgt) ? __group_del(&gl) : _group_go_next(&gl);
 564       gp = (struct group*)TRU1;
 565    } else if ((gp = _group_lookup(gt, &gl, id)) != NULL) {
 566       if (gp->g_type & xgt)
 567          __group_del(&gl);
 568       else
 569          gp = NULL;
 570    }
 571    NYD_LEAVE;
 572    return (gp != NULL);
 573 }
 574
 575 static struct group *
 576 __group_del(struct group_lookup *glp)
 577 {
 578    struct group *x, *gp;
 579    NYD_ENTER;
 580
 581    /* Overly complicated: link off this node, step ahead to next.. */
 582    x = glp->gl_group;
 583    if ((gp = glp->gl_slot_last) != NULL) {
 584       gp = (gp->g_next = x->g_next);
 585    } else {
 586       glp->gl_slot_last = NULL;
 587       gp = (*glp->gl_slot = x->g_next);
 588
 589       if (gp == NULL) {
 590          struct group **gpa = glp->gl_htable + HSHSIZE;
 591
 592          while (++glp->gl_slot < gpa)
 593             if ((gp = *glp->gl_slot) != NULL)
 594                break;
 595       }
 596    }
 597    glp->gl_group = gp;
 598
 599    if (x->g_type & GT_ALIAS)
 600       __names_del(x);
 601 #ifdef HAVE_REGEX
 602    else if (/*(x->g_type & GT_MLIST) &&*/ x->g_type & GT_REGEX) {
 603       struct grp_regex *grp;
 604       GP_TO_SUBCLASS(grp, x);
 605
 606       regfree(&grp->gr_regex);
 607       _mlmux_linkout(x);
 608    }
 609 #endif
 610
 611    free(x);
 612    NYD_LEAVE;
 613    return gp;
 614 }
 615
 616 static void
 617 __names_del(struct group *gp)
 618 {
 619    struct grp_names_head *gnhp;
 620    struct grp_names *gnp;
 621    NYD_ENTER;
 622
 623    GP_TO_SUBCLASS(gnhp, gp);
 624    for (gnp = gnhp->gnh_head; gnp != NULL;) {
 625       struct grp_names *x = gnp;
 626       gnp = gnp->gn_next;
 627       free(x);
 628    }
 629    NYD_LEAVE;
 630 }
 631
 632 static void
 633 _group_print_all(enum group_type gt)
 634 {
 635    enum group_type xgt;
 636    struct group **gpa;
 637    struct group const *gp;
 638    ui32_t h, i;
 639    char const **ida;
 640    FILE *fp;
 641    size_t lines;
 642    NYD_ENTER;
 643
 644    xgt = gt & GT_PRINT_MASK;
 645    gpa = (xgt & GT_ALIAS ? _alias_heads
 646          : (xgt & GT_MLIST ? _mlist_heads
 647          : (/*xgt & GT_SHORTCUT ?*/ _shortcut_heads
 648          /*: NULL */)));
 649
 650    for (h = 0, i = 1; h < HSHSIZE; ++h)
 651       for (gp = gpa[h]; gp != NULL; gp = gp->g_next)
 652          if ((gp->g_type & xgt) == xgt)
 653             ++i;
 654    ida = salloc(i * sizeof *ida);
 655
 656    for (i = h = 0; h < HSHSIZE; ++h)
 657       for (gp = gpa[h]; gp != NULL; gp = gp->g_next)
 658          if ((gp->g_type & xgt) == xgt)
 659             ida[i++] = gp->g_id;
 660    ida[i] = NULL;
 661
 662    if (i > 1)
 663       qsort(ida, i, sizeof *ida, &__group_print_qsorter);
 664
 665    if ((fp = Ftmp(NULL, "prgroup", OF_RDWR | OF_UNLINK | OF_REGISTER)) == NULL)
 666       fp = stdout;
 667    lines = 0;
 668
 669    for (i = 0; ida[i] != NULL; ++i)
 670       lines += _group_print(_group_find(gt, ida[i]), fp);
 671 #ifdef HAVE_REGEX
 672    if (gt & GT_MLIST) {
 673       if (gt & GT_SUBSCRIBE)
 674          i = (ui32_t)_mlsub_size, h = (ui32_t)_mlsub_hits;
 675       else
 676          i = (ui32_t)_mlist_size, h = (ui32_t)_mlist_hits;
 677       if (i > 0 && (options & OPT_D_V)){
 678          fprintf(fp, _("# %s list regex(7) total: %u entries, %u hits\n"),
 679             (gt & GT_SUBSCRIBE ? _("Subscribed") : _("Non-subscribed")),
 680             i, h);
 681          ++lines;
 682       }
 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**)n_UNCONST(a), *(char**)n_UNCONST(b));
 700    NYD_LEAVE;
 701    return rv;
 702 }
 703
 704 static size_t
 705 _group_print(struct group const *gp, FILE *fo)
 706 {
 707    char const *cp;
 708    size_t rv;
 709    NYD_ENTER;
 710
 711    rv = 1;
 712
 713    if (gp->g_type & GT_ALIAS) {
 714       struct grp_names_head *gnhp;
 715       struct grp_names *gnp;
 716
 717       fprintf(fo, "alias %s ", gp->g_id);
 718
 719       GP_TO_SUBCLASS(gnhp, gp);
 720       if ((gnp = gnhp->gnh_head) != NULL) { /* xxx always 1+ entries */
 721          do {
 722             struct grp_names *x = gnp;
 723             gnp = gnp->gn_next;
 724             fprintf(fo, " \"%s\"", string_quote(x->gn_id)); /* TODO shexp */
 725          } while (gnp != NULL);
 726       }
 727       putc('\n', fo);
 728    } else if (gp->g_type & GT_MLIST) {
 729 #ifdef HAVE_REGEX
 730       if ((gp->g_type & GT_REGEX) && (options & OPT_D_V)){
 731          size_t i;
 732          struct grp_regex *grp,
 733             *lp = (gp->g_type & GT_SUBSCRIBE ? _mlsub_regex : _mlist_regex);
 734
 735          GP_TO_SUBCLASS(grp, gp);
 736          for (i = 1; lp != grp; lp = lp->gr_next)
 737             ++i;
 738          fprintf(fo, "# regex(7): hits %" PRIuZ ", sort %" PRIuZ ".\n  ",
 739             grp->gr_hits, i);
 740          ++rv;
 741       }
 742 #endif
 743
 744       fprintf(fo, "wysh %s %s\n",
 745          (gp->g_type & GT_SUBSCRIBE ? "mlsubscribe" : "mlist"),
 746          n_shexp_quote_cp(gp->g_id, TRU1));
 747    } else if (gp->g_type & GT_SHORTCUT) {
 748       GP_TO_SUBCLASS(cp, gp);
 749       fprintf(fo, "wysh shortcut %s %s\n",
 750       gp->g_id, n_shexp_quote_cp(cp, TRU1));
 751    }
 752
 753    NYD_LEAVE;
 754    return rv;
 755 }
 756
 757 static int
 758 _mlmux(enum group_type gt, char **argv)
 759 {
 760    struct group *gp;
 761    int rv = 0;
 762    NYD_ENTER;
 763
 764    if (*argv == NULL)
 765       _group_print_all(gt);
 766    else do {
 767       if ((gp = _group_find(gt, *argv)) != NULL) {
 768          if (gt & GT_SUBSCRIBE) {
 769             if (!(gp->g_type & GT_SUBSCRIBE)) {
 770                _MLMUX_LINKOUT(gp);
 771                gp->g_type |= GT_SUBSCRIBE;
 772                _MLMUX_LINKIN(gp);
 773             } else {
 774                n_err(_("Mailing-list already `mlsubscribe'd: %s\n"),
 775                   *argv);
 776                rv = 1;
 777             }
 778          } else {
 779             n_err(_("Mailing-list already `mlist'ed: %s\n"), *argv);
 780             rv = 1;
 781          }
 782       } else
 783          _group_fetch(gt, *argv, 0);
 784    } while (*++argv != NULL);
 785
 786    NYD_LEAVE;
 787    return rv;
 788 }
 789
 790 static int
 791 _unmlmux(enum group_type gt, char **argv)
 792 {
 793    struct group *gp;
 794    int rv = 0;
 795    NYD_ENTER;
 796
 797    for (; *argv != NULL; ++argv) {
 798       if (gt & GT_SUBSCRIBE) {
 799          struct group_lookup gl;
 800          bool_t isaster;
 801
 802          if (!(isaster = (**argv == '*')))
 803             gp = _group_find(gt, *argv);
 804          else if ((gp = _group_go_first(gt, &gl)) == NULL)
 805             continue;
 806          else if (gp != NULL && !(gp->g_type & GT_SUBSCRIBE))
 807             goto jaster_entry;
 808
 809          if (gp != NULL) {
 810 jaster_redo:
 811             if (gp->g_type & GT_SUBSCRIBE) {
 812                _MLMUX_LINKOUT(gp);
 813                gp->g_type &= ~GT_SUBSCRIBE;
 814                _MLMUX_LINKIN(gp);
 815                if (isaster) {
 816 jaster_entry:
 817                   while ((gp = _group_go_next(&gl)) != NULL &&
 818                         !(gp->g_type & GT_SUBSCRIBE))
 819                      ;
 820                   if (gp != NULL)
 821                      goto jaster_redo;
 822                }
 823             } else {
 824                n_err(_("Mailing-list not `mlsubscribe'd: %s\n"),
 825                   n_shexp_quote_cp(*argv, FAL0));
 826                rv = 1;
 827             }
 828             continue;
 829          }
 830       } else if (_group_del(gt, *argv))
 831          continue;
 832       n_err(_("No such mailing-list: %s\n"), n_shexp_quote_cp(*argv, FAL0));
 833       rv = 1;
 834    }
 835    NYD_LEAVE;
 836    return rv;
 837 }
 838
 839 #ifdef HAVE_REGEX
 840 static void
 841 _mlmux_linkin(struct group *gp)
 842 {
 843    struct grp_regex **lpp, *grp, *lhp;
 844    NYD_ENTER;
 845
 846    if (gp->g_type & GT_SUBSCRIBE) {
 847       lpp = &_mlsub_regex;
 848       ++_mlsub_size;
 849    } else {
 850       lpp = &_mlist_regex;
 851       ++_mlist_size;
 852    }
 853
 854    GP_TO_SUBCLASS(grp, gp);
 855    if ((lhp = *lpp) != NULL) {
 856       (grp->gr_last = lhp->gr_last)->gr_next = grp;
 857       (grp->gr_next = lhp)->gr_last = grp;
 858    } else
 859       *lpp = grp->gr_last = grp->gr_next = grp;
 860    grp->gr_hits = 0;
 861    NYD_LEAVE;
 862 }
 863
 864 static void
 865 _mlmux_linkout(struct group *gp)
 866 {
 867    struct grp_regex *grp, **lpp;
 868    NYD_ENTER;
 869
 870    GP_TO_SUBCLASS(grp, gp);
 871
 872    if (gp->g_type & GT_SUBSCRIBE) {
 873       lpp = &_mlsub_regex;
 874       --_mlsub_size;
 875       _mlsub_hits -= grp->gr_hits;
 876    } else {
 877       lpp = &_mlist_regex;
 878       --_mlist_size;
 879       _mlist_hits -= grp->gr_hits;
 880    }
 881
 882    if (grp->gr_next == grp)
 883       *lpp = NULL;
 884    else {
 885       (grp->gr_last->gr_next = grp->gr_next)->gr_last = grp->gr_last;
 886       if (*lpp == grp)
 887          *lpp = grp->gr_next;
 888    }
 889    NYD_LEAVE;
 890 }
 891 #endif /* HAVE_REGEX */
 892
 893 FL struct name *
 894 nalloc(char const *str, enum gfield ntype)
 895 {
 896    struct n_addrguts ag;
 897    struct str in, out;
 898    struct name *np;
 899    NYD_ENTER;
 900    assert(!(ntype & GFULLEXTRA) || (ntype & GFULL) != 0);
 901
 902    str = n_addrspec_with_guts(&ag, str,
 903          ((ntype & (GFULL | GSKIN | GREF)) != 0));
 904    if(str == NULL){
 905       /*
 906       np = NULL; TODO We cannot return NULL,
 907       goto jleave; TODO thus handle failures in here!
 908       */
 909       str = ag.ag_input;
 910    }
 911
 912    if (!(ag.ag_n_flags & NAME_NAME_SALLOC)) {
 913       ag.ag_n_flags |= NAME_NAME_SALLOC;
 914       np = salloc(sizeof(*np) + ag.ag_slen +1);
 915       memcpy(np + 1, ag.ag_skinned, ag.ag_slen +1);
 916       ag.ag_skinned = (char*)(np + 1);
 917    } else
 918       np = salloc(sizeof *np);
 919
 920    np->n_flink = NULL;
 921    np->n_blink = NULL;
 922    np->n_type = ntype;
 923    np->n_flags = 0;
 924
 925    np->n_fullname = np->n_name = ag.ag_skinned;
 926    np->n_fullextra = NULL;
 927    np->n_flags = ag.ag_n_flags;
 928
 929    if (ntype & GFULL) {
 930       if (ag.ag_ilen == ag.ag_slen
 931 #ifdef HAVE_IDNA
 932             && !(ag.ag_n_flags & NAME_IDNA)
 933 #endif
 934       )
 935          goto jleave;
 936       if (ag.ag_n_flags & NAME_ADDRSPEC_ISFILEORPIPE)
 937          goto jleave;
 938
 939       /* n_fullextra is only the complete name part without address.
 940        * Beware of "-r '<abc@def>'", don't treat that as FULLEXTRA */
 941       if ((ntype & GFULLEXTRA) && ag.ag_ilen > ag.ag_slen + 2) {
 942          size_t s = ag.ag_iaddr_start, e = ag.ag_iaddr_aend, i;
 943          char const *cp;
 944
 945          if (s == 0 || str[--s] != '<' || str[e++] != '>')
 946             goto jskipfullextra;
 947          i = ag.ag_ilen - e;
 948          in.s = n_lofi_alloc(s + 1 + i +1);
 949          while(s > 0 && blankchar(str[s - 1]))
 950             --s;
 951          memcpy(in.s, str, s);
 952          if (i > 0) {
 953             in.s[s++] = ' ';
 954             while (blankchar(str[e])) {
 955                ++e;
 956                if (--i == 0)
 957                   break;
 958             }
 959             if (i > 0)
 960                memcpy(&in.s[s], &str[e], i);
 961          }
 962          s += i;
 963          in.s[in.l = s] = '\0';
 964          mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
 965
 966          for (cp = out.s, i = out.l; i > 0 && spacechar(*cp); --i, ++cp)
 967             ;
 968          while (i > 0 && spacechar(cp[i - 1]))
 969             --i;
 970          np->n_fullextra = savestrbuf(cp, i);
 971
 972          n_lofi_free(in.s);
 973          free(out.s);
 974       }
 975 jskipfullextra:
 976
 977       /* n_fullname depends on IDNA conversion */
 978 #ifdef HAVE_IDNA
 979       if (!(ag.ag_n_flags & NAME_IDNA)) {
 980 #endif
 981          in.s = n_UNCONST(str);
 982          in.l = ag.ag_ilen;
 983 #ifdef HAVE_IDNA
 984       } else {
 985          /* The domain name was IDNA and has been converted.  We also have to
 986           * ensure that the domain name in .n_fullname is replaced with the
 987           * converted version, since MIME doesn't perform encoding of addrs */
 988          /* TODO This definetely doesn't belong here! */
 989          size_t l = ag.ag_iaddr_start,
 990             lsuff = ag.ag_ilen - ag.ag_iaddr_aend;
 991          in.s = ac_alloc(l + ag.ag_slen + lsuff +1);
 992          memcpy(in.s, str, l);
 993          memcpy(in.s + l, ag.ag_skinned, ag.ag_slen);
 994          l += ag.ag_slen;
 995          memcpy(in.s + l, str + ag.ag_iaddr_aend, lsuff);
 996          l += lsuff;
 997          in.s[l] = '\0';
 998          in.l = l;
 999       }
1000 #endif
1001       mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
1002       np->n_fullname = savestr(out.s);
1003       free(out.s);
1004 #ifdef HAVE_IDNA
1005       if (ag.ag_n_flags & NAME_IDNA)
1006          ac_free(in.s);
1007 #endif
1008       np->n_flags |= NAME_FULLNAME_SALLOC;
1009    }
1010 jleave:
1011    NYD_LEAVE;
1012    return np;
1013 }
1014
1015 FL struct name *
1016 ndup(struct name *np, enum gfield ntype)
1017 {
1018    struct name *nnp;
1019    NYD_ENTER;
1020
1021    if ((ntype & (GFULL | GSKIN)) && !(np->n_flags & NAME_SKINNED)) {
1022       nnp = nalloc(np->n_name, ntype);
1023       goto jleave;
1024    }
1025
1026    nnp = salloc(sizeof *np);
1027    nnp->n_flink = nnp->n_blink = NULL;
1028    nnp->n_type = ntype;
1029    nnp->n_flags = (np->n_flags & ~(NAME_NAME_SALLOC | NAME_FULLNAME_SALLOC)) |
1030          NAME_NAME_SALLOC;
1031    nnp->n_name = savestr(np->n_name);
1032    if (np->n_name == np->n_fullname || !(ntype & (GFULL | GSKIN))) {
1033       nnp->n_fullname = nnp->n_name;
1034       nnp->n_fullextra = NULL;
1035    } else {
1036       nnp->n_flags |= NAME_FULLNAME_SALLOC;
1037       nnp->n_fullname = savestr(np->n_fullname);
1038       nnp->n_fullextra = (np->n_fullextra == NULL) ? NULL
1039             : savestr(np->n_fullextra);
1040    }
1041 jleave:
1042    NYD_LEAVE;
1043    return nnp;
1044 }
1045
1046 FL struct name *
1047 cat(struct name *n1, struct name *n2)
1048 {
1049    struct name *tail;
1050    NYD_ENTER;
1051
1052    tail = n2;
1053    if (n1 == NULL)
1054       goto jleave;
1055    tail = n1;
1056    if (n2 == NULL)
1057       goto jleave;
1058
1059    while (tail->n_flink != NULL)
1060       tail = tail->n_flink;
1061    tail->n_flink = n2;
1062    n2->n_blink = tail;
1063    tail = n1;
1064 jleave:
1065    NYD_LEAVE;
1066    return tail;
1067 }
1068
1069 FL struct name *
1070 namelist_dup(struct name const *np, enum gfield ntype)
1071 {
1072    struct name *nnp;
1073    NYD_ENTER;
1074
1075    for (nnp = NULL; np != NULL; np = np->n_flink) {
1076       struct name *x = ndup(n_UNCONST(np), (np->n_type & ~GMASK) | ntype);
1077       x->n_flink = nnp;
1078       nnp = x;
1079    }
1080    NYD_LEAVE;
1081    return nnp;
1082 }
1083
1084 FL ui32_t
1085 count(struct name const *np)
1086 {
1087    ui32_t c;
1088    NYD_ENTER;
1089
1090    for (c = 0; np != NULL; np = np->n_flink)
1091       if (!(np->n_type & GDEL))
1092          ++c;
1093    NYD_LEAVE;
1094    return c;
1095 }
1096
1097 FL ui32_t
1098 count_nonlocal(struct name const *np)
1099 {
1100    ui32_t c;
1101    NYD_ENTER;
1102
1103    for (c = 0; np != NULL; np = np->n_flink)
1104       if (!(np->n_type & GDEL) && !(np->n_flags & NAME_ADDRSPEC_ISFILEORPIPE))
1105          ++c;
1106    NYD_LEAVE;
1107    return c;
1108 }
1109
1110 FL struct name *
1111 extract(char const *line, enum gfield ntype)
1112 {
1113    struct name *rv;
1114    NYD_ENTER;
1115
1116    rv = _extract1(line, ntype, " \t,", 0);
1117    NYD_LEAVE;
1118    return rv;
1119 }
1120
1121 FL struct name *
1122 lextract(char const *line, enum gfield ntype)
1123 {
1124    struct name *rv;
1125    NYD_ENTER;
1126
1127    rv = ((line != NULL && strpbrk(line, ",\"\\(<|"))
1128          ? _extract1(line, ntype, ",", 1) : extract(line, ntype));
1129    NYD_LEAVE;
1130    return rv;
1131 }
1132
1133 FL char *
1134 detract(struct name *np, enum gfield ntype)
1135 {
1136    char *topp, *cp;
1137    struct name *p;
1138    int flags, s;
1139    NYD_ENTER;
1140
1141    topp = NULL;
1142    if (np == NULL)
1143       goto jleave;
1144
1145    flags = ntype & (GCOMMA | GNAMEONLY);
1146    ntype &= ~(GCOMMA | GNAMEONLY);
1147    s = 0;
1148
1149    for (p = np; p != NULL; p = p->n_flink) {
1150       if (ntype && (p->n_type & GMASK) != ntype)
1151          continue;
1152       s += strlen(flags & GNAMEONLY ? p->n_name : p->n_fullname) +1;
1153       if (flags & GCOMMA)
1154          ++s;
1155    }
1156    if (s == 0)
1157       goto jleave;
1158
1159    s += 2;
1160    topp = salloc(s);
1161    cp = topp;
1162    for (p = np; p != NULL; p = p->n_flink) {
1163       if (ntype && (p->n_type & GMASK) != ntype)
1164          continue;
1165       cp = sstpcpy(cp, (flags & GNAMEONLY ? p->n_name : p->n_fullname));
1166       if ((flags & GCOMMA) && p->n_flink != NULL)
1167          *cp++ = ',';
1168       *cp++ = ' ';
1169    }
1170    *--cp = 0;
1171    if ((flags & GCOMMA) && *--cp == ',')
1172       *cp = 0;
1173 jleave:
1174    NYD_LEAVE;
1175    return topp;
1176 }
1177
1178 FL struct name *
1179 grab_names(enum n_lexinput_flags lif, char const *field, struct name *np,
1180       int comma, enum gfield gflags)
1181 {
1182    struct name *nq;
1183    NYD_ENTER;
1184
1185 jloop:
1186    np = lextract(n_lex_input_cp(lif, field, detract(np, comma)), gflags);
1187    for (nq = np; nq != NULL; nq = nq->n_flink)
1188       if (is_addr_invalid(nq, EACM_NONE))
1189          goto jloop;
1190    NYD_LEAVE;
1191    return np;
1192 }
1193
1194 FL bool_t
1195 name_is_same_domain(struct name const *n1, struct name const *n2)
1196 {
1197    char const *d1, *d2;
1198    bool_t rv;
1199    NYD_ENTER;
1200
1201    d1 = strrchr(n1->n_name, '@');
1202    d2 = strrchr(n2->n_name, '@');
1203
1204    rv = (d1 != NULL && d2 != NULL) ? !asccasecmp(++d1, ++d2) : FAL0;
1205
1206    NYD_LEAVE;
1207    return rv;
1208 }
1209
1210 FL struct name *
1211 checkaddrs(struct name *np, enum expand_addr_check_mode eacm,
1212    si8_t *set_on_error)
1213 {
1214    struct name *n;
1215    NYD_ENTER;
1216
1217    for (n = np; n != NULL;) {
1218       si8_t rv;
1219
1220       if ((rv = is_addr_invalid(n, eacm)) != 0) {
1221          if (set_on_error != NULL)
1222             *set_on_error |= rv; /* don't loose -1! */
1223          if (n->n_blink)
1224             n->n_blink->n_flink = n->n_flink;
1225          if (n->n_flink)
1226             n->n_flink->n_blink = n->n_blink;
1227          if (n == np)
1228             np = n->n_flink;
1229       }
1230       n = n->n_flink;
1231    }
1232    NYD_LEAVE;
1233    return np;
1234 }
1235
1236 FL struct name *
1237 namelist_vaporise_head(struct header *hp, enum expand_addr_check_mode eacm,
1238    bool_t metoo, si8_t *set_on_error)
1239 {
1240    struct name *tolist, *np, **npp;
1241    NYD_ENTER;
1242
1243    tolist = usermap(cat(hp->h_to, cat(hp->h_cc, hp->h_bcc)), metoo);
1244    hp->h_to = hp->h_cc = hp->h_bcc = NULL;
1245
1246    tolist = elide(checkaddrs(tolist, eacm, set_on_error));
1247
1248    for (np = tolist; np != NULL; np = np->n_flink) {
1249       switch (np->n_type & (GDEL | GMASK)) {
1250       case GTO:   npp = &hp->h_to; break;
1251       case GCC:   npp = &hp->h_cc; break;
1252       case GBCC:  npp = &hp->h_bcc; break;
1253       default:    continue;
1254       }
1255       *npp = cat(*npp, ndup(np, np->n_type | GFULL));
1256    }
1257    NYD_LEAVE;
1258    return tolist;
1259 }
1260
1261 FL struct name *
1262 usermap(struct name *names, bool_t force_metoo)
1263 {
1264    struct name *new, *np, *cp;
1265    struct group *gp;
1266    int metoo;
1267    NYD_ENTER;
1268
1269    new = NULL;
1270    np = names;
1271    metoo = (force_metoo || ok_blook(metoo));
1272    while (np != NULL) {
1273       assert(!(np->n_type & GDEL)); /* TODO legacy */
1274       if (is_fileorpipe_addr(np) || np->n_name[0] == '\\') {
1275          cp = np->n_flink;
1276          new = put(new, np);
1277          np = cp;
1278          continue;
1279       }
1280       gp = _group_find(GT_ALIAS, np->n_name);
1281       cp = np->n_flink;
1282       if (gp != NULL)
1283          new = _gexpand(0, new, gp, metoo, np->n_type);
1284       else
1285          new = put(new, np);
1286       np = cp;
1287    }
1288    NYD_LEAVE;
1289    return new;
1290 }
1291
1292 FL struct name *
1293 elide(struct name *names)
1294 {
1295    struct name *np, *t, *newn, *x;
1296    NYD_ENTER;
1297
1298    newn = NULL;
1299    if (names == NULL)
1300       goto jleave;
1301
1302    /* Throw away all deleted nodes (XXX merge with plain sort below?) */
1303    for (np = NULL; names != NULL; names = names->n_flink)
1304       if  (!(names->n_type & GDEL)) {
1305          names->n_blink = np;
1306          if (np)
1307             np->n_flink = names;
1308          else
1309             newn = names;
1310          np = names;
1311       }
1312    if (newn == NULL)
1313       goto jleave;
1314
1315    np = newn->n_flink;
1316    if (np != NULL)
1317       np->n_blink = NULL;
1318    newn->n_flink = NULL;
1319
1320    while (np != NULL) {
1321       int cmpres;
1322
1323       t = newn;
1324       while ((cmpres = asccasecmp(t->n_name, np->n_name)) < 0) {
1325          if (t->n_flink == NULL)
1326             break;
1327          t = t->n_flink;
1328       }
1329
1330       /* If we ran out of t's, put new entry after the current value of t */
1331       if (cmpres < 0) {
1332          t->n_flink = np;
1333          np->n_blink = t;
1334          t = np;
1335          np = np->n_flink;
1336          t->n_flink = NULL;
1337          continue;
1338       }
1339
1340       /* Otherwise, put the new entry in front of the current t.  If at the
1341        * front of the list, the new guy becomes the new head of the list */
1342       if (t == newn) {
1343          t = np;
1344          np = np->n_flink;
1345          t->n_flink = newn;
1346          newn->n_blink = t;
1347          t->n_blink = NULL;
1348          newn = t;
1349          continue;
1350       }
1351
1352       /* The normal case -- we are inserting into the middle of the list */
1353       x = np;
1354       np = np->n_flink;
1355       x->n_flink = t;
1356       x->n_blink = t->n_blink;
1357       t->n_blink->n_flink = x;
1358       t->n_blink = x;
1359    }
1360
1361    /* Now the list headed up by new is sorted.  Remove duplicates */
1362    np = newn;
1363    while (np != NULL) {
1364       t = np;
1365       while (t->n_flink != NULL && !asccasecmp(np->n_name, t->n_flink->n_name))
1366          t = t->n_flink;
1367       if (t == np) {
1368          np = np->n_flink;
1369          continue;
1370       }
1371
1372       /* Now t points to the last entry with the same name as np.
1373        * Make np point beyond t */
1374       np->n_flink = t->n_flink;
1375       if (t->n_flink != NULL)
1376          t->n_flink->n_blink = np;
1377       np = np->n_flink;
1378    }
1379 jleave:
1380    NYD_LEAVE;
1381    return newn;
1382 }
1383
1384 FL int
1385 c_alternates(void *v)
1386 {
1387    size_t l;
1388    char **namelist = v, **ap, **ap2, *cp;
1389    NYD_ENTER;
1390
1391    for (namelist = v, l = 0; namelist[l] != NULL; ++l)
1392       ;
1393
1394    if (l == 0) {
1395       if (_altnames != NULL) {
1396          printf("alternates ");
1397          for (ap = _altnames; *ap != NULL; ++ap)
1398             printf("%s ", *ap);
1399          printf("\n");
1400       }
1401       goto jleave;
1402    }
1403
1404    if (_altnames != NULL) {
1405       for (ap = _altnames; *ap != NULL; ++ap)
1406          free(*ap);
1407       free(_altnames);
1408    }
1409
1410    ++l;
1411    _altnames = smalloc(l * sizeof(*_altnames));
1412    for (ap = namelist, ap2 = _altnames; *ap != NULL; ++ap, ++ap2) {
1413       l = strlen(*ap) +1;
1414       cp = smalloc(l);
1415       memcpy(cp, *ap, l);
1416       *ap2 = cp;
1417    }
1418    *ap2 = NULL;
1419 jleave:
1420    NYD_LEAVE;
1421    return 0;
1422 }
1423
1424 FL struct name *
1425 delete_alternates(struct name *np)
1426 {
1427    struct name *xp;
1428    char **ap;
1429    NYD_ENTER;
1430
1431    np = delname(np, ok_vlook(LOGNAME));
1432    if (_altnames != NULL)
1433       for (ap = _altnames; *ap != '\0'; ++ap)
1434          np = delname(np, *ap);
1435
1436    if ((xp = lextract(ok_vlook(from), GEXTRA | GSKIN)) != NULL)
1437       while (xp != NULL) {
1438          np = delname(np, xp->n_name);
1439          xp = xp->n_flink;
1440       }
1441
1442    if ((xp = lextract(ok_vlook(replyto), GEXTRA | GSKIN)) != NULL)
1443       while (xp != NULL) {
1444          np = delname(np, xp->n_name);
1445          xp = xp->n_flink;
1446       }
1447
1448    if ((xp = extract(ok_vlook(sender), GEXTRA | GSKIN)) != NULL)
1449       while (xp != NULL) {
1450          np = delname(np, xp->n_name);
1451          xp = xp->n_flink;
1452       }
1453    NYD_LEAVE;
1454    return np;
1455 }
1456
1457 FL int
1458 is_myname(char const *name)
1459 {
1460    int rv = 1;
1461    struct name *xp;
1462    char **ap;
1463    NYD_ENTER;
1464
1465    if (_same_name(ok_vlook(LOGNAME), name))
1466       goto jleave;
1467    if (_altnames != NULL)
1468       for (ap = _altnames; *ap != NULL; ++ap)
1469          if (_same_name(*ap, name))
1470             goto jleave;
1471
1472    if ((xp = lextract(ok_vlook(from), GEXTRA | GSKIN)) != NULL)
1473       while (xp != NULL) {
1474          if (_same_name(xp->n_name, name))
1475             goto jleave;
1476          xp = xp->n_flink;
1477       }
1478
1479    if ((xp = lextract(ok_vlook(replyto), GEXTRA | GSKIN)) != NULL)
1480       while (xp != NULL) {
1481          if (_same_name(xp->n_name, name))
1482             goto jleave;
1483          xp = xp->n_flink;
1484       }
1485
1486    if ((xp = extract(ok_vlook(sender), GEXTRA | GSKIN)) != NULL)
1487       while (xp != NULL) {
1488          if (_same_name(xp->n_name, name))
1489             goto jleave;
1490          xp = xp->n_flink;
1491       }
1492    rv = 0;
1493 jleave:
1494    NYD_LEAVE;
1495    return rv;
1496 }
1497
1498 FL int
1499 c_alias(void *v)
1500 {
1501    char **argv = v;
1502    struct group *gp;
1503    int rv = 0;
1504    NYD_ENTER;
1505
1506    if (*argv == NULL)
1507       _group_print_all(GT_ALIAS);
1508    else if (argv[1] == NULL) {
1509       if ((gp = _group_find(GT_ALIAS, *argv)) != NULL)
1510          _group_print(gp, stdout);
1511       else {
1512          n_err(_("No such alias: %s\n"), *argv);
1513          rv = 1;
1514       }
1515    } else {
1516       struct grp_names_head *gnhp;
1517
1518       gp = _group_fetch(GT_ALIAS, *argv, 0);
1519       GP_TO_SUBCLASS(gnhp, gp);
1520
1521       for (++argv; *argv != NULL; ++argv) {
1522          size_t l = strlen(*argv) +1;
1523          struct grp_names *gnp = smalloc(n_VSTRUCT_SIZEOF(struct grp_names,
1524                gn_id) + l);
1525          gnp->gn_next = gnhp->gnh_head;
1526          gnhp->gnh_head = gnp;
1527          memcpy(gnp->gn_id, *argv, l);
1528       }
1529       assert(gnhp->gnh_head != NULL);
1530    }
1531    NYD_LEAVE;
1532    return rv;
1533 }
1534
1535 FL int
1536 c_unalias(void *v)
1537 {
1538    char **argv = v;
1539    int rv = 0;
1540    NYD_ENTER;
1541
1542    do if (!_group_del(GT_ALIAS, *argv)) {
1543       n_err(_("No such alias: %s\n"), *argv);
1544       rv = 1;
1545    } while (*++argv != NULL);
1546    NYD_LEAVE;
1547    return rv;
1548 }
1549
1550 FL int
1551 c_mlist(void *v)
1552 {
1553    int rv;
1554    NYD_ENTER;
1555
1556    rv = _mlmux(GT_MLIST, v);
1557    NYD_LEAVE;
1558    return rv;
1559 }
1560
1561 FL int
1562 c_unmlist(void *v)
1563 {
1564    int rv;
1565    NYD_ENTER;
1566
1567    rv = _unmlmux(GT_MLIST, v);
1568    NYD_LEAVE;
1569    return rv;
1570 }
1571
1572 FL int
1573 c_mlsubscribe(void *v)
1574 {
1575    int rv;
1576    NYD_ENTER;
1577
1578    rv = _mlmux(GT_MLIST | GT_SUBSCRIBE, v);
1579    NYD_LEAVE;
1580    return rv;
1581 }
1582
1583 FL int
1584 c_unmlsubscribe(void *v)
1585 {
1586    int rv;
1587    NYD_ENTER;
1588
1589    rv = _unmlmux(GT_MLIST | GT_SUBSCRIBE, v);
1590    NYD_LEAVE;
1591    return rv;
1592 }
1593
1594 FL enum mlist_state
1595 is_mlist(char const *name, bool_t subscribed_only)
1596 {
1597    struct group *gp;
1598 #ifdef HAVE_REGEX
1599    struct grp_regex **lpp, *grp;
1600    bool_t re2;
1601 #endif
1602    enum mlist_state rv;
1603    NYD_ENTER;
1604
1605    gp = _group_find(GT_MLIST, name);
1606    rv = (gp != NULL) ? MLIST_KNOWN : MLIST_OTHER;
1607    if (rv == MLIST_KNOWN) {
1608       if (gp->g_type & GT_SUBSCRIBE)
1609          rv = MLIST_SUBSCRIBED;
1610       else if (subscribed_only)
1611          rv = MLIST_OTHER;
1612       /* Of course, if that is a regular expression it doesn't mean a thing */
1613 #ifdef HAVE_REGEX
1614       if (gp->g_type & GT_REGEX)
1615          rv = MLIST_OTHER;
1616       else
1617 #endif
1618          goto jleave;
1619    }
1620
1621    /* Not in the hashmap (as something matchable), walk the lists */
1622 #ifdef HAVE_REGEX
1623    re2 = FAL0;
1624    lpp = &_mlsub_regex;
1625 jregex_redo:
1626    if ((grp = *lpp) != NULL) {
1627       do if (regexec(&grp->gr_regex, name, 0,NULL, 0) != REG_NOMATCH) {
1628          /* Relink as the head of this list if the hit count of this group is
1629           * >= 25% of the average hit count */
1630          size_t i;
1631          if (!re2)
1632             i = ++_mlsub_hits / _mlsub_size;
1633          else
1634             i = ++_mlist_hits / _mlist_size;
1635          i >>= 2;
1636
1637          if (++grp->gr_hits >= i && *lpp != grp && grp->gr_next != grp) {
1638             grp->gr_last->gr_next = grp->gr_next;
1639             grp->gr_next->gr_last = grp->gr_last;
1640             (grp->gr_last = (*lpp)->gr_last)->gr_next = grp;
1641             (grp->gr_next = *lpp)->gr_last = grp;
1642             *lpp = grp;
1643          }
1644          rv = !re2 ? MLIST_SUBSCRIBED : MLIST_KNOWN;
1645          goto jleave;
1646       } while ((grp = grp->gr_next) != *lpp);
1647    }
1648    if (!re2 && !subscribed_only) {
1649       re2 = TRU1;
1650       lpp = &_mlist_regex;
1651       goto jregex_redo;
1652    }
1653    assert(rv == MLIST_OTHER);
1654 #endif
1655
1656 jleave:
1657    NYD_LEAVE;
1658    return rv;
1659 }
1660
1661 FL int
1662 c_shortcut(void *v)
1663 {
1664    char **argv = v;
1665    int rv = 0;
1666    NYD_ENTER;
1667
1668    if (*argv == NULL)
1669       _group_print_all(GT_SHORTCUT);
1670    else for (; *argv != NULL; argv += 2) {
1671       /* Because one hardly ever redefines, anything is stored in one chunk */
1672       size_t l;
1673       struct group *gp;
1674       char *cp;
1675
1676       if (argv[1] == NULL) {
1677          n_err(_("Shortcut expansion is missing: %s\n"), *argv);
1678          rv = 1;
1679          break;
1680       }
1681       if (_group_find(GT_SHORTCUT, *argv) != NULL)
1682          _group_del(GT_SHORTCUT, *argv);
1683
1684       l = strlen(argv[1]) +1;
1685       gp = _group_fetch(GT_SHORTCUT, *argv, l);
1686       GP_TO_SUBCLASS(cp, gp);
1687       memcpy(cp, argv[1], l);
1688    }
1689    NYD_LEAVE;
1690    return rv;
1691 }
1692
1693 FL int
1694 c_unshortcut(void *v)
1695 {
1696    char **argv = v;
1697    int rv = 0;
1698    NYD_ENTER;
1699
1700    do if (!_group_del(GT_SHORTCUT, *argv)) {
1701       n_err(_("No such shortcut: %s\n"), *argv);
1702       rv = 1;
1703    } while (*++argv != NULL);
1704    NYD_LEAVE;
1705    return rv;
1706 }
1707
1708 FL char const *
1709 shortcut_expand(char const *str)
1710 {
1711    struct group *gp;
1712    NYD_ENTER;
1713
1714    if ((gp = _group_find(GT_SHORTCUT, str)) != NULL)
1715       GP_TO_SUBCLASS(str, gp);
1716    else
1717       str = NULL;
1718    NYD_LEAVE;
1719    return str;
1720 }
1721
1722 /* s-it-mode */