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