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