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