unsigned int unowned : 1; /* don't unlink on detach */
} ATTACHPTR;
-ATTACHPTR **mutt_gen_attach_list (BODY *, int, ATTACHPTR **, short *, short *,
- int, int);
-void mutt_update_tree (ATTACHPTR **, short);
-int mutt_view_attachment (FILE*, BODY *, int, HEADER *, ATTACHPTR **, short);
-
-int mutt_tag_attach (MUTTMENU *menu, int n, int m);
-int mutt_attach_display_loop (MUTTMENU *menu, int op, FILE *fp, HEADER *hdr,
- BODY *cur, ATTACHPTR ***idxp, short *idxlen, short *idxmax,
- int recv);
-
-
-void mutt_save_attachment_list (FILE *fp, int tag, BODY *top, HEADER *hdr, MUTTMENU *menu);
-void mutt_pipe_attachment_list (FILE *fp, int tag, BODY *top, int filter);
-void mutt_print_attachment_list (FILE *fp, int tag, BODY *top);
-
-void mutt_attach_bounce (FILE *, HEADER *, ATTACHPTR **, short, BODY *);
-void mutt_attach_resend (FILE *, HEADER *, ATTACHPTR **, short, BODY *);
-void mutt_attach_forward (FILE *, HEADER *, ATTACHPTR **, short, BODY *, int);
-void mutt_attach_reply (FILE *, HEADER *, ATTACHPTR **, short, BODY *, int);
-
+ATTACHPTR **mutt_gen_attach_list(BODY *m, int parent_type, ATTACHPTR **idx,
+ short *idxlen, short *idxmax, int level, int compose);
+void mutt_update_tree(ATTACHPTR **idx, short idxlen);
+int mutt_view_attachment(FILE *fp, BODY *a, int flag, HEADER *hdr,
+ ATTACHPTR **idx, short idxlen);
+
+int mutt_tag_attach(MUTTMENU *menu, int n, int m);
+int mutt_attach_display_loop(MUTTMENU *menu, int op, FILE *fp, HEADER *hdr, BODY *cur,
+ ATTACHPTR ***idxp, short *idxlen, short *idxmax, int recv);
+
+void mutt_save_attachment_list(FILE *fp, int tag, BODY *top, HEADER *hdr, MUTTMENU *menu);
+void mutt_pipe_attachment_list(FILE *fp, int tag, BODY *top, int filter);
+void mutt_print_attachment_list(FILE *fp, int tag, BODY *top);
+
+void mutt_attach_bounce(FILE *fp, HEADER *hdr, ATTACHPTR **idx, short idxlen, BODY *cur);
+void mutt_attach_resend(FILE *fp, HEADER *hdr, ATTACHPTR **idx, short idxlen, BODY *cur);
+void mutt_attach_forward(FILE *fp, HEADER *hdr, ATTACHPTR **idx, short idxlen,
+ BODY *cur, int flags);
+void mutt_attach_reply(FILE *fp, HEADER *hdr, ATTACHPTR **idx, short idxlen,
+ BODY *cur, int flags);
#endif /* _ATTACH_H_ */
#define MUTT_TOKEN_COMMENT (1<<5) /* don't reap comments */
#define MUTT_TOKEN_SEMICOLON (1<<6) /* don't treat ; as special */
-BUFFER *mutt_buffer_new (void);
-BUFFER * mutt_buffer_init (BUFFER *);
-BUFFER * mutt_buffer_from (char *);
-void mutt_buffer_free(BUFFER **);
-int mutt_buffer_printf (BUFFER*, const char*, ...);
-void mutt_buffer_addstr (BUFFER* buf, const char* s);
-void mutt_buffer_addch (BUFFER* buf, char c);
-int mutt_extract_token (BUFFER *, BUFFER *, int);
+BUFFER *mutt_buffer_new(void);
+BUFFER *mutt_buffer_init(BUFFER *b);
+BUFFER *mutt_buffer_from(char *seed);
+void mutt_buffer_free(BUFFER **p);
+int mutt_buffer_printf(BUFFER *buf, const char *fmt, ...);
+void mutt_buffer_addstr(BUFFER *buf, const char *s);
+void mutt_buffer_addch(BUFFER *buf, char c);
+int mutt_extract_token(BUFFER *dest, BUFFER *tok, int flags);
#endif
/* mark mailbox just left as already notified */
void mutt_buffy_setnotified (const char *path);
-int mh_buffy (BUFFY *, int);
+int mh_buffy (BUFFY *mailbox, int check_stats);
#endif /* _BUFFY_H */
#include <iconv.h>
-int mutt_convert_string (char **, const char *, const char *, int);
+int mutt_convert_string (char **ps, const char *from, const char *to, int flags);
-iconv_t mutt_iconv_open (const char *, const char *, int);
-size_t mutt_iconv (iconv_t, ICONV_CONST char **, size_t *, char **, size_t *, ICONV_CONST char **, const char *);
+iconv_t mutt_iconv_open (const char *tocode, const char *fromcode, int flags);
+size_t mutt_iconv (iconv_t cd, ICONV_CONST char **inbuf, size_t *inbytesleft,
+ char **outbuf, size_t *outbytesleft,
+ ICONV_CONST char **inrepls, const char *outrepl);
typedef void * FGETCONV;
-FGETCONV *fgetconv_open (FILE *, const char *, const char *, int);
-int fgetconv (FGETCONV *);
-char * fgetconvs (char *, size_t, FGETCONV *);
-void fgetconv_close (FGETCONV **);
+FGETCONV *fgetconv_open (FILE *file, const char *from, const char *to, int flags);
+int fgetconv (FGETCONV *_fc);
+char *fgetconvs (char *buf, size_t l, FGETCONV *_fc);
+void fgetconv_close (FGETCONV **_fc);
void mutt_set_langinfo_charset (void);
char *mutt_get_default_charset (void);
#define CH_UPDATE_LABEL (1<<19) /* update X-Label: from hdr->env->x_label? */
#define CH_VIRTUAL (1<<20) /* write virtual header lines too */
+int mutt_copy_hdr(FILE *in, FILE *out, LOFF_T off_start, LOFF_T off_end,
+ int flags, const char *prefix);
-int mutt_copy_hdr (FILE *, FILE *, LOFF_T, LOFF_T, int, const char *);
+int mutt_copy_header(FILE *in, HEADER *h, FILE *out, int flags, const char *prefix);
-int mutt_copy_header (FILE *, HEADER *, FILE *, int, const char *);
+int _mutt_copy_message(FILE *fpout, FILE *fpin, HEADER *hdr, BODY *body,
+ int flags, int chflags);
-int _mutt_copy_message (FILE *fpout,
- FILE *fpin,
- HEADER *hdr,
- BODY *body,
- int flags,
- int chflags);
+int mutt_copy_message(FILE *fpout, CONTEXT *src, HEADER *hdr, int flags, int chflags);
-int mutt_copy_message (FILE *fpout,
- CONTEXT *src,
- HEADER *hdr,
- int flags,
- int chflags);
-
-int mutt_append_message (CONTEXT *dest,
- CONTEXT *src,
- HEADER *hdr,
- int cmflags,
- int chflags);
+int mutt_append_message(CONTEXT *dest, CONTEXT *src, HEADER *hdr, int cmflags, int chflags);
mutt_clear_error ();
}
-void mutt_init_windows ()
+void mutt_init_windows (void)
{
MuttHelpWindow = safe_calloc (sizeof (mutt_window_t), 1);
MuttIndexWindow = safe_calloc (sizeof (mutt_window_t), 1);
#endif
}
-void mutt_free_windows ()
+void mutt_free_windows (void)
{
FREE (&MuttHelpWindow);
FREE (&MuttIndexWindow);
#include <unistd.h>
#include <stdio.h>
-pid_t
-mutt_create_filter_fd (const char *cmd, FILE **in, FILE **out, FILE **err,
- int fdin, int fdout, int fderr);
-pid_t mutt_create_filter (const char *s, FILE **in, FILE **out, FILE **err);
-int mutt_wait_filter (pid_t pid);
+pid_t mutt_create_filter_fd(const char *cmd, FILE **in, FILE **out, FILE **err,
+ int fdin, int fdout, int fderr);
+pid_t mutt_create_filter(const char *s, FILE **in, FILE **out, FILE **err);
+int mutt_wait_filter(pid_t pid);
#endif
#define MUTT_GROUP 0
#define MUTT_UNGROUP 1
-void mutt_group_context_add (group_context_t **ctx, group_t *group);
-void mutt_group_context_destroy (group_context_t **ctx);
-void mutt_group_context_add_adrlist (group_context_t *ctx, ADDRESS *a);
-int mutt_group_context_add_rx (group_context_t *ctx, const char *s, int flags, BUFFER *err);
+void mutt_group_context_add(group_context_t **ctx, group_t *group);
+void mutt_group_context_destroy(group_context_t **ctx);
+void mutt_group_context_add_adrlist(group_context_t *ctx, ADDRESS *a);
+int mutt_group_context_add_rx(group_context_t *ctx, const char *s, int flags, BUFFER *err);
-int mutt_group_match (group_t *g, const char *s);
+int mutt_group_match(group_t *g, const char *s);
-int mutt_group_context_clear (group_context_t **ctx);
-int mutt_group_context_remove_rx (group_context_t *ctx, const char *s);
-int mutt_group_context_remove_adrlist (group_context_t *ctx, ADDRESS *);
+int mutt_group_context_clear(group_context_t **ctx);
+int mutt_group_context_remove_rx(group_context_t *ctx, const char *s);
+int mutt_group_context_remove_adrlist(group_context_t *ctx, ADDRESS *a);
#endif /* _MUTT_GROUP_H_ */
HASH *hash_create (int nelem, int flags);
HASH *int_hash_create (int nelem, int flags);
-int hash_insert (HASH * table, const char *key, void *data);
-int int_hash_insert (HASH *table, unsigned int key, void *data);
-HASH *hash_resize (HASH * table, int nelem, int lower);
+int hash_insert(HASH *table, const char *strkey, void *data);
+int int_hash_insert(HASH *table, unsigned int intkey, void *data);
+HASH *hash_resize(HASH *ptr, int nelem, int lower);
-void *hash_find (const HASH *table, const char *key);
-struct hash_elem *hash_find_elem (const HASH *table, const char *strkey);
-void *int_hash_find (const HASH *table, unsigned int key);
+void *hash_find(const HASH *table, const char *strkey);
+struct hash_elem *hash_find_elem(const HASH *table, const char *strkey);
+void *int_hash_find(const HASH *table, unsigned int intkey);
-struct hash_elem *hash_find_bucket (const HASH *table, const char *key);
+struct hash_elem *hash_find_bucket(const HASH *table, const char *strkey);
-void hash_delete (HASH * table, const char *key, const void *data,
- void (*destroy) (void *));
-void int_hash_delete (HASH * table, unsigned int key, const void *data,
- void (*destroy) (void *));
+void hash_delete(HASH *table, const char *strkey, const void *data,
+ void (*destroy)(void *));
+void int_hash_delete(HASH *table, unsigned int intkey, const void *data,
+ void (*destroy)(void *));
-void hash_destroy (HASH ** hash, void (*destroy) (void *));
+void hash_destroy (HASH **ptr, void (*destroy) (void *));
struct hash_walk_state {
int index;
void mutt_init_history(void);
void mutt_read_histfile(void);
-void mutt_history_add(history_class_t, const char *, int);
-char *mutt_history_next(history_class_t);
-char *mutt_history_prev(history_class_t);
-void mutt_reset_history_state (history_class_t);
-int mutt_history_at_scratch (history_class_t);
-void mutt_history_save_scratch (history_class_t, const char *);
+void mutt_history_add(history_class_t hclass, const char *s, int save);
+char *mutt_history_next(history_class_t hclass);
+char *mutt_history_prev(history_class_t hclass);
+void mutt_reset_history_state(history_class_t hclass);
+int mutt_history_at_scratch(history_class_t hclass);
+void mutt_history_save_scratch(history_class_t hclass, const char *s);
#endif
/* -- private IMAP functions -- */
/* imap.c */
-int imap_check (IMAP_DATA* idata, int force);
-int imap_create_mailbox (IMAP_DATA* idata, char* mailbox);
-int imap_rename_mailbox (IMAP_DATA* idata, IMAP_MBOX* mx, const char* newname);
-IMAP_STATUS* imap_mboxcache_get (IMAP_DATA* idata, const char* mbox,
- int create);
-void imap_mboxcache_free (IMAP_DATA* idata);
-int imap_exec_msgset (IMAP_DATA* idata, const char* pre, const char* post,
- int flag, int changed, int invert);
-int imap_open_connection (IMAP_DATA* idata);
-void imap_close_connection (IMAP_DATA* idata);
-IMAP_DATA* imap_conn_find (const ACCOUNT* account, int flags);
-int imap_read_literal (FILE* fp, IMAP_DATA* idata, long bytes, progress_t*);
-void imap_expunge_mailbox (IMAP_DATA* idata);
-void imap_logout (IMAP_DATA** idata);
-int imap_sync_message (IMAP_DATA *idata, HEADER *hdr, BUFFER *cmd,
- int *err_continue);
-int imap_has_flag (LIST* flag_list, const char* flag);
+int imap_check(IMAP_DATA *idata, int force);
+int imap_create_mailbox(IMAP_DATA *idata, char *mailbox);
+int imap_rename_mailbox(IMAP_DATA *idata, IMAP_MBOX *mx, const char *newname);
+IMAP_STATUS *imap_mboxcache_get(IMAP_DATA *idata, const char *mbox, int create);
+void imap_mboxcache_free(IMAP_DATA *idata);
+int imap_exec_msgset(IMAP_DATA *idata, const char *pre, const char *post,
+ int flag, int changed, int invert);
+int imap_open_connection(IMAP_DATA *idata);
+void imap_close_connection(IMAP_DATA *idata);
+IMAP_DATA *imap_conn_find(const ACCOUNT *account, int flags);
+int imap_read_literal(FILE *fp, IMAP_DATA *idata, long bytes,
+ progress_t *pbar);
+void imap_expunge_mailbox(IMAP_DATA *idata);
+void imap_logout(IMAP_DATA **idata);
+int imap_sync_message(IMAP_DATA *idata, HEADER *hdr, BUFFER *cmd, int *err_continue);
+int imap_has_flag(LIST *flag_list, const char *flag);
/* auth.c */
int imap_authenticate (IMAP_DATA* idata);
/* type for key storage, the rest of mutt works fine with int type */
typedef short keycode_t;
-void km_bind (char *, int, int, char *, char *);
-int km_dokey (int);
+void km_bind(char *s, int menu, int op, char *macro, char *descr);
+int km_dokey(int menu);
void init_extended_keys(void);
keycode_t *keys; /* key sequence */
};
-int km_expand_key (char *, size_t, struct keymap_t *);
-struct keymap_t *km_find_func (int, int);
-void km_init (void);
-void km_error_key (int);
-void mutt_what_key (void);
+int km_expand_key(char *s, size_t len, struct keymap_t *map);
+struct keymap_t *km_find_func(int menu, int func);
+void km_init(void);
+void km_error_key(int menu);
+void mutt_what_key(void);
enum
{
#ifdef DEBUG
extern FILE *debugfile;
extern int debuglevel;
-void mutt_debug (int level, const char *, ...);
+void mutt_debug (int level, const char *fmt, ...);
#else
#define mutt_debug(...) do { } while (0)
#endif
/* The actual library functions. */
-FILE *safe_fopen (const char *, const char *);
-
-char *mutt_concatn_path (char *, size_t, const char *, size_t, const char *, size_t);
-char *mutt_concat_path (char *, const char *, const char *, size_t);
-char *mutt_read_line (char *, size_t *, FILE *, int *, int);
-char *mutt_skip_whitespace (char *);
-char *mutt_strlower (char *);
-const char *mutt_strchrnul (const char *, char);
-char *mutt_substrcpy (char *, const char *, const char *, size_t);
-char *mutt_substrdup (const char *, const char *);
-char *safe_strcat (char *, size_t, const char *);
-char *safe_strncat (char *, size_t, const char *, size_t);
-char *safe_strdup (const char *);
-char *strfcpy (char *dest, const char *src, size_t dlen);
+FILE *safe_fopen(const char *path, const char *mode);
+
+char *mutt_concatn_path(char *dst, size_t dstlen, const char *dir,
+ size_t dirlen, const char *fname, size_t fnamelen);
+char *mutt_concat_path(char *d, const char *dir, const char *fname, size_t l);
+char *mutt_read_line(char *s, size_t *size, FILE *fp, int *line, int flags);
+char *mutt_skip_whitespace(char *p);
+char *mutt_strlower(char *s);
+const char *mutt_strchrnul(const char *s, char c);
+char *mutt_substrcpy(char *dest, const char *beg, const char *end, size_t destlen);
+char *mutt_substrdup(const char *begin, const char *end);
+char *safe_strcat(char *d, size_t l, const char *s);
+char *safe_strncat(char *d, size_t l, const char *s, size_t sl);
+char *safe_strdup(const char *s);
+char *strfcpy(char *dest, const char *src, size_t dlen);
/* strtol() wrappers with range checking; they return
* 0 success
time_t received; /* the time at which this message was received */
} MESSAGE;
-CONTEXT *mx_open_mailbox (const char *, int, CONTEXT *);
+CONTEXT *mx_open_mailbox(const char *path, int flags, CONTEXT *pctx);
-MESSAGE *mx_open_message (CONTEXT *, int);
-MESSAGE *mx_open_new_message (CONTEXT *, HEADER *, int);
+MESSAGE *mx_open_message(CONTEXT *ctx, int msgno);
+MESSAGE *mx_open_new_message(CONTEXT *dest, HEADER *hdr, int flags);
-void mx_fastclose_mailbox (CONTEXT *);
+void mx_fastclose_mailbox(CONTEXT *ctx);
-int mx_close_mailbox (CONTEXT *, int *);
-int mx_sync_mailbox (CONTEXT *, int *);
-int mx_commit_message (MESSAGE *, CONTEXT *);
-int mx_close_message (CONTEXT *, MESSAGE **);
-int mx_get_magic (const char *);
-int mx_set_magic (const char *);
-int mx_check_mailbox (CONTEXT *, int *);
+int mx_close_mailbox(CONTEXT *ctx, int *index_hint);
+int mx_sync_mailbox(CONTEXT *ctx, int *index_hint);
+int mx_commit_message(MESSAGE *msg, CONTEXT *ctx);
+int mx_close_message(CONTEXT *ctx, MESSAGE **msg);
+int mx_get_magic(const char *path);
+int mx_set_magic(const char *s);
+int mx_check_mailbox(CONTEXT *ctx, int *index_hint);
#ifdef USE_IMAP
-int mx_is_imap (const char *);
+int mx_is_imap(const char *p);
#endif
#ifdef USE_POP
-int mx_is_pop (const char *);
+int mx_is_pop(const char *p);
#endif
#ifdef USE_NNTP
-int mx_is_nntp (const char *);
+int mx_is_nntp(const char *p);
#endif
-int mx_access (const char*, int);
-int mx_check_empty (const char *);
+int mx_access(const char *path, int flags);
+int mx_check_empty(const char *path);
-int mx_is_maildir (const char *);
-int mx_is_mh (const char *);
+int mx_is_maildir(const char *path);
+int mx_is_mh(const char *path);
#endif
int value;
};
-const char *mutt_getnamebyvalue (int, const struct mapping_t *);
-char *mutt_compile_help (char *, size_t, int, const struct mapping_t *);
+const char *mutt_getnamebyvalue(int val, const struct mapping_t *map);
+char *mutt_compile_help(char *buf, size_t buflen, int menu, const struct mapping_t *items);
-int mutt_getvaluebyname (const char *, const struct mapping_t *);
+int mutt_getvaluebyname(const char *name, const struct mapping_t *map);
#endif
# endif /* !HAVE_WC_FUNCS */
-void mutt_set_charset (char *charset);
+void mutt_set_charset(char *charset);
extern int Charset_is_utf8;
-wchar_t replacement_char (void);
-int is_display_corrupting_utf8 (wchar_t wc);
+wchar_t replacement_char(void);
+int is_display_corrupting_utf8(wchar_t wc);
#endif /* _MBYTE_H */
return safe_calloc (1, sizeof (REPLACE_LIST));
}
-void mutt_free_list (LIST **);
-void mutt_free_rx_list (RX_LIST **);
-void mutt_free_replace_list (REPLACE_LIST **);
-LIST *mutt_copy_list (LIST *);
-int mutt_matches_ignore (const char *);
-int mutt_matches_list (const char *, LIST *);
+void mutt_free_list(LIST **list);
+void mutt_free_rx_list(RX_LIST **list);
+void mutt_free_replace_list(REPLACE_LIST **list);
+LIST *mutt_copy_list(LIST *p);
+int mutt_matches_ignore(const char *s);
+int mutt_matches_list(const char *s, LIST *t);
/* add an element to a list */
-LIST *mutt_add_list (LIST *, const char *);
-LIST *mutt_add_list_n (LIST*, const void *, size_t);
-LIST *mutt_find_list (LIST *, const char *);
-int mutt_remove_from_rx_list (RX_LIST **l, const char *str);
+LIST *mutt_add_list(LIST *head, const char *data);
+LIST *mutt_add_list_n(LIST *head, const void *data, size_t len);
+LIST *mutt_find_list(LIST *l, const char *data);
+int mutt_remove_from_rx_list(RX_LIST **l, const char *str);
/* handle stack */
void mutt_push_list(LIST **head, const char *data);
int mutt_pop_list(LIST **head);
const char *mutt_front_list(LIST *head);
-void mutt_init (int, LIST *);
+void mutt_init (int skip_sys_rc, LIST *commands);
typedef struct alias
{
*/
struct mx_ops
{
- int (*open) (struct _context *);
- int (*open_append) (struct _context *, int flags);
- int (*close) (struct _context *);
+ int (*open) (struct _context *ctx);
+ int (*open_append) (struct _context *ctx, int flags);
+ int (*close) (struct _context *ctx);
int (*check) (struct _context *ctx, int *index_hint);
int (*sync) (struct _context *ctx, int *index_hint);
- int (*open_msg) (struct _context *, struct _message *, int msgno);
- int (*close_msg) (struct _context *, struct _message *);
- int (*commit_msg) (struct _context *, struct _message *);
- int (*open_new_msg) (struct _message *, struct _context *, HEADER *);
+ int (*open_msg) (struct _context *ctx, struct _message *msg, int msgno);
+ int (*close_msg) (struct _context *ctx, struct _message *msg);
+ int (*commit_msg) (struct _context *ctx, struct _message *msg);
+ int (*open_new_msg) (struct _message *msg, struct _context *ctx, HEADER *hdr);
};
#include "mutt_menu.h"
#define state_puts(x,y) fputs(x,(y)->fpout)
#define state_putc(x,y) fputc(x,(y)->fpout)
-void state_mark_attach (STATE *);
-void state_attach_puts (const char *, STATE *);
-void state_prefix_putc (char, STATE *);
-int state_printf(STATE *, const char *, ...);
-int state_putws (const wchar_t *, STATE *);
+void state_mark_attach(STATE *s);
+void state_attach_puts(const char *t, STATE *s);
+void state_prefix_putc(char c, STATE *s);
+int state_printf(STATE *s, const char *fmt, ...);
+int state_putws(const wchar_t *ws, STATE *s);
/* for attachment counter */
typedef struct
};
const struct command_t *mutt_command_get(const char *s);
-void mutt_commands_apply(void *data,
- void (*application)(void *, const struct command_t *));
+void mutt_commands_apply(void *data, void (*application)(void *, const struct command_t *));
#endif
/* Some prototypes -- old crypt.h. */
-int mutt_protect (HEADER *, char *);
+int mutt_protect(HEADER *msg, char *keylist);
-int mutt_is_multipart_encrypted (BODY *);
+int mutt_is_multipart_encrypted(BODY *b);
-int mutt_is_valid_multipart_pgp_encrypted (BODY *b);
+int mutt_is_valid_multipart_pgp_encrypted(BODY *b);
-int mutt_is_malformed_multipart_pgp_encrypted (BODY *b);
+int mutt_is_malformed_multipart_pgp_encrypted(BODY *b);
-int mutt_is_multipart_signed (BODY *);
+int mutt_is_multipart_signed(BODY *b);
-int mutt_is_application_pgp (BODY *);
+int mutt_is_application_pgp(BODY *m);
-int mutt_is_application_smime (BODY *);
+int mutt_is_application_smime(BODY *m);
-int mutt_signed_handler (BODY *, STATE *);
+int mutt_signed_handler(BODY *a, STATE *s);
-int mutt_parse_crypt_hdr (const char *, int, int);
+int mutt_parse_crypt_hdr(const char *p, int set_empty_signas, int crypt_app);
-
-void convert_to_7bit (BODY *);
+void convert_to_7bit(BODY *a);
/* Check out the type of encryption used and set the cached status
values if there are any. */
-int crypt_query (BODY *m);
+int crypt_query(BODY *m);
/* Fixme: To be documented. */
-void crypt_extract_keys_from_messages (HEADER *h);
+void crypt_extract_keys_from_messages(HEADER *h);
/* Do a quick check to make sure that we can find all of the
encryption keys if the user has requested this service.
Return the list of keys in KEYLIST.
If oppenc_mode is true, only keys that can be determined without
prompting will be used. */
-int crypt_get_keys (HEADER *msg, char **keylist, int oppenc_mode);
+int crypt_get_keys(HEADER *msg, char **keylist, int oppenc_mode);
/* Check if all recipients keys can be automatically determined.
* Enable encryption if they can, otherwise disable encryption. */
void crypt_opportunistic_encrypt(HEADER *msg);
/* Forget a passphrase and display a message. */
-void crypt_forget_passphrase (void);
+void crypt_forget_passphrase(void);
/* Check that we have a usable passphrase, ask if not. */
-int crypt_valid_passphrase (int);
+int crypt_valid_passphrase(int flags);
/* Write the message body/part A described by state S to the given
TEMPFILE. */
-int crypt_write_signed(BODY *a, STATE *s, const char *tempf);
+int crypt_write_signed(BODY *a, STATE *s, const char *tempfile);
/* Obtain pointers to fingerprint or short or long key ID, if any.
crypt_add_string_to_hints().
*ppl Start of long key ID if detected, else NULL.
*pps Start of short key ID if detected, else NULL. */
-const char* crypt_get_fingerprint_or_id (char *p, const char **pphint,
- const char **ppl, const char **pps);
+const char *crypt_get_fingerprint_or_id(char *p, const char **pphint,
+ const char **ppl, const char **pps);
/* Check if a string contains a numerical key */
-short crypt_is_numerical_keyid (const char *s);
+short crypt_is_numerical_keyid(const char *s);
/* fixme: needs documentation. */
void crypt_pgp_invoke_getkeys (ADDRESS *addr);
-/* Ask for a PGP key. */
-pgp_key_t crypt_pgp_ask_for_key (char *tag, char *whatfor,
- short abilities, pgp_ring_t keyring);
-
/* Check for a traditional PGP message in body B. */
int crypt_pgp_check_traditional (FILE *fp, BODY *b, int tagged_only);
/* fixme: needs documentation. */
BODY *crypt_pgp_traditional_encryptsign (BODY *a, int flags, char *keylist);
-/* Release the PGP key KPP (note, that we pass a pointer to it). */
-void crypt_pgp_free_key (pgp_key_t *kpp);
-
/* Generate a PGP public key attachment. */
BODY *crypt_pgp_make_key_attachment (char *tempf);
/* fixme: needs documentation */
int crypt_pgp_verify_one (BODY *sigbdy, STATE *s, const char *tempf);
-/* Access the keyID in K. */
-char *crypt_pgp_keyid (pgp_key_t k);
-
/* fixme: needs documentation */
void crypt_pgp_extract_keys_from_attachment_list (FILE *fp, int tag,BODY *top);
event_t mutt_getch (void);
-void mutt_endwin (const char *);
-void mutt_flushinp (void);
-void mutt_refresh (void);
-void mutt_resize_screen (void);
-void mutt_unget_event (int, int);
-void mutt_unget_string (char *);
-void mutt_push_macro_event (int, int);
-void mutt_flush_macro_to_endcond (void);
-void mutt_need_hard_redraw (void);
+void mutt_endwin(const char *msg);
+void mutt_flushinp(void);
+void mutt_refresh(void);
+void mutt_resize_screen(void);
+void mutt_unget_event(int ch, int op);
+void mutt_unget_string(char *s);
+void mutt_push_macro_event(int ch, int op);
+void mutt_flush_macro_to_endcond(void);
+void mutt_need_hard_redraw(void);
/* ----------------------------------------------------------------------------
* Support for color
char sizestr[SHORT_STRING];
} progress_t;
-void mutt_progress_init (progress_t* progress, const char *msg,
- unsigned short flags, unsigned short inc,
- long size);
+void mutt_progress_init(progress_t *progress, const char *msg,
+ unsigned short flags, unsigned short inc, long size);
/* If percent is positive, it is displayed as percentage, otherwise
* percentage is calculated from progress->size and pos if progress
* was initialized with positive size, otherwise no percentage is shown */
-void mutt_progress_update (progress_t* progress, long pos, int percent);
+void mutt_progress_update(progress_t *progress, long pos, int percent);
/* Windows for different parts of the screen */
typedef struct
extern mutt_window_t *MuttSidebarWindow;
#endif
-void mutt_init_windows (void);
-void mutt_free_windows (void);
-void mutt_reflow_windows (void);
-int mutt_window_move (mutt_window_t *, int row, int col);
-int mutt_window_mvaddch (mutt_window_t *, int row, int col, const chtype ch);
-int mutt_window_mvaddstr (mutt_window_t *, int row, int col, const char *str);
-int mutt_window_mvprintw (mutt_window_t *, int row, int col, const char *fmt, ...);
-void mutt_window_clrtoeol (mutt_window_t *);
-void mutt_window_clearline (mutt_window_t *, int row);
-void mutt_window_getyx (mutt_window_t *, int *y, int *x);
+void mutt_init_windows(void);
+void mutt_free_windows(void);
+void mutt_reflow_windows(void);
+int mutt_window_move(mutt_window_t *win, int row, int col);
+int mutt_window_mvaddch(mutt_window_t *win, int row, int col, const chtype ch);
+int mutt_window_mvaddstr(mutt_window_t *win, int row, int col, const char *str);
+int mutt_window_mvprintw(mutt_window_t *win, int row, int col, const char *fmt, ...);
+void mutt_window_clrtoeol(mutt_window_t *win);
+void mutt_window_clearline(mutt_window_t *win, int row);
+void mutt_window_getyx(mutt_window_t *win, int *y, int *x);
static inline int mutt_window_wrap_cols(mutt_window_t *win, short wrap)
extern COLOR_LINE *ColorIndexTagList;
#endif
-void ci_init_color (void);
void ci_start_color (void);
/* If the system has bkgdset() use it rather than attrset() so that the clr*()
#endif /* HAVE_LIBIDN */
-int mutt_addrlist_to_intl (ADDRESS *, char **);
-int mutt_addrlist_to_local (ADDRESS *);
+int mutt_addrlist_to_intl(ADDRESS *a, char **err);
+int mutt_addrlist_to_local(ADDRESS *a);
-void mutt_env_to_local (ENVELOPE *);
-int mutt_env_to_intl (ENVELOPE *, char **, char **);
+void mutt_env_to_local(ENVELOPE *e);
+int mutt_env_to_intl(ENVELOPE *env, char **tag, char **err);
const char *mutt_addr_for_display (ADDRESS *a);
int tagged; /* number of tagged entries */
} MUTTMENU;
-void mutt_menu_init (void);
-void menu_redraw_full (MUTTMENU *);
+void mutt_menu_init(void);
+void menu_redraw_full(MUTTMENU *menu);
#ifdef USE_SIDEBAR
-void menu_redraw_sidebar (MUTTMENU *);
+void menu_redraw_sidebar(MUTTMENU *menu);
#endif
-void menu_redraw_index (MUTTMENU *);
-void menu_redraw_status (MUTTMENU *);
-void menu_redraw_motion (MUTTMENU *);
-void menu_redraw_current (MUTTMENU *);
-int menu_redraw (MUTTMENU *);
-void menu_first_entry (MUTTMENU *);
-void menu_last_entry (MUTTMENU *);
-void menu_top_page (MUTTMENU *);
-void menu_bottom_page (MUTTMENU *);
-void menu_middle_page (MUTTMENU *);
-void menu_next_page (MUTTMENU *);
-void menu_prev_page (MUTTMENU *);
-void menu_next_line (MUTTMENU *);
-void menu_prev_line (MUTTMENU *);
-void menu_half_up (MUTTMENU *);
-void menu_half_down (MUTTMENU *);
-void menu_current_top (MUTTMENU *);
-void menu_current_middle (MUTTMENU *);
-void menu_current_bottom (MUTTMENU *);
-void menu_check_recenter (MUTTMENU *);
-void menu_status_line (char *, size_t, MUTTMENU *, const char *);
-short mutt_ts_capability (void);
-void mutt_ts_status (char *);
-void mutt_ts_icon (char *);
-
-MUTTMENU *mutt_new_menu (int);
-void mutt_menuDestroy (MUTTMENU **);
-int mutt_menuLoop (MUTTMENU *);
+void menu_redraw_index(MUTTMENU *menu);
+void menu_redraw_status(MUTTMENU *menu);
+void menu_redraw_motion(MUTTMENU *menu);
+void menu_redraw_current(MUTTMENU *menu);
+int menu_redraw(MUTTMENU *menu);
+void menu_first_entry(MUTTMENU *menu);
+void menu_last_entry(MUTTMENU *menu);
+void menu_top_page(MUTTMENU *menu);
+void menu_bottom_page(MUTTMENU *menu);
+void menu_middle_page(MUTTMENU *menu);
+void menu_next_page(MUTTMENU *menu);
+void menu_prev_page(MUTTMENU *menu);
+void menu_next_line(MUTTMENU *menu);
+void menu_prev_line(MUTTMENU *menu);
+void menu_half_up(MUTTMENU *menu);
+void menu_half_down(MUTTMENU *menu);
+void menu_current_top(MUTTMENU *menu);
+void menu_current_middle(MUTTMENU *menu);
+void menu_current_bottom(MUTTMENU *menu);
+void menu_check_recenter(MUTTMENU *menu);
+void menu_status_line(char *buf, size_t buflen, MUTTMENU *menu, const char *p);
+short mutt_ts_capability(void);
+void mutt_ts_status(char *str);
+void mutt_ts_icon(char *str);
+
+MUTTMENU *mutt_new_menu(int menu);
+void mutt_menuDestroy(MUTTMENU **p);
+int mutt_menuLoop(MUTTMENU *menu);
/* used in both the index and pager index to make an entry. */
-void index_make_entry (char *, size_t, struct menu_t *, int);
-int index_color (int);
+void index_make_entry(char *s, size_t l, MUTTMENU *menu, int num);
+int index_color(int index_no);
int mutt_limit_current_thread (HEADER *h);
#include <stdbool.h>
-int nm_read_entire_thread(CONTEXT *ctx, HEADER *h);
+int nm_read_entire_thread(CONTEXT *ctx, HEADER *h);
char *nm_header_get_folder(HEADER *h);
-int nm_update_filename(CONTEXT *ctx, const char *old, const char *new, HEADER *h);
-bool nm_normalize_uri(char *new_uri, const char *orig_uri, size_t new_uri_sz);
+int nm_update_filename(CONTEXT *ctx, const char *old, const char *new, HEADER *h);
+bool nm_normalize_uri(char *new_uri, const char *orig_uri, size_t new_uri_sz);
char *nm_uri_from_query(CONTEXT *ctx, char *buf, size_t bufsz);
-int nm_modify_message_tags(CONTEXT *ctx, HEADER *hdr, char *buf);
+int nm_modify_message_tags(CONTEXT *ctx, HEADER *hdr, char *buf);
-void nm_query_window_backward(void);
-void nm_query_window_forward(void);
+void nm_query_window_backward(void);
+void nm_query_window_forward(void);
-void nm_longrun_init(CONTEXT *ctx, int writable);
-void nm_longrun_done(CONTEXT *ctx);
+void nm_longrun_init(CONTEXT *ctx, int writable);
+void nm_longrun_done(CONTEXT *ctx);
char *nm_get_description(CONTEXT *ctx);
int nm_description_to_path(const char *desc, char *buf, size_t bufsz);
-int nm_record_message(CONTEXT *ctx, char *path, HEADER *h);
+int nm_record_message(CONTEXT *ctx, char *path, HEADER *h);
-void nm_debug_check(CONTEXT *ctx);
-int nm_get_all_tags(CONTEXT *ctx, char **tag_list, int *tag_count);
+void nm_debug_check(CONTEXT *ctx);
+int nm_get_all_tags(CONTEXT *ctx, char **tag_list, int *tag_count);
/*
* functions usable outside notmuch CONTEXT
*/
-int nm_nonctx_get_count(char *path, int *all, int *new);
+int nm_nonctx_get_count(char *path, int *all, int *new);
char *nm_header_get_tag_transformed(char *tag, HEADER *h);
char *nm_header_get_tags_transformed(HEADER *h);
#include "mutt_socket.h"
-int mutt_sasl_client_new (CONNECTION*, sasl_conn_t**);
-int mutt_sasl_interact (sasl_interact_t*);
-void mutt_sasl_setup_conn (CONNECTION*, sasl_conn_t*);
-void mutt_sasl_done (void);
+int mutt_sasl_client_new(CONNECTION *conn, sasl_conn_t **saslconn);
+int mutt_sasl_interact(sasl_interact_t *interaction);
+void mutt_sasl_setup_conn(CONNECTION *conn, sasl_conn_t *saslconn);
+void mutt_sasl_done(void);
typedef struct
{
*
* Example usages for IMAP and SMTP, respectively:
*
- * mutt_sasl_plain_msg(buf, sizeof(buf), "AUTHENTICATE PLAIN", user, user, pass);
- * mutt_sasl_plain_msg(buf, sizeof(buf), "AUTH PLAIN", NULL, user, pass);
*/
size_t mutt_sasl_plain_msg(char *buf, size_t buflen, const char *cmd,
- const char *authz, const char *user,
- const char *pass);
+ const char *authz, const char *user, const char *pass);
#endif /* _MUTT_SASL_PLAIN_H_ */
int (*conn_poll) (struct _connection *conn);
} CONNECTION;
-int mutt_socket_open (CONNECTION* conn);
-int mutt_socket_close (CONNECTION* conn);
-int mutt_socket_poll (CONNECTION* conn);
-int mutt_socket_readchar (CONNECTION *conn, char *c);
+int mutt_socket_open(CONNECTION *conn);
+int mutt_socket_close(CONNECTION *conn);
+int mutt_socket_poll(CONNECTION *conn);
+int mutt_socket_readchar(CONNECTION *conn, char *c);
#define mutt_socket_readln(A,B,C) mutt_socket_readln_d(A,B,C,MUTT_SOCK_LOG_CMD)
-int mutt_socket_readln_d (char *buf, size_t buflen, CONNECTION *conn, int dbg);
+int mutt_socket_readln_d(char *buf, size_t buflen, CONNECTION *conn, int dbg);
#define mutt_socket_write(A,B) mutt_socket_write_d(A,B,-1,MUTT_SOCK_LOG_CMD)
#define mutt_socket_write_n(A,B,C) mutt_socket_write_d(A,B,C,MUTT_SOCK_LOG_CMD)
-int mutt_socket_write_d (CONNECTION *conn, const char *buf, int len, int dbg);
+int mutt_socket_write_d(CONNECTION *conn, const char *buf, int len, int dbg);
/* stupid hack for imap_logout_all */
-CONNECTION* mutt_socket_head (void);
-void mutt_socket_free (CONNECTION* conn);
-CONNECTION* mutt_conn_find (const CONNECTION* start, const ACCOUNT* account);
+CONNECTION *mutt_socket_head(void);
+void mutt_socket_free(CONNECTION *conn);
+CONNECTION *mutt_conn_find(const CONNECTION *start, const ACCOUNT *account);
-int raw_socket_read (CONNECTION* conn, char* buf, size_t len);
-int raw_socket_write (CONNECTION* conn, const char* buf, size_t count);
-int raw_socket_open (CONNECTION *conn);
-int raw_socket_close (CONNECTION *conn);
-int raw_socket_poll (CONNECTION* conn);
+int raw_socket_read(CONNECTION *conn, char *buf, size_t len);
+int raw_socket_write(CONNECTION *conn, const char *buf, size_t count);
+int raw_socket_open(CONNECTION *conn);
+int raw_socket_close(CONNECTION *conn);
+int raw_socket_poll(CONNECTION *conn);
#endif /* _MUTT_SOCKET_H_ */
#include "mutt_socket.h"
-int mutt_tunnel_socket_setup (CONNECTION *);
+int mutt_tunnel_socket_setup(CONNECTION *conn);
#endif /* _MUTT_TUNNEL_H_ */
#define MMDF_SEP "\001\001\001\001\n"
#define MAXLOCKATTEMPT 5
-int mbox_check_empty (const char *);
-void mbox_reset_atime (CONTEXT *, struct stat *);
+int mbox_check_empty(const char *path);
+void mbox_reset_atime(CONTEXT *ctx, struct stat *st);
-int mh_check_empty (const char *);
+int mh_check_empty(const char *path);
-int maildir_check_empty (const char *);
+int maildir_check_empty(const char *path);
-HEADER *maildir_parse_message (int magic, const char *fname, int is_old, HEADER * _h);
-HEADER *maildir_parse_stream (int magic, FILE *f, const char *fname, int is_old, HEADER * _h);
-void maildir_parse_flags (HEADER * h, const char *path);
-void maildir_update_flags (CONTEXT *ctx, HEADER *o, HEADER *n);
-void maildir_flags(char *dest, size_t destlen, HEADER * hdr);
+HEADER *maildir_parse_message(int magic, const char *fname, int is_old, HEADER *h);
+HEADER *maildir_parse_stream(int magic, FILE *f, const char *fname, int is_old, HEADER *_h);
+void maildir_parse_flags(HEADER *h, const char *path);
+void maildir_update_flags(CONTEXT *ctx, HEADER *o, HEADER *n);
+void maildir_flags(char *dest, size_t destlen, HEADER *hdr);
#ifdef USE_HCACHE
#include "hcache.h"
int mx_is_notmuch(const char *p);
#endif
-FILE *maildir_open_find_message (const char *, const char *, char **);
+FILE *maildir_open_find_message (const char *folder, const char *msg,
+ char **newname);
-int mbox_strict_cmp_headers (const HEADER *, const HEADER *);
+int mbox_strict_cmp_headers(const HEADER *h1, const HEADER *h2);
-void mx_alloc_memory (CONTEXT *);
-void mx_update_context (CONTEXT *, int);
-void mx_update_tables (CONTEXT *, int);
+void mx_alloc_memory(CONTEXT *ctx);
+void mx_update_context(CONTEXT *ctx, int new_messages);
+void mx_update_tables(CONTEXT *ctx, int committing);
-int mx_lock_file (const char *, int, int, int, int);
-int mx_unlock_file (const char *path, int fd, int dot);
+int mx_lock_file(const char *path, int fd, int excl, int dot, int timeout);
+int mx_unlock_file(const char *path, int fd, int dot);
struct mx_ops* mx_get_ops (int magic);
extern struct mx_ops mx_maildir_ops;
#include <sys/types.h>
-const char* myvar_get (const char* var);
-int var_to_string (int idx, char* val, size_t len);
-int mutt_option_index (const char *s);
+const char *myvar_get(const char *var);
+int var_to_string(int idx, char *val, size_t len);
+int mutt_option_index(const char *s);
#endif
#define NHDR(hdr) ((NNTP_HEADER_DATA*)((hdr)->data))
/* internal functions */
-int nntp_add_group (char *, void *);
-int nntp_active_save_cache (NNTP_SERVER *);
-int nntp_check_new_groups (NNTP_SERVER *);
-int nntp_open_connection (NNTP_SERVER *);
-void nntp_newsrc_gen_entries (CONTEXT *);
-void nntp_bcache_update (NNTP_DATA *);
-void nntp_article_status (CONTEXT *, HEADER *, char *, anum_t);
-void nntp_group_unread_stat (NNTP_DATA *);
-void nntp_data_free (void *);
-void nntp_acache_free (NNTP_DATA *);
-void nntp_delete_group_cache (NNTP_DATA *);
+int nntp_add_group(char *line, void *data);
+int nntp_active_save_cache(NNTP_SERVER *nserv);
+int nntp_check_new_groups(NNTP_SERVER *nserv);
+int nntp_open_connection(NNTP_SERVER *nserv);
+void nntp_newsrc_gen_entries(CONTEXT *ctx);
+void nntp_bcache_update(NNTP_DATA *nntp_data);
+void nntp_article_status(CONTEXT *ctx, HEADER *hdr, char *group, anum_t anum);
+void nntp_group_unread_stat(NNTP_DATA *nntp_data);
+void nntp_data_free(void *data);
+void nntp_acache_free(NNTP_DATA *nntp_data);
+void nntp_delete_group_cache(NNTP_DATA *nntp_data);
/* exposed interface */
-NNTP_SERVER *nntp_select_server (char *, int);
-NNTP_DATA *mutt_newsgroup_subscribe (NNTP_SERVER *, char *);
-NNTP_DATA *mutt_newsgroup_unsubscribe (NNTP_SERVER *, char *);
-NNTP_DATA *mutt_newsgroup_catchup (NNTP_SERVER *, char *);
-NNTP_DATA *mutt_newsgroup_uncatchup (NNTP_SERVER *, char *);
-int nntp_active_fetch (NNTP_SERVER *);
-int nntp_newsrc_update (NNTP_SERVER *);
-int nntp_post (const char *);
-int nntp_check_msgid (CONTEXT *, const char *);
-int nntp_check_children (CONTEXT *, const char *);
-int nntp_newsrc_parse (NNTP_SERVER *);
-void nntp_newsrc_close (NNTP_SERVER *);
-void nntp_buffy (char *, size_t);
-void nntp_expand_path (char *, size_t, ACCOUNT *);
-void nntp_clear_cache (NNTP_SERVER *);
-const char *nntp_format_str (char *, size_t, size_t, int, char, const char *,
- const char *, const char *, const char *,
- unsigned long, format_flag);
+NNTP_SERVER *nntp_select_server(char *server, int leave_lock);
+NNTP_DATA *mutt_newsgroup_subscribe(NNTP_SERVER *nserv, char *group);
+NNTP_DATA *mutt_newsgroup_unsubscribe(NNTP_SERVER *nserv, char *group);
+NNTP_DATA *mutt_newsgroup_catchup(NNTP_SERVER *nserv, char *group);
+NNTP_DATA *mutt_newsgroup_uncatchup(NNTP_SERVER *nserv, char *group);
+int nntp_active_fetch(NNTP_SERVER *nserv);
+int nntp_newsrc_update(NNTP_SERVER *nserv);
+int nntp_post(const char *msg);
+int nntp_check_msgid(CONTEXT *ctx, const char *msgid);
+int nntp_check_children(CONTEXT *ctx, const char *msgid);
+int nntp_newsrc_parse(NNTP_SERVER *nserv);
+void nntp_newsrc_close(NNTP_SERVER *nserv);
+void nntp_buffy(char *buf, size_t len);
+void nntp_expand_path(char *line, size_t len, ACCOUNT *acct);
+void nntp_clear_cache(NNTP_SERVER *nserv);
+const char *nntp_format_str(char *dest, size_t destlen, size_t col, int cols,
+ char op, const char *src, const char *fmt,
+ const char *ifstring, const char *elsestring,
+ unsigned long data, format_flag flags);
NNTP_SERVER *CurrentNewsSrv INITVAL (NULL);
#ifdef USE_HCACHE
-header_cache_t *nntp_hcache_open (NNTP_DATA *);
-void nntp_hcache_update (NNTP_DATA *, header_cache_t *);
+header_cache_t *nntp_hcache_open(NNTP_DATA *nntp_data);
+void nntp_hcache_update(NNTP_DATA *nntp_data, header_cache_t *hc);
#endif
extern struct mx_ops mx_nntp_ops;
short idxlen;
} pager_t;
-int mutt_do_pager (const char *, const char *, int, pager_t *);
-int mutt_pager (const char *, const char *, int, pager_t *);
-void update_index (MUTTMENU *menu, CONTEXT *ctx, int check, int oldcount, int index_hint);
+int mutt_do_pager(const char *banner, const char *tempfile, int do_color, pager_t *info);
+int mutt_pager(const char *banner, const char *fname, int flags, pager_t *extra);
+void update_index(MUTTMENU *menu, CONTEXT *ctx, int check, int oldcount, int index_hint);
int pgp_use_gpg_agent(void);
-int pgp_check_traditional (FILE *, BODY *, int);
-BODY *pgp_make_key_attachment (char *);
-const char *pgp_micalg (const char *fname);
+int pgp_check_traditional(FILE *fp, BODY *b, int tagged_only);
+BODY *pgp_make_key_attachment(char *tempf);
+const char *pgp_micalg(const char *fname);
char *_pgp_keyid (pgp_key_t);
char *pgp_keyid (pgp_key_t);
-char *pgp_short_keyid (pgp_key_t);
-char *pgp_long_keyid (pgp_key_t);
-char *pgp_fpr_or_lkeyid (pgp_key_t k);
+char *pgp_short_keyid(pgp_key_t k);
+char *pgp_long_keyid(pgp_key_t k);
+char *pgp_fpr_or_lkeyid(pgp_key_t k);
+int pgp_decrypt_mime(FILE *fpin, FILE **fpout, BODY *b, BODY **cur);
-int mutt_check_pgp (HEADER * h);
+pgp_key_t pgp_ask_for_key(char *tag, char *whatfor, short abilities, pgp_ring_t keyring);
+pgp_key_t pgp_get_candidates(pgp_ring_t keyring, LIST *hints);
+pgp_key_t pgp_getkeybyaddr(ADDRESS *a, short abilities, pgp_ring_t keyring, int oppenc_mode);
+pgp_key_t pgp_getkeybystr(char *p, short abilities, pgp_ring_t keyring);
-int pgp_decrypt_mime (FILE *, FILE **, BODY *, BODY **);
+char *pgp_findKeys(ADDRESS *adrlist, int oppenc_mode);
-pgp_key_t pgp_ask_for_key (char *, char *, short, pgp_ring_t);
-pgp_key_t pgp_get_candidates (pgp_ring_t, LIST *);
-pgp_key_t pgp_getkeybyaddr (ADDRESS *, short, pgp_ring_t, int);
-pgp_key_t pgp_getkeybystr (char *, short, pgp_ring_t);
-
-char *pgp_findKeys (ADDRESS *adrlist, int oppenc_mode);
-
-int pgp_application_pgp_handler (BODY *, STATE *);
-int pgp_encrypted_handler (BODY *, STATE *);
-void pgp_extract_keys_from_attachment_list (FILE * fp, int tag, BODY * top);
-void pgp_void_passphrase (void);
-int pgp_valid_passphrase (void);
+int pgp_application_pgp_handler(BODY *m, STATE *s);
+int pgp_encrypted_handler(BODY *a, STATE *s);
+void pgp_extract_keys_from_attachment_list(FILE *fp, int tag, BODY *top);
+void pgp_void_passphrase(void);
+int pgp_valid_passphrase(void);
/* The PGP invocation interface - not really beautiful. */
-pid_t pgp_invoke_decode (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- const char *fname, short need_passphrase);
-pid_t pgp_invoke_verify (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- const char *fname, const char *sig_fname);
-pid_t pgp_invoke_decrypt (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- const char *fname);
-pid_t pgp_invoke_sign (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- const char *fname);
-pid_t pgp_invoke_encrypt (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- const char *fname, const char *uids, int sign);
-pid_t pgp_invoke_export (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- const char *uids);
-pid_t pgp_invoke_verify_key (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- const char *uids);
-pid_t pgp_invoke_list_keys (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- pgp_ring_t keyring, LIST *hints);
-pid_t pgp_invoke_traditional (FILE **pgpin, FILE **pgpout, FILE **pgperr,
- int pgpinfd, int pgpoutfd, int pgperrfd,
- const char *fname, const char *uids, int flags);
-
-
-void pgp_invoke_import (const char *fname);
-void pgp_invoke_getkeys (ADDRESS *);
+pid_t pgp_invoke_decode(FILE **pgpin, FILE **pgpout, FILE **pgperr, int pgpinfd, int pgpoutfd,
+ int pgperrfd, const char *fname, short need_passphrase);
+pid_t pgp_invoke_verify(FILE **pgpin, FILE **pgpout, FILE **pgperr, int pgpinfd, int pgpoutfd,
+ int pgperrfd, const char *fname, const char *sig_fname);
+pid_t pgp_invoke_decrypt(FILE **pgpin, FILE **pgpout, FILE **pgperr, int pgpinfd,
+ int pgpoutfd, int pgperrfd, const char *fname);
+pid_t pgp_invoke_sign(FILE **pgpin, FILE **pgpout, FILE **pgperr, int pgpinfd,
+ int pgpoutfd, int pgperrfd, const char *fname);
+pid_t pgp_invoke_encrypt(FILE **pgpin, FILE **pgpout, FILE **pgperr,
+ int pgpinfd, int pgpoutfd, int pgperrfd,
+ const char *fname, const char *uids, int sign);
+pid_t pgp_invoke_export(FILE **pgpin, FILE **pgpout, FILE **pgperr, int pgpinfd,
+ int pgpoutfd, int pgperrfd, const char *uids);
+pid_t pgp_invoke_verify_key(FILE **pgpin, FILE **pgpout, FILE **pgperr, int pgpinfd,
+ int pgpoutfd, int pgperrfd, const char *uids);
+pid_t pgp_invoke_list_keys(FILE **pgpin, FILE **pgpout, FILE **pgperr, int pgpinfd,
+ int pgpoutfd, int pgperrfd, pgp_ring_t keyring, LIST *hints);
+pid_t pgp_invoke_traditional(FILE **pgpin, FILE **pgpout, FILE **pgperr,
+ int pgpinfd, int pgpoutfd, int pgperrfd,
+ const char *fname, const char *uids, int flags);
+
+
+void pgp_invoke_import(const char *fname);
+void pgp_invoke_getkeys(ADDRESS *addr);
/* private ? */
-int pgp_verify_one (BODY *, STATE *, const char *);
-BODY *pgp_traditional_encryptsign (BODY *, int, char *);
-BODY *pgp_encrypt_message (BODY *, char *, int);
-BODY *pgp_sign_message (BODY *);
+int pgp_verify_one(BODY *sigbdy, STATE *s, const char *tempfile);
+BODY *pgp_traditional_encryptsign(BODY *a, int flags, char *keylist);
+BODY *pgp_encrypt_message(BODY *a, char *keylist, int sign);
+BODY *pgp_sign_message(BODY *a);
-int pgp_send_menu (HEADER *msg, int *redraw);
+int pgp_send_menu(HEADER *msg, int *redraw);
#endif /* CRYPT_BACKEND_CLASSIC_PGP */
/* prototypes */
-const char *pgp_pkalgbytype (unsigned char);
+const char *pgp_pkalgbytype(unsigned char type);
-pgp_key_t pgp_remove_key (pgp_key_t *, pgp_key_t );
-pgp_uid_t *pgp_copy_uids (pgp_uid_t *, pgp_key_t );
+pgp_key_t pgp_remove_key(pgp_key_t *klist, pgp_key_t key);
+pgp_uid_t *pgp_copy_uids(pgp_uid_t *up, pgp_key_t parent);
-short pgp_canencrypt (unsigned char);
-short pgp_cansign (unsigned char);
-short pgp_get_abilities (unsigned char);
+short pgp_canencrypt(unsigned char type);
+short pgp_cansign(unsigned char type);
+short pgp_get_abilities(unsigned char type);
-void pgp_free_key (pgp_key_t *kpp);
+void pgp_free_key(pgp_key_t *kpp);
static inline pgp_key_t pgp_new_keyinfo(void)
{
PT_COMMENT /* Comment Packet */
};
-unsigned char *pgp_read_packet (FILE * fp, size_t * len);
-void pgp_release_packet (void);
+unsigned char *pgp_read_packet(FILE *fp, size_t *len);
+void pgp_release_packet(void);
#endif
} pop_auth_t;
/* pop_auth.c */
-int pop_authenticate (POP_DATA *);
-void pop_apop_timestamp (POP_DATA *, char *);
+int pop_authenticate(POP_DATA *pop_data);
+void pop_apop_timestamp(POP_DATA *pop_data, char *buf);
/* pop_lib.c */
#define pop_query(A,B,C) pop_query_d(A,B,C,NULL)
-int pop_parse_path (const char *, ACCOUNT *);
-int pop_connect (POP_DATA *);
-int pop_open_connection (POP_DATA *);
-int pop_query_d (POP_DATA *, char *, size_t, char *);
-int pop_fetch_data (POP_DATA *, char *, progress_t *, int (*funct) (char *, void *), void *);
-int pop_reconnect (CONTEXT *);
-void pop_logout (CONTEXT *);
+int pop_parse_path(const char *path, ACCOUNT *acct);
+int pop_connect(POP_DATA *pop_data);
+int pop_open_connection(POP_DATA *pop_data);
+int pop_query_d(POP_DATA *pop_data, char *buf, size_t buflen, char *msg);
+int pop_fetch_data(POP_DATA *pop_data, char *query, progress_t *progressbar,
+ int (*funct)(char *, void *), void *data);
+int pop_reconnect(CONTEXT *ctx);
+void pop_logout(CONTEXT *ctx);
/* pop.c */
-void pop_fetch_mail (void);
+void pop_fetch_mail(void);
extern struct mx_ops mx_pop_ops;
#define MoreArgs(p) (*p->dptr && *p->dptr != ';' && *p->dptr != '#')
#define mutt_make_string(A,B,C,D,E) _mutt_make_string(A,B,C,D,E,0)
-void _mutt_make_string (char *, size_t, const char *, CONTEXT *,
- HEADER *, format_flag);
+void _mutt_make_string(char *dest, size_t destlen, const char *s, CONTEXT *ctx,
+ HEADER *hdr, format_flag flags);
struct hdr_format_info
{
kXDGConfigDirs, /* $XDG_CONFIG_DIRS */
} XDGType;
-void mutt_make_string_info (char *, size_t, int, const char *, struct hdr_format_info *, format_flag);
+void mutt_make_string_info (char *dst, size_t dstlen, int cols, const char *s, struct hdr_format_info *hfi, format_flag flags);
-void mutt_free_opts (void);
+void mutt_free_opts(void);
#define mutt_system(x) _mutt_system(x,0)
-int _mutt_system (const char *, int);
+int _mutt_system(const char *cmd, int flags);
#define mutt_next_thread(x) _mutt_aside_thread(x,1,0)
#define mutt_previous_thread(x) _mutt_aside_thread(x,0,0)
#define mutt_next_subthread(x) _mutt_aside_thread(x,1,1)
#define mutt_previous_subthread(x) _mutt_aside_thread(x,0,1)
-int _mutt_aside_thread (HEADER *, short, short);
+int _mutt_aside_thread (HEADER *hdr, short dir, short subthreads);
#define mutt_collapse_thread(x,y) _mutt_traverse_thread (x,y,MUTT_THREAD_COLLAPSE)
#define mutt_uncollapse_thread(x,y) _mutt_traverse_thread (x,y,MUTT_THREAD_UNCOLLAPSE)
#define mutt_get_hidden(x,y)_mutt_traverse_thread (x,y,MUTT_THREAD_GET_HIDDEN)
#define mutt_thread_contains_unread(x,y) _mutt_traverse_thread (x,y,MUTT_THREAD_UNREAD)
#define mutt_thread_next_unread(x,y) _mutt_traverse_thread(x,y,MUTT_THREAD_NEXT_UNREAD)
-int _mutt_traverse_thread (CONTEXT *ctx, HEADER *hdr, int flag);
+int _mutt_traverse_thread(CONTEXT *ctx, HEADER *cur, int flag);
typedef const char * format_t (char *, size_t, size_t, int, char, const char *, const char *, const char *, const char *, unsigned long, format_flag);
-void mutt_FormatString (char *, size_t, size_t, int, const char *, format_t *, unsigned long, format_flag);
-void mutt_parse_content_type (char *, BODY *);
-void mutt_generate_boundary (PARAMETER **);
-void mutt_delete_parameter (const char *attribute, PARAMETER **p);
-void mutt_set_parameter (const char *, const char *, PARAMETER **);
+void mutt_FormatString (char *dest, /* output buffer */
+ size_t destlen, /* output buffer len */
+ size_t col, /* starting column (nonzero when called recursively) */
+ int cols, /* maximum columns */
+ const char *src, /* template string */
+ format_t *callback, /* callback for processing */
+ unsigned long data, /* callback data */
+ format_flag flags); /* callback flags */
+
+void mutt_parse_content_type(char *s, BODY *ct);
+void mutt_generate_boundary(PARAMETER **parm);
+void mutt_delete_parameter(const char *attribute, PARAMETER **p);
+void mutt_set_parameter(const char *attribute, const char *value, PARAMETER **p);
#ifdef USE_NOTMUCH
-int mutt_parse_virtual_mailboxes (BUFFER *path, BUFFER *s, unsigned long data, BUFFER *err);
-int mutt_parse_unvirtual_mailboxes (BUFFER *path, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_virtual_mailboxes(BUFFER *path, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_unvirtual_mailboxes(BUFFER *path, BUFFER *s, unsigned long data, BUFFER *err);
#endif
-FILE *mutt_open_read (const char *, pid_t *);
+FILE *mutt_open_read(const char *path, pid_t *thepid);
-void set_quadoption (int, int);
-int query_quadoption (int, const char *);
-int quadoption (int);
+void set_quadoption(int opt, int flag);
+int query_quadoption(int opt, const char *prompt);
+int quadoption(int opt);
-char* mutt_extract_message_id (const char *, const char **);
+char *mutt_extract_message_id(const char *s, const char **saveptr);
-ADDRESS *mutt_default_from (void);
-ADDRESS *mutt_get_address (ENVELOPE *, char **);
-ADDRESS *mutt_lookup_alias (const char *s);
-ADDRESS *mutt_remove_duplicates (ADDRESS *);
-ADDRESS *mutt_remove_xrefs (ADDRESS *, ADDRESS *);
-ADDRESS *mutt_expand_aliases (ADDRESS *);
-ADDRESS *mutt_parse_adrlist (ADDRESS *, const char *);
+ADDRESS *mutt_default_from(void);
+ADDRESS *mutt_get_address(ENVELOPE *env, char **pfxp);
+ADDRESS *mutt_lookup_alias(const char *s);
+ADDRESS *mutt_remove_duplicates(ADDRESS *addr);
+ADDRESS *mutt_remove_xrefs(ADDRESS *a, ADDRESS *b);
+ADDRESS *mutt_expand_aliases(ADDRESS *a);
+ADDRESS *mutt_parse_adrlist(ADDRESS *p, const char *s);
-BODY *mutt_make_file_attach (const char *);
-BODY *mutt_make_message_attach (CONTEXT *, HEADER *, int);
-BODY *mutt_remove_multipart (BODY *);
-BODY *mutt_make_multipart (BODY *);
-BODY *mutt_new_body (void);
-BODY *mutt_parse_multipart (FILE *, const char *, LOFF_T, int);
-BODY *mutt_parse_messageRFC822 (FILE *, BODY *);
-BODY *mutt_read_mime_header (FILE *, int);
+BODY *mutt_make_file_attach(const char *path);
+BODY *mutt_make_message_attach(CONTEXT *ctx, HEADER *hdr, int attach_msg);
+BODY *mutt_remove_multipart(BODY *b);
+BODY *mutt_make_multipart(BODY *b);
+BODY *mutt_new_body(void);
+BODY *mutt_parse_multipart(FILE *fp, const char *boundary, LOFF_T end_off, int digest);
+BODY *mutt_parse_messageRFC822(FILE *fp, BODY *parent);
+BODY *mutt_read_mime_header(FILE *fp, int digest);
-CONTENT *mutt_get_content_info (const char *fname, BODY *b);
+CONTENT *mutt_get_content_info(const char *fname, BODY *b);
-HASH *mutt_make_id_hash (CONTEXT *);
+HASH *mutt_make_id_hash(CONTEXT *ctx);
-char *mutt_read_rfc822_line (FILE *, char *, size_t *);
-ENVELOPE *mutt_read_rfc822_header (FILE *, HEADER *, short, short);
+char *mutt_read_rfc822_line(FILE *f, char *line, size_t *linelen);
+ENVELOPE *mutt_read_rfc822_header(FILE *f, HEADER *hdr, short user_hdrs, short weed);
-void mutt_set_mtime (const char *from, const char *to);
-time_t mutt_decrease_mtime (const char *, struct stat *);
-time_t mutt_local_tz (time_t);
-time_t mutt_mktime (struct tm *, int);
-time_t mutt_parse_date (const char *, HEADER *);
-int is_from (const char *, char *, size_t, time_t *);
-void mutt_touch_atime (int);
+void mutt_set_mtime(const char *from, const char *to);
+time_t mutt_decrease_mtime(const char *f, struct stat *st);
+time_t mutt_local_tz(time_t t);
+time_t mutt_mktime(struct tm *t, int local);
+time_t mutt_parse_date(const char *s, HEADER *h);
+int is_from(const char *s, char *path, size_t pathlen, time_t *tp);
+void mutt_touch_atime(int f);
const char *mutt_attach_fmt (
char *dest,
format_flag flags);
-char *mutt_charset_hook (const char *);
-char *mutt_iconv_hook (const char *);
-char *mutt_expand_path (char *, size_t);
-char *_mutt_expand_path (char *, size_t, int);
-char *mutt_find_hook (int, const char *);
-char *mutt_gecos_name (char *, size_t, struct passwd *);
-char *mutt_get_body_charset (char *, size_t, BODY *);
-const char *mutt_get_name (ADDRESS *);
-char *mutt_get_parameter (const char *, PARAMETER *);
-LIST *mutt_crypt_hook (ADDRESS *);
-char *mutt_make_date (char *, size_t);
-void mutt_timeout_hook (void);
-void mutt_startup_shutdown_hook (int);
+char *mutt_charset_hook(const char *chs);
+char *mutt_iconv_hook(const char *chs);
+char *mutt_expand_path(char *s, size_t slen);
+char *_mutt_expand_path(char *s, size_t slen, int rx);
+char *mutt_find_hook(int type, const char *pat);
+char *mutt_gecos_name(char *dest, size_t destlen, struct passwd *pw);
+char *mutt_get_body_charset(char *d, size_t dlen, BODY *b);
+const char *mutt_get_name(ADDRESS *a);
+char *mutt_get_parameter(const char *s, PARAMETER *p);
+LIST *mutt_crypt_hook(ADDRESS *adr);
+char *mutt_make_date(char *s, size_t len);
+void mutt_timeout_hook(void);
+void mutt_startup_shutdown_hook(int type);
int mutt_set_xdg_path(const XDGType type, char *buf, size_t bufsize);
-const char *mutt_make_version (void);
-
-const char *mutt_fqdn(short);
-
-group_t *mutt_pattern_group (const char *);
-
-REGEXP *mutt_compile_regexp (const char *, int);
-
-void mutt_account_hook (const char* url);
-void mutt_add_to_reference_headers (ENVELOPE *env, ENVELOPE *curenv, LIST ***pp, LIST ***qq);
-void mutt_adv_mktemp (char *, size_t);
-void mutt_alias_menu (char *, size_t, ALIAS *);
-void mutt_allow_interrupt (int);
-void mutt_attach_init (BODY *);
-void mutt_block_signals (void);
-void mutt_block_signals_system (void);
-int mutt_body_handler (BODY *, STATE *);
-int mutt_bounce_message (FILE *fp, HEADER *, ADDRESS *);
-void mutt_break_thread (HEADER *);
-void mutt_buffy (char *, size_t);
-int mutt_buffy_list (void);
-void mutt_canonical_charset (char *, size_t, const char *);
-int mutt_count_body_parts (CONTEXT *, HEADER *);
-void mutt_check_rescore (CONTEXT *);
-void mutt_clear_error (void);
-void mutt_clear_pager_position (void);
-void mutt_create_alias (ENVELOPE *, ADDRESS *);
-void mutt_decode_attachment (BODY *, STATE *);
-void mutt_decode_base64 (STATE *s, long len, int istext, iconv_t cd);
-void mutt_default_save (char *, size_t, HEADER *);
-void mutt_display_address (ENVELOPE *);
-void mutt_draw_statusline (int cols, const char *buf, int buflen);
-void mutt_edit_content_type (HEADER *, BODY *, FILE *);
-void mutt_edit_file (const char *, const char *);
-void mutt_edit_headers (const char *, const char *, HEADER *, char *, size_t);
+const char *mutt_make_version(void);
+
+const char *mutt_fqdn(short may_hide_host);
+
+group_t *mutt_pattern_group(const char *k);
+
+REGEXP *mutt_compile_regexp(const char *s, int flags);
+
+void mutt_account_hook(const char *url);
+void mutt_add_to_reference_headers(ENVELOPE *env, ENVELOPE *curenv, LIST ***pp,
+ LIST ***qq);
+void mutt_adv_mktemp(char *s, size_t l);
+void mutt_alias_menu(char *buf, size_t buflen, ALIAS *aliases);
+void mutt_allow_interrupt(int disposition);
+void mutt_attach_init(BODY *b);
+void mutt_block_signals(void);
+void mutt_block_signals_system(void);
+int mutt_body_handler(BODY *b, STATE *s);
+int mutt_bounce_message(FILE *fp, HEADER *h, ADDRESS *to);
+void mutt_break_thread(HEADER *hdr);
+void mutt_buffy(char *s, size_t slen);
+int mutt_buffy_list(void);
+void mutt_canonical_charset(char *dest, size_t dlen, const char *name);
+int mutt_count_body_parts(CONTEXT *ctx, HEADER *hdr);
+void mutt_check_rescore(CONTEXT *ctx);
+void mutt_clear_error(void);
+void mutt_clear_pager_position(void);
+void mutt_create_alias(ENVELOPE *cur, ADDRESS *iadr);
+void mutt_decode_attachment(BODY *b, STATE *s);
+void mutt_decode_base64(STATE *s, long len, int istext, iconv_t cd);
+void mutt_default_save(char *path, size_t pathlen, HEADER *hdr);
+void mutt_display_address(ENVELOPE *env);
+void mutt_draw_statusline(int cols, const char *buf, int buflen);
+void mutt_edit_content_type(HEADER *h, BODY *b, FILE *fp);
+void mutt_edit_file(const char *editor, const char *data);
+void mutt_edit_headers(const char *editor, const char *body, HEADER *msg,
+ char *fcc, size_t fcclen);
char **mutt_envlist (void);
void mutt_envlist_set (const char *name, const char *value);
-int mutt_filter_unprintable (char **);
-int mutt_label_message (HEADER *);
-void mutt_make_label_hash (CONTEXT *);
-void mutt_label_hash_add (CONTEXT *ctx, HEADER *hdr);
-void mutt_label_hash_remove (CONTEXT *ctx, HEADER *hdr);
-int mutt_label_complete (char *, size_t, int);
-void mutt_curses_error (const char *, ...);
-void mutt_curses_message (const char *, ...);
-void mutt_encode_descriptions (BODY *, short);
-void mutt_encode_path (char *, size_t, const char *);
-void mutt_enter_command (void);
-void mutt_expand_aliases_env (ENVELOPE *);
-void mutt_expand_file_fmt (char *, size_t, const char *, const char *);
-void mutt_expand_fmt (char *, size_t, const char *, const char *);
-void mutt_fix_reply_recipients (ENVELOPE *env);
-void mutt_folder_hook (char *);
-void mutt_format_string (char *, size_t, int, int, int, char, const char *, size_t, int);
-void mutt_format_s (char *, size_t, const char *, const char *);
-void mutt_format_s_tree (char *, size_t, const char *, const char *);
-void mutt_forward_intro (FILE *fp, HEADER *cur);
-void mutt_forward_trailer (FILE *fp);
-void mutt_free_alias (ALIAS **);
-void mutt_free_body (BODY **);
-void mutt_free_color (int fg, int bg);
-void mutt_free_enter_state (ENTER_STATE **);
-void mutt_free_envelope (ENVELOPE **);
-void mutt_free_header (HEADER **);
-void mutt_free_parameter (PARAMETER **);
-void mutt_free_regexp (REGEXP **);
-void mutt_generate_header (char *, size_t, HEADER *, int);
-void mutt_help (int);
-void mutt_draw_tree (CONTEXT *);
-void mutt_check_lookup_list (BODY *, char *, int);
-void mutt_make_attribution (CONTEXT *ctx, HEADER *cur, FILE *out);
-void mutt_make_forward_subject (ENVELOPE *env, CONTEXT *ctx, HEADER *cur);
-void mutt_make_help (char *, size_t, const char *, int, int);
-void mutt_make_misc_reply_headers (ENVELOPE *env, CONTEXT *ctx, HEADER *cur, ENVELOPE *curenv);
-void mutt_make_post_indent (CONTEXT *ctx, HEADER *cur, FILE *out);
-void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra);
-void mutt_message_to_7bit (BODY *, FILE *);
+int mutt_filter_unprintable(char **s);
+int mutt_label_message(HEADER *hdr);
+void mutt_make_label_hash(CONTEXT *ctx);
+void mutt_label_hash_add(CONTEXT *ctx, HEADER *hdr);
+void mutt_label_hash_remove(CONTEXT *ctx, HEADER *hdr);
+int mutt_label_complete(char *buffer, size_t len, int numtabs);
+void mutt_curses_error(const char *fmt, ...);
+void mutt_curses_message(const char *fmt, ...);
+void mutt_encode_descriptions(BODY *b, short recurse);
+void mutt_encode_path(char *dest, size_t dlen, const char *src);
+void mutt_enter_command(void);
+void mutt_expand_aliases_env(ENVELOPE *env);
+void mutt_expand_file_fmt(char *dest, size_t destlen, const char *fmt, const char *src);
+void mutt_expand_fmt(char *dest, size_t destlen, const char *fmt, const char *src);
+void mutt_fix_reply_recipients(ENVELOPE *env);
+void mutt_folder_hook(char *path);
+void mutt_format_string(char *dest, size_t destlen, int min_width, int max_width, int justify,
+ char m_pad_char, const char *s, size_t n, int arboreal);
+void mutt_format_s(char *dest, size_t destlen, const char *prefix, const char *s);
+void mutt_format_s_tree(char *dest, size_t destlen, const char *prefix, const char *s);
+void mutt_forward_intro(FILE *fp, HEADER *cur);
+void mutt_forward_trailer(FILE *fp);
+void mutt_free_alias(ALIAS **p);
+void mutt_free_body(BODY **p);
+void mutt_free_color(int fg, int bg);
+void mutt_free_enter_state(ENTER_STATE **esp);
+void mutt_free_envelope(ENVELOPE **p);
+void mutt_free_header(HEADER **h);
+void mutt_free_parameter(PARAMETER **p);
+void mutt_free_regexp(REGEXP **pp);
+void mutt_help(int menu);
+void mutt_draw_tree(CONTEXT *ctx);
+void mutt_check_lookup_list(BODY *b, char *type, int len);
+void mutt_make_attribution(CONTEXT *ctx, HEADER *cur, FILE *out);
+void mutt_make_forward_subject(ENVELOPE *env, CONTEXT *ctx, HEADER *cur);
+void mutt_make_help(char *d, size_t dlen, const char *txt, int menu, int op);
+void mutt_make_misc_reply_headers(ENVELOPE *env, CONTEXT *ctx, HEADER *cur, ENVELOPE *curenv);
+void mutt_make_post_indent(CONTEXT *ctx, HEADER *cur, FILE *out);
+void mutt_merge_envelopes(ENVELOPE *base, ENVELOPE **extra);
+void mutt_message_to_7bit(BODY *a, FILE *fp);
#define mutt_mktemp(a,b) mutt_mktemp_pfx_sfx (a, b, "mutt", NULL)
#define mutt_mktemp_pfx_sfx(a,b,c,d) _mutt_mktemp (a, b, c, d, __FILE__, __LINE__)
-void _mutt_mktemp (char *, size_t, const char *, const char *, const char *, int);
-void mutt_normalize_time (struct tm *);
-void mutt_paddstr (int, const char *);
-void mutt_parse_mime_message (CONTEXT *ctx, HEADER *);
-void mutt_parse_part (FILE *, BODY *);
-void mutt_perror (const char *);
-void mutt_prepare_envelope (ENVELOPE *, int);
-void mutt_unprepare_envelope (ENVELOPE *);
-void mutt_pretty_mailbox (char *, size_t);
-void mutt_pretty_size (char *, size_t, LOFF_T);
-void mutt_pipe_message (HEADER *);
-void mutt_print_message (HEADER *);
-void mutt_print_patchlist (void);
-void mutt_query_exit (void);
-void mutt_query_menu (char *, size_t);
-void mutt_safe_path (char *s, size_t l, ADDRESS *a);
-void mutt_save_path (char *s, size_t l, ADDRESS *a);
-void mutt_score_message (CONTEXT *, HEADER *, int);
-void mutt_select_fcc (char *, size_t, HEADER *);
+void _mutt_mktemp(char *s, size_t slen, const char *prefix, const char *suffix,
+ const char *src, int line);
+void mutt_normalize_time(struct tm *tm);
+void mutt_paddstr(int n, const char *s);
+void mutt_parse_mime_message(CONTEXT *ctx, HEADER *cur);
+void mutt_parse_part(FILE *fp, BODY *b);
+void mutt_perror(const char *s);
+void mutt_prepare_envelope(ENVELOPE *env, int final);
+void mutt_unprepare_envelope(ENVELOPE *env);
+void mutt_pretty_mailbox(char *s, size_t buflen);
+void mutt_pretty_size(char *s, size_t len, LOFF_T n);
+void mutt_pipe_message(HEADER *h);
+void mutt_print_message(HEADER *h);
+void mutt_query_exit(void);
+void mutt_query_menu(char *buf, size_t buflen);
+void mutt_safe_path(char *s, size_t l, ADDRESS *a);
+void mutt_save_path(char *d, size_t dsize, ADDRESS *a);
+void mutt_score_message(CONTEXT *ctx, HEADER *hdr, int upd_ctx);
+void mutt_select_fcc(char *path, size_t pathlen, HEADER *hdr);
#define mutt_select_file(A,B,C) _mutt_select_file(A,B,C,NULL,NULL)
-void _mutt_select_file (char *, size_t, int, char ***, int *);
-void mutt_message_hook (CONTEXT *, HEADER *, int);
-void _mutt_set_flag (CONTEXT *, HEADER *, int, int, int);
+void _mutt_select_file(char *f, size_t flen, int flags, char ***files, int *numfiles);
+void mutt_message_hook(CONTEXT *ctx, HEADER *hdr, int type);
+void _mutt_set_flag(CONTEXT *ctx, HEADER *h, int flag, int bf, int upd_ctx);
#define mutt_set_flag(a,b,c,d) _mutt_set_flag(a,b,c,d,1)
-void mutt_set_followup_to (ENVELOPE *);
-void mutt_shell_escape (void);
-void mutt_show_error (void);
-void mutt_signal_init (void);
-void mutt_stamp_attachment (BODY *a);
-void mutt_tabs_to_spaces (char *);
-void mutt_tag_set_flag (int, int);
-short mutt_ts_capability (void);
-void mutt_unblock_signals (void);
-void mutt_unblock_signals_system (int);
-void mutt_update_encoding (BODY *a);
-void mutt_version (void);
-void mutt_view_attachments (HEADER *);
-void mutt_write_address_list (ADDRESS *adr, FILE *fp, int linelen, int display);
-void mutt_set_virtual (CONTEXT *);
-
-int mutt_add_to_rx_list (RX_LIST **list, const char *s, int flags, BUFFER *err);
-int mutt_addr_is_user (ADDRESS *);
-int mutt_addwch (wchar_t);
-int mutt_alias_complete (char *, size_t);
-void mutt_alias_add_reverse (ALIAS *t);
-void mutt_alias_delete_reverse (ALIAS *t);
-int mutt_alloc_color (int fg, int bg);
-int mutt_any_key_to_continue (const char *);
-char *mutt_apply_replace (char *, size_t, char *, REPLACE_LIST *);
-int mutt_buffy_check (int);
-int mutt_buffy_notify (void);
-int mutt_builtin_editor (const char *, HEADER *, HEADER *);
-int mutt_can_decode (BODY *);
-int mutt_change_flag (HEADER *, int);
-int mutt_check_encoding (const char *);
-int mutt_check_key (const char *);
-int mutt_check_menu (const char *);
-int mutt_check_mime_type (const char *);
-int mutt_check_month (const char *);
-int mutt_check_overwrite (const char *, const char *, char *, size_t, int *, char **);
-int mutt_check_traditional_pgp (HEADER *, int *);
-int mutt_command_complete (char *, size_t, int, int);
-int mutt_var_value_complete (char *, size_t, int);
+void mutt_set_followup_to(ENVELOPE *e);
+void mutt_shell_escape(void);
+void mutt_show_error(void);
+void mutt_signal_init(void);
+void mutt_stamp_attachment(BODY *a);
+void mutt_tag_set_flag(int flag, int bf);
+short mutt_ts_capability(void);
+void mutt_unblock_signals(void);
+void mutt_unblock_signals_system(int catch);
+void mutt_update_encoding(BODY *a);
+void mutt_version(void);
+void mutt_view_attachments(HEADER *hdr);
+void mutt_write_address_list(ADDRESS *adr, FILE *fp, int linelen, int display);
+void mutt_set_virtual(CONTEXT *ctx);
+int mutt_add_to_rx_list(RX_LIST **list, const char *s, int flags, BUFFER *err);
+int mutt_addr_is_user(ADDRESS *addr);
+int mutt_addwch(wchar_t wc);
+int mutt_alias_complete(char *s, size_t buflen);
+void mutt_alias_add_reverse(ALIAS *t);
+void mutt_alias_delete_reverse(ALIAS *t);
+int mutt_alloc_color(int fg, int bg);
+int mutt_any_key_to_continue(const char *s);
+char *mutt_apply_replace(char *dbuf, size_t dlen, char *sbuf, REPLACE_LIST *rlist);
+int mutt_buffy_check(int force);
+int mutt_buffy_notify(void);
+int mutt_builtin_editor(const char *path, HEADER *msg, HEADER *cur);
+int mutt_can_decode(BODY *a);
+int mutt_change_flag(HEADER *h, int bf);
+int mutt_check_encoding(const char *c);
+
+int mutt_check_mime_type(const char *s);
+int mutt_check_month(const char *s);
+int mutt_check_overwrite(const char *attname, const char *path, char *fname,
+ size_t flen, int *append, char **directory);
+int mutt_check_traditional_pgp(HEADER *h, int *redraw);
+int mutt_command_complete(char *buffer, size_t len, int pos, int numtabs);
+int mutt_var_value_complete(char *buffer, size_t len, int pos);
#ifdef USE_NOTMUCH
-int mutt_nm_query_complete (char *buffer, size_t len, int pos, int numtabs);
-int mutt_nm_tag_complete (char *buffer, size_t len, int pos, int numtabs);
+int mutt_nm_query_complete(char *buffer, size_t len, int pos, int numtabs);
+int mutt_nm_tag_complete(char *buffer, size_t len, int pos, int numtabs);
#endif
-int mutt_complete (char *, size_t);
-int mutt_compose_attachment (BODY *a);
-int mutt_copy_body (FILE *, BODY **, BODY *);
-int mutt_decode_save_attachment (FILE *, BODY *, char *, int, int);
-int mutt_display_message (HEADER *h);
-int mutt_dump_variables (int hide_sensitive);
-int mutt_edit_attachment(BODY *);
-int mutt_edit_message (CONTEXT *, HEADER *);
-int mutt_fetch_recips (ENVELOPE *out, ENVELOPE *in, int flags);
-int mutt_chscmp (const char *s, const char *chs);
+int mutt_complete(char *s, size_t slen);
+int mutt_compose_attachment(BODY *a);
+int mutt_copy_body(FILE *fp, BODY **tgt, BODY *src);
+int mutt_decode_save_attachment(FILE *fp, BODY *m, char *path, int displaying, int flags);
+int mutt_display_message(HEADER *cur);
+int mutt_dump_variables(int hide_sensitive);
+int mutt_edit_attachment(BODY *a);
+int mutt_edit_message(CONTEXT *ctx, HEADER *hdr);
+int mutt_fetch_recips(ENVELOPE *out, ENVELOPE *in, int flags);
+int mutt_chscmp(const char *s, const char *chs);
#define mutt_is_utf8(a) mutt_chscmp (a, "utf-8")
#define mutt_is_us_ascii(a) mutt_chscmp (a, "us-ascii")
-int mutt_parent_message (CONTEXT *, HEADER *, int);
-int mutt_prepare_template(FILE*, CONTEXT *, HEADER *, HEADER *, short);
-int mutt_resend_message (FILE *, CONTEXT *, HEADER *);
-int mutt_compose_to_sender (HEADER *);
+int mutt_parent_message(CONTEXT *ctx, HEADER *hdr, int find_root);
+int mutt_prepare_template(FILE *fp, CONTEXT *ctx, HEADER *newhdr, HEADER *hdr, short resend);
+int mutt_resend_message(FILE *fp, CONTEXT *ctx, HEADER *cur);
+int mutt_compose_to_sender(HEADER *hdr);
#define mutt_enter_fname(A,B,C,D,E) _mutt_enter_fname(A,B,C,D,E,0,NULL,NULL,0)
#define mutt_enter_vfolder(A,B,C,D,E) _mutt_enter_fname(A,B,C,D,E,0,NULL,NULL,MUTT_SEL_VFOLDER)
-
-int _mutt_enter_fname (const char *, char *, size_t, int *, int, int, char ***, int *, int);
-int mutt_enter_string (char *buf, size_t buflen, int col, int flags);
-int _mutt_enter_string (char *, size_t, int, int, int, char ***, int *, ENTER_STATE *);
+int _mutt_enter_fname(const char *prompt, char *buf, size_t blen, int *redraw, int buffy,
+ int multiple, char ***files, int *numfiles, int flags);
+int mutt_enter_string(char *buf, size_t buflen, int col, int flags);
+int _mutt_enter_string(char *buf, size_t buflen, int col, int flags, int multiple,
+ char ***files, int *numfiles, ENTER_STATE *state);
#define mutt_get_field(A,B,C,D) _mutt_get_field(A,B,C,D,0,NULL,NULL)
-int _mutt_get_field (const char *, char *, size_t, int, int, char ***, int *);
-int mutt_get_hook_type (const char *);
-int mutt_get_field_unbuffered (char *, char *, size_t, int);
+int _mutt_get_field(const char *field, char *buf, size_t buflen, int complete,
+ int multiple, char ***files, int *numfiles);
+int mutt_get_hook_type(const char *name);
+int mutt_get_field_unbuffered(char *msg, char *buf, size_t buflen, int flags);
#define mutt_get_password(A,B,C) mutt_get_field_unbuffered(A,B,C,MUTT_PASS)
-int mutt_get_postponed (CONTEXT *, HEADER *, HEADER **, char *, size_t);
-int mutt_get_tmp_attachment (BODY *);
-int mutt_index_menu (void);
-int mutt_invoke_sendmail (ADDRESS *, ADDRESS *, ADDRESS *, ADDRESS *, const char *, int);
-int mutt_is_mail_list (ADDRESS *);
-int mutt_is_message_type(int, const char *);
-int mutt_is_list_cc (int, ADDRESS *, ADDRESS *);
-int mutt_is_list_recipient (int, ADDRESS *, ADDRESS *);
-int mutt_is_subscribed_list (ADDRESS *);
-int mutt_is_text_part (BODY *);
-int mutt_is_valid_mailbox (const char *);
-int mutt_link_threads (HEADER *, HEADER *, CONTEXT *);
-int mutt_lookup_mime_type (BODY *, const char *);
-int mutt_match_rx_list (const char *, RX_LIST *);
-int mutt_match_spam_list (const char *, REPLACE_LIST *, char *, int);
-int mutt_messages_in_thread (CONTEXT *, HEADER *, int);
-int mutt_multi_choice (char *prompt, char *letters);
-int mutt_needs_mailcap (BODY *);
-int mutt_num_postponed (int);
-int mutt_parse_bind (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_exec (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_color (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_uncolor (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_hook (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_macro (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_mailboxes (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_mono (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_unmono (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_push (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_rc_line (/* const */ char *, BUFFER *, BUFFER *);
-int mutt_parse_rfc822_line (ENVELOPE *e, HEADER *hdr, char *line, char *p,
- short user_hdrs, short weed, short do_2047, LIST **lastp);
-int mutt_parse_score (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_unscore (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_parse_unhook (BUFFER *, BUFFER *, unsigned long, BUFFER *);
-int mutt_pattern_func (int, char *);
-int mutt_pipe_attachment (FILE *, BODY *, const char *, char *);
-int mutt_print_attachment (FILE *, BODY *);
-int mutt_query_complete (char *, size_t);
-int mutt_query_variables (LIST *queries);
-int mutt_save_attachment (FILE *, BODY *, char *, int, HEADER *);
-int _mutt_save_message (HEADER *, CONTEXT *, int, int, int);
-int mutt_save_message (HEADER *, int, int, int, int *);
-int mutt_search_command (int, int);
+
+int mutt_get_postponed(CONTEXT *ctx, HEADER *hdr, HEADER **cur, char *fcc, size_t fcclen);
+int mutt_get_tmp_attachment(BODY *a);
+int mutt_index_menu(void);
+int mutt_invoke_sendmail(ADDRESS *from, ADDRESS *to, ADDRESS *cc, ADDRESS *bcc,
+ const char *msg, int eightbit);
+int mutt_is_mail_list(ADDRESS *addr);
+int mutt_is_message_type(int type, const char *subtype);
+int mutt_is_list_cc(int alladdr, ADDRESS *a1, ADDRESS *a2);
+int mutt_is_list_recipient(int alladdr, ADDRESS *a1, ADDRESS *a2);
+int mutt_is_subscribed_list(ADDRESS *addr);
+int mutt_is_text_part(BODY *b);
+int mutt_link_threads(HEADER *cur, HEADER *last, CONTEXT *ctx);
+int mutt_lookup_mime_type(BODY *att, const char *path);
+int mutt_match_rx_list(const char *s, RX_LIST *l);
+int mutt_match_spam_list(const char *s, REPLACE_LIST *l, char *text, int textsize);
+int mutt_messages_in_thread(CONTEXT *ctx, HEADER *hdr, int flag);
+int mutt_multi_choice(char *prompt, char *letters);
+int mutt_needs_mailcap(BODY *m);
+int mutt_num_postponed(int force);
+int mutt_parse_bind(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_exec(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_color(BUFFER *buff, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_uncolor(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_hook(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_macro(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_mailboxes(BUFFER *path, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_mono(BUFFER *buff, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_unmono(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_push(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_rc_line(/* const */ char *line, BUFFER *token, BUFFER *err);
+int mutt_parse_rfc822_line(ENVELOPE *e, HEADER *hdr, char *line, char *p,
+ short user_hdrs, short weed, short do_2047, LIST **lastp);
+int mutt_parse_score(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_unscore(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_parse_unhook(BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err);
+int mutt_pattern_func(int op, char *prompt);
+int mutt_pipe_attachment(FILE *fp, BODY *b, const char *path, char *outfile);
+int mutt_print_attachment(FILE *fp, BODY *a);
+int mutt_query_complete(char *buf, size_t buflen);
+int mutt_query_variables(LIST *queries);
+int mutt_save_attachment(FILE *fp, BODY *m, char *path, int flags, HEADER *hdr);
+int _mutt_save_message(HEADER *h, CONTEXT *ctx, int delete, int decode, int decrypt);
+int mutt_save_message(HEADER *h, int delete, int decode, int decrypt, int *redraw);
+int mutt_search_command(int cur, int op);
#ifdef USE_SMTP
-int mutt_smtp_send (const ADDRESS *, const ADDRESS *, const ADDRESS *,
- const ADDRESS *, const char *, int);
+int mutt_smtp_send(const ADDRESS *from, const ADDRESS *to, const ADDRESS *cc,
+ const ADDRESS *bcc, const char *msgfile, int eightbit);
#endif
-size_t mutt_wstr_trunc (const char *, size_t, size_t, size_t *);
-int mutt_charlen (const char *s, int *);
-int mutt_strwidth (const char *);
-int mutt_compose_menu (HEADER *, char *, size_t, HEADER *, int);
-int mutt_thread_set_flag (HEADER *, int, int, int);
-void mutt_update_num_postponed (void);
-int mutt_which_case (const char *);
-int mutt_write_fcc (const char *path, HEADER *hdr, const char *msgid, int, char *, char **);
-int mutt_write_multiple_fcc (const char *path, HEADER *hdr, const char *msgid, int, char *, char **);
-int mutt_write_mime_body (BODY *, FILE *);
-int mutt_write_mime_header (BODY *, FILE *);
-int mutt_write_one_header (FILE *fp, const char *tag, const char *value, const char *pfx, int wraplen, int flags);
-int mutt_write_rfc822_header (FILE *, ENVELOPE *, BODY *, int, int);
-void mutt_write_references (LIST *, FILE *, int);
-int mutt_yesorno (const char *, int);
-void mutt_set_header_color(CONTEXT *, HEADER *);
-void mutt_sleep (short);
-int mutt_save_confirm (const char *, struct stat *);
-
-void mutt_browser_select_dir (char *f);
-void mutt_get_parent_path (char *output, char *path, size_t olen);
+
+size_t mutt_wstr_trunc(const char *src, size_t maxlen, size_t maxwid, size_t *width);
+int mutt_charlen(const char *s, int *width);
+int mutt_strwidth(const char *s);
+int mutt_compose_menu(HEADER *msg, char *fcc, size_t fcclen, HEADER *cur, int flags);
+int mutt_thread_set_flag(HEADER *hdr, int flag, int bf, int subthread);
+void mutt_update_num_postponed(void);
+int mutt_which_case(const char *s);
+int mutt_write_fcc(const char *path, HEADER *hdr, const char *msgid, int post,
+ char *fcc, char **finalpath);
+int mutt_write_multiple_fcc(const char *path, HEADER *hdr, const char *msgid,
+ int post, char *fcc, char **finalpath);
+int mutt_write_mime_body(BODY *a, FILE *f);
+int mutt_write_mime_header(BODY *a, FILE *f);
+int mutt_write_one_header(FILE *fp, const char *tag, const char *value,
+ const char *pfx, int wraplen, int flags);
+int mutt_write_rfc822_header(FILE *fp, ENVELOPE *env, BODY *attach, int mode, int privacy);
+void mutt_write_references(LIST *r, FILE *f, int trim);
+int mutt_yesorno(const char *msg, int def);
+void mutt_set_header_color(CONTEXT *ctx, HEADER *curhdr);
+void mutt_sleep(short s);
+int mutt_save_confirm(const char *s, struct stat *st);
+
+void mutt_browser_select_dir(char *f);
+void mutt_get_parent_path(char *output, char *path, size_t olen);
#define MUTT_RANDTAG_LEN (16)
void mutt_rand_base32(void *out, size_t len);
uint64_t mutt_rand64(void);
-ADDRESS *alias_reverse_lookup (ADDRESS *);
+ADDRESS *alias_reverse_lookup(ADDRESS *a);
/* base64.c */
-size_t mutt_to_base64 (char*, const char*, size_t, size_t);
-int mutt_from_base64 (char*, const char*);
+size_t mutt_to_base64(char *out, const char *cin, size_t len, size_t olen);
+int mutt_from_base64(char *out, const char *in);
/* utf8.c */
-int mutt_wctoutf8 (char *s, unsigned int c, size_t buflen);
+int mutt_wctoutf8(char *s, unsigned int c, size_t buflen);
#ifdef LOCALES_HACK
#define IsPrint(c) (isprint((unsigned char)(c)) || \
return safe_calloc (1, sizeof (pattern_t));
}
-int mutt_pattern_exec (struct pattern_t *pat, pattern_exec_flag flags, CONTEXT *ctx, HEADER *h, pattern_cache_t *);
-pattern_t *mutt_pattern_comp (/* const */ char *s, int flags, BUFFER *err);
-void mutt_check_simple (char *s, size_t len, const char *simple);
-void mutt_pattern_free (pattern_t **pat);
+int mutt_pattern_exec(struct pattern_t *pat, pattern_exec_flag flags,
+ CONTEXT *ctx, HEADER *h, pattern_cache_t *cache);
+pattern_t *mutt_pattern_comp(/* const */ char *s, int flags, BUFFER *err);
+void mutt_check_simple(char *s, size_t len, const char *simple);
+void mutt_pattern_free(pattern_t **pat);
/* ----------------------------------------------------------------------------
* Prototypes for broken systems
#endif /* _AIX */
/* unsorted */
-void ci_bounce_message (HEADER *, int *);
-int ci_send_message (int, HEADER *, char *, CONTEXT *, HEADER *);
+void ci_bounce_message(HEADER *h, int *redraw);
+int ci_send_message(int flags, HEADER *msg, char *tempfile, CONTEXT *ctx, HEADER *cur);
/* prototypes for compatibility functions */
#ifndef HAVE_WCSCASECMP
-int wcscasecmp (const wchar_t *a, const wchar_t *b);
+int wcscasecmp(const wchar_t *a, const wchar_t *b);
#endif
#ifndef HAVE_STRCASESTR
-char *strcasestr (const char *, const char *);
+char *strcasestr(const char *s1, const char *s2);
#endif
typedef struct mixchain MIXCHAIN;
-int mix_send_message (LIST *, const char *);
-int mix_check_message (HEADER *msg);
-void mix_make_chain (LIST **, int *);
+int mix_send_message(LIST *chain, const char *tempfile);
+int mix_check_message(HEADER *msg);
+void mix_make_chain(LIST **chainp, int *redraw);
#endif /* MIXMASTER */
unsigned int copiousoutput : 1; /* needs pager, basically */
} rfc1524_entry;
-rfc1524_entry *rfc1524_new_entry (void);
-void rfc1524_free_entry (rfc1524_entry **);
-int rfc1524_expand_command (BODY *, char *, char *, char *, int);
-int rfc1524_expand_filename (char *, char *, char *, size_t);
-int rfc1524_mailcap_lookup (BODY *, char *, rfc1524_entry *, int);
-int mutt_rename_file (char *, char *);
+rfc1524_entry *rfc1524_new_entry(void);
+void rfc1524_free_entry(rfc1524_entry **entry);
+int rfc1524_expand_command(BODY *a, char *filename, char *_type, char *command, int clen);
+int rfc1524_expand_filename(char *nametemplate, char *oldfile, char *newfile, size_t nflen);
+int rfc1524_mailcap_lookup(BODY *a, char *type, rfc1524_entry *entry, int opt);
+int mutt_rename_file(char *oldfile, char *newfile);
#endif /* _RFC1524_H */
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-char *mutt_choose_charset (const char *fromcode, const char *charsets,
- char *u, size_t ulen, char **d, size_t *dlen);
-int convert_nonmime_string (char **);
+char *mutt_choose_charset(const char *fromcode, const char *charsets, char *u,
+ size_t ulen, char **d, size_t *dlen);
+int convert_nonmime_string(char **ps);
-void _rfc2047_encode_string (char **, int, int);
-void rfc2047_encode_adrlist (ADDRESS *, const char *);
+void _rfc2047_encode_string(char **pd, int encode_specials, int col);
+void rfc2047_encode_adrlist(ADDRESS *addr, const char *tag);
#define rfc2047_encode_string(a) _rfc2047_encode_string (a, 0, 32);
-void rfc2047_decode (char **);
-void rfc2047_decode_adrlist (ADDRESS *);
+void rfc2047_decode(char **pd);
+void rfc2047_decode_adrlist(ADDRESS *a);
* Boston, MA 02110-1301, USA.
*/
-void rfc2231_decode_parameters (PARAMETER **);
-int rfc2231_encode_string (char **);
+void rfc2231_decode_parameters(PARAMETER **headp);
+int rfc2231_encode_string(char **pd);
#include "mutt.h"
/* body handler implementing RfC 3676 for format=flowed */
-int rfc3676_handler (BODY *a, STATE *s);
+int rfc3676_handler(BODY *a, STATE *s);
/* this does the space-stuffing for RfC3676 style messages */
-void rfc3676_space_stuff (HEADER *hdr);
+void rfc3676_space_stuff(HEADER *hdr);
#endif /* !_MUTT_RFC3676_H */
}
ADDRESS;
-void rfc822_dequote_comment (char *s);
-void rfc822_free_address (ADDRESS **);
-void rfc822_qualify (ADDRESS *, const char *);
-ADDRESS *rfc822_parse_adrlist (ADDRESS *, const char *s);
-ADDRESS *rfc822_cpy_adr (ADDRESS *addr, int);
-ADDRESS *rfc822_cpy_adr_real (ADDRESS *addr);
-ADDRESS *rfc822_append (ADDRESS **a, ADDRESS *b, int);
-int rfc822_write_address (char *, size_t, ADDRESS *, int);
-void rfc822_write_address_single (char *, size_t, ADDRESS *, int);
-void rfc822_free_address (ADDRESS **addr);
-void rfc822_cat (char *, size_t, const char *, const char *);
-int rfc822_valid_msgid (const char *msgid);
-int rfc822_remove_from_adrlist (ADDRESS **a, const char *mailbox);
+void rfc822_dequote_comment(char *s);
+void rfc822_free_address(ADDRESS **p);
+void rfc822_qualify(ADDRESS *addr, const char *host);
+ADDRESS *rfc822_parse_adrlist(ADDRESS *top, const char *s);
+ADDRESS *rfc822_cpy_adr(ADDRESS *addr, int prune);
+ADDRESS *rfc822_cpy_adr_real(ADDRESS *addr);
+ADDRESS *rfc822_append(ADDRESS **a, ADDRESS *b, int prune);
+int rfc822_write_address(char *buf, size_t buflen, ADDRESS *addr, int display);
+void rfc822_write_address_single(char *buf, size_t buflen, ADDRESS *addr, int display);
+void rfc822_free_address(ADDRESS **p);
+void rfc822_cat(char *buf, size_t buflen, const char *value, const char *specials);
+int rfc822_valid_msgid(const char *msgid);
+int rfc822_remove_from_adrlist(ADDRESS **a, const char *mailbox);
extern int RFC822Error;
extern const char * const RFC822Errors[];
} SHA1_CTX;
void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]);
-void SHA1Init(SHA1_CTX* context);
-void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len);
-void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
+void SHA1Init(SHA1_CTX *context);
+void SHA1Update(SHA1_CTX *context, const unsigned char *data, uint32_t len);
+void SHA1Final(unsigned char digest[20], SHA1_CTX *context);
# define SHA1_Transform SHA1Transform
# define SHA1_Init SHA1Init
} smime_key_t;
-void smime_void_passphrase (void);
-int smime_valid_passphrase (void);
+void smime_void_passphrase(void);
+int smime_valid_passphrase(void);
-int smime_decrypt_mime (FILE *, FILE **, BODY *, BODY **);
+int smime_decrypt_mime(FILE *fpin, FILE **fpout, BODY *b, BODY **cur);
-int smime_application_smime_handler (BODY *, STATE *);
+int smime_application_smime_handler(BODY *m, STATE *s);
-BODY* smime_sign_message (BODY *);
+BODY *smime_sign_message(BODY *a);
-BODY* smime_build_smime_entity (BODY *, char *);
+BODY *smime_build_smime_entity(BODY *a, char *certlist);
-int smime_verify_one(BODY *, STATE *, const char *);
+int smime_verify_one(BODY *sigbdy, STATE *s, const char *tempfile);
-int smime_verify_sender(HEADER *);
+int smime_verify_sender(HEADER *h);
+void smime_getkeys(ENVELOPE *env);
-char* smime_get_field_from_db (char *, char *, short, short);
+char *smime_findKeys(ADDRESS *adrlist, int oppenc_mode);
-void smime_getkeys (ENVELOPE *);
+void smime_invoke_import(char *infile, char *mailbox);
-char *smime_findKeys (ADDRESS *adrlist, int oppenc_mode);
-
-void smime_invoke_import (char *, char *);
-
-int smime_send_menu (HEADER *msg, int *redraw);
+int smime_send_menu(HEADER *msg, int *redraw);
#endif
#define SORT_LAST (1<<9)
typedef int sort_t (const void *, const void *);
-sort_t *mutt_get_sort_func (int);
+sort_t *mutt_get_sort_func(int method);
-void mutt_clear_threads (CONTEXT *);
-void mutt_sort_headers (CONTEXT *, int);
-void mutt_sort_threads (CONTEXT *, int);
-int mutt_select_sort (int);
-THREAD *mutt_sort_subthreads (THREAD *, int);
+void mutt_clear_threads(CONTEXT *ctx);
+void mutt_sort_headers(CONTEXT *ctx, int init);
+void mutt_sort_threads(CONTEXT *ctx, int init);
+int mutt_select_sort(int reverse);
+THREAD *mutt_sort_subthreads(THREAD *thread, int init);
WHERE short BrowserSort INITVAL (SORT_SUBJECT);
WHERE short Sort INITVAL (SORT_DATE);
}
ciss_url_t;
-url_scheme_t url_check_scheme (const char *s);
-int url_parse_ciss (ciss_url_t *ciss, char *src);
-int url_ciss_tostring (ciss_url_t* ciss, char* dest, size_t len, int flags);
-int url_parse_mailto (ENVELOPE *e, char **body, const char *src);
-int url_pct_decode (char *s);
+url_scheme_t url_check_scheme(const char *s);
+int url_parse_ciss(ciss_url_t *ciss, char *src);
+int url_ciss_tostring(ciss_url_t *ciss, char *dest, size_t len, int flags);
+int url_parse_mailto(ENVELOPE *e, char **body, const char *src);
+int url_pct_decode(char *s);
#endif
projects / neomutt / commitdiff