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