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