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