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