3a1b7a7c2d3a3cfe2f8d08efa8d35a7284faf060
[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 (NEED_LIBGCRYPT_VERSION) )
592     {
593       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
594                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
595     }
596   if (!ksba_check_version (NEED_LIBKSBA_VERSION) )
597     {
598       log_fatal( _("libksba is too old (need %s, have %s)\n"),
599                  NEED_LIBKSBA_VERSION, ksba_check_version (NULL) );
600     }
601
602   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
603
604   may_coredump = disable_core_dumps ();
605   
606   /* Fixme: init_signals();*/
607   
608   create_dotlock (NULL); /* register locking cleanup */
609   i18n_init();
610
611   opt.def_cipher_algoid = "1.2.840.113549.3.7";  /*des-EDE3-CBC*/
612 #ifdef __MINGW32__
613   opt.homedir = read_w32_registry_string ( NULL,
614                                            "Software\\GNU\\GnuPG", "HomeDir" );
615 #else
616   opt.homedir = getenv ("GNUPGHOME");
617 #endif
618   if (!opt.homedir || !*opt.homedir ) 
619     {
620       opt.homedir = "~/.gnupg-test" /*fixme: GNUPG_HOMEDIR*/;
621     }
622
623   /* first check whether we have a config file on the commandline */
624   orig_argc = argc;
625   orig_argv = argv;
626   pargs.argc = &argc;
627   pargs.argv = &argv;
628   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
629   while (arg_parse( &pargs, opts))
630     {
631       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
632         parse_debug++;
633       else if (pargs.r_opt == oOptions)
634         { /* yes there is one, so we do not try the default one but
635              read the config file when it is encountered at the
636              commandline */
637           default_config = 0;
638         }
639       else if (pargs.r_opt == oNoOptions)
640         default_config = 0; /* --no-options */
641       else if (pargs.r_opt == oHomedir)
642         opt.homedir = pargs.r.ret_str;
643     }
644   
645   
646   /* initialize the secure memory. */
647   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
648   maybe_setuid = 0;
649
650   /* 
651      Now we are now working under our real uid 
652   */
653
654   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
655   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
656   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
657
658   /* Setup a default control structure for command line mode */
659   memset (&ctrl, 0, sizeof ctrl);
660   gpgsm_init_default_ctrl (&ctrl);
661   ctrl.no_server = 1;
662   ctrl.status_fd = -1; /* not status output */
663   ctrl.autodetect_encoding = 1;
664
665   /* set the default option file */
666   if (default_config )
667     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
668   /* cet the default policy file */
669   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
670   
671   argc        = orig_argc;
672   argv        = orig_argv;
673   pargs.argc  = &argc;
674   pargs.argv  = &argv;
675   pargs.flags =  1;  /* do not remove the args */
676
677  next_pass:
678   if (configname) {
679     configlineno = 0;
680     configfp = fopen (configname, "r");
681     if (!configfp)
682       {
683         if (default_config)
684           {
685             if (parse_debug)
686               log_info (_("NOTE: no default option file `%s'\n"), configname);
687           }
688         else 
689           {
690             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
691             gpgsm_exit(2);
692           }
693         xfree(configname);
694         configname = NULL;
695       }
696     if (parse_debug && configname)
697       log_info (_("reading options from `%s'\n"), configname);
698     default_config = 0;
699   }
700
701   while (optfile_parse (configfp, configname, &configlineno, &pargs, opts))
702     {
703       switch (pargs.r_opt)
704         {
705         case aServer: 
706           opt.batch = 1;
707           set_cmd (&cmd, aServer);
708           break;
709
710         case aCheckKeys: set_cmd (&cmd, aCheckKeys); break;
711         case aImport: set_cmd (&cmd, aImport); break;
712         case aSendKeys: set_cmd (&cmd, aSendKeys); break;
713         case aRecvKeys: set_cmd (&cmd, aRecvKeys); break;
714         case aExport: set_cmd (&cmd, aExport); break;
715         case aListKeys: set_cmd (&cmd, aListKeys); break;
716         case aListSecretKeys: set_cmd (&cmd, aListSecretKeys); break;
717
718         case aLearnCard: set_cmd (&cmd, aLearnCard); break;
719
720         case aDeleteKey:
721           set_cmd (&cmd, aDeleteKey);
722           greeting=1;
723           break;
724
725         case aDetachedSign:
726           detached_sig = 1;
727           set_cmd (&cmd, aSign ); 
728           break;
729           
730         case aSym: set_cmd (&cmd, aSym); break;
731         case aDecrypt: set_cmd (&cmd, aDecrypt); break;
732         case aEncr: set_cmd (&cmd, aEncr); break;
733         case aSign: set_cmd (&cmd, aSign );  break;
734         case aKeygen: set_cmd (&cmd, aKeygen); greeting=1; break;
735         case aClearsign: set_cmd (&cmd, aClearsign); break;
736         case aVerify: set_cmd (&cmd, aVerify); break;
737
738
739           /* output encoding selection */
740         case oArmor:
741           ctrl.create_pem = 1;
742           break;
743         case oBase64: 
744           ctrl.create_pem = 0;
745           ctrl.create_base64 = 1;
746           break;
747         case oNoArmor: 
748           ctrl.create_pem = 0;
749           ctrl.create_base64 = 0;
750           break;
751           
752           /* Input encoding selection */
753         case oAssumeArmor:
754           ctrl.autodetect_encoding = 0;
755           ctrl.is_pem = 1;
756           ctrl.is_base64 = 0;
757           break;
758         case oAssumeBase64:
759           ctrl.autodetect_encoding = 0;
760           ctrl.is_pem = 0;
761           ctrl.is_base64 = 1;
762           break;
763         case oAssumeBinary:
764           ctrl.autodetect_encoding = 0;
765           ctrl.is_pem = 0;
766           ctrl.is_base64 = 0;
767           break;
768
769         case oDisableCRLChecks:
770           opt.no_crl_check = 1;
771           break;
772         case oEnableCRLChecks:
773           opt.no_crl_check = 0;
774           break;
775
776         case oIncludeCerts: ctrl.include_certs = pargs.r.ret_int; break;
777
778         case oPolicyFile:
779           xfree (opt.policy_file);
780           if (*pargs.r.ret_str)
781             opt.policy_file = xstrdup (pargs.r.ret_str);
782           else
783             opt.policy_file = NULL;
784           break;
785
786         case oDisablePolicyChecks:
787           opt.no_policy_check = 1;
788           break;
789         case oEnablePolicyChecks:
790           opt.no_policy_check = 0;
791           break;
792
793
794         case oOutput: opt.outfile = pargs.r.ret_str; break;
795
796         
797         case oQuiet: opt.quiet = 1; break;
798         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
799         case oDryRun: opt.dry_run = 1; break;
800
801         case oVerbose:
802           opt.verbose++;
803           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
804           break;
805         case oNoVerbose:
806           opt.verbose = 0;
807           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
808           break;
809           
810         case oBatch: 
811           opt.batch = 1;
812           greeting = 0;
813           break;
814         case oNoBatch: opt.batch = 0; break;
815           
816         case oAnswerYes: opt.answer_yes = 1; break;
817         case oAnswerNo: opt.answer_no = 1; break;
818
819         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
820
821         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
822         case oDebugAll: opt.debug = ~0; break;
823         case oDebugWait: debug_wait = pargs.r.ret_int; break;
824
825         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
826         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
827         case oWithFingerprint:
828           with_fpr=1; /*fall thru*/
829         case oFingerprint:
830           opt.fingerprint++;
831           break;
832
833         case oOptions:
834           /* config files may not be nested (silently ignore them) */
835           if (!configfp)
836             {
837               xfree(configname);
838               configname = xstrdup (pargs.r.ret_str);
839               goto next_pass;
840             }
841           break;
842         case oNoOptions: break; /* no-options */
843         case oHomedir: opt.homedir = pargs.r.ret_str; break;
844         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
845         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
846           
847         case oNoDefKeyring: default_keyring = 0; break;
848         case oNoGreeting: nogreeting = 1; break;
849
850         case oDefaultKey:
851           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
852           break;
853         case oDefRecipient:
854           if (*pargs.r.ret_str)
855             opt.def_recipient = xstrdup (pargs.r.ret_str);
856           break;
857         case oDefRecipientSelf:
858           xfree (opt.def_recipient);
859           opt.def_recipient = NULL;
860           opt.def_recipient_self = 1;
861           break;
862         case oNoDefRecipient:
863           xfree (opt.def_recipient);
864           opt.def_recipient = NULL;
865           opt.def_recipient_self = 0;
866           break;
867
868         case oWithKeyData: opt.with_key_data=1; /* fall thru */
869         case oWithColons: ctrl.with_colons = 1; break;
870
871         case oSkipVerify: opt.skip_verify=1; break;
872
873         case oNoEncryptTo: /*fixme: opt.no_encrypt_to = 1;*/ break;
874         case oEncryptTo: /* store the recipient in the second list */
875           sl = add_to_strlist (&remusr, pargs.r.ret_str);
876           sl->flags = 1;
877           break;
878
879         case oRecipient: /* store the recipient */
880           add_to_strlist ( &remusr, pargs.r.ret_str);
881           break;
882
883         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
884         case oTextmode: /*fixme:opt.textmode=1;*/  break;
885
886         case oUser: /* store the local users */
887           opt.local_user = pargs.r.ret_str;
888           add_to_strlist ( &locusr, pargs.r.ret_str);
889           break;
890
891         case oNoSecmemWarn:
892           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
893           break;
894
895         case oCipherAlgo:
896           opt.def_cipher_algoid = pargs.r.ret_str;
897           break;
898
899         case oDisableCipherAlgo: 
900           {
901             int algo = gcry_cipher_map_name (pargs.r.ret_str);
902             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
903           }
904           break;
905         case oDisablePubkeyAlgo: 
906           {
907             int algo = gcry_pk_map_name (pargs.r.ret_str);
908             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
909           }
910           break;
911
912         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
913         case oNoRandomSeedFile: use_random_seed = 0; break;
914
915         case oEnableSpecialFilenames: allow_special_filenames =1; break;
916           
917
918         case aDummy:
919           break;
920         default: 
921           pargs.err = configfp? 1:2; 
922           break;
923         }
924     }
925
926   if (configfp)
927     {
928       fclose (configfp);
929       configfp = NULL;
930       xfree (configname);
931       configname = NULL;
932       goto next_pass;
933     }
934   
935   xfree (configname);
936   configname = NULL;
937
938   if (log_get_errorcount(0))
939     gpgsm_exit(2);
940   
941   if (nogreeting)
942     greeting = 0;
943   
944   if (greeting)
945     {
946       fprintf(stderr, "%s %s; %s\n",
947               strusage(11), strusage(13), strusage(14) );
948       fprintf(stderr, "%s\n", strusage(15) );
949     }
950 #  ifdef IS_DEVELOPMENT_VERSION
951   if (!opt.batch)
952     {
953       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
954       log_info ("It is only intended for test purposes and should NOT be\n");
955       log_info ("used in a production environment or with production keys!\n");
956     }
957 #  endif
958
959   if (may_coredump && !opt.quiet)
960     log_info (_("WARNING: program may create a core file!\n"));
961   
962 /*FIXME    if (opt.batch) */
963 /*      tty_batchmode (1); */
964
965   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
966
967   set_debug ();
968
969   /* FIXME: should set filenames of libgcrypt explicitly
970    * gpg_opt_homedir = opt.homedir; */
971
972   /* must do this after dropping setuid, because the mapping functions
973      may try to load an module and we may have disabled an algorithm */
974   if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
975        || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
976     log_error (_("selected cipher algorithm is invalid\n"));
977
978   if (def_digest_string)
979     {
980       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
981       xfree (def_digest_string);
982       def_digest_string = NULL;
983       if (our_md_test_algo(opt.def_digest_algo) )
984         log_error (_("selected digest algorithm is invalid\n"));
985     }
986
987   if (log_get_errorcount(0))
988     gpgsm_exit(2);
989   
990   /* set the random seed file */
991   if (use_random_seed) {
992     char *p = make_filename (opt.homedir, "random_seed", NULL);
993 #if 0
994 #warning set_random_seed_file not yet available in Libgcrypt
995     set_random_seed_file(p);
996 #endif
997     xfree(p);
998   }
999
1000
1001   if (!cmd && opt.fingerprint && !with_fpr)
1002     set_cmd (&cmd, aListKeys);
1003   
1004   if (!nrings && default_keyring)  /* add default keybox */
1005     keydb_add_resource ("pubring.kbx", 0, 0);
1006   for (sl = nrings; sl; sl = sl->next)
1007     keydb_add_resource (sl->d, 0, 0);
1008   FREE_STRLIST(nrings);
1009
1010   for (sl = remusr; sl; sl = sl->next)
1011     {
1012       int rc = gpgsm_add_to_certlist (sl->d, &recplist);
1013       if (rc)
1014         {
1015           log_error (_("can't encrypt to `%s': %s\n"),
1016                      sl->d, gnupg_strerror (rc));
1017           gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1018                          rc == -1? "1":
1019                          rc == GNUPG_Ambiguous_Name? "2 ": "0 ",
1020                          sl->d, NULL);
1021         }
1022   }
1023   if (log_get_errorcount(0))
1024     gpgsm_exit(1); /* must stop for invalid recipients */
1025   
1026
1027   
1028   fname = argc? *argv : NULL;
1029   
1030   switch (cmd)
1031     {
1032     case aServer:
1033       if (debug_wait)
1034         {
1035           log_debug ("waiting for debugger - my pid is %u .....\n",
1036                      (unsigned int)getpid());
1037           sleep (debug_wait);
1038           log_debug ("... okay\n");
1039          }
1040       gpgsm_server ();
1041       break;
1042
1043     case aEncr: /* encrypt the given file */
1044       if (!argc)
1045         gpgsm_encrypt (&ctrl, recplist, 0, stdout); /* from stdin */
1046       else if (argc == 1)
1047         gpgsm_encrypt (&ctrl, recplist, open_read (*argv), stdout); /* from file */
1048       else
1049         wrong_args (_("--encrypt [datafile]"));
1050       break;
1051
1052     case aSign: /* sign the given file */
1053       /* FIXME: we can only do detached sigs for now and we don't
1054          handle --output yet. We should also allow to concatenate
1055          multiple files for signing because that is what gpg does.*/
1056       if (!argc)
1057         gpgsm_sign (&ctrl, 0, 1, stdout); /* create from stdin */
1058       else if (argc == 1)
1059         gpgsm_sign (&ctrl, open_read (*argv), 1, stdout); /* from file */
1060       else
1061         wrong_args (_("--sign [datafile]"));
1062       break;
1063 #if 0
1064       sl = NULL;
1065       if (detached_sig)
1066         { /* sign all files */
1067           for (; argc; argc--, argv++ )
1068             add_to_strlist ( &sl, *argv );
1069         }
1070       else
1071         {
1072           if (argc > 1 )
1073             wrong_args (_("--sign [filename]"));
1074           if (argc)
1075             {
1076               sl = xcalloc (1, sizeof *sl + strlen(fname));
1077               strcpy(sl->d, fname);
1078             }
1079         }
1080       if ( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1081         log_error ("signing failed: %s\n", gpg_errstr(rc) );
1082       free_strlist(sl);
1083 #endif
1084       break;
1085         
1086     case aSignEncr: /* sign and encrypt the given file */
1087       log_error ("this command has not yet been implemented\n");
1088 #if 0
1089       if (argc > 1)
1090         wrong_args(_("--sign --encrypt [filename]"));
1091       if (argc)
1092         {
1093           sl = xcalloc( 1, sizeof *sl + strlen(fname));
1094           strcpy(sl->d, fname);
1095         }
1096       else
1097         sl = NULL;
1098
1099       if ( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1100         log_error ("%s: sign+encrypt failed: %s\n",
1101                    print_fname_stdin(fname), gpg_errstr(rc) );
1102       free_strlist(sl);
1103 #endif
1104       break;
1105
1106     case aClearsign: /* make a clearsig */
1107       log_error ("this command has not yet been implemented\n");
1108 #if 0
1109       if (argc > 1)
1110         wrong_args (_("--clearsign [filename]"));
1111       if ( (rc = clearsign_file(fname, locusr, NULL)) )
1112         log_error ("%s: clearsign failed: %s\n",
1113                    print_fname_stdin(fname), gpg_errstr(rc) );
1114 #endif
1115       break;
1116
1117     case aVerify:
1118       if (!argc)
1119         gpgsm_verify (&ctrl, 0, -1, NULL); /* normal signature from stdin */
1120       else if (argc == 1)
1121         gpgsm_verify (&ctrl, open_read (*argv), -1, NULL); /* std signature */
1122       else if (argc == 2) /* detached signature (sig, detached) */
1123         gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1124       else
1125         wrong_args (_("--verify [signature [detached_data]]"));
1126       break;
1127
1128     case aVerifyFiles:
1129       log_error ("this command has not yet been implemented\n");
1130 /*        if ((rc = verify_files( argc, argv ))) */
1131 /*          log_error ("verify files failed: %s\n", gpg_errstr(rc) ); */
1132       break;
1133
1134     case aDecrypt:
1135       if (!argc)
1136         gpgsm_decrypt (&ctrl, 0, stdout); /* from stdin */
1137       else if (argc == 1)
1138         gpgsm_decrypt (&ctrl, open_read (*argv), stdout); /* from file */
1139       else
1140         wrong_args (_("--decrypt [filename]"));
1141       break;
1142
1143     case aDeleteKey:
1144       if (argc != 1)
1145         wrong_args(_("--delete-key user-id"));
1146       log_error ("this command has not yet been implemented\n");
1147 /*        username = make_username (fname); */
1148 /*        if( (rc = delete_key(username)) ) */
1149 /*          log_error ("%s: delete key failed: %s\n", username, gpg_errstr(rc) ); */
1150 /*        xfree(username); */
1151       break;
1152
1153     case aListKeys:
1154       for (sl=NULL; argc; argc--, argv++)
1155         add_to_strlist (&sl, *argv);
1156       gpgsm_list_keys (&ctrl, sl, stdout, 0);
1157       free_strlist(sl);
1158       break;
1159
1160     case aListSecretKeys:
1161       for (sl=NULL; argc; argc--, argv++)
1162         add_to_strlist (&sl, *argv);
1163       gpgsm_list_keys (&ctrl, sl, stdout, 2);
1164       free_strlist(sl);
1165       break;
1166
1167     case aKeygen: /* generate a key */
1168       log_error ("this function is not yet available from the commandline\n");
1169 /*        if (opt.batch) */
1170 /*          { */
1171 /*            if (argc > 1) */
1172 /*              wrong_args("--gen-key [parameterfile]"); */
1173 /*            generate_keypair (argc? *argv : NULL); */
1174 /*      } */
1175 /*        else */
1176 /*          { */
1177 /*            if (argc) */
1178 /*              wrong_args ("--gen-key"); */
1179 /*            generate_keypair(NULL); */
1180 /*      } */
1181       break;
1182
1183     case aImport:
1184       if (!argc)
1185         gpgsm_import (&ctrl, 0);
1186       else
1187         {
1188           for (; argc; argc--, argv++)
1189             gpgsm_import (&ctrl, open_read (*argv));
1190         }
1191       break;
1192
1193     case aExport:
1194       for (sl=NULL; argc; argc--, argv++)
1195         add_to_strlist (&sl, *argv);
1196       gpgsm_export (&ctrl, sl, stdout);
1197       free_strlist(sl);
1198       break;
1199
1200       
1201     case aSendKeys:
1202     case aRecvKeys:
1203       log_error ("this command has not yet been implemented\n");
1204 /*        sl = NULL; */
1205 /*        for ( ; argc; argc--, argv++ ) */
1206 /*          add_to_strlist (&sl, *argv); */
1207 /*        if ( cmd == aSendKeys ) */
1208 /*          ldap_export (sl); */
1209 /*        else if (cmd == aRecvKeys ) */
1210 /*          ldap_import (sl); */
1211 /*        else */
1212 /*          export_pubkeys (sl, (cmd == aExport)); */
1213 /*        free_strlist (sl); */
1214       break;
1215
1216
1217     case aLearnCard:
1218       if (argc)
1219         wrong_args ("--learn-card");
1220       else
1221         {
1222           int rc = gpgsm_agent_learn ();
1223           if (rc)
1224             log_error ("error learning card: %s\n", gnupg_strerror (rc));
1225         }
1226       break;
1227
1228
1229     default:
1230         log_error ("invalid command\n");
1231         if (argc > 1)
1232           wrong_args(_("[filename]"));
1233         /* Issue some output for the unix newbie */
1234         if ( !fname && !opt.outfile && isatty( fileno(stdin) )
1235             && isatty (fileno(stdout) ) && isatty (fileno(stderr) ) )
1236           log_info (_("Go ahead and type your message ...\n"));
1237         
1238 #if 0
1239         if ( !(a = iobuf_open(fname)) )
1240           log_error (_("can't open `%s'\n"), print_fname_stdin(fname));
1241         else
1242           {
1243             if (!opt.no_armor) 
1244               iobuf_close(a);
1245         }
1246 #endif
1247         break;
1248     }
1249   
1250   /* cleanup */
1251   gpgsm_release_certlist (recplist);
1252   FREE_STRLIST(remusr);
1253   FREE_STRLIST(locusr);
1254   gpgsm_exit(0);
1255   return 8; /*NEVER REACHED*/
1256 }
1257
1258
1259 void
1260 gpgsm_exit (int rc)
1261 {
1262   #if 0
1263 #warning no update_random_seed_file
1264   update_random_seed_file();
1265   #endif
1266 #if 0
1267   /* at this time a bit annoying */
1268   if (opt.debug & DBG_MEMSTAT_VALUE)
1269     {
1270       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1271       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1272     }
1273   if (opt.debug)
1274     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1275 #endif
1276   gcry_control (GCRYCTL_TERM_SECMEM );
1277   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1278   exit (rc);
1279 }
1280
1281
1282 void
1283 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1284 {
1285   ctrl->include_certs = 1;  /* only include the signer's cert */
1286 }
1287
1288
1289
1290 /* Check whether the filename has the form "-&nnnn", where n is a
1291    non-zero number.  Returns this number or -1 if it is not the case.  */
1292 static int
1293 check_special_filename (const char *fname)
1294 {
1295   if (allow_special_filenames
1296       && fname && *fname == '-' && fname[1] == '&' ) {
1297     int i;
1298     
1299     fname += 2;
1300     for (i=0; isdigit (fname[i]); i++ )
1301       ;
1302     if ( !fname[i] ) 
1303       return atoi (fname);
1304   }
1305   return -1;
1306 }
1307
1308
1309
1310 /* Open the FILENAME for read and return the fieldescriptor.  Stop
1311    with an error message in case of problems.  "-" denotes stdin and
1312    if special filenames are allowed the given fd is opend instead. */
1313 static int 
1314 open_read (const char *filename)
1315 {
1316   int fd;
1317
1318   if (filename[0] == '-' && !filename[1])
1319     return 0; /* stdin */
1320   fd = check_special_filename (filename);
1321   if (fd != -1)
1322     return fd;
1323   fd = open (filename, O_RDONLY);
1324   if (fd == -1)
1325     {
1326       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1327       gpgsm_exit (2);
1328     }
1329   return fd;
1330 }