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