* decrypt.c (gpgsm_decrypt): Allow multiple recipients.
[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         {
1011           log_error (_("can't encrypt to `%s': %s\n"),
1012                      sl->d, gnupg_strerror (rc));
1013           gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1014                          rc == -1? "1":
1015                          rc == GNUPG_Ambiguous_Name? "2 ": "0 ",
1016                          sl->d, NULL);
1017         }
1018   }
1019   if (log_get_errorcount(0))
1020     gpgsm_exit(1); /* must stop for invalid recipients */
1021   
1022
1023   
1024   fname = argc? *argv : NULL;
1025   
1026   switch (cmd)
1027     {
1028     case aServer:
1029       if (debug_wait)
1030         {
1031           log_debug ("waiting for debugger - my pid is %u .....\n",
1032                      (unsigned int)getpid());
1033           sleep (debug_wait);
1034           log_debug ("... okay\n");
1035          }
1036       gpgsm_server ();
1037       break;
1038
1039     case aEncr: /* encrypt the given file */
1040       if (!argc)
1041         gpgsm_encrypt (&ctrl, recplist, 0, stdout); /* from stdin */
1042       else if (argc == 1)
1043         gpgsm_encrypt (&ctrl, recplist, open_read (*argv), stdout); /* from file */
1044       else
1045         wrong_args (_("--encrypt [datafile]"));
1046       break;
1047
1048     case aSign: /* sign the given file */
1049       /* FIXME: we can only do detached sigs for now and we don't
1050          handle --output yet. We should also allow to concatenate
1051          multiple files for signins because that is what gpg does.*/
1052       if (!argc)
1053         gpgsm_sign (&ctrl, 0, 1, stdout); /* create from stdin */
1054       else if (argc == 1)
1055         gpgsm_sign (&ctrl, open_read (*argv), 1, stdout); /* from file */
1056       else
1057         wrong_args (_("--sign [datafile]"));
1058       break;
1059 #if 0
1060       sl = NULL;
1061       if (detached_sig)
1062         { /* sign all files */
1063           for (; argc; argc--, argv++ )
1064             add_to_strlist ( &sl, *argv );
1065         }
1066       else
1067         {
1068           if (argc > 1 )
1069             wrong_args (_("--sign [filename]"));
1070           if (argc)
1071             {
1072               sl = xcalloc (1, sizeof *sl + strlen(fname));
1073               strcpy(sl->d, fname);
1074             }
1075         }
1076       if ( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1077         log_error ("signing failed: %s\n", gpg_errstr(rc) );
1078       free_strlist(sl);
1079 #endif
1080       break;
1081         
1082     case aSignEncr: /* sign and encrypt the given file */
1083       log_error ("this command has not yet been implemented\n");
1084 #if 0
1085       if (argc > 1)
1086         wrong_args(_("--sign --encrypt [filename]"));
1087       if (argc)
1088         {
1089           sl = xcalloc( 1, sizeof *sl + strlen(fname));
1090           strcpy(sl->d, fname);
1091         }
1092       else
1093         sl = NULL;
1094
1095       if ( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1096         log_error ("%s: sign+encrypt failed: %s\n",
1097                    print_fname_stdin(fname), gpg_errstr(rc) );
1098       free_strlist(sl);
1099 #endif
1100       break;
1101
1102     case aClearsign: /* make a clearsig */
1103       log_error ("this command has not yet been implemented\n");
1104 #if 0
1105       if (argc > 1)
1106         wrong_args (_("--clearsign [filename]"));
1107       if ( (rc = clearsign_file(fname, locusr, NULL)) )
1108         log_error ("%s: clearsign failed: %s\n",
1109                    print_fname_stdin(fname), gpg_errstr(rc) );
1110 #endif
1111       break;
1112
1113     case aVerify:
1114       if (!argc)
1115         gpgsm_verify (&ctrl, 0, -1, NULL); /* normal signature from stdin */
1116       else if (argc == 1)
1117         gpgsm_verify (&ctrl, open_read (*argv), -1, NULL); /* std signature */
1118       else if (argc == 2) /* detached signature (sig, detached) */
1119         gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1120       else
1121         wrong_args (_("--verify [signature [detached_data]]"));
1122       break;
1123
1124     case aVerifyFiles:
1125       log_error ("this command has not yet been implemented\n");
1126 /*        if ((rc = verify_files( argc, argv ))) */
1127 /*          log_error ("verify files failed: %s\n", gpg_errstr(rc) ); */
1128       break;
1129
1130     case aDecrypt:
1131       if (!argc)
1132         gpgsm_decrypt (&ctrl, 0, stdout); /* from stdin */
1133       else if (argc == 1)
1134         gpgsm_decrypt (&ctrl, open_read (*argv), stdout); /* from file */
1135       else
1136         wrong_args (_("--decrypt [filename]"));
1137       break;
1138
1139     case aDeleteKey:
1140       if (argc != 1)
1141         wrong_args(_("--delete-key user-id"));
1142       log_error ("this command has not yet been implemented\n");
1143 /*        username = make_username (fname); */
1144 /*        if( (rc = delete_key(username)) ) */
1145 /*          log_error ("%s: delete key failed: %s\n", username, gpg_errstr(rc) ); */
1146 /*        xfree(username); */
1147       break;
1148
1149     case aListKeys:
1150       for (sl=NULL; argc; argc--, argv++)
1151         add_to_strlist (&sl, *argv);
1152       gpgsm_list_keys (&ctrl, sl, stdout, 0);
1153       free_strlist(sl);
1154       break;
1155
1156     case aListSecretKeys:
1157       for (sl=NULL; argc; argc--, argv++)
1158         add_to_strlist (&sl, *argv);
1159       gpgsm_list_keys (&ctrl, sl, stdout, 2);
1160       free_strlist(sl);
1161       break;
1162
1163     case aKeygen: /* generate a key */
1164       log_error ("this function is not yet available from the commandline\n");
1165 /*        if (opt.batch) */
1166 /*          { */
1167 /*            if (argc > 1) */
1168 /*              wrong_args("--gen-key [parameterfile]"); */
1169 /*            generate_keypair (argc? *argv : NULL); */
1170 /*      } */
1171 /*        else */
1172 /*          { */
1173 /*            if (argc) */
1174 /*              wrong_args ("--gen-key"); */
1175 /*            generate_keypair(NULL); */
1176 /*      } */
1177       break;
1178
1179     case aImport:
1180       if (!argc)
1181         gpgsm_import (&ctrl, 0);
1182       else
1183         {
1184           for (; argc; argc--, argv++)
1185             gpgsm_import (&ctrl, open_read (*argv));
1186         }
1187       break;
1188
1189       
1190     case aExport:
1191     case aSendKeys:
1192     case aRecvKeys:
1193       log_error ("this command has not yet been implemented\n");
1194 /*        sl = NULL; */
1195 /*        for ( ; argc; argc--, argv++ ) */
1196 /*          add_to_strlist (&sl, *argv); */
1197 /*        if ( cmd == aSendKeys ) */
1198 /*          ldap_export (sl); */
1199 /*        else if (cmd == aRecvKeys ) */
1200 /*          ldap_import (sl); */
1201 /*        else */
1202 /*          export_pubkeys (sl, (cmd == aExport)); */
1203 /*        free_strlist (sl); */
1204       break;
1205
1206
1207     case aLearnCard:
1208       if (argc)
1209         wrong_args ("--learn-card");
1210       else
1211         {
1212           int rc = gpgsm_agent_learn ();
1213           if (rc)
1214             log_error ("error learning card: %s\n", gnupg_strerror (rc));
1215         }
1216       break;
1217
1218
1219     default:
1220         log_error ("invalid command\n");
1221         if (argc > 1)
1222           wrong_args(_("[filename]"));
1223         /* Issue some output for the unix newbie */
1224         if ( !fname && !opt.outfile && isatty( fileno(stdin) )
1225             && isatty (fileno(stdout) ) && isatty (fileno(stderr) ) )
1226           log_info (_("Go ahead and type your message ...\n"));
1227         
1228 #if 0
1229         if ( !(a = iobuf_open(fname)) )
1230           log_error (_("can't open `%s'\n"), print_fname_stdin(fname));
1231         else
1232           {
1233             if (!opt.no_armor) 
1234               iobuf_close(a);
1235         }
1236 #endif
1237         break;
1238     }
1239   
1240   /* cleanup */
1241   gpgsm_release_certlist (recplist);
1242   FREE_STRLIST(remusr);
1243   FREE_STRLIST(locusr);
1244   gpgsm_exit(0);
1245   return 8; /*NEVER REACHED*/
1246 }
1247
1248
1249 void
1250 gpgsm_exit (int rc)
1251 {
1252   #if 0
1253 #warning no update_random_seed_file
1254   update_random_seed_file();
1255   #endif
1256 #if 0
1257   /* at this time a bit annoying */
1258   if (opt.debug & DBG_MEMSTAT_VALUE)
1259     {
1260       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1261       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1262     }
1263   if (opt.debug)
1264     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1265 #endif
1266   gcry_control (GCRYCTL_TERM_SECMEM );
1267   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1268   exit (rc);
1269 }
1270
1271
1272 void
1273 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1274 {
1275   ctrl->include_certs = 1;  /* only include the signer's cert */
1276 }
1277
1278
1279
1280 /* Check whether the filename has the form "-&nnnn", where n is a
1281    non-zero number.  Returns this number or -1 if it is not the case.  */
1282 static int
1283 check_special_filename (const char *fname)
1284 {
1285   if (allow_special_filenames
1286       && fname && *fname == '-' && fname[1] == '&' ) {
1287     int i;
1288     
1289     fname += 2;
1290     for (i=0; isdigit (fname[i]); i++ )
1291       ;
1292     if ( !fname[i] ) 
1293       return atoi (fname);
1294   }
1295   return -1;
1296 }
1297
1298
1299
1300 /* Open the FILENAME for read and return the fieldescriptor.  Stop
1301    with an error message in case of problems.  "-" denotes stdin and
1302    if special filenames are allowed the given fd is opend instead. */
1303 static int 
1304 open_read (const char *filename)
1305 {
1306   int fd;
1307
1308   if (filename[0] == '-' && !filename[1])
1309     return 0; /* stdin */
1310   fd = check_special_filename (filename);
1311   if (fd != -1)
1312     return fd;
1313   fd = open (filename, O_RDONLY);
1314   if (fd == -1)
1315     {
1316       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1317       gpgsm_exit (2);
1318     }
1319   return fd;
1320 }