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