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