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