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