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