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