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