# include "config.h"
#endif
+#include <lib-lib/mem.h>
+#include <lib-lib/str.h>
+#include <lib-lib/macros.h>
+#include <lib-lib/file.h>
+
+#include <lib-mime/mime.h>
+
#include "mutt.h"
+#include "enter.h"
+#include "handler.h"
#include "mutt_curses.h"
#include "mutt_menu.h"
-#include "smime.h"
-#include "mime.h"
#include "copy.h"
-#include "lib/mem.h"
-#include "lib/intl.h"
-#include "lib/str.h"
#include "lib/debug.h"
#include <sys/wait.h>
# include <sys/resource.h>
#endif
-#ifdef CRYPT_BACKEND_CLASSIC_SMIME
-
#include "mutt_crypt.h"
struct smime_command_context {
/*
- * Queries and passphrase handling.
+ * Create a format string to be used with scanf.
+ * To use it, write, for instance, MUTT_FORMAT(HUGE_STRING).
+ *
+ * See K&R 2nd ed, p. 231 for an explanation.
*/
+#define _MUTT_FORMAT_2(a,b) "%" a b
+#define _MUTT_FORMAT_1(a, b) _MUTT_FORMAT_2(#a, b)
+#define MUTT_FORMAT(a) _MUTT_FORMAT_1(a, "s")
+/*
+ * Queries and passphrase handling.
+ */
/* these are copies from pgp.c */
void smime_void_passphrase (void)
{
- memset (SmimePass, 0, sizeof (SmimePass));
+ p_clear(SmimePass, sizeof(SmimePass));
SmimeExptime = 0;
}
smime_void_passphrase ();
- if (mutt_get_field_unbuffered (_("Enter SMIME passphrase:"), SmimePass,
+ if (mutt_get_field_unbuffered (_("Enter S/MIME passphrase:"), SmimePass,
sizeof (SmimePass), M_PASS) == 0) {
SmimeExptime = time (NULL) + SmimeTimeout;
return (1);
char buf1[LONG_STRING], buf2[LONG_STRING];
struct stat sb;
- strfcpy (path, NONULL (SmimeCALocation), sizeof (path));
+ m_strcpy(path, sizeof(path), NONULL(SmimeCALocation));
mutt_expand_path (path, sizeof (path));
mutt_quote_filename (buf1, sizeof (buf1), path);
struct smime_command_context cctx;
char cmd[HUGE_STRING];
- memset (&cctx, 0, sizeof (cctx));
+ p_clear(&cctx, 1);
if (!format || !*format)
return (pid_t) - 1;
{
smime_id *Table = (smime_id *) menu->data;
smime_id this = Table[num];
- char *truststate;
+ const char *truststate;
switch (this.trust) {
case 't':
}
fclose (index);
- FOREVER {
+ for (;;) {
*qry = 0;
if (mutt_get_field (prompt, qry, sizeof (qry), 0))
return NULL;
}
/* Read Entries */
cur = 0;
- Table = safe_calloc (cert_num, sizeof (smime_id));
+ Table = p_new(smime_id, cert_num);
while (!feof (index)) {
numFields =
fscanf (index, MUTT_FORMAT (STRING) " %x.%i " MUTT_FORMAT (STRING),
continue;
/* Check if query matches this certificate */
- if (!str_isstr (fields[0], qry) && !str_isstr (fields[2], qry))
+ if (!m_stristr(fields[0], qry) && !m_stristr(fields[2], qry))
continue;
Table[cur].hash = hash;
Table[cur].suffix = hash_suffix;
- strncpy (Table[cur].email, fields[0], sizeof (Table[cur].email));
- strncpy (Table[cur].nick, fields[2], sizeof (Table[cur].nick));
+ m_strcpy(Table[cur].email, sizeof(Table[cur].email), fields[0]);
+ m_strcpy(Table[cur].nick, sizeof(Table[cur].nick), fields[2]);
Table[cur].trust = *fields[4];
Table[cur].public = public;
}
}
if (hash) {
- fname = safe_malloc (13); /* Hash + '.' + Suffix + \0 */
+ fname = p_new(char, 13); /* Hash + '.' + Suffix + \0 */
sprintf (fname, "%.8x.%i", Table[cur].hash, Table[cur].suffix);
}
else
fname = NULL;
mutt_menuDestroy (&menu);
- FREE (&Table);
+ p_delete(&Table);
set_option (OPTNEEDREDRAW);
if (fname)
if (!mailbox && !query)
return (NULL);
- addr_len = mailbox ? mutt_strlen (mailbox) : 0;
- query_len = query ? mutt_strlen (query) : 0;
+ addr_len = mailbox ? m_strlen(mailbox) : 0;
+ query_len = query ? m_strlen(query) : 0;
*key = '\0';
}
while (fgets (buf, sizeof (buf) - 1, fp) != NULL)
- if (mailbox && !(safe_strncasecmp (mailbox, buf, addr_len))) {
+ if (mailbox && !(m_strncasecmp(mailbox, buf, addr_len))) {
numFields = sscanf (buf,
MUTT_FORMAT (STRING) " " MUTT_FORMAT (STRING) " "
MUTT_FORMAT (STRING) " " MUTT_FORMAT (STRING) " "
continue;
}
else if (choice == M_YES) {
- strfcpy (key, fields[1], sizeof (key));
+ m_strcpy(key, sizeof(key), fields[1]);
ask = 0;
break;
}
else {
if (public)
key_trust_level = *fields[4];
- strfcpy (key, fields[1], sizeof (key));
+ m_strcpy(key, sizeof(key), fields[1]);
}
found = 1;
}
/* query = label: return certificate. */
if (numFields >= 3 &&
- !(safe_strncasecmp (query, fields[2], query_len))) {
+ !(m_strncasecmp(query, fields[2], query_len))) {
ask = 0;
- strfcpy (key, fields[1], sizeof (key));
+ m_strcpy(key, sizeof(key), fields[1]);
}
/* query = certificate: return intermediate certificate. */
else if (numFields >= 4 &&
- !(safe_strncasecmp (query, fields[1], query_len))) {
+ !(m_strncasecmp(query, fields[1], query_len))) {
ask = 0;
- strfcpy (key, fields[3], sizeof (key));
+ m_strcpy(key, sizeof(key), fields[3]);
}
}
}
- /* Note: safe_strdup ("") returns NULL. */
- return safe_strdup (key);
+ /* Note: m_strdup("") returns NULL. */
+ return m_strdup(key);
}
if (k) {
/* the key used last time. */
if (*SmimeKeyToUse &&
- !safe_strcasecmp (k, SmimeKeyToUse + mutt_strlen (SmimeKeys) + 1)) {
- FREE (&k);
+ !m_strcasecmp(k, SmimeKeyToUse + m_strlen(SmimeKeys) + 1)) {
+ p_delete(&k);
return;
}
else
snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
NONULL (SmimeCertificates), k);
- if (safe_strcasecmp (k, SmimeDefaultKey))
+ if (m_strcasecmp(k, SmimeDefaultKey))
smime_void_passphrase ();
- FREE (&k);
+ p_delete(&k);
return;
}
if (*SmimeKeyToUse) {
- if (!safe_strcasecmp (SmimeDefaultKey,
- SmimeKeyToUse + mutt_strlen (SmimeKeys) + 1))
+ if (!m_strcasecmp(SmimeDefaultKey,
+ SmimeKeyToUse + m_strlen(SmimeKeys) + 1))
return;
smime_void_passphrase ();
void smime_getkeys (ENVELOPE * env)
{
- ADDRESS *t;
+ address_t *t;
int found = 0;
if (option (OPTSDEFAULTDECRYPTKEY) && SmimeDefaultKey && *SmimeDefaultKey) {
}
if (!found && (t = mutt_default_from ())) {
_smime_getkeys (t->mailbox);
- rfc822_free_address (&t);
+ address_delete (&t);
}
}
* It returns NULL if any of the keys can not be found.
*/
-char *smime_findKeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
+char *smime_findKeys (address_t * to, address_t * cc, address_t * bcc)
{
char *keyID, *keylist = NULL;
size_t keylist_size = 0;
size_t keylist_used = 0;
- ADDRESS *tmp = NULL, *addr = NULL;
- ADDRESS **last = &tmp;
- ADDRESS *p, *q;
+ address_t *tmp = NULL, *addr = NULL;
+ address_t **last = &tmp;
+ address_t *p, *q;
int i;
const char *fqdn = mutt_fqdn (1);
abort ();
}
- *last = rfc822_cpy_adr (p);
+ *last = address_list_dup (p);
while (*last)
last = &((*last)->next);
}
}
if (!keyID) {
mutt_message (_("No (valid) certificate found for %s."), q->mailbox);
- FREE (&keylist);
- rfc822_free_address (&tmp);
- rfc822_free_address (&addr);
+ p_delete(&keylist);
+ address_delete (&tmp);
+ address_delete (&addr);
return NULL;
}
- keylist_size += mutt_strlen (keyID) + 2;
- safe_realloc (&keylist, keylist_size);
+ keylist_size += m_strlen(keyID) + 2;
+ p_realloc(&keylist, keylist_size);
sprintf (keylist + keylist_used, "%s\n", keyID); /* __SPRINTF_CHECKED__ */
- keylist_used = mutt_strlen (keylist);
+ keylist_used = m_strlen(keylist);
- rfc822_free_address (&addr);
+ address_delete (&addr);
}
- rfc822_free_address (&tmp);
+ address_delete (&tmp);
return (keylist);
}
while ((fgets (email, sizeof (email), fpout))) {
- *(email + mutt_strlen (email) - 1) = '\0';
- if (safe_strncasecmp (email, mailbox, mutt_strlen (mailbox)) == 0)
+ *(email + m_strlen(email) - 1) = '\0';
+ if (m_strncasecmp(email, mailbox, m_strlen(mailbox)) == 0)
ret = 1;
ret = ret < 0 ? 0 : ret;
if (copy && buffer && num) {
(*num) = count;
- *buffer = safe_calloc (sizeof (char *), count);
+ *buffer = p_new(char *, count);
count = 0;
rewind (fpout);
while ((fgets (email, sizeof (email), fpout))) {
- *(email + mutt_strlen (email) - 1) = '\0';
- (*buffer)[count] = safe_calloc (1, mutt_strlen (email) + 1);
- strncpy ((*buffer)[count], email, mutt_strlen (email));
+ *(email + m_strlen(email) - 1) = '\0';
+ (*buffer)[count] = p_dupstr(email, m_strlen(email));
count++;
}
}
fclose (fpout);
fclose (fperr);
- return safe_strdup (certfile);
+ return m_strdup(certfile);
}
static char *smime_extract_signer_certificate (char *infile)
fclose (fpout);
fclose (fperr);
- return safe_strdup (certfile);
+ return m_strdup(certfile);
}
mutt_wait_filter (thepid);
mutt_unlink (certfile);
- FREE (&certfile);
+ p_delete(&certfile);
}
fflush (fpout);
else
retval = 0;
mutt_unlink (certfile);
- FREE (&certfile);
+ p_delete(&certfile);
}
else
mutt_any_key_to_continue (_("no certfile"));
*certfile = '\0';
while (1) {
- int off = mutt_strlen (certfile);
+ int off = m_strlen(certfile);
while (*++cert_end && *cert_end != '\n');
if (!*cert_end)
t = mutt_new_body ();
t->type = TYPEAPPLICATION;
- t->subtype = safe_strdup ("x-pkcs7-mime");
+ t->subtype = m_strdup("x-pkcs7-mime");
mutt_set_parameter ("name", "smime.p7m", &t->parameter);
mutt_set_parameter ("smime-type", "enveloped-data", &t->parameter);
t->encoding = ENCBASE64; /* The output of OpenSSL SHOULD be binary */
t->use_disp = 1;
t->disposition = DISPATTACH;
- t->d_filename = safe_strdup ("smime.p7m");
- t->filename = safe_strdup (tempfile);
+ t->d_filename = m_strdup("smime.p7m");
+ t->filename = m_strdup(tempfile);
t->unlink = 1; /*delete after sending the message */
t->parts = 0;
t->next = 0;
t = mutt_new_body ();
t->type = TYPEMULTIPART;
- t->subtype = safe_strdup ("signed");
+ t->subtype = m_strdup("signed");
t->encoding = ENC7BIT;
t->use_disp = 0;
t->disposition = DISPINLINE;
t->parts->next = mutt_new_body ();
t = t->parts->next;
t->type = TYPEAPPLICATION;
- t->subtype = safe_strdup ("x-pkcs7-signature");
- t->filename = safe_strdup (signedfile);
- t->d_filename = safe_strdup ("smime.p7s");
+ t->subtype = m_strdup("x-pkcs7-signature");
+ t->filename = m_strdup(signedfile);
+ t->d_filename = m_strdup("smime.p7s");
t->use_disp = 1;
t->disposition = DISPATTACH;
t->encoding = ENCBASE64;
mutt_decode_attachment (sigbdy, s);
- sigbdy->length = ftell (s->fpout);
+ sigbdy->length = ftello (s->fpout);
sigbdy->offset = 0;
fclose (s->fpout);
rewind (smimeerr);
line = mutt_read_line (line, &linelen, smimeerr, &lineno);
- if (linelen && !safe_strcasecmp (line, "verification successful"))
+ if (linelen && !m_strcasecmp(line, "verification successful"))
badsig = 0;
- FREE (&line);
+ p_delete(&line);
}
}
return NULL;
}
- fseek (s->fpin, m->offset, 0);
+ fseeko (s->fpin, m->offset, 0);
last_pos = m->offset;
mutt_copy_bytes (s->fpin, tmpfp, m->length);
}
}
while (fgets (buf, sizeof (buf) - 1, smimeout) != NULL) {
- len = mutt_strlen (buf);
+ len = m_strlen(buf);
if (len > 1 && buf[len - 2] == '\r') {
buf[len - 2] = '\n';
buf[len - 1] = '\0';
rewind (smimeerr);
line = mutt_read_line (line, &linelen, smimeerr, &lineno);
- if (linelen && !safe_strcasecmp (line, "verification successful"))
+ if (linelen && !m_strcasecmp(line, "verification successful"))
m->goodsig = 1;
- FREE (&line);
+ p_delete(&line);
}
else {
m->goodsig = p->goodsig;
if (b->parts)
return -1;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = fpin;
- fseek (s.fpin, b->offset, 0);
+ fseeko (s.fpin, b->offset, 0);
mutt_mktemp (tempfile);
if ((tmpfp = safe_fopen (tempfile, "w+")) == NULL) {
s.fpout = tmpfp;
mutt_decode_attachment (b, &s);
fflush (tmpfp);
- b->length = ftell (s.fpout);
+ b->length = ftello (s.fpout);
b->offset = 0;
rewind (tmpfp);
s.fpin = tmpfp;
}
-void smime_application_smime_handler (BODY * m, STATE * s)
+int smime_application_smime_handler (BODY * m, STATE * s)
{
-
- smime_handle_entity (m, s, NULL);
-
+ return smime_handle_entity (m, s, NULL) ? 0 : -1;
}
int smime_send_menu (HEADER * msg, int *redraw)
{
char *p;
- if (!(WithCrypto & APPLICATION_SMIME))
- return msg->security;
-
switch (mutt_multi_choice
- (_
- ("S/MIME (e)ncrypt, (s)ign, encrypt (w)ith, sign (a)s, (b)oth, or (c)lear? "),
+ (_("S/MIME (e)ncrypt, (s)ign, encrypt (w)ith, sign (a)s, (b)oth, or (c)lear? "),
_("eswabfc"))) {
case 1: /* (e)ncrypt */
msg->security |= ENCRYPT;
break;
case 3: /* encrypt (w)ith */
- msg->security |= ENCRYPT;
- switch (mutt_multi_choice (_("1: DES, 2: Triple-DES, 3: RC2-40,"
- " 4: RC2-64, 5: RC2-128, or (f)orget it? "),
- _("12345f"))) {
- case 1:
- str_replace (&SmimeCryptAlg, "des");
- break;
- case 2:
- str_replace (&SmimeCryptAlg, "des3");
- break;
- case 3:
- str_replace (&SmimeCryptAlg, "rc2-40");
- break;
- case 4:
- str_replace (&SmimeCryptAlg, "rc2-64");
- break;
- case 5:
- str_replace (&SmimeCryptAlg, "rc2-128");
- break;
- case 6: /* forget it */
- break;
+ {
+ int choice = 0;
+ msg->security |= ENCRYPT;
+
+ do {
+ /* I use "dra" because "123" is recognized anyway */
+ switch (mutt_multi_choice (_("Choose algorithm family:"
+ " 1: DES, 2: RC2, 3: AES,"
+ " or (c)lear? "), _("drac"))) {
+ case 1:
+ switch (choice = mutt_multi_choice (_("1: DES, 2: Triple-DES "),
+ _("dt"))) {
+ case 1:
+ m_strreplace(&SmimeCryptAlg, "des");
+ break;
+ case 2:
+ m_strreplace(&SmimeCryptAlg, "des3");
+ break;
+ }
+ break;
+
+ case 2:
+ switch (choice = mutt_multi_choice (_("1: RC2-40, 2: RC2-64, 3: RC2-128 "),
+ _("468"))) {
+ case 1:
+ m_strreplace(&SmimeCryptAlg, "rc2-40");
+ break;
+ case 2:
+ m_strreplace(&SmimeCryptAlg, "rc2-64");
+ break;
+ case 3:
+ m_strreplace(&SmimeCryptAlg, "rc2-128");
+ break;
+ }
+ break;
+
+ case 3:
+ switch (choice = mutt_multi_choice (_("1: AES128, 2: AES192, 3: AES256 "),
+ _("895"))) {
+ case 1:
+ m_strreplace(&SmimeCryptAlg, "aes128");
+ break;
+ case 2:
+ m_strreplace(&SmimeCryptAlg, "aes192");
+ break;
+ case 3:
+ m_strreplace(&SmimeCryptAlg, "aes256");
+ break;
+ }
+ break;
+
+ case 4: /* (c)lear */
+ p_delete(&SmimeCryptAlg);
+ /* fallback */
+ case -1: /* Ctrl-G or Enter */
+ choice = 0;
+ break;
+ }
+ } while (choice == -1);
}
break;
case 4: /* sign (a)s */
if ((p = smime_ask_for_key (_("Sign as: "), NULL, 0))) {
- p[mutt_strlen (p) - 1] = '\0';
- str_replace (&SmimeDefaultKey, p);
+ m_strreplace(&SmimeDefaultKey, p);
msg->security |= SIGN;
return (msg->security);
}
-
-
-#endif /* CRYPT_BACKEND_CLASSIC_SMIME */
projects / apps / madmutt.git / blobdiff