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