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