* | addrsrc() | Search for an e-mail address in a list
* | has_recips() | Count the number of Addresses with valid recipients
* | mutt_parse_adrlist() | Parse a list of email addresses
- * | rfc822_append() | Append one list of addresses onto another
- * | rfc822_cat() | Copy a string and escape the specified characters
- * | rfc822_cpy_adr() | Copy an Address
- * | rfc822_cpy_adr_real | Copy the real address
- * | rfc822_free_address() | Free a list of Addresses
- * | rfc822_parse_adrlist() | Parse a list of email addresses
- * | rfc822_qualify() | Expand local names in an Address list using a hostname
- * | rfc822_remove_from_adrlist() | Remove an Address from a list
- * | rfc822_valid_msgid() | Is this a valid Message ID?
- * | rfc822_write_address | Write an address to a buffer
+ * | mutt_addr_append() | Append one list of addresses onto another
+ * | mutt_addr_cat() | Copy a string and escape the specified characters
+ * | mutt_addr_copy_list() | Copy an Address
+ * | mutt_addr_copy | Copy the real address
+ * | mutt_addr_free() | Free a list of Addresses
+ * | mutt_addr_parse_list() | Parse a list of email addresses
+ * | mutt_addr_qualify() | Expand local names in an Address list using a hostname
+ * | mutt_addr_remove_from_list() | Remove an Address from a list
+ * | mutt_addr_valid_msgid() | Is this a valid Message ID?
*/
#include "config.h"
};
/**
- * rfc822_new_address - Create a new Address
+ * mutt_addr_new - Create a new Address
* @retval ptr Newly allocated Address
*
- * Free the result with free_address() or rfc822_free_address()
+ * Free the result with free_address() or mutt_addr_free()
*/
-struct Address *rfc822_new_address(void)
+struct Address *mutt_addr_new(void)
{
return mutt_mem_calloc(1, sizeof(struct Address));
}
}
/**
- * rfc822_remove_from_adrlist - Remove an Address from a list
+ * mutt_addr_remove_from_list - Remove an Address from a list
* @param a Address list
* @param mailbox Email address to match
* @retval 0 Success
* @retval -1 Error, or email not found
*/
-int rfc822_remove_from_adrlist(struct Address **a, const char *mailbox)
+int mutt_addr_remove_from_list(struct Address **a, const char *mailbox)
{
struct Address *p = NULL, *last = NULL, *t = NULL;
int rc = -1;
}
/**
- * rfc822_free_address - Free a list of Addresses
+ * mutt_addr_free - Free a list of Addresses
* @param p Top of the list
*/
-void rfc822_free_address(struct Address **p)
+void mutt_addr_free(struct Address **p)
{
struct Address *t = NULL;
static void add_addrspec(struct Address **top, struct Address **last, const char *phrase,
char *comment, size_t *commentlen, size_t commentmax)
{
- struct Address *cur = rfc822_new_address();
+ struct Address *cur = mutt_addr_new();
if (parse_addr_spec(phrase, comment, commentlen, commentmax, cur) == NULL)
{
- rfc822_free_address(&cur);
+ mutt_addr_free(&cur);
return;
}
}
/**
- * rfc822_parse_adrlist - Parse a list of email addresses
+ * mutt_addr_parse_list - Parse a list of email addresses
* @param top List to append addresses
* @param s String to parse
* @retval ptr Top of the address list
* @retval NULL Error
*/
-struct Address *rfc822_parse_adrlist(struct Address *top, const char *s)
+struct Address *mutt_addr_parse_list(struct Address *top, const char *s)
{
int ws_pending, nl;
const char *ps = NULL;
ps = next_token(s, comment, &commentlen, sizeof(comment) - 1);
if (!ps)
{
- rfc822_free_address(&top);
+ mutt_addr_free(&top);
return NULL;
}
s = ps;
ps = parse_quote(s + 1, phrase, &phraselen, sizeof(phrase) - 1);
if (!ps)
{
- rfc822_free_address(&top);
+ mutt_addr_free(&top);
return NULL;
}
s = ps;
}
else if (*s == ':')
{
- cur = rfc822_new_address();
+ cur = mutt_addr_new();
terminate_buffer(phrase, phraselen);
cur->mailbox = mutt_str_strdup(phrase);
cur->group = 1;
}
/* add group terminator */
- cur = rfc822_new_address();
+ cur = mutt_addr_new();
if (last)
{
last->next = cur;
else if (*s == '<')
{
terminate_buffer(phrase, phraselen);
- cur = rfc822_new_address();
+ cur = mutt_addr_new();
if (phraselen)
cur->personal = mutt_str_strdup(phrase);
ps = parse_route_addr(s + 1, comment, &commentlen, sizeof(comment) - 1, cur);
if (!ps)
{
- rfc822_free_address(&top);
- rfc822_free_address(&cur);
+ mutt_addr_free(&top);
+ mutt_addr_free(&cur);
return NULL;
}
ps = next_token(s, phrase, &phraselen, sizeof(phrase) - 1);
if (!ps)
{
- rfc822_free_address(&top);
+ mutt_addr_free(&top);
return NULL;
}
s = ps;
}
/**
- * rfc822_qualify - Expand local names in an Address list using a hostname
+ * mutt_addr_qualify - Expand local names in an Address list using a hostname
* @param addr Address list
* @param host Hostname
*
* Any addresses containing a bare name will be expanded using the hostname.
* e.g. "john", "example.com" -> 'john@example.com'.
*/
-void rfc822_qualify(struct Address *addr, const char *host)
+void mutt_addr_qualify(struct Address *addr, const char *host)
{
char *p = NULL;
}
/**
- * rfc822_cat - Copy a string and escape the specified characters
+ * mutt_addr_cat - Copy a string and escape the specified characters
* @param buf Buffer for the result
* @param buflen Length of the result buffer
* @param value String to copy
* @param specials Characters to be escaped
*/
-void rfc822_cat(char *buf, size_t buflen, const char *value, const char *specials)
+void mutt_addr_cat(char *buf, size_t buflen, const char *value, const char *specials)
{
if (strpbrk(value, specials))
{
}
/**
- * rfc822_cpy_adr_real - Copy the real address
+ * mutt_addr_copy - Copy the real address
* @param addr Address to copy
* @retval ptr New Address
*
- * this should be rfc822_cpy_adr
+ * this should be mutt_addr_copy_list
*/
-struct Address *rfc822_cpy_adr_real(struct Address *addr)
+struct Address *mutt_addr_copy(struct Address *addr)
{
- struct Address *p = rfc822_new_address();
+ struct Address *p = mutt_addr_new();
p->personal = mutt_str_strdup(addr->personal);
p->mailbox = mutt_str_strdup(addr->mailbox);
}
/**
- * rfc822_cpy_adr - Copy a list of addresses
+ * mutt_addr_copy_list - Copy a list of addresses
* @param addr Address list
* @param prune Skip groups if there are more addresses
* @retval ptr New Address list
*
* this should be rfc822_cpy_adrlist
*/
-struct Address *rfc822_cpy_adr(struct Address *addr, int prune)
+struct Address *mutt_addr_copy_list(struct Address *addr, int prune)
{
struct Address *top = NULL, *last = NULL;
}
else if (last)
{
- last->next = rfc822_cpy_adr_real(addr);
+ last->next = mutt_addr_copy(addr);
last = last->next;
}
else
- top = last = rfc822_cpy_adr_real(addr);
+ top = last = mutt_addr_copy(addr);
}
return top;
}
/**
- * rfc822_append - Append one list of addresses onto another
+ * mutt_addr_append - Append one list of addresses onto another
* @param a Destination Address list
* @param b Source Address list
* @param prune Skip groups if there are more addresses
*
* Append the Source onto the end of the Destination Address list.
*/
-struct Address *rfc822_append(struct Address **a, struct Address *b, int prune)
+struct Address *mutt_addr_append(struct Address **a, struct Address *b, int prune)
{
struct Address *tmp = *a;
if (!b)
return tmp;
if (tmp)
- tmp->next = rfc822_cpy_adr(b, prune);
+ tmp->next = mutt_addr_copy_list(b, prune);
else
- tmp = *a = rfc822_cpy_adr(b, prune);
+ tmp = *a = mutt_addr_copy_list(b, prune);
while (tmp && tmp->next)
tmp = tmp->next;
return tmp;
}
/**
- * rfc822_valid_msgid - Is this a valid Message ID?
+ * mutt_addr_valid_msgid - Is this a valid Message ID?
* @param msgid Message ID
* @retval bool True if it is valid
*
* Incomplete. Only used to thwart the APOP MD5 attack (#2846).
*/
-bool rfc822_valid_msgid(const char *msgid)
+bool mutt_addr_valid_msgid(const char *msgid)
{
/* msg-id = "<" addr-spec ">"
* addr-spec = local-part "@" domain
ERR_BAD_ADDR_SPEC
};
-struct Address *rfc822_new_address(void);
-void rfc822_free_address(struct Address **p);
-void rfc822_qualify(struct Address *addr, const char *host);
-struct Address *rfc822_parse_adrlist(struct Address *top, const char *s);
-struct Address *rfc822_cpy_adr(struct Address *addr, int prune);
-struct Address *rfc822_cpy_adr_real(struct Address *addr);
-struct Address *rfc822_append(struct Address **a, struct Address *b, int prune);
+struct Address *mutt_addr_new(void);
+void mutt_addr_free(struct Address **p);
+void mutt_addr_qualify(struct Address *addr, const char *host);
+struct Address *mutt_addr_parse_list(struct Address *top, const char *s);
+struct Address *mutt_addr_copy_list(struct Address *addr, int prune);
+struct Address *mutt_addr_copy(struct Address *addr);
+struct Address *mutt_addr_append(struct Address **a, struct Address *b, int prune);
int rfc822_write_address(char *buf, size_t buflen, struct Address *addr, int display);
void rfc822_write_address_single(char *buf, size_t buflen, struct Address *addr, int display);
-void rfc822_cat(char *buf, size_t buflen, const char *value, const char *specials);
-bool rfc822_valid_msgid(const char *msgid);
-int rfc822_remove_from_adrlist(struct Address **a, const char *mailbox);
+void mutt_addr_cat(char *buf, size_t buflen, const char *value, const char *specials);
+bool mutt_addr_valid_msgid(const char *msgid);
+int mutt_addr_remove_from_list(struct Address **a, const char *mailbox);
extern int RFC822Error;
extern const char *const RFC822Errors[];
if (!i)
{
mutt_list_insert_head(expn, mutt_str_strdup(a->mailbox));
- w = rfc822_cpy_adr(t, 0);
+ w = mutt_addr_copy_list(t, 0);
w = expand_aliases_r(w, expn);
if (head)
last->next = w;
t = a;
a = a->next;
t->next = NULL;
- rfc822_free_address(&t);
+ mutt_addr_free(&t);
continue;
}
else
if (option(OPT_USE_DOMAIN) && (fqdn = mutt_fqdn(1)))
{
/* now qualify all local addresses */
- rfc822_qualify(head, fqdn);
+ mutt_addr_qualify(head, fqdn);
}
return head;
return;
}
- new->addr = rfc822_parse_adrlist(new->addr, buf);
+ new->addr = mutt_addr_parse_list(new->addr, buf);
if (!new->addr)
BEEP();
if (mutt_addrlist_to_intl(new->addr, &err))
*p = (*p)->next;
mutt_alias_delete_reverse(t);
FREE(&t->name);
- rfc822_free_address(&t->addr);
+ mutt_addr_free(&t->addr);
FREE(&t);
}
}
{
mutt_error(_("Bad IDN: '%s'"), err);
FREE(&err);
- rfc822_free_address(&adr);
+ mutt_addr_free(&adr);
return;
}
if (query_quadoption(OPT_BOUNCE, prompt) != MUTT_YES)
{
- rfc822_free_address(&adr);
+ mutt_addr_free(&adr);
mutt_window_clearline(MuttMessageWindow, 0);
mutt_message(h ? _("Message not bounced.") : _("Messages not bounced."));
return;
mutt_window_clearline(MuttMessageWindow, 0);
rc = mutt_bounce_message(NULL, h, adr);
- rfc822_free_address(&adr);
+ mutt_addr_free(&adr);
/* If no error, or background, display message. */
if ((rc == 0) || (rc == S_BKG))
mutt_message(h ? _("Message bounced.") : _("Messages bounced."));
{
l = strlen(buf);
- rfc822_cat(tmp, sizeof(tmp), p->value, MimeSpecials);
+ mutt_addr_cat(tmp, sizeof(tmp), p->value, MimeSpecials);
snprintf(buf + l, sizeof(buf) - l, "; %s=%s", p->attribute, tmp);
}
}
rfc822_write_address(buf, sizeof(buf), *addr, 0);
if (mutt_get_field(_(Prompts[line]), buf, sizeof(buf), MUTT_ALIAS) == 0)
{
- rfc822_free_address(addr);
+ mutt_addr_free(addr);
*addr = mutt_parse_adrlist(*addr, buf);
*addr = mutt_expand_aliases(*addr);
}
fputs("Content-Type: text/plain; charset=", out);
mutt_canonical_charset(chsbuf, sizeof(chsbuf),
Charset ? Charset : "us-ascii");
- rfc822_cat(buffer, sizeof(buffer), chsbuf, MimeSpecials);
+ mutt_addr_cat(buffer, sizeof(buffer), chsbuf, MimeSpecials);
fputs(buffer, out);
fputc('\n', out);
}
return 0;
}
- a = rfc822_parse_adrlist(a, s + l);
+ a = mutt_addr_parse_list(a, s + l);
if (!a)
return 0;
format_address_header(h, a);
}
- rfc822_free_address(&a);
+ mutt_addr_free(&a);
FREE(&s);
return 1;
{
if (mutt_enter_string(tmp, sizeof(tmp), 4, 0) == 0)
{
- rfc822_free_address(&e->to);
+ mutt_addr_free(&e->to);
e->to = mutt_parse_adrlist(e->to, tmp);
e->to = mutt_expand_aliases(e->to);
mutt_addrlist_to_intl(e->to, NULL); /* XXX - IDNA error reporting? */
rfc822_write_address(tmp, sizeof(tmp), e->cc, 0);
if (mutt_enter_string(tmp, sizeof(tmp), 4, 0) == 0)
{
- rfc822_free_address(&e->cc);
+ mutt_addr_free(&e->cc);
e->cc = mutt_parse_adrlist(e->cc, tmp);
e->cc = mutt_expand_aliases(e->cc);
tmp[0] = '\0';
rfc822_write_address(tmp, sizeof(tmp), e->bcc, 0);
if (mutt_enter_string(tmp, sizeof(tmp), 5, 0) == 0)
{
- rfc822_free_address(&e->bcc);
+ mutt_addr_free(&e->bcc);
e->bcc = mutt_parse_adrlist(e->bcc, tmp);
e->bcc = mutt_expand_aliases(e->bcc);
mutt_addrlist_to_intl(e->bcc, NULL);
mutt_str_replace(&msg->env->subject, p);
break;
case 't':
- msg->env->to = rfc822_parse_adrlist(msg->env->to, p);
+ msg->env->to = mutt_addr_parse_list(msg->env->to, p);
msg->env->to = mutt_expand_aliases(msg->env->to);
break;
case 'u':
{
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);
+ mutt_addr_free(&(*p)->return_path);
+ mutt_addr_free(&(*p)->from);
+ mutt_addr_free(&(*p)->to);
+ mutt_addr_free(&(*p)->cc);
+ mutt_addr_free(&(*p)->bcc);
+ mutt_addr_free(&(*p)->sender);
+ mutt_addr_free(&(*p)->reply_to);
+ mutt_addr_free(&(*p)->mail_followup_to);
FREE(&(*p)->list_post);
FREE(&(*p)->subject);
if (!g)
return;
mutt_hash_delete(Groups, g->name, g, NULL);
- rfc822_free_address(&g->as);
+ mutt_addr_free(&g->as);
mutt_free_regex_list(&g->rs);
FREE(&g->name);
FREE(&g);
for (p = &g->as; *p; p = &((*p)->next))
;
- q = rfc822_cpy_adr(a, 0);
+ q = mutt_addr_copy_list(a, 0);
q = mutt_remove_xrefs(g->as, q);
*p = q;
}
return -1;
for (p = a; p; p = p->next)
- rfc822_remove_from_adrlist(&g->as, p->mailbox);
+ mutt_addr_remove_from_list(&g->as, p->mailbox);
return 0;
}
while (counter)
{
- *a = rfc822_new_address();
+ *a = mutt_addr_new();
restore_char(&(*a)->personal, d, off, convert);
restore_char(&(*a)->mailbox, d, off, false);
restore_int((unsigned int *) &(*a)->group, d, off);
}
break;
case DT_ADDRESS:
- rfc822_free_address((struct Address **) MuttVars[idx].data);
+ mutt_addr_free((struct Address **) MuttVars[idx].data);
*((struct Address **) MuttVars[idx].data) =
- rfc822_parse_adrlist(NULL, (const char *) val->data);
+ mutt_addr_parse_list(NULL, (const char *) val->data);
break;
case DT_PATH:
{
switch (DTYPE(p->type))
{
case DT_ADDRESS:
- rfc822_free_address((struct Address **) p->data);
+ mutt_addr_free((struct Address **) p->data);
break;
case DT_REGEX:
pp = (struct Regex *) p->data;
{
snprintf(err->data, err->dsize,
_("%sgroup: warning: bad IDN '%s'.\n"), data == 1 ? "un" : "", estr);
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
FREE(&estr);
goto bail;
}
mutt_group_context_add_adrlist(gc, addr);
else if (data == MUTT_UNGROUP)
mutt_group_context_remove_adrlist(gc, addr);
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
break;
}
}
{
mutt_alias_delete_reverse(tmp);
/* override the previous value */
- rfc822_free_address(&tmp->addr);
+ mutt_addr_free(&tmp->addr);
if (CurrentMenu == MENU_ALIAS)
mutt_set_current_menu_redraw_full();
}
}
break;
case DT_ADDRESS:
- rfc822_free_address((struct Address **) p->data);
+ mutt_addr_free((struct Address **) p->data);
if (p->init)
- *((struct Address **) p->data) = rfc822_parse_adrlist(NULL, (char *) p->init);
+ *((struct Address **) p->data) = mutt_addr_parse_list(NULL, (char *) p->init);
break;
case DT_BOOL:
if (p->init)
if (myvar)
myvar_del(myvar);
else if (DTYPE(MuttVars[idx].type) == DT_ADDRESS)
- rfc822_free_address((struct Address **) MuttVars[idx].data);
+ mutt_addr_free((struct Address **) MuttVars[idx].data);
else if (DTYPE(MuttVars[idx].type) == DT_MBTABLE)
free_mbtable((struct MbTable **) MuttVars[idx].data);
else
}
else
{
- rfc822_free_address((struct Address **) MuttVars[idx].data);
+ mutt_addr_free((struct Address **) MuttVars[idx].data);
*((struct Address **) MuttVars[idx].data) =
- rfc822_parse_adrlist(NULL, tmp->data);
+ mutt_addr_parse_list(NULL, tmp->data);
}
}
}
p = getenv("EMAIL");
if (p)
- From = rfc822_parse_adrlist(NULL, p);
+ From = mutt_addr_parse_list(NULL, p);
mutt_set_langinfo_charset();
mutt_set_charset(Charset);
if (!msg->env)
msg->env = mutt_new_envelope();
if (i == 'b')
- msg->env->bcc = rfc822_parse_adrlist(msg->env->bcc, optarg);
+ msg->env->bcc = mutt_addr_parse_list(msg->env->bcc, optarg);
else
- msg->env->cc = rfc822_parse_adrlist(msg->env->cc, optarg);
+ msg->env->cc = mutt_addr_parse_list(msg->env->cc, optarg);
break;
case 'D':
}
}
else
- msg->env->to = rfc822_parse_adrlist(msg->env->to, argv[i]);
+ msg->env->to = mutt_addr_parse_list(msg->env->to, argv[i]);
}
if (!draftFile && option(OPT_AUTOEDIT) && !msg->env->to && !msg->env->cc)
}
}
- rfc822_append(&msg->env->to, opts_env->to, 0);
- rfc822_append(&msg->env->cc, opts_env->cc, 0);
- rfc822_append(&msg->env->bcc, opts_env->bcc, 0);
+ mutt_addr_append(&msg->env->to, opts_env->to, 0);
+ mutt_addr_append(&msg->env->cc, opts_env->cc, 0);
+ mutt_addr_append(&msg->env->bcc, opts_env->bcc, 0);
if (opts_env->subject)
mutt_str_replace(&msg->env->subject, opts_env->subject);
}
if (!hdr->env->return_path && return_path[0])
- hdr->env->return_path = rfc822_parse_adrlist(hdr->env->return_path, return_path);
+ hdr->env->return_path = mutt_addr_parse_list(hdr->env->return_path, return_path);
if (!hdr->env->from)
- hdr->env->from = rfc822_cpy_adr(hdr->env->return_path, 0);
+ hdr->env->from = mutt_addr_copy_list(hdr->env->return_path, 0);
ctx->msgcount++;
}
if (!curhdr->env->return_path && return_path[0])
curhdr->env->return_path =
- rfc822_parse_adrlist(curhdr->env->return_path, return_path);
+ mutt_addr_parse_list(curhdr->env->return_path, return_path);
if (!curhdr->env->from)
- curhdr->env->from = rfc822_cpy_adr(curhdr->env->return_path, 0);
+ curhdr->env->from = mutt_addr_copy_list(curhdr->env->return_path, 0);
lines = 0;
}
crypt_pgp_set_sender(mailbox);
if (!msg->env->from)
- rfc822_free_address(&from);
+ mutt_addr_free(&from);
}
if (msg->security & SIGN)
if ((WithCrypto & APPLICATION_PGP))
set_option(OPT_PGP_CHECK_TRUST);
- last = rfc822_append(&adrlist, msg->env->to, 0);
- last = rfc822_append(last ? &last : &adrlist, msg->env->cc, 0);
- rfc822_append(last ? &last : &adrlist, msg->env->bcc, 0);
+ last = mutt_addr_append(&adrlist, msg->env->to, 0);
+ last = mutt_addr_append(last ? &last : &adrlist, msg->env->cc, 0);
+ mutt_addr_append(last ? &last : &adrlist, msg->env->bcc, 0);
if (fqdn)
- rfc822_qualify(adrlist, fqdn);
+ mutt_addr_qualify(adrlist, fqdn);
adrlist = mutt_remove_duplicates(adrlist);
*keylist = NULL;
*keylist = crypt_pgp_findkeys(adrlist, oppenc_mode);
if (!*keylist)
{
- rfc822_free_address(&adrlist);
+ mutt_addr_free(&adrlist);
return -1;
}
unset_option(OPT_PGP_CHECK_TRUST);
*keylist = crypt_smime_findkeys(adrlist, oppenc_mode);
if (!*keylist)
{
- rfc822_free_address(&adrlist);
+ mutt_addr_free(&adrlist);
return -1;
}
if (option(OPT_SMIME_SELF_ENCRYPT) || (quadoption(OPT_SMIME_ENCRYPT_SELF) == MUTT_YES))
sprintf(*keylist + keylist_size, " %s", self_encrypt);
}
- rfc822_free_address(&adrlist);
+ mutt_addr_free(&adrlist);
return 0;
}
this_key_has_addr_match = false;
match = false; /* any match */
- r = rfc822_parse_adrlist(NULL, k->uid);
+ r = mutt_addr_parse_list(NULL, k->uid);
for (p = r; p; p = p->next)
{
int validity = crypt_id_matches_addr(a, p, k);
}
}
}
- rfc822_free_address(&r);
+ mutt_addr_free(&r);
if (match)
{
/* check for e-mail address */
if ((t = strchr(crypt_hook_val, '@')) &&
- (addr = rfc822_parse_adrlist(NULL, crypt_hook_val)))
+ (addr = mutt_addr_parse_list(NULL, crypt_hook_val)))
{
if (fqdn)
- rfc822_qualify(addr, fqdn);
+ mutt_addr_qualify(addr, fqdn);
q = addr;
}
else if (!oppenc_mode)
else if (r == MUTT_ABORT)
{
FREE(&keylist);
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
mutt_list_free(&crypt_hook_list);
return NULL;
}
if (!k_info)
{
FREE(&keylist);
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
mutt_list_free(&crypt_hook_list);
return NULL;
}
key_selected = true;
crypt_free_key(&k_info);
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
if (crypt_hook)
crypt_hook = STAILQ_NEXT(crypt_hook, entries);
}
/* check for e-mail address */
- if (strchr(keyID, '@') && (addr = rfc822_parse_adrlist(NULL, keyID)))
+ if (strchr(keyID, '@') && (addr = mutt_addr_parse_list(NULL, keyID)))
{
if (fqdn)
- rfc822_qualify(addr, fqdn);
+ mutt_addr_qualify(addr, fqdn);
q = addr;
}
else if (!oppenc_mode)
else if (r == MUTT_ABORT)
{
FREE(&keylist);
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
mutt_list_free(&crypt_hook_list);
return NULL;
}
if (!k_info)
{
FREE(&keylist);
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
mutt_list_free(&crypt_hook_list);
return NULL;
}
key_selected = true;
pgp_free_key(&k_info);
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
if (crypt_hook)
crypt_hook = STAILQ_NEXT(crypt_hook, entries);
for (q = k->address; q; q = q->next)
{
- r = rfc822_parse_adrlist(NULL, NONULL(q->addr));
+ r = mutt_addr_parse_list(NULL, NONULL(q->addr));
for (p = r; p; p = p->next)
{
}
}
- rfc822_free_address(&r);
+ mutt_addr_free(&r);
}
if (match)
if (!found && (t = mutt_default_from()))
{
getkeys(t->mailbox);
- rfc822_free_address(&t);
+ mutt_addr_free(&t);
}
}
case 'a':
if (mutt_str_strcasecmp(line + 1, "pparently-to") == 0)
{
- e->to = rfc822_parse_adrlist(e->to, p);
+ e->to = mutt_addr_parse_list(e->to, p);
matched = 1;
}
else if (mutt_str_strcasecmp(line + 1, "pparently-from") == 0)
{
- e->from = rfc822_parse_adrlist(e->from, p);
+ e->from = mutt_addr_parse_list(e->from, p);
matched = 1;
}
break;
case 'b':
if (mutt_str_strcasecmp(line + 1, "cc") == 0)
{
- e->bcc = rfc822_parse_adrlist(e->bcc, p);
+ e->bcc = mutt_addr_parse_list(e->bcc, p);
matched = 1;
}
break;
case 'c':
if (mutt_str_strcasecmp(line + 1, "c") == 0)
{
- e->cc = rfc822_parse_adrlist(e->cc, p);
+ e->cc = mutt_addr_parse_list(e->cc, p);
matched = 1;
}
else if (mutt_str_strncasecmp(line + 1, "ontent-", 7) == 0)
case 'f':
if (mutt_str_strcasecmp("rom", line + 1) == 0)
{
- e->from = rfc822_parse_adrlist(e->from, p);
+ e->from = mutt_addr_parse_list(e->from, p);
matched = 1;
}
#ifdef USE_NNTP
if (mutt_str_strcasecmp(line + 5, "reply-to") == 0)
{
/* override the Reply-To: field */
- rfc822_free_address(&e->reply_to);
- e->reply_to = rfc822_parse_adrlist(e->reply_to, p);
+ mutt_addr_free(&e->reply_to);
+ e->reply_to = mutt_addr_parse_list(e->reply_to, p);
matched = 1;
}
else if (mutt_str_strcasecmp(line + 5, "followup-to") == 0)
{
- e->mail_followup_to = rfc822_parse_adrlist(e->mail_followup_to, p);
+ e->mail_followup_to = mutt_addr_parse_list(e->mail_followup_to, p);
matched = 1;
}
}
}
else if (mutt_str_strcasecmp(line + 1, "eply-to") == 0)
{
- e->reply_to = rfc822_parse_adrlist(e->reply_to, p);
+ e->reply_to = mutt_addr_parse_list(e->reply_to, p);
matched = 1;
}
else if (mutt_str_strcasecmp(line + 1, "eturn-path") == 0)
{
- e->return_path = rfc822_parse_adrlist(e->return_path, p);
+ e->return_path = mutt_addr_parse_list(e->return_path, p);
matched = 1;
}
else if (mutt_str_strcasecmp(line + 1, "eceived") == 0)
}
else if (mutt_str_strcasecmp(line + 1, "ender") == 0)
{
- e->sender = rfc822_parse_adrlist(e->sender, p);
+ e->sender = mutt_addr_parse_list(e->sender, p);
matched = 1;
}
else if (mutt_str_strcasecmp(line + 1, "tatus") == 0)
case 't':
if (mutt_str_strcasecmp(line + 1, "o") == 0)
{
- e->to = rfc822_parse_adrlist(e->to, p);
+ e->to = mutt_addr_parse_list(e->to, p);
matched = 1;
}
break;
#endif
else if (mutt_str_strcasecmp(line + 1, "-original-to") == 0)
{
- e->x_original_to = rfc822_parse_adrlist(e->x_original_to, p);
+ e->x_original_to = mutt_addr_parse_list(e->x_original_to, p);
matched = 1;
}
r = tmp;
while ((r = strtok(r, " \t")) != NULL)
{
- p = rfc822_parse_adrlist(p, r);
+ p = mutt_addr_parse_list(p, r);
r = NULL;
}
}
else
- p = rfc822_parse_adrlist(p, s);
+ p = mutt_addr_parse_list(p, s);
return p;
}
if (!pop_data->timestamp)
return POP_A_UNAVAIL;
- if (!rfc822_valid_msgid(pop_data->timestamp))
+ if (!mutt_addr_valid_msgid(pop_data->timestamp))
{
mutt_error(_("POP timestamp is invalid!"));
mutt_sleep(2);
{
static struct Address *tmp = NULL;
- tmp = rfc822_cpy_adr(r->addr, 0);
+ tmp = mutt_addr_copy_list(r->addr, 0);
if (!tmp)
return NULL;
p = *query;
*query = (*query)->next;
- rfc822_free_address(&p->addr);
+ mutt_addr_free(&p->addr);
FREE(&p->name);
FREE(&p->other);
FREE(&p);
cur = cur->next;
}
- cur->addr = rfc822_parse_adrlist(cur->addr, p);
+ cur->addr = mutt_addr_parse_list(cur->addr, p);
p = strtok(NULL, "\t\n");
if (p)
{
if (QueryTable[i].tagged)
{
struct Address *a = result_to_addr(QueryTable[i].data);
- rfc822_append(&naddr, a, 0);
- rfc822_free_address(&a);
+ mutt_addr_append(&naddr, a, 0);
+ mutt_addr_free(&a);
}
}
mutt_create_alias(NULL, naddr);
- rfc822_free_address(&naddr);
+ mutt_addr_free(&naddr);
}
else
{
struct Address *a = result_to_addr(QueryTable[menu->current].data);
mutt_create_alias(NULL, a);
- rfc822_free_address(&a);
+ mutt_addr_free(&a);
}
break;
if (QueryTable[i].tagged)
{
struct Address *a = result_to_addr(QueryTable[i].data);
- rfc822_append(&msg->env->to, a, 0);
- rfc822_free_address(&a);
+ mutt_addr_append(&msg->env->to, a, 0);
+ mutt_addr_free(&a);
}
}
ci_send_message(0, msg, NULL, Context, NULL);
tagged = true;
rfc822_write_address(buf, buflen, tmpa, 0);
curpos = mutt_str_strlen(buf);
- rfc822_free_address(&tmpa);
+ mutt_addr_free(&tmpa);
}
else if (curpos + 2 < buflen)
{
strcat(buf, ", ");
rfc822_write_address((char *) buf + curpos + 1, buflen - curpos - 1, tmpa, 0);
curpos = mutt_str_strlen(buf);
- rfc822_free_address(&tmpa);
+ mutt_addr_free(&tmpa);
}
}
}
struct Address *tmpa = result_to_addr(QueryTable[menu->current].data);
mutt_addrlist_to_local(tmpa);
rfc822_write_address(buf, buflen, tmpa, 0);
- rfc822_free_address(&tmpa);
+ mutt_addr_free(&tmpa);
}
}
mutt_addrlist_to_local(tmpa);
buf[0] = '\0';
rfc822_write_address(buf, buflen, tmpa, 0);
- rfc822_free_address(&tmpa);
+ mutt_addr_free(&tmpa);
free_query(&results);
mutt_clear_error();
return 0;
if (mutt_get_field(prompt, buf, sizeof(buf), MUTT_ALIAS) || buf[0] == '\0')
return;
- adr = rfc822_parse_adrlist(adr, buf);
+ adr = mutt_addr_parse_list(adr, buf);
if (!adr)
{
mutt_error(_("Error parsing address!"));
{
mutt_error(_("Bad IDN: '%s'"), err);
FREE(&err);
- rfc822_free_address(&adr);
+ mutt_addr_free(&adr);
return;
}
if (query_quadoption(OPT_BOUNCE, prompt) != MUTT_YES)
{
- rfc822_free_address(&adr);
+ mutt_addr_free(&adr);
mutt_window_clearline(MuttMessageWindow, 0);
mutt_message(p ? _("Message not bounced.") : _("Messages not bounced."));
return;
mutt_error(p ? _("Error bouncing message!") :
_("Error bouncing messages!"));
- rfc822_free_address(&adr);
+ mutt_addr_free(&adr);
}
/**
}
/* Cc and Bcc are empty at this point. */
- rfc822_qualify(msg->env->to, fqdn);
- rfc822_qualify(msg->env->reply_to, fqdn);
- rfc822_qualify(msg->env->mail_followup_to, fqdn);
+ mutt_addr_qualify(msg->env->to, fqdn);
+ mutt_addr_qualify(msg->env->reply_to, fqdn);
+ mutt_addr_qualify(msg->env->mail_followup_to, fqdn);
}
return 0;
{
prev->next = b->next;
b->next = NULL;
- rfc822_free_address(&b);
+ mutt_addr_free(&b);
b = prev;
}
else
{
top = top->next;
b->next = NULL;
- rfc822_free_address(&b);
+ mutt_addr_free(&b);
b = top;
}
}
if (!leave_only || a || last)
{
tmp->next = NULL;
- rfc822_free_address(&tmp);
+ mutt_addr_free(&tmp);
}
else
last = top = tmp;
{
if (top)
{
- ptr->next = rfc822_cpy_adr_real(t);
+ ptr->next = mutt_addr_copy(t);
ptr = ptr->next;
}
else
- ptr = top = rfc822_cpy_adr_real(t);
+ ptr = top = mutt_addr_copy(t);
}
}
}
rfc822_write_address(buf, sizeof(buf), *a, 0);
if (mutt_get_field(field, buf, sizeof(buf), MUTT_ALIAS) != 0)
return -1;
- rfc822_free_address(a);
+ mutt_addr_free(a);
*a = mutt_expand_aliases(mutt_parse_adrlist(NULL, buf));
idna_ok = mutt_addrlist_to_intl(*a, &err);
if (idna_ok != 0)
STAILQ_FOREACH(uh, &UserHeader, entries)
{
if (mutt_str_strncasecmp("to:", uh->data, 3) == 0)
- env->to = rfc822_parse_adrlist(env->to, uh->data + 3);
+ env->to = mutt_addr_parse_list(env->to, uh->data + 3);
else if (mutt_str_strncasecmp("cc:", uh->data, 3) == 0)
- env->cc = rfc822_parse_adrlist(env->cc, uh->data + 3);
+ env->cc = mutt_addr_parse_list(env->cc, uh->data + 3);
else if (mutt_str_strncasecmp("bcc:", uh->data, 4) == 0)
- env->bcc = rfc822_parse_adrlist(env->bcc, uh->data + 4);
+ env->bcc = mutt_addr_parse_list(env->bcc, uh->data + 4);
#ifdef USE_NNTP
else if (mutt_str_strncasecmp("newsgroups:", uh->data, 11) == 0)
env->newsgroups = nntp_get_header(uh->data + 11);
if (mutt_str_strncasecmp("from:", uh->data, 5) == 0)
{
/* User has specified a default From: address. Remove default address */
- rfc822_free_address(&env->from);
- env->from = rfc822_parse_adrlist(env->from, uh->data + 5);
+ mutt_addr_free(&env->from);
+ env->from = mutt_addr_parse_list(env->from, uh->data + 5);
}
else if (mutt_str_strncasecmp("reply-to:", uh->data, 9) == 0)
{
- rfc822_free_address(&env->reply_to);
- env->reply_to = rfc822_parse_adrlist(env->reply_to, uh->data + 9);
+ mutt_addr_free(&env->reply_to);
+ env->reply_to = mutt_addr_parse_list(env->reply_to, uh->data + 9);
}
else if (mutt_str_strncasecmp("message-id:", uh->data, 11) == 0)
{
char *tmp = mutt_extract_message_id(uh->data + 11, NULL);
- if (rfc822_valid_msgid(tmp))
+ if (mutt_addr_valid_msgid(tmp))
{
FREE(&env->message_id);
env->message_id = tmp;
if (flags && env->mail_followup_to && hmfupto == MUTT_YES)
{
- rfc822_append(to, env->mail_followup_to, 1);
+ mutt_addr_append(to, env->mail_followup_to, 1);
return 0;
}
if (!option(OPT_REPLY_SELF) && mutt_addr_is_user(env->from))
{
/* mail is from the user, assume replying to recipients */
- rfc822_append(to, env->to, 1);
+ mutt_addr_append(to, env->to, 1);
}
else if (env->reply_to)
{
* in his From header, and the reply-to has no display-name.
*
*/
- rfc822_append(to, env->from, 0);
+ mutt_addr_append(to, env->from, 0);
}
else if (!(addrcmp(env->from, env->reply_to) && !env->reply_to->next) &&
quadoption(OPT_REPLY_TO) != MUTT_YES)
switch (query_quadoption(OPT_REPLY_TO, prompt))
{
case MUTT_YES:
- rfc822_append(to, env->reply_to, 0);
+ mutt_addr_append(to, env->reply_to, 0);
break;
case MUTT_NO:
- rfc822_append(to, env->from, 0);
+ mutt_addr_append(to, env->from, 0);
break;
default:
}
}
else
- rfc822_append(to, env->reply_to, 0);
+ mutt_addr_append(to, env->reply_to, 0);
}
else
- rfc822_append(to, env->from, 0);
+ mutt_addr_append(to, env->from, 0);
return 0;
}
if (flags & SENDLISTREPLY)
{
tmp = find_mailing_lists(in->to, in->cc);
- rfc822_append(&out->to, tmp, 0);
- rfc822_free_address(&tmp);
+ mutt_addr_append(&out->to, tmp, 0);
+ mutt_addr_free(&tmp);
if (in->mail_followup_to && hmfupto == MUTT_YES &&
default_to(&out->cc, in, flags & SENDLISTREPLY, hmfupto) == MUTT_ABORT)
if ((flags & SENDGROUPREPLY) && (!in->mail_followup_to || hmfupto != MUTT_YES))
{
/* if(!mutt_addr_is_user(in->to)) */
- rfc822_append(&out->cc, in->to, 1);
- rfc822_append(&out->cc, in->cc, 1);
+ mutt_addr_append(&out->cc, in->to, 1);
+ mutt_addr_append(&out->cc, in->cc, 1);
}
}
return 0;
* mail-followup-to header
*/
- t = rfc822_append(&e->mail_followup_to, e->to, 0);
- rfc822_append(&t, e->cc, 1);
+ t = mutt_addr_append(&e->mail_followup_to, e->to, 0);
+ mutt_addr_append(&t, e->cc, 1);
}
/* remove ourselves from the mail-followup-to header */
if (e->mail_followup_to && !mutt_is_list_recipient(0, e->to, e->cc))
{
if (e->reply_to)
- from = rfc822_cpy_adr(e->reply_to, 0);
+ from = mutt_addr_copy_list(e->reply_to, 0);
else if (e->from)
- from = rfc822_cpy_adr(e->from, 0);
+ from = mutt_addr_copy_list(e->from, 0);
else
from = mutt_default_from();
tmp = env->from;
if (tmp)
{
- tmp = rfc822_cpy_adr_real(tmp);
+ tmp = mutt_addr_copy(tmp);
/* when $reverse_realname is not set, clear the personal name so that it
* may be set vi a reply- or send-hook.
*/
*/
if (From)
- adr = rfc822_cpy_adr_real(From);
+ adr = mutt_addr_copy(From);
else if (option(OPT_USE_DOMAIN))
{
- adr = rfc822_new_address();
+ adr = mutt_addr_new();
adr->mailbox =
mutt_mem_malloc(mutt_str_strlen(Username) + mutt_str_strlen(fqdn) + 2);
sprintf(adr->mailbox, "%s@%s", NONULL(Username), NONULL(fqdn));
}
else
{
- adr = rfc822_new_address();
+ adr = mutt_addr_new();
adr->mailbox = mutt_str_strdup(NONULL(Username));
}
for (int i = 0; i < Context->msgcount; i++)
{
if (message_is_tagged(Context, i))
- rfc822_append(&msg->env->to, Context->hdrs[i]->env->from, 0);
+ mutt_addr_append(&msg->env->to, Context->hdrs[i]->env->from, 0);
}
}
else
- msg->env->to = rfc822_cpy_adr(hdr->env->from, 0);
+ msg->env->to = mutt_addr_copy_list(hdr->env->from, 0);
return ci_send_message(0, msg, NULL, NULL, NULL);
}
/* 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);
+ mutt_addr_free(&msg->env->from);
}
if (!(flags & (SENDKEY | SENDPOSTPONED | SENDRESEND)))
/* $use_from and/or $from might have changed in a send-hook */
if (killfrom)
{
- rfc822_free_address(&msg->env->from);
+ mutt_addr_free(&msg->env->from);
if (option(OPT_USE_FROM) && !(flags & (SENDPOSTPONED | SENDRESEND)))
msg->env->from = mutt_default_from();
killfrom = false;
mutt_select_fcc(fcc, sizeof(fcc), msg);
if (killfrom)
{
- rfc822_free_address(&msg->env->from);
+ mutt_addr_free(&msg->env->from);
killfrom = false;
}
}
buffer[0] = 0;
tmp = mutt_str_strdup(p->value);
encode = rfc2231_encode_string(&tmp);
- rfc822_cat(buffer, sizeof(buffer), tmp, MimeSpecials);
+ mutt_addr_cat(buffer, sizeof(buffer), tmp, MimeSpecials);
/* Dirty hack to make messages readable by Outlook Express
* for the Mac: force quotes around the boundary parameter
buffer[0] = 0;
tmp = mutt_str_strdup(t);
encode = rfc2231_encode_string(&tmp);
- rfc822_cat(buffer, sizeof(buffer), tmp, MimeSpecials);
+ mutt_addr_cat(buffer, sizeof(buffer), tmp, MimeSpecials);
FREE(&tmp);
fprintf(f, "; filename%s=%s", encode ? "*" : "", buffer);
}
* 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 = mutt_addr_new();
env->to->group = 1;
- env->to->next = rfc822_new_address();
+ env->to->next = mutt_addr_new();
buffer[0] = 0;
- rfc822_cat(buffer, sizeof(buffer), "undisclosed-recipients", RFC822Specials);
+ mutt_addr_cat(buffer, sizeof(buffer), "undisclosed-recipients", RFC822Specials);
env->to->mailbox = mutt_str_strdup(buffer);
}
rfc2047_decode(&item->data);
}
- rfc822_free_address(&env->mail_followup_to);
+ mutt_addr_free(&env->mail_followup_to);
/* back conversions */
rfc2047_decode_adrlist(env->to);
from->personal = mutt_str_strdup(RealName);
if (fqdn)
- rfc822_qualify(from, fqdn);
+ mutt_addr_qualify(from, fqdn);
rfc2047_encode_adrlist(from, "Resent-From");
if (mutt_addrlist_to_intl(from, &err))
{
mutt_error(_("Bad IDN %s while preparing resent-from."), err);
- rfc822_free_address(&from);
+ mutt_addr_free(&from);
return -1;
}
rfc822_write_address(resent_from, sizeof(resent_from), from, 0);
* function is called, since the user receives confirmation of the address
* list being bounced to.
*/
- resent_to = rfc822_cpy_adr(to, 0);
+ resent_to = mutt_addr_copy_list(to, 0);
rfc2047_encode_adrlist(resent_to, "Resent-To");
ret = bounce_message(fp, h, resent_to, resent_from, from);
- rfc822_free_address(&resent_to);
- rfc822_free_address(&from);
+ mutt_addr_free(&resent_to);
+ mutt_addr_free(&from);
return ret;
}
*last = addr->next;
addr->next = NULL;
- rfc822_free_address(&addr);
+ mutt_addr_free(&addr);
addr = *last;
}
if (url_pct_decode(tmp) < 0)
goto out;
- e->to = rfc822_parse_adrlist(e->to, tmp);
+ e->to = mutt_addr_parse_list(e->to, tmp);
tag = headers ? strtok_r(headers, "&", &p) : NULL;
projects / neomutt / commitdiff