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