709263cba3909be42001ce13a43a7e90025e8098
[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   /* For W32 we need pth.  */
744   pth_init ();
745 #endif
746
747
748   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
749
750   may_coredump = disable_core_dumps ();
751   
752   gnupg_init_signals (0, emergency_cleanup);
753   
754   create_dotlock (NULL); /* register locking cleanup */
755   i18n_init();
756
757   opt.def_cipher_algoid = "1.2.840.113549.3.7";  /*des-EDE3-CBC*/
758
759 #ifdef HAVE_W32_SYSTEM
760   opt.homedir = read_w32_registry_string ( NULL,
761                                            "Software\\GNU\\GnuPG", "HomeDir" );
762 #else
763   opt.homedir = getenv ("GNUPGHOME");
764 #endif
765   if (!opt.homedir || !*opt.homedir ) 
766     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
767
768   /* first check whether we have a config file on the commandline */
769   orig_argc = argc;
770   orig_argv = argv;
771   pargs.argc = &argc;
772   pargs.argv = &argv;
773   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
774   while (arg_parse( &pargs, opts))
775     {
776       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
777         parse_debug++;
778       else if (pargs.r_opt == oOptions)
779         { /* yes there is one, so we do not try the default one but
780              read the config file when it is encountered at the
781              commandline */
782           default_config = 0;
783         }
784       else if (pargs.r_opt == oNoOptions)
785         default_config = 0; /* --no-options */
786       else if (pargs.r_opt == oHomedir)
787         opt.homedir = pargs.r.ret_str;
788       else if (pargs.r_opt == aCallProtectTool)
789         break; /* This break makes sure that --version and --help are
790                   passed to the protect-tool. */
791     }
792   
793   
794   /* initialize the secure memory. */
795   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
796   maybe_setuid = 0;
797
798   /* 
799      Now we are now working under our real uid 
800   */
801
802   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
803
804   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
805   assuan_set_assuan_log_stream (log_get_stream ());
806   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
807
808   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
809
810   /* Setup a default control structure for command line mode */
811   memset (&ctrl, 0, sizeof ctrl);
812   gpgsm_init_default_ctrl (&ctrl);
813   ctrl.no_server = 1;
814   ctrl.status_fd = -1; /* not status output */
815   ctrl.autodetect_encoding = 1;
816
817   /* Set the default option file */
818   if (default_config )
819     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
820   /* Set the default policy file */
821   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
822   
823   argc        = orig_argc;
824   argv        = orig_argv;
825   pargs.argc  = &argc;
826   pargs.argv  = &argv;
827   pargs.flags =  1;  /* do not remove the args */
828
829  next_pass:
830   if (configname) {
831     configlineno = 0;
832     configfp = fopen (configname, "r");
833     if (!configfp)
834       {
835         if (default_config)
836           {
837             if (parse_debug)
838               log_info (_("NOTE: no default option file `%s'\n"), configname);
839           }
840         else 
841           {
842             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
843             gpgsm_exit(2);
844           }
845         xfree(configname);
846         configname = NULL;
847       }
848     if (parse_debug && configname)
849       log_info (_("reading options from `%s'\n"), configname);
850     default_config = 0;
851   }
852
853   while (!no_more_options 
854          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
855     {
856       switch (pargs.r_opt)
857         {
858         case aGPGConfList: 
859           set_cmd (&cmd, pargs.r_opt);
860           do_not_setup_keys = 1;
861           nogreeting = 1;
862           break;
863
864         case aServer: 
865           opt.batch = 1;
866           set_cmd (&cmd, aServer);
867           break;
868
869         case aCallDirmngr:
870           opt.batch = 1;
871           set_cmd (&cmd, aCallDirmngr);
872           do_not_setup_keys = 1;
873           break;
874
875         case aCallProtectTool:
876           opt.batch = 1;
877           set_cmd (&cmd, aCallProtectTool);
878           no_more_options = 1; /* Stop parsing. */
879           do_not_setup_keys = 1;
880           break;
881         
882         case aDeleteKey:
883           set_cmd (&cmd, aDeleteKey);
884           /*greeting=1;*/
885           do_not_setup_keys = 1;
886           break;
887
888         case aDetachedSign:
889           detached_sig = 1;
890           set_cmd (&cmd, aSign ); 
891           break;
892
893         case aKeygen:
894           set_cmd (&cmd, aKeygen);
895           greeting=1; 
896           do_not_setup_keys = 1;
897           break;
898
899         case aCheckKeys:
900         case aImport: 
901         case aSendKeys: 
902         case aRecvKeys: 
903         case aExport: 
904         case aExportSecretKeyP12: 
905         case aDumpKeys:
906         case aDumpExternalKeys: 
907         case aDumpSecretKeys: 
908         case aListKeys:
909         case aListExternalKeys: 
910         case aListSecretKeys: 
911         case aListSigs: 
912         case aLearnCard: 
913         case aPasswd: 
914         case aKeydbClearSomeCertFlags:
915           do_not_setup_keys = 1;
916           set_cmd (&cmd, pargs.r_opt);
917           break;
918
919         case aSym:
920         case aDecrypt: 
921         case aEncr: 
922         case aSign: 
923         case aClearsign: 
924         case aVerify: 
925           set_cmd (&cmd, pargs.r_opt);
926           break;
927
928           /* output encoding selection */
929         case oArmor:
930           ctrl.create_pem = 1;
931           break;
932         case oBase64: 
933           ctrl.create_pem = 0;
934           ctrl.create_base64 = 1;
935           break;
936         case oNoArmor: 
937           ctrl.create_pem = 0;
938           ctrl.create_base64 = 0;
939           break;
940           
941           /* Input encoding selection */
942         case oAssumeArmor:
943           ctrl.autodetect_encoding = 0;
944           ctrl.is_pem = 1;
945           ctrl.is_base64 = 0;
946           break;
947         case oAssumeBase64:
948           ctrl.autodetect_encoding = 0;
949           ctrl.is_pem = 0;
950           ctrl.is_base64 = 1;
951           break;
952         case oAssumeBinary:
953           ctrl.autodetect_encoding = 0;
954           ctrl.is_pem = 0;
955           ctrl.is_base64 = 0;
956           break;
957
958         case oDisableCRLChecks:
959           opt.no_crl_check = 1;
960           break;
961         case oEnableCRLChecks:
962           opt.no_crl_check = 0;
963           break;
964         case oForceCRLRefresh:
965           opt.force_crl_refresh = 1;
966           break;
967
968         case oDisableOCSP:
969           ctrl.use_ocsp = opt.enable_ocsp = 0;
970           break;
971         case oEnableOCSP:
972           ctrl.use_ocsp = opt.enable_ocsp = 1;
973           break;
974
975         case oIncludeCerts: ctrl.include_certs = pargs.r.ret_int; break;
976
977         case oPolicyFile:
978           xfree (opt.policy_file);
979           if (*pargs.r.ret_str)
980             opt.policy_file = xstrdup (pargs.r.ret_str);
981           else
982             opt.policy_file = NULL;
983           break;
984
985         case oDisablePolicyChecks:
986           opt.no_policy_check = 1;
987           break;
988         case oEnablePolicyChecks:
989           opt.no_policy_check = 0;
990           break;
991           
992         case oAutoIssuerKeyRetrieve:
993           opt.auto_issuer_key_retrieve = 1;
994           break;
995
996         case oOutput: opt.outfile = pargs.r.ret_str; break;
997
998         
999         case oQuiet: opt.quiet = 1; break;
1000         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1001         case oDryRun: opt.dry_run = 1; break;
1002
1003         case oVerbose:
1004           opt.verbose++;
1005           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1006           break;
1007         case oNoVerbose:
1008           opt.verbose = 0;
1009           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1010           break;
1011
1012         case oLogFile: logfile = pargs.r.ret_str; break;
1013           
1014         case oBatch: 
1015           opt.batch = 1;
1016           greeting = 0;
1017           break;
1018         case oNoBatch: opt.batch = 0; break;
1019           
1020         case oAnswerYes: opt.answer_yes = 1; break;
1021         case oAnswerNo: opt.answer_no = 1; break;
1022
1023         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1024
1025         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1026         case oDebugAll: debug_value = ~0; break;
1027         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1028         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1029         case oDebugAllowCoreDump:
1030           may_coredump = enable_core_dumps ();
1031           break;
1032         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1033         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1034         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1035
1036         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1037         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1038         case oWithMD5Fingerprint:
1039           opt.with_md5_fingerprint=1; /*fall thru*/
1040         case oWithFingerprint:
1041           with_fpr=1; /*fall thru*/
1042         case oFingerprint:
1043           opt.fingerprint++;
1044           break;
1045
1046         case oOptions:
1047           /* config files may not be nested (silently ignore them) */
1048           if (!configfp)
1049             {
1050               xfree(configname);
1051               configname = xstrdup (pargs.r.ret_str);
1052               goto next_pass;
1053             }
1054           break;
1055         case oNoOptions: break; /* no-options */
1056         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1057         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1058         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
1059         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
1060         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
1061         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1062         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1063         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1064         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1065         case oProtectToolProgram:
1066           opt.protect_tool_program = pargs.r.ret_str; 
1067           break;
1068           
1069         case oFakedSystemTime:
1070           gnupg_set_time ( (time_t)pargs.r.ret_ulong, 0);
1071           break;
1072
1073         case oNoDefKeyring: default_keyring = 0; break;
1074         case oNoGreeting: nogreeting = 1; break;
1075
1076         case oDefaultKey:
1077           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
1078           log_info ("WARNING: --default-key has not yet been implemented\n");
1079           break;
1080         case oDefRecipient:
1081           if (*pargs.r.ret_str)
1082             opt.def_recipient = xstrdup (pargs.r.ret_str);
1083           break;
1084         case oDefRecipientSelf:
1085           xfree (opt.def_recipient);
1086           opt.def_recipient = NULL;
1087           opt.def_recipient_self = 1;
1088           break;
1089         case oNoDefRecipient:
1090           xfree (opt.def_recipient);
1091           opt.def_recipient = NULL;
1092           opt.def_recipient_self = 0;
1093           break;
1094
1095         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1096         case oWithColons: ctrl.with_colons = 1; break;
1097         case oWithValidation: ctrl.with_validation=1; break;
1098         case oWithEphemeralKeys: opt.with_ephemeral_keys=1; break;
1099
1100         case oSkipVerify: opt.skip_verify=1; break;
1101
1102         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1103         case oEncryptTo: /* Store the recipient in the second list */
1104           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1105           sl->flags = 1;
1106           break;
1107
1108         case oRecipient: /* store the recipient */
1109           add_to_strlist ( &remusr, pargs.r.ret_str);
1110           break;
1111
1112         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
1113         case oTextmode: /*fixme:opt.textmode=1;*/  break;
1114
1115         case oUser: /* store the local users, the first one is the default */
1116           if (!opt.local_user)
1117             opt.local_user = pargs.r.ret_str;
1118           add_to_strlist (&locusr, pargs.r.ret_str);
1119           break;
1120
1121         case oNoSecmemWarn:
1122           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1123           break;
1124
1125         case oCipherAlgo:
1126           opt.def_cipher_algoid = pargs.r.ret_str;
1127           break;
1128
1129         case oDisableCipherAlgo: 
1130           {
1131             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1132             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1133           }
1134           break;
1135         case oDisablePubkeyAlgo: 
1136           {
1137             int algo = gcry_pk_map_name (pargs.r.ret_str);
1138             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1139           }
1140           break;
1141
1142         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1143         case oNoRandomSeedFile: use_random_seed = 0; break;
1144
1145         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1146           
1147
1148         case aDummy:
1149           break;
1150         default: 
1151           pargs.err = configfp? 1:2; 
1152           break;
1153         }
1154     }
1155
1156   if (configfp)
1157     {
1158       fclose (configfp);
1159       configfp = NULL;
1160       /* Keep a copy of the config filename. */
1161       opt.config_filename = configname;
1162       configname = NULL;
1163       goto next_pass;
1164     }
1165   xfree (configname);
1166   configname = NULL;
1167
1168   if (!opt.config_filename)
1169     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1170
1171   if (log_get_errorcount(0))
1172     gpgsm_exit(2);
1173   
1174   if (nogreeting)
1175     greeting = 0;
1176   
1177   if (greeting)
1178     {
1179       fprintf(stderr, "%s %s; %s\n",
1180               strusage(11), strusage(13), strusage(14) );
1181       fprintf(stderr, "%s\n", strusage(15) );
1182     }
1183 #  ifdef IS_DEVELOPMENT_VERSION
1184   if (!opt.batch)
1185     {
1186       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1187       log_info ("It is only intended for test purposes and should NOT be\n");
1188       log_info ("used in a production environment or with production keys!\n");
1189     }
1190 #  endif
1191
1192   if (may_coredump && !opt.quiet)
1193     log_info (_("WARNING: program may create a core file!\n"));
1194
1195   if (logfile && cmd == aServer)
1196     {
1197       log_set_file (logfile);
1198       log_set_prefix (NULL, 1|2|4);
1199     }
1200
1201   if (gnupg_faked_time_p ())
1202     {
1203       gnupg_isotime_t tbuf;
1204
1205       log_info (_("WARNING: running with faked system time: "));
1206       gnupg_get_isotime (tbuf);
1207       gpgsm_dump_time (tbuf);
1208       log_printf ("\n");
1209     }
1210   
1211 /*FIXME    if (opt.batch) */
1212 /*      tty_batchmode (1); */
1213
1214   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1215
1216   set_debug ();
1217
1218   /* Although we alwasy use gpgsm_exit, we better install a regualr
1219      exit handler so that at least the secure memory gets wiped
1220      out. */
1221   if (atexit (emergency_cleanup))
1222     {
1223       log_error ("atexit failed\n");
1224       gpgsm_exit (2);
1225     }
1226
1227   /* Must do this after dropping setuid, because the mapping functions
1228      may try to load an module and we may have disabled an algorithm. */
1229   if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1230        || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1231     log_error (_("selected cipher algorithm is invalid\n"));
1232
1233   if (def_digest_string)
1234     {
1235       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1236       xfree (def_digest_string);
1237       def_digest_string = NULL;
1238       if (our_md_test_algo(opt.def_digest_algo) )
1239         log_error (_("selected digest algorithm is invalid\n"));
1240     }
1241
1242   if (log_get_errorcount(0))
1243     gpgsm_exit(2);
1244   
1245   /* Set the random seed file. */
1246   if (use_random_seed) {
1247     char *p = make_filename (opt.homedir, "random_seed", NULL);
1248     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1249     xfree(p);
1250   }
1251
1252
1253   if (!cmd && opt.fingerprint && !with_fpr)
1254     set_cmd (&cmd, aListKeys);
1255   
1256   if (!nrings && default_keyring)  /* add default keybox */
1257     keydb_add_resource ("pubring.kbx", 0, 0);
1258   for (sl = nrings; sl; sl = sl->next)
1259     keydb_add_resource (sl->d, 0, 0);
1260   FREE_STRLIST(nrings);
1261
1262   if (!do_not_setup_keys)
1263     {
1264       for (sl = locusr; sl ; sl = sl->next)
1265         {
1266           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1267           if (rc)
1268             {
1269               log_error (_("can't sign using `%s': %s\n"),
1270                          sl->d, gpg_strerror (rc));
1271               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1272                          gpg_err_code (rc) == -1?                      "1":
1273                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1274                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1275                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1276                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1277                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1278                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1279                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1280                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1281                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1282                          "0",
1283                          sl->d, NULL);
1284             }
1285         }
1286       
1287       /* Build the recipient list.  We first add the regular ones and then
1288          the encrypt-to ones because the underlying function will silenty
1289          ignore duplicates and we can't allow to keep a duplicate which is
1290          flagged as encrypt-to as the actually encrypt function would then
1291          complain about no (regular) recipients. */
1292       for (sl = remusr; sl; sl = sl->next)
1293         if (!(sl->flags & 1))
1294           do_add_recipient (&ctrl, sl->d, &recplist, 0);
1295       if (!opt.no_encrypt_to)
1296         {
1297           for (sl = remusr; sl; sl = sl->next)
1298             if ((sl->flags & 1))
1299               do_add_recipient (&ctrl, sl->d, &recplist, 1);
1300         }
1301     }
1302
1303   if (log_get_errorcount(0))
1304     gpgsm_exit(1); /* must stop for invalid recipients */
1305   
1306   fname = argc? *argv : NULL;
1307   
1308   switch (cmd)
1309     {
1310     case aGPGConfList: 
1311       { /* List options and default values in the GPG Conf format.  */
1312
1313         /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1314         /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1315            FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1316 #define GC_OPT_FLAG_NONE        0UL
1317         /* The RUNTIME flag for an option indicates that the option can be
1318            changed at runtime.  */
1319 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
1320         /* The DEFAULT flag for an option indicates that the option has a
1321            default value.  */
1322 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1323         /* The DEF_DESC flag for an option indicates that the option has a
1324            default, which is described by the value of the default field.  */
1325 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1326         /* The NO_ARG_DESC flag for an option indicates that the argument has
1327            a default, which is described by the value of the ARGDEF field.  */
1328 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1329
1330         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1331                 GC_OPT_FLAG_DEFAULT, opt.config_filename);
1332         
1333         printf ("verbose:%lu:\n"
1334                 "quiet:%lu:\n"
1335                 "debug-level:%lu:\"none:\n"
1336                 "log-file:%lu:\n",
1337                 GC_OPT_FLAG_NONE,
1338                 GC_OPT_FLAG_NONE,
1339                 GC_OPT_FLAG_DEFAULT,
1340                 GC_OPT_FLAG_NONE );
1341         printf ("disable-crl-checks:%lu:\n",
1342                 GC_OPT_FLAG_NONE );
1343         printf ("enable-ocsp:%lu:\n",
1344                 GC_OPT_FLAG_NONE );
1345         printf ("include-certs:%lu:1:\n",
1346                 GC_OPT_FLAG_DEFAULT );
1347         printf ("disable-policy-checks:%lu:\n",
1348                 GC_OPT_FLAG_NONE );
1349         printf ("auto-issuer-key-retrieve:%lu:\n",
1350                 GC_OPT_FLAG_NONE );
1351         printf ("prefer-system-dirmngr:%lu:\n",
1352                 GC_OPT_FLAG_NONE );
1353
1354       }
1355       break;
1356
1357     case aServer:
1358       if (debug_wait)
1359         {
1360           log_debug ("waiting for debugger - my pid is %u .....\n",
1361                      (unsigned int)getpid());
1362           sleep (debug_wait);
1363           log_debug ("... okay\n");
1364          }
1365       gpgsm_server (recplist);
1366       break;
1367
1368     case aCallDirmngr:
1369       if (!argc)
1370         wrong_args ("--call-dirmngr <command> {args}");
1371       else
1372         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1373           gpgsm_exit (1);
1374       break;
1375
1376     case aCallProtectTool:
1377       run_protect_tool (argc, argv);
1378       break;
1379
1380     case aEncr: /* encrypt the given file */
1381       if (!argc)
1382         gpgsm_encrypt (&ctrl, recplist, 0, stdout); /* from stdin */
1383       else if (argc == 1)
1384         gpgsm_encrypt (&ctrl, recplist, open_read (*argv), stdout); /* from file */
1385       else
1386         wrong_args ("--encrypt [datafile]");
1387       break;
1388
1389     case aSign: /* sign the given file */
1390       /* FIXME: We don't handle --output yet. We should also allow
1391          to concatenate multiple files for signing because that is
1392          what gpg does.*/
1393       if (!argc)
1394         gpgsm_sign (&ctrl, signerlist,
1395                     0, detached_sig, stdout); /* create from stdin */
1396       else if (argc == 1)
1397         gpgsm_sign (&ctrl, signerlist,
1398                     open_read (*argv), detached_sig, stdout); /* from file */
1399       else
1400         wrong_args ("--sign [datafile]");
1401       break;
1402         
1403     case aSignEncr: /* sign and encrypt the given file */
1404       log_error ("this command has not yet been implemented\n");
1405       break;
1406
1407     case aClearsign: /* make a clearsig */
1408       log_error ("this command has not yet been implemented\n");
1409       break;
1410
1411     case aVerify:
1412       {
1413         FILE *fp = NULL;
1414
1415         if (argc == 2 && opt.outfile)
1416           log_info ("option --output ignored for a detached signature\n");
1417         else if (opt.outfile)
1418           fp = open_fwrite (opt.outfile);
1419
1420         if (!argc)
1421           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1422         else if (argc == 1)
1423           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1424         else if (argc == 2) /* detached signature (sig, detached) */
1425           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1426         else
1427           wrong_args ("--verify [signature [detached_data]]");
1428
1429         if (fp && fp != stdout)
1430           fclose (fp);
1431       }
1432       break;
1433
1434     case aVerifyFiles:
1435       log_error (_("this command has not yet been implemented\n"));
1436       break;
1437
1438     case aDecrypt:
1439       if (!argc)
1440         gpgsm_decrypt (&ctrl, 0, stdout); /* from stdin */
1441       else if (argc == 1)
1442         gpgsm_decrypt (&ctrl, open_read (*argv), stdout); /* from file */
1443       else
1444         wrong_args ("--decrypt [filename]");
1445       break;
1446
1447     case aDeleteKey:
1448       for (sl=NULL; argc; argc--, argv++)
1449         add_to_strlist (&sl, *argv);
1450       gpgsm_delete (&ctrl, sl);
1451       free_strlist(sl);
1452       break;
1453
1454     case aListSigs:
1455       ctrl.with_chain = 1;
1456     case aListKeys:
1457       for (sl=NULL; argc; argc--, argv++)
1458         add_to_strlist (&sl, *argv);
1459       gpgsm_list_keys (&ctrl, sl, stdout, (0 | (1<<6)));
1460       free_strlist(sl);
1461       break;
1462
1463     case aDumpKeys:
1464       for (sl=NULL; argc; argc--, argv++)
1465         add_to_strlist (&sl, *argv);
1466       gpgsm_list_keys (&ctrl, sl, stdout, (256 | (1<<6)));
1467       free_strlist(sl);
1468       break;
1469
1470     case aListExternalKeys:
1471       for (sl=NULL; argc; argc--, argv++)
1472         add_to_strlist (&sl, *argv);
1473       gpgsm_list_keys (&ctrl, sl, stdout,
1474                        (0 | (1<<7)));
1475       free_strlist(sl);
1476       break;
1477
1478     case aDumpExternalKeys:
1479       for (sl=NULL; argc; argc--, argv++)
1480         add_to_strlist (&sl, *argv);
1481       gpgsm_list_keys (&ctrl, sl, stdout,
1482                        (256 | (1<<7)));
1483       free_strlist(sl);
1484       break;
1485
1486     case aListSecretKeys:
1487       for (sl=NULL; argc; argc--, argv++)
1488         add_to_strlist (&sl, *argv);
1489       gpgsm_list_keys (&ctrl, sl, stdout, (2 | (1<<6)));
1490       free_strlist(sl);
1491       break;
1492
1493     case aDumpSecretKeys:
1494       for (sl=NULL; argc; argc--, argv++)
1495         add_to_strlist (&sl, *argv);
1496       gpgsm_list_keys (&ctrl, sl, stdout, (256 | 2 | (1<<6)));
1497       free_strlist(sl);
1498       break;
1499
1500     case aKeygen: /* generate a key */
1501       log_error ("this function is not yet available from the commandline\n");
1502       break;
1503
1504     case aImport:
1505       gpgsm_import_files (&ctrl, argc, argv, open_read);
1506       break;
1507
1508     case aExport:
1509       for (sl=NULL; argc; argc--, argv++)
1510         add_to_strlist (&sl, *argv);
1511       gpgsm_export (&ctrl, sl, stdout);
1512       free_strlist(sl);
1513       break;
1514
1515     case aExportSecretKeyP12:
1516       if (argc == 1)
1517         gpgsm_p12_export (&ctrl, *argv, stdout);
1518       else
1519         wrong_args ("--export-secret-key-p12 KEY-ID");
1520       break;
1521       
1522     case aSendKeys:
1523     case aRecvKeys:
1524       log_error ("this command has not yet been implemented\n");
1525       break;
1526
1527
1528     case aLearnCard:
1529       if (argc)
1530         wrong_args ("--learn-card");
1531       else
1532         {
1533           int rc = gpgsm_agent_learn (&ctrl);
1534           if (rc)
1535             log_error ("error learning card: %s\n", gpg_strerror (rc));
1536         }
1537       break;
1538
1539     case aPasswd:
1540       if (argc != 1)
1541         wrong_args ("--passwd <key-Id>");
1542       else
1543         {
1544           int rc;
1545           ksba_cert_t cert = NULL;
1546           char *grip = NULL;
1547
1548           rc = gpgsm_find_cert (*argv, &cert);
1549           if (rc)
1550             ;
1551           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1552             rc = gpg_error (GPG_ERR_BUG);
1553           else 
1554             {
1555               char *desc = gpgsm_format_keydesc (cert);
1556               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1557               xfree (desc);
1558             }
1559           if (rc)
1560             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1561           xfree (grip);
1562           ksba_cert_release (cert);
1563         }
1564       break;
1565
1566     case aKeydbClearSomeCertFlags:
1567       for (sl=NULL; argc; argc--, argv++)
1568         add_to_strlist (&sl, *argv);
1569       keydb_clear_some_cert_flags (&ctrl, sl);
1570       free_strlist(sl);
1571       break;
1572
1573
1574     default:
1575         log_error ("invalid command (there is no implicit command)\n");
1576         break;
1577     }
1578   
1579   /* cleanup */
1580   gpgsm_release_certlist (recplist);
1581   gpgsm_release_certlist (signerlist);
1582   FREE_STRLIST(remusr);
1583   FREE_STRLIST(locusr);
1584   gpgsm_exit(0);
1585   return 8; /*NEVER REACHED*/
1586 }
1587
1588 /* Note: This function is used by signal handlers!. */
1589 static void
1590 emergency_cleanup (void)
1591 {
1592   gcry_control (GCRYCTL_TERM_SECMEM );
1593 }
1594
1595
1596 void
1597 gpgsm_exit (int rc)
1598 {
1599   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1600   if (opt.debug & DBG_MEMSTAT_VALUE)
1601     {
1602       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1603       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1604     }
1605   if (opt.debug)
1606     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1607   emergency_cleanup ();
1608   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1609   exit (rc);
1610 }
1611
1612
1613 void
1614 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1615 {
1616   ctrl->include_certs = 1;  /* only include the signer's cert */
1617   ctrl->use_ocsp = opt.enable_ocsp;
1618 }
1619
1620
1621
1622 /* Check whether the filename has the form "-&nnnn", where n is a
1623    non-zero number.  Returns this number or -1 if it is not the case.  */
1624 static int
1625 check_special_filename (const char *fname)
1626 {
1627   if (allow_special_filenames
1628       && fname && *fname == '-' && fname[1] == '&' ) {
1629     int i;
1630     
1631     fname += 2;
1632     for (i=0; isdigit (fname[i]); i++ )
1633       ;
1634     if ( !fname[i] ) 
1635       return atoi (fname);
1636   }
1637   return -1;
1638 }
1639
1640
1641
1642 /* Open the FILENAME for read and return the filedescriptor.  Stop
1643    with an error message in case of problems.  "-" denotes stdin and
1644    if special filenames are allowed the given fd is opened instead. */
1645 static int 
1646 open_read (const char *filename)
1647 {
1648   int fd;
1649
1650   if (filename[0] == '-' && !filename[1])
1651     return 0; /* stdin */
1652   fd = check_special_filename (filename);
1653   if (fd != -1)
1654     return fd;
1655   fd = open (filename, O_RDONLY);
1656   if (fd == -1)
1657     {
1658       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1659       gpgsm_exit (2);
1660     }
1661   return fd;
1662 }
1663
1664 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1665    message in case of problems.  "-" denotes stdout and if special
1666    filenames are allowed the given fd is opened instead. Caller must
1667    close the returned stream unless it is stdout. */
1668 static FILE *
1669 open_fwrite (const char *filename)
1670 {
1671   int fd;
1672   FILE *fp;
1673
1674   if (filename[0] == '-' && !filename[1])
1675     return stdout;
1676
1677   fd = check_special_filename (filename);
1678   if (fd != -1)
1679     {
1680       fp = fdopen (dup (fd), "wb");
1681       if (!fp)
1682         {
1683           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1684           gpgsm_exit (2);
1685         }
1686       return fp;
1687     }
1688   fp = fopen (filename, "wb");
1689   if (!fp)
1690     {
1691       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1692       gpgsm_exit (2);
1693     }
1694   return fp;
1695 }
1696
1697
1698 static void
1699 run_protect_tool (int argc, char **argv)
1700 {
1701 #ifndef HAVE_W32_SYSTEM
1702   const char *pgm;
1703   char **av;
1704   int i;
1705
1706   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1707     pgm = GNUPG_DEFAULT_PROTECT_TOOL;
1708   else
1709     pgm = opt.protect_tool_program;
1710
1711   av = xcalloc (argc+2, sizeof *av);
1712   av[0] = strrchr (pgm, '/');
1713   if (!av[0])
1714     av[0] = xstrdup (pgm);
1715   for (i=1; argc; i++, argc--, argv++)
1716     av[i] = *argv;
1717   av[i] = NULL;
1718   execv (pgm, av); 
1719   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1720 #endif /*HAVE_W32_SYSTEM*/
1721   gpgsm_exit (2);
1722 }