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