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