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