t = a;
a = a->next;
t->next = NULL;
- rfc822_free_address (&t);
+ address_delete (&t);
continue;
}
else {
if (mutt_addrlist_to_idna (adr, &err) < 0) {
mutt_error (_("Bad IDN: '%s'"), err);
p_delete(&err);
- rfc822_free_address (&adr);
+ address_delete (&adr);
return;
}
}
if (query_quadoption (OPT_BOUNCE, prompt) != M_YES) {
- rfc822_free_address (&adr);
+ address_delete (&adr);
CLEARLINE (LINES - 1);
mutt_message (h ? _("Message not bounced.") : _("Messages not bounced."));
return;
CLEARLINE (LINES - 1);
rc = mutt_bounce_message (NULL, h, adr);
- rfc822_free_address (&adr);
+ address_delete (&adr);
/* If no error, or background, display message. */
if ((rc == 0) || (rc == S_BKG))
mutt_message (h ? _("Message bounced.") : _("Messages bounced."));
mutt_addrlist_to_local (*addr);
rfc822_write_address (buf, sizeof (buf), *addr, 0);
if (mutt_get_field (Prompts[line - 1], buf, sizeof (buf), M_ALIAS) == 0) {
- rfc822_free_address (addr);
+ address_delete (addr);
*addr = mutt_parse_adrlist (*addr, buf);
*addr = mutt_expand_aliases (*addr);
}
format_address_header (h, a);
- rfc822_free_address (&a);
+ address_delete (&a);
p_delete(&s);
return 1;
|| !(validity & CRYPT_KV_ADDR)))
this_key_has_weak = 1;
}
- rfc822_free_address (&r);
+ address_delete (&r);
if (match) {
crypt_key_t *tmp;
}
else if (r == -1) {
p_delete(&keylist);
- rfc822_free_address (&tmp);
- rfc822_free_address (&addr);
+ address_delete (&tmp);
+ address_delete (&addr);
return NULL;
}
}
#endif
&forced_valid)) == NULL) {
p_delete(&keylist);
- rfc822_free_address (&tmp);
- rfc822_free_address (&addr);
+ address_delete (&tmp);
+ address_delete (&addr);
return NULL;
}
}
keylist_used = m_strlen(keylist);
crypt_free_key (&key);
- rfc822_free_address (&addr);
+ address_delete (&addr);
}
- rfc822_free_address (&tmp);
+ address_delete (&tmp);
return (keylist);
}
rfc822_write_address (tmp, sizeof (tmp), e->to, 0);
if (!e->to || force) {
if (mutt_enter_string (tmp, sizeof (tmp), LINES - 1, 4, 0) == 0) {
- rfc822_free_address (&e->to);
+ address_delete (&e->to);
e->to = mutt_parse_adrlist (e->to, tmp);
e->to = mutt_expand_aliases (e->to);
mutt_addrlist_to_idna (e->to, NULL); /* XXX - IDNA error reporting? */
mutt_addrlist_to_local (e->cc);
rfc822_write_address (tmp, sizeof (tmp), e->cc, 0);
if (mutt_enter_string (tmp, sizeof (tmp), LINES - 1, 4, 0) == 0) {
- rfc822_free_address (&e->cc);
+ address_delete (&e->cc);
e->cc = mutt_parse_adrlist (e->cc, tmp);
e->cc = mutt_expand_aliases (e->cc);
tmp[0] = 0;
mutt_addrlist_to_local (e->bcc);
rfc822_write_address (tmp, sizeof (tmp), e->bcc, 0);
if (mutt_enter_string (tmp, sizeof (tmp), LINES - 1, 5, 0) == 0) {
- rfc822_free_address (&e->bcc);
+ address_delete (&e->bcc);
e->bcc = mutt_parse_adrlist (e->bcc, tmp);
e->bcc = mutt_expand_aliases (e->bcc);
mutt_addrlist_to_idna (e->bcc, NULL);
char* errbuf, size_t errlen) {
if (!dst)
return (0);
- rfc822_free_address ((address_t**) dst->data);
+ address_delete ((address_t**) dst->data);
if (val && *val)
*((address_t**) dst->data) = rfc822_parse_adrlist (NULL, val);
return (1);
}
else {
/* override the previous value */
- rfc822_free_address (&tmp->addr);
+ address_delete (&tmp->addr);
if (CurrentMenu == MENU_ALIAS)
set_option (OPTFORCEREDRAWINDEX);
}
r = -1;
break;
} else if (DTYPE (option->type) == DT_ADDR)
- rfc822_free_address ((address_t **) option->data);
+ address_delete ((address_t **) option->data);
else if (DTYPE (option->type) == DT_USER)
/* to unset $user_ means remove */
hash_delete (ConfigOptions, option->option,
#include <stdlib.h>
+#include <lib-lib/mem.h>
+
/* Content-Type */
enum {
TYPEOTHER,
struct address_t *next;
} address_t;
-void rfc822_free_address(address_t **);
+DO_INIT(address_t, address);
+void address_wipe(address_t *);
+
+DO_NEW(address_t, address);
+DO_DELETE(address_t, address);
+
void rfc822_qualify(address_t *, const char *);
address_t *rfc822_parse_adrlist(address_t *, const char *s);
address_t *rfc822_cpy_adr(address_t * addr);
extern const char RFC822Specials[];
#define rfc822_error(x) RFC822Errors[x]
-#define rfc822_new_address() calloc(1,sizeof(address_t))
/****************************************************************************/
/* RFC 2231 */
#include "mutt_idna.h"
+void address_wipe(address_t *addr)
+{
+ address_delete(&addr->next);
+ p_delete(&addr->personal);
+ p_delete(&addr->mailbox);
+}
+
#define terminate_string(a, b, c) do { if ((b) < (c)) a[(b)] = 0; else \
a[(c)] = 0; } while (0)
*w = 0;
}
-void rfc822_free_address (address_t ** p)
-{
- address_t *t;
-
- while (*p) {
- t = *p;
- *p = (*p)->next;
- p_delete(&t->personal);
- p_delete(&t->mailbox);
- p_delete(&t);
- }
-}
-
static const char *parse_comment (const char *s,
char *comment, size_t * commentlen,
size_t commentmax)
add_addrspec (address_t ** top, address_t ** last, const char *phrase,
char *comment, size_t * commentlen, size_t commentmax)
{
- address_t *cur = rfc822_new_address ();
+ address_t *cur = address_new ();
if (parse_addr_spec (phrase, comment, commentlen, commentmax, cur) == NULL) {
- rfc822_free_address (&cur);
+ address_delete (&cur);
return;
}
if ((ps =
next_token (s, comment, &commentlen,
sizeof (comment) - 1)) == NULL) {
- rfc822_free_address (&top);
+ address_delete (&top);
return NULL;
}
s = ps;
}
else if (*s == ':') {
- cur = rfc822_new_address ();
+ cur = address_new ();
terminate_buffer (phrase, phraselen);
cur->mailbox = m_strdup(phrase);
cur->group = 1;
}
/* add group terminator */
- cur = rfc822_new_address ();
+ cur = address_new ();
if (last) {
last->next = cur;
last = cur;
}
else if (*s == '<') {
terminate_buffer (phrase, phraselen);
- cur = rfc822_new_address ();
+ cur = address_new ();
if (phraselen) {
if (cur->personal)
p_delete(&cur->personal);
if ((ps =
parse_route_addr (s + 1, comment, &commentlen,
sizeof (comment) - 1, cur)) == NULL) {
- rfc822_free_address (&top);
- rfc822_free_address (&cur);
+ address_delete (&top);
+ address_delete (&cur);
return NULL;
}
phrase[phraselen++] = ' ';
if ((ps =
next_token (s, phrase, &phraselen, sizeof (phrase) - 1)) == NULL) {
- rfc822_free_address (&top);
+ address_delete (&top);
return NULL;
}
s = ps;
/* this should be rfc822_cpy_adr */
address_t *rfc822_cpy_adr_real (address_t * addr)
{
- address_t *p = rfc822_new_address ();
+ address_t *p = address_new ();
p->personal = m_strdup(addr->personal);
p->mailbox = m_strdup(addr->mailbox);
{
if (!*p)
return;
- rfc822_free_address (&(*p)->return_path);
- rfc822_free_address (&(*p)->from);
- rfc822_free_address (&(*p)->to);
- rfc822_free_address (&(*p)->cc);
- rfc822_free_address (&(*p)->bcc);
- rfc822_free_address (&(*p)->sender);
- rfc822_free_address (&(*p)->reply_to);
- rfc822_free_address (&(*p)->mail_followup_to);
+ 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);
t = *p;
*p = (*p)->next;
p_delete(&t->name);
- rfc822_free_address (&t->addr);
+ address_delete (&t->addr);
p_delete(&t);
}
}
hdr->env->subject = m_strdup(b);
break;
case 2:
- rfc822_free_address (&hdr->env->from);
+ address_delete (&hdr->env->from);
hdr->env->from = rfc822_parse_adrlist (hdr->env->from, b);
/* same as for mutt_parse_rfc822_line():
* don't leave from info NULL if there's an invalid address (or
* and mark mail/(esp.) news article as your own. aaargh! this
* bothered me for _years_ */
if (!hdr->env->from) {
- hdr->env->from = rfc822_new_address ();
+ hdr->env->from = address_new ();
hdr->env->from->personal = m_strdup(b);
}
break;
* and mark mail/(esp.) news article as your own. aaargh! this
* bothered me for _years_ */
if (!e->from) {
- e->from = rfc822_new_address ();
+ e->from = address_new ();
e->from->personal = m_strdup(p);
}
matched = 1;
else if (!ascii_strncasecmp (line + 1, "ail-", 4)) {
if (!ascii_strcasecmp (line + 5, "reply-to")) {
/* override the Reply-To: field */
- rfc822_free_address (&e->reply_to);
+ address_delete (&e->reply_to);
e->reply_to = rfc822_parse_adrlist (e->reply_to, p);
matched = 1;
}
}
else if (r == -1) {
p_delete(&keylist);
- rfc822_free_address (&tmp);
- rfc822_free_address (&addr);
+ address_delete (&tmp);
+ address_delete (&addr);
return NULL;
}
}
if ((key = pgp_ask_for_key (buf, q->mailbox,
KEYFLAG_CANENCRYPT, PGP_PUBRING)) == NULL) {
p_delete(&keylist);
- rfc822_free_address (&tmp);
- rfc822_free_address (&addr);
+ address_delete (&tmp);
+ address_delete (&addr);
return NULL;
}
}
keylist_used = m_strlen(keylist);
pgp_free_key (&key);
- rfc822_free_address (&addr);
+ address_delete (&addr);
}
- rfc822_free_address (&tmp);
+ address_delete (&tmp);
return (keylist);
}
this_key_has_weak = 1;
}
- rfc822_free_address (&r);
+ address_delete (&r);
}
if (match && !this_key_has_strong && this_key_has_invalid)
mutt_addrlist_to_local (tmpa);
buf[0] = '\0';
rfc822_write_address (buf, buflen, tmpa, 0);
- rfc822_free_address (&tmpa);
+ address_delete (&tmpa);
mutt_clear_error ();
return (0);
}
if (op == OP_QUERY) {
queryp = results;
while (queryp) {
- rfc822_free_address (&queryp->addr);
+ address_delete (&queryp->addr);
p_delete(&queryp->name);
p_delete(&queryp->other);
results = queryp->next;
address_t *a = result_to_addr (QueryTable[i].data);
rfc822_append (&naddr, a);
- rfc822_free_address (&a);
+ address_delete (&a);
}
mutt_create_alias (NULL, naddr);
address_t *a = result_to_addr (QueryTable[menu->current].data);
mutt_create_alias (NULL, a);
- rfc822_free_address (&a);
+ address_delete (&a);
}
break;
address_t *a = result_to_addr (QueryTable[i].data);
rfc822_append (&msg->env->to, a);
- rfc822_free_address (&a);
+ address_delete (&a);
}
}
ci_send_message (0, msg, NULL, Context, NULL);
tagged = 1;
rfc822_write_address (buf, buflen, tmpa, 0);
curpos = m_strlen(buf);
- rfc822_free_address (&tmpa);
+ address_delete (&tmpa);
}
else if (curpos + 2 < buflen) {
address_t *tmpa = result_to_addr (QueryTable[i].data);
rfc822_write_address ((char *) buf + curpos + 1,
buflen - curpos - 1, tmpa, 0);
curpos = m_strlen(buf);
- rfc822_free_address (&tmpa);
+ address_delete (&tmpa);
}
}
}
mutt_addrlist_to_local (tmpa);
rfc822_write_address (buf, buflen, tmpa, 0);
- rfc822_free_address (&tmpa);
+ address_delete (&tmpa);
}
}
queryp = results;
while (queryp) {
- rfc822_free_address (&queryp->addr);
+ address_delete (&queryp->addr);
p_delete(&queryp->name);
p_delete(&queryp->other);
results = queryp->next;
if (mutt_addrlist_to_idna (adr, &err) < 0) {
mutt_error (_("Bad IDN: '%s'"), err);
p_delete(&err);
- rfc822_free_address (&adr);
+ address_delete (&adr);
return;
}
}
if (query_quadoption (OPT_BOUNCE, prompt) != M_YES) {
- rfc822_free_address (&adr);
+ address_delete (&adr);
CLEARLINE (LINES - 1);
mutt_message (p ? _("Message not bounced.") : _("Messages not bounced."));
return;
if (prev) {
prev->next = b->next;
b->next = NULL;
- rfc822_free_address (&b);
+ address_delete (&b);
b = prev;
}
else {
top = top->next;
b->next = NULL;
- rfc822_free_address (&b);
+ address_delete (&b);
b = top;
}
}
a = a->next;
if (!leave_only || a || last) {
tmp->next = NULL;
- rfc822_free_address (&tmp);
+ address_delete (&tmp);
}
else
last = top = tmp;
rfc822_write_address (buf, sizeof (buf), *a, 0);
if (mutt_get_field (field, buf, sizeof (buf), M_ALIAS) != 0)
return (-1);
- rfc822_free_address (a);
+ address_delete (a);
*a = mutt_expand_aliases (mutt_parse_adrlist (NULL, buf));
if ((idna_ok = mutt_addrlist_to_idna (*a, &err)) != 0) {
mutt_error (_("Error: '%s' is a bad IDN."), err);
for (; uh; uh = uh->next) {
if (ascii_strncasecmp ("from:", uh->data, 5) == 0) {
/* User has specified a default From: address. Remove default address */
- rfc822_free_address (&env->from);
+ address_delete (&env->from);
env->from = rfc822_parse_adrlist (env->from, uh->data + 5);
}
else if (ascii_strncasecmp ("reply-to:", uh->data, 9) == 0) {
- rfc822_free_address (&env->reply_to);
+ address_delete (&env->reply_to);
env->reply_to = rfc822_parse_adrlist (env->reply_to, uh->data + 9);
}
else if (ascii_strncasecmp ("message-id:", uh->data, 11) == 0)
case M_YES:
tmp = find_mailing_lists (env->to, env->cc);
rfc822_append (to, tmp);
- rfc822_free_address (&tmp);
+ address_delete (&tmp);
return 0;
case -1:
return -1; /* abort */
if (flags & SENDLISTREPLY) {
tmp = find_mailing_lists (in->to, in->cc);
rfc822_append (&out->to, tmp);
- rfc822_free_address (&tmp);
+ address_delete (&tmp);
if (in->mail_followup_to && hmfupto == M_YES &&
default_to (&out->cc, in, flags & SENDLISTREPLY, hmfupto) == -1)
if (From)
adr = rfc822_cpy_adr_real (From);
else if (option (OPTUSEDOMAIN)) {
- adr = rfc822_new_address ();
+ adr = address_new ();
adr->mailbox = p_new(char, m_strlen(Username) + m_strlen(fqdn) + 2);
sprintf (adr->mailbox, "%s@%s", NONULL (Username), NONULL (fqdn)); /* __SPRINTF_CHECKED__ */
}
else {
- adr = rfc822_new_address ();
+ adr = address_new ();
adr->mailbox = m_strdup(NONULL (Username));
}
/* Use any list-post header as a template */
url_parse_mailto (msg->env, NULL, cur->env->list_post);
/* We don't let them set the sender's address. */
- rfc822_free_address (&msg->env->from);
+ address_delete (&msg->env->from);
}
if (!(flags & (SENDKEY | SENDPOSTPONED | SENDRESEND))) {
msg->replied = 0;
if (killfrom) {
- rfc822_free_address (&msg->env->from);
+ address_delete (&msg->env->from);
killfrom = 0;
}
}
mutt_select_fcc (fcc, sizeof (fcc), msg);
if (killfrom) {
- rfc822_free_address (&msg->env->from);
+ address_delete (&msg->env->from);
killfrom = 0;
}
}
* recipients if there is no To: or Cc: field, so attempt to suppress
* it by using an empty To: field.
*/
- env->to = rfc822_new_address ();
+ env->to = address_new ();
env->to->group = 1;
- env->to->next = rfc822_new_address ();
+ env->to->next = address_new ();
buffer[0] = 0;
rfc822_cat (buffer, sizeof (buffer), "undisclosed-recipients",
for (item = env->userhdrs; item; item = item->next)
rfc2047_decode (&item->data);
- rfc822_free_address (&env->mail_followup_to);
+ address_delete (&env->mail_followup_to);
/* back conversions */
rfc2047_decode_adrlist (env->to);
ret = _mutt_bounce_message (fp, h, to, resent_from, from);
- rfc822_free_address (&from);
+ address_delete (&from);
return ret;
}
*last = addr->next;
addr->next = NULL;
- rfc822_free_address (&addr);
+ address_delete (&addr);
addr = *last;
}
}
if (!found && (t = mutt_default_from ())) {
_smime_getkeys (t->mailbox);
- rfc822_free_address (&t);
+ address_delete (&t);
}
}
if (!keyID) {
mutt_message (_("No (valid) certificate found for %s."), q->mailbox);
p_delete(&keylist);
- rfc822_free_address (&tmp);
- rfc822_free_address (&addr);
+ address_delete (&tmp);
+ address_delete (&addr);
return NULL;
}
sprintf (keylist + keylist_used, "%s\n", keyID); /* __SPRINTF_CHECKED__ */
keylist_used = m_strlen(keylist);
- rfc822_free_address (&addr);
+ address_delete (&addr);
}
- rfc822_free_address (&tmp);
+ address_delete (&tmp);
return (keylist);
}