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