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