common,gpg,sm: Move the compliance option parser.
[gnupg.git] / sm / gpgsm.c
1 /* gpgsm.c - GnuPG for S/MIME
2  * Copyright (C) 2001-2008, 2010  Free Software Foundation, Inc.
3  * Copyright (C) 2001-2008, 2010  Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
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 /*#include <mcheck.h>*/
30
31 #include "gpgsm.h"
32 #include <gcrypt.h>
33 #include <assuan.h> /* malloc hooks */
34
35 #include "passphrase.h"
36 #include "../common/shareddefs.h"
37 #include "../kbx/keybox.h" /* malloc hooks */
38 #include "../common/i18n.h"
39 #include "keydb.h"
40 #include "../common/sysutils.h"
41 #include "../common/gc-opt-flags.h"
42 #include "../common/asshelp.h"
43 #include "../common/init.h"
44 #include "../common/compliance.h"
45
46
47 #ifndef O_BINARY
48 #define O_BINARY 0
49 #endif
50
51 enum cmd_and_opt_values {
52   aNull = 0,
53   oArmor        = 'a',
54   aDetachedSign = 'b',
55   aSym          = 'c',
56   aDecrypt      = 'd',
57   aEncr         = 'e',
58   aListKeys     = 'k',
59   aListSecretKeys = 'K',
60   oDryRun       = 'n',
61   oOutput       = 'o',
62   oQuiet        = 'q',
63   oRecipient    = 'r',
64   aSign         = 's',
65   oUser         = 'u',
66   oVerbose      = 'v',
67   oBatch        = 500,
68   aClearsign,
69   aKeygen,
70   aSignEncr,
71   aDeleteKey,
72   aImport,
73   aVerify,
74   aListExternalKeys,
75   aListChain,
76   aSendKeys,
77   aRecvKeys,
78   aExport,
79   aExportSecretKeyP12,
80   aExportSecretKeyP8,
81   aExportSecretKeyRaw,
82   aServer,
83   aLearnCard,
84   aCallDirmngr,
85   aCallProtectTool,
86   aPasswd,
87   aGPGConfList,
88   aGPGConfTest,
89   aDumpKeys,
90   aDumpChain,
91   aDumpSecretKeys,
92   aDumpExternalKeys,
93   aKeydbClearSomeCertFlags,
94   aFingerprint,
95
96   oOptions,
97   oDebug,
98   oDebugLevel,
99   oDebugAll,
100   oDebugNone,
101   oDebugWait,
102   oDebugAllowCoreDump,
103   oDebugNoChainValidation,
104   oDebugIgnoreExpiration,
105   oLogFile,
106   oNoLogFile,
107   oAuditLog,
108   oHtmlAuditLog,
109
110   oEnableSpecialFilenames,
111
112   oAgentProgram,
113   oDisplay,
114   oTTYname,
115   oTTYtype,
116   oLCctype,
117   oLCmessages,
118   oXauthority,
119
120   oPreferSystemDirmngr,
121   oDirmngrProgram,
122   oDisableDirmngr,
123   oProtectToolProgram,
124   oFakedSystemTime,
125
126   oPassphraseFD,
127   oPinentryMode,
128
129   oAssumeArmor,
130   oAssumeBase64,
131   oAssumeBinary,
132
133   oBase64,
134   oNoArmor,
135   oP12Charset,
136
137   oCompliance,
138
139   oDisableCRLChecks,
140   oEnableCRLChecks,
141   oDisableTrustedCertCRLCheck,
142   oEnableTrustedCertCRLCheck,
143   oForceCRLRefresh,
144
145   oDisableOCSP,
146   oEnableOCSP,
147
148   oIncludeCerts,
149   oPolicyFile,
150   oDisablePolicyChecks,
151   oEnablePolicyChecks,
152   oAutoIssuerKeyRetrieve,
153
154   oWithFingerprint,
155   oWithMD5Fingerprint,
156   oWithKeygrip,
157   oWithSecret,
158   oAnswerYes,
159   oAnswerNo,
160   oKeyring,
161   oDefaultKey,
162   oDefRecipient,
163   oDefRecipientSelf,
164   oNoDefRecipient,
165   oStatusFD,
166   oCipherAlgo,
167   oDigestAlgo,
168   oExtraDigestAlgo,
169   oNoVerbose,
170   oNoSecmemWarn,
171   oNoDefKeyring,
172   oNoGreeting,
173   oNoTTY,
174   oNoOptions,
175   oNoBatch,
176   oHomedir,
177   oWithColons,
178   oWithKeyData,
179   oWithValidation,
180   oWithEphemeralKeys,
181   oSkipVerify,
182   oValidationModel,
183   oKeyServer,
184   oEncryptTo,
185   oNoEncryptTo,
186   oLoggerFD,
187   oDisableCipherAlgo,
188   oDisablePubkeyAlgo,
189   oIgnoreTimeConflict,
190   oNoRandomSeedFile,
191   oNoCommonCertsImport,
192   oIgnoreCertExtension,
193   oNoAutostart
194  };
195
196
197 static ARGPARSE_OPTS opts[] = {
198
199   ARGPARSE_group (300, N_("@Commands:\n ")),
200
201   ARGPARSE_c (aSign, "sign", N_("make a signature")),
202 /*ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature") ),*/
203   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
204   ARGPARSE_c (aEncr, "encrypt", N_("encrypt data")),
205 /*ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),*/
206   ARGPARSE_c (aDecrypt, "decrypt", N_("decrypt data (default)")),
207   ARGPARSE_c (aVerify, "verify",  N_("verify a signature")),
208   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
209   ARGPARSE_c (aListExternalKeys, "list-external-keys",
210               N_("list external keys")),
211   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
212   ARGPARSE_c (aListChain,   "list-chain",  N_("list certificate chain")),
213   ARGPARSE_c (aFingerprint, "fingerprint", N_("list keys and fingerprints")),
214   ARGPARSE_c (aKeygen, "generate-key", N_("generate a new key pair")),
215   ARGPARSE_c (aKeygen, "gen-key", "@"),
216   ARGPARSE_c (aDeleteKey, "delete-keys",
217               N_("remove keys from the public keyring")),
218 /*ARGPARSE_c (aSendKeys, "send-keys", N_("export keys to a keyserver")),*/
219 /*ARGPARSE_c (aRecvKeys, "recv-keys", N_("import keys from a keyserver")),*/
220   ARGPARSE_c (aImport, "import", N_("import certificates")),
221   ARGPARSE_c (aExport, "export", N_("export certificates")),
222
223   /* We use -raw and not -p1 for pkcs#1 secret key export so that it
224      won't accidentally be used in case -p12 was intended.  */
225   ARGPARSE_c (aExportSecretKeyP12, "export-secret-key-p12", "@"),
226   ARGPARSE_c (aExportSecretKeyP8,  "export-secret-key-p8", "@"),
227   ARGPARSE_c (aExportSecretKeyRaw, "export-secret-key-raw", "@"),
228
229   ARGPARSE_c (aLearnCard, "learn-card", N_("register a smartcard")),
230   ARGPARSE_c (aServer, "server", N_("run in server mode")),
231   ARGPARSE_c (aCallDirmngr, "call-dirmngr",
232               N_("pass a command to the dirmngr")),
233   ARGPARSE_c (aCallProtectTool, "call-protect-tool",
234               N_("invoke gpg-protect-tool")),
235   ARGPARSE_c (aPasswd, "change-passphrase", N_("change a passphrase")),
236   ARGPARSE_c (aPasswd, "passwd", "@"),
237   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
238   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
239
240   ARGPARSE_c (aDumpKeys, "dump-cert", "@"),
241   ARGPARSE_c (aDumpKeys, "dump-keys", "@"),
242   ARGPARSE_c (aDumpChain, "dump-chain", "@"),
243   ARGPARSE_c (aDumpExternalKeys, "dump-external-keys", "@"),
244   ARGPARSE_c (aDumpSecretKeys, "dump-secret-keys", "@"),
245   ARGPARSE_c (aKeydbClearSomeCertFlags, "keydb-clear-some-cert-flags", "@"),
246
247   ARGPARSE_group (301, N_("@\nOptions:\n ")),
248
249   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
250   ARGPARSE_s_n (oArmor, "armour", "@"),
251   ARGPARSE_s_n (oBase64, "base64", N_("create base-64 encoded output")),
252
253   ARGPARSE_s_s (oP12Charset, "p12-charset", "@"),
254
255   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
256   ARGPARSE_s_s (oPinentryMode,    "pinentry-mode", "@"),
257
258   ARGPARSE_s_n (oAssumeArmor, "assume-armor",
259                 N_("assume input is in PEM format")),
260   ARGPARSE_s_n (oAssumeBase64, "assume-base64",
261                 N_("assume input is in base-64 format")),
262   ARGPARSE_s_n (oAssumeBinary, "assume-binary",
263                 N_("assume input is in binary format")),
264
265   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
266
267   ARGPARSE_s_n (oPreferSystemDirmngr,"prefer-system-dirmngr", "@"),
268
269   ARGPARSE_s_n (oDisableCRLChecks, "disable-crl-checks",
270                 N_("never consult a CRL")),
271   ARGPARSE_s_n (oEnableCRLChecks, "enable-crl-checks", "@"),
272   ARGPARSE_s_n (oDisableTrustedCertCRLCheck,
273                 "disable-trusted-cert-crl-check", "@"),
274   ARGPARSE_s_n (oEnableTrustedCertCRLCheck,
275                 "enable-trusted-cert-crl-check", "@"),
276
277   ARGPARSE_s_n (oForceCRLRefresh, "force-crl-refresh", "@"),
278
279   ARGPARSE_s_n (oDisableOCSP, "disable-ocsp", "@"),
280   ARGPARSE_s_n (oEnableOCSP,  "enable-ocsp", N_("check validity using OCSP")),
281
282   ARGPARSE_s_s (oValidationModel, "validation-model", "@"),
283
284   ARGPARSE_s_i (oIncludeCerts, "include-certs",
285                 N_("|N|number of certificates to include") ),
286
287   ARGPARSE_s_s (oPolicyFile, "policy-file",
288                 N_("|FILE|take policy information from FILE")),
289
290   ARGPARSE_s_n (oDisablePolicyChecks, "disable-policy-checks",
291                 N_("do not check certificate policies")),
292   ARGPARSE_s_n (oEnablePolicyChecks, "enable-policy-checks", "@"),
293
294   ARGPARSE_s_n (oAutoIssuerKeyRetrieve, "auto-issuer-key-retrieve",
295                 N_("fetch missing issuer certificates")),
296
297   ARGPARSE_s_s (oEncryptTo, "encrypt-to", "@"),
298   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
299
300   ARGPARSE_s_s (oUser, "local-user",
301                 N_("|USER-ID|use USER-ID to sign or decrypt")),
302
303   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
304   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
305   ARGPARSE_s_n (oQuiet, "quiet",  N_("be somewhat more quiet")),
306   ARGPARSE_s_n (oNoTTY, "no-tty", N_("don't use the terminal at all")),
307   ARGPARSE_s_s (oLogFile, "log-file",
308                 N_("|FILE|write a server mode log to FILE")),
309   ARGPARSE_s_n (oNoLogFile, "no-log-file", "@"),
310   ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
311
312   ARGPARSE_s_s (oAuditLog, "audit-log",
313                 N_("|FILE|write an audit log to FILE")),
314   ARGPARSE_s_s (oHtmlAuditLog, "html-audit-log", "@"),
315   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
316   ARGPARSE_s_n (oBatch, "batch", N_("batch mode: never ask")),
317   ARGPARSE_s_n (oAnswerYes, "yes", N_("assume yes on most questions")),
318   ARGPARSE_s_n (oAnswerNo,  "no",  N_("assume no on most questions")),
319
320   ARGPARSE_s_s (oKeyring, "keyring",
321                 N_("|FILE|add keyring to the list of keyrings")),
322
323   ARGPARSE_s_s (oDefaultKey, "default-key",
324                 N_("|USER-ID|use USER-ID as default secret key")),
325
326   /* Not yet used: */
327   /*   ARGPARSE_s_s (oDefRecipient, "default-recipient", */
328   /*                  N_("|NAME|use NAME as default recipient")), */
329   /*   ARGPARSE_s_n (oDefRecipientSelf, "default-recipient-self", */
330   /*                  N_("use the default key as default recipient")), */
331   /*   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"), */
332
333   ARGPARSE_s_s (oKeyServer, "keyserver",
334                 N_("|SPEC|use this keyserver to lookup keys")),
335   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
336
337   ARGPARSE_s_s (oDebug, "debug", "@"),
338   ARGPARSE_s_s (oDebugLevel, "debug-level",
339                 N_("|LEVEL|set the debugging level to LEVEL")),
340   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
341   ARGPARSE_s_n (oDebugNone, "debug-none", "@"),
342   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
343   ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
344   ARGPARSE_s_n (oDebugNoChainValidation, "debug-no-chain-validation", "@"),
345   ARGPARSE_s_n (oDebugIgnoreExpiration,  "debug-ignore-expiration", "@"),
346
347   ARGPARSE_s_i (oStatusFD, "status-fd",
348                 N_("|FD|write status info to this FD")),
349
350   ARGPARSE_s_s (oCipherAlgo, "cipher-algo",
351                 N_("|NAME|use cipher algorithm NAME")),
352   ARGPARSE_s_s (oDigestAlgo, "digest-algo",
353                 N_("|NAME|use message digest algorithm NAME")),
354   ARGPARSE_s_s (oExtraDigestAlgo, "extra-digest-algo", "@"),
355
356
357   ARGPARSE_group (302, N_(
358   "@\n(See the man page for a complete listing of all commands and options)\n"
359   )),
360
361
362   /* Hidden options. */
363   ARGPARSE_s_s (oCompliance, "compliance",   "@"),
364   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
365   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
366   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
367   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
368   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
369   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
370   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
371   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
372   ARGPARSE_s_s (oHomedir, "homedir", "@"),
373   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
374   ARGPARSE_s_s (oDisplay,    "display", "@"),
375   ARGPARSE_s_s (oTTYname,    "ttyname", "@"),
376   ARGPARSE_s_s (oTTYtype,    "ttytype", "@"),
377   ARGPARSE_s_s (oLCctype,    "lc-ctype", "@"),
378   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
379   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
380   ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
381   ARGPARSE_s_n (oDisableDirmngr, "disable-dirmngr", "@"),
382   ARGPARSE_s_s (oProtectToolProgram, "protect-tool-program", "@"),
383   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
384   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
385   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
386   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
387   ARGPARSE_s_n (oWithValidation, "with-validation", "@"),
388   ARGPARSE_s_n (oWithMD5Fingerprint, "with-md5-fingerprint", "@"),
389   ARGPARSE_s_n (oWithEphemeralKeys,  "with-ephemeral-keys", "@"),
390   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
391   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
392   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
393   ARGPARSE_s_n (oWithSecret,      "with-secret", "@"),
394   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
395   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
396   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
397   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
398   ARGPARSE_s_n (oNoCommonCertsImport, "no-common-certs-import", "@"),
399   ARGPARSE_s_s (oIgnoreCertExtension, "ignore-cert-extension", "@"),
400   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
401
402   /* Command aliases.  */
403   ARGPARSE_c (aListKeys, "list-key", "@"),
404   ARGPARSE_c (aListChain, "list-signatures", "@"),
405   ARGPARSE_c (aListChain, "list-sigs", "@"),
406   ARGPARSE_c (aListChain, "check-signatures", "@"),
407   ARGPARSE_c (aListChain, "check-sigs", "@"),
408   ARGPARSE_c (aDeleteKey, "delete-key", "@"),
409
410   ARGPARSE_end ()
411 };
412
413
414 /* The list of supported debug flags.  */
415 static struct debug_flags_s debug_flags [] =
416   {
417     { DBG_X509_VALUE   , "x509"    },
418     { DBG_MPI_VALUE    , "mpi"     },
419     { DBG_CRYPTO_VALUE , "crypto"  },
420     { DBG_MEMORY_VALUE , "memory"  },
421     { DBG_CACHE_VALUE  , "cache"   },
422     { DBG_MEMSTAT_VALUE, "memstat" },
423     { DBG_HASHING_VALUE, "hashing" },
424     { DBG_IPC_VALUE    , "ipc"     },
425     { 0, NULL }
426   };
427
428
429 /* Global variable to keep an error count. */
430 int gpgsm_errors_seen = 0;
431
432 /* It is possible that we are currentlu running under setuid permissions */
433 static int maybe_setuid = 1;
434
435 /* Helper to implement --debug-level and --debug*/
436 static const char *debug_level;
437 static unsigned int debug_value;
438
439 /* Default value for include-certs.  We need an extra macro for
440    gpgconf-list because the variable will be changed by the command
441    line option.
442
443    It is often cumbersome to locate intermediate certificates, thus by
444    default we include all certificates in the chain.  However we leave
445    out the root certificate because that would make it too easy for
446    the recipient to import that root certificate.  A root certificate
447    should be installed only after due checks and thus it won't help to
448    send it along with each message.  */
449 #define DEFAULT_INCLUDE_CERTS -2 /* Include all certs but root. */
450 static int default_include_certs = DEFAULT_INCLUDE_CERTS;
451
452 /* Whether the chain mode shall be used for validation.  */
453 static int default_validation_model;
454
455 /* The default cipher algo.  */
456 #define DEFAULT_CIPHER_ALGO "AES"
457
458
459 static char *build_list (const char *text,
460                          const char *(*mapf)(int), int (*chkf)(int));
461 static void set_cmd (enum cmd_and_opt_values *ret_cmd,
462                      enum cmd_and_opt_values new_cmd );
463
464 static void emergency_cleanup (void);
465 static int open_read (const char *filename);
466 static estream_t open_es_fread (const char *filename, const char *mode);
467 static estream_t open_es_fwrite (const char *filename);
468 static void run_protect_tool (int argc, char **argv);
469
470 static int
471 our_pk_test_algo (int algo)
472 {
473   switch (algo)
474     {
475     case GCRY_PK_RSA:
476     case GCRY_PK_ECDSA:
477       return gcry_pk_test_algo (algo);
478     default:
479       return 1;
480     }
481 }
482
483 static int
484 our_cipher_test_algo (int algo)
485 {
486   switch (algo)
487     {
488     case GCRY_CIPHER_3DES:
489     case GCRY_CIPHER_AES128:
490     case GCRY_CIPHER_AES192:
491     case GCRY_CIPHER_AES256:
492     case GCRY_CIPHER_SERPENT128:
493     case GCRY_CIPHER_SERPENT192:
494     case GCRY_CIPHER_SERPENT256:
495     case GCRY_CIPHER_SEED:
496     case GCRY_CIPHER_CAMELLIA128:
497     case GCRY_CIPHER_CAMELLIA192:
498     case GCRY_CIPHER_CAMELLIA256:
499       return gcry_cipher_test_algo (algo);
500     default:
501       return 1;
502     }
503 }
504
505
506 static int
507 our_md_test_algo (int algo)
508 {
509   switch (algo)
510     {
511     case GCRY_MD_MD5:
512     case GCRY_MD_SHA1:
513     case GCRY_MD_RMD160:
514     case GCRY_MD_SHA224:
515     case GCRY_MD_SHA256:
516     case GCRY_MD_SHA384:
517     case GCRY_MD_SHA512:
518     case GCRY_MD_WHIRLPOOL:
519       return gcry_md_test_algo (algo);
520     default:
521       return 1;
522     }
523 }
524
525
526 static char *
527 make_libversion (const char *libname, const char *(*getfnc)(const char*))
528 {
529   const char *s;
530   char *result;
531
532   if (maybe_setuid)
533     {
534       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
535       maybe_setuid = 0;
536     }
537   s = getfnc (NULL);
538   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
539   strcpy (stpcpy (stpcpy (result, libname), " "), s);
540   return result;
541 }
542
543
544 static const char *
545 my_strusage( int level )
546 {
547   static char *digests, *pubkeys, *ciphers;
548   static char *ver_gcry, *ver_ksba;
549   const char *p;
550
551   switch (level)
552     {
553     case 11: p = "@GPGSM@ (@GNUPG@)";
554       break;
555     case 13: p = VERSION; break;
556     case 17: p = PRINTABLE_OS_NAME; break;
557     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
558
559     case 1:
560     case 40: p = _("Usage: @GPGSM@ [options] [files] (-h for help)");
561       break;
562     case 41:
563       p = _("Syntax: @GPGSM@ [options] [files]\n"
564             "Sign, check, encrypt or decrypt using the S/MIME protocol\n"
565             "Default operation depends on the input data\n");
566       break;
567
568     case 20:
569       if (!ver_gcry)
570         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
571       p = ver_gcry;
572       break;
573     case 21:
574       if (!ver_ksba)
575         ver_ksba = make_libversion ("libksba", ksba_check_version);
576       p = ver_ksba;
577       break;
578
579     case 31: p = "\nHome: "; break;
580     case 32: p = gnupg_homedir (); break;
581     case 33: p = _("\nSupported algorithms:\n"); break;
582     case 34:
583       if (!ciphers)
584         ciphers = build_list ("Cipher: ", gnupg_cipher_algo_name,
585                               our_cipher_test_algo );
586       p = ciphers;
587       break;
588     case 35:
589       if (!pubkeys)
590         pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
591                               our_pk_test_algo );
592       p = pubkeys;
593       break;
594     case 36:
595       if (!digests)
596         digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
597       p = digests;
598       break;
599
600     default: p = NULL; break;
601     }
602   return p;
603 }
604
605
606 static char *
607 build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
608 {
609   int i;
610   size_t n=strlen(text)+2;
611   char *list, *p;
612
613   if (maybe_setuid) {
614     gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
615   }
616
617   for (i=1; i < 400; i++ )
618     if (!chkf(i))
619       n += strlen(mapf(i)) + 2;
620   list = xmalloc (21 + n);
621   *list = 0;
622   for (p=NULL, i=1; i < 400; i++)
623     {
624       if (!chkf(i))
625         {
626           if( !p )
627             p = stpcpy (list, text );
628           else
629             p = stpcpy (p, ", ");
630           p = stpcpy (p, mapf(i) );
631         }
632     }
633   if (p)
634     strcpy (p, "\n" );
635   return list;
636 }
637
638
639 /* Set the file pointer into binary mode if required.  */
640 static void
641 set_binary (FILE *fp)
642 {
643 #ifdef HAVE_DOSISH_SYSTEM
644   setmode (fileno (fp), O_BINARY);
645 #else
646   (void)fp;
647 #endif
648 }
649
650
651
652 static void
653 wrong_args (const char *text)
654 {
655   fprintf (stderr, _("usage: %s [options] %s\n"), GPGSM_NAME, text);
656   gpgsm_exit (2);
657 }
658
659
660 static void
661 set_opt_session_env (const char *name, const char *value)
662 {
663   gpg_error_t err;
664
665   err = session_env_setenv (opt.session_env, name, value);
666   if (err)
667     log_fatal ("error setting session environment: %s\n",
668                gpg_strerror (err));
669 }
670
671
672 /* Setup the debugging.  With a DEBUG_LEVEL of NULL only the active
673    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
674    set, a specific set of debug flags is set; and individual debugging
675    flags will be added on top.  */
676 static void
677 set_debug (void)
678 {
679   int numok = (debug_level && digitp (debug_level));
680   int numlvl = numok? atoi (debug_level) : 0;
681
682   if (!debug_level)
683     ;
684   else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
685     opt.debug = 0;
686   else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
687     opt.debug = DBG_IPC_VALUE;
688   else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
689     opt.debug = DBG_IPC_VALUE|DBG_X509_VALUE;
690   else if (!strcmp (debug_level, "expert")  || (numok && numlvl <= 8))
691     opt.debug = (DBG_IPC_VALUE|DBG_X509_VALUE
692                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
693   else if (!strcmp (debug_level, "guru") || numok)
694     {
695       opt.debug = ~0;
696       /* Unless the "guru" string has been used we don't want to allow
697          hashing debugging.  The rationale is that people tend to
698          select the highest debug value and would then clutter their
699          disk with debug files which may reveal confidential data.  */
700       if (numok)
701         opt.debug &= ~(DBG_HASHING_VALUE);
702     }
703   else
704     {
705       log_error (_("invalid debug-level '%s' given\n"), debug_level);
706       gpgsm_exit (2);
707     }
708
709   opt.debug |= debug_value;
710
711   if (opt.debug && !opt.verbose)
712     opt.verbose = 1;
713   if (opt.debug)
714     opt.quiet = 0;
715
716   if (opt.debug & DBG_MPI_VALUE)
717     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
718   if (opt.debug & DBG_CRYPTO_VALUE )
719     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
720   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
721
722   if (opt.debug)
723     parse_debug_flag (NULL, &opt.debug, debug_flags);
724 }
725
726
727
728 static void
729 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
730 {
731   enum cmd_and_opt_values cmd = *ret_cmd;
732
733   if (!cmd || cmd == new_cmd)
734     cmd = new_cmd;
735   else if ( cmd == aSign && new_cmd == aEncr )
736     cmd = aSignEncr;
737   else if ( cmd == aEncr && new_cmd == aSign )
738     cmd = aSignEncr;
739   else if ( (cmd == aSign && new_cmd == aClearsign)
740             || (cmd == aClearsign && new_cmd == aSign) )
741     cmd = aClearsign;
742   else
743     {
744       log_error(_("conflicting commands\n"));
745       gpgsm_exit(2);
746     }
747
748   *ret_cmd = cmd;
749 }
750
751
752 /* Helper to add recipients to a list. */
753 static void
754 do_add_recipient (ctrl_t ctrl, const char *name,
755                   certlist_t *recplist, int is_encrypt_to, int recp_required)
756 {
757   int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
758   if (rc)
759     {
760       if (recp_required)
761         {
762           log_error ("can't encrypt to '%s': %s\n", name, gpg_strerror (rc));
763           gpgsm_status2 (ctrl, STATUS_INV_RECP,
764                          get_inv_recpsgnr_code (rc), name, NULL);
765         }
766       else
767         log_info (_("Note: won't be able to encrypt to '%s': %s\n"),
768                   name, gpg_strerror (rc));
769     }
770 }
771
772
773 static void
774 parse_validation_model (const char *model)
775 {
776   int i = gpgsm_parse_validation_model (model);
777   if (i == -1)
778     log_error (_("unknown validation model '%s'\n"), model);
779   else
780     default_validation_model = i;
781 }
782
783
784 /* Release the list of SERVERS.  As usual it is okay to call this
785    function with SERVERS passed as NULL.  */
786 void
787 keyserver_list_free (struct keyserver_spec *servers)
788 {
789   while (servers)
790     {
791       struct keyserver_spec *tmp = servers->next;
792       xfree (servers->host);
793       xfree (servers->user);
794       if (servers->pass)
795         memset (servers->pass, 0, strlen (servers->pass));
796       xfree (servers->pass);
797       xfree (servers->base);
798       xfree (servers);
799       servers = tmp;
800     }
801 }
802
803 /* See also dirmngr ldapserver_parse_one().  */
804 struct keyserver_spec *
805 parse_keyserver_line (char *line,
806                       const char *filename, unsigned int lineno)
807 {
808   char *p;
809   char *endp;
810   struct keyserver_spec *server;
811   int fieldno;
812   int fail = 0;
813
814   /* Parse the colon separated fields.  */
815   server = xcalloc (1, sizeof *server);
816   for (fieldno = 1, p = line; p; p = endp, fieldno++ )
817     {
818       endp = strchr (p, ':');
819       if (endp)
820         *endp++ = '\0';
821       trim_spaces (p);
822       switch (fieldno)
823         {
824         case 1:
825           if (*p)
826             server->host = xstrdup (p);
827           else
828             {
829               log_error (_("%s:%u: no hostname given\n"),
830                          filename, lineno);
831               fail = 1;
832             }
833           break;
834
835         case 2:
836           if (*p)
837             server->port = atoi (p);
838           break;
839
840         case 3:
841           if (*p)
842             server->user = xstrdup (p);
843           break;
844
845         case 4:
846           if (*p && !server->user)
847             {
848               log_error (_("%s:%u: password given without user\n"),
849                          filename, lineno);
850               fail = 1;
851             }
852           else if (*p)
853             server->pass = xstrdup (p);
854           break;
855
856         case 5:
857           if (*p)
858             server->base = xstrdup (p);
859           break;
860
861         default:
862           /* (We silently ignore extra fields.) */
863           break;
864         }
865     }
866
867   if (fail)
868     {
869       log_info (_("%s:%u: skipping this line\n"), filename, lineno);
870       keyserver_list_free (server);
871       server = NULL;
872     }
873
874   return server;
875 }
876
877
878 int
879 main ( int argc, char **argv)
880 {
881   ARGPARSE_ARGS pargs;
882   int orig_argc;
883   char **orig_argv;
884   /*  char *username;*/
885   int may_coredump;
886   strlist_t sl, remusr= NULL, locusr=NULL;
887   strlist_t nrings=NULL;
888   int detached_sig = 0;
889   FILE *configfp = NULL;
890   char *configname = NULL;
891   unsigned configlineno;
892   int parse_debug = 0;
893   int no_more_options = 0;
894   int default_config =1;
895   int default_keyring = 1;
896   char *logfile = NULL;
897   char *auditlog = NULL;
898   char *htmlauditlog = NULL;
899   int greeting = 0;
900   int nogreeting = 0;
901   int debug_wait = 0;
902   int use_random_seed = 1;
903   int no_common_certs_import = 0;
904   int with_fpr = 0;
905   const char *forced_digest_algo = NULL;
906   const char *extra_digest_algo = NULL;
907   enum cmd_and_opt_values cmd = 0;
908   struct server_control_s ctrl;
909   certlist_t recplist = NULL;
910   certlist_t signerlist = NULL;
911   int do_not_setup_keys = 0;
912   int recp_required = 0;
913   estream_t auditfp = NULL;
914   estream_t htmlauditfp = NULL;
915   struct assuan_malloc_hooks malloc_hooks;
916   int pwfd = -1;
917   /*mtrace();*/
918
919   early_system_init ();
920   gnupg_reopen_std (GPGSM_NAME);
921   /* trap_unaligned ();*/
922   gnupg_rl_initialize ();
923   set_strusage (my_strusage);
924   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
925
926   /* Please note that we may running SUID(ROOT), so be very CAREFUL
927      when adding any stuff between here and the call to secmem_init()
928      somewhere after the option parsing */
929   log_set_prefix (GPGSM_NAME, GPGRT_LOG_WITH_PREFIX);
930
931   /* Make sure that our subsystems are ready.  */
932   i18n_init ();
933   init_common_subsystems (&argc, &argv);
934
935   /* Check that the libraries are suitable.  Do it here because the
936      option parse may need services of the library */
937   if (!ksba_check_version (NEED_KSBA_VERSION) )
938     log_fatal (_("%s is too old (need %s, have %s)\n"), "libksba",
939                NEED_KSBA_VERSION, ksba_check_version (NULL) );
940
941
942   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
943
944   may_coredump = disable_core_dumps ();
945
946   gnupg_init_signals (0, emergency_cleanup);
947
948   dotlock_create (NULL, 0); /* Register lockfile cleanup.  */
949
950   opt.autostart = 1;
951   opt.session_env = session_env_new ();
952   if (!opt.session_env)
953     log_fatal ("error allocating session environment block: %s\n",
954                strerror (errno));
955
956   /* Note: If you change this default cipher algorithm , please
957      remember to update the Gpgconflist entry as well.  */
958   opt.def_cipher_algoid = DEFAULT_CIPHER_ALGO;
959
960
961   /* First check whether we have a config file on the commandline */
962   orig_argc = argc;
963   orig_argv = argv;
964   pargs.argc = &argc;
965   pargs.argv = &argv;
966   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
967   while (arg_parse( &pargs, opts))
968     {
969       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
970         parse_debug++;
971       else if (pargs.r_opt == oOptions)
972         { /* yes there is one, so we do not try the default one but
973              read the config file when it is encountered at the
974              commandline */
975           default_config = 0;
976         }
977       else if (pargs.r_opt == oNoOptions)
978         {
979           default_config = 0; /* --no-options */
980           opt.no_homedir_creation = 1;
981         }
982       else if (pargs.r_opt == oHomedir)
983         gnupg_set_homedir (pargs.r.ret_str);
984       else if (pargs.r_opt == aCallProtectTool)
985         break; /* This break makes sure that --version and --help are
986                   passed to the protect-tool. */
987     }
988
989
990   /* Initialize the secure memory. */
991   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
992   maybe_setuid = 0;
993
994   /*
995      Now we are now working under our real uid
996   */
997
998   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
999
1000   malloc_hooks.malloc = gcry_malloc;
1001   malloc_hooks.realloc = gcry_realloc;
1002   malloc_hooks.free = gcry_free;
1003   assuan_set_malloc_hooks (&malloc_hooks);
1004   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
1005   setup_libassuan_logging (&opt.debug, NULL);
1006
1007   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
1008
1009   /* Setup a default control structure for command line mode */
1010   memset (&ctrl, 0, sizeof ctrl);
1011   gpgsm_init_default_ctrl (&ctrl);
1012   ctrl.no_server = 1;
1013   ctrl.status_fd = -1; /* No status output. */
1014   ctrl.autodetect_encoding = 1;
1015
1016   /* Set the default option file */
1017   if (default_config )
1018     configname = make_filename (gnupg_homedir (),
1019                                 GPGSM_NAME EXTSEP_S "conf", NULL);
1020   /* Set the default policy file */
1021   opt.policy_file = make_filename (gnupg_homedir (), "policies.txt", NULL);
1022
1023   argc        = orig_argc;
1024   argv        = orig_argv;
1025   pargs.argc  = &argc;
1026   pargs.argv  = &argv;
1027   pargs.flags =  1;  /* do not remove the args */
1028
1029  next_pass:
1030   if (configname) {
1031     configlineno = 0;
1032     configfp = fopen (configname, "r");
1033     if (!configfp)
1034       {
1035         if (default_config)
1036           {
1037             if (parse_debug)
1038               log_info (_("Note: no default option file '%s'\n"), configname);
1039           }
1040         else
1041           {
1042             log_error (_("option file '%s': %s\n"), configname, strerror(errno));
1043             gpgsm_exit(2);
1044           }
1045         xfree(configname);
1046         configname = NULL;
1047       }
1048     if (parse_debug && configname)
1049       log_info (_("reading options from '%s'\n"), configname);
1050     default_config = 0;
1051   }
1052
1053   while (!no_more_options
1054          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
1055     {
1056       switch (pargs.r_opt)
1057         {
1058         case aGPGConfList:
1059         case aGPGConfTest:
1060           set_cmd (&cmd, pargs.r_opt);
1061           do_not_setup_keys = 1;
1062           nogreeting = 1;
1063           break;
1064
1065         case aServer:
1066           opt.batch = 1;
1067           set_cmd (&cmd, aServer);
1068           break;
1069
1070         case aCallDirmngr:
1071           opt.batch = 1;
1072           set_cmd (&cmd, aCallDirmngr);
1073           do_not_setup_keys = 1;
1074           break;
1075
1076         case aCallProtectTool:
1077           opt.batch = 1;
1078           set_cmd (&cmd, aCallProtectTool);
1079           no_more_options = 1; /* Stop parsing. */
1080           do_not_setup_keys = 1;
1081           break;
1082
1083         case aDeleteKey:
1084           set_cmd (&cmd, aDeleteKey);
1085           /*greeting=1;*/
1086           do_not_setup_keys = 1;
1087           break;
1088
1089         case aDetachedSign:
1090           detached_sig = 1;
1091           set_cmd (&cmd, aSign );
1092           break;
1093
1094         case aKeygen:
1095           set_cmd (&cmd, aKeygen);
1096           greeting=1;
1097           do_not_setup_keys = 1;
1098           break;
1099
1100         case aImport:
1101         case aSendKeys:
1102         case aRecvKeys:
1103         case aExport:
1104         case aExportSecretKeyP12:
1105         case aExportSecretKeyP8:
1106         case aExportSecretKeyRaw:
1107         case aDumpKeys:
1108         case aDumpChain:
1109         case aDumpExternalKeys:
1110         case aDumpSecretKeys:
1111         case aListKeys:
1112         case aListExternalKeys:
1113         case aListSecretKeys:
1114         case aListChain:
1115         case aLearnCard:
1116         case aPasswd:
1117         case aKeydbClearSomeCertFlags:
1118           do_not_setup_keys = 1;
1119           set_cmd (&cmd, pargs.r_opt);
1120           break;
1121
1122         case aEncr:
1123           recp_required = 1;
1124           set_cmd (&cmd, pargs.r_opt);
1125           break;
1126
1127         case aSym:
1128         case aDecrypt:
1129         case aSign:
1130         case aClearsign:
1131         case aVerify:
1132           set_cmd (&cmd, pargs.r_opt);
1133           break;
1134
1135           /* Output encoding selection.  */
1136         case oArmor:
1137           ctrl.create_pem = 1;
1138           break;
1139         case oBase64:
1140           ctrl.create_pem = 0;
1141           ctrl.create_base64 = 1;
1142           break;
1143         case oNoArmor:
1144           ctrl.create_pem = 0;
1145           ctrl.create_base64 = 0;
1146           break;
1147
1148         case oP12Charset:
1149           opt.p12_charset = pargs.r.ret_str;
1150           break;
1151
1152         case oPassphraseFD:
1153           pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
1154           break;
1155
1156         case oPinentryMode:
1157           opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
1158           if (opt.pinentry_mode == -1)
1159             log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
1160           break;
1161
1162           /* Input encoding selection.  */
1163         case oAssumeArmor:
1164           ctrl.autodetect_encoding = 0;
1165           ctrl.is_pem = 1;
1166           ctrl.is_base64 = 0;
1167           break;
1168         case oAssumeBase64:
1169           ctrl.autodetect_encoding = 0;
1170           ctrl.is_pem = 0;
1171           ctrl.is_base64 = 1;
1172           break;
1173         case oAssumeBinary:
1174           ctrl.autodetect_encoding = 0;
1175           ctrl.is_pem = 0;
1176           ctrl.is_base64 = 0;
1177           break;
1178
1179         case oDisableCRLChecks:
1180           opt.no_crl_check = 1;
1181           break;
1182         case oEnableCRLChecks:
1183           opt.no_crl_check = 0;
1184           break;
1185         case oDisableTrustedCertCRLCheck:
1186           opt.no_trusted_cert_crl_check = 1;
1187           break;
1188         case oEnableTrustedCertCRLCheck:
1189           opt.no_trusted_cert_crl_check = 0;
1190           break;
1191         case oForceCRLRefresh:
1192           opt.force_crl_refresh = 1;
1193           break;
1194
1195         case oDisableOCSP:
1196           ctrl.use_ocsp = opt.enable_ocsp = 0;
1197           break;
1198         case oEnableOCSP:
1199           ctrl.use_ocsp = opt.enable_ocsp = 1;
1200           break;
1201
1202         case oIncludeCerts:
1203           ctrl.include_certs = default_include_certs = pargs.r.ret_int;
1204           break;
1205
1206         case oPolicyFile:
1207           xfree (opt.policy_file);
1208           if (*pargs.r.ret_str)
1209             opt.policy_file = xstrdup (pargs.r.ret_str);
1210           else
1211             opt.policy_file = NULL;
1212           break;
1213
1214         case oDisablePolicyChecks:
1215           opt.no_policy_check = 1;
1216           break;
1217         case oEnablePolicyChecks:
1218           opt.no_policy_check = 0;
1219           break;
1220
1221         case oAutoIssuerKeyRetrieve:
1222           opt.auto_issuer_key_retrieve = 1;
1223           break;
1224
1225         case oOutput: opt.outfile = pargs.r.ret_str; break;
1226
1227
1228         case oQuiet: opt.quiet = 1; break;
1229         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1230         case oDryRun: opt.dry_run = 1; break;
1231
1232         case oVerbose:
1233           opt.verbose++;
1234           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1235           break;
1236         case oNoVerbose:
1237           opt.verbose = 0;
1238           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1239           break;
1240
1241         case oLogFile: logfile = pargs.r.ret_str; break;
1242         case oNoLogFile: logfile = NULL; break;
1243
1244         case oAuditLog: auditlog = pargs.r.ret_str; break;
1245         case oHtmlAuditLog: htmlauditlog = pargs.r.ret_str; break;
1246
1247         case oBatch:
1248           opt.batch = 1;
1249           greeting = 0;
1250           break;
1251         case oNoBatch: opt.batch = 0; break;
1252
1253         case oAnswerYes: opt.answer_yes = 1; break;
1254         case oAnswerNo: opt.answer_no = 1; break;
1255
1256         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1257
1258         case oDebug:
1259           if (parse_debug_flag (pargs.r.ret_str, &debug_value, debug_flags))
1260             {
1261               pargs.r_opt = ARGPARSE_INVALID_ARG;
1262               pargs.err = ARGPARSE_PRINT_ERROR;
1263             }
1264           break;
1265         case oDebugAll: debug_value = ~0; break;
1266         case oDebugNone: debug_value = 0; break;
1267         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1268         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1269         case oDebugAllowCoreDump:
1270           may_coredump = enable_core_dumps ();
1271           break;
1272         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1273         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1274
1275         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1276         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1277         case oWithMD5Fingerprint:
1278           opt.with_md5_fingerprint=1; /*fall through*/
1279         case oWithFingerprint:
1280           with_fpr=1; /*fall through*/
1281         case aFingerprint:
1282           opt.fingerprint++;
1283           break;
1284
1285         case oWithKeygrip:
1286           opt.with_keygrip = 1;
1287           break;
1288
1289         case oOptions:
1290           /* config files may not be nested (silently ignore them) */
1291           if (!configfp)
1292             {
1293               xfree(configname);
1294               configname = xstrdup (pargs.r.ret_str);
1295               goto next_pass;
1296             }
1297           break;
1298         case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1299         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
1300         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1301
1302         case oDisplay:
1303           set_opt_session_env ("DISPLAY", pargs.r.ret_str);
1304           break;
1305         case oTTYname:
1306           set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
1307           break;
1308         case oTTYtype:
1309           set_opt_session_env ("TERM", pargs.r.ret_str);
1310           break;
1311         case oXauthority:
1312           set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
1313           break;
1314
1315         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1316         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1317
1318         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1319         case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
1320         case oPreferSystemDirmngr: /* Obsolete */; break;
1321         case oProtectToolProgram:
1322           opt.protect_tool_program = pargs.r.ret_str;
1323           break;
1324
1325         case oFakedSystemTime:
1326           {
1327             time_t faked_time = isotime2epoch (pargs.r.ret_str);
1328             if (faked_time == (time_t)(-1))
1329               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1330             gnupg_set_time (faked_time, 0);
1331           }
1332           break;
1333
1334         case oNoDefKeyring: default_keyring = 0; break;
1335         case oNoGreeting: nogreeting = 1; break;
1336
1337         case oDefaultKey:
1338           if (*pargs.r.ret_str)
1339             {
1340               xfree (opt.local_user);
1341               opt.local_user = xstrdup (pargs.r.ret_str);
1342             }
1343           break;
1344         case oDefRecipient:
1345           if (*pargs.r.ret_str)
1346             opt.def_recipient = xstrdup (pargs.r.ret_str);
1347           break;
1348         case oDefRecipientSelf:
1349           xfree (opt.def_recipient);
1350           opt.def_recipient = NULL;
1351           opt.def_recipient_self = 1;
1352           break;
1353         case oNoDefRecipient:
1354           xfree (opt.def_recipient);
1355           opt.def_recipient = NULL;
1356           opt.def_recipient_self = 0;
1357           break;
1358
1359         case oWithKeyData: opt.with_key_data=1; /* fall through */
1360         case oWithColons: ctrl.with_colons = 1; break;
1361         case oWithSecret: ctrl.with_secret = 1; break;
1362         case oWithValidation: ctrl.with_validation=1; break;
1363         case oWithEphemeralKeys: ctrl.with_ephemeral_keys=1; break;
1364
1365         case oSkipVerify: opt.skip_verify=1; break;
1366
1367         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1368         case oEncryptTo: /* Store the recipient in the second list */
1369           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1370           sl->flags = 1;
1371           break;
1372
1373         case oRecipient: /* store the recipient */
1374           add_to_strlist ( &remusr, pargs.r.ret_str);
1375           break;
1376
1377         case oUser: /* Store the local users, the first one is the default */
1378           if (!opt.local_user)
1379             opt.local_user = xstrdup (pargs.r.ret_str);
1380           add_to_strlist (&locusr, pargs.r.ret_str);
1381           break;
1382
1383         case oNoSecmemWarn:
1384           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
1385           break;
1386
1387         case oCipherAlgo:
1388           opt.def_cipher_algoid = pargs.r.ret_str;
1389           break;
1390
1391         case oDisableCipherAlgo:
1392           {
1393             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1394             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1395           }
1396           break;
1397         case oDisablePubkeyAlgo:
1398           {
1399             int algo = gcry_pk_map_name (pargs.r.ret_str);
1400             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1401           }
1402           break;
1403
1404         case oDigestAlgo:
1405           forced_digest_algo = pargs.r.ret_str;
1406           break;
1407
1408         case oExtraDigestAlgo:
1409           extra_digest_algo = pargs.r.ret_str;
1410           break;
1411
1412         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1413         case oNoRandomSeedFile: use_random_seed = 0; break;
1414         case oNoCommonCertsImport: no_common_certs_import = 1; break;
1415
1416         case oEnableSpecialFilenames:
1417           enable_special_filenames ();
1418           break;
1419
1420         case oValidationModel: parse_validation_model (pargs.r.ret_str); break;
1421
1422         case oKeyServer:
1423           {
1424             struct keyserver_spec *keyserver;
1425             keyserver = parse_keyserver_line (pargs.r.ret_str,
1426                                               configname, configlineno);
1427             if (! keyserver)
1428               log_error (_("could not parse keyserver\n"));
1429             else
1430               {
1431                 /* FIXME: Keep last next pointer.  */
1432                 struct keyserver_spec **next_p = &opt.keyserver;
1433                 while (*next_p)
1434                   next_p = &(*next_p)->next;
1435                 *next_p = keyserver;
1436               }
1437           }
1438           break;
1439
1440         case oIgnoreCertExtension:
1441           add_to_strlist (&opt.ignored_cert_extensions, pargs.r.ret_str);
1442           break;
1443
1444         case oNoAutostart: opt.autostart = 0; break;
1445
1446         case oCompliance:
1447           {
1448             struct gnupg_compliance_option compliance_options[] =
1449               {
1450                 { "de-vs", CO_DE_VS }
1451               };
1452             int compliance = gnupg_parse_compliance_option (pargs.r.ret_str,
1453                                                             compliance_options,
1454                                                             DIM (compliance_options),
1455                                                             opt.quiet);
1456             if (compliance < 0)
1457               gpgsm_exit (1);
1458             opt.compliance = compliance;
1459           }
1460           break;
1461
1462         default:
1463           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
1464           break;
1465         }
1466     }
1467
1468   if (configfp)
1469     {
1470       fclose (configfp);
1471       configfp = NULL;
1472       /* Keep a copy of the config filename. */
1473       opt.config_filename = configname;
1474       configname = NULL;
1475       goto next_pass;
1476     }
1477   xfree (configname);
1478   configname = NULL;
1479
1480   if (!opt.config_filename)
1481     opt.config_filename = make_filename (gnupg_homedir (),
1482                                          GPGSM_NAME EXTSEP_S "conf",
1483                                          NULL);
1484
1485   if (log_get_errorcount(0))
1486     gpgsm_exit(2);
1487
1488   if (pwfd != -1)       /* Read the passphrase now.  */
1489     read_passphrase_from_fd (pwfd);
1490
1491   /* Now that we have the options parsed we need to update the default
1492      control structure.  */
1493   gpgsm_init_default_ctrl (&ctrl);
1494
1495   if (nogreeting)
1496     greeting = 0;
1497
1498   if (greeting)
1499     {
1500       es_fprintf (es_stderr, "%s %s; %s\n",
1501                   strusage(11), strusage(13), strusage(14) );
1502       es_fprintf (es_stderr, "%s\n", strusage(15) );
1503     }
1504 #  ifdef IS_DEVELOPMENT_VERSION
1505   if (!opt.batch)
1506     {
1507       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1508       log_info ("It is only intended for test purposes and should NOT be\n");
1509       log_info ("used in a production environment or with production keys!\n");
1510     }
1511 #  endif
1512
1513   if (may_coredump && !opt.quiet)
1514     log_info (_("WARNING: program may create a core file!\n"));
1515
1516 /*   if (opt.qualsig_approval && !opt.quiet) */
1517 /*     log_info (_("This software has officially been approved to " */
1518 /*                 "create and verify\n" */
1519 /*                 "qualified signatures according to German law.\n")); */
1520
1521   if (logfile && cmd == aServer)
1522     {
1523       log_set_file (logfile);
1524       log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
1525     }
1526
1527   if (gnupg_faked_time_p ())
1528     {
1529       gnupg_isotime_t tbuf;
1530
1531       log_info (_("WARNING: running with faked system time: "));
1532       gnupg_get_isotime (tbuf);
1533       dump_isotime (tbuf);
1534       log_printf ("\n");
1535     }
1536
1537   /* Print a warning if an argument looks like an option.  */
1538   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1539     {
1540       int i;
1541
1542       for (i=0; i < argc; i++)
1543         if (argv[i][0] == '-' && argv[i][1] == '-')
1544           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1545     }
1546
1547 /*FIXME    if (opt.batch) */
1548 /*      tty_batchmode (1); */
1549
1550   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1551
1552   set_debug ();
1553
1554   /* Although we always use gpgsm_exit, we better install a regualr
1555      exit handler so that at least the secure memory gets wiped
1556      out. */
1557   if (atexit (emergency_cleanup))
1558     {
1559       log_error ("atexit failed\n");
1560       gpgsm_exit (2);
1561     }
1562
1563   /* Must do this after dropping setuid, because the mapping functions
1564      may try to load an module and we may have disabled an algorithm.
1565      We remap the commonly used algorithms to the OIDs for
1566      convenience.  We need to work with the OIDs because they are used
1567      to check whether the encryption mode is actually available. */
1568   if (!strcmp (opt.def_cipher_algoid, "3DES") )
1569     opt.def_cipher_algoid = "1.2.840.113549.3.7";
1570   else if (!strcmp (opt.def_cipher_algoid, "AES")
1571            || !strcmp (opt.def_cipher_algoid, "AES128"))
1572     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1573   else if (!strcmp (opt.def_cipher_algoid, "AES192") )
1574     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.22";
1575   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1576     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1577   else if (!strcmp (opt.def_cipher_algoid, "SERPENT")
1578            || !strcmp (opt.def_cipher_algoid, "SERPENT128") )
1579     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.2";
1580   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1581     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.22";
1582   else if (!strcmp (opt.def_cipher_algoid, "SERPENT256") )
1583     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.42";
1584   else if (!strcmp (opt.def_cipher_algoid, "SEED") )
1585     opt.def_cipher_algoid = "1.2.410.200004.1.4";
1586   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA")
1587            || !strcmp (opt.def_cipher_algoid, "CAMELLIA128") )
1588     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.2";
1589   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA192") )
1590     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
1591   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
1592     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
1593
1594   if (cmd != aGPGConfList)
1595     {
1596       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1597            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1598         log_error (_("selected cipher algorithm is invalid\n"));
1599
1600       if (forced_digest_algo)
1601         {
1602           opt.forced_digest_algo = gcry_md_map_name (forced_digest_algo);
1603           if (our_md_test_algo(opt.forced_digest_algo) )
1604             log_error (_("selected digest algorithm is invalid\n"));
1605         }
1606       if (extra_digest_algo)
1607         {
1608           opt.extra_digest_algo = gcry_md_map_name (extra_digest_algo);
1609           if (our_md_test_algo (opt.extra_digest_algo) )
1610             log_error (_("selected digest algorithm is invalid\n"));
1611         }
1612     }
1613
1614   if (log_get_errorcount(0))
1615     gpgsm_exit(2);
1616
1617   /* Set the random seed file. */
1618   if (use_random_seed)
1619     {
1620       char *p = make_filename (gnupg_homedir (), "random_seed", NULL);
1621       gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1622       xfree(p);
1623     }
1624
1625   if (!cmd && opt.fingerprint && !with_fpr)
1626     set_cmd (&cmd, aListKeys);
1627
1628   /* Add default keybox. */
1629   if (!nrings && default_keyring)
1630     {
1631       int created;
1632
1633       keydb_add_resource (&ctrl, "pubring.kbx", 0, &created);
1634       if (created && !no_common_certs_import)
1635         {
1636           /* Import the standard certificates for a new default keybox. */
1637           char *filelist[2];
1638
1639           filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
1640           filelist[1] = NULL;
1641           if (!access (filelist[0], F_OK))
1642             {
1643               log_info (_("importing common certificates '%s'\n"),
1644                         filelist[0]);
1645               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1646             }
1647           xfree (filelist[0]);
1648         }
1649     }
1650   for (sl = nrings; sl; sl = sl->next)
1651     keydb_add_resource (&ctrl, sl->d, 0, NULL);
1652   FREE_STRLIST(nrings);
1653
1654
1655   /* Prepare the audit log feature for certain commands.  */
1656   if (auditlog || htmlauditlog)
1657     {
1658       switch (cmd)
1659         {
1660         case aEncr:
1661         case aSign:
1662         case aDecrypt:
1663         case aVerify:
1664           audit_release (ctrl.audit);
1665           ctrl.audit = audit_new ();
1666           if (auditlog)
1667             auditfp = open_es_fwrite (auditlog);
1668           if (htmlauditlog)
1669             htmlauditfp = open_es_fwrite (htmlauditlog);
1670           break;
1671         default:
1672           break;
1673         }
1674     }
1675
1676
1677   if (!do_not_setup_keys)
1678     {
1679       for (sl = locusr; sl ; sl = sl->next)
1680         {
1681           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1682           if (rc)
1683             {
1684               log_error (_("can't sign using '%s': %s\n"),
1685                          sl->d, gpg_strerror (rc));
1686               gpgsm_status2 (&ctrl, STATUS_INV_SGNR,
1687                              get_inv_recpsgnr_code (rc), sl->d, NULL);
1688               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1689                              get_inv_recpsgnr_code (rc), sl->d, NULL);
1690             }
1691         }
1692
1693       /* Build the recipient list.  We first add the regular ones and then
1694          the encrypt-to ones because the underlying function will silently
1695          ignore duplicates and we can't allow keeping a duplicate which is
1696          flagged as encrypt-to as the actually encrypt function would then
1697          complain about no (regular) recipients. */
1698       for (sl = remusr; sl; sl = sl->next)
1699         if (!(sl->flags & 1))
1700           do_add_recipient (&ctrl, sl->d, &recplist, 0, recp_required);
1701       if (!opt.no_encrypt_to)
1702         {
1703           for (sl = remusr; sl; sl = sl->next)
1704             if ((sl->flags & 1))
1705               do_add_recipient (&ctrl, sl->d, &recplist, 1, recp_required);
1706         }
1707     }
1708
1709   if (log_get_errorcount(0))
1710     gpgsm_exit(1); /* Must stop for invalid recipients. */
1711
1712   /* Dispatch command.  */
1713   switch (cmd)
1714     {
1715     case aGPGConfList:
1716       { /* List options and default values in the GPG Conf format.  */
1717         char *config_filename_esc = percent_escape (opt.config_filename, NULL);
1718
1719         es_printf ("%s-%s.conf:%lu:\"%s\n",
1720                    GPGCONF_NAME, GPGSM_NAME,
1721                    GC_OPT_FLAG_DEFAULT, config_filename_esc);
1722         xfree (config_filename_esc);
1723
1724         es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1725         es_printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
1726         es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1727         es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1728         es_printf ("disable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
1729         es_printf ("enable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
1730         es_printf ("disable-trusted-cert-crl-check:%lu:\n", GC_OPT_FLAG_NONE);
1731         es_printf ("enable-ocsp:%lu:\n", GC_OPT_FLAG_NONE);
1732         es_printf ("include-certs:%lu:%d:\n", GC_OPT_FLAG_DEFAULT,
1733                    DEFAULT_INCLUDE_CERTS);
1734         es_printf ("disable-policy-checks:%lu:\n", GC_OPT_FLAG_NONE);
1735         es_printf ("auto-issuer-key-retrieve:%lu:\n", GC_OPT_FLAG_NONE);
1736         es_printf ("disable-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1737         es_printf ("cipher-algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1738                    DEFAULT_CIPHER_ALGO);
1739         es_printf ("p12-charset:%lu:\n", GC_OPT_FLAG_DEFAULT);
1740         es_printf ("default-key:%lu:\n", GC_OPT_FLAG_DEFAULT);
1741         es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_DEFAULT);
1742         es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1743
1744         /* The next one is an info only item and should match what
1745            proc_parameters actually implements.  */
1746         es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1747                    "RSA-2048");
1748
1749       }
1750       break;
1751     case aGPGConfTest:
1752       /* This is merely a dummy command to test whether the
1753          configuration file is valid.  */
1754       break;
1755
1756     case aServer:
1757       if (debug_wait)
1758         {
1759           log_debug ("waiting for debugger - my pid is %u .....\n",
1760                      (unsigned int)getpid());
1761           gnupg_sleep (debug_wait);
1762           log_debug ("... okay\n");
1763          }
1764       gpgsm_server (recplist);
1765       break;
1766
1767     case aCallDirmngr:
1768       if (!argc)
1769         wrong_args ("--call-dirmngr <command> {args}");
1770       else
1771         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1772           gpgsm_exit (1);
1773       break;
1774
1775     case aCallProtectTool:
1776       run_protect_tool (argc, argv);
1777       break;
1778
1779     case aEncr: /* Encrypt the given file. */
1780       {
1781         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1782
1783         set_binary (stdin);
1784
1785         if (!argc) /* Source is stdin. */
1786           gpgsm_encrypt (&ctrl, recplist, 0, fp);
1787         else if (argc == 1)  /* Source is the given file. */
1788           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1789         else
1790           wrong_args ("--encrypt [datafile]");
1791
1792         es_fclose (fp);
1793       }
1794       break;
1795
1796     case aSign: /* Sign the given file. */
1797       {
1798         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1799
1800         /* Fixme: We should also allow concatenation of multiple files for
1801            signing because that is what gpg does.*/
1802         set_binary (stdin);
1803         if (!argc) /* Create from stdin. */
1804           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp);
1805         else if (argc == 1) /* From file. */
1806           gpgsm_sign (&ctrl, signerlist,
1807                       open_read (*argv), detached_sig, fp);
1808         else
1809           wrong_args ("--sign [datafile]");
1810
1811         es_fclose (fp);
1812       }
1813       break;
1814
1815     case aSignEncr: /* sign and encrypt the given file */
1816       log_error ("this command has not yet been implemented\n");
1817       break;
1818
1819     case aClearsign: /* make a clearsig */
1820       log_error ("this command has not yet been implemented\n");
1821       break;
1822
1823     case aVerify:
1824       {
1825         estream_t fp = NULL;
1826
1827         set_binary (stdin);
1828         if (argc == 2 && opt.outfile)
1829           log_info ("option --output ignored for a detached signature\n");
1830         else if (opt.outfile)
1831           fp = open_es_fwrite (opt.outfile);
1832
1833         if (!argc)
1834           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1835         else if (argc == 1)
1836           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1837         else if (argc == 2) /* detached signature (sig, detached) */
1838           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL);
1839         else
1840           wrong_args ("--verify [signature [detached_data]]");
1841
1842         es_fclose (fp);
1843       }
1844       break;
1845
1846     case aDecrypt:
1847       {
1848         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1849
1850         set_binary (stdin);
1851         if (!argc)
1852           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1853         else if (argc == 1)
1854           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1855         else
1856           wrong_args ("--decrypt [filename]");
1857
1858         es_fclose (fp);
1859       }
1860       break;
1861
1862     case aDeleteKey:
1863       for (sl=NULL; argc; argc--, argv++)
1864         add_to_strlist (&sl, *argv);
1865       gpgsm_delete (&ctrl, sl);
1866       free_strlist(sl);
1867       break;
1868
1869     case aListChain:
1870     case aDumpChain:
1871        ctrl.with_chain = 1; /* fall through */
1872     case aListKeys:
1873     case aDumpKeys:
1874     case aListExternalKeys:
1875     case aDumpExternalKeys:
1876     case aListSecretKeys:
1877     case aDumpSecretKeys:
1878       {
1879         unsigned int mode;
1880         estream_t fp;
1881
1882         switch (cmd)
1883           {
1884           case aListChain:
1885           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1886           case aDumpChain:
1887           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1888           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1889           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1890           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1891           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1892           default: BUG();
1893           }
1894
1895         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1896         for (sl=NULL; argc; argc--, argv++)
1897           add_to_strlist (&sl, *argv);
1898         gpgsm_list_keys (&ctrl, sl, fp, mode);
1899         free_strlist(sl);
1900         es_fclose (fp);
1901       }
1902       break;
1903
1904
1905     case aKeygen: /* Generate a key; well kind of. */
1906       {
1907         estream_t fpin = NULL;
1908         estream_t fpout;
1909
1910         if (opt.batch)
1911           {
1912             if (!argc) /* Create from stdin. */
1913               fpin = open_es_fread ("-", "r");
1914             else if (argc == 1) /* From file. */
1915               fpin = open_es_fread (*argv, "r");
1916             else
1917               wrong_args ("--generate-key --batch [parmfile]");
1918           }
1919
1920         fpout = open_es_fwrite (opt.outfile?opt.outfile:"-");
1921
1922         if (fpin)
1923           gpgsm_genkey (&ctrl, fpin, fpout);
1924         else
1925           gpgsm_gencertreq_tty (&ctrl, fpout);
1926
1927         es_fclose (fpout);
1928       }
1929       break;
1930
1931
1932     case aImport:
1933       gpgsm_import_files (&ctrl, argc, argv, open_read);
1934       break;
1935
1936     case aExport:
1937       {
1938         estream_t fp;
1939
1940         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1941         for (sl=NULL; argc; argc--, argv++)
1942           add_to_strlist (&sl, *argv);
1943         gpgsm_export (&ctrl, sl, fp);
1944         free_strlist(sl);
1945         es_fclose (fp);
1946       }
1947       break;
1948
1949     case aExportSecretKeyP12:
1950       {
1951         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1952
1953         if (argc == 1)
1954           gpgsm_p12_export (&ctrl, *argv, fp, 0);
1955         else
1956           wrong_args ("--export-secret-key-p12 KEY-ID");
1957         if (fp != es_stdout)
1958           es_fclose (fp);
1959       }
1960       break;
1961
1962     case aExportSecretKeyP8:
1963       {
1964         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1965
1966         if (argc == 1)
1967           gpgsm_p12_export (&ctrl, *argv, fp, 1);
1968         else
1969           wrong_args ("--export-secret-key-p8 KEY-ID");
1970         if (fp != es_stdout)
1971           es_fclose (fp);
1972       }
1973       break;
1974
1975     case aExportSecretKeyRaw:
1976       {
1977         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1978
1979         if (argc == 1)
1980           gpgsm_p12_export (&ctrl, *argv, fp, 2);
1981         else
1982           wrong_args ("--export-secret-key-raw KEY-ID");
1983         if (fp != es_stdout)
1984           es_fclose (fp);
1985       }
1986       break;
1987
1988     case aSendKeys:
1989     case aRecvKeys:
1990       log_error ("this command has not yet been implemented\n");
1991       break;
1992
1993
1994     case aLearnCard:
1995       if (argc)
1996         wrong_args ("--learn-card");
1997       else
1998         {
1999           int rc = gpgsm_agent_learn (&ctrl);
2000           if (rc)
2001             log_error ("error learning card: %s\n", gpg_strerror (rc));
2002         }
2003       break;
2004
2005     case aPasswd:
2006       if (argc != 1)
2007         wrong_args ("--change-passphrase <key-Id>");
2008       else
2009         {
2010           int rc;
2011           ksba_cert_t cert = NULL;
2012           char *grip = NULL;
2013
2014           rc = gpgsm_find_cert (&ctrl, *argv, NULL, &cert);
2015           if (rc)
2016             ;
2017           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
2018             rc = gpg_error (GPG_ERR_BUG);
2019           else
2020             {
2021               char *desc = gpgsm_format_keydesc (cert);
2022               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
2023               xfree (desc);
2024             }
2025           if (rc)
2026             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
2027           xfree (grip);
2028           ksba_cert_release (cert);
2029         }
2030       break;
2031
2032     case aKeydbClearSomeCertFlags:
2033       for (sl=NULL; argc; argc--, argv++)
2034         add_to_strlist (&sl, *argv);
2035       keydb_clear_some_cert_flags (&ctrl, sl);
2036       free_strlist(sl);
2037       break;
2038
2039
2040     default:
2041         log_error (_("invalid command (there is no implicit command)\n"));
2042         break;
2043     }
2044
2045   /* Print the audit result if needed.  */
2046   if ((auditlog && auditfp) || (htmlauditlog && htmlauditfp))
2047     {
2048       if (auditlog && auditfp)
2049         audit_print_result (ctrl.audit, auditfp, 0);
2050       if (htmlauditlog && htmlauditfp)
2051         audit_print_result (ctrl.audit, htmlauditfp, 1);
2052       audit_release (ctrl.audit);
2053       ctrl.audit = NULL;
2054       es_fclose (auditfp);
2055       es_fclose (htmlauditfp);
2056     }
2057
2058   /* cleanup */
2059   keyserver_list_free (opt.keyserver);
2060   opt.keyserver = NULL;
2061   gpgsm_release_certlist (recplist);
2062   gpgsm_release_certlist (signerlist);
2063   FREE_STRLIST (remusr);
2064   FREE_STRLIST (locusr);
2065   gpgsm_exit(0);
2066   return 8; /*NOTREACHED*/
2067 }
2068
2069 /* Note: This function is used by signal handlers!. */
2070 static void
2071 emergency_cleanup (void)
2072 {
2073   gcry_control (GCRYCTL_TERM_SECMEM );
2074 }
2075
2076
2077 void
2078 gpgsm_exit (int rc)
2079 {
2080   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
2081   if (opt.debug & DBG_MEMSTAT_VALUE)
2082     {
2083       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
2084       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
2085     }
2086   if (opt.debug)
2087     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
2088   emergency_cleanup ();
2089   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
2090   exit (rc);
2091 }
2092
2093
2094 void
2095 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
2096 {
2097   ctrl->include_certs = default_include_certs;
2098   ctrl->use_ocsp = opt.enable_ocsp;
2099   ctrl->validation_model = default_validation_model;
2100   ctrl->offline = opt.disable_dirmngr;
2101 }
2102
2103
2104 int
2105 gpgsm_parse_validation_model (const char *model)
2106 {
2107   if (!ascii_strcasecmp (model, "shell") )
2108     return 0;
2109   else if ( !ascii_strcasecmp (model, "chain") )
2110     return 1;
2111   else if ( !ascii_strcasecmp (model, "steed") )
2112     return 2;
2113   else
2114     return -1;
2115 }
2116
2117
2118
2119 /* Open the FILENAME for read and return the file descriptor.  Stop
2120    with an error message in case of problems.  "-" denotes stdin and
2121    if special filenames are allowed the given fd is opened instead.  */
2122 static int
2123 open_read (const char *filename)
2124 {
2125   int fd;
2126
2127   if (filename[0] == '-' && !filename[1])
2128     {
2129       set_binary (stdin);
2130       return 0; /* stdin */
2131     }
2132   fd = check_special_filename (filename, 0, 0);
2133   if (fd != -1)
2134     return fd;
2135   fd = open (filename, O_RDONLY | O_BINARY);
2136   if (fd == -1)
2137     {
2138       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
2139       gpgsm_exit (2);
2140     }
2141   return fd;
2142 }
2143
2144 /* Same as open_read but return an estream_t.  */
2145 static estream_t
2146 open_es_fread (const char *filename, const char *mode)
2147 {
2148   int fd;
2149   estream_t fp;
2150
2151   if (filename[0] == '-' && !filename[1])
2152     fd = fileno (stdin);
2153   else
2154     fd = check_special_filename (filename, 0, 0);
2155   if (fd != -1)
2156     {
2157       fp = es_fdopen_nc (fd, mode);
2158       if (!fp)
2159         {
2160           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2161           gpgsm_exit (2);
2162         }
2163       return fp;
2164     }
2165   fp = es_fopen (filename, mode);
2166   if (!fp)
2167     {
2168       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
2169       gpgsm_exit (2);
2170     }
2171   return fp;
2172 }
2173
2174
2175 /* Open FILENAME for fwrite and return an extended stream.  Stop with
2176    an error message in case of problems.  "-" denotes stdout and if
2177    special filenames are allowed the given fd is opened instead.
2178    Caller must close the returned stream. */
2179 static estream_t
2180 open_es_fwrite (const char *filename)
2181 {
2182   int fd;
2183   estream_t fp;
2184
2185   if (filename[0] == '-' && !filename[1])
2186     {
2187       fflush (stdout);
2188       fp = es_fdopen_nc (fileno(stdout), "wb");
2189       return fp;
2190     }
2191
2192   fd = check_special_filename (filename, 1, 0);
2193   if (fd != -1)
2194     {
2195       fp = es_fdopen_nc (fd, "wb");
2196       if (!fp)
2197         {
2198           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2199           gpgsm_exit (2);
2200         }
2201       return fp;
2202     }
2203   fp = es_fopen (filename, "wb");
2204   if (!fp)
2205     {
2206       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
2207       gpgsm_exit (2);
2208     }
2209   return fp;
2210 }
2211
2212
2213 static void
2214 run_protect_tool (int argc, char **argv)
2215 {
2216 #ifdef HAVE_W32_SYSTEM
2217   (void)argc;
2218   (void)argv;
2219 #else
2220   const char *pgm;
2221   char **av;
2222   int i;
2223
2224   if (!opt.protect_tool_program || !*opt.protect_tool_program)
2225     pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
2226   else
2227     pgm = opt.protect_tool_program;
2228
2229   av = xcalloc (argc+2, sizeof *av);
2230   av[0] = strrchr (pgm, '/');
2231   if (!av[0])
2232     av[0] = xstrdup (pgm);
2233   for (i=1; argc; i++, argc--, argv++)
2234     av[i] = *argv;
2235   av[i] = NULL;
2236   execv (pgm, av);
2237   log_error ("error executing '%s': %s\n", pgm, strerror (errno));
2238 #endif /*!HAVE_W32_SYSTEM*/
2239   gpgsm_exit (2);
2240 }