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