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