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