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