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