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