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