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