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