summaryrefslogtreecommitdiffstats
path: root/src/HTInit.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 16:37:15 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 16:37:15 +0000
commitae5d181b854d3ccb373b6bc01b4869e44ff4d87a (patch)
tree91f59efb48c56a84cc798e012fccb667b63d3fee /src/HTInit.c
parentInitial commit. (diff)
downloadlynx-ae5d181b854d3ccb373b6bc01b4869e44ff4d87a.tar.xz
lynx-ae5d181b854d3ccb373b6bc01b4869e44ff4d87a.zip
Adding upstream version 2.9.0dev.12.upstream/2.9.0dev.12upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/HTInit.c')
-rw-r--r--src/HTInit.c1503
1 files changed, 1503 insertions, 0 deletions
diff --git a/src/HTInit.c b/src/HTInit.c
new file mode 100644
index 0000000..466bc72
--- /dev/null
+++ b/src/HTInit.c
@@ -0,0 +1,1503 @@
+/*
+ * $LynxId: HTInit.c,v 1.98 2022/06/12 21:17:37 tom Exp $
+ *
+ * Configuration-specific Initialization HTInit.c
+ * ----------------------------------------
+ */
+
+/* Define a basic set of suffixes and presentations
+ * ------------------------------------------------
+ */
+
+#include <HTUtils.h>
+
+/* Implements:
+*/
+#include <HTInit.h>
+
+#include <HTML.h>
+#include <HTPlain.h>
+#include <HTMLGen.h>
+#include <HTFile.h>
+#include <HTFormat.h>
+#include <HTMIME.h>
+#include <HTWSRC.h>
+
+#include <HTSaveToFile.h> /* LJM */
+#include <LYStrings.h>
+#include <LYUtils.h>
+#include <LYGlobalDefs.h>
+
+#include <LYexit.h>
+#include <LYLeaks.h>
+
+#define CTrace(p) CTRACE2(TRACE_CFG, p)
+
+static int HTLoadTypesConfigFile(char *fn, AcceptMedia media);
+static int HTLoadExtensionsConfigFile(char *fn);
+
+#define SET_SUFFIX1(suffix, description, type) \
+ HTSetSuffix(suffix, description, type, 1.0)
+
+#define SET_SUFFIX5(suffix, mimetype, type, description) \
+ HTSetSuffix5(suffix, mimetype, type, description, 1.0)
+
+#define SET_PRESENT(mimetype, command, quality, delay) \
+ HTSetPresentation(mimetype, command, 0, quality, delay, 0.0, 0L, media)
+
+#define SET_EXTERNL(rep_in, rep_out, command, quality) \
+ HTSetConversion(rep_in, rep_out, command, quality, 3.0, 0.0, 0L, mediaEXT)
+
+#define SET_INTERNL(rep_in, rep_out, command, quality) \
+ HTSetConversion(rep_in, rep_out, command, quality, 0.0, 0.0, 0L, mediaINT)
+
+void HTFormatInit(void)
+{
+ AcceptMedia media = mediaEXT;
+
+ CTrace((tfp, "HTFormatInit\n"));
+#ifdef NeXT
+ SET_PRESENT("application/postscript", "open %s", 1.0, 2.0);
+ SET_PRESENT("image/x-tiff", "open %s", 2.0, 2.0);
+ SET_PRESENT("image/tiff", "open %s", 1.0, 2.0);
+ SET_PRESENT("audio/basic", "open %s", 1.0, 2.0);
+ SET_PRESENT("*", "open %s", 1.0, 0.0);
+#else
+ if (LYgetXDisplay() != 0) { /* Must have X11 */
+ SET_PRESENT("application/postscript", "ghostview %s&", 1.0, 3.0);
+ if (non_empty(XLoadImageCommand)) {
+ /* *INDENT-OFF* */
+ SET_PRESENT("image/gif", XLoadImageCommand, 1.0, 3.0);
+ SET_PRESENT("image/x-xbm", XLoadImageCommand, 1.0, 3.0);
+ SET_PRESENT("image/x-xbitmap", XLoadImageCommand, 1.0, 3.0);
+ SET_PRESENT("image/x-png", XLoadImageCommand, 2.0, 3.0);
+ SET_PRESENT("image/png", XLoadImageCommand, 1.0, 3.0);
+ SET_PRESENT("image/x-rgb", XLoadImageCommand, 1.0, 3.0);
+ SET_PRESENT("image/x-tiff", XLoadImageCommand, 2.0, 3.0);
+ SET_PRESENT("image/tiff", XLoadImageCommand, 1.0, 3.0);
+ SET_PRESENT("image/jpeg", XLoadImageCommand, 1.0, 3.0);
+ /* *INDENT-ON* */
+
+ }
+ SET_PRESENT("video/mpeg", "mpeg_play %s &", 1.0, 3.0);
+
+ }
+#endif
+
+#ifdef EXEC_SCRIPTS
+ /* set quality to 999.0 for protected exec applications */
+#ifndef VMS
+ SET_PRESENT("application/x-csh", "csh %s", 999.0, 3.0);
+ SET_PRESENT("application/x-sh", "sh %s", 999.0, 3.0);
+ SET_PRESENT("application/x-ksh", "ksh %s", 999.0, 3.0);
+#else
+ SET_PRESENT("application/x-VMS_script", "@%s", 999.0, 3.0);
+#endif /* not VMS */
+#endif /* EXEC_SCRIPTS */
+
+ /*
+ * Add our header handlers.
+ */
+ SET_INTERNL("message/x-http-redirection", "*", HTMIMERedirect, 2.0);
+ SET_INTERNL("message/x-http-redirection", STR_PRESENT, HTMIMERedirect, 2.0);
+ SET_INTERNL("message/x-http-redirection", "www/debug", HTMIMERedirect, 1.0);
+ SET_INTERNL("www/mime", STR_PRESENT, HTMIMEConvert, 1.0);
+ SET_INTERNL("www/mime", STR_DOWNLOAD, HTMIMEConvert, 1.0);
+ SET_INTERNL("www/mime", STR_SOURCE, HTMIMEConvert, 1.0);
+ SET_INTERNL("www/mime", STR_DUMP, HTMIMEConvert, 1.0);
+
+ /*
+ * Add our compressed file handlers.
+ */
+ SET_INTERNL("www/compressed", STR_DOWNLOAD, HTCompressed, 1.0);
+ SET_INTERNL("www/compressed", STR_PRESENT, HTCompressed, 1.0);
+ SET_INTERNL("www/compressed", STR_SOURCE, HTCompressed, 1.0);
+ SET_INTERNL("www/compressed", STR_DUMP, HTCompressed, 1.0);
+
+ /*
+ * The following support some content types seen here/there:
+ */
+ SET_INTERNL("application/html", "text/x-c", HTMLToC, 0.5);
+ SET_INTERNL("application/html", STR_PLAINTEXT, HTMLToPlain, 0.5);
+ SET_INTERNL("application/html", STR_PRESENT, HTMLPresent, 2.0);
+ SET_INTERNL("application/html", STR_SOURCE, HTPlainPresent, 1.0);
+ SET_INTERNL("application/xml", STR_PRESENT, HTMLPresent, 2.0);
+ SET_INTERNL("application/x-wais-source", STR_SOURCE, HTPlainPresent, 1.0);
+ SET_INTERNL("application/x-wais-source", STR_PRESENT, HTWSRCConvert, 2.0);
+ SET_INTERNL("application/x-wais-source", STR_DOWNLOAD, HTWSRCConvert, 1.0);
+ SET_INTERNL("application/x-wais-source", STR_DUMP, HTWSRCConvert, 1.0);
+
+ /*
+ * Save all unknown mime types to disk.
+ */
+ SET_EXTERNL(STR_SOURCE, STR_PRESENT, HTSaveToFile, 1.0);
+ SET_EXTERNL(STR_SOURCE, STR_SOURCE, HTSaveToFile, 1.0);
+ SET_EXTERNL(STR_SOURCE, STR_DOWNLOAD, HTSaveToFile, 1.0);
+ SET_EXTERNL(STR_SOURCE, "*", HTSaveToFile, 1.0);
+
+ /*
+ * Output all www/dump presentations to stdout.
+ */
+ SET_EXTERNL(STR_SOURCE, STR_DUMP, HTDumpToStdout, 1.0);
+
+ /*
+ * Other internal types, which must precede the "www/present" entries
+ * below (otherwise, they will be filtered out in HTFilterPresentations()).
+ */
+ SET_INTERNL("text/css", STR_PLAINTEXT, HTMLToPlain, 0.5);
+ SET_INTERNL(STR_HTML, STR_PLAINTEXT, HTMLToPlain, 0.5);
+ SET_INTERNL(STR_HTML, "text/x-c", HTMLToC, 0.5);
+ SET_INTERNL(STR_HTML, STR_SOURCE, HTPlainPresent, 1.0);
+ SET_INTERNL(STR_PLAINTEXT, STR_SOURCE, HTPlainPresent, 1.0);
+ SET_INTERNL("text/sgml", STR_SOURCE, HTPlainPresent, 1.0);
+ SET_INTERNL("text/x-sgml", STR_SOURCE, HTPlainPresent, 1.0);
+
+ /*
+ * Now add our basic conversions. These include the types which will
+ * be listed in a "Accept:" line sent to a server. These criteria are
+ * used in HTFilterPresentations() to select acceptable types:
+ *
+ * a) input is not "www/mime" or "www/compressed"
+ * b) output is "www/present"
+ * c) quality is in the range 0.0 to 1.0, i.e., excludes the 2.0's.
+ *
+ * For reference:
+ * RFC 1874 - text/sgml
+ * RFC 2046 - text/plain
+ * RFC 2318 - text/css
+ * RFC 3023 - text/xml
+ * obsolete - text/x-sgml
+ *
+ * as well as
+ * http://www.iana.org/assignments/media-types/media-types.xhtml
+ *
+ * and
+ * http://www.w3.org/TR/xhtml-media-types/
+ *
+ * which describes
+ * application/xhtml+xml
+ * text/html
+ */
+ SET_INTERNL("application/xhtml+xml", STR_PRESENT, XHTMLPresent, 1.0);
+ SET_INTERNL("application/xhtml+xml", STR_SOURCE, HTPlainPresent, 1.0);
+ SET_INTERNL("text/css", STR_PRESENT, HTPlainPresent, 1.0);
+ SET_INTERNL(STR_HTML, STR_PRESENT, HTMLPresent, 1.0);
+ SET_INTERNL(STR_PLAINTEXT, STR_PRESENT, HTPlainPresent, 1.0);
+ SET_INTERNL("text/sgml", STR_PRESENT, HTMLPresent, 1.0);
+ SET_INTERNL("text/x-sgml", STR_PRESENT, HTMLPresent, 2.0);
+ SET_INTERNL("text/xml", STR_PRESENT, HTMLPresent, 2.0);
+
+ if (LYisAbsPath(global_type_map)) {
+ /* These should override the default types as necessary. */
+ HTLoadTypesConfigFile(global_type_map, mediaSYS);
+ }
+
+ /*
+ * Load the local maps.
+ */
+ if (IsOurFile(LYAbsOrHomePath(&personal_type_map))
+ && LYCanReadFile(personal_type_map)) {
+ /* These should override everything else. */
+ HTLoadTypesConfigFile(personal_type_map, mediaUSR);
+ }
+
+ /*
+ * Put text/html and text/plain at beginning of list. - kw
+ */
+ HTReorderPresentation(WWW_PLAINTEXT, WWW_PRESENT);
+ HTReorderPresentation(WWW_HTML, WWW_PRESENT);
+
+ /*
+ * Analyze the list, and set 'get_accept' for those whose representations
+ * are not redundant.
+ */
+ HTFilterPresentations();
+}
+
+void HTPreparsedFormatInit(void)
+{
+ CTrace((tfp, "HTPreparsedFormatInit\n"));
+ if (LYPreparsedSource) {
+ SET_INTERNL(STR_HTML, STR_SOURCE, HTMLParsedPresent, 1.0);
+ SET_INTERNL(STR_HTML, STR_DUMP, HTMLParsedPresent, 1.0);
+ }
+}
+
+/* Some of the following is taken from: */
+
+/*
+Copyright (c) 1991 Bell Communications Research, Inc. (Bellcore)
+
+Permission to use, copy, modify, and distribute this material
+for any purpose and without fee is hereby granted, provided
+that the above copyright notice and this permission notice
+appear in all copies, and that the name of Bellcore not be
+used in advertising or publicity pertaining to this
+material without the specific, prior written permission
+of an authorized representative of Bellcore. BELLCORE
+MAKES NO REPRESENTATIONS ABOUT THE ACCURACY OR SUITABILITY
+OF THIS MATERIAL FOR ANY PURPOSE. IT IS PROVIDED "AS IS",
+WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.
+*/
+/******************************************************
+ Metamail -- A tool to help diverse mail readers
+ cope with diverse multimedia mail formats.
+
+ Author: Nathaniel S. Borenstein, Bellcore
+
+ ******************************************************* */
+
+struct MailcapEntry {
+ char *contenttype;
+ char *command;
+ char *testcommand;
+ int needsterminal;
+ int copiousoutput;
+ int needtofree;
+ char *label;
+ char *printcommand;
+ char *nametemplate;
+ float quality;
+ long int maxbytes;
+};
+
+static int ExitWithError(const char *txt);
+static int PassesTest(struct MailcapEntry *mc);
+
+static char *GetCommand(char *s, char **t)
+{
+ char *s2;
+ int quoted = 0;
+
+ s = LYSkipBlanks(s);
+ /* marca -- added + 1 for error case -- oct 24, 1993. */
+ s2 = typeMallocn(char, strlen(s) * 2 + 1); /* absolute max, if all % signs */
+
+ if (!s2)
+ ExitWithError(MEMORY_EXHAUSTED_ABORT);
+
+ *t = s2;
+ while (non_empty(s)) {
+ if (quoted) {
+ if (*s == '%')
+ *s2++ = '%'; /* Quote through next level, ugh! */
+
+ *s2++ = *s++;
+ quoted = 0;
+ } else {
+ if (*s == ';') {
+ *s2 = '\0';
+ return (++s);
+ }
+ if (*s == ESCAPE) {
+ quoted = 1;
+ ++s;
+ } else {
+ *s2++ = *s++;
+ }
+ }
+ }
+ *s2 = '\0';
+ return (NULL);
+}
+
+/* no leading or trailing space, all lower case */
+static char *Cleanse(char *s)
+{
+ LYTrimLeading(s);
+ LYTrimTrailing(s);
+ LYLowerCase(s);
+ return (s);
+}
+
+/* remove unnecessary (unquoted) blanks in a shell command */
+static void TrimCommand(char *command)
+{
+ LYTrimTrailing(command);
+#ifdef UNIX
+ {
+ char *s = command;
+ char *d = command;
+ int ch;
+ int c0 = ' ';
+ BOOL escape = FALSE;
+ BOOL dquote = FALSE;
+ BOOL squote = FALSE;
+
+ while ((ch = *s++) != '\0') {
+ if (escape) {
+ escape = FALSE;
+ } else if (squote) {
+ if (ch == SQUOTE)
+ squote = FALSE;
+ } else if (dquote) {
+ switch (ch) {
+ case DQUOTE:
+ dquote = FALSE;
+ break;
+ case ESCAPE:
+ escape = TRUE;
+ break;
+ }
+ } else {
+ switch (ch) {
+ case DQUOTE:
+ dquote = TRUE;
+ break;
+ case SQUOTE:
+ squote = TRUE;
+ break;
+ }
+ }
+ if (!escape && !dquote && !squote) {
+ if (ch == '\t')
+ ch = ' ';
+ if (ch == ' ') {
+ if (c0 == ' ')
+ continue;
+ }
+ }
+ *d++ = (char) ch;
+ c0 = ch;
+ }
+ *d = '\0';
+ }
+#endif
+}
+
+static int ProcessMailcapEntry(FILE *fp, struct MailcapEntry *mc, AcceptMedia media)
+{
+ size_t rawentryalloc = 2000, len, need;
+ char *rawentry, *s, *t;
+ char *LineBuf = NULL;
+
+ rawentry = (char *) malloc(rawentryalloc);
+ if (!rawentry)
+ ExitWithError(MEMORY_EXHAUSTED_ABORT);
+
+ *rawentry = '\0';
+ while (LYSafeGets(&LineBuf, fp) != 0) {
+ LYTrimNewline(LineBuf);
+ if (LineBuf[0] == '#' || LineBuf[0] == '\0')
+ continue;
+ len = strlen(LineBuf);
+ need = len + strlen(rawentry) + 1;
+ if (need > rawentryalloc) {
+ rawentryalloc += (2000 + need);
+ rawentry = typeRealloc(char, rawentry, rawentryalloc);
+
+ if (!rawentry)
+ ExitWithError(MEMORY_EXHAUSTED_ABORT);
+ }
+ if (len > 0 && LineBuf[len - 1] == ESCAPE) {
+ LineBuf[len - 1] = '\0';
+ strcat(rawentry, LineBuf);
+ } else {
+ strcat(rawentry, LineBuf);
+ break;
+ }
+ }
+ FREE(LineBuf);
+
+ t = s = LYSkipBlanks(rawentry);
+ if (!*s) {
+ /* totally blank entry -- quietly ignore */
+ FREE(rawentry);
+ return (0);
+ }
+ s = StrChr(rawentry, ';');
+ if (s == NULL) {
+ CTrace((tfp,
+ "ProcessMailcapEntry: Ignoring invalid mailcap entry: %s\n",
+ rawentry));
+ FREE(rawentry);
+ return (0);
+ }
+ *s++ = '\0';
+ if (!strncasecomp(t, STR_HTML, 9) ||
+ !strncasecomp(t, STR_PLAINTEXT, 10)) {
+ --s;
+ *s = ';';
+ CTrace((tfp, "ProcessMailcapEntry: Ignoring mailcap entry: %s\n",
+ rawentry));
+ FREE(rawentry);
+ return (0);
+ }
+ LYRemoveBlanks(rawentry);
+ LYLowerCase(rawentry);
+
+ mc->needsterminal = 0;
+ mc->copiousoutput = 0;
+ mc->needtofree = 1;
+ mc->testcommand = NULL;
+ mc->label = NULL;
+ mc->printcommand = NULL;
+ mc->contenttype = NULL;
+ StrAllocCopy(mc->contenttype, rawentry);
+ mc->quality = (float) 1.0;
+ mc->maxbytes = 0;
+ t = GetCommand(s, &mc->command);
+ if (!t) {
+ goto assign_presentation;
+ }
+ s = LYSkipBlanks(t);
+ while (s) {
+ char *arg, *eq, *mallocd_string;
+
+ t = GetCommand(s, &mallocd_string);
+ arg = mallocd_string;
+ eq = StrChr(arg, '=');
+ if (eq) {
+ *eq++ = '\0';
+ eq = LYSkipBlanks(eq);
+ }
+ if (non_empty(arg)) {
+ arg = Cleanse(arg);
+ if (!strcmp(arg, "needsterminal")) {
+ mc->needsterminal = 1;
+ } else if (!strcmp(arg, "copiousoutput")) {
+ mc->copiousoutput = 1;
+ } else if (eq && !strcmp(arg, "test")) {
+ mc->testcommand = NULL;
+ StrAllocCopy(mc->testcommand, eq);
+ TrimCommand(mc->testcommand);
+ CTrace((tfp, "ProcessMailcapEntry: Found testcommand:%s\n",
+ mc->testcommand));
+ } else if (eq && !strcmp(arg, "description")) {
+ mc->label = eq; /* ignored */
+ } else if (eq && !strcmp(arg, "label")) {
+ mc->label = eq; /* ignored: bogus old name for description */
+ } else if (eq && !strcmp(arg, "print")) {
+ mc->printcommand = eq; /* ignored */
+ } else if (eq && !strcmp(arg, "textualnewlines")) {
+ /* no support for now. What does this do anyways? */
+ /* ExceptionalNewline(mc->contenttype, atoi(eq)); */
+ } else if (eq && !strcmp(arg, "q")) {
+ mc->quality = (float) atof(eq);
+ if (mc->quality > 0.000 && mc->quality < 0.001)
+ mc->quality = (float) 0.001;
+ } else if (eq && !strcmp(arg, "mxb")) {
+ mc->maxbytes = atol(eq);
+ if (mc->maxbytes < 0)
+ mc->maxbytes = 0;
+ } else if (strcmp(arg, "notes")) { /* IGNORE notes field */
+ if (*arg)
+ CTrace((tfp,
+ "ProcessMailcapEntry: Ignoring mailcap flag '%s'.\n",
+ arg));
+ }
+
+ }
+ FREE(mallocd_string);
+ s = t;
+ }
+
+ assign_presentation:
+ FREE(rawentry);
+
+ if (PassesTest(mc)) {
+ CTrace((tfp, "ProcessMailcapEntry Setting up conversion %s : %s\n",
+ mc->contenttype, mc->command));
+ HTSetPresentation(mc->contenttype,
+ mc->command,
+ mc->testcommand,
+ mc->quality,
+ 3.0, 0.0, mc->maxbytes, media);
+ }
+ FREE(mc->command);
+ FREE(mc->testcommand);
+ FREE(mc->contenttype);
+
+ return (1);
+}
+
+#define L_CURL '{'
+#define R_CURL '}'
+
+static const char *LYSkipQuoted(const char *s)
+{
+ int escaped = 0;
+
+ ++s; /* skip first quote */
+ while (*s != 0) {
+ if (escaped) {
+ escaped = 0;
+ } else if (*s == ESCAPE) {
+ escaped = 1;
+ } else if (*s == DQUOTE) {
+ ++s;
+ break;
+ }
+ ++s;
+ }
+ return s;
+}
+
+/*
+ * Note: the tspecials[] here are those defined for Content-Type header, so
+ * this function is not really general-purpose.
+ */
+static const char *LYSkipToken(const char *s)
+{
+ static const char tspecials[] = "\"()<>@,;:\\/[]?.=";
+
+ while (*s != '\0' && !WHITE(*s) && StrChr(tspecials, *s) == 0) {
+ ++s;
+ }
+ return s;
+}
+
+static const char *LYSkipValue(const char *s)
+{
+ if (*s == DQUOTE)
+ s = LYSkipQuoted(s);
+ else
+ s = LYSkipToken(s);
+ return s;
+}
+
+/*
+ * Copy the value from the source, dequoting if needed.
+ */
+static char *LYCopyValue(const char *s)
+{
+ const char *t;
+ char *result = 0;
+ int j, k;
+
+ if (*s == DQUOTE) {
+ t = LYSkipQuoted(s);
+ StrAllocCopy(result, s + 1);
+ result[t - s - 2] = '\0';
+ for (j = k = 0;; ++j, ++k) {
+ if (result[j] == ESCAPE) {
+ ++j;
+ }
+ if ((result[k] = result[j]) == '\0')
+ break;
+ }
+ } else {
+ t = LYSkipToken(s);
+ StrAllocCopy(result, s);
+ result[t - s] = '\0';
+ }
+ return result;
+}
+
+/*
+ * The "Content-Type:" field, contains zero or more parameters after a ';'.
+ * Return the value of the named parameter, or null.
+ */
+static char *LYGetContentType(const char *name,
+ const char *params)
+{
+ char *result = 0;
+
+ if (params != 0) {
+ if (name != 0) {
+ size_t length = strlen(name);
+ const char *test = StrChr(params, ';'); /* skip type/subtype */
+ const char *next;
+
+ while (test != 0) {
+ BOOL found = FALSE;
+
+ ++test; /* skip the ';' */
+ test = LYSkipCBlanks(test);
+ next = LYSkipToken(test);
+ if ((next - test) == (int) length
+ && !StrNCmp(test, name, length)) {
+ found = TRUE;
+ }
+ test = LYSkipCBlanks(next);
+ if (*test == '=') {
+ ++test;
+ test = LYSkipCBlanks(test);
+ if (found) {
+ result = LYCopyValue(test);
+ break;
+ } else {
+ test = LYSkipValue(test);
+ }
+ test = LYSkipCBlanks(test);
+ }
+ if (*test != ';') {
+ break; /* we're lost */
+ }
+ }
+ } else { /* return the content-type */
+ StrAllocCopy(result, params);
+ *LYSkipNonBlanks(result) = '\0';
+ }
+ }
+ return result;
+}
+
+/*
+ * Check if the command uses a "%s" substitution. We need to know this, to
+ * decide when to create temporary files, etc.
+ */
+BOOL LYMailcapUsesPctS(const char *controlstring)
+{
+ BOOL result = FALSE;
+ const char *from;
+ const char *next;
+ int prefixed = 0;
+ int escaped = 0;
+
+ for (from = controlstring; *from != '\0'; from++) {
+ if (escaped) {
+ escaped = 0;
+ } else if (*from == ESCAPE) {
+ escaped = 1;
+ } else if (prefixed) {
+ prefixed = 0;
+ switch (*from) {
+ case '%': /* not defined */
+ case 'n':
+ case 'F':
+ case 't':
+ break;
+ case 's':
+ result = TRUE;
+ break;
+ case L_CURL:
+ next = StrChr(from, R_CURL);
+ if (next != 0) {
+ from = next;
+ break;
+ }
+ /* FALLTHRU */
+ default:
+ break;
+ }
+ } else if (*from == '%') {
+ prefixed = 1;
+ }
+ }
+ return result;
+}
+
+/*
+ * Build the command string for testing or executing a mailcap entry.
+ * If a substitution from the Content-Type header is requested but no
+ * parameters are available, return -1, otherwise 0.
+ *
+ * This does not support multipart %n or %F (does this apply to lynx?)
+ */
+static int BuildCommand(HTChunk *cmd,
+ const char *controlstring,
+ const char *TmpFileName,
+ const char *params)
+{
+ int result = 0;
+ size_t TmpFileLen = strlen(TmpFileName);
+ const char *from;
+ const char *next;
+ char *name, *value;
+ int prefixed = 0;
+ int escaped = 0;
+
+ for (from = controlstring; *from != '\0'; from++) {
+ if (escaped) {
+ escaped = 0;
+ HTChunkPutc(cmd, UCH(*from));
+ } else if (*from == ESCAPE) {
+ escaped = 1;
+ } else if (prefixed) {
+ prefixed = 0;
+ switch (*from) {
+ case '%': /* not defined */
+ HTChunkPutc(cmd, UCH(*from));
+ break;
+ case 'n':
+ /* FALLTHRU */
+ case 'F':
+ CTrace((tfp, "BuildCommand: Bad mailcap \"test\" clause: %s\n",
+ controlstring));
+ break;
+ case 't':
+ if ((value = LYGetContentType(NULL, params)) != 0) {
+ HTChunkPuts(cmd, value);
+ FREE(value);
+ }
+ break;
+ case 's':
+ if (TmpFileLen) {
+ HTChunkPuts(cmd, TmpFileName);
+ }
+ break;
+ case L_CURL:
+ next = StrChr(from, R_CURL);
+ if (next != 0) {
+ if (params != 0) {
+ ++from;
+ name = 0;
+ HTSprintf0(&name, "%.*s", (int) (next - from), from);
+ if ((value = LYGetContentType(name, params)) != 0) {
+ HTChunkPuts(cmd, value);
+ FREE(value);
+ } else if (name) {
+ if (!strcmp(name, "charset")) {
+ HTChunkPuts(cmd, "ISO-8859-1");
+ } else {
+ CTrace((tfp, "BuildCommand no value for %s\n", name));
+ }
+ }
+ FREE(name);
+ } else {
+ result = -1;
+ }
+ from = next;
+ break;
+ }
+ /* FALLTHRU */
+ default:
+ CTrace((tfp,
+ "BuildCommand: Ignoring unrecognized format code in mailcap file '%%%c'.\n",
+ *from));
+ break;
+ }
+ } else if (*from == '%') {
+ prefixed = 1;
+ } else {
+ HTChunkPutc(cmd, UCH(*from));
+ }
+ }
+ HTChunkTerminate(cmd);
+ return result;
+}
+
+/*
+ * Build the mailcap test-command and execute it. This is only invoked when
+ * we cannot tell just by looking at the command if it would succeed.
+ *
+ * Returns 0 for success, -1 for error and 1 for deferred.
+ */
+int LYTestMailcapCommand(const char *testcommand,
+ const char *params)
+{
+ int result;
+ char TmpFileName[LY_MAXPATH];
+ HTChunk *expanded = 0;
+
+ if (LYMailcapUsesPctS(testcommand)) {
+ if (LYOpenTemp(TmpFileName, HTML_SUFFIX, "w") == 0)
+ ExitWithError(CANNOT_OPEN_TEMP);
+ LYCloseTemp(TmpFileName);
+ } else {
+ /* We normally don't need a temp file name - kw */
+ TmpFileName[0] = '\0';
+ }
+ expanded = HTChunkCreate(1024);
+ if (BuildCommand(expanded, testcommand, TmpFileName, params) != 0) {
+ result = 1;
+ CTrace((tfp, "PassesTest: Deferring test command: %s\n", expanded->data));
+ } else {
+ CTrace((tfp, "PassesTest: Executing test command: %s\n", expanded->data));
+ if ((result = LYSystem(expanded->data)) != 0) {
+ result = -1;
+ CTrace((tfp, "PassesTest: Test failed!\n"));
+ } else {
+ CTrace((tfp, "PassesTest: Test passed!\n"));
+ }
+ }
+
+ HTChunkFree(expanded);
+ (void) LYRemoveTemp(TmpFileName);
+
+ return result;
+}
+
+char *LYMakeMailcapCommand(const char *command,
+ const char *params,
+ const char *filename)
+{
+ HTChunk *expanded = 0;
+ char *result = 0;
+
+ expanded = HTChunkCreate(1024);
+ BuildCommand(expanded, command, filename, params);
+ StrAllocCopy(result, expanded->data);
+ HTChunkFree(expanded);
+ return result;
+}
+
+#define RTR_forget 0
+#define RTR_lookup 1
+#define RTR_add 2
+
+static int RememberTestResult(int mode, char *cmd, int result)
+{
+ struct cmdlist_s {
+ char *cmd;
+ int result;
+ struct cmdlist_s *next;
+ };
+ static struct cmdlist_s *cmdlist = NULL;
+ struct cmdlist_s *cur;
+
+ switch (mode) {
+ case RTR_forget:
+ while (cmdlist) {
+ cur = cmdlist->next;
+ FREE(cmdlist->cmd);
+ FREE(cmdlist);
+ cmdlist = cur;
+ }
+ break;
+ case RTR_lookup:
+ for (cur = cmdlist; cur; cur = cur->next)
+ if (!strcmp(cmd, cur->cmd))
+ return cur->result;
+ return -1;
+ case RTR_add:
+ cur = typecalloc(struct cmdlist_s);
+
+ if (cur == NULL)
+ outofmem(__FILE__, "RememberTestResult");
+
+ cur->next = cmdlist;
+ StrAllocCopy(cur->cmd, cmd);
+ cur->result = result;
+ cmdlist = cur;
+ break;
+ }
+ return 0;
+}
+
+/* FIXME: this sometimes used caseless comparison, e.g., strcasecomp */
+#define SameCommand(tst,ref) !strcmp(tst,ref)
+
+static int PassesTest(struct MailcapEntry *mc)
+{
+ int result;
+
+ /*
+ * Make sure we have a command
+ */
+ if (!mc->testcommand)
+ return (1);
+
+ /*
+ * Save overhead of system() calls by faking these. - FM
+ */
+ if (SameCommand(mc->testcommand, "test \"$DISPLAY\"") ||
+ SameCommand(mc->testcommand, "test \"$DISPLAY\" != \"\"") ||
+ SameCommand(mc->testcommand, "test -n \"$DISPLAY\"")) {
+ FREE(mc->testcommand);
+ CTrace((tfp, "PassesTest: Testing for XWINDOWS environment.\n"));
+ if (LYgetXDisplay() != NULL) {
+ CTrace((tfp, "PassesTest: Test passed!\n"));
+ return (0 == 0);
+ } else {
+ CTrace((tfp, "PassesTest: Test failed!\n"));
+ return (-1 == 0);
+ }
+ }
+ if (SameCommand(mc->testcommand, "test -z \"$DISPLAY\"")) {
+ FREE(mc->testcommand);
+ CTrace((tfp, "PassesTest: Testing for NON_XWINDOWS environment.\n"));
+ if (LYgetXDisplay() == NULL) {
+ CTrace((tfp, "PassesTest: Test passed!\n"));
+ return (0 == 0);
+ } else {
+ CTrace((tfp, "PassesTest: Test failed!\n"));
+ return (-1 == 0);
+ }
+ }
+
+ /*
+ * Why do anything but return success for this one! - FM
+ */
+ if (SameCommand(mc->testcommand, "test -n \"$LYNX_VERSION\"")) {
+ FREE(mc->testcommand);
+ CTrace((tfp, "PassesTest: Testing for LYNX environment.\n"));
+ CTrace((tfp, "PassesTest: Test passed!\n"));
+ return (0 == 0);
+ } else
+ /*
+ * ... or failure for this one! - FM
+ */
+ if (SameCommand(mc->testcommand, "test -z \"$LYNX_VERSION\"")) {
+ FREE(mc->testcommand);
+ CTrace((tfp, "PassesTest: Testing for non-LYNX environment.\n"));
+ CTrace((tfp, "PassesTest: Test failed!\n"));
+ return (-1 == 0);
+ }
+
+ result = RememberTestResult(RTR_lookup, mc->testcommand, 0);
+ if (result == -1) {
+ result = LYTestMailcapCommand(mc->testcommand, NULL);
+ RememberTestResult(RTR_add, mc->testcommand, result ? 1 : 0);
+ }
+
+ /*
+ * Free the test command as well since
+ * we won't be needing it anymore.
+ */
+ if (result != 1)
+ FREE(mc->testcommand);
+
+ if (result < 0) {
+ CTrace((tfp, "PassesTest: Test failed!\n"));
+ } else if (result == 0) {
+ CTrace((tfp, "PassesTest: Test passed!\n"));
+ }
+
+ return (result >= 0);
+}
+
+static int ProcessMailcapFile(char *file, AcceptMedia media)
+{
+ struct MailcapEntry mc;
+ FILE *fp;
+
+ CTrace((tfp, "ProcessMailcapFile: Loading file '%s'.\n",
+ file));
+ if ((fp = fopen(file, TXT_R)) == NULL) {
+ CTrace((tfp, "ProcessMailcapFile: Could not open '%s'.\n",
+ file));
+ return (-1 == 0);
+ }
+
+ while (fp && !feof(fp)) {
+ ProcessMailcapEntry(fp, &mc, media);
+ }
+ LYCloseInput(fp);
+ RememberTestResult(RTR_forget, NULL, 0);
+ return (0 == 0);
+}
+
+static int ExitWithError(const char *txt)
+{
+ if (txt)
+ fprintf(tfp, "Lynx: %s\n", txt);
+ exit_immediately(EXIT_FAILURE);
+ return (-1);
+}
+
+/* Reverse the entries from each mailcap after it has been read, so that
+ * earlier entries have precedence. Set to 0 to get traditional lynx
+ * behavior, which means that the last match wins. - kw */
+static int reverse_mailcap = 1;
+
+static int HTLoadTypesConfigFile(char *fn, AcceptMedia media)
+{
+ int result = 0;
+ HTList *saved = HTPresentations;
+
+ if (reverse_mailcap) { /* temporarily hide existing list */
+ HTPresentations = NULL;
+ }
+
+ result = ProcessMailcapFile(fn, media);
+
+ if (reverse_mailcap) {
+ if (result && HTPresentations) {
+ HTList_reverse(HTPresentations);
+ HTList_appendList(HTPresentations, saved);
+ FREE(saved);
+ } else {
+ HTPresentations = saved;
+ }
+ }
+ return result;
+}
+
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
+/* Define a basic set of suffixes
+ * ------------------------------
+ *
+ * The LAST suffix for a type is that used for temporary files
+ * of that type.
+ * The quality is an apriori bias as to whether the file should be
+ * used. Not that different suffixes can be used to represent files
+ * which are of the same format but are originals or regenerated,
+ * with different values.
+ */
+/*
+ * Additional notes: the encoding parameter may be taken into account when
+ * looking for a match; for that purpose "7bit", "8bit", and "binary" are
+ * equivalent.
+ *
+ * Use of mixed case and of pseudo MIME types with embedded spaces should be
+ * avoided. It was once necessary for getting the fancy strings into type
+ * labels in FTP directory listings, but that can now be done with the
+ * description field (using HTSetSuffix5). AFAIK the only effect of such
+ * "fancy" (and mostly invalid) types that cannot be reproduced by using a
+ * description fields is some statusline messages in SaveToFile (HTFWriter.c).
+ * And showing the user an invalid MIME type as the 'Content-type:' is not such
+ * a hot idea anyway, IMO. Still, if you want it, it is still possible (even
+ * in lynx.cfg now), but use of it in the defaults below has been reduced.
+ *
+ * Case variations rely on peculiar behavior of HTAtom.c for matching. They
+ * lead to surprising behavior, Lynx retains the case of a string in the form
+ * first encountered after starting up. So while later suffix rules generally
+ * override or modify earlier ones, the case used for a MIME time is determined
+ * by the first suffix rule (or other occurrence). Matching in HTAtom_for is
+ * effectively case insensitive, except for the first character of the string
+ * which is treated as case-sensitive by the hash function there; best not to
+ * rely on that, rather convert MIME types to lowercase on input as is already
+ * done in most places (And HTAtom could become consistently case-sensitive, as
+ * in newer W3C libwww).
+ * - kw 1999-10-12
+ */
+void HTFileInit(void)
+{
+#ifdef BUILTIN_SUFFIX_MAPS
+ if (LYUseBuiltinSuffixes) {
+ CTrace((tfp, "HTFileInit: Loading default (HTInit) extension maps.\n"));
+
+ /* default suffix interpretation */
+ SET_SUFFIX1("*", STR_PLAINTEXT, "8bit");
+ SET_SUFFIX1("*.*", STR_PLAINTEXT, "8bit");
+
+#ifdef EXEC_SCRIPTS
+ /*
+ * define these extensions for exec scripts.
+ */
+#ifndef VMS
+ /* for csh exec links */
+ HTSetSuffix(".csh", "application/x-csh", "8bit", 0.8);
+ HTSetSuffix(".sh", "application/x-sh", "8bit", 0.8);
+ HTSetSuffix(".ksh", "application/x-ksh", "8bit", 0.8);
+#else
+ HTSetSuffix(".com", "application/x-VMS_script", "8bit", 0.8);
+#endif /* !VMS */
+#endif /* EXEC_SCRIPTS */
+
+ /*
+ * Some of the old incarnation of the mappings is preserved and can be had
+ * by defining TRADITIONAL_SUFFIXES. This is for some cases where I felt
+ * the old rules might be preferred by someone, for some reason. It's not
+ * done consistently. A lot more of this stuff could probably be changed
+ * too or omitted, now that nearly the equivalent functionality is
+ * available in lynx.cfg. - kw 1999-10-12
+ */
+ /* *INDENT-OFF* */
+ SET_SUFFIX1(".saveme", "application/x-Binary", "binary");
+ SET_SUFFIX1(".dump", "application/x-Binary", "binary");
+ SET_SUFFIX1(".bin", "application/x-Binary", "binary");
+
+ SET_SUFFIX1(".arc", "application/x-Compressed", "binary");
+
+ SET_SUFFIX1(".alpha-exe", "application/x-Executable", "binary");
+ SET_SUFFIX1(".alpha_exe", "application/x-Executable", "binary");
+ SET_SUFFIX1(".AXP-exe", "application/x-Executable", "binary");
+ SET_SUFFIX1(".AXP_exe", "application/x-Executable", "binary");
+ SET_SUFFIX1(".VAX-exe", "application/x-Executable", "binary");
+ SET_SUFFIX1(".VAX_exe", "application/x-Executable", "binary");
+ SET_SUFFIX5(".exe", STR_BINARY, "binary", "Executable");
+
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX1(".exe.Z", "application/x-Comp. Executable", "binary");
+ SET_SUFFIX1(".Z", "application/UNIX Compressed", "binary");
+ SET_SUFFIX1(".tar_Z", "application/UNIX Compr. Tar", "binary");
+ SET_SUFFIX1(".tar.Z", "application/UNIX Compr. Tar", "binary");
+#else
+ SET_SUFFIX5(".Z", "application/x-compress", "binary", "UNIX Compressed");
+ SET_SUFFIX5(".Z", NULL, "compress", "UNIX Compressed");
+ SET_SUFFIX5(".exe.Z", STR_BINARY, "compress", "Executable");
+ SET_SUFFIX5(".tar_Z", "application/x-tar", "compress", "UNIX Compr. Tar");
+ SET_SUFFIX5(".tar.Z", "application/x-tar", "compress", "UNIX Compr. Tar");
+#endif
+
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX1("-gz", "application/GNU Compressed", "binary");
+ SET_SUFFIX1("_gz", "application/GNU Compressed", "binary");
+ SET_SUFFIX1(".gz", "application/GNU Compressed", "binary");
+
+ SET_SUFFIX5(".tar.gz", "application/x-tar", "binary", "GNU Compr. Tar");
+ SET_SUFFIX5(".tgz", "application/x-tar", "gzip", "GNU Compr. Tar");
+#else
+ SET_SUFFIX5("-gz", "application/x-gzip", "binary", "GNU Compressed");
+ SET_SUFFIX5("_gz", "application/x-gzip", "binary", "GNU Compressed");
+ SET_SUFFIX5(".gz", "application/x-gzip", "binary", "GNU Compressed");
+ SET_SUFFIX5("-gz", NULL, "gzip", "GNU Compressed");
+ SET_SUFFIX5("_gz", NULL, "gzip", "GNU Compressed");
+ SET_SUFFIX5(".gz", NULL, "gzip", "GNU Compressed");
+
+ SET_SUFFIX5(".tar.gz", "application/x-tar", "gzip", "GNU Compr. Tar");
+ SET_SUFFIX5(".tgz", "application/x-tar", "gzip", "GNU Compr. Tar");
+#endif
+
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX1(".src", "application/x-WAIS-source", "8bit");
+ SET_SUFFIX1(".wsrc", "application/x-WAIS-source", "8bit");
+#else
+ SET_SUFFIX5(".wsrc", "application/x-wais-source", "8bit", "WAIS-source");
+#endif
+
+ SET_SUFFIX5(".zip", "application/zip", "binary", "Zip File");
+
+ SET_SUFFIX1(".zz", "application/x-deflate", "binary");
+ SET_SUFFIX1(".zz", "application/deflate", "binary");
+
+ SET_SUFFIX1(".bz2", "application/x-bzip2", "binary");
+ SET_SUFFIX1(".bz2", "application/bzip2", "binary");
+
+ SET_SUFFIX1(".br", "application/x-brotli", "binary");
+
+ SET_SUFFIX1(".xz", "application/x-xz", "binary");
+
+ SET_SUFFIX1(".lz", "application/x-lzip", "binary");
+ SET_SUFFIX1(".lzma", "application/x-lzma", "binary");
+
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX1(".uu", "application/x-UUencoded", "8bit");
+
+ SET_SUFFIX1(".hqx", "application/x-Binhex", "8bit");
+
+ SET_SUFFIX1(".o", "application/x-Prog. Object", "binary");
+ SET_SUFFIX1(".a", "application/x-Prog. Library", "binary");
+#else
+ SET_SUFFIX5(".uu", "application/x-uuencoded", "7bit", "UUencoded");
+
+ SET_SUFFIX5(".hqx", "application/mac-binhex40", "8bit", "Mac BinHex");
+
+ HTSetSuffix5(".o", STR_BINARY, "binary", "Prog. Object", 0.5);
+ HTSetSuffix5(".a", STR_BINARY, "binary", "Prog. Library", 0.5);
+ HTSetSuffix5(".so", STR_BINARY, "binary", "Shared Lib", 0.5);
+#endif
+
+ SET_SUFFIX5(".oda", "application/oda", "binary", "ODA");
+
+ SET_SUFFIX5(".pdf", "application/pdf", "binary", "PDF");
+
+ SET_SUFFIX5(".eps", "application/postscript", "8bit", "Postscript");
+ SET_SUFFIX5(".ai", "application/postscript", "8bit", "Postscript");
+ SET_SUFFIX5(".ps", "application/postscript", "8bit", "Postscript");
+
+ SET_SUFFIX5(".rtf", "application/rtf", "8bit", "RTF");
+
+ SET_SUFFIX5(".dvi", "application/x-dvi", "8bit", "DVI");
+
+ SET_SUFFIX5(".hdf", "application/x-hdf", "8bit", "HDF");
+
+ SET_SUFFIX1(".cdf", "application/x-netcdf", "8bit");
+ SET_SUFFIX1(".nc", "application/x-netcdf", "8bit");
+
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX1(".latex", "application/x-Latex", "8bit");
+ SET_SUFFIX1(".tex", "application/x-Tex", "8bit");
+ SET_SUFFIX1(".texinfo", "application/x-Texinfo", "8bit");
+ SET_SUFFIX1(".texi", "application/x-Texinfo", "8bit");
+#else
+ SET_SUFFIX5(".latex", "application/x-latex", "8bit", "LaTeX");
+ SET_SUFFIX5(".tex", "text/x-tex", "8bit", "TeX");
+ SET_SUFFIX5(".texinfo", "application/x-texinfo", "8bit", "Texinfo");
+ SET_SUFFIX5(".texi", "application/x-texinfo", "8bit", "Texinfo");
+#endif
+
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX1(".t", "application/x-Troff", "8bit");
+ SET_SUFFIX1(".tr", "application/x-Troff", "8bit");
+ SET_SUFFIX1(".roff", "application/x-Troff", "8bit");
+
+ SET_SUFFIX1(".man", "application/x-Troff-man", "8bit");
+ SET_SUFFIX1(".me", "application/x-Troff-me", "8bit");
+ SET_SUFFIX1(".ms", "application/x-Troff-ms", "8bit");
+#else
+ SET_SUFFIX5(".t", "application/x-troff", "8bit", "Troff");
+ SET_SUFFIX5(".tr", "application/x-troff", "8bit", "Troff");
+ SET_SUFFIX5(".roff", "application/x-troff", "8bit", "Troff");
+
+ SET_SUFFIX5(".man", "application/x-troff-man", "8bit", "Man Page");
+ SET_SUFFIX5(".me", "application/x-troff-me", "8bit", "Troff me");
+ SET_SUFFIX5(".ms", "application/x-troff-ms", "8bit", "Troff ms");
+#endif
+
+ SET_SUFFIX1(".zoo", "application/x-Zoo File", "binary");
+
+#if defined(TRADITIONAL_SUFFIXES) || defined(VMS)
+ SET_SUFFIX1(".bak", "application/x-VMS BAK File", "binary");
+ SET_SUFFIX1(".bkp", "application/x-VMS BAK File", "binary");
+ SET_SUFFIX1(".bck", "application/x-VMS BAK File", "binary");
+
+ SET_SUFFIX5(".bkp_gz", STR_BINARY, "gzip", "GNU BAK File");
+ SET_SUFFIX5(".bkp-gz", STR_BINARY, "gzip", "GNU BAK File");
+ SET_SUFFIX5(".bck_gz", STR_BINARY, "gzip", "GNU BAK File");
+ SET_SUFFIX5(".bck-gz", STR_BINARY, "gzip", "GNU BAK File");
+
+ SET_SUFFIX5(".bkp-Z", STR_BINARY, "compress", "Comp. BAK File");
+ SET_SUFFIX5(".bkp_Z", STR_BINARY, "compress", "Comp. BAK File");
+ SET_SUFFIX5(".bck-Z", STR_BINARY, "compress", "Comp. BAK File");
+ SET_SUFFIX5(".bck_Z", STR_BINARY, "compress", "Comp. BAK File");
+#else
+ HTSetSuffix5(".bak", NULL, "binary", "Backup", 0.5);
+ SET_SUFFIX5(".bkp", STR_BINARY, "binary", "VMS BAK File");
+ SET_SUFFIX5(".bck", STR_BINARY, "binary", "VMS BAK File");
+#endif
+
+#if defined(TRADITIONAL_SUFFIXES) || defined(VMS)
+ SET_SUFFIX1(".hlb", "application/x-VMS Help Libr.", "binary");
+ SET_SUFFIX1(".olb", "application/x-VMS Obj. Libr.", "binary");
+ SET_SUFFIX1(".tlb", "application/x-VMS Text Libr.", "binary");
+ SET_SUFFIX1(".obj", "application/x-VMS Prog. Obj.", "binary");
+ SET_SUFFIX1(".decw$book", "application/x-DEC BookReader", "binary");
+ SET_SUFFIX1(".mem", "application/x-RUNOFF-MANUAL", "8bit");
+#else
+ SET_SUFFIX5(".hlb", STR_BINARY, "binary", "VMS Help Libr.");
+ SET_SUFFIX5(".olb", STR_BINARY, "binary", "VMS Obj. Libr.");
+ SET_SUFFIX5(".tlb", STR_BINARY, "binary", "VMS Text Libr.");
+ SET_SUFFIX5(".obj", STR_BINARY, "binary", "Prog. Object");
+ SET_SUFFIX5(".decw$book", STR_BINARY, "binary", "DEC BookReader");
+ SET_SUFFIX5(".mem", "text/x-runoff-manual", "8bit", "RUNOFF-MANUAL");
+#endif
+
+ SET_SUFFIX1(".vsd", "application/visio", "binary");
+
+ SET_SUFFIX5(".lha", "application/x-lha", "binary", "lha File");
+ SET_SUFFIX5(".lzh", "application/x-lzh", "binary", "lzh File");
+ SET_SUFFIX5(".sea", "application/x-sea", "binary", "sea File");
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX5(".sit", "application/x-sit", "binary", "sit File");
+#else
+ SET_SUFFIX5(".sit", "application/x-stuffit", "binary", "StuffIt");
+#endif
+ SET_SUFFIX5(".dms", "application/x-dms", "binary", "dms File");
+ SET_SUFFIX5(".iff", "application/x-iff", "binary", "iff File");
+
+ SET_SUFFIX1(".bcpio", "application/x-bcpio", "binary");
+ SET_SUFFIX1(".cpio", "application/x-cpio", "binary");
+
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX1(".gtar", "application/x-gtar", "binary");
+#endif
+
+ SET_SUFFIX1(".shar", "application/x-shar", "8bit");
+ SET_SUFFIX1(".share", "application/x-share", "8bit");
+
+#ifdef TRADITIONAL_SUFFIXES
+ SET_SUFFIX1(".sh", "application/x-sh", "8bit"); /* xtra */
+#endif
+
+ SET_SUFFIX1(".sv4cpio", "application/x-sv4cpio", "binary");
+ SET_SUFFIX1(".sv4crc", "application/x-sv4crc", "binary");
+
+ SET_SUFFIX5(".tar", "application/x-tar", "binary", "Tar File");
+ SET_SUFFIX1(".ustar", "application/x-ustar", "binary");
+
+ SET_SUFFIX1(".snd", "audio/basic", "binary");
+ SET_SUFFIX1(".au", "audio/basic", "binary");
+
+ SET_SUFFIX1(".aifc", "audio/x-aiff", "binary");
+ SET_SUFFIX1(".aif", "audio/x-aiff", "binary");
+ SET_SUFFIX1(".aiff", "audio/x-aiff", "binary");
+ SET_SUFFIX1(".wav", "audio/x-wav", "binary");
+ SET_SUFFIX1(".midi", "audio/midi", "binary");
+ SET_SUFFIX1(".mod", "audio/mod", "binary");
+
+ SET_SUFFIX1(".gif", "image/gif", "binary");
+ SET_SUFFIX1(".ief", "image/ief", "binary");
+ SET_SUFFIX1(".jfif", "image/jpeg", "binary"); /* xtra */
+ SET_SUFFIX1(".jfif-tbnl", "image/jpeg", "binary"); /* xtra */
+ SET_SUFFIX1(".jpe", "image/jpeg", "binary");
+ SET_SUFFIX1(".jpg", "image/jpeg", "binary");
+ SET_SUFFIX1(".jpeg", "image/jpeg", "binary");
+ SET_SUFFIX1(".tif", "image/tiff", "binary");
+ SET_SUFFIX1(".tiff", "image/tiff", "binary");
+ SET_SUFFIX1(".ham", "image/ham", "binary");
+ SET_SUFFIX1(".ras", "image/x-cmu-rast", "binary");
+ SET_SUFFIX1(".pnm", "image/x-portable-anymap", "binary");
+ SET_SUFFIX1(".pbm", "image/x-portable-bitmap", "binary");
+ SET_SUFFIX1(".pgm", "image/x-portable-graymap", "binary");
+ SET_SUFFIX1(".ppm", "image/x-portable-pixmap", "binary");
+ SET_SUFFIX1(".png", "image/png", "binary");
+ SET_SUFFIX1(".rgb", "image/x-rgb", "binary");
+ SET_SUFFIX1(".xbm", "image/x-xbitmap", "binary");
+ SET_SUFFIX1(".xpm", "image/x-xpixmap", "binary");
+ SET_SUFFIX1(".xwd", "image/x-xwindowdump", "binary");
+
+ SET_SUFFIX1(".rtx", "text/richtext", "8bit");
+ SET_SUFFIX1(".tsv", "text/tab-separated-values", "8bit");
+ SET_SUFFIX1(".etx", "text/x-setext", "8bit");
+
+ SET_SUFFIX1(".mpg", "video/mpeg", "binary");
+ SET_SUFFIX1(".mpe", "video/mpeg", "binary");
+ SET_SUFFIX1(".mpeg", "video/mpeg", "binary");
+ SET_SUFFIX1(".mov", "video/quicktime", "binary");
+ SET_SUFFIX1(".qt", "video/quicktime", "binary");
+ SET_SUFFIX1(".avi", "video/x-msvideo", "binary");
+ SET_SUFFIX1(".movie", "video/x-sgi-movie", "binary");
+ SET_SUFFIX1(".mv", "video/x-sgi-movie", "binary");
+
+ SET_SUFFIX1(".mime", "message/rfc822", "8bit");
+
+ SET_SUFFIX1(".c", STR_PLAINTEXT, "8bit");
+ SET_SUFFIX1(".cc", STR_PLAINTEXT, "8bit");
+ SET_SUFFIX1(".c++", STR_PLAINTEXT, "8bit");
+ SET_SUFFIX1(".css", STR_PLAINTEXT, "8bit");
+ SET_SUFFIX1(".h", STR_PLAINTEXT, "8bit");
+ SET_SUFFIX1(".pl", STR_PLAINTEXT, "8bit");
+ SET_SUFFIX1(".text", STR_PLAINTEXT, "8bit");
+ SET_SUFFIX1(".txt", STR_PLAINTEXT, "8bit");
+
+ SET_SUFFIX1(".php", STR_HTML, "8bit");
+ SET_SUFFIX1(".php3", STR_HTML, "8bit");
+ SET_SUFFIX1(".html3", STR_HTML, "8bit");
+ SET_SUFFIX1(".ht3", STR_HTML, "8bit");
+ SET_SUFFIX1(".phtml", STR_HTML, "8bit");
+ SET_SUFFIX1(".shtml", STR_HTML, "8bit");
+ SET_SUFFIX1(".sht", STR_HTML, "8bit");
+ SET_SUFFIX1(".htmlx", STR_HTML, "8bit");
+ SET_SUFFIX1(".htm", STR_HTML, "8bit");
+ SET_SUFFIX1(".html", STR_HTML, "8bit");
+ /* *INDENT-ON* */
+
+ } else { /* LYSuffixRules */
+ /*
+ * Note that even .html -> text/html, .htm -> text/html are omitted if
+ * default maps are compiled in but then skipped because of a
+ * configuration file directive. Whoever changes the config file in
+ * this way can easily also add the SUFFIX rules there. - kw
+ */
+ CTrace((tfp,
+ "HTFileInit: Skipping all default (HTInit) extension maps!\n"));
+ } /* LYSuffixRules */
+
+#else /* BUILTIN_SUFFIX_MAPS */
+
+ CTrace((tfp,
+ "HTFileInit: Default (HTInit) extension maps not compiled in.\n"));
+ /*
+ * The following two are still used if BUILTIN_SUFFIX_MAPS was undefined.
+ * Without one of them, lynx would always need to have a mapping specified
+ * in a lynx.cfg or mime.types file to be usable for local HTML files at
+ * all. That includes many of the generated user interface pages. - kw
+ */
+ SET_SUFFIX1(".htm", STR_HTML, "8bit");
+ SET_SUFFIX1(".html", STR_HTML, "8bit");
+#endif /* BUILTIN_SUFFIX_MAPS */
+
+ if (LYisAbsPath(global_extension_map)) {
+ /* These should override the default extensions as necessary. */
+ HTLoadExtensionsConfigFile(global_extension_map);
+ }
+
+ /*
+ * Load the local maps.
+ */
+ if (IsOurFile(LYAbsOrHomePath(&personal_extension_map))
+ && LYCanReadFile(personal_extension_map)) {
+ /* These should override everything else. */
+ HTLoadExtensionsConfigFile(personal_extension_map);
+ }
+}
+
+/* -------------------- Extension config file reading --------------------- */
+
+/*
+ * The following is lifted from NCSA httpd 1.0a1, by Rob McCool;
+ * NCSA httpd is in the public domain, as is this code.
+ *
+ * Modified Oct 97 - KW
+ */
+
+#define MAX_STRING_LEN 256
+
+static int HTGetLine(char *s, int n, FILE *f)
+{
+ register int i = 0, r;
+
+ if (!f)
+ return (1);
+
+ while (1) {
+ r = fgetc(f);
+ s[i] = (char) r;
+
+ if (s[i] == CR) {
+ r = fgetc(f);
+ if (r == LF)
+ s[i] = (char) r;
+ else if (r != EOF)
+ ungetc(r, f);
+ }
+
+ if ((r == EOF) || (s[i] == LF) || (s[i] == CR) || (i == (n - 1))) {
+ s[i] = '\0';
+ return (feof(f) ? 1 : 0);
+ }
+ ++i;
+ }
+}
+
+static void HTGetWord(char *word, char *line, int stop, int stop2)
+{
+ int x = 0, y;
+
+ for (x = 0; (line[x]
+ && UCH(line[x]) != UCH(stop)
+ && UCH(line[x]) != UCH(stop2)); x++) {
+ word[x] = line[x];
+ }
+
+ word[x] = '\0';
+ if (line[x])
+ ++x;
+ y = 0;
+
+ while ((line[y++] = line[x++])) {
+ ;
+ }
+
+ return;
+}
+
+static int HTLoadExtensionsConfigFile(char *fn)
+{
+ char line[MAX_STRING_LEN];
+ char word[MAX_STRING_LEN];
+ char *ct;
+ FILE *f;
+ int count = 0;
+
+ CTrace((tfp, "HTLoadExtensionsConfigFile: Loading file '%s'.\n", fn));
+
+ if ((f = fopen(fn, TXT_R)) == NULL) {
+ CTrace((tfp, "HTLoadExtensionsConfigFile: Could not open '%s'.\n", fn));
+ return count;
+ }
+
+ while (!(HTGetLine(line, (int) sizeof(line), f))) {
+ HTGetWord(word, line, ' ', '\t');
+ if (line[0] == '\0' || word[0] == '#')
+ continue;
+ ct = NULL;
+ StrAllocCopy(ct, word);
+ LYLowerCase(ct);
+
+ while (line[0]) {
+ HTGetWord(word, line, ' ', '\t');
+ if (word[0] && (word[0] != ' ')) {
+ char *ext = NULL;
+
+ HTSprintf0(&ext, ".%s", word);
+ LYLowerCase(ext);
+
+ CTrace((tfp, "setting suffix '%s' to '%s'.\n", ext, ct));
+
+ if (strstr(ct, "tex") != NULL ||
+ strstr(ct, "postscript") != NULL ||
+ strstr(ct, "sh") != NULL ||
+ strstr(ct, "troff") != NULL ||
+ strstr(ct, "rtf") != NULL)
+ SET_SUFFIX1(ext, ct, "8bit");
+ else
+ SET_SUFFIX1(ext, ct, "binary");
+ count++;
+
+ FREE(ext);
+ }
+ }
+ FREE(ct);
+ }
+ LYCloseInput(f);
+
+ return count;
+}