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