1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ Name lists, alternates and groups: aliases, mailing lists, shortcuts.
3 *@ TODO Dynamic hashmaps; names and (these) groups have _nothing_ in common!
5 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
6 * Copyright (c) 2012 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
9 * Copyright (c) 1980, 1993
10 * The Regents of the University of California. All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 #define n_FILE nam_a_grp
39 #ifndef HAVE_AMALGAMATION
45 a_NAG_T_ALTERNATES
= 1,
54 /* Subtype bits and flags */
55 a_NAG_T_SUBSCRIBE
= 1u<<6,
56 a_NAG_T_REGEX
= 1u<<7,
58 /* Extended type mask to be able to reflect what we really have; i.e., mlist
59 * can have a_NAG_T_REGEX if they are subscribed or not, but `mlsubscribe'
60 * should print out only a_NAG_T_MLIST which have the a_NAG_T_SUBSCRIBE
62 a_NAG_T_PRINT_MASK
= a_NAG_T_MASK
| a_NAG_T_SUBSCRIBE
64 n_CTA(a_NAG_T_MASK
>= a_NAG_T_FILETYPE
, "Mask does not cover necessary bits");
67 struct a_nag_group
*ng_next
;
68 ui32_t ng_subclass_off
; /* of "subclass" in .ng_id (if any) */
69 ui16_t ng_id_len_sub
; /* length of .ng_id: _subclass_off - this */
70 ui8_t ng_type
; /* enum a_nag_type */
71 /* Identifying name, of variable size. Dependent on actual "subtype" more
72 * data follows thereafter, but note this is always used (i.e., for regular
73 * expression entries this is still set to the plain string) */
74 char ng_id
[n_VFIELD_SIZE(1)];
76 #define a_NAG_GP_TO_SUBCLASS(X,G) \
78 union a_nag_group_subclass {void *gs_vp; char *gs_cp;} a__gs__;\
79 a__gs__.gs_cp = &((char*)n_UNCONST(G))[(G)->ng_subclass_off];\
83 struct a_nag_grp_names_head
{
84 struct a_nag_grp_names
*ngnh_head
;
87 struct a_nag_grp_names
{
88 struct a_nag_grp_names
*ngn_next
;
89 char ngn_id
[n_VFIELD_SIZE(0)];
93 struct a_nag_grp_regex
{
94 struct a_nag_grp_regex
*ngr_last
;
95 struct a_nag_grp_regex
*ngr_next
;
96 struct a_nag_group
*ngr_mygroup
; /* xxx because lists use grp_regex*! ?? */
97 size_t ngr_hits
; /* Number of times this group matched */
102 struct a_nag_cmd_alias
{
103 struct str nca_expand
;
106 struct a_nag_file_type
{
111 struct a_nag_group_lookup
{
112 struct a_nag_group
**ngl_htable
;
113 struct a_nag_group
**ngl_slot
;
114 struct a_nag_group
*ngl_slot_last
;
115 struct a_nag_group
*ngl_group
;
118 static struct n_file_type
const a_nag_OBSOLETE_xz
= { /* TODO v15 compat */
119 "xz", 2, "xz -cd", sizeof("xz -cd") -1, "xz -cz", sizeof("xz -cz") -1
120 }, a_nag_OBSOLETE_gz
= {
121 "gz", 2, "gzip -cd", sizeof("gzip -cd") -1, "gzip -cz", sizeof("gzip -cz") -1
122 }, a_nag_OBSOLETE_bz2
= {
123 "bz2", 3, "bzip2 -cd", sizeof("bzip2 -cd") -1,
124 "bzip2 -cz", sizeof("bzip2 -cz") -1
128 static struct a_nag_group
*a_nag_alternates_heads
[HSHSIZE
];
131 static struct a_nag_group
*a_nag_commandalias_heads
[HSHSIZE
];
134 static struct a_nag_group
*a_nag_alias_heads
[HSHSIZE
];
136 /* `mlist', `mlsubscribe'. Anything is stored in the hashmap.. */
137 static struct a_nag_group
*a_nag_mlist_heads
[HSHSIZE
];
139 /* ..but entries which have a_NAG_T_REGEX set are false lookups and will really
140 * be accessed via sequential lists instead, which are type-specific for better
141 * performance, but also to make it possible to have ".*@xy.org" as a mlist
142 * and "(one|two)@xy.org" as a mlsubscription.
143 * These lists use a bit of QOS optimization in that a matching group will
144 * become relinked as the new list head if its hit count is
145 * (>= ((xy_hits / _xy_size) >> 2))
146 * Note that the hit counts only count currently linked in nodes.. */
148 static struct a_nag_grp_regex
*a_nag_mlist_regex
;
149 static struct a_nag_grp_regex
*a_nag_mlsub_regex
;
150 static size_t a_nag_mlist_size
;
151 static size_t a_nag_mlist_hits
;
152 static size_t a_nag_mlsub_size
;
153 static size_t a_nag_mlsub_hits
;
157 static struct a_nag_group
*a_nag_shortcut_heads
[HSHSIZE
];
160 static struct a_nag_group
*a_nag_charsetalias_heads
[HSHSIZE
];
163 static struct a_nag_group
*a_nag_filetype_heads
[HSHSIZE
];
165 /* Same name, while taking care for *allnet*? */
166 static bool_t
a_nag_is_same_name(char const *n1
, char const *n2
);
168 /* Mark all nodes with the given name */
169 static struct name
*a_nag_namelist_mark_name(struct name
*np
, char const *name
);
171 /* Grab a single name (liberal name) */
172 static char const *a_nag_yankname(char const *ap
, char *wbuf
,
173 char const *separators
, int keepcomms
);
175 /* Extraction multiplexer that splits an input line to names */
176 static struct name
*a_nag_extract1(char const *line
, enum gfield ntype
,
177 char const *separators
, bool_t keepcomms
);
179 /* Recursively expand a alias name. Limit expansion to some fixed level.
180 * Direct recursion is not expanded for convenience */
181 static struct name
*a_nag_gexpand(size_t level
, struct name
*nlist
,
182 struct a_nag_group
*ngp
, bool_t metoo
, int ntype
);
185 static int a_nag_elide_qsort(void const *s1
, void const *s2
);
187 /* Lookup a group, return it or NULL, fill in glp anyway */
188 static struct a_nag_group
*a_nag_group_lookup(enum a_nag_type nt
,
189 struct a_nag_group_lookup
*nglp
, char const *id
);
191 /* Easier-to-use wrapper around _group_lookup() */
192 static struct a_nag_group
*a_nag_group_find(enum a_nag_type nt
, char const *id
);
194 /* Iteration: go to the first group, which also inits the iterator. A valid
195 * iterator can be stepped via _next(). A NULL return means no (more) groups
196 * to be iterated exist, in which case only nglp->ngl_group is set (NULL) */
197 static struct a_nag_group
*a_nag_group_go_first(enum a_nag_type nt
,
198 struct a_nag_group_lookup
*nglp
);
199 static struct a_nag_group
*a_nag_group_go_next(struct a_nag_group_lookup
*nglp
);
201 /* Fetch the group id, create it as necessary, fail with NULL if impossible */
202 static struct a_nag_group
*a_nag_group_fetch(enum a_nag_type nt
, char const *id
,
205 /* "Intelligent" delete which handles a "*" id, too;
206 * returns a true boolean if a group was deleted, and always succeeds for "*" */
207 static bool_t
a_nag_group_del(enum a_nag_type nt
, char const *id
);
209 static struct a_nag_group
*a_nag__group_del(struct a_nag_group_lookup
*nglp
);
210 static void a_nag__names_del(struct a_nag_group
*ngp
);
212 /* Print all groups of the given type, alphasorted, or store in `vput' varname:
213 * only in this mode it can return failure */
214 static bool_t
a_nag_group_print_all(enum a_nag_type nt
,
215 char const *varname
);
217 static int a_nag__group_print_qsorter(void const *a
, void const *b
);
219 /* Really print a group, actually. Or store in vputsp, if set.
220 * Return number of written lines */
221 static size_t a_nag_group_print(struct a_nag_group
const *ngp
, FILE *fo
,
222 struct n_string
*vputsp
);
224 /* Multiplexers for list and subscribe commands */
225 static int a_nag_mlmux(enum a_nag_type nt
, char const **argv
);
226 static int a_nag_unmlmux(enum a_nag_type nt
, char const **argv
);
228 /* Relinkers for the sequential match lists */
230 static void a_nag_mlmux_linkin(struct a_nag_group
*ngp
);
231 static void a_nag_mlmux_linkout(struct a_nag_group
*ngp
);
232 # define a_NAG_MLMUX_LINKIN(GP) \
233 do if((GP)->ng_type & a_NAG_T_REGEX) a_nag_mlmux_linkin(GP); while(0)
234 # define a_NAG_MLMUX_LINKOUT(GP) \
235 do if((GP)->ng_type & a_NAG_T_REGEX) a_nag_mlmux_linkout(GP); while(0)
237 # define a_NAG_MLMUX_LINKIN(GP)
238 # define a_NAG_MLMUX_LINKOUT(GP)
242 a_nag_is_same_name(char const *n1
, char const *n2
){
244 char c1
, c2
, c1r
, c2r
;
247 if(ok_blook(allnet
)){
251 c1r
= (c1
== '\0' || c1
== '@');
254 c2r
= (c2
== '\0' || c2
== '@');
265 rv
= !asccasecmp(n1
, n2
);
271 a_nag_namelist_mark_name(struct name
*np
, char const *name
){
275 for(p
= np
; p
!= NULL
; p
= p
->n_flink
)
276 if(!(p
->n_type
& GDEL
) && !(p
->n_flags
& (ui32_t
)SI32_MIN
) &&
277 a_nag_is_same_name(p
->n_name
, name
))
278 p
->n_flags
|= (ui32_t
)SI32_MIN
;
284 a_nag_yankname(char const *ap
, char *wbuf
, char const *separators
,
288 char *wp
, c
, inquote
, lc
, lastsp
;
293 /* Skip over intermediate list trash, as in ".org> , <xy@zz.org>" */
294 for (c
= *ap
; blankchar(c
) || c
== ','; c
= *++ap
)
301 /* Parse a full name: TODO RFC 5322
302 * - Keep everything in quotes, liberal handle *quoted-pair*s therein
303 * - Skip entire (nested) comments
304 * - In non-quote, non-comment, join adjacent space to a single SP
305 * - Understand separators only in non-quote, non-comment context,
306 * and only if not part of a *quoted-pair* (XXX too liberal) */
308 for (inquote
= lc
= lastsp
= 0;; lc
= c
, ++cp
) {
317 #if 0 /* TODO when doing real RFC 5322 parsers - why have i done this? */
323 if (inquote
|| lc
== '\\') {
331 cp
= skip_comment(cp
+ 1);
339 if (strchr(separators
, c
) != NULL
)
343 lastsp
= blankchar(c
);
357 a_nag_extract1(char const *line
, enum gfield ntype
, char const *separators
,
360 struct name
*topp
, *np
, *t
;
366 if (line
== NULL
|| *line
== '\0')
371 nbuf
= n_alloc(strlen(line
) +1);
372 while ((cp
= a_nag_yankname(cp
, nbuf
, separators
, keepcomms
)) != NULL
) {
373 t
= nalloc(nbuf
, ntype
);
388 a_nag_gexpand(size_t level
, struct name
*nlist
, struct a_nag_group
*ngp
,
389 bool_t metoo
, int ntype
){
390 struct a_nag_grp_names
*ngnp
;
391 struct name
*nlist_tail
;
393 struct a_nag_grp_names_head
*ngnhp
;
396 if(UICMP(z
, level
++, >, n_ALIAS_MAXEXP
)){
397 n_err(_("Expanding alias to depth larger than %d\n"), n_ALIAS_MAXEXP
);
401 a_NAG_GP_TO_SUBCLASS(ngnhp
, ngp
);
402 logname
= ok_vlook(LOGNAME
);
404 for(ngnp
= ngnhp
->ngnh_head
; ngnp
!= NULL
; ngnp
= ngnp
->ngn_next
){
405 struct a_nag_group
*xngp
;
410 if(!strcmp(cp
, ngp
->ng_id
))
413 if((xngp
= a_nag_group_find(a_NAG_T_ALIAS
, cp
)) != NULL
){
414 /* For S-nail(1), the "alias" may *be* the sender in that a name maps
415 * to a full address specification; aliases cannot be empty */
416 struct a_nag_grp_names_head
*xngnhp
;
418 a_NAG_GP_TO_SUBCLASS(xngnhp
, xngp
);
420 assert(xngnhp
->ngnh_head
!= NULL
);
421 if(metoo
|| xngnhp
->ngnh_head
->ngn_next
!= NULL
||
422 !a_nag_is_same_name(cp
, logname
))
423 nlist
= a_nag_gexpand(level
, nlist
, xngp
, metoo
, ntype
);
427 /* Here we should allow to expand to itself if only person in alias */
429 if(metoo
|| ngnhp
->ngnh_head
->ngn_next
== NULL
||
430 !a_nag_is_same_name(cp
, logname
)){
433 np
= nalloc(cp
, ntype
| GFULL
);
434 if((nlist_tail
= nlist
) != NULL
){
435 while(nlist_tail
->n_flink
!= NULL
)
436 nlist_tail
= nlist_tail
->n_flink
;
437 nlist_tail
->n_flink
= np
;
438 np
->n_blink
= nlist_tail
;
449 a_nag_elide_qsort(void const *s1
, void const *s2
){
450 struct name
const * const *np1
, * const *np2
;
456 rv
= asccasecmp((*np1
)->n_name
, (*np2
)->n_name
);
461 static struct a_nag_group
*
462 a_nag_group_lookup(enum a_nag_type nt
, struct a_nag_group_lookup
*nglp
,
465 struct a_nag_group
*lngp
, *ngp
;
473 struct a_nag_group
**ngpa
;
475 switch((nt
&= a_NAG_T_MASK
)){
476 case a_NAG_T_ALTERNATES
:
477 ngpa
= a_nag_alternates_heads
;
481 case a_NAG_T_COMMANDALIAS
:
482 ngpa
= a_nag_commandalias_heads
;
485 ngpa
= a_nag_alias_heads
;
488 ngpa
= a_nag_mlist_heads
;
491 case a_NAG_T_SHORTCUT
:
492 ngpa
= a_nag_shortcut_heads
;
494 case a_NAG_T_CHARSETALIAS
:
495 ngpa
= a_nag_charsetalias_heads
;
498 case a_NAG_T_FILETYPE
:
499 ngpa
= a_nag_filetype_heads
;
504 nglp
->ngl_htable
= ngpa
;
505 h
= icase
? n_torek_hash(id
) : n_torek_ihash(id
);
506 ngp
= *(nglp
->ngl_slot
= &ngpa
[h
% HSHSIZE
]);
514 for(; ngp
!= NULL
; lngp
= ngp
, ngp
= ngp
->ng_next
)
515 if((ngp
->ng_type
& a_NAG_T_MASK
) == nt
&& *ngp
->ng_id
== c1
&&
516 !asccasecmp(&ngp
->ng_id
[1], id
))
519 for(; ngp
!= NULL
; lngp
= ngp
, ngp
= ngp
->ng_next
)
520 if((ngp
->ng_type
& a_NAG_T_MASK
) == nt
&& *ngp
->ng_id
== c1
&&
521 !strcmp(&ngp
->ng_id
[1], id
))
525 nglp
->ngl_slot_last
= lngp
;
526 nglp
->ngl_group
= ngp
;
531 static struct a_nag_group
*
532 a_nag_group_find(enum a_nag_type nt
, char const *id
){
533 struct a_nag_group_lookup ngl
;
534 struct a_nag_group
*ngp
;
537 ngp
= a_nag_group_lookup(nt
, &ngl
, id
);
542 static struct a_nag_group
*
543 a_nag_group_go_first(enum a_nag_type nt
, struct a_nag_group_lookup
*nglp
){
545 struct a_nag_group
**ngpa
, *ngp
;
548 switch((nt
&= a_NAG_T_MASK
)){
549 case a_NAG_T_ALTERNATES
:
550 ngpa
= a_nag_alternates_heads
;
553 case a_NAG_T_COMMANDALIAS
:
554 ngpa
= a_nag_commandalias_heads
;
557 ngpa
= a_nag_alias_heads
;
560 ngpa
= a_nag_mlist_heads
;
562 case a_NAG_T_SHORTCUT
:
563 ngpa
= a_nag_shortcut_heads
;
565 case a_NAG_T_CHARSETALIAS
:
566 ngpa
= a_nag_charsetalias_heads
;
568 case a_NAG_T_FILETYPE
:
569 ngpa
= a_nag_filetype_heads
;
573 nglp
->ngl_htable
= ngpa
;
575 for(i
= 0; i
< HSHSIZE
; ++ngpa
, ++i
)
576 if((ngp
= *ngpa
) != NULL
){
577 nglp
->ngl_slot
= ngpa
;
578 nglp
->ngl_group
= ngp
;
582 nglp
->ngl_group
= ngp
= NULL
;
584 nglp
->ngl_slot_last
= NULL
;
589 static struct a_nag_group
*
590 a_nag_group_go_next(struct a_nag_group_lookup
*nglp
){
591 struct a_nag_group
*ngp
, **ngpa
;
594 if((ngp
= nglp
->ngl_group
->ng_next
) != NULL
)
595 nglp
->ngl_slot_last
= nglp
->ngl_group
;
597 nglp
->ngl_slot_last
= NULL
;
598 for(ngpa
= &nglp
->ngl_htable
[HSHSIZE
]; ++nglp
->ngl_slot
< ngpa
;)
599 if((ngp
= *nglp
->ngl_slot
) != NULL
)
602 nglp
->ngl_group
= ngp
;
607 static struct a_nag_group
*
608 a_nag_group_fetch(enum a_nag_type nt
, char const *id
, size_t addsz
){
609 struct a_nag_group_lookup ngl
;
610 struct a_nag_group
*ngp
;
614 if((ngp
= a_nag_group_lookup(nt
, &ngl
, id
)) != NULL
)
618 if(UIZ_MAX
- n_ALIGN(l
) <=
619 n_ALIGN(n_VSTRUCT_SIZEOF(struct a_nag_group
, ng_id
)))
622 i
= n_ALIGN(n_VSTRUCT_SIZEOF(struct a_nag_group
, ng_id
) + l
);
623 switch(nt
& a_NAG_T_MASK
){
624 case a_NAG_T_ALTERNATES
:
625 case a_NAG_T_SHORTCUT
:
626 case a_NAG_T_CHARSETALIAS
:
629 case a_NAG_T_COMMANDALIAS
:
630 addsz
+= sizeof(struct a_nag_cmd_alias
);
633 addsz
+= sizeof(struct a_nag_grp_names_head
);
637 if(n_is_maybe_regex(id
)){
638 addsz
= sizeof(struct a_nag_grp_regex
);
643 case a_NAG_T_FILETYPE
:
644 addsz
+= sizeof(struct a_nag_file_type
);
647 if(UIZ_MAX
- i
< addsz
|| UI32_MAX
<= i
|| UI16_MAX
< i
- l
)
650 ngp
= n_alloc(i
+ addsz
);
651 memcpy(ngp
->ng_id
, id
, l
);
652 ngp
->ng_subclass_off
= (ui32_t
)i
;
653 ngp
->ng_id_len_sub
= (ui16_t
)(i
- --l
);
655 switch(nt
& a_NAG_T_MASK
){
656 case a_NAG_T_ALTERNATES
:
658 case a_NAG_T_CHARSETALIAS
:
659 case a_NAG_T_FILETYPE
:{
662 for(cp
= ngp
->ng_id
; (c
= *cp
) != '\0'; ++cp
)
669 if((nt
& a_NAG_T_MASK
) == a_NAG_T_ALIAS
){
670 struct a_nag_grp_names_head
*ngnhp
;
672 a_NAG_GP_TO_SUBCLASS(ngnhp
, ngp
);
673 ngnhp
->ngnh_head
= NULL
;
676 else if(nt
& a_NAG_T_REGEX
){
678 struct a_nag_grp_regex
*ngrp
;
680 a_NAG_GP_TO_SUBCLASS(ngrp
, ngp
);
682 if((s
= regcomp(&ngrp
->ngr_regex
, id
,
683 REG_EXTENDED
| REG_ICASE
| REG_NOSUB
)) != 0){
684 n_err(_("Invalid regular expression: %s: %s\n"),
685 n_shexp_quote_cp(id
, FAL0
),
686 n_regex_err_to_doc(&ngrp
->ngr_regex
, s
));
691 ngrp
->ngr_mygroup
= ngp
;
692 a_nag_mlmux_linkin(ngp
);
694 #endif /* HAVE_REGEX */
696 ngp
->ng_next
= *ngl
.ngl_slot
;
704 a_nag_group_del(enum a_nag_type nt
, char const *id
){
705 struct a_nag_group_lookup ngl
;
706 struct a_nag_group
*ngp
;
710 xnt
= nt
& a_NAG_T_MASK
;
712 /* Delete 'em all? */
713 if(id
[0] == '*' && id
[1] == '\0'){
714 for(ngp
= a_nag_group_go_first(nt
, &ngl
); ngp
!= NULL
;)
715 ngp
= ((ngp
->ng_type
& a_NAG_T_MASK
) == xnt
) ? a_nag__group_del(&ngl
)
716 : a_nag_group_go_next(&ngl
);
717 ngp
= (struct a_nag_group
*)TRU1
;
718 }else if((ngp
= a_nag_group_lookup(nt
, &ngl
, id
)) != NULL
){
719 if(ngp
->ng_type
& xnt
)
720 a_nag__group_del(&ngl
);
725 return (ngp
!= NULL
);
728 static struct a_nag_group
*
729 a_nag__group_del(struct a_nag_group_lookup
*nglp
){
730 struct a_nag_group
*x
, *ngp
;
733 /* Overly complicated: link off this node, step ahead to next.. */
735 if((ngp
= nglp
->ngl_slot_last
) != NULL
)
736 ngp
= (ngp
->ng_next
= x
->ng_next
);
738 nglp
->ngl_slot_last
= NULL
;
739 ngp
= (*nglp
->ngl_slot
= x
->ng_next
);
742 struct a_nag_group
**ngpa
;
744 for(ngpa
= &nglp
->ngl_htable
[HSHSIZE
]; ++nglp
->ngl_slot
< ngpa
;)
745 if((ngp
= *nglp
->ngl_slot
) != NULL
)
749 nglp
->ngl_group
= ngp
;
751 if((x
->ng_type
& a_NAG_T_MASK
) == a_NAG_T_ALIAS
)
754 else if(x
->ng_type
& a_NAG_T_REGEX
){
755 struct a_nag_grp_regex
*ngrp
;
757 a_NAG_GP_TO_SUBCLASS(ngrp
, x
);
759 regfree(&ngrp
->ngr_regex
);
760 a_nag_mlmux_linkout(x
);
770 a_nag__names_del(struct a_nag_group
*ngp
){
771 struct a_nag_grp_names_head
*ngnhp
;
772 struct a_nag_grp_names
*ngnp
;
775 a_NAG_GP_TO_SUBCLASS(ngnhp
, ngp
);
777 for(ngnp
= ngnhp
->ngnh_head
; ngnp
!= NULL
;){
778 struct a_nag_grp_names
*x
;
781 ngnp
= ngnp
->ngn_next
;
788 a_nag_group_print_all(enum a_nag_type nt
, char const *varname
){
793 struct a_nag_group
const *ngp
;
795 struct a_nag_group
**ngpa
;
801 n_string_creat_auto(&s
);
803 xnt
= nt
& a_NAG_T_PRINT_MASK
;
805 switch(xnt
& a_NAG_T_MASK
){
806 case a_NAG_T_ALTERNATES
:
807 tname
= "alternates";
808 ngpa
= a_nag_alternates_heads
;
811 case a_NAG_T_COMMANDALIAS
:
812 tname
= "commandalias";
813 ngpa
= a_nag_commandalias_heads
;
817 ngpa
= a_nag_alias_heads
;
821 ngpa
= a_nag_mlist_heads
;
823 case a_NAG_T_SHORTCUT
:
825 ngpa
= a_nag_shortcut_heads
;
827 case a_NAG_T_CHARSETALIAS
:
828 tname
= "charsetalias";
829 ngpa
= a_nag_charsetalias_heads
;
831 case a_NAG_T_FILETYPE
:
833 ngpa
= a_nag_filetype_heads
;
838 for(i
= h
= 0; h
< HSHSIZE
; ++h
)
839 for(ngp
= ngpa
[h
]; ngp
!= NULL
; ngp
= ngp
->ng_next
)
840 if((ngp
->ng_type
& a_NAG_T_PRINT_MASK
) == xnt
)
844 fprintf(n_stdout
, _("# no %s registered\n"), tname
);
848 ida
= n_autorec_alloc(i
* sizeof *ida
);
850 /* Create alpha sorted array of entries */
851 for(i
= h
= 0; h
< HSHSIZE
; ++h
)
852 for(ngp
= ngpa
[h
]; ngp
!= NULL
; ngp
= ngp
->ng_next
)
853 if((ngp
->ng_type
& a_NAG_T_PRINT_MASK
) == xnt
)
854 ida
[i
++] = ngp
->ng_id
;
856 qsort(ida
, i
, sizeof *ida
, &a_nag__group_print_qsorter
);
861 else if((fp
= Ftmp(NULL
, "nagprint", OF_RDWR
| OF_UNLINK
| OF_REGISTER
)
865 /* Create visual result */
868 switch(xnt
& a_NAG_T_MASK
){
869 case a_NAG_T_ALTERNATES
:
879 for(i
= 0; ida
[i
] != NULL
; ++i
)
880 lines
+= a_nag_group_print(a_nag_group_find(nt
, ida
[i
]), fp
, &s
);
883 if(varname
== NULL
&& (nt
& a_NAG_T_MASK
) == a_NAG_T_MLIST
){
884 if(nt
& a_NAG_T_SUBSCRIBE
)
885 i
= (ui32_t
)a_nag_mlsub_size
, h
= (ui32_t
)a_nag_mlsub_hits
;
887 i
= (ui32_t
)a_nag_mlist_size
, h
= (ui32_t
)a_nag_mlist_hits
;
889 if(i
> 0 && (n_poption
& n_PO_D_V
)){
891 fprintf(fp
, _("# %s list regex(7) total: %u entries, %u hits\n"),
892 (nt
& a_NAG_T_SUBSCRIBE
? _("Subscribed") : _("Non-subscribed")),
899 switch(xnt
& a_NAG_T_MASK
){
900 case a_NAG_T_ALTERNATES
:
910 if(varname
== NULL
&& fp
!= n_stdout
){
912 page_or_print(fp
, lines
);
918 tname
= n_string_cp(&s
);
919 if(n_var_vset(varname
, (uintptr_t)tname
))
922 n_pstate_err_no
= n_ERR_NOTSUP
;
925 return (varname
== NULL
);
929 a_nag__group_print_qsorter(void const *a
, void const *b
){
933 rv
= strcmp(*(char**)n_UNCONST(a
), *(char**)n_UNCONST(b
));
939 a_nag_group_print(struct a_nag_group
const *ngp
, FILE *fo
,
940 struct n_string
*vputsp
){
947 switch(ngp
->ng_type
& a_NAG_T_MASK
){
948 case a_NAG_T_ALTERNATES
:{
950 fprintf(fo
, " %s", ngp
->ng_id
);
952 if(vputsp
->s_len
> 0)
953 vputsp
= n_string_push_c(vputsp
, ' ');
954 /*vputsp =*/ n_string_push_cp(vputsp
, ngp
->ng_id
);
958 case a_NAG_T_COMMANDALIAS
:{
959 struct a_nag_cmd_alias
*ncap
;
961 assert(fo
!= NULL
); /* xxx no vput yet */
962 a_NAG_GP_TO_SUBCLASS(ncap
, ngp
);
963 fprintf(fo
, "commandalias %s %s\n",
964 n_shexp_quote_cp(ngp
->ng_id
, TRU1
),
965 n_shexp_quote_cp(ncap
->nca_expand
.s
, TRU1
));
968 struct a_nag_grp_names_head
*ngnhp
;
969 struct a_nag_grp_names
*ngnp
;
971 assert(fo
!= NULL
); /* xxx no vput yet */
972 fprintf(fo
, "alias %s ", ngp
->ng_id
);
974 a_NAG_GP_TO_SUBCLASS(ngnhp
, ngp
);
975 if((ngnp
= ngnhp
->ngnh_head
) != NULL
) { /* xxx always 1+ entries */
977 struct a_nag_grp_names
*x
;
980 ngnp
= ngnp
->ngn_next
;
981 fprintf(fo
, " \"%s\"", string_quote(x
->ngn_id
)); /* TODO shexp */
982 }while(ngnp
!= NULL
);
987 assert(fo
!= NULL
); /* xxx no vput yet */
989 if((ngp
->ng_type
& a_NAG_T_REGEX
) && (n_poption
& n_PO_D_V
)){
991 struct a_nag_grp_regex
*lp
, *ngrp
;
993 lp
= (ngp
->ng_type
& a_NAG_T_SUBSCRIBE
? a_nag_mlsub_regex
994 : a_nag_mlist_regex
);
995 a_NAG_GP_TO_SUBCLASS(ngrp
, ngp
);
996 for(i
= 1; lp
!= ngrp
; lp
= lp
->ngr_next
)
998 fprintf(fo
, "# regex(7): hits %" PRIuZ
", sort %" PRIuZ
".\n ",
1003 fprintf(fo
, "wysh %s %s\n",
1004 (ngp
->ng_type
& a_NAG_T_SUBSCRIBE
? "mlsubscribe" : "mlist"),
1005 n_shexp_quote_cp(ngp
->ng_id
, TRU1
));
1007 case a_NAG_T_SHORTCUT
:
1008 assert(fo
!= NULL
); /* xxx no vput yet */
1009 a_NAG_GP_TO_SUBCLASS(cp
, ngp
);
1010 fprintf(fo
, "wysh shortcut %s %s\n",
1011 ngp
->ng_id
, n_shexp_quote_cp(cp
, TRU1
));
1013 case a_NAG_T_CHARSETALIAS
:
1014 assert(fo
!= NULL
); /* xxx no vput yet */
1015 a_NAG_GP_TO_SUBCLASS(cp
, ngp
);
1016 fprintf(fo
, "charsetalias %s %s\n",
1017 n_shexp_quote_cp(ngp
->ng_id
, TRU1
), n_shexp_quote_cp(cp
, TRU1
));
1019 case a_NAG_T_FILETYPE
:{
1020 struct a_nag_file_type
*nftp
;
1022 assert(fo
!= NULL
); /* xxx no vput yet */
1023 a_NAG_GP_TO_SUBCLASS(nftp
, ngp
);
1024 fprintf(fo
, "filetype %s %s %s\n",
1025 n_shexp_quote_cp(ngp
->ng_id
, TRU1
),
1026 n_shexp_quote_cp(nftp
->nft_load
.s
, TRU1
),
1027 n_shexp_quote_cp(nftp
->nft_save
.s
, TRU1
));
1035 a_nag_mlmux(enum a_nag_type nt
, char const **argv
){
1036 struct a_nag_group
*ngp
;
1042 n_UNINIT(ecp
, NULL
);
1045 a_nag_group_print_all(nt
, NULL
);
1047 if((ngp
= a_nag_group_find(nt
, *argv
)) != NULL
){
1048 if(nt
& a_NAG_T_SUBSCRIBE
){
1049 if(!(ngp
->ng_type
& a_NAG_T_SUBSCRIBE
)){
1050 a_NAG_MLMUX_LINKOUT(ngp
);
1051 ngp
->ng_type
|= a_NAG_T_SUBSCRIBE
;
1052 a_NAG_MLMUX_LINKIN(ngp
);
1054 ecp
= N_("Mailing-list already `mlsubscribe'd: %s\n");
1058 ecp
= N_("Mailing-list already `mlist'ed: %s\n");
1061 }else if(a_nag_group_fetch(nt
, *argv
, 0) == NULL
){
1062 ecp
= N_("Failed to create storage for mailing-list: %s\n");
1064 n_err(V_(ecp
), n_shexp_quote_cp(*argv
, FAL0
));
1067 }while(*++argv
!= NULL
);
1074 a_nag_unmlmux(enum a_nag_type nt
, char const **argv
){
1075 struct a_nag_group
*ngp
;
1081 for(; *argv
!= NULL
; ++argv
){
1082 if(nt
& a_NAG_T_SUBSCRIBE
){
1083 struct a_nag_group_lookup ngl
;
1086 if(!(isaster
= (**argv
== '*')))
1087 ngp
= a_nag_group_find(nt
, *argv
);
1088 else if((ngp
= a_nag_group_go_first(nt
, &ngl
)) == NULL
)
1090 else if(ngp
!= NULL
&& !(ngp
->ng_type
& a_NAG_T_SUBSCRIBE
))
1095 if(ngp
->ng_type
& a_NAG_T_SUBSCRIBE
){
1096 a_NAG_MLMUX_LINKOUT(ngp
);
1097 ngp
->ng_type
&= ~a_NAG_T_SUBSCRIBE
;
1098 a_NAG_MLMUX_LINKIN(ngp
);
1102 while((ngp
= a_nag_group_go_next(&ngl
)) != NULL
&&
1103 !(ngp
->ng_type
& a_NAG_T_SUBSCRIBE
))
1109 n_err(_("Mailing-list not `mlsubscribe'd: %s\n"),
1110 n_shexp_quote_cp(*argv
, FAL0
));
1115 }else if(a_nag_group_del(nt
, *argv
))
1117 n_err(_("No such mailing-list: %s\n"), n_shexp_quote_cp(*argv
, FAL0
));
1126 a_nag_mlmux_linkin(struct a_nag_group
*ngp
){
1127 struct a_nag_grp_regex
**lpp
, *ngrp
, *lhp
;
1130 if(ngp
->ng_type
& a_NAG_T_SUBSCRIBE
){
1131 lpp
= &a_nag_mlsub_regex
;
1134 lpp
= &a_nag_mlist_regex
;
1138 a_NAG_GP_TO_SUBCLASS(ngrp
, ngp
);
1140 if((lhp
= *lpp
) != NULL
){
1141 (ngrp
->ngr_last
= lhp
->ngr_last
)->ngr_next
= ngrp
;
1142 (ngrp
->ngr_next
= lhp
)->ngr_last
= ngrp
;
1144 *lpp
= ngrp
->ngr_last
= ngrp
->ngr_next
= ngrp
;
1150 a_nag_mlmux_linkout(struct a_nag_group
*ngp
){
1151 struct a_nag_grp_regex
*ngrp
, **lpp
;
1154 a_NAG_GP_TO_SUBCLASS(ngrp
, ngp
);
1156 if(ngp
->ng_type
& a_NAG_T_SUBSCRIBE
){
1157 lpp
= &a_nag_mlsub_regex
;
1159 a_nag_mlsub_hits
-= ngrp
->ngr_hits
;
1161 lpp
= &a_nag_mlist_regex
;
1163 a_nag_mlist_hits
-= ngrp
->ngr_hits
;
1166 if(ngrp
->ngr_next
== ngrp
)
1169 (ngrp
->ngr_last
->ngr_next
= ngrp
->ngr_next
)->ngr_last
= ngrp
->ngr_last
;
1171 *lpp
= ngrp
->ngr_next
;
1175 #endif /* HAVE_REGEX */
1178 nalloc(char const *str
, enum gfield ntype
)
1180 struct n_addrguts ag
;
1184 assert(!(ntype
& GFULLEXTRA
) || (ntype
& GFULL
) != 0);
1186 str
= n_addrspec_with_guts(&ag
, str
,
1187 ((ntype
& (GFULL
| GSKIN
| GREF
)) != 0), FAL0
);
1190 np = NULL; TODO We cannot return NULL,
1191 goto jleave; TODO thus handle failures in here!
1196 if (!(ag
.ag_n_flags
& NAME_NAME_SALLOC
)) {
1197 ag
.ag_n_flags
|= NAME_NAME_SALLOC
;
1198 np
= n_autorec_alloc(sizeof(*np
) + ag
.ag_slen
+1);
1199 memcpy(np
+ 1, ag
.ag_skinned
, ag
.ag_slen
+1);
1200 ag
.ag_skinned
= (char*)(np
+ 1);
1202 np
= n_autorec_alloc(sizeof *np
);
1209 np
->n_fullname
= np
->n_name
= ag
.ag_skinned
;
1210 np
->n_fullextra
= NULL
;
1211 np
->n_flags
= ag
.ag_n_flags
;
1213 if (ntype
& GFULL
) {
1214 if (ag
.ag_ilen
== ag
.ag_slen
1216 && !(ag
.ag_n_flags
& NAME_IDNA
)
1220 if (ag
.ag_n_flags
& NAME_ADDRSPEC_ISFILEORPIPE
)
1223 /* n_fullextra is only the complete name part without address.
1224 * Beware of "-r '<abc@def>'", don't treat that as FULLEXTRA */
1225 if ((ntype
& GFULLEXTRA
) && ag
.ag_ilen
> ag
.ag_slen
+ 2) {
1226 size_t s
= ag
.ag_iaddr_start
, e
= ag
.ag_iaddr_aend
, i
;
1229 if (s
== 0 || str
[--s
] != '<' || str
[e
++] != '>')
1230 goto jskipfullextra
;
1232 in
.s
= n_lofi_alloc(s
+ 1 + i
+1);
1233 while(s
> 0 && blankchar(str
[s
- 1]))
1235 memcpy(in
.s
, str
, s
);
1238 while (blankchar(str
[e
])) {
1244 memcpy(&in
.s
[s
], &str
[e
], i
);
1247 in
.s
[in
.l
= s
] = '\0';
1248 mime_fromhdr(&in
, &out
, TD_ISPR
| TD_ICONV
);
1250 for (cp
= out
.s
, i
= out
.l
; i
> 0 && spacechar(*cp
); --i
, ++cp
)
1252 while (i
> 0 && spacechar(cp
[i
- 1]))
1254 np
->n_fullextra
= savestrbuf(cp
, i
);
1261 /* n_fullname depends on IDNA conversion */
1263 if (!(ag
.ag_n_flags
& NAME_IDNA
)) {
1265 in
.s
= n_UNCONST(str
);
1269 /* The domain name was IDNA and has been converted. We also have to
1270 * ensure that the domain name in .n_fullname is replaced with the
1271 * converted version, since MIME doesn't perform encoding of addrs */
1272 /* TODO This definetely doesn't belong here! */
1273 size_t l
= ag
.ag_iaddr_start
,
1274 lsuff
= ag
.ag_ilen
- ag
.ag_iaddr_aend
;
1275 in
.s
= n_lofi_alloc(l
+ ag
.ag_slen
+ lsuff
+1);
1276 memcpy(in
.s
, str
, l
);
1277 memcpy(in
.s
+ l
, ag
.ag_skinned
, ag
.ag_slen
);
1279 memcpy(in
.s
+ l
, str
+ ag
.ag_iaddr_aend
, lsuff
);
1285 mime_fromhdr(&in
, &out
, TD_ISPR
| TD_ICONV
);
1286 np
->n_fullname
= savestr(out
.s
);
1289 if (ag
.ag_n_flags
& NAME_IDNA
)
1292 np
->n_flags
|= NAME_FULLNAME_SALLOC
;
1300 ndup(struct name
*np
, enum gfield ntype
)
1305 if ((ntype
& (GFULL
| GSKIN
)) && !(np
->n_flags
& NAME_SKINNED
)) {
1306 nnp
= nalloc(np
->n_name
, ntype
);
1310 nnp
= n_autorec_alloc(sizeof *np
);
1311 nnp
->n_flink
= nnp
->n_blink
= NULL
;
1312 nnp
->n_type
= ntype
;
1313 nnp
->n_flags
= (np
->n_flags
& ~(NAME_NAME_SALLOC
| NAME_FULLNAME_SALLOC
)) |
1315 nnp
->n_name
= savestr(np
->n_name
);
1316 if (np
->n_name
== np
->n_fullname
|| !(ntype
& (GFULL
| GSKIN
))) {
1317 nnp
->n_fullname
= nnp
->n_name
;
1318 nnp
->n_fullextra
= NULL
;
1320 nnp
->n_flags
|= NAME_FULLNAME_SALLOC
;
1321 nnp
->n_fullname
= savestr(np
->n_fullname
);
1322 nnp
->n_fullextra
= (np
->n_fullextra
== NULL
) ? NULL
1323 : savestr(np
->n_fullextra
);
1331 cat(struct name
*n1
, struct name
*n2
){
1339 if(n2
== NULL
|| (n2
->n_type
& GDEL
))
1342 while(tail
->n_flink
!= NULL
)
1343 tail
= tail
->n_flink
;
1353 namelist_dup(struct name
const *np
, enum gfield ntype
){
1354 struct name
*nlist
, *xnp
;
1357 for(nlist
= xnp
= NULL
; np
!= NULL
; np
= np
->n_flink
){
1360 if(!(np
->n_type
& GDEL
)){
1361 x
= ndup(n_UNCONST(np
), (np
->n_type
& ~GMASK
) | ntype
);
1362 if((x
->n_blink
= xnp
) == NULL
)
1374 count(struct name
const *np
)
1379 for (c
= 0; np
!= NULL
; np
= np
->n_flink
)
1380 if (!(np
->n_type
& GDEL
))
1387 count_nonlocal(struct name
const *np
)
1392 for (c
= 0; np
!= NULL
; np
= np
->n_flink
)
1393 if (!(np
->n_type
& GDEL
) && !(np
->n_flags
& NAME_ADDRSPEC_ISFILEORPIPE
))
1400 extract(char const *line
, enum gfield ntype
)
1405 rv
= a_nag_extract1(line
, ntype
, " \t,", 0);
1411 lextract(char const *line
, enum gfield ntype
)
1416 rv
= ((line
!= NULL
&& strpbrk(line
, ",\"\\(<|"))
1417 ? a_nag_extract1(line
, ntype
, ",", 1) : extract(line
, ntype
));
1423 detract(struct name
*np
, enum gfield ntype
)
1434 flags
= ntype
& (GCOMMA
| GNAMEONLY
);
1435 ntype
&= ~(GCOMMA
| GNAMEONLY
);
1438 for (p
= np
; p
!= NULL
; p
= p
->n_flink
) {
1439 if (ntype
&& (p
->n_type
& GMASK
) != ntype
)
1441 s
+= strlen(flags
& GNAMEONLY
? p
->n_name
: p
->n_fullname
) +1;
1449 topp
= n_autorec_alloc(s
);
1451 for (p
= np
; p
!= NULL
; p
= p
->n_flink
) {
1452 if (ntype
&& (p
->n_type
& GMASK
) != ntype
)
1454 cp
= sstpcpy(cp
, (flags
& GNAMEONLY
? p
->n_name
: p
->n_fullname
));
1455 if ((flags
& GCOMMA
) && p
->n_flink
!= NULL
)
1460 if ((flags
& GCOMMA
) && *--cp
== ',')
1468 grab_names(enum n_go_input_flags gif
, char const *field
, struct name
*np
,
1469 int comma
, enum gfield gflags
)
1475 np
= lextract(n_go_input_cp(gif
, field
, detract(np
, comma
)), gflags
);
1476 for (nq
= np
; nq
!= NULL
; nq
= nq
->n_flink
)
1477 if (is_addr_invalid(nq
, EACM_NONE
))
1484 name_is_same_domain(struct name
const *n1
, struct name
const *n2
)
1486 char const *d1
, *d2
;
1490 d1
= strrchr(n1
->n_name
, '@');
1491 d2
= strrchr(n2
->n_name
, '@');
1493 rv
= (d1
!= NULL
&& d2
!= NULL
) ? !asccasecmp(++d1
, ++d2
) : FAL0
;
1500 checkaddrs(struct name
*np
, enum expand_addr_check_mode eacm
,
1501 si8_t
*set_on_error
)
1506 for (n
= np
; n
!= NULL
; n
= n
->n_flink
) {
1509 if ((rv
= is_addr_invalid(n
, eacm
)) != 0) {
1510 if (set_on_error
!= NULL
)
1511 *set_on_error
|= rv
; /* don't loose -1! */
1512 else if (eacm
& EAF_MAYKEEP
) /* TODO HACK! See definition! */
1515 n
->n_blink
->n_flink
= n
->n_flink
;
1517 n
->n_flink
->n_blink
= n
->n_blink
;
1527 namelist_vaporise_head(struct header
*hp
, enum expand_addr_check_mode eacm
,
1528 bool_t metoo
, si8_t
*set_on_error
)
1530 /* TODO namelist_vaporise_head() is incredibly expensive and redundant */
1531 struct name
*tolist
, *np
, **npp
;
1534 tolist
= cat(hp
->h_to
, cat(hp
->h_cc
, hp
->h_bcc
));
1535 hp
->h_to
= hp
->h_cc
= hp
->h_bcc
= NULL
;
1537 tolist
= usermap(tolist
, metoo
);
1538 tolist
= n_alternates_remove(tolist
, TRU1
);
1539 tolist
= elide(checkaddrs(tolist
, eacm
, set_on_error
));
1541 for (np
= tolist
; np
!= NULL
; np
= np
->n_flink
) {
1542 switch (np
->n_type
& (GDEL
| GMASK
)) {
1543 case GTO
: npp
= &hp
->h_to
; break;
1544 case GCC
: npp
= &hp
->h_cc
; break;
1545 case GBCC
: npp
= &hp
->h_bcc
; break;
1548 *npp
= cat(*npp
, ndup(np
, np
->n_type
| GFULL
));
1555 usermap(struct name
*names
, bool_t force_metoo
){
1556 struct a_nag_group
*ngp
;
1557 struct name
*nlist
, *nlist_tail
, *np
, *cp
;
1561 metoo
= (force_metoo
|| ok_blook(metoo
));
1562 nlist
= nlist_tail
= NULL
;
1565 for(; np
!= NULL
; np
= cp
){
1566 assert(!(np
->n_type
& GDEL
)); /* TODO legacy */
1569 if(is_fileorpipe_addr(np
) ||
1570 (ngp
= a_nag_group_find(a_NAG_T_ALIAS
, np
->n_name
)) == NULL
){
1571 if((np
->n_blink
= nlist_tail
) != NULL
)
1572 nlist_tail
->n_flink
= np
;
1578 nlist
= a_nag_gexpand(0, nlist
, ngp
, metoo
, np
->n_type
);
1579 if((nlist_tail
= nlist
) != NULL
)
1580 while(nlist_tail
->n_flink
!= NULL
)
1581 nlist_tail
= nlist_tail
->n_flink
;
1589 elide(struct name
*names
)
1592 struct name
*nlist
, *np
, **nparr
;
1600 /* Throw away all deleted nodes */
1601 for(np
= NULL
, i
= 0; names
!= NULL
; names
= names
->n_flink
)
1602 if(!(names
->n_type
& GDEL
)){
1603 names
->n_blink
= np
;
1605 np
->n_flink
= names
;
1611 if(nlist
== NULL
|| i
== 1)
1615 /* Create a temporay array and sort that */
1616 nparr
= n_lofi_alloc(sizeof(*nparr
) * i
);
1618 for(i
= 0, np
= nlist
; np
!= NULL
; np
= np
->n_flink
)
1621 qsort(nparr
, i
, sizeof *nparr
, &a_nag_elide_qsort
);
1623 /* Remove duplicates XXX speedup, or list_uniq()! */
1624 for(j
= 0, --i
; j
< i
;){
1625 if(asccasecmp(nparr
[j
]->n_name
, nparr
[k
= j
+ 1]->n_name
))
1629 nparr
[k
] = nparr
[k
+ 1];
1634 /* Throw away all list members which are not part of the array.
1635 * Note this keeps the original, possibly carefully crafted, order of the
1636 * addressees, thus */
1637 for(np
= nlist
; np
!= NULL
; np
= np
->n_flink
){
1638 for(j
= 0; j
<= i
; ++j
)
1645 nlist
= np
->n_flink
;
1648 np
->n_blink
->n_flink
= np
->n_flink
;
1649 if(np
->n_flink
!= NULL
)
1650 np
->n_flink
->n_blink
= np
->n_blink
;
1661 c_alternates(void *vp
){
1662 struct a_nag_group
*ngp
;
1663 char const *varname
, *ccp
;
1667 n_pstate_err_no
= n_ERR_NONE
;
1670 varname
= (n_pstate
& n_PS_ARGMOD_VPUT
) ? *argv
++ : NULL
;
1673 if(!a_nag_group_print_all(a_NAG_T_ALTERNATES
, varname
))
1677 n_err(_("`alternates': `vput' only supported for show mode\n"));
1679 /* Delete the old set to "declare a list", if *posix* */
1681 a_nag_group_del(a_NAG_T_ALTERNATES
, n_star
);
1683 while((ccp
= *argv
++) != NULL
){
1687 if((np
= lextract(ccp
, GSKIN
)) == NULL
|| np
->n_flink
!= NULL
||
1688 (np
= checkaddrs(np
, EACM_STRICT
, NULL
)) == NULL
){
1689 n_err(_("Invalid `alternates' argument: %s\n"),
1690 n_shexp_quote_cp(ccp
, FAL0
));
1691 n_pstate_err_no
= n_ERR_INVAL
;
1698 if((ngp
= a_nag_group_fetch(a_NAG_T_ALTERNATES
, ccp
, l
)) == NULL
){
1699 n_err(_("Failed to create storage for alternates: %s\n"),
1700 n_shexp_quote_cp(ccp
, FAL0
));
1701 n_pstate_err_no
= n_ERR_NOMEM
;
1707 return (vp
!= NULL
? 0 : 1);
1711 c_unalternates(void *vp
){
1719 do if(!a_nag_group_del(a_NAG_T_ALTERNATES
, *argv
)){
1720 n_err(_("No such `alternates': %s\n"), n_shexp_quote_cp(*argv
, FAL0
));
1722 }while(*++argv
!= NULL
);
1728 n_alternates_remove(struct name
*np
, bool_t keep_single
){
1729 /* XXX keep a single pointer, initial null, and immediate remove nodes
1730 * XXX on successful match unless keep single and that pointer null! */
1731 struct a_nag_group_lookup ngl
;
1732 struct a_nag_group
*ngp
;
1733 struct name
*xp
, *newnp
;
1736 /* Delete the temporary bit from all */
1737 for(xp
= np
; xp
!= NULL
; xp
= xp
->n_flink
)
1738 xp
->n_flags
&= ~(ui32_t
)SI32_MIN
;
1740 /* Mark all possible alternate names (xxx sic: instead walk over namelist
1741 * and hash-lookup alternate instead (unless *allnet*) */
1742 for(ngp
= a_nag_group_go_first(a_NAG_T_ALTERNATES
, &ngl
); ngp
!= NULL
;
1743 ngp
= a_nag_group_go_next(&ngl
))
1744 np
= a_nag_namelist_mark_name(np
, ngp
->ng_id
);
1746 np
= a_nag_namelist_mark_name(np
, ok_vlook(LOGNAME
));
1748 for(xp
= lextract(ok_vlook(from
), GEXTRA
| GSKIN
); xp
!= NULL
;
1750 np
= a_nag_namelist_mark_name(np
, xp
->n_name
);
1752 for(xp
= extract(ok_vlook(sender
), GEXTRA
| GSKIN
); xp
!= NULL
;
1754 np
= a_nag_namelist_mark_name(np
, xp
->n_name
);
1756 for(xp
= lextract(ok_vlook(replyto
), GEXTRA
| GSKIN
); xp
!= NULL
;
1758 np
= a_nag_namelist_mark_name(np
, xp
->n_name
);
1760 /* Clean the list by throwing away all deleted or marked (but one) nodes */
1761 for(xp
= newnp
= NULL
; np
!= NULL
; np
= np
->n_flink
){
1762 if(np
->n_type
& GDEL
)
1764 if(np
->n_flags
& (ui32_t
)SI32_MIN
){
1776 xp
->n_flags
&= ~(ui32_t
)SI32_MIN
;
1787 n_is_myname(char const *name
){
1788 struct a_nag_group_lookup ngl
;
1789 struct a_nag_group
*ngp
;
1793 if(a_nag_is_same_name(ok_vlook(LOGNAME
), name
))
1796 if(!ok_blook(allnet
)){
1797 if(a_nag_group_lookup(a_NAG_T_ALTERNATES
, &ngl
, name
) != NULL
)
1800 for(ngp
= a_nag_group_go_first(a_NAG_T_ALTERNATES
, &ngl
); ngp
!= NULL
;
1801 ngp
= a_nag_group_go_next(&ngl
))
1802 if(a_nag_is_same_name(ngp
->ng_id
, name
))
1806 for(xp
= lextract(ok_vlook(from
), GEXTRA
| GSKIN
); xp
!= NULL
;
1808 if(a_nag_is_same_name(xp
->n_name
, name
))
1811 for(xp
= lextract(ok_vlook(replyto
), GEXTRA
| GSKIN
); xp
!= NULL
;
1813 if(a_nag_is_same_name(xp
->n_name
, name
))
1816 for(xp
= extract(ok_vlook(sender
), GEXTRA
| GSKIN
); xp
!= NULL
;
1818 if(a_nag_is_same_name(xp
->n_name
, name
))
1824 return (name
!= NULL
);
1828 c_addrcodec(void *vp
){
1829 struct n_addrguts ag
;
1830 struct n_string s_b
, *sp
;
1833 char const **argv
, *varname
, *act
, *cp
;
1836 sp
= n_string_creat_auto(&s_b
);
1838 varname
= (n_pstate
& n_PS_ARGMOD_VPUT
) ? *argv
++ : NULL
;
1841 for(cp
= act
; *cp
!= '\0' && !blankspacechar(*cp
); ++cp
)
1852 alen
= PTR2SIZE(cp
- act
);
1860 if(i
<= UIZ_MAX
/ 4)
1862 sp
= n_string_reserve(sp
, i
);
1865 n_pstate_err_no
= n_ERR_NONE
;
1867 if(is_ascncaseprefix(act
, "encode", alen
)){
1868 /* This function cannot be a simple nalloc() wrapper even later on, since
1869 * we may need to turn any ", () or \ into quoted-pairs */
1872 while((c
= *cp
++) != '\0'){
1873 if(((c
== '(' || c
== ')') && mode
< 1) || (c
== '"' && mode
< 2) ||
1874 (c
== '\\' && mode
< 3))
1875 sp
= n_string_push_c(sp
, '\\');
1876 sp
= n_string_push_c(sp
, c
);
1879 if(n_addrspec_with_guts(&ag
, n_string_cp(sp
), TRU1
, TRU1
) == NULL
||
1880 (ag
.ag_n_flags
& (NAME_ADDRSPEC_ISADDR
| NAME_ADDRSPEC_INVALID
)
1881 ) != NAME_ADDRSPEC_ISADDR
){
1883 n_pstate_err_no
= n_ERR_INVAL
;
1888 np
= nalloc(ag
.ag_input
, GTO
| GFULL
| GSKIN
);
1889 cp
= np
->n_fullname
;
1891 }else if(mode
== 0){
1892 if(is_ascncaseprefix(act
, "decode", alen
)){
1895 while((c
= *cp
++) != '\0'){
1898 sp
= n_string_push_c(sp
, '(');
1899 act
= skip_comment(cp
);
1901 sp
= n_string_push_buf(sp
, cp
, PTR2SIZE(act
- cp
));
1902 sp
= n_string_push_c(sp
, ')');
1907 if((c
= *cp
++) == '"')
1909 if(c
== '\\' && (c
= *cp
) != '\0')
1911 sp
= n_string_push_c(sp
, c
);
1915 if(c
== '\\' && (c
= *cp
++) == '\0')
1917 sp
= n_string_push_c(sp
, c
);
1921 cp
= n_string_cp(sp
);
1922 }else if(is_ascncaseprefix(act
, "skin", alen
)){
1923 /* Let's just use the is-single-address hack for this one, too.. */
1924 if(n_addrspec_with_guts(&ag
, cp
, TRU1
, TRU1
) == NULL
||
1925 (ag
.ag_n_flags
& (NAME_ADDRSPEC_ISADDR
| NAME_ADDRSPEC_INVALID
)
1926 ) != NAME_ADDRSPEC_ISADDR
){
1927 n_pstate_err_no
= n_ERR_INVAL
;
1932 np
= nalloc(ag
.ag_input
, GTO
| GFULL
| GSKIN
);
1940 if(varname
== NULL
){
1941 if(fprintf(n_stdout
, "%s\n", cp
) < 0){
1942 n_pstate_err_no
= n_err_no
;
1945 }else if(!n_var_vset(varname
, (uintptr_t)cp
)){
1946 n_pstate_err_no
= n_ERR_NOTSUP
;
1952 return (vp
!= NULL
? 0 : 1);
1954 n_err(_("Synopsis: addrcodec: <[+[+[+]]]e[ncode]|d[ecode]|s[kin]> "
1955 "<rest-of-line>\n"));
1956 n_pstate_err_no
= n_ERR_INVAL
;
1962 c_commandalias(void *vp
){
1963 struct a_nag_group
*ngp
;
1964 char const **argv
, *ccp
;
1971 if((ccp
= *argv
) == NULL
){
1972 a_nag_group_print_all(a_NAG_T_COMMANDALIAS
, NULL
);
1976 /* Verify the name is a valid one, and not a command modifier */
1977 if(*ccp
== '\0' || *n_cmd_isolate(ccp
) != '\0' ||
1978 !asccasecmp(ccp
, "ignerr") || !asccasecmp(ccp
, "wysh") ||
1979 !asccasecmp(ccp
, "vput")){
1980 n_err(_("`commandalias': not a valid command name: %s\n"),
1981 n_shexp_quote_cp(ccp
, FAL0
));
1986 if(argv
[1] == NULL
){
1987 if((ngp
= a_nag_group_find(a_NAG_T_COMMANDALIAS
, ccp
)) != NULL
)
1988 a_nag_group_print(ngp
, n_stdout
, NULL
);
1990 n_err(_("No such commandalias: %s\n"), n_shexp_quote_cp(ccp
, FAL0
));
1994 /* Because one hardly ever redefines, anything is stored in one chunk */
1998 /* Delete the old one, if any; don't get fooled to remove them all */
1999 if(ccp
[0] != '*' || ccp
[1] != '\0')
2000 a_nag_group_del(a_NAG_T_COMMANDALIAS
, ccp
);
2002 for(i
= len
= 0, ++argv
; argv
[i
] != NULL
; ++i
)
2003 len
+= strlen(argv
[i
]) + 1;
2007 if((ngp
= a_nag_group_fetch(a_NAG_T_COMMANDALIAS
, ccp
, len
)) == NULL
){
2008 n_err(_("Failed to create storage for commandalias: %s\n"),
2009 n_shexp_quote_cp(ccp
, FAL0
));
2012 struct a_nag_cmd_alias
*ncap
;
2014 a_NAG_GP_TO_SUBCLASS(ncap
, ngp
);
2015 a_NAG_GP_TO_SUBCLASS(cp
, ngp
);
2017 ncap
->nca_expand
.s
= cp
;
2018 ncap
->nca_expand
.l
= len
- 1;
2020 for(len
= 0; (ccp
= *argv
++) != NULL
;)
2021 if((i
= strlen(ccp
)) > 0){
2036 c_uncommandalias(void *vp
){
2044 do if(!a_nag_group_del(a_NAG_T_COMMANDALIAS
, *argv
)){
2045 n_err(_("No such `commandalias': %s\n"), n_shexp_quote_cp(*argv
, FAL0
));
2047 }while(*++argv
!= NULL
);
2053 n_commandalias_exists(char const *name
, struct str
const **expansion_or_null
){
2054 struct a_nag_group
*ngp
;
2057 if((ngp
= a_nag_group_find(a_NAG_T_COMMANDALIAS
, name
)) != NULL
){
2060 if(expansion_or_null
!= NULL
){
2061 struct a_nag_cmd_alias
*ncap
;
2063 a_NAG_GP_TO_SUBCLASS(ncap
, ngp
);
2064 *expansion_or_null
= &ncap
->nca_expand
;
2073 n_alias_is_valid_name(char const *name
){
2079 for(rv
= TRU1
, cp
= name
++; (c
= *cp
++) != '\0';)
2080 /* User names, plus things explicitly mentioned in Postfix aliases(5).
2081 * As an extension, allow period: [[:alnum:]_#:@.-]+$? */
2082 if(!alnumchar(c
) && c
!= '_' && c
!= '-' &&
2083 c
!= '#' && c
!= ':' && c
!= '@' &&
2085 if(c
== '$' && cp
!= name
&& *cp
== '\0')
2099 struct a_nag_group
*ngp
;
2105 n_UNINIT(ecp
, NULL
);
2108 a_nag_group_print_all(a_NAG_T_ALIAS
, NULL
);
2109 else if(!n_alias_is_valid_name(*argv
)){
2110 ecp
= N_("Not a valid alias name: %s\n");
2112 }else if(argv
[1] == NULL
){
2113 if((ngp
= a_nag_group_find(a_NAG_T_ALIAS
, *argv
)) != NULL
)
2114 a_nag_group_print(ngp
, n_stdout
, NULL
);
2116 ecp
= N_("No such alias: %s\n");
2119 }else if((ngp
= a_nag_group_fetch(a_NAG_T_ALIAS
, *argv
, 0)) == NULL
){
2120 ecp
= N_("Failed to create alias storage for: %s\n");
2122 n_err(V_(ecp
), n_shexp_quote_cp(*argv
, FAL0
));
2125 struct a_nag_grp_names
*ngnp_tail
, *ngnp
;
2126 struct a_nag_grp_names_head
*ngnhp
;
2128 a_NAG_GP_TO_SUBCLASS(ngnhp
, ngp
);
2130 if((ngnp_tail
= ngnhp
->ngnh_head
) != NULL
)
2131 while((ngnp
= ngnp_tail
->ngn_next
) != NULL
)
2134 for(++argv
; *argv
!= NULL
; ++argv
){
2137 i
= strlen(*argv
) +1;
2138 ngnp
= n_alloc(n_VSTRUCT_SIZEOF(struct a_nag_grp_names
, ngn_id
) + i
);
2139 if(ngnp_tail
!= NULL
)
2140 ngnp_tail
->ngn_next
= ngnp
;
2142 ngnhp
->ngnh_head
= ngnp
;
2144 ngnp
->ngn_next
= NULL
;
2145 memcpy(ngnp
->ngn_id
, *argv
, i
);
2161 do if(!a_nag_group_del(a_NAG_T_ALIAS
, *argv
)){
2162 n_err(_("No such alias: %s\n"), *argv
);
2164 }while(*++argv
!= NULL
);
2174 rv
= a_nag_mlmux(a_NAG_T_MLIST
, v
);
2184 rv
= a_nag_unmlmux(a_NAG_T_MLIST
, v
);
2190 c_mlsubscribe(void *v
){
2194 rv
= a_nag_mlmux(a_NAG_T_MLIST
| a_NAG_T_SUBSCRIBE
, v
);
2200 c_unmlsubscribe(void *v
){
2204 rv
= a_nag_unmlmux(a_NAG_T_MLIST
| a_NAG_T_SUBSCRIBE
, v
);
2210 is_mlist(char const *name
, bool_t subscribed_only
){
2211 struct a_nag_group
*ngp
;
2213 struct a_nag_grp_regex
**lpp
, *ngrp
;
2216 enum mlist_state rv
;
2219 ngp
= a_nag_group_find(a_NAG_T_MLIST
, name
);
2220 rv
= (ngp
!= NULL
) ? MLIST_KNOWN
: MLIST_OTHER
;
2222 if(rv
== MLIST_KNOWN
){
2223 if(ngp
->ng_type
& a_NAG_T_SUBSCRIBE
)
2224 rv
= MLIST_SUBSCRIBED
;
2225 else if(subscribed_only
)
2227 /* Of course, if that is a regular expression it doesn't mean a thing */
2229 if(ngp
->ng_type
& a_NAG_T_REGEX
)
2236 /* Not in the hashmap (as something matchable), walk the lists */
2239 lpp
= &a_nag_mlsub_regex
;
2242 if((ngrp
= *lpp
) != NULL
){
2243 do if(regexec(&ngrp
->ngr_regex
, name
, 0,NULL
, 0) != REG_NOMATCH
){
2244 /* Relink as the head of this list if the hit count of this group is
2245 * >= 25% of the average hit count */
2249 i
= ++a_nag_mlsub_hits
/ a_nag_mlsub_size
;
2251 i
= ++a_nag_mlist_hits
/ a_nag_mlist_size
;
2254 if(++ngrp
->ngr_hits
>= i
&& *lpp
!= ngrp
&& ngrp
->ngr_next
!= ngrp
){
2255 ngrp
->ngr_last
->ngr_next
= ngrp
->ngr_next
;
2256 ngrp
->ngr_next
->ngr_last
= ngrp
->ngr_last
;
2257 (ngrp
->ngr_last
= (*lpp
)->ngr_last
)->ngr_next
= ngrp
;
2258 (ngrp
->ngr_next
= *lpp
)->ngr_last
= ngrp
;
2261 rv
= !re2
? MLIST_SUBSCRIBED
: MLIST_KNOWN
;
2263 }while((ngrp
= ngrp
->ngr_next
) != *lpp
);
2266 if(!re2
&& !subscribed_only
){
2268 lpp
= &a_nag_mlist_regex
;
2271 assert(rv
== MLIST_OTHER
);
2272 #endif /* HAVE_REGEX */
2280 c_shortcut(void *vp
){
2281 struct a_nag_group
*ngp
;
2290 a_nag_group_print_all(a_NAG_T_SHORTCUT
, NULL
);
2291 else if(argv
[1] == NULL
){
2292 if((ngp
= a_nag_group_find(a_NAG_T_SHORTCUT
, *argv
)) != NULL
)
2293 a_nag_group_print(ngp
, n_stdout
, NULL
);
2295 n_err(_("No such shortcut: %s\n"), n_shexp_quote_cp(*argv
, FAL0
));
2298 }else for(; *argv
!= NULL
; argv
+= 2){
2299 /* Because one hardly ever redefines, anything is stored in one chunk */
2303 if(argv
[1] == NULL
){
2304 n_err(_("Synopsis: shortcut: <shortcut> <expansion>\n"));
2308 if(a_nag_group_find(a_NAG_T_SHORTCUT
, *argv
) != NULL
)
2309 a_nag_group_del(a_NAG_T_SHORTCUT
, *argv
);
2311 l
= strlen(argv
[1]) +1;
2312 if((ngp
= a_nag_group_fetch(a_NAG_T_SHORTCUT
, *argv
, l
)) == NULL
){
2313 n_err(_("Failed to create storage for shortcut: %s\n"),
2314 n_shexp_quote_cp(*argv
, FAL0
));
2317 a_NAG_GP_TO_SUBCLASS(cp
, ngp
);
2318 memcpy(cp
, argv
[1], l
);
2326 c_unshortcut(void *vp
){
2334 do if(!a_nag_group_del(a_NAG_T_SHORTCUT
, *argv
)){
2335 n_err(_("No such shortcut: %s\n"), *argv
);
2337 }while(*++argv
!= NULL
);
2343 shortcut_expand(char const *str
){
2344 struct a_nag_group
*ngp
;
2347 if((ngp
= a_nag_group_find(a_NAG_T_SHORTCUT
, str
)) != NULL
)
2348 a_NAG_GP_TO_SUBCLASS(str
, ngp
);
2356 c_charsetalias(void *vp
){
2357 struct a_nag_group
*ngp
;
2366 a_nag_group_print_all(a_NAG_T_CHARSETALIAS
, NULL
);
2367 else if(argv
[1] == NULL
){
2368 if((ngp
= a_nag_group_find(a_NAG_T_CHARSETALIAS
, *argv
)) != NULL
)
2369 a_nag_group_print(ngp
, n_stdout
, NULL
);
2371 n_err(_("No such charsetalias: %s\n"), n_shexp_quote_cp(*argv
, FAL0
));
2374 }else for(; *argv
!= NULL
; argv
+= 2){
2375 /* Because one hardly ever redefines, anything is stored in one chunk */
2380 if(argv
[1] == NULL
){
2381 n_err(_("Synopsis: charsetalias: <charset> <charset-alias>\n"));
2386 /* Delete the old one, if any; don't get fooled to remove them all */
2388 if(ccp
[0] != '*' || ccp
[1] != '\0')
2389 a_nag_group_del(a_NAG_T_CHARSETALIAS
, ccp
);
2391 l
= strlen(argv
[1]) +1;
2392 if((ngp
= a_nag_group_fetch(a_NAG_T_CHARSETALIAS
, ccp
, l
)) == NULL
){
2393 n_err(_("Failed to create storage for charsetalias: %s\n"),
2394 n_shexp_quote_cp(ccp
, FAL0
));
2397 a_NAG_GP_TO_SUBCLASS(cp
, ngp
);
2399 for(ccp
= argv
[1]; (c
= *ccp
++) != '\0';)
2400 *cp
++ = lowerconv(c
);
2409 c_uncharsetalias(void *vp
){
2417 do if(!a_nag_group_del(a_NAG_T_CHARSETALIAS
, *argv
)){
2418 n_err(_("No such `charsetalias': %s\n"), n_shexp_quote_cp(*argv
, FAL0
));
2420 }while(*++argv
!= NULL
);
2426 n_charsetalias_expand(char const *cp
){
2427 struct a_nag_group
*ngp
;
2429 char const *cp_orig
;
2434 for(i
= 0; (ngp
= a_nag_group_find(a_NAG_T_CHARSETALIAS
, cp
)) != NULL
;){
2435 a_NAG_GP_TO_SUBCLASS(cp
, ngp
);
2436 if(++i
== 8) /* XXX Magic (same as for `ghost' expansion) */
2447 c_filetype(void *vp
){ /* TODO support automatic chains: .tar.gz -> .gz + .tar */
2448 struct a_nag_group
*ngp
;
2449 char **argv
; /* TODO While there: let ! prefix mean: direct execlp(2) */
2457 a_nag_group_print_all(a_NAG_T_FILETYPE
, NULL
);
2458 else if(argv
[1] == NULL
){
2459 if((ngp
= a_nag_group_find(a_NAG_T_FILETYPE
, *argv
)) != NULL
)
2460 a_nag_group_print(ngp
, n_stdout
, NULL
);
2462 n_err(_("No such filetype: %s\n"), n_shexp_quote_cp(*argv
, FAL0
));
2465 }else for(; *argv
!= NULL
; argv
+= 3){
2466 /* Because one hardly ever redefines, anything is stored in one chunk */
2471 if(argv
[1] == NULL
|| argv
[2] == NULL
){
2472 n_err(_("Synopsis: filetype: <extension> <load-cmd> <save-cmd>\n"));
2477 /* Delete the old one, if any; don't get fooled to remove them all */
2479 if(ccp
[0] != '*' || ccp
[1] != '\0')
2480 a_nag_group_del(a_NAG_T_FILETYPE
, ccp
);
2482 /* Lowercase it all (for display purposes) */
2485 while((c
= *cp
) != '\0')
2486 *cp
++ = lowerconv(c
);
2488 llc
= strlen(argv
[1]) +1;
2489 lsc
= strlen(argv
[2]) +1;
2490 if(UIZ_MAX
- llc
<= lsc
)
2493 if((ngp
= a_nag_group_fetch(a_NAG_T_FILETYPE
, ccp
, llc
+ lsc
)) == NULL
){
2495 n_err(_("Failed to create storage for filetype: %s\n"),
2496 n_shexp_quote_cp(argv
[0], FAL0
));
2499 struct a_nag_file_type
*nftp
;
2501 a_NAG_GP_TO_SUBCLASS(nftp
, ngp
);
2502 a_NAG_GP_TO_SUBCLASS(cp
, ngp
);
2504 memcpy(nftp
->nft_load
.s
= cp
, argv
[1], llc
);
2506 nftp
->nft_load
.l
= --llc
;
2507 memcpy(nftp
->nft_save
.s
= cp
, argv
[2], lsc
);
2509 nftp
->nft_save
.l
= --lsc
;
2517 c_unfiletype(void *vp
){
2525 do if(!a_nag_group_del(a_NAG_T_FILETYPE
, *argv
)){
2526 n_err(_("No such `filetype': %s\n"), n_shexp_quote_cp(*argv
, FAL0
));
2528 }while(*++argv
!= NULL
);
2534 n_filetype_trial(struct n_file_type
*res_or_null
, char const *file
){
2536 struct a_nag_group_lookup ngl
;
2537 struct n_string s
, *sp
;
2538 struct a_nag_group
const *ngp
;
2542 sp
= n_string_creat_auto(&s
);
2543 sp
= n_string_assign_cp(sp
, file
);
2544 sp
= n_string_push_c(sp
, '.');
2547 for(ngp
= a_nag_group_go_first(a_NAG_T_FILETYPE
, &ngl
); ngp
!= NULL
;
2548 ngp
= a_nag_group_go_next(&ngl
)){
2549 sp
= n_string_trunc(sp
, l
);
2550 sp
= n_string_push_buf(sp
, ngp
->ng_id
,
2551 ngp
->ng_subclass_off
- ngp
->ng_id_len_sub
);
2553 if(!stat(n_string_cp(sp
), &stb
) && S_ISREG(stb
.st_mode
)){
2554 if(res_or_null
!= NULL
){
2555 struct a_nag_file_type
*nftp
;
2557 a_NAG_GP_TO_SUBCLASS(nftp
, ngp
);
2558 res_or_null
->ft_ext_dat
= ngp
->ng_id
;
2559 res_or_null
->ft_ext_len
= ngp
->ng_subclass_off
- ngp
->ng_id_len_sub
;
2560 res_or_null
->ft_load_dat
= nftp
->nft_load
.s
;
2561 res_or_null
->ft_load_len
= nftp
->nft_load
.l
;
2562 res_or_null
->ft_save_dat
= nftp
->nft_save
.s
;
2563 res_or_null
->ft_save_len
= nftp
->nft_save
.l
;
2565 goto jleave
; /* TODO after v15 legacy drop: break; */
2569 /* TODO v15 legacy code: automatic file hooks for .{bz2,gz,xz},
2570 * TODO but NOT supporting *file-hook-{load,save}-EXTENSION* */
2571 ngp
= (struct a_nag_group
*)0x1;
2573 sp
= n_string_trunc(sp
, l
);
2574 sp
= n_string_push_buf(sp
, a_nag_OBSOLETE_xz
.ft_ext_dat
,
2575 a_nag_OBSOLETE_xz
.ft_ext_len
);
2576 if(!stat(n_string_cp(sp
), &stb
) && S_ISREG(stb
.st_mode
)){
2577 n_OBSOLETE(".xz support will vanish, please use the `filetype' command");
2578 if(res_or_null
!= NULL
)
2579 *res_or_null
= a_nag_OBSOLETE_xz
;
2583 sp
= n_string_trunc(sp
, l
);
2584 sp
= n_string_push_buf(sp
, a_nag_OBSOLETE_gz
.ft_ext_dat
,
2585 a_nag_OBSOLETE_gz
.ft_ext_len
);
2586 if(!stat(n_string_cp(sp
), &stb
) && S_ISREG(stb
.st_mode
)){
2587 n_OBSOLETE(".gz support will vanish, please use the `filetype' command");
2588 if(res_or_null
!= NULL
)
2589 *res_or_null
= a_nag_OBSOLETE_gz
;
2593 sp
= n_string_trunc(sp
, l
);
2594 sp
= n_string_push_buf(sp
, a_nag_OBSOLETE_bz2
.ft_ext_dat
,
2595 a_nag_OBSOLETE_bz2
.ft_ext_len
);
2596 if(!stat(n_string_cp(sp
), &stb
) && S_ISREG(stb
.st_mode
)){
2597 n_OBSOLETE(".bz2 support will vanish, please use the `filetype' command");
2598 if(res_or_null
!= NULL
)
2599 *res_or_null
= a_nag_OBSOLETE_bz2
;
2607 return (ngp
!= NULL
);
2611 n_filetype_exists(struct n_file_type
*res_or_null
, char const *file
){
2612 char const *ext
, *lext
;
2615 if((ext
= strrchr(file
, '/')) != NULL
)
2618 for(lext
= NULL
; (ext
= strchr(file
, '.')) != NULL
; lext
= file
= ext
){
2619 struct a_nag_group
const *ngp
;
2621 if((ngp
= a_nag_group_find(a_NAG_T_FILETYPE
, ++ext
)) != NULL
){
2623 if(res_or_null
!= NULL
){
2624 struct a_nag_file_type
*nftp
;
2626 a_NAG_GP_TO_SUBCLASS(nftp
, ngp
);
2627 res_or_null
->ft_ext_dat
= ngp
->ng_id
;
2628 res_or_null
->ft_ext_len
= ngp
->ng_subclass_off
- ngp
->ng_id_len_sub
;
2629 res_or_null
->ft_load_dat
= nftp
->nft_load
.s
;
2630 res_or_null
->ft_load_len
= nftp
->nft_load
.l
;
2631 res_or_null
->ft_save_dat
= nftp
->nft_save
.s
;
2632 res_or_null
->ft_save_len
= nftp
->nft_save
.l
;
2634 goto jleave
; /* TODO after v15 legacy drop: break; */
2638 /* TODO v15 legacy code: automatic file hooks for .{bz2,gz,xz},
2639 * TODO as well as supporting *file-hook-{load,save}-EXTENSION* */
2643 if(!asccasecmp(lext
, "xz")){
2644 n_OBSOLETE(".xz support will vanish, please use the `filetype' command");
2645 if(res_or_null
!= NULL
)
2646 *res_or_null
= a_nag_OBSOLETE_xz
;
2648 }else if(!asccasecmp(lext
, "gz")){
2649 n_OBSOLETE(".gz support will vanish, please use the `filetype' command");
2650 if(res_or_null
!= NULL
)
2651 *res_or_null
= a_nag_OBSOLETE_gz
;
2653 }else if(!asccasecmp(lext
, "bz2")){
2654 n_OBSOLETE(".bz2 support will vanish, please use the `filetype' command");
2655 if(res_or_null
!= NULL
)
2656 *res_or_null
= a_nag_OBSOLETE_bz2
;
2659 char const *cload
, *csave
;
2664 #define a_X1 "file-hook-load-"
2666 #define a_X2 "file-hook-save-"
2668 vbuf
= n_lofi_alloc(l
+ n_MAX(sizeof(a_X1
), sizeof(a_X2
)));
2670 memcpy(vbuf
, a_X1
, sizeof(a_X1
) -1);
2671 memcpy(&vbuf
[sizeof(a_X1
) -1], lext
, l
);
2672 vbuf
[sizeof(a_X1
) -1 + l
] = '\0';
2673 cload
= n_var_vlook(vbuf
, FAL0
);
2675 memcpy(vbuf
, a_X2
, sizeof(a_X2
) -1);
2676 memcpy(&vbuf
[sizeof(a_X2
) -1], lext
, l
);
2677 vbuf
[sizeof(a_X2
) -1 + l
] = '\0';
2678 csave
= n_var_vlook(vbuf
, FAL0
);
2684 if((csave
!= NULL
) | (cload
!= NULL
)){
2685 n_OBSOLETE("*file-hook-{load,save}-EXTENSION* will vanish, "
2686 "please use the `filetype' command");
2688 if(((csave
!= NULL
) ^ (cload
!= NULL
)) == 0){
2689 if(res_or_null
!= NULL
){
2690 res_or_null
->ft_ext_dat
= lext
;
2691 res_or_null
->ft_ext_len
= l
;
2692 res_or_null
->ft_load_dat
= cload
;
2693 res_or_null
->ft_load_len
= strlen(cload
);
2694 res_or_null
->ft_save_dat
= csave
;
2695 res_or_null
->ft_save_len
= strlen(csave
);
2699 n_alert(_("Incomplete *file-hook-{load,save}-EXTENSION* for: .%s"),
2708 return (lext
!= NULL
);