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