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