* call-agent.c (gpgsm_agent_havekey): New.
[gnupg.git] / sm / gpgsm.c
1 /* gpgsm.c - GnuPG for S/MIME 
2  *      Copyright (C) 2001 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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29
30 #include <gcrypt.h>
31 #include "gpgsm.h"
32 #include "../assuan/assuan.h" /* malloc hooks */
33 #include "../kbx/keybox.h" /* malloc hooks */
34 #include "i18n.h"
35 #include "keydb.h"
36 #include "sysutils.h"
37
38 enum cmd_and_opt_values {
39   aNull = 0,
40   oArmor        = 'a',
41   aDetachedSign = 'b',
42   aSym          = 'c',
43   aDecrypt      = 'd',
44   aEncr         = 'e',
45   oInteractive  = 'i',
46   oKOption      = 'k',
47   oDryRun       = 'n',
48   oOutput       = 'o',
49   oQuiet        = 'q',
50   oRecipient    = 'r',
51   aSign         = 's',
52   oTextmodeShort= 't',
53   oUser         = 'u',
54   oVerbose      = 'v',
55   oCompress     = 'z',
56   oNotation     = 'N',
57   oBatch        = 500,
58   aClearsign,
59   aStore,
60   aKeygen,
61   aSignEncr,
62   aSignKey,
63   aLSignKey,
64   aListPackets,
65   aEditKey,
66   aDeleteKey,
67   aImport,
68   aVerify,
69   aVerifyFiles,
70   aListKeys,
71   aListSigs,
72   aListSecretKeys,
73   aSendKeys,
74   aRecvKeys,
75   aExport,
76   aExportAll,
77   aCheckKeys,
78   aServer,                        
79
80   oOptions,
81   oDebug,
82   oDebugAll,
83   oDebugWait,
84
85   oEnableSpecialFilenames,
86   oAgentProgram,
87   oDirmngrProgram,
88
89
90
91
92   oAssumeArmor,
93   oAssumeBase64,
94   oAssumeBinary,
95
96   oBase64,
97   oNoArmor,
98
99   oDisableCRLChecks,
100   oEnableCRLChecks,
101
102   oIncludeCerts,
103
104
105
106
107
108
109
110   oTextmode,
111   oFingerprint,
112   oWithFingerprint,
113   oAnswerYes,
114   oAnswerNo,
115   oKeyring,
116   oSecretKeyring,
117   oDefaultKey,
118   oDefRecipient,
119   oDefRecipientSelf,
120   oNoDefRecipient,
121   oStatusFD,
122   oNoComment,
123   oNoVersion,
124   oEmitVersion,
125   oCompletesNeeded,
126   oMarginalsNeeded,
127   oMaxCertDepth,
128   oLoadExtension,
129   oRFC1991,
130   oOpenPGP,
131   oCipherAlgo,
132   oDigestAlgo,
133   oCompressAlgo,
134   oPasswdFD,
135   oCommandFD,
136   oNoVerbose,
137   oTrustDBName,
138   oNoSecmemWarn,
139   oNoDefKeyring,
140   oNoGreeting,
141   oNoTTY,
142   oNoOptions,
143   oNoBatch,
144   oHomedir,
145   oWithColons,
146   oWithKeyData,
147   oSkipVerify,
148   oCompressKeys,
149   oCompressSigs,
150   oAlwaysTrust,
151   oRunAsShmCP,
152   oSetFilename,
153   oSetPolicyURL,
154   oUseEmbeddedFilename,
155   oComment,
156   oDefaultComment,
157   oThrowKeyid,
158   oForceV3Sigs,
159   oForceMDC,
160   oS2KMode,
161   oS2KDigest,
162   oS2KCipher,
163   oCharset,
164   oNotDashEscaped,
165   oEscapeFrom,
166   oLockOnce,
167   oLockMultiple,
168   oLockNever,
169   oKeyServer,
170   oEncryptTo,
171   oNoEncryptTo,
172   oLoggerFD,
173   oUtf8Strings,
174   oNoUtf8Strings,
175   oDisableCipherAlgo,
176   oDisablePubkeyAlgo,
177   oAllowNonSelfsignedUID,
178   oAllowFreeformUID,
179   oNoLiteral,
180   oSetFilesize,
181   oHonorHttpProxy,
182   oFastListMode,
183   oListOnly,
184   oIgnoreTimeConflict,
185   oNoRandomSeedFile,
186   oNoAutoKeyRetrieve,
187   oUseAgent,
188   oMergeOnly,
189   oTryAllSecrets,
190   oTrustedKey,
191   oEmuMDEncodeBug,
192   aDummy
193  };
194
195
196 static ARGPARSE_OPTS opts[] = {
197
198     { 300, NULL, 0, N_("@Commands:\n ") },
199
200     { aSign, "sign",      256, N_("|[file]|make a signature")},
201     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature") },
202     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
203     { aEncr, "encrypt",   256, N_("encrypt data")},
204     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
205     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
206     { aVerify, "verify"   , 256, N_("verify a signature")},
207     { aVerifyFiles, "verify-files" , 256, "@" },
208     { aListKeys, "list-keys", 256, N_("list keys")},
209     { aListKeys, "list-public-keys", 256, "@" },
210     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
211     { aDummy,    "list-sigs", 256, "@"}, 
212     { aDummy,    "check-sigs",256, "@"},
213     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
214     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
215     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
216     { aDeleteKey, "delete-key",256, N_("remove key from the public keyring")},
217     { aExport, "export"           , 256, N_("export keys") },
218     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
219     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
220     { aImport, "import",      256     , N_("import/merge keys")},
221     { aServer, "server",      256, N_("run in server mode")},
222     
223
224     { 301, NULL, 0, N_("@\nOptions:\n ") },
225
226     { oArmor, "armor",     0, N_("create ascii armored output")},
227     { oArmor, "armour",    0, "@" },
228     { oBase64, "base64",    0, N_("create base-64 encoded output")},
229     
230     { oAssumeArmor,  "assume-armor", 0, N_("assume input is in PEM format")},
231     { oAssumeBase64, "assume-base64", 0,
232                                       N_("assume input is in base-64 format")},
233     { oAssumeBase64, "assume-binary", 0,
234                                       N_("assume input is in binary format")},
235
236     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
237
238
239     { oDisableCRLChecks, "disable-crl-checks", 0, N_("never consult a CRL")},
240     { oEnableCRLChecks, "enable-crl-checks", 0, "@"},
241
242     { oIncludeCerts, "include-certs", 1,
243                                  N_("|N|number of certificates to include") },
244
245
246 #if 0
247     { oDefRecipient, "default-recipient" ,2,
248                                   N_("|NAME|use NAME as default recipient")},
249     { oDefRecipientSelf, "default-recipient-self" ,0,
250                                 N_("use the default key as default recipient")},
251     { oNoDefRecipient, "no-default-recipient", 0, "@" },
252     { oEncryptTo, "encrypt-to", 2, "@" },
253     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
254
255 #endif
256     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
257
258 #if 0
259     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
260     { oTextmodeShort, NULL,   0, "@"},
261     { oTextmode, "textmode",  0, N_("use canonical text mode")},
262 #endif
263
264     { oOutput, "output",    2, N_("use as output file")},
265     { oVerbose, "verbose",   0, N_("verbose") },
266     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
267     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
268 #if 0
269     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
270     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
271 #endif
272     { oDryRun, "dry-run",   0, N_("do not make any changes") },
273   /*{ oInteractive, "interactive", 0, N_("prompt before overwriting") }, */
274     /*{ oUseAgent, "use-agent",0, N_("use the gpg-agent")},*/
275     { oBatch, "batch",     0, N_("batch mode: never ask")},
276     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
277     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
278
279     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
280     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
281     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
282     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
283     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
284     { oOptions, "options"   , 2, N_("read options from file")},
285
286     { oDebug, "debug"     ,4|16, "@"},
287     { oDebugAll, "debug-all" ,0, "@"},
288     { oDebugWait, "debug-wait" ,1, "@"},
289     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
290     { aDummy, "no-comment", 0,   "@"},
291     { aDummy, "completes-needed", 1, "@"},
292     { aDummy, "marginals-needed", 1, "@"},
293     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
294     { aDummy, "trusted-key", 2, "@"},
295     { oLoadExtension, "load-extension" ,2,
296       N_("|FILE|load extension module FILE")},
297     { aDummy, "rfc1991",   0, "@"},
298     { aDummy, "openpgp",   0, "@"},
299     { aDummy, "s2k-mode",  1, "@"},
300     { aDummy, "s2k-digest-algo",2, "@"},
301     { aDummy, "s2k-cipher-algo",2, "@"},
302     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
303     { oDigestAlgo, "digest-algo", 2 ,
304       N_("|NAME|use message digest algorithm NAME")},
305 #if 0
306     { oCompressAlgo, "compress-algo", 1 , N_("|N|use compress algorithm N")},
307 #endif
308     { aDummy, "throw-keyid", 0, "@"},
309     { aDummy, "notation-data", 2, "@"},
310
311     { 302, NULL, 0, N_(
312   "@\n(See the man page for a complete listing of all commands and options)\n"
313                       )},
314
315     { 303, NULL, 0, N_("@\nExamples:\n\n"
316     " -se -r Bob [file]          sign and encrypt for user Bob\n"
317     " --clearsign [file]         make a clear text signature\n"
318     " --detach-sign [file]       make a detached signature\n"
319     " --list-keys [names]        show keys\n"
320     " --fingerprint [names]      show fingerprints\n"  ) },
321
322   /* hidden options */
323     { oNoVerbose, "no-verbose", 0, "@"},
324
325     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
326
327
328     { oTrustDBName, "trustdb-name", 2, "@" },
329     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, 
330     { oNoArmor, "no-armor",   0, "@"},
331     { oNoArmor, "no-armour",   0, "@"},
332     { oNoDefKeyring, "no-default-keyring", 0, "@" },
333     { oNoGreeting, "no-greeting", 0, "@" },
334     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
335     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
336     { oAgentProgram, "agent-program", 2 , "@" },
337     { oDirmngrProgram, "dirmngr-program", 2 , "@" },
338
339     { oNoBatch, "no-batch", 0, "@" },
340     { oWithColons, "with-colons", 0, "@"},
341     { oWithKeyData,"with-key-data", 0, "@"},
342     { aListKeys, "list-key", 0, "@" }, /* alias */
343     { aListSigs, "list-sig", 0, "@" }, /* alias */
344     { aCheckKeys, "check-sig",0, "@" }, /* alias */
345     { oSkipVerify, "skip-verify",0, "@" },
346     { oCompressKeys, "compress-keys",0, "@"},
347     { oCompressSigs, "compress-sigs",0, "@"},
348     { oAlwaysTrust, "always-trust", 0, "@"},
349     { oNoVersion, "no-version", 0, "@"},
350     { oLockOnce, "lock-once", 0, "@" },
351     { oLockMultiple, "lock-multiple", 0, "@" },
352     { oLockNever, "lock-never", 0, "@" },
353     { oLoggerFD, "logger-fd",1, "@" },
354     { oWithFingerprint, "with-fingerprint", 0, "@" },
355     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
356     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
357     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
358     { oListOnly, "list-only", 0, "@"},
359     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
360     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
361 {0} };
362
363
364
365 int gpgsm_errors_seen = 0;
366
367 /* It is possible that we are currentlu running under setuid permissions */
368 static int maybe_setuid = 1;
369
370 /* Option --enable-special-filenames */
371 static int allow_special_filenames;
372
373
374 static char *build_list (const char *text,
375                          const char *(*mapf)(int), int (*chkf)(int));
376 static void set_cmd (enum cmd_and_opt_values *ret_cmd,
377                      enum cmd_and_opt_values new_cmd );
378
379 static int check_special_filename (const char *fname);
380 static int open_read (const char *filename);
381
382
383 static int
384 our_pk_test_algo (int algo)
385 {
386   return 1;
387 }
388
389 static int
390 our_cipher_test_algo (int algo)
391 {
392   return 1;
393 }
394
395 static int
396 our_md_test_algo (int algo)
397 {
398   return 1;
399 }
400
401 static const char *
402 my_strusage( int level )
403 {
404   static char *digests, *pubkeys, *ciphers;
405   const char *p;
406
407   switch (level)
408     {
409     case 11: p = "gpgsm (GnuPG)";
410       break;
411     case 13: p = VERSION; break;
412     case 17: p = PRINTABLE_OS_NAME; break;
413     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
414       break;
415     case 1:
416     case 40: p = _("Usage: gpgsm [options] [files] (-h for help)");
417       break;
418     case 41:
419       p = _("Syntax: gpgsm [options] [files]\n"
420             "sign, check, encrypt or decrypt using the S/MIME protocol\n"
421             "default operation depends on the input data\n");
422       break;
423
424     case 31: p = "\nHome: "; break;
425     case 32: p = opt.homedir; break;
426     case 33: p = _("\nSupported algorithms:\n"); break;
427     case 34:
428       if (!ciphers)
429         ciphers = build_list ("Cipher: ", gcry_cipher_algo_name,
430                               our_cipher_test_algo );
431       p = ciphers;
432       break;
433     case 35:
434       if (!pubkeys)
435         pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
436                               our_pk_test_algo );
437       p = pubkeys;
438       break;
439     case 36:
440       if (!digests)
441         digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
442       p = digests;
443       break;
444       
445     default: p = NULL; break;
446     }
447   return p;
448 }
449
450
451 static char *
452 build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
453 {
454   int i;
455   size_t n=strlen(text)+2;
456   char *list, *p;
457   
458   if (maybe_setuid) {
459     gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
460   }
461
462   for (i=1; i < 110; i++ )
463     if (!chkf(i))
464       n += strlen(mapf(i)) + 2;
465   list = xmalloc (21 + n);
466   *list = 0;
467   for (p=NULL, i=1; i < 110; i++)
468     {
469       if (!chkf(i))
470         {
471           if( !p )
472             p = stpcpy (list, text );
473           else
474             p = stpcpy (p, ", ");
475           p = stpcpy (p, mapf(i) );
476         }
477     }
478   if (p)
479     p = stpcpy(p, "\n" );
480   return list;
481 }
482
483
484 static void
485 i18n_init(void)
486 {
487 #ifdef USE_SIMPLE_GETTEXT
488   set_gettext_file (PACKAGE);
489 #else
490 # ifdef ENABLE_NLS
491 #  ifdef HAVE_LC_MESSAGES
492   setlocale (LC_TIME, "");
493   setlocale (LC_MESSAGES, "");
494 #  else
495   setlocale (LC_ALL, "" );
496 #  endif
497   bindtextdomain (PACKAGE, GNUPG_LOCALEDIR);
498   textdomain (PACKAGE);
499 # endif
500 #endif
501 }
502
503
504 static void
505 wrong_args (const char *text)
506 {
507   fputs (_("usage: gpgsm [options] "), stderr);
508   fputs (text, stderr);
509   putc ('\n', stderr);
510   gpgsm_exit (2);
511 }
512
513
514 static void
515 set_debug(void)
516 {
517   if (opt.debug & DBG_MPI_VALUE)
518     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
519   if (opt.debug & DBG_CRYPTO_VALUE )
520     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
521 }
522
523
524 static void
525 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
526 {
527   enum cmd_and_opt_values cmd = *ret_cmd;
528
529   if (!cmd || cmd == new_cmd)
530     cmd = new_cmd;
531   else if ( cmd == aSign && new_cmd == aEncr )
532     cmd = aSignEncr;
533   else if ( cmd == aEncr && new_cmd == aSign )
534     cmd = aSignEncr;
535   else if ( (cmd == aSign && new_cmd == aClearsign)
536             || (cmd == aClearsign && new_cmd == aSign) )
537     cmd = aClearsign;
538   else 
539     {
540       log_error(_("conflicting commands\n"));
541       gpgsm_exit(2);
542     }
543
544   *ret_cmd = cmd;
545 }
546
547
548 int
549 main ( int argc, char **argv)
550 {
551   ARGPARSE_ARGS pargs;
552   int orig_argc;
553   char **orig_argv;
554   const char *fname;
555   /*  char *username;*/
556   int may_coredump;
557   STRLIST sl, remusr= NULL, locusr=NULL;
558   STRLIST nrings=NULL;
559   int detached_sig = 0;
560   FILE *configfp = NULL;
561   char *configname = NULL;
562   unsigned configlineno;
563   int parse_debug = 0;
564   int default_config =1;
565   int default_keyring = 1;
566   int greeting = 0;
567   int nogreeting = 0;
568   int debug_wait = 0;
569   int use_random_seed = 1;
570   int with_fpr = 0;
571   char *def_digest_string = NULL;
572   enum cmd_and_opt_values cmd = 0;
573   struct server_control_s ctrl;
574   CERTLIST recplist = NULL;
575
576   /* FIXME: trap_unaligned ();*/
577   set_strusage (my_strusage);
578   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
579   /* Please note that we may running SUID(ROOT), so be very CAREFUL
580      when adding any stuff between here and the call to secmem_init()
581      somewhere after the option parsing */
582   log_set_prefix ("gpgsm", 1);
583   /* check that the libraries are suitable.  Do it here because the
584      option parse may need services of the library */
585   if (!gcry_check_version ( "1.1.4" ) )
586     {
587       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
588                  VERSION, gcry_check_version (NULL) );
589     }
590
591   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
592
593   may_coredump = disable_core_dumps ();
594   
595   /* FIXME: init_signals();*/
596   
597   create_dotlock (NULL); /* register locking cleanup */
598   i18n_init();
599
600   opt.def_cipher_algoid = "1.2.840.113549.3.7";  /*des-EDE3-CBC*/
601 #ifdef __MINGW32__
602   opt.homedir = read_w32_registry_string ( NULL,
603                                            "Software\\GNU\\GnuPG", "HomeDir" );
604 #else
605   opt.homedir = getenv ("GNUPGHOME");
606 #endif
607   if (!opt.homedir || !*opt.homedir ) 
608     {
609       opt.homedir = "~/.gnupg-test" /*fixme: GNUPG_HOMEDIR*/;
610     }
611
612   /* first check whether we have a config file on the commandline */
613   orig_argc = argc;
614   orig_argv = argv;
615   pargs.argc = &argc;
616   pargs.argv = &argv;
617   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
618   while (arg_parse( &pargs, opts))
619     {
620       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
621         parse_debug++;
622       else if (pargs.r_opt == oOptions)
623         { /* yes there is one, so we do not try the default one but
624              read the config file when it is encountered at the
625              commandline */
626           default_config = 0;
627         }
628       else if (pargs.r_opt == oNoOptions)
629         default_config = 0; /* --no-options */
630       else if (pargs.r_opt == oHomedir)
631         opt.homedir = pargs.r.ret_str;
632     }
633   
634   
635   /* initialize the secure memory. */
636   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
637   maybe_setuid = 0;
638
639   /* 
640      Now we are now working under our real uid 
641   */
642
643   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
644   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
645   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
646
647   /* Setup a default control structure for command line mode */
648   memset (&ctrl, 0, sizeof ctrl);
649   gpgsm_init_default_ctrl (&ctrl);
650   ctrl.no_server = 1;
651   ctrl.status_fd = -1; /* not status output */
652   ctrl.autodetect_encoding = 1;
653
654   /* set the default option file */
655   if (default_config )
656     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
657   
658   argc        = orig_argc;
659   argv        = orig_argv;
660   pargs.argc  = &argc;
661   pargs.argv  = &argv;
662   pargs.flags =  1;  /* do not remove the args */
663
664  next_pass:
665   if (configname) {
666     configlineno = 0;
667     configfp = fopen (configname, "r");
668     if (!configfp)
669       {
670         if (default_config)
671           {
672             if (parse_debug)
673               log_info (_("NOTE: no default option file `%s'\n"), configname);
674           }
675         else 
676           {
677             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
678             gpgsm_exit(2);
679           }
680         xfree(configname);
681         configname = NULL;
682       }
683     if (parse_debug && configname)
684       log_info (_("reading options from `%s'\n"), configname);
685     default_config = 0;
686   }
687
688   while (optfile_parse (configfp, configname, &configlineno, &pargs, opts))
689     {
690       switch (pargs.r_opt)
691         {
692         case aServer: 
693           opt.batch = 1;
694           set_cmd (&cmd, aServer);
695           break;
696
697         case aCheckKeys: set_cmd (&cmd, aCheckKeys); break;
698         case aImport: set_cmd (&cmd, aImport); break;
699         case aSendKeys: set_cmd (&cmd, aSendKeys); break;
700         case aRecvKeys: set_cmd (&cmd, aRecvKeys); break;
701         case aExport: set_cmd (&cmd, aExport); break;
702         case aListKeys: set_cmd (&cmd, aListKeys); break;
703         case aListSecretKeys: set_cmd (&cmd, aListSecretKeys); break;
704
705         case aDeleteKey:
706           set_cmd (&cmd, aDeleteKey);
707           greeting=1;
708           break;
709
710         case aDetachedSign:
711           detached_sig = 1;
712           set_cmd (&cmd, aSign ); 
713           break;
714           
715         case aSym: set_cmd (&cmd, aSym); break;
716         case aDecrypt: set_cmd (&cmd, aDecrypt); break;
717         case aEncr: set_cmd (&cmd, aEncr); break;
718         case aSign: set_cmd (&cmd, aSign );  break;
719         case aKeygen: set_cmd (&cmd, aKeygen); greeting=1; break;
720         case aClearsign: set_cmd (&cmd, aClearsign); break;
721         case aVerify: set_cmd (&cmd, aVerify); break;
722
723           /* output encoding selection */
724         case oArmor:
725           ctrl.create_pem = 1;
726           break;
727         case oBase64: 
728           ctrl.create_pem = 0;
729           ctrl.create_base64 = 1;
730           break;
731         case oNoArmor: 
732           ctrl.create_pem = 0;
733           ctrl.create_base64 = 0;
734           break;
735           
736           /* Input encoding selection */
737         case oAssumeArmor:
738           ctrl.autodetect_encoding = 0;
739           ctrl.is_pem = 1;
740           ctrl.is_base64 = 0;
741           break;
742         case oAssumeBase64:
743           ctrl.autodetect_encoding = 0;
744           ctrl.is_pem = 0;
745           ctrl.is_base64 = 1;
746           break;
747         case oAssumeBinary:
748           ctrl.autodetect_encoding = 0;
749           ctrl.is_pem = 0;
750           ctrl.is_base64 = 0;
751           break;
752
753         case oDisableCRLChecks:
754           opt.no_crl_check = 1;
755           break;
756         case oEnableCRLChecks:
757           opt.no_crl_check = 0;
758           break;
759
760         case oIncludeCerts: ctrl.include_certs = pargs.r.ret_int; break;
761
762         case oOutput: opt.outfile = pargs.r.ret_str; break;
763
764         
765         case oQuiet: opt.quiet = 1; break;
766         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
767         case oDryRun: opt.dry_run = 1; break;
768
769         case oVerbose:
770           opt.verbose++;
771           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
772           break;
773         case oNoVerbose:
774           opt.verbose = 0;
775           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
776           break;
777           
778         case oBatch: 
779           opt.batch = 1;
780           greeting = 0;
781           break;
782         case oNoBatch: opt.batch = 0; break;
783           
784         case oAnswerYes: opt.answer_yes = 1; break;
785         case oAnswerNo: opt.answer_no = 1; break;
786
787         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
788
789         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
790         case oDebugAll: opt.debug = ~0; break;
791         case oDebugWait: debug_wait = pargs.r.ret_int; break;
792
793         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
794         case oLoggerFD: /* fixme: log_set_logfile (NULL, pargs.r.ret_int );*/ break;
795         case oWithFingerprint:
796           with_fpr=1; /*fall thru*/
797         case oFingerprint:
798           opt.fingerprint++;
799           break;
800
801         case oOptions:
802           /* config files may not be nested (silently ignore them) */
803           if (!configfp)
804             {
805               xfree(configname);
806               configname = xstrdup (pargs.r.ret_str);
807               goto next_pass;
808             }
809           break;
810         case oNoOptions: break; /* no-options */
811         case oHomedir: opt.homedir = pargs.r.ret_str; break;
812         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
813         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
814           
815         case oNoDefKeyring: default_keyring = 0; break;
816         case oNoGreeting: nogreeting = 1; break;
817
818         case oDefaultKey:
819           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
820           break;
821         case oDefRecipient:
822           if (*pargs.r.ret_str)
823             opt.def_recipient = xstrdup (pargs.r.ret_str);
824           break;
825         case oDefRecipientSelf:
826           xfree (opt.def_recipient);
827           opt.def_recipient = NULL;
828           opt.def_recipient_self = 1;
829           break;
830         case oNoDefRecipient:
831           xfree (opt.def_recipient);
832           opt.def_recipient = NULL;
833           opt.def_recipient_self = 0;
834           break;
835
836         case oWithKeyData: opt.with_key_data=1; /* fall thru */
837         case oWithColons: ctrl.with_colons = 1; break;
838
839         case oSkipVerify: opt.skip_verify=1; break;
840
841         case oNoEncryptTo: /*fixme: opt.no_encrypt_to = 1;*/ break;
842         case oEncryptTo: /* store the recipient in the second list */
843           sl = add_to_strlist (&remusr, pargs.r.ret_str);
844           sl->flags = 1;
845           break;
846
847         case oRecipient: /* store the recipient */
848           add_to_strlist ( &remusr, pargs.r.ret_str);
849           break;
850
851         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
852         case oTextmode: /*fixme:opt.textmode=1;*/  break;
853
854         case oUser: /* store the local users */
855           add_to_strlist ( &locusr, pargs.r.ret_str);
856           break;
857
858         case oNoSecmemWarn:
859           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
860           break;
861
862         case oCipherAlgo:
863           opt.def_cipher_algoid = pargs.r.ret_str;
864           break;
865
866         case oDisableCipherAlgo: 
867           {
868             int algo = gcry_cipher_map_name (pargs.r.ret_str);
869             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
870           }
871           break;
872         case oDisablePubkeyAlgo: 
873           {
874             int algo = gcry_pk_map_name (pargs.r.ret_str);
875             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
876           }
877           break;
878
879         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
880         case oNoRandomSeedFile: use_random_seed = 0; break;
881
882         case oEnableSpecialFilenames: allow_special_filenames =1; break;
883           
884
885         case aDummy:
886           break;
887         default: 
888           pargs.err = configfp? 1:2; 
889           break;
890         }
891     }
892
893   if (configfp)
894     {
895       fclose (configfp);
896       configfp = NULL;
897       xfree (configname);
898       configname = NULL;
899       goto next_pass;
900     }
901   
902   xfree (configname);
903   configname = NULL;
904
905   if (log_get_errorcount(0))
906     gpgsm_exit(2);
907   
908   if (nogreeting)
909     greeting = 0;
910   
911   if (greeting)
912     {
913       fprintf(stderr, "%s %s; %s\n",
914               strusage(11), strusage(13), strusage(14) );
915       fprintf(stderr, "%s\n", strusage(15) );
916     }
917 #  ifdef IS_DEVELOPMENT_VERSION
918   if (!opt.batch)
919     {
920       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
921       log_info ("It is only intended for test purposes and should NOT be\n");
922       log_info ("used in a production environment or with production keys!\n");
923     }
924 #  endif
925
926   if (may_coredump && !opt.quiet)
927     log_info (_("WARNING: program may create a core file!\n"));
928   
929 /*FIXME    if (opt.batch) */
930 /*      tty_batchmode (1); */
931
932   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
933
934   set_debug ();
935
936   /* FIXME: should set filenames of libgcrypt explicitly
937    * gpg_opt_homedir = opt.homedir; */
938
939   /* must do this after dropping setuid, because the mapping functions
940      may try to load an module and we may have disabled an algorithm */
941   if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
942        || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
943     log_error (_("selected cipher algorithm is invalid\n"));
944
945   if (def_digest_string)
946     {
947       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
948       xfree (def_digest_string);
949       def_digest_string = NULL;
950       if (our_md_test_algo(opt.def_digest_algo) )
951         log_error (_("selected digest algorithm is invalid\n"));
952     }
953
954   if (log_get_errorcount(0))
955     gpgsm_exit(2);
956   
957   /* set the random seed file */
958   if (use_random_seed) {
959     char *p = make_filename (opt.homedir, "random_seed", NULL);
960 #if 0
961 #warning set_random_seed_file not yet available in Libgcrypt
962     set_random_seed_file(p);
963 #endif
964     xfree(p);
965   }
966
967
968   if (!cmd && opt.fingerprint && !with_fpr)
969     set_cmd (&cmd, aListKeys);
970   
971   if (!nrings && default_keyring)  /* add default keybox */
972     keydb_add_resource ("pubring.kbx", 0, 0);
973   for (sl = nrings; sl; sl = sl->next)
974     keydb_add_resource (sl->d, 0, 0);
975   FREE_STRLIST(nrings);
976
977   for (sl = remusr; sl; sl = sl->next)
978     {
979       int rc = gpgsm_add_to_certlist (sl->d, &recplist);
980       if (rc)
981         log_error (_("can't encrypt to `%s': %s\n"),
982                    sl->d, gnupg_strerror (rc));
983     }
984   if (log_get_errorcount(0))
985     gpgsm_exit(1); /* must stop for invalid recipients */
986   
987
988   
989   fname = argc? *argv : NULL;
990   
991   switch (cmd)
992     {
993     case aServer:
994       if (debug_wait)
995         {
996           log_debug ("waiting for debugger - my pid is %u .....\n",
997                      (unsigned int)getpid());
998           sleep (debug_wait);
999           log_debug ("... okay\n");
1000          }
1001       gpgsm_server ();
1002       break;
1003
1004     case aEncr: /* encrypt the given file */
1005       if (!argc)
1006         gpgsm_encrypt (&ctrl, recplist, 0, stdout); /* from stdin */
1007       else if (argc == 1)
1008         gpgsm_encrypt (&ctrl, recplist, open_read (*argv), stdout); /* from file */
1009       else
1010         wrong_args (_("--encrypt [datafile]"));
1011       break;
1012
1013     case aSign: /* sign the given file */
1014       /* FIXME: we can only do detached sigs for now and we don't
1015          handle --output yet. We should also allow to concatenate
1016          multiple files for signins because that is what gpg does.*/
1017       if (!argc)
1018         gpgsm_sign (&ctrl, 0, 1, stdout); /* create from stdin */
1019       else if (argc == 1)
1020         gpgsm_sign (&ctrl, open_read (*argv), 1, stdout); /* from file */
1021       else
1022         wrong_args (_("--sign [datafile]"));
1023       break;
1024 #if 0
1025       sl = NULL;
1026       if (detached_sig)
1027         { /* sign all files */
1028           for (; argc; argc--, argv++ )
1029             add_to_strlist ( &sl, *argv );
1030         }
1031       else
1032         {
1033           if (argc > 1 )
1034             wrong_args (_("--sign [filename]"));
1035           if (argc)
1036             {
1037               sl = xcalloc (1, sizeof *sl + strlen(fname));
1038               strcpy(sl->d, fname);
1039             }
1040         }
1041       if ( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1042         log_error ("signing failed: %s\n", gpg_errstr(rc) );
1043       free_strlist(sl);
1044 #endif
1045       break;
1046         
1047     case aSignEncr: /* sign and encrypt the given file */
1048 #if 0
1049       if (argc > 1)
1050         wrong_args(_("--sign --encrypt [filename]"));
1051       if (argc)
1052         {
1053           sl = xcalloc( 1, sizeof *sl + strlen(fname));
1054           strcpy(sl->d, fname);
1055         }
1056       else
1057         sl = NULL;
1058
1059       if ( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1060         log_error ("%s: sign+encrypt failed: %s\n",
1061                    print_fname_stdin(fname), gpg_errstr(rc) );
1062       free_strlist(sl);
1063 #endif
1064       break;
1065
1066     case aClearsign: /* make a clearsig */
1067 #if 0
1068       if (argc > 1)
1069         wrong_args (_("--clearsign [filename]"));
1070       if ( (rc = clearsign_file(fname, locusr, NULL)) )
1071         log_error ("%s: clearsign failed: %s\n",
1072                    print_fname_stdin(fname), gpg_errstr(rc) );
1073 #endif
1074       break;
1075
1076     case aVerify:
1077       if (!argc)
1078         gpgsm_verify (&ctrl, 0, -1, NULL); /* normal signature from stdin */
1079       else if (argc == 1)
1080         gpgsm_verify (&ctrl, open_read (*argv), -1, NULL); /* std signature */
1081       else if (argc == 2) /* detached signature (sig, detached) */
1082         gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1083       else
1084         wrong_args (_("--verify [signature [detached_data]]"));
1085       break;
1086
1087     case aVerifyFiles:
1088 /*        if ((rc = verify_files( argc, argv ))) */
1089 /*          log_error ("verify files failed: %s\n", gpg_errstr(rc) ); */
1090       break;
1091
1092     case aDecrypt:
1093       if (!argc)
1094         gpgsm_decrypt (&ctrl, 0, stdout); /* from stdin */
1095       else if (argc == 1)
1096         gpgsm_decrypt (&ctrl, open_read (*argv), stdout); /* from file */
1097       else
1098         wrong_args (_("--decrypt [filename]"));
1099       break;
1100
1101     case aDeleteKey:
1102       if (argc != 1)
1103         wrong_args(_("--delete-key user-id"));
1104 /*        username = make_username (fname); */
1105 /*        if( (rc = delete_key(username)) ) */
1106 /*          log_error ("%s: delete key failed: %s\n", username, gpg_errstr(rc) ); */
1107 /*        xfree(username); */
1108       break;
1109
1110     case aListKeys:
1111       for (sl=NULL; argc; argc--, argv++)
1112         add_to_strlist (&sl, *argv);
1113       gpgsm_list_keys (&ctrl, sl, stdout, 0);
1114       free_strlist(sl);
1115       break;
1116
1117     case aListSecretKeys:
1118       for (sl=NULL; argc; argc--, argv++)
1119         add_to_strlist (&sl, *argv);
1120       gpgsm_list_keys (&ctrl, sl, stdout, 2);
1121       free_strlist(sl);
1122       break;
1123
1124     case aKeygen: /* generate a key */
1125 /*        if (opt.batch) */
1126 /*          { */
1127 /*            if (argc > 1) */
1128 /*              wrong_args("--gen-key [parameterfile]"); */
1129 /*            generate_keypair (argc? *argv : NULL); */
1130 /*      } */
1131 /*        else */
1132 /*          { */
1133 /*            if (argc) */
1134 /*              wrong_args ("--gen-key"); */
1135 /*            generate_keypair(NULL); */
1136 /*      } */
1137       break;
1138
1139     case aImport:
1140       if (!argc)
1141         gpgsm_import (&ctrl, 0);
1142       else
1143         {
1144           for (; argc; argc--, argv++)
1145             gpgsm_import (&ctrl, open_read (*argv));
1146         }
1147       break;
1148       
1149     case aExport:
1150     case aSendKeys:
1151     case aRecvKeys:
1152 /*        sl = NULL; */
1153 /*        for ( ; argc; argc--, argv++ ) */
1154 /*          add_to_strlist (&sl, *argv); */
1155 /*        if ( cmd == aSendKeys ) */
1156 /*          ldap_export (sl); */
1157 /*        else if (cmd == aRecvKeys ) */
1158 /*          ldap_import (sl); */
1159 /*        else */
1160 /*          export_pubkeys (sl, (cmd == aExport)); */
1161 /*        free_strlist (sl); */
1162       break;
1163
1164       default:
1165         if (argc > 1)
1166           wrong_args(_("[filename]"));
1167         /* Issue some output for the unix newbie */
1168         if ( !fname && !opt.outfile && isatty( fileno(stdin) )
1169             && isatty (fileno(stdout) ) && isatty (fileno(stderr) ) )
1170           log_info (_("Go ahead and type your message ...\n"));
1171         
1172 #if 0
1173         if ( !(a = iobuf_open(fname)) )
1174           log_error (_("can't open `%s'\n"), print_fname_stdin(fname));
1175         else
1176           {
1177             if (!opt.no_armor) 
1178               iobuf_close(a);
1179         }
1180 #endif
1181         break;
1182     }
1183   
1184   /* cleanup */
1185   gpgsm_release_certlist (recplist);
1186   FREE_STRLIST(remusr);
1187   FREE_STRLIST(locusr);
1188   gpgsm_exit(0);
1189   return 8; /*NEVER REACHED*/
1190 }
1191
1192
1193 void
1194 gpgsm_exit (int rc)
1195 {
1196   #if 0
1197 #warning no update_random_seed_file
1198   update_random_seed_file();
1199   #endif
1200 #if 0
1201   /* at this time a bit annoying */
1202   if (opt.debug & DBG_MEMSTAT_VALUE)
1203     {
1204       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1205       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1206     }
1207   if (opt.debug)
1208     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1209 #endif
1210   gcry_control (GCRYCTL_TERM_SECMEM );
1211   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1212   exit (rc);
1213 }
1214
1215
1216 void
1217 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1218 {
1219   ctrl->include_certs = 1;
1220 }
1221
1222
1223
1224 /* Check whether the filename has the form "-&nnnn", where n is a
1225    non-zero number.  Returns this number or -1 if it is not the case.  */
1226 static int
1227 check_special_filename (const char *fname)
1228 {
1229   if (allow_special_filenames
1230       && fname && *fname == '-' && fname[1] == '&' ) {
1231     int i;
1232     
1233     fname += 2;
1234     for (i=0; isdigit (fname[i]); i++ )
1235       ;
1236     if ( !fname[i] ) 
1237       return atoi (fname);
1238   }
1239   return -1;
1240 }
1241
1242
1243
1244 /* Open the FILENAME for read and return the fieldescriptor.  Stop
1245    with an error message in case of problems.  "-" denotes stdin and
1246    if special filenames are allowed the given fd is opend instead. */
1247 static int 
1248 open_read (const char *filename)
1249 {
1250   int fd;
1251
1252   if (filename[0] == '-' && !filename[1])
1253     return 0; /* stdin */
1254   fd = check_special_filename (filename);
1255   if (fd != -1)
1256     return fd;
1257   fd = open (filename, O_RDONLY);
1258   if (fd == -1)
1259     {
1260       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1261       gpgsm_exit (2);
1262     }
1263   return fd;
1264 }