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