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