Added qualified signature features.
[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 (logfile && cmd == aServer)
1224     {
1225       log_set_file (logfile);
1226       log_set_prefix (NULL, 1|2|4);
1227     }
1228
1229   if (gnupg_faked_time_p ())
1230     {
1231       gnupg_isotime_t tbuf;
1232
1233       log_info (_("WARNING: running with faked system time: "));
1234       gnupg_get_isotime (tbuf);
1235       gpgsm_dump_time (tbuf);
1236       log_printf ("\n");
1237     }
1238   
1239 /*FIXME    if (opt.batch) */
1240 /*      tty_batchmode (1); */
1241
1242   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1243
1244   set_debug ();
1245
1246   /* Although we alwasy use gpgsm_exit, we better install a regualr
1247      exit handler so that at least the secure memory gets wiped
1248      out. */
1249   if (atexit (emergency_cleanup))
1250     {
1251       log_error ("atexit failed\n");
1252       gpgsm_exit (2);
1253     }
1254
1255   /* Must do this after dropping setuid, because the mapping functions
1256      may try to load an module and we may have disabled an algorithm. */
1257   if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1258        || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1259     log_error (_("selected cipher algorithm is invalid\n"));
1260
1261   if (def_digest_string)
1262     {
1263       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1264       xfree (def_digest_string);
1265       def_digest_string = NULL;
1266       if (our_md_test_algo(opt.def_digest_algo) )
1267         log_error (_("selected digest algorithm is invalid\n"));
1268     }
1269
1270   if (log_get_errorcount(0))
1271     gpgsm_exit(2);
1272   
1273   /* Set the random seed file. */
1274   if (use_random_seed) {
1275     char *p = make_filename (opt.homedir, "random_seed", NULL);
1276     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1277     xfree(p);
1278   }
1279
1280
1281   if (!cmd && opt.fingerprint && !with_fpr)
1282     set_cmd (&cmd, aListKeys);
1283   
1284   if (!nrings && default_keyring)  /* add default keybox */
1285     keydb_add_resource ("pubring.kbx", 0, 0);
1286   for (sl = nrings; sl; sl = sl->next)
1287     keydb_add_resource (sl->d, 0, 0);
1288   FREE_STRLIST(nrings);
1289
1290   if (!do_not_setup_keys)
1291     {
1292       for (sl = locusr; sl ; sl = sl->next)
1293         {
1294           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1295           if (rc)
1296             {
1297               log_error (_("can't sign using `%s': %s\n"),
1298                          sl->d, gpg_strerror (rc));
1299               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1300                          gpg_err_code (rc) == -1?                      "1":
1301                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1302                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1303                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1304                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1305                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1306                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1307                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1308                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1309                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1310                          "0",
1311                          sl->d, NULL);
1312             }
1313         }
1314       
1315       /* Build the recipient list.  We first add the regular ones and then
1316          the encrypt-to ones because the underlying function will silenty
1317          ignore duplicates and we can't allow to keep a duplicate which is
1318          flagged as encrypt-to as the actually encrypt function would then
1319          complain about no (regular) recipients. */
1320       for (sl = remusr; sl; sl = sl->next)
1321         if (!(sl->flags & 1))
1322           do_add_recipient (&ctrl, sl->d, &recplist, 0);
1323       if (!opt.no_encrypt_to)
1324         {
1325           for (sl = remusr; sl; sl = sl->next)
1326             if ((sl->flags & 1))
1327               do_add_recipient (&ctrl, sl->d, &recplist, 1);
1328         }
1329     }
1330
1331   if (log_get_errorcount(0))
1332     gpgsm_exit(1); /* must stop for invalid recipients */
1333   
1334   fname = argc? *argv : NULL;
1335   
1336   switch (cmd)
1337     {
1338     case aGPGConfList: 
1339       { /* List options and default values in the GPG Conf format.  */
1340
1341         /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1342         /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1343            FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1344 #define GC_OPT_FLAG_NONE        0UL
1345         /* The RUNTIME flag for an option indicates that the option can be
1346            changed at runtime.  */
1347 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
1348         /* The DEFAULT flag for an option indicates that the option has a
1349            default value.  */
1350 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1351         /* The DEF_DESC flag for an option indicates that the option has a
1352            default, which is described by the value of the default field.  */
1353 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1354         /* The NO_ARG_DESC flag for an option indicates that the argument has
1355            a default, which is described by the value of the ARGDEF field.  */
1356 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1357
1358         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1359                 GC_OPT_FLAG_DEFAULT, opt.config_filename);
1360         
1361         printf ("verbose:%lu:\n"
1362                 "quiet:%lu:\n"
1363                 "debug-level:%lu:\"none:\n"
1364                 "log-file:%lu:\n",
1365                 GC_OPT_FLAG_NONE,
1366                 GC_OPT_FLAG_NONE,
1367                 GC_OPT_FLAG_DEFAULT,
1368                 GC_OPT_FLAG_NONE );
1369         printf ("disable-crl-checks:%lu:\n",
1370                 GC_OPT_FLAG_NONE );
1371         printf ("disable-trusted-cert-crl-check:%lu:\n",
1372                 GC_OPT_FLAG_NONE );
1373         printf ("enable-ocsp:%lu:\n",
1374                 GC_OPT_FLAG_NONE );
1375         printf ("include-certs:%lu:1:\n",
1376                 GC_OPT_FLAG_DEFAULT );
1377         printf ("disable-policy-checks:%lu:\n",
1378                 GC_OPT_FLAG_NONE );
1379         printf ("auto-issuer-key-retrieve:%lu:\n",
1380                 GC_OPT_FLAG_NONE );
1381         printf ("prefer-system-dirmngr:%lu:\n",
1382                 GC_OPT_FLAG_NONE );
1383
1384       }
1385       break;
1386
1387     case aServer:
1388       if (debug_wait)
1389         {
1390           log_debug ("waiting for debugger - my pid is %u .....\n",
1391                      (unsigned int)getpid());
1392           sleep (debug_wait);
1393           log_debug ("... okay\n");
1394          }
1395       gpgsm_server (recplist);
1396       break;
1397
1398     case aCallDirmngr:
1399       if (!argc)
1400         wrong_args ("--call-dirmngr <command> {args}");
1401       else
1402         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1403           gpgsm_exit (1);
1404       break;
1405
1406     case aCallProtectTool:
1407       run_protect_tool (argc, argv);
1408       break;
1409
1410     case aEncr: /* encrypt the given file */
1411       set_binary (stdin);
1412       set_binary (stdout);
1413       if (!argc)
1414         gpgsm_encrypt (&ctrl, recplist, 0, stdout); /* from stdin */
1415       else if (argc == 1)
1416         gpgsm_encrypt (&ctrl, recplist, open_read (*argv), stdout); /* from file */
1417       else
1418         wrong_args ("--encrypt [datafile]");
1419       break;
1420
1421     case aSign: /* sign the given file */
1422       /* FIXME: We don't handle --output yet. We should also allow
1423          to concatenate multiple files for signing because that is
1424          what gpg does.*/
1425       set_binary (stdin);
1426       set_binary (stdout);
1427       if (!argc)
1428         gpgsm_sign (&ctrl, signerlist,
1429                     0, detached_sig, stdout); /* create from stdin */
1430       else if (argc == 1)
1431         gpgsm_sign (&ctrl, signerlist,
1432                     open_read (*argv), detached_sig, stdout); /* from file */
1433       else
1434         wrong_args ("--sign [datafile]");
1435       break;
1436         
1437     case aSignEncr: /* sign and encrypt the given file */
1438       log_error ("this command has not yet been implemented\n");
1439       break;
1440
1441     case aClearsign: /* make a clearsig */
1442       log_error ("this command has not yet been implemented\n");
1443       break;
1444
1445     case aVerify:
1446       {
1447         FILE *fp = NULL;
1448
1449         set_binary (stdin);
1450         if (argc == 2 && opt.outfile)
1451           log_info ("option --output ignored for a detached signature\n");
1452         else if (opt.outfile)
1453           fp = open_fwrite (opt.outfile);
1454
1455         if (!argc)
1456           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1457         else if (argc == 1)
1458           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1459         else if (argc == 2) /* detached signature (sig, detached) */
1460           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1461         else
1462           wrong_args ("--verify [signature [detached_data]]");
1463
1464         if (fp && fp != stdout)
1465           fclose (fp);
1466       }
1467       break;
1468
1469     case aVerifyFiles:
1470       log_error (_("this command has not yet been implemented\n"));
1471       break;
1472
1473     case aDecrypt:
1474       set_binary (stdin);
1475       set_binary (stdout);
1476       if (!argc)
1477         gpgsm_decrypt (&ctrl, 0, stdout); /* from stdin */
1478       else if (argc == 1)
1479         gpgsm_decrypt (&ctrl, open_read (*argv), stdout); /* from file */
1480       else
1481         wrong_args ("--decrypt [filename]");
1482       break;
1483
1484     case aDeleteKey:
1485       for (sl=NULL; argc; argc--, argv++)
1486         add_to_strlist (&sl, *argv);
1487       gpgsm_delete (&ctrl, sl);
1488       free_strlist(sl);
1489       break;
1490
1491     case aListSigs:
1492       ctrl.with_chain = 1;
1493     case aListKeys:
1494       for (sl=NULL; argc; argc--, argv++)
1495         add_to_strlist (&sl, *argv);
1496       gpgsm_list_keys (&ctrl, sl, stdout, (0 | (1<<6)));
1497       free_strlist(sl);
1498       break;
1499
1500     case aDumpKeys:
1501       for (sl=NULL; argc; argc--, argv++)
1502         add_to_strlist (&sl, *argv);
1503       gpgsm_list_keys (&ctrl, sl, stdout, (256 | (1<<6)));
1504       free_strlist(sl);
1505       break;
1506
1507     case aListExternalKeys:
1508       for (sl=NULL; argc; argc--, argv++)
1509         add_to_strlist (&sl, *argv);
1510       gpgsm_list_keys (&ctrl, sl, stdout,
1511                        (0 | (1<<7)));
1512       free_strlist(sl);
1513       break;
1514
1515     case aDumpExternalKeys:
1516       for (sl=NULL; argc; argc--, argv++)
1517         add_to_strlist (&sl, *argv);
1518       gpgsm_list_keys (&ctrl, sl, stdout,
1519                        (256 | (1<<7)));
1520       free_strlist(sl);
1521       break;
1522
1523     case aListSecretKeys:
1524       for (sl=NULL; argc; argc--, argv++)
1525         add_to_strlist (&sl, *argv);
1526       gpgsm_list_keys (&ctrl, sl, stdout, (2 | (1<<6)));
1527       free_strlist(sl);
1528       break;
1529
1530     case aDumpSecretKeys:
1531       for (sl=NULL; argc; argc--, argv++)
1532         add_to_strlist (&sl, *argv);
1533       gpgsm_list_keys (&ctrl, sl, stdout, (256 | 2 | (1<<6)));
1534       free_strlist(sl);
1535       break;
1536
1537     case aKeygen: /* generate a key */
1538       log_error ("this function is not yet available from the commandline\n");
1539       break;
1540
1541     case aImport:
1542       gpgsm_import_files (&ctrl, argc, argv, open_read);
1543       break;
1544
1545     case aExport:
1546       set_binary (stdout);
1547       for (sl=NULL; argc; argc--, argv++)
1548         add_to_strlist (&sl, *argv);
1549       gpgsm_export (&ctrl, sl, stdout);
1550       free_strlist(sl);
1551       break;
1552
1553     case aExportSecretKeyP12:
1554       set_binary (stdout);
1555       if (argc == 1)
1556         gpgsm_p12_export (&ctrl, *argv, stdout);
1557       else
1558         wrong_args ("--export-secret-key-p12 KEY-ID");
1559       break;
1560       
1561     case aSendKeys:
1562     case aRecvKeys:
1563       log_error ("this command has not yet been implemented\n");
1564       break;
1565
1566
1567     case aLearnCard:
1568       if (argc)
1569         wrong_args ("--learn-card");
1570       else
1571         {
1572           int rc = gpgsm_agent_learn (&ctrl);
1573           if (rc)
1574             log_error ("error learning card: %s\n", gpg_strerror (rc));
1575         }
1576       break;
1577
1578     case aPasswd:
1579       if (argc != 1)
1580         wrong_args ("--passwd <key-Id>");
1581       else
1582         {
1583           int rc;
1584           ksba_cert_t cert = NULL;
1585           char *grip = NULL;
1586
1587           rc = gpgsm_find_cert (*argv, NULL, &cert);
1588           if (rc)
1589             ;
1590           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1591             rc = gpg_error (GPG_ERR_BUG);
1592           else 
1593             {
1594               char *desc = gpgsm_format_keydesc (cert);
1595               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1596               xfree (desc);
1597             }
1598           if (rc)
1599             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1600           xfree (grip);
1601           ksba_cert_release (cert);
1602         }
1603       break;
1604
1605     case aKeydbClearSomeCertFlags:
1606       for (sl=NULL; argc; argc--, argv++)
1607         add_to_strlist (&sl, *argv);
1608       keydb_clear_some_cert_flags (&ctrl, sl);
1609       free_strlist(sl);
1610       break;
1611
1612
1613     default:
1614         log_error ("invalid command (there is no implicit command)\n");
1615         break;
1616     }
1617   
1618   /* cleanup */
1619   gpgsm_release_certlist (recplist);
1620   gpgsm_release_certlist (signerlist);
1621   FREE_STRLIST(remusr);
1622   FREE_STRLIST(locusr);
1623   gpgsm_exit(0);
1624   return 8; /*NEVER REACHED*/
1625 }
1626
1627 /* Note: This function is used by signal handlers!. */
1628 static void
1629 emergency_cleanup (void)
1630 {
1631   gcry_control (GCRYCTL_TERM_SECMEM );
1632 }
1633
1634
1635 void
1636 gpgsm_exit (int rc)
1637 {
1638   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1639   if (opt.debug & DBG_MEMSTAT_VALUE)
1640     {
1641       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1642       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1643     }
1644   if (opt.debug)
1645     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1646   emergency_cleanup ();
1647   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1648   exit (rc);
1649 }
1650
1651
1652 void
1653 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1654 {
1655   ctrl->include_certs = 1;  /* only include the signer's cert */
1656   ctrl->use_ocsp = opt.enable_ocsp;
1657 }
1658
1659
1660
1661 /* Check whether the filename has the form "-&nnnn", where n is a
1662    non-zero number.  Returns this number or -1 if it is not the case.  */
1663 static int
1664 check_special_filename (const char *fname)
1665 {
1666   if (allow_special_filenames
1667       && fname && *fname == '-' && fname[1] == '&' ) {
1668     int i;
1669     
1670     fname += 2;
1671     for (i=0; isdigit (fname[i]); i++ )
1672       ;
1673     if ( !fname[i] ) 
1674       return atoi (fname);
1675   }
1676   return -1;
1677 }
1678
1679
1680
1681 /* Open the FILENAME for read and return the filedescriptor.  Stop
1682    with an error message in case of problems.  "-" denotes stdin and
1683    if special filenames are allowed the given fd is opened instead. */
1684 static int 
1685 open_read (const char *filename)
1686 {
1687   int fd;
1688
1689   if (filename[0] == '-' && !filename[1])
1690     {
1691       set_binary (stdin);
1692       return 0; /* stdin */
1693     }
1694   fd = check_special_filename (filename);
1695   if (fd != -1)
1696     return fd;
1697   fd = open (filename, O_RDONLY | O_BINARY);
1698   if (fd == -1)
1699     {
1700       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1701       gpgsm_exit (2);
1702     }
1703   return fd;
1704 }
1705
1706 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1707    message in case of problems.  "-" denotes stdout and if special
1708    filenames are allowed the given fd is opened instead. Caller must
1709    close the returned stream unless it is stdout. */
1710 static FILE *
1711 open_fwrite (const char *filename)
1712 {
1713   int fd;
1714   FILE *fp;
1715
1716   if (filename[0] == '-' && !filename[1])
1717     {
1718       set_binary (stdout);
1719       return stdout;
1720     }
1721
1722   fd = check_special_filename (filename);
1723   if (fd != -1)
1724     {
1725       fp = fdopen (dup (fd), "wb");
1726       if (!fp)
1727         {
1728           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1729           gpgsm_exit (2);
1730         }
1731       set_binary (fp);
1732       return fp;
1733     }
1734   fp = fopen (filename, "wb");
1735   if (!fp)
1736     {
1737       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1738       gpgsm_exit (2);
1739     }
1740   return fp;
1741 }
1742
1743
1744 static void
1745 run_protect_tool (int argc, char **argv)
1746 {
1747 #ifndef HAVE_W32_SYSTEM
1748   const char *pgm;
1749   char **av;
1750   int i;
1751
1752   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1753     pgm = GNUPG_DEFAULT_PROTECT_TOOL;
1754   else
1755     pgm = opt.protect_tool_program;
1756
1757   av = xcalloc (argc+2, sizeof *av);
1758   av[0] = strrchr (pgm, '/');
1759   if (!av[0])
1760     av[0] = xstrdup (pgm);
1761   for (i=1; argc; i++, argc--, argv++)
1762     av[i] = *argv;
1763   av[i] = NULL;
1764   execv (pgm, av); 
1765   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1766 #endif /*HAVE_W32_SYSTEM*/
1767   gpgsm_exit (2);
1768 }