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