Dump to a "-" file recipient even with *debug* enabled!
[s-mailx.git] / nailfuns.h
blobafdcfe215df088f0c17be2c329fe74161c5e6b91
1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ Function prototypes and function-alike macros.
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.
37 * TODO Convert optional utility+ functions to n_*(); ditto
38 * TODO else use generic module-specific prefixes: str_(), am[em]_, sm[em]_, ..
40 /* TODO s-it-mode: not really (docu, funnames, funargs, etc) */
42 #undef FL
43 #ifndef HAVE_AMALGAMATION
44 # define FL extern
45 #else
46 # define FL static
47 #endif
49 /* Memory allocation routines from memory.c offer some debug support */
50 #if (defined HAVE_DEBUG || defined HAVE_DEVEL) && !defined HAVE_NOMEMDBG
51 # define HAVE_MEMORY_DEBUG
52 # define n_MEMORY_DEBUG_ARGS , char const *mdbg_file, int mdbg_line
53 # define n_MEMORY_DEBUG_ARGSCALL , mdbg_file, mdbg_line
54 #else
55 # define n_MEMORY_DEBUG_ARGS
56 # define n_MEMORY_DEBUG_ARGSCALL
57 #endif
60 * Macro-based generics
63 /* ASCII char classification */
64 #define __ischarof(C, FLAGS) \
65 (asciichar(C) && (class_char[(ui8_t)(C)] & (FLAGS)) != 0)
67 #define n_uasciichar(U) ((size_t)(U) <= 0x7F)
68 #define asciichar(c) ((uc_i)(c) <= 0x7F)
69 #define alnumchar(c) __ischarof(c, C_DIGIT | C_OCTAL | C_UPPER | C_LOWER)
70 #define alphachar(c) __ischarof(c, C_UPPER | C_LOWER)
71 #define blankchar(c) __ischarof(c, C_BLANK)
72 #define blankspacechar(c) __ischarof(c, C_BLANK | C_SPACE)
73 #define cntrlchar(c) __ischarof(c, C_CNTRL)
74 #define digitchar(c) __ischarof(c, C_DIGIT | C_OCTAL)
75 #define lowerchar(c) __ischarof(c, C_LOWER)
76 #define punctchar(c) __ischarof(c, C_PUNCT)
77 #define spacechar(c) __ischarof(c, C_BLANK | C_SPACE | C_WHITE)
78 #define upperchar(c) __ischarof(c, C_UPPER)
79 #define whitechar(c) __ischarof(c, C_BLANK | C_WHITE)
80 #define octalchar(c) __ischarof(c, C_OCTAL)
81 #define hexchar(c) /* TODO extend bits, add C_HEX */\
82 (__ischarof(c, C_DIGIT | C_OCTAL) || ((c) >= 'A' && (c) <= 'F') ||\
83 ((c) >= 'a' && (c) <= 'f'))
85 #define upperconv(c) \
86 (lowerchar(c) ? (char)((uc_i)(c) - 'a' + 'A') : (char)(c))
87 #define lowerconv(c) \
88 (upperchar(c) ? (char)((uc_i)(c) - 'A' + 'a') : (char)(c))
89 /* RFC 822, 3.2. */
90 #define fieldnamechar(c) \
91 (asciichar(c) && (c) > 040 && (c) != 0177 && (c) != ':')
93 /* Could the string contain a regular expression? */
94 #define is_maybe_regex(S) n_is_maybe_regex(S)
95 #define n_is_maybe_regex(S) n_is_maybe_regex_buf(S, UIZ_MAX)
96 #define n_is_maybe_regex_buf(D,L) n_anyof_buf("^[]*+?|$", D, L)
98 /* Single-threaded, use unlocked I/O */
99 #ifdef HAVE_PUTC_UNLOCKED
100 # undef getc
101 # define getc(c) getc_unlocked(c)
102 # undef putc
103 # define putc(c, f) putc_unlocked(c, f)
104 # undef putchar
105 # define putchar(c) putc_unlocked((c), stdout)
106 #endif
108 /* There are problems with dup()ing of file-descriptors for child processes.
109 * We have to somehow accomplish that the FILE* fp makes itself comfortable
110 * with the *real* offset of the underlaying file descriptor.
111 * POSIX Issue 7 overloaded fflush(3): if used on a readable stream, then
113 * if the file is not already at EOF, and the file is one capable of
114 * seeking, the file offset of the underlying open file description shall
115 * be set to the file position of the stream */
116 #if defined _POSIX_VERSION && _POSIX_VERSION + 0 >= 200809L
117 # define n_real_seek(FP,OFF,WH) (fseek(FP, OFF, WH) != -1 && fflush(FP) != EOF)
118 # define really_rewind(stream) \
119 do{\
120 rewind(stream);\
121 fflush(stream);\
122 }while(0)
124 #else
125 # define n_real_seek(FP,OFF,WH) \
126 (fseek(FP, OFF, WH) != -1 && fflush(FP) != EOF &&\
127 lseek(fileno(FP), OFF, WH) != -1)
128 # define really_rewind(stream) \
129 do{\
130 rewind(stream);\
131 fflush(stream);\
132 lseek(fileno(stream), 0, SEEK_SET);\
133 }while(0)
134 #endif
136 /* fflush() and rewind() */
137 #define fflush_rewind(stream) \
138 do{\
139 fflush(stream);\
140 rewind(stream);\
141 }while(0)
143 /* Truncate a file to the last character written. This is useful just before
144 * closing an old file that was opened for read/write */
145 #define ftrunc(stream) \
146 do{\
147 off_t off;\
148 fflush(stream);\
149 off = ftell(stream);\
150 if(off >= 0)\
151 ftruncate(fileno(stream), off);\
152 }while(0)
155 * accmacvar.c
158 /* Macros: `define', `undefine', `call' / `~' */
159 FL int c_define(void *v);
160 FL int c_undefine(void *v);
161 FL int c_call(void *v);
163 /* TODO Check whether a *folder-hook* exists for the currently active mailbox */
164 FL bool_t check_folder_hook(bool_t nmail);
166 /* TODO v15 drop Invoke compose hook macname */
167 FL void temporary_call_compose_mode_hook(char const *macname,
168 void (*hook_pre)(void *), void *hook_arg);
169 FL void temporary_unroll_compose_mode(void);
171 /* Accounts: `account', `unaccount' */
172 FL int c_account(void *v);
173 FL int c_unaccount(void *v);
175 /* `localopts' */
176 FL int c_localopts(void *v);
178 FL void temporary_localopts_folder_hook_unroll(void); /* XXX im. hack */
180 /* Don't use n_var_* unless you *really* have to! */
182 /* Constant option key look/(un)set/clear */
183 FL char * n_var_oklook(enum okeys okey);
184 #define ok_blook(C) (n_var_oklook(n_CONCAT(ok_b_, C)) != NULL)
185 #define ok_vlook(C) n_var_oklook(n_CONCAT(ok_v_, C))
187 FL bool_t n_var_okset(enum okeys okey, uintptr_t val);
188 #define ok_bset(C) \
189 n_var_okset(n_CONCAT(ok_b_, C), (uintptr_t)TRU1)
190 #define ok_vset(C,V) \
191 n_var_okset(n_CONCAT(ok_v_, C), (uintptr_t)(V))
193 FL bool_t n_var_okclear(enum okeys okey);
194 #define ok_bclear(C) n_var_okclear(n_CONCAT(ok_b_, C))
195 #define ok_vclear(C) n_var_okclear(n_CONCAT(ok_v_, C))
197 /* Variable option key look/(un)set/clear */
198 FL char * n_var_voklook(char const *vokey);
199 #define vok_blook(S) (n_var_voklook(S) != NULL)
200 #define vok_vlook(S) n_var_voklook(S)
202 FL bool_t n_var_vokset(char const *vokey, uintptr_t val);
203 #define vok_bset(S,B) n_var_vokset(S, (uintptr_t)(B))
204 #define vok_vset(S,V) n_var_vokset(S, (uintptr_t)(V))
206 FL bool_t n_var_vokclear(char const *vokey);
207 #define vok_bclear(S) n_var_vokclear(S)
208 #define vok_vclear(S) n_var_vokclear(S)
210 /* Special case to handle the typical [xy-USER@HOST,] xy-HOST and plain xy
211 * variable chains; oxm is a bitmix which tells which combinations to test */
212 #ifdef HAVE_SOCKETS
213 FL char * n_var_xoklook(enum okeys okey, struct url const *urlp,
214 enum okey_xlook_mode oxm);
215 # define xok_BLOOK(C,URL,M) (n_var_xoklook(C, URL, M) != NULL)
216 # define xok_VLOOK(C,URL,M) n_var_xoklook(C, URL, M)
217 # define xok_blook(C,URL,M) xok_BLOOK(n_CONCAT(ok_b_, C), URL, M)
218 # define xok_vlook(C,URL,M) xok_VLOOK(n_CONCAT(ok_v_, C), URL, M)
219 #endif
221 /* User variable access: `set' and `unset' */
222 FL int c_set(void *v);
223 FL int c_unset(void *v);
225 /* `varshow' */
226 FL int c_varshow(void *v);
228 /* Ditto: `varedit' */
229 FL int c_varedit(void *v);
231 /* `environ' */
232 FL int c_environ(void *v);
235 * attachments.c
238 /* Try to add an attachment for file, fexpand(_LOCAL|_NOPROTO)ed.
239 * Return the new head of list aphead, or NULL.
240 * The newly created attachment will be stored in *newap, if given */
241 FL struct attachment * add_attachment(enum n_lexinput_flags lif,
242 struct attachment *aphead, char *file,
243 struct attachment **newap);
245 /* Append comma-separated list of file names to the end of attachment list */
246 FL void append_attachments(enum n_lexinput_flags lif,
247 struct attachment **aphead, char *names);
249 /* Interactively edit the attachment list */
250 FL void edit_attachments(enum n_lexinput_flags lif,
251 struct attachment **aphead);
254 * auxlily.c
257 /* Compute screen size */
258 FL int screensize(void);
260 /* Get our $PAGER; if env_addon is not NULL it is checked whether we know about
261 * some environment variable that supports colour+ and set *env_addon to that,
262 * e.g., "LESS=FRSXi" */
263 FL char const *n_pager_get(char const **env_addon);
265 /* Use a pager or STDOUT to print *fp*; if *lines* is 0, they'll be counted */
266 FL void page_or_print(FILE *fp, size_t lines);
268 /* Parse name and guess at the required protocol */
269 FL enum protocol which_protocol(char const *name);
271 /* Hexadecimal itoa (NUL terminates) / atoi (-1 on error) */
272 FL char * n_c_to_hex_base16(char store[3], char c);
273 FL si32_t n_c_from_hex_base16(char const hex[2]);
275 /* Hash the passed string -- uses Chris Torek's hash algorithm.
276 * i*() hashes case-insensitively (ASCII), and *n() uses maximally len bytes;
277 * if len is UIZ_MAX, we go .), since we anyway stop for NUL */
278 FL ui32_t torek_hash(char const *name);
279 FL ui32_t torek_ihashn(char const *dat, size_t len);
281 /* Find a prime greater than n */
282 FL ui32_t nextprime(ui32_t n);
284 /* Return the name of the dead.letter file */
285 FL char const * n_getdeadletter(void);
287 /* Detect and query the hostname to use */
288 FL char * nodename(int mayoverride);
290 /* Get a (pseudo) random string of *length* bytes; returns salloc()ed buffer */
291 FL char * getrandstring(size_t length);
293 /* Check whether the argument string is a true (1) or false (0) boolean, or an
294 * invalid string, in which case -1 is returned; if emptyrv is not -1 then it,
295 * treated as a boolean, is used as the return value shall inbuf be empty.
296 * inlen may be UIZ_MAX to force strlen() detection */
297 FL si8_t boolify(char const *inbuf, uiz_t inlen, si8_t emptyrv);
299 /* Dig a "quadoption" in inbuf (possibly going through getapproval() in
300 * interactive mode). Returns a boolean or -1 if inbuf content is invalid;
301 * if emptyrv is not -1 then it, treated as a boolean, is used as the return
302 * value shall inbuf be empty. If prompt is set it is printed first if intera.
303 * inlen may be UIZ_MAX to force strlen() detection */
304 FL si8_t quadify(char const *inbuf, uiz_t inlen, char const *prompt,
305 si8_t emptyrv);
307 /* Is the argument "all" (case-insensitive) or "*" */
308 FL bool_t n_is_all_or_aster(char const *name);
310 /* Get seconds since epoch */
311 FL time_t n_time_epoch(void);
313 /* Update *tc* to now; only .tc_time updated unless *full_update* is true */
314 FL void time_current_update(struct time_current *tc,
315 bool_t full_update);
317 /* Returns 0 if fully slept, number of millis left if ignint is true and we
318 * were interrupted. Actual resolution may be second or less.
319 * Note in case of HAVE_SLEEP this may be SIGALARM based. */
320 FL uiz_t n_msleep(uiz_t millis, bool_t ignint);
322 /* Our error print series.. Note: these reverse scan format in order to know
323 * whether a newline was included or not -- this affects the output! */
324 FL void n_err(char const *format, ...);
325 FL void n_verr(char const *format, va_list ap);
327 /* ..(for use in a signal handler; to be obsoleted..).. */
328 FL void n_err_sighdl(char const *format, ...);
330 /* Our perror(3); if errval is 0 errno(3) is used; newline appended */
331 FL void n_perr(char const *msg, int errval);
333 /* Announce a fatal error (and die); newline appended */
334 FL void n_alert(char const *format, ...);
335 FL void n_panic(char const *format, ...);
337 /* `errors' */
338 #ifdef HAVE_ERRORS
339 FL int c_errors(void *vp);
340 #else
341 # define c_errors c_cmdnotsupp
342 #endif
345 * cmd_arg.c
348 /* Scan out the list of string arguments according to rm, return -1 on error;
349 * res_dat is NULL terminated unless res_size is 0 or error occurred */
350 FL int getrawlist(bool_t wysh, char **res_dat, size_t res_size,
351 char const *line, size_t linesize);
353 /* Scan an entire command argument line, return whether result can be used,
354 * otherwise no resources are allocated (in ->cac_arg).
355 * For _WYSH arguments the flags _TRIMSPACE and _LOG are implicit */
356 FL bool_t n_cmd_arg_parse(struct n_cmd_arg_ctx *cacp);
358 /* Join all the _GREEDY arguments that were seen into a single string.
359 * Asserted they are string-based. The data (if any) is appended to store */
360 FL struct n_string *n_cmd_arg_join_greedy(struct n_cmd_arg_ctx const *cacp,
361 struct n_string *store);
364 * cmd_cnd.c
367 /* if.elif.else.endif conditional execution.
368 * condstack_isskip() returns whether the current condition state doesn't allow
369 * execution of commands.
370 * condstack_release() and condstack_take() rotate the current condition stack;
371 * condstack_take() returns a false boolean if the current condition stack has
372 * unclosed conditionals */
373 FL int c_if(void *v);
374 FL int c_elif(void *v);
375 FL int c_else(void *v);
376 FL int c_endif(void *v);
377 FL bool_t condstack_isskip(void);
378 FL void *condstack_release(void);
379 FL bool_t condstack_take(void *self);
382 * cmd_folder.c
385 /* `file' (`folder') and `File' (`Folder') */
386 FL int c_file(void *v);
387 FL int c_File(void *v);
389 /* 'newmail' command: Check for new mail without writing old mail back */
390 FL int c_newmail(void *v);
392 /* noop */
393 FL int c_noop(void *v);
395 /* Remove mailbox */
396 FL int c_remove(void *v);
398 /* Rename mailbox */
399 FL int c_rename(void *v);
401 /* List the folders the user currently has */
402 FL int c_folders(void *v);
405 * cmd_headers.c
408 /* `headers' (show header group, possibly after setting dot) */
409 FL int c_headers(void *v);
411 /* Like c_headers(), but pre-prepared message vector */
412 FL int print_header_group(int *vector);
414 /* Scroll to the next/previous screen */
415 FL int c_scroll(void *v);
416 FL int c_Scroll(void *v);
418 /* Move the dot up or down by one message */
419 FL int c_dotmove(void *v);
421 /* Print out the headlines for each message in the passed message list */
422 FL int c_from(void *v);
424 /* Print all message in between and including bottom and topx if they are
425 * visible and either only_marked is false or they are MMARKed */
426 FL void print_headers(size_t bottom, size_t topx, bool_t only_marked);
429 * cmd_message.c
432 /* Paginate messages, honour/don't honour ignored fields, respectively */
433 FL int c_more(void *v);
434 FL int c_More(void *v);
436 /* Type out messages, honour/don't honour ignored fields, respectively */
437 FL int c_type(void *v);
438 FL int c_Type(void *v);
440 /* Show raw message content */
441 FL int c_show(void *v);
443 /* Pipe messages, honour/don't honour ignored fields, respectively */
444 FL int c_pipe(void *v);
445 FL int c_Pipe(void *v);
447 /* Print the first *toplines* of each desired message */
448 FL int c_top(void *v);
449 FL int c_Top(void *v);
451 /* If any arguments were given, go to the next applicable argument following
452 * dot, otherwise, go to the next applicable message. If given as first
453 * command with no arguments, print first message */
454 FL int c_next(void *v);
456 /* Print out the value of dot */
457 FL int c_pdot(void *v);
459 /* Print the size of each message */
460 FL int c_messize(void *v);
462 /* Delete messages */
463 FL int c_delete(void *v);
465 /* Delete messages, then type the new dot */
466 FL int c_deltype(void *v);
468 /* Undelete the indicated messages */
469 FL int c_undelete(void *v);
471 /* Touch all the given messages so that they will get mboxed */
472 FL int c_stouch(void *v);
474 /* Make sure all passed messages get mboxed */
475 FL int c_mboxit(void *v);
477 /* Preserve messages, so that they will be sent back to the system mailbox */
478 FL int c_preserve(void *v);
480 /* Mark all given messages as unread */
481 FL int c_unread(void *v);
483 /* Mark all given messages as read */
484 FL int c_seen(void *v);
486 /* Message flag manipulation */
487 FL int c_flag(void *v);
488 FL int c_unflag(void *v);
489 FL int c_answered(void *v);
490 FL int c_unanswered(void *v);
491 FL int c_draft(void *v);
492 FL int c_undraft(void *v);
495 * cmd_misc.c
498 /* Process a shell escape by saving signals, ignoring signals and a sh -c */
499 FL int c_shell(void *v);
501 /* Fork an interactive shell */
502 FL int c_dosh(void *v);
504 /* Print user's working directory */
505 FL int c_cwd(void *v);
507 /* Change user's working directory */
508 FL int c_chdir(void *v);
510 /* Expand file names like echo (to stdout/stderr) */
511 FL int c_echo(void *v);
512 FL int c_echoerr(void *v);
515 * cmd_resend.c
518 /* All thinkable sorts of `reply' / `respond' and `followup'.. */
519 FL int c_reply(void *v);
520 FL int c_replyall(void *v);
521 FL int c_replysender(void *v);
522 FL int c_Reply(void *v);
523 FL int c_followup(void *v);
524 FL int c_followupall(void *v);
525 FL int c_followupsender(void *v);
526 FL int c_Followup(void *v);
528 /* ..and a mailing-list reply */
529 FL int c_Lreply(void *v);
531 /* The 'forward' command */
532 FL int c_forward(void *v);
534 /* Similar to forward, saving the message in a file named after the first
535 * recipient */
536 FL int c_Forward(void *v);
538 /* Resend a message list to a third person */
539 FL int c_resend(void *v);
541 /* Resend a message list to a third person without adding headers */
542 FL int c_Resend(void *v);
545 * cmd_write.c
548 /* Save a message in a file. Mark the message as saved so we can discard when
549 * the user quits */
550 FL int c_save(void *v);
551 FL int c_Save(void *v);
553 /* Copy a message to a file without affected its saved-ness */
554 FL int c_copy(void *v);
555 FL int c_Copy(void *v);
557 /* Move a message to a file */
558 FL int c_move(void *v);
559 FL int c_Move(void *v);
561 /* Decrypt and copy a message to a file */
562 FL int c_decrypt(void *v);
563 FL int c_Decrypt(void *v);
565 /* Write the indicated messages at the end of the passed file name, minus
566 * header and trailing blank line. This is the MIME save function */
567 FL int c_write(void *v);
570 * collect.c
574 * If quotefile is (char*)-1, stdin will be used, caller has to verify that
575 * we're not running in interactive mode */
576 FL FILE * collect(struct header *hp, int printheaders, struct message *mp,
577 char *quotefile, int doprefix, si8_t *checkaddr_err);
580 * colour.c
583 #ifdef HAVE_COLOUR
584 /* `(un)?colour' */
585 FL int c_colour(void *v);
586 FL int c_uncolour(void *v);
588 /* We want coloured output (in this salloc() cycle). pager_used is used to
589 * test whether *colour-pager* is to be inspected.
590 * The push/pop functions deal with recursive execute()ions, for now. TODO
591 * env_gut() will reset() as necessary */
592 FL void n_colour_env_create(enum n_colour_ctx cctx, bool_t pager_used);
593 FL void n_colour_env_push(void);
594 FL void n_colour_env_pop(bool_t any_env_till_root);
595 FL void n_colour_env_gut(FILE *fp);
597 /* Putting anything (for pens: including NULL) resets current state first */
598 FL void n_colour_put(FILE *fp, enum n_colour_id cid, char const *ctag);
599 FL void n_colour_reset(FILE *fp);
601 /* Of course temporary only and may return NULL. Doesn't affect state! */
602 FL struct str const *n_colour_reset_to_str(void);
604 /* A pen is bound to its environment and automatically reclaimed; it may be
605 * NULL but that can be used anyway for simplicity.
606 * This includes pen_to_str() -- which doesn't affect state! */
607 FL struct n_colour_pen *n_colour_pen_create(enum n_colour_id cid,
608 char const *ctag);
609 FL void n_colour_pen_put(struct n_colour_pen *self, FILE *fp);
611 FL struct str const *n_colour_pen_to_str(struct n_colour_pen *self);
613 #else /* HAVE_COLOUR */
614 # define c_colour c_cmdnotsupp
615 # define c_uncolour c_cmdnotsupp
616 # define c_mono c_cmdnotsupp
617 # define c_unmono c_cmdnotsupp
618 #endif
621 * dotlock.c
624 /* Aquire a flt lock and create a dotlock file; upon success a registered
625 * control-pipe FILE* is returned that keeps the link in between us and the
626 * lock-holding fork(2)ed subprocess (which conditionally replaced itself via
627 * execv(2) with the privilege-separated dotlock helper program): the lock file
628 * will be removed once the control pipe is closed via Pclose().
629 * Will try FILE_LOCK_TRIES times if pollmsecs > 0 (once otherwise).
630 * If pollmsecs is UIZ_MAX, FILE_LOCK_MILLIS is used.
631 * If *dotlock_ignore_error* is set (FILE*)-1 will be returned if at least the
632 * normal file lock could be established, otherwise errno is usable on error */
633 FL FILE * n_dotlock(char const *fname, int fd, enum n_file_lock_type flt,
634 off_t off, off_t len, size_t pollmsecs);
637 * edit.c
640 /* Edit a message list */
641 FL int c_editor(void *v);
643 /* Invoke the visual editor on a message list */
644 FL int c_visual(void *v);
646 /* Run an editor on either size bytes of the file fp (or until EOF if size is
647 * negative) or on the message mp, and return a new file or NULL on error of if
648 * the user didn't perform any edits.
649 * For now we assert that mp==NULL if hp!=NULL, treating this as a special call
650 * from within compose mode, and giving TRUM1 to puthead().
651 * Signals must be handled by the caller. viored is 'e' for ed, 'v' for vi */
652 FL FILE * run_editor(FILE *fp, off_t size, int viored, int readonly,
653 struct header *hp, struct message *mp,
654 enum sendaction action, sighandler_type oldint);
657 * filter.c
660 /* Quote filter */
661 FL struct quoteflt * quoteflt_dummy(void); /* TODO LEGACY */
662 FL void quoteflt_init(struct quoteflt *self, char const *prefix);
663 FL void quoteflt_destroy(struct quoteflt *self);
664 FL void quoteflt_reset(struct quoteflt *self, FILE *f);
665 FL ssize_t quoteflt_push(struct quoteflt *self, char const *dat,
666 size_t len);
667 FL ssize_t quoteflt_flush(struct quoteflt *self);
669 /* (Primitive) HTML tagsoup filter */
670 #ifdef HAVE_FILTER_HTML_TAGSOUP
671 /* TODO Because we don't support filter chains yet this filter will be run
672 * TODO in a dedicated subprocess, driven via a special Popen() mode */
673 FL int htmlflt_process_main(void);
675 FL void htmlflt_init(struct htmlflt *self);
676 FL void htmlflt_destroy(struct htmlflt *self);
677 FL void htmlflt_reset(struct htmlflt *self, FILE *f);
678 FL ssize_t htmlflt_push(struct htmlflt *self, char const *dat, size_t len);
679 FL ssize_t htmlflt_flush(struct htmlflt *self);
680 #endif
683 * fio.c
686 /* fgets() replacement to handle lines of arbitrary size and with embedded \0
687 * characters.
688 * line - line buffer. *line may be NULL.
689 * linesize - allocated size of line buffer.
690 * count - maximum characters to read. May be NULL.
691 * llen - length_of_line(*line).
692 * fp - input FILE.
693 * appendnl - always terminate line with \n, append if necessary.
694 * Manages the PS_READLINE_NL hack */
695 FL char * fgetline(char **line, size_t *linesize, size_t *count,
696 size_t *llen, FILE *fp, int appendnl n_MEMORY_DEBUG_ARGS);
697 #ifdef HAVE_MEMORY_DEBUG
698 # define fgetline(A,B,C,D,E,F) \
699 fgetline(A, B, C, D, E, F, __FILE__, __LINE__)
700 #endif
702 /* Read up a line from the specified input into the linebuffer.
703 * Return the number of characters read. Do not include the newline at EOL.
704 * n is the number of characters already read and present in *linebuf; it'll be
705 * treated as _the_ line if no more (successful) reads are possible.
706 * Manages the PS_READLINE_NL hack */
707 FL int readline_restart(FILE *ibuf, char **linebuf, size_t *linesize,
708 size_t n n_MEMORY_DEBUG_ARGS);
709 #ifdef HAVE_MEMORY_DEBUG
710 # define readline_restart(A,B,C,D) \
711 readline_restart(A, B, C, D, __FILE__, __LINE__)
712 #endif
714 /* Set up the input pointers while copying the mail file into /tmp */
715 FL void setptr(FILE *ibuf, off_t offset);
717 /* Determine the size of the file possessed by the passed buffer */
718 FL off_t fsize(FILE *iob);
720 /* Will retry FILE_LOCK_RETRIES times if pollmsecs > 0.
721 * If pollmsecs is UIZ_MAX, FILE_LOCK_MILLIS is used */
722 FL bool_t n_file_lock(int fd, enum n_file_lock_type flt,
723 off_t off, off_t len, size_t pollmsecs);
726 * folder.c
729 /* Set up editing on the given file name.
730 * If the first character of name is %, we are considered to be editing the
731 * file, otherwise we are reading our mail which has signficance for mbox and
732 * so forth */
733 FL int setfile(char const *name, enum fedit_mode fm);
735 FL int newmailinfo(int omsgCount);
737 /* Set the size of the message vector used to construct argument lists to
738 * message list functions */
739 FL void setmsize(int sz);
741 /* Logic behind -H / -L invocations */
742 FL void print_header_summary(char const *Larg);
744 /* Announce the presence of the current Mail version, give the message count,
745 * and print a header listing */
746 FL void announce(int printheaders);
748 /* Announce information about the file we are editing. Return a likely place
749 * to set dot */
750 FL int newfileinfo(void);
752 FL int getmdot(int nmail);
754 FL void initbox(char const *name);
756 /* Determine and expand the current *folder* name, return it (with trailing
757 * solidus) or the empty string also in case of errors: since POSIX mandates
758 * a default of CWD if not set etc., that seems to be a valid fallback, then */
759 FL char const *folder_query(void);
762 * head.c
765 /* Return the user's From: address(es) */
766 FL char const * myaddrs(struct header *hp);
768 /* Boil the user's From: addresses down to a single one, or use *sender* */
769 FL char const * myorigin(struct header *hp);
771 /* See if the passed line buffer, which may include trailing newline (sequence)
772 * is a mail From_ header line according to POSIX ("From ").
773 * If check_rfc4155 is true we'll return TRUM1 instead if the From_ line
774 * matches POSIX but is _not_ compatible to RFC 4155 */
775 FL bool_t is_head(char const *linebuf, size_t linelen,
776 bool_t check_rfc4155);
778 /* Savage extract date field from From_ line. linelen is convenience as line
779 * must be terminated (but it may end in a newline [sequence]).
780 * Return whether the From_ line was parsed successfully (-1 if the From_ line
781 * wasn't really RFC 4155 compliant) */
782 FL int extract_date_from_from_(char const *line, size_t linelen,
783 char datebuf[FROM_DATEBUF]);
785 /* Extract some header fields (see e.g. -t documentation) from a message.
786 * If options&OPT_t_FLAG *and* pstate&PS_t_FLAG are both set a number of
787 * additional header fields are understood and address joining is performed as
788 * necessary, and the subject is treated with additional care, too.
789 * If pstate&PS_t_FLAG is set but OPT_t_FLAG is no more, From: will not be
790 * assigned no more.
791 * This calls expandaddr() on some headers and sets checkaddr_err if that is
792 * not NULL -- note it explicitly allows EAF_NAME because aliases are not
793 * expanded when this is called! */
794 FL void extract_header(FILE *fp, struct header *hp,
795 si8_t *checkaddr_err);
797 /* Return the desired header line from the passed message
798 * pointer (or NULL if the desired header field is not available).
799 * If mult is zero, return the content of the first matching header
800 * field only, the content of all matching header fields else */
801 FL char * hfield_mult(char const *field, struct message *mp, int mult);
802 #define hfieldX(a, b) hfield_mult(a, b, 1)
803 #define hfield1(a, b) hfield_mult(a, b, 0)
805 /* Check whether the passed line is a header line of the desired breed.
806 * Return the field body, or 0 */
807 FL char const * thisfield(char const *linebuf, char const *field);
809 /* Get sender's name from this message. If the message has a bunch of arpanet
810 * stuff in it, we may have to skin the name before returning it */
811 FL char * nameof(struct message *mp, int reptype);
813 /* Start of a "comment". Ignore it */
814 FL char const * skip_comment(char const *cp);
816 /* Return the start of a route-addr (address in angle brackets), if present */
817 FL char const * routeaddr(char const *name);
819 /* Query *expandaddr*, parse it and return flags.
820 * The flags are already adjusted for OPT_INTERACTIVE / OPT_TILDE_FLAG etc. */
821 FL enum expand_addr_flags expandaddr_to_eaf(void);
823 /* Check if an address is invalid, either because it is malformed or, if not,
824 * according to eacm. Return FAL0 when it looks good, TRU1 if it is invalid
825 * but the error condition wasn't covered by a 'hard "fail"ure', -1 otherwise */
826 FL si8_t is_addr_invalid(struct name *np,
827 enum expand_addr_check_mode eacm);
829 /* Does *NP* point to a file or pipe addressee? */
830 #define is_fileorpipe_addr(NP) \
831 (((NP)->n_flags & NAME_ADDRSPEC_ISFILEORPIPE) != 0)
833 /* Return skinned version of *NP*s name */
834 #define skinned_name(NP) \
835 (assert((NP)->n_flags & NAME_SKINNED), \
836 ((struct name const*)NP)->n_name)
838 /* Skin an address according to the RFC 822 interpretation of "host-phrase" */
839 FL char * skin(char const *name);
841 /* Skin *name* and extract the *addr-spec* according to RFC 5322.
842 * Store the result in .ag_skinned and also fill in those .ag_ fields that have
843 * actually been seen.
844 * Return 0 if something good has been parsed, 1 if fun didn't exactly know how
845 * to deal with the input, or if that was plain invalid */
846 FL int addrspec_with_guts(int doskin, char const *name,
847 struct addrguts *agp);
849 /* Fetch the real name from an internet mail address field */
850 FL char * realname(char const *name);
852 /* Fetch the sender's name from the passed message. reptype can be
853 * 0 -- get sender's name for display purposes
854 * 1 -- get sender's name for reply
855 * 2 -- get sender's name for Reply */
856 FL char * name1(struct message *mp, int reptype);
858 /* Trim away all leading Re: etc., return pointer to plain subject.
859 * Note it doesn't perform any MIME decoding by itself */
860 FL char * subject_re_trim(char *cp);
862 FL int msgidcmp(char const *s1, char const *s2);
864 /* Fake Sender for From_ lines if missing, e. g. with POP3 */
865 FL char const * fakefrom(struct message *mp);
867 FL char const * fakedate(time_t t);
869 /* From username Fri Jan 2 20:13:51 2004
870 * | | | | |
871 * 0 5 10 15 20 */
872 #ifdef HAVE_IMAP_SEARCH
873 FL time_t unixtime(char const *from);
874 #endif
876 FL time_t rfctime(char const *date);
878 FL time_t combinetime(int year, int month, int day,
879 int hour, int minute, int second);
881 FL void substdate(struct message *m);
883 /* TODO Weird thing that tries to fill in From: and Sender: */
884 FL void setup_from_and_sender(struct header *hp);
886 /* Note: returns 0x1 if both args were NULL */
887 FL struct name const * check_from_and_sender(struct name const *fromfield,
888 struct name const *senderfield);
890 #ifdef HAVE_XSSL
891 FL char * getsender(struct message *m);
892 #endif
894 /* Fill in / reedit the desired header fields */
895 FL int grab_headers(enum n_lexinput_flags lif, struct header *hp,
896 enum gfield gflags, int subjfirst);
898 /* Check whether sep->ss_sexpr (or ->ss_regex) matches any header of mp */
899 FL bool_t header_match(struct message *mp, struct search_expr const *sep);
901 /* Query *customhdr* */
902 FL struct n_header_field *n_customhdr_query(void);
905 * ignore.c
908 /* `headerpick' */
909 FL int c_headerpick(void *v);
911 /* TODO Compat variants of the c_(un)?h*() series,
912 * except for `retain' and `ignore', which are standardized */
913 FL int c_retain(void *v);
914 FL int c_ignore(void *v);
915 FL int c_unretain(void *v);
916 FL int c_unignore(void *v);
918 FL int c_saveretain(void *v);
919 FL int c_saveignore(void *v);
920 FL int c_unsaveretain(void *v);
921 FL int c_unsaveignore(void *v);
923 FL int c_fwdretain(void *v);
924 FL int c_fwdignore(void *v);
925 FL int c_unfwdretain(void *v);
926 FL int c_unfwdignore(void *v);
928 /* Ignore object lifecycle. (Most of the time this interface deals with
929 * special n_IGNORE_* objects, e.g., n_IGNORE_TYPE, though.)
930 * isauto: whether auto-reclaimed storage is to be used for allocations;
931 * if so, _del() needn't be called */
932 FL struct n_ignore *n_ignore_new(bool_t isauto);
933 FL void n_ignore_del(struct n_ignore *self);
935 /* Are there just _any_ user settings covered by self? */
936 FL bool_t n_ignore_is_any(struct n_ignore const *self);
938 /* Set an entry to retain (or ignore).
939 * Returns FAL0 if dat is not a valid header field name or an invalid regular
940 * expression, TRU1 if insertion took place, and TRUM1 if already set */
941 FL bool_t n_ignore_insert(struct n_ignore *self, bool_t retain,
942 char const *dat, size_t len);
943 #define n_ignore_insert_cp(SELF,RT,CP) n_ignore_insert(SELF, RT, CP, UIZ_MAX)
945 /* Returns TRU1 if retained, TRUM1 if ignored, FAL0 if not covered */
946 FL bool_t n_ignore_lookup(struct n_ignore const *self,
947 char const *dat, size_t len);
948 #define n_ignore_lookup_cp(SELF,CP) n_ignore_lookup(SELF, CP, UIZ_MAX)
949 #define n_ignore_is_ign(SELF,FDAT,FLEN) \
950 (n_ignore_lookup(SELF, FDAT, FLEN) == TRUM1)
953 * imap_search.c
956 /* Return -1 on invalid spec etc., the number of matches otherwise */
957 #ifdef HAVE_IMAP_SEARCH
958 FL ssize_t imap_search(char const *spec, int f);
959 #endif
962 * lex_input.c
965 /* */
966 FL int c_cmdnotsupp(void *v);
968 /* Interpret user commands. If stdin is not a tty, print no prompt; return
969 * whether last processed command returned error; this is *only* for main()! */
970 FL bool_t n_commands(void);
972 /* Actual cmd input */
974 /* Read a complete line of input, with editing if interactive and possible.
975 * If string is set it is used as the initial line content if in interactive
976 * mode, otherwise this argument is ignored for reproducibility.
977 * Return number of octets or a value <0 on error.
978 * Note: may use the currently `source'd file stream instead of stdin!
979 * Manages the PS_READLINE_NL hack */
980 FL int n_lex_input(enum n_lexinput_flags lif, char const *prompt,
981 char **linebuf, size_t *linesize, char const *string
982 n_MEMORY_DEBUG_ARGS);
983 #ifdef HAVE_MEMORY_DEBUG
984 # define n_lex_input(A,B,C,D,E) n_lex_input(A,B,C,D,E,__FILE__,__LINE__)
985 #endif
987 /* Read a line of input, with editing if interactive and possible, return it
988 * savestr()d or NULL in case of errors or if an empty line would be returned.
989 * This may only be called from toplevel (not during PS_ROBOT).
990 * If string is set it is used as the initial line content if in interactive
991 * mode, otherwise this argument is ignored for reproducibility */
992 FL char * n_lex_input_cp(enum n_lexinput_flags lif,
993 char const *prompt, char const *string);
995 /* `read' */
996 FL int c_read(void *v);
998 /* Deal with loading of resource files and dealing with a stack of files for
999 * the source command */
1001 /* Load a file of user definitions -- this is *only* for main()! */
1002 FL void n_load(char const *name);
1004 /* "Load" all the -X command line definitions in order -- *only* for main() */
1005 FL void n_load_Xargs(char const **lines, size_t cnt);
1007 /* Pushdown current input file and switch to a new one. Set the global flag
1008 * PS_SOURCING so that others will realize that they are no longer reading from
1009 * a tty (in all probability).
1010 * The latter won't return failure (TODO should be replaced by "-f FILE") */
1011 FL int c_source(void *v);
1012 FL int c_source_if(void *v);
1014 /* Evaluate a complete macro / a single command. For the former lines will
1015 * always be free()d, for the latter cmd will always be duplicated internally */
1016 FL bool_t n_source_macro(enum n_lexinput_flags lif, char const *name,
1017 char **lines, void (*on_finalize)(void*), void *finalize_arg);
1018 FL bool_t n_source_command(enum n_lexinput_flags lif, char const *cmd);
1020 /* XXX See a_LEX_SLICE in source */
1021 FL void n_source_slice_hack(char const *cmd, FILE *new_stdin,
1022 FILE *new_stdout, ui32_t new_options,
1023 void (*on_finalize)(void*), void *finalize_arg);
1024 FL void n_source_slice_hack_remove_after_jump(void);
1026 /* XXX Hack: may we release our (interactive) (terminal) control to a different
1027 * XXX program, e.g., a $PAGER? */
1028 FL bool_t n_source_may_yield_control(void);
1031 * message.c
1034 /* Return a file buffer all ready to read up the passed message pointer */
1035 FL FILE * setinput(struct mailbox *mp, struct message *m,
1036 enum needspec need);
1038 /* */
1039 FL enum okay get_body(struct message *mp);
1041 /* Reset (free) the global message array */
1042 FL void message_reset(void);
1044 /* Append the passed message descriptor onto the message array; if mp is NULL,
1045 * NULLify the entry at &[msgCount-1] */
1046 FL void message_append(struct message *mp);
1048 /* Append a NULL message */
1049 FL void message_append_null(void);
1051 /* Check whether sep->ss_sexpr (or ->ss_regex) matches mp. If with_headers is
1052 * true then the headers will also be searched (as plain text) */
1053 FL bool_t message_match(struct message *mp, struct search_expr const *sep,
1054 bool_t with_headers);
1056 /* */
1057 FL struct message * setdot(struct message *mp);
1059 /* Touch the named message by setting its MTOUCH flag. Touched messages have
1060 * the effect of not being sent back to the system mailbox on exit */
1061 FL void touch(struct message *mp);
1063 /* Convert user string of message numbers and store the numbers into vector.
1064 * Returns the count of messages picked up or -1 on error */
1065 FL int getmsglist(char *buf, int *vector, int flags);
1067 /* Find the first message whose flags&m==f and return its message number */
1068 FL int first(int f, int m);
1070 /* Mark the named message by setting its mark bit */
1071 FL void mark(int mesg, int f);
1074 * maildir.c
1077 FL int maildir_setfile(char const *name, enum fedit_mode fm);
1079 FL bool_t maildir_quit(bool_t hold_sigs_on);
1081 FL enum okay maildir_append(char const *name, FILE *fp, long offset);
1083 FL enum okay maildir_remove(char const *name);
1086 * main.c
1089 /* Quit quickly. In recursed state, return error to just pop the input level */
1090 FL int c_exit(void *v);
1093 * memory.c
1094 * Heap memory and automatically reclaimed storage, plus pseudo "alloca"
1097 /* Called from the (main)loops upon tick and break-off time to perform debug
1098 * checking and memory cleanup, including stack-top of auto-reclaimed storage */
1099 FL void n_memory_reset(void);
1101 /* Generic heap memory */
1103 FL void * n_alloc(size_t s n_MEMORY_DEBUG_ARGS);
1104 FL void * n_realloc(void *v, size_t s n_MEMORY_DEBUG_ARGS);
1105 FL void * n_calloc(size_t nmemb, size_t size n_MEMORY_DEBUG_ARGS);
1106 FL void n_free(void *vp n_MEMORY_DEBUG_ARGS);
1108 /* TODO obsolete c{m,re,c}salloc -> n_* */
1109 #ifdef HAVE_MEMORY_DEBUG
1110 # define n_alloc(S) (n_alloc)(S, __FILE__, __LINE__)
1111 # define n_realloc(P,S) (n_realloc)(P, S, __FILE__, __LINE__)
1112 # define n_calloc(N,S) (n_calloc)(N, S, __FILE__, __LINE__)
1113 # define n_free(P) (n_free)(P, __FILE__, __LINE__)
1114 # define free(P) (n_free)(P, __FILE__, __LINE__)
1115 #else
1116 # define n_free(P) free(P)
1117 #endif
1118 #define smalloc(SZ) n_alloc(SZ)
1119 #define srealloc(P,SZ) n_realloc(P, SZ)
1120 #define scalloc(N,SZ) n_calloc(N, SZ)
1122 /* Fluctuating heap memory (supposed to exist for one command loop tick) */
1124 #define n_flux_alloc(S) n_alloc(S)
1125 #define n_flux_realloc(P,S) n_realloc(P, S)
1126 #define n_flux_calloc(N,S) n_calloc(N, S)
1127 #define n_flux_free(P) n_free(P)
1129 /* Auto-reclaimed storage */
1131 /* Fixate the current snapshot of our global auto-reclaimed storage instance,
1132 * so that further allocations become auto-reclaimed.
1133 * This is only called from main.c for the global anon arena */
1134 FL void n_memory_autorec_fixate(void);
1136 /* Lifetime management of a per-execution level arena. vp provides
1137 * n_MEMORY_AUTOREC_TYPE_SIZEOF bytes of storage to allocate that.
1138 * Note that anyone can anywhere _push() a storage level, and _pop() will drop
1139 * all possible levels "above" vp, too! */
1140 FL void n_memory_autorec_push(void *vp);
1141 FL void n_memory_autorec_pop(void *vp);
1142 FL void * n_memory_autorec_current(void);
1144 /* Lower memory pressure on auto-reclaimed storage for code which has
1145 * a sinus-curve looking style of memory usage, i.e., peak followed by release,
1146 * like, e.g., doing a task on all messages of a box in order.
1147 * Such code should call srelax_hold(), successively call srelax() after
1148 * a single message has been handled, and finally srelax_rele() */
1149 FL void srelax_hold(void);
1150 FL void srelax_rele(void);
1151 FL void srelax(void);
1153 /* Allocate size more bytes of space and return the address of the first byte
1154 * to the caller. An even number of bytes are always allocated so that the
1155 * space will always be on a word boundary */
1156 FL void * n_autorec_alloc(void *vp, size_t size n_MEMORY_DEBUG_ARGS);
1157 FL void * n_autorec_calloc(void *vp, size_t nmemb, size_t size
1158 n_MEMORY_DEBUG_ARGS);
1159 #ifdef HAVE_MEMORY_DEBUG
1160 # define n_autorec_alloc(VP,SZ) (n_autorec_alloc)(VP, SZ, __FILE__, __LINE__)
1161 # define n_autorec_calloc(VP,NM,SZ) \
1162 (n_autorec_calloc)(VP, NM, SZ, __FILE__, __LINE__)
1163 #endif
1165 /* TODO obsolete c?salloc -> n_autorec_* */
1166 #define salloc(SZ) n_autorec_alloc(NULL, SZ)
1167 #define csalloc(NM,SZ) n_autorec_calloc(NULL, NM, SZ)
1169 /* Pseudo alloca (and also auto-reclaimed in autorec_pop()) */
1170 FL void * n_lofi_alloc(size_t size n_MEMORY_DEBUG_ARGS);
1171 FL void n_lofi_free(void *vp n_MEMORY_DEBUG_ARGS);
1173 #ifdef HAVE_MEMORY_DEBUG
1174 # define n_lofi_alloc(SZ) (n_lofi_alloc)(SZ, __FILE__, __LINE__)
1175 # define n_lofi_free(P) (n_lofi_free)(P, __FILE__, __LINE__)
1176 #endif
1178 /* TODO obsolete ac_alloc / ac_free -> n_lofi_* */
1179 #define ac_alloc(SZ) n_lofi_alloc(SZ)
1180 #define ac_free(P) n_lofi_free(P)
1182 /* */
1183 #ifdef HAVE_MEMORY_DEBUG
1184 FL int c_memtrace(void *v);
1186 /* For immediate debugging purposes, it is possible to check on request */
1187 FL bool_t n__memory_check(char const *file, int line);
1188 # define n_memory_check() n__memory_check(__FILE__, __LINE__)
1189 #else
1190 # define n_memory_check() do{;}while(0)
1191 #endif
1194 * mime.c
1197 /* *charset-7bit*, else CHARSET_7BIT */
1198 FL char const * charset_get_7bit(void);
1200 /* *charset-8bit*, else CHARSET_8BIT */
1201 #ifdef HAVE_ICONV
1202 FL char const * charset_get_8bit(void);
1203 #endif
1205 /* LC_CTYPE:CODESET / *ttycharset*, else *charset-8bit*, else CHARSET_8BIT */
1206 FL char const * charset_get_lc(void);
1208 /* *sendcharsets* .. *charset-8bit* iterator; *a_charset_to_try_first* may be
1209 * used to prepend a charset to this list (e.g., for *reply-in-same-charset*).
1210 * The returned boolean indicates charset_iter_is_valid().
1211 * Without HAVE_ICONV, this "iterates" over charset_get_lc() only */
1212 FL bool_t charset_iter_reset(char const *a_charset_to_try_first);
1213 FL bool_t charset_iter_next(void);
1214 FL bool_t charset_iter_is_valid(void);
1215 FL char const * charset_iter(void);
1217 /* And this is (xxx temporary?) which returns the iterator if that is valid and
1218 * otherwise either charset_get_8bit() or charset_get_lc() dep. on HAVE_ICONV */
1219 FL char const * charset_iter_or_fallback(void);
1221 FL void charset_iter_recurse(char *outer_storage[2]); /* TODO LEGACY */
1222 FL void charset_iter_restore(char *outer_storage[2]); /* TODO LEGACY */
1224 /* Check whether our headers will need MIME conversion */
1225 #ifdef HAVE_ICONV
1226 FL char const * need_hdrconv(struct header *hp);
1227 #endif
1229 /* Convert header fields from RFC 1522 format */
1230 FL void mime_fromhdr(struct str const *in, struct str *out,
1231 enum tdflags flags);
1233 /* Interpret MIME strings in parts of an address field */
1234 FL char * mime_fromaddr(char const *name);
1236 /* fwrite(3) performing the given MIME conversion */
1237 FL ssize_t mime_write(char const *ptr, size_t size, FILE *f,
1238 enum conversion convert, enum tdflags dflags,
1239 struct quoteflt *qf, struct str *outrest,
1240 struct str *inrest);
1241 FL ssize_t xmime_write(char const *ptr, size_t size, /* TODO LEGACY */
1242 FILE *f, enum conversion convert, enum tdflags dflags);
1245 * mime_enc.c
1246 * Content-Transfer-Encodings as defined in RFC 2045 (and RFC 2047):
1247 * - Quoted-Printable, section 6.7
1248 * - Base64, section 6.8
1249 * TODO For now this is pretty mixed up regarding this external interface
1250 * TODO (and due to that the code is, too).
1251 * TODO In v15.0 CTE will be filter based, and explicit conversion will
1252 * TODO gain clear error codes
1255 /* Default MIME Content-Transfer-Encoding: as via *encoding* */
1256 FL enum mime_enc mime_enc_target(void);
1258 /* Map from a Content-Transfer-Encoding: header body (which may be NULL) */
1259 FL enum mime_enc mime_enc_from_ctehead(char const *hbody);
1261 /* XXX Try to get rid of that */
1262 FL char const * mime_enc_from_conversion(enum conversion const convert);
1264 /* How many characters of (the complete body) ln need to be quoted.
1265 * Only MIMEEF_ISHEAD and MIMEEF_ISENCWORD are understood */
1266 FL size_t mime_enc_mustquote(char const *ln, size_t lnlen,
1267 enum mime_enc_flags flags);
1269 /* How much space is necessary to encode len bytes in QP, worst case.
1270 * Includes room for terminator, UIZ_MAX on overflow */
1271 FL size_t qp_encode_calc_size(size_t len);
1273 /* If flags includes QP_ISHEAD these assume "word" input and use special
1274 * quoting rules in addition; soft line breaks are not generated.
1275 * Otherwise complete input lines are assumed and soft line breaks are
1276 * generated as necessary. Return NULL on error (overflow) */
1277 FL struct str * qp_encode(struct str *out, struct str const *in,
1278 enum qpflags flags);
1279 #ifdef notyet
1280 FL struct str * qp_encode_cp(struct str *out, char const *cp,
1281 enum qpflags flags);
1282 FL struct str * qp_encode_buf(struct str *out, void const *vp, size_t vp_len,
1283 enum qpflags flags);
1284 #endif
1286 /* The buffers of out and *rest* will be managed via srealloc().
1287 * If inrest_or_null is needed but NULL an error occurs, otherwise tolerant.
1288 * Return FAL0 on error; caller is responsible to free buffers */
1289 FL bool_t qp_decode_header(struct str *out, struct str const *in);
1290 FL bool_t qp_decode_part(struct str *out, struct str const *in,
1291 struct str *outrest, struct str *inrest_or_null);
1293 /* How much space is necessary to encode len bytes in Base64, worst case.
1294 * Includes room for (CR/LF/CRLF and) terminator, UIZ_MAX on overflow */
1295 FL size_t b64_encode_calc_size(size_t len);
1297 /* Note these simply convert all the input (if possible), including the
1298 * insertion of NL sequences if B64_CRLF or B64_LF is set (and multiple thereof
1299 * if B64_MULTILINE is set).
1300 * Thus, in the B64_BUF case, better call b64_encode_calc_size() first.
1301 * Return NULL on error (overflow; cannot happen for B64_BUF) */
1302 FL struct str * b64_encode(struct str *out, struct str const *in,
1303 enum b64flags flags);
1304 FL struct str * b64_encode_buf(struct str *out, void const *vp, size_t vp_len,
1305 enum b64flags flags);
1306 #ifdef notyet
1307 FL struct str * b64_encode_cp(struct str *out, char const *cp,
1308 enum b64flags flags);
1309 #endif
1311 /* The _{header,part}() variants are failure tolerant, the latter requires
1312 * outrest to be set; due to the odd 4:3 relation inrest_or_null should be
1313 * given, _then_, it is an error if it is needed but not set.
1314 * TODO pre v15 callers should ensure that no endless loop is entered because
1315 * TODO the inrest cannot be converted and ends up as inrest over and over:
1316 * TODO give NULL to stop such loops.
1317 * The buffers of out and possibly *rest* will be managed via srealloc().
1318 * Returns FAL0 on error; caller is responsible to free buffers.
1319 * XXX FAL0 is effectively not returned for _part*() variants,
1320 * XXX (instead replacement characters are produced for invalid data.
1321 * XXX _Unless_ operation could EOVERFLOW.)
1322 * XXX I.e. this is bad and is tolerant for text and otherwise not */
1323 FL bool_t b64_decode(struct str *out, struct str const *in);
1324 FL bool_t b64_decode_header(struct str *out, struct str const *in);
1325 FL bool_t b64_decode_part(struct str *out, struct str const *in,
1326 struct str *outrest, struct str *inrest_or_null);
1329 * mime_param.c
1332 /* Get a mime style parameter from a header body */
1333 FL char * mime_param_get(char const *param, char const *headerbody);
1335 /* Format parameter name to have value, salloc() it or NULL (error) in result.
1336 * 0 on error, 1 or -1 on success: the latter if result contains \n newlines,
1337 * which it will if the created param requires more than MIME_LINELEN bytes;
1338 * there is never a trailing newline character */
1339 /* TODO mime_param_create() should return a StrList<> or something.
1340 * TODO in fact it should take a HeaderField* and append a HeaderFieldParam*! */
1341 FL si8_t mime_param_create(struct str *result, char const *name,
1342 char const *value);
1344 /* Get the boundary out of a Content-Type: multipart/xyz header field, return
1345 * salloc()ed copy of it; store strlen() in *len if set */
1346 FL char * mime_param_boundary_get(char const *headerbody, size_t *len);
1348 /* Create a salloc()ed MIME boundary */
1349 FL char * mime_param_boundary_create(void);
1352 * mime_parse.c
1355 /* Create MIME part object tree for and of mp */
1356 FL struct mimepart * mime_parse_msg(struct message *mp,
1357 enum mime_parse_flags mpf);
1360 * mime_types.c
1363 /* `(un)?mimetype' commands */
1364 FL int c_mimetype(void *v);
1365 FL int c_unmimetype(void *v);
1367 /* Check whether the Content-Type name is internally known */
1368 FL bool_t mime_type_check_mtname(char const *name);
1370 /* Return a Content-Type matching the name, or NULL if none could be found */
1371 FL char * mime_type_classify_filename(char const *name);
1373 /* Classify content of *fp* as necessary and fill in arguments; **charset* is
1374 * left alone unless it's non-NULL */
1375 FL enum conversion mime_type_classify_file(FILE *fp, char const **contenttype,
1376 char const **charset, int *do_iconv);
1378 /* Dependend on *mime-counter-evidence* mpp->m_ct_type_usr_ovwr will be set,
1379 * but otherwise mpp is const */
1380 FL enum mimecontent mime_type_classify_part(struct mimepart *mpp);
1382 /* Query handler for a part, return the plain type (& MIME_HDL_TYPE_MASK).
1383 * mhp is anyway initialized (mh_flags, mh_msg) */
1384 FL enum mime_handler_flags mime_type_handler(struct mime_handler *mhp,
1385 struct mimepart const *mpp,
1386 enum sendaction action);
1389 * nam_a_grp.c
1392 /* Allocate a single element of a name list, initialize its name field to the
1393 * passed name and return it */
1394 FL struct name * nalloc(char const *str, enum gfield ntype);
1396 /* Like nalloc(), but initialize from content of np */
1397 FL struct name * ndup(struct name *np, enum gfield ntype);
1399 /* Concatenate the two passed name lists, return the result */
1400 FL struct name * cat(struct name *n1, struct name *n2);
1402 /* Duplicate np */
1403 FL struct name * namelist_dup(struct name const *np, enum gfield ntype);
1405 /* Determine the number of undeleted elements in a name list and return it;
1406 * the latter also doesn't count file and pipe addressees in addition */
1407 FL ui32_t count(struct name const *np);
1408 FL ui32_t count_nonlocal(struct name const *np);
1410 /* Extract a list of names from a line, and make a list of names from it.
1411 * Return the list or NULL if none found */
1412 FL struct name * extract(char const *line, enum gfield ntype);
1414 /* Like extract() unless line contains anyof ",\"\\(<|", in which case
1415 * comma-separated list extraction is used instead */
1416 FL struct name * lextract(char const *line, enum gfield ntype);
1418 /* Turn a list of names into a string of the same names */
1419 FL char * detract(struct name *np, enum gfield ntype);
1421 /* Get a lextract() list via n_lex_input_cp_addhist(), reassigning to *np* */
1422 FL struct name * grab_names(enum n_lexinput_flags lif, char const *field,
1423 struct name *np, int comma, enum gfield gflags);
1425 /* Check whether n1 n2 share the domain name */
1426 FL bool_t name_is_same_domain(struct name const *n1,
1427 struct name const *n2);
1429 /* Check all addresses in np and delete invalid ones; if set_on_error is not
1430 * NULL it'll be set to TRU1 for error or -1 for "hard fail" error */
1431 FL struct name * checkaddrs(struct name *np, enum expand_addr_check_mode eacm,
1432 si8_t *set_on_error);
1434 /* Vaporise all duplicate addresses in hp (.h_(to|cc|bcc)) so that an address
1435 * that "first" occurs in To: is solely in there, ditto Cc:, after expanding
1436 * aliases etc. eacm and set_on_error are passed to checkaddrs(), metoo is
1437 * passed to usermap(). After updating hp to the new state this returns
1438 * a flat list of all addressees, which may be NULL */
1439 FL struct name * namelist_vaporise_head(struct header *hp,
1440 enum expand_addr_check_mode eacm, bool_t metoo,
1441 si8_t *set_on_error);
1443 /* Map all of the aliased users in the invoker's mailrc file and insert them
1444 * into the list */
1445 FL struct name * usermap(struct name *names, bool_t force_metoo);
1447 /* Remove all of the duplicates from the passed name list by insertion sorting
1448 * them, then checking for dups. Return the head of the new list */
1449 FL struct name * elide(struct name *names);
1451 /* `alternates' deal with the list of alternate names */
1452 FL int c_alternates(void *v);
1454 FL struct name * delete_alternates(struct name *np);
1456 FL int is_myname(char const *name);
1458 /* `(un)?alias' */
1459 FL int c_alias(void *v);
1460 FL int c_unalias(void *v);
1462 /* `(un)?ml(ist|subscribe)', and a check whether a name is a (wanted) list */
1463 FL int c_mlist(void *v);
1464 FL int c_unmlist(void *v);
1465 FL int c_mlsubscribe(void *v);
1466 FL int c_unmlsubscribe(void *v);
1468 FL enum mlist_state is_mlist(char const *name, bool_t subscribed_only);
1470 /* `(un)?shortcut', and check if str is one, return expansion or NULL */
1471 FL int c_shortcut(void *v);
1472 FL int c_unshortcut(void *v);
1474 FL char const * shortcut_expand(char const *str);
1477 * path.c
1480 /* Test to see if the passed file name is a directory, return true if it is */
1481 FL bool_t is_dir(char const *name);
1483 /* Recursively create a directory */
1484 FL bool_t n_path_mkdir(char const *name);
1486 /* Delete a file, but only if the file is a plain file; return FAL0 on system
1487 * error and TRUM1 if name is not a plain file, return TRU1 on success */
1488 FL bool_t n_path_rm(char const *name);
1490 /* A get-wd..restore-wd approach */
1491 FL enum okay cwget(struct cw *cw);
1492 FL enum okay cwret(struct cw *cw);
1493 FL void cwrelse(struct cw *cw);
1496 * pop3.c
1499 #ifdef HAVE_POP3
1500 /* */
1501 FL enum okay pop3_noop(void);
1503 /* */
1504 FL int pop3_setfile(char const *server, enum fedit_mode fm);
1506 /* */
1507 FL enum okay pop3_header(struct message *m);
1509 /* */
1510 FL enum okay pop3_body(struct message *m);
1512 /* */
1513 FL bool_t pop3_quit(bool_t hold_sigs_on);
1514 #endif /* HAVE_POP3 */
1517 * popen.c
1518 * Subprocesses, popen, but also file handling with registering
1521 /* For program startup in main.c: initialize process manager */
1522 FL void command_manager_start(void);
1524 /* Notes: OF_CLOEXEC is implied in oflags, xflags may be NULL */
1525 FL FILE * safe_fopen(char const *file, char const *oflags, int *xflags);
1527 /* Notes: OF_CLOEXEC|OF_REGISTER are implied in oflags!
1528 * Exception is Fdopen() if nocloexec is TRU1, but otherwise even for it the fd
1529 * creator has to take appropriate steps in order to ensure this is true! */
1530 FL FILE * Fopen(char const *file, char const *oflags);
1531 FL FILE * Fdopen(int fd, char const *oflags, bool_t nocloexec);
1533 FL int Fclose(FILE *fp);
1535 /* Open file according to oflags (see popen.c). Handles compressed files */
1536 FL FILE * Zopen(char const *file, char const *oflags);
1538 /* Create a temporary file in *TMPDIR*, use namehint for its name (prefix
1539 * unless OF_SUFFIX is set, in which case namehint is an extension that MUST be
1540 * part of the resulting filename, otherwise Ftmp() will fail), store the
1541 * unique name in fn (unless OF_UNLINK is set in oflags), and return a stdio
1542 * FILE pointer with access oflags. OF_CLOEXEC is implied in oflags.
1543 * One of OF_WRONLY and OF_RDWR must be set. Mode of 0600 is implied */
1544 FL FILE * Ftmp(char **fn, char const *namehint, enum oflags oflags);
1546 /* If OF_HOLDSIGS was set when calling Ftmp(), then hold_all_sigs() had been
1547 * called: call this to unlink(2) and free *fn and to rele_all_sigs() */
1548 FL void Ftmp_release(char **fn);
1550 /* Free the resources associated with the given filename. To be called after
1551 * unlink() */
1552 FL void Ftmp_free(char **fn);
1554 /* Create a pipe and ensure CLOEXEC bit is set in both descriptors */
1555 FL bool_t pipe_cloexec(int fd[2]);
1558 * env_addon may be NULL, otherwise it is expected to be a NULL terminated
1559 * array of "K=V" strings to be placed into the childs environment.
1560 * If cmd==(char*)-1 then shell is indeed expected to be a PTF :P that will be
1561 * called from within the child process */
1562 FL FILE * Popen(char const *cmd, char const *mode, char const *shell,
1563 char const **env_addon, int newfd1);
1564 FL bool_t Pclose(FILE *fp, bool_t dowait);
1566 /* In OPT_INTERACTIVE, we want to go over $PAGER.
1567 * These are specialized version of Popen()/Pclose() which also encapsulate
1568 * error message printing, terminal handling etc. additionally */
1569 FL FILE * n_pager_open(void);
1570 FL bool_t n_pager_close(FILE *fp);
1572 /* */
1573 FL void close_all_files(void);
1575 /* Fork a child process, enable use of the *child() series below */
1576 FL int fork_child(void);
1578 /* Run a command without a shell, with optional arguments and splicing of stdin
1579 * and stdout. FDs may also be COMMAND_FD_NULL and COMMAND_FD_PASS, meaning to
1580 * redirect from/to /dev/null or pass through our own set of FDs; in the
1581 * latter case terminal capabilities are saved/restored if possible.
1582 * The command name can be a sequence of words.
1583 * Signals must be handled by the caller. "Mask" contains the signals to
1584 * ignore in the new process. SIGINT is enabled unless it's in the mask.
1585 * env_addon may be NULL, otherwise it is expected to be a NULL terminated
1586 * array of "K=V" strings to be placed into the childs environment */
1587 FL int run_command(char const *cmd, sigset_t *mask, int infd,
1588 int outfd, char const *a0, char const *a1, char const *a2,
1589 char const **env_addon);
1591 /* Like run_command, but don't wait for the command to finish.
1592 * Also it is usually an error to use COMMAND_FD_PASS for this one */
1593 FL int start_command(char const *cmd, sigset_t *mask, int infd,
1594 int outfd, char const *a0, char const *a1, char const *a2,
1595 char const **env_addon);
1597 /* In-child process */
1598 FL void prepare_child(sigset_t *nset, int infd, int outfd);
1600 /* Mark a child as don't care - pid */
1601 FL void free_child(int pid);
1603 /* Wait for pid, return whether we've had a normal EXIT_SUCCESS exit.
1604 * If wait_status is set, set it to the reported waitpid(2) wait status */
1605 FL bool_t wait_child(int pid, int *wait_status);
1608 * quit.c
1611 /* Save all of the undetermined messages at the top of "mbox". Save all
1612 * untouched messages back in the system mailbox. Remove the system mailbox,
1613 * if none saved there.
1614 * TODO v15 Note: assumes hold_sigs() has been called _and_ can be temporarily
1615 * TODO dropped via a single rele_sigs() if hold_sigs_on */
1616 FL bool_t quit(bool_t hold_sigs_on);
1618 /* Adjust the message flags in each message */
1619 FL int holdbits(void);
1621 /* Create another temporary file and copy user's mbox file darin. If there is
1622 * no mbox, copy nothing. If he has specified "append" don't copy his mailbox,
1623 * just copy saveable entries at the end */
1624 FL enum okay makembox(void);
1626 FL void save_mbox_for_possible_quitstuff(void); /* TODO DROP IF U CAN */
1628 FL int savequitflags(void);
1630 FL void restorequitflags(int);
1633 * send.c
1636 /* Send message described by the passed pointer to the passed output buffer.
1637 * Return -1 on error. Adjust the status: field if need be. If doitp is
1638 * given, suppress ignored header fields. prefix is a string to prepend to
1639 * each output line. action = data destination
1640 * (SEND_MBOX,_TOFILE,_TODISP,_QUOTE,_DECRYPT). stats[0] is line count,
1641 * stats[1] is character count. stats may be NULL. Note that stats[0] is
1642 * valid for SEND_MBOX only */
1643 FL int sendmp(struct message *mp, FILE *obuf,
1644 struct n_ignore const *doitp,
1645 char const *prefix, enum sendaction action, ui64_t *stats);
1648 * sendout.c
1651 /* Interface between the argument list and the mail1 routine which does all the
1652 * dirty work */
1653 FL int mail(struct name *to, struct name *cc, struct name *bcc,
1654 char *subject, struct attachment *attach, char *quotefile,
1655 int recipient_record);
1657 /* `mail' and `Mail' commands, respectively */
1658 FL int c_sendmail(void *v);
1659 FL int c_Sendmail(void *v);
1661 /* Mail a message on standard input to the people indicated in the passed
1662 * header. (Internal interface) */
1663 FL enum okay mail1(struct header *hp, int printheaders,
1664 struct message *quote, char *quotefile, int recipient_record,
1665 int doprefix);
1667 /* Create a Date: header field.
1668 * We compare the localtime() and gmtime() results to get the timezone, because
1669 * numeric timezones are easier to read and because $TZ isn't always set */
1670 FL int mkdate(FILE *fo, char const *field);
1672 /* Dump the to, subject, cc header on the passed file buffer.
1673 * nosend_msg tells us not to dig to deep but to instead go for compose mode or
1674 * editing a message (yet we're stupid and cannot do it any better) - if it is
1675 * TRUM1 then we're really in compose mode and will produce some fields for
1676 * easier filling in */
1677 FL int puthead(bool_t nosend_msg, struct header *hp, FILE *fo,
1678 enum gfield w, enum sendaction action,
1679 enum conversion convert, char const *contenttype,
1680 char const *charset);
1682 /* */
1683 FL enum okay resend_msg(struct message *mp, struct name *to, int add_resent);
1685 /* $DEAD */
1686 FL void savedeadletter(FILE *fp, bool_t fflush_rewind_first);
1689 * shexp.c
1692 /* Evaluate the string given as a new mailbox name. Supported meta characters:
1693 * . % for my system mail box
1694 * . %user for user's system mail box
1695 * . # for previous file
1696 * . & invoker's mbox file
1697 * . +file file in folder directory
1698 * . any shell meta character (except for FEXP_NSHELL).
1699 * a poor man's vis(3), on name before calling this (and showing the user).
1700 * If FEXP_MULTIOK is set we return an array of terminated strings, the (last)
1701 * result string is terminated via \0\0 and PS_EXPAND_MULTIRESULT is set.
1702 * Returns the file name as an auto-reclaimed string */
1703 FL char * fexpand(char const *name, enum fexp_mode fexpm);
1705 #define expand(N) fexpand(N, FEXP_FULL) /* XXX remove these */
1707 /* Parse the next shell token from input (->s and ->l are adjusted to the
1708 * remains, data is constant beside that; ->s may be NULL if ->l is 0, if ->l
1709 * EQ UIZ_MAX strlen(->s) is used) and append the resulting output to store */
1710 FL enum n_shexp_state n_shexp_parse_token(struct n_string *store,
1711 struct str *input, enum n_shexp_parse_flags flags);
1713 /* Likewise, but strips n_SHEXP_STATE_STOP if input remains after parsing,
1714 * otherwise forcefully sets it. Returns autoreclaimed storage */
1715 FL enum n_shexp_state n_shexp_parse_token_buf(char **store,
1716 char const *indat, size_t inlen,
1717 enum n_shexp_parse_flags flags);
1719 /* Quote input in a way that can, in theory, be fed into parse_token() again.
1720 * ->s may be NULL if ->l is 0, if ->l EQ UIZ_MAX strlen(->s) is used.
1721 * If rndtrip is true we try to make the resulting string "portable" (by
1722 * converting Unicode to \u etc.), otherwise we produce something to be
1723 * consumed "now", i.e., to display for the user.
1724 * Resulting output is _appended_ to store.
1725 * TODO Note: last resort, since \u and $ expansions etc. are necessarily
1726 * TODO already expanded and can thus not be reverted, but ALL we have */
1727 FL struct n_string *n_shexp_quote(struct n_string *store,
1728 struct str const *input, bool_t rndtrip);
1729 FL char * n_shexp_quote_cp(char const *cp, bool_t rndtrip);
1731 /* Can name be used as a variable name? */
1732 FL bool_t n_shexp_is_valid_varname(char const *name);
1735 * signal.c
1738 #ifdef HAVE_DEVEL
1739 FL int c_sigstate(void *);
1740 #endif
1742 FL void n_raise(int signo);
1744 /* Provide BSD-like signal() on all systems TODO v15 -> SysV -> n_signal() */
1745 FL sighandler_type safe_signal(int signum, sighandler_type handler);
1747 /* Provide reproducable non-restartable signal handler installation */
1748 FL n_sighdl_t n_signal(int signo, n_sighdl_t hdl);
1750 /* Hold *all* signals but SIGCHLD, and release that total block again */
1751 FL void hold_all_sigs(void);
1752 FL void rele_all_sigs(void);
1754 /* Hold HUP/QUIT/INT */
1755 FL void hold_sigs(void);
1756 FL void rele_sigs(void);
1758 /* Call _ENTER_SWITCH() with the according flags, it'll take care for the rest
1759 * and also set the jump buffer - it returns 0 if anything went fine and
1760 * a signal number if a jump occurred, in which case all handlers requested in
1761 * flags are temporarily SIG_IGN.
1762 * _cleanup_ping() informs the condome that no jumps etc. shall be performed
1763 * until _leave() is called in the following -- to be (optionally) called right
1764 * before the local jump label is reached which is jumped to after a long jump
1765 * occurred, straight code flow provided, e.g., to avoid destructors to be
1766 * called twice. _leave() must always be called last, reraise_flags will be
1767 * used to decide how signal handling has to continue
1769 #define n_SIGMAN_ENTER_SWITCH(S,F) do{\
1770 int __x__;\
1771 hold_sigs();\
1772 if(sigsetjmp((S)->sm_jump, 1))\
1773 __x__ = -1;\
1774 else\
1775 __x__ = F;\
1776 n__sigman_enter(S, __x__);\
1777 }while(0); switch((S)->sm_signo)
1778 FL int n__sigman_enter(struct n_sigman *self, int flags);
1779 FL void n_sigman_cleanup_ping(struct n_sigman *self);
1780 FL void n_sigman_leave(struct n_sigman *self, enum n_sigman_flags flags);
1782 /* Pending signal or 0? */
1783 FL int n_sigman_peek(void);
1784 FL void n_sigman_consume(void);
1786 /* Not-Yet-Dead debug information (handler installation in main.c) */
1787 #if defined HAVE_DEBUG || defined HAVE_DEVEL
1788 FL void _nyd_chirp(ui8_t act, char const *file, ui32_t line,
1789 char const *fun);
1790 FL void _nyd_oncrash(int signo);
1792 # define HAVE_NYD
1793 # define NYD_ENTER _nyd_chirp(1, __FILE__, __LINE__, __FUN__)
1794 # define NYD_LEAVE _nyd_chirp(2, __FILE__, __LINE__, __FUN__)
1795 # define NYD _nyd_chirp(0, __FILE__, __LINE__, __FUN__)
1796 # define NYD_X _nyd_chirp(0, __FILE__, __LINE__, __FUN__)
1797 # ifdef HAVE_NYD2
1798 # define NYD2_ENTER _nyd_chirp(1, __FILE__, __LINE__, __FUN__)
1799 # define NYD2_LEAVE _nyd_chirp(2, __FILE__, __LINE__, __FUN__)
1800 # define NYD2 _nyd_chirp(0, __FILE__, __LINE__, __FUN__)
1801 # endif
1802 #else
1803 # undef HAVE_NYD
1804 #endif
1805 #ifndef NYD
1806 # define NYD_ENTER do {} while (0)
1807 # define NYD_LEAVE do {} while (0)
1808 # define NYD do {} while (0)
1809 # define NYD_X do {} while (0) /* XXX LEGACY */
1810 #endif
1811 #ifndef NYD2
1812 # define NYD2_ENTER do {} while (0)
1813 # define NYD2_LEAVE do {} while (0)
1814 # define NYD2 do {} while (0)
1815 #endif
1818 * smtp.c
1821 #ifdef HAVE_SMTP
1822 /* Send a message via SMTP */
1823 FL bool_t smtp_mta(struct sendbundle *sbp);
1824 #endif
1827 * socket.c
1830 #ifdef HAVE_SOCKETS
1831 FL bool_t sopen(struct sock *sp, struct url *urlp);
1832 FL int sclose(struct sock *sp);
1833 FL enum okay swrite(struct sock *sp, char const *data);
1834 FL enum okay swrite1(struct sock *sp, char const *data, int sz,
1835 int use_buffer);
1837 /* */
1838 FL int sgetline(char **line, size_t *linesize, size_t *linelen,
1839 struct sock *sp n_MEMORY_DEBUG_ARGS);
1840 # ifdef HAVE_MEMORY_DEBUG
1841 # define sgetline(A,B,C,D) sgetline(A, B, C, D, __FILE__, __LINE__)
1842 # endif
1843 #endif
1846 * spam.c
1849 #ifdef HAVE_SPAM
1850 /* Direct mappings of the various spam* commands */
1851 FL int c_spam_clear(void *v);
1852 FL int c_spam_set(void *v);
1853 FL int c_spam_forget(void *v);
1854 FL int c_spam_ham(void *v);
1855 FL int c_spam_rate(void *v);
1856 FL int c_spam_spam(void *v);
1857 #else
1858 # define c_spam_clear c_cmdnotsupp
1859 # define c_spam_set c_cmdnotsupp
1860 # define c_spam_forget c_cmdnotsupp
1861 # define c_spam_ham c_cmdnotsupp
1862 # define c_spam_rate c_cmdnotsupp
1863 # define c_spam_spam c_cmdnotsupp
1864 #endif
1867 * ssl.c
1870 #ifdef HAVE_SSL
1871 /* */
1872 FL void ssl_set_verify_level(struct url const *urlp);
1874 /* */
1875 FL enum okay ssl_verify_decide(void);
1877 /* */
1878 FL enum okay smime_split(FILE *ip, FILE **hp, FILE **bp, long xcount,
1879 int keep);
1881 /* */
1882 FL FILE * smime_sign_assemble(FILE *hp, FILE *bp, FILE *sp,
1883 char const *message_digest);
1885 /* */
1886 FL FILE * smime_encrypt_assemble(FILE *hp, FILE *yp);
1888 /* */
1889 FL struct message * smime_decrypt_assemble(struct message *m, FILE *hp,
1890 FILE *bp);
1892 /* */
1893 FL int c_certsave(void *v);
1895 /* */
1896 FL enum okay rfc2595_hostname_match(char const *host, char const *pattern);
1897 #else /* HAVE_SSL */
1898 # define c_certsave c_cmdnotsupp
1899 #endif
1902 * strings.c
1905 /* Return a pointer to a dynamic copy of the argument */
1906 FL char * savestr(char const *str n_MEMORY_DEBUG_ARGS);
1907 FL char * savestrbuf(char const *sbuf, size_t slen n_MEMORY_DEBUG_ARGS);
1908 #ifdef HAVE_MEMORY_DEBUG
1909 # define savestr(CP) savestr(CP, __FILE__, __LINE__)
1910 # define savestrbuf(CBP,CBL) savestrbuf(CBP, CBL, __FILE__, __LINE__)
1911 #endif
1913 /* Concatenate cp2 onto cp1 (if not NULL), separated by sep (if not '\0') */
1914 FL char * savecatsep(char const *cp1, char sep, char const *cp2
1915 n_MEMORY_DEBUG_ARGS);
1916 #ifdef HAVE_MEMORY_DEBUG
1917 # define savecatsep(S1,SEP,S2) savecatsep(S1, SEP, S2, __FILE__, __LINE__)
1918 #endif
1920 /* Make copy of argument incorporating old one, if set, separated by space */
1921 #define save2str(S,O) savecatsep(O, ' ', S)
1923 /* strcat */
1924 #define savecat(S1,S2) savecatsep(S1, '\0', S2)
1926 /* Create duplicate, lowercasing all characters along the way */
1927 FL char * i_strdup(char const *src n_MEMORY_DEBUG_ARGS);
1928 #ifdef HAVE_MEMORY_DEBUG
1929 # define i_strdup(CP) i_strdup(CP, __FILE__, __LINE__)
1930 #endif
1932 /* */
1933 FL struct str * str_concat_csvl(struct str *self, ...);
1935 /* */
1936 FL struct str * str_concat_cpa(struct str *self, char const * const *cpa,
1937 char const *sep_o_null n_MEMORY_DEBUG_ARGS);
1938 #ifdef HAVE_MEMORY_DEBUG
1939 # define str_concat_cpa(S,A,N) str_concat_cpa(S, A, N, __FILE__, __LINE__)
1940 #endif
1942 /* Plain char* support, not auto-reclaimed (unless noted) */
1944 /* Are any of the characters in the two strings the same? */
1945 FL bool_t n_anyof_buf(char const *template, char const *dat, size_t len);
1946 #define n_anyof_cp(S1,S2) n_anyof_buf(S1, S2, UIZ_MAX)
1947 #define anyof(S1,S2) n_anyof_buf(S1, S2, UIZ_MAX)
1949 /* Treat *iolist as a sep separated list of strings; find and return the
1950 * next entry, trimming surrounding whitespace, and point *iolist to the next
1951 * entry or to NULL if no more entries are contained. If ignore_empty is
1952 * set empty entries are started over.
1953 * See n_shexp_parse_token() for the new way that supports sh(1) quoting.
1954 * Return NULL or an entry */
1955 FL char * n_strsep(char **iolist, char sep, bool_t ignore_empty);
1957 /* Copy a string, lowercasing it as we go; *size* is buffer size of *dest*;
1958 * *dest* will always be terminated unless *size* is 0 */
1959 FL void i_strcpy(char *dest, char const *src, size_t size);
1961 /* Is *as1* a valid prefix of *as2*? */
1962 FL int is_prefix(char const *as1, char const *as2);
1964 /* Backslash quote (" and \) v'alue, and return salloc()ed result */
1965 FL char * string_quote(char const *v);
1967 /* Get (and isolate) the last, possibly quoted part of linebuf, set *needs_list
1968 * to indicate whether getmsglist() et al need to be called to collect
1969 * additional args that remain in linebuf. If strip is true possibly
1970 * surrounding quote characters are removed. Return NULL on "error" */
1971 FL char * laststring(char *linebuf, bool_t *needs_list, bool_t strip);
1973 /* Convert a string to lowercase, in-place and with multibyte-aware */
1974 FL void makelow(char *cp);
1976 /* Is *sub* a substring of *str*, case-insensitive and multibyte-aware? */
1977 FL bool_t substr(char const *str, char const *sub);
1979 /* */
1980 FL char * sstpcpy(char *dst, char const *src);
1981 FL char * sstrdup(char const *cp n_MEMORY_DEBUG_ARGS);
1982 FL char * sbufdup(char const *cp, size_t len n_MEMORY_DEBUG_ARGS);
1983 #ifdef HAVE_MEMORY_DEBUG
1984 # define sstrdup(CP) sstrdup(CP, __FILE__, __LINE__)
1985 # define sbufdup(CP,L) sbufdup(CP, L, __FILE__, __LINE__)
1986 #endif
1988 /* Copy at most dstsize bytes of src to dst and return string length.
1989 * Returns -E2BIG if dst is not large enough; dst will always be terminated
1990 * unless dstsize was 0 on entry */
1991 FL ssize_t n_strscpy(char *dst, char const *src, size_t dstsize);
1993 /* Case-independent ASCII comparisons */
1994 FL int asccasecmp(char const *s1, char const *s2);
1995 FL int ascncasecmp(char const *s1, char const *s2, size_t sz);
1997 /* Case-independent ASCII string find s2 in s1, return it or NULL */
1998 FL char const *asccasestr(char const *s1, char const *s2);
2000 /* Case-independent ASCII check wjether as2 is the initial substring of as1 */
2001 FL bool_t is_asccaseprefix(char const *as1, char const *as2);
2003 /* struct str related support funs TODO _cp->_cs! */
2005 /* *self->s* is srealloc()ed */
2006 #define n_str_dup(S, T) n_str_assign_buf((S), (T)->s, (T)->l)
2008 /* *self->s* is srealloc()ed; if buflen==UIZ_MAX strlen() is called unless buf
2009 * is NULL; buf may be NULL if buflen is 0 */
2010 FL struct str * n_str_assign_buf(struct str *self,
2011 char const *buf, uiz_t buflen n_MEMORY_DEBUG_ARGS);
2012 #define n_str_assign(S, T) n_str_assign_buf(S, (T)->s, (T)->l)
2013 #define n_str_assign_cp(S, CP) n_str_assign_buf(S, CP, UIZ_MAX)
2015 /* *self->s* is srealloc()ed, *self->l* incremented; if buflen==UIZ_MAX
2016 * strlen() is called unless buf is NULL; buf may be NULL if buflen is 0 */
2017 FL struct str * n_str_add_buf(struct str *self, char const *buf, uiz_t buflen
2018 n_MEMORY_DEBUG_ARGS);
2019 #define n_str_add(S, T) n_str_add_buf(S, (T)->s, (T)->l)
2020 #define n_str_add_cp(S, CP) n_str_add_buf(S, CP, UIZ_MAX)
2022 #ifdef HAVE_MEMORY_DEBUG
2023 # define n_str_assign_buf(S,B,BL) n_str_assign_buf(S, B, BL, __FILE__, __LINE__)
2024 # define n_str_add_buf(S,B,BL) n_str_add_buf(S, B, BL, __FILE__, __LINE__)
2025 #endif
2027 /* struct n_string
2028 * May have NULL buffer, may contain embedded NULs */
2030 /* Lifetime. n_string_gut() is optional for _creat_auto() strings */
2031 #define n_string_creat(S) \
2032 ((S)->s_dat = NULL, (S)->s_len = (S)->s_auto = (S)->s_size = 0, (S))
2033 #define n_string_creat_auto(S) \
2034 ((S)->s_dat = NULL, (S)->s_len = (S)->s_size = 0, (S)->s_auto = TRU1, (S))
2035 #define n_string_gut(S) ((S)->s_size != 0 ? (void)n_string_clear(S) : (void)0)
2037 /* Truncate to size, which must be LE current length */
2038 #define n_string_trunc(S,L) \
2039 (assert(UICMP(z, L, <=, (S)->s_len)), (S)->s_len = (ui32_t)(L), (S))
2041 /* Take/Release buffer ownership */
2042 #define n_string_take_ownership(SP,B,S,L) \
2043 (assert((SP)->s_dat == NULL), assert((S) == 0 || (B) != NULL),\
2044 assert((L) < (S) || (L) == 0),\
2045 (SP)->s_dat = (B), (SP)->s_len = (L), (SP)->s_size = (S), (SP))
2046 #define n_string_drop_ownership(SP) \
2047 ((SP)->s_dat = NULL, (SP)->s_len = (SP)->s_size = 0, (SP))
2049 /* Release all memory */
2050 FL struct n_string *n_string_clear(struct n_string *self n_MEMORY_DEBUG_ARGS);
2052 #ifdef HAVE_MEMORY_DEBUG
2053 # define n_string_clear(S) \
2054 ((S)->s_size != 0 ? (n_string_clear)(S, __FILE__, __LINE__) : (S))
2055 #else
2056 # define n_string_clear(S) ((S)->s_size != 0 ? (n_string_clear)(S) : (S))
2057 #endif
2059 /* Reserve room for noof additional bytes, but don't adjust length (yet) */
2060 FL struct n_string *n_string_reserve(struct n_string *self, size_t noof
2061 n_MEMORY_DEBUG_ARGS);
2063 /* Resize to exactly nlen bytes; any new storage isn't initialized */
2064 FL struct n_string *n_string_resize(struct n_string *self, size_t nlen
2065 n_MEMORY_DEBUG_ARGS);
2067 #ifdef HAVE_MEMORY_DEBUG
2068 # define n_string_reserve(S,N) (n_string_reserve)(S, N, __FILE__, __LINE__)
2069 # define n_string_resize(S,N) (n_string_resize)(S, N, __FILE__, __LINE__)
2070 #endif
2072 /* */
2073 FL struct n_string *n_string_push_buf(struct n_string *self, char const *buf,
2074 size_t buflen n_MEMORY_DEBUG_ARGS);
2075 #define n_string_push(S, T) n_string_push_buf(S, (T)->s_len, (T)->s_dat)
2076 #define n_string_push_cp(S,CP) n_string_push_buf(S, CP, UIZ_MAX)
2077 FL struct n_string *n_string_push_c(struct n_string *self, char c
2078 n_MEMORY_DEBUG_ARGS);
2080 #define n_string_assign(S,T) ((S)->s_len = 0, n_string_push(S, T))
2081 #define n_string_assign_cp(S,CP) ((S)->s_len = 0, n_string_push_cp(S, CP))
2082 #define n_string_assign_buf(S,B,BL) \
2083 ((S)->s_len = 0, n_string_push_buf(S, B, BL))
2085 #ifdef HAVE_MEMORY_DEBUG
2086 # define n_string_push_buf(S,B,BL) \
2087 n_string_push_buf(S, B, BL, __FILE__, __LINE__)
2088 # define n_string_push_c(S,C) n_string_push_c(S, C, __FILE__, __LINE__)
2089 #endif
2091 /* */
2092 FL struct n_string *n_string_unshift_buf(struct n_string *self, char const *buf,
2093 size_t buflen n_MEMORY_DEBUG_ARGS);
2094 #define n_string_unshift(S,T) \
2095 n_string_unshift_buf(S, (T)->s_len, (T)->s_dat)
2096 #define n_string_unshift_cp(S,CP) \
2097 n_string_unshift_buf(S, CP, UIZ_MAX)
2098 FL struct n_string *n_string_unshift_c(struct n_string *self, char c
2099 n_MEMORY_DEBUG_ARGS);
2101 #ifdef HAVE_MEMORY_DEBUG
2102 # define n_string_unshift_buf(S,B,BL) \
2103 n_string_unshift_buf(S,B,BL, __FILE__, __LINE__)
2104 # define n_string_unshift_c(S,C) n_string_unshift_c(S, C, __FILE__, __LINE__)
2105 #endif
2107 /* */
2108 FL struct n_string *n_string_insert_buf(struct n_string *self, size_t idx,
2109 char const *buf, size_t buflen n_MEMORY_DEBUG_ARGS);
2110 #define n_string_insert(S,I,T) \
2111 n_string_insert_buf(S, I, (T)->s_len, (T)->s_dat)
2112 #define n_string_insert_cp(S,I,CP) \
2113 n_string_insert_buf(S, I, CP, UIZ_MAX)
2114 FL struct n_string *n_string_insert_c(struct n_string *self, size_t idx,
2115 char c n_MEMORY_DEBUG_ARGS);
2117 #ifdef HAVE_MEMORY_DEBUG
2118 # define n_string_insert_buf(S,I,B,BL) \
2119 n_string_insert_buf(S, I, B, BL, __FILE__, __LINE__)
2120 # define n_string_insert_c(S,I,C) n_string_insert_c(S, I, C, __FILE__, __LINE__)
2121 #endif
2123 /* */
2124 FL struct n_string *n_string_cut(struct n_string *self, size_t idx, size_t len);
2126 /* Ensure self has a - NUL terminated - buffer, and return that.
2127 * The latter may return the pointer to an internal empty RODATA instead */
2128 FL char * n_string_cp(struct n_string *self n_MEMORY_DEBUG_ARGS);
2129 FL char const *n_string_cp_const(struct n_string const *self);
2131 #ifdef HAVE_MEMORY_DEBUG
2132 # define n_string_cp(S) n_string_cp(S, __FILE__, __LINE__)
2133 #endif
2135 #ifdef HAVE_INLINE
2136 n_INLINE struct n_string *
2137 (n_string_creat)(struct n_string *self){
2138 return n_string_creat(self);
2140 # undef n_string_creat
2142 n_INLINE struct n_string *
2143 (n_string_creat_auto)(struct n_string *self){
2144 return n_string_creat_auto(self);
2146 # undef n_string_creat_auto
2148 n_INLINE void
2149 (n_string_gut)(struct n_string *self){
2150 n_string_gut(self);
2152 # undef n_string_gut
2154 n_INLINE struct n_string *
2155 (n_string_trunc)(struct n_string *self, size_t l){
2156 return n_string_trunc(self, l);
2158 # undef n_string_trunc
2160 n_INLINE struct n_string *
2161 (n_string_drop_ownership)(struct n_string *self){
2162 return n_string_drop_ownership(self);
2164 # undef n_string_drop_ownership
2165 #endif /* HAVE_INLINE */
2167 /* UTF-8 / UTF-32 stuff */
2169 /* ..and update arguments to point after range; returns UI32_MAX on error, in
2170 * which case the arguments will have been stepped one byte */
2171 FL ui32_t n_utf8_to_utf32(char const **bdat, size_t *blen);
2173 /* buf must be large enough also for NUL, it's new length will be returned */
2174 FL size_t n_utf32_to_utf8(ui32_t c, char *buf);
2176 /* Our iconv(3) wrappers */
2178 #ifdef HAVE_ICONV
2179 FL iconv_t n_iconv_open(char const *tocode, char const *fromcode);
2180 /* If *cd* == *iconvd*, assigns -1 to the latter */
2181 FL void n_iconv_close(iconv_t cd);
2183 /* Reset encoding state */
2184 FL void n_iconv_reset(iconv_t cd);
2186 /* iconv(3), but return errno or 0 upon success.
2187 * The errno may be ENOENT unless n_ICONV_IGN_NOREVERSE is set in icf.
2188 * iconv_str() auto-grows on E2BIG errors; in and in_rest_or_null may be the
2189 * same object.
2190 * Note: EINVAL (incomplete sequence at end of input) is NOT handled, so the
2191 * replacement character must be added manually if that happens at EOF! */
2192 FL int n_iconv_buf(iconv_t cd, enum n_iconv_flags icf,
2193 char const **inb, size_t *inbleft,
2194 char **outb, size_t *outbleft);
2195 FL int n_iconv_str(iconv_t icp, enum n_iconv_flags icf,
2196 struct str *out, struct str const *in,
2197 struct str *in_rest_or_null);
2199 /* If tocode==NULL, uses charset_get_lc(). If fromcode==NULL, uses UTF-8.
2200 * Returns a salloc()ed buffer or NULL */
2201 FL char * n_iconv_onetime_cp(enum n_iconv_flags icf,
2202 char const *tocode, char const *fromcode, char const *input);
2203 #endif
2206 * termcap.c
2207 * This is a little bit hairy since it provides some stuff even if HAVE_TERMCAP
2208 * is false due to encapsulation desire
2211 #ifdef n_HAVE_TCAP
2212 /* termcap(3) / xy lifetime handling -- only called if we're OPT_INTERACTIVE
2213 * but not doing something in OPT_QUICKRUN_MASK */
2214 FL void n_termcap_init(void);
2215 FL void n_termcap_destroy(void);
2217 /* enter_ca_mode / enable keypad (both if possible).
2218 * TODO When complete is not set we won't enter_ca_mode, for example: we don't
2219 * TODO want a complete screen clearance after $PAGER returned after displaying
2220 * TODO a mail, because otherwise the screen would look differently for normal
2221 * TODO stdout display messages. Etc. */
2222 # ifdef HAVE_TERMCAP
2223 FL void n_termcap_resume(bool_t complete);
2224 FL void n_termcap_suspend(bool_t complete);
2226 # define n_TERMCAP_RESUME(CPL) n_termcap_resume(CPL)
2227 # define n_TERMCAP_SUSPEND(CPL) n_termcap_suspend(CPL)
2228 # else
2229 # define n_TERMCAP_RESUME(CPL)
2230 # define n_TERMCAP_SUSPEND(CPL)
2231 # endif
2233 /* Command multiplexer, returns FAL0 on I/O error, TRU1 on success and TRUM1
2234 * for commands which are not available and have no builtin fallback.
2235 * For query options the return represents a true value and -1 error.
2236 * Will return FAL0 directly unless we've been initialized.
2237 * By convention unused argument slots are given as -1 */
2238 FL ssize_t n_termcap_cmd(enum n_termcap_cmd cmd, ssize_t a1, ssize_t a2);
2239 # define n_termcap_cmdx(CMD) n_termcap_cmd(CMD, -1, -1)
2241 /* Query multiplexer. If query is n__TERMCAP_QUERY_MAX1 then
2242 * tvp->tv_data.tvd_string must contain the name of the query to look up; this
2243 * is used to lookup just about *any* (string) capability.
2244 * Returns TRU1 on success and TRUM1 for queries for which a builtin default
2245 * is returned; FAL0 is returned on non-availability */
2246 FL bool_t n_termcap_query(enum n_termcap_query query,
2247 struct n_termcap_value *tvp);
2249 /* Get a n_termcap_query for name or -1 if it is not known, and -2 if
2250 * type wasn't _NONE and the type doesn't match. */
2251 # ifdef HAVE_KEY_BINDINGS
2252 FL si32_t n_termcap_query_for_name(char const *name,
2253 enum n_termcap_captype type);
2254 FL char const *n_termcap_name_of_query(enum n_termcap_query query);
2255 # endif
2256 #endif /* n_HAVE_TCAP */
2259 * thread.c
2262 /* */
2263 FL int c_thread(void *vp);
2265 /* */
2266 FL int c_unthread(void *vp);
2268 /* */
2269 FL struct message * next_in_thread(struct message *mp);
2270 FL struct message * prev_in_thread(struct message *mp);
2271 FL struct message * this_in_thread(struct message *mp, long n);
2273 /* Sorted mode is internally just a variant of threaded mode with all m_parent
2274 * and m_child links being NULL */
2275 FL int c_sort(void *vp);
2277 /* */
2278 FL int c_collapse(void *v);
2279 FL int c_uncollapse(void *v);
2281 /* */
2282 FL void uncollapse1(struct message *mp, int always);
2285 * tty.c
2288 /* Return whether user says yes, on STDIN if interactive.
2289 * Uses noninteract_default, the return value for non-interactive use cases,
2290 * as a hint for boolify() and chooses the yes/no string to append to prompt
2291 * accordingly. If prompt is NULL "Continue" is used instead.
2292 * Handles+reraises SIGINT */
2293 FL bool_t getapproval(char const *prompt, bool_t noninteract_default);
2295 #ifdef HAVE_SOCKETS
2296 /* Get a password the expected way, return termios_state.ts_linebuf on
2297 * success or NULL on error */
2298 FL char * getuser(char const *query);
2300 /* Get a password the expected way, return termios_state.ts_linebuf on
2301 * success or NULL on error. SIGINT is temporarily blocked, *not* reraised.
2302 * termios_state_reset() (def.h) must be called anyway */
2303 FL char * getpassword(char const *query);
2304 #endif
2306 /* Create the prompt and return its visual width in columns, which may be 0
2307 * if evaluation is disabled etc. The data is placed in store.
2308 * xprompt is inspected only if prompt is enabled and no *prompt* evaluation
2309 * takes place */
2310 FL ui32_t n_tty_create_prompt(struct n_string *store,
2311 char const *xprompt, enum n_lexinput_flags lif);
2313 /* At least readline(3) (formerly supported) desires to handle SIGWINCH and
2314 * install its own handler */
2315 #if 0
2316 # define TTY_WANTS_SIGWINCH
2317 #endif
2319 /* Overall interactive terminal life cycle for command line editor library */
2320 FL void n_tty_init(void);
2321 FL void n_tty_destroy(void);
2323 /* Rather for main.c / SIGWINCH interaction only */
2324 FL void n_tty_signal(int sig);
2326 /* Read a line after printing prompt (if set and non-empty).
2327 * If n>0 assumes that *linebuf has n bytes of default content.
2328 * Only the _CTX_ bits in lif are used */
2329 FL int n_tty_readline(enum n_lexinput_flags lif, char const *prompt,
2330 char **linebuf, size_t *linesize, size_t n
2331 n_MEMORY_DEBUG_ARGS);
2332 #ifdef HAVE_MEMORY_DEBUG
2333 # define n_tty_readline(A,B,C,D,E) (n_tty_readline)(A,B,C,D,E,__FILE__,__LINE__)
2334 #endif
2336 /* Add a line (most likely as returned by n_tty_readline()) to the history.
2337 * Whether an entry added for real depends on the isgabby / *history-gabby*
2338 * relation, and / or whether s is non-empty and doesn't begin with spacechar() */
2339 FL void n_tty_addhist(char const *s, bool_t isgabby);
2341 #ifdef HAVE_HISTORY
2342 FL int c_history(void *v);
2343 #else
2344 # define c_history c_cmdnotsupp
2345 #endif
2347 /* `bind' and `unbind' */
2348 #ifdef HAVE_KEY_BINDINGS
2349 FL int c_bind(void *v);
2350 FL int c_unbind(void *v);
2351 #else
2352 # define c_bind c_cmdnotsupp
2353 # define c_unbind c_cmdnotsupp
2354 #endif
2357 * ui_str.c
2360 /* Parse (onechar of) a given buffer, and generate infos along the way.
2361 * If _WOUT_CREATE is set in vif, .vic_woudat will be NUL terminated!
2362 * vicp must be zeroed before first use */
2363 FL bool_t n_visual_info(struct n_visual_info_ctx *vicp,
2364 enum n_visual_info_flags vif);
2366 /* Check (multibyte-safe) how many bytes of buf (which is blen byts) can be
2367 * safely placed in a buffer (field width) of maxlen bytes */
2368 FL size_t field_detect_clip(size_t maxlen, char const *buf, size_t blen);
2370 /* Place cp in a salloc()ed buffer, column-aligned; for header display only */
2371 FL char * colalign(char const *cp, int col, int fill,
2372 int *cols_decr_used_or_null);
2374 /* Convert a string to a displayable one;
2375 * prstr() returns the result savestr()d, prout() writes it */
2376 FL void makeprint(struct str const *in, struct str *out);
2377 FL size_t delctrl(char *cp, size_t len);
2378 FL char * prstr(char const *s);
2379 FL int prout(char const *s, size_t sz, FILE *fp);
2381 /* Print out a Unicode character or a substitute for it, return 0 on error or
2382 * wcwidth() (or 1) on success */
2383 FL size_t putuc(int u, int c, FILE *fp);
2385 /* Check whether bidirectional info maybe needed for blen bytes of bdat */
2386 FL bool_t bidi_info_needed(char const *bdat, size_t blen);
2388 /* Create bidirectional text encapsulation information; without HAVE_NATCH_CHAR
2389 * the strings are always empty */
2390 FL void bidi_info_create(struct bidi_info *bip);
2393 * urlcrecry.c
2396 /* URL en- and decoding according to (enough of) RFC 3986 (RFC 1738).
2397 * These return a newly salloc()ated result, or NULL on length excess */
2398 FL char * urlxenc(char const *cp, bool_t ispath n_MEMORY_DEBUG_ARGS);
2399 FL char * urlxdec(char const *cp n_MEMORY_DEBUG_ARGS);
2400 #ifdef HAVE_MEMORY_DEBUG
2401 # define urlxenc(CP,P) urlxenc(CP, P, __FILE__, __LINE__)
2402 # define urlxdec(CP) urlxdec(CP, __FILE__, __LINE__)
2403 #endif
2405 /* `urlcodec' */
2406 FL int c_urlcodec(void *v);
2408 FL int c_urlencode(void *v); /* TODO obsolete*/
2409 FL int c_urldecode(void *v); /* TODO obsolete */
2411 /* Parse a RFC 6058 'mailto' URI to a single to: (TODO yes, for now hacky).
2412 * Return NULL or something that can be converted to a struct name */
2413 FL char * url_mailto_to_address(char const *mailtop);
2415 /* Return port for proto (and set irv_or_null), or NULL if unknown.
2416 * For file:// this returns an empty string */
2417 FL char const *n_servbyname(char const *proto, ui16_t *irv_or_null);
2419 #ifdef HAVE_SOCKETS
2420 /* Parse data, which must meet the criteria of the protocol cproto, and fill
2421 * in the URL structure urlp (URL rather according to RFC 3986) */
2422 FL bool_t url_parse(struct url *urlp, enum cproto cproto,
2423 char const *data);
2425 /* Zero ccp and lookup credentials for communicating with urlp.
2426 * Return whether credentials are available and valid (for chosen auth) */
2427 FL bool_t ccred_lookup(struct ccred *ccp, struct url *urlp);
2428 FL bool_t ccred_lookup_old(struct ccred *ccp, enum cproto cproto,
2429 char const *addr);
2430 #endif /* HAVE_SOCKETS */
2432 /* `netrc' */
2433 #ifdef HAVE_NETRC
2434 FL int c_netrc(void *v);
2435 #else
2436 # define c_netrc c_cmdnotsupp
2437 #endif
2439 /* MD5 (RFC 1321) related facilities */
2440 #ifdef HAVE_MD5
2441 # ifdef HAVE_XSSL_MD5
2442 # define md5_ctx MD5_CTX
2443 # define md5_init MD5_Init
2444 # define md5_update MD5_Update
2445 # define md5_final MD5_Final
2446 # else
2447 /* The function definitions are instantiated in main.c */
2448 # include "rfc1321.h"
2449 # endif
2451 /* Store the MD5 checksum as a hexadecimal string in *hex*, *not* terminated,
2452 * using lowercase ASCII letters as defined in RFC 2195 */
2453 # define MD5TOHEX_SIZE 32
2454 FL char * md5tohex(char hex[MD5TOHEX_SIZE], void const *vp);
2456 /* CRAM-MD5 encode the *user* / *pass* / *b64* combo; NULL on overflow error */
2457 FL char * cram_md5_string(struct str const *user, struct str const *pass,
2458 char const *b64);
2460 /* RFC 2104: HMAC: Keyed-Hashing for Message Authentication.
2461 * unsigned char *text: pointer to data stream
2462 * int text_len : length of data stream
2463 * unsigned char *key : pointer to authentication key
2464 * int key_len : length of authentication key
2465 * caddr_t digest : caller digest to be filled in */
2466 FL void hmac_md5(unsigned char *text, int text_len, unsigned char *key,
2467 int key_len, void *digest);
2468 #endif /* HAVE_MD5 */
2471 * xssl.c
2474 #ifdef HAVE_XSSL
2475 /* */
2476 FL enum okay ssl_open(struct url const *urlp, struct sock *sp);
2478 /* */
2479 FL void ssl_gen_err(char const *fmt, ...);
2481 /* */
2482 FL int c_verify(void *vp);
2484 /* */
2485 FL FILE * smime_sign(FILE *ip, char const *addr);
2487 /* */
2488 FL FILE * smime_encrypt(FILE *ip, char const *certfile, char const *to);
2490 FL struct message * smime_decrypt(struct message *m, char const *to,
2491 char const *cc, bool_t is_a_verify_call);
2493 /* */
2494 FL enum okay smime_certsave(struct message *m, int n, FILE *op);
2496 #else /* HAVE_XSSL */
2497 # define c_verify c_cmdnotsupp
2498 #endif
2500 #ifndef HAVE_AMALGAMATION
2501 # undef FL
2502 # define FL
2503 #endif
2505 /* s-it-mode */