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