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