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