Tweak of [3051546]: avoid const cast-away
[s-mailx.git] / nam_a_grp.c
blob4e5570619308b10b1c836d8a0c99d7c92a9fa090
1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ Name lists, alternates and groups: aliases, mailing lists, shortcuts.
4 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
5 * Copyright (c) 2012 - 2016 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
6 */
7 /*
8 * Copyright (c) 1980, 1993
9 * The Regents of the University of California. All rights reserved.
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.
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.
35 #undef n_FILE
36 #define n_FILE nam_a_grp
38 #ifndef HAVE_AMALGAMATION
39 # include "nail.h"
40 #endif
42 enum group_type {
43 /* Main types (bits not values for easier testing only) */
44 GT_ALIAS = 1<< 0,
45 GT_MLIST = 1<< 1,
46 GT_SHORTCUT = 1<< 2,
47 GT_CUSTOMHDR = 1<< 3,
48 GT_MASK = GT_ALIAS | GT_MLIST | GT_SHORTCUT | GT_CUSTOMHDR,
50 /* Subtype bits and flags */
51 GT_SUBSCRIBE = 1<< 4,
52 GT_REGEX = 1<< 5,
54 /* Extended type mask to be able to reflect what we really have; i.e., mlist
55 * can have GT_REGEX if they are subscribed or not, but `mlsubscribe' should
56 * print out only GT_MLIST which have the GT_SUBSCRIBE attribute set */
57 GT_PRINT_MASK = GT_MASK | GT_SUBSCRIBE
60 struct group {
61 struct group *g_next;
62 size_t g_subclass_off; /* of "subclass" in .g_id (if any) */
63 ui8_t g_type; /* enum group_type */
64 /* Identifying name, of variable size. Dependent on actual "subtype" more
65 * data follows thereafter, but note this is always used (i.e., for regular
66 * expression entries this is still set to the plain string) */
67 char g_id[VFIELD_SIZE(-1)];
69 #define GP_TO_SUBCLASS(X,G) \
70 do {\
71 union __group_subclass {void *gs_vp; char *gs_cp;} __gs__;\
72 __gs__.gs_cp = (char*)UNCONST(G) + (G)->g_subclass_off;\
73 (X) = __gs__.gs_vp;\
74 } while (0)
76 struct grp_names_head {
77 struct grp_names *gnh_head;
80 struct grp_names {
81 struct grp_names *gn_next;
82 char gn_id[VFIELD_SIZE(0)];
85 #ifdef HAVE_REGEX
86 struct grp_regex {
87 struct grp_regex *gr_last;
88 struct grp_regex *gr_next;
89 struct group *gr_mygroup; /* xxx because lists use grp_regex*! ?? */
90 size_t gr_hits; /* Number of times this group matched */
91 regex_t gr_regex;
93 #endif
95 struct group_lookup {
96 struct group **gl_htable;
97 struct group **gl_slot;
98 struct group *gl_slot_last;
99 struct group *gl_group;
102 /* List of alternate names of user */
103 static char **_altnames;
105 /* `alias' */
106 static struct group *_alias_heads[HSHSIZE]; /* TODO dynamic hash */
108 /* `mlist', `mlsubscribe'. Anything is stored in the hashmap.. */
109 static struct group *_mlist_heads[HSHSIZE]; /* TODO dynamic hash */
111 /* ..but entries which have GT_REGEX set are false lookups and will really be
112 * accessed via sequential lists instead, which are type-specific for better
113 * performance, but also to make it possible to have ".*@xy.org" as a mlist
114 * and "(one|two)@xy.org" as a mlsubscription.
115 * These lists use a bit of QOS optimization in that a matching group will
116 * become relinked as the new list head if its hit count is
117 * (>= ((xy_hits / _xy_size) >> 2))
118 * Note that the hit counts only count currently linked in nodes.. */
119 #ifdef HAVE_REGEX
120 static struct grp_regex *_mlist_regex, *_mlsub_regex;
121 static size_t _mlist_size, _mlist_hits, _mlsub_size, _mlsub_hits;
122 #endif
124 /* `shortcut' */
125 static struct group *_shortcut_heads[HSHSIZE]; /* TODO dynamic hash */
127 /* `customhdr' */
128 static struct group *_customhdr_heads[HSHSIZE]; /* TODO dynamic hash */
130 /* Same name, while taking care for *allnet*? */
131 static bool_t _same_name(char const *n1, char const *n2);
133 /* Delete the given name from a namelist */
134 static struct name * delname(struct name *np, char const *name);
136 /* Put another node onto a list of names and return the list */
137 static struct name * put(struct name *list, struct name *node);
139 /* Grab a single name (liberal name) */
140 static char const * yankname(char const *ap, char *wbuf,
141 char const *separators, int keepcomms);
143 /* Extraction multiplexer that splits an input line to names */
144 static struct name * _extract1(char const *line, enum gfield ntype,
145 char const *separators, bool_t keepcomms);
147 /* Recursively expand a alias name. Limit expansion to some fixed level.
148 * Direct recursion is not expanded for convenience */
149 static struct name * _gexpand(size_t level, struct name *nlist,
150 struct group *gp, bool_t metoo, int ntype);
152 /* Lookup a group, return it or NULL, fill in glp anyway */
153 static struct group * _group_lookup(enum group_type gt,
154 struct group_lookup *glp, char const *id);
156 /* Easier-to-use wrapper around _group_lookup() */
157 static struct group * _group_find(enum group_type gt, char const *id);
159 /* Iteration: go to the first group, which also inits the iterator. A valid
160 * iterator can be stepped via _next(). A NULL return means no (more) groups
161 * to be iterated exist, in which case only glp->gl_group is set (NULL) */
162 static struct group * _group_go_first(enum group_type gt,
163 struct group_lookup *glp);
164 static struct group * _group_go_next(struct group_lookup *glp);
166 /* Fetch the group id, create it as necessary */
167 static struct group * _group_fetch(enum group_type gt, char const *id,
168 size_t addsz);
170 /* "Intelligent" delete which handles a "*" id, too;
171 * returns a true boolean if a group was deleted, and always succeeds for "*" */
172 static bool_t _group_del(enum group_type gt, char const *id);
174 static struct group * __group_del(struct group_lookup *glp);
175 static void __names_del(struct group *gp);
177 /* Print all groups of the given type, alphasorted */
178 static void _group_print_all(enum group_type gt);
180 static int __group_print_qsorter(void const *a, void const *b);
182 /* Really print a group, actually. Return number of written lines */
183 static size_t _group_print(struct group const *gp, FILE *fo);
185 /* Multiplexers for list and subscribe commands */
186 static int _mlmux(enum group_type gt, char **argv);
187 static int _unmlmux(enum group_type gt, char **argv);
189 /* Relinkers for the sequential match lists */
190 #ifdef HAVE_REGEX
191 static void _mlmux_linkin(struct group *gp);
192 static void _mlmux_linkout(struct group *gp);
193 # define _MLMUX_LINKIN(GP) \
194 do if ((GP)->g_type & GT_REGEX) _mlmux_linkin(GP); while (0)
195 # define _MLMUX_LINKOUT(GP) \
196 do if ((GP)->g_type & GT_REGEX) _mlmux_linkout(GP); while (0)
197 #else
198 # define _MLMUX_LINKIN(GP)
199 # define _MLMUX_LINKOUT(GP)
200 #endif
202 /* TODO v15: drop *customhdr* (OR change syntax and use shell tokens) */
203 static char *a_nag_custom_sep(char **iolist);
205 static bool_t
206 _same_name(char const *n1, char const *n2)
208 bool_t rv = FAL0;
209 char c1, c2;
210 NYD_ENTER;
212 if (ok_blook(allnet)) {
213 do {
214 c1 = *n1++;
215 c2 = *n2++;
216 c1 = lowerconv(c1);
217 c2 = lowerconv(c2);
218 if (c1 != c2)
219 goto jleave;
220 } while (c1 != '\0' && c2 != '\0' && c1 != '@' && c2 != '@');
221 rv = 1;
222 } else
223 rv = !asccasecmp(n1, n2);
224 jleave:
225 NYD_LEAVE;
226 return rv;
229 static struct name *
230 delname(struct name *np, char const *name)
232 struct name *p;
233 NYD_ENTER;
235 for (p = np; p != NULL; p = p->n_flink)
236 if (_same_name(p->n_name, name)) {
237 if (p->n_blink == NULL) {
238 if (p->n_flink != NULL)
239 p->n_flink->n_blink = NULL;
240 np = p->n_flink;
241 continue;
243 if (p->n_flink == NULL) {
244 if (p->n_blink != NULL)
245 p->n_blink->n_flink = NULL;
246 continue;
248 p->n_blink->n_flink = p->n_flink;
249 p->n_flink->n_blink = p->n_blink;
251 NYD_LEAVE;
252 return np;
255 static struct name *
256 put(struct name *list, struct name *node)
258 NYD_ENTER;
259 node->n_flink = list;
260 node->n_blink = NULL;
261 if (list != NULL)
262 list->n_blink = node;
263 NYD_LEAVE;
264 return node;
267 static char const *
268 yankname(char const *ap, char *wbuf, char const *separators, int keepcomms)
270 char const *cp;
271 char *wp, c, inquote, lc, lastsp;
272 NYD_ENTER;
274 *(wp = wbuf) = '\0';
276 /* Skip over intermediate list trash, as in ".org> , <xy@zz.org>" */
277 for (c = *ap; blankchar(c) || c == ','; c = *++ap)
279 if (c == '\0') {
280 cp = NULL;
281 goto jleave;
284 /* Parse a full name: TODO RFC 5322
285 * - Keep everything in quotes, liberal handle *quoted-pair*s therein
286 * - Skip entire (nested) comments
287 * - In non-quote, non-comment, join adjacent space to a single SP
288 * - Understand separators only in non-quote, non-comment context,
289 * and only if not part of a *quoted-pair* (XXX too liberal) */
290 cp = ap;
291 for (inquote = lc = lastsp = 0;; lc = c, ++cp) {
292 c = *cp;
293 if (c == '\0')
294 break;
295 if (c == '\\') {
296 lastsp = 0;
297 continue;
299 if (c == '"') {
300 if (lc != '\\')
301 inquote = !inquote;
302 #if 0 /* TODO when doing real RFC 5322 parsers - why have i done this? */
303 else
304 --wp;
305 #endif
306 goto jwpwc;
308 if (inquote || lc == '\\') {
309 jwpwc:
310 *wp++ = c;
311 lastsp = 0;
312 continue;
314 if (c == '(') {
315 ap = cp;
316 cp = skip_comment(cp + 1);
317 if (keepcomms)
318 while (ap < cp)
319 *wp++ = *ap++;
320 --cp;
321 lastsp = 0;
322 continue;
324 if (strchr(separators, c) != NULL)
325 break;
327 lc = lastsp;
328 lastsp = blankchar(c);
329 if (!lastsp || !lc)
330 *wp++ = c;
332 if (blankchar(lc))
333 --wp;
335 *wp = '\0';
336 jleave:
337 NYD_LEAVE;
338 return cp;
341 static struct name *
342 _extract1(char const *line, enum gfield ntype, char const *separators,
343 bool_t keepcomms)
345 struct name *topp, *np, *t;
346 char const *cp;
347 char *nbuf;
348 NYD_ENTER;
350 topp = NULL;
351 if (line == NULL || *line == '\0')
352 goto jleave;
354 np = NULL;
355 cp = line;
356 nbuf = smalloc(strlen(line) +1);
357 while ((cp = yankname(cp, nbuf, separators, keepcomms)) != NULL) {
358 t = nalloc(nbuf, ntype);
359 if (topp == NULL)
360 topp = t;
361 else
362 np->n_flink = t;
363 t->n_blink = np;
364 np = t;
366 free(nbuf);
367 jleave:
368 NYD_LEAVE;
369 return topp;
372 static struct name *
373 _gexpand(size_t level, struct name *nlist, struct group *gp, bool_t metoo,
374 int ntype)
376 struct grp_names_head *gnhp;
377 struct grp_names *gnp;
378 NYD_ENTER;
380 if (UICMP(z, level++, >, MAXEXP)) {
381 n_err(_("Expanding alias to depth larger than %d\n"), MAXEXP);
382 goto jleave;
385 GP_TO_SUBCLASS(gnhp, gp);
386 for (gnp = gnhp->gnh_head; gnp != NULL; gnp = gnp->gn_next) {
387 char *cp;
388 struct group *ngp;
390 /* FIXME we do not really support leading backslash quoting do we??? */
391 if (*(cp = gnp->gn_id) == '\\' || !strcmp(cp, gp->g_id))
392 goto jquote;
394 if ((ngp = _group_find(GT_ALIAS, cp)) != NULL) {
395 /* For S-nail(1), the "alias" may *be* the sender in that a name maps
396 * to a full address specification; aliases cannot be empty */
397 struct grp_names_head *ngnhp;
398 GP_TO_SUBCLASS(ngnhp, ngp);
400 assert(ngnhp->gnh_head != NULL);
401 if (metoo || ngnhp->gnh_head->gn_next != NULL ||
402 !_same_name(cp, myname))
403 nlist = _gexpand(level, nlist, ngp, metoo, ntype);
404 continue;
407 /* Here we should allow to expand to itself if only person in alias */
408 jquote:
409 if (metoo || gnhp->gnh_head->gn_next == NULL || !_same_name(cp, myname))
410 nlist = put(nlist, nalloc(cp, ntype | GFULL));
412 jleave:
413 NYD_LEAVE;
414 return nlist;
417 static struct group *
418 _group_lookup(enum group_type gt, struct group_lookup *glp, char const *id)
420 struct group *lgp, *gp;
421 NYD_ENTER;
423 gt &= GT_MASK;
424 lgp = NULL;
425 gp = *(glp->gl_htable = glp->gl_slot =
426 ((gt & GT_ALIAS ? _alias_heads :
427 (gt & GT_MLIST ? _mlist_heads :
428 (gt & GT_SHORTCUT ? _shortcut_heads : _customhdr_heads))) +
429 torek_hash(id) % HSHSIZE));
431 for (; gp != NULL; lgp = gp, gp = gp->g_next)
432 if ((gp->g_type & gt) && *gp->g_id == *id && !strcmp(gp->g_id, id))
433 break;
435 glp->gl_slot_last = lgp;
436 glp->gl_group = gp;
437 NYD_LEAVE;
438 return gp;
441 static struct group *
442 _group_find(enum group_type gt, char const *id)
444 struct group_lookup gl;
445 struct group *gp;
446 NYD_ENTER;
448 gp = _group_lookup(gt, &gl, id);
449 NYD_LEAVE;
450 return gp;
453 static struct group *
454 _group_go_first(enum group_type gt, struct group_lookup *glp)
456 struct group **gpa, *gp;
457 size_t i;
458 NYD_ENTER;
460 for (glp->gl_htable = gpa = (gt & GT_ALIAS ? _alias_heads :
461 (gt & GT_MLIST ? _mlist_heads :
462 (gt & GT_SHORTCUT ? _shortcut_heads : _customhdr_heads))), i = 0;
463 i < HSHSIZE; ++gpa, ++i)
464 if ((gp = *gpa) != NULL) {
465 glp->gl_slot = gpa;
466 glp->gl_group = gp;
467 goto jleave;
470 glp->gl_group = gp = NULL;
471 jleave:
472 glp->gl_slot_last = NULL;
473 NYD_LEAVE;
474 return gp;
477 static struct group *
478 _group_go_next(struct group_lookup *glp)
480 struct group *gp, **gpa;
481 NYD_ENTER;
483 if ((gp = glp->gl_group->g_next) != NULL)
484 glp->gl_slot_last = glp->gl_group;
485 else {
486 glp->gl_slot_last = NULL;
487 for (gpa = glp->gl_htable + HSHSIZE; ++glp->gl_slot < gpa;)
488 if ((gp = *glp->gl_slot) != NULL)
489 break;
491 glp->gl_group = gp;
492 NYD_LEAVE;
493 return gp;
496 static struct group *
497 _group_fetch(enum group_type gt, char const *id, size_t addsz)
499 struct group_lookup gl;
500 struct group *gp;
501 size_t l, i;
502 NYD_ENTER;
504 if ((gp = _group_lookup(gt, &gl, id)) != NULL)
505 goto jleave;
507 l = strlen(id) +1;
508 i = n_ALIGN(sizeof(*gp) - VFIELD_SIZEOF(struct group, g_id) + l);
509 switch (gt & GT_MASK) {
510 case GT_ALIAS:
511 addsz = sizeof(struct grp_names_head);
512 break;
513 case GT_MLIST:
514 #ifdef HAVE_REGEX
515 if (is_maybe_regex(id)) {
516 addsz = sizeof(struct grp_regex);
517 gt |= GT_REGEX;
518 } else
519 #endif
520 case GT_SHORTCUT:
521 default:
522 break;
525 gp = smalloc(i + addsz);
526 gp->g_subclass_off = i;
527 gp->g_type = gt;
528 memcpy(gp->g_id, id, l);
530 if (gt & GT_ALIAS) {
531 struct grp_names_head *gnhp;
532 GP_TO_SUBCLASS(gnhp, gp);
533 gnhp->gnh_head = NULL;
535 #ifdef HAVE_REGEX
536 else if (/*(gt & GT_MLIST) &&*/ gt & GT_REGEX) {
537 struct grp_regex *grp;
538 GP_TO_SUBCLASS(grp, gp);
540 if (regcomp(&grp->gr_regex, id, REG_EXTENDED | REG_ICASE | REG_NOSUB)) {
541 n_err(_("Invalid regular expression: %s\n"), id);
542 free(gp);
543 gp = NULL;
544 goto jleave;
546 grp->gr_mygroup = gp;
547 _mlmux_linkin(gp);
549 #endif
551 gp->g_next = *gl.gl_slot;
552 *gl.gl_slot = gp;
553 jleave:
554 NYD_LEAVE;
555 return gp;
558 static bool_t
559 _group_del(enum group_type gt, char const *id)
561 enum group_type xgt = gt & GT_MASK;
562 struct group_lookup gl;
563 struct group *gp;
564 NYD_ENTER;
566 /* Delete 'em all? */
567 if (id[0] == '*' && id[1] == '\0') {
568 for (gp = _group_go_first(gt, &gl); gp != NULL;)
569 gp = (gp->g_type & xgt) ? __group_del(&gl) : _group_go_next(&gl);
570 gp = (struct group*)TRU1;
571 } else if ((gp = _group_lookup(gt, &gl, id)) != NULL) {
572 if (gp->g_type & xgt)
573 __group_del(&gl);
574 else
575 gp = NULL;
577 NYD_LEAVE;
578 return (gp != NULL);
581 static struct group *
582 __group_del(struct group_lookup *glp)
584 struct group *x, *gp;
585 NYD_ENTER;
587 /* Overly complicated: link off this node, step ahead to next.. */
588 x = glp->gl_group;
589 if ((gp = glp->gl_slot_last) != NULL) {
590 gp = (gp->g_next = x->g_next);
591 } else {
592 glp->gl_slot_last = NULL;
593 gp = (*glp->gl_slot = x->g_next);
595 if (gp == NULL) {
596 struct group **gpa = glp->gl_htable + HSHSIZE;
598 while (++glp->gl_slot < gpa)
599 if ((gp = *glp->gl_slot) != NULL)
600 break;
603 glp->gl_group = gp;
605 if (x->g_type & GT_ALIAS)
606 __names_del(x);
607 #ifdef HAVE_REGEX
608 else if (/*(x->g_type & GT_MLIST) &&*/ x->g_type & GT_REGEX) {
609 struct grp_regex *grp;
610 GP_TO_SUBCLASS(grp, x);
612 regfree(&grp->gr_regex);
613 _mlmux_linkout(x);
615 #endif
617 free(x);
618 NYD_LEAVE;
619 return gp;
622 static void
623 __names_del(struct group *gp)
625 struct grp_names_head *gnhp;
626 struct grp_names *gnp;
627 NYD_ENTER;
629 GP_TO_SUBCLASS(gnhp, gp);
630 for (gnp = gnhp->gnh_head; gnp != NULL;) {
631 struct grp_names *x = gnp;
632 gnp = gnp->gn_next;
633 free(x);
635 NYD_LEAVE;
638 static void
639 _group_print_all(enum group_type gt)
641 enum group_type xgt;
642 struct group **gpa;
643 struct group const *gp;
644 ui32_t h, i;
645 char const **ida;
646 FILE *fp;
647 size_t lines;
648 NYD_ENTER;
650 xgt = gt & GT_PRINT_MASK;
651 gpa = (xgt & GT_ALIAS ? _alias_heads
652 : (xgt & GT_MLIST ? _mlist_heads
653 : (xgt & GT_SHORTCUT ? _shortcut_heads : _customhdr_heads)));
655 for (h = 0, i = 1; h < HSHSIZE; ++h)
656 for (gp = gpa[h]; gp != NULL; gp = gp->g_next)
657 if ((gp->g_type & xgt) == xgt)
658 ++i;
659 ida = salloc(i * sizeof *ida);
661 for (i = h = 0; h < HSHSIZE; ++h)
662 for (gp = gpa[h]; gp != NULL; gp = gp->g_next)
663 if ((gp->g_type & xgt) == xgt)
664 ida[i++] = gp->g_id;
665 ida[i] = NULL;
667 if (i > 1)
668 qsort(ida, i, sizeof *ida, &__group_print_qsorter);
670 if ((fp = Ftmp(NULL, "prgroup", OF_RDWR | OF_UNLINK | OF_REGISTER)) == NULL)
671 fp = stdout;
672 lines = 0;
674 for (i = 0; ida[i] != NULL; ++i)
675 lines += _group_print(_group_find(gt, ida[i]), fp);
676 #ifdef HAVE_REGEX
677 if (gt & GT_MLIST) {
678 if (gt & GT_SUBSCRIBE)
679 i = (ui32_t)_mlsub_size, h = (ui32_t)_mlsub_hits;
680 else
681 i = (ui32_t)_mlist_size, h = (ui32_t)_mlist_hits;
682 if (i > 0 && (options & OPT_D_V)){
683 fprintf(fp, _("# %s list regex(7) total: %u entries, %u hits\n"),
684 (gt & GT_SUBSCRIBE ? _("Subscribed") : _("Non-subscribed")),
685 i, h);
686 ++lines;
689 #endif
691 if (fp != stdout) {
692 page_or_print(fp, lines);
693 Fclose(fp);
695 NYD_LEAVE;
698 static int
699 __group_print_qsorter(void const *a, void const *b)
701 int rv;
702 NYD_ENTER;
704 rv = strcmp(*(char**)UNCONST(a), *(char**)UNCONST(b));
705 NYD_LEAVE;
706 return rv;
709 static size_t
710 _group_print(struct group const *gp, FILE *fo)
712 char const *cp;
713 size_t rv;
714 NYD_ENTER;
716 rv = 1;
718 if (gp->g_type & GT_ALIAS) {
719 struct grp_names_head *gnhp;
720 struct grp_names *gnp;
722 fprintf(fo, "alias %s", gp->g_id);
724 GP_TO_SUBCLASS(gnhp, gp);
725 if ((gnp = gnhp->gnh_head) != NULL) { /* xxx always 1+ entries */
726 do {
727 struct grp_names *x = gnp;
728 gnp = gnp->gn_next;
729 fprintf(fo, " \"%s\"", string_quote(x->gn_id)); /* TODO shexp */
730 } while (gnp != NULL);
732 } else if (gp->g_type & GT_MLIST) {
733 #ifdef HAVE_REGEX
734 if ((gp->g_type & GT_REGEX) && (options & OPT_D_V)){
735 size_t i;
736 struct grp_regex *grp,
737 *lp = (gp->g_type & GT_SUBSCRIBE ? _mlsub_regex : _mlist_regex);
739 GP_TO_SUBCLASS(grp, gp);
740 for (i = 1; lp != grp; lp = lp->gr_next)
741 ++i;
742 fprintf(fo, "# regex(7): hits %" PRIuZ ", sort %" PRIuZ ".\n ",
743 grp->gr_hits, i);
744 ++rv;
746 #endif
748 fprintf(fo, "wysh %s %s",
749 (gp->g_type & GT_SUBSCRIBE ? "mlsubscribe" : "mlist"),
750 n_shexp_quote_cp(gp->g_id, TRU1));
751 } else if (gp->g_type & GT_SHORTCUT) {
752 GP_TO_SUBCLASS(cp, gp);
753 fprintf(fo, "wysh shortcut %s %s", gp->g_id, n_shexp_quote_cp(cp, TRU1));
754 } else if (gp->g_type & GT_CUSTOMHDR) {
755 GP_TO_SUBCLASS(cp, gp);
756 fprintf(fo, "customhdr %s %s", gp->g_id, n_shexp_quote_cp(cp, TRU1));
759 putc('\n', fo);
760 NYD_LEAVE;
761 return rv;
764 static int
765 _mlmux(enum group_type gt, char **argv)
767 struct group *gp;
768 int rv = 0;
769 NYD_ENTER;
771 if (*argv == NULL)
772 _group_print_all(gt);
773 else do {
774 if ((gp = _group_find(gt, *argv)) != NULL) {
775 if (gt & GT_SUBSCRIBE) {
776 if (!(gp->g_type & GT_SUBSCRIBE)) {
777 _MLMUX_LINKOUT(gp);
778 gp->g_type |= GT_SUBSCRIBE;
779 _MLMUX_LINKIN(gp);
780 } else {
781 n_err(_("Mailing-list already `mlsubscribe'd: %s\n"),
782 *argv);
783 rv = 1;
785 } else {
786 n_err(_("Mailing-list already `mlist'ed: %s\n"), *argv);
787 rv = 1;
789 } else
790 _group_fetch(gt, *argv, 0);
791 } while (*++argv != NULL);
793 NYD_LEAVE;
794 return rv;
797 static int
798 _unmlmux(enum group_type gt, char **argv)
800 struct group *gp;
801 int rv = 0;
802 NYD_ENTER;
804 for (; *argv != NULL; ++argv) {
805 if (gt & GT_SUBSCRIBE) {
806 struct group_lookup gl;
807 bool_t isaster;
809 if (!(isaster = (**argv == '*')))
810 gp = _group_find(gt, *argv);
811 else if ((gp = _group_go_first(gt, &gl)) == NULL)
812 continue;
813 else if (gp != NULL && !(gp->g_type & GT_SUBSCRIBE))
814 goto jaster_entry;
816 if (gp != NULL) {
817 jaster_redo:
818 if (gp->g_type & GT_SUBSCRIBE) {
819 _MLMUX_LINKOUT(gp);
820 gp->g_type &= ~GT_SUBSCRIBE;
821 _MLMUX_LINKIN(gp);
822 if (isaster) {
823 jaster_entry:
824 while ((gp = _group_go_next(&gl)) != NULL &&
825 !(gp->g_type & GT_SUBSCRIBE))
827 if (gp != NULL)
828 goto jaster_redo;
830 } else {
831 n_err(_("Mailing-list not `mlsubscribe'd: %s\n"),
832 n_shexp_quote_cp(*argv, FAL0));
833 rv = 1;
835 continue;
837 } else if (_group_del(gt, *argv))
838 continue;
839 n_err(_("No such mailing-list: %s\n"), n_shexp_quote_cp(*argv, FAL0));
840 rv = 1;
842 NYD_LEAVE;
843 return rv;
846 #ifdef HAVE_REGEX
847 static void
848 _mlmux_linkin(struct group *gp)
850 struct grp_regex **lpp, *grp, *lhp;
851 NYD_ENTER;
853 if (gp->g_type & GT_SUBSCRIBE) {
854 lpp = &_mlsub_regex;
855 ++_mlsub_size;
856 } else {
857 lpp = &_mlist_regex;
858 ++_mlist_size;
861 GP_TO_SUBCLASS(grp, gp);
862 if ((lhp = *lpp) != NULL) {
863 (grp->gr_last = lhp->gr_last)->gr_next = grp;
864 (grp->gr_next = lhp)->gr_last = grp;
865 } else
866 *lpp = grp->gr_last = grp->gr_next = grp;
867 grp->gr_hits = 0;
868 NYD_LEAVE;
871 static void
872 _mlmux_linkout(struct group *gp)
874 struct grp_regex *grp, **lpp;
875 NYD_ENTER;
877 GP_TO_SUBCLASS(grp, gp);
879 if (gp->g_type & GT_SUBSCRIBE) {
880 lpp = &_mlsub_regex;
881 --_mlsub_size;
882 _mlsub_hits -= grp->gr_hits;
883 } else {
884 lpp = &_mlist_regex;
885 --_mlist_size;
886 _mlist_hits -= grp->gr_hits;
889 if (grp->gr_next == grp)
890 *lpp = NULL;
891 else {
892 (grp->gr_last->gr_next = grp->gr_next)->gr_last = grp->gr_last;
893 if (*lpp == grp)
894 *lpp = grp->gr_next;
896 NYD_LEAVE;
898 #endif /* HAVE_REGEX */
900 static char *
901 a_nag_custom_sep(char **iolist){
902 char *cp, c, *base;
903 bool_t isesc, anyesc;
904 NYD2_ENTER;
906 for(base = *iolist; base != NULL; base = *iolist){
907 while((c = *base) != '\0' && blankspacechar(c))
908 ++base;
910 for(isesc = anyesc = FAL0, cp = base;; ++cp){
911 if(UNLIKELY((c = *cp) == '\0')){
912 *iolist = NULL;
913 break;
914 }else if(!isesc){
915 if(c == ','){
916 *iolist = cp + 1;
917 break;
919 isesc = (c == '\\');
920 }else{
921 isesc = FAL0;
922 anyesc |= (c == ',');
926 while(cp > base && blankspacechar(cp[-1]))
927 --cp;
928 *cp = '\0';
930 if(*base != '\0'){
931 if(anyesc){
932 char *ins;
934 for(ins = cp = base;; ++ins)
935 if((c = *cp) == '\\' && cp[1] == ','){
936 *ins = ',';
937 cp += 2;
938 }else if((*ins = (++cp, c)) == '\0')
939 break;
941 break;
944 NYD2_LEAVE;
945 return base;
948 FL struct name *
949 nalloc(char const *str, enum gfield ntype)
951 struct addrguts ag;
952 struct str in, out;
953 struct name *np;
954 NYD_ENTER;
955 assert(!(ntype & GFULLEXTRA) || (ntype & GFULL) != 0);
957 addrspec_with_guts(((ntype & (GFULL | GSKIN | GREF)) != 0), str, &ag);
958 if (!(ag.ag_n_flags & NAME_NAME_SALLOC)) {
959 ag.ag_n_flags |= NAME_NAME_SALLOC;
960 np = salloc(sizeof(*np) + ag.ag_slen +1);
961 memcpy(np + 1, ag.ag_skinned, ag.ag_slen +1);
962 ag.ag_skinned = (char*)(np + 1);
963 } else
964 np = salloc(sizeof *np);
966 np->n_flink = NULL;
967 np->n_blink = NULL;
968 np->n_type = ntype;
969 np->n_flags = 0;
971 np->n_fullname = np->n_name = ag.ag_skinned;
972 np->n_fullextra = NULL;
973 np->n_flags = ag.ag_n_flags;
975 if (ntype & GFULL) {
976 if (ag.ag_ilen == ag.ag_slen
977 #ifdef HAVE_IDNA
978 && !(ag.ag_n_flags & NAME_IDNA)
979 #endif
981 goto jleave;
982 if (ag.ag_n_flags & NAME_ADDRSPEC_ISFILEORPIPE)
983 goto jleave;
985 /* n_fullextra is only the complete name part without address.
986 * Beware of "-r '<abc@def>'", don't treat that as FULLEXTRA */
987 if ((ntype & GFULLEXTRA) && ag.ag_ilen > ag.ag_slen + 2) {
988 size_t s = ag.ag_iaddr_start, e = ag.ag_iaddr_aend, i;
989 char const *cp;
991 if (s == 0 || str[--s] != '<' || str[e++] != '>')
992 goto jskipfullextra;
993 i = ag.ag_ilen - e;
994 in.s = ac_alloc(s + i +1);
995 memcpy(in.s, str, s);
996 if (i > 0)
997 memcpy(in.s + s, str + e, i);
998 s += i;
999 in.s[in.l = s] = '\0';
1000 mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
1002 for (cp = out.s, i = out.l; i > 0 && spacechar(*cp); --i, ++cp)
1004 while (i > 0 && spacechar(cp[i - 1]))
1005 --i;
1006 np->n_fullextra = savestrbuf(cp, i);
1008 free(out.s);
1009 ac_free(in.s);
1011 jskipfullextra:
1013 /* n_fullname depends on IDNA conversion */
1014 #ifdef HAVE_IDNA
1015 if (!(ag.ag_n_flags & NAME_IDNA)) {
1016 #endif
1017 in.s = UNCONST(str);
1018 in.l = ag.ag_ilen;
1019 #ifdef HAVE_IDNA
1020 } else {
1021 /* The domain name was IDNA and has been converted. We also have to
1022 * ensure that the domain name in .n_fullname is replaced with the
1023 * converted version, since MIME doesn't perform encoding of addrs */
1024 size_t l = ag.ag_iaddr_start,
1025 lsuff = ag.ag_ilen - ag.ag_iaddr_aend;
1026 in.s = ac_alloc(l + ag.ag_slen + lsuff +1);
1027 memcpy(in.s, str, l);
1028 memcpy(in.s + l, ag.ag_skinned, ag.ag_slen);
1029 l += ag.ag_slen;
1030 memcpy(in.s + l, str + ag.ag_iaddr_aend, lsuff);
1031 l += lsuff;
1032 in.s[l] = '\0';
1033 in.l = l;
1035 #endif
1036 mime_fromhdr(&in, &out, TD_ISPR | TD_ICONV);
1037 np->n_fullname = savestr(out.s);
1038 free(out.s);
1039 #ifdef HAVE_IDNA
1040 if (ag.ag_n_flags & NAME_IDNA)
1041 ac_free(in.s);
1042 #endif
1043 np->n_flags |= NAME_FULLNAME_SALLOC;
1045 jleave:
1046 NYD_LEAVE;
1047 return np;
1050 FL struct name *
1051 ndup(struct name *np, enum gfield ntype)
1053 struct name *nnp;
1054 NYD_ENTER;
1056 if ((ntype & (GFULL | GSKIN)) && !(np->n_flags & NAME_SKINNED)) {
1057 nnp = nalloc(np->n_name, ntype);
1058 goto jleave;
1061 nnp = salloc(sizeof *np);
1062 nnp->n_flink = nnp->n_blink = NULL;
1063 nnp->n_type = ntype;
1064 nnp->n_flags = (np->n_flags & ~(NAME_NAME_SALLOC | NAME_FULLNAME_SALLOC)) |
1065 NAME_NAME_SALLOC;
1066 nnp->n_name = savestr(np->n_name);
1067 if (np->n_name == np->n_fullname || !(ntype & (GFULL | GSKIN))) {
1068 nnp->n_fullname = nnp->n_name;
1069 nnp->n_fullextra = NULL;
1070 } else {
1071 nnp->n_flags |= NAME_FULLNAME_SALLOC;
1072 nnp->n_fullname = savestr(np->n_fullname);
1073 nnp->n_fullextra = (np->n_fullextra == NULL) ? NULL
1074 : savestr(np->n_fullextra);
1076 jleave:
1077 NYD_LEAVE;
1078 return nnp;
1081 FL struct name *
1082 cat(struct name *n1, struct name *n2)
1084 struct name *tail;
1085 NYD_ENTER;
1087 tail = n2;
1088 if (n1 == NULL)
1089 goto jleave;
1090 tail = n1;
1091 if (n2 == NULL)
1092 goto jleave;
1094 while (tail->n_flink != NULL)
1095 tail = tail->n_flink;
1096 tail->n_flink = n2;
1097 n2->n_blink = tail;
1098 tail = n1;
1099 jleave:
1100 NYD_LEAVE;
1101 return tail;
1104 FL struct name *
1105 namelist_dup(struct name const *np, enum gfield ntype)
1107 struct name *nnp;
1108 NYD_ENTER;
1110 for (nnp = NULL; np != NULL; np = np->n_flink) {
1111 struct name *x = ndup(UNCONST(np), (np->n_type & ~GMASK) | ntype);
1112 x->n_flink = nnp;
1113 nnp = x;
1115 NYD_LEAVE;
1116 return nnp;
1119 FL ui32_t
1120 count(struct name const *np)
1122 ui32_t c;
1123 NYD_ENTER;
1125 for (c = 0; np != NULL; np = np->n_flink)
1126 if (!(np->n_type & GDEL))
1127 ++c;
1128 NYD_LEAVE;
1129 return c;
1132 FL ui32_t
1133 count_nonlocal(struct name const *np)
1135 ui32_t c;
1136 NYD_ENTER;
1138 for (c = 0; np != NULL; np = np->n_flink)
1139 if (!(np->n_type & GDEL) && !(np->n_flags & NAME_ADDRSPEC_ISFILEORPIPE))
1140 ++c;
1141 NYD_LEAVE;
1142 return c;
1145 FL struct name *
1146 extract(char const *line, enum gfield ntype)
1148 struct name *rv;
1149 NYD_ENTER;
1151 rv = _extract1(line, ntype, " \t,", 0);
1152 NYD_LEAVE;
1153 return rv;
1156 FL struct name *
1157 lextract(char const *line, enum gfield ntype)
1159 struct name *rv;
1160 NYD_ENTER;
1162 rv = ((line != NULL && strpbrk(line, ",\"\\(<|"))
1163 ? _extract1(line, ntype, ",", 1) : extract(line, ntype));
1164 NYD_LEAVE;
1165 return rv;
1168 FL char *
1169 detract(struct name *np, enum gfield ntype)
1171 char *topp, *cp;
1172 struct name *p;
1173 int flags, s;
1174 NYD_ENTER;
1176 topp = NULL;
1177 if (np == NULL)
1178 goto jleave;
1180 flags = ntype & (GCOMMA | GNAMEONLY);
1181 ntype &= ~(GCOMMA | GNAMEONLY);
1182 s = 0;
1184 for (p = np; p != NULL; p = p->n_flink) {
1185 if (ntype && (p->n_type & GMASK) != ntype)
1186 continue;
1187 s += strlen(flags & GNAMEONLY ? p->n_name : p->n_fullname) +1;
1188 if (flags & GCOMMA)
1189 ++s;
1191 if (s == 0)
1192 goto jleave;
1194 s += 2;
1195 topp = salloc(s);
1196 cp = topp;
1197 for (p = np; p != NULL; p = p->n_flink) {
1198 if (ntype && (p->n_type & GMASK) != ntype)
1199 continue;
1200 cp = sstpcpy(cp, (flags & GNAMEONLY ? p->n_name : p->n_fullname));
1201 if ((flags & GCOMMA) && p->n_flink != NULL)
1202 *cp++ = ',';
1203 *cp++ = ' ';
1205 *--cp = 0;
1206 if ((flags & GCOMMA) && *--cp == ',')
1207 *cp = 0;
1208 jleave:
1209 NYD_LEAVE;
1210 return topp;
1213 FL struct name *
1214 grab_names(enum n_lexinput_flags lif, char const *field, struct name *np,
1215 int comma, enum gfield gflags)
1217 struct name *nq;
1218 NYD_ENTER;
1220 jloop:
1221 np = lextract(n_lex_input_cp(lif, field, detract(np, comma)), gflags);
1222 for (nq = np; nq != NULL; nq = nq->n_flink)
1223 if (is_addr_invalid(nq, EACM_NONE))
1224 goto jloop;
1225 NYD_LEAVE;
1226 return np;
1229 FL bool_t
1230 name_is_same_domain(struct name const *n1, struct name const *n2)
1232 char const *d1, *d2;
1233 bool_t rv;
1234 NYD_ENTER;
1236 d1 = strrchr(n1->n_name, '@');
1237 d2 = strrchr(n2->n_name, '@');
1239 rv = (d1 != NULL && d2 != NULL) ? !asccasecmp(++d1, ++d2) : FAL0;
1241 NYD_LEAVE;
1242 return rv;
1245 FL struct name *
1246 checkaddrs(struct name *np, enum expand_addr_check_mode eacm,
1247 si8_t *set_on_error)
1249 struct name *n;
1250 NYD_ENTER;
1252 for (n = np; n != NULL;) {
1253 si8_t rv;
1255 if ((rv = is_addr_invalid(n, eacm)) != 0) {
1256 if (set_on_error != NULL)
1257 *set_on_error |= rv; /* don't loose -1! */
1258 if (n->n_blink)
1259 n->n_blink->n_flink = n->n_flink;
1260 if (n->n_flink)
1261 n->n_flink->n_blink = n->n_blink;
1262 if (n == np)
1263 np = n->n_flink;
1265 n = n->n_flink;
1267 NYD_LEAVE;
1268 return np;
1271 FL struct name *
1272 namelist_vaporise_head(struct header *hp, enum expand_addr_check_mode eacm,
1273 bool_t metoo, si8_t *set_on_error)
1275 struct name *tolist, *np, **npp;
1276 NYD_ENTER;
1278 tolist = usermap(cat(hp->h_to, cat(hp->h_cc, hp->h_bcc)), metoo);
1279 hp->h_to = hp->h_cc = hp->h_bcc = NULL;
1281 tolist = elide(checkaddrs(tolist, eacm, set_on_error));
1283 for (np = tolist; np != NULL; np = np->n_flink) {
1284 switch (np->n_type & (GDEL | GMASK)) {
1285 case GTO: npp = &hp->h_to; break;
1286 case GCC: npp = &hp->h_cc; break;
1287 case GBCC: npp = &hp->h_bcc; break;
1288 default: continue;
1290 *npp = cat(*npp, ndup(np, np->n_type | GFULL));
1292 NYD_LEAVE;
1293 return tolist;
1296 FL struct name *
1297 usermap(struct name *names, bool_t force_metoo)
1299 struct name *new, *np, *cp;
1300 struct group *gp;
1301 int metoo;
1302 NYD_ENTER;
1304 new = NULL;
1305 np = names;
1306 metoo = (force_metoo || ok_blook(metoo));
1307 while (np != NULL) {
1308 assert(!(np->n_type & GDEL)); /* TODO legacy */
1309 if (is_fileorpipe_addr(np) || np->n_name[0] == '\\') {
1310 cp = np->n_flink;
1311 new = put(new, np);
1312 np = cp;
1313 continue;
1315 gp = _group_find(GT_ALIAS, np->n_name);
1316 cp = np->n_flink;
1317 if (gp != NULL)
1318 new = _gexpand(0, new, gp, metoo, np->n_type);
1319 else
1320 new = put(new, np);
1321 np = cp;
1323 NYD_LEAVE;
1324 return new;
1327 FL struct name *
1328 elide(struct name *names)
1330 struct name *np, *t, *newn, *x;
1331 NYD_ENTER;
1333 newn = NULL;
1334 if (names == NULL)
1335 goto jleave;
1337 /* Throw away all deleted nodes (XXX merge with plain sort below?) */
1338 for (np = NULL; names != NULL; names = names->n_flink)
1339 if (!(names->n_type & GDEL)) {
1340 names->n_blink = np;
1341 if (np)
1342 np->n_flink = names;
1343 else
1344 newn = names;
1345 np = names;
1347 if (newn == NULL)
1348 goto jleave;
1350 np = newn->n_flink;
1351 if (np != NULL)
1352 np->n_blink = NULL;
1353 newn->n_flink = NULL;
1355 while (np != NULL) {
1356 int cmpres;
1358 t = newn;
1359 while ((cmpres = asccasecmp(t->n_name, np->n_name)) < 0) {
1360 if (t->n_flink == NULL)
1361 break;
1362 t = t->n_flink;
1365 /* If we ran out of t's, put new entry after the current value of t */
1366 if (cmpres < 0) {
1367 t->n_flink = np;
1368 np->n_blink = t;
1369 t = np;
1370 np = np->n_flink;
1371 t->n_flink = NULL;
1372 continue;
1375 /* Otherwise, put the new entry in front of the current t. If at the
1376 * front of the list, the new guy becomes the new head of the list */
1377 if (t == newn) {
1378 t = np;
1379 np = np->n_flink;
1380 t->n_flink = newn;
1381 newn->n_blink = t;
1382 t->n_blink = NULL;
1383 newn = t;
1384 continue;
1387 /* The normal case -- we are inserting into the middle of the list */
1388 x = np;
1389 np = np->n_flink;
1390 x->n_flink = t;
1391 x->n_blink = t->n_blink;
1392 t->n_blink->n_flink = x;
1393 t->n_blink = x;
1396 /* Now the list headed up by new is sorted. Remove duplicates */
1397 np = newn;
1398 while (np != NULL) {
1399 t = np;
1400 while (t->n_flink != NULL && !asccasecmp(np->n_name, t->n_flink->n_name))
1401 t = t->n_flink;
1402 if (t == np) {
1403 np = np->n_flink;
1404 continue;
1407 /* Now t points to the last entry with the same name as np.
1408 * Make np point beyond t */
1409 np->n_flink = t->n_flink;
1410 if (t->n_flink != NULL)
1411 t->n_flink->n_blink = np;
1412 np = np->n_flink;
1414 jleave:
1415 NYD_LEAVE;
1416 return newn;
1419 FL int
1420 c_alternates(void *v)
1422 size_t l;
1423 char **namelist = v, **ap, **ap2, *cp;
1424 NYD_ENTER;
1426 for (namelist = v, l = 0; namelist[l] != NULL; ++l)
1429 if (l == 0) {
1430 if (_altnames != NULL) {
1431 printf("alternates ");
1432 for (ap = _altnames; *ap != NULL; ++ap)
1433 printf("%s ", *ap);
1434 printf("\n");
1436 goto jleave;
1439 if (_altnames != NULL) {
1440 for (ap = _altnames; *ap != NULL; ++ap)
1441 free(*ap);
1442 free(_altnames);
1445 ++l;
1446 _altnames = smalloc(l * sizeof(*_altnames));
1447 for (ap = namelist, ap2 = _altnames; *ap != NULL; ++ap, ++ap2) {
1448 l = strlen(*ap) +1;
1449 cp = smalloc(l);
1450 memcpy(cp, *ap, l);
1451 *ap2 = cp;
1453 *ap2 = NULL;
1454 jleave:
1455 NYD_LEAVE;
1456 return 0;
1459 FL struct name *
1460 delete_alternates(struct name *np)
1462 struct name *xp;
1463 char **ap;
1464 NYD_ENTER;
1466 np = delname(np, myname);
1467 if (_altnames != NULL)
1468 for (ap = _altnames; *ap != '\0'; ++ap)
1469 np = delname(np, *ap);
1471 if ((xp = lextract(ok_vlook(from), GEXTRA | GSKIN)) != NULL)
1472 while (xp != NULL) {
1473 np = delname(np, xp->n_name);
1474 xp = xp->n_flink;
1477 if ((xp = lextract(ok_vlook(replyto), GEXTRA | GSKIN)) != NULL)
1478 while (xp != NULL) {
1479 np = delname(np, xp->n_name);
1480 xp = xp->n_flink;
1483 if ((xp = extract(ok_vlook(sender), GEXTRA | GSKIN)) != NULL)
1484 while (xp != NULL) {
1485 np = delname(np, xp->n_name);
1486 xp = xp->n_flink;
1488 NYD_LEAVE;
1489 return np;
1492 FL int
1493 is_myname(char const *name)
1495 int rv = 1;
1496 struct name *xp;
1497 char **ap;
1498 NYD_ENTER;
1500 if (_same_name(myname, name))
1501 goto jleave;
1502 if (_altnames != NULL)
1503 for (ap = _altnames; *ap != NULL; ++ap)
1504 if (_same_name(*ap, name))
1505 goto jleave;
1507 if ((xp = lextract(ok_vlook(from), GEXTRA | GSKIN)) != NULL)
1508 while (xp != NULL) {
1509 if (_same_name(xp->n_name, name))
1510 goto jleave;
1511 xp = xp->n_flink;
1514 if ((xp = lextract(ok_vlook(replyto), GEXTRA | GSKIN)) != NULL)
1515 while (xp != NULL) {
1516 if (_same_name(xp->n_name, name))
1517 goto jleave;
1518 xp = xp->n_flink;
1521 if ((xp = extract(ok_vlook(sender), GEXTRA | GSKIN)) != NULL)
1522 while (xp != NULL) {
1523 if (_same_name(xp->n_name, name))
1524 goto jleave;
1525 xp = xp->n_flink;
1527 rv = 0;
1528 jleave:
1529 NYD_LEAVE;
1530 return rv;
1533 FL int
1534 c_alias(void *v)
1536 char **argv = v;
1537 struct group *gp;
1538 int rv = 0;
1539 NYD_ENTER;
1541 if (*argv == NULL)
1542 _group_print_all(GT_ALIAS);
1543 else if (argv[1] == NULL) {
1544 if ((gp = _group_find(GT_ALIAS, *argv)) != NULL)
1545 _group_print(gp, stdout);
1546 else {
1547 n_err(_("No such alias: %s\n"), *argv);
1548 rv = 1;
1550 } else {
1551 struct grp_names_head *gnhp;
1553 gp = _group_fetch(GT_ALIAS, *argv, 0);
1554 GP_TO_SUBCLASS(gnhp, gp);
1556 for (++argv; *argv != NULL; ++argv) {
1557 size_t l = strlen(*argv) +1;
1558 struct grp_names *gnp = smalloc(sizeof(*gnp) -
1559 VFIELD_SIZEOF(struct grp_names, gn_id) + l);
1560 gnp->gn_next = gnhp->gnh_head;
1561 gnhp->gnh_head = gnp;
1562 memcpy(gnp->gn_id, *argv, l);
1564 assert(gnhp->gnh_head != NULL);
1566 NYD_LEAVE;
1567 return rv;
1570 FL int
1571 c_unalias(void *v)
1573 char **argv = v;
1574 int rv = 0;
1575 NYD_ENTER;
1577 do if (!_group_del(GT_ALIAS, *argv)) {
1578 n_err(_("No such alias: %s\n"), *argv);
1579 rv = 1;
1580 } while (*++argv != NULL);
1581 NYD_LEAVE;
1582 return rv;
1585 FL int
1586 c_mlist(void *v)
1588 int rv;
1589 NYD_ENTER;
1591 rv = _mlmux(GT_MLIST, v);
1592 NYD_LEAVE;
1593 return rv;
1596 FL int
1597 c_unmlist(void *v)
1599 int rv;
1600 NYD_ENTER;
1602 rv = _unmlmux(GT_MLIST, v);
1603 NYD_LEAVE;
1604 return rv;
1607 FL int
1608 c_mlsubscribe(void *v)
1610 int rv;
1611 NYD_ENTER;
1613 rv = _mlmux(GT_MLIST | GT_SUBSCRIBE, v);
1614 NYD_LEAVE;
1615 return rv;
1618 FL int
1619 c_unmlsubscribe(void *v)
1621 int rv;
1622 NYD_ENTER;
1624 rv = _unmlmux(GT_MLIST | GT_SUBSCRIBE, v);
1625 NYD_LEAVE;
1626 return rv;
1629 FL enum mlist_state
1630 is_mlist(char const *name, bool_t subscribed_only)
1632 struct group *gp;
1633 #ifdef HAVE_REGEX
1634 struct grp_regex **lpp, *grp;
1635 bool_t re2;
1636 #endif
1637 enum mlist_state rv;
1638 NYD_ENTER;
1640 gp = _group_find(GT_MLIST, name);
1641 rv = (gp != NULL) ? MLIST_KNOWN : MLIST_OTHER;
1642 if (rv == MLIST_KNOWN) {
1643 if (gp->g_type & GT_SUBSCRIBE)
1644 rv = MLIST_SUBSCRIBED;
1645 else if (subscribed_only)
1646 rv = MLIST_OTHER;
1647 /* Of course, if that is a regular expression it doesn't mean a thing */
1648 #ifdef HAVE_REGEX
1649 if (gp->g_type & GT_REGEX)
1650 rv = MLIST_OTHER;
1651 else
1652 #endif
1653 goto jleave;
1656 /* Not in the hashmap (as something matchable), walk the lists */
1657 #ifdef HAVE_REGEX
1658 re2 = FAL0;
1659 lpp = &_mlsub_regex;
1660 jregex_redo:
1661 if ((grp = *lpp) != NULL) {
1662 do if (regexec(&grp->gr_regex, name, 0,NULL, 0) != REG_NOMATCH) {
1663 /* Relink as the head of this list if the hit count of this group is
1664 * >= 25% of the average hit count */
1665 size_t i;
1666 if (!re2)
1667 i = ++_mlsub_hits / _mlsub_size;
1668 else
1669 i = ++_mlist_hits / _mlist_size;
1670 i >>= 2;
1672 if (++grp->gr_hits >= i && *lpp != grp && grp->gr_next != grp) {
1673 grp->gr_last->gr_next = grp->gr_next;
1674 grp->gr_next->gr_last = grp->gr_last;
1675 (grp->gr_last = (*lpp)->gr_last)->gr_next = grp;
1676 (grp->gr_next = *lpp)->gr_last = grp;
1677 *lpp = grp;
1679 rv = !re2 ? MLIST_SUBSCRIBED : MLIST_KNOWN;
1680 goto jleave;
1681 } while ((grp = grp->gr_next) != *lpp);
1683 if (!re2 && !subscribed_only) {
1684 re2 = TRU1;
1685 lpp = &_mlist_regex;
1686 goto jregex_redo;
1688 assert(rv == MLIST_OTHER);
1689 #endif
1691 jleave:
1692 NYD_LEAVE;
1693 return rv;
1696 FL int
1697 c_shortcut(void *v)
1699 char **argv = v;
1700 int rv = 0;
1701 NYD_ENTER;
1703 if (*argv == NULL)
1704 _group_print_all(GT_SHORTCUT);
1705 else for (; *argv != NULL; argv += 2) {
1706 /* Because one hardly ever redefines, anything is stored in one chunk */
1707 size_t l;
1708 struct group *gp;
1709 char *cp;
1711 if (argv[1] == NULL) {
1712 n_err(_("Shortcut expansion is missing: %s\n"), *argv);
1713 rv = 1;
1714 break;
1716 if (_group_find(GT_SHORTCUT, *argv) != NULL)
1717 _group_del(GT_SHORTCUT, *argv);
1719 l = strlen(argv[1]) +1;
1720 gp = _group_fetch(GT_SHORTCUT, *argv, l);
1721 GP_TO_SUBCLASS(cp, gp);
1722 memcpy(cp, argv[1], l);
1724 NYD_LEAVE;
1725 return rv;
1728 FL int
1729 c_unshortcut(void *v)
1731 char **argv = v;
1732 int rv = 0;
1733 NYD_ENTER;
1735 do if (!_group_del(GT_SHORTCUT, *argv)) {
1736 n_err(_("No such shortcut: %s\n"), *argv);
1737 rv = 1;
1738 } while (*++argv != NULL);
1739 NYD_LEAVE;
1740 return rv;
1743 FL char const *
1744 shortcut_expand(char const *str)
1746 struct group *gp;
1747 NYD_ENTER;
1749 if ((gp = _group_find(GT_SHORTCUT, str)) != NULL)
1750 GP_TO_SUBCLASS(str, gp);
1751 else
1752 str = NULL;
1753 NYD_LEAVE;
1754 return str;
1757 FL int
1758 c_customhdr(void *v){
1759 struct group *gp;
1760 char const **argv, *hcp;
1761 int rv;
1762 NYD_ENTER;
1764 rv = 0;
1766 if((hcp = *(argv = v)) == NULL){
1767 _group_print_all(GT_CUSTOMHDR);
1768 goto jleave;
1771 /* Verify the header field name */
1772 for(rv = 1;; ++hcp){
1773 if(fieldnamechar(*hcp))
1774 continue;
1775 if(*hcp == '\0'){
1776 if(hcp == *argv){
1777 n_err(_("`customhdr': no name specified\n"));
1778 goto jleave;
1780 hcp = *argv;
1781 break;
1783 n_err(_("`customhdr': invalid name: %s\n"), *argv);
1784 goto jleave;
1786 rv = 0;
1788 if(*++argv == NULL){
1789 if((gp = _group_find(GT_CUSTOMHDR, hcp)) != NULL)
1790 _group_print(gp, stdout);
1791 else{
1792 n_err(_("No such `customhdr': %s\n"), hcp);
1793 rv = 1;
1795 }else{
1796 /* Because one hardly ever redefines, anything is stored in one chunk */
1797 size_t i, l;
1798 char *cp;
1800 if(pstate & PS_WYSHLIST_SAW_CONTROL){
1801 n_err(_("`customhdr': control characters not allowed: %s: %s%s\n"),
1802 hcp, n_shexp_quote_cp(*argv, FAL0), (argv[1] != NULL ? "..." : ""));
1803 rv = 1;
1804 goto jleave;
1807 if(_group_find(GT_CUSTOMHDR, hcp) != NULL)
1808 _group_del(GT_CUSTOMHDR, hcp);
1810 for(l = i = 0; argv[i] != NULL; ++i)
1811 l += strlen(argv[i]) + 1;
1812 gp = _group_fetch(GT_CUSTOMHDR, hcp, l +1);
1813 GP_TO_SUBCLASS(cp, gp);
1814 for(i = 0; argv[i] != NULL; ++i){
1815 if(i > 0)
1816 *cp++ = ' ';
1817 l = strlen(argv[i]);
1818 memcpy(cp, argv[i], l);
1819 cp += l;
1821 *cp = '\0';
1823 jleave:
1824 NYD_LEAVE;
1825 return rv;
1828 FL int
1829 c_uncustomhdr(void *v){
1830 int rv;
1831 char **argv;
1832 NYD_ENTER;
1834 rv = 0;
1836 argv = v;
1838 if(!_group_del(GT_CUSTOMHDR, *argv)){
1839 n_err(_("No such custom header: %s\n"), *argv);
1840 rv = 1;
1842 }while(*++argv != NULL);
1843 NYD_LEAVE;
1844 return rv;
1847 FL struct n_header_field *
1848 n_customhdr_query(void){ /* XXX Uses salloc()! */
1849 struct group const *gp;
1850 ui32_t h;
1851 struct n_header_field *rv, **tail, *hfp;
1852 NYD_ENTER;
1854 rv = NULL;
1855 tail = &rv;
1857 for(h = 0; h < HSHSIZE; ++h)
1858 for(gp = _customhdr_heads[h]; gp != NULL; gp = gp->g_next){
1859 char const *cp;
1860 ui32_t nl, bl;
1862 GP_TO_SUBCLASS(cp, gp);
1863 nl = (ui32_t)strlen(gp->g_id) +1;
1864 bl = (ui32_t)strlen(cp) +1;
1866 *tail = hfp = salloc(VSTRUCT_SIZEOF(struct n_header_field, hf_dat) +
1867 nl + bl);
1868 tail = &hfp->hf_next;
1869 hfp->hf_next = NULL;
1870 hfp->hf_nl = nl - 1;
1871 hfp->hf_bl = bl - 1;
1872 memcpy(hfp->hf_dat, gp->g_id, nl);
1873 memcpy(hfp->hf_dat + nl, cp, bl);
1876 /* TODO We have no copy-on-write environments yet, and since custom headers
1877 * TODO are a perfect subject for localization, add the OBSOLETE variable
1878 * TODO *customhdr*, too */
1880 char const *vp = ok_vlook(customhdr);
1882 if(vp != NULL){
1883 char *buf = savestr(vp);
1884 jch_outer:
1885 while((vp = a_nag_custom_sep(&buf)) != NULL){
1886 ui32_t nl, bl;
1887 char const *nstart, *cp;
1889 for(nstart = cp = vp;; ++cp){
1890 if(fieldnamechar(*cp))
1891 continue;
1892 if(*cp == '\0'){
1893 if(cp == nstart){
1894 n_err(_("Invalid nameless *customhdr* entry\n"));
1895 goto jch_outer;
1897 }else if(*cp != ':' && !blankchar(*cp)){
1898 jch_badent:
1899 n_err(_("Invalid *customhdr* entry: %s\n"), vp);
1900 goto jch_outer;
1902 break;
1904 nl = (ui32_t)PTR2SIZE(cp - nstart);
1906 while(blankchar(*cp))
1907 ++cp;
1908 if(*cp++ != ':')
1909 goto jch_badent;
1910 while(blankchar(*cp))
1911 ++cp;
1912 bl = (ui32_t)strlen(cp) +1;
1914 *tail = hfp = salloc(VSTRUCT_SIZEOF(struct n_header_field, hf_dat) +
1915 nl +1 + bl);
1916 tail = &hfp->hf_next;
1917 hfp->hf_next = NULL;
1918 hfp->hf_nl = nl;
1919 hfp->hf_bl = bl - 1;
1920 memcpy(hfp->hf_dat, nstart, nl);
1921 hfp->hf_dat[nl++] = '\0';
1922 memcpy(hfp->hf_dat + nl, cp, bl);
1926 NYD_LEAVE;
1927 return rv;
1930 /* s-it-mode */