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