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