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