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