[g13] Add RECIPEINT and CREATE command.
[gnupg.git] / sm / gpgsm.c
1 /* gpgsm.c - GnuPG for S/MIME 
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007, 2008  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
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 /*#include <mcheck.h>*/
30
31 #include "gpgsm.h"
32 #include <gcrypt.h>
33 #include <assuan.h> /* malloc hooks */
34
35 #include "../kbx/keybox.h" /* malloc hooks */
36 #include "i18n.h"
37 #include "keydb.h"
38 #include "sysutils.h"
39 #include "gc-opt-flags.h"
40
41
42 #ifndef O_BINARY
43 #define O_BINARY 0
44 #endif
45
46 enum cmd_and_opt_values {
47   aNull = 0,
48   oArmor        = 'a',
49   aDetachedSign = 'b',
50   aSym          = 'c',
51   aDecrypt      = 'd',
52   aEncr         = 'e',
53   aListKeys     = 'k',
54   aListSecretKeys = 'K',
55   oDryRun       = 'n',
56   oOutput       = 'o',
57   oQuiet        = 'q',
58   oRecipient    = 'r',
59   aSign         = 's',
60   oUser         = 'u',
61   oVerbose      = 'v',
62   oBatch        = 500,
63   aClearsign,
64   aKeygen,
65   aSignEncr,
66   aDeleteKey,
67   aImport,
68   aVerify,
69   aListExternalKeys,
70   aListChain,
71   aSendKeys,
72   aRecvKeys,
73   aExport,
74   aExportSecretKeyP12,
75   aServer,                        
76   aLearnCard,
77   aCallDirmngr,
78   aCallProtectTool,
79   aPasswd,
80   aGPGConfList,
81   aGPGConfTest,
82   aDumpKeys,
83   aDumpChain,
84   aDumpSecretKeys,
85   aDumpExternalKeys,
86   aKeydbClearSomeCertFlags,
87   aFingerprint,
88
89   oOptions,
90   oDebug,
91   oDebugLevel,
92   oDebugAll,
93   oDebugNone,
94   oDebugWait,
95   oDebugAllowCoreDump,
96   oDebugNoChainValidation,
97   oDebugIgnoreExpiration,
98   oFixedPassphrase,
99   oLogFile,
100   oNoLogFile,
101   oAuditLog,
102
103   oEnableSpecialFilenames,
104
105   oAgentProgram,
106   oDisplay,
107   oTTYname,
108   oTTYtype,
109   oLCctype,
110   oLCmessages,
111   oXauthority,
112
113   oPreferSystemDirmngr,
114   oDirmngrProgram,
115   oDisableDirmngr,
116   oProtectToolProgram,
117   oFakedSystemTime,
118
119
120   oAssumeArmor,
121   oAssumeBase64,
122   oAssumeBinary,
123
124   oBase64,
125   oNoArmor,
126   oP12Charset,
127
128   oDisableCRLChecks,
129   oEnableCRLChecks,
130   oDisableTrustedCertCRLCheck,
131   oEnableTrustedCertCRLCheck,
132   oForceCRLRefresh,
133
134   oDisableOCSP,
135   oEnableOCSP,
136
137   oIncludeCerts,
138   oPolicyFile,
139   oDisablePolicyChecks,
140   oEnablePolicyChecks,
141   oAutoIssuerKeyRetrieve,
142   
143   oWithFingerprint,
144   oWithMD5Fingerprint,
145   oAnswerYes,
146   oAnswerNo,
147   oKeyring,
148   oDefaultKey,
149   oDefRecipient,
150   oDefRecipientSelf,
151   oNoDefRecipient,
152   oStatusFD,
153   oCipherAlgo,
154   oDigestAlgo,
155   oExtraDigestAlgo,
156   oNoVerbose,
157   oNoSecmemWarn,
158   oNoDefKeyring,
159   oNoGreeting,
160   oNoTTY,
161   oNoOptions,
162   oNoBatch,
163   oHomedir,
164   oWithColons,
165   oWithKeyData,
166   oWithValidation,
167   oWithEphemeralKeys,
168   oSkipVerify,
169   oValidationModel,
170   oKeyServer,
171   oEncryptTo,
172   oNoEncryptTo,
173   oLoggerFD,
174   oDisableCipherAlgo,
175   oDisablePubkeyAlgo,
176   oIgnoreTimeConflict,
177   oNoRandomSeedFile,
178   oNoCommonCertsImport
179  };
180
181
182 static ARGPARSE_OPTS opts[] = {
183
184   ARGPARSE_group (300, N_("@Commands:\n ")),
185
186   ARGPARSE_c (aSign, "sign", N_("make a signature")),
187   ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature") ),
188   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
189   ARGPARSE_c (aEncr, "encrypt", N_("encrypt data")),
190   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
191   ARGPARSE_c (aDecrypt, "decrypt", N_("decrypt data (default)")),
192   ARGPARSE_c (aVerify, "verify",  N_("verify a signature")),
193   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
194   ARGPARSE_c (aListExternalKeys, "list-external-keys", 
195               N_("list external keys")),
196   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
197   ARGPARSE_c (aListChain,   "list-chain",  N_("list certificate chain")), 
198   ARGPARSE_c (aFingerprint, "fingerprint", N_("list keys and fingerprints")),
199   ARGPARSE_c (aKeygen, "gen-key", N_("generate a new key pair")),
200   ARGPARSE_c (aDeleteKey, "delete-keys", 
201               N_("remove keys from the public keyring")),
202   ARGPARSE_c (aSendKeys, "send-keys", N_("export keys to a key server")),
203   ARGPARSE_c (aRecvKeys, "recv-keys", N_("import keys from a key server")),
204   ARGPARSE_c (aImport, "import", N_("import certificates")),
205   ARGPARSE_c (aExport, "export", N_("export certificates")),
206   ARGPARSE_c (aExportSecretKeyP12, "export-secret-key-p12", "@"), 
207   ARGPARSE_c (aLearnCard, "learn-card", N_("register a smartcard")),
208   ARGPARSE_c (aServer, "server", N_("run in server mode")),
209   ARGPARSE_c (aCallDirmngr, "call-dirmngr", 
210               N_("pass a command to the dirmngr")),
211   ARGPARSE_c (aCallProtectTool, "call-protect-tool",
212               N_("invoke gpg-protect-tool")),
213   ARGPARSE_c (aPasswd, "passwd", N_("change a passphrase")),
214   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
215   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
216
217   ARGPARSE_c (aDumpKeys, "dump-cert", "@"),
218   ARGPARSE_c (aDumpKeys, "dump-keys", "@"),
219   ARGPARSE_c (aDumpChain, "dump-chain", "@"),
220   ARGPARSE_c (aDumpExternalKeys, "dump-external-keys", "@"),
221   ARGPARSE_c (aDumpSecretKeys, "dump-secret-keys", "@"),
222   ARGPARSE_c (aKeydbClearSomeCertFlags, "keydb-clear-some-cert-flags", "@"),
223
224   ARGPARSE_group (301, N_("@\nOptions:\n ")),
225
226   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
227   ARGPARSE_s_n (oArmor, "armour", "@"),
228   ARGPARSE_s_n (oBase64, "base64", N_("create base-64 encoded output")),
229
230   ARGPARSE_s_s (oP12Charset, "p12-charset", "@"),
231
232   ARGPARSE_s_n (oAssumeArmor, "assume-armor", 
233                 N_("assume input is in PEM format")),
234   ARGPARSE_s_n (oAssumeBase64, "assume-base64",
235                 N_("assume input is in base-64 format")),
236   ARGPARSE_s_n (oAssumeBinary, "assume-binary", 
237                 N_("assume input is in binary format")),
238
239   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
240
241   ARGPARSE_s_n (oPreferSystemDirmngr,"prefer-system-dirmngr",
242                 N_("use system's dirmngr if available")),
243
244   ARGPARSE_s_n (oDisableCRLChecks, "disable-crl-checks", 
245                 N_("never consult a CRL")),
246   ARGPARSE_s_n (oEnableCRLChecks, "enable-crl-checks", "@"),
247   ARGPARSE_s_n (oDisableTrustedCertCRLCheck,
248                 "disable-trusted-cert-crl-check", "@"),
249   ARGPARSE_s_n (oEnableTrustedCertCRLCheck, 
250                 "enable-trusted-cert-crl-check", "@"),
251
252   ARGPARSE_s_n (oForceCRLRefresh, "force-crl-refresh", "@"),
253
254   ARGPARSE_s_n (oDisableOCSP, "disable-ocsp", "@"),
255   ARGPARSE_s_n (oEnableOCSP,  "enable-ocsp", N_("check validity using OCSP")),
256
257   ARGPARSE_s_s (oValidationModel, "validation-model", "@"),
258
259   ARGPARSE_s_i (oIncludeCerts, "include-certs", 
260                 N_("|N|number of certificates to include") ),
261
262   ARGPARSE_s_s (oPolicyFile, "policy-file",
263                 N_("|FILE|take policy information from FILE")),
264
265   ARGPARSE_s_n (oDisablePolicyChecks, "disable-policy-checks",
266                 N_("do not check certificate policies")),
267   ARGPARSE_s_n (oEnablePolicyChecks, "enable-policy-checks", "@"),
268
269   ARGPARSE_s_n (oAutoIssuerKeyRetrieve, "auto-issuer-key-retrieve",
270                 N_("fetch missing issuer certificates")),
271
272   ARGPARSE_s_s (oEncryptTo, "encrypt-to", "@"),
273   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
274
275   ARGPARSE_s_s (oUser, "local-user",
276                 N_("|USER-ID|use USER-ID to sign or decrypt")),
277
278   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
279   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
280   ARGPARSE_s_n (oQuiet, "quiet",  N_("be somewhat more quiet")),
281   ARGPARSE_s_n (oNoTTY, "no-tty", N_("don't use the terminal at all")),
282   ARGPARSE_s_s (oLogFile, "log-file",
283                 N_("|FILE|write a server mode log to FILE")),
284   ARGPARSE_s_n (oNoLogFile, "no-log-file", "@"),
285   ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
286
287   ARGPARSE_s_s (oAuditLog, "audit-log", 
288                 N_("|FILE|write an audit log to FILE")),
289   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
290   ARGPARSE_s_n (oBatch, "batch", N_("batch mode: never ask")),
291   ARGPARSE_s_n (oAnswerYes, "yes", N_("assume yes on most questions")),
292   ARGPARSE_s_n (oAnswerNo,  "no",  N_("assume no on most questions")),
293
294   ARGPARSE_s_s (oKeyring, "keyring",
295                 N_("|FILE|add keyring to the list of keyrings")),
296
297   ARGPARSE_s_s (oDefaultKey, "default-key",
298                 N_("|USER-ID|use USER-ID as default secret key")),
299
300   /* Not yet used: */
301   /*   ARGPARSE_s_s (oDefRecipient, "default-recipient", */
302   /*                  N_("|NAME|use NAME as default recipient")), */
303   /*   ARGPARSE_s_n (oDefRecipientSelf, "default-recipient-self", */
304   /*                  N_("use the default key as default recipient")), */
305   /*   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"), */
306
307   ARGPARSE_s_s (oKeyServer, "keyserver",
308                 N_("|SPEC|use this keyserver to lookup keys")),
309   ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
310
311   ARGPARSE_p_u (oDebug, "debug", "@"),
312   ARGPARSE_s_s (oDebugLevel, "debug-level",
313                 N_("|LEVEL|set the debugging level to LEVEL")),
314   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
315   ARGPARSE_s_n (oDebugNone, "debug-none", "@"),
316   ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
317   ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
318   ARGPARSE_s_n (oDebugNoChainValidation, "debug-no-chain-validation", "@"),
319   ARGPARSE_s_n (oDebugIgnoreExpiration,  "debug-ignore-expiration", "@"),
320   ARGPARSE_s_s (oFixedPassphrase, "fixed-passphrase", "@"),
321
322   ARGPARSE_s_i (oStatusFD, "status-fd",
323                 N_("|FD|write status info to this FD")),
324
325   ARGPARSE_s_s (oCipherAlgo, "cipher-algo", 
326                 N_("|NAME|use cipher algorithm NAME")),
327   ARGPARSE_s_s (oDigestAlgo, "digest-algo",
328                 N_("|NAME|use message digest algorithm NAME")),
329   ARGPARSE_s_s (oExtraDigestAlgo, "extra-digest-algo", "@"),
330     
331
332   ARGPARSE_group (302, N_(
333   "@\n(See the man page for a complete listing of all commands and options)\n"
334   )),
335
336   ARGPARSE_group (303, N_("@\nExamples:\n\n"
337     " -se -r Bob [file]          sign and encrypt for user Bob\n"
338     " --clearsign [file]         make a clear text signature\n"
339     " --detach-sign [file]       make a detached signature\n"
340     " --list-keys [names]        show keys\n"
341     " --fingerprint [names]      show fingerprints\n"  )),
342
343   /* Hidden options. */
344   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
345   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
346   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"), 
347   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
348   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
349   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
350   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
351   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
352   ARGPARSE_s_s (oHomedir, "homedir", "@"),   
353   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
354   ARGPARSE_s_s (oDisplay,    "display", "@"),
355   ARGPARSE_s_s (oTTYname,    "ttyname", "@"),
356   ARGPARSE_s_s (oTTYtype,    "ttytype", "@"),
357   ARGPARSE_s_s (oLCctype,    "lc-ctype", "@"),
358   ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
359   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
360   ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
361   ARGPARSE_s_n (oDisableDirmngr, "disable-dirmngr", "@"),
362   ARGPARSE_s_s (oProtectToolProgram, "protect-tool-program", "@"),
363   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
364   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
365   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
366   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
367   ARGPARSE_s_n (oWithValidation, "with-validation", "@"),
368   ARGPARSE_s_n (oWithMD5Fingerprint, "with-md5-fingerprint", "@"),
369   ARGPARSE_s_n (oWithEphemeralKeys,  "with-ephemeral-keys", "@"),
370   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
371   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
372   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
373   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
374   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
375   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
376   ARGPARSE_s_n (oNoCommonCertsImport, "no-common-certs-import", "@"),
377
378   /* Command aliases.  */
379   ARGPARSE_c (aListKeys, "list-key", "@"),  
380   ARGPARSE_c (aListChain, "list-sig", "@"), 
381   ARGPARSE_c (aListChain, "list-sigs", "@"), 
382   ARGPARSE_c (aListChain, "check-sig", "@"), 
383   ARGPARSE_c (aListChain, "check-sigs", "@"), 
384   ARGPARSE_c (aDeleteKey, "delete-key", "@"),
385
386   ARGPARSE_end ()
387 };
388
389
390
391
392 /* Global variable to keep an error count. */
393 int gpgsm_errors_seen = 0;
394
395 /* It is possible that we are currentlu running under setuid permissions */
396 static int maybe_setuid = 1;
397
398 /* Helper to implement --debug-level and --debug*/
399 static const char *debug_level;
400 static unsigned int debug_value;
401
402 /* Option --enable-special-filenames */
403 static int allow_special_filenames;
404
405 /* Default value for include-certs.  We need an extra macro for
406    gpgconf-list because the variable will be changed by the command
407    line option.  
408
409    It is often cumbersome to locate intermediate certificates, thus by
410    default we include all certificates in the chain.  However we leave
411    out the root certificate because that would make it too easy for
412    the recipient to import that root certificate.  A root certificate
413    should be installed only after due checks and thus it won't help to
414    send it along with each message.  */
415 #define DEFAULT_INCLUDE_CERTS -2 /* Include all certs but root. */
416 static int default_include_certs = DEFAULT_INCLUDE_CERTS; 
417
418 /* Whether the chain mode shall be used for validation.  */
419 static int default_validation_model;
420
421 /* The default cipher algo.  */
422 #define DEFAULT_CIPHER_ALGO "3DES"  /*des-EDE3-CBC*/
423
424
425 static char *build_list (const char *text,
426                          const char *(*mapf)(int), int (*chkf)(int));
427 static void set_cmd (enum cmd_and_opt_values *ret_cmd,
428                      enum cmd_and_opt_values new_cmd );
429
430 static void emergency_cleanup (void);
431 static int check_special_filename (const char *fname, int for_write);
432 static int open_read (const char *filename);
433 static estream_t open_es_fread (const char *filename);
434 static FILE *open_fwrite (const char *filename);
435 static estream_t open_es_fwrite (const char *filename);
436 static void run_protect_tool (int argc, char **argv);
437
438 static int
439 our_pk_test_algo (int algo)
440 {
441   switch (algo)
442     {
443     case GCRY_PK_RSA:
444     case GCRY_PK_ECDSA:
445       return gcry_pk_test_algo (algo);
446     default:
447       return 1;
448     }
449 }
450
451 static int
452 our_cipher_test_algo (int algo)
453 {
454   switch (algo)
455     {
456     case GCRY_CIPHER_3DES:
457     case GCRY_CIPHER_AES128:
458     case GCRY_CIPHER_AES192:
459     case GCRY_CIPHER_AES256:
460     case GCRY_CIPHER_SERPENT128:
461     case GCRY_CIPHER_SERPENT192:
462     case GCRY_CIPHER_SERPENT256:
463     case GCRY_CIPHER_SEED:
464     case GCRY_CIPHER_CAMELLIA128:
465     case GCRY_CIPHER_CAMELLIA192:
466     case GCRY_CIPHER_CAMELLIA256:
467       return gcry_cipher_test_algo (algo);
468     default:
469       return 1;
470     }
471 }
472
473
474 static int
475 our_md_test_algo (int algo)
476 {
477   switch (algo)
478     {
479     case GCRY_MD_MD5:
480     case GCRY_MD_SHA1:
481     case GCRY_MD_RMD160:
482     case GCRY_MD_SHA224:
483     case GCRY_MD_SHA256:
484     case GCRY_MD_SHA384:
485     case GCRY_MD_SHA512:
486     case GCRY_MD_WHIRLPOOL:
487       return gcry_md_test_algo (algo);
488     default:
489       return 1;
490     }
491 }
492
493
494 static char *
495 make_libversion (const char *libname, const char *(*getfnc)(const char*))
496 {
497   const char *s;
498   char *result;
499   
500   if (maybe_setuid)
501     {
502       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
503       maybe_setuid = 0;
504     }
505   s = getfnc (NULL);
506   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
507   strcpy (stpcpy (stpcpy (result, libname), " "), s);
508   return result;
509 }
510
511
512 static const char *
513 my_strusage( int level )
514 {
515   static char *digests, *pubkeys, *ciphers;
516   static char *ver_gcry, *ver_ksba;
517   const char *p;
518
519   switch (level)
520     {
521     case 11: p = "gpgsm (GnuPG)";
522       break;
523     case 13: p = VERSION; break;
524     case 17: p = PRINTABLE_OS_NAME; break;
525     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
526
527     case 1:
528     case 40: p = _("Usage: gpgsm [options] [files] (-h for help)");
529       break;
530     case 41:
531       p = _("Syntax: gpgsm [options] [files]\n"
532             "sign, check, encrypt or decrypt using the S/MIME protocol\n"
533             "default operation depends on the input data\n");
534       break;
535
536     case 20:
537       if (!ver_gcry)
538         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
539       p = ver_gcry;
540       break;
541     case 21:
542       if (!ver_ksba)
543         ver_ksba = make_libversion ("libksba", ksba_check_version);
544       p = ver_ksba;
545       break;
546
547     case 31: p = "\nHome: "; break;
548     case 32: p = opt.homedir; break;
549     case 33: p = _("\nSupported algorithms:\n"); break;
550     case 34:
551       if (!ciphers)
552         ciphers = build_list ("Cipher: ", gcry_cipher_algo_name,
553                               our_cipher_test_algo );
554       p = ciphers;
555       break;
556     case 35:
557       if (!pubkeys)
558         pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
559                               our_pk_test_algo );
560       p = pubkeys;
561       break;
562     case 36:
563       if (!digests)
564         digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
565       p = digests;
566       break;
567      
568     default: p = NULL; break;
569     }
570   return p;
571 }
572
573
574 static char *
575 build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
576 {
577   int i;
578   size_t n=strlen(text)+2;
579   char *list, *p;
580   
581   if (maybe_setuid) {
582     gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
583   }
584
585   for (i=1; i < 400; i++ )
586     if (!chkf(i))
587       n += strlen(mapf(i)) + 2;
588   list = xmalloc (21 + n);
589   *list = 0;
590   for (p=NULL, i=1; i < 400; i++)
591     {
592       if (!chkf(i))
593         {
594           if( !p )
595             p = stpcpy (list, text );
596           else
597             p = stpcpy (p, ", ");
598           p = stpcpy (p, mapf(i) );
599         }
600     }
601   if (p)
602     p = stpcpy(p, "\n" );
603   return list;
604 }
605
606
607 /* Set the file pointer into binary mode if required.  */
608 static void
609 set_binary (FILE *fp)
610 {
611 #ifdef HAVE_DOSISH_SYSTEM
612   setmode (fileno (fp), O_BINARY);
613 #else
614   (void)fp;
615 #endif
616 }
617
618
619
620 static void
621 wrong_args (const char *text)
622 {
623   fputs (_("usage: gpgsm [options] "), stderr);
624   fputs (text, stderr);
625   putc ('\n', stderr);
626   gpgsm_exit (2);
627 }
628
629
630 static void
631 set_opt_session_env (const char *name, const char *value)
632 {
633   gpg_error_t err;
634   
635   err = session_env_setenv (opt.session_env, name, value);
636   if (err)
637     log_fatal ("error setting session environment: %s\n",
638                gpg_strerror (err));
639 }
640
641
642 /* Setup the debugging.  With a DEBUG_LEVEL of NULL only the active
643    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
644    set, a specific set of debug flags is set; and individual debugging
645    flags will be added on top.  */
646 static void
647 set_debug (void)
648 {
649   if (!debug_level)
650     ;
651   else if (!strcmp (debug_level, "none"))
652     opt.debug = 0;
653   else if (!strcmp (debug_level, "basic"))
654     opt.debug = DBG_ASSUAN_VALUE;
655   else if (!strcmp (debug_level, "advanced"))
656     opt.debug = DBG_ASSUAN_VALUE|DBG_X509_VALUE;
657   else if (!strcmp (debug_level, "expert"))
658     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE
659                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
660   else if (!strcmp (debug_level, "guru"))
661     opt.debug = ~0;
662   else
663     {
664       log_error (_("invalid debug-level `%s' given\n"), debug_level);
665       gpgsm_exit(2);
666     }
667
668   opt.debug |= debug_value;
669
670   if (opt.debug && !opt.verbose)
671     opt.verbose = 1;
672   if (opt.debug)
673     opt.quiet = 0;
674
675   if (opt.debug & DBG_MPI_VALUE)
676     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
677   if (opt.debug & DBG_CRYPTO_VALUE )
678     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
679   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
680 }
681  
682
683
684 static void
685 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
686 {
687   enum cmd_and_opt_values cmd = *ret_cmd;
688
689   if (!cmd || cmd == new_cmd)
690     cmd = new_cmd;
691   else if ( cmd == aSign && new_cmd == aEncr )
692     cmd = aSignEncr;
693   else if ( cmd == aEncr && new_cmd == aSign )
694     cmd = aSignEncr;
695   else if ( (cmd == aSign && new_cmd == aClearsign)
696             || (cmd == aClearsign && new_cmd == aSign) )
697     cmd = aClearsign;
698   else 
699     {
700       log_error(_("conflicting commands\n"));
701       gpgsm_exit(2);
702     }
703
704   *ret_cmd = cmd;
705 }
706
707
708 /* Helper to add recipients to a list. */
709 static void
710 do_add_recipient (ctrl_t ctrl, const char *name,
711                   certlist_t *recplist, int is_encrypt_to, int recp_required)
712 {
713   int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
714   if (rc)
715     {
716       if (recp_required)
717         {
718           log_error ("can't encrypt to `%s': %s\n", name, gpg_strerror (rc));
719           gpgsm_status2 (ctrl, STATUS_INV_RECP,
720                          get_inv_recpsgnr_code (rc), name, NULL);
721         }
722       else
723         log_info (_("NOTE: won't be able to encrypt to `%s': %s\n"),
724                   name, gpg_strerror (rc));
725     }
726 }
727
728
729 static void
730 parse_validation_model (const char *model)
731 {
732   int i = gpgsm_parse_validation_model (model);
733   if (i == -1)
734     log_error (_("unknown validation model `%s'\n"), model);
735   else
736     default_validation_model = i;
737 }
738
739
740 /* Release the list of SERVERS.  As usual it is okay to call this
741    function with SERVERS passed as NULL.  */
742 void
743 keyserver_list_free (struct keyserver_spec *servers)
744 {
745   while (servers)
746     {
747       struct keyserver_spec *tmp = servers->next;
748       xfree (servers->host);
749       xfree (servers->user);
750       if (servers->pass)
751         memset (servers->pass, 0, strlen (servers->pass));
752       xfree (servers->pass);
753       xfree (servers->base);
754       xfree (servers);
755       servers = tmp;
756     }
757 }
758
759 /* See also dirmngr ldapserver_parse_one().  */
760 struct keyserver_spec *
761 parse_keyserver_line (char *line,
762                       const char *filename, unsigned int lineno)
763 {
764   char *p;
765   char *endp;
766   struct keyserver_spec *server;
767   int fieldno;
768   int fail = 0;
769
770   /* Parse the colon separated fields.  */
771   server = xcalloc (1, sizeof *server);
772   for (fieldno = 1, p = line; p; p = endp, fieldno++ )
773     {
774       endp = strchr (p, ':');
775       if (endp)
776         *endp++ = '\0';
777       trim_spaces (p);
778       switch (fieldno)
779         {
780         case 1:
781           if (*p)
782             server->host = xstrdup (p);
783           else
784             {
785               log_error (_("%s:%u: no hostname given\n"),
786                          filename, lineno);
787               fail = 1;
788             }
789           break;
790           
791         case 2:
792           if (*p)
793             server->port = atoi (p);
794           break;
795           
796         case 3:
797           if (*p)
798             server->user = xstrdup (p);
799           break;
800           
801         case 4:
802           if (*p && !server->user)
803             {
804               log_error (_("%s:%u: password given without user\n"), 
805                          filename, lineno);
806               fail = 1;
807             }
808           else if (*p)
809             server->pass = xstrdup (p);
810           break;
811           
812         case 5:
813           if (*p)
814             server->base = xstrdup (p);
815           break;
816           
817         default:
818           /* (We silently ignore extra fields.) */
819           break;
820         }
821     }
822   
823   if (fail)
824     {
825       log_info (_("%s:%u: skipping this line\n"), filename, lineno);
826       keyserver_list_free (server);
827     }
828
829   return server;
830 }
831
832
833 int
834 main ( int argc, char **argv)
835 {
836   ARGPARSE_ARGS pargs;
837   int orig_argc;
838   char **orig_argv;
839   const char *fname;
840   /*  char *username;*/
841   int may_coredump;
842   strlist_t sl, remusr= NULL, locusr=NULL;
843   strlist_t nrings=NULL;
844   int detached_sig = 0;
845   FILE *configfp = NULL;
846   char *configname = NULL;
847   unsigned configlineno;
848   int parse_debug = 0;
849   int no_more_options = 0;
850   int default_config =1;
851   int default_keyring = 1;
852   char *logfile = NULL;
853   char *auditlog = NULL;
854   int greeting = 0;
855   int nogreeting = 0;
856   int debug_wait = 0;
857   int use_random_seed = 1;
858   int no_common_certs_import = 0;
859   int with_fpr = 0;
860   const char *forced_digest_algo = NULL;
861   const char *extra_digest_algo = NULL;
862   enum cmd_and_opt_values cmd = 0;
863   struct server_control_s ctrl;
864   certlist_t recplist = NULL;
865   certlist_t signerlist = NULL;
866   int do_not_setup_keys = 0;
867   int recp_required = 0;
868   estream_t auditfp = NULL;
869   struct assuan_malloc_hooks malloc_hooks;
870
871   /*mtrace();*/
872
873   gnupg_reopen_std ("gpgsm");
874   /* trap_unaligned ();*/
875   gnupg_rl_initialize ();
876   set_strusage (my_strusage);
877   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
878
879   /* Please note that we may running SUID(ROOT), so be very CAREFUL
880      when adding any stuff between here and the call to secmem_init()
881      somewhere after the option parsing */
882   log_set_prefix ("gpgsm", 1);
883
884   /* Make sure that our subsystems are ready.  */
885   i18n_init();
886   init_common_subsystems ();
887
888   /* Check that the libraries are suitable.  Do it here because the
889      option parse may need services of the library */
890   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
891     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt", 
892                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
893   if (!ksba_check_version (NEED_KSBA_VERSION) )
894     log_fatal (_("%s is too old (need %s, have %s)\n"), "libksba",
895                NEED_KSBA_VERSION, ksba_check_version (NULL) );
896
897
898   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
899
900   may_coredump = disable_core_dumps ();
901   
902   gnupg_init_signals (0, emergency_cleanup);
903   
904   create_dotlock (NULL); /* register locking cleanup */
905
906   opt.session_env = session_env_new ();
907   if (!opt.session_env)
908     log_fatal ("error allocating session environment block: %s\n",
909                strerror (errno));
910
911   /* Note: If you change this default cipher algorithm , please
912      remember to update the Gpgconflist entry as well.  */
913   opt.def_cipher_algoid = DEFAULT_CIPHER_ALGO; 
914
915   opt.homedir = default_homedir ();
916
917   /* First check whether we have a config file on the commandline */
918   orig_argc = argc;
919   orig_argv = argv;
920   pargs.argc = &argc;
921   pargs.argv = &argv;
922   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
923   while (arg_parse( &pargs, opts))
924     {
925       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
926         parse_debug++;
927       else if (pargs.r_opt == oOptions)
928         { /* yes there is one, so we do not try the default one but
929              read the config file when it is encountered at the
930              commandline */
931           default_config = 0;
932         }
933       else if (pargs.r_opt == oNoOptions)
934         default_config = 0; /* --no-options */
935       else if (pargs.r_opt == oHomedir)
936         opt.homedir = pargs.r.ret_str;
937       else if (pargs.r_opt == aCallProtectTool)
938         break; /* This break makes sure that --version and --help are
939                   passed to the protect-tool. */
940     }
941   
942   
943   /* Initialize the secure memory. */
944   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
945   maybe_setuid = 0;
946
947   /* 
948      Now we are now working under our real uid 
949   */
950
951   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
952
953   malloc_hooks.malloc = gcry_malloc;
954   malloc_hooks.realloc = gcry_realloc;
955   malloc_hooks.free = gcry_free;
956   assuan_set_malloc_hooks (&malloc_hooks);
957   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
958   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
959
960   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
961
962   /* Setup a default control structure for command line mode */
963   memset (&ctrl, 0, sizeof ctrl);
964   gpgsm_init_default_ctrl (&ctrl);
965   ctrl.no_server = 1;
966   ctrl.status_fd = -1; /* No status output. */
967   ctrl.autodetect_encoding = 1;
968
969   /* Set the default option file */
970   if (default_config )
971     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
972   /* Set the default policy file */
973   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
974   
975   argc        = orig_argc;
976   argv        = orig_argv;
977   pargs.argc  = &argc;
978   pargs.argv  = &argv;
979   pargs.flags =  1;  /* do not remove the args */
980
981  next_pass:
982   if (configname) {
983     configlineno = 0;
984     configfp = fopen (configname, "r");
985     if (!configfp)
986       {
987         if (default_config)
988           {
989             if (parse_debug)
990               log_info (_("NOTE: no default option file `%s'\n"), configname);
991           }
992         else 
993           {
994             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
995             gpgsm_exit(2);
996           }
997         xfree(configname);
998         configname = NULL;
999       }
1000     if (parse_debug && configname)
1001       log_info (_("reading options from `%s'\n"), configname);
1002     default_config = 0;
1003   }
1004
1005   while (!no_more_options 
1006          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
1007     {
1008       switch (pargs.r_opt)
1009         {
1010         case aGPGConfList: 
1011         case aGPGConfTest: 
1012           set_cmd (&cmd, pargs.r_opt);
1013           do_not_setup_keys = 1;
1014           nogreeting = 1;
1015           break;
1016
1017         case aServer: 
1018           opt.batch = 1;
1019           set_cmd (&cmd, aServer);
1020           break;
1021
1022         case aCallDirmngr:
1023           opt.batch = 1;
1024           set_cmd (&cmd, aCallDirmngr);
1025           do_not_setup_keys = 1;
1026           break;
1027
1028         case aCallProtectTool:
1029           opt.batch = 1;
1030           set_cmd (&cmd, aCallProtectTool);
1031           no_more_options = 1; /* Stop parsing. */
1032           do_not_setup_keys = 1;
1033           break;
1034         
1035         case aDeleteKey:
1036           set_cmd (&cmd, aDeleteKey);
1037           /*greeting=1;*/
1038           do_not_setup_keys = 1;
1039           break;
1040
1041         case aDetachedSign:
1042           detached_sig = 1;
1043           set_cmd (&cmd, aSign ); 
1044           break;
1045
1046         case aKeygen:
1047           set_cmd (&cmd, aKeygen);
1048           greeting=1; 
1049           do_not_setup_keys = 1;
1050           break;
1051
1052         case aImport: 
1053         case aSendKeys: 
1054         case aRecvKeys: 
1055         case aExport: 
1056         case aExportSecretKeyP12: 
1057         case aDumpKeys:
1058         case aDumpChain:
1059         case aDumpExternalKeys: 
1060         case aDumpSecretKeys: 
1061         case aListKeys:
1062         case aListExternalKeys: 
1063         case aListSecretKeys: 
1064         case aListChain: 
1065         case aLearnCard: 
1066         case aPasswd: 
1067         case aKeydbClearSomeCertFlags:
1068           do_not_setup_keys = 1;
1069           set_cmd (&cmd, pargs.r_opt);
1070           break;
1071
1072         case aEncr: 
1073           recp_required = 1;
1074           set_cmd (&cmd, pargs.r_opt);
1075           break;
1076
1077         case aSym:
1078         case aDecrypt: 
1079         case aSign: 
1080         case aClearsign: 
1081         case aVerify: 
1082           set_cmd (&cmd, pargs.r_opt);
1083           break;
1084
1085           /* Output encoding selection.  */
1086         case oArmor:
1087           ctrl.create_pem = 1;
1088           break;
1089         case oBase64: 
1090           ctrl.create_pem = 0;
1091           ctrl.create_base64 = 1;
1092           break;
1093         case oNoArmor: 
1094           ctrl.create_pem = 0;
1095           ctrl.create_base64 = 0;
1096           break;
1097           
1098         case oP12Charset:
1099           opt.p12_charset = pargs.r.ret_str;
1100           break;
1101
1102           /* Input encoding selection.  */
1103         case oAssumeArmor:
1104           ctrl.autodetect_encoding = 0;
1105           ctrl.is_pem = 1;
1106           ctrl.is_base64 = 0;
1107           break;
1108         case oAssumeBase64:
1109           ctrl.autodetect_encoding = 0;
1110           ctrl.is_pem = 0;
1111           ctrl.is_base64 = 1;
1112           break;
1113         case oAssumeBinary:
1114           ctrl.autodetect_encoding = 0;
1115           ctrl.is_pem = 0;
1116           ctrl.is_base64 = 0;
1117           break;
1118
1119         case oDisableCRLChecks:
1120           opt.no_crl_check = 1;
1121           break;
1122         case oEnableCRLChecks:
1123           opt.no_crl_check = 0;
1124           break;
1125         case oDisableTrustedCertCRLCheck:
1126           opt.no_trusted_cert_crl_check = 1;
1127           break;
1128         case oEnableTrustedCertCRLCheck:
1129           opt.no_trusted_cert_crl_check = 0;
1130           break;
1131         case oForceCRLRefresh:
1132           opt.force_crl_refresh = 1;
1133           break;
1134
1135         case oDisableOCSP:
1136           ctrl.use_ocsp = opt.enable_ocsp = 0;
1137           break;
1138         case oEnableOCSP:
1139           ctrl.use_ocsp = opt.enable_ocsp = 1;
1140           break;
1141
1142         case oIncludeCerts: 
1143           ctrl.include_certs = default_include_certs = pargs.r.ret_int; 
1144           break;
1145
1146         case oPolicyFile:
1147           xfree (opt.policy_file);
1148           if (*pargs.r.ret_str)
1149             opt.policy_file = xstrdup (pargs.r.ret_str);
1150           else
1151             opt.policy_file = NULL;
1152           break;
1153
1154         case oDisablePolicyChecks:
1155           opt.no_policy_check = 1;
1156           break;
1157         case oEnablePolicyChecks:
1158           opt.no_policy_check = 0;
1159           break;
1160           
1161         case oAutoIssuerKeyRetrieve:
1162           opt.auto_issuer_key_retrieve = 1;
1163           break;
1164
1165         case oOutput: opt.outfile = pargs.r.ret_str; break;
1166
1167         
1168         case oQuiet: opt.quiet = 1; break;
1169         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1170         case oDryRun: opt.dry_run = 1; break;
1171
1172         case oVerbose:
1173           opt.verbose++;
1174           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1175           break;
1176         case oNoVerbose:
1177           opt.verbose = 0;
1178           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1179           break;
1180
1181         case oLogFile: logfile = pargs.r.ret_str; break;
1182         case oNoLogFile: logfile = NULL; break;          
1183
1184         case oAuditLog: auditlog = pargs.r.ret_str; break;
1185
1186         case oBatch: 
1187           opt.batch = 1;
1188           greeting = 0;
1189           break;
1190         case oNoBatch: opt.batch = 0; break;
1191           
1192         case oAnswerYes: opt.answer_yes = 1; break;
1193         case oAnswerNo: opt.answer_no = 1; break;
1194
1195         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1196
1197         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1198         case oDebugAll: debug_value = ~0; break;
1199         case oDebugNone: debug_value = 0; break;
1200         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1201         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1202         case oDebugAllowCoreDump:
1203           may_coredump = enable_core_dumps ();
1204           break;
1205         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1206         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1207         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1208
1209         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1210         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1211         case oWithMD5Fingerprint:
1212           opt.with_md5_fingerprint=1; /*fall thru*/
1213         case oWithFingerprint:
1214           with_fpr=1; /*fall thru*/
1215         case aFingerprint:
1216           opt.fingerprint++;
1217           break;
1218
1219         case oOptions:
1220           /* config files may not be nested (silently ignore them) */
1221           if (!configfp)
1222             {
1223               xfree(configname);
1224               configname = xstrdup (pargs.r.ret_str);
1225               goto next_pass;
1226             }
1227           break;
1228         case oNoOptions: break; /* no-options */
1229         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1230         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1231
1232         case oDisplay:
1233           set_opt_session_env ("DISPLAY", pargs.r.ret_str);
1234           break;
1235         case oTTYname:
1236           set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
1237           break;
1238         case oTTYtype:
1239           set_opt_session_env ("TERM", pargs.r.ret_str);
1240           break;
1241         case oXauthority:
1242           set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
1243           break;
1244
1245         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1246         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1247
1248         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1249         case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
1250         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1251         case oProtectToolProgram:
1252           opt.protect_tool_program = pargs.r.ret_str; 
1253           break;
1254           
1255         case oFakedSystemTime:
1256           {
1257             time_t faked_time = isotime2epoch (pargs.r.ret_str); 
1258             if (faked_time == (time_t)(-1))
1259               faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
1260             gnupg_set_time (faked_time, 0);
1261           }
1262           break;
1263
1264         case oNoDefKeyring: default_keyring = 0; break;
1265         case oNoGreeting: nogreeting = 1; break;
1266
1267         case oDefaultKey:
1268           if (*pargs.r.ret_str)
1269             {
1270               xfree (opt.local_user);
1271               opt.local_user = xstrdup (pargs.r.ret_str);
1272             }
1273           break;
1274         case oDefRecipient:
1275           if (*pargs.r.ret_str)
1276             opt.def_recipient = xstrdup (pargs.r.ret_str);
1277           break;
1278         case oDefRecipientSelf:
1279           xfree (opt.def_recipient);
1280           opt.def_recipient = NULL;
1281           opt.def_recipient_self = 1;
1282           break;
1283         case oNoDefRecipient:
1284           xfree (opt.def_recipient);
1285           opt.def_recipient = NULL;
1286           opt.def_recipient_self = 0;
1287           break;
1288
1289         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1290         case oWithColons: ctrl.with_colons = 1; break;
1291         case oWithValidation: ctrl.with_validation=1; break;
1292         case oWithEphemeralKeys: ctrl.with_ephemeral_keys=1; break;
1293
1294         case oSkipVerify: opt.skip_verify=1; break;
1295
1296         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1297         case oEncryptTo: /* Store the recipient in the second list */
1298           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1299           sl->flags = 1;
1300           break;
1301
1302         case oRecipient: /* store the recipient */
1303           add_to_strlist ( &remusr, pargs.r.ret_str);
1304           break;
1305
1306         case oUser: /* Store the local users, the first one is the default */
1307           if (!opt.local_user)
1308             opt.local_user = xstrdup (pargs.r.ret_str);
1309           add_to_strlist (&locusr, pargs.r.ret_str);
1310           break;
1311
1312         case oNoSecmemWarn:
1313           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1314           break;
1315
1316         case oCipherAlgo:
1317           opt.def_cipher_algoid = pargs.r.ret_str;
1318           break;
1319
1320         case oDisableCipherAlgo: 
1321           {
1322             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1323             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1324           }
1325           break;
1326         case oDisablePubkeyAlgo: 
1327           {
1328             int algo = gcry_pk_map_name (pargs.r.ret_str);
1329             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1330           }
1331           break;
1332
1333         case oDigestAlgo:
1334           forced_digest_algo = pargs.r.ret_str;
1335           break;
1336
1337         case oExtraDigestAlgo: 
1338           extra_digest_algo = pargs.r.ret_str;
1339           break;
1340
1341         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1342         case oNoRandomSeedFile: use_random_seed = 0; break;
1343         case oNoCommonCertsImport: no_common_certs_import = 1; break;
1344
1345         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1346
1347         case oValidationModel: parse_validation_model (pargs.r.ret_str); break;
1348
1349         case oKeyServer:
1350           {
1351             struct keyserver_spec *keyserver;
1352             keyserver = parse_keyserver_line (pargs.r.ret_str,
1353                                               configname, configlineno);
1354             if (! keyserver)
1355               log_error (_("could not parse keyserver\n"));
1356             else
1357               {
1358                 /* FIXME: Keep last next pointer.  */
1359                 struct keyserver_spec **next_p = &opt.keyserver;
1360                 while (*next_p)
1361                   next_p = &(*next_p)->next;
1362                 *next_p = keyserver;
1363               }
1364           }
1365           break;
1366
1367         default: 
1368           pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR; 
1369           break;
1370         }
1371     }
1372
1373   if (configfp)
1374     {
1375       fclose (configfp);
1376       configfp = NULL;
1377       /* Keep a copy of the config filename. */
1378       opt.config_filename = configname;
1379       configname = NULL;
1380       goto next_pass;
1381     }
1382   xfree (configname);
1383   configname = NULL;
1384
1385   if (!opt.config_filename)
1386     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1387
1388   if (log_get_errorcount(0))
1389     gpgsm_exit(2);
1390
1391   /* Now that we have the options parsed we need to update the default
1392      control structure.  */
1393   gpgsm_init_default_ctrl (&ctrl);
1394
1395   if (nogreeting)
1396     greeting = 0;
1397   
1398   if (greeting)
1399     {
1400       fprintf(stderr, "%s %s; %s\n",
1401               strusage(11), strusage(13), strusage(14) );
1402       fprintf(stderr, "%s\n", strusage(15) );
1403     }
1404 #  ifdef IS_DEVELOPMENT_VERSION
1405   if (!opt.batch)
1406     {
1407       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1408       log_info ("It is only intended for test purposes and should NOT be\n");
1409       log_info ("used in a production environment or with production keys!\n");
1410     }
1411 #  endif
1412
1413   if (auditlog)
1414     log_info ("NOTE: The audit log feature (--audit-log) is "
1415               "WORK IN PRORESS and not ready for use!\n");
1416
1417
1418   if (may_coredump && !opt.quiet)
1419     log_info (_("WARNING: program may create a core file!\n"));
1420
1421 /*   if (opt.qualsig_approval && !opt.quiet) */
1422 /*     log_info (_("This software has offically been approved to " */
1423 /*                 "create and verify\n" */
1424 /*                 "qualified signatures according to German law.\n")); */
1425
1426   if (logfile && cmd == aServer)
1427     {
1428       log_set_file (logfile);
1429       log_set_prefix (NULL, 1|2|4);
1430     }
1431
1432   if (gnupg_faked_time_p ())
1433     {
1434       gnupg_isotime_t tbuf;
1435
1436       log_info (_("WARNING: running with faked system time: "));
1437       gnupg_get_isotime (tbuf);
1438       dump_isotime (tbuf);
1439       log_printf ("\n");
1440     }
1441   
1442 /*FIXME    if (opt.batch) */
1443 /*      tty_batchmode (1); */
1444
1445   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1446
1447   set_debug ();
1448
1449   /* Although we alwasy use gpgsm_exit, we better install a regualr
1450      exit handler so that at least the secure memory gets wiped
1451      out. */
1452   if (atexit (emergency_cleanup))
1453     {
1454       log_error ("atexit failed\n");
1455       gpgsm_exit (2);
1456     }
1457
1458   /* Must do this after dropping setuid, because the mapping functions
1459      may try to load an module and we may have disabled an algorithm.
1460      We remap the commonly used algorithms to the OIDs for
1461      convenience.  We need to work with the OIDs because they are used
1462      to check whether the encryption mode is actually available. */
1463   if (!strcmp (opt.def_cipher_algoid, "3DES") )
1464     opt.def_cipher_algoid = "1.2.840.113549.3.7";
1465   else if (!strcmp (opt.def_cipher_algoid, "AES")
1466            || !strcmp (opt.def_cipher_algoid, "AES128"))
1467     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1468   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1469     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1470   else if (!strcmp (opt.def_cipher_algoid, "SERPENT")
1471            || !strcmp (opt.def_cipher_algoid, "SERPENT128") )
1472     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.2";
1473   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1474     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.22";
1475   else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
1476     opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.42";
1477   else if (!strcmp (opt.def_cipher_algoid, "SEED") )
1478     opt.def_cipher_algoid = "1.2.410.200004.1.4";
1479   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA") 
1480            || !strcmp (opt.def_cipher_algoid, "CAMELLIA128") )
1481     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.2";
1482   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA192") )
1483     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
1484   else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
1485     opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
1486
1487   if (cmd != aGPGConfList)
1488     {
1489       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1490            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1491         log_error (_("selected cipher algorithm is invalid\n"));
1492
1493       if (forced_digest_algo)
1494         {
1495           opt.forced_digest_algo = gcry_md_map_name (forced_digest_algo);
1496           if (our_md_test_algo(opt.forced_digest_algo) )
1497             log_error (_("selected digest algorithm is invalid\n"));
1498         }
1499       if (extra_digest_algo)
1500         {
1501           opt.extra_digest_algo = gcry_md_map_name (extra_digest_algo);
1502           if (our_md_test_algo (opt.extra_digest_algo) )
1503             log_error (_("selected digest algorithm is invalid\n"));
1504         }
1505     }
1506
1507   if (log_get_errorcount(0))
1508     gpgsm_exit(2);
1509   
1510   /* Set the random seed file. */
1511   if (use_random_seed) 
1512     {
1513       char *p = make_filename (opt.homedir, "random_seed", NULL);
1514       gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1515       xfree(p);
1516     }
1517   
1518   if (!cmd && opt.fingerprint && !with_fpr)
1519     set_cmd (&cmd, aListKeys);
1520   
1521   /* Add default keybox. */
1522   if (!nrings && default_keyring)
1523     {
1524       int created;
1525
1526       keydb_add_resource ("pubring.kbx", 0, 0, &created);
1527       if (created && !no_common_certs_import)
1528         {
1529           /* Import the standard certificates for a new default keybox. */
1530           char *filelist[2];
1531           
1532           filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
1533           filelist[1] = NULL;
1534           if (!access (filelist[0], F_OK))
1535             {
1536               log_info (_("importing common certificates `%s'\n"),
1537                         filelist[0]);
1538               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1539             }
1540           xfree (filelist[0]);
1541         }
1542     }
1543   for (sl = nrings; sl; sl = sl->next)
1544     keydb_add_resource (sl->d, 0, 0, NULL);
1545   FREE_STRLIST(nrings);
1546
1547
1548   /* Prepare the audit log feature for certain commands.  */
1549   if (auditlog)
1550     {
1551       switch (cmd)
1552         {
1553         case aEncr: 
1554         case aSign:
1555         case aDecrypt:
1556         case aVerify:
1557           audit_release (ctrl.audit);
1558           ctrl.audit = audit_new ();
1559           auditfp = open_es_fwrite (auditlog);
1560           break;
1561         default:
1562           break;
1563         }
1564     }
1565
1566
1567   if (!do_not_setup_keys)
1568     {
1569       for (sl = locusr; sl ; sl = sl->next)
1570         {
1571           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1572           if (rc)
1573             {
1574               log_error (_("can't sign using `%s': %s\n"),
1575                          sl->d, gpg_strerror (rc));
1576               gpgsm_status2 (&ctrl, STATUS_INV_SGNR,
1577                              get_inv_recpsgnr_code (rc), sl->d, NULL);
1578               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1579                              get_inv_recpsgnr_code (rc), sl->d, NULL);
1580             }
1581         }
1582       
1583       /* Build the recipient list.  We first add the regular ones and then
1584          the encrypt-to ones because the underlying function will silently
1585          ignore duplicates and we can't allow to keep a duplicate which is
1586          flagged as encrypt-to as the actually encrypt function would then
1587          complain about no (regular) recipients. */
1588       for (sl = remusr; sl; sl = sl->next)
1589         if (!(sl->flags & 1))
1590           do_add_recipient (&ctrl, sl->d, &recplist, 0, recp_required);
1591       if (!opt.no_encrypt_to)
1592         {
1593           for (sl = remusr; sl; sl = sl->next)
1594             if ((sl->flags & 1))
1595               do_add_recipient (&ctrl, sl->d, &recplist, 1, recp_required);
1596         }
1597     }
1598
1599   if (log_get_errorcount(0))
1600     gpgsm_exit(1); /* Must stop for invalid recipients. */
1601   
1602   fname = argc? *argv : NULL;
1603   
1604   /* Dispatch command.  */
1605   switch (cmd)
1606     {
1607     case aGPGConfList: 
1608       { /* List options and default values in the GPG Conf format.  */
1609         char *config_filename_esc = percent_escape (opt.config_filename, NULL);
1610
1611         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1612                 GC_OPT_FLAG_DEFAULT, config_filename_esc);
1613         xfree (config_filename_esc);
1614
1615         printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1616         printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
1617         printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1618         printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1619         printf ("disable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
1620         printf ("disable-trusted-cert-crl-check:%lu:\n", GC_OPT_FLAG_NONE);
1621         printf ("enable-ocsp:%lu:\n", GC_OPT_FLAG_NONE);
1622         printf ("include-certs:%lu:%d:\n", GC_OPT_FLAG_DEFAULT,
1623                 DEFAULT_INCLUDE_CERTS);
1624         printf ("disable-policy-checks:%lu:\n", GC_OPT_FLAG_NONE);
1625         printf ("auto-issuer-key-retrieve:%lu:\n", GC_OPT_FLAG_NONE);
1626         printf ("disable-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1627 #ifndef HAVE_W32_SYSTEM
1628         printf ("prefer-system-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1629 #endif
1630         printf ("cipher-algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1631                 DEFAULT_CIPHER_ALGO);
1632         printf ("p12-charset:%lu:\n", GC_OPT_FLAG_DEFAULT);
1633         printf ("default-key:%lu:\n", GC_OPT_FLAG_DEFAULT);
1634         printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_DEFAULT);
1635         printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1636
1637       }
1638       break;
1639     case aGPGConfTest:
1640       /* This is merely a dummy command to test whether the
1641          configuration file is valid.  */
1642       break;
1643
1644     case aServer:
1645       if (debug_wait)
1646         {
1647           log_debug ("waiting for debugger - my pid is %u .....\n",
1648                      (unsigned int)getpid());
1649           gnupg_sleep (debug_wait);
1650           log_debug ("... okay\n");
1651          }
1652       gpgsm_server (recplist);
1653       break;
1654
1655     case aCallDirmngr:
1656       if (!argc)
1657         wrong_args ("--call-dirmngr <command> {args}");
1658       else
1659         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1660           gpgsm_exit (1);
1661       break;
1662
1663     case aCallProtectTool:
1664       run_protect_tool (argc, argv);
1665       break;
1666
1667     case aEncr: /* Encrypt the given file. */
1668       {
1669         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1670
1671         set_binary (stdin);
1672
1673         if (!argc) /* Source is stdin. */
1674           gpgsm_encrypt (&ctrl, recplist, 0, fp); 
1675         else if (argc == 1)  /* Source is the given file. */
1676           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1677         else
1678           wrong_args ("--encrypt [datafile]");
1679
1680         if (fp != stdout)
1681           fclose (fp);
1682       }
1683       break;
1684
1685     case aSign: /* Sign the given file. */
1686       {
1687         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1688
1689         /* Fixme: We should also allow to concatenate multiple files for
1690            signing because that is what gpg does.*/
1691         set_binary (stdin);
1692         if (!argc) /* Create from stdin. */
1693           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp); 
1694         else if (argc == 1) /* From file. */
1695           gpgsm_sign (&ctrl, signerlist,
1696                       open_read (*argv), detached_sig, fp); 
1697         else
1698           wrong_args ("--sign [datafile]");
1699
1700         if (fp != stdout)
1701           fclose (fp);
1702       }
1703       break;
1704         
1705     case aSignEncr: /* sign and encrypt the given file */
1706       log_error ("this command has not yet been implemented\n");
1707       break;
1708
1709     case aClearsign: /* make a clearsig */
1710       log_error ("this command has not yet been implemented\n");
1711       break;
1712
1713     case aVerify:
1714       {
1715         FILE *fp = NULL;
1716
1717         set_binary (stdin);
1718         if (argc == 2 && opt.outfile)
1719           log_info ("option --output ignored for a detached signature\n");
1720         else if (opt.outfile)
1721           fp = open_fwrite (opt.outfile);
1722
1723         if (!argc)
1724           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1725         else if (argc == 1)
1726           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1727         else if (argc == 2) /* detached signature (sig, detached) */
1728           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1729         else
1730           wrong_args ("--verify [signature [detached_data]]");
1731
1732         if (fp && fp != stdout)
1733           fclose (fp);
1734       }
1735       break;
1736
1737     case aDecrypt:
1738       {
1739         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1740
1741         set_binary (stdin);
1742         if (!argc)
1743           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1744         else if (argc == 1)
1745           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1746         else
1747           wrong_args ("--decrypt [filename]");
1748         if (fp != stdout)
1749           fclose (fp);
1750       }
1751       break;
1752
1753     case aDeleteKey:
1754       for (sl=NULL; argc; argc--, argv++)
1755         add_to_strlist (&sl, *argv);
1756       gpgsm_delete (&ctrl, sl);
1757       free_strlist(sl);
1758       break;
1759
1760     case aListChain:
1761     case aDumpChain:
1762        ctrl.with_chain = 1;
1763     case aListKeys:
1764     case aDumpKeys:
1765     case aListExternalKeys:
1766     case aDumpExternalKeys:
1767     case aListSecretKeys:
1768     case aDumpSecretKeys:
1769       {
1770         unsigned int mode;
1771         estream_t fp;
1772
1773         switch (cmd)
1774           {
1775           case aListChain:
1776           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1777           case aDumpChain: 
1778           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1779           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1780           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1781           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1782           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1783           default: BUG();
1784           }
1785
1786         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1787         for (sl=NULL; argc; argc--, argv++)
1788           add_to_strlist (&sl, *argv);
1789         gpgsm_list_keys (&ctrl, sl, fp, mode);
1790         free_strlist(sl);
1791         es_fclose (fp);
1792       }
1793       break;
1794
1795
1796     case aKeygen: /* Generate a key; well kind of. */
1797       {
1798         estream_t fpin = NULL;
1799         FILE *fpout;
1800
1801         if (opt.batch)
1802           {
1803             if (!argc) /* Create from stdin. */
1804               fpin = open_es_fread ("-"); 
1805             else if (argc == 1) /* From file. */
1806               fpin = open_es_fread (*argv); 
1807             else
1808               wrong_args ("--gen-key --batch [parmfile]");
1809           }
1810         
1811         fpout = open_fwrite (opt.outfile?opt.outfile:"-");
1812
1813         if (fpin)
1814           gpgsm_genkey (&ctrl, fpin, fpout);
1815         else
1816           gpgsm_gencertreq_tty (&ctrl, fpout);
1817
1818         if (fpout != stdout)
1819           fclose (fpout);
1820       }
1821       break;
1822
1823
1824     case aImport:
1825       gpgsm_import_files (&ctrl, argc, argv, open_read);
1826       break;
1827
1828     case aExport:
1829       {
1830         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1831
1832         for (sl=NULL; argc; argc--, argv++)
1833           add_to_strlist (&sl, *argv);
1834         gpgsm_export (&ctrl, sl, fp, NULL);
1835         free_strlist(sl);
1836         if (fp != stdout)
1837           fclose (fp);
1838       }
1839       break;
1840
1841     case aExportSecretKeyP12:
1842       {
1843         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1844
1845         if (argc == 1)
1846           gpgsm_p12_export (&ctrl, *argv, fp);
1847         else
1848           wrong_args ("--export-secret-key-p12 KEY-ID");
1849         if (fp != stdout)
1850           fclose (fp);
1851       }
1852       break;
1853       
1854     case aSendKeys:
1855     case aRecvKeys:
1856       log_error ("this command has not yet been implemented\n");
1857       break;
1858
1859
1860     case aLearnCard:
1861       if (argc)
1862         wrong_args ("--learn-card");
1863       else
1864         {
1865           int rc = gpgsm_agent_learn (&ctrl);
1866           if (rc)
1867             log_error ("error learning card: %s\n", gpg_strerror (rc));
1868         }
1869       break;
1870
1871     case aPasswd:
1872       if (argc != 1)
1873         wrong_args ("--passwd <key-Id>");
1874       else
1875         {
1876           int rc;
1877           ksba_cert_t cert = NULL;
1878           char *grip = NULL;
1879
1880           rc = gpgsm_find_cert (*argv, NULL, &cert);
1881           if (rc)
1882             ;
1883           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1884             rc = gpg_error (GPG_ERR_BUG);
1885           else 
1886             {
1887               char *desc = gpgsm_format_keydesc (cert);
1888               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1889               xfree (desc);
1890             }
1891           if (rc)
1892             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1893           xfree (grip);
1894           ksba_cert_release (cert);
1895         }
1896       break;
1897
1898     case aKeydbClearSomeCertFlags:
1899       for (sl=NULL; argc; argc--, argv++)
1900         add_to_strlist (&sl, *argv);
1901       keydb_clear_some_cert_flags (&ctrl, sl);
1902       free_strlist(sl);
1903       break;
1904
1905
1906     default:
1907         log_error (_("invalid command (there is no implicit command)\n"));
1908         break;
1909     }
1910
1911   /* Print the audit result if needed.  */
1912   if (auditlog && auditfp)
1913     {
1914       audit_print_result (ctrl.audit, auditfp, 0);
1915       audit_release (ctrl.audit);
1916       ctrl.audit = NULL;
1917       es_fclose (auditfp);
1918     }
1919   
1920   /* cleanup */
1921   keyserver_list_free (opt.keyserver);
1922   opt.keyserver = NULL;
1923   gpgsm_release_certlist (recplist);
1924   gpgsm_release_certlist (signerlist);
1925   FREE_STRLIST (remusr);
1926   FREE_STRLIST (locusr);
1927   gpgsm_exit(0);
1928   return 8; /*NOTREACHED*/
1929 }
1930
1931 /* Note: This function is used by signal handlers!. */
1932 static void
1933 emergency_cleanup (void)
1934 {
1935   gcry_control (GCRYCTL_TERM_SECMEM );
1936 }
1937
1938
1939 void
1940 gpgsm_exit (int rc)
1941 {
1942   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1943   if (opt.debug & DBG_MEMSTAT_VALUE)
1944     {
1945       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1946       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1947     }
1948   if (opt.debug)
1949     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1950   emergency_cleanup ();
1951   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1952   exit (rc);
1953 }
1954
1955
1956 void
1957 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1958 {
1959   ctrl->include_certs = default_include_certs;
1960   ctrl->use_ocsp = opt.enable_ocsp;
1961   ctrl->validation_model = default_validation_model;
1962 }
1963
1964
1965 int
1966 gpgsm_parse_validation_model (const char *model)
1967 {     
1968   if (!ascii_strcasecmp (model, "shell") )
1969     return 0;
1970   else if ( !ascii_strcasecmp (model, "chain") )
1971     return 1;
1972   else
1973     return -1;
1974 }
1975
1976
1977 /* Check whether the filename has the form "-&nnnn", where n is a
1978    non-zero number.  Returns this number or -1 if it is not the case.  */
1979 static int
1980 check_special_filename (const char *fname, int for_write)
1981 {
1982   if (allow_special_filenames
1983       && fname && *fname == '-' && fname[1] == '&' ) {
1984     int i;
1985     
1986     fname += 2;
1987     for (i=0; isdigit (fname[i]); i++ )
1988       ;
1989     if ( !fname[i] ) 
1990       return translate_sys2libc_fd_int (atoi (fname), for_write);
1991   }
1992   return -1;
1993 }
1994
1995
1996
1997 /* Open the FILENAME for read and return the filedescriptor.  Stop
1998    with an error message in case of problems.  "-" denotes stdin and
1999    if special filenames are allowed the given fd is opened instead. */
2000 static int 
2001 open_read (const char *filename)
2002 {
2003   int fd;
2004
2005   if (filename[0] == '-' && !filename[1])
2006     {
2007       set_binary (stdin);
2008       return 0; /* stdin */
2009     }
2010   fd = check_special_filename (filename, 0);
2011   if (fd != -1)
2012     return fd;
2013   fd = open (filename, O_RDONLY | O_BINARY);
2014   if (fd == -1)
2015     {
2016       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2017       gpgsm_exit (2);
2018     }
2019   return fd;
2020 }
2021
2022 /* Same as open_read but return an estream_t.  */
2023 static estream_t
2024 open_es_fread (const char *filename)
2025 {
2026   int fd;
2027   estream_t fp;
2028
2029   if (filename[0] == '-' && !filename[1])
2030     fd = fileno (stdin);
2031   else
2032     fd = check_special_filename (filename, 0);
2033   if (fd != -1)
2034     {
2035       fp = es_fdopen_nc (fd, "rb");
2036       if (!fp)
2037         {
2038           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2039           gpgsm_exit (2);
2040         }
2041       return fp;
2042     }
2043   fp = es_fopen (filename, "rb");
2044   if (!fp)
2045     {
2046       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2047       gpgsm_exit (2);
2048     }
2049   return fp;
2050 }
2051
2052
2053 /* Open FILENAME for fwrite and return the stream.  Stop with an error
2054    message in case of problems.  "-" denotes stdout and if special
2055    filenames are allowed the given fd is opened instead. Caller must
2056    close the returned stream unless it is stdout. */
2057 static FILE *
2058 open_fwrite (const char *filename)
2059 {
2060   int fd;
2061   FILE *fp;
2062
2063   if (filename[0] == '-' && !filename[1])
2064     {
2065       set_binary (stdout);
2066       return stdout;
2067     }
2068
2069   fd = check_special_filename (filename, 1);
2070   if (fd != -1)
2071     {
2072       fp = fdopen (dup (fd), "wb");
2073       if (!fp)
2074         {
2075           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
2076           gpgsm_exit (2);
2077         }
2078       set_binary (fp);
2079       return fp;
2080     }
2081   fp = fopen (filename, "wb");
2082   if (!fp)
2083     {
2084       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2085       gpgsm_exit (2);
2086     }
2087   return fp;
2088 }
2089
2090
2091 /* Open FILENAME for fwrite and return an extended stream.  Stop with
2092    an error message in case of problems.  "-" denotes stdout and if
2093    special filenames are allowed the given fd is opened instead.
2094    Caller must close the returned stream. */
2095 static estream_t
2096 open_es_fwrite (const char *filename)
2097 {
2098   int fd;
2099   estream_t fp;
2100
2101   if (filename[0] == '-' && !filename[1])
2102     {
2103       fflush (stdout);
2104       fp = es_fdopen_nc (fileno(stdout), "wb");
2105       return fp;
2106     }
2107
2108   fd = check_special_filename (filename, 1);
2109   if (fd != -1)
2110     {
2111       fp = es_fdopen_nc (fd, "wb");
2112       if (!fp)
2113         {
2114           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
2115           gpgsm_exit (2);
2116         }
2117       return fp;
2118     }
2119   fp = es_fopen (filename, "wb");
2120   if (!fp)
2121     {
2122       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2123       gpgsm_exit (2);
2124     }
2125   return fp;
2126 }
2127
2128
2129 static void
2130 run_protect_tool (int argc, char **argv)
2131 {
2132 #ifndef HAVE_W32_SYSTEM
2133   const char *pgm;
2134   char **av;
2135   int i;
2136
2137   if (!opt.protect_tool_program || !*opt.protect_tool_program)
2138     pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
2139   else
2140     pgm = opt.protect_tool_program;
2141
2142   av = xcalloc (argc+2, sizeof *av);
2143   av[0] = strrchr (pgm, '/');
2144   if (!av[0])
2145     av[0] = xstrdup (pgm);
2146   for (i=1; argc; i++, argc--, argv++)
2147     av[i] = *argv;
2148   av[i] = NULL;
2149   execv (pgm, av); 
2150   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
2151 #endif /*HAVE_W32_SYSTEM*/
2152   gpgsm_exit (2);
2153 }