more constness.

[apps/madmutt.git] / smime.c

diff --git a/smime.c b/smime.c
index 24c237c..cba7100 100644 (file)
--- a/smime.c
+++ b/smime.c
@@ -1,21 +1,12 @@
 /*
 /*

+ * Copyright notice from original mutt:

  * Copyright (C) 2001,2002 Oliver Ehli <elmy@acm.org>
  * Copyright (C) 2002 Mike Schiraldi <raldi@research.netsol.com>
  * Copyright (C) 2004 g10 Code GmbH
  *
  * Copyright (C) 2001,2002 Oliver Ehli <elmy@acm.org>
  * Copyright (C) 2002 Mike Schiraldi <raldi@research.netsol.com>
  * Copyright (C) 2004 g10 Code GmbH
  *

- *     This program is free software; you can redistribute it and/or modify
- *     it under the terms of the GNU General Public License as published by
- *     the Free Software Foundation; either version 2 of the License, or
- *     (at your option) any later version.
- * 
- *     This program is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- * 
- *     You should have received a copy of the GNU General Public License
- *     along with this program; if not, write to the Free Software
- *     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * This file is part of mutt-ng, see http://www.muttng.org/.
+ * It's licensed under the GNU General Public License,
+ * please see the file GPL in the top level source directory.

  */
 
 #if HAVE_CONFIG_H
  */
 
 #if HAVE_CONFIG_H


@@ -23,12 +14,19 @@
 #endif
 
 #include "mutt.h"
 #endif
 
 #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 "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 <string.h>
 #include <stdlib.h>
 #include <sys/wait.h>
 #include <string.h>
 #include <stdlib.h>


@@ -54,12 +52,12 @@
 #include "mutt_crypt.h"
 
 struct smime_command_context {
 #include "mutt_crypt.h"
 
 struct smime_command_context {

-  const char *key;                 /* %k */
-  const char *cryptalg;                    /* %a */
-  const char *fname;               /* %f */
-  const char *sig_fname;           /* %s */
-  const char *certificates;        /* %c */
-  const char *intermediates;        /* %i */
+  const char *key;              /* %k */
+  const char *cryptalg;         /* %a */
+  const char *fname;            /* %f */
+  const char *sig_fname;        /* %s */
+  const char *certificates;     /* %c */
+  const char *intermediates;    /* %i */

 };
 
 
 };
 
 


@@ -68,13 +66,13 @@ typedef struct {
   char suffix;
   char email[256];
   char nick[256];
   char suffix;
   char email[256];
   char nick[256];

-  char trust; /* i=Invalid r=revoked e=expired u=unverified v=verified t=trusted */
-  short public; /* 1=public 0=private */
+  char trust;                   /* i=Invalid r=revoked e=expired u=unverified v=verified t=trusted */
+  short public;                 /* 1=public 0=private */

 } smime_id;
 
 
 char SmimePass[STRING];
 } smime_id;
 
 
 char SmimePass[STRING];

-time_t SmimeExptime = 0; /* when does the cached passphrase expire? */
+time_t SmimeExptime = 0;        /* when does the cached passphrase expire? */

 
 
 static char SmimeKeyToUse[_POSIX_PATH_MAX] = { 0 };
 
 
 static char SmimeKeyToUse[_POSIX_PATH_MAX] = { 0 };


@@ -106,13 +104,13 @@ int smime_valid_passphrase (void)
     /* Use cached copy.  */
     return 1;
 
     /* Use cached copy.  */
     return 1;
 

-  smime_void_passphrase();
-  
-  if (mutt_get_password (_("Enter SMIME passphrase:"), SmimePass, sizeof (SmimePass)) == 0)
-    {
-      SmimeExptime = time (NULL) + SmimeTimeout;
-      return (1);
-    }
+  smime_void_passphrase ();
+
+  if (mutt_get_field_unbuffered (_("Enter S/MIME passphrase:"), SmimePass,
+                                 sizeof (SmimePass), M_PASS) == 0) {
+    SmimeExptime = time (NULL) + SmimeTimeout;
+    return (1);
+  }

   else
     SmimeExptime = 0;
 
   else
     SmimeExptime = 0;
 


@@ -127,126 +125,121 @@ int smime_valid_passphrase (void)
 /* This is almost identical to ppgp's invoking interface. */
 
 static const char *_mutt_fmt_smime_command (char *dest,
 /* This is almost identical to ppgp's invoking interface. */
 
 static const char *_mutt_fmt_smime_command (char *dest,

-                                           size_t destlen,
-                                           char op,
-                                           const char *src,
-                                           const char *prefix,
-                                           const char *ifstring,
-                                           const char *elsestring,
-                                           unsigned long data,
-                                           format_flag flags)
+                                            size_t destlen,
+                                            char op,
+                                            const char *src,
+                                            const char *prefix,
+                                            const char *ifstring,
+                                            const char *elsestring,
+                                            unsigned long data,
+                                            format_flag flags)

 {
   char fmt[16];
   struct smime_command_context *cctx = (struct smime_command_context *) data;
   int optional = (flags & M_FORMAT_OPTIONAL);
 {
   char fmt[16];
   struct smime_command_context *cctx = (struct smime_command_context *) data;
   int optional = (flags & M_FORMAT_OPTIONAL);

-  
-  switch (op)
-  {
-    case 'C':
+
+  switch (op) {
+  case 'C':

     {
     {

-      if (!optional)
-      {
-       char path[_POSIX_PATH_MAX];
-       char buf1[LONG_STRING], buf2[LONG_STRING];
-       struct stat sb;
-
-       strfcpy (path, NONULL (SmimeCALocation), sizeof (path));
-       mutt_expand_path (path, sizeof (path));
-       mutt_quote_filename (buf1, sizeof (buf1), path);
-
-       if (stat (path, &sb) != 0 || !S_ISDIR (sb.st_mode))
-         snprintf (buf2, sizeof (buf2), "-CAfile %s", buf1);
-       else
-         snprintf (buf2, sizeof (buf2), "-CApath %s", buf1);
-       
-       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
-       snprintf (dest, destlen, fmt, buf2);
+      if (!optional) {
+        char path[_POSIX_PATH_MAX];
+        char buf1[LONG_STRING], buf2[LONG_STRING];
+        struct stat sb;
+
+        strfcpy (path, NONULL (SmimeCALocation), sizeof (path));
+        mutt_expand_path (path, sizeof (path));
+        mutt_quote_filename (buf1, sizeof (buf1), path);
+
+        if (stat (path, &sb) != 0 || !S_ISDIR (sb.st_mode))
+          snprintf (buf2, sizeof (buf2), "-CAfile %s", buf1);
+        else
+          snprintf (buf2, sizeof (buf2), "-CApath %s", buf1);
+
+        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
+        snprintf (dest, destlen, fmt, buf2);

       }
       else if (!SmimeCALocation)
       }
       else if (!SmimeCALocation)

-       optional = 0;
+        optional = 0;

       break;
     }
       break;
     }

-    
-    case 'c':
-    {           /* certificate (list) */
+
+  case 'c':
+    {                           /* certificate (list) */

       if (!optional) {
       if (!optional) {

-       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
-       snprintf (dest, destlen, fmt, NONULL(cctx->certificates));
+        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
+        snprintf (dest, destlen, fmt, NONULL (cctx->certificates));

       }
       else if (!cctx->certificates)
       }
       else if (!cctx->certificates)

-       optional = 0;
+        optional = 0;

       break;
     }
       break;
     }

-    
-    case 'i':
-    {           /* intermediate certificates  */
+
+  case 'i':
+    {                           /* intermediate certificates  */

       if (!optional) {
       if (!optional) {

-       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
-       snprintf (dest, destlen, fmt, NONULL(cctx->intermediates));
+        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
+        snprintf (dest, destlen, fmt, NONULL (cctx->intermediates));

       }
       else if (!cctx->intermediates)
       }
       else if (!cctx->intermediates)

-       optional = 0;
+        optional = 0;

       break;
     }
       break;
     }

-    
-    case 's':
-    {           /* detached signature */
-      if (!optional)
-      {
-       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
-       snprintf (dest, destlen, fmt, NONULL (cctx->sig_fname));
+
+  case 's':
+    {                           /* detached signature */
+      if (!optional) {
+        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
+        snprintf (dest, destlen, fmt, NONULL (cctx->sig_fname));

       }
       else if (!cctx->sig_fname)
       }
       else if (!cctx->sig_fname)

-       optional = 0;
+        optional = 0;

       break;
     }
       break;
     }

-    
-    case 'k':
-    {           /* private key */
-      if (!optional)
-      {
-       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
-       snprintf (dest, destlen, fmt, NONULL (cctx->key));
+
+  case 'k':
+    {                           /* private key */
+      if (!optional) {
+        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
+        snprintf (dest, destlen, fmt, NONULL (cctx->key));

       }
       else if (!cctx->key)
       }
       else if (!cctx->key)

-       optional = 0;
+        optional = 0;

       break;
     }
       break;
     }

-    
-    case 'a':
-    {           /* algorithm for encryption */
+
+  case 'a':
+    {                           /* algorithm for encryption */

       if (!optional) {
       if (!optional) {

-       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
-       snprintf (dest, destlen, fmt, NONULL (cctx->cryptalg));
+        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
+        snprintf (dest, destlen, fmt, NONULL (cctx->cryptalg));

       }
       else if (!cctx->key)
       }
       else if (!cctx->key)

-       optional = 0;
+        optional = 0;

       break;
     }
       break;
     }

-    
-    case 'f':
-    {           /* file to process */
-      if (!optional)
-      {
-       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
-       snprintf (dest, destlen, fmt, NONULL (cctx->fname));
+
+  case 'f':
+    {                           /* file to process */
+      if (!optional) {
+        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
+        snprintf (dest, destlen, fmt, NONULL (cctx->fname));

       }
       else if (!cctx->fname)
       }
       else if (!cctx->fname)

-       optional = 0;
+        optional = 0;

       break;
     }
       break;
     }

-    
-    default:
-      *dest = '\0';
-      break;
+
+  default:
+    *dest = '\0';
+    break;

   }
 
   if (optional)
     mutt_FormatString (dest, destlen, ifstring, _mutt_fmt_smime_command,
   }
 
   if (optional)
     mutt_FormatString (dest, destlen, ifstring, _mutt_fmt_smime_command,

-                      data, 0);
+                       data, 0);

   else if (flags & M_FORMAT_OPTIONAL)
     mutt_FormatString (dest, destlen, elsestring, _mutt_fmt_smime_command,
   else if (flags & M_FORMAT_OPTIONAL)
     mutt_FormatString (dest, destlen, elsestring, _mutt_fmt_smime_command,

-                      data, 0);
+                       data, 0);

 
   return (src);
 }
 
   return (src);
 }


@@ -254,45 +247,40 @@ static const char *_mutt_fmt_smime_command (char *dest,
 
 
 static void mutt_smime_command (char *d, size_t dlen,
 
 
 static void mutt_smime_command (char *d, size_t dlen,

-                               struct smime_command_context *cctx, const char *fmt)
+                                struct smime_command_context *cctx,
+                                const char *fmt)

 {
 {

-  mutt_FormatString (d, dlen, NONULL(fmt), _mutt_fmt_smime_command,
-                   (unsigned long) cctx, 0);
-  dprint (2,(debugfile, "mutt_smime_command: %s\n", d));
+  mutt_FormatString (d, dlen, NONULL (fmt), _mutt_fmt_smime_command,
+                     (unsigned long) cctx, 0);
+  debug_print (2, ("%s\n", d));

 }
 
 }
 

-
-
-
-static pid_t smime_invoke (FILE **smimein, FILE **smimeout, FILE **smimeerr,
-                          int smimeinfd, int smimeoutfd, int smimeerrfd,
-                          const char *fname,
-                          const char *sig_fname,
-                          const char *cryptalg,
-                          const char *key,
-                          const char *certificates,
-                          const char *intermediates,
-                          const char *format)
+static pid_t smime_invoke (FILE ** smimein, FILE ** smimeout,
+                           FILE ** smimeerr, int smimeinfd, int smimeoutfd,
+                           int smimeerrfd, const char *fname,
+                           const char *sig_fname, const char *cryptalg,
+                           const char *key, const char *certificates,
+                           const char *intermediates, const char *format)

 {
   struct smime_command_context cctx;
   char cmd[HUGE_STRING];
 {
   struct smime_command_context cctx;
   char cmd[HUGE_STRING];

-  
+

   memset (&cctx, 0, sizeof (cctx));
 
   if (!format || !*format)
   memset (&cctx, 0, sizeof (cctx));
 
   if (!format || !*format)

-    return (pid_t) -1;
-  
-  cctx.fname          = fname;
-  cctx.sig_fname       = sig_fname;
-  cctx.key            = key;
-  cctx.cryptalg               = cryptalg;
-  cctx.certificates    = certificates;
-  cctx.intermediates   = intermediates;
-  
+    return (pid_t) - 1;
+
+  cctx.fname = fname;
+  cctx.sig_fname = sig_fname;
+  cctx.key = key;
+  cctx.cryptalg = cryptalg;
+  cctx.certificates = certificates;
+  cctx.intermediates = intermediates;
+

   mutt_smime_command (cmd, sizeof (cmd), &cctx, format);
 
   return mutt_create_filter_fd (cmd, smimein, smimeout, smimeerr,
   mutt_smime_command (cmd, sizeof (cmd), &cctx, format);
 
   return mutt_create_filter_fd (cmd, smimein, smimeout, smimeerr,

-                               smimeinfd, smimeoutfd, smimeerrfd);
+                                smimeinfd, smimeoutfd, smimeerrfd);

 }
 
 
 }
 
 


@@ -313,131 +301,134 @@ static pid_t smime_invoke (FILE **smimein, FILE **smimeout, FILE **smimeerr,
 
 static void smime_entry (char *s, size_t l, MUTTMENU * menu, int num)
 {
 
 static void smime_entry (char *s, size_t l, MUTTMENU * menu, int num)
 {

-  smime_id *Table = (smime_id*) menu->data;
+  smime_id *Table = (smime_id *) menu->data;

   smime_id this = Table[num];
   smime_id this = Table[num];

-  char* truststate;
-  switch(this.trust) {
-    case 't':
-      truststate = N_("Trusted   ");
-      break;
-    case 'v':
-      truststate = N_("Verified  ");
-      break;
-    case 'u':
-      truststate = N_("Unverified");
-      break;
-    case 'e':
-      truststate = N_("Expired   ");
-      break;
-    case 'r':
-      truststate = N_("Revoked   ");
-      break;
-    case 'i':
-      truststate = N_("Invalid   ");
-      break;
-    default:
-      truststate = N_("Unknown   ");
+  const char *truststate;
+
+  switch (this.trust) {
+  case 't':
+    truststate = N_("Trusted   ");
+    break;
+  case 'v':
+    truststate = N_("Verified  ");
+    break;
+  case 'u':
+    truststate = N_("Unverified");
+    break;
+  case 'e':
+    truststate = N_("Expired   ");
+    break;
+  case 'r':
+    truststate = N_("Revoked   ");
+    break;
+  case 'i':
+    truststate = N_("Invalid   ");
+    break;
+  default:
+    truststate = N_("Unknown   ");

   }
   if (this.public)
   }
   if (this.public)

-    snprintf(s, l, " 0x%.8X.%i %s %-35.35s %s", this.hash, this.suffix, truststate, this.email, this.nick);
+    snprintf (s, l, " 0x%.8X.%i %s %-35.35s %s", this.hash, this.suffix,
+              truststate, this.email, this.nick);

   else
   else

-    snprintf(s, l, " 0x%.8X.%i %-35.35s %s", this.hash, this.suffix, this.email, this.nick);
+    snprintf (s, l, " 0x%.8X.%i %-35.35s %s", this.hash, this.suffix,
+              this.email, this.nick);

 }
 
 
 
 
 
 }
 
 
 
 
 

-char* smime_ask_for_key (char *prompt, char *mailbox, short public)
+char *smime_ask_for_key (char *prompt, char *mailbox, short public)

 {
   char *fname;
   smime_id *Table;
 {
   char *fname;
   smime_id *Table;

-  long cert_num; /* Will contain the number of certificates.
-      * To be able to get it, the .index file will be read twice... */
+  long cert_num;                /* Will contain the number of certificates.
+                                 * To be able to get it, the .index file will be read twice... */

   char index_file[_POSIX_PATH_MAX];
   FILE *index;
   char buf[LONG_STRING];
   char fields[5][STRING];
   char index_file[_POSIX_PATH_MAX];
   FILE *index;
   char buf[LONG_STRING];
   char fields[5][STRING];

-  int numFields, hash_suffix, done, cur; /* The current entry */
-  MUTTMENU* menu;
+  int numFields, hash_suffix, done, cur;        /* The current entry */
+  MUTTMENU *menu;

   unsigned int hash;
   unsigned int hash;

-  char helpstr[HUGE_STRING*3];
+  char helpstr[HUGE_STRING * 3];

   char qry[256];
   char title[256];
 
   char qry[256];
   char title[256];
 

-  if (!prompt) prompt = _("Enter keyID: ");
-  snprintf(index_file, sizeof (index_file), "%s/.index",
-    public ? NONULL(SmimeCertificates) : NONULL(SmimeKeys));
-  
-  index = fopen(index_file, "r");
-  if (index == NULL) 
-  {
-    mutt_perror (index_file);      
+  if (!prompt)
+    prompt = _("Enter keyID: ");
+  snprintf (index_file, sizeof (index_file), "%s/.index",
+            public ? NONULL (SmimeCertificates) : NONULL (SmimeKeys));
+
+  index = fopen (index_file, "r");
+  if (index == NULL) {
+    mutt_perror (index_file);

     return NULL;
   }
   /* Count Lines */
   cert_num = 0;
     return NULL;
   }
   /* Count Lines */
   cert_num = 0;

-  while (!feof(index)) {
-    if (fgets(buf, sizeof(buf), index)) cert_num++;
+  while (!feof (index)) {
+    if (fgets (buf, sizeof (buf), index))
+      cert_num++;

   }
   }

-  fclose(index);
+  fclose (index);

 
 

-  FOREVER
-  {
+  FOREVER {

     *qry = 0;
     *qry = 0;

-    if (mutt_get_field(prompt,
-      qry, sizeof(qry), 0))
+    if (mutt_get_field (prompt, qry, sizeof (qry), 0))

       return NULL;
       return NULL;

-    snprintf(title, sizeof(title), _("S/MIME certificates matching \"%s\"."),
-      qry);
+    snprintf (title, sizeof (title),
+              _("S/MIME certificates matching \"%s\"."), qry);

 
 

-    
-    index = fopen(index_file, "r");
-    if (index == NULL) 
-    {
-      mutt_perror (index_file);      
+
+    index = fopen (index_file, "r");
+    if (index == NULL) {
+      mutt_perror (index_file);

       return NULL;
     }
     /* Read Entries */
     cur = 0;
       return NULL;
     }
     /* Read Entries */
     cur = 0;

-    Table = safe_calloc(cert_num, sizeof (smime_id));
-    while (!feof(index)) {
-        numFields = fscanf (index, MUTT_FORMAT(STRING) " %x.%i " MUTT_FORMAT(STRING), fields[0], &hash,
-          &hash_suffix, fields[2]);
-        if (public)
-          fscanf (index, MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) "\n", fields[3], fields[4]);
-  
+    Table = mem_calloc (cert_num, sizeof (smime_id));
+    while (!feof (index)) {
+      numFields =
+        fscanf (index, MUTT_FORMAT (STRING) " %x.%i " MUTT_FORMAT (STRING),
+                fields[0], &hash, &hash_suffix, fields[2]);
+      if (public)
+        fscanf (index, MUTT_FORMAT (STRING) " " MUTT_FORMAT (STRING) "\n",
+                fields[3], fields[4]);
+

       /* 0=email 1=name 2=nick 3=intermediate 4=trust */
       /* 0=email 1=name 2=nick 3=intermediate 4=trust */

-      if (numFields < 2) continue;
-  
+      if (numFields < 2)
+        continue;
+

       /* Check if query matches this certificate */
       /* Check if query matches this certificate */

-      if (!mutt_stristr(fields[0], qry) &&
-          !mutt_stristr(fields[2], qry))
+      if (!str_isstr (fields[0], qry) && !str_isstr (fields[2], qry))

         continue;
         continue;

-  
+

       Table[cur].hash = hash;
       Table[cur].suffix = hash_suffix;
       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));
+      strncpy (Table[cur].email, fields[0], sizeof (Table[cur].email));
+      strncpy (Table[cur].nick, fields[2], sizeof (Table[cur].nick));

       Table[cur].trust = *fields[4];
       Table[cur].public = public;
       Table[cur].trust = *fields[4];
       Table[cur].public = public;

-  
+

       cur++;
     }
       cur++;
     }

-    fclose(index);
-  
+    fclose (index);
+

     /* Make Helpstring */
     helpstr[0] = 0;
     mutt_make_help (buf, sizeof (buf), _("Exit  "), MENU_SMIME, OP_EXIT);
     /* Make Helpstring */
     helpstr[0] = 0;
     mutt_make_help (buf, sizeof (buf), _("Exit  "), MENU_SMIME, OP_EXIT);

-    strcat (helpstr, buf);     /* __STRCAT_CHECKED__ */
+    strcat (helpstr, buf);      /* __STRCAT_CHECKED__ */

     mutt_make_help (buf, sizeof (buf), _("Select  "), MENU_SMIME,
     mutt_make_help (buf, sizeof (buf), _("Select  "), MENU_SMIME,

-        OP_GENERIC_SELECT_ENTRY);
-    strcat (helpstr, buf);     /* __STRCAT_CHECKED__ */
-    mutt_make_help (buf, sizeof(buf), _("Help"), MENU_SMIME, OP_HELP);
-    strcat (helpstr, buf);     /* __STRCAT_CHECKED__ */
-  
+                    OP_GENERIC_SELECT_ENTRY);
+    strcat (helpstr, buf);      /* __STRCAT_CHECKED__ */
+    mutt_make_help (buf, sizeof (buf), _("Help"), MENU_SMIME, OP_HELP);
+    strcat (helpstr, buf);      /* __STRCAT_CHECKED__ */
+

     /* Create the menu */
     /* Create the menu */

-    menu = mutt_new_menu();
+    menu = mutt_new_menu ();

     menu->max = cur;
     menu->make_entry = smime_entry;
     menu->menu = MENU_SMIME;
     menu->max = cur;
     menu->make_entry = smime_entry;
     menu->menu = MENU_SMIME;


@@ -445,57 +436,61 @@ char* smime_ask_for_key (char *prompt, char *mailbox, short public)
     menu->data = Table;
     menu->title = title;
     /* sorting keys might be done later - TODO */
     menu->data = Table;
     menu->title = title;
     /* sorting keys might be done later - TODO */

-  
-    mutt_clear_error();
-  
+
+    mutt_clear_error ();
+

     done = 0;
     hash = 0;
     while (!done) {
       switch (mutt_menuLoop (menu)) {
     done = 0;
     hash = 0;
     while (!done) {
       switch (mutt_menuLoop (menu)) {

-        case OP_GENERIC_SELECT_ENTRY:
-          cur = menu->current;
-       hash = 1;
-          done = 1;
-          break;
-        case OP_EXIT:
-          hash = 0;
-          done = 1;
-          break;
+      case OP_GENERIC_SELECT_ENTRY:
+        cur = menu->current;
+        hash = 1;
+        done = 1;
+        break;
+      case OP_EXIT:
+        hash = 0;
+        done = 1;
+        break;

       }
     }
     if (hash) {
       }
     }
     if (hash) {

-      fname = safe_malloc(14); /* Hash + '.' + Suffix + \n + \0 */
-      sprintf(fname, "%.8x.%i\n", Table[cur].hash, Table[cur].suffix);
+      fname = mem_malloc (13); /* Hash + '.' + Suffix + \0 */
+      sprintf (fname, "%.8x.%i", Table[cur].hash, Table[cur].suffix);

     }
     }

-    else fname = NULL;
-  
+    else
+      fname = NULL;
+

     mutt_menuDestroy (&menu);
     mutt_menuDestroy (&menu);

-    FREE (&Table);
+    mem_free (&Table);

     set_option (OPTNEEDREDRAW);
     set_option (OPTNEEDREDRAW);

-  
-    if (fname) return fname;
+
+    if (fname)
+      return fname;

   }
 }
 
 
 
   }
 }
 
 
 

-char *smime_get_field_from_db (char *mailbox, char *query, short public, short may_ask)
+char *smime_get_field_from_db (char *mailbox, char *query, short public,
+                               short may_ask)

 {
   int addr_len, query_len, found = 0, ask = 0, choice = 0;
   char cert_path[_POSIX_PATH_MAX];
   char buf[LONG_STRING], prompt[STRING];
   char fields[5][STRING];
 {
   int addr_len, query_len, found = 0, ask = 0, choice = 0;
   char cert_path[_POSIX_PATH_MAX];
   char buf[LONG_STRING], prompt[STRING];
   char fields[5][STRING];

-  char key[STRING];  
+  char key[STRING];

   int numFields;
   struct stat info;
   char key_trust_level = 0;
   FILE *fp;
 
   int numFields;
   struct stat info;
   char key_trust_level = 0;
   FILE *fp;
 

-  if(!mailbox && !query) return(NULL);
+  if (!mailbox && !query)
+    return (NULL);
+
+  addr_len = mailbox ? str_len (mailbox) : 0;
+  query_len = query ? str_len (query) : 0;

 
 

-  addr_len = mailbox ? mutt_strlen (mailbox) : 0;
-  query_len = query ? mutt_strlen (query) : 0;
-  

   *key = '\0';
 
   /* index-file format:
   *key = '\0';
 
   /* index-file format:


@@ -505,144 +500,129 @@ char *smime_get_field_from_db (char *mailbox, char *query, short public, short m
      Note that this was done according to the OpenSSL
      specs on their CA-directory.
 
      Note that this was done according to the OpenSSL
      specs on their CA-directory.
 

-  */
+   */

   snprintf (cert_path, sizeof (cert_path), "%s/.index",
   snprintf (cert_path, sizeof (cert_path), "%s/.index",

-           (public ? NONULL(SmimeCertificates) : NONULL(SmimeKeys)));
+            (public ? NONULL (SmimeCertificates) : NONULL (SmimeKeys)));

 
 

-  if (!stat (cert_path, &info))
-  {
-    if ((fp = safe_fopen (cert_path, "r")) == NULL)
-    {
+  if (!stat (cert_path, &info)) {
+    if ((fp = safe_fopen (cert_path, "r")) == NULL) {

       mutt_perror (cert_path);
       return (NULL);
     }
 
     while (fgets (buf, sizeof (buf) - 1, fp) != NULL)
       mutt_perror (cert_path);
       return (NULL);
     }
 
     while (fgets (buf, sizeof (buf) - 1, fp) != NULL)

-      if (mailbox && !(mutt_strncasecmp (mailbox, buf, addr_len)))
-      {
-       numFields = sscanf (buf, 
-                           MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) " " 
-                           MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) " " 
-                           MUTT_FORMAT(STRING) "\n", 
-                           fields[0], fields[1],
-                          fields[2], fields[3], 
-                           fields[4]);
-       if (numFields < 2)
-           continue;
-       if (mailbox && public && 
-           (!fields[4] ||
-            *fields[4] == 'i' || *fields[4] == 'e' || *fields[4] == 'r'))
-           continue;
-
-       if (found)
-       {
-         if (public && *fields[4] == 'u' )
-           snprintf (prompt, sizeof (prompt),
-                     _("ID %s is unverified. Do you want to use it for %s ?"),
-                     fields[1], mailbox);
-         else if (public && *fields[4] == 'v' )
-           snprintf (prompt, sizeof (prompt),
-                     _("Use (untrusted!) ID %s for %s ?"),
-                     fields[1], mailbox);
-         else
-           snprintf (prompt, sizeof (prompt), _("Use ID %s for %s ?"),
-                     fields[1], mailbox);
-         if (may_ask == 0)
-           choice = M_YES;
-         if (may_ask && (choice = mutt_yesorno (prompt, M_NO)) == -1)
-         {
-           found = 0;
-           ask = 0;
-           *key = '\0';
-           break;
-         }
-         else if (choice == M_NO) 
-         {
-           ask = 1;
-           continue;
-         }
-         else if (choice == M_YES)
-         {
-           strfcpy (key, fields[1], sizeof (key));
-           ask = 0;
-           break;
-         }
-       }
-       else
-       {
-         if (public) 
-           key_trust_level = *fields[4];
-         strfcpy (key, fields[1], sizeof (key));
-       }
-       found = 1;
+      if (mailbox && !(str_ncasecmp (mailbox, buf, addr_len))) {
+        numFields = sscanf (buf,
+                            MUTT_FORMAT (STRING) " " MUTT_FORMAT (STRING) " "
+                            MUTT_FORMAT (STRING) " " MUTT_FORMAT (STRING) " "
+                            MUTT_FORMAT (STRING) "\n",
+                            fields[0], fields[1],
+                            fields[2], fields[3], fields[4]);
+        if (numFields < 2)
+          continue;
+        if (mailbox && public &&
+            (!fields[4] ||
+             *fields[4] == 'i' || *fields[4] == 'e' || *fields[4] == 'r'))
+          continue;
+
+        if (found) {
+          if (public && *fields[4] == 'u')
+            snprintf (prompt, sizeof (prompt),
+                      _
+                      ("ID %s is unverified. Do you want to use it for %s ?"),
+                      fields[1], mailbox);
+          else if (public && *fields[4] == 'v')
+            snprintf (prompt, sizeof (prompt),
+                      _("Use (untrusted!) ID %s for %s ?"),
+                      fields[1], mailbox);
+          else
+            snprintf (prompt, sizeof (prompt), _("Use ID %s for %s ?"),
+                      fields[1], mailbox);
+          if (may_ask == 0)
+            choice = M_YES;
+          if (may_ask && (choice = mutt_yesorno (prompt, M_NO)) == -1) {
+            found = 0;
+            ask = 0;
+            *key = '\0';
+            break;
+          }
+          else if (choice == M_NO) {
+            ask = 1;
+            continue;
+          }
+          else if (choice == M_YES) {
+            strfcpy (key, fields[1], sizeof (key));
+            ask = 0;
+            break;
+          }
+        }
+        else {
+          if (public)
+            key_trust_level = *fields[4];
+          strfcpy (key, fields[1], sizeof (key));
+        }
+        found = 1;

       }
       }

-      else if(query)
-      {
-       numFields = sscanf (buf, 
-                           MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) " " 
-                           MUTT_FORMAT(STRING) " " MUTT_FORMAT(STRING) " " 
-                           MUTT_FORMAT(STRING) "\n", 
-                           fields[0], fields[1],
-                           fields[2], fields[3], 
-                           fields[4]);
-
-       /* query = label: return certificate. */
-       if (numFields >= 3 && 
-           !(mutt_strncasecmp (query, fields[2], query_len)))
-       {
-         ask = 0;
-         strfcpy (key, fields[1], sizeof (key));
-       }
-       /* query = certificate: return intermediate certificate. */
-       else if (numFields >= 4 && 
-                !(mutt_strncasecmp (query, fields[1], query_len)))
-       {
-         ask = 0;
-         strfcpy (key, fields[3], sizeof (key));
-       }
+      else if (query) {
+        numFields = sscanf (buf,
+                            MUTT_FORMAT (STRING) " " MUTT_FORMAT (STRING) " "
+                            MUTT_FORMAT (STRING) " " MUTT_FORMAT (STRING) " "
+                            MUTT_FORMAT (STRING) "\n",
+                            fields[0], fields[1],
+                            fields[2], fields[3], fields[4]);
+
+        /* query = label: return certificate. */
+        if (numFields >= 3 &&
+            !(str_ncasecmp (query, fields[2], query_len))) {
+          ask = 0;
+          strfcpy (key, fields[1], sizeof (key));
+        }
+        /* query = certificate: return intermediate certificate. */
+        else if (numFields >= 4 &&
+                 !(str_ncasecmp (query, fields[1], query_len))) {
+          ask = 0;
+          strfcpy (key, fields[3], sizeof (key));
+        }

       }
 
     safe_fclose (&fp);
 
       }
 
     safe_fclose (&fp);
 

-    if (ask)
-    {
-      if (public && *fields[4] == 'u' )
-       snprintf (prompt, sizeof (prompt),
-                 _("ID %s is unverified. Do you want to use it for %s ?"),
-                 fields[1], mailbox);
-      else if (public && *fields[4] == 'v' )
-       snprintf (prompt, sizeof (prompt),
-                 _("Use (untrusted!) ID %s for %s ?"),
-                 fields[1], mailbox);
+    if (ask) {
+      if (public && *fields[4] == 'u')
+        snprintf (prompt, sizeof (prompt),
+                  _("ID %s is unverified. Do you want to use it for %s ?"),
+                  fields[1], mailbox);
+      else if (public && *fields[4] == 'v')
+        snprintf (prompt, sizeof (prompt),
+                  _("Use (untrusted!) ID %s for %s ?"), fields[1], mailbox);

       else
       else

-       snprintf (prompt, sizeof(prompt), _("Use ID %s for %s ?"), key,
-                 mailbox);
+        snprintf (prompt, sizeof (prompt), _("Use ID %s for %s ?"), key,
+                  mailbox);

       choice = mutt_yesorno (prompt, M_NO);
       if (choice == -1 || choice == M_NO)
       choice = mutt_yesorno (prompt, M_NO);
       if (choice == -1 || choice == M_NO)

-       *key = '\0';
+        *key = '\0';

     }
     }

-    else if (key_trust_level && may_ask)
-    {
-      if (key_trust_level == 'u' )
-      {
-       snprintf (prompt, sizeof (prompt),
-                 _("ID %s is unverified. Do you want to use it for %s ?"),
-                 key, mailbox);
-       choice = mutt_yesorno (prompt, M_NO);
-       if (choice != M_YES)
-         *key = '\0';
+    else if (key_trust_level && may_ask) {
+      if (key_trust_level == 'u') {
+        snprintf (prompt, sizeof (prompt),
+                  _("ID %s is unverified. Do you want to use it for %s ?"),
+                  key, mailbox);
+        choice = mutt_yesorno (prompt, M_NO);
+        if (choice != M_YES)
+          *key = '\0';

       }
       }

-      else if (key_trust_level == 'v' )
-      {
-       mutt_error (_("Warning: You have not yet decided to trust ID %s. (any key to continue)"), key);
-       mutt_sleep (5);
+      else if (key_trust_level == 'v') {
+        mutt_error (_
+                    ("Warning: You have not yet decided to trust ID %s. (any key to continue)"),
+                    key);
+        mutt_sleep (5);

       }
     }
 
   }
 
       }
     }
 
   }
 

-  /* Note: safe_strdup ("") returns NULL. */
-  return safe_strdup (key);
+  /* Note: str_dup ("") returns NULL. */
+  return str_dup (key);

 }
 
 
 }
 
 


@@ -660,83 +640,75 @@ void _smime_getkeys (char *mailbox)
 
   k = smime_get_field_from_db (mailbox, NULL, 0, 1);
 
 
   k = smime_get_field_from_db (mailbox, NULL, 0, 1);
 

-  if (!k)
-  {
-    snprintf(buf, sizeof(buf), _("Enter keyID for %s: "),
-            mailbox);
-    k = smime_ask_for_key(buf, mailbox, 0);
+  if (!k) {
+    snprintf (buf, sizeof (buf), _("Enter keyID for %s: "), mailbox);
+    k = smime_ask_for_key (buf, mailbox, 0);

   }
 
   }
 

-  if (k)
-  {
+  if (k) {

     /* the key used last time. */
     /* the key used last time. */

-    if (*SmimeKeyToUse && 
-        !mutt_strcasecmp (k, SmimeKeyToUse + mutt_strlen (SmimeKeys)+1))
-    {
-      FREE (&k);
+    if (*SmimeKeyToUse &&
+        !str_casecmp (k, SmimeKeyToUse + str_len (SmimeKeys) + 1)) {
+      mem_free (&k);

       return;
     }
       return;
     }

-    else smime_void_passphrase ();
+    else
+      smime_void_passphrase ();
+
+    snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s",
+              NONULL (SmimeKeys), k);

 
 

-    snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s", 
-             NONULL(SmimeKeys), k);
-    

     snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
     snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",

-             NONULL(SmimeCertificates), k);
+              NONULL (SmimeCertificates), k);

 
 

-    if (mutt_strcasecmp (k, SmimeDefaultKey))
+    if (str_casecmp (k, SmimeDefaultKey))

       smime_void_passphrase ();
 
       smime_void_passphrase ();
 

-    FREE (&k);
+    mem_free (&k);

     return;
   }
 
     return;
   }
 

-  if (*SmimeKeyToUse)
-  {
-    if (!mutt_strcasecmp (SmimeDefaultKey, 
-                          SmimeKeyToUse + mutt_strlen (SmimeKeys)+1))
+  if (*SmimeKeyToUse) {
+    if (!str_casecmp (SmimeDefaultKey,
+                          SmimeKeyToUse + str_len (SmimeKeys) + 1))

       return;
 
     smime_void_passphrase ();
   }
 
       return;
 
     smime_void_passphrase ();
   }
 

-  snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s", 
-           NONULL (SmimeKeys), NONULL (SmimeDefaultKey));
-  
+  snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s",
+            NONULL (SmimeKeys), NONULL (SmimeDefaultKey));
+

   snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
   snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",

-           NONULL (SmimeCertificates), NONULL (SmimeDefaultKey));
+            NONULL (SmimeCertificates), NONULL (SmimeDefaultKey));

 }
 
 }
 

-void smime_getkeys (ENVELOPE *env)
+void smime_getkeys (ENVELOPE * env)

 {
   ADDRESS *t;
   int found = 0;
 
 {
   ADDRESS *t;
   int found = 0;
 

-  if (option (OPTSDEFAULTDECRYPTKEY) && SmimeDefaultKey && *SmimeDefaultKey)
-  {
-    snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s", 
-             NONULL (SmimeKeys), SmimeDefaultKey);
-    
+  if (option (OPTSDEFAULTDECRYPTKEY) && SmimeDefaultKey && *SmimeDefaultKey) {
+    snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s",
+              NONULL (SmimeKeys), SmimeDefaultKey);
+

     snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
     snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",

-             NONULL(SmimeCertificates), SmimeDefaultKey);
+              NONULL (SmimeCertificates), SmimeDefaultKey);

 
     return;
   }
 
   for (t = env->to; !found && t; t = t->next)
 
     return;
   }
 
   for (t = env->to; !found && t; t = t->next)

-    if (mutt_addr_is_user (t))
-    {
+    if (mutt_addr_is_user (t)) {

       found = 1;
       _smime_getkeys (t->mailbox);
     }
   for (t = env->cc; !found && t; t = t->next)
       found = 1;
       _smime_getkeys (t->mailbox);
     }
   for (t = env->cc; !found && t; t = t->next)

-    if (mutt_addr_is_user (t))
-    {
+    if (mutt_addr_is_user (t)) {

       found = 1;
       _smime_getkeys (t->mailbox);
     }
       found = 1;
       _smime_getkeys (t->mailbox);
     }

-  if (!found && (t = mutt_default_from()))
-  {
+  if (!found && (t = mutt_default_from ())) {

     _smime_getkeys (t->mailbox);
     rfc822_free_address (&t);
   }
     _smime_getkeys (t->mailbox);
     rfc822_free_address (&t);
   }


@@ -746,7 +718,7 @@ void smime_getkeys (ENVELOPE *env)
  * It returns NULL if any of the keys can not be found.
  */
 
  * 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 * to, ADDRESS * cc, ADDRESS * bcc)

 {
   char *keyID, *keylist = NULL;
   size_t keylist_size = 0;
 {
   char *keyID, *keylist = NULL;
   size_t keylist_size = 0;


@@ -757,17 +729,22 @@ char *smime_findKeys (ADDRESS *to, ADDRESS *cc, ADDRESS *bcc)
   int i;
 
   const char *fqdn = mutt_fqdn (1);
   int i;
 
   const char *fqdn = mutt_fqdn (1);

-  
-  for (i = 0; i < 3; i++)
-  {
-    switch (i)
-    {
-      case 0: p = to; break;
-      case 1: p = cc; break;
-      case 2: p = bcc; break;
-      default: abort ();
+
+  for (i = 0; i < 3; i++) {
+    switch (i) {
+    case 0:
+      p = to;
+      break;
+    case 1:
+      p = cc;
+      break;
+    case 2:
+      p = bcc;
+      break;
+    default:
+      abort ();

     }
     }

-    
+

     *last = rfc822_cpy_adr (p);
     while (*last)
       last = &((*last)->next);
     *last = rfc822_cpy_adr (p);
     while (*last)
       last = &((*last)->next);


@@ -777,33 +754,28 @@ char *smime_findKeys (ADDRESS *to, ADDRESS *cc, ADDRESS *bcc)
     rfc822_qualify (tmp, fqdn);
 
   tmp = mutt_remove_duplicates (tmp);
     rfc822_qualify (tmp, fqdn);
 
   tmp = mutt_remove_duplicates (tmp);

-  
-  for (p = tmp; p ; p = p->next)
-  {
+
+  for (p = tmp; p; p = p->next) {

     char buf[LONG_STRING];
 
     q = p;
 
     char buf[LONG_STRING];
 
     q = p;
 

-    if ((keyID = smime_get_field_from_db (q->mailbox, NULL, 1, 1)) == NULL)
-    {
-      snprintf(buf, sizeof(buf),
-              _("Enter keyID for %s: "),
-              q->mailbox);
-      keyID = smime_ask_for_key(buf, q->mailbox, 1);
+    if ((keyID = smime_get_field_from_db (q->mailbox, NULL, 1, 1)) == NULL) {
+      snprintf (buf, sizeof (buf), _("Enter keyID for %s: "), q->mailbox);
+      keyID = smime_ask_for_key (buf, q->mailbox, 1);

     }
     }

-    if(!keyID)
-    {
+    if (!keyID) {

       mutt_message (_("No (valid) certificate found for %s."), q->mailbox);
       mutt_message (_("No (valid) certificate found for %s."), q->mailbox);

-      FREE (&keylist);
+      mem_free (&keylist);

       rfc822_free_address (&tmp);
       rfc822_free_address (&addr);
       return NULL;
     }
       rfc822_free_address (&tmp);
       rfc822_free_address (&addr);
       return NULL;
     }

-    
-    keylist_size += mutt_strlen (keyID) + 2;
-    safe_realloc (&keylist, keylist_size);
-    sprintf (keylist + keylist_used, "%s\n", keyID);   /* __SPRINTF_CHECKED__ */
-    keylist_used = mutt_strlen (keylist);
+
+    keylist_size += str_len (keyID) + 2;
+    mem_realloc (&keylist, keylist_size);
+    sprintf (keylist + keylist_used, "%s\n", keyID);    /* __SPRINTF_CHECKED__ */
+    keylist_used = str_len (keylist);

 
     rfc822_free_address (&addr);
 
 
     rfc822_free_address (&addr);
 


@@ -818,7 +790,7 @@ char *smime_findKeys (ADDRESS *to, ADDRESS *cc, ADDRESS *bcc)
 
 
 static int smime_handle_cert_email (char *certificate, char *mailbox,
 
 
 static int smime_handle_cert_email (char *certificate, char *mailbox,

-                                  int copy, char ***buffer, int *num)
+                                    int copy, char ***buffer, int *num)

 {
   FILE *fpout = NULL, *fperr = NULL;
   char tmpfname[_POSIX_PATH_MAX];
 {
   FILE *fpout = NULL, *fperr = NULL;
   char tmpfname[_POSIX_PATH_MAX];


@@ -827,27 +799,24 @@ static int smime_handle_cert_email (char *certificate, char *mailbox,
   pid_t thepid;
 
   mutt_mktemp (tmpfname);
   pid_t thepid;
 
   mutt_mktemp (tmpfname);

-  if ((fperr = safe_fopen (tmpfname, "w+")) == NULL)
-  {
+  if ((fperr = safe_fopen (tmpfname, "w+")) == NULL) {

     mutt_perror (tmpfname);
     return 1;
   }
   mutt_unlink (tmpfname);
 
   mutt_mktemp (tmpfname);
     mutt_perror (tmpfname);
     return 1;
   }
   mutt_unlink (tmpfname);
 
   mutt_mktemp (tmpfname);

-  if ((fpout = safe_fopen (tmpfname, "w+")) == NULL)
-  {
+  if ((fpout = safe_fopen (tmpfname, "w+")) == NULL) {

     fclose (fperr);
     mutt_perror (tmpfname);
     return 1;
   }
   mutt_unlink (tmpfname);
 
     fclose (fperr);
     mutt_perror (tmpfname);
     return 1;
   }
   mutt_unlink (tmpfname);
 

-  if ((thepid =  smime_invoke (NULL, NULL, NULL,
-                              -1, fileno (fpout), fileno (fperr),
-                              certificate, NULL, NULL, NULL, NULL, NULL,
-                              SmimeGetCertEmailCommand))== -1)
-  {
+  if ((thepid = smime_invoke (NULL, NULL, NULL,
+                              -1, fileno (fpout), fileno (fperr),
+                              certificate, NULL, NULL, NULL, NULL, NULL,
+                              SmimeGetCertEmailCommand)) == -1) {

     mutt_message (_("Error: unable to create OpenSSL subprocess!"));
     fclose (fperr);
     fclose (fpout);
     mutt_message (_("Error: unable to create OpenSSL subprocess!"));
     fclose (fperr);
     fclose (fpout);


@@ -862,43 +831,42 @@ static int smime_handle_cert_email (char *certificate, char *mailbox,
   fflush (fperr);
 
 
   fflush (fperr);
 
 

-  while ((fgets (email, sizeof (email), fpout)))
-  {
-    *(email + mutt_strlen (email)-1) = '\0';
-    if(mutt_strncasecmp (email, mailbox, mutt_strlen (mailbox)) == 0)
-      ret=1;
+  while ((fgets (email, sizeof (email), fpout))) {
+    *(email + str_len (email) - 1) = '\0';
+    if (str_ncasecmp (email, mailbox, str_len (mailbox)) == 0)
+      ret = 1;

 
     ret = ret < 0 ? 0 : ret;
     count++;
   }
 
 
     ret = ret < 0 ? 0 : ret;
     count++;
   }
 

-  if (ret == -1)
-  {
-    mutt_endwin(NULL);
+  if (ret == -1) {
+    mutt_endwin (NULL);

     mutt_copy_stream (fperr, stdout);
     mutt_copy_stream (fperr, stdout);

-    mutt_any_key_to_continue (_("Error: unable to create OpenSSL subprocess!"));
+    mutt_any_key_to_continue (_
+                              ("Error: unable to create OpenSSL subprocess!"));

     ret = 1;
   }
   else if (!ret)
     ret = 1;
     ret = 1;
   }
   else if (!ret)
     ret = 1;

-  else ret = 0;
+  else
+    ret = 0;

 
 

-  if(copy && buffer && num)
-  {
+  if (copy && buffer && num) {

     (*num) = count;
     (*num) = count;

-    *buffer =  safe_calloc(sizeof(char*), count);
+    *buffer = mem_calloc (sizeof (char *), count);

     count = 0;
 
     rewind (fpout);
     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));
+    while ((fgets (email, sizeof (email), fpout))) {
+      *(email + str_len (email) - 1) = '\0';
+      (*buffer)[count] = mem_calloc (1, str_len (email) + 1);
+      strncpy ((*buffer)[count], email, str_len (email));

       count++;
     }
   }
       count++;
     }
   }

-  else if(copy) ret = 2;
+  else if (copy)
+    ret = 2;

 
   fclose (fpout);
   fclose (fperr);
 
   fclose (fpout);
   fclose (fperr);


@@ -918,16 +886,14 @@ static char *smime_extract_certificate (char *infile)
 
 
   mutt_mktemp (tmpfname);
 
 
   mutt_mktemp (tmpfname);

-  if ((fperr = safe_fopen (tmpfname, "w+")) == NULL)
-  {
+  if ((fperr = safe_fopen (tmpfname, "w+")) == NULL) {

     mutt_perror (tmpfname);
     return NULL;
   }
   mutt_unlink (tmpfname);
 
   mutt_mktemp (pk7out);
     mutt_perror (tmpfname);
     return NULL;
   }
   mutt_unlink (tmpfname);
 
   mutt_mktemp (pk7out);

-  if ((fpout = safe_fopen (pk7out, "w+")) == NULL)
-  {
+  if ((fpout = safe_fopen (pk7out, "w+")) == NULL) {

     fclose (fperr);
     mutt_perror (pk7out);
     return NULL;
     fclose (fperr);
     mutt_perror (pk7out);
     return NULL;


@@ -935,13 +901,13 @@ static char *smime_extract_certificate (char *infile)
 
   /* Step 1: Convert the signature to a PKCS#7 structure, as we can't
      extract the full set of certificates directly.
 
   /* Step 1: Convert the signature to a PKCS#7 structure, as we can't
      extract the full set of certificates directly.

-  */
-  if ((thepid =  smime_invoke (NULL, NULL, NULL,
-                              -1, fileno (fpout), fileno (fperr),
-                              infile, NULL, NULL, NULL, NULL, NULL,
-                              SmimePk7outCommand))== -1)
-  {
-    mutt_any_key_to_continue (_("Error: unable to create OpenSSL subprocess!"));
+   */
+  if ((thepid = smime_invoke (NULL, NULL, NULL,
+                              -1, fileno (fpout), fileno (fperr),
+                              infile, NULL, NULL, NULL, NULL, NULL,
+                              SmimePk7outCommand)) == -1) {
+    mutt_any_key_to_continue (_
+                              ("Error: unable to create OpenSSL subprocess!"));

     fclose (fperr);
     fclose (fpout);
     mutt_unlink (pk7out);
     fclose (fperr);
     fclose (fpout);
     mutt_unlink (pk7out);


@@ -956,36 +922,34 @@ static char *smime_extract_certificate (char *infile)
   rewind (fperr);
   fflush (fperr);
   empty = (fgetc (fpout) == EOF);
   rewind (fperr);
   fflush (fperr);
   empty = (fgetc (fpout) == EOF);

-  if (empty)
-  {
+  if (empty) {

     mutt_perror (pk7out);
     mutt_copy_stream (fperr, stdout);
     fclose (fpout);
     fclose (fperr);
     mutt_unlink (pk7out);
     return NULL;
     mutt_perror (pk7out);
     mutt_copy_stream (fperr, stdout);
     fclose (fpout);
     fclose (fperr);
     mutt_unlink (pk7out);
     return NULL;

-    
+

   }
 
 
   fclose (fpout);
   mutt_mktemp (certfile);
   }
 
 
   fclose (fpout);
   mutt_mktemp (certfile);

-  if ((fpout = safe_fopen (certfile, "w+")) == NULL)
-  {
+  if ((fpout = safe_fopen (certfile, "w+")) == NULL) {

     fclose (fperr);
     mutt_unlink (pk7out);
     mutt_perror (certfile);
     return NULL;
   }
     fclose (fperr);
     mutt_unlink (pk7out);
     mutt_perror (certfile);
     return NULL;
   }

-  
+

   /* Step 2: Extract the certificates from a PKCS#7 structure.
    */
   /* Step 2: Extract the certificates from a PKCS#7 structure.
    */

-  if ((thepid =  smime_invoke (NULL, NULL, NULL,
-                              -1, fileno (fpout), fileno (fperr),
-                              pk7out, NULL, NULL, NULL, NULL, NULL,
-                              SmimeGetCertCommand))== -1)
-  {
-    mutt_any_key_to_continue (_("Error: unable to create OpenSSL subprocess!"));
+  if ((thepid = smime_invoke (NULL, NULL, NULL,
+                              -1, fileno (fpout), fileno (fperr),
+                              pk7out, NULL, NULL, NULL, NULL, NULL,
+                              SmimeGetCertCommand)) == -1) {
+    mutt_any_key_to_continue (_
+                              ("Error: unable to create OpenSSL subprocess!"));

     fclose (fperr);
     fclose (fpout);
     mutt_unlink (pk7out);
     fclose (fperr);
     fclose (fpout);
     mutt_unlink (pk7out);


@@ -1001,9 +965,8 @@ static char *smime_extract_certificate (char *infile)
   rewind (fpout);
   rewind (fperr);
   fflush (fperr);
   rewind (fpout);
   rewind (fperr);
   fflush (fperr);

-  empty =  (fgetc (fpout) == EOF);
-  if (empty)
-  {
+  empty = (fgetc (fpout) == EOF);
+  if (empty) {

     mutt_copy_stream (fperr, stdout);
     fclose (fpout);
     fclose (fperr);
     mutt_copy_stream (fperr, stdout);
     fclose (fpout);
     fclose (fperr);


@@ -1014,7 +977,7 @@ static char *smime_extract_certificate (char *infile)
   fclose (fpout);
   fclose (fperr);
 
   fclose (fpout);
   fclose (fperr);
 

-  return safe_strdup (certfile);
+  return str_dup (certfile);

 }
 
 static char *smime_extract_signer_certificate (char *infile)
 }
 
 static char *smime_extract_signer_certificate (char *infile)


@@ -1027,8 +990,7 @@ static char *smime_extract_signer_certificate (char *infile)
 
 
   mutt_mktemp (tmpfname);
 
 
   mutt_mktemp (tmpfname);

-  if ((fperr = safe_fopen (tmpfname, "w+")) == NULL)
-  {
+  if ((fperr = safe_fopen (tmpfname, "w+")) == NULL) {

     mutt_perror (tmpfname);
     return NULL;
   }
     mutt_perror (tmpfname);
     return NULL;
   }


@@ -1036,21 +998,20 @@ static char *smime_extract_signer_certificate (char *infile)
 
 
   mutt_mktemp (certfile);
 
 
   mutt_mktemp (certfile);

-  if ((fpout = safe_fopen (certfile, "w+")) == NULL)
-  {
+  if ((fpout = safe_fopen (certfile, "w+")) == NULL) {

     fclose (fperr);
     mutt_perror (certfile);
     return NULL;
   }
     fclose (fperr);
     mutt_perror (certfile);
     return NULL;
   }

-  
+

   /* Extract signer's certificate
    */
   /* Extract signer's certificate
    */

-  if ((thepid =  smime_invoke (NULL, NULL, NULL,
-                              -1, -1, fileno (fperr),
-                              infile, NULL, NULL, NULL, certfile, NULL,
-                              SmimeGetSignerCertCommand))== -1)
-  {
-    mutt_any_key_to_continue (_("Error: unable to create OpenSSL subprocess!"));
+  if ((thepid = smime_invoke (NULL, NULL, NULL,
+                              -1, -1, fileno (fperr),
+                              infile, NULL, NULL, NULL, certfile, NULL,
+                              SmimeGetSignerCertCommand)) == -1) {
+    mutt_any_key_to_continue (_
+                              ("Error: unable to create OpenSSL subprocess!"));

     fclose (fperr);
     fclose (fpout);
     mutt_unlink (pk7out);
     fclose (fperr);
     fclose (fpout);
     mutt_unlink (pk7out);


@@ -1064,9 +1025,8 @@ static char *smime_extract_signer_certificate (char *infile)
   rewind (fpout);
   rewind (fperr);
   fflush (fperr);
   rewind (fpout);
   rewind (fperr);
   fflush (fperr);

-  empty =  (fgetc (fpout) == EOF);
-  if (empty)
-  {
+  empty = (fgetc (fpout) == EOF);
+  if (empty) {

     mutt_endwin (NULL);
     mutt_copy_stream (fperr, stdout);
     mutt_any_key_to_continue (NULL);
     mutt_endwin (NULL);
     mutt_copy_stream (fperr, stdout);
     mutt_any_key_to_continue (NULL);


@@ -1079,7 +1039,7 @@ static char *smime_extract_signer_certificate (char *infile)
   fclose (fpout);
   fclose (fperr);
 
   fclose (fpout);
   fclose (fperr);
 

-  return safe_strdup (certfile);
+  return str_dup (certfile);

 }
 
 
 }
 
 


@@ -1090,20 +1050,18 @@ static char *smime_extract_signer_certificate (char *infile)
 void smime_invoke_import (char *infile, char *mailbox)
 {
   char tmpfname[_POSIX_PATH_MAX], *certfile = NULL, buf[STRING];
 void smime_invoke_import (char *infile, char *mailbox)
 {
   char tmpfname[_POSIX_PATH_MAX], *certfile = NULL, buf[STRING];

-  FILE *smimein=NULL, *fpout = NULL, *fperr = NULL;
-  pid_t thepid=-1;
+  FILE *smimein = NULL, *fpout = NULL, *fperr = NULL;
+  pid_t thepid = -1;

 
   mutt_mktemp (tmpfname);
 
   mutt_mktemp (tmpfname);

-  if ((fperr = safe_fopen (tmpfname, "w+")) == NULL)
-  {
+  if ((fperr = safe_fopen (tmpfname, "w+")) == NULL) {

     mutt_perror (tmpfname);
     return;
   }
   mutt_unlink (tmpfname);
 
   mutt_mktemp (tmpfname);
     mutt_perror (tmpfname);
     return;
   }
   mutt_unlink (tmpfname);
 
   mutt_mktemp (tmpfname);

-  if ((fpout = safe_fopen (tmpfname, "w+")) == NULL)
-  {
+  if ((fpout = safe_fopen (tmpfname, "w+")) == NULL) {

     fclose (fperr);
     mutt_perror (tmpfname);
     return;
     fclose (fperr);
     mutt_perror (tmpfname);
     return;


@@ -1116,26 +1074,24 @@ void smime_invoke_import (char *infile, char *mailbox)
     mutt_get_field ("Label for certificate:", buf, sizeof (buf), 0);
 
   mutt_endwin (NULL);
     mutt_get_field ("Label for certificate:", buf, sizeof (buf), 0);
 
   mutt_endwin (NULL);

-  if ((certfile = smime_extract_certificate(infile)))
-  {
+  if ((certfile = smime_extract_certificate (infile))) {

     mutt_endwin (NULL);
     mutt_endwin (NULL);

-  
-    if ((thepid =  smime_invoke (&smimein, NULL, NULL,
-                                -1, fileno(fpout), fileno(fperr),
-                                certfile, NULL, NULL, NULL, NULL, NULL,
-                                SmimeImportCertCommand))== -1)
-    {
+
+    if ((thepid = smime_invoke (&smimein, NULL, NULL,
+                                -1, fileno (fpout), fileno (fperr),
+                                certfile, NULL, NULL, NULL, NULL, NULL,
+                                SmimeImportCertCommand)) == -1) {

       mutt_message (_("Error: unable to create OpenSSL subprocess!"));
       return;
     }
     fputs (buf, smimein);
     fputc ('\n', smimein);
       mutt_message (_("Error: unable to create OpenSSL subprocess!"));
       return;
     }
     fputs (buf, smimein);
     fputc ('\n', smimein);

-    fclose(smimein);
+    fclose (smimein);

 
     mutt_wait_filter (thepid);
 
     mutt_wait_filter (thepid);

-  
+

     mutt_unlink (certfile);
     mutt_unlink (certfile);

-    FREE (&certfile);
+    mem_free (&certfile);

   }
 
   fflush (fpout);
   }
 
   fflush (fpout);


@@ -1153,62 +1109,56 @@ void smime_invoke_import (char *infile, char *mailbox)
 
 
 
 
 
 

-int smime_verify_sender(HEADER *h)
+int smime_verify_sender (HEADER * h)

 {
   char *mbox = NULL, *certfile, tempfname[_POSIX_PATH_MAX];
   FILE *fpout;
 {
   char *mbox = NULL, *certfile, tempfname[_POSIX_PATH_MAX];
   FILE *fpout;

-  int retval=1;
+  int retval = 1;

 
   mutt_mktemp (tempfname);
 
   mutt_mktemp (tempfname);

-  if (!(fpout = safe_fopen (tempfname, "w")))
-  {
+  if (!(fpout = safe_fopen (tempfname, "w"))) {

     mutt_perror (tempfname);
     return 1;
   }
 
     mutt_perror (tempfname);
     return 1;
   }
 

-  if(h->security & ENCRYPT)
+  if (h->security & ENCRYPT)

     mutt_copy_message (fpout, Context, h,
     mutt_copy_message (fpout, Context, h,

-                      M_CM_DECODE_CRYPT & M_CM_DECODE_SMIME,
-                      CH_MIME|CH_WEED|CH_NONEWLINE);
+                       M_CM_DECODE_CRYPT & M_CM_DECODE_SMIME,
+                       CH_MIME | CH_WEED | CH_NONEWLINE);

   else
     mutt_copy_message (fpout, Context, h, 0, 0);
 
   else
     mutt_copy_message (fpout, Context, h, 0, 0);
 

-  fflush(fpout);
+  fflush (fpout);

   fclose (fpout);
 
   fclose (fpout);
 

-  if (h->env->from)
-  {
-    h->env->from = mutt_expand_aliases (h->env->from); 
-    mbox = h->env->from->mailbox; 
+  if (h->env->from) {
+    h->env->from = mutt_expand_aliases (h->env->from);
+    mbox = h->env->from->mailbox;

   }
   }

-  else if (h->env->sender)
-  {
-    h->env->sender = mutt_expand_aliases (h->env->sender); 
-    mbox = h->env->sender->mailbox; 
+  else if (h->env->sender) {
+    h->env->sender = mutt_expand_aliases (h->env->sender);
+    mbox = h->env->sender->mailbox;

   }
 
   }
 

-  if (mbox)
-  {
-    if ((certfile = smime_extract_signer_certificate(tempfname)))
-    {
-      mutt_unlink(tempfname);
-      if (smime_handle_cert_email (certfile, mbox, 0, NULL, NULL))
-      {
-       if(isendwin())
-         mutt_any_key_to_continue(NULL);
+  if (mbox) {
+    if ((certfile = smime_extract_signer_certificate (tempfname))) {
+      mutt_unlink (tempfname);
+      if (smime_handle_cert_email (certfile, mbox, 0, NULL, NULL)) {
+        if (isendwin ())
+          mutt_any_key_to_continue (NULL);

       }
       else
       }
       else

-       retval = 0;
-      mutt_unlink(certfile);
-      FREE (&certfile);
+        retval = 0;
+      mutt_unlink (certfile);
+      mem_free (&certfile);

     }
     }

-  else 
-       mutt_any_key_to_continue(_("no certfile"));
+    else
+      mutt_any_key_to_continue (_("no certfile"));

   }
   }

-  else 
-       mutt_any_key_to_continue(_("no mbox"));
+  else
+    mutt_any_key_to_continue (_("no mbox"));

 
 

-  mutt_unlink(tempfname);
+  mutt_unlink (tempfname);

   return retval;
 }
 
   return retval;
 }
 


@@ -1228,32 +1178,33 @@ int smime_verify_sender(HEADER *h)
 
 
 static
 
 
 static

-pid_t smime_invoke_encrypt (FILE **smimein, FILE **smimeout, FILE **smimeerr,
-                           int smimeinfd, int smimeoutfd, int smimeerrfd,
-                           const char *fname, const char *uids)
+pid_t smime_invoke_encrypt (FILE ** smimein, FILE ** smimeout,
+                            FILE ** smimeerr, int smimeinfd, int smimeoutfd,
+                            int smimeerrfd, const char *fname,
+                            const char *uids)

 {
   return smime_invoke (smimein, smimeout, smimeerr,
 {
   return smime_invoke (smimein, smimeout, smimeerr,

-                      smimeinfd, smimeoutfd, smimeerrfd,
-                      fname, NULL, SmimeCryptAlg, NULL, uids, NULL,
-                      SmimeEncryptCommand);
+                       smimeinfd, smimeoutfd, smimeerrfd,
+                       fname, NULL, SmimeCryptAlg, NULL, uids, NULL,
+                       SmimeEncryptCommand);

 }
 
 
 static
 }
 
 
 static

-pid_t smime_invoke_sign (FILE **smimein, FILE **smimeout, FILE **smimeerr,
-                        int smimeinfd, int smimeoutfd, int smimeerrfd, 
-                        const char *fname)
+pid_t smime_invoke_sign (FILE ** smimein, FILE ** smimeout, FILE ** smimeerr,
+                         int smimeinfd, int smimeoutfd, int smimeerrfd,
+                         const char *fname)

 {
   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,
 {
   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,

-                      smimeerrfd, fname, NULL, NULL, SmimeKeyToUse,
-                      SmimeCertToUse, SmimeIntermediateToUse,
-                      SmimeSignCommand);
+                       smimeerrfd, fname, NULL, NULL, SmimeKeyToUse,
+                       SmimeCertToUse, SmimeIntermediateToUse,
+                       SmimeSignCommand);

 }
 
 
 
 
 }
 
 
 
 

-BODY *smime_build_smime_entity (BODY *a, char *certlist)
+BODY *smime_build_smime_entity (BODY * a, char *certlist)

 {
   char buf[LONG_STRING], certfile[LONG_STRING];
   char tempfile[_POSIX_PATH_MAX], smimeerrfile[_POSIX_PATH_MAX];
 {
   char buf[LONG_STRING], certfile[LONG_STRING];
   char tempfile[_POSIX_PATH_MAX], smimeerrfile[_POSIX_PATH_MAX];


@@ -1263,27 +1214,24 @@ BODY *smime_build_smime_entity (BODY *a, char *certlist)
   BODY *t;
   int err = 0, empty;
   pid_t thepid;
   BODY *t;
   int err = 0, empty;
   pid_t thepid;

-  
+

   mutt_mktemp (tempfile);
   mutt_mktemp (tempfile);

-  if ((fpout = safe_fopen (tempfile, "w+")) == NULL)
-  {
+  if ((fpout = safe_fopen (tempfile, "w+")) == NULL) {

     mutt_perror (tempfile);
     return (NULL);
   }
 
   mutt_mktemp (smimeerrfile);
     mutt_perror (tempfile);
     return (NULL);
   }
 
   mutt_mktemp (smimeerrfile);

-  if ((smimeerr = safe_fopen (smimeerrfile, "w+")) == NULL)
-  {
+  if ((smimeerr = safe_fopen (smimeerrfile, "w+")) == NULL) {

     mutt_perror (smimeerrfile);
     fclose (fpout);
     mutt_unlink (tempfile);
     return NULL;
   }
   mutt_unlink (smimeerrfile);
     mutt_perror (smimeerrfile);
     fclose (fpout);
     mutt_unlink (tempfile);
     return NULL;
   }
   mutt_unlink (smimeerrfile);

-  
+

   mutt_mktemp (smimeinfile);
   mutt_mktemp (smimeinfile);

-  if ((fptmp = safe_fopen (smimeinfile, "w+")) == NULL)
-  {
+  if ((fptmp = safe_fopen (smimeinfile, "w+")) == NULL) {

     mutt_perror (smimeinfile);
     mutt_unlink (tempfile);
     fclose (fpout);
     mutt_perror (smimeinfile);
     mutt_unlink (tempfile);
     fclose (fpout);


@@ -1292,14 +1240,15 @@ BODY *smime_build_smime_entity (BODY *a, char *certlist)
   }
 
   *certfile = '\0';
   }
 
   *certfile = '\0';

-  while (1)
-  {
-    int off = mutt_strlen (certfile);
+  while (1) {
+    int off = str_len (certfile);
+

     while (*++cert_end && *cert_end != '\n');
     while (*++cert_end && *cert_end != '\n');

-    if (!*cert_end) break;
+    if (!*cert_end)
+      break;

     *cert_end = '\0';
     *cert_end = '\0';

-    snprintf (certfile+off, sizeof (certfile)-off, " %s/%s",
-             NONULL(SmimeCertificates), cert_start);
+    snprintf (certfile + off, sizeof (certfile) - off, " %s/%s",
+              NONULL (SmimeCertificates), cert_start);

     *cert_end = '\n';
     cert_start = cert_end;
     cert_start++;
     *cert_end = '\n';
     cert_start = cert_end;
     cert_start++;


@@ -1313,9 +1262,8 @@ BODY *smime_build_smime_entity (BODY *a, char *certlist)
 
   if ((thepid =
        smime_invoke_encrypt (&smimein, NULL, NULL, -1,
 
   if ((thepid =
        smime_invoke_encrypt (&smimein, NULL, NULL, -1,

-                            fileno (fpout), fileno (smimeerr),
-                            smimeinfile, certfile)) == -1)
-  {
+                             fileno (fpout), fileno (smimeerr),
+                             smimeinfile, certfile)) == -1) {

     fclose (smimeerr);
     mutt_unlink (smimeinfile);
     mutt_unlink (certfile);
     fclose (smimeerr);
     mutt_unlink (smimeinfile);
     mutt_unlink (certfile);


@@ -1323,20 +1271,19 @@ BODY *smime_build_smime_entity (BODY *a, char *certlist)
   }
 
   fclose (smimein);
   }
 
   fclose (smimein);

-  
+

   mutt_wait_filter (thepid);
   mutt_unlink (smimeinfile);
   mutt_unlink (certfile);
   mutt_wait_filter (thepid);
   mutt_unlink (smimeinfile);
   mutt_unlink (certfile);

-  
+

   fflush (fpout);
   rewind (fpout);
   empty = (fgetc (fpout) == EOF);
   fclose (fpout);
   fflush (fpout);
   rewind (fpout);
   empty = (fgetc (fpout) == EOF);
   fclose (fpout);

- 
+

   fflush (smimeerr);
   rewind (smimeerr);
   fflush (smimeerr);
   rewind (smimeerr);

-  while (fgets (buf, sizeof (buf) - 1, smimeerr) != NULL)
-  {
+  while (fgets (buf, sizeof (buf) - 1, smimeerr) != NULL) {

     err = 1;
     fputs (buf, stdout);
   }
     err = 1;
     fputs (buf, stdout);
   }


@@ -1346,35 +1293,36 @@ BODY *smime_build_smime_entity (BODY *a, char *certlist)
   if (err)
     mutt_any_key_to_continue (NULL);
 
   if (err)
     mutt_any_key_to_continue (NULL);
 

-  if (empty)
-  {
+  if (empty) {

     /* fatal error while trying to encrypt message */
     /* fatal error while trying to encrypt message */

-    if (!err) mutt_any_key_to_continue _("No output from OpenSSL..");
+    if (!err)
+      mutt_any_key_to_continue _("No output from OpenSSL..");
+

     mutt_unlink (tempfile);
     return (NULL);
   }
 
   t = mutt_new_body ();
   t->type = TYPEAPPLICATION;
     mutt_unlink (tempfile);
     return (NULL);
   }
 
   t = mutt_new_body ();
   t->type = TYPEAPPLICATION;

-  t->subtype = safe_strdup ("x-pkcs7-mime");
+  t->subtype = str_dup ("x-pkcs7-mime");

   mutt_set_parameter ("name", "smime.p7m", &t->parameter);
   mutt_set_parameter ("smime-type", "enveloped-data", &t->parameter);
   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->encoding = ENCBASE64;      /* The output of OpenSSL SHOULD be binary */

   t->use_disp = 1;
   t->disposition = DISPATTACH;
   t->use_disp = 1;
   t->disposition = DISPATTACH;

-  t->d_filename = safe_strdup ("smime.p7m");
-  t->filename = safe_strdup (tempfile);
-  t->unlink = 1; /*delete after sending the message */
-  t->parts=0;
-  t->next=0;
-  
+  t->d_filename = str_dup ("smime.p7m");
+  t->filename = str_dup (tempfile);
+  t->unlink = 1;                /*delete after sending the message */
+  t->parts = 0;
+  t->next = 0;
+

   return (t);
 }
 
 
 
 
   return (t);
 }
 
 
 
 

-BODY *smime_sign_message (BODY *a )
+BODY *smime_sign_message (BODY * a)

 {
   BODY *t;
   char buffer[LONG_STRING];
 {
   BODY *t;
   char buffer[LONG_STRING];


@@ -1383,54 +1331,52 @@ BODY *smime_sign_message (BODY *a )
   int err = 0;
   int empty = 0;
   pid_t thepid;
   int err = 0;
   int empty = 0;
   pid_t thepid;

-  char *intermediates = smime_get_field_from_db(NULL, SmimeDefaultKey, 1, 1);
+  char *intermediates = smime_get_field_from_db (NULL, SmimeDefaultKey, 1, 1);

 
 

-  if (!intermediates)
-  {
-    mutt_message(_("Warning: Intermediate certificate not found."));
-    intermediates = SmimeDefaultKey; /* so openssl won't complain in any case */
+  if (!intermediates) {
+    mutt_message (_("Warning: Intermediate certificate not found."));
+    intermediates = SmimeDefaultKey;    /* so openssl won't complain in any case */

   }
 
   }
 

-  convert_to_7bit (a); /* Signed data _must_ be in 7-bit format. */
+  convert_to_7bit (a);          /* Signed data _must_ be in 7-bit format. */

 
   mutt_mktemp (filetosign);
 
   mutt_mktemp (filetosign);

-  if ((sfp = safe_fopen (filetosign, "w+")) == NULL)
-  {
+  if ((sfp = safe_fopen (filetosign, "w+")) == NULL) {

     mutt_perror (filetosign);
     return NULL;
   }
 
   mutt_mktemp (signedfile);
     mutt_perror (filetosign);
     return NULL;
   }
 
   mutt_mktemp (signedfile);

-  if ((smimeout = safe_fopen (signedfile, "w+")) == NULL)
-  {
+  if ((smimeout = safe_fopen (signedfile, "w+")) == NULL) {

     mutt_perror (signedfile);
     fclose (sfp);
     mutt_unlink (filetosign);
     return NULL;
   }
     mutt_perror (signedfile);
     fclose (sfp);
     mutt_unlink (filetosign);
     return NULL;
   }

-  
+

   mutt_write_mime_header (a, sfp);
   fputc ('\n', sfp);
   mutt_write_mime_body (a, sfp);
   fclose (sfp);
 
   mutt_write_mime_header (a, sfp);
   fputc ('\n', sfp);
   mutt_write_mime_body (a, sfp);
   fclose (sfp);
 

-  

 
 

-  snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s", 
-          NONULL(SmimeKeys), SmimeDefaultKey);
+
+  snprintf (SmimeKeyToUse, sizeof (SmimeKeyToUse), "%s/%s",
+            NONULL (SmimeKeys), SmimeDefaultKey);

 
   snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",
 
   snprintf (SmimeCertToUse, sizeof (SmimeCertToUse), "%s/%s",

-          NONULL(SmimeCertificates), SmimeDefaultKey);
-  
+            NONULL (SmimeCertificates), SmimeDefaultKey);
+

   snprintf (SmimeIntermediateToUse, sizeof (SmimeIntermediateToUse), "%s/%s",
   snprintf (SmimeIntermediateToUse, sizeof (SmimeIntermediateToUse), "%s/%s",

-          NONULL(SmimeCertificates), intermediates);
-  
+            NONULL (SmimeCertificates), intermediates);
+

 
 
   if ((thepid = smime_invoke_sign (&smimein, NULL, &smimeerr,
 
 
   if ((thepid = smime_invoke_sign (&smimein, NULL, &smimeerr,

-                                -1, fileno (smimeout), -1, filetosign)) == -1)
-  {
-    mutt_perror _("Can't open OpenSSL subprocess!");
+                                   -1, fileno (smimeout), -1,
+                                   filetosign)) == -1) {
+    mutt_perror (_("Can't open OpenSSL subprocess!"));
+

     fclose (smimeout);
     mutt_unlink (signedfile);
     mutt_unlink (filetosign);
     fclose (smimeout);
     mutt_unlink (signedfile);
     mutt_unlink (filetosign);


@@ -1439,7 +1385,7 @@ BODY *smime_sign_message (BODY *a )
   fputs (SmimePass, smimein);
   fputc ('\n', smimein);
   fclose (smimein);
   fputs (SmimePass, smimein);
   fputc ('\n', smimein);
   fclose (smimein);

-  
+

 
   mutt_wait_filter (thepid);
 
 
   mutt_wait_filter (thepid);
 


@@ -1447,8 +1393,7 @@ BODY *smime_sign_message (BODY *a )
   err = 0;
   fflush (smimeerr);
   rewind (smimeerr);
   err = 0;
   fflush (smimeerr);
   rewind (smimeerr);

-  while (fgets (buffer, sizeof (buffer) - 1, smimeerr) != NULL)
-  {
+  while (fgets (buffer, sizeof (buffer) - 1, smimeerr) != NULL) {

     err = 1;
     fputs (buffer, stdout);
   }
     err = 1;
     fputs (buffer, stdout);
   }


@@ -1461,21 +1406,21 @@ BODY *smime_sign_message (BODY *a )
   fclose (smimeout);
 
   mutt_unlink (filetosign);
   fclose (smimeout);
 
   mutt_unlink (filetosign);

-  
+

 
   if (err)
     mutt_any_key_to_continue (NULL);
 
 
   if (err)
     mutt_any_key_to_continue (NULL);
 

-  if (empty)
-  {
+  if (empty) {

     mutt_any_key_to_continue _("No output from OpenSSL...");
     mutt_any_key_to_continue _("No output from OpenSSL...");

+

     mutt_unlink (signedfile);
     mutt_unlink (signedfile);

-    return (NULL); /* fatal error while signing */
+    return (NULL);              /* fatal error while signing */

   }
 
   t = mutt_new_body ();
   t->type = TYPEMULTIPART;
   }
 
   t = mutt_new_body ();
   t->type = TYPEMULTIPART;

-  t->subtype = safe_strdup ("signed");
+  t->subtype = str_dup ("signed");

   t->encoding = ENC7BIT;
   t->use_disp = 0;
   t->disposition = DISPINLINE;
   t->encoding = ENC7BIT;
   t->use_disp = 0;
   t->disposition = DISPINLINE;


@@ -1484,7 +1429,7 @@ BODY *smime_sign_message (BODY *a )
   /* check if this can be extracted from private key somehow.... */
   mutt_set_parameter ("micalg", "sha1", &t->parameter);
   mutt_set_parameter ("protocol", "application/x-pkcs7-signature",
   /* check if this can be extracted from private key somehow.... */
   mutt_set_parameter ("micalg", "sha1", &t->parameter);
   mutt_set_parameter ("protocol", "application/x-pkcs7-signature",

-                    &t->parameter);
+                      &t->parameter);

 
   t->parts = a;
   a = t;
 
   t->parts = a;
   a = t;


@@ -1492,13 +1437,13 @@ BODY *smime_sign_message (BODY *a )
   t->parts->next = mutt_new_body ();
   t = t->parts->next;
   t->type = TYPEAPPLICATION;
   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 = str_dup ("x-pkcs7-signature");
+  t->filename = str_dup (signedfile);
+  t->d_filename = str_dup ("smime.p7s");

   t->use_disp = 1;
   t->disposition = DISPATTACH;
   t->encoding = ENCBASE64;
   t->use_disp = 1;
   t->disposition = DISPATTACH;
   t->encoding = ENCBASE64;

-  t->unlink = 1; /* ok to remove this file after sending. */
+  t->unlink = 1;                /* ok to remove this file after sending. */

 
   return (a);
 
 
   return (a);
 


@@ -1519,32 +1464,34 @@ BODY *smime_sign_message (BODY *a )
 
 
 static
 
 
 static

-pid_t smime_invoke_verify (FILE **smimein, FILE **smimeout, FILE **smimeerr,
-                          int smimeinfd, int smimeoutfd, int smimeerrfd, 
-                          const char *fname, const char *sig_fname, int opaque)
+pid_t smime_invoke_verify (FILE ** smimein, FILE ** smimeout,
+                           FILE ** smimeerr, int smimeinfd, int smimeoutfd,
+                           int smimeerrfd, const char *fname,
+                           const char *sig_fname, int opaque)

 {
   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,
 {
   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,

-                      smimeerrfd, fname, sig_fname, NULL, NULL, NULL, NULL,
-                      (opaque ? SmimeVerifyOpaqueCommand : SmimeVerifyCommand));
+                       smimeerrfd, fname, sig_fname, NULL, NULL, NULL, NULL,
+                       (opaque ? SmimeVerifyOpaqueCommand :
+                        SmimeVerifyCommand));

 }
 
 
 static
 }
 
 
 static

-pid_t smime_invoke_decrypt (FILE **smimein, FILE **smimeout, FILE **smimeerr,
-                           int smimeinfd, int smimeoutfd, int smimeerrfd, 
-                           const char *fname)
+pid_t smime_invoke_decrypt (FILE ** smimein, FILE ** smimeout,
+                            FILE ** smimeerr, int smimeinfd, int smimeoutfd,
+                            int smimeerrfd, const char *fname)

 {
   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,
 {
   return smime_invoke (smimein, smimeout, smimeerr, smimeinfd, smimeoutfd,

-                      smimeerrfd, fname, NULL, NULL, SmimeKeyToUse,
-                      SmimeCertToUse, NULL, SmimeDecryptCommand);
+                       smimeerrfd, fname, NULL, NULL, SmimeKeyToUse,
+                       SmimeCertToUse, NULL, SmimeDecryptCommand);

 }
 
 
 
 }
 
 
 

-int smime_verify_one (BODY *sigbdy, STATE *s, const char *tempfile)
+int smime_verify_one (BODY * sigbdy, STATE * s, const char *tempfile)

 {
   char signedfile[_POSIX_PATH_MAX], smimeerrfile[_POSIX_PATH_MAX];
 {
   char signedfile[_POSIX_PATH_MAX], smimeerrfile[_POSIX_PATH_MAX];

-  FILE *fp=NULL, *smimeout=NULL, *smimeerr=NULL;
+  FILE *fp = NULL, *smimeout = NULL, *smimeerr = NULL;

   pid_t thepid;
   int badsig = -1;
 
   pid_t thepid;
   int badsig = -1;
 


@@ -1555,11 +1502,10 @@ int smime_verify_one (BODY *sigbdy, STATE *s, const char *tempfile)
 
 
   snprintf (signedfile, sizeof (signedfile), "%s.sig", tempfile);
 
 
   snprintf (signedfile, sizeof (signedfile), "%s.sig", tempfile);

-  
+

   /* decode to a tempfile, saving the original destination */
   fp = s->fpout;
   /* decode to a tempfile, saving the original destination */
   fp = s->fpout;

-  if ((s->fpout = safe_fopen (signedfile, "w")) == NULL)
-  {
+  if ((s->fpout = safe_fopen (signedfile, "w")) == NULL) {

     mutt_perror (signedfile);
     return -1;
   }
     mutt_perror (signedfile);
     return -1;
   }


@@ -1577,7 +1523,7 @@ int smime_verify_one (BODY *sigbdy, STATE *s, const char *tempfile)
 
   mutt_decode_attachment (sigbdy, s);
 
 
   mutt_decode_attachment (sigbdy, s);
 

-  sigbdy->length = ftell (s->fpout);
+  sigbdy->length = ftello (s->fpout);

   sigbdy->offset = 0;
   fclose (s->fpout);
 
   sigbdy->offset = 0;
   fclose (s->fpout);
 


@@ -1588,63 +1534,60 @@ int smime_verify_one (BODY *sigbdy, STATE *s, const char *tempfile)
 
   /* restore the prefix */
   s->prefix = savePrefix;
 
   /* restore the prefix */
   s->prefix = savePrefix;

-  
+

   sigbdy->type = origType;
 
   sigbdy->type = origType;
 

-  
+

   mutt_mktemp (smimeerrfile);
   mutt_mktemp (smimeerrfile);

-  if (!(smimeerr = safe_fopen (smimeerrfile, "w+")))
-  {
+  if (!(smimeerr = safe_fopen (smimeerrfile, "w+"))) {

     mutt_perror (smimeerrfile);
     mutt_unlink (signedfile);
     return -1;
   }
     mutt_perror (smimeerrfile);
     mutt_unlink (signedfile);
     return -1;
   }

-  
+

   crypt_current_time (s, "OpenSSL");
   crypt_current_time (s, "OpenSSL");

-  
-  if ((thepid = smime_invoke_verify (NULL, &smimeout, NULL, 
-                                  -1, -1, fileno (smimeerr),
-                                  tempfile, signedfile, 0)) != -1)
-  {
+
+  if ((thepid = smime_invoke_verify (NULL, &smimeout, NULL,
+                                     -1, -1, fileno (smimeerr),
+                                     tempfile, signedfile, 0)) != -1) {

     fflush (smimeout);
     fclose (smimeout);
     fflush (smimeout);
     fclose (smimeout);

-      
+

     if (mutt_wait_filter (thepid))
       badsig = -1;
     if (mutt_wait_filter (thepid))
       badsig = -1;

-    else
-    {
+    else {

       char *line = NULL;
       int lineno = 0;
       size_t linelen;
       char *line = NULL;
       int lineno = 0;
       size_t linelen;

-      
+

       fflush (smimeerr);
       rewind (smimeerr);
       fflush (smimeerr);
       rewind (smimeerr);

-      
+

       line = mutt_read_line (line, &linelen, smimeerr, &lineno);
       line = mutt_read_line (line, &linelen, smimeerr, &lineno);

-      if (linelen && !mutt_strcasecmp (line, "verification successful"))
-       badsig = 0;
+      if (linelen && !str_casecmp (line, "verification successful"))
+        badsig = 0;

 
 

-      FREE (&line);
+      mem_free (&line);

     }
   }
     }
   }

-  
+

   fflush (smimeerr);
   rewind (smimeerr);
   mutt_copy_stream (smimeerr, s->fpout);
   fclose (smimeerr);
   fflush (smimeerr);
   rewind (smimeerr);
   mutt_copy_stream (smimeerr, s->fpout);
   fclose (smimeerr);

-    
+

   state_attach_puts (_("[-- End of OpenSSL output --]\n\n"), s);
   state_attach_puts (_("[-- End of OpenSSL output --]\n\n"), s);

-  
+

   mutt_unlink (signedfile);
   mutt_unlink (smimeerrfile);
 
   sigbdy->length = tmplength;
   sigbdy->offset = tmpoffset;
   mutt_unlink (signedfile);
   mutt_unlink (smimeerrfile);
 
   sigbdy->length = tmplength;
   sigbdy->offset = tmpoffset;

-  
+

   /* restore the original source stream */
   fclose (s->fpin);
   s->fpin = fp;
   /* restore the original source stream */
   fclose (s->fpin);
   s->fpin = fp;

-  
+

 
   return badsig;
 }
 
   return badsig;
 }


@@ -1658,81 +1601,85 @@ int smime_verify_one (BODY *sigbdy, STATE *s, const char *tempfile)
   or an encrypted message.
 */
 
   or an encrypted message.
 */
 

-static BODY *smime_handle_entity (BODY *m, STATE *s, FILE *outFile)
+static BODY *smime_handle_entity (BODY * m, STATE * s, FILE * outFile)

 {
 {

-  int len=0;
+  int len = 0;

   int c;
   long last_pos;
   char buf[HUGE_STRING];
   char outfile[_POSIX_PATH_MAX], errfile[_POSIX_PATH_MAX];
   char tmpfname[_POSIX_PATH_MAX];
   char tmptmpfname[_POSIX_PATH_MAX];
   int c;
   long last_pos;
   char buf[HUGE_STRING];
   char outfile[_POSIX_PATH_MAX], errfile[_POSIX_PATH_MAX];
   char tmpfname[_POSIX_PATH_MAX];
   char tmptmpfname[_POSIX_PATH_MAX];

-  FILE *smimeout = NULL, *smimein=NULL, *smimeerr=NULL;
-  FILE *tmpfp=NULL, *tmpfp_buffer=NULL, *fpout=NULL;
+  FILE *smimeout = NULL, *smimein = NULL, *smimeerr = NULL;
+  FILE *tmpfp = NULL, *tmpfp_buffer = NULL, *fpout = NULL;

   struct stat info;
   struct stat info;

-  BODY *p=NULL;
-  pid_t thepid=-1;
+  BODY *p = NULL;
+  pid_t thepid = -1;

   unsigned int type = mutt_is_application_smime (m);
 
   unsigned int type = mutt_is_application_smime (m);
 

-  if (!(type & APPLICATION_SMIME)) return NULL;
+  if (!(type & APPLICATION_SMIME))
+    return NULL;

 
   mutt_mktemp (outfile);
 
   mutt_mktemp (outfile);

-  if ((smimeout = safe_fopen (outfile, "w+")) == NULL)
-  {
+  if ((smimeout = safe_fopen (outfile, "w+")) == NULL) {

     mutt_perror (outfile);
     return NULL;
   }
     mutt_perror (outfile);
     return NULL;
   }

-  
+

   mutt_mktemp (errfile);
   mutt_mktemp (errfile);

-  if ((smimeerr = safe_fopen (errfile, "w+")) == NULL)
-  {
+  if ((smimeerr = safe_fopen (errfile, "w+")) == NULL) {

     mutt_perror (errfile);
     mutt_perror (errfile);

-    fclose (smimeout); smimeout = NULL;
+    fclose (smimeout);
+    smimeout = NULL;

     return NULL;
   }
   mutt_unlink (errfile);
 
     return NULL;
   }
   mutt_unlink (errfile);
 

-  
+

   mutt_mktemp (tmpfname);
   mutt_mktemp (tmpfname);

-  if ((tmpfp = safe_fopen (tmpfname, "w+")) == NULL)
-  {
+  if ((tmpfp = safe_fopen (tmpfname, "w+")) == NULL) {

     mutt_perror (tmpfname);
     mutt_perror (tmpfname);

-    fclose (smimeout); smimeout = NULL;
-    fclose (smimeerr); smimeerr = NULL;
+    fclose (smimeout);
+    smimeout = NULL;
+    fclose (smimeerr);
+    smimeerr = NULL;

     return NULL;
   }
 
     return NULL;
   }
 

-  fseek (s->fpin, m->offset, 0);
+  fseeko (s->fpin, m->offset, 0);

   last_pos = m->offset;
 
   last_pos = m->offset;
 

-  mutt_copy_bytes (s->fpin, tmpfp,  m->length);
+  mutt_copy_bytes (s->fpin, tmpfp, m->length);

 
   fflush (tmpfp);
   fclose (tmpfp);
 
   if ((type & ENCRYPT) &&
       (thepid = smime_invoke_decrypt (&smimein, NULL, NULL, -1,
 
   fflush (tmpfp);
   fclose (tmpfp);
 
   if ((type & ENCRYPT) &&
       (thepid = smime_invoke_decrypt (&smimein, NULL, NULL, -1,

-                                     fileno (smimeout),  fileno (smimeerr), tmpfname)) == -1)
-  {
-    fclose (smimeout); smimeout = NULL;
+                                      fileno (smimeout), fileno (smimeerr),
+                                      tmpfname)) == -1) {
+    fclose (smimeout);
+    smimeout = NULL;

     mutt_unlink (tmpfname);
     mutt_unlink (tmpfname);

-    state_attach_puts (_("[-- Error: unable to create OpenSSL subprocess! --]\n"), s);
+    if (s->flags & M_DISPLAY)
+      state_attach_puts (_("[-- Error: unable to create OpenSSL subprocess! --]\n"), s);

     return NULL;
   }
   else if ((type & SIGNOPAQUE) &&
     return NULL;
   }
   else if ((type & SIGNOPAQUE) &&

-          (thepid = smime_invoke_verify (&smimein, NULL, NULL, -1,
-                                         fileno (smimeout), fileno (smimeerr), NULL,
-                                         tmpfname, SIGNOPAQUE)) == -1)
-  {
-    fclose (smimeout); smimeout = NULL;
+           (thepid = smime_invoke_verify (&smimein, NULL, NULL, -1,
+                                          fileno (smimeout),
+                                          fileno (smimeerr), NULL, tmpfname,
+                                          SIGNOPAQUE)) == -1) {
+    fclose (smimeout);
+    smimeout = NULL;

     mutt_unlink (tmpfname);
     mutt_unlink (tmpfname);

-    state_attach_puts (_("[-- Error: unable to create OpenSSL subprocess! --]\n"), s);
+    if (s->flags & M_DISPLAY)
+      state_attach_puts (_("[-- Error: unable to create OpenSSL subprocess! --]\n"), s);

     return NULL;
   }
 
     return NULL;
   }
 

-  
-  if (type & ENCRYPT)
-  {
+
+  if (type & ENCRYPT) {

     if (!smime_valid_passphrase ())
       smime_void_passphrase ();
     fputs (SmimePass, smimein);
     if (!smime_valid_passphrase ())
       smime_void_passphrase ();
     fputs (SmimePass, smimein);


@@ -1740,114 +1687,104 @@ static BODY *smime_handle_entity (BODY *m, STATE *s, FILE *outFile)
   }
 
   fclose (smimein);
   }
 
   fclose (smimein);

-       
+

   mutt_wait_filter (thepid);
   mutt_unlink (tmpfname);
   mutt_wait_filter (thepid);
   mutt_unlink (tmpfname);

-  

 
 

-  if (s->flags & M_DISPLAY)
-  {
+
+  if (s->flags & M_DISPLAY) {

     rewind (smimeerr);
     rewind (smimeerr);

-    
-    if ((c = fgetc (smimeerr)) != EOF)
-    {
+
+    if ((c = fgetc (smimeerr)) != EOF) {

       ungetc (c, smimeerr);
       ungetc (c, smimeerr);

-      
+

       crypt_current_time (s, "OpenSSL");
       mutt_copy_stream (smimeerr, s->fpout);
       state_attach_puts (_("[-- End of OpenSSL output --]\n\n"), s);
     }
       crypt_current_time (s, "OpenSSL");
       mutt_copy_stream (smimeerr, s->fpout);
       state_attach_puts (_("[-- End of OpenSSL output --]\n\n"), s);
     }

-    
+

     if (type & ENCRYPT)
       state_attach_puts (_("[-- The following data is S/MIME"
                            " encrypted --]\n"), s);
     else
     if (type & ENCRYPT)
       state_attach_puts (_("[-- The following data is S/MIME"
                            " encrypted --]\n"), s);
     else

-      state_attach_puts (_("[-- The following data is S/MIME signed --]\n"), s);
+      state_attach_puts (_("[-- The following data is S/MIME signed --]\n"),
+                         s);

   }
 
   }
 

-  if (smimeout)
-  {
+  if (smimeout) {

     fflush (smimeout);
     rewind (smimeout);
     fflush (smimeout);
     rewind (smimeout);

-    
-    if (outFile) fpout = outFile;
-    else
-    {
+
+    if (outFile)
+      fpout = outFile;
+    else {

       mutt_mktemp (tmptmpfname);
       mutt_mktemp (tmptmpfname);

-      if ((fpout = safe_fopen (tmptmpfname, "w+")) == NULL)
-      {
-       mutt_perror(tmptmpfname);
-       fclose (smimeout); smimeout = NULL;
-       return NULL;
+      if ((fpout = safe_fopen (tmptmpfname, "w+")) == NULL) {
+        mutt_perror (tmptmpfname);
+        fclose (smimeout);
+        smimeout = NULL;
+        return NULL;

       }
     }
       }
     }

-    while (fgets (buf, sizeof (buf) - 1, smimeout) != NULL)
-    {
-      len = mutt_strlen (buf);
-      if (len > 1 && buf[len - 2] == '\r')
-      {
-       buf[len-2] = '\n';
-       buf[len-1] = '\0';
+    while (fgets (buf, sizeof (buf) - 1, smimeout) != NULL) {
+      len = str_len (buf);
+      if (len > 1 && buf[len - 2] == '\r') {
+        buf[len - 2] = '\n';
+        buf[len - 1] = '\0';

       }
       fputs (buf, fpout);
     }
     fflush (fpout);
       }
       fputs (buf, fpout);
     }
     fflush (fpout);

-    rewind (fpout); 
+    rewind (fpout);

 
 
 
 

-    if ((p = mutt_read_mime_header (fpout, 0)) != NULL)
-    {
+    if ((p = mutt_read_mime_header (fpout, 0)) != NULL) {

       fstat (fileno (fpout), &info);
       p->length = info.st_size - p->offset;
       fstat (fileno (fpout), &info);
       p->length = info.st_size - p->offset;

-         
+

       mutt_parse_part (fpout, p);
       mutt_parse_part (fpout, p);

-      if (s->fpout)
-      {
-       rewind (fpout);
-       tmpfp_buffer = s->fpin;
-       s->fpin = fpout;
-       mutt_body_handler (p, s);
-       s->fpin = tmpfp_buffer;
+      if (s->fpout) {
+        rewind (fpout);
+        tmpfp_buffer = s->fpin;
+        s->fpin = fpout;
+        mutt_body_handler (p, s);
+        s->fpin = tmpfp_buffer;

       }
       }

-      
+

     }
     fclose (smimeout);
     smimeout = NULL;
     mutt_unlink (outfile);
 
     }
     fclose (smimeout);
     smimeout = NULL;
     mutt_unlink (outfile);
 

-    if (!outFile)
-    {
+    if (!outFile) {

       fclose (fpout);
       mutt_unlink (tmptmpfname);
     }
     fpout = NULL;
   }
 
       fclose (fpout);
       mutt_unlink (tmptmpfname);
     }
     fpout = NULL;
   }
 

-  if (s->flags & M_DISPLAY)
-  {
+  if (s->flags & M_DISPLAY) {

     if (type & ENCRYPT)
       state_attach_puts (_("\n[-- End of S/MIME encrypted data. --]\n"), s);
     else
       state_attach_puts (_("\n[-- End of S/MIME signed data. --]\n"), s);
   }
 
     if (type & ENCRYPT)
       state_attach_puts (_("\n[-- End of S/MIME encrypted data. --]\n"), s);
     else
       state_attach_puts (_("\n[-- End of S/MIME signed data. --]\n"), s);
   }
 

-  if (type & SIGNOPAQUE)
-  {
+  if (type & SIGNOPAQUE) {

     char *line = NULL;
     int lineno = 0;
     size_t linelen;
     char *line = NULL;
     int lineno = 0;
     size_t linelen;

-    
+

     rewind (smimeerr);
     rewind (smimeerr);

-    
+

     line = mutt_read_line (line, &linelen, smimeerr, &lineno);
     line = mutt_read_line (line, &linelen, smimeerr, &lineno);

-    if (linelen && !mutt_strcasecmp (line, "verification successful"))
+    if (linelen && !str_casecmp (line, "verification successful"))

       m->goodsig = 1;
       m->goodsig = 1;

-    FREE (&line);
+    mem_free (&line);

   }
   }

-  else 
-  {
+  else {

     m->goodsig = p->goodsig;
     m->goodsig = p->goodsig;

-    m->badsig  = p->badsig;
+    m->badsig = p->badsig;

   }
   fclose (smimeerr);
 
   }
   fclose (smimeerr);
 


@@ -1858,7 +1795,7 @@ static BODY *smime_handle_entity (BODY *m, STATE *s, FILE *outFile)
 
 
 
 
 
 

-int smime_decrypt_mime (FILE *fpin, FILE **fpout, BODY *b, BODY **cur)
+int smime_decrypt_mime (FILE * fpin, FILE ** fpout, BODY * b, BODY ** cur)

 {
 
 
 {
 
 


@@ -1867,21 +1804,21 @@ int smime_decrypt_mime (FILE *fpin, FILE **fpout, BODY *b, BODY **cur)
   long tmpoffset = b->offset;
   size_t tmplength = b->length;
   int origType = b->type;
   long tmpoffset = b->offset;
   size_t tmplength = b->length;
   int origType = b->type;

-  FILE *tmpfp=NULL;
+  FILE *tmpfp = NULL;
+  int rv = 0;

 
   if (!mutt_is_application_smime (b))
     return -1;
 
   if (b->parts)
     return -1;
 
   if (!mutt_is_application_smime (b))
     return -1;
 
   if (b->parts)
     return -1;

-  
+

   memset (&s, 0, sizeof (s));
   s.fpin = fpin;
   memset (&s, 0, sizeof (s));
   s.fpin = fpin;

-  fseek (s.fpin, b->offset, 0);
+  fseeko (s.fpin, b->offset, 0);

 
   mutt_mktemp (tempfile);
 
   mutt_mktemp (tempfile);

-  if ((tmpfp = safe_fopen (tempfile, "w+")) == NULL)
-  {
+  if ((tmpfp = safe_fopen (tempfile, "w+")) == NULL) {

     mutt_perror (tempfile);
     return (-1);
   }
     mutt_perror (tempfile);
     return (-1);
   }


@@ -1890,99 +1827,140 @@ int smime_decrypt_mime (FILE *fpin, FILE **fpout, BODY *b, BODY **cur)
   s.fpout = tmpfp;
   mutt_decode_attachment (b, &s);
   fflush (tmpfp);
   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;
   s.fpout = 0;
 
   mutt_mktemp (tempfile);
   b->offset = 0;
   rewind (tmpfp);
   s.fpin = tmpfp;
   s.fpout = 0;
 
   mutt_mktemp (tempfile);

-  if ((*fpout = safe_fopen (tempfile, "w+")) == NULL)
-  {
+  if ((*fpout = safe_fopen (tempfile, "w+")) == NULL) {

     mutt_perror (tempfile);
     mutt_perror (tempfile);

-    return (-1);
+    rv = -1;
+    goto bail;

   }
   mutt_unlink (tempfile);
 
   }
   mutt_unlink (tempfile);
 

-  *cur = smime_handle_entity (b, &s, *fpout);
+  if (!(*cur = smime_handle_entity (b, &s, *fpout))) {
+    rv = -1;
+    goto bail;
+  }
+

   (*cur)->goodsig = b->goodsig;
   (*cur)->goodsig = b->goodsig;

-  (*cur)->badsig = b->badsig;
+  (*cur)->badsig  = b->badsig;
+
+bail:

   b->type = origType;
   b->length = tmplength;
   b->offset = tmpoffset;
   b->type = origType;
   b->length = tmplength;
   b->offset = tmpoffset;

-  fclose (tmpfp);
-
-  rewind (*fpout);
-  return (0);

 
 

+  safe_fclose (&tmpfp);
+  if (*fpout)
+    rewind (*fpout);
+  return (rv);

 }
 
 
 }
 
 

-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)
+int smime_send_menu (HEADER * msg, int *redraw)

 {
   char *p;
 
   if (!(WithCrypto & APPLICATION_SMIME))
     return msg->security;
 
 {
   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? "),
-                            _("eswabfc")))
-  {
-  case 1: /* (e)ncrypt */
+  switch (mutt_multi_choice
+          (_
+           ("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;
     msg->security &= ~SIGN;
     break;
 
     msg->security |= ENCRYPT;
     msg->security &= ~SIGN;
     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:
-       mutt_str_replace (&SmimeCryptAlg, "des");
-       break;
-    case 2:
-       mutt_str_replace (&SmimeCryptAlg, "des3");
-       break;
-    case 3:
-       mutt_str_replace (&SmimeCryptAlg, "rc2-40");
-       break;
-    case 4:
-       mutt_str_replace (&SmimeCryptAlg, "rc2-64");
-       break;
-    case 5:
-       mutt_str_replace (&SmimeCryptAlg, "rc2-128");
-       break;
-    case 6: /* forget it */
-       break;
+  case 3:                      /* encrypt (w)ith */
+    {
+      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:
+                str_replace (&SmimeCryptAlg, "des");
+                break;
+              case 2:
+                str_replace (&SmimeCryptAlg, "des3");
+                break;
+            }
+            break;
+
+          case 2:
+            switch (choice = mutt_multi_choice (_("1: RC2-40, 2: RC2-64, 3: RC2-128 "),
+                                                _("468"))) {
+              case 1:
+                str_replace (&SmimeCryptAlg, "rc2-40");
+                break;
+              case 2:
+                str_replace (&SmimeCryptAlg, "rc2-64");
+                break;
+              case 3:
+                str_replace (&SmimeCryptAlg, "rc2-128");
+                break;
+            }
+            break;
+
+          case 3:
+            switch (choice = mutt_multi_choice (_("1: AES128, 2: AES192, 3: AES256 "),
+                                                _("895"))) {
+              case 1:
+                str_replace (&SmimeCryptAlg, "aes128");
+                break;
+              case 2:
+                str_replace (&SmimeCryptAlg, "aes192");
+                break;
+              case 3:
+                str_replace (&SmimeCryptAlg, "aes256");
+                break;
+            }
+            break;
+
+          case 4: /* (c)lear */
+            mem_free (&SmimeCryptAlg);
+            /* fallback */
+          case -1: /* Ctrl-G or Enter */
+            choice = 0;
+            break;
+        }
+      } while (choice == -1);

     }
     break;
 
     }
     break;
 

-  case 2: /* (s)ign */
-      
-    if(!SmimeDefaultKey)
-       mutt_message _("Can't sign: No key specified. Use Sign As.");
-    else
-    {
+  case 2:                      /* (s)ign */
+
+    if (!SmimeDefaultKey)
+      mutt_message (_("Can't sign: No key specified. Use Sign As."));
+
+    else {

       msg->security |= SIGN;
       msg->security &= ~ENCRYPT;
     }
     break;
 
       msg->security |= SIGN;
       msg->security &= ~ENCRYPT;
     }
     break;
 

-  case 4: /* sign (a)s */
+  case 4:                      /* sign (a)s */
+
+    if ((p = smime_ask_for_key (_("Sign as: "), NULL, 0))) {
+      str_replace (&SmimeDefaultKey, p);

 
 

-    if ((p = smime_ask_for_key (_("Sign as: "), NULL, 0))) 
-    {
-      p[mutt_strlen (p)-1] = '\0';
-      mutt_str_replace (&SmimeDefaultKey, p);
-       

       msg->security |= SIGN;
 
       /* probably need a different passphrase */
       msg->security |= SIGN;
 
       /* probably need a different passphrase */


@@ -1996,12 +1974,12 @@ int smime_send_menu (HEADER *msg, int *redraw)
     *redraw = REDRAW_FULL;
     break;
 
     *redraw = REDRAW_FULL;
     break;
 

-  case 5: /* (b)oth */
+  case 5:                      /* (b)oth */

     msg->security |= (ENCRYPT | SIGN);
     break;
 
     msg->security |= (ENCRYPT | SIGN);
     break;
 

-  case 6: /* (f)orget it */
-  case 7: /* (c)lear */
+  case 6:                      /* (f)orget it */
+  case 7:                      /* (c)lear */

     msg->security = 0;
     break;
   }
     msg->security = 0;
     break;
   }