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