Fix for bug 537
[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 #ifdef USE_GNU_PTH
32 # include <pth.h>
33 #endif
34
35 #include "gpgsm.h"
36 #include <gcrypt.h>
37 #include <assuan.h> /* malloc hooks */
38
39 #include "../kbx/keybox.h" /* malloc hooks */
40 #include "i18n.h"
41 #include "keydb.h"
42 #include "sysutils.h"
43
44
45 #ifndef O_BINARY
46 #define O_BINARY 0
47 #endif
48
49 enum cmd_and_opt_values {
50   aNull = 0,
51   oArmor        = 'a',
52   aDetachedSign = 'b',
53   aSym          = 'c',
54   aDecrypt      = 'd',
55   aEncr         = 'e',
56   oInteractive  = 'i',
57   aListKeys     = 'k',
58   aListSecretKeys = 'K',
59   oDryRun       = 'n',
60   oOutput       = 'o',
61   oQuiet        = 'q',
62   oRecipient    = 'r',
63   aSign         = 's',
64   oTextmodeShort= 't',
65   oUser         = 'u',
66   oVerbose      = 'v',
67   oCompress     = 'z',
68   oNotation     = 'N',
69   oBatch        = 500,
70   aClearsign,
71   aStore,
72   aKeygen,
73   aSignEncr,
74   aSignKey,
75   aLSignKey,
76   aListPackets,
77   aEditKey,
78   aDeleteKey,
79   aImport,
80   aVerify,
81   aVerifyFiles,
82   aListExternalKeys,
83   aListChain,
84   aSendKeys,
85   aRecvKeys,
86   aExport,
87   aExportSecretKeyP12,
88   aCheckKeys, /* nyi */
89   aServer,                        
90   aLearnCard,
91   aCallDirmngr,
92   aCallProtectTool,
93   aPasswd,
94   aGPGConfList,
95   aDumpKeys,
96   aDumpChain,
97   aDumpSecretKeys,
98   aDumpExternalKeys,
99   aKeydbClearSomeCertFlags,
100
101   oOptions,
102   oDebug,
103   oDebugLevel,
104   oDebugAll,
105   oDebugNone,
106   oDebugWait,
107   oDebugAllowCoreDump,
108   oDebugNoChainValidation,
109   oDebugIgnoreExpiration,
110   oFixedPassphrase,
111   oLogFile,
112   oNoLogFile,
113
114   oEnableSpecialFilenames,
115
116   oAgentProgram,
117   oDisplay,
118   oTTYname,
119   oTTYtype,
120   oLCctype,
121   oLCmessages,
122
123   oPreferSystemDirmngr,
124   oDirmngrProgram,
125   oProtectToolProgram,
126   oFakedSystemTime,
127
128
129   oAssumeArmor,
130   oAssumeBase64,
131   oAssumeBinary,
132
133   oBase64,
134   oNoArmor,
135
136   oDisableCRLChecks,
137   oEnableCRLChecks,
138   oDisableTrustedCertCRLCheck,
139   oEnableTrustedCertCRLCheck,
140   oForceCRLRefresh,
141
142   oDisableOCSP,
143   oEnableOCSP,
144
145   oIncludeCerts,
146   oPolicyFile,
147   oDisablePolicyChecks,
148   oEnablePolicyChecks,
149   oAutoIssuerKeyRetrieve,
150   
151
152   oTextmode,
153   oFingerprint,
154   oWithFingerprint,
155   oWithMD5Fingerprint,
156   oAnswerYes,
157   oAnswerNo,
158   oKeyring,
159   oSecretKeyring,
160   oDefaultKey,
161   oDefRecipient,
162   oDefRecipientSelf,
163   oNoDefRecipient,
164   oStatusFD,
165   oNoComment,
166   oNoVersion,
167   oEmitVersion,
168   oCompletesNeeded,
169   oMarginalsNeeded,
170   oMaxCertDepth,
171   oLoadExtension,
172   oRFC1991,
173   oOpenPGP,
174   oCipherAlgo,
175   oDigestAlgo,
176   oCompressAlgo,
177   oCommandFD,
178   oNoVerbose,
179   oTrustDBName,
180   oNoSecmemWarn,
181   oNoDefKeyring,
182   oNoGreeting,
183   oNoTTY,
184   oNoOptions,
185   oNoBatch,
186   oHomedir,
187   oWithColons,
188   oWithKeyData,
189   oWithValidation,
190   oWithEphemeralKeys,
191   oSkipVerify,
192   oCompressKeys,
193   oCompressSigs,
194   oAlwaysTrust,
195   oRunAsShmCP,
196   oSetFilename,
197   oSetPolicyURL,
198   oUseEmbeddedFilename,
199   oComment,
200   oDefaultComment,
201   oThrowKeyid,
202   oForceV3Sigs,
203   oForceMDC,
204   oS2KMode,
205   oS2KDigest,
206   oS2KCipher,
207   oCharset,
208   oNotDashEscaped,
209   oEscapeFrom,
210   oLockOnce,
211   oLockMultiple,
212   oLockNever,
213   oKeyServer,
214   oEncryptTo,
215   oNoEncryptTo,
216   oLoggerFD,
217   oUtf8Strings,
218   oNoUtf8Strings,
219   oDisableCipherAlgo,
220   oDisablePubkeyAlgo,
221   oAllowNonSelfsignedUID,
222   oAllowFreeformUID,
223   oNoLiteral,
224   oSetFilesize,
225   oHonorHttpProxy,
226   oFastListMode,
227   oListOnly,
228   oIgnoreTimeConflict,
229   oNoRandomSeedFile,
230   oNoAutoKeyRetrieve,
231   oUseAgent,
232   oMergeOnly,
233   oTryAllSecrets,
234   oTrustedKey,
235   oEmuMDEncodeBug,
236   aDummy
237  };
238
239
240 static ARGPARSE_OPTS opts[] = {
241
242     { 300, NULL, 0, N_("@Commands:\n ") },
243
244     { aSign, "sign",      256, N_("|[FILE]|make a signature")},
245     { aClearsign, "clearsign", 256, N_("|[FILE]|make a clear text signature") },
246     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
247     { aEncr, "encrypt",   256, N_("encrypt data")},
248     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
249     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
250     { aVerify, "verify"   , 256, N_("verify a signature")},
251     { aVerifyFiles, "verify-files" , 256, "@" },
252     { aListKeys, "list-keys", 256, N_("list keys")},
253     { aListExternalKeys, "list-external-keys", 256, N_("list external keys")},
254     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
255     { aListChain,   "list-chain",  256, N_("list certificate chain")}, 
256     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
257     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
258     { aDeleteKey, "delete-key",256, N_("remove key from the public keyring")},
259     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
260     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
261     { aImport, "import",      256     , N_("import certificates")},
262     { aExport, "export",      256     , N_("export certificates")},
263     { aLearnCard, "learn-card", 256 ,N_("register a smartcard")},
264     { aServer, "server",      256, N_("run in server mode")},
265     { aCallDirmngr, "call-dirmngr", 256, N_("pass a command to the dirmngr")},
266     { aCallProtectTool, "call-protect-tool", 256,
267                                    N_("invoke gpg-protect-tool")},
268     { aPasswd, "passwd",      256, N_("change a passphrase")},
269     { aGPGConfList, "gpgconf-list", 256, "@" },
270
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 #ifdef HAVE_W32_SYSTEM
777   /* For W32 we need pth.  */
778   pth_init ();
779 #endif
780
781
782   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
783
784   may_coredump = disable_core_dumps ();
785   
786   gnupg_init_signals (0, emergency_cleanup);
787   
788   create_dotlock (NULL); /* register locking cleanup */
789   i18n_init();
790
791   opt.def_cipher_algoid = "1.2.840.113549.3.7";  /*des-EDE3-CBC*/
792
793   opt.homedir = default_homedir ();
794 #ifdef HAVE_W32_SYSTEM
795   opt.no_crl_check = 1;
796 #endif
797
798   /* First check whether we have a config file on the commandline */
799   orig_argc = argc;
800   orig_argv = argv;
801   pargs.argc = &argc;
802   pargs.argv = &argv;
803   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
804   while (arg_parse( &pargs, opts))
805     {
806       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
807         parse_debug++;
808       else if (pargs.r_opt == oOptions)
809         { /* yes there is one, so we do not try the default one but
810              read the config file when it is encountered at the
811              commandline */
812           default_config = 0;
813         }
814       else if (pargs.r_opt == oNoOptions)
815         default_config = 0; /* --no-options */
816       else if (pargs.r_opt == oHomedir)
817         opt.homedir = pargs.r.ret_str;
818       else if (pargs.r_opt == aCallProtectTool)
819         break; /* This break makes sure that --version and --help are
820                   passed to the protect-tool. */
821     }
822   
823   
824   /* initialize the secure memory. */
825   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
826   maybe_setuid = 0;
827
828   /* 
829      Now we are now working under our real uid 
830   */
831
832   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
833
834   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
835   assuan_set_assuan_log_stream (log_get_stream ());
836   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
837   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
838
839   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
840
841   /* Setup a default control structure for command line mode */
842   memset (&ctrl, 0, sizeof ctrl);
843   gpgsm_init_default_ctrl (&ctrl);
844   ctrl.no_server = 1;
845   ctrl.status_fd = -1; /* not status output */
846   ctrl.autodetect_encoding = 1;
847
848   /* Set the default option file */
849   if (default_config )
850     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
851   /* Set the default policy file */
852   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
853   
854   argc        = orig_argc;
855   argv        = orig_argv;
856   pargs.argc  = &argc;
857   pargs.argv  = &argv;
858   pargs.flags =  1;  /* do not remove the args */
859
860  next_pass:
861   if (configname) {
862     configlineno = 0;
863     configfp = fopen (configname, "r");
864     if (!configfp)
865       {
866         if (default_config)
867           {
868             if (parse_debug)
869               log_info (_("NOTE: no default option file `%s'\n"), configname);
870           }
871         else 
872           {
873             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
874             gpgsm_exit(2);
875           }
876         xfree(configname);
877         configname = NULL;
878       }
879     if (parse_debug && configname)
880       log_info (_("reading options from `%s'\n"), configname);
881     default_config = 0;
882   }
883
884   while (!no_more_options 
885          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
886     {
887       switch (pargs.r_opt)
888         {
889         case aGPGConfList: 
890           set_cmd (&cmd, pargs.r_opt);
891           do_not_setup_keys = 1;
892           nogreeting = 1;
893           break;
894
895         case aServer: 
896           opt.batch = 1;
897           set_cmd (&cmd, aServer);
898           break;
899
900         case aCallDirmngr:
901           opt.batch = 1;
902           set_cmd (&cmd, aCallDirmngr);
903           do_not_setup_keys = 1;
904           break;
905
906         case aCallProtectTool:
907           opt.batch = 1;
908           set_cmd (&cmd, aCallProtectTool);
909           no_more_options = 1; /* Stop parsing. */
910           do_not_setup_keys = 1;
911           break;
912         
913         case aDeleteKey:
914           set_cmd (&cmd, aDeleteKey);
915           /*greeting=1;*/
916           do_not_setup_keys = 1;
917           break;
918
919         case aDetachedSign:
920           detached_sig = 1;
921           set_cmd (&cmd, aSign ); 
922           break;
923
924         case aKeygen:
925           set_cmd (&cmd, aKeygen);
926           greeting=1; 
927           do_not_setup_keys = 1;
928           break;
929
930         case aCheckKeys:
931         case aImport: 
932         case aSendKeys: 
933         case aRecvKeys: 
934         case aExport: 
935         case aExportSecretKeyP12: 
936         case aDumpKeys:
937         case aDumpChain:
938         case aDumpExternalKeys: 
939         case aDumpSecretKeys: 
940         case aListKeys:
941         case aListExternalKeys: 
942         case aListSecretKeys: 
943         case aListChain: 
944         case aLearnCard: 
945         case aPasswd: 
946         case aKeydbClearSomeCertFlags:
947           do_not_setup_keys = 1;
948           set_cmd (&cmd, pargs.r_opt);
949           break;
950
951         case aSym:
952         case aDecrypt: 
953         case aEncr: 
954         case aSign: 
955         case aClearsign: 
956         case aVerify: 
957           set_cmd (&cmd, pargs.r_opt);
958           break;
959
960           /* output encoding selection */
961         case oArmor:
962           ctrl.create_pem = 1;
963           break;
964         case oBase64: 
965           ctrl.create_pem = 0;
966           ctrl.create_base64 = 1;
967           break;
968         case oNoArmor: 
969           ctrl.create_pem = 0;
970           ctrl.create_base64 = 0;
971           break;
972           
973           /* Input encoding selection */
974         case oAssumeArmor:
975           ctrl.autodetect_encoding = 0;
976           ctrl.is_pem = 1;
977           ctrl.is_base64 = 0;
978           break;
979         case oAssumeBase64:
980           ctrl.autodetect_encoding = 0;
981           ctrl.is_pem = 0;
982           ctrl.is_base64 = 1;
983           break;
984         case oAssumeBinary:
985           ctrl.autodetect_encoding = 0;
986           ctrl.is_pem = 0;
987           ctrl.is_base64 = 0;
988           break;
989
990         case oDisableCRLChecks:
991           opt.no_crl_check = 1;
992           break;
993         case oEnableCRLChecks:
994           opt.no_crl_check = 0;
995           break;
996         case oDisableTrustedCertCRLCheck:
997           opt.no_trusted_cert_crl_check = 1;
998           break;
999         case oEnableTrustedCertCRLCheck:
1000           opt.no_trusted_cert_crl_check = 0;
1001           break;
1002         case oForceCRLRefresh:
1003           opt.force_crl_refresh = 1;
1004           break;
1005
1006         case oDisableOCSP:
1007           ctrl.use_ocsp = opt.enable_ocsp = 0;
1008           break;
1009         case oEnableOCSP:
1010           ctrl.use_ocsp = opt.enable_ocsp = 1;
1011           break;
1012
1013         case oIncludeCerts: 
1014           ctrl.include_certs = default_include_certs = pargs.r.ret_int; 
1015           break;
1016
1017         case oPolicyFile:
1018           xfree (opt.policy_file);
1019           if (*pargs.r.ret_str)
1020             opt.policy_file = xstrdup (pargs.r.ret_str);
1021           else
1022             opt.policy_file = NULL;
1023           break;
1024
1025         case oDisablePolicyChecks:
1026           opt.no_policy_check = 1;
1027           break;
1028         case oEnablePolicyChecks:
1029           opt.no_policy_check = 0;
1030           break;
1031           
1032         case oAutoIssuerKeyRetrieve:
1033           opt.auto_issuer_key_retrieve = 1;
1034           break;
1035
1036         case oOutput: opt.outfile = pargs.r.ret_str; break;
1037
1038         
1039         case oQuiet: opt.quiet = 1; break;
1040         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1041         case oDryRun: opt.dry_run = 1; break;
1042
1043         case oVerbose:
1044           opt.verbose++;
1045           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1046           break;
1047         case oNoVerbose:
1048           opt.verbose = 0;
1049           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1050           break;
1051
1052         case oLogFile: logfile = pargs.r.ret_str; break;
1053         case oNoLogFile: logfile = NULL; break;          
1054
1055         case oBatch: 
1056           opt.batch = 1;
1057           greeting = 0;
1058           break;
1059         case oNoBatch: opt.batch = 0; break;
1060           
1061         case oAnswerYes: opt.answer_yes = 1; break;
1062         case oAnswerNo: opt.answer_no = 1; break;
1063
1064         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1065
1066         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1067         case oDebugAll: debug_value = ~0; break;
1068         case oDebugNone: debug_value = 0; break;
1069         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1070         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1071         case oDebugAllowCoreDump:
1072           may_coredump = enable_core_dumps ();
1073           break;
1074         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1075         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1076         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1077
1078         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1079         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1080         case oWithMD5Fingerprint:
1081           opt.with_md5_fingerprint=1; /*fall thru*/
1082         case oWithFingerprint:
1083           with_fpr=1; /*fall thru*/
1084         case oFingerprint:
1085           opt.fingerprint++;
1086           break;
1087
1088         case oOptions:
1089           /* config files may not be nested (silently ignore them) */
1090           if (!configfp)
1091             {
1092               xfree(configname);
1093               configname = xstrdup (pargs.r.ret_str);
1094               goto next_pass;
1095             }
1096           break;
1097         case oNoOptions: break; /* no-options */
1098         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1099         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1100         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
1101         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
1102         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
1103         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1104         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1105         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1106         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1107         case oProtectToolProgram:
1108           opt.protect_tool_program = pargs.r.ret_str; 
1109           break;
1110           
1111         case oFakedSystemTime:
1112           gnupg_set_time ( (time_t)pargs.r.ret_ulong, 0);
1113           break;
1114
1115         case oNoDefKeyring: default_keyring = 0; break;
1116         case oNoGreeting: nogreeting = 1; break;
1117
1118         case oDefaultKey:
1119           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
1120           log_info ("WARNING: --default-key has not yet been implemented\n");
1121           break;
1122         case oDefRecipient:
1123           if (*pargs.r.ret_str)
1124             opt.def_recipient = xstrdup (pargs.r.ret_str);
1125           break;
1126         case oDefRecipientSelf:
1127           xfree (opt.def_recipient);
1128           opt.def_recipient = NULL;
1129           opt.def_recipient_self = 1;
1130           break;
1131         case oNoDefRecipient:
1132           xfree (opt.def_recipient);
1133           opt.def_recipient = NULL;
1134           opt.def_recipient_self = 0;
1135           break;
1136
1137         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1138         case oWithColons: ctrl.with_colons = 1; break;
1139         case oWithValidation: ctrl.with_validation=1; break;
1140         case oWithEphemeralKeys: opt.with_ephemeral_keys=1; break;
1141
1142         case oSkipVerify: opt.skip_verify=1; break;
1143
1144         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1145         case oEncryptTo: /* Store the recipient in the second list */
1146           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1147           sl->flags = 1;
1148           break;
1149
1150         case oRecipient: /* store the recipient */
1151           add_to_strlist ( &remusr, pargs.r.ret_str);
1152           break;
1153
1154         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
1155         case oTextmode: /*fixme:opt.textmode=1;*/  break;
1156
1157         case oUser: /* store the local users, the first one is the default */
1158           if (!opt.local_user)
1159             opt.local_user = pargs.r.ret_str;
1160           add_to_strlist (&locusr, pargs.r.ret_str);
1161           break;
1162
1163         case oNoSecmemWarn:
1164           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1165           break;
1166
1167         case oCipherAlgo:
1168           opt.def_cipher_algoid = pargs.r.ret_str;
1169           break;
1170
1171         case oDisableCipherAlgo: 
1172           {
1173             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1174             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1175           }
1176           break;
1177         case oDisablePubkeyAlgo: 
1178           {
1179             int algo = gcry_pk_map_name (pargs.r.ret_str);
1180             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1181           }
1182           break;
1183
1184         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1185         case oNoRandomSeedFile: use_random_seed = 0; break;
1186
1187         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1188           
1189
1190         case aDummy:
1191           break;
1192         default: 
1193           pargs.err = configfp? 1:2; 
1194           break;
1195         }
1196     }
1197
1198   if (configfp)
1199     {
1200       fclose (configfp);
1201       configfp = NULL;
1202       /* Keep a copy of the config filename. */
1203       opt.config_filename = configname;
1204       configname = NULL;
1205       goto next_pass;
1206     }
1207   xfree (configname);
1208   configname = NULL;
1209
1210   if (!opt.config_filename)
1211     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1212
1213   if (log_get_errorcount(0))
1214     gpgsm_exit(2);
1215   
1216   if (nogreeting)
1217     greeting = 0;
1218   
1219   if (greeting)
1220     {
1221       fprintf(stderr, "%s %s; %s\n",
1222               strusage(11), strusage(13), strusage(14) );
1223       fprintf(stderr, "%s\n", strusage(15) );
1224     }
1225 #  ifdef IS_DEVELOPMENT_VERSION
1226   if (!opt.batch)
1227     {
1228       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1229       log_info ("It is only intended for test purposes and should NOT be\n");
1230       log_info ("used in a production environment or with production keys!\n");
1231     }
1232 #  endif
1233
1234   if (may_coredump && !opt.quiet)
1235     log_info (_("WARNING: program may create a core file!\n"));
1236
1237 /*   if (opt.qualsig_approval && !opt.quiet) */
1238 /*     log_info (_("This software has offically been approved to " */
1239 /*                 "create and verify\n" */
1240 /*                 "qualified signatures according to German law.\n")); */
1241
1242   if (logfile && cmd == aServer)
1243     {
1244       log_set_file (logfile);
1245       log_set_prefix (NULL, 1|2|4);
1246     }
1247
1248   if (gnupg_faked_time_p ())
1249     {
1250       gnupg_isotime_t tbuf;
1251
1252       log_info (_("WARNING: running with faked system time: "));
1253       gnupg_get_isotime (tbuf);
1254       gpgsm_dump_time (tbuf);
1255       log_printf ("\n");
1256     }
1257   
1258 /*FIXME    if (opt.batch) */
1259 /*      tty_batchmode (1); */
1260
1261   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1262
1263   set_debug ();
1264
1265   /* Although we alwasy use gpgsm_exit, we better install a regualr
1266      exit handler so that at least the secure memory gets wiped
1267      out. */
1268   if (atexit (emergency_cleanup))
1269     {
1270       log_error ("atexit failed\n");
1271       gpgsm_exit (2);
1272     }
1273
1274   /* Must do this after dropping setuid, because the mapping functions
1275      may try to load an module and we may have disabled an algorithm. */
1276   if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1277        || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1278     log_error (_("selected cipher algorithm is invalid\n"));
1279
1280   if (def_digest_string)
1281     {
1282       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1283       xfree (def_digest_string);
1284       def_digest_string = NULL;
1285       if (our_md_test_algo(opt.def_digest_algo) )
1286         log_error (_("selected digest algorithm is invalid\n"));
1287     }
1288
1289   if (log_get_errorcount(0))
1290     gpgsm_exit(2);
1291   
1292   /* Set the random seed file. */
1293   if (use_random_seed) {
1294     char *p = make_filename (opt.homedir, "random_seed", NULL);
1295     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1296     xfree(p);
1297   }
1298
1299
1300   if (!cmd && opt.fingerprint && !with_fpr)
1301     set_cmd (&cmd, aListKeys);
1302   
1303   if (!nrings && default_keyring)  /* Add default keybox. */
1304     {
1305       int created;
1306
1307       keydb_add_resource ("pubring.kbx", 0, 0, &created);
1308       if (created)
1309         {
1310           /* Import the standard certificates for a new default keybox. */
1311           char *filelist[2];
1312           
1313           filelist[0] = make_filename (GNUPG_DATADIR, "com-certs.pem", NULL);
1314           filelist[1] = NULL;
1315           if (!access (filelist[0], F_OK))
1316             {
1317               log_info (_("importing common certificates `%s'\n"),
1318                         filelist[0]);
1319               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1320             }
1321           xfree (filelist[0]);
1322         }
1323     }
1324   for (sl = nrings; sl; sl = sl->next)
1325     keydb_add_resource (sl->d, 0, 0, NULL);
1326   FREE_STRLIST(nrings);
1327
1328   if (!do_not_setup_keys)
1329     {
1330       for (sl = locusr; sl ; sl = sl->next)
1331         {
1332           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1333           if (rc)
1334             {
1335               log_error (_("can't sign using `%s': %s\n"),
1336                          sl->d, gpg_strerror (rc));
1337               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1338                          gpg_err_code (rc) == -1?                      "1":
1339                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1340                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1341                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1342                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1343                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1344                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1345                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1346                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1347                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1348                          "0",
1349                          sl->d, NULL);
1350             }
1351         }
1352       
1353       /* Build the recipient list.  We first add the regular ones and then
1354          the encrypt-to ones because the underlying function will silenty
1355          ignore duplicates and we can't allow to keep a duplicate which is
1356          flagged as encrypt-to as the actually encrypt function would then
1357          complain about no (regular) recipients. */
1358       for (sl = remusr; sl; sl = sl->next)
1359         if (!(sl->flags & 1))
1360           do_add_recipient (&ctrl, sl->d, &recplist, 0);
1361       if (!opt.no_encrypt_to)
1362         {
1363           for (sl = remusr; sl; sl = sl->next)
1364             if ((sl->flags & 1))
1365               do_add_recipient (&ctrl, sl->d, &recplist, 1);
1366         }
1367     }
1368
1369   if (log_get_errorcount(0))
1370     gpgsm_exit(1); /* must stop for invalid recipients */
1371   
1372   fname = argc? *argv : NULL;
1373   
1374   switch (cmd)
1375     {
1376     case aGPGConfList: 
1377       { /* List options and default values in the GPG Conf format.  */
1378
1379         /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1380         /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1381            FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1382 #define GC_OPT_FLAG_NONE        0UL
1383         /* The RUNTIME flag for an option indicates that the option can be
1384            changed at runtime.  */
1385 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
1386         /* The DEFAULT flag for an option indicates that the option has a
1387            default value.  */
1388 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1389         /* The DEF_DESC flag for an option indicates that the option has a
1390            default, which is described by the value of the default field.  */
1391 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1392         /* The NO_ARG_DESC flag for an option indicates that the argument has
1393            a default, which is described by the value of the ARGDEF field.  */
1394 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1395
1396         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1397                 GC_OPT_FLAG_DEFAULT, opt.config_filename);
1398         
1399         printf ("verbose:%lu:\n"
1400                 "quiet:%lu:\n"
1401                 "debug-level:%lu:\"none:\n"
1402                 "log-file:%lu:\n",
1403                 GC_OPT_FLAG_NONE,
1404                 GC_OPT_FLAG_NONE,
1405                 GC_OPT_FLAG_DEFAULT,
1406                 GC_OPT_FLAG_NONE );
1407         printf ("disable-crl-checks:%lu:\n",
1408                 GC_OPT_FLAG_NONE );
1409         printf ("disable-trusted-cert-crl-check:%lu:\n",
1410                 GC_OPT_FLAG_NONE );
1411         printf ("enable-ocsp:%lu:\n",
1412                 GC_OPT_FLAG_NONE );
1413         printf ("include-certs:%lu:1:\n",
1414                 GC_OPT_FLAG_DEFAULT );
1415         printf ("disable-policy-checks:%lu:\n",
1416                 GC_OPT_FLAG_NONE );
1417         printf ("auto-issuer-key-retrieve:%lu:\n",
1418                 GC_OPT_FLAG_NONE );
1419         printf ("prefer-system-dirmngr:%lu:\n",
1420                 GC_OPT_FLAG_NONE );
1421
1422       }
1423       break;
1424
1425     case aServer:
1426       if (debug_wait)
1427         {
1428           log_debug ("waiting for debugger - my pid is %u .....\n",
1429                      (unsigned int)getpid());
1430           sleep (debug_wait);
1431           log_debug ("... okay\n");
1432          }
1433       gpgsm_server (recplist);
1434       break;
1435
1436     case aCallDirmngr:
1437       if (!argc)
1438         wrong_args ("--call-dirmngr <command> {args}");
1439       else
1440         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1441           gpgsm_exit (1);
1442       break;
1443
1444     case aCallProtectTool:
1445       run_protect_tool (argc, argv);
1446       break;
1447
1448     case aEncr: /* Encrypt the given file. */
1449       {
1450         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1451
1452         set_binary (stdin);
1453
1454         if (!argc) /* Source is stdin. */
1455           gpgsm_encrypt (&ctrl, recplist, 0, fp); 
1456         else if (argc == 1)  /* Source is the given file. */
1457           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1458         else
1459           wrong_args ("--encrypt [datafile]");
1460
1461         if (fp != stdout)
1462           fclose (fp);
1463       }
1464       break;
1465
1466     case aSign: /* Sign the given file. */
1467       {
1468         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1469
1470         /* Fixme: We should also allow to concatenate multiple files for
1471            signing because that is what gpg does.*/
1472         set_binary (stdin);
1473         if (!argc) /* Create from stdin. */
1474           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp); 
1475         else if (argc == 1) /* From file. */
1476           gpgsm_sign (&ctrl, signerlist,
1477                       open_read (*argv), detached_sig, fp); 
1478         else
1479           wrong_args ("--sign [datafile]");
1480
1481         if (fp != stdout)
1482           fclose (fp);
1483       }
1484       break;
1485         
1486     case aSignEncr: /* sign and encrypt the given file */
1487       log_error ("this command has not yet been implemented\n");
1488       break;
1489
1490     case aClearsign: /* make a clearsig */
1491       log_error ("this command has not yet been implemented\n");
1492       break;
1493
1494     case aVerify:
1495       {
1496         FILE *fp = NULL;
1497
1498         set_binary (stdin);
1499         if (argc == 2 && opt.outfile)
1500           log_info ("option --output ignored for a detached signature\n");
1501         else if (opt.outfile)
1502           fp = open_fwrite (opt.outfile);
1503
1504         if (!argc)
1505           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1506         else if (argc == 1)
1507           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1508         else if (argc == 2) /* detached signature (sig, detached) */
1509           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1510         else
1511           wrong_args ("--verify [signature [detached_data]]");
1512
1513         if (fp && fp != stdout)
1514           fclose (fp);
1515       }
1516       break;
1517
1518     case aVerifyFiles:
1519       log_error (_("this command has not yet been implemented\n"));
1520       break;
1521
1522     case aDecrypt:
1523       {
1524         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1525
1526         set_binary (stdin);
1527         if (!argc)
1528           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1529         else if (argc == 1)
1530           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1531         else
1532           wrong_args ("--decrypt [filename]");
1533         if (fp != stdout)
1534           fclose (fp);
1535       }
1536       break;
1537
1538     case aDeleteKey:
1539       for (sl=NULL; argc; argc--, argv++)
1540         add_to_strlist (&sl, *argv);
1541       gpgsm_delete (&ctrl, sl);
1542       free_strlist(sl);
1543       break;
1544
1545     case aListChain:
1546     case aDumpChain:
1547        ctrl.with_chain = 1;
1548     case aListKeys:
1549     case aDumpKeys:
1550     case aListExternalKeys:
1551     case aDumpExternalKeys:
1552     case aListSecretKeys:
1553     case aDumpSecretKeys:
1554       {
1555         unsigned int mode;
1556         FILE *fp;
1557
1558         switch (cmd)
1559           {
1560           case aListChain:
1561           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1562           case aDumpChain: 
1563           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1564           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1565           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1566           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1567           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1568           default: BUG();
1569           }
1570
1571         fp = open_fwrite (opt.outfile?opt.outfile:"-");
1572         for (sl=NULL; argc; argc--, argv++)
1573           add_to_strlist (&sl, *argv);
1574         gpgsm_list_keys (&ctrl, sl, fp, mode);
1575         free_strlist(sl);
1576         if (fp != stdout)
1577           fclose (fp);
1578       }
1579       break;
1580
1581
1582     case aKeygen: /* generate a key */
1583       log_error ("this function is not yet available from the commandline\n");
1584       break;
1585
1586     case aImport:
1587       gpgsm_import_files (&ctrl, argc, argv, open_read);
1588       break;
1589
1590     case aExport:
1591       {
1592         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1593
1594         for (sl=NULL; argc; argc--, argv++)
1595           add_to_strlist (&sl, *argv);
1596         gpgsm_export (&ctrl, sl, fp);
1597         free_strlist(sl);
1598         if (fp != stdout)
1599           fclose (fp);
1600       }
1601       break;
1602
1603     case aExportSecretKeyP12:
1604       {
1605         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1606
1607         if (argc == 1)
1608           gpgsm_p12_export (&ctrl, *argv, stdout);
1609         else
1610           wrong_args ("--export-secret-key-p12 KEY-ID");
1611         if (fp != stdout)
1612           fclose (fp);
1613       }
1614       break;
1615       
1616     case aSendKeys:
1617     case aRecvKeys:
1618       log_error ("this command has not yet been implemented\n");
1619       break;
1620
1621
1622     case aLearnCard:
1623       if (argc)
1624         wrong_args ("--learn-card");
1625       else
1626         {
1627           int rc = gpgsm_agent_learn (&ctrl);
1628           if (rc)
1629             log_error ("error learning card: %s\n", gpg_strerror (rc));
1630         }
1631       break;
1632
1633     case aPasswd:
1634       if (argc != 1)
1635         wrong_args ("--passwd <key-Id>");
1636       else
1637         {
1638           int rc;
1639           ksba_cert_t cert = NULL;
1640           char *grip = NULL;
1641
1642           rc = gpgsm_find_cert (*argv, NULL, &cert);
1643           if (rc)
1644             ;
1645           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1646             rc = gpg_error (GPG_ERR_BUG);
1647           else 
1648             {
1649               char *desc = gpgsm_format_keydesc (cert);
1650               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1651               xfree (desc);
1652             }
1653           if (rc)
1654             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1655           xfree (grip);
1656           ksba_cert_release (cert);
1657         }
1658       break;
1659
1660     case aKeydbClearSomeCertFlags:
1661       for (sl=NULL; argc; argc--, argv++)
1662         add_to_strlist (&sl, *argv);
1663       keydb_clear_some_cert_flags (&ctrl, sl);
1664       free_strlist(sl);
1665       break;
1666
1667
1668     default:
1669         log_error ("invalid command (there is no implicit command)\n");
1670         break;
1671     }
1672   
1673   /* cleanup */
1674   gpgsm_release_certlist (recplist);
1675   gpgsm_release_certlist (signerlist);
1676   FREE_STRLIST (remusr);
1677   FREE_STRLIST (locusr);
1678   gpgsm_exit(0);
1679   return 8; /*NOTREACHED*/
1680 }
1681
1682 /* Note: This function is used by signal handlers!. */
1683 static void
1684 emergency_cleanup (void)
1685 {
1686   gcry_control (GCRYCTL_TERM_SECMEM );
1687 }
1688
1689
1690 void
1691 gpgsm_exit (int rc)
1692 {
1693   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1694   if (opt.debug & DBG_MEMSTAT_VALUE)
1695     {
1696       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1697       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1698     }
1699   if (opt.debug)
1700     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1701   emergency_cleanup ();
1702   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1703   exit (rc);
1704 }
1705
1706
1707 void
1708 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1709 {
1710   ctrl->include_certs = default_include_certs;
1711   ctrl->use_ocsp = opt.enable_ocsp;
1712 }
1713
1714
1715
1716 /* Check whether the filename has the form "-&nnnn", where n is a
1717    non-zero number.  Returns this number or -1 if it is not the case.  */
1718 static int
1719 check_special_filename (const char *fname)
1720 {
1721   if (allow_special_filenames
1722       && fname && *fname == '-' && fname[1] == '&' ) {
1723     int i;
1724     
1725     fname += 2;
1726     for (i=0; isdigit (fname[i]); i++ )
1727       ;
1728     if ( !fname[i] ) 
1729       return atoi (fname);
1730   }
1731   return -1;
1732 }
1733
1734
1735
1736 /* Open the FILENAME for read and return the filedescriptor.  Stop
1737    with an error message in case of problems.  "-" denotes stdin and
1738    if special filenames are allowed the given fd is opened instead. */
1739 static int 
1740 open_read (const char *filename)
1741 {
1742   int fd;
1743
1744   if (filename[0] == '-' && !filename[1])
1745     {
1746       set_binary (stdin);
1747       return 0; /* stdin */
1748     }
1749   fd = check_special_filename (filename);
1750   if (fd != -1)
1751     return fd;
1752   fd = open (filename, O_RDONLY | O_BINARY);
1753   if (fd == -1)
1754     {
1755       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1756       gpgsm_exit (2);
1757     }
1758   return fd;
1759 }
1760
1761 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1762    message in case of problems.  "-" denotes stdout and if special
1763    filenames are allowed the given fd is opened instead. Caller must
1764    close the returned stream unless it is stdout. */
1765 static FILE *
1766 open_fwrite (const char *filename)
1767 {
1768   int fd;
1769   FILE *fp;
1770
1771   if (filename[0] == '-' && !filename[1])
1772     {
1773       set_binary (stdout);
1774       return stdout;
1775     }
1776
1777   fd = check_special_filename (filename);
1778   if (fd != -1)
1779     {
1780       fp = fdopen (dup (fd), "wb");
1781       if (!fp)
1782         {
1783           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1784           gpgsm_exit (2);
1785         }
1786       set_binary (fp);
1787       return fp;
1788     }
1789   fp = fopen (filename, "wb");
1790   if (!fp)
1791     {
1792       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1793       gpgsm_exit (2);
1794     }
1795   return fp;
1796 }
1797
1798
1799 static void
1800 run_protect_tool (int argc, char **argv)
1801 {
1802 #ifndef HAVE_W32_SYSTEM
1803   const char *pgm;
1804   char **av;
1805   int i;
1806
1807   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1808     pgm = GNUPG_DEFAULT_PROTECT_TOOL;
1809   else
1810     pgm = opt.protect_tool_program;
1811
1812   av = xcalloc (argc+2, sizeof *av);
1813   av[0] = strrchr (pgm, '/');
1814   if (!av[0])
1815     av[0] = xstrdup (pgm);
1816   for (i=1; argc; i++, argc--, argv++)
1817     av[i] = *argv;
1818   av[i] = NULL;
1819   execv (pgm, av); 
1820   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1821 #endif /*HAVE_W32_SYSTEM*/
1822   gpgsm_exit (2);
1823 }