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