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