The big Assuan error code removal.
[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_t recplist = NULL;
740   certlist_t 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   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
834
835   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
836
837   /* Setup a default control structure for command line mode */
838   memset (&ctrl, 0, sizeof ctrl);
839   gpgsm_init_default_ctrl (&ctrl);
840   ctrl.no_server = 1;
841   ctrl.status_fd = -1; /* not status output */
842   ctrl.autodetect_encoding = 1;
843
844   /* Set the default option file */
845   if (default_config )
846     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
847   /* Set the default policy file */
848   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
849   
850   argc        = orig_argc;
851   argv        = orig_argv;
852   pargs.argc  = &argc;
853   pargs.argv  = &argv;
854   pargs.flags =  1;  /* do not remove the args */
855
856  next_pass:
857   if (configname) {
858     configlineno = 0;
859     configfp = fopen (configname, "r");
860     if (!configfp)
861       {
862         if (default_config)
863           {
864             if (parse_debug)
865               log_info (_("NOTE: no default option file `%s'\n"), configname);
866           }
867         else 
868           {
869             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
870             gpgsm_exit(2);
871           }
872         xfree(configname);
873         configname = NULL;
874       }
875     if (parse_debug && configname)
876       log_info (_("reading options from `%s'\n"), configname);
877     default_config = 0;
878   }
879
880   while (!no_more_options 
881          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
882     {
883       switch (pargs.r_opt)
884         {
885         case aGPGConfList: 
886           set_cmd (&cmd, pargs.r_opt);
887           do_not_setup_keys = 1;
888           nogreeting = 1;
889           break;
890
891         case aServer: 
892           opt.batch = 1;
893           set_cmd (&cmd, aServer);
894           break;
895
896         case aCallDirmngr:
897           opt.batch = 1;
898           set_cmd (&cmd, aCallDirmngr);
899           do_not_setup_keys = 1;
900           break;
901
902         case aCallProtectTool:
903           opt.batch = 1;
904           set_cmd (&cmd, aCallProtectTool);
905           no_more_options = 1; /* Stop parsing. */
906           do_not_setup_keys = 1;
907           break;
908         
909         case aDeleteKey:
910           set_cmd (&cmd, aDeleteKey);
911           /*greeting=1;*/
912           do_not_setup_keys = 1;
913           break;
914
915         case aDetachedSign:
916           detached_sig = 1;
917           set_cmd (&cmd, aSign ); 
918           break;
919
920         case aKeygen:
921           set_cmd (&cmd, aKeygen);
922           greeting=1; 
923           do_not_setup_keys = 1;
924           break;
925
926         case aCheckKeys:
927         case aImport: 
928         case aSendKeys: 
929         case aRecvKeys: 
930         case aExport: 
931         case aExportSecretKeyP12: 
932         case aDumpKeys:
933         case aDumpExternalKeys: 
934         case aDumpSecretKeys: 
935         case aListKeys:
936         case aListExternalKeys: 
937         case aListSecretKeys: 
938         case aListSigs: 
939         case aLearnCard: 
940         case aPasswd: 
941         case aKeydbClearSomeCertFlags:
942           do_not_setup_keys = 1;
943           set_cmd (&cmd, pargs.r_opt);
944           break;
945
946         case aSym:
947         case aDecrypt: 
948         case aEncr: 
949         case aSign: 
950         case aClearsign: 
951         case aVerify: 
952           set_cmd (&cmd, pargs.r_opt);
953           break;
954
955           /* output encoding selection */
956         case oArmor:
957           ctrl.create_pem = 1;
958           break;
959         case oBase64: 
960           ctrl.create_pem = 0;
961           ctrl.create_base64 = 1;
962           break;
963         case oNoArmor: 
964           ctrl.create_pem = 0;
965           ctrl.create_base64 = 0;
966           break;
967           
968           /* Input encoding selection */
969         case oAssumeArmor:
970           ctrl.autodetect_encoding = 0;
971           ctrl.is_pem = 1;
972           ctrl.is_base64 = 0;
973           break;
974         case oAssumeBase64:
975           ctrl.autodetect_encoding = 0;
976           ctrl.is_pem = 0;
977           ctrl.is_base64 = 1;
978           break;
979         case oAssumeBinary:
980           ctrl.autodetect_encoding = 0;
981           ctrl.is_pem = 0;
982           ctrl.is_base64 = 0;
983           break;
984
985         case oDisableCRLChecks:
986           opt.no_crl_check = 1;
987           break;
988         case oEnableCRLChecks:
989           opt.no_crl_check = 0;
990           break;
991         case oDisableTrustedCertCRLCheck:
992           opt.no_trusted_cert_crl_check = 1;
993           break;
994         case oEnableTrustedCertCRLCheck:
995           opt.no_trusted_cert_crl_check = 0;
996           break;
997         case oForceCRLRefresh:
998           opt.force_crl_refresh = 1;
999           break;
1000
1001         case oDisableOCSP:
1002           ctrl.use_ocsp = opt.enable_ocsp = 0;
1003           break;
1004         case oEnableOCSP:
1005           ctrl.use_ocsp = opt.enable_ocsp = 1;
1006           break;
1007
1008         case oIncludeCerts: 
1009           ctrl.include_certs = default_include_certs = pargs.r.ret_int; 
1010           break;
1011
1012         case oPolicyFile:
1013           xfree (opt.policy_file);
1014           if (*pargs.r.ret_str)
1015             opt.policy_file = xstrdup (pargs.r.ret_str);
1016           else
1017             opt.policy_file = NULL;
1018           break;
1019
1020         case oDisablePolicyChecks:
1021           opt.no_policy_check = 1;
1022           break;
1023         case oEnablePolicyChecks:
1024           opt.no_policy_check = 0;
1025           break;
1026           
1027         case oAutoIssuerKeyRetrieve:
1028           opt.auto_issuer_key_retrieve = 1;
1029           break;
1030
1031         case oOutput: opt.outfile = pargs.r.ret_str; break;
1032
1033         
1034         case oQuiet: opt.quiet = 1; break;
1035         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1036         case oDryRun: opt.dry_run = 1; break;
1037
1038         case oVerbose:
1039           opt.verbose++;
1040           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1041           break;
1042         case oNoVerbose:
1043           opt.verbose = 0;
1044           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1045           break;
1046
1047         case oLogFile: logfile = pargs.r.ret_str; break;
1048         case oNoLogFile: logfile = NULL; break;          
1049
1050         case oBatch: 
1051           opt.batch = 1;
1052           greeting = 0;
1053           break;
1054         case oNoBatch: opt.batch = 0; break;
1055           
1056         case oAnswerYes: opt.answer_yes = 1; break;
1057         case oAnswerNo: opt.answer_no = 1; break;
1058
1059         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1060
1061         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1062         case oDebugAll: debug_value = ~0; break;
1063         case oDebugNone: debug_value = 0; break;
1064         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1065         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1066         case oDebugAllowCoreDump:
1067           may_coredump = enable_core_dumps ();
1068           break;
1069         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1070         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1071         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1072
1073         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1074         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1075         case oWithMD5Fingerprint:
1076           opt.with_md5_fingerprint=1; /*fall thru*/
1077         case oWithFingerprint:
1078           with_fpr=1; /*fall thru*/
1079         case oFingerprint:
1080           opt.fingerprint++;
1081           break;
1082
1083         case oOptions:
1084           /* config files may not be nested (silently ignore them) */
1085           if (!configfp)
1086             {
1087               xfree(configname);
1088               configname = xstrdup (pargs.r.ret_str);
1089               goto next_pass;
1090             }
1091           break;
1092         case oNoOptions: break; /* no-options */
1093         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1094         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1095         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
1096         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
1097         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
1098         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1099         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1100         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1101         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1102         case oProtectToolProgram:
1103           opt.protect_tool_program = pargs.r.ret_str; 
1104           break;
1105           
1106         case oFakedSystemTime:
1107           gnupg_set_time ( (time_t)pargs.r.ret_ulong, 0);
1108           break;
1109
1110         case oNoDefKeyring: default_keyring = 0; break;
1111         case oNoGreeting: nogreeting = 1; break;
1112
1113         case oDefaultKey:
1114           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
1115           log_info ("WARNING: --default-key has not yet been implemented\n");
1116           break;
1117         case oDefRecipient:
1118           if (*pargs.r.ret_str)
1119             opt.def_recipient = xstrdup (pargs.r.ret_str);
1120           break;
1121         case oDefRecipientSelf:
1122           xfree (opt.def_recipient);
1123           opt.def_recipient = NULL;
1124           opt.def_recipient_self = 1;
1125           break;
1126         case oNoDefRecipient:
1127           xfree (opt.def_recipient);
1128           opt.def_recipient = NULL;
1129           opt.def_recipient_self = 0;
1130           break;
1131
1132         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1133         case oWithColons: ctrl.with_colons = 1; break;
1134         case oWithValidation: ctrl.with_validation=1; break;
1135         case oWithEphemeralKeys: opt.with_ephemeral_keys=1; break;
1136
1137         case oSkipVerify: opt.skip_verify=1; break;
1138
1139         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1140         case oEncryptTo: /* Store the recipient in the second list */
1141           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1142           sl->flags = 1;
1143           break;
1144
1145         case oRecipient: /* store the recipient */
1146           add_to_strlist ( &remusr, pargs.r.ret_str);
1147           break;
1148
1149         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
1150         case oTextmode: /*fixme:opt.textmode=1;*/  break;
1151
1152         case oUser: /* store the local users, the first one is the default */
1153           if (!opt.local_user)
1154             opt.local_user = pargs.r.ret_str;
1155           add_to_strlist (&locusr, pargs.r.ret_str);
1156           break;
1157
1158         case oNoSecmemWarn:
1159           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1160           break;
1161
1162         case oCipherAlgo:
1163           opt.def_cipher_algoid = pargs.r.ret_str;
1164           break;
1165
1166         case oDisableCipherAlgo: 
1167           {
1168             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1169             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1170           }
1171           break;
1172         case oDisablePubkeyAlgo: 
1173           {
1174             int algo = gcry_pk_map_name (pargs.r.ret_str);
1175             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1176           }
1177           break;
1178
1179         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1180         case oNoRandomSeedFile: use_random_seed = 0; break;
1181
1182         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1183           
1184
1185         case aDummy:
1186           break;
1187         default: 
1188           pargs.err = configfp? 1:2; 
1189           break;
1190         }
1191     }
1192
1193   if (configfp)
1194     {
1195       fclose (configfp);
1196       configfp = NULL;
1197       /* Keep a copy of the config filename. */
1198       opt.config_filename = configname;
1199       configname = NULL;
1200       goto next_pass;
1201     }
1202   xfree (configname);
1203   configname = NULL;
1204
1205   if (!opt.config_filename)
1206     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1207
1208   if (log_get_errorcount(0))
1209     gpgsm_exit(2);
1210   
1211   if (nogreeting)
1212     greeting = 0;
1213   
1214   if (greeting)
1215     {
1216       fprintf(stderr, "%s %s; %s\n",
1217               strusage(11), strusage(13), strusage(14) );
1218       fprintf(stderr, "%s\n", strusage(15) );
1219     }
1220 #  ifdef IS_DEVELOPMENT_VERSION
1221   if (!opt.batch)
1222     {
1223       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1224       log_info ("It is only intended for test purposes and should NOT be\n");
1225       log_info ("used in a production environment or with production keys!\n");
1226     }
1227 #  endif
1228
1229   if (may_coredump && !opt.quiet)
1230     log_info (_("WARNING: program may create a core file!\n"));
1231
1232 /*   if (opt.qualsig_approval && !opt.quiet) */
1233 /*     log_info (_("This software has offically been approved to " */
1234 /*                 "create and verify\n" */
1235 /*                 "qualified signatures according to German law.\n")); */
1236
1237   if (logfile && cmd == aServer)
1238     {
1239       log_set_file (logfile);
1240       log_set_prefix (NULL, 1|2|4);
1241     }
1242
1243   if (gnupg_faked_time_p ())
1244     {
1245       gnupg_isotime_t tbuf;
1246
1247       log_info (_("WARNING: running with faked system time: "));
1248       gnupg_get_isotime (tbuf);
1249       gpgsm_dump_time (tbuf);
1250       log_printf ("\n");
1251     }
1252   
1253 /*FIXME    if (opt.batch) */
1254 /*      tty_batchmode (1); */
1255
1256   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1257
1258   set_debug ();
1259
1260   /* Although we alwasy use gpgsm_exit, we better install a regualr
1261      exit handler so that at least the secure memory gets wiped
1262      out. */
1263   if (atexit (emergency_cleanup))
1264     {
1265       log_error ("atexit failed\n");
1266       gpgsm_exit (2);
1267     }
1268
1269   /* Must do this after dropping setuid, because the mapping functions
1270      may try to load an module and we may have disabled an algorithm. */
1271   if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1272        || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1273     log_error (_("selected cipher algorithm is invalid\n"));
1274
1275   if (def_digest_string)
1276     {
1277       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1278       xfree (def_digest_string);
1279       def_digest_string = NULL;
1280       if (our_md_test_algo(opt.def_digest_algo) )
1281         log_error (_("selected digest algorithm is invalid\n"));
1282     }
1283
1284   if (log_get_errorcount(0))
1285     gpgsm_exit(2);
1286   
1287   /* Set the random seed file. */
1288   if (use_random_seed) {
1289     char *p = make_filename (opt.homedir, "random_seed", NULL);
1290     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1291     xfree(p);
1292   }
1293
1294
1295   if (!cmd && opt.fingerprint && !with_fpr)
1296     set_cmd (&cmd, aListKeys);
1297   
1298   if (!nrings && default_keyring)  /* add default keybox */
1299     keydb_add_resource ("pubring.kbx", 0, 0);
1300   for (sl = nrings; sl; sl = sl->next)
1301     keydb_add_resource (sl->d, 0, 0);
1302   FREE_STRLIST(nrings);
1303
1304   if (!do_not_setup_keys)
1305     {
1306       for (sl = locusr; sl ; sl = sl->next)
1307         {
1308           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1309           if (rc)
1310             {
1311               log_error (_("can't sign using `%s': %s\n"),
1312                          sl->d, gpg_strerror (rc));
1313               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1314                          gpg_err_code (rc) == -1?                      "1":
1315                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1316                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1317                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1318                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1319                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1320                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1321                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1322                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1323                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1324                          "0",
1325                          sl->d, NULL);
1326             }
1327         }
1328       
1329       /* Build the recipient list.  We first add the regular ones and then
1330          the encrypt-to ones because the underlying function will silenty
1331          ignore duplicates and we can't allow to keep a duplicate which is
1332          flagged as encrypt-to as the actually encrypt function would then
1333          complain about no (regular) recipients. */
1334       for (sl = remusr; sl; sl = sl->next)
1335         if (!(sl->flags & 1))
1336           do_add_recipient (&ctrl, sl->d, &recplist, 0);
1337       if (!opt.no_encrypt_to)
1338         {
1339           for (sl = remusr; sl; sl = sl->next)
1340             if ((sl->flags & 1))
1341               do_add_recipient (&ctrl, sl->d, &recplist, 1);
1342         }
1343     }
1344
1345   if (log_get_errorcount(0))
1346     gpgsm_exit(1); /* must stop for invalid recipients */
1347   
1348   fname = argc? *argv : NULL;
1349   
1350   switch (cmd)
1351     {
1352     case aGPGConfList: 
1353       { /* List options and default values in the GPG Conf format.  */
1354
1355         /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1356         /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1357            FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1358 #define GC_OPT_FLAG_NONE        0UL
1359         /* The RUNTIME flag for an option indicates that the option can be
1360            changed at runtime.  */
1361 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
1362         /* The DEFAULT flag for an option indicates that the option has a
1363            default value.  */
1364 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1365         /* The DEF_DESC flag for an option indicates that the option has a
1366            default, which is described by the value of the default field.  */
1367 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1368         /* The NO_ARG_DESC flag for an option indicates that the argument has
1369            a default, which is described by the value of the ARGDEF field.  */
1370 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1371
1372         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1373                 GC_OPT_FLAG_DEFAULT, opt.config_filename);
1374         
1375         printf ("verbose:%lu:\n"
1376                 "quiet:%lu:\n"
1377                 "debug-level:%lu:\"none:\n"
1378                 "log-file:%lu:\n",
1379                 GC_OPT_FLAG_NONE,
1380                 GC_OPT_FLAG_NONE,
1381                 GC_OPT_FLAG_DEFAULT,
1382                 GC_OPT_FLAG_NONE );
1383         printf ("disable-crl-checks:%lu:\n",
1384                 GC_OPT_FLAG_NONE );
1385         printf ("disable-trusted-cert-crl-check:%lu:\n",
1386                 GC_OPT_FLAG_NONE );
1387         printf ("enable-ocsp:%lu:\n",
1388                 GC_OPT_FLAG_NONE );
1389         printf ("include-certs:%lu:1:\n",
1390                 GC_OPT_FLAG_DEFAULT );
1391         printf ("disable-policy-checks:%lu:\n",
1392                 GC_OPT_FLAG_NONE );
1393         printf ("auto-issuer-key-retrieve:%lu:\n",
1394                 GC_OPT_FLAG_NONE );
1395         printf ("prefer-system-dirmngr:%lu:\n",
1396                 GC_OPT_FLAG_NONE );
1397
1398       }
1399       break;
1400
1401     case aServer:
1402       if (debug_wait)
1403         {
1404           log_debug ("waiting for debugger - my pid is %u .....\n",
1405                      (unsigned int)getpid());
1406           sleep (debug_wait);
1407           log_debug ("... okay\n");
1408          }
1409       gpgsm_server (recplist);
1410       break;
1411
1412     case aCallDirmngr:
1413       if (!argc)
1414         wrong_args ("--call-dirmngr <command> {args}");
1415       else
1416         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1417           gpgsm_exit (1);
1418       break;
1419
1420     case aCallProtectTool:
1421       run_protect_tool (argc, argv);
1422       break;
1423
1424     case aEncr: /* Encrypt the given file. */
1425       {
1426         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1427
1428         set_binary (stdin);
1429
1430         if (!argc) /* Source is stdin. */
1431           gpgsm_encrypt (&ctrl, recplist, 0, fp); 
1432         else if (argc == 1)  /* Source is the given file. */
1433           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1434         else
1435           wrong_args ("--encrypt [datafile]");
1436
1437         if (fp != stdout)
1438           fclose (fp);
1439       }
1440       break;
1441
1442     case aSign: /* Sign the given file. */
1443       {
1444         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1445
1446         /* Fixme: We should also allow to concatenate multiple files for
1447            signing because that is what gpg does.*/
1448         set_binary (stdin);
1449         if (!argc) /* Create from stdin. */
1450           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp); 
1451         else if (argc == 1) /* From file. */
1452           gpgsm_sign (&ctrl, signerlist,
1453                       open_read (*argv), detached_sig, fp); 
1454         else
1455           wrong_args ("--sign [datafile]");
1456
1457         if (fp != stdout)
1458           fclose (fp);
1459       }
1460       break;
1461         
1462     case aSignEncr: /* sign and encrypt the given file */
1463       log_error ("this command has not yet been implemented\n");
1464       break;
1465
1466     case aClearsign: /* make a clearsig */
1467       log_error ("this command has not yet been implemented\n");
1468       break;
1469
1470     case aVerify:
1471       {
1472         FILE *fp = NULL;
1473
1474         set_binary (stdin);
1475         if (argc == 2 && opt.outfile)
1476           log_info ("option --output ignored for a detached signature\n");
1477         else if (opt.outfile)
1478           fp = open_fwrite (opt.outfile);
1479
1480         if (!argc)
1481           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1482         else if (argc == 1)
1483           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1484         else if (argc == 2) /* detached signature (sig, detached) */
1485           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1486         else
1487           wrong_args ("--verify [signature [detached_data]]");
1488
1489         if (fp && fp != stdout)
1490           fclose (fp);
1491       }
1492       break;
1493
1494     case aVerifyFiles:
1495       log_error (_("this command has not yet been implemented\n"));
1496       break;
1497
1498     case aDecrypt:
1499       {
1500         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1501
1502         set_binary (stdin);
1503         if (!argc)
1504           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1505         else if (argc == 1)
1506           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1507         else
1508           wrong_args ("--decrypt [filename]");
1509         if (fp != stdout)
1510           fclose (fp);
1511       }
1512       break;
1513
1514     case aDeleteKey:
1515       for (sl=NULL; argc; argc--, argv++)
1516         add_to_strlist (&sl, *argv);
1517       gpgsm_delete (&ctrl, sl);
1518       free_strlist(sl);
1519       break;
1520
1521     case aListSigs:
1522       ctrl.with_chain = 1;
1523     case aListKeys:
1524       for (sl=NULL; argc; argc--, argv++)
1525         add_to_strlist (&sl, *argv);
1526       gpgsm_list_keys (&ctrl, sl, stdout, (0 | (1<<6)));
1527       free_strlist(sl);
1528       break;
1529
1530     case aDumpKeys:
1531       for (sl=NULL; argc; argc--, argv++)
1532         add_to_strlist (&sl, *argv);
1533       gpgsm_list_keys (&ctrl, sl, stdout, (256 | (1<<6)));
1534       free_strlist(sl);
1535       break;
1536
1537     case aListExternalKeys:
1538       for (sl=NULL; argc; argc--, argv++)
1539         add_to_strlist (&sl, *argv);
1540       gpgsm_list_keys (&ctrl, sl, stdout,
1541                        (0 | (1<<7)));
1542       free_strlist(sl);
1543       break;
1544
1545     case aDumpExternalKeys:
1546       for (sl=NULL; argc; argc--, argv++)
1547         add_to_strlist (&sl, *argv);
1548       gpgsm_list_keys (&ctrl, sl, stdout,
1549                        (256 | (1<<7)));
1550       free_strlist(sl);
1551       break;
1552
1553     case aListSecretKeys:
1554       for (sl=NULL; argc; argc--, argv++)
1555         add_to_strlist (&sl, *argv);
1556       gpgsm_list_keys (&ctrl, sl, stdout, (2 | (1<<6)));
1557       free_strlist(sl);
1558       break;
1559
1560     case aDumpSecretKeys:
1561       for (sl=NULL; argc; argc--, argv++)
1562         add_to_strlist (&sl, *argv);
1563       gpgsm_list_keys (&ctrl, sl, stdout, (256 | 2 | (1<<6)));
1564       free_strlist(sl);
1565       break;
1566
1567     case aKeygen: /* generate a key */
1568       log_error ("this function is not yet available from the commandline\n");
1569       break;
1570
1571     case aImport:
1572       gpgsm_import_files (&ctrl, argc, argv, open_read);
1573       break;
1574
1575     case aExport:
1576       {
1577         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1578
1579         for (sl=NULL; argc; argc--, argv++)
1580           add_to_strlist (&sl, *argv);
1581         gpgsm_export (&ctrl, sl, fp);
1582         free_strlist(sl);
1583         if (fp != stdout)
1584           fclose (fp);
1585       }
1586       break;
1587
1588     case aExportSecretKeyP12:
1589       {
1590         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1591
1592         if (argc == 1)
1593           gpgsm_p12_export (&ctrl, *argv, stdout);
1594         else
1595           wrong_args ("--export-secret-key-p12 KEY-ID");
1596         if (fp != stdout)
1597           fclose (fp);
1598       }
1599       break;
1600       
1601     case aSendKeys:
1602     case aRecvKeys:
1603       log_error ("this command has not yet been implemented\n");
1604       break;
1605
1606
1607     case aLearnCard:
1608       if (argc)
1609         wrong_args ("--learn-card");
1610       else
1611         {
1612           int rc = gpgsm_agent_learn (&ctrl);
1613           if (rc)
1614             log_error ("error learning card: %s\n", gpg_strerror (rc));
1615         }
1616       break;
1617
1618     case aPasswd:
1619       if (argc != 1)
1620         wrong_args ("--passwd <key-Id>");
1621       else
1622         {
1623           int rc;
1624           ksba_cert_t cert = NULL;
1625           char *grip = NULL;
1626
1627           rc = gpgsm_find_cert (*argv, NULL, &cert);
1628           if (rc)
1629             ;
1630           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1631             rc = gpg_error (GPG_ERR_BUG);
1632           else 
1633             {
1634               char *desc = gpgsm_format_keydesc (cert);
1635               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1636               xfree (desc);
1637             }
1638           if (rc)
1639             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1640           xfree (grip);
1641           ksba_cert_release (cert);
1642         }
1643       break;
1644
1645     case aKeydbClearSomeCertFlags:
1646       for (sl=NULL; argc; argc--, argv++)
1647         add_to_strlist (&sl, *argv);
1648       keydb_clear_some_cert_flags (&ctrl, sl);
1649       free_strlist(sl);
1650       break;
1651
1652
1653     default:
1654         log_error ("invalid command (there is no implicit command)\n");
1655         break;
1656     }
1657   
1658   /* cleanup */
1659   gpgsm_release_certlist (recplist);
1660   gpgsm_release_certlist (signerlist);
1661   FREE_STRLIST(remusr);
1662   FREE_STRLIST(locusr);
1663   gpgsm_exit(0);
1664   return 8; /*NEVER REACHED*/
1665 }
1666
1667 /* Note: This function is used by signal handlers!. */
1668 static void
1669 emergency_cleanup (void)
1670 {
1671   gcry_control (GCRYCTL_TERM_SECMEM );
1672 }
1673
1674
1675 void
1676 gpgsm_exit (int rc)
1677 {
1678   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1679   if (opt.debug & DBG_MEMSTAT_VALUE)
1680     {
1681       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1682       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1683     }
1684   if (opt.debug)
1685     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1686   emergency_cleanup ();
1687   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1688   exit (rc);
1689 }
1690
1691
1692 void
1693 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1694 {
1695   ctrl->include_certs = default_include_certs;
1696   ctrl->use_ocsp = opt.enable_ocsp;
1697 }
1698
1699
1700
1701 /* Check whether the filename has the form "-&nnnn", where n is a
1702    non-zero number.  Returns this number or -1 if it is not the case.  */
1703 static int
1704 check_special_filename (const char *fname)
1705 {
1706   if (allow_special_filenames
1707       && fname && *fname == '-' && fname[1] == '&' ) {
1708     int i;
1709     
1710     fname += 2;
1711     for (i=0; isdigit (fname[i]); i++ )
1712       ;
1713     if ( !fname[i] ) 
1714       return atoi (fname);
1715   }
1716   return -1;
1717 }
1718
1719
1720
1721 /* Open the FILENAME for read and return the filedescriptor.  Stop
1722    with an error message in case of problems.  "-" denotes stdin and
1723    if special filenames are allowed the given fd is opened instead. */
1724 static int 
1725 open_read (const char *filename)
1726 {
1727   int fd;
1728
1729   if (filename[0] == '-' && !filename[1])
1730     {
1731       set_binary (stdin);
1732       return 0; /* stdin */
1733     }
1734   fd = check_special_filename (filename);
1735   if (fd != -1)
1736     return fd;
1737   fd = open (filename, O_RDONLY | O_BINARY);
1738   if (fd == -1)
1739     {
1740       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1741       gpgsm_exit (2);
1742     }
1743   return fd;
1744 }
1745
1746 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1747    message in case of problems.  "-" denotes stdout and if special
1748    filenames are allowed the given fd is opened instead. Caller must
1749    close the returned stream unless it is stdout. */
1750 static FILE *
1751 open_fwrite (const char *filename)
1752 {
1753   int fd;
1754   FILE *fp;
1755
1756   if (filename[0] == '-' && !filename[1])
1757     {
1758       set_binary (stdout);
1759       return stdout;
1760     }
1761
1762   fd = check_special_filename (filename);
1763   if (fd != -1)
1764     {
1765       fp = fdopen (dup (fd), "wb");
1766       if (!fp)
1767         {
1768           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1769           gpgsm_exit (2);
1770         }
1771       set_binary (fp);
1772       return fp;
1773     }
1774   fp = fopen (filename, "wb");
1775   if (!fp)
1776     {
1777       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1778       gpgsm_exit (2);
1779     }
1780   return fp;
1781 }
1782
1783
1784 static void
1785 run_protect_tool (int argc, char **argv)
1786 {
1787 #ifndef HAVE_W32_SYSTEM
1788   const char *pgm;
1789   char **av;
1790   int i;
1791
1792   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1793     pgm = GNUPG_DEFAULT_PROTECT_TOOL;
1794   else
1795     pgm = opt.protect_tool_program;
1796
1797   av = xcalloc (argc+2, sizeof *av);
1798   av[0] = strrchr (pgm, '/');
1799   if (!av[0])
1800     av[0] = xstrdup (pgm);
1801   for (i=1; argc; i++, argc--, argv++)
1802     av[i] = *argv;
1803   av[i] = NULL;
1804   execv (pgm, av); 
1805   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1806 #endif /*HAVE_W32_SYSTEM*/
1807   gpgsm_exit (2);
1808 }