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