[unstable] Change the way mutt_quote_filename() worked. It's not

too reasonable to allocate memory dynamically whenever we quote a
file name.  (I guess I should add "vim" to pgpinvoke.c's copyright
notice. :-)

diff --git a/lib.c b/lib.c
index 553a40ae02eb0fcfa94645302269950c739a3873..9da750851b8aa59438754a06a44bc23276a4fe84 100644 (file)
--- a/lib.c
+++ b/lib.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
+ * Copyright (C) 1999 Thomas Roessler <roessler@guug.de>
  * 
  *     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
@@ -608,10 +609,10 @@ int mutt_copy_stream (FILE *fin, FILE *fout)
 
 void mutt_expand_file_fmt (char *dest, size_t destlen, const char *fmt, const char *src)
 {
-  char *_src = mutt_quote_filename(src);
+  char tmp[LONG_STRING];
   
-  mutt_expand_fmt(dest, destlen, fmt, _src);
-  safe_free((void **) &_src);
+  mutt_quote_filename (tmp, sizeof (tmp), src);
+  mutt_expand_fmt (dest, destlen, fmt, tmp);
 }
 
 void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt, const char *src)
@@ -1225,41 +1226,38 @@ int mutt_save_confirm (const char *s, struct stat *st)
  * From the Unix programming FAQ by way of Liviu.
  */
 
-char *mutt_quote_filename(const char *f)
+size_t mutt_quote_filename(char *d, size_t l, const char *f)
 {
-  char *d;
-  size_t i,l;
+  size_t i, j = 0;
 
-  if(!f) return NULL;
-  
-  for(i = 0, l = 3; f[i]; i++, l++)
+  if(!f) 
   {
-    if(f[i] == '\'')
-      l += 3;
+    *d = '\0';
+    return 0;
   }
+
+  /* leave some space for the trailing characters. */
+  l -= 6;
   
-  d = safe_malloc(l);
-  
-  l = 0;
-  d[l++] = '\'';
+  d[j++] = '\'';
   
-  for(i = 0; f[i]; i++)
+  for(i = 0; j < l && f[i]; i++)
   {
     if(f[i] == '\'')
     {
-      d[l++] = '\'';
-      d[l++] = '\\';
-      d[l++] = '\'';
-      d[l++] = '\'';
+      d[j++] = '\'';
+      d[j++] = '\\';
+      d[j++] = '\'';
+      d[j++] = '\'';
     }
     else
-      d[l++] = f[i];
+      d[j++] = f[i];
   }
   
-  d[l++] = '\'';
-  d[l]   = '\0';
+  d[j++] = '\'';
+  d[j]   = '\0';
   
-  return d;
+  return j;
 }
 
 void state_prefix_putc(char c, STATE *s)

diff --git a/mx.c b/mx.c
index 3c04a9a000077cab629844f9ffa6105e99833f49..f5deb166bb4cbe4a4ac289328c971dc13ac6dc6c 100644 (file)
--- a/mx.c
+++ b/mx.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
+ * Copyright (C) 1999 Thomas Roessler <roessler@guug.de>
  * 
  *     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
@@ -65,18 +66,18 @@
 
 #ifdef DL_STANDALONE
 
-static int invoke_dotlock(const char *path, int flags, int retry)
+static int invoke_dotlock (const char *path, int flags, int retry)
 {
   char cmd[LONG_STRING + _POSIX_PATH_MAX];
+  char f[SHORT_STRING + _POSIX_PATH_MAX];
   char r[SHORT_STRING];
-  char *f;
   
-  if(flags & DL_FL_RETRY)
-    snprintf(r, sizeof(r), "-r %d ", retry ? MAXLOCKATTEMPT : 0);
+  if (flags & DL_FL_RETRY)
+    snprintf (r, sizeof (r), "-r %d ", retry ? MAXLOCKATTEMPT : 0);
   
-  f = mutt_quote_filename(path);
+  mutt_quote_filename (f, sizeof (f), path);
   
-  snprintf(cmd, sizeof(cmd),
+  snprintf (cmd, sizeof (cmd),
           "%s %s%s%s%s%s%s",
           DOTLOCK,
           flags & DL_FL_TRY ? "-t " : "",
@@ -86,9 +87,7 @@ static int invoke_dotlock(const char *path, int flags, int retry)
           flags & DL_FL_RETRY ? r : "",
           f);
   
-  FREE(&f);
-
-  return mutt_system(cmd);
+  return mutt_system (cmd);
 }
 
 #else 

diff --git a/pgpinvoke.c b/pgpinvoke.c
index e180fa05e1ff012732fc8dda6eb27851e7565326..ccc7d4945598ca29058a6bb786e43a394e6f1cd1 100644 (file)
--- a/pgpinvoke.c
+++ b/pgpinvoke.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1997-1998 Thomas Roessler <roessler@guug.de>
+ * Copyright (C) 1997-1999 Thomas Roessler <roessler@guug.de>
  * 
  *     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
@@ -25,7 +25,6 @@
 #include "mutt.h"
 #include "pgp.h"
 
-
 /*******************************************************************
  * 
  * PGP V2 Invocation stuff
@@ -37,142 +36,141 @@ pid_t pgp_v2_invoke_decode(struct pgp_vinfo *pgp,
                           int pgpinfd, int pgpoutfd, int pgperrfd,
                           const char *fname, int need_passphrase)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd), "%scat %s%s | "
           "%s +language=%s +pubring=%s +secring=%s +verbose=0 +batchmode -f",
           need_passphrase ? "PGPPASSFD=0; export PGPPASSFD; " : "",
           need_passphrase ? "- " : "",
           _fname,
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring));
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring));
 
-  FREE(&pubring); FREE(&secring); FREE(&binary); 
-  FREE(&_fname);
-  
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
 pid_t pgp_v2_invoke_verify(struct pgp_vinfo *pgp,
                           FILE **pgpin, FILE **pgpout, FILE **pgperr,
                           int pgpinfd, int pgpoutfd, int pgperrfd,
                           const char *signedstuff, const char *sigfile)
 {
+  char _sig[_POSIX_PATH_MAX + SHORT_STRING];
+  char _signed[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_signed = mutt_quote_filename(signedstuff);
-  char *_sig    = mutt_quote_filename(sigfile);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_sig, sizeof (_sig), sigfile);
+  mutt_quote_filename (_signed, sizeof (_signed), signedstuff);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd), 
           "%s +language=%s +pubring=%s +secring=%s +batchmode +verbose=0 %s %s",
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), 
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), 
           NONULL (secring), _sig, _signed);
 
-  FREE(&pubring); FREE(&secring); FREE(&binary);
-  FREE(&_signed); FREE(&_sig);
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
 pid_t pgp_v2_invoke_decrypt(struct pgp_vinfo *pgp,
                            FILE **pgpin, FILE **pgpout, FILE **pgperr,
                            int pgpinfd, int pgpoutfd, int pgperrfd,
                            const char *fname)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
 
   snprintf(cmd, sizeof(cmd),
           "PGPPASSFD=0; export PGPPASSFD; cat - %s | %s +language=%s +pubring=%s +secring=%s "
           "+verbose=0 +batchmode -f",
-          _fname, NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring));
-  FREE(&pubring); FREE(&secring); FREE(&binary);
-  FREE(&_fname);
+          _fname, NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring));
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                            pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
-
-
 pid_t pgp_v2_invoke_sign(struct pgp_vinfo *pgp,
                         FILE **pgpin, FILE **pgpout, FILE **pgperr,
                         int pgpinfd, int pgpoutfd, int pgperrfd, 
                         const char *fname)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd),
           "PGPPASSFD=0; export PGPPASSFD; cat - %s | %s "
           "+language=%s +pubring=%s +secring=%s +verbose=0 +batchmode -abfst %s %s",
-          _fname, NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), 
+          _fname, NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), 
           PgpSignAs ? "-u" : "",
           PgpSignAs ? PgpSignAs : "");
-  
-  FREE(&pubring); FREE(&secring); FREE(&binary);
-  FREE(&_fname);
+
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
-
 pid_t pgp_v2_invoke_encrypt(struct pgp_vinfo *pgp,
                            FILE **pgpin, FILE **pgpout, FILE **pgperr,
                            int pgpinfd, int pgpoutfd, int pgperrfd,
                            const char *fname, const char *uids, int sign)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd),
           "%scat %s%s | %s +language=%s +pubring=%s +secring=%s +verbose=0 %s +batchmode -aeft%s %s%s %s",
           sign ? "PGPPASSFD=0; export PGPPASSFD; " : "",
           sign ? "- " : "",
           _fname,
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), 
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), 
           option(OPTPGPENCRYPTSELF) ? "+encrypttoself" : "",
           sign ? "s" : "",
           sign && PgpSignAs ? "-u " : "",
           sign && PgpSignAs ? PgpSignAs : "",
           uids);
-  FREE(&pubring); FREE(&secring); FREE(&binary);
-  FREE(&_fname);
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr, 
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
 void pgp_v2_invoke_import(struct pgp_vinfo *pgp, const char *fname)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd), "%s +language=%s +pubring=%s +secring=%s -ka %s",
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), 
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), 
           NONULL (secring), _fname);
-  FREE(&pubring); FREE(&secring); FREE(&binary);
-  FREE(&_fname);
   mutt_system(cmd);
 }
 
@@ -181,85 +179,87 @@ pid_t pgp_v2_invoke_export(struct pgp_vinfo *pgp,
                           int pgpinfd, int pgpoutfd, int pgperrfd, const char *id)
 {
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
 
   snprintf(cmd, sizeof(cmd), "%s -kxaf +language=%s +pubring=%s +secring=%s 0x%8s",
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), id);
-  FREE(&pubring); FREE(&secring); FREE(&binary);
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), id);
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
 pid_t pgp_v2_invoke_verify_key(struct pgp_vinfo *pgp,
                               FILE **pgpin, FILE **pgpout, FILE **pgperr,
                               int pgpinfd, int pgpoutfd, int pgperrfd, const char *id)
 {
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
 
   snprintf(cmd, sizeof(cmd), "%s +language=%s +pubring=%s +secring=%s +batchmode -kcc 0x%8s",
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), id);
-  FREE(&pubring); FREE(&secring); FREE(&binary);
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), id);
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
 /*******************************************************************
  * 
  * PGP V3 Invocation stuff
  * 
  *******************************************************************/
 
-
 pid_t pgp_v3_invoke_decode(struct pgp_vinfo *pgp,
                           FILE **pgpin, FILE **pgpout, FILE **pgperr,
                           int pgpinfd, int pgpoutfd, int pgperrfd,
                           const char *fname, int need_passphrase)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd), "%scat %s%s | "
           "%sv +language=%s +pubring=%s +secring=%s +verbose=0 +batchmode -f "
           "--OutputInformationFD=2",
           need_passphrase ? "PGPPASSFD=0; export PGPPASSFD; " : "",
           need_passphrase ? "- " : "",
           _fname,
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring));
-  FREE(&pubring); FREE(&secring); FREE(&binary); FREE(&_fname);
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring));
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
 pid_t pgp_v3_invoke_verify(struct pgp_vinfo *pgp,
                           FILE **pgpin, FILE **pgpout, FILE **pgperr,
                           int pgpinfd, int pgpoutfd, int pgperrfd,
                           const char *signedstuff, const char *sigfile)
 {
+  char _sig[_POSIX_PATH_MAX + SHORT_STRING];
+  char _sign[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_sign   = mutt_quote_filename(signedstuff);
-  char *_sig    = mutt_quote_filename(sigfile);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_sig, sizeof (_sig), sigfile);
+  mutt_quote_filename (_sign, sizeof (_sign), signedstuff);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd),
           "%sv +language=%s +pubring=%s +secring=%s --OutputInformationFD=1 +batchmode +verbose=0 %s %s",
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), 
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), 
           _sig, _sign);
-  
-  FREE(&pubring); FREE(&secring); FREE(&binary);
-  FREE(&_sign); FREE(&_sig);
+
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
@@ -269,30 +269,31 @@ pid_t pgp_v3_invoke_encrypt(struct pgp_vinfo *pgp,
                            int pgpinfd, int pgpoutfd, int pgperrfd,
                            const char *fname, const char *uids, int sign)
 {
-  char cmd[HUGE_STRING];
-  char tmpcmd[HUGE_STRING];
   char *cp;
   char *keylist;
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
+  char cmd[HUGE_STRING];
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+  char tmpcmd[HUGE_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd),
           "%scat %s%s | %se +language=%s +pubring=%s +secring=%s +verbose=0 %s +batchmode +nobatchinvalidkeys=off -aft%s %s%s",
           sign ? "PGPPASSFD=0; export PGPPASSFD; " : "",
           sign ? "- " : "",
           _fname,
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), 
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), 
           option(OPTPGPENCRYPTSELF) ? "+encrypttoself" : "",
           sign ? "s" : "",
           sign && PgpSignAs ? "-u " : "",
           sign && PgpSignAs ? PgpSignAs : "");
-  
-  FREE(&pubring); FREE(&secring); FREE(&binary); FREE(&_fname);
-  
+
   keylist = safe_strdup(uids);
-  
+
   for(cp = strtok(keylist, " "); cp ; cp = strtok(NULL, " "))
   {
     snprintf(tmpcmd, sizeof(tmpcmd), "%s -r %s", 
@@ -300,7 +301,7 @@ pid_t pgp_v3_invoke_encrypt(struct pgp_vinfo *pgp,
     strcpy(cmd, tmpcmd);
   }
   safe_free((void **) &keylist);
-  
+
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr, 
                               pgpinfd, pgpoutfd, pgperrfd);
 }
@@ -310,72 +311,77 @@ pid_t pgp_v3_invoke_decrypt(struct pgp_vinfo *pgp,
                            int pgpinfd, int pgpoutfd, int pgperrfd,
                            const char *fname)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd),
           "PGPPASSFD=0; export PGPPASSFD; cat - %s | %sv +language=%s +pubring=%s +secring=%s "
           "+verbose=0 +batchmode -f --OutputInformationFD=2",
-          _fname, NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring));
+          _fname, NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring));
 
-  FREE(&pubring); FREE(&secring); FREE(&binary); FREE(&_fname);
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
 pid_t pgp_v3_invoke_sign(struct pgp_vinfo *pgp,
                         FILE **pgpin, FILE **pgpout, FILE **pgperr,
                         int pgpinfd, int pgpoutfd, int pgperrfd, 
                         const char *fname)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd),
           "PGPPASSFD=0; export PGPPASSFD; cat - %s | %ss "
           "+language=%s +pubring=%s +secring=%s +verbose=0 -abft %s %s",
-          _fname, NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring),
+          _fname, NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring),
           PgpSignAs ? "-u" : "",
           PgpSignAs ? PgpSignAs : "");
-  FREE(&pubring); FREE(&secring); FREE(&binary); FREE(&_fname);
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 void pgp_v3_invoke_import(struct pgp_vinfo *pgp, const char *fname)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
+
   snprintf(cmd, sizeof(cmd), "%sk +language=%s +pubring=%s +secring=%s -a --OutputInformationFD=1 %s",
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), _fname);
-  FREE(&pubring); FREE(&secring); FREE(&binary); FREE(&_fname);
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), _fname);
   mutt_system(cmd);
 }
 
-
 pid_t pgp_v3_invoke_export(struct pgp_vinfo *pgp,
                           FILE **pgpin, FILE **pgpout, FILE **pgperr,
                           int pgpinfd, int pgpoutfd, int pgperrfd, const char *id)
 {
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
 
   snprintf(cmd, sizeof(cmd), "%sk -xa +language=%s +pubring=%s +secring=%s --OutputInformationFD=1 0x%8s",
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), id);
-  
-  FREE(&pubring); FREE(&secring); FREE(&binary);
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), id);
+
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
@@ -385,19 +391,19 @@ pid_t pgp_v3_invoke_verify_key(struct pgp_vinfo *pgp,
                               int pgpinfd, int pgpoutfd, int pgperrfd, const char *id)
 {
   char cmd[HUGE_STRING];
-  char *pubring = mutt_quote_filename(*pgp->pubring);
-  char *secring = mutt_quote_filename(*pgp->secring); 
-  char *binary  = mutt_quote_filename(*pgp->binary);
+  char pubring[_POSIX_PATH_MAX + SHORT_STRING];
+  char secring[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (pubring, sizeof (pubring), *pgp->pubring);
+  mutt_quote_filename (secring, sizeof (secring), *pgp->secring); 
 
   snprintf(cmd, sizeof(cmd), "%sk +language=%s +pubring=%s +secring=%s +batchmode -c --OutputInformationFD=1 0x%8s",
-          NONULL (binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), id);
+          NONULL(*pgp->binary), NONULL (*pgp->language), NONULL (pubring), NONULL (secring), id);
 
-  FREE(&pubring); FREE(&secring); FREE(&binary);  
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
 /*******************************************************************
  * 
  * GNU Privacy Guard invocation stuff
@@ -413,15 +419,15 @@ pid_t pgp_gpg_invoke_decode(struct pgp_vinfo *pgp,
                            const char *fname, int need_passphrase)
 {
   char cmd[HUGE_STRING];
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+
   snprintf(cmd, sizeof(cmd),
           "%s%s --no-verbose --batch  -o - %s",
-          NONULL(binary), need_passphrase? " --passphrase-fd 0":"",
+          NONULL(*pgp->binary), need_passphrase? " --passphrase-fd 0":"",
           _fname);
 
-  FREE(&binary); FREE(&_fname);
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
@@ -431,17 +437,17 @@ pid_t pgp_gpg_invoke_verify(struct pgp_vinfo *pgp,
                            int pgpinfd, int pgpoutfd, int pgperrfd,
                            const char *signedstuff, const char *sigfile)
 {  
+  char _sig[_POSIX_PATH_MAX + SHORT_STRING];
+  char _sign[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_sign   = mutt_quote_filename(signedstuff);
-  char *_sig   = mutt_quote_filename(sigfile);
-  
+
+  mutt_quote_filename (_sig, sizeof (_sig), sigfile);
+  mutt_quote_filename (_sign, sizeof (_sign), signedstuff);
+
   snprintf(cmd, sizeof(cmd),
           "%s --no-verbose --batch  -o - "
           "--verify %s %s",
-          NONULL(binary), _sig, _sign);
-
-  FREE(&binary); FREE(&_sign); FREE(&_sig);
+          NONULL(*pgp->binary), _sig, _sign);
 
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
@@ -452,16 +458,15 @@ pid_t pgp_gpg_invoke_decrypt(struct pgp_vinfo *pgp,
                            int pgpinfd, int pgpoutfd, int pgperrfd,
                            const char *fname)
 {
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
   char cmd[HUGE_STRING];
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+
   snprintf(cmd, sizeof(cmd),
           "%s --passphrase-fd 0 --no-verbose --batch  -o - "
           "--decrypt %s",
-          NONULL(binary), _fname);
-
-  FREE(&binary); FREE(&_fname);
+          NONULL(*pgp->binary), _fname);
 
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
@@ -483,33 +488,31 @@ static char *gpg_digalg(void)
   }
   return digalg;
 }
-  
+
 pid_t pgp_gpg_invoke_sign(struct pgp_vinfo *pgp,
                         FILE **pgpin, FILE **pgpout, FILE **pgperr,
                         int pgpinfd, int pgpoutfd, int pgperrfd, 
                         const char *fname)
 {
   char cmd[HUGE_STRING];
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+
   snprintf(cmd, sizeof(cmd),
           "%s --no-verbose --batch  -o - "
           "--passphrase-fd 0 --digest-algo %s "
           "--detach-sign --textmode --armor %s%s %s",
-          NONULL(binary),
+          NONULL(*pgp->binary),
           gpg_digalg(),
           PgpSignAs? "-u " : "",
           PgpSignAs? PgpSignAs : "", _fname);
-  
-  
-  FREE(&binary); FREE(&_fname);
+
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
-
 pid_t pgp_gpg_invoke_encrypt(struct pgp_vinfo *pgp,
                            FILE **pgpin, FILE **pgpout, FILE **pgperr,
                            int pgpinfd, int pgpoutfd, int pgperrfd,
@@ -519,20 +522,21 @@ pid_t pgp_gpg_invoke_encrypt(struct pgp_vinfo *pgp,
   char tmpcmd[HUGE_STRING];
   char *cp;
   char *keylist;
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
-  
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
+
   snprintf(cmd, sizeof(cmd),
           "%s%s --no-verbose -v --batch  -o - "
           "--digest-algo %s "
           "--encrypt%s --textmode --armor --always-trust %s%s",
-          NONULL(binary),
+          NONULL(*pgp->binary),
           sign? " --passphrase-fd 0":"",
           gpg_digalg(),
           sign? " --sign":"",
           PgpSignAs? "-u " : "",
           PgpSignAs? PgpSignAs : "" );
-  
+
   keylist = safe_strdup(uids);
   for(cp = strtok(keylist, " "); cp ; cp = strtok(NULL, " "))
   {
@@ -545,8 +549,6 @@ pid_t pgp_gpg_invoke_encrypt(struct pgp_vinfo *pgp,
   snprintf(tmpcmd, sizeof(tmpcmd), "%s %s", cmd, _fname);
   strcpy(cmd, tmpcmd);
 
-  FREE(&binary); FREE(&_fname);
-  
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr, 
                               pgpinfd, pgpoutfd, pgperrfd);
 }
@@ -554,15 +556,13 @@ pid_t pgp_gpg_invoke_encrypt(struct pgp_vinfo *pgp,
 void pgp_gpg_invoke_import(struct pgp_vinfo *pgp, const char *fname)
 {
   char cmd[HUGE_STRING];
-  char *binary  = mutt_quote_filename(*pgp->binary);
-  char *_fname  = mutt_quote_filename(fname);
+  char _fname[_POSIX_PATH_MAX + SHORT_STRING];
+
+  mutt_quote_filename (_fname, sizeof (_fname), fname);
 
   snprintf(cmd, sizeof(cmd), "%sm --no-verbose --import -v %s",
-          NONULL (binary), _fname);
-  
-  FREE(&binary);
-  FREE(&_fname);
-  
+          NONULL(*pgp->binary), _fname);
+
   mutt_system(cmd);
 }
 
@@ -571,31 +571,24 @@ pid_t pgp_gpg_invoke_export(struct pgp_vinfo *pgp,
                           int pgpinfd, int pgpoutfd, int pgperrfd, const char *id)
 {
   char cmd[HUGE_STRING];
-  char *binary  = mutt_quote_filename(*pgp->binary);
 
   snprintf(cmd, sizeof(cmd), "%sm --no-verbose --export --armor 0x%8s",
-          NONULL (binary), id);
-  
-  FREE(&binary);
-  
+          NONULL(*pgp->binary), id);
+
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }
 
-
 pid_t pgp_gpg_invoke_verify_key(struct pgp_vinfo *pgp,
                               FILE **pgpin, FILE **pgpout, FILE **pgperr,
                               int pgpinfd, int pgpoutfd, int pgperrfd, const char *id)
 {
   char cmd[HUGE_STRING];
-  char *binary  = mutt_quote_filename(*pgp->binary);
 
   snprintf(cmd, sizeof(cmd),
           "%sm --no-verbose --batch --fingerprint --check-sigs %s%s",
-          NONULL(binary), (mutt_strlen(id)==8 || mutt_strlen(id)==16)? "0x":"", id );
-  
-  FREE(&binary);
-  
+          NONULL(*pgp->binary), (mutt_strlen(id)==8 || mutt_strlen(id)==16)? "0x":"", id );
+
   return mutt_create_filter_fd(cmd, pgpin, pgpout, pgperr,
                               pgpinfd, pgpoutfd, pgperrfd);
 }

diff --git a/protos.h b/protos.h
index 2fa200c3ed8ebfc9a4838e157023ac47d4a8d45c..a86fc865acbe40316c83402f4b563ba8a204063e 100644 (file)
--- a/protos.h
+++ b/protos.h
@@ -122,7 +122,6 @@ char *mutt_get_send_charset (char *, size_t, BODY *, short);
 char *mutt_pgp_hook (ADDRESS *);
 #endif /* _PGPPATH */
 char *mutt_make_date (char *, size_t);
-char *mutt_quote_filename(const char *);
 char *mutt_read_line (char *, size_t *, FILE *, int *);
 char *mutt_strlower (char *);
 char *mutt_skip_whitespace (char *);
@@ -269,6 +268,7 @@ int mutt_pipe_attachment (FILE *, BODY *, const char *, char *);
 int mutt_pipe_message (HEADER *);
 int mutt_print_attachment (FILE *, BODY *);
 int mutt_query_complete (char *, size_t);
+size_t mutt_quote_filename(char *, size_t, const char *);
 int mutt_save_attachment (FILE *, BODY *, char *, int, HEADER *);
 int mutt_save_message (HEADER *, int, int, int, int *);
 int mutt_search_command (int, int);

diff --git a/rfc1524.c b/rfc1524.c
index 7bbc748a17a39e8d9c08a900497e899c90667e26..28c6e757e9b2b6307054e1b76aaac69af3e6c085 100644 (file)
--- a/rfc1524.c
+++ b/rfc1524.c
@@ -68,29 +68,16 @@ int rfc1524_expand_command (BODY *a, char *filename, char *type,
       {
        char param[STRING];
        int z = 0;
-       char *ret = NULL;
 
        x++;
        while (command[x] && command[x] != '}' && z<sizeof(param))
          param[z++] = command[x++];
        param[z] = '\0';
-       dprint(2,(debugfile,"Parameter: %s  Returns: %s\n",param,ret));
-       ret = mutt_quote_filename(mutt_get_parameter(param,a->parameter));
-       dprint(2,(debugfile,"Parameter: %s  Returns: %s\n",param,ret));
-       z = 0;
-       while (ret && ret[z] && y<sizeof(buf))
-         buf[y++] = ret[z++];
-       FREE(&ret);
+       y += mutt_quote_filename (buf + y, sizeof (buf) - y, mutt_get_parameter(param,a->parameter));
       }
       else if (command[x] == 's' && filename != NULL)
       {
-       char *fn = mutt_quote_filename(filename);
-       int i;
-       
-       for(i = 0; fn[i] && y < sizeof(buf); i++)
-         buf[y++] = fn[i];
-       
-       FREE(&fn);
+       y += mutt_quote_filename (buf + y, sizeof (buf) - y, filename);
        needspipe = FALSE;
       }
       else if (command[x] == 't')