tools/symcryptrun.c

   1 /* symcryptrun.c - Tool to call simple symmetric encryption tools.
   2  *      Copyright (C) 2005, 2007 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  18  */
  19
  20
  21 /* Sometimes simple encryption tools are already in use for a long
  22    time and there is a desire to integrate them into the GnuPG
  23    framework.  The protocols and encryption methods might be
  24    non-standard or not even properly documented, so that a
  25    full-fledged encryption tool with an interface like gpg is not
  26    doable.  This simple wrapper program provides a solution: It
  27    operates by calling the encryption/decryption module and providing
  28    the passphrase for a key (or even the key directly) using the
  29    standard pinentry mechanism through gpg-agent.  */
  30
  31 /* This program is invoked in the following way:
  32
  33    symcryptrun --class CLASS --program PROGRAM --keyfile KEYFILE \
  34      [--decrypt | --encrypt]
  35
  36    For encryption, the plain text must be provided on STDIN, and the
  37    ciphertext will be output to STDOUT.  For decryption vice versa.
  38
  39    CLASS can currently only be "confucius".
  40
  41    PROGRAM must be the path to the crypto engine.
  42
  43    KEYFILE must contain the secret key, which may be protected by a
  44    passphrase.  The passphrase is retrieved via the pinentry program.
  45
  46
  47    The GPG Agent _must_ be running before starting symcryptrun.
  48
  49    The possible exit status codes:
  50
  51    0    Success
  52    1    Some error occurred
  53    2    No valid passphrase was provided
  54    3    The operation was canceled by the user
  55
  56    Other classes may be added in the future.  */
  57
  58 #define SYMC_BAD_PASSPHRASE     2
  59 #define SYMC_CANCELED           3
  60
  61 \f
  62 #include <config.h>
  63
  64 #include <unistd.h>
  65 #include <stdio.h>
  66 #include <stdlib.h>
  67 #include <string.h>
  68 #include <errno.h>
  69 #include <assert.h>
  70 #include <signal.h>
  71 #include <sys/stat.h>
  72 #include <sys/types.h>
  73 #include <sys/wait.h>
  74 #ifdef HAVE_PTY_H
  75 #include <pty.h>
  76 #endif
  77 #ifdef HAVE_UTMP_H
  78 #include <utmp.h>
  79 #endif
  80 #include <ctype.h>
  81 #ifdef HAVE_LOCALE_H
  82 #include <locale.h>
  83 #endif
  84 #ifdef HAVE_LANGINFO_CODESET
  85 #include <langinfo.h>
  86 #endif
  87 #include <gpg-error.h>
  88
  89 #include "i18n.h"
  90 #include "../common/util.h"
  91 #include "../common/init.h"
  92 #include "../common/sysutils.h"
  93
  94 /* FIXME: Bah.  For spwq_secure_free.  */
  95 #define SIMPLE_PWQUERY_IMPLEMENTATION 1
  96 #include "../common/simple-pwquery.h"
  97
  98 \f
  99 /* From simple-gettext.c.  */
 100
 101 /* We assume to have 'unsigned long int' value with at least 32 bits.  */
 102 #define HASHWORDBITS 32
 103
 104 /* The so called 'hashpjw' function by P.J. Weinberger
 105    [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
 106    1986, 1987 Bell Telephone Laboratories, Inc.]  */
 107
 108 static __inline__ ulong
 109 hash_string( const char *str_param )
 110 {
 111     unsigned long int hval, g;
 112     const char *str = str_param;
 113
 114     hval = 0;
 115     while (*str != '\0')
 116     {
 117         hval <<= 4;
 118         hval += (unsigned long int) *str++;
 119         g = hval & ((unsigned long int) 0xf << (HASHWORDBITS - 4));
 120         if (g != 0)
 121         {
 122           hval ^= g >> (HASHWORDBITS - 8);
 123           hval ^= g;
 124         }
 125     }
 126     return hval;
 127 }
 128
 129 \f
 130 /* Constants to identify the commands and options. */
 131 enum cmd_and_opt_values
 132   {
 133     aNull = 0,
 134     oQuiet      = 'q',
 135     oVerbose    = 'v',
 136
 137     oNoVerbose  = 500,
 138     oOptions,
 139     oNoOptions,
 140     oLogFile,
 141     oHomedir,
 142     oClass,
 143     oProgram,
 144     oKeyfile,
 145     oDecrypt,
 146     oEncrypt,
 147     oInput
 148   };
 149
 150
 151 /* The list of commands and options.  */
 152 static ARGPARSE_OPTS opts[] =
 153   {
 154     { 301, NULL, 0, N_("@\nCommands:\n ") },
 155
 156     { oDecrypt, "decrypt", 0, N_("decryption modus") },
 157     { oEncrypt, "encrypt", 0, N_("encryption modus") },
 158
 159     { 302, NULL, 0, N_("@\nOptions:\n ") },
 160
 161     { oClass, "class", 2, N_("tool class (confucius)") },
 162     { oProgram, "program", 2, N_("program filename") },
 163
 164     { oKeyfile, "keyfile", 2, N_("secret key file (required)") },
 165     { oInput, "inputfile", 2, N_("input file name (default stdin)") },
 166     { oVerbose, "verbose",  0, N_("verbose") },
 167     { oQuiet, "quiet",      0, N_("quiet") },
 168     { oLogFile, "log-file", 2, N_("use a log file for the server") },
 169     { oOptions,  "options"  , 2, N_("|FILE|read options from FILE") },
 170
 171     /* Hidden options.  */
 172     { oNoVerbose, "no-verbose",  0, "@" },
 173     { oHomedir, "homedir", 2, "@" },
 174     { oNoOptions, "no-options", 0, "@" },/* shortcut for --options /dev/null */
 175
 176     {0}
 177   };
 178
 179
 180 /* We keep all global options in the structure OPT.  */
 181 struct
 182 {
 183   int verbose;          /* Verbosity level.  */
 184   int quiet;            /* Be extra quiet.  */
 185   const char *homedir;  /* Configuration directory name */
 186
 187   char *class;
 188   char *program;
 189   char *keyfile;
 190   char *input;
 191 } opt;
 192
 193 \f
 194 /* Print usage information and and provide strings for help.  */
 195 static const char *
 196 my_strusage (int level)
 197 {
 198   const char *p;
 199
 200   switch (level)
 201     {
 202     case 11: p = "symcryptrun (@GNUPG@)";
 203       break;
 204     case 13: p = VERSION; break;
 205     case 17: p = PRINTABLE_OS_NAME; break;
 206     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
 207
 208     case 1:
 209     case 40: p = _("Usage: symcryptrun [options] (-h for help)");
 210       break;
 211     case 41:
 212       p = _("Syntax: symcryptrun --class CLASS --program PROGRAM "
 213             "--keyfile KEYFILE [options...] COMMAND [inputfile]\n"
 214             "Call a simple symmetric encryption tool\n");
 215       break;
 216     case 31: p = "\nHome: "; break;
 217     case 32: p = gnupg_homedir (); break;
 218     case 33: p = "\n"; break;
 219
 220     default: p = NULL; break;
 221     }
 222   return p;
 223 }
 224
 225
 226 \f
 227 /* This is in the GNU C library in unistd.h.  */
 228
 229 #ifndef TEMP_FAILURE_RETRY
 230 /* Evaluate EXPRESSION, and repeat as long as it returns -1 with 'errno'
 231    set to EINTR.  */
 232
 233 # define TEMP_FAILURE_RETRY(expression) \
 234   (__extension__                                                              \
 235     ({ long int __result;                                                     \
 236        do __result = (long int) (expression);                                 \
 237        while (__result == -1L && errno == EINTR);                             \
 238        __result; }))
 239 #endif
 240
 241 /* Unlink a file, and shred it if SHRED is true.  */
 242 int
 243 remove_file (char *name, int shred)
 244 {
 245   if (!shred)
 246     return unlink (name);
 247   else
 248     {
 249       int status;
 250       pid_t pid;
 251
 252       pid = fork ();
 253       if (pid == 0)
 254         {
 255           /* Child.  */
 256
 257           /* -f forces file to be writable, and -u unlinks it afterwards.  */
 258           char *args[] = { SHRED, "-uf", name, NULL };
 259
 260           execv (SHRED, args);
 261           _exit (127);
 262         }
 263       else if (pid < 0)
 264         {
 265           /* Fork failed.  */
 266           status = -1;
 267         }
 268       else
 269         {
 270           /* Parent.  */
 271
 272           if (TEMP_FAILURE_RETRY (waitpid (pid, &status, 0)) != pid)
 273             status = -1;
 274         }
 275
 276       if (!WIFEXITED (status))
 277         {
 278           log_error (_("%s on %s aborted with status %i\n"),
 279                      SHRED, name, status);
 280           unlink (name);
 281           return 1;
 282         }
 283       else if (WEXITSTATUS (status))
 284         {
 285           log_error (_("%s on %s failed with status %i\n"), SHRED, name,
 286                      WEXITSTATUS (status));
 287           unlink (name);
 288           return 1;
 289         }
 290
 291       return 0;
 292     }
 293 }
 294
 295 \f
 296 /* Class Confucius.
 297
 298    "Don't worry that other people don't know you;
 299    worry that you don't know other people."            Analects--1.16.  */
 300
 301 /* Create temporary directory with mode 0700.  Returns a dynamically
 302    allocated string with the filename of the directory.  */
 303 static char *
 304 confucius_mktmpdir (void)
 305 {
 306   char *name, *p;
 307
 308   p = getenv ("TMPDIR");
 309   if (!p || !*p)
 310     p = "/tmp";
 311   if (p[strlen (p) - 1] == '/')
 312     name = xstrconcat (p, "gpg-XXXXXX", NULL);
 313   else
 314     name = xstrconcat (p, "/", "gpg-XXXXXX", NULL);
 315   if (!name || !gnupg_mkdtemp (name))
 316     {
 317       log_error (_("can't create temporary directory '%s': %s\n"),
 318                  name?name:"", strerror (errno));
 319       return NULL;
 320     }
 321
 322   return name;
 323 }
 324
 325
 326 /* Buffer size for I/O operations.  */
 327 #define CONFUCIUS_BUFSIZE 4096
 328
 329 /* Buffer size for output lines.  */
 330 #define CONFUCIUS_LINESIZE 4096
 331
 332
 333 /* Copy the file IN to OUT, either of which may be "-".  If PLAIN is
 334    true, and the copying fails, and OUT is not STDOUT, then shred the
 335    file instead unlinking it.  */
 336 static int
 337 confucius_copy_file (char *infile, char *outfile, int plain)
 338 {
 339   FILE *in;
 340   int in_is_stdin = 0;
 341   FILE *out;
 342   int out_is_stdout = 0;
 343   char data[CONFUCIUS_BUFSIZE];
 344   ssize_t data_len;
 345
 346   if (infile[0] == '-' && infile[1] == '\0')
 347     {
 348       /* FIXME: Is stdin in binary mode?  */
 349       in = stdin;
 350       in_is_stdin = 1;
 351     }
 352   else
 353     {
 354       in = fopen (infile, "rb");
 355       if (!in)
 356         {
 357           log_error (_("could not open %s for writing: %s\n"),
 358                      infile, strerror (errno));
 359           return 1;
 360         }
 361     }
 362
 363   if (outfile[0] == '-' && outfile[1] == '\0')
 364     {
 365       /* FIXME: Is stdout in binary mode?  */
 366       out = stdout;
 367       out_is_stdout = 1;
 368     }
 369   else
 370     {
 371       out = fopen (outfile, "wb");
 372       if (!out)
 373         {
 374           log_error (_("could not open %s for writing: %s\n"),
 375                      infile, strerror (errno));
 376           return 1;
 377         }
 378     }
 379
 380   /* Now copy the data.  */
 381   while ((data_len = fread (data, 1, sizeof (data), in)) > 0)
 382     {
 383       if (fwrite (data, 1, data_len, out) != data_len)
 384         {
 385           log_error (_("error writing to %s: %s\n"), outfile,
 386                      strerror (errno));
 387           goto copy_err;
 388         }
 389     }
 390   if (data_len < 0 || ferror (in))
 391     {
 392       log_error (_("error reading from %s: %s\n"), infile, strerror (errno));
 393       goto copy_err;
 394     }
 395
 396   /* Close IN if appropriate.  */
 397   if (!in_is_stdin && fclose (in) && ferror (in))
 398     {
 399       log_error (_("error closing %s: %s\n"), infile, strerror (errno));
 400       goto copy_err;
 401     }
 402
 403   /* Close OUT if appropriate.  */
 404   if (!out_is_stdout && fclose (out) && ferror (out))
 405     {
 406       log_error (_("error closing %s: %s\n"), infile, strerror (errno));
 407       goto copy_err;
 408     }
 409
 410   return 0;
 411
 412  copy_err:
 413   if (!out_is_stdout)
 414     remove_file (outfile, plain);
 415
 416   return 1;
 417 }
 418
 419
 420 /* Get a passphrase in secure storage (if possible).  If AGAIN is
 421    true, then this is a repeated attempt.  If CANCELED is not a null
 422    pointer, it will be set to true or false, depending on if the user
 423    canceled the operation or not.  On error (including cancelation), a
 424    null pointer is returned.  The passphrase must be deallocated with
 425    confucius_drop_pass.  CACHEID is the ID to be used for passphrase
 426    caching and can be NULL to disable caching.  */
 427 char *
 428 confucius_get_pass (const char *cacheid, int again, int *canceled)
 429 {
 430   int err;
 431   char *pw;
 432   char *orig_codeset;
 433
 434   if (canceled)
 435     *canceled = 0;
 436
 437   orig_codeset = i18n_switchto_utf8 ();
 438   pw = simple_pwquery (cacheid,
 439                        again ? _("does not match - try again"):NULL,
 440                        _("Passphrase:"), NULL, 0, &err);
 441   i18n_switchback (orig_codeset);
 442
 443   if (!pw)
 444     {
 445       if (err)
 446         log_error (_("error while asking for the passphrase: %s\n"),
 447                    gpg_strerror (err));
 448       else
 449         {
 450           log_info (_("cancelled\n"));
 451           if (canceled)
 452             *canceled = 1;
 453         }
 454     }
 455
 456   return pw;
 457 }
 458
 459
 460 /* Drop a passphrase retrieved with confucius_get_pass.  */
 461 void
 462 confucius_drop_pass (char *pass)
 463 {
 464   if (pass)
 465     spwq_secure_free (pass);
 466 }
 467
 468
 469 /* Run a confucius crypto engine.  If MODE is oEncrypt, encryption is
 470    requested.  If it is oDecrypt, decryption is requested.  INFILE and
 471    OUTFILE are the temporary files used in the process.  */
 472 int
 473 confucius_process (int mode, char *infile, char *outfile,
 474                    int argc, char *argv[])
 475 {
 476   char **args;
 477   int cstderr[2];
 478   int master;
 479   int slave;
 480   int res;
 481   pid_t pid;
 482   pid_t wpid;
 483   int tries = 0;
 484   char cacheid[40];
 485
 486   signal (SIGPIPE, SIG_IGN);
 487
 488   if (!opt.program)
 489     {
 490       log_error (_("no --program option provided\n"));
 491       return 1;
 492     }
 493
 494   if (mode != oDecrypt && mode != oEncrypt)
 495     {
 496       log_error (_("only --decrypt and --encrypt are supported\n"));
 497       return 1;
 498     }
 499
 500   if (!opt.keyfile)
 501     {
 502       log_error (_("no --keyfile option provided\n"));
 503       return 1;
 504     }
 505
 506   /* Generate a hash from the keyfile name for caching.  */
 507   snprintf (cacheid, sizeof (cacheid), "confucius:%lu",
 508             hash_string (opt.keyfile));
 509   cacheid[sizeof (cacheid) - 1] = '\0';
 510   args = malloc (sizeof (char *) * (10 + argc));
 511   if (!args)
 512     {
 513       log_error (_("cannot allocate args vector\n"));
 514       return 1;
 515     }
 516   args[0] = opt.program;
 517   args[1] = (mode == oEncrypt) ? "-m1" : "-m2";
 518   args[2] = "-q";
 519   args[3] = infile;
 520   args[4] = "-z";
 521   args[5] = outfile;
 522   args[6] = "-s";
 523   args[7] = opt.keyfile;
 524   args[8] = (mode == oEncrypt) ? "-af" : "-f";
 525   args[9 + argc] = NULL;
 526   while (argc--)
 527     args[9 + argc] = argv[argc];
 528
 529   if (pipe (cstderr) < 0)
 530     {
 531       log_error (_("could not create pipe: %s\n"), strerror (errno));
 532       free (args);
 533       return 1;
 534     }
 535
 536   if (openpty (&master, &slave, NULL, NULL, NULL) == -1)
 537     {
 538       log_error (_("could not create pty: %s\n"), strerror (errno));
 539       close (cstderr[0]);
 540       close (cstderr[1]);
 541       free (args);
 542       return -1;
 543     }
 544
 545   /* We don't want to deal with the worst case scenarios.  */
 546   assert (master > 2);
 547   assert (slave > 2);
 548   assert (cstderr[0] > 2);
 549   assert (cstderr[1] > 2);
 550
 551   pid = fork ();
 552   if (pid < 0)
 553     {
 554       log_error (_("could not fork: %s\n"), strerror (errno));
 555       close (master);
 556       close (slave);
 557       close (cstderr[0]);
 558       close (cstderr[1]);
 559       free (args);
 560       return 1;
 561     }
 562   else if (pid == 0)
 563     {
 564       /* Child.  */
 565
 566       /* Close the parent ends.  */
 567       close (master);
 568       close (cstderr[0]);
 569
 570       /* Change controlling terminal.  */
 571       if (login_tty (slave))
 572         {
 573           /* It's too early to output a debug message.  */
 574           _exit (1);
 575         }
 576
 577       dup2 (cstderr[1], 2);
 578       close (cstderr[1]);
 579
 580       /* Now kick off the engine program.  */
 581       execv (opt.program, args);
 582       log_error (_("execv failed: %s\n"), strerror (errno));
 583       _exit (1);
 584     }
 585   else
 586     {
 587       /* Parent.  */
 588       char buffer[CONFUCIUS_LINESIZE];
 589       int buffer_len = 0;
 590       fd_set fds;
 591       int slave_closed = 0;
 592       int stderr_closed = 0;
 593
 594       close (slave);
 595       close (cstderr[1]);
 596       free (args);
 597
 598       /* Listen on the output FDs.  */
 599       do
 600         {
 601           FD_ZERO (&fds);
 602
 603           if (!slave_closed)
 604             FD_SET (master, &fds);
 605           if (!stderr_closed)
 606             FD_SET (cstderr[0], &fds);
 607
 608           res = select (FD_SETSIZE, &fds, NULL, NULL, NULL);
 609           if (res < 0)
 610             {
 611               log_error (_("select failed: %s\n"), strerror (errno));
 612
 613               kill (pid, SIGTERM);
 614               close (master);
 615               close (cstderr[0]);
 616               return 1;
 617             }
 618
 619           if (FD_ISSET (cstderr[0], &fds))
 620             {
 621               /* We got some output on stderr.  This is just passed
 622                  through via the logging facility.  */
 623
 624               res = read (cstderr[0], &buffer[buffer_len],
 625                           sizeof (buffer) - buffer_len - 1);
 626               if (res < 0)
 627                 {
 628                   log_error (_("read failed: %s\n"), strerror (errno));
 629
 630                   kill (pid, SIGTERM);
 631                   close (master);
 632                   close (cstderr[0]);
 633                   return 1;
 634                 }
 635               else
 636                 {
 637                   char *newline;
 638
 639                   buffer_len += res;
 640                   for (;;)
 641                     {
 642                       buffer[buffer_len] = '\0';
 643                       newline = strchr (buffer, '\n');
 644                       if (newline)
 645                         {
 646                           *newline = '\0';
 647                           log_error ("%s\n", buffer);
 648                           buffer_len -= newline + 1 - buffer;
 649                           memmove (buffer, newline + 1, buffer_len);
 650                         }
 651                       else if (buffer_len == sizeof (buffer) - 1)
 652                         {
 653                           /* Overflow.  */
 654                           log_error ("%s\n", buffer);
 655                           buffer_len = 0;
 656                         }
 657                       else
 658                         break;
 659                     }
 660
 661                   if (res == 0)
 662                     stderr_closed = 1;
 663                 }
 664             }
 665           else if (FD_ISSET (master, &fds))
 666             {
 667               char data[512];
 668
 669               res = read (master, data, sizeof (data));
 670               if (res < 0)
 671                 {
 672                   if (errno == EIO)
 673                     {
 674                       /* Slave-side close leads to readable fd and
 675                          EIO.  */
 676                       slave_closed = 1;
 677                     }
 678                   else
 679                     {
 680                       log_error (_("pty read failed: %s\n"), strerror (errno));
 681
 682                       kill (pid, SIGTERM);
 683                       close (master);
 684                       close (cstderr[0]);
 685                       return 1;
 686                     }
 687                 }
 688               else if (res == 0)
 689                 /* This never seems to be what happens on slave-side
 690                    close.  */
 691                 slave_closed = 1;
 692               else
 693                 {
 694                   /* Check for password prompt.  */
 695                   if (data[res - 1] == ':')
 696                     {
 697                       char *pass;
 698                       int canceled;
 699
 700                       /* If this is not the first attempt, the
 701                          passphrase seems to be wrong, so clear the
 702                          cache.  */
 703                       if (tries)
 704                         simple_pwclear (cacheid);
 705
 706                       pass = confucius_get_pass (cacheid,
 707                                                  tries ? 1 : 0, &canceled);
 708                       if (!pass)
 709                         {
 710                           kill (pid, SIGTERM);
 711                           close (master);
 712                           close (cstderr[0]);
 713                           return canceled ? SYMC_CANCELED : 1;
 714                         }
 715                       write (master, pass, strlen (pass));
 716                       write (master, "\n", 1);
 717                       confucius_drop_pass (pass);
 718
 719                       tries++;
 720                     }
 721                 }
 722             }
 723         }
 724       while (!stderr_closed || !slave_closed);
 725
 726       close (master);
 727       close (cstderr[0]);
 728
 729       wpid = waitpid (pid, &res, 0);
 730       if (wpid < 0)
 731         {
 732           log_error (_("waitpid failed: %s\n"), strerror (errno));
 733
 734           kill (pid, SIGTERM);
 735           /* State of cached password is unclear.  Just remove it.  */
 736           simple_pwclear (cacheid);
 737           return 1;
 738         }
 739       else
 740         {
 741           /* Shouldn't happen, as we don't use WNOHANG.  */
 742           assert (wpid != 0);
 743
 744           if (!WIFEXITED (res))
 745             {
 746               log_error (_("child aborted with status %i\n"), res);
 747
 748               /* State of cached password is unclear.  Just remove it.  */
 749               simple_pwclear (cacheid);
 750
 751               return 1;
 752             }
 753
 754           if (WEXITSTATUS (res))
 755             {
 756               /* The passphrase was wrong.  Remove it from the cache.  */
 757               simple_pwclear (cacheid);
 758
 759               /* We probably exceeded our number of attempts at guessing
 760                  the password.  */
 761               if (tries >= 3)
 762                 return SYMC_BAD_PASSPHRASE;
 763               else
 764                 return 1;
 765             }
 766
 767           return 0;
 768         }
 769     }
 770
 771   /* Not reached.  */
 772 }
 773
 774
 775 /* Class confucius main program.  If MODE is oEncrypt, encryption is
 776    requested.  If it is oDecrypt, decryption is requested.  The other
 777    parameters are taken from the global option data.  */
 778 int
 779 confucius_main (int mode, int argc, char *argv[])
 780 {
 781   int res;
 782   char *tmpdir;
 783   char *infile;
 784   int infile_from_stdin = 0;
 785   char *outfile;
 786
 787   tmpdir = confucius_mktmpdir ();
 788   if (!tmpdir)
 789     return 1;
 790
 791   if (opt.input && !(opt.input[0] == '-' && opt.input[1] == '\0'))
 792     infile = xstrdup (opt.input);
 793   else
 794     {
 795       infile_from_stdin = 1;
 796
 797       /* TMPDIR + "/" + "in" + "\0".  */
 798       infile = malloc (strlen (tmpdir) + 1 + 2 + 1);
 799       if (!infile)
 800         {
 801           log_error (_("cannot allocate infile string: %s\n"),
 802                      strerror (errno));
 803           rmdir (tmpdir);
 804           return 1;
 805         }
 806       strcpy (infile, tmpdir);
 807       strcat (infile, "/in");
 808     }
 809
 810   /* TMPDIR + "/" + "out" + "\0".  */
 811   outfile = malloc (strlen (tmpdir) + 1 + 3 + 1);
 812   if (!outfile)
 813     {
 814       log_error (_("cannot allocate outfile string: %s\n"), strerror (errno));
 815       free (infile);
 816       rmdir (tmpdir);
 817       return 1;
 818     }
 819   strcpy (outfile, tmpdir);
 820   strcat (outfile, "/out");
 821
 822   if (infile_from_stdin)
 823     {
 824       /* Create INFILE and fill it with content.  */
 825       res = confucius_copy_file ("-", infile, mode == oEncrypt);
 826       if (res)
 827         {
 828           free (outfile);
 829           free (infile);
 830           rmdir (tmpdir);
 831           return res;
 832         }
 833     }
 834
 835   /* Run the engine and thus create the output file, handling
 836      passphrase retrieval.  */
 837   res = confucius_process (mode, infile, outfile, argc, argv);
 838   if (res)
 839     {
 840       remove_file (outfile, mode == oDecrypt);
 841       if (infile_from_stdin)
 842         remove_file (infile, mode == oEncrypt);
 843       free (outfile);
 844       free (infile);
 845       rmdir (tmpdir);
 846       return res;
 847     }
 848
 849   /* Dump the output file to stdout.  */
 850   res = confucius_copy_file (outfile, "-", mode == oDecrypt);
 851   if (res)
 852     {
 853       remove_file (outfile, mode == oDecrypt);
 854       if (infile_from_stdin)
 855         remove_file (infile, mode == oEncrypt);
 856       free (outfile);
 857       free (infile);
 858       rmdir (tmpdir);
 859       return res;
 860     }
 861
 862   remove_file (outfile, mode == oDecrypt);
 863   if (infile_from_stdin)
 864     remove_file (infile, mode == oEncrypt);
 865   free (outfile);
 866   free (infile);
 867   rmdir (tmpdir);
 868   return 0;
 869 }
 870
 871 \f
 872 /* symcryptrun's entry point.  */
 873 int
 874 main (int argc, char **argv)
 875 {
 876   ARGPARSE_ARGS pargs;
 877   int orig_argc;
 878   char **orig_argv;
 879   FILE *configfp = NULL;
 880   char *configname = NULL;
 881   unsigned configlineno;
 882   int mode = 0;
 883   int res;
 884   char *logfile = NULL;
 885   int default_config = 1;
 886
 887   early_system_init ();
 888   set_strusage (my_strusage);
 889   log_set_prefix ("symcryptrun", GPGRT_LOG_WITH_PREFIX);
 890
 891   /* Make sure that our subsystems are ready.  */
 892   i18n_init();
 893   init_common_subsystems (&argc, &argv);
 894
 895   /* Check whether we have a config file given on the commandline */
 896   orig_argc = argc;
 897   orig_argv = argv;
 898   pargs.argc = &argc;
 899   pargs.argv = &argv;
 900   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
 901   while (arg_parse( &pargs, opts))
 902     {
 903       if (pargs.r_opt == oOptions)
 904         { /* Yes there is one, so we do not try the default one, but
 905              read the option file when it is encountered at the
 906              commandline */
 907           default_config = 0;
 908         }
 909       else if (pargs.r_opt == oNoOptions)
 910         default_config = 0; /* --no-options */
 911       else if (pargs.r_opt == oHomedir)
 912         gnupg_set_homedir (pargs.r.ret_str);
 913     }
 914
 915   if (default_config)
 916     configname = make_filename (gnupg_homedir (), "symcryptrun.conf", NULL );
 917
 918   argc = orig_argc;
 919   argv = orig_argv;
 920   pargs.argc = &argc;
 921   pargs.argv = &argv;
 922   pargs.flags= 1;  /* do not remove the args */
 923  next_pass:
 924   if (configname)
 925     {
 926       configlineno = 0;
 927       configfp = fopen (configname, "r");
 928       if (!configfp)
 929         {
 930           if (!default_config)
 931             {
 932               log_error (_("option file '%s': %s\n"),
 933                          configname, strerror(errno) );
 934               exit(1);
 935             }
 936           xfree (configname);
 937           configname = NULL;
 938         }
 939       default_config = 0;
 940     }
 941
 942   /* Parse the command line. */
 943   while (optfile_parse (configfp, configname, &configlineno, &pargs, opts))
 944     {
 945       switch (pargs.r_opt)
 946         {
 947         case oDecrypt:   mode = oDecrypt; break;
 948         case oEncrypt:   mode = oEncrypt; break;
 949
 950         case oQuiet:     opt.quiet = 1; break;
 951         case oVerbose:   opt.verbose++; break;
 952         case oNoVerbose: opt.verbose = 0; break;
 953
 954         case oClass:    opt.class = pargs.r.ret_str; break;
 955         case oProgram:  opt.program = pargs.r.ret_str; break;
 956         case oKeyfile:  opt.keyfile = pargs.r.ret_str; break;
 957         case oInput:    opt.input = pargs.r.ret_str; break;
 958
 959         case oLogFile:  logfile = pargs.r.ret_str; break;
 960
 961         case oOptions:
 962           /* Config files may not be nested (silently ignore them) */
 963           if (!configfp)
 964             {
 965                 xfree(configname);
 966                 configname = xstrdup(pargs.r.ret_str);
 967                 goto next_pass;
 968             }
 969           break;
 970         case oNoOptions: break; /* no-options */
 971         case oHomedir: /* Ignore this option here. */; break;
 972
 973         default : pargs.err = configfp? 1:2; break;
 974         }
 975     }
 976   if (configfp)
 977     {
 978       fclose( configfp );
 979       configfp = NULL;
 980       configname = NULL;
 981       goto next_pass;
 982     }
 983   xfree (configname);
 984   configname = NULL;
 985
 986   if (!mode)
 987     log_error (_("either %s or %s must be given\n"),
 988                "--decrypt", "--encrypt");
 989
 990   if (log_get_errorcount (0))
 991     exit (1);
 992
 993   if (logfile)
 994     log_set_file (logfile);
 995
 996   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
 997   setup_libgcrypt_logging ();
 998   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
 999
1000   /* Tell simple-pwquery about the the standard socket name.  */
1001   {
1002     char *tmp = make_filename (gnupg_socketdir (), GPG_AGENT_SOCK_NAME, NULL);
1003     simple_pw_set_socket (tmp);
1004     xfree (tmp);
1005   }
1006
1007   if (!opt.class)
1008     {
1009       log_error (_("no class provided\n"));
1010       res = 1;
1011     }
1012   else if (!strcmp (opt.class, "confucius"))
1013     {
1014       res = confucius_main (mode, argc, argv);
1015     }
1016   else
1017     {
1018       log_error (_("class %s is not supported\n"), opt.class);
1019       res = 1;
1020     }
1021
1022   return res;
1023 }