lib-crypt/pgpinvoke.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 1997-2000 Thomas Roessler <roessler@does-not-exist.org>
   4  *
   5  * This file is part of mutt-ng, see http://www.muttng.org/.
   6  * It's licensed under the GNU General Public License,
   7  * please see the file GPL in the top level source directory.
   8  */
   9
  10 /* This file contains the new pgp invocation code.  Note that this
  11  * is almost entirely format based.
  12  */
  13
  14 #include <lib-lib/lib-lib.h>
  15
  16 #include <lib-sys/unix.h>
  17 #include <lib-mime/mime.h>
  18 #include <lib-ui/curses.h>
  19
  20 #include "mutt_idna.h"
  21 #include "pgp.h"
  22
  23
  24 /*
  25  * The actual command line formatter.
  26  */
  27
  28 struct pgp_command_context {
  29   short need_passphrase;        /* %p */
  30   const char *fname;            /* %f */
  31   const char *sig_fname;        /* %s */
  32   const char *signas;           /* %a */
  33   const char *ids;              /* %r */
  34 };
  35
  36
  37 static const char *
  38 _mutt_fmt_pgp_command(char *dest, ssize_t destlen,
  39                       char op, const char *src, const char *prefix,
  40                       const char *ifstr, const char *elstr,
  41                       anytype data, format_flag flags)
  42 {
  43   char fmt[16];
  44   struct pgp_command_context *cctx = data.ptr;
  45   int optional = (flags & M_FORMAT_OPTIONAL);
  46
  47   switch (op) {
  48   case 'r':
  49     {
  50       if (!optional) {
  51         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
  52         snprintf (dest, destlen, fmt, NONULL (cctx->ids));
  53       }
  54       else if (!cctx->ids)
  55         optional = 0;
  56       break;
  57     }
  58
  59   case 'a':
  60     {
  61       if (!optional) {
  62         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
  63         snprintf (dest, destlen, fmt, NONULL (cctx->signas));
  64       }
  65       else if (!cctx->signas)
  66         optional = 0;
  67       break;
  68     }
  69
  70   case 's':
  71     {
  72       if (!optional) {
  73         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
  74         snprintf (dest, destlen, fmt, NONULL (cctx->sig_fname));
  75       }
  76       else if (!cctx->sig_fname)
  77         optional = 0;
  78       break;
  79     }
  80
  81   case 'f':
  82     {
  83       if (!optional) {
  84         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
  85         snprintf (dest, destlen, fmt, NONULL (cctx->fname));
  86       }
  87       else if (!cctx->fname)
  88         optional = 0;
  89       break;
  90     }
  91
  92   case 'p':
  93     {
  94       if (!optional) {
  95         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
  96         snprintf (dest, destlen, fmt,
  97                   cctx->need_passphrase ? "PGPPASSFD=0" : "");
  98       }
  99       else if (!cctx->need_passphrase || pgp_use_gpg_agent ())
 100         optional = 0;
 101       break;
 102     }
 103   default:
 104     {
 105       *dest = '\0';
 106       break;
 107     }
 108   }
 109
 110   if (flags & M_FORMAT_OPTIONAL)
 111     m_strformat(dest, destlen, 0, optional ? ifstr : elstr,
 112                 _mutt_fmt_pgp_command, data, 0);
 113
 114   return src;
 115 }
 116
 117 static void
 118 mutt_pgp_command(char *d, ssize_t dlen, struct pgp_command_context *cctx,
 119                  const char *fmt)
 120 {
 121     m_strformat(d, dlen, 0, fmt, _mutt_fmt_pgp_command, cctx, 0);
 122 }
 123
 124 /*
 125  * Glue.
 126  */
 127
 128
 129 static pid_t pgp_invoke (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 130                          int pgpinfd, int pgpoutfd, int pgperrfd,
 131                          short need_passphrase,
 132                          const char *fname,
 133                          const char *sig_fname,
 134                          const char *signas,
 135                          const char *ids, const char *format)
 136 {
 137   struct pgp_command_context cctx;
 138   char cmd[HUGE_STRING];
 139
 140   p_clear(&cctx, 1);
 141
 142   if (!format || !*format)
 143     return (pid_t) - 1;
 144
 145   cctx.need_passphrase = need_passphrase;
 146   cctx.fname = fname;
 147   cctx.sig_fname = sig_fname;
 148   cctx.signas = signas;
 149   cctx.ids = ids;
 150
 151   mutt_pgp_command (cmd, sizeof (cmd), &cctx, format);
 152
 153   return mutt_create_filter_fd (cmd, pgpin, pgpout, pgperr,
 154                                 pgpinfd, pgpoutfd, pgperrfd);
 155 }
 156
 157
 158 /*
 159  * The exported interface.
 160  *
 161  * This is historic and may be removed at some point.
 162  *
 163  */
 164
 165
 166 pid_t pgp_invoke_decode (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 167                          int pgpinfd, int pgpoutfd, int pgperrfd,
 168                          const char *fname, short need_passphrase)
 169 {
 170   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 171                      need_passphrase, fname, NULL, NULL, NULL,
 172                      PgpDecodeCommand);
 173 }
 174
 175 pid_t pgp_invoke_verify (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 176                          int pgpinfd, int pgpoutfd, int pgperrfd,
 177                          const char *fname, const char *sig_fname)
 178 {
 179   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 180                      0, fname, sig_fname, NULL, NULL, PgpVerifyCommand);
 181 }
 182
 183 pid_t pgp_invoke_decrypt (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 184                           int pgpinfd, int pgpoutfd, int pgperrfd,
 185                           const char *fname)
 186 {
 187   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 188                      1, fname, NULL, NULL, NULL, PgpDecryptCommand);
 189 }
 190
 191 pid_t pgp_invoke_sign (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 192                        int pgpinfd, int pgpoutfd, int pgperrfd,
 193                        const char *fname)
 194 {
 195   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 196                      1, fname, NULL, PgpSignAs, NULL, PgpSignCommand);
 197 }
 198
 199
 200 pid_t pgp_invoke_encrypt (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 201                           int pgpinfd, int pgpoutfd, int pgperrfd,
 202                           const char *fname, const char *uids, int sign)
 203 {
 204   if (sign)
 205     return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 206                        1, fname, NULL, PgpSignAs, uids,
 207                        PgpEncryptSignCommand);
 208   else
 209     return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 210                        0, fname, NULL, NULL, uids, PgpEncryptOnlyCommand);
 211 }
 212
 213 pid_t pgp_invoke_traditional (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 214                               int pgpinfd, int pgpoutfd, int pgperrfd,
 215                               const char *fname, const char *uids, int flags)
 216 {
 217   if (flags & ENCRYPT)
 218     return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 219                        flags & SIGN ? 1 : 0, fname, NULL, PgpSignAs, uids,
 220                        flags & SIGN ? PgpEncryptSignCommand :
 221                        PgpEncryptOnlyCommand);
 222   else
 223     return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 224                        1, fname, NULL, PgpSignAs, NULL, PgpClearSignCommand);
 225 }
 226
 227
 228 void pgp_invoke_import (const char *fname)
 229 {
 230   char _fname[_POSIX_PATH_MAX + STRING];
 231   char cmd[HUGE_STRING];
 232   struct pgp_command_context cctx;
 233
 234   p_clear(&cctx, 1);
 235
 236   mutt_quote_filename (_fname, sizeof (_fname), fname);
 237   cctx.fname = _fname;
 238
 239   mutt_pgp_command (cmd, sizeof (cmd), &cctx, PgpImportCommand);
 240   mutt_system (cmd);
 241 }
 242
 243 void pgp_invoke_getkeys (address_t * addr)
 244 {
 245   char buff[LONG_STRING];
 246   char tmp[LONG_STRING];
 247   char cmd[HUGE_STRING];
 248   int devnull;
 249
 250   char *personal;
 251
 252   struct pgp_command_context cctx;
 253
 254   if (!PgpGetkeysCommand)
 255     return;
 256
 257   p_clear(&cctx, 1);
 258
 259   personal = addr->personal;
 260   addr->personal = NULL;
 261
 262   mutt_addrlist_to_local(addr);
 263   rfc822_addrcpy(tmp, sizeof(tmp), addr, 0);
 264   mutt_quote_filename(buff, sizeof(buff), tmp);
 265
 266   addr->personal = personal;
 267
 268   cctx.ids = buff;
 269
 270   mutt_pgp_command (cmd, sizeof (cmd), &cctx, PgpGetkeysCommand);
 271
 272   devnull = open ("/dev/null", O_RDWR);
 273
 274   if (!isendwin ())
 275     mutt_message _("Fetching PGP key...");
 276
 277   mutt_system (cmd);
 278
 279   if (!isendwin ())
 280     mutt_clear_error ();
 281
 282   close (devnull);
 283 }
 284
 285 pid_t pgp_invoke_export (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 286                          int pgpinfd, int pgpoutfd, int pgperrfd,
 287                          const char *uids)
 288 {
 289   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 290                      0, NULL, NULL, NULL, uids, PgpExportCommand);
 291 }
 292
 293 pid_t pgp_invoke_verify_key (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 294                              int pgpinfd, int pgpoutfd, int pgperrfd,
 295                              const char *uids)
 296 {
 297   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 298                      0, NULL, NULL, NULL, uids, PgpVerifyKeyCommand);
 299 }
 300
 301 pid_t pgp_invoke_list_keys (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 302                             int pgpinfd, int pgpoutfd, int pgperrfd,
 303                             pgp_ring_t keyring, string_list_t * hints)
 304 {
 305   char uids[HUGE_STRING];
 306   char tmpuids[HUGE_STRING];
 307   char quoted[HUGE_STRING];
 308
 309   *uids = '\0';
 310
 311   for (; hints; hints = hints->next) {
 312     mutt_quote_filename (quoted, sizeof (quoted), (char *) hints->data);
 313     snprintf (tmpuids, sizeof (tmpuids), "%s %s", uids, quoted);
 314     m_strcpy(uids, sizeof(uids), tmpuids);
 315   }
 316
 317   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 318                      0, NULL, NULL, NULL, uids,
 319                      keyring == PGP_SECRING ? PgpListSecringCommand :
 320                      PgpListPubringCommand);
 321 }