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