415a7cafa9bbd06df0ff6dcbbed071ffa1f5af63
[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 estream_t open_es_fwrite (const char *filename);
485 static void run_protect_tool (int argc, char **argv);
486
487
488 static int
489 our_pk_test_algo (int algo)
490 {
491   return 1;
492 }
493
494 static int
495 our_cipher_test_algo (int algo)
496 {
497   return 1;
498 }
499
500 static int
501 our_md_test_algo (int algo)
502 {
503   return 1;
504 }
505
506 static const char *
507 my_strusage( int level )
508 {
509   static char *digests, *pubkeys, *ciphers;
510   const char *p;
511
512   switch (level)
513     {
514     case 11: p = "gpgsm (GnuPG)";
515       break;
516     case 13: p = VERSION; break;
517     case 17: p = PRINTABLE_OS_NAME; break;
518     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
519       break;
520     case 1:
521     case 40: p = _("Usage: gpgsm [options] [files] (-h for help)");
522       break;
523     case 41:
524       p = _("Syntax: gpgsm [options] [files]\n"
525             "sign, check, encrypt or decrypt using the S/MIME protocol\n"
526             "default operation depends on the input data\n");
527       break;
528
529     case 31: p = "\nHome: "; break;
530     case 32: p = opt.homedir; break;
531     case 33: p = _("\nSupported algorithms:\n"); break;
532     case 34:
533       if (!ciphers)
534         ciphers = build_list ("Cipher: ", gcry_cipher_algo_name,
535                               our_cipher_test_algo );
536       p = ciphers;
537       break;
538     case 35:
539       if (!pubkeys)
540         pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
541                               our_pk_test_algo );
542       p = pubkeys;
543       break;
544     case 36:
545       if (!digests)
546         digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
547       p = digests;
548       break;
549       
550     default: p = NULL; break;
551     }
552   return p;
553 }
554
555
556 static char *
557 build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
558 {
559   int i;
560   size_t n=strlen(text)+2;
561   char *list, *p;
562   
563   if (maybe_setuid) {
564     gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
565   }
566
567   for (i=1; i < 110; i++ )
568     if (!chkf(i))
569       n += strlen(mapf(i)) + 2;
570   list = xmalloc (21 + n);
571   *list = 0;
572   for (p=NULL, i=1; i < 110; i++)
573     {
574       if (!chkf(i))
575         {
576           if( !p )
577             p = stpcpy (list, text );
578           else
579             p = stpcpy (p, ", ");
580           p = stpcpy (p, mapf(i) );
581         }
582     }
583   if (p)
584     p = stpcpy(p, "\n" );
585   return list;
586 }
587
588
589 /* Set the file pointer into binary mode if required.  */
590 static void
591 set_binary (FILE *fp)
592 {
593 #ifdef HAVE_DOSISH_SYSTEM
594   setmode (fileno (fp), O_BINARY);
595 #endif
596 }
597
598
599
600 static void
601 i18n_init(void)
602 {
603 #ifdef USE_SIMPLE_GETTEXT
604   set_gettext_file (PACKAGE_GT);
605 #else
606 # ifdef ENABLE_NLS
607   setlocale (LC_ALL, "" );
608   bindtextdomain (PACKAGE_GT, LOCALEDIR);
609   textdomain (PACKAGE_GT);
610 # endif
611 #endif
612 }
613
614
615 static void
616 wrong_args (const char *text)
617 {
618   fputs (_("usage: gpgsm [options] "), stderr);
619   fputs (text, stderr);
620   putc ('\n', stderr);
621   gpgsm_exit (2);
622 }
623
624
625 /* Setup the debugging.  With a DEBUG_LEVEL of NULL only the active
626    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
627    set, a specific set of debug flags is set; and individual debugging
628    flags will be added on top.  */
629 static void
630 set_debug (void)
631 {
632   if (!debug_level)
633     ;
634   else if (!strcmp (debug_level, "none"))
635     opt.debug = 0;
636   else if (!strcmp (debug_level, "basic"))
637     opt.debug = DBG_ASSUAN_VALUE;
638   else if (!strcmp (debug_level, "advanced"))
639     opt.debug = DBG_ASSUAN_VALUE|DBG_X509_VALUE;
640   else if (!strcmp (debug_level, "expert"))
641     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE
642                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
643   else if (!strcmp (debug_level, "guru"))
644     opt.debug = ~0;
645   else
646     {
647       log_error (_("invalid debug-level `%s' given\n"), debug_level);
648       gpgsm_exit(2);
649     }
650
651   opt.debug |= debug_value;
652
653   if (opt.debug && !opt.verbose)
654     opt.verbose = 1;
655   if (opt.debug)
656     opt.quiet = 0;
657
658   if (opt.debug & DBG_MPI_VALUE)
659     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
660   if (opt.debug & DBG_CRYPTO_VALUE )
661     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
662   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
663 }
664  
665
666
667 static void
668 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
669 {
670   enum cmd_and_opt_values cmd = *ret_cmd;
671
672   if (!cmd || cmd == new_cmd)
673     cmd = new_cmd;
674   else if ( cmd == aSign && new_cmd == aEncr )
675     cmd = aSignEncr;
676   else if ( cmd == aEncr && new_cmd == aSign )
677     cmd = aSignEncr;
678   else if ( (cmd == aSign && new_cmd == aClearsign)
679             || (cmd == aClearsign && new_cmd == aSign) )
680     cmd = aClearsign;
681   else 
682     {
683       log_error(_("conflicting commands\n"));
684       gpgsm_exit(2);
685     }
686
687   *ret_cmd = cmd;
688 }
689
690
691 /* Helper to add recipients to a list. */
692 static void
693 do_add_recipient (ctrl_t ctrl, const char *name,
694                   certlist_t *recplist, int is_encrypt_to)
695 {
696   int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
697   if (rc)
698     {
699       log_error (_("can't encrypt to `%s': %s\n"), name, gpg_strerror (rc));
700       gpgsm_status2 (ctrl, STATUS_INV_RECP,
701                      gpg_err_code (rc) == -1?                         "1":
702                      gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?          "1":
703                      gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?     "2":
704                      gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE?    "3":
705                      gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?       "4":
706                      gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?       "5":
707                      gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?       "6":
708                      gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?        "7":
709                      gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH?    "8":
710                      "0",
711                      name, NULL);
712     }
713 }
714
715
716 int
717 main ( int argc, char **argv)
718 {
719   ARGPARSE_ARGS pargs;
720   int orig_argc;
721   char **orig_argv;
722   const char *fname;
723   /*  char *username;*/
724   int may_coredump;
725   strlist_t sl, remusr= NULL, locusr=NULL;
726   strlist_t nrings=NULL;
727   int detached_sig = 0;
728   FILE *configfp = NULL;
729   char *configname = NULL;
730   unsigned configlineno;
731   int parse_debug = 0;
732   int no_more_options = 0;
733   int default_config =1;
734   int default_keyring = 1;
735   char *logfile = NULL;
736   int greeting = 0;
737   int nogreeting = 0;
738   int debug_wait = 0;
739   int use_random_seed = 1;
740   int with_fpr = 0;
741   char *def_digest_string = NULL;
742   enum cmd_and_opt_values cmd = 0;
743   struct server_control_s ctrl;
744   certlist_t recplist = NULL;
745   certlist_t signerlist = NULL;
746   int do_not_setup_keys = 0;
747
748   /*mtrace();*/
749
750   /* trap_unaligned ();*/
751   set_strusage (my_strusage);
752   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
753   /* We don't need any locking in libgcrypt unless we use any kind of
754      threading. */
755   gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
756
757   /* Please note that we may running SUID(ROOT), so be very CAREFUL
758      when adding any stuff between here and the call to secmem_init()
759      somewhere after the option parsing */
760   log_set_prefix ("gpgsm", 1);
761
762   /* Try to auto set the character set.  */
763   set_native_charset (NULL); 
764
765   /* Check that the libraries are suitable.  Do it here because the
766      option parse may need services of the library */
767   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
768     {
769       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
770                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
771     }
772   if (!ksba_check_version (NEED_KSBA_VERSION) )
773     {
774       log_fatal( _("libksba is too old (need %s, have %s)\n"),
775                  NEED_KSBA_VERSION, ksba_check_version (NULL) );
776     }
777
778
779   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
780
781   may_coredump = disable_core_dumps ();
782   
783   gnupg_init_signals (0, emergency_cleanup);
784   
785   create_dotlock (NULL); /* register locking cleanup */
786   i18n_init();
787
788   opt.def_cipher_algoid = "3DES";  /*des-EDE3-CBC*/
789
790   opt.homedir = default_homedir ();
791 #ifdef HAVE_W32_SYSTEM
792   opt.no_crl_check = 1;
793 #endif
794
795   /* First check whether we have a config file on the commandline */
796   orig_argc = argc;
797   orig_argv = argv;
798   pargs.argc = &argc;
799   pargs.argv = &argv;
800   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
801   while (arg_parse( &pargs, opts))
802     {
803       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
804         parse_debug++;
805       else if (pargs.r_opt == oOptions)
806         { /* yes there is one, so we do not try the default one but
807              read the config file when it is encountered at the
808              commandline */
809           default_config = 0;
810         }
811       else if (pargs.r_opt == oNoOptions)
812         default_config = 0; /* --no-options */
813       else if (pargs.r_opt == oHomedir)
814         opt.homedir = pargs.r.ret_str;
815       else if (pargs.r_opt == aCallProtectTool)
816         break; /* This break makes sure that --version and --help are
817                   passed to the protect-tool. */
818     }
819   
820   
821   /* initialize the secure memory. */
822   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
823   maybe_setuid = 0;
824
825   /* 
826      Now we are now working under our real uid 
827   */
828
829   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
830
831   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
832   assuan_set_assuan_log_stream (log_get_stream ());
833   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
834   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
835
836   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
837
838   /* Setup a default control structure for command line mode */
839   memset (&ctrl, 0, sizeof ctrl);
840   gpgsm_init_default_ctrl (&ctrl);
841   ctrl.no_server = 1;
842   ctrl.status_fd = -1; /* not status output */
843   ctrl.autodetect_encoding = 1;
844
845   /* Set the default option file */
846   if (default_config )
847     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
848   /* Set the default policy file */
849   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
850   
851   argc        = orig_argc;
852   argv        = orig_argv;
853   pargs.argc  = &argc;
854   pargs.argv  = &argv;
855   pargs.flags =  1;  /* do not remove the args */
856
857  next_pass:
858   if (configname) {
859     configlineno = 0;
860     configfp = fopen (configname, "r");
861     if (!configfp)
862       {
863         if (default_config)
864           {
865             if (parse_debug)
866               log_info (_("NOTE: no default option file `%s'\n"), configname);
867           }
868         else 
869           {
870             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
871             gpgsm_exit(2);
872           }
873         xfree(configname);
874         configname = NULL;
875       }
876     if (parse_debug && configname)
877       log_info (_("reading options from `%s'\n"), configname);
878     default_config = 0;
879   }
880
881   while (!no_more_options 
882          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
883     {
884       switch (pargs.r_opt)
885         {
886         case aGPGConfList: 
887         case aGPGConfTest: 
888           set_cmd (&cmd, pargs.r_opt);
889           do_not_setup_keys = 1;
890           nogreeting = 1;
891           break;
892
893         case aServer: 
894           opt.batch = 1;
895           set_cmd (&cmd, aServer);
896           break;
897
898         case aCallDirmngr:
899           opt.batch = 1;
900           set_cmd (&cmd, aCallDirmngr);
901           do_not_setup_keys = 1;
902           break;
903
904         case aCallProtectTool:
905           opt.batch = 1;
906           set_cmd (&cmd, aCallProtectTool);
907           no_more_options = 1; /* Stop parsing. */
908           do_not_setup_keys = 1;
909           break;
910         
911         case aDeleteKey:
912           set_cmd (&cmd, aDeleteKey);
913           /*greeting=1;*/
914           do_not_setup_keys = 1;
915           break;
916
917         case aDetachedSign:
918           detached_sig = 1;
919           set_cmd (&cmd, aSign ); 
920           break;
921
922         case aKeygen:
923           set_cmd (&cmd, aKeygen);
924           greeting=1; 
925           do_not_setup_keys = 1;
926           break;
927
928         case aCheckKeys:
929         case aImport: 
930         case aSendKeys: 
931         case aRecvKeys: 
932         case aExport: 
933         case aExportSecretKeyP12: 
934         case aDumpKeys:
935         case aDumpChain:
936         case aDumpExternalKeys: 
937         case aDumpSecretKeys: 
938         case aListKeys:
939         case aListExternalKeys: 
940         case aListSecretKeys: 
941         case aListChain: 
942         case aLearnCard: 
943         case aPasswd: 
944         case aKeydbClearSomeCertFlags:
945           do_not_setup_keys = 1;
946           set_cmd (&cmd, pargs.r_opt);
947           break;
948
949         case aSym:
950         case aDecrypt: 
951         case aEncr: 
952         case aSign: 
953         case aClearsign: 
954         case aVerify: 
955           set_cmd (&cmd, pargs.r_opt);
956           break;
957
958           /* output encoding selection */
959         case oArmor:
960           ctrl.create_pem = 1;
961           break;
962         case oBase64: 
963           ctrl.create_pem = 0;
964           ctrl.create_base64 = 1;
965           break;
966         case oNoArmor: 
967           ctrl.create_pem = 0;
968           ctrl.create_base64 = 0;
969           break;
970           
971           /* Input encoding selection */
972         case oAssumeArmor:
973           ctrl.autodetect_encoding = 0;
974           ctrl.is_pem = 1;
975           ctrl.is_base64 = 0;
976           break;
977         case oAssumeBase64:
978           ctrl.autodetect_encoding = 0;
979           ctrl.is_pem = 0;
980           ctrl.is_base64 = 1;
981           break;
982         case oAssumeBinary:
983           ctrl.autodetect_encoding = 0;
984           ctrl.is_pem = 0;
985           ctrl.is_base64 = 0;
986           break;
987
988         case oDisableCRLChecks:
989           opt.no_crl_check = 1;
990           break;
991         case oEnableCRLChecks:
992           opt.no_crl_check = 0;
993           break;
994         case oDisableTrustedCertCRLCheck:
995           opt.no_trusted_cert_crl_check = 1;
996           break;
997         case oEnableTrustedCertCRLCheck:
998           opt.no_trusted_cert_crl_check = 0;
999           break;
1000         case oForceCRLRefresh:
1001           opt.force_crl_refresh = 1;
1002           break;
1003
1004         case oDisableOCSP:
1005           ctrl.use_ocsp = opt.enable_ocsp = 0;
1006           break;
1007         case oEnableOCSP:
1008           ctrl.use_ocsp = opt.enable_ocsp = 1;
1009           break;
1010
1011         case oIncludeCerts: 
1012           ctrl.include_certs = default_include_certs = pargs.r.ret_int; 
1013           break;
1014
1015         case oPolicyFile:
1016           xfree (opt.policy_file);
1017           if (*pargs.r.ret_str)
1018             opt.policy_file = xstrdup (pargs.r.ret_str);
1019           else
1020             opt.policy_file = NULL;
1021           break;
1022
1023         case oDisablePolicyChecks:
1024           opt.no_policy_check = 1;
1025           break;
1026         case oEnablePolicyChecks:
1027           opt.no_policy_check = 0;
1028           break;
1029           
1030         case oAutoIssuerKeyRetrieve:
1031           opt.auto_issuer_key_retrieve = 1;
1032           break;
1033
1034         case oOutput: opt.outfile = pargs.r.ret_str; break;
1035
1036         
1037         case oQuiet: opt.quiet = 1; break;
1038         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1039         case oDryRun: opt.dry_run = 1; break;
1040
1041         case oVerbose:
1042           opt.verbose++;
1043           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1044           break;
1045         case oNoVerbose:
1046           opt.verbose = 0;
1047           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1048           break;
1049
1050         case oLogFile: logfile = pargs.r.ret_str; break;
1051         case oNoLogFile: logfile = NULL; break;          
1052
1053         case oBatch: 
1054           opt.batch = 1;
1055           greeting = 0;
1056           break;
1057         case oNoBatch: opt.batch = 0; break;
1058           
1059         case oAnswerYes: opt.answer_yes = 1; break;
1060         case oAnswerNo: opt.answer_no = 1; break;
1061
1062         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1063
1064         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1065         case oDebugAll: debug_value = ~0; break;
1066         case oDebugNone: debug_value = 0; break;
1067         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1068         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1069         case oDebugAllowCoreDump:
1070           may_coredump = enable_core_dumps ();
1071           break;
1072         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1073         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1074         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1075
1076         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1077         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1078         case oWithMD5Fingerprint:
1079           opt.with_md5_fingerprint=1; /*fall thru*/
1080         case oWithFingerprint:
1081           with_fpr=1; /*fall thru*/
1082         case oFingerprint:
1083           opt.fingerprint++;
1084           break;
1085
1086         case oOptions:
1087           /* config files may not be nested (silently ignore them) */
1088           if (!configfp)
1089             {
1090               xfree(configname);
1091               configname = xstrdup (pargs.r.ret_str);
1092               goto next_pass;
1093             }
1094           break;
1095         case oNoOptions: break; /* no-options */
1096         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1097         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1098         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
1099         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
1100         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
1101         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1102         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1103         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1104         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1105         case oProtectToolProgram:
1106           opt.protect_tool_program = pargs.r.ret_str; 
1107           break;
1108           
1109         case oFakedSystemTime:
1110           gnupg_set_time ( (time_t)pargs.r.ret_ulong, 0);
1111           break;
1112
1113         case oNoDefKeyring: default_keyring = 0; break;
1114         case oNoGreeting: nogreeting = 1; break;
1115
1116         case oDefaultKey:
1117           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
1118           log_info ("WARNING: --default-key has not yet been implemented\n");
1119           break;
1120         case oDefRecipient:
1121           if (*pargs.r.ret_str)
1122             opt.def_recipient = xstrdup (pargs.r.ret_str);
1123           break;
1124         case oDefRecipientSelf:
1125           xfree (opt.def_recipient);
1126           opt.def_recipient = NULL;
1127           opt.def_recipient_self = 1;
1128           break;
1129         case oNoDefRecipient:
1130           xfree (opt.def_recipient);
1131           opt.def_recipient = NULL;
1132           opt.def_recipient_self = 0;
1133           break;
1134
1135         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1136         case oWithColons: ctrl.with_colons = 1; break;
1137         case oWithValidation: ctrl.with_validation=1; break;
1138         case oWithEphemeralKeys: opt.with_ephemeral_keys=1; break;
1139
1140         case oSkipVerify: opt.skip_verify=1; break;
1141
1142         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1143         case oEncryptTo: /* Store the recipient in the second list */
1144           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1145           sl->flags = 1;
1146           break;
1147
1148         case oRecipient: /* store the recipient */
1149           add_to_strlist ( &remusr, pargs.r.ret_str);
1150           break;
1151
1152         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
1153         case oTextmode: /*fixme:opt.textmode=1;*/  break;
1154
1155         case oUser: /* store the local users, the first one is the default */
1156           if (!opt.local_user)
1157             opt.local_user = pargs.r.ret_str;
1158           add_to_strlist (&locusr, pargs.r.ret_str);
1159           break;
1160
1161         case oNoSecmemWarn:
1162           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1163           break;
1164
1165         case oCipherAlgo:
1166           opt.def_cipher_algoid = pargs.r.ret_str;
1167           break;
1168
1169         case oDisableCipherAlgo: 
1170           {
1171             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1172             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1173           }
1174           break;
1175         case oDisablePubkeyAlgo: 
1176           {
1177             int algo = gcry_pk_map_name (pargs.r.ret_str);
1178             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1179           }
1180           break;
1181
1182         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1183         case oNoRandomSeedFile: use_random_seed = 0; break;
1184
1185         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1186           
1187
1188         case aDummy:
1189           break;
1190         default: 
1191           pargs.err = configfp? 1:2; 
1192           break;
1193         }
1194     }
1195
1196   if (configfp)
1197     {
1198       fclose (configfp);
1199       configfp = NULL;
1200       /* Keep a copy of the config filename. */
1201       opt.config_filename = configname;
1202       configname = NULL;
1203       goto next_pass;
1204     }
1205   xfree (configname);
1206   configname = NULL;
1207
1208   if (!opt.config_filename)
1209     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1210
1211   if (log_get_errorcount(0))
1212     gpgsm_exit(2);
1213   
1214   if (nogreeting)
1215     greeting = 0;
1216   
1217   if (greeting)
1218     {
1219       fprintf(stderr, "%s %s; %s\n",
1220               strusage(11), strusage(13), strusage(14) );
1221       fprintf(stderr, "%s\n", strusage(15) );
1222     }
1223 #  ifdef IS_DEVELOPMENT_VERSION
1224   if (!opt.batch)
1225     {
1226       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1227       log_info ("It is only intended for test purposes and should NOT be\n");
1228       log_info ("used in a production environment or with production keys!\n");
1229     }
1230 #  endif
1231
1232   if (may_coredump && !opt.quiet)
1233     log_info (_("WARNING: program may create a core file!\n"));
1234
1235 /*   if (opt.qualsig_approval && !opt.quiet) */
1236 /*     log_info (_("This software has offically been approved to " */
1237 /*                 "create and verify\n" */
1238 /*                 "qualified signatures according to German law.\n")); */
1239
1240   if (logfile && cmd == aServer)
1241     {
1242       log_set_file (logfile);
1243       log_set_prefix (NULL, 1|2|4);
1244     }
1245
1246   if (gnupg_faked_time_p ())
1247     {
1248       gnupg_isotime_t tbuf;
1249
1250       log_info (_("WARNING: running with faked system time: "));
1251       gnupg_get_isotime (tbuf);
1252       gpgsm_dump_time (tbuf);
1253       log_printf ("\n");
1254     }
1255   
1256 /*FIXME    if (opt.batch) */
1257 /*      tty_batchmode (1); */
1258
1259   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1260
1261   set_debug ();
1262
1263   /* Although we alwasy use gpgsm_exit, we better install a regualr
1264      exit handler so that at least the secure memory gets wiped
1265      out. */
1266   if (atexit (emergency_cleanup))
1267     {
1268       log_error ("atexit failed\n");
1269       gpgsm_exit (2);
1270     }
1271
1272   /* Must do this after dropping setuid, because the mapping functions
1273      may try to load an module and we may have disabled an algorithm.
1274      We remap the commonly used algorithms to the OIDs for
1275      convenience.  We need to work with the OIDs because they are used
1276      to check whether the encryption mode is actually available. */
1277   if (!strcmp (opt.def_cipher_algoid, "3DES") )
1278     opt.def_cipher_algoid = "1.2.840.113549.3.7";
1279   else if (!strcmp (opt.def_cipher_algoid, "AES")
1280            || !strcmp (opt.def_cipher_algoid, "AES128"))
1281     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1282   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1283     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1284
1285   if (cmd != aGPGConfList)
1286     {
1287       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1288            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1289         log_error (_("selected cipher algorithm is invalid\n"));
1290
1291       if (def_digest_string)
1292         {
1293           opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1294           xfree (def_digest_string);
1295           def_digest_string = NULL;
1296           if (our_md_test_algo(opt.def_digest_algo) )
1297             log_error (_("selected digest algorithm is invalid\n"));
1298         }
1299     }
1300
1301   if (log_get_errorcount(0))
1302     gpgsm_exit(2);
1303   
1304   /* Set the random seed file. */
1305   if (use_random_seed) {
1306     char *p = make_filename (opt.homedir, "random_seed", NULL);
1307     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1308     xfree(p);
1309   }
1310
1311
1312   if (!cmd && opt.fingerprint && !with_fpr)
1313     set_cmd (&cmd, aListKeys);
1314   
1315   if (!nrings && default_keyring)  /* Add default keybox. */
1316     {
1317       int created;
1318
1319       keydb_add_resource ("pubring.kbx", 0, 0, &created);
1320       if (created)
1321         {
1322           /* Import the standard certificates for a new default keybox. */
1323           char *filelist[2];
1324           
1325           filelist[0] = make_filename (GNUPG_DATADIR, "com-certs.pem", NULL);
1326           filelist[1] = NULL;
1327           if (!access (filelist[0], F_OK))
1328             {
1329               log_info (_("importing common certificates `%s'\n"),
1330                         filelist[0]);
1331               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1332             }
1333           xfree (filelist[0]);
1334         }
1335     }
1336   for (sl = nrings; sl; sl = sl->next)
1337     keydb_add_resource (sl->d, 0, 0, NULL);
1338   FREE_STRLIST(nrings);
1339
1340   if (!do_not_setup_keys)
1341     {
1342       for (sl = locusr; sl ; sl = sl->next)
1343         {
1344           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1345           if (rc)
1346             {
1347               log_error (_("can't sign using `%s': %s\n"),
1348                          sl->d, gpg_strerror (rc));
1349               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1350                          gpg_err_code (rc) == -1?                      "1":
1351                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1352                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1353                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1354                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1355                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1356                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1357                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1358                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1359                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1360                          "0",
1361                          sl->d, NULL);
1362             }
1363         }
1364       
1365       /* Build the recipient list.  We first add the regular ones and then
1366          the encrypt-to ones because the underlying function will silenty
1367          ignore duplicates and we can't allow to keep a duplicate which is
1368          flagged as encrypt-to as the actually encrypt function would then
1369          complain about no (regular) recipients. */
1370       for (sl = remusr; sl; sl = sl->next)
1371         if (!(sl->flags & 1))
1372           do_add_recipient (&ctrl, sl->d, &recplist, 0);
1373       if (!opt.no_encrypt_to)
1374         {
1375           for (sl = remusr; sl; sl = sl->next)
1376             if ((sl->flags & 1))
1377               do_add_recipient (&ctrl, sl->d, &recplist, 1);
1378         }
1379     }
1380
1381   if (log_get_errorcount(0))
1382     gpgsm_exit(1); /* must stop for invalid recipients */
1383   
1384   fname = argc? *argv : NULL;
1385   
1386   switch (cmd)
1387     {
1388     case aGPGConfList: 
1389       { /* List options and default values in the GPG Conf format.  */
1390
1391         /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1392         /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1393            FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1394 #define GC_OPT_FLAG_NONE        0UL
1395         /* The RUNTIME flag for an option indicates that the option can be
1396            changed at runtime.  */
1397 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
1398         /* The DEFAULT flag for an option indicates that the option has a
1399            default value.  */
1400 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1401         /* The DEF_DESC flag for an option indicates that the option has a
1402            default, which is described by the value of the default field.  */
1403 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1404         /* The NO_ARG_DESC flag for an option indicates that the argument has
1405            a default, which is described by the value of the ARGDEF field.  */
1406 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1407
1408         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1409                 GC_OPT_FLAG_DEFAULT, opt.config_filename);
1410         
1411         printf ("verbose:%lu:\n"
1412                 "quiet:%lu:\n"
1413                 "debug-level:%lu:\"none:\n"
1414                 "log-file:%lu:\n",
1415                 GC_OPT_FLAG_NONE,
1416                 GC_OPT_FLAG_NONE,
1417                 GC_OPT_FLAG_DEFAULT,
1418                 GC_OPT_FLAG_NONE );
1419         printf ("disable-crl-checks:%lu:\n",
1420                 GC_OPT_FLAG_NONE );
1421         printf ("disable-trusted-cert-crl-check:%lu:\n",
1422                 GC_OPT_FLAG_NONE );
1423         printf ("enable-ocsp:%lu:\n",
1424                 GC_OPT_FLAG_NONE );
1425         printf ("include-certs:%lu:1:\n",
1426                 GC_OPT_FLAG_DEFAULT );
1427         printf ("disable-policy-checks:%lu:\n",
1428                 GC_OPT_FLAG_NONE );
1429         printf ("auto-issuer-key-retrieve:%lu:\n",
1430                 GC_OPT_FLAG_NONE );
1431         printf ("prefer-system-dirmngr:%lu:\n",
1432                 GC_OPT_FLAG_NONE );
1433         printf ("cipher-algo:%lu:\"3DES:\n",
1434                 GC_OPT_FLAG_DEFAULT );
1435
1436       }
1437       break;
1438     case aGPGConfTest:
1439       /* This is merely a dummy command to test whether the
1440          configuration file is valid.  */
1441       break;
1442
1443     case aServer:
1444       if (debug_wait)
1445         {
1446           log_debug ("waiting for debugger - my pid is %u .....\n",
1447                      (unsigned int)getpid());
1448           sleep (debug_wait);
1449           log_debug ("... okay\n");
1450          }
1451       gpgsm_server (recplist);
1452       break;
1453
1454     case aCallDirmngr:
1455       if (!argc)
1456         wrong_args ("--call-dirmngr <command> {args}");
1457       else
1458         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1459           gpgsm_exit (1);
1460       break;
1461
1462     case aCallProtectTool:
1463       run_protect_tool (argc, argv);
1464       break;
1465
1466     case aEncr: /* Encrypt the given file. */
1467       {
1468         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1469
1470         set_binary (stdin);
1471
1472         if (!argc) /* Source is stdin. */
1473           gpgsm_encrypt (&ctrl, recplist, 0, fp); 
1474         else if (argc == 1)  /* Source is the given file. */
1475           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1476         else
1477           wrong_args ("--encrypt [datafile]");
1478
1479         if (fp != stdout)
1480           fclose (fp);
1481       }
1482       break;
1483
1484     case aSign: /* Sign the given file. */
1485       {
1486         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1487
1488         /* Fixme: We should also allow to concatenate multiple files for
1489            signing because that is what gpg does.*/
1490         set_binary (stdin);
1491         if (!argc) /* Create from stdin. */
1492           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp); 
1493         else if (argc == 1) /* From file. */
1494           gpgsm_sign (&ctrl, signerlist,
1495                       open_read (*argv), detached_sig, fp); 
1496         else
1497           wrong_args ("--sign [datafile]");
1498
1499         if (fp != stdout)
1500           fclose (fp);
1501       }
1502       break;
1503         
1504     case aSignEncr: /* sign and encrypt the given file */
1505       log_error ("this command has not yet been implemented\n");
1506       break;
1507
1508     case aClearsign: /* make a clearsig */
1509       log_error ("this command has not yet been implemented\n");
1510       break;
1511
1512     case aVerify:
1513       {
1514         FILE *fp = NULL;
1515
1516         set_binary (stdin);
1517         if (argc == 2 && opt.outfile)
1518           log_info ("option --output ignored for a detached signature\n");
1519         else if (opt.outfile)
1520           fp = open_fwrite (opt.outfile);
1521
1522         if (!argc)
1523           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1524         else if (argc == 1)
1525           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1526         else if (argc == 2) /* detached signature (sig, detached) */
1527           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1528         else
1529           wrong_args ("--verify [signature [detached_data]]");
1530
1531         if (fp && fp != stdout)
1532           fclose (fp);
1533       }
1534       break;
1535
1536     case aVerifyFiles:
1537       log_error (_("this command has not yet been implemented\n"));
1538       break;
1539
1540     case aDecrypt:
1541       {
1542         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1543
1544         set_binary (stdin);
1545         if (!argc)
1546           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1547         else if (argc == 1)
1548           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1549         else
1550           wrong_args ("--decrypt [filename]");
1551         if (fp != stdout)
1552           fclose (fp);
1553       }
1554       break;
1555
1556     case aDeleteKey:
1557       for (sl=NULL; argc; argc--, argv++)
1558         add_to_strlist (&sl, *argv);
1559       gpgsm_delete (&ctrl, sl);
1560       free_strlist(sl);
1561       break;
1562
1563     case aListChain:
1564     case aDumpChain:
1565        ctrl.with_chain = 1;
1566     case aListKeys:
1567     case aDumpKeys:
1568     case aListExternalKeys:
1569     case aDumpExternalKeys:
1570     case aListSecretKeys:
1571     case aDumpSecretKeys:
1572       {
1573         unsigned int mode;
1574         estream_t fp;
1575
1576         switch (cmd)
1577           {
1578           case aListChain:
1579           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1580           case aDumpChain: 
1581           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1582           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1583           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1584           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1585           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1586           default: BUG();
1587           }
1588
1589         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1590         for (sl=NULL; argc; argc--, argv++)
1591           add_to_strlist (&sl, *argv);
1592         gpgsm_list_keys (&ctrl, sl, fp, mode);
1593         free_strlist(sl);
1594         es_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, NULL);
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 /* Open FILENAME for fwrite and return an extended stream.  Stop with
1820    an error message in case of problems.  "-" denotes stdout and if
1821    special filenames are allowed the given fd is opened instead.
1822    Caller must close the returned stream. */
1823 static estream_t
1824 open_es_fwrite (const char *filename)
1825 {
1826   int fd;
1827   estream_t fp;
1828
1829   if (filename[0] == '-' && !filename[1])
1830     {
1831       fflush (stdout);
1832       fp = es_fdopen (dup (fileno(stdout)), "wb");
1833       return fp;
1834     }
1835
1836   fd = check_special_filename (filename);
1837   if (fd != -1)
1838     {
1839       fp = es_fdopen (dup (fd), "wb");
1840       if (!fp)
1841         {
1842           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
1843           gpgsm_exit (2);
1844         }
1845       return fp;
1846     }
1847   fp = es_fopen (filename, "wb");
1848   if (!fp)
1849     {
1850       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1851       gpgsm_exit (2);
1852     }
1853   return fp;
1854 }
1855
1856
1857 static void
1858 run_protect_tool (int argc, char **argv)
1859 {
1860 #ifndef HAVE_W32_SYSTEM
1861   const char *pgm;
1862   char **av;
1863   int i;
1864
1865   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1866     pgm = GNUPG_DEFAULT_PROTECT_TOOL;
1867   else
1868     pgm = opt.protect_tool_program;
1869
1870   av = xcalloc (argc+2, sizeof *av);
1871   av[0] = strrchr (pgm, '/');
1872   if (!av[0])
1873     av[0] = xstrdup (pgm);
1874   for (i=1; argc; i++, argc--, argv++)
1875     av[i] = *argv;
1876   av[i] = NULL;
1877   execv (pgm, av); 
1878   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1879 #endif /*HAVE_W32_SYSTEM*/
1880   gpgsm_exit (2);
1881 }