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