/*

 * $LynxId: HTInit.c,v 1.90 2018/03/05 22:35:07 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", "www/present", HTMIMERedirect, 2.0);

    SET_INTERNL("message/x-http-redirection", "www/debug", HTMIMERedirect, 1.0);

    SET_INTERNL("www/mime", "www/present", HTMIMEConvert, 1.0);

    SET_INTERNL("www/mime", "www/download", HTMIMEConvert, 1.0);

    SET_INTERNL("www/mime", "www/source", HTMIMEConvert, 1.0);

    SET_INTERNL("www/mime", "www/dump", HTMIMEConvert, 1.0);

    /*

     * Add our compressed file handlers.

     */

    SET_INTERNL("www/compressed", "www/download", HTCompressed, 1.0);

    SET_INTERNL("www/compressed", "www/present", HTCompressed, 1.0);

    SET_INTERNL("www/compressed", "www/source", HTCompressed, 1.0);

    SET_INTERNL("www/compressed", "www/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", "www/present", HTMLPresent, 2.0);

    SET_INTERNL("application/html", "www/source", HTPlainPresent, 1.0);

    SET_INTERNL("application/xml", "www/present", HTMLPresent, 2.0);

    SET_INTERNL("application/x-wais-source", "www/source", HTPlainPresent, 1.0);

    SET_INTERNL("application/x-wais-source", "www/present", HTWSRCConvert, 2.0);

    SET_INTERNL("application/x-wais-source", "www/download", HTWSRCConvert, 1.0);

    SET_INTERNL("application/x-wais-source", "www/dump", HTWSRCConvert, 1.0);

    /*

     * Save all unknown mime types to disk.

     */

    SET_EXTERNL("www/source", "www/present", HTSaveToFile, 1.0);

    SET_EXTERNL("www/source", "www/source", HTSaveToFile, 1.0);

    SET_EXTERNL("www/source", "www/download", HTSaveToFile, 1.0);

    SET_EXTERNL("www/source", "*", HTSaveToFile, 1.0);

    /*

     * Output all www/dump presentations to stdout.

     */

    SET_EXTERNL("www/source", "www/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, "www/source", HTPlainPresent, 1.0);

    SET_INTERNL(STR_PLAINTEXT, "www/source", HTPlainPresent, 1.0);

    SET_INTERNL("text/sgml", "www/source", HTPlainPresent, 1.0);

    SET_INTERNL("text/x-sgml", "www/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", "www/present", HTMLPresent, 1.0);

    SET_INTERNL("text/css", "www/present", HTPlainPresent, 1.0);

    SET_INTERNL(STR_HTML, "www/present", HTMLPresent, 1.0);

    SET_INTERNL(STR_PLAINTEXT, "www/present", HTPlainPresent, 1.0);

    SET_INTERNL("text/sgml", "www/present", HTMLPresent, 1.0);

    SET_INTERNL("text/x-sgml", "www/present", HTMLPresent, 2.0);

    SET_INTERNL("text/xml", "www/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, "www/source", HTMLParsedPresent, 1.0);

	SET_INTERNL(STR_HTML, "www/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);