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