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 - 2015 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
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
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
36 #define n_FILE nam_a_grp
38 #ifndef HAVE_AMALGAMATION
43 /* Main types (bits not values for easier testing only) */
48 GT_MASK
= GT_ALIAS
| GT_MLIST
| GT_SHORTCUT
| GT_CUSTOMHDR
,
50 /* Subtype bits and flags */
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
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) \
71 union __group_subclass {void *gs_vp; char *gs_cp;} __gs__;\
72 __gs__.gs_cp = (char*)UNCONST(G) + (G)->g_subclass_off;\
76 struct grp_names_head
{
77 struct grp_names
*gnh_head
;
81 struct grp_names
*gn_next
;
82 char gn_id
[VFIELD_SIZE(0)];
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 */
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
;
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.. */
120 static struct grp_regex
*_mlist_regex
, *_mlsub_regex
;
121 static size_t _mlist_size
, _mlist_hits
, _mlsub_size
, _mlsub_hits
;
125 static struct group
*_shortcut_heads
[HSHSIZE
]; /* TODO dynamic hash */
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
,
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 */
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)
198 # define _MLMUX_LINKIN(GP)
199 # define _MLMUX_LINKOUT(GP)
202 /* TODO v15: drop *customhdr* (OR change syntax and use shell tokens) */
203 static char *a_nag_custom_sep(char **iolist
);
206 _same_name(char const *n1
, char const *n2
)
212 if (ok_blook(allnet
)) {
220 } while (c1
!= '\0' && c2
!= '\0' && c1
!= '@' && c2
!= '@');
223 rv
= !asccasecmp(n1
, n2
);
230 delname(struct name
*np
, char const *name
)
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
;
243 if (p
->n_flink
== NULL
) {
244 if (p
->n_blink
!= NULL
)
245 p
->n_blink
->n_flink
= NULL
;
248 p
->n_blink
->n_flink
= p
->n_flink
;
249 p
->n_flink
->n_blink
= p
->n_blink
;
256 put(struct name
*list
, struct name
*node
)
259 node
->n_flink
= list
;
260 node
->n_blink
= NULL
;
262 list
->n_blink
= node
;
268 yankname(char const *ap
, char *wbuf
, char const *separators
, int keepcomms
)
271 char *wp
, c
, inquote
, lc
, lastsp
;
276 /* Skip over intermediate list trash, as in ".org> , <xy@zz.org>" */
277 for (c
= *ap
; blankchar(c
) || c
== ','; c
= *++ap
)
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) */
291 for (inquote
= lc
= lastsp
= 0;; lc
= c
, ++cp
) {
302 #if 0 /* TODO when doing real RFC 5322 parsers - why have i done this? */
308 if (inquote
|| lc
== '\\') {
316 cp
= skip_comment(cp
+ 1);
324 if (strchr(separators
, c
) != NULL
)
328 lastsp
= blankchar(c
);
342 _extract1(char const *line
, enum gfield ntype
, char const *separators
,
345 struct name
*topp
, *np
, *t
;
351 if (line
== NULL
|| *line
== '\0')
356 nbuf
= smalloc(strlen(line
) +1);
357 while ((cp
= yankname(cp
, nbuf
, separators
, keepcomms
)) != NULL
) {
358 t
= nalloc(nbuf
, ntype
);
373 _gexpand(size_t level
, struct name
*nlist
, struct group
*gp
, bool_t metoo
,
376 struct grp_names_head
*gnhp
;
377 struct grp_names
*gnp
;
380 if (UICMP(z
, level
++, >, MAXEXP
)) {
381 n_err(_("Expanding alias to depth larger than %d\n"), MAXEXP
);
385 GP_TO_SUBCLASS(gnhp
, gp
);
386 for (gnp
= gnhp
->gnh_head
; gnp
!= NULL
; gnp
= gnp
->gn_next
) {
390 /* FIXME we do not really support leading backslash quoting do we??? */
391 if (*(cp
= gnp
->gn_id
) == '\\' || !strcmp(cp
, gp
->g_id
))
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
);
407 /* Here we should allow to expand to itself if only person in alias */
409 if (metoo
|| gnhp
->gnh_head
->gn_next
== NULL
|| !_same_name(cp
, myname
))
410 nlist
= put(nlist
, nalloc(cp
, ntype
| GFULL
));
417 static struct group
*
418 _group_lookup(enum group_type gt
, struct group_lookup
*glp
, char const *id
)
420 struct group
*lgp
, *gp
;
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
))
435 glp
->gl_slot_last
= lgp
;
441 static struct group
*
442 _group_find(enum group_type gt
, char const *id
)
444 struct group_lookup gl
;
448 gp
= _group_lookup(gt
, &gl
, id
);
453 static struct group
*
454 _group_go_first(enum group_type gt
, struct group_lookup
*glp
)
456 struct group
**gpa
, *gp
;
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
) {
470 glp
->gl_group
= gp
= NULL
;
472 glp
->gl_slot_last
= NULL
;
477 static struct group
*
478 _group_go_next(struct group_lookup
*glp
)
480 struct group
*gp
, **gpa
;
483 if ((gp
= glp
->gl_group
->g_next
) != NULL
)
484 glp
->gl_slot_last
= glp
->gl_group
;
486 glp
->gl_slot_last
= NULL
;
487 for (gpa
= glp
->gl_htable
+ HSHSIZE
; ++glp
->gl_slot
< gpa
;)
488 if ((gp
= *glp
->gl_slot
) != NULL
)
496 static struct group
*
497 _group_fetch(enum group_type gt
, char const *id
, size_t addsz
)
499 struct group_lookup gl
;
504 if ((gp
= _group_lookup(gt
, &gl
, id
)) != NULL
)
508 i
= n_ALIGN(sizeof(*gp
) - VFIELD_SIZEOF(struct group
, g_id
) + l
);
509 switch (gt
& GT_MASK
) {
511 addsz
= sizeof(struct grp_names_head
);
515 if (is_maybe_regex(id
)) {
516 addsz
= sizeof(struct grp_regex
);
525 gp
= smalloc(i
+ addsz
);
526 gp
->g_subclass_off
= i
;
528 memcpy(gp
->g_id
, id
, l
);
531 struct grp_names_head
*gnhp
;
532 GP_TO_SUBCLASS(gnhp
, gp
);
533 gnhp
->gnh_head
= NULL
;
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
);
546 grp
->gr_mygroup
= gp
;
551 gp
->g_next
= *gl
.gl_slot
;
559 _group_del(enum group_type gt
, char const *id
)
561 enum group_type xgt
= gt
& GT_MASK
;
562 struct group_lookup gl
;
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
)
581 static struct group
*
582 __group_del(struct group_lookup
*glp
)
584 struct group
*x
, *gp
;
587 /* Overly complicated: link off this node, step ahead to next.. */
589 if ((gp
= glp
->gl_slot_last
) != NULL
) {
590 gp
= (gp
->g_next
= x
->g_next
);
592 glp
->gl_slot_last
= NULL
;
593 gp
= (*glp
->gl_slot
= x
->g_next
);
596 struct group
**gpa
= glp
->gl_htable
+ HSHSIZE
;
598 while (++glp
->gl_slot
< gpa
)
599 if ((gp
= *glp
->gl_slot
) != NULL
)
605 if (x
->g_type
& GT_ALIAS
)
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
);
623 __names_del(struct group
*gp
)
625 struct grp_names_head
*gnhp
;
626 struct grp_names
*gnp
;
629 GP_TO_SUBCLASS(gnhp
, gp
);
630 for (gnp
= gnhp
->gnh_head
; gnp
!= NULL
;) {
631 struct grp_names
*x
= gnp
;
639 _group_print_all(enum group_type gt
)
643 struct group
const *gp
;
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
)
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
)
668 qsort(ida
, i
, sizeof *ida
, &__group_print_qsorter
);
670 if ((fp
= Ftmp(NULL
, "prgroup", OF_RDWR
| OF_UNLINK
| OF_REGISTER
)) == NULL
)
674 for (i
= 0; ida
[i
] != NULL
; ++i
)
675 lines
+= _group_print(_group_find(gt
, ida
[i
]), fp
);
678 if (gt
& GT_SUBSCRIBE
)
679 i
= (ui32_t
)_mlsub_size
, h
= (ui32_t
)_mlsub_hits
;
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")),
692 page_or_print(fp
, lines
);
699 __group_print_qsorter(void const *a
, void const *b
)
704 rv
= strcmp(*(char**)UNCONST(a
), *(char**)UNCONST(b
));
710 _group_print(struct group
const *gp
, FILE *fo
)
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 */
727 struct grp_names
*x
= gnp
;
729 fprintf(fo
, " \"%s\"", string_quote(x
->gn_id
));
730 } while (gnp
!= NULL
);
732 } else if (gp
->g_type
& GT_MLIST
) {
734 if ((gp
->g_type
& GT_REGEX
) && (options
& OPT_D_V
)){
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
)
742 fprintf(fo
, "# regex(7): hits %" PRIuZ
", sort %" PRIuZ
".\n ",
748 fprintf(fo
, "wysh %s %s",
749 (gp
->g_type
& GT_SUBSCRIBE
? "mlsubscribe" : "mlist"),
750 n_shell_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_shell_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_shell_quote_cp(cp
, TRU1
));
765 _mlmux(enum group_type gt
, char **argv
)
772 _group_print_all(gt
);
774 if ((gp
= _group_find(gt
, *argv
)) != NULL
) {
775 if (gt
& GT_SUBSCRIBE
) {
776 if (!(gp
->g_type
& GT_SUBSCRIBE
)) {
778 gp
->g_type
|= GT_SUBSCRIBE
;
781 n_err(_("Mailing-list already `mlsubscribe'd: %s\n"),
786 n_err(_("Mailing-list already `mlist'ed: %s\n"), *argv
);
790 _group_fetch(gt
, *argv
, 0);
791 } while (*++argv
!= NULL
);
798 _unmlmux(enum group_type gt
, char **argv
)
804 for (; *argv
!= NULL
; ++argv
) {
805 if (gt
& GT_SUBSCRIBE
) {
806 struct group_lookup gl
;
809 if (!(isaster
= (**argv
== '*')))
810 gp
= _group_find(gt
, *argv
);
811 else if ((gp
= _group_go_first(gt
, &gl
)) == NULL
)
813 else if (gp
!= NULL
&& !(gp
->g_type
& GT_SUBSCRIBE
))
818 if (gp
->g_type
& GT_SUBSCRIBE
) {
820 gp
->g_type
&= ~GT_SUBSCRIBE
;
824 while ((gp
= _group_go_next(&gl
)) != NULL
&&
825 !(gp
->g_type
& GT_SUBSCRIBE
))
831 n_err(_("Mailing-list not `mlsubscribe'd: \"%s\"\n"), *argv
);
836 } else if (_group_del(gt
, *argv
))
838 n_err(_("No such mailing-list: \"%s\"\n"), *argv
);
847 _mlmux_linkin(struct group
*gp
)
849 struct grp_regex
**lpp
, *grp
, *lhp
;
852 if (gp
->g_type
& GT_SUBSCRIBE
) {
860 GP_TO_SUBCLASS(grp
, gp
);
861 if ((lhp
= *lpp
) != NULL
) {
862 (grp
->gr_last
= lhp
->gr_last
)->gr_next
= grp
;
863 (grp
->gr_next
= lhp
)->gr_last
= grp
;
865 *lpp
= grp
->gr_last
= grp
->gr_next
= grp
;
871 _mlmux_linkout(struct group
*gp
)
873 struct grp_regex
*grp
, **lpp
;
876 GP_TO_SUBCLASS(grp
, gp
);
878 if (gp
->g_type
& GT_SUBSCRIBE
) {
881 _mlsub_hits
-= grp
->gr_hits
;
885 _mlist_hits
-= grp
->gr_hits
;
888 if (grp
->gr_next
== grp
)
891 (grp
->gr_last
->gr_next
= grp
->gr_next
)->gr_last
= grp
->gr_last
;
897 #endif /* HAVE_REGEX */
900 a_nag_custom_sep(char **iolist
){
902 bool_t isesc
, anyesc
;
905 for(base
= *iolist
; base
!= NULL
; base
= *iolist
){
906 while((c
= *base
) != '\0' && blankspacechar(c
))
909 for(isesc
= anyesc
= FAL0
, cp
= base
;; ++cp
){
910 if(UNLIKELY((c
= *cp
) == '\0')){
921 anyesc
|= (c
== ',');
925 while(cp
> base
&& blankspacechar(cp
[-1]))
933 for(ins
= cp
= base
;; ++ins
)
934 if((c
= *cp
) == '\\' && cp
[1] == ','){
937 }else if((*ins
= (++cp
, c
)) == '\0')
948 nalloc(char *str
, enum gfield ntype
)
954 assert(!(ntype
& GFULLEXTRA
) || (ntype
& GFULL
) != 0);
956 addrspec_with_guts(((ntype
& (GFULL
| GSKIN
| GREF
)) != 0), str
, &ag
);
957 if (!(ag
.ag_n_flags
& NAME_NAME_SALLOC
)) {
958 ag
.ag_n_flags
|= NAME_NAME_SALLOC
;
959 np
= salloc(sizeof(*np
) + ag
.ag_slen
+1);
960 memcpy(np
+ 1, ag
.ag_skinned
, ag
.ag_slen
+1);
961 ag
.ag_skinned
= (char*)(np
+ 1);
963 np
= salloc(sizeof *np
);
970 np
->n_fullname
= np
->n_name
= ag
.ag_skinned
;
971 np
->n_fullextra
= NULL
;
972 np
->n_flags
= ag
.ag_n_flags
;
975 if (ag
.ag_ilen
== ag
.ag_slen
977 && !(ag
.ag_n_flags
& NAME_IDNA
)
981 if (ag
.ag_n_flags
& NAME_ADDRSPEC_ISFILEORPIPE
)
984 /* n_fullextra is only the complete name part without address.
985 * Beware of "-r '<abc@def>'", don't treat that as FULLEXTRA */
986 if ((ntype
& GFULLEXTRA
) && ag
.ag_ilen
> ag
.ag_slen
+ 2) {
987 size_t s
= ag
.ag_iaddr_start
, e
= ag
.ag_iaddr_aend
, i
;
990 if (s
== 0 || str
[--s
] != '<' || str
[e
++] != '>')
993 in
.s
= ac_alloc(s
+ i
+1);
994 memcpy(in
.s
, str
, s
);
996 memcpy(in
.s
+ s
, str
+ e
, i
);
998 in
.s
[in
.l
= s
] = '\0';
999 mime_fromhdr(&in
, &out
, TD_ISPR
| TD_ICONV
);
1001 for (cp
= out
.s
, i
= out
.l
; i
> 0 && spacechar(*cp
); --i
, ++cp
)
1003 while (i
> 0 && spacechar(cp
[i
- 1]))
1005 np
->n_fullextra
= savestrbuf(cp
, i
);
1012 /* n_fullname depends on IDNA conversion */
1014 if (!(ag
.ag_n_flags
& NAME_IDNA
)) {
1020 /* The domain name was IDNA and has been converted. We also have to
1021 * ensure that the domain name in .n_fullname is replaced with the
1022 * converted version, since MIME doesn't perform encoding of addrs */
1023 size_t l
= ag
.ag_iaddr_start
,
1024 lsuff
= ag
.ag_ilen
- ag
.ag_iaddr_aend
;
1025 in
.s
= ac_alloc(l
+ ag
.ag_slen
+ lsuff
+1);
1026 memcpy(in
.s
, str
, l
);
1027 memcpy(in
.s
+ l
, ag
.ag_skinned
, ag
.ag_slen
);
1029 memcpy(in
.s
+ l
, str
+ ag
.ag_iaddr_aend
, lsuff
);
1035 mime_fromhdr(&in
, &out
, TD_ISPR
| TD_ICONV
);
1036 np
->n_fullname
= savestr(out
.s
);
1039 if (ag
.ag_n_flags
& NAME_IDNA
)
1042 np
->n_flags
|= NAME_FULLNAME_SALLOC
;
1050 ndup(struct name
*np
, enum gfield ntype
)
1055 if ((ntype
& (GFULL
| GSKIN
)) && !(np
->n_flags
& NAME_SKINNED
)) {
1056 nnp
= nalloc(np
->n_name
, ntype
);
1060 nnp
= salloc(sizeof *np
);
1061 nnp
->n_flink
= nnp
->n_blink
= NULL
;
1062 nnp
->n_type
= ntype
;
1063 nnp
->n_flags
= (np
->n_flags
& ~(NAME_NAME_SALLOC
| NAME_FULLNAME_SALLOC
)) |
1065 nnp
->n_name
= savestr(np
->n_name
);
1066 if (np
->n_name
== np
->n_fullname
|| !(ntype
& (GFULL
| GSKIN
))) {
1067 nnp
->n_fullname
= nnp
->n_name
;
1068 nnp
->n_fullextra
= NULL
;
1070 nnp
->n_flags
|= NAME_FULLNAME_SALLOC
;
1071 nnp
->n_fullname
= savestr(np
->n_fullname
);
1072 nnp
->n_fullextra
= (np
->n_fullextra
== NULL
) ? NULL
1073 : savestr(np
->n_fullextra
);
1081 cat(struct name
*n1
, struct name
*n2
)
1093 while (tail
->n_flink
!= NULL
)
1094 tail
= tail
->n_flink
;
1104 namelist_dup(struct name
const *np
, enum gfield ntype
)
1109 for (nnp
= NULL
; np
!= NULL
; np
= np
->n_flink
) {
1110 struct name
*x
= ndup(UNCONST(np
), (np
->n_type
& ~GMASK
) | ntype
);
1119 count(struct name
const *np
)
1124 for (c
= 0; np
!= NULL
; np
= np
->n_flink
)
1125 if (!(np
->n_type
& GDEL
))
1132 count_nonlocal(struct name
const *np
)
1137 for (c
= 0; np
!= NULL
; np
= np
->n_flink
)
1138 if (!(np
->n_type
& GDEL
) && !(np
->n_flags
& NAME_ADDRSPEC_ISFILEORPIPE
))
1145 extract(char const *line
, enum gfield ntype
)
1150 rv
= _extract1(line
, ntype
, " \t,", 0);
1156 lextract(char const *line
, enum gfield ntype
)
1161 rv
= ((line
!= NULL
&& strpbrk(line
, ",\"\\(<|"))
1162 ? _extract1(line
, ntype
, ",", 1) : extract(line
, ntype
));
1168 detract(struct name
*np
, enum gfield ntype
)
1179 flags
= ntype
& (GCOMMA
| GNAMEONLY
);
1180 ntype
&= ~(GCOMMA
| GNAMEONLY
);
1183 for (p
= np
; p
!= NULL
; p
= p
->n_flink
) {
1184 if (ntype
&& (p
->n_type
& GMASK
) != ntype
)
1186 s
+= strlen(flags
& GNAMEONLY
? p
->n_name
: p
->n_fullname
) +1;
1196 for (p
= np
; p
!= NULL
; p
= p
->n_flink
) {
1197 if (ntype
&& (p
->n_type
& GMASK
) != ntype
)
1199 cp
= sstpcpy(cp
, (flags
& GNAMEONLY
? p
->n_name
: p
->n_fullname
));
1200 if ((flags
& GCOMMA
) && p
->n_flink
!= NULL
)
1205 if ((flags
& GCOMMA
) && *--cp
== ',')
1213 grab_names(char const *field
, struct name
*np
, int comma
, enum gfield gflags
)
1219 np
= lextract(n_lex_input_cp_addhist(field
, detract(np
, comma
), TRU1
),
1221 for (nq
= np
; nq
!= NULL
; nq
= nq
->n_flink
)
1222 if (is_addr_invalid(nq
, EACM_NONE
))
1229 name_is_same_domain(struct name
const *n1
, struct name
const *n2
)
1231 char const *d1
, *d2
;
1235 d1
= strrchr(n1
->n_name
, '@');
1236 d2
= strrchr(n2
->n_name
, '@');
1238 rv
= (d1
!= NULL
&& d2
!= NULL
) ? !asccasecmp(++d1
, ++d2
) : FAL0
;
1245 checkaddrs(struct name
*np
, enum expand_addr_check_mode eacm
,
1246 si8_t
*set_on_error
)
1251 for (n
= np
; n
!= NULL
;) {
1254 if ((rv
= is_addr_invalid(n
, eacm
)) != 0) {
1255 if (set_on_error
!= NULL
)
1256 *set_on_error
|= rv
; /* don't loose -1! */
1258 n
->n_blink
->n_flink
= n
->n_flink
;
1260 n
->n_flink
->n_blink
= n
->n_blink
;
1271 namelist_vaporise_head(struct header
*hp
, enum expand_addr_check_mode eacm
,
1272 bool_t metoo
, si8_t
*set_on_error
)
1274 struct name
*tolist
, *np
, **npp
;
1277 tolist
= usermap(cat(hp
->h_to
, cat(hp
->h_cc
, hp
->h_bcc
)), metoo
);
1278 hp
->h_to
= hp
->h_cc
= hp
->h_bcc
= NULL
;
1280 tolist
= elide(checkaddrs(tolist
, eacm
, set_on_error
));
1282 for (np
= tolist
; np
!= NULL
; np
= np
->n_flink
) {
1283 switch (np
->n_type
& (GDEL
| GMASK
)) {
1284 case GTO
: npp
= &hp
->h_to
; break;
1285 case GCC
: npp
= &hp
->h_cc
; break;
1286 case GBCC
: npp
= &hp
->h_bcc
; break;
1289 *npp
= cat(*npp
, ndup(np
, np
->n_type
| GFULL
));
1296 usermap(struct name
*names
, bool_t force_metoo
)
1298 struct name
*new, *np
, *cp
;
1305 metoo
= (force_metoo
|| ok_blook(metoo
));
1306 while (np
!= NULL
) {
1307 assert(!(np
->n_type
& GDEL
)); /* TODO legacy */
1308 if (is_fileorpipe_addr(np
) || np
->n_name
[0] == '\\') {
1314 gp
= _group_find(GT_ALIAS
, np
->n_name
);
1317 new = _gexpand(0, new, gp
, metoo
, np
->n_type
);
1327 elide(struct name
*names
)
1329 struct name
*np
, *t
, *newn
, *x
;
1336 /* Throw away all deleted nodes (XXX merge with plain sort below?) */
1337 for (np
= NULL
; names
!= NULL
; names
= names
->n_flink
)
1338 if (!(names
->n_type
& GDEL
)) {
1339 names
->n_blink
= np
;
1341 np
->n_flink
= names
;
1352 newn
->n_flink
= NULL
;
1354 while (np
!= NULL
) {
1358 while ((cmpres
= asccasecmp(t
->n_name
, np
->n_name
)) < 0) {
1359 if (t
->n_flink
== NULL
)
1364 /* If we ran out of t's, put new entry after the current value of t */
1374 /* Otherwise, put the new entry in front of the current t. If at the
1375 * front of the list, the new guy becomes the new head of the list */
1386 /* The normal case -- we are inserting into the middle of the list */
1390 x
->n_blink
= t
->n_blink
;
1391 t
->n_blink
->n_flink
= x
;
1395 /* Now the list headed up by new is sorted. Remove duplicates */
1397 while (np
!= NULL
) {
1399 while (t
->n_flink
!= NULL
&& !asccasecmp(np
->n_name
, t
->n_flink
->n_name
))
1406 /* Now t points to the last entry with the same name as np.
1407 * Make np point beyond t */
1408 np
->n_flink
= t
->n_flink
;
1409 if (t
->n_flink
!= NULL
)
1410 t
->n_flink
->n_blink
= np
;
1419 c_alternates(void *v
)
1422 char **namelist
= v
, **ap
, **ap2
, *cp
;
1425 l
= argcount(namelist
) +1;
1428 if (_altnames
!= NULL
) {
1429 printf("alternates ");
1430 for (ap
= _altnames
; *ap
!= NULL
; ++ap
)
1437 if (_altnames
!= NULL
) {
1438 for (ap
= _altnames
; *ap
!= NULL
; ++ap
)
1443 _altnames
= smalloc(l
* sizeof(*_altnames
));
1444 for (ap
= namelist
, ap2
= _altnames
; *ap
!= NULL
; ++ap
, ++ap2
) {
1457 delete_alternates(struct name
*np
)
1463 np
= delname(np
, myname
);
1464 if (_altnames
!= NULL
)
1465 for (ap
= _altnames
; *ap
!= '\0'; ++ap
)
1466 np
= delname(np
, *ap
);
1468 if ((xp
= lextract(ok_vlook(from
), GEXTRA
| GSKIN
)) != NULL
)
1469 while (xp
!= NULL
) {
1470 np
= delname(np
, xp
->n_name
);
1474 if ((xp
= lextract(ok_vlook(replyto
), GEXTRA
| GSKIN
)) != NULL
)
1475 while (xp
!= NULL
) {
1476 np
= delname(np
, xp
->n_name
);
1480 if ((xp
= extract(ok_vlook(sender
), GEXTRA
| GSKIN
)) != NULL
)
1481 while (xp
!= NULL
) {
1482 np
= delname(np
, xp
->n_name
);
1490 is_myname(char const *name
)
1497 if (_same_name(myname
, name
))
1499 if (_altnames
!= NULL
)
1500 for (ap
= _altnames
; *ap
!= NULL
; ++ap
)
1501 if (_same_name(*ap
, name
))
1504 if ((xp
= lextract(ok_vlook(from
), GEXTRA
| GSKIN
)) != NULL
)
1505 while (xp
!= NULL
) {
1506 if (_same_name(xp
->n_name
, name
))
1511 if ((xp
= lextract(ok_vlook(replyto
), GEXTRA
| GSKIN
)) != NULL
)
1512 while (xp
!= NULL
) {
1513 if (_same_name(xp
->n_name
, name
))
1518 if ((xp
= extract(ok_vlook(sender
), GEXTRA
| GSKIN
)) != NULL
)
1519 while (xp
!= NULL
) {
1520 if (_same_name(xp
->n_name
, name
))
1539 _group_print_all(GT_ALIAS
);
1540 else if (argv
[1] == NULL
) {
1541 if ((gp
= _group_find(GT_ALIAS
, *argv
)) != NULL
)
1542 _group_print(gp
, stdout
);
1544 n_err(_("No such alias: \"%s\"\n"), *argv
);
1548 struct grp_names_head
*gnhp
;
1550 gp
= _group_fetch(GT_ALIAS
, *argv
, 0);
1551 GP_TO_SUBCLASS(gnhp
, gp
);
1553 for (++argv
; *argv
!= NULL
; ++argv
) {
1554 size_t l
= strlen(*argv
) +1;
1555 struct grp_names
*gnp
= smalloc(sizeof(*gnp
) -
1556 VFIELD_SIZEOF(struct grp_names
, gn_id
) + l
);
1557 gnp
->gn_next
= gnhp
->gnh_head
;
1558 gnhp
->gnh_head
= gnp
;
1559 memcpy(gnp
->gn_id
, *argv
, l
);
1561 assert(gnhp
->gnh_head
!= NULL
);
1574 do if (!_group_del(GT_ALIAS
, *argv
)) {
1575 n_err(_("No such alias: \"%s\"\n"), *argv
);
1577 } while (*++argv
!= NULL
);
1588 rv
= _mlmux(GT_MLIST
, v
);
1599 rv
= _unmlmux(GT_MLIST
, v
);
1605 c_mlsubscribe(void *v
)
1610 rv
= _mlmux(GT_MLIST
| GT_SUBSCRIBE
, v
);
1616 c_unmlsubscribe(void *v
)
1621 rv
= _unmlmux(GT_MLIST
| GT_SUBSCRIBE
, v
);
1627 is_mlist(char const *name
, bool_t subscribed_only
)
1631 struct grp_regex
**lpp
, *grp
;
1634 enum mlist_state rv
;
1637 gp
= _group_find(GT_MLIST
, name
);
1638 rv
= (gp
!= NULL
) ? MLIST_KNOWN
: MLIST_OTHER
;
1639 if (rv
== MLIST_KNOWN
) {
1640 if (gp
->g_type
& GT_SUBSCRIBE
)
1641 rv
= MLIST_SUBSCRIBED
;
1642 else if (subscribed_only
)
1644 /* Of course, if that is a regular expression it doesn't mean a thing */
1646 if (gp
->g_type
& GT_REGEX
)
1653 /* Not in the hashmap (as something matchable), walk the lists */
1656 lpp
= &_mlsub_regex
;
1658 if ((grp
= *lpp
) != NULL
) {
1659 do if (regexec(&grp
->gr_regex
, name
, 0,NULL
, 0) != REG_NOMATCH
) {
1660 /* Relink as the head of this list if the hit count of this group is
1661 * >= 25% of the average hit count */
1664 i
= ++_mlsub_hits
/ _mlsub_size
;
1666 i
= ++_mlist_hits
/ _mlist_size
;
1669 if (++grp
->gr_hits
>= i
&& *lpp
!= grp
&& grp
->gr_next
!= grp
) {
1670 grp
->gr_last
->gr_next
= grp
->gr_next
;
1671 grp
->gr_next
->gr_last
= grp
->gr_last
;
1672 (grp
->gr_last
= (*lpp
)->gr_last
)->gr_next
= grp
;
1673 (grp
->gr_next
= *lpp
)->gr_last
= grp
;
1676 rv
= !re2
? MLIST_SUBSCRIBED
: MLIST_KNOWN
;
1678 } while ((grp
= grp
->gr_next
) != *lpp
);
1680 if (!re2
&& !subscribed_only
) {
1682 lpp
= &_mlist_regex
;
1685 assert(rv
== MLIST_OTHER
);
1701 _group_print_all(GT_SHORTCUT
);
1702 else for (; *argv
!= NULL
; argv
+= 2) {
1703 /* Because one hardly ever redefines, anything is stored in one chunk */
1708 if (argv
[1] == NULL
) {
1709 n_err(_("Shortcut expansion is missing: \"%s\"\n"), *argv
);
1713 if (_group_find(GT_SHORTCUT
, *argv
) != NULL
)
1714 _group_del(GT_SHORTCUT
, *argv
);
1716 l
= strlen(argv
[1]) +1;
1717 gp
= _group_fetch(GT_SHORTCUT
, *argv
, l
);
1718 GP_TO_SUBCLASS(cp
, gp
);
1719 memcpy(cp
, argv
[1], l
);
1726 c_unshortcut(void *v
)
1732 do if (!_group_del(GT_SHORTCUT
, *argv
)) {
1733 n_err(_("No such shortcut: \"%s\"\n"), *argv
);
1735 } while (*++argv
!= NULL
);
1741 shortcut_expand(char const *str
)
1746 if ((gp
= _group_find(GT_SHORTCUT
, str
)) != NULL
)
1747 GP_TO_SUBCLASS(str
, gp
);
1755 c_customhdr(void *v
){
1757 char const **argv
, *hcp
;
1763 if((hcp
= *(argv
= v
)) == NULL
){
1764 _group_print_all(GT_CUSTOMHDR
);
1768 /* Verify the header field name */
1769 for(rv
= 1;; ++hcp
){
1770 if(fieldnamechar(*hcp
))
1774 n_err(_("`customhdr': no name specified\n"));
1780 n_err(_("`customhdr': invalid name: \"%s\"\n"), *argv
);
1785 if(*++argv
== NULL
){
1786 if((gp
= _group_find(GT_CUSTOMHDR
, hcp
)) != NULL
)
1787 _group_print(gp
, stdout
);
1789 n_err(_("No such `customhdr': \"%s\"\n"), hcp
);
1793 /* Because one hardly ever redefines, anything is stored in one chunk */
1797 if(pstate
& PS_WYSHLIST_SAW_CONTROL
){
1798 n_err(_("`customhdr': \"%s\": control characters not allowed: %s%s\n"),
1799 hcp
, n_shell_quote_cp(*argv
, FAL0
), (argv
[1] != NULL
? "..." : ""));
1804 if(_group_find(GT_CUSTOMHDR
, hcp
) != NULL
)
1805 _group_del(GT_CUSTOMHDR
, hcp
);
1807 for(l
= i
= 0; argv
[i
] != NULL
; ++i
)
1808 l
+= strlen(argv
[i
]) + 1;
1809 gp
= _group_fetch(GT_CUSTOMHDR
, hcp
, l
+1);
1810 GP_TO_SUBCLASS(cp
, gp
);
1811 for(i
= 0; argv
[i
] != NULL
; ++i
){
1814 l
= strlen(argv
[i
]);
1815 memcpy(cp
, argv
[i
], l
);
1826 c_uncustomhdr(void *v
){
1835 if(!_group_del(GT_CUSTOMHDR
, *argv
)){
1836 n_err(_("No such custom header: \"%s\"\n"), *argv
);
1839 }while(*++argv
!= NULL
);
1844 FL
struct n_header_field
*
1845 n_customhdr_query(void){ /* XXX Uses salloc()! */
1846 struct group
const *gp
;
1848 struct n_header_field
*rv
, **tail
, *hfp
;
1854 for(h
= 0; h
< HSHSIZE
; ++h
)
1855 for(gp
= _customhdr_heads
[h
]; gp
!= NULL
; gp
= gp
->g_next
){
1859 GP_TO_SUBCLASS(cp
, gp
);
1860 nl
= (ui32_t
)strlen(gp
->g_id
) +1;
1861 bl
= (ui32_t
)strlen(cp
) +1;
1863 *tail
= hfp
= salloc(VSTRUCT_SIZEOF(struct n_header_field
, hf_dat
) +
1865 tail
= &hfp
->hf_next
;
1866 hfp
->hf_next
= NULL
;
1867 hfp
->hf_nl
= nl
- 1;
1868 hfp
->hf_bl
= bl
- 1;
1869 memcpy(hfp
->hf_dat
, gp
->g_id
, nl
);
1870 memcpy(hfp
->hf_dat
+ nl
, cp
, bl
);
1873 /* TODO We have no copy-on-write environments yet, and since custom headers
1874 * TODO are a perfect subject for localization, add the OBSOLETE variable
1875 * TODO *customhdr*, too */
1877 char const *vp
= ok_vlook(customhdr
);
1880 char *buf
= savestr(vp
);
1882 while((vp
= a_nag_custom_sep(&buf
)) != NULL
){
1884 char const *nstart
, *cp
;
1886 for(nstart
= cp
= vp
;; ++cp
){
1887 if(fieldnamechar(*cp
))
1891 n_err(_("Invalid nameless *customhdr* entry\n"));
1894 }else if(*cp
!= ':' && !blankchar(*cp
)){
1896 n_err(_("Invalid *customhdr* entry: \"%s\"\n"), vp
);
1901 nl
= (ui32_t
)PTR2SIZE(cp
- nstart
);
1903 while(blankchar(*cp
))
1907 while(blankchar(*cp
))
1909 bl
= (ui32_t
)strlen(cp
) +1;
1911 *tail
= hfp
= salloc(VSTRUCT_SIZEOF(struct n_header_field
, hf_dat
) +
1913 tail
= &hfp
->hf_next
;
1914 hfp
->hf_next
= NULL
;
1916 hfp
->hf_bl
= bl
- 1;
1917 memcpy(hfp
->hf_dat
, nstart
, nl
);
1918 hfp
->hf_dat
[nl
++] = '\0';
1919 memcpy(hfp
->hf_dat
+ nl
, cp
, bl
);