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