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