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