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