dirmngr,gpgsm: Return NULL on fail
[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       server = NULL;
866     }
867
868   return server;
869 }
870
871
872 int
873 main ( int argc, char **argv)
874 {
875   ARGPARSE_ARGS pargs;
876   int orig_argc;
877   char **orig_argv;
878   /*  char *username;*/
879   int may_coredump;
880   strlist_t sl, remusr= NULL, locusr=NULL;
881   strlist_t nrings=NULL;
882   int detached_sig = 0;
883   FILE *configfp = NULL;
884   char *configname = NULL;
885   unsigned configlineno;
886   int parse_debug = 0;
887   int no_more_options = 0;
888   int default_config =1;
889   int default_keyring = 1;
890   char *logfile = NULL;
891   char *auditlog = NULL;
892   char *htmlauditlog = NULL;
893   int greeting = 0;
894   int nogreeting = 0;
895   int debug_wait = 0;
896   int use_random_seed = 1;
897   int no_common_certs_import = 0;
898   int with_fpr = 0;
899   const char *forced_digest_algo = NULL;
900   const char *extra_digest_algo = NULL;
901   enum cmd_and_opt_values cmd = 0;
902   struct server_control_s ctrl;
903   certlist_t recplist = NULL;
904   certlist_t signerlist = NULL;
905   int do_not_setup_keys = 0;
906   int recp_required = 0;
907   estream_t auditfp = NULL;
908   estream_t htmlauditfp = NULL;
909   struct assuan_malloc_hooks malloc_hooks;
910
911   /*mtrace();*/
912
913   gnupg_reopen_std (GPGSM_NAME);
914   /* trap_unaligned ();*/
915   gnupg_rl_initialize ();
916   set_strusage (my_strusage);
917   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
918
919   /* Please note that we may running SUID(ROOT), so be very CAREFUL
920      when adding any stuff between here and the call to secmem_init()
921      somewhere after the option parsing */
922   log_set_prefix (GPGSM_NAME, 1);
923
924   /* Make sure that our subsystems are ready.  */
925   i18n_init ();
926   init_common_subsystems (&argc, &argv);
927
928   /* Check that the libraries are suitable.  Do it here because the
929      option parse may need services of the library */
930   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
931     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
932                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
933   if (!ksba_check_version (NEED_KSBA_VERSION) )
934     log_fatal (_("%s is too old (need %s, have %s)\n"), "libksba",
935                NEED_KSBA_VERSION, ksba_check_version (NULL) );
936
937
938   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
939
940   may_coredump = disable_core_dumps ();
941
942   gnupg_init_signals (0, emergency_cleanup);
943
944   dotlock_create (NULL, 0); /* Register lockfile cleanup.  */
945
946   opt.autostart = 1;
947   opt.session_env = session_env_new ();
948   if (!opt.session_env)
949     log_fatal ("error allocating session environment block: %s\n",
950                strerror (errno));
951
952   /* Note: If you change this default cipher algorithm , please
953      remember to update the Gpgconflist entry as well.  */
954   opt.def_cipher_algoid = DEFAULT_CIPHER_ALGO;
955
956   opt.homedir = default_homedir ();
957
958
959   /* First check whether we have a config file on the commandline */
960   orig_argc = argc;
961   orig_argv = argv;
962   pargs.argc = &argc;
963   pargs.argv = &argv;
964   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
965   while (arg_parse( &pargs, opts))
966     {
967       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
968         parse_debug++;
969       else if (pargs.r_opt == oOptions)
970         { /* yes there is one, so we do not try the default one but
971              read the config file when it is encountered at the
972              commandline */
973           default_config = 0;
974         }
975       else if (pargs.r_opt == oNoOptions)
976         {
977           default_config = 0; /* --no-options */
978           opt.no_homedir_creation = 1;
979         }
980       else if (pargs.r_opt == oHomedir)
981         opt.homedir = pargs.r.ret_str;
982       else if (pargs.r_opt == aCallProtectTool)
983         break; /* This break makes sure that --version and --help are
984                   passed to the protect-tool. */
985     }
986
987
988   /* Initialize the secure memory. */
989   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
990   maybe_setuid = 0;
991
992   /*
993      Now we are now working under our real uid
994   */
995
996   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
997
998   malloc_hooks.malloc = gcry_malloc;
999   malloc_hooks.realloc = gcry_realloc;
1000   malloc_hooks.free = gcry_free;
1001   assuan_set_malloc_hooks (&malloc_hooks);
1002   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
1003   setup_libassuan_logging (&opt.debug);
1004
1005   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
1006
1007   /* Setup a default control structure for command line mode */
1008   memset (&ctrl, 0, sizeof ctrl);
1009   gpgsm_init_default_ctrl (&ctrl);
1010   ctrl.no_server = 1;
1011   ctrl.status_fd = -1; /* No status output. */
1012   ctrl.autodetect_encoding = 1;
1013
1014   /* Set the default option file */
1015   if (default_config )
1016     configname = make_filename (opt.homedir, GPGSM_NAME EXTSEP_S "conf", NULL);
1017   /* Set the default policy file */
1018   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
1019
1020   argc        = orig_argc;
1021   argv        = orig_argv;
1022   pargs.argc  = &argc;
1023   pargs.argv  = &argv;
1024   pargs.flags =  1;  /* do not remove the args */
1025
1026  next_pass:
1027   if (configname) {
1028     configlineno = 0;
1029     configfp = fopen (configname, "r");
1030     if (!configfp)
1031       {
1032         if (default_config)
1033           {
1034             if (parse_debug)
1035               log_info (_("Note: no default option file '%s'\n"), configname);
1036           }
1037         else
1038           {
1039             log_error (_("option file '%s': %s\n"), configname, strerror(errno));
1040             gpgsm_exit(2);
1041           }
1042         xfree(configname);
1043         configname = NULL;
1044       }
1045     if (parse_debug && configname)
1046       log_info (_("reading options from '%s'\n"), configname);
1047     default_config = 0;
1048   }
1049
1050   while (!no_more_options
1051          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
1052     {
1053       switch (pargs.r_opt)
1054         {
1055         case aGPGConfList:
1056         case aGPGConfTest:
1057           set_cmd (&cmd, pargs.r_opt);
1058           do_not_setup_keys = 1;
1059           nogreeting = 1;
1060           break;
1061
1062         case aServer:
1063           opt.batch = 1;
1064           set_cmd (&cmd, aServer);
1065           break;
1066
1067         case aCallDirmngr:
1068           opt.batch = 1;
1069           set_cmd (&cmd, aCallDirmngr);
1070           do_not_setup_keys = 1;
1071           break;
1072
1073         case aCallProtectTool:
1074           opt.batch = 1;
1075           set_cmd (&cmd, aCallProtectTool);
1076           no_more_options = 1; /* Stop parsing. */
1077           do_not_setup_keys = 1;
1078           break;
1079
1080         case aDeleteKey:
1081           set_cmd (&cmd, aDeleteKey);
1082           /*greeting=1;*/
1083           do_not_setup_keys = 1;
1084           break;
1085
1086         case aDetachedSign:
1087           detached_sig = 1;
1088           set_cmd (&cmd, aSign );
1089           break;
1090
1091         case aKeygen:
1092           set_cmd (&cmd, aKeygen);
1093           greeting=1;
1094           do_not_setup_keys = 1;
1095           break;
1096
1097         case aImport:
1098         case aSendKeys:
1099         case aRecvKeys:
1100         case aExport:
1101         case aExportSecretKeyP12:
1102         case aExportSecretKeyP8:
1103         case aExportSecretKeyRaw:
1104         case aDumpKeys:
1105         case aDumpChain:
1106         case aDumpExternalKeys:
1107         case aDumpSecretKeys:
1108         case aListKeys:
1109         case aListExternalKeys:
1110         case aListSecretKeys:
1111         case aListChain:
1112         case aLearnCard:
1113         case aPasswd:
1114         case aKeydbClearSomeCertFlags:
1115           do_not_setup_keys = 1;
1116           set_cmd (&cmd, pargs.r_opt);
1117           break;
1118
1119         case aEncr:
1120           recp_required = 1;
1121           set_cmd (&cmd, pargs.r_opt);
1122           break;
1123
1124         case aSym:
1125         case aDecrypt:
1126         case aSign:
1127         case aClearsign:
1128         case aVerify:
1129           set_cmd (&cmd, pargs.r_opt);
1130           break;
1131
1132           /* Output encoding selection.  */
1133         case oArmor:
1134           ctrl.create_pem = 1;
1135           break;
1136         case oBase64:
1137           ctrl.create_pem = 0;
1138           ctrl.create_base64 = 1;
1139           break;
1140         case oNoArmor:
1141           ctrl.create_pem = 0;
1142           ctrl.create_base64 = 0;
1143           break;
1144
1145         case oP12Charset:
1146           opt.p12_charset = pargs.r.ret_str;
1147           break;
1148
1149           /* Input encoding selection.  */
1150         case oAssumeArmor:
1151           ctrl.autodetect_encoding = 0;
1152           ctrl.is_pem = 1;
1153           ctrl.is_base64 = 0;
1154           break;
1155         case oAssumeBase64:
1156           ctrl.autodetect_encoding = 0;
1157           ctrl.is_pem = 0;
1158           ctrl.is_base64 = 1;
1159           break;
1160         case oAssumeBinary:
1161           ctrl.autodetect_encoding = 0;
1162           ctrl.is_pem = 0;
1163           ctrl.is_base64 = 0;
1164           break;
1165
1166         case oDisableCRLChecks:
1167           opt.no_crl_check = 1;
1168           break;
1169         case oEnableCRLChecks:
1170           opt.no_crl_check = 0;
1171           break;
1172         case oDisableTrustedCertCRLCheck:
1173           opt.no_trusted_cert_crl_check = 1;
1174           break;
1175         case oEnableTrustedCertCRLCheck:
1176           opt.no_trusted_cert_crl_check = 0;
1177           break;
1178         case oForceCRLRefresh:
1179           opt.force_crl_refresh = 1;
1180           break;
1181
1182         case oDisableOCSP:
1183           ctrl.use_ocsp = opt.enable_ocsp = 0;
1184           break;
1185         case oEnableOCSP:
1186           ctrl.use_ocsp = opt.enable_ocsp = 1;
1187           break;
1188
1189         case oIncludeCerts:
1190           ctrl.include_certs = default_include_certs = pargs.r.ret_int;
1191           break;
1192
1193         case oPolicyFile:
1194           xfree (opt.policy_file);
1195           if (*pargs.r.ret_str)
1196             opt.policy_file = xstrdup (pargs.r.ret_str);
1197           else
1198             opt.policy_file = NULL;
1199           break;
1200
1201         case oDisablePolicyChecks:
1202           opt.no_policy_check = 1;
1203           break;
1204         case oEnablePolicyChecks:
1205           opt.no_policy_check = 0;
1206           break;
1207
1208         case oAutoIssuerKeyRetrieve:
1209           opt.auto_issuer_key_retrieve = 1;
1210           break;
1211
1212         case oOutput: opt.outfile = pargs.r.ret_str; break;
1213
1214
1215         case oQuiet: opt.quiet = 1; break;
1216         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1217         case oDryRun: opt.dry_run = 1; break;
1218
1219         case oVerbose:
1220           opt.verbose++;
1221           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1222           break;
1223         case oNoVerbose:
1224           opt.verbose = 0;
1225           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1226           break;
1227
1228         case oLogFile: logfile = pargs.r.ret_str; break;
1229         case oNoLogFile: logfile = NULL; break;
1230
1231         case oAuditLog: auditlog = pargs.r.ret_str; break;
1232         case oHtmlAuditLog: htmlauditlog = pargs.r.ret_str; break;
1233
1234         case oBatch:
1235           opt.batch = 1;
1236           greeting = 0;
1237           break;
1238         case oNoBatch: opt.batch = 0; break;
1239
1240         case oAnswerYes: opt.answer_yes = 1; break;
1241         case oAnswerNo: opt.answer_no = 1; break;
1242
1243         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1244
1245         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1246         case oDebugAll: debug_value = ~0; break;
1247         case oDebugNone: debug_value = 0; break;
1248         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1249         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1250         case oDebugAllowCoreDump:
1251           may_coredump = enable_core_dumps ();
1252           break;
1253         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1254         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1255         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1256
1257         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1258         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1259         case oWithMD5Fingerprint:
1260           opt.with_md5_fingerprint=1; /*fall thru*/
1261         case oWithFingerprint:
1262           with_fpr=1; /*fall thru*/
1263         case aFingerprint:
1264           opt.fingerprint++;
1265           break;
1266
1267         case oWithKeygrip:
1268           opt.with_keygrip = 1;
1269           break;
1270
1271         case oOptions:
1272           /* config files may not be nested (silently ignore them) */
1273           if (!configfp)
1274             {
1275               xfree(configname);
1276               configname = xstrdup (pargs.r.ret_str);
1277               goto next_pass;
1278             }
1279           break;
1280         case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1281         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1282         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1283
1284         case oDisplay:
1285           set_opt_session_env ("DISPLAY", pargs.r.ret_str);
1286           break;
1287         case oTTYname:
1288           set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
1289           break;
1290         case oTTYtype:
1291           set_opt_session_env ("TERM", pargs.r.ret_str);
1292           break;
1293         case oXauthority:
1294           set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
1295           break;
1296
1297         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1298         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1299
1300         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1301         case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
1302         case oPreferSystemDirmngr: /* Obsolete */; break;
1303         case oProtectToolProgram:
1304           opt.protect_tool_program = pargs.r.ret_str;
1305           break;
1306
1307         case oFakedSystemTime:
1308           {
1309             time_t faked_time = isotime2epoch (pargs.r.ret_str);
1310             if (faked_time == (time_t)(-1))
1311               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1312             gnupg_set_time (faked_time, 0);
1313           }
1314           break;
1315
1316         case oNoDefKeyring: default_keyring = 0; break;
1317         case oNoGreeting: nogreeting = 1; break;
1318
1319         case oDefaultKey:
1320           if (*pargs.r.ret_str)
1321             {
1322               xfree (opt.local_user);
1323               opt.local_user = xstrdup (pargs.r.ret_str);
1324             }
1325           break;
1326         case oDefRecipient:
1327           if (*pargs.r.ret_str)
1328             opt.def_recipient = xstrdup (pargs.r.ret_str);
1329           break;
1330         case oDefRecipientSelf:
1331           xfree (opt.def_recipient);
1332           opt.def_recipient = NULL;
1333           opt.def_recipient_self = 1;
1334           break;
1335         case oNoDefRecipient:
1336           xfree (opt.def_recipient);
1337           opt.def_recipient = NULL;
1338           opt.def_recipient_self = 0;
1339           break;
1340
1341         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1342         case oWithColons: ctrl.with_colons = 1; break;
1343         case oWithSecret: ctrl.with_secret = 1; break;
1344         case oWithValidation: ctrl.with_validation=1; break;
1345         case oWithEphemeralKeys: ctrl.with_ephemeral_keys=1; break;
1346
1347         case oSkipVerify: opt.skip_verify=1; break;
1348
1349         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1350         case oEncryptTo: /* Store the recipient in the second list */
1351           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1352           sl->flags = 1;
1353           break;
1354
1355         case oRecipient: /* store the recipient */
1356           add_to_strlist ( &remusr, pargs.r.ret_str);
1357           break;
1358
1359         case oUser: /* Store the local users, the first one is the default */
1360           if (!opt.local_user)
1361             opt.local_user = xstrdup (pargs.r.ret_str);
1362           add_to_strlist (&locusr, pargs.r.ret_str);
1363           break;
1364
1365         case oNoSecmemWarn:
1366           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
1367           break;
1368
1369         case oCipherAlgo:
1370           opt.def_cipher_algoid = pargs.r.ret_str;
1371           break;
1372
1373         case oDisableCipherAlgo:
1374           {
1375             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1376             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1377           }
1378           break;
1379         case oDisablePubkeyAlgo:
1380           {
1381             int algo = gcry_pk_map_name (pargs.r.ret_str);
1382             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1383           }
1384           break;
1385
1386         case oDigestAlgo:
1387           forced_digest_algo = pargs.r.ret_str;
1388           break;
1389
1390         case oExtraDigestAlgo:
1391           extra_digest_algo = pargs.r.ret_str;
1392           break;
1393
1394         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1395         case oNoRandomSeedFile: use_random_seed = 0; break;
1396         case oNoCommonCertsImport: no_common_certs_import = 1; break;
1397
1398         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1399
1400         case oValidationModel: parse_validation_model (pargs.r.ret_str); break;
1401
1402         case oKeyServer:
1403           {
1404             struct keyserver_spec *keyserver;
1405             keyserver = parse_keyserver_line (pargs.r.ret_str,
1406                                               configname, configlineno);
1407             if (! keyserver)
1408               log_error (_("could not parse keyserver\n"));
1409             else
1410               {
1411                 /* FIXME: Keep last next pointer.  */
1412                 struct keyserver_spec **next_p = &opt.keyserver;
1413                 while (*next_p)
1414                   next_p = &(*next_p)->next;
1415                 *next_p = keyserver;
1416               }
1417           }
1418           break;
1419
1420         case oIgnoreCertExtension:
1421           add_to_strlist (&opt.ignored_cert_extensions, pargs.r.ret_str);
1422           break;
1423
1424         case oNoAutostart: opt.autostart = 0; break;
1425
1426         default:
1427           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
1428           break;
1429         }
1430     }
1431
1432   if (configfp)
1433     {
1434       fclose (configfp);
1435       configfp = NULL;
1436       /* Keep a copy of the config filename. */
1437       opt.config_filename = configname;
1438       configname = NULL;
1439       goto next_pass;
1440     }
1441   xfree (configname);
1442   configname = NULL;
1443
1444   if (!opt.config_filename)
1445     opt.config_filename = make_filename (opt.homedir,
1446                                          GPGSM_NAME EXTSEP_S "conf",
1447                                          NULL);
1448
1449   if (log_get_errorcount(0))
1450     gpgsm_exit(2);
1451
1452   /* Now that we have the options parsed we need to update the default
1453      control structure.  */
1454   gpgsm_init_default_ctrl (&ctrl);
1455
1456   if (nogreeting)
1457     greeting = 0;
1458
1459   if (greeting)
1460     {
1461       es_fprintf (es_stderr, "%s %s; %s\n",
1462                   strusage(11), strusage(13), strusage(14) );
1463       es_fprintf (es_stderr, "%s\n", strusage(15) );
1464     }
1465 #  ifdef IS_DEVELOPMENT_VERSION
1466   if (!opt.batch)
1467     {
1468       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1469       log_info ("It is only intended for test purposes and should NOT be\n");
1470       log_info ("used in a production environment or with production keys!\n");
1471     }
1472 #  endif
1473
1474   if (may_coredump && !opt.quiet)
1475     log_info (_("WARNING: program may create a core file!\n"));
1476
1477 /*   if (opt.qualsig_approval && !opt.quiet) */
1478 /*     log_info (_("This software has offically been approved to " */
1479 /*                 "create and verify\n" */
1480 /*                 "qualified signatures according to German law.\n")); */
1481
1482   if (logfile && cmd == aServer)
1483     {
1484       log_set_file (logfile);
1485       log_set_prefix (NULL, 1|2|4);
1486     }
1487
1488   if (gnupg_faked_time_p ())
1489     {
1490       gnupg_isotime_t tbuf;
1491
1492       log_info (_("WARNING: running with faked system time: "));
1493       gnupg_get_isotime (tbuf);
1494       dump_isotime (tbuf);
1495       log_printf ("\n");
1496     }
1497
1498   /* Print a warning if an argument looks like an option.  */
1499   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
1500     {
1501       int i;
1502
1503       for (i=0; i < argc; i++)
1504         if (argv[i][0] == '-' && argv[i][1] == '-')
1505           log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
1506     }
1507
1508 /*FIXME    if (opt.batch) */
1509 /*      tty_batchmode (1); */
1510
1511   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1512
1513   set_debug ();
1514
1515   /* Although we alwasy use gpgsm_exit, we better install a regualr
1516      exit handler so that at least the secure memory gets wiped
1517      out. */
1518   if (atexit (emergency_cleanup))
1519     {
1520       log_error ("atexit failed\n");
1521       gpgsm_exit (2);
1522     }
1523
1524   /* Must do this after dropping setuid, because the mapping functions
1525      may try to load an module and we may have disabled an algorithm.
1526      We remap the commonly used algorithms to the OIDs for
1527      convenience.  We need to work with the OIDs because they are used
1528      to check whether the encryption mode is actually available. */
1529   if (!strcmp (opt.def_cipher_algoid, "3DES") )
1530     opt.def_cipher_algoid = "1.2.840.113549.3.7";
1531   else if (!strcmp (opt.def_cipher_algoid, "AES")
1532            || !strcmp (opt.def_cipher_algoid, "AES128"))
1533     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1534   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1535     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1536   else if (!strcmp (opt.def_cipher_algoid, "SERPENT")
1537            || !strcmp (opt.def_cipher_algoid, "SERPENT128") )
1538     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.2";
1539   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1540     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.22";
1541   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1542     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.42";
1543   else if (!strcmp (opt.def_cipher_algoid, "SEED") )
1544     opt.def_cipher_algoid = "1.2.410.200004.1.4";
1545   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA")
1546            || !strcmp (opt.def_cipher_algoid, "CAMELLIA128") )
1547     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.2";
1548   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA192") )
1549     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
1550   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
1551     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
1552
1553   if (cmd != aGPGConfList)
1554     {
1555       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1556            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1557         log_error (_("selected cipher algorithm is invalid\n"));
1558
1559       if (forced_digest_algo)
1560         {
1561           opt.forced_digest_algo = gcry_md_map_name (forced_digest_algo);
1562           if (our_md_test_algo(opt.forced_digest_algo) )
1563             log_error (_("selected digest algorithm is invalid\n"));
1564         }
1565       if (extra_digest_algo)
1566         {
1567           opt.extra_digest_algo = gcry_md_map_name (extra_digest_algo);
1568           if (our_md_test_algo (opt.extra_digest_algo) )
1569             log_error (_("selected digest algorithm is invalid\n"));
1570         }
1571     }
1572
1573   if (log_get_errorcount(0))
1574     gpgsm_exit(2);
1575
1576   /* Set the random seed file. */
1577   if (use_random_seed)
1578     {
1579       char *p = make_filename (opt.homedir, "random_seed", NULL);
1580       gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1581       xfree(p);
1582     }
1583
1584   if (!cmd && opt.fingerprint && !with_fpr)
1585     set_cmd (&cmd, aListKeys);
1586
1587   /* Add default keybox. */
1588   if (!nrings && default_keyring)
1589     {
1590       int created;
1591
1592       keydb_add_resource ("pubring.kbx", 0, 0, &created);
1593       if (created && !no_common_certs_import)
1594         {
1595           /* Import the standard certificates for a new default keybox. */
1596           char *filelist[2];
1597
1598           filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
1599           filelist[1] = NULL;
1600           if (!access (filelist[0], F_OK))
1601             {
1602               log_info (_("importing common certificates '%s'\n"),
1603                         filelist[0]);
1604               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1605             }
1606           xfree (filelist[0]);
1607         }
1608     }
1609   for (sl = nrings; sl; sl = sl->next)
1610     keydb_add_resource (sl->d, 0, 0, NULL);
1611   FREE_STRLIST(nrings);
1612
1613
1614   /* Prepare the audit log feature for certain commands.  */
1615   if (auditlog || htmlauditlog)
1616     {
1617       switch (cmd)
1618         {
1619         case aEncr:
1620         case aSign:
1621         case aDecrypt:
1622         case aVerify:
1623           audit_release (ctrl.audit);
1624           ctrl.audit = audit_new ();
1625           if (auditlog)
1626             auditfp = open_es_fwrite (auditlog);
1627           if (htmlauditlog)
1628             htmlauditfp = open_es_fwrite (htmlauditlog);
1629           break;
1630         default:
1631           break;
1632         }
1633     }
1634
1635
1636   if (!do_not_setup_keys)
1637     {
1638       for (sl = locusr; sl ; sl = sl->next)
1639         {
1640           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1641           if (rc)
1642             {
1643               log_error (_("can't sign using '%s': %s\n"),
1644                          sl->d, gpg_strerror (rc));
1645               gpgsm_status2 (&ctrl, STATUS_INV_SGNR,
1646                              get_inv_recpsgnr_code (rc), sl->d, NULL);
1647               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1648                              get_inv_recpsgnr_code (rc), sl->d, NULL);
1649             }
1650         }
1651
1652       /* Build the recipient list.  We first add the regular ones and then
1653          the encrypt-to ones because the underlying function will silently
1654          ignore duplicates and we can't allow to keep a duplicate which is
1655          flagged as encrypt-to as the actually encrypt function would then
1656          complain about no (regular) recipients. */
1657       for (sl = remusr; sl; sl = sl->next)
1658         if (!(sl->flags & 1))
1659           do_add_recipient (&ctrl, sl->d, &recplist, 0, recp_required);
1660       if (!opt.no_encrypt_to)
1661         {
1662           for (sl = remusr; sl; sl = sl->next)
1663             if ((sl->flags & 1))
1664               do_add_recipient (&ctrl, sl->d, &recplist, 1, recp_required);
1665         }
1666     }
1667
1668   if (log_get_errorcount(0))
1669     gpgsm_exit(1); /* Must stop for invalid recipients. */
1670
1671   /* Dispatch command.  */
1672   switch (cmd)
1673     {
1674     case aGPGConfList:
1675       { /* List options and default values in the GPG Conf format.  */
1676         char *config_filename_esc = percent_escape (opt.config_filename, NULL);
1677
1678         es_printf ("%s-%s.conf:%lu:\"%s\n",
1679                    GPGCONF_NAME, GPGSM_NAME,
1680                    GC_OPT_FLAG_DEFAULT, config_filename_esc);
1681         xfree (config_filename_esc);
1682
1683         es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1684         es_printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
1685         es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1686         es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1687         es_printf ("disable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
1688         es_printf ("disable-trusted-cert-crl-check:%lu:\n", GC_OPT_FLAG_NONE);
1689         es_printf ("enable-ocsp:%lu:\n", GC_OPT_FLAG_NONE);
1690         es_printf ("include-certs:%lu:%d:\n", GC_OPT_FLAG_DEFAULT,
1691                    DEFAULT_INCLUDE_CERTS);
1692         es_printf ("disable-policy-checks:%lu:\n", GC_OPT_FLAG_NONE);
1693         es_printf ("auto-issuer-key-retrieve:%lu:\n", GC_OPT_FLAG_NONE);
1694         es_printf ("disable-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1695         es_printf ("cipher-algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1696                    DEFAULT_CIPHER_ALGO);
1697         es_printf ("p12-charset:%lu:\n", GC_OPT_FLAG_DEFAULT);
1698         es_printf ("default-key:%lu:\n", GC_OPT_FLAG_DEFAULT);
1699         es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_DEFAULT);
1700         es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1701
1702         /* The next one is an info only item and should match what
1703            proc_parameters actually implements.  */
1704         es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1705                    "RSA-2048");
1706
1707       }
1708       break;
1709     case aGPGConfTest:
1710       /* This is merely a dummy command to test whether the
1711          configuration file is valid.  */
1712       break;
1713
1714     case aServer:
1715       if (debug_wait)
1716         {
1717           log_debug ("waiting for debugger - my pid is %u .....\n",
1718                      (unsigned int)getpid());
1719           gnupg_sleep (debug_wait);
1720           log_debug ("... okay\n");
1721          }
1722       gpgsm_server (recplist);
1723       break;
1724
1725     case aCallDirmngr:
1726       if (!argc)
1727         wrong_args ("--call-dirmngr <command> {args}");
1728       else
1729         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1730           gpgsm_exit (1);
1731       break;
1732
1733     case aCallProtectTool:
1734       run_protect_tool (argc, argv);
1735       break;
1736
1737     case aEncr: /* Encrypt the given file. */
1738       {
1739         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1740
1741         set_binary (stdin);
1742
1743         if (!argc) /* Source is stdin. */
1744           gpgsm_encrypt (&ctrl, recplist, 0, fp);
1745         else if (argc == 1)  /* Source is the given file. */
1746           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1747         else
1748           wrong_args ("--encrypt [datafile]");
1749
1750         es_fclose (fp);
1751       }
1752       break;
1753
1754     case aSign: /* Sign the given file. */
1755       {
1756         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1757
1758         /* Fixme: We should also allow to concatenate multiple files for
1759            signing because that is what gpg does.*/
1760         set_binary (stdin);
1761         if (!argc) /* Create from stdin. */
1762           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp);
1763         else if (argc == 1) /* From file. */
1764           gpgsm_sign (&ctrl, signerlist,
1765                       open_read (*argv), detached_sig, fp);
1766         else
1767           wrong_args ("--sign [datafile]");
1768
1769         es_fclose (fp);
1770       }
1771       break;
1772
1773     case aSignEncr: /* sign and encrypt the given file */
1774       log_error ("this command has not yet been implemented\n");
1775       break;
1776
1777     case aClearsign: /* make a clearsig */
1778       log_error ("this command has not yet been implemented\n");
1779       break;
1780
1781     case aVerify:
1782       {
1783         estream_t fp = NULL;
1784
1785         set_binary (stdin);
1786         if (argc == 2 && opt.outfile)
1787           log_info ("option --output ignored for a detached signature\n");
1788         else if (opt.outfile)
1789           fp = open_es_fwrite (opt.outfile);
1790
1791         if (!argc)
1792           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1793         else if (argc == 1)
1794           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1795         else if (argc == 2) /* detached signature (sig, detached) */
1796           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL);
1797         else
1798           wrong_args ("--verify [signature [detached_data]]");
1799
1800         es_fclose (fp);
1801       }
1802       break;
1803
1804     case aDecrypt:
1805       {
1806         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1807
1808         set_binary (stdin);
1809         if (!argc)
1810           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1811         else if (argc == 1)
1812           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1813         else
1814           wrong_args ("--decrypt [filename]");
1815
1816         es_fclose (fp);
1817       }
1818       break;
1819
1820     case aDeleteKey:
1821       for (sl=NULL; argc; argc--, argv++)
1822         add_to_strlist (&sl, *argv);
1823       gpgsm_delete (&ctrl, sl);
1824       free_strlist(sl);
1825       break;
1826
1827     case aListChain:
1828     case aDumpChain:
1829        ctrl.with_chain = 1;
1830     case aListKeys:
1831     case aDumpKeys:
1832     case aListExternalKeys:
1833     case aDumpExternalKeys:
1834     case aListSecretKeys:
1835     case aDumpSecretKeys:
1836       {
1837         unsigned int mode;
1838         estream_t fp;
1839
1840         switch (cmd)
1841           {
1842           case aListChain:
1843           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1844           case aDumpChain:
1845           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1846           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1847           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1848           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1849           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1850           default: BUG();
1851           }
1852
1853         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1854         for (sl=NULL; argc; argc--, argv++)
1855           add_to_strlist (&sl, *argv);
1856         gpgsm_list_keys (&ctrl, sl, fp, mode);
1857         free_strlist(sl);
1858         es_fclose (fp);
1859       }
1860       break;
1861
1862
1863     case aKeygen: /* Generate a key; well kind of. */
1864       {
1865         estream_t fpin = NULL;
1866         estream_t fpout;
1867
1868         if (opt.batch)
1869           {
1870             if (!argc) /* Create from stdin. */
1871               fpin = open_es_fread ("-", "r");
1872             else if (argc == 1) /* From file. */
1873               fpin = open_es_fread (*argv, "r");
1874             else
1875               wrong_args ("--gen-key --batch [parmfile]");
1876           }
1877
1878         fpout = open_es_fwrite (opt.outfile?opt.outfile:"-");
1879
1880         if (fpin)
1881           gpgsm_genkey (&ctrl, fpin, fpout);
1882         else
1883           gpgsm_gencertreq_tty (&ctrl, fpout);
1884
1885         es_fclose (fpout);
1886       }
1887       break;
1888
1889
1890     case aImport:
1891       gpgsm_import_files (&ctrl, argc, argv, open_read);
1892       break;
1893
1894     case aExport:
1895       {
1896         estream_t fp;
1897
1898         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1899         for (sl=NULL; argc; argc--, argv++)
1900           add_to_strlist (&sl, *argv);
1901         gpgsm_export (&ctrl, sl, fp);
1902         free_strlist(sl);
1903         es_fclose (fp);
1904       }
1905       break;
1906
1907     case aExportSecretKeyP12:
1908       {
1909         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1910
1911         if (argc == 1)
1912           gpgsm_p12_export (&ctrl, *argv, fp, 0);
1913         else
1914           wrong_args ("--export-secret-key-p12 KEY-ID");
1915         if (fp != es_stdout)
1916           es_fclose (fp);
1917       }
1918       break;
1919
1920     case aExportSecretKeyP8:
1921       {
1922         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1923
1924         if (argc == 1)
1925           gpgsm_p12_export (&ctrl, *argv, fp, 1);
1926         else
1927           wrong_args ("--export-secret-key-p8 KEY-ID");
1928         if (fp != es_stdout)
1929           es_fclose (fp);
1930       }
1931       break;
1932
1933     case aExportSecretKeyRaw:
1934       {
1935         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1936
1937         if (argc == 1)
1938           gpgsm_p12_export (&ctrl, *argv, fp, 2);
1939         else
1940           wrong_args ("--export-secret-key-raw KEY-ID");
1941         if (fp != es_stdout)
1942           es_fclose (fp);
1943       }
1944       break;
1945
1946     case aSendKeys:
1947     case aRecvKeys:
1948       log_error ("this command has not yet been implemented\n");
1949       break;
1950
1951
1952     case aLearnCard:
1953       if (argc)
1954         wrong_args ("--learn-card");
1955       else
1956         {
1957           int rc = gpgsm_agent_learn (&ctrl);
1958           if (rc)
1959             log_error ("error learning card: %s\n", gpg_strerror (rc));
1960         }
1961       break;
1962
1963     case aPasswd:
1964       if (argc != 1)
1965         wrong_args ("--passwd <key-Id>");
1966       else
1967         {
1968           int rc;
1969           ksba_cert_t cert = NULL;
1970           char *grip = NULL;
1971
1972           rc = gpgsm_find_cert (*argv, NULL, &cert);
1973           if (rc)
1974             ;
1975           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1976             rc = gpg_error (GPG_ERR_BUG);
1977           else
1978             {
1979               char *desc = gpgsm_format_keydesc (cert);
1980               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1981               xfree (desc);
1982             }
1983           if (rc)
1984             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1985           xfree (grip);
1986           ksba_cert_release (cert);
1987         }
1988       break;
1989
1990     case aKeydbClearSomeCertFlags:
1991       for (sl=NULL; argc; argc--, argv++)
1992         add_to_strlist (&sl, *argv);
1993       keydb_clear_some_cert_flags (&ctrl, sl);
1994       free_strlist(sl);
1995       break;
1996
1997
1998     default:
1999         log_error (_("invalid command (there is no implicit command)\n"));
2000         break;
2001     }
2002
2003   /* Print the audit result if needed.  */
2004   if ((auditlog && auditfp) || (htmlauditlog && htmlauditfp))
2005     {
2006       if (auditlog && auditfp)
2007         audit_print_result (ctrl.audit, auditfp, 0);
2008       if (htmlauditlog && htmlauditfp)
2009         audit_print_result (ctrl.audit, htmlauditfp, 1);
2010       audit_release (ctrl.audit);
2011       ctrl.audit = NULL;
2012       es_fclose (auditfp);
2013       es_fclose (htmlauditfp);
2014     }
2015
2016   /* cleanup */
2017   keyserver_list_free (opt.keyserver);
2018   opt.keyserver = NULL;
2019   gpgsm_release_certlist (recplist);
2020   gpgsm_release_certlist (signerlist);
2021   FREE_STRLIST (remusr);
2022   FREE_STRLIST (locusr);
2023   gpgsm_exit(0);
2024   return 8; /*NOTREACHED*/
2025 }
2026
2027 /* Note: This function is used by signal handlers!. */
2028 static void
2029 emergency_cleanup (void)
2030 {
2031   gcry_control (GCRYCTL_TERM_SECMEM );
2032 }
2033
2034
2035 void
2036 gpgsm_exit (int rc)
2037 {
2038   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
2039   if (opt.debug & DBG_MEMSTAT_VALUE)
2040     {
2041       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
2042       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
2043     }
2044   if (opt.debug)
2045     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
2046   emergency_cleanup ();
2047   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
2048   exit (rc);
2049 }
2050
2051
2052 void
2053 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
2054 {
2055   ctrl->include_certs = default_include_certs;
2056   ctrl->use_ocsp = opt.enable_ocsp;
2057   ctrl->validation_model = default_validation_model;
2058 }
2059
2060
2061 int
2062 gpgsm_parse_validation_model (const char *model)
2063 {
2064   if (!ascii_strcasecmp (model, "shell") )
2065     return 0;
2066   else if ( !ascii_strcasecmp (model, "chain") )
2067     return 1;
2068   else if ( !ascii_strcasecmp (model, "steed") )
2069     return 2;
2070   else
2071     return -1;
2072 }
2073
2074
2075 /* Check whether the filename has the form "-&nnnn", where n is a
2076    non-zero number.  Returns this number or -1 if it is not the case.  */
2077 static int
2078 check_special_filename (const char *fname, int for_write)
2079 {
2080   if (allow_special_filenames
2081       && fname && *fname == '-' && fname[1] == '&' ) {
2082     int i;
2083
2084     fname += 2;
2085     for (i=0; isdigit (fname[i]); i++ )
2086       ;
2087     if ( !fname[i] )
2088       return translate_sys2libc_fd_int (atoi (fname), for_write);
2089   }
2090   return -1;
2091 }
2092
2093
2094
2095 /* Open the FILENAME for read and return the file descriptor.  Stop
2096    with an error message in case of problems.  "-" denotes stdin and
2097    if special filenames are allowed the given fd is opened instead.  */
2098 static int
2099 open_read (const char *filename)
2100 {
2101   int fd;
2102
2103   if (filename[0] == '-' && !filename[1])
2104     {
2105       set_binary (stdin);
2106       return 0; /* stdin */
2107     }
2108   fd = check_special_filename (filename, 0);
2109   if (fd != -1)
2110     return fd;
2111   fd = open (filename, O_RDONLY | O_BINARY);
2112   if (fd == -1)
2113     {
2114       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
2115       gpgsm_exit (2);
2116     }
2117   return fd;
2118 }
2119
2120 /* Same as open_read but return an estream_t.  */
2121 static estream_t
2122 open_es_fread (const char *filename, const char *mode)
2123 {
2124   int fd;
2125   estream_t fp;
2126
2127   if (filename[0] == '-' && !filename[1])
2128     fd = fileno (stdin);
2129   else
2130     fd = check_special_filename (filename, 0);
2131   if (fd != -1)
2132     {
2133       fp = es_fdopen_nc (fd, mode);
2134       if (!fp)
2135         {
2136           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2137           gpgsm_exit (2);
2138         }
2139       return fp;
2140     }
2141   fp = es_fopen (filename, mode);
2142   if (!fp)
2143     {
2144       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
2145       gpgsm_exit (2);
2146     }
2147   return fp;
2148 }
2149
2150
2151 /* Open FILENAME for fwrite and return an extended stream.  Stop with
2152    an error message in case of problems.  "-" denotes stdout and if
2153    special filenames are allowed the given fd is opened instead.
2154    Caller must close the returned stream. */
2155 static estream_t
2156 open_es_fwrite (const char *filename)
2157 {
2158   int fd;
2159   estream_t fp;
2160
2161   if (filename[0] == '-' && !filename[1])
2162     {
2163       fflush (stdout);
2164       fp = es_fdopen_nc (fileno(stdout), "wb");
2165       return fp;
2166     }
2167
2168   fd = check_special_filename (filename, 1);
2169   if (fd != -1)
2170     {
2171       fp = es_fdopen_nc (fd, "wb");
2172       if (!fp)
2173         {
2174           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2175           gpgsm_exit (2);
2176         }
2177       return fp;
2178     }
2179   fp = es_fopen (filename, "wb");
2180   if (!fp)
2181     {
2182       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
2183       gpgsm_exit (2);
2184     }
2185   return fp;
2186 }
2187
2188
2189 static void
2190 run_protect_tool (int argc, char **argv)
2191 {
2192 #ifdef HAVE_W32_SYSTEM
2193   (void)argc;
2194   (void)argv;
2195 #else
2196   const char *pgm;
2197   char **av;
2198   int i;
2199
2200   if (!opt.protect_tool_program || !*opt.protect_tool_program)
2201     pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
2202   else
2203     pgm = opt.protect_tool_program;
2204
2205   av = xcalloc (argc+2, sizeof *av);
2206   av[0] = strrchr (pgm, '/');
2207   if (!av[0])
2208     av[0] = xstrdup (pgm);
2209   for (i=1; argc; i++, argc--, argv++)
2210     av[i] = *argv;
2211   av[i] = NULL;
2212   execv (pgm, av);
2213   log_error ("error executing '%s': %s\n", pgm, strerror (errno));
2214 #endif /*!HAVE_W32_SYSTEM*/
2215   gpgsm_exit (2);
2216 }