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