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