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