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