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