static int smtp_helo (CONNECTION* conn)
{
char buf[LONG_STRING];
const char* fqdn;
memset (Capabilities, 0, sizeof (Capabilities));
if (!Esmtp) {
/* if TLS or AUTH are requested, use EHLO */
if (conn->account.flags & M_ACCT_USER)
Esmtp = 1;
#ifdef USE_SSL
if (option (OPTSSLFORCETLS) || quadoption (OPT_SSLSTARTTLS) != M_NO)
Esmtp = 1;
#endif
}
if(!(fqdn = mutt_fqdn (0)))
fqdn = NONULL (Hostname);
snprintf (buf, sizeof (buf), "%s %s\r\n", Esmtp ? "EHLO" : "HELO", fqdn);
/* XXX there should probably be a wrapper in mutt_socket.c that
* repeatedly calls conn->write until all data is sent. This
* currently doesn't check for a short write.
*/
if (mutt_socket_write (conn, buf) == -1)
return smtp_err_write;
return smtp_get_resp (conn);
}
ADDRESS *mutt_default_from (void)
{
ADDRESS *adr;
const char *fqdn = mutt_fqdn(1);
/*
* Note: We let $from override $realname here. Is this the right
* thing to do?
*/
if (From)
adr = rfc822_cpy_adr_real (From);
else if (option (OPTUSEDOMAIN))
{
adr = rfc822_new_address ();
adr->mailbox = safe_malloc (mutt_strlen (Username) + mutt_strlen (fqdn) + 2);
sprintf (adr->mailbox, "%s@%s", NONULL(Username), NONULL(fqdn)); /* __SPRINTF_CHECKED__ */
}
else
{
adr = rfc822_new_address ();
adr->mailbox = safe_strdup (NONULL(Username));
}
return (adr);
}
int mix_check_message (HEADER *msg)
{
const char *fqdn;
short need_hostname = 0;
ADDRESS *p;
if (msg->env->cc || msg->env->bcc)
{
mutt_error _("Mixmaster doesn't accept Cc or Bcc headers.");
return -1;
}
/* When using mixmaster, we MUST qualify any addresses since
* the message will be delivered through remote systems.
*
* use_domain won't be respected at this point, hidden_host will.
*/
for (p = msg->env->to; p; p = p->next)
{
if (!p->group && strchr (p->mailbox, '@') == NULL)
{
need_hostname = 1;
break;
}
}
if (need_hostname)
{
if (!(fqdn = mutt_fqdn (1)))
{
mutt_error _("Please set the hostname variable to a proper value when using mixmaster!");
return (-1);
}
/* 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);
}
return 0;
}
static ADDRESS *mutt_expand_aliases_r (ADDRESS *a, LIST **expn)
{
ADDRESS *head = NULL, *last = NULL, *t, *w;
LIST *u;
char i;
const char *fqdn;
while (a)
{
if (!a->group && !a->personal && a->mailbox && strchr (a->mailbox, '@') == NULL)
{
t = mutt_lookup_alias (a->mailbox);
if (t)
{
i = 0;
for (u = *expn; u; u = u->next)
{
if (mutt_strcmp (a->mailbox, u->data) == 0) /* alias already found */
{
dprint (1, (debugfile, "mutt_expand_aliases_r(): loop in alias found for '%s'\n", a->mailbox));
i = 1;
break;
}
}
if (!i)
{
u = safe_malloc (sizeof (LIST));
u->data = safe_strdup (a->mailbox);
u->next = *expn;
*expn = u;
w = rfc822_cpy_adr (t, 0);
w = mutt_expand_aliases_r (w, expn);
if (head)
last->next = w;
else
head = last = w;
while (last && last->next)
last = last->next;
}
t = a;
a = a->next;
t->next = NULL;
rfc822_free_address (&t);
continue;
}
else
{
struct passwd *pw = getpwnam (a->mailbox);
if (pw)
{
char namebuf[STRING];
mutt_gecos_name (namebuf, sizeof (namebuf), pw);
mutt_str_replace (&a->personal, namebuf);
#ifdef EXACT_ADDRESS
FREE (&a->val);
#endif
}
}
}
if (head)
{
last->next = a;
last = last->next;
}
else
head = last = a;
a = a->next;
last->next = NULL;
}
if (option (OPTUSEDOMAIN) && (fqdn = mutt_fqdn(1)))
{
/* now qualify all local addresses */
rfc822_qualify (head, fqdn);
}
return (head);
}
/**
* crypt_get_keys - Check we have all the keys we need
* @param[in] msg Message with addresses to match
* @param[out] keylist Keys needed
* @param[in] oppenc_mode If true, use opportunistic encryption
* @retval 0 Success
* @retval -1 Error
*
* 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(struct Email *msg, char **keylist, bool oppenc_mode)
{
struct Address *addrlist = NULL, *last = NULL;
const char *fqdn = mutt_fqdn(true);
char *self_encrypt = NULL;
/* Do a quick check to make sure that we can find all of the encryption
* keys if the user has requested this service. */
if (!WithCrypto)
return 0;
if (WithCrypto & APPLICATION_PGP)
OptPgpCheckTrust = true;
last = mutt_addr_append(&addrlist, msg->env->to, false);
last = mutt_addr_append(last ? &last : &addrlist, msg->env->cc, false);
mutt_addr_append(last ? &last : &addrlist, msg->env->bcc, false);
if (fqdn)
mutt_addr_qualify(addrlist, fqdn);
addrlist = mutt_addrlist_dedupe(addrlist);
*keylist = NULL;
if (oppenc_mode || (msg->security & SEC_ENCRYPT))
{
if (((WithCrypto & APPLICATION_PGP) != 0) && (msg->security & APPLICATION_PGP))
{
*keylist = crypt_pgp_find_keys(addrlist, oppenc_mode);
if (!*keylist)
{
mutt_addr_free(&addrlist);
return -1;
}
OptPgpCheckTrust = false;
if (C_PgpSelfEncrypt || (C_PgpEncryptSelf == MUTT_YES))
self_encrypt = C_PgpDefaultKey;
}
if (((WithCrypto & APPLICATION_SMIME) != 0) && (msg->security & APPLICATION_SMIME))
{
*keylist = crypt_smime_find_keys(addrlist, oppenc_mode);
if (!*keylist)
{
mutt_addr_free(&addrlist);
return -1;
}
if (C_SmimeSelfEncrypt || (C_SmimeEncryptSelf == MUTT_YES))
self_encrypt = C_SmimeDefaultKey;
}
}
if (!oppenc_mode && self_encrypt && *self_encrypt)
{
const size_t keylist_size = mutt_str_strlen(*keylist);
mutt_mem_realloc(keylist, keylist_size + mutt_str_strlen(self_encrypt) + 2);
sprintf(*keylist + keylist_size, " %s", self_encrypt);
}
mutt_addr_free(&addrlist);
return 0;
}
