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