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