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