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