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