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 (optional)
 111     m_strformat(dest, destlen, ifstr, _mutt_fmt_pgp_command, data, 0);
 112   else if (flags & M_FORMAT_OPTIONAL)
 113     m_strformat(dest, destlen, elstr, _mutt_fmt_pgp_command, data, 0);
 114
 115   return (src);
 116 }
 117
 118 static void
 119 mutt_pgp_command(char *d, ssize_t dlen, struct pgp_command_context *cctx,
 120                  const char *fmt)
 121 {
 122   m_strformat(d, dlen, NONULL (fmt), _mutt_fmt_pgp_command, cctx, 0);
 123 }
 124
 125 /*
 126  * Glue.
 127  */
 128
 129
 130 static pid_t pgp_invoke (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 131                          int pgpinfd, int pgpoutfd, int pgperrfd,
 132                          short need_passphrase,
 133                          const char *fname,
 134                          const char *sig_fname,
 135                          const char *signas,
 136                          const char *ids, const char *format)
 137 {
 138   struct pgp_command_context cctx;
 139   char cmd[HUGE_STRING];
 140
 141   p_clear(&cctx, 1);
 142
 143   if (!format || !*format)
 144     return (pid_t) - 1;
 145
 146   cctx.need_passphrase = need_passphrase;
 147   cctx.fname = fname;
 148   cctx.sig_fname = sig_fname;
 149   cctx.signas = signas;
 150   cctx.ids = ids;
 151
 152   mutt_pgp_command (cmd, sizeof (cmd), &cctx, format);
 153
 154   return mutt_create_filter_fd (cmd, pgpin, pgpout, pgperr,
 155                                 pgpinfd, pgpoutfd, pgperrfd);
 156 }
 157
 158
 159 /*
 160  * The exported interface.
 161  *
 162  * This is historic and may be removed at some point.
 163  *
 164  */
 165
 166
 167 pid_t pgp_invoke_decode (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 168                          int pgpinfd, int pgpoutfd, int pgperrfd,
 169                          const char *fname, short need_passphrase)
 170 {
 171   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 172                      need_passphrase, fname, NULL, NULL, NULL,
 173                      PgpDecodeCommand);
 174 }
 175
 176 pid_t pgp_invoke_verify (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 177                          int pgpinfd, int pgpoutfd, int pgperrfd,
 178                          const char *fname, const char *sig_fname)
 179 {
 180   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 181                      0, fname, sig_fname, NULL, NULL, PgpVerifyCommand);
 182 }
 183
 184 pid_t pgp_invoke_decrypt (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 185                           int pgpinfd, int pgpoutfd, int pgperrfd,
 186                           const char *fname)
 187 {
 188   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 189                      1, fname, NULL, NULL, NULL, PgpDecryptCommand);
 190 }
 191
 192 pid_t pgp_invoke_sign (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 193                        int pgpinfd, int pgpoutfd, int pgperrfd,
 194                        const char *fname)
 195 {
 196   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 197                      1, fname, NULL, PgpSignAs, NULL, PgpSignCommand);
 198 }
 199
 200
 201 pid_t pgp_invoke_encrypt (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 202                           int pgpinfd, int pgpoutfd, int pgperrfd,
 203                           const char *fname, const char *uids, int sign)
 204 {
 205   if (sign)
 206     return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 207                        1, fname, NULL, PgpSignAs, uids,
 208                        PgpEncryptSignCommand);
 209   else
 210     return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 211                        0, fname, NULL, NULL, uids, PgpEncryptOnlyCommand);
 212 }
 213
 214 pid_t pgp_invoke_traditional (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 215                               int pgpinfd, int pgpoutfd, int pgperrfd,
 216                               const char *fname, const char *uids, int flags)
 217 {
 218   if (flags & ENCRYPT)
 219     return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 220                        flags & SIGN ? 1 : 0, fname, NULL, PgpSignAs, uids,
 221                        flags & SIGN ? PgpEncryptSignCommand :
 222                        PgpEncryptOnlyCommand);
 223   else
 224     return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 225                        1, fname, NULL, PgpSignAs, NULL, PgpClearSignCommand);
 226 }
 227
 228
 229 void pgp_invoke_import (const char *fname)
 230 {
 231   char _fname[_POSIX_PATH_MAX + STRING];
 232   char cmd[HUGE_STRING];
 233   struct pgp_command_context cctx;
 234
 235   p_clear(&cctx, 1);
 236
 237   mutt_quote_filename (_fname, sizeof (_fname), fname);
 238   cctx.fname = _fname;
 239
 240   mutt_pgp_command (cmd, sizeof (cmd), &cctx, PgpImportCommand);
 241   mutt_system (cmd);
 242 }
 243
 244 void pgp_invoke_getkeys (address_t * addr)
 245 {
 246   char buff[LONG_STRING];
 247   char tmp[LONG_STRING];
 248   char cmd[HUGE_STRING];
 249   int devnull;
 250
 251   char *personal;
 252
 253   struct pgp_command_context cctx;
 254
 255   if (!PgpGetkeysCommand)
 256     return;
 257
 258   p_clear(&cctx, 1);
 259
 260   personal = addr->personal;
 261   addr->personal = NULL;
 262
 263   mutt_addrlist_to_local(addr);
 264   rfc822_addrcpy(tmp, sizeof(tmp), addr, 0);
 265   mutt_quote_filename(buff, sizeof(buff), tmp);
 266
 267   addr->personal = personal;
 268
 269   cctx.ids = buff;
 270
 271   mutt_pgp_command (cmd, sizeof (cmd), &cctx, PgpGetkeysCommand);
 272
 273   devnull = open ("/dev/null", O_RDWR);
 274
 275   if (!isendwin ())
 276     mutt_message _("Fetching PGP key...");
 277
 278   mutt_system (cmd);
 279
 280   if (!isendwin ())
 281     mutt_clear_error ();
 282
 283   close (devnull);
 284 }
 285
 286 pid_t pgp_invoke_export (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 287                          int pgpinfd, int pgpoutfd, int pgperrfd,
 288                          const char *uids)
 289 {
 290   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 291                      0, NULL, NULL, NULL, uids, PgpExportCommand);
 292 }
 293
 294 pid_t pgp_invoke_verify_key (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 295                              int pgpinfd, int pgpoutfd, int pgperrfd,
 296                              const char *uids)
 297 {
 298   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 299                      0, NULL, NULL, NULL, uids, PgpVerifyKeyCommand);
 300 }
 301
 302 pid_t pgp_invoke_list_keys (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 303                             int pgpinfd, int pgpoutfd, int pgperrfd,
 304                             pgp_ring_t keyring, string_list_t * hints)
 305 {
 306   char uids[HUGE_STRING];
 307   char tmpuids[HUGE_STRING];
 308   char quoted[HUGE_STRING];
 309
 310   *uids = '\0';
 311
 312   for (; hints; hints = hints->next) {
 313     mutt_quote_filename (quoted, sizeof (quoted), (char *) hints->data);
 314     snprintf (tmpuids, sizeof (tmpuids), "%s %s", uids, quoted);
 315     m_strcpy(uids, sizeof(uids), tmpuids);
 316   }
 317
 318   return pgp_invoke (pgpin, pgpout, pgperr, pgpinfd, pgpoutfd, pgperrfd,
 319                      0, NULL, NULL, NULL, uids,
 320                      keyring == PGP_SECRING ? PgpListSecringCommand :
 321                      PgpListPubringCommand);
 322 }