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