* gpgsm.c: New command --keydb-clear-some-cert-flags.
[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   char *config_filename = NULL;
705
706   /* trap_unaligned ();*/
707   set_strusage (my_strusage);
708   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
709   /* We don't need any locking in libgcrypt unless we use any kind of
710      threading. */
711   gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
712
713   /* Please note that we may running SUID(ROOT), so be very CAREFUL
714      when adding any stuff between here and the call to secmem_init()
715      somewhere after the option parsing */
716   log_set_prefix ("gpgsm", 1);
717
718   /* Try to auto set the character set.  */
719   set_native_charset (NULL); 
720
721   /* Check that the libraries are suitable.  Do it here because the
722      option parse may need services of the library */
723   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
724     {
725       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
726                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
727     }
728   if (!ksba_check_version (NEED_KSBA_VERSION) )
729     {
730       log_fatal( _("libksba is too old (need %s, have %s)\n"),
731                  NEED_KSBA_VERSION, ksba_check_version (NULL) );
732     }
733
734   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
735
736   may_coredump = disable_core_dumps ();
737   
738   gnupg_init_signals (0, emergency_cleanup);
739   
740   create_dotlock (NULL); /* register locking cleanup */
741   i18n_init();
742
743   opt.def_cipher_algoid = "1.2.840.113549.3.7";  /*des-EDE3-CBC*/
744 #ifdef __MINGW32__
745   opt.homedir = read_w32_registry_string ( NULL,
746                                            "Software\\GNU\\GnuPG", "HomeDir" );
747 #else
748   opt.homedir = getenv ("GNUPGHOME");
749 #endif
750   if (!opt.homedir || !*opt.homedir ) 
751     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
752
753   /* first check whether we have a config file on the commandline */
754   orig_argc = argc;
755   orig_argv = argv;
756   pargs.argc = &argc;
757   pargs.argv = &argv;
758   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
759   while (arg_parse( &pargs, opts))
760     {
761       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
762         parse_debug++;
763       else if (pargs.r_opt == oOptions)
764         { /* yes there is one, so we do not try the default one but
765              read the config file when it is encountered at the
766              commandline */
767           default_config = 0;
768         }
769       else if (pargs.r_opt == oNoOptions)
770         default_config = 0; /* --no-options */
771       else if (pargs.r_opt == oHomedir)
772         opt.homedir = pargs.r.ret_str;
773       else if (pargs.r_opt == aCallProtectTool)
774         break; /* This break makes sure that --version and --help are
775                   passed to the protect-tool. */
776     }
777   
778   
779   /* initialize the secure memory. */
780   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
781   maybe_setuid = 0;
782
783   /* 
784      Now we are now working under our real uid 
785   */
786
787   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
788
789   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
790   assuan_set_assuan_log_stream (log_get_stream ());
791   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
792
793   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
794
795   /* Setup a default control structure for command line mode */
796   memset (&ctrl, 0, sizeof ctrl);
797   gpgsm_init_default_ctrl (&ctrl);
798   ctrl.no_server = 1;
799   ctrl.status_fd = -1; /* not status output */
800   ctrl.autodetect_encoding = 1;
801
802   /* set the default option file */
803   if (default_config )
804     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
805   /* cet the default policy file */
806   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
807   
808   argc        = orig_argc;
809   argv        = orig_argv;
810   pargs.argc  = &argc;
811   pargs.argv  = &argv;
812   pargs.flags =  1;  /* do not remove the args */
813
814  next_pass:
815   if (configname) {
816     configlineno = 0;
817     configfp = fopen (configname, "r");
818     if (!configfp)
819       {
820         if (default_config)
821           {
822             if (parse_debug)
823               log_info (_("NOTE: no default option file `%s'\n"), configname);
824           }
825         else 
826           {
827             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
828             gpgsm_exit(2);
829           }
830         xfree(configname);
831         configname = NULL;
832       }
833     if (parse_debug && configname)
834       log_info (_("reading options from `%s'\n"), configname);
835     default_config = 0;
836   }
837
838   while (!no_more_options 
839          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
840     {
841       switch (pargs.r_opt)
842         {
843         case aGPGConfList: 
844           set_cmd (&cmd, pargs.r_opt);
845           do_not_setup_keys = 1;
846           nogreeting = 1;
847           break;
848
849         case aServer: 
850           opt.batch = 1;
851           set_cmd (&cmd, aServer);
852           break;
853
854         case aCallDirmngr:
855           opt.batch = 1;
856           set_cmd (&cmd, aCallDirmngr);
857           do_not_setup_keys = 1;
858           break;
859
860         case aCallProtectTool:
861           opt.batch = 1;
862           set_cmd (&cmd, aCallProtectTool);
863           no_more_options = 1; /* Stop parsing. */
864           do_not_setup_keys = 1;
865           break;
866         
867         case aDeleteKey:
868           set_cmd (&cmd, aDeleteKey);
869           /*greeting=1;*/
870           do_not_setup_keys = 1;
871           break;
872
873         case aDetachedSign:
874           detached_sig = 1;
875           set_cmd (&cmd, aSign ); 
876           break;
877
878         case aKeygen:
879           set_cmd (&cmd, aKeygen);
880           greeting=1; 
881           do_not_setup_keys = 1;
882           break;
883
884         case aCheckKeys:
885         case aImport: 
886         case aSendKeys: 
887         case aRecvKeys: 
888         case aExport: 
889         case aExportSecretKeyP12: 
890         case aDumpKeys:
891         case aDumpExternalKeys: 
892         case aDumpSecretKeys: 
893         case aListKeys:
894         case aListExternalKeys: 
895         case aListSecretKeys: 
896         case aListSigs: 
897         case aLearnCard: 
898         case aPasswd: 
899         case aKeydbClearSomeCertFlags:
900           do_not_setup_keys = 1;
901           set_cmd (&cmd, pargs.r_opt);
902           break;
903
904         case aSym:
905         case aDecrypt: 
906         case aEncr: 
907         case aSign: 
908         case aClearsign: 
909         case aVerify: 
910           set_cmd (&cmd, pargs.r_opt);
911           break;
912
913           /* output encoding selection */
914         case oArmor:
915           ctrl.create_pem = 1;
916           break;
917         case oBase64: 
918           ctrl.create_pem = 0;
919           ctrl.create_base64 = 1;
920           break;
921         case oNoArmor: 
922           ctrl.create_pem = 0;
923           ctrl.create_base64 = 0;
924           break;
925           
926           /* Input encoding selection */
927         case oAssumeArmor:
928           ctrl.autodetect_encoding = 0;
929           ctrl.is_pem = 1;
930           ctrl.is_base64 = 0;
931           break;
932         case oAssumeBase64:
933           ctrl.autodetect_encoding = 0;
934           ctrl.is_pem = 0;
935           ctrl.is_base64 = 1;
936           break;
937         case oAssumeBinary:
938           ctrl.autodetect_encoding = 0;
939           ctrl.is_pem = 0;
940           ctrl.is_base64 = 0;
941           break;
942
943         case oDisableCRLChecks:
944           opt.no_crl_check = 1;
945           break;
946         case oEnableCRLChecks:
947           opt.no_crl_check = 0;
948           break;
949         case oForceCRLRefresh:
950           opt.force_crl_refresh = 1;
951           break;
952
953         case oDisableOCSP:
954           ctrl.use_ocsp = opt.enable_ocsp = 0;
955           break;
956         case oEnableOCSP:
957           ctrl.use_ocsp = opt.enable_ocsp = 1;
958           break;
959
960         case oIncludeCerts: ctrl.include_certs = pargs.r.ret_int; break;
961
962         case oPolicyFile:
963           xfree (opt.policy_file);
964           if (*pargs.r.ret_str)
965             opt.policy_file = xstrdup (pargs.r.ret_str);
966           else
967             opt.policy_file = NULL;
968           break;
969
970         case oDisablePolicyChecks:
971           opt.no_policy_check = 1;
972           break;
973         case oEnablePolicyChecks:
974           opt.no_policy_check = 0;
975           break;
976           
977         case oAutoIssuerKeyRetrieve:
978           opt.auto_issuer_key_retrieve = 1;
979           break;
980
981         case oOutput: opt.outfile = pargs.r.ret_str; break;
982
983         
984         case oQuiet: opt.quiet = 1; break;
985         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
986         case oDryRun: opt.dry_run = 1; break;
987
988         case oVerbose:
989           opt.verbose++;
990           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
991           break;
992         case oNoVerbose:
993           opt.verbose = 0;
994           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
995           break;
996
997         case oLogFile: logfile = pargs.r.ret_str; break;
998           
999         case oBatch: 
1000           opt.batch = 1;
1001           greeting = 0;
1002           break;
1003         case oNoBatch: opt.batch = 0; break;
1004           
1005         case oAnswerYes: opt.answer_yes = 1; break;
1006         case oAnswerNo: opt.answer_no = 1; break;
1007
1008         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1009
1010         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1011         case oDebugAll: opt.debug = ~0; break;
1012         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1013         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1014         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1015         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1016
1017         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1018         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1019         case oWithMD5Fingerprint:
1020           opt.with_md5_fingerprint=1; /*fall thru*/
1021         case oWithFingerprint:
1022           with_fpr=1; /*fall thru*/
1023         case oFingerprint:
1024           opt.fingerprint++;
1025           break;
1026
1027         case oOptions:
1028           /* config files may not be nested (silently ignore them) */
1029           if (!configfp)
1030             {
1031               xfree(configname);
1032               configname = xstrdup (pargs.r.ret_str);
1033               goto next_pass;
1034             }
1035           break;
1036         case oNoOptions: break; /* no-options */
1037         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1038         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1039         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
1040         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
1041         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
1042         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1043         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1044         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1045         case oProtectToolProgram:
1046           opt.protect_tool_program = pargs.r.ret_str; 
1047           break;
1048           
1049         case oFakedSystemTime:
1050           gnupg_set_time ( (time_t)pargs.r.ret_ulong, 0);
1051           break;
1052
1053         case oNoDefKeyring: default_keyring = 0; break;
1054         case oNoGreeting: nogreeting = 1; break;
1055
1056         case oDefaultKey:
1057           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
1058           break;
1059         case oDefRecipient:
1060           if (*pargs.r.ret_str)
1061             opt.def_recipient = xstrdup (pargs.r.ret_str);
1062           break;
1063         case oDefRecipientSelf:
1064           xfree (opt.def_recipient);
1065           opt.def_recipient = NULL;
1066           opt.def_recipient_self = 1;
1067           break;
1068         case oNoDefRecipient:
1069           xfree (opt.def_recipient);
1070           opt.def_recipient = NULL;
1071           opt.def_recipient_self = 0;
1072           break;
1073
1074         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1075         case oWithColons: ctrl.with_colons = 1; break;
1076         case oWithValidation: ctrl.with_validation=1; break;
1077
1078         case oSkipVerify: opt.skip_verify=1; break;
1079
1080         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1081         case oEncryptTo: /* Store the recipient in the second list */
1082           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1083           sl->flags = 1;
1084           break;
1085
1086         case oRecipient: /* store the recipient */
1087           add_to_strlist ( &remusr, pargs.r.ret_str);
1088           break;
1089
1090         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
1091         case oTextmode: /*fixme:opt.textmode=1;*/  break;
1092
1093         case oUser: /* store the local users, the first one is the default */
1094           if (!opt.local_user)
1095             opt.local_user = pargs.r.ret_str;
1096           add_to_strlist (&locusr, pargs.r.ret_str);
1097           break;
1098
1099         case oNoSecmemWarn:
1100           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1101           break;
1102
1103         case oCipherAlgo:
1104           opt.def_cipher_algoid = pargs.r.ret_str;
1105           break;
1106
1107         case oDisableCipherAlgo: 
1108           {
1109             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1110             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1111           }
1112           break;
1113         case oDisablePubkeyAlgo: 
1114           {
1115             int algo = gcry_pk_map_name (pargs.r.ret_str);
1116             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1117           }
1118           break;
1119
1120         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1121         case oNoRandomSeedFile: use_random_seed = 0; break;
1122
1123         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1124           
1125
1126         case aDummy:
1127           break;
1128         default: 
1129           pargs.err = configfp? 1:2; 
1130           break;
1131         }
1132     }
1133
1134   if (configfp)
1135     {
1136       fclose (configfp);
1137       configfp = NULL;
1138       /* Keep a copy of the config filename. */
1139       config_filename = configname;
1140       configname = NULL;
1141       goto next_pass;
1142     }
1143   
1144   xfree (configname);
1145   configname = NULL;
1146
1147   if (log_get_errorcount(0))
1148     gpgsm_exit(2);
1149   
1150   if (nogreeting)
1151     greeting = 0;
1152   
1153   if (greeting)
1154     {
1155       fprintf(stderr, "%s %s; %s\n",
1156               strusage(11), strusage(13), strusage(14) );
1157       fprintf(stderr, "%s\n", strusage(15) );
1158     }
1159 #  ifdef IS_DEVELOPMENT_VERSION
1160   if (!opt.batch)
1161     {
1162       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1163       log_info ("It is only intended for test purposes and should NOT be\n");
1164       log_info ("used in a production environment or with production keys!\n");
1165     }
1166 #  endif
1167
1168   if (may_coredump && !opt.quiet)
1169     log_info (_("WARNING: program may create a core file!\n"));
1170
1171   if (logfile && cmd == aServer)
1172     {
1173       log_set_file (logfile);
1174       log_set_prefix (NULL, 1|2|4);
1175     }
1176
1177   if (gnupg_faked_time_p ())
1178     {
1179       gnupg_isotime_t tbuf;
1180
1181       log_info (_("WARNING: running with faked system time: "));
1182       gnupg_get_isotime (tbuf);
1183       gpgsm_dump_time (tbuf);
1184       log_printf ("\n");
1185     }
1186   
1187 /*FIXME    if (opt.batch) */
1188 /*      tty_batchmode (1); */
1189
1190   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1191
1192   set_debug (debug_level);
1193
1194   /* FIXME: should set filenames of libgcrypt explicitly
1195    * gpg_opt_homedir = opt.homedir; */
1196
1197   /* must do this after dropping setuid, because the mapping functions
1198      may try to load an module and we may have disabled an algorithm */
1199   if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1200        || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1201     log_error (_("selected cipher algorithm is invalid\n"));
1202
1203   if (def_digest_string)
1204     {
1205       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1206       xfree (def_digest_string);
1207       def_digest_string = NULL;
1208       if (our_md_test_algo(opt.def_digest_algo) )
1209         log_error (_("selected digest algorithm is invalid\n"));
1210     }
1211
1212   if (log_get_errorcount(0))
1213     gpgsm_exit(2);
1214   
1215   /* set the random seed file */
1216   if (use_random_seed) {
1217     char *p = make_filename (opt.homedir, "random_seed", NULL);
1218     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1219     xfree(p);
1220   }
1221
1222
1223   if (!cmd && opt.fingerprint && !with_fpr)
1224     set_cmd (&cmd, aListKeys);
1225   
1226   if (!nrings && default_keyring)  /* add default keybox */
1227     keydb_add_resource ("pubring.kbx", 0, 0);
1228   for (sl = nrings; sl; sl = sl->next)
1229     keydb_add_resource (sl->d, 0, 0);
1230   FREE_STRLIST(nrings);
1231
1232   if (!do_not_setup_keys)
1233     {
1234       for (sl = locusr; sl ; sl = sl->next)
1235         {
1236           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1237           if (rc)
1238             {
1239               log_error (_("can't sign using `%s': %s\n"),
1240                          sl->d, gpg_strerror (rc));
1241               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1242                          gpg_err_code (rc) == -1?                      "1":
1243                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1244                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1245                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1246                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1247                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1248                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1249                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1250                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1251                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1252                          "0",
1253                          sl->d, NULL);
1254             }
1255         }
1256       
1257       /* Build the recipient list.  We first add the regular ones and then
1258          the encrypt-to ones because the underlying function will silenty
1259          ignore duplicates and we can't allow to keep a duplicate which is
1260          flagged as encrypt-to as the actually encrypt function would then
1261          complain about no (regular) recipients. */
1262       for (sl = remusr; sl; sl = sl->next)
1263         if (!(sl->flags & 1))
1264           do_add_recipient (&ctrl, sl->d, &recplist, 0);
1265       if (!opt.no_encrypt_to)
1266         {
1267           for (sl = remusr; sl; sl = sl->next)
1268             if ((sl->flags & 1))
1269               do_add_recipient (&ctrl, sl->d, &recplist, 1);
1270         }
1271     }
1272
1273   if (log_get_errorcount(0))
1274     gpgsm_exit(1); /* must stop for invalid recipients */
1275   
1276   fname = argc? *argv : NULL;
1277   
1278   switch (cmd)
1279     {
1280     case aGPGConfList: 
1281       { /* List options and default values in the GPG Conf format.  */
1282
1283         /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1284         /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1285            FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1286 #define GC_OPT_FLAG_NONE        0UL
1287         /* The RUNTIME flag for an option indicates that the option can be
1288            changed at runtime.  */
1289 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
1290         /* The DEFAULT flag for an option indicates that the option has a
1291            default value.  */
1292 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1293         /* The DEF_DESC flag for an option indicates that the option has a
1294            default, which is described by the value of the default field.  */
1295 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1296         /* The NO_ARG_DESC flag for an option indicates that the argument has
1297            a default, which is described by the value of the ARGDEF field.  */
1298 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1299
1300         if (!config_filename)
1301           config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1302
1303         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1304                 GC_OPT_FLAG_DEFAULT, config_filename);
1305         
1306         printf ("verbose:%lu:\n"
1307                 "quiet:%lu:\n"
1308                 "debug-level:%lu:\"none:\n"
1309                 "log-file:%lu:\n",
1310                 GC_OPT_FLAG_NONE,
1311                 GC_OPT_FLAG_NONE,
1312                 GC_OPT_FLAG_DEFAULT,
1313                 GC_OPT_FLAG_NONE );
1314         printf ("disable-crl-checks:%lu:\n",
1315                 GC_OPT_FLAG_NONE );
1316         printf ("enable-ocsp:%lu:\n",
1317                 GC_OPT_FLAG_NONE );
1318         printf ("include-certs:%lu:1:\n",
1319                 GC_OPT_FLAG_DEFAULT );
1320         printf ("disable-policy-checks:%lu:\n",
1321                 GC_OPT_FLAG_NONE );
1322         printf ("auto-issuer-key-retrieve:%lu:\n",
1323                 GC_OPT_FLAG_NONE );
1324
1325       }
1326       break;
1327
1328     case aServer:
1329       if (debug_wait)
1330         {
1331           log_debug ("waiting for debugger - my pid is %u .....\n",
1332                      (unsigned int)getpid());
1333           sleep (debug_wait);
1334           log_debug ("... okay\n");
1335          }
1336       gpgsm_server (recplist);
1337       break;
1338
1339     case aCallDirmngr:
1340       if (!argc)
1341         wrong_args ("--call-dirmngr <command> {args}");
1342       else
1343         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1344           gpgsm_exit (1);
1345       break;
1346
1347     case aCallProtectTool:
1348       run_protect_tool (argc, argv);
1349       break;
1350
1351     case aEncr: /* encrypt the given file */
1352       if (!argc)
1353         gpgsm_encrypt (&ctrl, recplist, 0, stdout); /* from stdin */
1354       else if (argc == 1)
1355         gpgsm_encrypt (&ctrl, recplist, open_read (*argv), stdout); /* from file */
1356       else
1357         wrong_args ("--encrypt [datafile]");
1358       break;
1359
1360     case aSign: /* sign the given file */
1361       /* FIXME: We don't handle --output yet. We should also allow
1362          to concatenate multiple files for signing because that is
1363          what gpg does.*/
1364       if (!argc)
1365         gpgsm_sign (&ctrl, signerlist,
1366                     0, detached_sig, stdout); /* create from stdin */
1367       else if (argc == 1)
1368         gpgsm_sign (&ctrl, signerlist,
1369                     open_read (*argv), detached_sig, stdout); /* from file */
1370       else
1371         wrong_args ("--sign [datafile]");
1372       break;
1373         
1374     case aSignEncr: /* sign and encrypt the given file */
1375       log_error ("this command has not yet been implemented\n");
1376       break;
1377
1378     case aClearsign: /* make a clearsig */
1379       log_error ("this command has not yet been implemented\n");
1380       break;
1381
1382     case aVerify:
1383       {
1384         FILE *fp = NULL;
1385
1386         if (argc == 2 && opt.outfile)
1387           log_info ("option --output ignored for a detached signature\n");
1388         else if (opt.outfile)
1389           fp = open_fwrite (opt.outfile);
1390
1391         if (!argc)
1392           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1393         else if (argc == 1)
1394           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1395         else if (argc == 2) /* detached signature (sig, detached) */
1396           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1397         else
1398           wrong_args ("--verify [signature [detached_data]]");
1399
1400         if (fp && fp != stdout)
1401           fclose (fp);
1402       }
1403       break;
1404
1405     case aVerifyFiles:
1406       log_error (_("this command has not yet been implemented\n"));
1407       break;
1408
1409     case aDecrypt:
1410       if (!argc)
1411         gpgsm_decrypt (&ctrl, 0, stdout); /* from stdin */
1412       else if (argc == 1)
1413         gpgsm_decrypt (&ctrl, open_read (*argv), stdout); /* from file */
1414       else
1415         wrong_args ("--decrypt [filename]");
1416       break;
1417
1418     case aDeleteKey:
1419       for (sl=NULL; argc; argc--, argv++)
1420         add_to_strlist (&sl, *argv);
1421       gpgsm_delete (&ctrl, sl);
1422       free_strlist(sl);
1423       break;
1424
1425     case aListSigs:
1426       ctrl.with_chain = 1;
1427     case aListKeys:
1428       for (sl=NULL; argc; argc--, argv++)
1429         add_to_strlist (&sl, *argv);
1430       gpgsm_list_keys (&ctrl, sl, stdout, (0 | (1<<6)));
1431       free_strlist(sl);
1432       break;
1433
1434     case aDumpKeys:
1435       for (sl=NULL; argc; argc--, argv++)
1436         add_to_strlist (&sl, *argv);
1437       gpgsm_list_keys (&ctrl, sl, stdout, (256 | (1<<6)));
1438       free_strlist(sl);
1439       break;
1440
1441     case aListExternalKeys:
1442       for (sl=NULL; argc; argc--, argv++)
1443         add_to_strlist (&sl, *argv);
1444       gpgsm_list_keys (&ctrl, sl, stdout,
1445                        (0 | (1<<7)));
1446       free_strlist(sl);
1447       break;
1448
1449     case aDumpExternalKeys:
1450       for (sl=NULL; argc; argc--, argv++)
1451         add_to_strlist (&sl, *argv);
1452       gpgsm_list_keys (&ctrl, sl, stdout,
1453                        (256 | (1<<7)));
1454       free_strlist(sl);
1455       break;
1456
1457     case aListSecretKeys:
1458       for (sl=NULL; argc; argc--, argv++)
1459         add_to_strlist (&sl, *argv);
1460       gpgsm_list_keys (&ctrl, sl, stdout, (2 | (1<<6)));
1461       free_strlist(sl);
1462       break;
1463
1464     case aDumpSecretKeys:
1465       for (sl=NULL; argc; argc--, argv++)
1466         add_to_strlist (&sl, *argv);
1467       gpgsm_list_keys (&ctrl, sl, stdout, (256 | 2 | (1<<6)));
1468       free_strlist(sl);
1469       break;
1470
1471     case aKeygen: /* generate a key */
1472       log_error ("this function is not yet available from the commandline\n");
1473       break;
1474
1475     case aImport:
1476       gpgsm_import_files (&ctrl, argc, argv, open_read);
1477       break;
1478
1479     case aExport:
1480       for (sl=NULL; argc; argc--, argv++)
1481         add_to_strlist (&sl, *argv);
1482       gpgsm_export (&ctrl, sl, stdout);
1483       free_strlist(sl);
1484       break;
1485
1486     case aExportSecretKeyP12:
1487       if (argc == 1)
1488         gpgsm_p12_export (&ctrl, *argv, stdout);
1489       else
1490         wrong_args ("--export-secret-key-p12 KEY-ID");
1491       break;
1492       
1493     case aSendKeys:
1494     case aRecvKeys:
1495       log_error ("this command has not yet been implemented\n");
1496       break;
1497
1498
1499     case aLearnCard:
1500       if (argc)
1501         wrong_args ("--learn-card");
1502       else
1503         {
1504           int rc = gpgsm_agent_learn (&ctrl);
1505           if (rc)
1506             log_error ("error learning card: %s\n", gpg_strerror (rc));
1507         }
1508       break;
1509
1510     case aPasswd:
1511       if (argc != 1)
1512         wrong_args ("--passwd <key-Id>");
1513       else
1514         {
1515           int rc;
1516           ksba_cert_t cert = NULL;
1517           char *grip = NULL;
1518
1519           rc = gpgsm_find_cert (*argv, &cert);
1520           if (rc)
1521             ;
1522           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1523             rc = gpg_error (GPG_ERR_BUG);
1524           else 
1525             {
1526               char *desc = gpgsm_format_keydesc (cert);
1527               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1528               xfree (desc);
1529             }
1530           if (rc)
1531             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1532           xfree (grip);
1533           ksba_cert_release (cert);
1534         }
1535       break;
1536
1537     case aKeydbClearSomeCertFlags:
1538       for (sl=NULL; argc; argc--, argv++)
1539         add_to_strlist (&sl, *argv);
1540       keydb_clear_some_cert_flags (&ctrl, sl);
1541       free_strlist(sl);
1542       break;
1543
1544
1545     default:
1546         log_error ("invalid command (there is no implicit command)\n");
1547         break;
1548     }
1549   
1550   /* cleanup */
1551   gpgsm_release_certlist (recplist);
1552   gpgsm_release_certlist (signerlist);
1553   FREE_STRLIST(remusr);
1554   FREE_STRLIST(locusr);
1555   gpgsm_exit(0);
1556   return 8; /*NEVER REACHED*/
1557 }
1558
1559 /* Note: This function is used by signal handlers!. */
1560 static void
1561 emergency_cleanup (void)
1562 {
1563   gcry_control (GCRYCTL_TERM_SECMEM );
1564 }
1565
1566
1567 void
1568 gpgsm_exit (int rc)
1569 {
1570   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1571   if (opt.debug & DBG_MEMSTAT_VALUE)
1572     {
1573       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1574       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1575     }
1576   if (opt.debug)
1577     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1578   emergency_cleanup ();
1579   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1580   exit (rc);
1581 }
1582
1583
1584 void
1585 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1586 {
1587   ctrl->include_certs = 1;  /* only include the signer's cert */
1588   ctrl->use_ocsp = opt.enable_ocsp;
1589 }
1590
1591
1592
1593 /* Check whether the filename has the form "-&nnnn", where n is a
1594    non-zero number.  Returns this number or -1 if it is not the case.  */
1595 static int
1596 check_special_filename (const char *fname)
1597 {
1598   if (allow_special_filenames
1599       && fname && *fname == '-' && fname[1] == '&' ) {
1600     int i;
1601     
1602     fname += 2;
1603     for (i=0; isdigit (fname[i]); i++ )
1604       ;
1605     if ( !fname[i] ) 
1606       return atoi (fname);
1607   }
1608   return -1;
1609 }
1610
1611
1612
1613 /* Open the FILENAME for read and return the filedescriptor.  Stop
1614    with an error message in case of problems.  "-" denotes stdin and
1615    if special filenames are allowed the given fd is opened instead. */
1616 static int 
1617 open_read (const char *filename)
1618 {
1619   int fd;
1620
1621   if (filename[0] == '-' && !filename[1])
1622     return 0; /* stdin */
1623   fd = check_special_filename (filename);
1624   if (fd != -1)
1625     return fd;
1626   fd = open (filename, O_RDONLY);
1627   if (fd == -1)
1628     {
1629       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1630       gpgsm_exit (2);
1631     }
1632   return fd;
1633 }
1634
1635 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1636    message in case of problems.  "-" denotes stdout and if special
1637    filenames are allowed the given fd is opened instead. Caller must
1638    close the returned stream unless it is stdout. */
1639 static FILE *
1640 open_fwrite (const char *filename)
1641 {
1642   int fd;
1643   FILE *fp;
1644
1645   if (filename[0] == '-' && !filename[1])
1646     return stdout;
1647
1648   fd = check_special_filename (filename);
1649   if (fd != -1)
1650     {
1651       fp = fdopen (dup (fd), "wb");
1652       if (!fp)
1653         {
1654           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1655           gpgsm_exit (2);
1656         }
1657       return fp;
1658     }
1659   fp = fopen (filename, "wb");
1660   if (!fp)
1661     {
1662       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1663       gpgsm_exit (2);
1664     }
1665   return fp;
1666 }
1667
1668
1669 static void
1670 run_protect_tool (int argc, char **argv)
1671 {
1672   const char *pgm;
1673   char **av;
1674   int i;
1675
1676   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1677     pgm = GNUPG_DEFAULT_PROTECT_TOOL;
1678   else
1679     pgm = opt.protect_tool_program;
1680
1681   av = xcalloc (argc+2, sizeof *av);
1682   av[0] = strrchr (pgm, '/');
1683   if (!av[0])
1684     av[0] = xstrdup (pgm);
1685   for (i=1; argc; i++, argc--, argv++)
1686     av[i] = *argv;
1687   av[i] = NULL;
1688   execv (pgm, av); 
1689   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1690   gpgsm_exit (2);
1691 }