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