b = mutt_read_mime_header (fp, 0);
if (b) {
if (b->parameter) {
- mutt_free_parameter (&a->parameter);
+ parameter_delete(&a->parameter);
a->parameter = b->parameter;
b->parameter = NULL;
}
m->length = 0;
m->encoding = saved_encoding;
if (saved_parts) {
- mutt_free_header (&m->hdr);
+ header_delete(&m->hdr);
m->parts = saved_parts;
m->hdr = saved_hdr;
}
if (fseeko_last_message (f) == -1)
return (0);
- hdr = mutt_new_header ();
+ hdr = header_new();
tmp_envelope = mutt_read_rfc822_header (f, hdr, 0, 0);
if (!(hdr->read || hdr->old))
result = 1;
- mutt_free_envelope (&tmp_envelope);
- mutt_free_header (&hdr);
+ envelope_delete(&tmp_envelope);
+ header_delete(&hdr);
return result;
}
return;
/* clean up previous junk */
- mutt_free_parameter (&b->parameter);
+ parameter_delete(&b->parameter);
p_delete(&b->subtype);
mutt_parse_content_type (buf, b);
mutt_free_body (&b->parts);
if (!mutt_is_message_type (b->type, b->subtype) && b->hdr) {
b->hdr->content = NULL;
- mutt_free_header (&b->hdr);
+ header_delete(&b->hdr);
}
if (fp && (is_multipart (b) || mutt_is_message_type (b->type, b->subtype)))
HEADER *mutt_hcache_restore (const unsigned char *d, HEADER ** oh)
{
int off = 0;
- HEADER *h = mutt_new_header ();
+ HEADER *h = header_new();
/* skip validate */
off += sizeof (validate);
memcpy (h, d + off, sizeof (HEADER));
off += sizeof (HEADER);
- h->env = mutt_new_envelope ();
+ h->env = envelope_new();
restore_envelope (h->env, d, &off);
h->content = mutt_new_body ();
if (oh) {
h->old = (*oh)->old;
h->path = m_strdup((*oh)->path);
- mutt_free_header (oh);
+ header_delete(oh);
}
return h;
n->references = msg->env->references;
msg->env->references = NULL;
- mutt_free_envelope (&msg->env);
+ envelope_delete(&msg->env);
msg->env = n;
n = NULL;
fputs ("\n\n", fp);
/* update context with message header */
- ctx->hdrs[msgno] = mutt_new_header ();
+ ctx->hdrs[msgno] = header_new();
ctx->hdrs[msgno]->index = h.sid - 1;
if (h.sid != ctx->msgcount + 1)
struct parameter *next;
} PARAMETER;
+DO_INIT(PARAMETER, parameter);
+void parameter_wipe(PARAMETER *);
+
+DO_NEW(PARAMETER, parameter);
+DO_DELETE(PARAMETER, parameter);
+DO_SLIST(PARAMETER, parameter);
+
/****************************************************************************/
/* rfc822 envelopes */
unsigned int refs_changed:1; /* References changed to break thread */
} ENVELOPE;
+DO_INIT(ENVELOPE, envelope);
+void envelope_wipe(ENVELOPE*);
+
+DO_NEW(ENVELOPE, envelope);
+DO_DELETE(ENVELOPE, envelope);
/****************************************************************************/
/* rfc822 content-* */
char *maildir_flags; /* unknown maildir flags */
} HEADER;
+DO_INIT(HEADER, header);
+void header_wipe(HEADER *);
+
+DO_NEW(HEADER, header);
+DO_DELETE(HEADER, header);
+
#endif /* MUTT_LIB_MIME_MIME_TYPES_H */
* Copyright © 2006 Pierre Habouzit
*/
+#include "mime-types.h"
+
const char MimeSpecials[] = "@.,;:<>[]\\\"()?/= \t";
const char *BodyTypes[] = {
"x-uuencoded",
};
+void address_wipe(address_t *addr)
+{
+ p_delete(&addr->personal);
+ p_delete(&addr->mailbox);
+ address_delete(&addr->next);
+}
+
+void parameter_wipe(PARAMETER *param)
+{
+ p_delete(¶m->attribute);
+ p_delete(¶m->value);
+ parameter_delete(¶m->next);
+}
+
+void envelope_wipe(ENVELOPE *p)
+{
+ address_delete(&p->return_path);
+ address_delete(&p->from);
+ address_delete(&p->to);
+ address_delete(&p->cc);
+ address_delete(&p->bcc);
+ address_delete(&p->sender);
+ address_delete(&p->reply_to);
+ address_delete(&p->mail_followup_to);
+
+ p_delete(&p->list_post);
+ p_delete(&p->subject);
+ /* real_subj is just an offset to subject and shouldn't be freed */
+ p_delete(&p->message_id);
+ p_delete(&p->supersedes);
+ p_delete(&p->date);
+ p_delete(&p->x_label);
+ p_delete(&p->organization);
+#ifdef USE_NNTP
+ p_delete(&p->newsgroups);
+ p_delete(&p->xref);
+ p_delete(&p->followup_to);
+ p_delete(&p->x_comment_to);
+#endif
+
+ mutt_buffer_free (&p->spam);
+ mutt_free_list(&p->references);
+ mutt_free_list(&p->in_reply_to);
+ mutt_free_list(&p->userhdrs);
+}
+
+void header_wipe(HEADER *h)
+{
+ envelope_delete(&h->env);
+ mutt_free_body (&h->content);
+ p_delete(&h->maildir_flags);
+ p_delete(&h->tree);
+ p_delete(&h->path);
+#ifdef MIXMASTER
+ mutt_free_list(&h->chain);
+#endif
+ p_delete(&h->data);
+}
+
extern const char RFC822Specials[];
ssize_t mutt_read_rfc822_line(FILE*, char**, ssize_t*);
-LIST *mutt_parse_references (char *, int);
+LIST *mutt_parse_references(char *, int);
+int mutt_check_encoding(const char *);
/*** addresses ***/
if (!p->attribute || !p->value) {
*headp = p->next;
p->next = NULL;
- mutt_free_parameter(&p);
+ parameter_delete(&p);
} else {
headp = &(*headp)->next;
}
if (value) {
if (encoded)
mutt_convert_string (&value, charset, Charset, M_ICONV_HOOK_FROM);
- *head = mutt_new_parameter ();
+ *head = parameter_new();
(*head)->attribute = m_strdup(attribute);
(*head)->value = value;
head = &(*head)->next;
int encoded;
int idx;
- short dirty = 0; /* set to 1 when we may have created
- * empty parameters.
- */
+ short dirty = 0; /* 1 when we may have created empty parameters. */
if (!headp)
return;
#include "mutt_idna.h"
-void address_wipe(address_t *addr)
-{
- p_delete(&addr->personal);
- p_delete(&addr->mailbox);
- address_delete(&addr->next);
-}
-
-
void rfc822_qualify(address_t *addr, const char *host)
{
char *p;
return lst;
}
-int mutt_check_encoding (const char *c)
+int mutt_check_encoding(const char *s)
{
- if (ascii_strncasecmp ("7bit", c, sizeof ("7bit") - 1) == 0)
- return (ENC7BIT);
- else if (ascii_strncasecmp ("8bit", c, sizeof ("8bit") - 1) == 0)
- return (ENC8BIT);
- else if (ascii_strncasecmp ("binary", c, sizeof ("binary") - 1) == 0)
- return (ENCBINARY);
- else
- if (ascii_strncasecmp
- ("quoted-printable", c, sizeof ("quoted-printable") - 1) == 0)
- return (ENCQUOTEDPRINTABLE);
- else if (ascii_strncasecmp ("base64", c, sizeof ("base64") - 1) == 0)
- return (ENCBASE64);
- else if (ascii_strncasecmp ("x-uuencode", c, sizeof ("x-uuencode") - 1) == 0)
- return (ENCUUENCODED);
- else
- return (ENCOTHER);
+#define COMPARE(tok, value) \
+ if (!ascii_strncasecmp(tok, s, sizeof(tok) - 1)) { \
+ return value; \
+ }
+ COMPARE("7bit", ENC7BIT);
+ COMPARE("8bit", ENC8BIT);
+ COMPARE("binary", ENCBINARY);
+ COMPARE("quoted-printable", ENCQUOTEDPRINTABLE);
+ COMPARE("base64", ENCBASE64);
+ COMPARE("x-uuencode", ENCUUENCODED);
+#undef COMPARE
+
+ return ENCOTHER;
}
-static PARAMETER *parse_parameters (const char *s)
+static PARAMETER *parse_parameters(const char *s)
{
PARAMETER *head = 0, *cur = 0, *new;
char buffer[LONG_STRING];
if (*p != ';') {
i = p - s;
- new = mutt_new_parameter ();
+ new = parameter_new();
new->attribute = p_dupstr(s, i);
char *subtype;
p_delete(&ct->subtype);
- mutt_free_parameter (&ct->parameter);
+ parameter_delete(&ct->parameter);
/* First extract any existing parameters */
if ((pc = strchr (s, ';')) != NULL) {
m_strreplace(&ct->filename, s);
if ((s = mutt_get_parameter ("name", parms)) != 0)
ct->form_name = m_strdup(s);
- mutt_free_parameter (&parms);
+ parameter_delete(&parms);
}
}
{
BODY *msg;
- parent->hdr = mutt_new_header ();
+ parent->hdr = header_new();
parent->hdr->offset = ftello (fp);
parent->hdr->env = mutt_read_rfc822_header (fp, parent->hdr, 0, 0);
msg = parent->hdr->content;
* Used for recall-message.
*
* Returns: newly allocated envelope structure. You should free it by
- * mutt_free_envelope() when envelope stay unneeded.
+ * envelope_delete() when envelope stay unneeded.
*/
ENVELOPE *mutt_read_rfc822_header (FILE * f, HEADER * hdr, short user_hdrs,
short weed)
{
- ENVELOPE *e = mutt_new_envelope ();
+ ENVELOPE *e = envelope_new();
LIST *last = NULL;
char *line = p_new(char, LONG_STRING);
char *p;
case 'b':
case 'c':
if (!msg)
- msg = mutt_new_header ();
+ msg = header_new();
if (!msg->env)
- msg->env = mutt_new_envelope ();
+ msg->env = envelope_new();
if (i == 'b')
msg->env->bcc = rfc822_parse_adrlist (msg->env->bcc, optarg);
else
mutt_flushinp ();
if (!msg)
- msg = mutt_new_header ();
+ msg = header_new();
if (draftFile)
infile = draftFile;
else {
if (!msg->env)
- msg->env = mutt_new_envelope ();
+ msg->env = envelope_new();
for (i = optind; i < argc; i++) {
if (url_check_scheme (argv[i]) == U_MAILTO)
if (ctx->msgcount == ctx->hdrmax)
mx_alloc_memory (ctx);
- ctx->hdrs[ctx->msgcount] = hdr = mutt_new_header ();
+ ctx->hdrs[ctx->msgcount] = hdr = header_new();
hdr->offset = loc;
hdr->index = ctx->msgcount;
if (ctx->msgcount == ctx->hdrmax)
mx_alloc_memory (ctx);
- curhdr = ctx->hdrs[ctx->msgcount] = mutt_new_header ();
+ curhdr = ctx->hdrs[ctx->msgcount] = header_new();
curhdr->received = t - tz;
curhdr->offset = loc;
curhdr->index = ctx->msgcount;
p_delete(&ctx->v2r);
if (ctx->readonly) {
for (i = 0; i < ctx->msgcount; i++)
- mutt_free_header (&(ctx->hdrs[i])); /* nothing to do! */
+ header_delete(&(ctx->hdrs[i])); /* nothing to do! */
p_delete(&ctx->hdrs);
}
else {
if (rc == -1) {
/* free the old headers */
for (j = 0; j < old_msgcount; j++)
- mutt_free_header (&(old_hdrs[j]));
+ header_delete(&(old_hdrs[j]));
p_delete(&old_hdrs);
ctx->quiet = 0;
mutt_set_flag (ctx, ctx->hdrs[i], M_TAG, old_hdrs[j]->tagged);
/* we don't need this header any more */
- mutt_free_header (&(old_hdrs[j]));
+ header_delete(&(old_hdrs[j]));
}
}
/* free the remaining old headers */
for (j = 0; j < old_msgcount; j++) {
if (old_hdrs[j]) {
- mutt_free_header (&(old_hdrs[j]));
+ header_delete(&(old_hdrs[j]));
msg_mod = 1;
}
}
p_delete(&(*md)->canon_fname);
if ((*md)->h)
- mutt_free_header (&(*md)->h);
+ header_delete(&(*md)->h);
p_delete(md);
}
if ((f = fopen (fname, "r")) != NULL) {
if (!h)
- h = mutt_new_header ();
+ h = header_new();
h->env = mutt_read_rfc822_header (f, h, 0, 0);
fstat (fileno (f), &st);
if (ctx->magic == M_MH)
h = maildir_parse_message (ctx->magic, buf, is_old, NULL);
else {
- h = mutt_new_header ();
+ h = header_new();
h->old = is_old;
maildir_parse_flags (h, buf);
}
#endif
}
else
- mutt_free_header (&p->h);
+ header_delete(&p->h);
#ifdef USE_HCACHE
p_delete(&data);
#endif
ctx->hdrs[i]->trash = p->h->trash;
/* this is a duplicate of an existing header, so remove it */
- mutt_free_header (&p->h);
+ header_delete(&p->h);
}
/* This message was not in the list of messages we just scanned.
* Check to see if we have enough information to know if the
if (!ctx->hdrs[i]->changed)
maildir_update_flags (ctx, ctx->hdrs[i], p->h);
- mutt_free_header (&p->h);
+ header_delete(&p->h);
}
else /* message has disappeared */
occult = 1;
/* copy parameters */
for (par = b->parameter, ppar = &b->parameter; par;
ppar = &(*ppar)->next, par = par->next) {
- *ppar = mutt_new_parameter ();
+ *ppar = parameter_new();
(*ppar)->attribute = m_strdup(par->attribute);
(*ppar)->value = m_strdup(par->value);
}
a = a->next;
if (b->parameter)
- mutt_free_parameter (&b->parameter);
+ parameter_delete(&b->parameter);
if (b->unlink && b->filename) {
debug_print (1, ("unlinking %s.\n", b->filename));
unlink (b->filename);
if (b->hdr) {
/* Don't free twice (b->hdr->content = b->parts) */
b->hdr->content = NULL;
- mutt_free_header (&b->hdr);
+ header_delete(&b->hdr);
}
if (b->parts)
*p = 0;
}
-void mutt_free_parameter (PARAMETER ** p)
-{
- PARAMETER *t = *p;
- PARAMETER *o;
-
- while (t) {
- p_delete(&t->attribute);
- p_delete(&t->value);
- o = t;
- t = t->next;
- p_delete(&o);
- }
- *p = 0;
-}
-
HEADER *mutt_dup_header (HEADER * h)
{
HEADER *hnew;
- hnew = mutt_new_header ();
+ hnew = header_new();
memcpy (hnew, h, sizeof (HEADER));
return hnew;
}
-void mutt_free_header (HEADER ** h)
-{
- if (!h || !*h)
- return;
- mutt_free_envelope (&(*h)->env);
- mutt_free_body (&(*h)->content);
- p_delete(&(*h)->maildir_flags);
- p_delete(&(*h)->tree);
- p_delete(&(*h)->path);
-#ifdef MIXMASTER
- mutt_free_list (&(*h)->chain);
-#endif
- p_delete(&(*h)->data);
- p_delete(h);
-}
-
/* returns true if the header contained in "s" is in list "t" */
int mutt_matches_ignore (const char *s, LIST * t)
{
address_t *alias;
if ((alias = mutt_lookup_alias (s + 1))) {
- h = mutt_new_header ();
- h->env = mutt_new_envelope ();
+ h = header_new();
+ h->env = envelope_new();
h->env->from = h->env->to = alias;
mutt_default_save (p, sizeof (p), h);
h->env->from = h->env->to = NULL;
- mutt_free_header (&h);
+ header_delete(&h);
/* Avoid infinite recursion if the resulting folder starts with '@' */
if (*p != '@')
recurse = 1;
}
}
- q = mutt_new_parameter ();
+ q = parameter_new();
q->attribute = m_strdup(attribute);
q->value = m_strdup(value);
q->next = *p;
if (ascii_strcasecmp (attribute, q->attribute) == 0) {
*p = q->next;
q->next = NULL;
- mutt_free_parameter (&q);
+ parameter_delete(&q);
return;
}
}
return 0;
}
-void mutt_free_envelope (ENVELOPE ** p)
-{
- if (!*p)
- return;
- address_delete (&(*p)->return_path);
- address_delete (&(*p)->from);
- address_delete (&(*p)->to);
- address_delete (&(*p)->cc);
- address_delete (&(*p)->bcc);
- address_delete (&(*p)->sender);
- address_delete (&(*p)->reply_to);
- address_delete (&(*p)->mail_followup_to);
-
- p_delete(&(*p)->list_post);
- p_delete(&(*p)->subject);
- /* real_subj is just an offset to subject and shouldn't be freed */
- p_delete(&(*p)->message_id);
- p_delete(&(*p)->supersedes);
- p_delete(&(*p)->date);
- p_delete(&(*p)->x_label);
- p_delete(&(*p)->organization);
-#ifdef USE_NNTP
- p_delete(&(*p)->newsgroups);
- p_delete(&(*p)->xref);
- p_delete(&(*p)->followup_to);
- p_delete(&(*p)->x_comment_to);
-#endif
-
- mutt_buffer_free (&(*p)->spam);
- mutt_free_list (&(*p)->references);
- mutt_free_list (&(*p)->in_reply_to);
- mutt_free_list (&(*p)->userhdrs);
- p_delete(p);
-}
-
/* move all the headers from extra not present in base into base */
void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra)
{
/* copies each existing element if necessary, and sets the element
- * to NULL in the source so that mutt_free_envelope doesn't leave us
+ * to NULL in the source so that envelope_delete doesn't leave us
* with dangling pointers. */
#define MOVE_ELEM(h) if (!base->h) { base->h = (*extra)->h; (*extra)->h = NULL; }
MOVE_ELEM(return_path);
MOVE_ELEM(userhdrs);
#undef MOVE_ELEM
- mutt_free_envelope(extra);
+ envelope_delete(extra);
}
void _mutt_mktemp (char *s, const char *src, int line)
hash_destroy (&ctx->id_hash, NULL);
mutt_clear_threads (ctx);
for (i = 0; i < ctx->msgcount; i++)
- mutt_free_header (&ctx->hdrs[i]);
+ header_delete(&ctx->hdrs[i]);
p_delete(&ctx->hdrs);
p_delete(&ctx->v2r);
if (ctx->id_hash && ctx->hdrs[i]->env->message_id)
hash_delete (ctx->id_hash, ctx->hdrs[i]->env->message_id,
ctx->hdrs[i], NULL);
- mutt_free_header (&ctx->hdrs[i]);
+ header_delete(&ctx->hdrs[i]);
}
}
#undef this_body
char *p, *b;
int x, done = 0;
- hdr->env = mutt_new_envelope ();
+ hdr->env = envelope_new();
hdr->env->newsgroups = m_strdup(nntp_data->group);
hdr->content = mutt_new_body ();
hdr->content->type = TYPETEXT;
if (ctx->msgcount >= ctx->hdrmax)
mx_alloc_memory (ctx);
- ctx->hdrs[ctx->msgcount] = mutt_new_header ();
+ ctx->hdrs[ctx->msgcount] = header_new();
ctx->hdrs[ctx->msgcount]->index = ctx->msgcount;
nntp_parse_xover (ctx, line, ctx->hdrs[ctx->msgcount]);
mutt_message ("%s %d/%d", fc->msg, num, total);
}
else
- mutt_free_header (&ctx->hdrs[ctx->msgcount]); /* skip it */
+ header_delete(&ctx->hdrs[ctx->msgcount]); /* skip it */
return 0;
}
if (ctx->msgcount >= ctx->hdrmax)
mx_alloc_memory (ctx);
- h = ctx->hdrs[ctx->msgcount] = mutt_new_header ();
+ h = ctx->hdrs[ctx->msgcount] = header_new();
h->index = ctx->msgcount;
ret = nntp_read_header (ctx, NULL, current);
mx_update_context (ctx, 1);
}
else
- mutt_free_header (&h); /* skip it */
+ header_delete(&h); /* skip it */
if (ret == -1) {
p_delete(&fc.messages);
return -1;
return -1;
}
- mutt_free_envelope (&ctx->hdrs[msgno]->env);
+ envelope_delete(&ctx->hdrs[msgno]->env);
ctx->hdrs[msgno]->env =
mutt_read_rfc822_header (msg->fp, ctx->hdrs[msgno], 0, 0);
/* fix content length */
return 1;
if (ctx->msgcount == ctx->hdrmax)
mx_alloc_memory (ctx);
- ctx->hdrs[ctx->msgcount] = mutt_new_header ();
+ ctx->hdrs[ctx->msgcount] = header_new();
ctx->hdrs[ctx->msgcount]->index = ctx->msgcount;
mutt_message (_("Fetching %s from server..."), msgid);
/* since nntp_read_header() may set read flag, we must reset it */
ctx->hdrs[ctx->msgcount]->read = 0;
if (ret != 0)
- mutt_free_header (&ctx->hdrs[ctx->msgcount]);
+ header_delete(&ctx->hdrs[ctx->msgcount]);
else {
ctx->msgcount++;
mx_update_context (ctx, 1);
mx_alloc_memory (ctx);
ctx->msgcount++;
- ctx->hdrs[i] = mutt_new_header ();
+ ctx->hdrs[i] = header_new();
ctx->hdrs[i]->data = m_strdup(line);
}
else if (ctx->hdrs[i]->index != index - 1)
if (ret != PQ_OK) {
for (i = ctx->msgcount; i < new_count; i++)
- mutt_free_header (&ctx->hdrs[i]);
+ header_delete(&ctx->hdrs[i]);
return ret;
}
cache->path = m_strdup(path);
rewind (msg->fp);
uidl = h->data;
- mutt_free_envelope (&h->env);
+ envelope_delete(&h->env);
h->env = mutt_read_rfc822_header (msg->fp, h, 0, 0);
h->data = uidl;
h->lines = 0;
|| b == NULL) {
err:
mx_close_message (&msg);
- mutt_free_envelope (&newhdr->env);
+ envelope_delete(&newhdr->env);
mutt_free_body (&newhdr->content);
mutt_error _("Decryption failed.");
mx_close_message (&msg);
if (rv == -1) {
- mutt_free_envelope (&newhdr->env);
+ envelope_delete(&newhdr->env);
mutt_free_body (&newhdr->content);
}
#define mutt_system(x) _mutt_system(x,0)
int _mutt_system (const char *, int);
-#define mutt_new_parameter() p_new(PARAMETER, 1)
-#define mutt_new_header() p_new(HEADER, 1)
-#define mutt_new_envelope() p_new(ENVELOPE, 1)
#define mutt_new_enter_state() p_new(ENTER_STATE, 1)
typedef const char *format_t (char *, size_t, char, 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_new_body(void);
BODY *mutt_parse_multipart (FILE *, const char *, off_t, int);
BODY *mutt_parse_messageRFC822 (FILE *, BODY *);
BODY *mutt_read_mime_header (FILE *, int);
void mutt_forward_trailer (FILE * fp);
void mutt_free_body (BODY **);
void mutt_free_color (int fg, int bg);
-void mutt_free_envelope (ENVELOPE **);
-void mutt_free_header (HEADER **);
-void mutt_free_parameter (PARAMETER **);
void mutt_generate_header (char *, size_t, HEADER *, int);
void mutt_help (int);
void mutt_draw_tree (CONTEXT *);
int mutt_any_key_to_continue (const char *);
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 *);
/* fall through to OP_MAIL */
case OP_MAIL:
- msg = mutt_new_header ();
- msg->env = mutt_new_envelope ();
+ msg = header_new();
+ msg->env = envelope_new();
if (!menu->tagprefix) {
msg->env->to = result_to_addr (QueryTable[menu->current].data);
}
parent = hdr;
- tmphdr = mutt_new_header ();
- tmphdr->env = mutt_new_envelope ();
+ tmphdr = header_new();
+ tmphdr->env = envelope_new();
mutt_make_forward_subject (tmphdr->env, Context, parent);
mutt_mktemp (tmpbody);
mutt_unlink (tmpbody);
}
- mutt_free_header (&tmphdr);
+ header_delete(&tmphdr);
}
}
}
- tmphdr = mutt_new_header ();
- tmphdr->env = mutt_new_envelope ();
+ tmphdr = header_new();
+ tmphdr->env = envelope_new();
mutt_make_forward_subject (tmphdr->env, Context, curhdr);
mutt_mktemp (tmpbody);
if (!(tmpfp = safe_fopen (tmpbody, "w"))) {
mutt_error (_("Can't create %s."), tmpbody);
- mutt_free_header (&tmphdr);
+ header_delete(&tmphdr);
return;
}
}
}
else
- mutt_free_header (&tmphdr);
+ header_delete(&tmphdr);
ci_send_message (flags, tmphdr, *tmpbody ? tmpbody : NULL, NULL, curhdr);
else if (nattach == 1)
mime_reply_any = 1;
- tmphdr = mutt_new_header ();
- tmphdr->env = mutt_new_envelope ();
+ tmphdr = header_new();
+ tmphdr->env = envelope_new();
if (attach_reply_envelope_defaults (tmphdr->env, idx, idxlen,
parent ? parent : (cur ? cur->
hdr : NULL),
flags) == -1) {
- mutt_free_header (&tmphdr);
+ header_delete(&tmphdr);
return;
}
mutt_mktemp (tmpbody);
if ((tmpfp = safe_fopen (tmpbody, "w")) == NULL) {
mutt_error (_("Can't create %s."), tmpbody);
- mutt_free_header (&tmphdr);
+ header_delete(&tmphdr);
return;
}
if (mime_reply_any && !cur &&
copy_problematic_attachments (fp, &tmphdr->content, idx, idxlen,
0) == NULL) {
- mutt_free_header (&tmphdr);
+ header_delete(&tmphdr);
fclose (tmpfp);
return;
}
int mutt_resend_message (FILE * fp, CONTEXT * ctx, HEADER * cur)
{
- HEADER *msg = mutt_new_header ();
+ HEADER *msg = header_new();
if (mutt_prepare_template (fp, ctx, msg, cur, 1) < 0)
return -1;
*/
if (!msg) {
- msg = mutt_new_header ();
+ msg = header_new();
if (flags == SENDPOSTPONED) {
if ((flags =
}
if (!msg->env)
- msg->env = mutt_new_envelope ();
+ msg->env = envelope_new();
}
/* Parse and use an eventual list-post header */
}
safe_fclose (&tempfp);
- mutt_free_header (&msg);
+ header_delete(&msg);
return rv;
}
fflush (fp);
rewind (fp);
- body->hdr = mutt_new_header ();
+ body->hdr = header_new();
body->hdr->offset = 0;
/* we don't need the user headers here */
body->hdr->env = mutt_read_rfc822_header (fp, body->hdr, 0, 0);
projects / apps / madmutt.git / commitdiff