* verify.c (strtimestamp_r, gpgsm_verify):
[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       gnupg_isotime_t tbuf;
1039
1040       log_info (_("WARNING: running with faked system time: "));
1041       gnupg_get_isotime (tbuf);
1042       gpgsm_dump_time (tbuf);
1043       log_printf ("\n");
1044     }
1045   
1046 /*FIXME    if (opt.batch) */
1047 /*      tty_batchmode (1); */
1048
1049   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1050
1051   set_debug ();
1052
1053   /* FIXME: should set filenames of libgcrypt explicitly
1054    * gpg_opt_homedir = opt.homedir; */
1055
1056   /* must do this after dropping setuid, because the mapping functions
1057      may try to load an module and we may have disabled an algorithm */
1058   if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1059        || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1060     log_error (_("selected cipher algorithm is invalid\n"));
1061
1062   if (def_digest_string)
1063     {
1064       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1065       xfree (def_digest_string);
1066       def_digest_string = NULL;
1067       if (our_md_test_algo(opt.def_digest_algo) )
1068         log_error (_("selected digest algorithm is invalid\n"));
1069     }
1070
1071   if (log_get_errorcount(0))
1072     gpgsm_exit(2);
1073   
1074   /* set the random seed file */
1075   if (use_random_seed) {
1076     char *p = make_filename (opt.homedir, "random_seed", NULL);
1077     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1078     xfree(p);
1079   }
1080
1081
1082   if (!cmd && opt.fingerprint && !with_fpr)
1083     set_cmd (&cmd, aListKeys);
1084   
1085   if (!nrings && default_keyring)  /* add default keybox */
1086     keydb_add_resource ("pubring.kbx", 0, 0);
1087   for (sl = nrings; sl; sl = sl->next)
1088     keydb_add_resource (sl->d, 0, 0);
1089   FREE_STRLIST(nrings);
1090
1091
1092   for (sl = locusr; sl; sl = sl->next)
1093     {
1094       int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist);
1095       if (rc)
1096         {
1097           log_error (_("can't sign using `%s': %s\n"),
1098                      sl->d, gpg_strerror (rc));
1099           gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1100                          gpg_err_code (rc) == -1?                      "1":
1101                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1102                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1103                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1104                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1105                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1106                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1107                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1108                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1109                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1110                          "0",
1111                          sl->d, NULL);
1112         }
1113     }
1114   for (sl = remusr; sl; sl = sl->next)
1115     {
1116       int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 0, &recplist);
1117       if (rc)
1118         {
1119           log_error (_("can't encrypt to `%s': %s\n"),
1120                      sl->d, gpg_strerror (rc));
1121           gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1122                          gpg_err_code (rc) == -1?                         "1":
1123                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?          "1":
1124                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?     "2":
1125                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE?    "3":
1126                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?       "4":
1127                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?       "5":
1128                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?       "6":
1129                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?        "7":
1130                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH?    "8":
1131                          "0",
1132                          sl->d, NULL);
1133         }
1134   }
1135   if (log_get_errorcount(0))
1136     gpgsm_exit(1); /* must stop for invalid recipients */
1137   
1138
1139   
1140   fname = argc? *argv : NULL;
1141   
1142   switch (cmd)
1143     {
1144     case aServer:
1145       if (debug_wait)
1146         {
1147           log_debug ("waiting for debugger - my pid is %u .....\n",
1148                      (unsigned int)getpid());
1149           sleep (debug_wait);
1150           log_debug ("... okay\n");
1151          }
1152       gpgsm_server ();
1153       break;
1154
1155     case aCallDirmngr:
1156       if (!argc)
1157         wrong_args (_("--call-dirmngr <command> {args}"));
1158       else
1159         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1160           gpgsm_exit (1);
1161       break;
1162
1163     case aCallProtectTool:
1164       run_protect_tool (argc, argv);
1165       break;
1166
1167     case aEncr: /* encrypt the given file */
1168       if (!argc)
1169         gpgsm_encrypt (&ctrl, recplist, 0, stdout); /* from stdin */
1170       else if (argc == 1)
1171         gpgsm_encrypt (&ctrl, recplist, open_read (*argv), stdout); /* from file */
1172       else
1173         wrong_args (_("--encrypt [datafile]"));
1174       break;
1175
1176     case aSign: /* sign the given file */
1177       /* FIXME: We don't handle --output yet. We should also allow
1178          to concatenate multiple files for signing because that is
1179          what gpg does.*/
1180       if (!argc)
1181         gpgsm_sign (&ctrl, signerlist,
1182                     0, detached_sig, stdout); /* create from stdin */
1183       else if (argc == 1)
1184         gpgsm_sign (&ctrl, signerlist,
1185                     open_read (*argv), detached_sig, stdout); /* from file */
1186       else
1187         wrong_args (_("--sign [datafile]"));
1188       break;
1189         
1190     case aSignEncr: /* sign and encrypt the given file */
1191       log_error ("this command has not yet been implemented\n");
1192       break;
1193
1194     case aClearsign: /* make a clearsig */
1195       log_error ("this command has not yet been implemented\n");
1196       break;
1197
1198     case aVerify:
1199       {
1200         FILE *fp = NULL;
1201
1202         if (argc == 2 && opt.outfile)
1203           log_info ("option --output ignored for a detached signature\n");
1204         else if (opt.outfile)
1205           fp = open_fwrite (opt.outfile);
1206
1207         if (!argc)
1208           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1209         else if (argc == 1)
1210           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1211         else if (argc == 2) /* detached signature (sig, detached) */
1212           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1213         else
1214           wrong_args (_("--verify [signature [detached_data]]"));
1215
1216         if (fp && fp != stdout)
1217           fclose (fp);
1218       }
1219       break;
1220
1221     case aVerifyFiles:
1222       log_error ("this command has not yet been implemented\n");
1223       break;
1224
1225     case aDecrypt:
1226       if (!argc)
1227         gpgsm_decrypt (&ctrl, 0, stdout); /* from stdin */
1228       else if (argc == 1)
1229         gpgsm_decrypt (&ctrl, open_read (*argv), stdout); /* from file */
1230       else
1231         wrong_args (_("--decrypt [filename]"));
1232       break;
1233
1234     case aDeleteKey:
1235       for (sl=NULL; argc; argc--, argv++)
1236         add_to_strlist (&sl, *argv);
1237       gpgsm_delete (&ctrl, sl);
1238       free_strlist(sl);
1239       break;
1240
1241     case aListSigs:
1242       ctrl.with_chain = 1;
1243     case aListKeys:
1244       for (sl=NULL; argc; argc--, argv++)
1245         add_to_strlist (&sl, *argv);
1246       gpgsm_list_keys (&ctrl, sl, stdout, (0 | (1<<6)));
1247       free_strlist(sl);
1248       break;
1249
1250     case aListExternalKeys:
1251       for (sl=NULL; argc; argc--, argv++)
1252         add_to_strlist (&sl, *argv);
1253       gpgsm_list_keys (&ctrl, sl, stdout, (0 | (1<<7)));
1254       free_strlist(sl);
1255       break;
1256
1257     case aListSecretKeys:
1258       for (sl=NULL; argc; argc--, argv++)
1259         add_to_strlist (&sl, *argv);
1260       gpgsm_list_keys (&ctrl, sl, stdout, (2 | (1<<6)));
1261       free_strlist(sl);
1262       break;
1263
1264     case aKeygen: /* generate a key */
1265       log_error ("this function is not yet available from the commandline\n");
1266       break;
1267
1268     case aImport:
1269       gpgsm_import_files (&ctrl, argc, argv, open_read);
1270       break;
1271
1272     case aExport:
1273       for (sl=NULL; argc; argc--, argv++)
1274         add_to_strlist (&sl, *argv);
1275       gpgsm_export (&ctrl, sl, stdout);
1276       free_strlist(sl);
1277       break;
1278
1279       
1280     case aSendKeys:
1281     case aRecvKeys:
1282       log_error ("this command has not yet been implemented\n");
1283       break;
1284
1285
1286     case aLearnCard:
1287       if (argc)
1288         wrong_args ("--learn-card");
1289       else
1290         {
1291           int rc = gpgsm_agent_learn ();
1292           if (rc)
1293             log_error ("error learning card: %s\n", gpg_strerror (rc));
1294         }
1295       break;
1296
1297     case aPasswd:
1298       if (argc != 1)
1299         wrong_args ("--passwd <key-Id>");
1300       else
1301         {
1302           int rc;
1303           KsbaCert cert = NULL;
1304           char *grip = NULL;
1305
1306           rc = gpgsm_find_cert (*argv, &cert);
1307           if (rc)
1308             ;
1309           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1310             rc = gpg_error (GPG_ERR_BUG);
1311           else 
1312             rc = gpgsm_agent_passwd (grip);
1313           if (rc)
1314             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1315           xfree (grip);
1316           ksba_cert_release (cert);
1317         }
1318       break;
1319
1320     default:
1321         log_error ("invalid command (there is no implicit command)\n");
1322         break;
1323     }
1324   
1325   /* cleanup */
1326   gpgsm_release_certlist (recplist);
1327   gpgsm_release_certlist (signerlist);
1328   FREE_STRLIST(remusr);
1329   FREE_STRLIST(locusr);
1330   gpgsm_exit(0);
1331   return 8; /*NEVER REACHED*/
1332 }
1333
1334 /* Note: This function is used by signal handlers!. */
1335 static void
1336 emergency_cleanup (void)
1337 {
1338   gcry_control (GCRYCTL_TERM_SECMEM );
1339 }
1340
1341
1342 void
1343 gpgsm_exit (int rc)
1344 {
1345   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1346   if (opt.debug & DBG_MEMSTAT_VALUE)
1347     {
1348       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1349       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1350     }
1351   if (opt.debug)
1352     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1353   emergency_cleanup ();
1354   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1355   exit (rc);
1356 }
1357
1358
1359 void
1360 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1361 {
1362   ctrl->include_certs = 1;  /* only include the signer's cert */
1363 }
1364
1365
1366
1367 /* Check whether the filename has the form "-&nnnn", where n is a
1368    non-zero number.  Returns this number or -1 if it is not the case.  */
1369 static int
1370 check_special_filename (const char *fname)
1371 {
1372   if (allow_special_filenames
1373       && fname && *fname == '-' && fname[1] == '&' ) {
1374     int i;
1375     
1376     fname += 2;
1377     for (i=0; isdigit (fname[i]); i++ )
1378       ;
1379     if ( !fname[i] ) 
1380       return atoi (fname);
1381   }
1382   return -1;
1383 }
1384
1385
1386
1387 /* Open the FILENAME for read and return the filedescriptor.  Stop
1388    with an error message in case of problems.  "-" denotes stdin and
1389    if special filenames are allowed the given fd is opened instead. */
1390 static int 
1391 open_read (const char *filename)
1392 {
1393   int fd;
1394
1395   if (filename[0] == '-' && !filename[1])
1396     return 0; /* stdin */
1397   fd = check_special_filename (filename);
1398   if (fd != -1)
1399     return fd;
1400   fd = open (filename, O_RDONLY);
1401   if (fd == -1)
1402     {
1403       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1404       gpgsm_exit (2);
1405     }
1406   return fd;
1407 }
1408
1409 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1410    message in case of problems.  "-" denotes stdout and if special
1411    filenames are allowed the given fd is opened instead. Caller must
1412    close the returned stream unless it is stdout. */
1413 static FILE *
1414 open_fwrite (const char *filename)
1415 {
1416   int fd;
1417   FILE *fp;
1418
1419   if (filename[0] == '-' && !filename[1])
1420     return stdout;
1421
1422   fd = check_special_filename (filename);
1423   if (fd != -1)
1424     {
1425       fp = fdopen (dup (fd), "wb");
1426       if (!fp)
1427         {
1428           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1429           gpgsm_exit (2);
1430         }
1431       return fp;
1432     }
1433   fp = fopen (filename, "wb");
1434   if (!fp)
1435     {
1436       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1437       gpgsm_exit (2);
1438     }
1439   return fp;
1440 }
1441
1442
1443 static void
1444 run_protect_tool (int argc, char **argv)
1445 {
1446   char *pgm = GNUPG_PROTECT_TOOL;
1447   char **av;
1448   int i;
1449
1450   av = xcalloc (argc+2, sizeof *av);
1451   av[0] = strrchr (pgm, '/');
1452   if (!av[0])
1453     av[0] = pgm;
1454   for (i=1; argc; i++, argc--, argv++)
1455     av[i] = *argv;
1456   av[i] = NULL;
1457   execv (pgm, av); 
1458   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1459   gpgsm_exit (2);
1460 }
1461