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