Replace use stdio by estream functions.
[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
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);
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 ();
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   /* First check whether we have a config file on the commandline */
946   orig_argc = argc;
947   orig_argv = argv;
948   pargs.argc = &argc;
949   pargs.argv = &argv;
950   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
951   while (arg_parse( &pargs, opts))
952     {
953       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
954         parse_debug++;
955       else if (pargs.r_opt == oOptions)
956         { /* yes there is one, so we do not try the default one but
957              read the config file when it is encountered at the
958              commandline */
959           default_config = 0;
960         }
961       else if (pargs.r_opt == oNoOptions)
962         default_config = 0; /* --no-options */
963       else if (pargs.r_opt == oHomedir)
964         opt.homedir = pargs.r.ret_str;
965       else if (pargs.r_opt == aCallProtectTool)
966         break; /* This break makes sure that --version and --help are
967                   passed to the protect-tool. */
968     }
969   
970   
971   /* Initialize the secure memory. */
972   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
973   maybe_setuid = 0;
974
975   /* 
976      Now we are now working under our real uid 
977   */
978
979   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
980
981   malloc_hooks.malloc = gcry_malloc;
982   malloc_hooks.realloc = gcry_realloc;
983   malloc_hooks.free = gcry_free;
984   assuan_set_malloc_hooks (&malloc_hooks);
985   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
986   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
987
988   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
989
990   /* Setup a default control structure for command line mode */
991   memset (&ctrl, 0, sizeof ctrl);
992   gpgsm_init_default_ctrl (&ctrl);
993   ctrl.no_server = 1;
994   ctrl.status_fd = -1; /* No status output. */
995   ctrl.autodetect_encoding = 1;
996
997   /* Set the default option file */
998   if (default_config )
999     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
1000   /* Set the default policy file */
1001   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
1002   
1003   argc        = orig_argc;
1004   argv        = orig_argv;
1005   pargs.argc  = &argc;
1006   pargs.argv  = &argv;
1007   pargs.flags =  1;  /* do not remove the args */
1008
1009  next_pass:
1010   if (configname) {
1011     configlineno = 0;
1012     configfp = fopen (configname, "r");
1013     if (!configfp)
1014       {
1015         if (default_config)
1016           {
1017             if (parse_debug)
1018               log_info (_("NOTE: no default option file `%s'\n"), configname);
1019           }
1020         else 
1021           {
1022             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
1023             gpgsm_exit(2);
1024           }
1025         xfree(configname);
1026         configname = NULL;
1027       }
1028     if (parse_debug && configname)
1029       log_info (_("reading options from `%s'\n"), configname);
1030     default_config = 0;
1031   }
1032
1033   while (!no_more_options 
1034          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
1035     {
1036       switch (pargs.r_opt)
1037         {
1038         case aGPGConfList: 
1039         case aGPGConfTest: 
1040           set_cmd (&cmd, pargs.r_opt);
1041           do_not_setup_keys = 1;
1042           nogreeting = 1;
1043           break;
1044
1045         case aServer: 
1046           opt.batch = 1;
1047           set_cmd (&cmd, aServer);
1048           break;
1049
1050         case aCallDirmngr:
1051           opt.batch = 1;
1052           set_cmd (&cmd, aCallDirmngr);
1053           do_not_setup_keys = 1;
1054           break;
1055
1056         case aCallProtectTool:
1057           opt.batch = 1;
1058           set_cmd (&cmd, aCallProtectTool);
1059           no_more_options = 1; /* Stop parsing. */
1060           do_not_setup_keys = 1;
1061           break;
1062         
1063         case aDeleteKey:
1064           set_cmd (&cmd, aDeleteKey);
1065           /*greeting=1;*/
1066           do_not_setup_keys = 1;
1067           break;
1068
1069         case aDetachedSign:
1070           detached_sig = 1;
1071           set_cmd (&cmd, aSign ); 
1072           break;
1073
1074         case aKeygen:
1075           set_cmd (&cmd, aKeygen);
1076           greeting=1; 
1077           do_not_setup_keys = 1;
1078           break;
1079
1080         case aImport: 
1081         case aSendKeys: 
1082         case aRecvKeys: 
1083         case aExport: 
1084         case aExportSecretKeyP12: 
1085         case aDumpKeys:
1086         case aDumpChain:
1087         case aDumpExternalKeys: 
1088         case aDumpSecretKeys: 
1089         case aListKeys:
1090         case aListExternalKeys: 
1091         case aListSecretKeys: 
1092         case aListChain: 
1093         case aLearnCard: 
1094         case aPasswd: 
1095         case aKeydbClearSomeCertFlags:
1096           do_not_setup_keys = 1;
1097           set_cmd (&cmd, pargs.r_opt);
1098           break;
1099
1100         case aEncr: 
1101           recp_required = 1;
1102           set_cmd (&cmd, pargs.r_opt);
1103           break;
1104
1105         case aSym:
1106         case aDecrypt: 
1107         case aSign: 
1108         case aClearsign: 
1109         case aVerify: 
1110           set_cmd (&cmd, pargs.r_opt);
1111           break;
1112
1113           /* Output encoding selection.  */
1114         case oArmor:
1115           ctrl.create_pem = 1;
1116           break;
1117         case oBase64: 
1118           ctrl.create_pem = 0;
1119           ctrl.create_base64 = 1;
1120           break;
1121         case oNoArmor: 
1122           ctrl.create_pem = 0;
1123           ctrl.create_base64 = 0;
1124           break;
1125           
1126         case oP12Charset:
1127           opt.p12_charset = pargs.r.ret_str;
1128           break;
1129
1130           /* Input encoding selection.  */
1131         case oAssumeArmor:
1132           ctrl.autodetect_encoding = 0;
1133           ctrl.is_pem = 1;
1134           ctrl.is_base64 = 0;
1135           break;
1136         case oAssumeBase64:
1137           ctrl.autodetect_encoding = 0;
1138           ctrl.is_pem = 0;
1139           ctrl.is_base64 = 1;
1140           break;
1141         case oAssumeBinary:
1142           ctrl.autodetect_encoding = 0;
1143           ctrl.is_pem = 0;
1144           ctrl.is_base64 = 0;
1145           break;
1146
1147         case oDisableCRLChecks:
1148           opt.no_crl_check = 1;
1149           break;
1150         case oEnableCRLChecks:
1151           opt.no_crl_check = 0;
1152           break;
1153         case oDisableTrustedCertCRLCheck:
1154           opt.no_trusted_cert_crl_check = 1;
1155           break;
1156         case oEnableTrustedCertCRLCheck:
1157           opt.no_trusted_cert_crl_check = 0;
1158           break;
1159         case oForceCRLRefresh:
1160           opt.force_crl_refresh = 1;
1161           break;
1162
1163         case oDisableOCSP:
1164           ctrl.use_ocsp = opt.enable_ocsp = 0;
1165           break;
1166         case oEnableOCSP:
1167           ctrl.use_ocsp = opt.enable_ocsp = 1;
1168           break;
1169
1170         case oIncludeCerts: 
1171           ctrl.include_certs = default_include_certs = pargs.r.ret_int; 
1172           break;
1173
1174         case oPolicyFile:
1175           xfree (opt.policy_file);
1176           if (*pargs.r.ret_str)
1177             opt.policy_file = xstrdup (pargs.r.ret_str);
1178           else
1179             opt.policy_file = NULL;
1180           break;
1181
1182         case oDisablePolicyChecks:
1183           opt.no_policy_check = 1;
1184           break;
1185         case oEnablePolicyChecks:
1186           opt.no_policy_check = 0;
1187           break;
1188           
1189         case oAutoIssuerKeyRetrieve:
1190           opt.auto_issuer_key_retrieve = 1;
1191           break;
1192
1193         case oOutput: opt.outfile = pargs.r.ret_str; break;
1194
1195         
1196         case oQuiet: opt.quiet = 1; break;
1197         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1198         case oDryRun: opt.dry_run = 1; break;
1199
1200         case oVerbose:
1201           opt.verbose++;
1202           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1203           break;
1204         case oNoVerbose:
1205           opt.verbose = 0;
1206           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1207           break;
1208
1209         case oLogFile: logfile = pargs.r.ret_str; break;
1210         case oNoLogFile: logfile = NULL; break;          
1211
1212         case oAuditLog: auditlog = pargs.r.ret_str; break;
1213         case oHtmlAuditLog: htmlauditlog = pargs.r.ret_str; break;
1214
1215         case oBatch: 
1216           opt.batch = 1;
1217           greeting = 0;
1218           break;
1219         case oNoBatch: opt.batch = 0; break;
1220           
1221         case oAnswerYes: opt.answer_yes = 1; break;
1222         case oAnswerNo: opt.answer_no = 1; break;
1223
1224         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1225
1226         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1227         case oDebugAll: debug_value = ~0; break;
1228         case oDebugNone: debug_value = 0; break;
1229         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1230         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1231         case oDebugAllowCoreDump:
1232           may_coredump = enable_core_dumps ();
1233           break;
1234         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1235         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1236         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1237
1238         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1239         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1240         case oWithMD5Fingerprint:
1241           opt.with_md5_fingerprint=1; /*fall thru*/
1242         case oWithFingerprint:
1243           with_fpr=1; /*fall thru*/
1244         case aFingerprint:
1245           opt.fingerprint++;
1246           break;
1247
1248         case oOptions:
1249           /* config files may not be nested (silently ignore them) */
1250           if (!configfp)
1251             {
1252               xfree(configname);
1253               configname = xstrdup (pargs.r.ret_str);
1254               goto next_pass;
1255             }
1256           break;
1257         case oNoOptions: break; /* no-options */
1258         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1259         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1260
1261         case oDisplay:
1262           set_opt_session_env ("DISPLAY", pargs.r.ret_str);
1263           break;
1264         case oTTYname:
1265           set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
1266           break;
1267         case oTTYtype:
1268           set_opt_session_env ("TERM", pargs.r.ret_str);
1269           break;
1270         case oXauthority:
1271           set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
1272           break;
1273
1274         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1275         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1276
1277         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1278         case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
1279         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1280         case oProtectToolProgram:
1281           opt.protect_tool_program = pargs.r.ret_str; 
1282           break;
1283           
1284         case oFakedSystemTime:
1285           {
1286             time_t faked_time = isotime2epoch (pargs.r.ret_str); 
1287             if (faked_time == (time_t)(-1))
1288               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1289             gnupg_set_time (faked_time, 0);
1290           }
1291           break;
1292
1293         case oNoDefKeyring: default_keyring = 0; break;
1294         case oNoGreeting: nogreeting = 1; break;
1295
1296         case oDefaultKey:
1297           if (*pargs.r.ret_str)
1298             {
1299               xfree (opt.local_user);
1300               opt.local_user = xstrdup (pargs.r.ret_str);
1301             }
1302           break;
1303         case oDefRecipient:
1304           if (*pargs.r.ret_str)
1305             opt.def_recipient = xstrdup (pargs.r.ret_str);
1306           break;
1307         case oDefRecipientSelf:
1308           xfree (opt.def_recipient);
1309           opt.def_recipient = NULL;
1310           opt.def_recipient_self = 1;
1311           break;
1312         case oNoDefRecipient:
1313           xfree (opt.def_recipient);
1314           opt.def_recipient = NULL;
1315           opt.def_recipient_self = 0;
1316           break;
1317
1318         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1319         case oWithColons: ctrl.with_colons = 1; break;
1320         case oWithValidation: ctrl.with_validation=1; break;
1321         case oWithEphemeralKeys: ctrl.with_ephemeral_keys=1; break;
1322
1323         case oSkipVerify: opt.skip_verify=1; break;
1324
1325         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1326         case oEncryptTo: /* Store the recipient in the second list */
1327           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1328           sl->flags = 1;
1329           break;
1330
1331         case oRecipient: /* store the recipient */
1332           add_to_strlist ( &remusr, pargs.r.ret_str);
1333           break;
1334
1335         case oUser: /* Store the local users, the first one is the default */
1336           if (!opt.local_user)
1337             opt.local_user = xstrdup (pargs.r.ret_str);
1338           add_to_strlist (&locusr, pargs.r.ret_str);
1339           break;
1340
1341         case oNoSecmemWarn:
1342           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1343           break;
1344
1345         case oCipherAlgo:
1346           opt.def_cipher_algoid = pargs.r.ret_str;
1347           break;
1348
1349         case oDisableCipherAlgo: 
1350           {
1351             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1352             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1353           }
1354           break;
1355         case oDisablePubkeyAlgo: 
1356           {
1357             int algo = gcry_pk_map_name (pargs.r.ret_str);
1358             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1359           }
1360           break;
1361
1362         case oDigestAlgo:
1363           forced_digest_algo = pargs.r.ret_str;
1364           break;
1365
1366         case oExtraDigestAlgo: 
1367           extra_digest_algo = pargs.r.ret_str;
1368           break;
1369
1370         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1371         case oNoRandomSeedFile: use_random_seed = 0; break;
1372         case oNoCommonCertsImport: no_common_certs_import = 1; break;
1373
1374         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1375
1376         case oValidationModel: parse_validation_model (pargs.r.ret_str); break;
1377
1378         case oKeyServer:
1379           {
1380             struct keyserver_spec *keyserver;
1381             keyserver = parse_keyserver_line (pargs.r.ret_str,
1382                                               configname, configlineno);
1383             if (! keyserver)
1384               log_error (_("could not parse keyserver\n"));
1385             else
1386               {
1387                 /* FIXME: Keep last next pointer.  */
1388                 struct keyserver_spec **next_p = &opt.keyserver;
1389                 while (*next_p)
1390                   next_p = &(*next_p)->next;
1391                 *next_p = keyserver;
1392               }
1393           }
1394           break;
1395
1396         case oIgnoreCertExtension:
1397           add_to_strlist (&opt.ignored_cert_extensions, pargs.r.ret_str);
1398           break;
1399
1400         default: 
1401           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR; 
1402           break;
1403         }
1404     }
1405
1406   if (configfp)
1407     {
1408       fclose (configfp);
1409       configfp = NULL;
1410       /* Keep a copy of the config filename. */
1411       opt.config_filename = configname;
1412       configname = NULL;
1413       goto next_pass;
1414     }
1415   xfree (configname);
1416   configname = NULL;
1417
1418   if (!opt.config_filename)
1419     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1420
1421   if (log_get_errorcount(0))
1422     gpgsm_exit(2);
1423
1424   /* Now that we have the options parsed we need to update the default
1425      control structure.  */
1426   gpgsm_init_default_ctrl (&ctrl);
1427
1428   if (nogreeting)
1429     greeting = 0;
1430   
1431   if (greeting)
1432     {
1433       fprintf(stderr, "%s %s; %s\n",
1434               strusage(11), strusage(13), strusage(14) );
1435       fprintf(stderr, "%s\n", strusage(15) );
1436     }
1437 #  ifdef IS_DEVELOPMENT_VERSION
1438   if (!opt.batch)
1439     {
1440       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1441       log_info ("It is only intended for test purposes and should NOT be\n");
1442       log_info ("used in a production environment or with production keys!\n");
1443     }
1444 #  endif
1445
1446   if (may_coredump && !opt.quiet)
1447     log_info (_("WARNING: program may create a core file!\n"));
1448
1449 /*   if (opt.qualsig_approval && !opt.quiet) */
1450 /*     log_info (_("This software has offically been approved to " */
1451 /*                 "create and verify\n" */
1452 /*                 "qualified signatures according to German law.\n")); */
1453
1454   if (logfile && cmd == aServer)
1455     {
1456       log_set_file (logfile);
1457       log_set_prefix (NULL, 1|2|4);
1458     }
1459
1460   if (gnupg_faked_time_p ())
1461     {
1462       gnupg_isotime_t tbuf;
1463
1464       log_info (_("WARNING: running with faked system time: "));
1465       gnupg_get_isotime (tbuf);
1466       dump_isotime (tbuf);
1467       log_printf ("\n");
1468     }
1469   
1470 /*FIXME    if (opt.batch) */
1471 /*      tty_batchmode (1); */
1472
1473   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1474
1475   set_debug ();
1476
1477   /* Although we alwasy use gpgsm_exit, we better install a regualr
1478      exit handler so that at least the secure memory gets wiped
1479      out. */
1480   if (atexit (emergency_cleanup))
1481     {
1482       log_error ("atexit failed\n");
1483       gpgsm_exit (2);
1484     }
1485
1486   /* Must do this after dropping setuid, because the mapping functions
1487      may try to load an module and we may have disabled an algorithm.
1488      We remap the commonly used algorithms to the OIDs for
1489      convenience.  We need to work with the OIDs because they are used
1490      to check whether the encryption mode is actually available. */
1491   if (!strcmp (opt.def_cipher_algoid, "3DES") )
1492     opt.def_cipher_algoid = "1.2.840.113549.3.7";
1493   else if (!strcmp (opt.def_cipher_algoid, "AES")
1494            || !strcmp (opt.def_cipher_algoid, "AES128"))
1495     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1496   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1497     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1498   else if (!strcmp (opt.def_cipher_algoid, "SERPENT")
1499            || !strcmp (opt.def_cipher_algoid, "SERPENT128") )
1500     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.2";
1501   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1502     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.22";
1503   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1504     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.42";
1505   else if (!strcmp (opt.def_cipher_algoid, "SEED") )
1506     opt.def_cipher_algoid = "1.2.410.200004.1.4";
1507   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA") 
1508            || !strcmp (opt.def_cipher_algoid, "CAMELLIA128") )
1509     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.2";
1510   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA192") )
1511     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
1512   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
1513     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
1514
1515   if (cmd != aGPGConfList)
1516     {
1517       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1518            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1519         log_error (_("selected cipher algorithm is invalid\n"));
1520
1521       if (forced_digest_algo)
1522         {
1523           opt.forced_digest_algo = gcry_md_map_name (forced_digest_algo);
1524           if (our_md_test_algo(opt.forced_digest_algo) )
1525             log_error (_("selected digest algorithm is invalid\n"));
1526         }
1527       if (extra_digest_algo)
1528         {
1529           opt.extra_digest_algo = gcry_md_map_name (extra_digest_algo);
1530           if (our_md_test_algo (opt.extra_digest_algo) )
1531             log_error (_("selected digest algorithm is invalid\n"));
1532         }
1533     }
1534
1535   if (log_get_errorcount(0))
1536     gpgsm_exit(2);
1537   
1538   /* Set the random seed file. */
1539   if (use_random_seed) 
1540     {
1541       char *p = make_filename (opt.homedir, "random_seed", NULL);
1542       gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1543       xfree(p);
1544     }
1545   
1546   if (!cmd && opt.fingerprint && !with_fpr)
1547     set_cmd (&cmd, aListKeys);
1548   
1549   /* Add default keybox. */
1550   if (!nrings && default_keyring)
1551     {
1552       int created;
1553
1554       keydb_add_resource ("pubring.kbx", 0, 0, &created);
1555       if (created && !no_common_certs_import)
1556         {
1557           /* Import the standard certificates for a new default keybox. */
1558           char *filelist[2];
1559           
1560           filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
1561           filelist[1] = NULL;
1562           if (!access (filelist[0], F_OK))
1563             {
1564               log_info (_("importing common certificates `%s'\n"),
1565                         filelist[0]);
1566               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1567             }
1568           xfree (filelist[0]);
1569         }
1570     }
1571   for (sl = nrings; sl; sl = sl->next)
1572     keydb_add_resource (sl->d, 0, 0, NULL);
1573   FREE_STRLIST(nrings);
1574
1575
1576   /* Prepare the audit log feature for certain commands.  */
1577   if (auditlog || htmlauditlog)
1578     {
1579       switch (cmd)
1580         {
1581         case aEncr: 
1582         case aSign:
1583         case aDecrypt:
1584         case aVerify:
1585           audit_release (ctrl.audit);
1586           ctrl.audit = audit_new ();
1587           if (auditlog)
1588             auditfp = open_es_fwrite (auditlog);
1589           if (htmlauditlog)
1590             htmlauditfp = open_es_fwrite (htmlauditlog);
1591           break;
1592         default:
1593           break;
1594         }
1595     }
1596
1597
1598   if (!do_not_setup_keys)
1599     {
1600       for (sl = locusr; sl ; sl = sl->next)
1601         {
1602           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1603           if (rc)
1604             {
1605               log_error (_("can't sign using `%s': %s\n"),
1606                          sl->d, gpg_strerror (rc));
1607               gpgsm_status2 (&ctrl, STATUS_INV_SGNR,
1608                              get_inv_recpsgnr_code (rc), sl->d, NULL);
1609               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1610                              get_inv_recpsgnr_code (rc), sl->d, NULL);
1611             }
1612         }
1613       
1614       /* Build the recipient list.  We first add the regular ones and then
1615          the encrypt-to ones because the underlying function will silently
1616          ignore duplicates and we can't allow to keep a duplicate which is
1617          flagged as encrypt-to as the actually encrypt function would then
1618          complain about no (regular) recipients. */
1619       for (sl = remusr; sl; sl = sl->next)
1620         if (!(sl->flags & 1))
1621           do_add_recipient (&ctrl, sl->d, &recplist, 0, recp_required);
1622       if (!opt.no_encrypt_to)
1623         {
1624           for (sl = remusr; sl; sl = sl->next)
1625             if ((sl->flags & 1))
1626               do_add_recipient (&ctrl, sl->d, &recplist, 1, recp_required);
1627         }
1628     }
1629
1630   if (log_get_errorcount(0))
1631     gpgsm_exit(1); /* Must stop for invalid recipients. */
1632   
1633   fname = argc? *argv : NULL;
1634   
1635   /* Dispatch command.  */
1636   switch (cmd)
1637     {
1638     case aGPGConfList: 
1639       { /* List options and default values in the GPG Conf format.  */
1640         char *config_filename_esc = percent_escape (opt.config_filename, NULL);
1641
1642         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1643                 GC_OPT_FLAG_DEFAULT, config_filename_esc);
1644         xfree (config_filename_esc);
1645
1646         printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1647         printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
1648         printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1649         printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1650         printf ("disable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
1651         printf ("disable-trusted-cert-crl-check:%lu:\n", GC_OPT_FLAG_NONE);
1652         printf ("enable-ocsp:%lu:\n", GC_OPT_FLAG_NONE);
1653         printf ("include-certs:%lu:%d:\n", GC_OPT_FLAG_DEFAULT,
1654                 DEFAULT_INCLUDE_CERTS);
1655         printf ("disable-policy-checks:%lu:\n", GC_OPT_FLAG_NONE);
1656         printf ("auto-issuer-key-retrieve:%lu:\n", GC_OPT_FLAG_NONE);
1657         printf ("disable-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1658 #ifndef HAVE_W32_SYSTEM
1659         printf ("prefer-system-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1660 #endif
1661         printf ("cipher-algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1662                 DEFAULT_CIPHER_ALGO);
1663         printf ("p12-charset:%lu:\n", GC_OPT_FLAG_DEFAULT);
1664         printf ("default-key:%lu:\n", GC_OPT_FLAG_DEFAULT);
1665         printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_DEFAULT);
1666         printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1667
1668         /* The next one is an info only item and should match what
1669            proc_parameters actually implements.  */
1670         printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1671                 "RSA-2048");
1672
1673       }
1674       break;
1675     case aGPGConfTest:
1676       /* This is merely a dummy command to test whether the
1677          configuration file is valid.  */
1678       break;
1679
1680     case aServer:
1681       if (debug_wait)
1682         {
1683           log_debug ("waiting for debugger - my pid is %u .....\n",
1684                      (unsigned int)getpid());
1685           gnupg_sleep (debug_wait);
1686           log_debug ("... okay\n");
1687          }
1688       gpgsm_server (recplist);
1689       break;
1690
1691     case aCallDirmngr:
1692       if (!argc)
1693         wrong_args ("--call-dirmngr <command> {args}");
1694       else
1695         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1696           gpgsm_exit (1);
1697       break;
1698
1699     case aCallProtectTool:
1700       run_protect_tool (argc, argv);
1701       break;
1702
1703     case aEncr: /* Encrypt the given file. */
1704       {
1705         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1706
1707         set_binary (stdin);
1708
1709         if (!argc) /* Source is stdin. */
1710           gpgsm_encrypt (&ctrl, recplist, 0, fp); 
1711         else if (argc == 1)  /* Source is the given file. */
1712           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1713         else
1714           wrong_args ("--encrypt [datafile]");
1715
1716         es_fclose (fp);
1717       }
1718       break;
1719
1720     case aSign: /* Sign the given file. */
1721       {
1722         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1723
1724         /* Fixme: We should also allow to concatenate multiple files for
1725            signing because that is what gpg does.*/
1726         set_binary (stdin);
1727         if (!argc) /* Create from stdin. */
1728           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp); 
1729         else if (argc == 1) /* From file. */
1730           gpgsm_sign (&ctrl, signerlist,
1731                       open_read (*argv), detached_sig, fp); 
1732         else
1733           wrong_args ("--sign [datafile]");
1734
1735         es_fclose (fp);
1736       }
1737       break;
1738         
1739     case aSignEncr: /* sign and encrypt the given file */
1740       log_error ("this command has not yet been implemented\n");
1741       break;
1742
1743     case aClearsign: /* make a clearsig */
1744       log_error ("this command has not yet been implemented\n");
1745       break;
1746
1747     case aVerify:
1748       {
1749         estream_t fp = NULL;
1750
1751         set_binary (stdin);
1752         if (argc == 2 && opt.outfile)
1753           log_info ("option --output ignored for a detached signature\n");
1754         else if (opt.outfile)
1755           fp = open_es_fwrite (opt.outfile);
1756
1757         if (!argc)
1758           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1759         else if (argc == 1)
1760           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1761         else if (argc == 2) /* detached signature (sig, detached) */
1762           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1763         else
1764           wrong_args ("--verify [signature [detached_data]]");
1765
1766         es_fclose (fp);
1767       }
1768       break;
1769
1770     case aDecrypt:
1771       {
1772         estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1773
1774         set_binary (stdin);
1775         if (!argc)
1776           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1777         else if (argc == 1)
1778           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1779         else
1780           wrong_args ("--decrypt [filename]");
1781
1782         es_fclose (fp);
1783       }
1784       break;
1785
1786     case aDeleteKey:
1787       for (sl=NULL; argc; argc--, argv++)
1788         add_to_strlist (&sl, *argv);
1789       gpgsm_delete (&ctrl, sl);
1790       free_strlist(sl);
1791       break;
1792
1793     case aListChain:
1794     case aDumpChain:
1795        ctrl.with_chain = 1;
1796     case aListKeys:
1797     case aDumpKeys:
1798     case aListExternalKeys:
1799     case aDumpExternalKeys:
1800     case aListSecretKeys:
1801     case aDumpSecretKeys:
1802       {
1803         unsigned int mode;
1804         estream_t fp;
1805
1806         switch (cmd)
1807           {
1808           case aListChain:
1809           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1810           case aDumpChain: 
1811           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1812           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1813           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1814           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1815           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1816           default: BUG();
1817           }
1818
1819         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1820         for (sl=NULL; argc; argc--, argv++)
1821           add_to_strlist (&sl, *argv);
1822         gpgsm_list_keys (&ctrl, sl, fp, mode);
1823         free_strlist(sl);
1824         es_fclose (fp);
1825       }
1826       break;
1827
1828
1829     case aKeygen: /* Generate a key; well kind of. */
1830       {
1831         estream_t fpin = NULL;
1832         FILE *fpout;
1833
1834         if (opt.batch)
1835           {
1836             if (!argc) /* Create from stdin. */
1837               fpin = open_es_fread ("-"); 
1838             else if (argc == 1) /* From file. */
1839               fpin = open_es_fread (*argv); 
1840             else
1841               wrong_args ("--gen-key --batch [parmfile]");
1842           }
1843         
1844         fpout = open_fwrite (opt.outfile?opt.outfile:"-");
1845
1846         if (fpin)
1847           gpgsm_genkey (&ctrl, fpin, fpout);
1848         else
1849           gpgsm_gencertreq_tty (&ctrl, fpout);
1850
1851         if (fpout != stdout)
1852           fclose (fpout);
1853       }
1854       break;
1855
1856
1857     case aImport:
1858       gpgsm_import_files (&ctrl, argc, argv, open_read);
1859       break;
1860
1861     case aExport:
1862       {
1863         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1864
1865         for (sl=NULL; argc; argc--, argv++)
1866           add_to_strlist (&sl, *argv);
1867         gpgsm_export (&ctrl, sl, fp, NULL);
1868         free_strlist(sl);
1869         if (fp != stdout)
1870           fclose (fp);
1871       }
1872       break;
1873
1874     case aExportSecretKeyP12:
1875       {
1876         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1877
1878         if (argc == 1)
1879           gpgsm_p12_export (&ctrl, *argv, fp);
1880         else
1881           wrong_args ("--export-secret-key-p12 KEY-ID");
1882         if (fp != stdout)
1883           fclose (fp);
1884       }
1885       break;
1886       
1887     case aSendKeys:
1888     case aRecvKeys:
1889       log_error ("this command has not yet been implemented\n");
1890       break;
1891
1892
1893     case aLearnCard:
1894       if (argc)
1895         wrong_args ("--learn-card");
1896       else
1897         {
1898           int rc = gpgsm_agent_learn (&ctrl);
1899           if (rc)
1900             log_error ("error learning card: %s\n", gpg_strerror (rc));
1901         }
1902       break;
1903
1904     case aPasswd:
1905       if (argc != 1)
1906         wrong_args ("--passwd <key-Id>");
1907       else
1908         {
1909           int rc;
1910           ksba_cert_t cert = NULL;
1911           char *grip = NULL;
1912
1913           rc = gpgsm_find_cert (*argv, NULL, &cert);
1914           if (rc)
1915             ;
1916           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1917             rc = gpg_error (GPG_ERR_BUG);
1918           else 
1919             {
1920               char *desc = gpgsm_format_keydesc (cert);
1921               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1922               xfree (desc);
1923             }
1924           if (rc)
1925             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1926           xfree (grip);
1927           ksba_cert_release (cert);
1928         }
1929       break;
1930
1931     case aKeydbClearSomeCertFlags:
1932       for (sl=NULL; argc; argc--, argv++)
1933         add_to_strlist (&sl, *argv);
1934       keydb_clear_some_cert_flags (&ctrl, sl);
1935       free_strlist(sl);
1936       break;
1937
1938
1939     default:
1940         log_error (_("invalid command (there is no implicit command)\n"));
1941         break;
1942     }
1943
1944   /* Print the audit result if needed.  */
1945   if ((auditlog && auditfp) || (htmlauditlog && htmlauditfp))
1946     {
1947       if (auditlog && auditfp)
1948         audit_print_result (ctrl.audit, auditfp, 0);
1949       if (htmlauditlog && htmlauditfp)
1950         audit_print_result (ctrl.audit, htmlauditfp, 1);
1951       audit_release (ctrl.audit);
1952       ctrl.audit = NULL;
1953       es_fclose (auditfp);
1954       es_fclose (htmlauditfp);
1955     }
1956   
1957   /* cleanup */
1958   keyserver_list_free (opt.keyserver);
1959   opt.keyserver = NULL;
1960   gpgsm_release_certlist (recplist);
1961   gpgsm_release_certlist (signerlist);
1962   FREE_STRLIST (remusr);
1963   FREE_STRLIST (locusr);
1964   gpgsm_exit(0);
1965   return 8; /*NOTREACHED*/
1966 }
1967
1968 /* Note: This function is used by signal handlers!. */
1969 static void
1970 emergency_cleanup (void)
1971 {
1972   gcry_control (GCRYCTL_TERM_SECMEM );
1973 }
1974
1975
1976 void
1977 gpgsm_exit (int rc)
1978 {
1979   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1980   if (opt.debug & DBG_MEMSTAT_VALUE)
1981     {
1982       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1983       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1984     }
1985   if (opt.debug)
1986     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1987   emergency_cleanup ();
1988   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1989   exit (rc);
1990 }
1991
1992
1993 void
1994 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1995 {
1996   ctrl->include_certs = default_include_certs;
1997   ctrl->use_ocsp = opt.enable_ocsp;
1998   ctrl->validation_model = default_validation_model;
1999 }
2000
2001
2002 int
2003 gpgsm_parse_validation_model (const char *model)
2004 {     
2005   if (!ascii_strcasecmp (model, "shell") )
2006     return 0;
2007   else if ( !ascii_strcasecmp (model, "chain") )
2008     return 1;
2009   else
2010     return -1;
2011 }
2012
2013
2014 /* Check whether the filename has the form "-&nnnn", where n is a
2015    non-zero number.  Returns this number or -1 if it is not the case.  */
2016 static int
2017 check_special_filename (const char *fname, int for_write)
2018 {
2019   if (allow_special_filenames
2020       && fname && *fname == '-' && fname[1] == '&' ) {
2021     int i;
2022     
2023     fname += 2;
2024     for (i=0; isdigit (fname[i]); i++ )
2025       ;
2026     if ( !fname[i] ) 
2027       return translate_sys2libc_fd_int (atoi (fname), for_write);
2028   }
2029   return -1;
2030 }
2031
2032
2033
2034 /* Open the FILENAME for read and return the file descriptor.  Stop
2035    with an error message in case of problems.  "-" denotes stdin and
2036    if special filenames are allowed the given fd is opened instead.  */
2037 static int 
2038 open_read (const char *filename)
2039 {
2040   int fd;
2041
2042   if (filename[0] == '-' && !filename[1])
2043     {
2044       set_binary (stdin);
2045       return 0; /* stdin */
2046     }
2047   fd = check_special_filename (filename, 0);
2048   if (fd != -1)
2049     return fd;
2050   fd = open (filename, O_RDONLY | O_BINARY);
2051   if (fd == -1)
2052     {
2053       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2054       gpgsm_exit (2);
2055     }
2056   return fd;
2057 }
2058
2059 /* Same as open_read but return an estream_t.  */
2060 static estream_t
2061 open_es_fread (const char *filename)
2062 {
2063   int fd;
2064   estream_t fp;
2065
2066   if (filename[0] == '-' && !filename[1])
2067     fd = fileno (stdin);
2068   else
2069     fd = check_special_filename (filename, 0);
2070   if (fd != -1)
2071     {
2072       fp = es_fdopen_nc (fd, "rb");
2073       if (!fp)
2074         {
2075           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2076           gpgsm_exit (2);
2077         }
2078       return fp;
2079     }
2080   fp = es_fopen (filename, "rb");
2081   if (!fp)
2082     {
2083       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2084       gpgsm_exit (2);
2085     }
2086   return fp;
2087 }
2088
2089
2090 /* Open FILENAME for fwrite and return the stream.  Stop with an error
2091    message in case of problems.  "-" denotes stdout and if special
2092    filenames are allowed the given fd is opened instead. Caller must
2093    close the returned stream unless it is stdout. */
2094 static FILE *
2095 open_fwrite (const char *filename)
2096 {
2097   int fd;
2098   FILE *fp;
2099
2100   if (filename[0] == '-' && !filename[1])
2101     {
2102       set_binary (stdout);
2103       return stdout;
2104     }
2105
2106   fd = check_special_filename (filename, 1);
2107   if (fd != -1)
2108     {
2109       fp = fdopen (dup (fd), "wb");
2110       if (!fp)
2111         {
2112           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
2113           gpgsm_exit (2);
2114         }
2115       set_binary (fp);
2116       return fp;
2117     }
2118   fp = fopen (filename, "wb");
2119   if (!fp)
2120     {
2121       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2122       gpgsm_exit (2);
2123     }
2124   return fp;
2125 }
2126
2127
2128 /* Open FILENAME for fwrite and return an extended stream.  Stop with
2129    an error message in case of problems.  "-" denotes stdout and if
2130    special filenames are allowed the given fd is opened instead.
2131    Caller must close the returned stream. */
2132 static estream_t
2133 open_es_fwrite (const char *filename)
2134 {
2135   int fd;
2136   estream_t fp;
2137
2138   if (filename[0] == '-' && !filename[1])
2139     {
2140       fflush (stdout);
2141       fp = es_fdopen_nc (fileno(stdout), "wb");
2142       return fp;
2143     }
2144
2145   fd = check_special_filename (filename, 1);
2146   if (fd != -1)
2147     {
2148       fp = es_fdopen_nc (fd, "wb");
2149       if (!fp)
2150         {
2151           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2152           gpgsm_exit (2);
2153         }
2154       return fp;
2155     }
2156   fp = es_fopen (filename, "wb");
2157   if (!fp)
2158     {
2159       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2160       gpgsm_exit (2);
2161     }
2162   return fp;
2163 }
2164
2165
2166 static void
2167 run_protect_tool (int argc, char **argv)
2168 {
2169 #ifndef HAVE_W32_SYSTEM
2170   const char *pgm;
2171   char **av;
2172   int i;
2173
2174   if (!opt.protect_tool_program || !*opt.protect_tool_program)
2175     pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
2176   else
2177     pgm = opt.protect_tool_program;
2178
2179   av = xcalloc (argc+2, sizeof *av);
2180   av[0] = strrchr (pgm, '/');
2181   if (!av[0])
2182     av[0] = xstrdup (pgm);
2183   for (i=1; argc; i++, argc--, argv++)
2184     av[i] = *argv;
2185   av[i] = NULL;
2186   execv (pgm, av); 
2187   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
2188 #endif /*HAVE_W32_SYSTEM*/
2189   gpgsm_exit (2);
2190 }