Adding upstream version 2.9.0dev.12.upstream/2.9.0dev.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 4177 insertions, 0 deletions

diff --git a/WWW/Library/Implementation/HTFTP.c b/WWW/Library/Implementation/HTFTP.c
new file mode 100644
index 0000000..decf559
--- /dev/null
+++ b/WWW/Library/Implementation/HTFTP.c
@@ -0,0 +1,4177 @@
+/*
+ * $LynxId: HTFTP.c,v 1.148 2023/01/05 09:17:15 tom Exp $
+ *
+ *			File Transfer Protocol (FTP) Client
+ *			for a WorldWideWeb browser
+ *			===================================
+ *
+ *	A cache of control connections is kept.
+ *
+ * Note: Port allocation
+ *
+ *	It is essential that the port is allocated by the system, rather
+ *	than chosen in rotation by us (POLL_PORTS), or the following
+ *	problem occurs.
+ *
+ *	It seems that an attempt by the server to connect to a port which has
+ *	been used recently by a listen on the same socket, or by another
+ *	socket this or another process causes a hangup of (almost exactly)
+ *	one minute.  Therefore, we have to use a rotating port number.
+ *	The problem remains that if the application is run twice in quick
+ *	succession, it will hang for what remains of a minute.
+ *
+ * Authors
+ *	TBL	Tim Berners-lee <timbl@info.cern.ch>
+ *	DD	Denis DeLaRoca 310 825-4580 <CSP1DWD@mvs.oac.ucla.edu>
+ *	LM	Lou Montulli <montulli@ukanaix.cc.ukans.edu>
+ *	FM	Foteos Macrides <macrides@sci.wfeb.edu>
+ * History:
+ *	 2 May 91	Written TBL, as a part of the WorldWideWeb project.
+ *	15 Jan 92	Bug fix: close() was used for NETCLOSE for control soc
+ *	10 Feb 92	Retry if cached connection times out or breaks
+ *	 8 Dec 92	Bug fix 921208 TBL after DD
+ *	17 Dec 92	Anon FTP password now just WWWuser@ suggested by DD
+ *			fails on princeton.edu!
+ *	27 Dec 93 (FM)	Fixed up so FTP now works with VMS hosts.  Path
+ *			must be Unix-style and cannot include the device
+ *			or top directory.
+ *	?? ??? ?? (LM)	Added code to prompt and send passwords for non
+ *			anonymous FTP
+ *	25 Mar 94 (LM)	Added code to recognize different ftp server types
+ *			and code to parse dates and sizes on most hosts.
+ *	27 Mar 93 (FM)	Added code for getting dates and sizes on VMS hosts.
+ *
+ * Notes:
+ *			Portions Copyright 1994 Trustees of Dartmouth College
+ *			Code for recognizing different FTP servers and
+ *			parsing "ls -l" output taken from Macintosh Fetch
+ *			program with permission from Jim Matthews,
+ *			Dartmouth Software Development Team.
+ */
+
+/*
+ * BUGS:	@@@	Limit connection cache size!
+ * 		Error reporting to user.
+ * 		400 & 500 errors are ack'ed by user with windows.
+ * 		Use configuration file for user names
+ * 
+ *		Note for portability this version does not use select() and
+ *		so does not watch the control and data channels at the
+ *		same time.
+ */
+
+#include <HTUtils.h>
+
+#include <HTAlert.h>
+
+#include <HTFTP.h>		/* Implemented here */
+#include <HTTCP.h>
+#include <HTTP.h>
+#include <HTFont.h>
+
+#define REPEAT_PORT		/* Give the port number for each file */
+#define REPEAT_LISTEN		/* Close each listen socket and open a new one */
+
+/* define POLL_PORTS		 If allocation does not work, poll ourselves.*/
+#define LISTEN_BACKLOG 2	/* Number of pending connect requests (TCP) */
+
+#define FIRST_TCP_PORT	1024	/* Region to try for a listening port */
+#define LAST_TCP_PORT	5999
+
+#define LINE_LENGTH 256
+
+#include <HTParse.h>
+#include <HTAnchor.h>
+#include <HTFile.h>		/* For HTFileFormat() */
+#include <HTBTree.h>
+#include <HTChunk.h>
+#ifndef IPPORT_FTP
+#define IPPORT_FTP	21
+#endif /* !IPORT_FTP */
+
+#include <LYUtils.h>
+#include <LYGlobalDefs.h>
+#include <LYStrings.h>
+#include <LYLeaks.h>
+
+typedef struct _connection {
+    struct _connection *next;	/* Link on list         */
+    int socket;			/* Socket number for communication */
+    BOOL is_binary;		/* Binary mode? */
+} connection;
+
+/*		Hypertext object building machinery
+*/
+#include <HTML.h>
+
+/*
+ * socklen_t is the standard, but there are many pre-standard variants.
+ * This ifdef works around a few of those cases.
+ *
+ * Information was obtained from header files on these platforms:
+ *	AIX 4.3.2, 5.1
+ *	HPUX 10.20, 11.00, 11.11
+ *	IRIX64 6.5
+ *	Tru64 4.0G, 4.0D, 5.1
+ */
+#if defined(SYS_IRIX64)
+	/* IRIX64 6.5 socket.h may use socklen_t if SGI_SOURCE is not defined */
+#  if _NO_XOPEN4 && _NO_XOPEN5
+#    define LY_SOCKLEN socklen_t
+#  elif _ABIAPI
+#    define LY_SOCKLEN int
+#  elif _XOPEN5
+#    if (_MIPS_SIM != _ABIO32)
+#      define LY_SOCKLEN socklen_t
+#    else
+#      define LY_SOCKLEN int
+#    endif
+#  else
+#    define LY_SOCKLEN size_t
+#  endif
+#elif defined(SYS_HPUX)
+#  if defined(_XOPEN_SOURCE_EXTENDED) && defined(SO_PROTOTYPE)
+#    define LY_SOCKLEN socklen_t
+#  else	/* HPUX 10.20, etc. */
+#    define LY_SOCKLEN int
+#  endif
+#elif defined(SYS_TRU64)
+#  if defined(_POSIX_PII_SOCKET)
+#    define LY_SOCKLEN socklen_t
+#  elif defined(_XOPEN_SOURCE_EXTENDED)
+#    define LY_SOCKLEN size_t
+#  else
+#    define LY_SOCKLEN int
+#  endif
+#else
+#  define LY_SOCKLEN socklen_t
+#endif
+
+#define PUTC(c)      (*target->isa->put_character) (target, c)
+#define PUTS(s)      (*target->isa->put_string)    (target, s)
+#define START(e)     (*target->isa->start_element) (target, e, 0, 0, -1, 0)
+#define END(e)       (*target->isa->end_element)   (target, e, 0)
+#define FREE_TARGET  (*target->isa->_free)         (target)
+#define ABORT_TARGET (*target->isa->_free)         (target)
+
+#define TRACE_ENTRY(tag, entry_info) \
+    CTRACE((tfp, "HTFTP: %s filename: %s  date: %s  size: %" PRI_off_t "\n", \
+	    tag, \
+	    entry_info->filename, \
+	    NonNull(entry_info->date), \
+	    CAST_off_t(entry_info->size)))
+
+struct _HTStructured {
+    const HTStructuredClass *isa;
+    /* ... */
+};
+
+/*	Global Variables
+ *	---------------------
+ */
+int HTfileSortMethod = FILE_BY_NAME;
+
+#ifndef DISABLE_FTP		/*This disables everything to end-of-file */
+static char ThisYear[8];
+static char LastYear[8];
+static int TheDate;
+static BOOLEAN HaveYears = FALSE;
+
+/*	Module-Wide Variables
+ *	---------------------
+ */
+static connection *connections = NULL;	/* Linked list of connections */
+static char response_text[LINE_LENGTH + 1];	/* Last response from ftp host */
+static connection *control = NULL;	/* Current connection */
+static int data_soc = -1;	/* Socket for data transfer =invalid */
+static char *user_entered_password = NULL;
+static char *last_username_and_host = NULL;
+
+/*
+ * Some ftp servers are known to have a broken implementation of RETR.  If
+ * asked to retrieve a directory, they get confused and fail subsequent
+ * commands such as CWD and LIST.
+ */
+static int Broken_RETR = FALSE;
+
+/*
+ * Some ftp servers are known to have a broken implementation of EPSV.  The
+ * server will hang for a long time when we attempt to connect after issuing
+ * this command.
+ */
+#ifdef INET6
+static int Broken_EPSV = FALSE;
+#endif
+
+typedef enum {
+    GENERIC_SERVER
+    ,MACHTEN_SERVER
+    ,UNIX_SERVER
+    ,VMS_SERVER
+    ,CMS_SERVER
+    ,DCTS_SERVER
+    ,TCPC_SERVER
+    ,PETER_LEWIS_SERVER
+    ,NCSA_SERVER
+    ,WINDOWS_NT_SERVER
+    ,WINDOWS_2K_SERVER
+    ,MS_WINDOWS_SERVER
+    ,MSDOS_SERVER
+    ,APPLESHARE_SERVER
+    ,NETPRESENZ_SERVER
+    ,DLS_SERVER
+} eServerType;
+
+static eServerType server_type = GENERIC_SERVER;	/* the type of ftp host */
+static int unsure_type = FALSE;	/* sure about the type? */
+static BOOLEAN use_list = FALSE;	/* use the LIST command? */
+
+static int interrupted_in_next_data_char = FALSE;
+
+#ifdef POLL_PORTS
+static PortNumber port_number = FIRST_TCP_PORT;
+#endif /* POLL_PORTS */
+
+static BOOL have_socket = FALSE;	/* true if master_socket is valid */
+static LYNX_FD master_socket;	/* Listening socket = invalid */
+
+static char *port_command;	/* Command for setting the port */
+static fd_set open_sockets;	/* Mask of active channels */
+static LYNX_FD num_sockets;	/* Number of sockets to scan */
+static PortNumber passive_port;	/* Port server specified for data */
+
+#define NEXT_CHAR HTGetCharacter()	/* Use function in HTFormat.c */
+
+#define DATA_BUFFER_SIZE 2048
+static char data_buffer[DATA_BUFFER_SIZE];	/* Input data buffer */
+static char *data_read_pointer;
+static char *data_write_pointer;
+
+#define NEXT_DATA_CHAR next_data_char()
+static int close_connection(connection * con);
+
+#ifndef HAVE_ATOLL
+off_t LYatoll(const char *value)
+{
+    off_t result = 0;
+
+    while (*value != '\0') {
+	result = (result * 10) + (off_t) (*value++ - '0');
+    }
+    return result;
+}
+#endif
+
+#ifdef LY_FIND_LEAKS
+/*
+ *  This function frees module globals. - FM
+ */
+static void free_FTPGlobals(void)
+{
+    FREE(user_entered_password);
+    FREE(last_username_and_host);
+    if (control) {
+	if (control->socket != -1)
+	    close_connection(control);
+	FREE(control);
+    }
+}
+#endif /* LY_FIND_LEAKS */
+
+/* PUBLIC						HTVMS_name()
+ *		CONVERTS WWW name into a VMS name
+ * ON ENTRY:
+ *	nn		Node Name (optional)
+ *	fn		WWW file name
+ *
+ * ON EXIT:
+ *	returns		vms file specification
+ *
+ * Bug: Returns pointer to static -- non-reentrant
+ */
+char *HTVMS_name(const char *nn,
+		 const char *fn)
+{
+    /* We try converting the filename into Files-11 syntax.  That is, we assume
+     * first that the file is, like us, on a VMS node.  We try remote (or
+     * local) DECnet access.  Files-11, VMS, VAX and DECnet are trademarks of
+     * Digital Equipment Corporation.  The node is assumed to be local if the
+     * hostname WITHOUT DOMAIN matches the local one.  @@@
+     */
+    static char *vmsname;
+    char *filename = (char *) malloc(strlen(fn) + 1);
+    char *nodename = (char *) malloc(strlen(nn) + 2 + 1);	/* Copies to hack */
+    char *second;		/* 2nd slash */
+    char *last;			/* last slash */
+
+    const char *hostname = HTHostName();
+
+    if (!filename || !nodename)
+	outofmem(__FILE__, "HTVMSname");
+
+    strcpy(filename, fn);
+    strcpy(nodename, "");	/* On same node?  Yes if node names match */
+    if (StrNCmp(nn, "localhost", 9)) {
+	const char *p;
+	const char *q;
+
+	for (p = hostname, q = nn;
+	     *p && *p != '.' && *q && *q != '.'; p++, q++) {
+	    if (TOUPPER(*p) != TOUPPER(*q)) {
+		char *r;
+
+		strcpy(nodename, nn);
+		r = StrChr(nodename, '.');	/* Mismatch */
+		if (r)
+		    *r = '\0';	/* Chop domain */
+		strcat(nodename, "::");		/* Try decnet anyway */
+		break;
+	    }
+	}
+    }
+
+    second = StrChr(filename + 1, '/');		/* 2nd slash */
+    last = strrchr(filename, '/');	/* last slash */
+
+    if (!second) {		/* Only one slash */
+	HTSprintf0(&vmsname, "%s%s", nodename, filename + 1);
+    } else if (second == last) {	/* Exactly two slashes */
+	*second = '\0';		/* Split filename from disk */
+	HTSprintf0(&vmsname, "%s%s:%s", nodename, filename + 1, second + 1);
+	*second = '/';		/* restore */
+    } else {			/* More than two slashes */
+	char *p;
+
+	*second = '\0';		/* Split disk from directories */
+	*last = '\0';		/* Split dir from filename */
+	HTSprintf0(&vmsname, "%s%s:[%s]%s",
+		   nodename, filename + 1, second + 1, last + 1);
+	*second = *last = '/';	/* restore filename */
+	if ((p = StrChr(vmsname, '[')) != 0) {
+	    while (*p != '\0' && *p != ']') {
+		if (*p == '/')
+		    *p = '.';	/* Convert dir sep.  to dots */
+		++p;
+	    }
+	}
+    }
+    FREE(nodename);
+    FREE(filename);
+    return vmsname;
+}
+
+/*	Procedure: Read a character from the data connection
+ *	----------------------------------------------------
+ */
+static int next_data_char(void)
+{
+    int status;
+
+    if (data_read_pointer >= data_write_pointer) {
+	status = NETREAD(data_soc, data_buffer, DATA_BUFFER_SIZE);
+	if (status == HT_INTERRUPTED)
+	    interrupted_in_next_data_char = 1;
+	if (status <= 0)
+	    return EOF;
+	data_write_pointer = data_buffer + status;
+	data_read_pointer = data_buffer;
+    }
+#ifdef NOT_ASCII
+    {
+	char c = *data_read_pointer++;
+
+	return FROMASCII(c);
+    }
+#else
+    return UCH(*data_read_pointer++);
+#endif /* NOT_ASCII */
+}
+
+/*	Close an individual connection
+ *
+ */
+static int close_connection(connection * con)
+{
+    connection *scan;
+    int status;
+
+    CTRACE((tfp, "HTFTP: Closing control socket %d\n", con->socket));
+    status = NETCLOSE(con->socket);
+    if (TRACE && status != 0) {
+#ifdef UNIX
+	CTRACE((tfp, "HTFTP:close_connection: %s", LYStrerror(errno)));
+#else
+	if (con->socket != INVSOC)
+	    HTInetStatus("HTFTP:close_connection");
+#endif
+    }
+    con->socket = -1;
+    if (connections == con) {
+	connections = con->next;
+	return status;
+    }
+    for (scan = connections; scan; scan = scan->next) {
+	if (scan->next == con) {
+	    scan->next = con->next;	/* Unlink */
+	    if (control == con)
+		control = (connection *) 0;
+	    return status;
+	}			/*if */
+    }				/* for */
+    return -1;			/* very strange -- was not on list. */
+}
+
+static char *help_message_buffer = NULL;	/* global :( */
+
+static void init_help_message_cache(void)
+{
+    FREE(help_message_buffer);
+}
+
+static void help_message_cache_add(char *string)
+{
+    if (help_message_buffer)
+	StrAllocCat(help_message_buffer, string);
+    else
+	StrAllocCopy(help_message_buffer, string);
+
+    CTRACE((tfp, "Adding message to help cache: %s\n", string));
+}
+
+static char *help_message_cache_non_empty(void)
+{
+    return (help_message_buffer);
+}
+
+static char *help_message_cache_contents(void)
+{
+    return (help_message_buffer);
+}
+
+/*	Send One Command
+ *	----------------
+ *
+ *	This function checks whether we have a control connection, and sends
+ *	one command if given.
+ *
+ * On entry,
+ *	control	points to the connection which is established.
+ *	cmd	points to a command, or is zero to just get the response.
+ *
+ *	The command should already be terminated with the CRLF pair.
+ *
+ * On exit,
+ *	returns:  1 for success,
+ *		  or negative for communication failure (in which case
+ *		  the control connection will be closed).
+ */
+static int write_cmd(const char *cmd)
+{
+    int status;
+
+    if (!control) {
+	CTRACE((tfp, "HTFTP: No control connection set up!!\n"));
+	return HT_NO_CONNECTION;
+    }
+
+    if (cmd) {
+	CTRACE((tfp, "  Tx: %s", cmd));
+#ifdef NOT_ASCII
+	{
+	    char *p;
+
+	    for (p = cmd; *p; p++) {
+		*p = TOASCII(*p);
+	    }
+	}
+#endif /* NOT_ASCII */
+	status = (int) NETWRITE(control->socket, cmd, (unsigned) strlen(cmd));
+	if (status < 0) {
+	    CTRACE((tfp,
+		    "HTFTP: Error %d sending command: closing socket %d\n",
+		    status, control->socket));
+	    close_connection(control);
+	    return status;
+	}
+    }
+    return 1;
+}
+
+/*
+ * For each string in the list, check if it is found in the response text.
+ * If so, return TRUE.
+ */
+static BOOL find_response(HTList *list)
+{
+    BOOL result = FALSE;
+    HTList *p = list;
+    char *value;
+
+    while ((value = (char *) HTList_nextObject(p)) != NULL) {
+	if (LYstrstr(response_text, value)) {
+	    result = TRUE;
+	    break;
+	}
+    }
+    return result;
+}
+
+/*	Execute Command and get Response
+ *	--------------------------------
+ *
+ *	See the state machine illustrated in RFC959, p57. This implements
+ *	one command/reply sequence.  It also interprets lines which are to
+ *	be continued, which are marked with a "-" immediately after the
+ *	status code.
+ *
+ *	Continuation then goes on until a line with a matching reply code
+ *	an a space after it.
+ *
+ * On entry,
+ *	control	points to the connection which is established.
+ *	cmd	points to a command, or is zero to just get the response.
+ *
+ *	The command must already be terminated with the CRLF pair.
+ *
+ * On exit,
+ *	returns:  The first digit of the reply type,
+ *		  or negative for communication failure.
+ */
+static int response(const char *cmd)
+{
+    int result;			/* Three-digit decimal code */
+    int continuation_response = -1;
+    int status;
+
+    if ((status = write_cmd(cmd)) < 0)
+	return status;
+
+    do {
+	char *p = response_text;
+
+	for (;;) {
+	    int ich = NEXT_CHAR;
+
+	    if (((*p++ = (char) ich) == LF)
+		|| (p == &response_text[LINE_LENGTH])) {
+
+		char continuation;
+
+		if (interrupted_in_htgetcharacter) {
+		    CTRACE((tfp,
+			    "HTFTP: Interrupted in HTGetCharacter, apparently.\n"));
+		    NETCLOSE(control->socket);
+		    control->socket = -1;
+		    return HT_INTERRUPTED;
+		}
+
+		*p = '\0';	/* Terminate the string */
+		CTRACE((tfp, "    Rx: %s", response_text));
+
+		/* Check for login or help messages */
+		if (!StrNCmp(response_text, "230-", 4) ||
+		    !StrNCmp(response_text, "250-", 4) ||
+		    !StrNCmp(response_text, "220-", 4))
+		    help_message_cache_add(response_text + 4);
+
+		sscanf(response_text, "%d%c", &result, &continuation);
+		if (continuation_response == -1) {
+		    if (continuation == '-')	/* start continuation */
+			continuation_response = result;
+		} else {	/* continuing */
+		    if (continuation_response == result &&
+			continuation == ' ')
+			continuation_response = -1;	/* ended */
+		}
+		if (result == 220 && find_response(broken_ftp_retr)) {
+		    Broken_RETR = TRUE;
+		    CTRACE((tfp, "This server is broken (RETR)\n"));
+		}
+#ifdef INET6
+		if (result == 220 && find_response(broken_ftp_epsv)) {
+		    Broken_EPSV = TRUE;
+		    CTRACE((tfp, "This server is broken (EPSV)\n"));
+		}
+#endif
+		break;
+	    }
+	    /* if end of line */
+	    if (interrupted_in_htgetcharacter) {
+		CTRACE((tfp,
+			"HTFTP: Interrupted in HTGetCharacter, apparently.\n"));
+		NETCLOSE(control->socket);
+		control->socket = -1;
+		return HT_INTERRUPTED;
+	    }
+
+	    if (ich == EOF) {
+		CTRACE((tfp, "Error on rx: closing socket %d\n",
+			control->socket));
+		strcpy(response_text, "000 *** TCP read error on response\n");
+		close_connection(control);
+		return -1;	/* End of file on response */
+	    }
+	}			/* Loop over characters */
+
+    } while (continuation_response != -1);
+
+    if (result == 421) {
+	CTRACE((tfp, "HTFTP: They close so we close socket %d\n",
+		control->socket));
+	close_connection(control);
+	return -1;
+    }
+    if ((result == 255 && server_type == CMS_SERVER) &&
+	(0 == strncasecomp(cmd, "CWD", 3) ||
+	 0 == strcasecomp(cmd, "CDUP"))) {
+	/*
+	 * Alas, CMS returns 255 on failure to CWD to parent of root.  - PG
+	 */
+	result = 555;
+    }
+    return result / 100;
+}
+
+static int send_cmd_1(const char *verb)
+{
+    char command[80];
+
+    sprintf(command, "%.*s%c%c", (int) sizeof(command) - 4, verb, CR, LF);
+    return response(command);
+}
+
+static int send_cmd_2(const char *verb, const char *param)
+{
+    char *command = 0;
+    int status;
+
+    HTSprintf0(&command, "%s %s%c%c", verb, param, CR, LF);
+    status = response(command);
+    FREE(command);
+
+    return status;
+}
+
+#define send_cwd(path) send_cmd_2("CWD", path)
+
+/*
+ * This function should try to set the macintosh server into binary mode.  Some
+ * servers need an additional letter after the MACB command.
+ */
+static int set_mac_binary(eServerType ServerType)
+{
+    /* try to set mac binary mode */
+    if (ServerType == APPLESHARE_SERVER ||
+	ServerType == NETPRESENZ_SERVER) {
+	/*
+	 * Presumably E means "Enable".  - KW
+	 */
+	return (2 == response("MACB E\r\n"));
+    } else {
+	return (2 == response("MACB\r\n"));
+    }
+}
+
+/* This function gets the current working directory to help
+ * determine what kind of host it is
+ */
+
+static void get_ftp_pwd(eServerType *ServerType, BOOLEAN *UseList)
+{
+    char *cp;
+
+    /* get the working directory (to see what it looks like) */
+    int status = response("PWD\r\n");
+
+    if (status < 0) {
+	return;
+    } else {
+	cp = StrChr(response_text + 5, '"');
+	if (cp)
+	    *cp = '\0';
+	if (*ServerType == TCPC_SERVER) {
+	    *ServerType = ((response_text[5] == '/') ?
+			   NCSA_SERVER : TCPC_SERVER);
+	    CTRACE((tfp, "HTFTP: Treating as %s server.\n",
+		    ((*ServerType == NCSA_SERVER) ?
+		     "NCSA" : "TCPC")));
+	} else if (response_text[5] == '/') {
+	    /* path names beginning with / imply Unix,
+	     * right?
+	     */
+	    if (set_mac_binary(*ServerType)) {
+		*ServerType = NCSA_SERVER;
+		CTRACE((tfp, "HTFTP: Treating as NCSA server.\n"));
+	    } else {
+		*ServerType = UNIX_SERVER;
+		*UseList = TRUE;
+		CTRACE((tfp, "HTFTP: Treating as Unix server.\n"));
+	    }
+	    return;
+	} else if (response_text[strlen(response_text) - 1] == ']') {
+	    /* path names ending with ] imply VMS, right? */
+	    *ServerType = VMS_SERVER;
+	    *UseList = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as VMS server.\n"));
+	} else {
+	    *ServerType = GENERIC_SERVER;
+	    CTRACE((tfp, "HTFTP: Treating as Generic server.\n"));
+	}
+
+	if ((*ServerType == NCSA_SERVER) ||
+	    (*ServerType == TCPC_SERVER) ||
+	    (*ServerType == PETER_LEWIS_SERVER) ||
+	    (*ServerType == NETPRESENZ_SERVER))
+	    set_mac_binary(*ServerType);
+    }
+}
+
+/* This function turns MSDOS-like directory output off for
+ * Windows NT servers.
+ */
+
+static void set_unix_dirstyle(eServerType *ServerType, BOOLEAN *UseList)
+{
+    char *cp;
+
+    /* This is a toggle.  It seems we have to toggle in order to see
+     * the current state (after toggling), so we may end up toggling
+     * twice.  - kw
+     */
+    int status = response("SITE DIRSTYLE\r\n");
+
+    if (status != 2) {
+	*ServerType = GENERIC_SERVER;
+	CTRACE((tfp, "HTFTP: DIRSTYLE failed, treating as Generic server.\n"));
+	return;
+    } else {
+	*UseList = TRUE;
+	/* Expecting one of:
+	 * 200 MSDOS-like directory output is off
+	 * 200 MSDOS-like directory output is on
+	 * The following code doesn't look for the full exact string -
+	 * who knows how the wording may change in some future version.
+	 * If the first response isn't recognized, we toggle again
+	 * anyway, under the assumption that it's more likely that
+	 * the MSDOS setting was "off" originally. - kw
+	 */
+	cp = strstr(response_text + 4, "MSDOS");
+	if (cp && strstr(cp, " off")) {
+	    return;		/* already off now. */
+	} else {
+	    response("SITE DIRSTYLE\r\n");
+	}
+    }
+}
+
+#define CheckForInterrupt(msg) \
+	if (status == HT_INTERRUPTED) { \
+	    CTRACE((tfp, "HTFTP: Interrupted %s.\n", msg)); \
+	    _HTProgress(CONNECTION_INTERRUPTED); \
+	    NETCLOSE(control->socket); \
+	    control->socket = -1; \
+	    return HT_INTERRUPTED; \
+	}
+
+/*	Get a valid connection to the host
+ *	----------------------------------
+ *
+ * On entry,
+ *	arg	points to the name of the host in a hypertext address
+ * On exit,
+ *	returns <0 if error
+ *		socket number if success
+ *
+ *	This routine takes care of managing timed-out connections, and
+ *	limiting the number of connections in use at any one time.
+ *
+ *	It ensures that all connections are logged in if they exist.
+ *	It ensures they have the port number transferred.
+ */
+static int get_connection(const char *arg,
+			  HTParentAnchor *anchor)
+{
+    int status;
+    char *command = 0;
+    connection *con;
+    char *username = NULL;
+    char *password = NULL;
+    static BOOLEAN firstuse = TRUE;
+
+    if (firstuse) {
+	/*
+	 * Set up freeing at exit.  - FM
+	 */
+#ifdef LY_FIND_LEAKS
+	atexit(free_FTPGlobals);
+#endif
+	firstuse = FALSE;
+    }
+
+    if (control != 0) {
+	connection *next = control->next;
+
+	if (control->socket != -1) {
+	    NETCLOSE(control->socket);
+	}
+	memset(con = control, 0, sizeof(*con));
+	con->next = next;
+    } else {
+	con = typecalloc(connection);
+	if (con == NULL)
+	    outofmem(__FILE__, "get_connection");
+    }
+    con->socket = -1;
+
+    if (isEmpty(arg)) {
+	free(con);
+	return -1;		/* Bad if no name specified     */
+    }
+
+    /* Get node name:
+     */
+    CTRACE((tfp, "get_connection(%s)\n", arg));
+    {
+	char *p1 = HTParse(arg, "", PARSE_HOST);
+	char *p2 = strrchr(p1, '@');	/* user? */
+	char *pw = NULL;
+
+	if (p2 != NULL) {
+	    username = p1;
+	    *p2 = '\0';		/* terminate */
+	    p1 = p2 + 1;	/* point to host */
+	    pw = StrChr(username, ':');
+	    if (pw != NULL) {
+		*pw++ = '\0';
+		password = HTUnEscape(pw);
+	    }
+	    if (*username)
+		HTUnEscape(username);
+
+	    /*
+	     * If the password doesn't exist then we are going to have to ask
+	     * the user for it.  The only problem is that we don't want to ask
+	     * for it every time, so we will store away in a primitive fashion.
+	     */
+	    if (!password) {
+		char *tmp = NULL;
+
+		HTSprintf0(&tmp, "%s@%s", username, p1);
+		/*
+		 * If the user@host is not equal to the last time through or
+		 * user_entered_password has no data then we need to ask the
+		 * user for the password.
+		 */
+		if (!last_username_and_host ||
+		    strcmp(tmp, last_username_and_host) ||
+		    !user_entered_password) {
+
+		    StrAllocCopy(last_username_and_host, tmp);
+		    HTSprintf0(&tmp, gettext("Enter password for user %s@%s:"),
+			       username, p1);
+		    FREE(user_entered_password);
+		    user_entered_password = HTPromptPassword(tmp, NULL);
+
+		}		/* else we already know the password */
+		password = user_entered_password;
+		FREE(tmp);
+	    }
+	}
+
+	if (!username)
+	    FREE(p1);
+    }				/* scope of p1 */
+
+    status = HTDoConnect(arg, "FTP", IPPORT_FTP, (int *) &con->socket);
+
+    if (status < 0) {
+	if (status == HT_INTERRUPTED) {
+	    CTRACE((tfp, "HTFTP: Interrupted on connect\n"));
+	} else {
+	    CTRACE((tfp, "HTFTP: Unable to connect to remote host for `%s'.\n",
+		    arg));
+	}
+	if (status == HT_INTERRUPTED) {
+	    _HTProgress(CONNECTION_INTERRUPTED);
+	    status = HT_NOT_LOADED;
+	} else {
+	    HTAlert(gettext("Unable to connect to FTP host."));
+	}
+	if (con->socket != -1) {
+	    NETCLOSE(con->socket);
+	}
+
+	FREE(username);
+	if (control == con)
+	    control = NULL;
+	FREE(con);
+	return status;		/* Bad return */
+    }
+
+    CTRACE((tfp, "FTP connected, socket %d  control %p\n",
+	    con->socket, (void *) con));
+    control = con;		/* Current control connection */
+
+    /* Initialise buffering for control connection */
+    HTInitInput(control->socket);
+    init_help_message_cache();	/* Clear the login message buffer. */
+
+    /*  Now we log in           Look up username, prompt for pw.
+     */
+    status = response(NULL);	/* Get greeting */
+    CheckForInterrupt("at beginning of login");
+
+    server_type = GENERIC_SERVER;	/* reset */
+    if (status == 2) {		/* Send username */
+	char *cp;		/* look at greeting text */
+
+	/* don't gettext() this -- incoming text: */
+	if (strlen(response_text) > 4) {
+	    if ((cp = strstr(response_text, " awaits your command")) ||
+		(cp = strstr(response_text, " ready."))) {
+		*cp = '\0';
+	    }
+	    cp = response_text + 4;
+	    if (!strncasecomp(cp, "NetPresenz", 10))
+		server_type = NETPRESENZ_SERVER;
+	} else {
+	    cp = response_text;
+	}
+	StrAllocCopy(anchor->server, cp);
+
+	status = send_cmd_2("USER", (username && *username)
+			    ? username
+			    : "anonymous");
+
+	CheckForInterrupt("while sending username");
+    }
+    if (status == 3) {		/* Send password */
+	if (non_empty(password)) {
+	    HTSprintf0(&command, "PASS %s%c%c", password, CR, LF);
+	} else {
+	    /*
+	     * No password was given; use mail-address.
+	     */
+	    const char *the_address;
+	    char *user = NULL;
+	    const char *host = NULL;
+	    char *cp;
+
+	    the_address = anonftp_password;
+	    if (isEmpty(the_address))
+		the_address = personal_mail_address;
+	    if (isEmpty(the_address))
+		the_address = LYGetEnv("USER");
+	    if (isEmpty(the_address))
+		the_address = "WWWuser";
+
+	    StrAllocCopy(user, the_address);
+	    if ((cp = StrChr(user, '@')) != NULL) {
+		*cp++ = '\0';
+		if (*cp == '\0')
+		    host = HTHostName();
+		else
+		    host = cp;
+	    } else {
+		host = HTHostName();
+	    }
+
+	    /*
+	     * If host is not fully qualified, suppress it
+	     * as ftp.uu.net prefers a blank to a bad name
+	     */
+	    if (!(host) || StrChr(host, '.') == NULL)
+		host = "";
+
+	    HTSprintf0(&command, "PASS %s@%s%c%c", user, host, CR, LF);
+	    FREE(user);
+	}
+	status = response(command);
+	FREE(command);
+	CheckForInterrupt("while sending password");
+    }
+    FREE(username);
+
+    if (status == 3) {
+	status = send_cmd_1("ACCT noaccount");
+	CheckForInterrupt("while sending password");
+    }
+    if (status != 2) {
+	CTRACE((tfp, "HTFTP: Login fail: %s", response_text));
+	/* if (control->socket > 0) close_connection(control->socket); */
+	return -1;		/* Bad return */
+    }
+    CTRACE((tfp, "HTFTP: Logged in.\n"));
+
+    /* Check for host type */
+    if (server_type != NETPRESENZ_SERVER)
+	server_type = GENERIC_SERVER;	/* reset */
+    use_list = FALSE;		/* reset */
+    if (response("SYST\r\n") == 2) {
+	/* we got a line -- what kind of server are we talking to? */
+	if (StrNCmp(response_text + 4,
+		    "UNIX Type: L8 MAC-OS MachTen", 28) == 0) {
+	    server_type = MACHTEN_SERVER;
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as MachTen server.\n"));
+
+	} else if (strstr(response_text + 4, "UNIX") != NULL ||
+		   strstr(response_text + 4, "Unix") != NULL) {
+	    server_type = UNIX_SERVER;
+	    unsure_type = FALSE;	/* to the best of out knowledge... */
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as Unix server.\n"));
+
+	} else if (strstr(response_text + 4, "MSDOS") != NULL) {
+	    server_type = MSDOS_SERVER;
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as MSDOS (Unix emulation) server.\n"));
+
+	} else if (StrNCmp(response_text + 4, "VMS", 3) == 0) {
+	    char *tilde = strstr(arg, "/~");
+
+	    use_list = TRUE;
+	    if (tilde != 0
+		&& tilde[2] != 0
+		&& strstr(response_text + 4, "MadGoat") != 0) {
+		server_type = UNIX_SERVER;
+		CTRACE((tfp, "HTFTP: Treating VMS as UNIX server.\n"));
+	    } else {
+		server_type = VMS_SERVER;
+		CTRACE((tfp, "HTFTP: Treating as VMS server.\n"));
+	    }
+
+	} else if ((StrNCmp(response_text + 4, "VM/CMS", 6) == 0) ||
+		   (StrNCmp(response_text + 4, "VM ", 3) == 0)) {
+	    server_type = CMS_SERVER;
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as CMS server.\n"));
+
+	} else if (StrNCmp(response_text + 4, "DCTS", 4) == 0) {
+	    server_type = DCTS_SERVER;
+	    CTRACE((tfp, "HTFTP: Treating as DCTS server.\n"));
+
+	} else if (strstr(response_text + 4, "MAC-OS TCP/Connect II") != NULL) {
+	    server_type = TCPC_SERVER;
+	    CTRACE((tfp, "HTFTP: Looks like a TCPC server.\n"));
+	    get_ftp_pwd(&server_type, &use_list);
+	    unsure_type = TRUE;
+
+	} else if (server_type == NETPRESENZ_SERVER) {	/* already set above */
+	    use_list = TRUE;
+	    set_mac_binary(server_type);
+	    CTRACE((tfp, "HTFTP: Treating as NetPresenz (MACOS) server.\n"));
+
+	} else if (StrNCmp(response_text + 4, "MACOS Peter's Server", 20) == 0) {
+	    server_type = PETER_LEWIS_SERVER;
+	    use_list = TRUE;
+	    set_mac_binary(server_type);
+	    CTRACE((tfp, "HTFTP: Treating as Peter Lewis (MACOS) server.\n"));
+
+	} else if (StrNCmp(response_text + 4, "Windows_NT", 10) == 0) {
+	    server_type = WINDOWS_NT_SERVER;
+	    CTRACE((tfp, "HTFTP: Treating as Window_NT server.\n"));
+	    set_unix_dirstyle(&server_type, &use_list);
+
+	} else if (StrNCmp(response_text + 4, "Windows2000", 11) == 0) {
+	    server_type = WINDOWS_2K_SERVER;
+	    CTRACE((tfp, "HTFTP: Treating as Window_2K server.\n"));
+	    set_unix_dirstyle(&server_type, &use_list);
+
+	} else if (StrNCmp(response_text + 4, "MS Windows", 10) == 0) {
+	    server_type = MS_WINDOWS_SERVER;
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as MS Windows server.\n"));
+
+	} else if (StrNCmp(response_text + 4,
+			   "MACOS AppleShare IP FTP Server", 30) == 0) {
+	    server_type = APPLESHARE_SERVER;
+	    use_list = TRUE;
+	    set_mac_binary(server_type);
+	    CTRACE((tfp, "HTFTP: Treating as AppleShare server.\n"));
+
+	} else {
+	    server_type = GENERIC_SERVER;
+	    CTRACE((tfp, "HTFTP: Ugh!  A Generic server.\n"));
+	    get_ftp_pwd(&server_type, &use_list);
+	    unsure_type = TRUE;
+	}
+    } else {
+	/* SYST fails :(  try to get the type from the PWD command */
+	get_ftp_pwd(&server_type, &use_list);
+    }
+
+    return con->socket;		/* Good return */
+}
+
+static void reset_master_socket(void)
+{
+    have_socket = FALSE;
+}
+
+static void set_master_socket(int value)
+{
+    have_socket = (BOOLEAN) (value >= 0);
+    if (have_socket)
+	master_socket = (LYNX_FD) value;
+}
+
+/*	Close Master (listening) socket
+ *	-------------------------------
+ *
+ *
+ */
+static int close_master_socket(void)
+{
+    int status;
+
+    if (have_socket)
+	FD_CLR(master_socket, &open_sockets);
+
+    status = NETCLOSE((int) master_socket);
+    CTRACE((tfp, "HTFTP: Closed master socket %u\n", (unsigned) master_socket));
+
+    reset_master_socket();
+
+    if (status < 0)
+	return HTInetStatus(gettext("close master socket"));
+    else
+	return status;
+}
+
+/*	Open a master socket for listening on
+ *	-------------------------------------
+ *
+ *	When data is transferred, we open a port, and wait for the server to
+ *	connect with the data.
+ *
+ * On entry,
+ *	have_socket	Must be false, if master_socket is not setup already
+ *	master_socket	Must be negative if not set up already.
+ * On exit,
+ *	Returns		socket number if good
+ *			less than zero if error.
+ *	master_socket	is socket number if good, else negative.
+ *	port_number	is valid if good.
+ */
+static int get_listen_socket(void)
+{
+    LY_SOCKADDR soc_A;
+
+#ifdef INET6
+    unsigned short af;
+    LY_SOCKLEN slen;
+#endif /* INET6 */
+    int new_socket;		/* Will be master_socket */
+
+    FD_ZERO(&open_sockets);	/* Clear our record of open sockets */
+    num_sockets = 0;
+
+    FREE(port_command);
+#ifndef REPEAT_LISTEN
+    if (have_socket)
+	return master_socket;	/* Done already */
+#endif /* !REPEAT_LISTEN */
+
+#ifdef INET6
+    /* query address family of control connection */
+    memset(&soc_A, 0, sizeof(soc_A));
+    slen = (LY_SOCKLEN) sizeof(soc_A);
+    if (getsockname(control->socket, SOCKADDR_OF(soc_A), &slen) < 0) {
+	return HTInetStatus("getsockname failed");
+    }
+    af = SOCKADDR_OF(soc_A)->sa_family;
+#endif /* INET6 */
+
+/*  Create internet socket
+*/
+#ifdef INET6
+    new_socket = socket(af, SOCK_STREAM, IPPROTO_TCP);
+#else
+    new_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+#endif /* INET6 */
+
+    if (new_socket < 0)
+	return HTInetStatus(gettext("socket for master socket"));
+
+    CTRACE((tfp, "HTFTP: Opened master socket number %d\n", new_socket));
+
+/*  Search for a free port.
+*/
+#ifdef INET6
+    memset(&soc_A, 0, sizeof(soc_A));
+    SOCKADDR_OF(soc_A)->sa_family = (unsigned short) af;
+    switch (af) {
+    case AF_INET:
+#ifdef SIN6_LEN
+	SOCKADDR_OF(soc_A)->sa_len = sizeof(struct sockaddr_in);
+#endif /* SIN6_LEN */
+	break;
+    case AF_INET6:
+#ifdef SIN6_LEN
+	SOCKADDR_OF(soc_A)->sa_len = sizeof(struct sockaddr_in6);
+#endif /* SIN6_LEN */
+	break;
+    default:
+	HTInetStatus("AF");
+    }
+#else
+    soc_A.soc_in.sin_family = AF_INET;	/* Family = internet, host order  */
+    soc_A.soc_in.sin_addr.s_addr = INADDR_ANY;	/* Any peer address */
+#endif /* INET6 */
+#ifdef POLL_PORTS
+    {
+	PortNumber old_port_number = port_number;
+
+	for (port_number = (old_port_number + 1);; port_number++) {
+	    int status;
+
+	    if (port_number > LAST_TCP_PORT)
+		port_number = FIRST_TCP_PORT;
+	    if (port_number == old_port_number) {
+		return HTInetStatus("bind");
+	    }
+#ifdef INET6
+	    soc_A.soc_in.sin_port = htons(port_number);
+#else
+	    soc_A.sin_port = htons(port_number);
+#endif /* INET6 */
+#ifdef SOCKS
+	    if (socks_flag)
+		if ((status = Rbind(new_socket,
+				    SOCKADDR_OF(soc_A),
+				    SOCKADDR_LEN(soc_A))) == 0) {
+		    break;
+		} else
+#endif /* SOCKS */
+		    if ((status = bind(new_socket,
+				       SOCKADDR_OF(soc_A),
+				       SOCKADDR_LEN(soc_A)
+			 )) == 0) {
+		    break;
+		}
+	    CTRACE((tfp, "TCP bind attempt to port %d yields %d, errno=%d\n",
+		    port_number, status, SOCKET_ERRNO));
+	}			/* for */
+    }
+#else
+    {
+	int status;
+	LY_SOCKLEN address_length = (LY_SOCKLEN) sizeof(soc_A);
+
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Rgetsockname(control->socket,
+				  SOCKADDR_OF(soc_A),
+				  &address_length);
+	else
+#endif /* SOCKS */
+	    status = getsockname(control->socket,
+				 SOCKADDR_OF(soc_A),
+				 &address_length);
+	if (status < 0) {
+	    close(new_socket);
+	    return HTInetStatus("getsockname");
+	}
+	CTRACE((tfp, "HTFTP: This host is %s\n",
+		HTInetString((void *) &soc_A.soc_in)));
+
+	soc_A.soc_in.sin_port = 0;	/* Unspecified: please allocate */
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Rbind(new_socket,
+			   SOCKADDR_OF(soc_A),
+			   sizeof(soc_A));
+	else
+#endif /* SOCKS */
+	    status = bind(new_socket,
+			  SOCKADDR_OF(soc_A),
+			  SOCKADDR_LEN(soc_A));
+	if (status < 0) {
+	    close(new_socket);
+	    return HTInetStatus("bind");
+	}
+
+	address_length = sizeof(soc_A);
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Rgetsockname(new_socket,
+				  SOCKADDR_OF(soc_A),
+				  &address_length);
+	else
+#endif /* SOCKS */
+	    status = getsockname(new_socket,
+				 SOCKADDR_OF(soc_A),
+				 &address_length);
+	if (status < 0) {
+	    close(new_socket);
+	    return HTInetStatus("getsockname");
+	}
+    }
+#endif /* POLL_PORTS */
+
+    CTRACE((tfp, "HTFTP: bound to port %d on %s\n",
+	    (int) ntohs(soc_A.soc_in.sin_port),
+	    HTInetString((void *) &soc_A.soc_in)));
+
+#ifdef REPEAT_LISTEN
+    if (have_socket)
+	(void) close_master_socket();
+#endif /* REPEAT_LISTEN */
+
+    set_master_socket(new_socket);
+
+/*	Now we must find out who we are to tell the other guy
+*/
+    (void) HTHostName();	/* Make address valid - doesn't work */
+#ifdef INET6
+    switch (SOCKADDR_OF(soc_A)->sa_family) {
+    case AF_INET:
+#endif /* INET6 */
+	HTSprintf0(&port_command, "PORT %d,%d,%d,%d,%d,%d%c%c",
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_addr) + 0),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_addr) + 1),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_addr) + 2),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_addr) + 3),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_port) + 0),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_port) + 1),
+		   CR, LF);
+
+#ifdef INET6
+	break;
+
+    case AF_INET6:
+	{
+	    char hostbuf[MAXHOSTNAMELEN];
+	    char portbuf[MAXHOSTNAMELEN];
+
+	    getnameinfo(SOCKADDR_OF(soc_A),
+			SOCKADDR_LEN(soc_A),
+			hostbuf,
+			(socklen_t) sizeof(hostbuf),
+			portbuf,
+			(socklen_t) sizeof(portbuf),
+			NI_NUMERICHOST | NI_NUMERICSERV);
+	    HTSprintf0(&port_command, "EPRT |%d|%s|%s|%c%c", 2, hostbuf, portbuf,
+		       CR, LF);
+	    break;
+	}
+    default:
+	HTSprintf0(&port_command, "JUNK%c%c", CR, LF);
+	break;
+    }
+#endif /* INET6 */
+    if (port_command == NULL)
+	return -1;
+
+    /*  Inform TCP that we will accept connections
+     */
+    {
+	int status;
+
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Rlisten((int) master_socket, 1);
+	else
+#endif /* SOCKS */
+	    status = listen((int) master_socket, 1);
+	if (status < 0) {
+	    reset_master_socket();
+	    return HTInetStatus("listen");
+	}
+    }
+    CTRACE((tfp, "TCP: Master socket(), bind() and listen() all OK\n"));
+    FD_SET(master_socket, &open_sockets);
+    if ((master_socket + 1) > num_sockets)
+	num_sockets = master_socket + 1;
+
+    return (int) master_socket;	/* Good */
+
+}				/* get_listen_socket */
+
+static const char *months[12] =
+{
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+
+/*	Procedure: Set the current and last year strings and date integer
+ *	-----------------------------------------------------------------
+ *
+ *	Bug:
+ *		This code is for sorting listings by date, if that option
+ *		is selected in Lynx, and doesn't take into account time
+ *		zones or ensure resetting at midnight, so the sort may not
+ *		be perfect, but the actual date isn't changed in the display,
+ *		i.e., the date is still correct. - FM
+ */
+static void set_years_and_date(void)
+{
+    char day[8], month[8], date[12];
+    time_t NowTime;
+    int i;
+    char *printable;
+
+    NowTime = time(NULL);
+    printable = ctime(&NowTime);
+    LYStrNCpy(day, printable + 8, 2);
+    if (day[0] == ' ') {
+	day[0] = '0';
+    }
+    LYStrNCpy(month, printable + 4, 3);
+    for (i = 0; i < 12; i++) {
+	if (!strcasecomp(month, months[i])) {
+	    break;
+	}
+    }
+    i++;
+    sprintf(date, "9999%02d%.2s", i % 100, day);
+    TheDate = atoi(date);
+    LYStrNCpy(ThisYear, printable + 20, 4);
+    sprintf(LastYear, "%d", (atoi(ThisYear) - 1) % 10000);
+    HaveYears = TRUE;
+}
+
+typedef struct _EntryInfo {
+    char *filename;
+    char *linkname;		/* symbolic link, if any */
+    char *type;
+    char *date;
+    off_t size;
+    BOOLEAN display;		/* show this entry? */
+#ifdef LONG_LIST
+    unsigned long file_links;
+    char *file_mode;
+    char *file_user;
+    char *file_group;
+#endif
+} EntryInfo;
+
+static void free_entryinfo_struct_contents(EntryInfo *entry_info)
+{
+    if (entry_info) {
+#ifdef LONG_LIST
+	FREE(entry_info->file_mode);
+	FREE(entry_info->file_user);
+	FREE(entry_info->file_group);
+#endif
+	FREE(entry_info->filename);
+	FREE(entry_info->linkname);
+	FREE(entry_info->type);
+	FREE(entry_info->date);
+    }
+    /* don't free the struct */
+}
+
+/*
+ * is_ls_date() --
+ *	Return TRUE if s points to a string of the form:
+ *		"Sep  1  1990 " or
+ *		"Sep 11 11:59 " or
+ *		"Dec 12 1989  " or
+ *		"FCv 23 1990  " ...
+ */
+static BOOLEAN is_ls_date(char *s)
+{
+    /* must start with three alpha characters */
+    if (!isalpha(UCH(*s++)) || !isalpha(UCH(*s++)) || !isalpha(UCH(*s++)))
+	return FALSE;
+
+    /* space or HT_NON_BREAK_SPACE */
+    if (!(*s == ' ' || *s == HT_NON_BREAK_SPACE)) {
+	return FALSE;
+    }
+    s++;
+
+    /* space or digit */
+    if (!(*s == ' ' || isdigit(UCH(*s)))) {
+	return FALSE;
+    }
+    s++;
+
+    /* digit */
+    if (!isdigit(UCH(*s++)))
+	return FALSE;
+
+    /* space */
+    if (*s++ != ' ')
+	return FALSE;
+
+    /* space or digit */
+    if (!(*s == ' ' || isdigit(UCH(*s)))) {
+	return FALSE;
+    }
+    s++;
+
+    /* digit */
+    if (!isdigit(UCH(*s++)))
+	return FALSE;
+
+    /* colon or digit */
+    if (!(*s == ':' || isdigit(UCH(*s)))) {
+	return FALSE;
+    }
+    s++;
+
+    /* digit */
+    if (!isdigit(UCH(*s++)))
+	return FALSE;
+
+    /* space or digit */
+    if (!(*s == ' ' || isdigit(UCH(*s)))) {
+	return FALSE;
+    }
+    s++;
+
+    /* space */
+    if (*s != ' ')
+	return FALSE;
+
+    return TRUE;
+}				/* is_ls_date() */
+
+/*
+ * Extract the name, size, and date from an EPLF line.  - 08-06-96 DJB
+ */
+static void parse_eplf_line(char *line,
+			    EntryInfo *info)
+{
+    char *cp = line;
+    char ct[26];
+    off_t size;
+    time_t secs;
+    static time_t base;		/* time() value on this OS in 1970 */
+    static int flagbase = 0;
+
+    if (!flagbase) {
+	struct tm t;
+
+	t.tm_year = 70;
+	t.tm_mon = 0;
+	t.tm_mday = 0;
+	t.tm_hour = 0;
+	t.tm_min = 0;
+	t.tm_sec = 0;
+	t.tm_isdst = -1;
+	base = mktime(&t);	/* could return -1 */
+	flagbase = 1;
+    }
+
+    while (*cp) {
+	switch (*cp) {
+	case '\t':
+	    StrAllocCopy(info->filename, cp + 1);
+	    return;
+	case 's':
+	    size = 0;
+	    while (*(++cp) && (*cp != ','))
+		size = (size * 10) + (off_t) (*cp - '0');
+	    info->size = size;
+	    break;
+	case 'm':
+	    secs = 0;
+	    while (*(++cp) && (*cp != ','))
+		secs = (secs * 10) + (*cp - '0');
+	    secs += base;	/* assumes that time_t is #seconds */
+	    LYStrNCpy(ct, ctime(&secs), 24);
+	    StrAllocCopy(info->date, ct);
+	    break;
+	case '/':
+	    StrAllocCopy(info->type, ENTRY_IS_DIRECTORY);
+	    /* FALLTHRU */
+	default:
+	    while (*cp) {
+		if (*cp++ == ',')
+		    break;
+	    }
+	    break;
+	}
+    }
+}				/* parse_eplf_line */
+
+/*
+ * Extract the name, size, and date from an ls -l line.
+ */
+static void parse_ls_line(char *line,
+			  EntryInfo *entry)
+{
+#ifdef LONG_LIST
+    char *next;
+    char *cp;
+#endif
+    int i, j;
+    off_t base = 1;
+    off_t size_num = 0;
+
+    for (i = (int) strlen(line) - 1;
+	 (i > 13) && (!isspace(UCH(line[i])) || !is_ls_date(&line[i - 12]));
+	 i--) {
+	;			/* null body */
+    }
+    line[i] = '\0';
+    if (i > 13) {
+	StrAllocCopy(entry->date, &line[i - 12]);
+	/* replace the 4th location with nbsp if it is a space or zero */
+	if (entry->date[4] == ' ' || entry->date[4] == '0')
+	    entry->date[4] = HT_NON_BREAK_SPACE;
+	/* make sure year or time is flush right */
+	if (entry->date[11] == ' ') {
+	    for (j = 11; j > 6; j--) {
+		entry->date[j] = entry->date[j - 1];
+	    }
+	}
+    }
+    j = i - 14;
+    while (isdigit(UCH(line[j]))) {
+	size_num += ((off_t) (line[j] - '0') * base);
+	base *= 10;
+	j--;
+    }
+    entry->size = size_num;
+    StrAllocCopy(entry->filename, &line[i + 1]);
+
+#ifdef LONG_LIST
+    line[j] = '\0';
+
+    /*
+     * Extract the file-permissions, as a string.
+     */
+    if ((cp = StrChr(line, ' ')) != 0) {
+	if ((cp - line) == 10) {
+	    *cp = '\0';
+	    StrAllocCopy(entry->file_mode, line);
+	    *cp = ' ';
+	}
+
+	/*
+	 * Next is the link-count.
+	 */
+	next = 0;
+	entry->file_links = (unsigned long) strtol(cp, &next, 10);
+	if (next == 0 || *next != ' ') {
+	    entry->file_links = 0;
+	    next = cp;
+	} else {
+	    cp = next;
+	}
+	/*
+	 * Next is the user-name.
+	 */
+	while (isspace(UCH(*cp)))
+	    ++cp;
+	if ((next = StrChr(cp, ' ')) != 0)
+	    *next = '\0';
+	if (*cp != '\0')
+	    StrAllocCopy(entry->file_user, cp);
+	/*
+	 * Next is the group-name (perhaps).
+	 */
+	if (next != NULL) {
+	    cp = (next + 1);
+	    while (isspace(UCH(*cp)))
+		++cp;
+	    if ((next = StrChr(cp, ' ')) != 0)
+		*next = '\0';
+	    if (*cp != '\0')
+		StrAllocCopy(entry->file_group, cp);
+	}
+    }
+#endif
+}
+
+/*
+ * Extract the name and size info and whether it refers to a directory from a
+ * LIST line in "dls" format.
+ */
+static void parse_dls_line(char *line,
+			   EntryInfo *entry_info,
+			   char **pspilledname)
+{
+    short j;
+    int base = 1;
+    off_t size_num = 0;
+    int len;
+    char *cps = NULL;
+
+    /* README              763  Information about this server\0
+       bin/                  -  \0
+       etc/                  =  \0
+       ls-lR                 0  \0
+       ls-lR.Z               3  \0
+       pub/                  =  Public area\0
+       usr/                  -  \0
+       morgan               14  -> ../real/morgan\0
+       TIMIT.mostlikely.Z\0
+       79215    \0
+     */
+
+    len = (int) strlen(line);
+    if (len == 0) {
+	FREE(*pspilledname);
+	entry_info->display = FALSE;
+	return;
+    }
+    cps = LYSkipNonBlanks(line);
+    if (*cps == '\0') {		/* only a filename, save it and return. */
+	StrAllocCopy(*pspilledname, line);
+	entry_info->display = FALSE;
+	return;
+    }
+    if (len < 24 || line[23] != ' ' ||
+	(isspace(UCH(line[0])) && !*pspilledname)) {
+	/* this isn't the expected "dls" format! */
+	if (!isspace(UCH(line[0])))
+	    *cps = '\0';
+	if (*pspilledname && !*line) {
+	    entry_info->filename = *pspilledname;
+	    *pspilledname = NULL;
+	    if (entry_info->filename[strlen(entry_info->filename) - 1] == '/')
+		StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    else
+		StrAllocCopy(entry_info->type, "");
+	} else {
+	    StrAllocCopy(entry_info->filename, line);
+	    if (cps != line && *(cps - 1) == '/')
+		StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    else
+		StrAllocCopy(entry_info->type, "");
+	    FREE(*pspilledname);
+	}
+	return;
+    }
+
+    j = 22;
+    if (line[j] == '=' || line[j] == '-') {
+	StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+    } else {
+	while (isdigit(UCH(line[j]))) {
+	    size_num += (line[j] - '0') * base;
+	    base *= 10;
+	    j--;
+	}
+    }
+    entry_info->size = size_num;
+
+    cps = LYSkipBlanks(&line[23]);
+    if (!StrNCmp(cps, "-> ", 3) && cps[3] != '\0' && cps[3] != ' ') {
+	StrAllocCopy(entry_info->type, ENTRY_IS_SYMBOLIC_LINK);
+	StrAllocCopy(entry_info->linkname, LYSkipBlanks(cps + 3));
+	entry_info->size = 0;	/* don't display size */
+    }
+
+    if (j > 0)
+	line[j] = '\0';
+
+    LYTrimTrailing(line);
+
+    len = (int) strlen(line);
+    if (len == 0 && *pspilledname && **pspilledname) {
+	line = *pspilledname;
+	len = (int) strlen(*pspilledname);
+    }
+    if (len > 0 && line[len - 1] == '/') {
+	/*
+	 * It's a dir, remove / and mark it as such.
+	 */
+	if (len > 1)
+	    line[len - 1] = '\0';
+	if (!entry_info->type)
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+    }
+
+    StrAllocCopy(entry_info->filename, line);
+    FREE(*pspilledname);
+}				/* parse_dls_line() */
+
+/*
+ * parse_vms_dir_entry()
+ *	Format the name, date, and size from a VMS LIST line
+ *	into the EntryInfo structure - FM
+ */
+static void parse_vms_dir_entry(char *line,
+				EntryInfo *entry_info)
+{
+    int i, j;
+    off_t ialloc;
+    char *cp, *cpd, *cps, date[16];
+    const char *sp = " ";
+
+    /* Get rid of blank lines, and information lines.  Valid lines have the ';'
+     * version number token.
+     */
+    if (!strlen(line) || (cp = StrChr(line, ';')) == NULL) {
+	entry_info->display = FALSE;
+	return;
+    }
+
+    /* Cut out file or directory name at VMS version number. */
+    *cp++ = '\0';
+    StrAllocCopy(entry_info->filename, line);
+
+    /* Cast VMS non-README file and directory names to lowercase. */
+    if (strstr(entry_info->filename, "READ") == NULL) {
+	LYLowerCase(entry_info->filename);
+	i = (int) strlen(entry_info->filename);
+    } else {
+	i = (int) ((strstr(entry_info->filename, "READ")
+		    - entry_info->filename)
+		   + 4);
+	if (!StrNCmp(&entry_info->filename[i], "ME", 2)) {
+	    i += 2;
+	    while (entry_info->filename[i] && entry_info->filename[i] != '.') {
+		i++;
+	    }
+	} else if (!StrNCmp(&entry_info->filename[i], ".ME", 3)) {
+	    i = (int) strlen(entry_info->filename);
+	} else {
+	    i = 0;
+	}
+	LYLowerCase(entry_info->filename + i);
+    }
+
+    /* Uppercase terminal .z's or _z's. */
+    if ((--i > 2) &&
+	entry_info->filename[i] == 'z' &&
+	(entry_info->filename[i - 1] == '.' ||
+	 entry_info->filename[i - 1] == '_'))
+	entry_info->filename[i] = 'Z';
+
+    /* Convert any tabs in rest of line to spaces. */
+    cps = cp - 1;
+    while ((cps = StrChr(cps + 1, '\t')) != NULL)
+	*cps = ' ';
+
+    /* Collapse serial spaces. */
+    i = 0;
+    j = 1;
+    cps = cp;
+    while (cps[j] != '\0') {
+	if (cps[i] == ' ' && cps[j] == ' ')
+	    j++;
+	else
+	    cps[++i] = cps[j++];
+    }
+    cps[++i] = '\0';
+
+    /* Set the years and date, if we don't have them yet. * */
+    if (!HaveYears) {
+	set_years_and_date();
+    }
+
+    /* Track down the date. */
+    if ((cpd = StrChr(cp, '-')) != NULL &&
+	strlen(cpd) > 9 && isdigit(UCH(*(cpd - 1))) &&
+	isalpha(UCH(*(cpd + 1))) && *(cpd + 4) == '-') {
+
+	/* Month */
+	*(cpd + 2) = (char) TOLOWER(*(cpd + 2));
+	*(cpd + 3) = (char) TOLOWER(*(cpd + 3));
+	sprintf(date, "%.3s ", cpd + 1);
+
+	/* Day */
+	if (isdigit(UCH(*(cpd - 2))))
+	    sprintf(date + 4, "%.2s ", cpd - 2);
+	else
+	    sprintf(date + 4, "%c%.1s ", HT_NON_BREAK_SPACE, cpd - 1);
+
+	/* Time or Year */
+	if (!StrNCmp(ThisYear, cpd + 5, 4) &&
+	    strlen(cpd) > 15 && *(cpd + 12) == ':') {
+	    sprintf(date + 7, "%.5s", cpd + 10);
+	} else {
+	    sprintf(date + 7, " %.4s", cpd + 5);
+	}
+
+	StrAllocCopy(entry_info->date, date);
+    }
+
+    /* Track down the size */
+    if ((cpd = StrChr(cp, '/')) != NULL) {
+	/* Appears be in used/allocated format */
+	cps = cpd;
+	while (isdigit(UCH(*(cps - 1))))
+	    cps--;
+	if (cps < cpd)
+	    *cpd = '\0';
+	entry_info->size = LYatoll(cps);
+	cps = cpd + 1;
+	while (isdigit(UCH(*cps)))
+	    cps++;
+	*cps = '\0';
+	ialloc = LYatoll(cpd + 1);
+	/* Check if used is in blocks or bytes */
+	if (entry_info->size <= ialloc)
+	    entry_info->size *= 512;
+
+    } else if (strtok(cp, sp) != NULL) {
+	/* We just initialized on the version number */
+	/* Now let's hunt for a lone, size number    */
+	while ((cps = strtok(NULL, sp)) != NULL) {
+	    cpd = cps;
+	    while (isdigit(UCH(*cpd)))
+		cpd++;
+	    if (*cpd == '\0') {
+		/* Assume it's blocks */
+		entry_info->size = (LYatoll(cps) * 512);
+		break;
+	    }
+	}
+    }
+
+    TRACE_ENTRY("VMS", entry_info);
+    return;
+}				/* parse_vms_dir_entry() */
+
+/*
+ * parse_ms_windows_dir_entry() --
+ *	Format the name, date, and size from an MS_WINDOWS LIST line into
+ *	the EntryInfo structure (assumes Chameleon NEWT format). - FM
+ */
+static void parse_ms_windows_dir_entry(char *line,
+				       EntryInfo *entry_info)
+{
+    char *cp = line;
+    char *cps, *cpd, date[16];
+    char *end = line + strlen(line);
+
+    /*  Get rid of blank or junk lines.  */
+    cp = LYSkipBlanks(cp);
+    if (!(*cp)) {
+	entry_info->display = FALSE;
+	return;
+    }
+
+    /* Cut out file or directory name. */
+    cps = LYSkipNonBlanks(cp);
+    *cps++ = '\0';
+    cpd = cps;
+    StrAllocCopy(entry_info->filename, cp);
+
+    /* Track down the size */
+    if (cps < end) {
+	cps = LYSkipBlanks(cps);
+	cpd = LYSkipNonBlanks(cps);
+	*cpd++ = '\0';
+	if (isdigit(UCH(*cps))) {
+	    entry_info->size = LYatoll(cps);
+	} else {
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	}
+    } else {
+	StrAllocCopy(entry_info->type, "");
+    }
+
+    /* Set the years and date, if we don't have them yet. * */
+    if (!HaveYears) {
+	set_years_and_date();
+    }
+
+    /* Track down the date. */
+    if (cpd < end) {
+	cpd = LYSkipBlanks(cpd);
+	if (strlen(cpd) > 17) {
+	    *(cpd + 6) = '\0';	/* Month and Day */
+	    *(cpd + 11) = '\0';	/* Year */
+	    *(cpd + 17) = '\0';	/* Time */
+	    if (strcmp(ThisYear, cpd + 7))
+		/* Not this year, so show the year */
+		sprintf(date, "%.6s  %.4s", cpd, (cpd + 7));
+	    else
+		/* Is this year, so show the time */
+		sprintf(date, "%.6s %.5s", cpd, (cpd + 12));
+	    StrAllocCopy(entry_info->date, date);
+	    if (entry_info->date[4] == ' ' || entry_info->date[4] == '0') {
+		entry_info->date[4] = HT_NON_BREAK_SPACE;
+	    }
+	}
+    }
+
+    TRACE_ENTRY("MS Windows", entry_info);
+    return;
+}				/* parse_ms_windows_dir_entry */
+
+/*
+ * parse_windows_nt_dir_entry() --
+ *	Format the name, date, and size from a WINDOWS_NT LIST line into
+ *	the EntryInfo structure (assumes Chameleon NEWT format). - FM
+ */
+#ifdef NOTDEFINED
+static void parse_windows_nt_dir_entry(char *line,
+				       EntryInfo *entry_info)
+{
+    char *cp = line;
+    char *cps, *cpd, date[16];
+    char *end = line + strlen(line);
+    int i;
+
+    /*  Get rid of blank or junk lines.  */
+    cp = LYSkipBlanks(cp);
+    if (!(*cp)) {
+	entry_info->display = FALSE;
+	return;
+    }
+
+    /* Cut out file or directory name. */
+    cpd = cp;
+    cps = LYSkipNonBlanks(end - 1);
+    cp = (cps + 1);
+    if (!strcmp(cp, ".") || !strcmp(cp, "..")) {
+	entry_info->display = FALSE;
+	return;
+    }
+    StrAllocCopy(entry_info->filename, cp);
+    if (cps < cpd)
+	return;
+    *cp = '\0';
+    end = cp;
+
+    /* Set the years and date, if we don't have them yet. * */
+    if (!HaveYears) {
+	set_years_and_date();
+    }
+
+    /* Cut out the date. */
+    cp = cps = cpd;
+    cps = LYSkipNonBlanks(cps);
+    *cps++ = '\0';
+    if (cps > end) {
+	entry_info->display = FALSE;
+	return;
+    }
+    cps = LYSkipBlanks(cps);
+    cpd = LYSkipNonBlanks(cps);
+    *cps++ = '\0';
+    if (cps > end || cpd == cps || strlen(cpd) < 7) {
+	entry_info->display = FALSE;
+	return;
+    }
+    if (strlen(cp) == 8 &&
+	isdigit(*cp) && isdigit(*(cp + 1)) && *(cp + 2) == '-' &&
+	isdigit(*(cp + 3)) && isdigit(*(cp + 4)) && *(cp + 5) == '-') {
+	*(cp + 2) = '\0';	/* Month */
+	i = atoi(cp) - 1;
+	*(cp + 5) = '\0';	/* Day */
+	sprintf(date, "%.3s %.2s", months[i], (cp + 3));
+	if (date[4] == '0')
+	    date[4] = ' ';
+	cp += 6;		/* Year */
+	if (strcmp((ThisYear + 2), cp)) {
+	    /* Not this year, so show the year */
+	    if (atoi(cp) < 70) {
+		sprintf(&date[6], "  20%.2s", cp);
+	    } else {
+		sprintf(&date[6], "  19%.2s", cp);
+	    }
+	} else {
+	    /* Is this year, so show the time */
+	    *(cpd + 2) = '\0';	/* Hour */
+	    i = atoi(cpd);
+	    if (*(cpd + 5) == 'P' || *(cpd + 5) == 'p')
+		i += 12;
+	    sprintf(&date[6], " %02d:%.2s", i, (cpd + 3));
+	}
+	StrAllocCopy(entry_info->date, date);
+	if (entry_info->date[4] == ' ' || entry_info->date[4] == '0') {
+	    entry_info->date[4] = HT_NON_BREAK_SPACE;
+	}
+    }
+
+    /* Track down the size */
+    if (cps < end) {
+	cps = LYSkipBlanks(cps);
+	cpd = LYSkipNonBlanks(cps);
+	*cpd = '\0';
+	if (isdigit(*cps)) {
+	    entry_info->size = LYatoll(cps);
+	} else {
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	}
+    } else {
+	StrAllocCopy(entry_info->type, "");
+    }
+
+    /* Wrap it up */
+    CTRACE((tfp, "HTFTP: Windows NT filename: %s  date: %s  size: %d\n",
+	    entry_info->filename,
+	    NonNull(entry_info->date),
+	    entry_info->size));
+    return;
+}				/* parse_windows_nt_dir_entry */
+#endif /* NOTDEFINED */
+
+/*
+ * parse_cms_dir_entry() --
+ *	Format the name, date, and size from a VM/CMS line into
+ *	the EntryInfo structure. - FM
+ */
+static void parse_cms_dir_entry(char *line,
+				EntryInfo *entry_info)
+{
+    char *cp = line;
+    char *cps, *cpd, date[16];
+    char *end = line + strlen(line);
+    int RecordLength = 0;
+    int Records = 0;
+    int i;
+
+    /*  Get rid of blank or junk lines.  */
+    cp = LYSkipBlanks(cp);
+    if (!(*cp)) {
+	entry_info->display = FALSE;
+	return;
+    }
+
+    /* Cut out file or directory name. */
+    cps = LYSkipNonBlanks(cp);
+    *cps++ = '\0';
+    StrAllocCopy(entry_info->filename, cp);
+    if (StrChr(entry_info->filename, '.') != NULL)
+	/* If we already have a dot, we did an NLST. */
+	return;
+    cp = LYSkipBlanks(cps);
+    if (!(*cp)) {
+	/* If we don't have more, we've misparsed. */
+	FREE(entry_info->filename);
+	FREE(entry_info->type);
+	entry_info->display = FALSE;
+	return;
+    }
+    cps = LYSkipNonBlanks(cp);
+    *cps++ = '\0';
+    if ((0 == strcasecomp(cp, "DIR")) && (cp - line) > 17) {
+	/* It's an SFS directory. */
+	StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	entry_info->size = 0;
+    } else {
+	/* It's a file. */
+	cp--;
+	*cp = '.';
+	StrAllocCat(entry_info->filename, cp);
+
+	/* Track down the VM/CMS RECFM or type. */
+	cp = cps;
+	if (cp < end) {
+	    cp = LYSkipBlanks(cp);
+	    cps = LYSkipNonBlanks(cp);
+	    *cps++ = '\0';
+	    /* Check cp here, if it's relevant someday. */
+	}
+    }
+
+    /* Track down the record length or dash. */
+    cp = cps;
+    if (cp < end) {
+	cp = LYSkipBlanks(cp);
+	cps = LYSkipNonBlanks(cp);
+	*cps++ = '\0';
+	if (isdigit(UCH(*cp))) {
+	    RecordLength = atoi(cp);
+	}
+    }
+
+    /* Track down the number of records or the dash. */
+    cp = cps;
+    if (cps < end) {
+	cp = LYSkipBlanks(cp);
+	cps = LYSkipNonBlanks(cp);
+	*cps++ = '\0';
+	if (isdigit(UCH(*cp))) {
+	    Records = atoi(cp);
+	}
+	if (Records > 0 && RecordLength > 0) {
+	    /* Compute an approximate size. */
+	    entry_info->size = ((off_t) Records * (off_t) RecordLength);
+	}
+    }
+
+    /* Set the years and date, if we don't have them yet. */
+    if (!HaveYears) {
+	set_years_and_date();
+    }
+
+    /* Track down the date. */
+    cpd = cps;
+    if (((cps < end) &&
+	 (cps = StrChr(cpd, ':')) != NULL) &&
+	(cps < (end - 3) &&
+	 isdigit(UCH(*(cps + 1))) && isdigit(UCH(*(cps + 2))) && *(cps + 3) == ':')) {
+	cps += 3;
+	*cps = '\0';
+	if ((cps - cpd) >= 14) {
+	    cpd = (cps - 14);
+	    *(cpd + 2) = '\0';	/* Month */
+	    *(cpd + 5) = '\0';	/* Day */
+	    *(cpd + 8) = '\0';	/* Year */
+	    cps -= 5;		/* Time */
+	    if (*cpd == ' ')
+		*cpd = '0';
+	    i = atoi(cpd) - 1;
+	    sprintf(date, "%.3s %.2s", months[i], (cpd + 3));
+	    if (date[4] == '0')
+		date[4] = ' ';
+	    cpd += 6;		/* Year */
+	    if (strcmp((ThisYear + 2), cpd)) {
+		/* Not this year, so show the year. */
+		if (atoi(cpd) < 70) {
+		    sprintf(&date[6], "  20%.2s", cpd);
+		} else {
+		    sprintf(&date[6], "  19%.2s", cpd);
+		}
+	    } else {
+		/* Is this year, so show the time. */
+		*(cps + 2) = '\0';	/* Hour */
+		i = atoi(cps);
+		sprintf(&date[6], " %02d:%.2s", i, (cps + 3));
+	    }
+	    StrAllocCopy(entry_info->date, date);
+	    if (entry_info->date[4] == ' ' || entry_info->date[4] == '0') {
+		entry_info->date[4] = HT_NON_BREAK_SPACE;
+	    }
+	}
+    }
+
+    TRACE_ENTRY("VM/CMS", entry_info);
+    return;
+}				/* parse_cms_dir_entry */
+
+/*
+ * Given a line of LIST/NLST output in entry, return results and a file/dir
+ * name in entry_info struct
+ *
+ * If first is true, this is the first name in a directory.
+ */
+static EntryInfo *parse_dir_entry(char *entry,
+				  BOOLEAN *first,
+				  char **pspilledname)
+{
+    EntryInfo *entry_info;
+    int i;
+    int len;
+    BOOLEAN remove_size = FALSE;
+    char *cp;
+
+    entry_info = typecalloc(EntryInfo);
+
+    if (entry_info == NULL)
+	outofmem(__FILE__, "parse_dir_entry");
+
+    entry_info->display = TRUE;
+
+    switch (server_type) {
+    case DLS_SERVER:
+
+	/*
+	 * Interpret and edit LIST output from a Unix server in "dls" format. 
+	 * This one must have claimed to be Unix in order to get here; if the
+	 * first line looks fishy, we revert to Unix and hope that fits better
+	 * (this recovery is untested).  - kw
+	 */
+
+	if (*first) {
+	    len = (int) strlen(entry);
+	    if (!len || entry[0] == ' ' ||
+		(len >= 24 && entry[23] != ' ') ||
+		(len < 24 && StrChr(entry, ' '))) {
+		server_type = UNIX_SERVER;
+		CTRACE((tfp,
+			"HTFTP: Falling back to treating as Unix server.\n"));
+	    } else {
+		*first = FALSE;
+	    }
+	}
+
+	if (server_type == DLS_SERVER) {
+	    /* if still unchanged... */
+	    parse_dls_line(entry, entry_info, pspilledname);
+
+	    if (isEmpty(entry_info->filename)) {
+		entry_info->display = FALSE;
+		return (entry_info);
+	    }
+	    if (!strcmp(entry_info->filename, "..") ||
+		!strcmp(entry_info->filename, "."))
+		entry_info->display = FALSE;
+	    if (entry_info->type && *entry_info->type == '\0') {
+		FREE(entry_info->type);
+		return (entry_info);
+	    }
+	    /*
+	     * Goto the bottom and get real type.
+	     */
+	    break;
+	}
+	/* fall through if server_type changed for *first == TRUE ! */
+	/* FALLTHRU */
+    case UNIX_SERVER:
+    case PETER_LEWIS_SERVER:
+    case MACHTEN_SERVER:
+    case MSDOS_SERVER:
+    case WINDOWS_NT_SERVER:
+    case WINDOWS_2K_SERVER:
+    case APPLESHARE_SERVER:
+    case NETPRESENZ_SERVER:
+	/*
+	 * Check for EPLF output (local times).
+	 */
+	if (*entry == '+') {
+	    parse_eplf_line(entry, entry_info);
+	    break;
+	}
+
+	/*
+	 * Interpret and edit LIST output from Unix server.
+	 */
+	len = (int) strlen(entry);
+	if (*first) {
+	    /* don't gettext() this -- incoming text: */
+	    if (!strcmp(entry, "can not access directory .")) {
+		/*
+		 * Don't reset *first, nothing real will follow.  - KW
+		 */
+		entry_info->display = FALSE;
+		return (entry_info);
+	    }
+	    *first = FALSE;
+	    if (!StrNCmp(entry, "total ", 6) ||
+		strstr(entry, "not available") != NULL) {
+		entry_info->display = FALSE;
+		return (entry_info);
+	    } else if (unsure_type) {
+		/* this isn't really a unix server! */
+		server_type = GENERIC_SERVER;
+		entry_info->display = FALSE;
+		return (entry_info);
+	    }
+	}
+
+	/*
+	 * Check first character of ls -l output.
+	 */
+	if (TOUPPER(entry[0]) == 'D') {
+	    /*
+	     * It's a directory.
+	     */
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    remove_size = TRUE;	/* size is not useful */
+	} else if (entry[0] == 'l') {
+	    /*
+	     * It's a symbolic link, does the user care about knowing if it is
+	     * symbolic?  I think so since it might be a directory.
+	     */
+	    StrAllocCopy(entry_info->type, ENTRY_IS_SYMBOLIC_LINK);
+	    remove_size = TRUE;	/* size is not useful */
+
+	    /*
+	     * Strip off " -> pathname".
+	     */
+	    for (i = len - 1; (i > 3) &&
+		 (!isspace(UCH(entry[i])) ||
+		  (entry[i - 1] != '>') ||
+		  (entry[i - 2] != '-') ||
+		  (entry[i - 3] != ' ')); i--) ;	/* null body */
+	    if (i > 3) {
+		entry[i - 3] = '\0';
+		StrAllocCopy(entry_info->linkname, LYSkipBlanks(entry + i));
+	    }
+	}
+	/* link */
+	parse_ls_line(entry, entry_info);
+
+	if (!strcmp(entry_info->filename, "..") ||
+	    !strcmp(entry_info->filename, "."))
+	    entry_info->display = FALSE;
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+
+    case VMS_SERVER:
+	/*
+	 * Interpret and edit LIST output from VMS server and convert
+	 * information lines to zero length.
+	 */
+	parse_vms_dir_entry(entry, entry_info);
+
+	/*
+	 * Get rid of any junk lines.
+	 */
+	if (!entry_info->display)
+	    return (entry_info);
+
+	/*
+	 * Trim off VMS directory extensions.
+	 */
+	len = (int) strlen(entry_info->filename);
+	if ((len > 4) && !strcmp(&entry_info->filename[len - 4], ".dir")) {
+	    entry_info->filename[len - 4] = '\0';
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    remove_size = TRUE;	/* size is not useful */
+	}
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+
+    case MS_WINDOWS_SERVER:
+	/*
+	 * Interpret and edit LIST output from MS_WINDOWS server and convert
+	 * information lines to zero length.
+	 */
+	parse_ms_windows_dir_entry(entry, entry_info);
+
+	/*
+	 * Get rid of any junk lines.
+	 */
+	if (!entry_info->display)
+	    return (entry_info);
+	if (entry_info->type && *entry_info->type == '\0') {
+	    FREE(entry_info->type);
+	    return (entry_info);
+	}
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+
+#ifdef NOTDEFINED
+    case WINDOWS_NT_SERVER:
+	/*
+	 * Interpret and edit LIST output from MS_WINDOWS server and convert
+	 * information lines to zero length.
+	 */
+	parse_windows_nt_dir_entry(entry, entry_info);
+
+	/*
+	 * Get rid of any junk lines.
+	 */
+	if (!entry_info->display)
+	    return (entry_info);
+	if (entry_info->type && *entry_info->type == '\0') {
+	    FREE(entry_info->type);
+	    return (entry_info);
+	}
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+#endif /* NOTDEFINED */
+
+    case CMS_SERVER:
+	{
+	    /*
+	     * Interpret and edit LIST output from VM/CMS server and convert
+	     * any information lines to zero length.
+	     */
+	    parse_cms_dir_entry(entry, entry_info);
+
+	    /*
+	     * Get rid of any junk lines.
+	     */
+	    if (!entry_info->display)
+		return (entry_info);
+	    if (entry_info->type && *entry_info->type == '\0') {
+		FREE(entry_info->type);
+		return (entry_info);
+	    }
+	    /*
+	     * Goto the bottom and get real type.
+	     */
+	    break;
+	}
+
+    case NCSA_SERVER:
+    case TCPC_SERVER:
+	/*
+	 * Directories identified by trailing "/" characters.
+	 */
+	StrAllocCopy(entry_info->filename, entry);
+	len = (int) strlen(entry);
+	if (entry[len - 1] == '/') {
+	    /*
+	     * It's a dir, remove / and mark it as such.
+	     */
+	    entry[len - 1] = '\0';
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    remove_size = TRUE;	/* size is not useful */
+	}
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+
+    default:
+	/*
+	 * We can't tell if it is a directory since we only did an NLST :( List
+	 * bad file types anyways?  NOT!
+	 */
+	StrAllocCopy(entry_info->filename, entry);
+	return (entry_info);	/* mostly empty info */
+
+    }				/* switch (server_type) */
+
+#ifdef LONG_LIST
+    (void) remove_size;
+#else
+    if (remove_size && entry_info->size) {
+	entry_info->size = 0;
+    }
+#endif
+
+    if (isEmpty(entry_info->filename)) {
+	entry_info->display = FALSE;
+	return (entry_info);
+    }
+    if (strlen(entry_info->filename) > 3) {
+	if (((cp = strrchr(entry_info->filename, '.')) != NULL &&
+	     0 == strncasecomp(cp, ".me", 3)) &&
+	    (cp[3] == '\0' || cp[3] == ';')) {
+	    /*
+	     * Don't treat this as application/x-Troff-me if it's a Unix server
+	     * but has the string "read.me", or if it's not a Unix server.  -
+	     * FM
+	     */
+	    if ((server_type != UNIX_SERVER) ||
+		(cp > (entry_info->filename + 3) &&
+		 0 == strncasecomp((cp - 4), "read.me", 7))) {
+		StrAllocCopy(entry_info->type, STR_PLAINTEXT);
+	    }
+	}
+    }
+
+    /*
+     * Get real types eventually.
+     */
+    if (!entry_info->type) {
+	const char *cp2;
+	HTFormat format;
+	HTAtom *encoding;	/* @@ not used at all */
+
+	format = HTFileFormat(entry_info->filename, &encoding, &cp2);
+
+	if (cp2 == NULL) {
+	    if (!StrNCmp(HTAtom_name(format), "application", 11)) {
+		cp2 = HTAtom_name(format) + 12;
+		if (!StrNCmp(cp2, "x-", 2))
+		    cp2 += 2;
+	    } else {
+		cp2 = HTAtom_name(format);
+	    }
+	}
+
+	StrAllocCopy(entry_info->type, cp2);
+    }
+
+    return (entry_info);
+}
+
+static void formatDate(char target[16], EntryInfo *entry)
+{
+    char temp[8], month[4];
+    int i;
+
+    /*
+     * Set up for sorting in reverse chronological order. - FM
+     */
+    if (entry->date[9] == ':') {
+	strcpy(target, "9999");
+	LYStrNCpy(temp, &entry->date[7], 5);
+	if (temp[0] == ' ') {
+	    temp[0] = '0';
+	}
+    } else {
+	LYStrNCpy(target, &entry->date[8], 4);
+	strcpy(temp, "00:00");
+    }
+    LYStrNCpy(month, entry->date, 3);
+    for (i = 0; i < 12; i++) {
+	if (!strcasecomp(month, months[i])) {
+	    break;
+	}
+    }
+    i++;
+    sprintf(month, "%02d", i % 100);
+    strcat(target, month);
+    StrNCat(target, &entry->date[4], 2);
+    if (target[6] == ' ' || target[6] == HT_NON_BREAK_SPACE) {
+	target[6] = '0';
+    }
+
+    /* If no year given, assume last year if it would otherwise be in the
+     * future by more than one day.  The one day tolerance is to account for a
+     * possible timezone difference. - kw
+     */
+    if (target[0] == '9' && atoi(target) > TheDate + 1) {
+	for (i = 0; i < 4; i++) {
+	    target[i] = LastYear[i];
+	}
+    }
+    strcat(target, temp);
+}
+
+static int compare_EntryInfo_structs(EntryInfo *entry1, EntryInfo *entry2)
+{
+    int status;
+    char date1[16], date2[16];
+    int result = strcmp(entry1->filename, entry2->filename);
+
+    switch (HTfileSortMethod) {
+    case FILE_BY_SIZE:
+	/* both equal or both 0 */
+	if (entry1->size > entry2->size)
+	    result = 1;
+	else if (entry1->size < entry2->size)
+	    result = -1;
+	break;
+
+    case FILE_BY_TYPE:
+	if (entry1->type && entry2->type) {
+	    status = strcasecomp(entry1->type, entry2->type);
+	    if (status)
+		result = status;
+	}
+	break;
+
+    case FILE_BY_DATE:
+	if (entry1->date && entry2->date &&
+	    strlen(entry1->date) == 12 &&
+	    strlen(entry2->date) == 12) {
+	    /*
+	     * Set the years and date, if we don't have them yet.
+	     */
+	    if (!HaveYears) {
+		set_years_and_date();
+	    }
+	    formatDate(date1, entry1);
+	    formatDate(date2, entry2);
+	    /*
+	     * Do the comparison. - FM
+	     */
+	    status = strcasecomp(date2, date1);
+	    if (status)
+		result = status;
+	}
+	break;
+
+    case FILE_BY_NAME:
+    default:
+	break;
+    }
+    return result;
+}
+
+#ifdef LONG_LIST
+static char *FormatStr(char **bufp,
+		       char *start,
+		       const char *value)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*ss", (int) sizeof(fmt) - 3, start);
+	HTSprintf(bufp, fmt, value);
+    } else if (*bufp && !(value && *value)) {
+	;
+    } else if (value) {
+	StrAllocCat(*bufp, value);
+    }
+    return *bufp;
+}
+
+static char *FormatSize(char **bufp,
+			char *start,
+			off_t value)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*s" PRI_off_t,
+		  (int) sizeof(fmt) - DigitsOf(start) - 3, start);
+
+	HTSprintf(bufp, fmt, value);
+    } else {
+	sprintf(fmt, "%" PRI_off_t, CAST_off_t (value));
+
+	StrAllocCat(*bufp, fmt);
+    }
+    return *bufp;
+}
+
+static char *FormatNum(char **bufp,
+		       char *start,
+		       unsigned long value)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*sld",
+		(int) sizeof(fmt) - DigitsOf(start) - 3, start);
+	HTSprintf(bufp, fmt, value);
+    } else {
+	sprintf(fmt, "%lu", value);
+	StrAllocCat(*bufp, fmt);
+    }
+    return *bufp;
+}
+
+static void FlushParse(HTStructured * target, char **buf)
+{
+    if (*buf && **buf) {
+	PUTS(*buf);
+	**buf = '\0';
+    }
+}
+
+static void LYListFmtParse(const char *fmtstr,
+			   EntryInfo *data,
+			   HTStructured * target,
+			   char *tail)
+{
+    char c;
+    char *s;
+    char *end;
+    char *start;
+    char *str = NULL;
+    char *buf = NULL;
+    BOOL is_directory = (BOOL) (data->file_mode != 0 &&
+				(TOUPPER(data->file_mode[0]) == 'D'));
+    BOOL is_symlinked = (BOOL) (data->file_mode != 0 &&
+				(TOUPPER(data->file_mode[0]) == 'L'));
+    BOOL remove_size = (BOOL) (is_directory || is_symlinked);
+
+    StrAllocCopy(str, fmtstr);
+    s = str;
+    end = str + strlen(str);
+    while (*s) {
+	start = s;
+	while (*s) {
+	    if (*s == '%') {
+		if (*(s + 1) == '%')	/* literal % */
+		    s++;
+		else
+		    break;
+	    }
+	    s++;
+	}
+	/* s is positioned either at a % or at \0 */
+	*s = '\0';
+	if (s > start) {	/* some literal chars. */
+	    StrAllocCat(buf, start);
+	}
+	if (s == end)
+	    break;
+	start = ++s;
+	while (isdigit(UCH(*s)) || *s == '.' || *s == '-' || *s == ' ' ||
+	       *s == '#' || *s == '+' || *s == '\'')
+	    s++;
+	c = *s;			/* the format char. or \0 */
+	*s = '\0';
+
+	switch (c) {
+	case '\0':
+	    StrAllocCat(buf, start);
+	    continue;
+
+	case 'A':
+	case 'a':		/* anchor */
+	    FlushParse(target, &buf);
+	    HTDirEntry(target, tail, data->filename);
+	    FormatStr(&buf, start, data->filename);
+	    PUTS(buf);
+	    END(HTML_A);
+	    if (buf != 0)
+		*buf = '\0';
+	    if (c != 'A' && data->linkname != 0) {
+		PUTS(" -> ");
+		PUTS(data->linkname);
+	    }
+	    break;
+
+	case 'T':		/* MIME type */
+	case 't':		/* MIME type description */
+	    if (is_directory) {
+		if (c != 'T') {
+		    FormatStr(&buf, start, ENTRY_IS_DIRECTORY);
+		} else {
+		    FormatStr(&buf, start, "");
+		}
+	    } else if (is_symlinked) {
+		if (c != 'T') {
+		    FormatStr(&buf, start, ENTRY_IS_SYMBOLIC_LINK);
+		} else {
+		    FormatStr(&buf, start, "");
+		}
+	    } else {
+		const char *cp2;
+		HTFormat format;
+
+		format = HTFileFormat(data->filename, NULL, &cp2);
+
+		if (c != 'T') {
+		    if (cp2 == NULL) {
+			if (!StrNCmp(HTAtom_name(format),
+				     "application", 11)) {
+			    cp2 = HTAtom_name(format) + 12;
+			    if (!StrNCmp(cp2, "x-", 2))
+				cp2 += 2;
+			} else {
+			    cp2 = HTAtom_name(format);
+			}
+		    }
+		    FormatStr(&buf, start, cp2);
+		} else {
+		    FormatStr(&buf, start, HTAtom_name(format));
+		}
+	    }
+	    break;
+
+	case 'd':		/* date */
+	    if (data->date) {
+		FormatStr(&buf, start, data->date);
+	    } else {
+		FormatStr(&buf, start, " * ");
+	    }
+	    break;
+
+	case 's':		/* size in bytes */
+	    FormatSize(&buf, start, data->size);
+	    break;
+
+	case 'K':		/* size in Kilobytes but not for directories */
+	    if (remove_size) {
+		FormatStr(&buf, start, "");
+		StrAllocCat(buf, " ");
+		break;
+	    }
+	    /* FALL THROUGH */
+	case 'k':		/* size in Kilobytes */
+	    /* FIXME - this is inconsistent with HTFile.c, but historical */
+	    if (data->size < 1024) {
+		FormatSize(&buf, start, data->size);
+		StrAllocCat(buf, " bytes");
+	    } else {
+		FormatSize(&buf, start, data->size / 1024);
+		StrAllocCat(buf, "Kb");
+	    }
+	    break;
+
+#ifdef LONG_LIST
+	case 'p':		/* unix-style permission bits */
+	    FormatStr(&buf, start, NonNull(data->file_mode));
+	    break;
+
+	case 'o':		/* owner */
+	    FormatStr(&buf, start, NonNull(data->file_user));
+	    break;
+
+	case 'g':		/* group */
+	    FormatStr(&buf, start, NonNull(data->file_group));
+	    break;
+
+	case 'l':		/* link count */
+	    FormatNum(&buf, start, data->file_links);
+	    break;
+#endif
+
+	case '%':		/* literal % with flags/width */
+	    FormatStr(&buf, start, "%");
+	    break;
+
+	default:
+	    fprintf(stderr,
+		    "Unknown format character `%c' in list format\n", c);
+	    break;
+	}
+
+	s++;
+    }
+    if (buf) {
+	LYTrimTrailing(buf);
+	FlushParse(target, &buf);
+	FREE(buf);
+    }
+    PUTC('\n');
+    FREE(str);
+}
+#endif /* LONG_LIST */
+
+/*	Read a directory into an hypertext object from the data socket
+ *	--------------------------------------------------------------
+ *
+ * On entry,
+ *	anchor		Parent anchor to link the this node to
+ *	address		Address of the directory
+ * On exit,
+ *	returns		HT_LOADED if OK
+ *			<0 if error.
+ */
+static int read_directory(HTParentAnchor *parent,
+			  const char *address,
+			  HTFormat format_out,
+			  HTStream *sink)
+{
+    int status;
+    BOOLEAN WasInterrupted = FALSE;
+    HTStructured *target = HTML_new(parent, format_out, sink);
+    char *filename = HTParse(address, "", PARSE_PATH + PARSE_PUNCTUATION);
+    EntryInfo *entry_info;
+    BOOLEAN first = TRUE;
+    char *lastpath = NULL;	/* prefix for link, either "" (for root) or xxx  */
+    BOOL tildeIsTop = FALSE;
+
+#ifndef LONG_LIST
+    char string_buffer[64];
+#endif
+
+    _HTProgress(gettext("Receiving FTP directory."));
+
+    /*
+     * Force the current Date and Year (TheDate, ThisYear, and LastYear) to be
+     * recalculated for each directory request.  Otherwise we have a problem
+     * with long-running sessions assuming the wrong date for today.  - kw
+     */
+    HaveYears = FALSE;
+    /*
+     * Check whether we always want the home directory treated as Welcome.  -
+     * FM
+     */
+    if (server_type == VMS_SERVER)
+	tildeIsTop = TRUE;
+
+    /*
+     * This should always come back FALSE, since the flag is set only for local
+     * directory listings if LONG_LIST was defined on compilation, but we could
+     * someday set up an equivalent listing for Unix ftp servers.  - FM
+     */
+    (void) HTDirTitles(target, parent, format_out, tildeIsTop);
+
+    data_read_pointer = data_write_pointer = data_buffer;
+
+    if (*filename == '\0') {	/* Empty filename: use root. */
+	StrAllocCopy(lastpath, "/");
+    } else if (!strcmp(filename, "/")) {	/* Root path. */
+	StrAllocCopy(lastpath, "/foo/..");
+    } else {
+	char *p = strrchr(filename, '/');	/* Find the lastslash. */
+	char *cp;
+
+	if (server_type == CMS_SERVER) {
+	    StrAllocCopy(lastpath, filename);	/* Use absolute path for CMS. */
+	} else {
+	    StrAllocCopy(lastpath, p + 1);	/* Take slash off the beginning. */
+	}
+	if ((cp = strrchr(lastpath, ';')) != NULL) {	/* Trim type= param. */
+	    if (!strncasecomp((cp + 1), "type=", 5)) {
+		if (TOUPPER(*(cp + 6)) == 'D' ||
+		    TOUPPER(*(cp + 6)) == 'A' ||
+		    TOUPPER(*(cp + 6)) == 'I')
+		    *cp = '\0';
+	    }
+	}
+    }
+    FREE(filename);
+
+    {
+	HTBTree *bt = HTBTree_new((HTComparer) compare_EntryInfo_structs);
+	int ic;
+	HTChunk *chunk = HTChunkCreate(128);
+	int BytesReceived = 0;
+	int BytesReported = 0;
+	char NumBytes[64];
+	char *spilledname = NULL;
+
+	PUTC('\n');		/* prettier LJM */
+	for (ic = 0; ic != EOF;) {	/* For each entry in the directory */
+	    HTChunkClear(chunk);
+
+	    if (HTCheckForInterrupt()) {
+		CTRACE((tfp,
+			"read_directory: interrupted after %d bytes\n",
+			BytesReceived));
+		WasInterrupted = TRUE;
+		if (BytesReceived) {
+		    goto unload_btree;	/* unload btree */
+		} else {
+		    ABORT_TARGET;
+		    HTBTreeAndObject_free(bt);
+		    FREE(spilledname);
+		    HTChunkFree(chunk);
+		    return HT_INTERRUPTED;
+		}
+	    }
+
+	    /*   read directory entry
+	     */
+	    interrupted_in_next_data_char = FALSE;
+	    for (;;) {		/* Read in one line as filename */
+		ic = NEXT_DATA_CHAR;
+	      AgainForMultiNet:
+		if (interrupted_in_next_data_char) {
+		    CTRACE((tfp,
+			    "read_directory: interrupted_in_next_data_char after %d bytes\n",
+			    BytesReceived));
+		    WasInterrupted = TRUE;
+		    if (BytesReceived) {
+			goto unload_btree;	/* unload btree */
+		    } else {
+			ABORT_TARGET;
+			HTBTreeAndObject_free(bt);
+			FREE(spilledname);
+			HTChunkFree(chunk);
+			return HT_INTERRUPTED;
+		    }
+		} else if ((char) ic == CR || (char) ic == LF) {	/* Terminator? */
+		    if (chunk->size != 0) {	/* got some text */
+			/* Deal with MultiNet's wrapping of long lines */
+			if (server_type == VMS_SERVER) {
+			    /* Deal with MultiNet's wrapping of long lines - F.M. */
+			    if (data_read_pointer < data_write_pointer &&
+				*(data_read_pointer + 1) == ' ')
+				data_read_pointer++;
+			    else if (data_read_pointer >= data_write_pointer) {
+				status = NETREAD(data_soc, data_buffer,
+						 DATA_BUFFER_SIZE);
+				if (status == HT_INTERRUPTED) {
+				    interrupted_in_next_data_char = 1;
+				    goto AgainForMultiNet;
+				}
+				if (status <= 0) {
+				    ic = EOF;
+				    break;
+				}
+				data_write_pointer = data_buffer + status;
+				data_read_pointer = data_buffer;
+				if (*data_read_pointer == ' ')
+				    data_read_pointer++;
+				else
+				    break;
+			    } else
+				break;
+			} else
+			    break;	/* finish getting one entry */
+		    }
+		} else if (ic == EOF) {
+		    break;	/* End of file */
+		} else {
+		    HTChunkPutc(chunk, UCH(ic));
+		}
+	    }
+	    HTChunkTerminate(chunk);
+
+	    BytesReceived += chunk->size;
+	    if (BytesReceived > BytesReported + 1024) {
+#ifdef _WINDOWS
+		sprintf(NumBytes, gettext("Transferred %d bytes (%5d)"),
+			BytesReceived, ws_read_per_sec);
+#else
+		sprintf(NumBytes, TRANSFERRED_X_BYTES, BytesReceived);
+#endif
+		HTProgress(NumBytes);
+		BytesReported = BytesReceived;
+	    }
+
+	    if (ic == EOF && chunk->size == 1)
+		/* 1 means empty: includes terminating 0 */
+		break;
+	    CTRACE((tfp, "HTFTP: Line in %s is %s\n",
+		    lastpath, chunk->data));
+
+	    entry_info = parse_dir_entry(chunk->data, &first, &spilledname);
+	    if (entry_info->display) {
+		FREE(spilledname);
+		CTRACE((tfp, "Adding file to BTree: %s\n",
+			entry_info->filename));
+		HTBTree_add(bt, entry_info);
+	    } else {
+		free_entryinfo_struct_contents(entry_info);
+		FREE(entry_info);
+	    }
+
+	}			/* next entry */
+
+      unload_btree:
+
+	HTChunkFree(chunk);
+	FREE(spilledname);
+
+	/* print out the handy help message if it exists :) */
+	if (help_message_cache_non_empty()) {
+	    START(HTML_PRE);
+	    START(HTML_HR);
+	    PUTC('\n');
+	    PUTS(help_message_cache_contents());
+	    init_help_message_cache();	/* to free memory */
+	    START(HTML_HR);
+	    PUTC('\n');
+	} else {
+	    START(HTML_PRE);
+	    PUTC('\n');
+	}
+
+	/* Run through tree printing out in order
+	 */
+	{
+#ifndef LONG_LIST
+#ifdef SH_EX			/* 1997/10/18 (Sat) 14:14:28 */
+	    char *p, name_buff[256];
+	    int name_len, dot_len;
+
+#define	FNAME_WIDTH	30
+#define	FILE_GAP	1
+
+#endif
+	    int i;
+#endif
+	    HTBTElement *ele;
+
+	    for (ele = HTBTree_next(bt, NULL);
+		 ele != NULL;
+		 ele = HTBTree_next(bt, ele)) {
+		entry_info = (EntryInfo *) HTBTree_object(ele);
+
+#ifdef LONG_LIST
+		LYListFmtParse(ftp_format,
+			       entry_info,
+			       target,
+			       lastpath);
+#else
+		if (entry_info->date) {
+		    PUTS(entry_info->date);
+		    PUTS("  ");
+		} else {
+		    PUTS("     * ");
+		}
+
+		if (entry_info->type) {
+		    for (i = 0; entry_info->type[i] != '\0' && i < 16; i++)
+			PUTC(entry_info->type[i]);
+		    for (; i < 17; i++)
+			PUTC(' ');
+		}
+		/* start the anchor */
+		HTDirEntry(target, lastpath, entry_info->filename);
+#ifdef SH_EX			/* 1997/10/18 (Sat) 16:00 */
+		name_len = strlen(entry_info->filename);
+
+		sprintf(name_buff, "%-*s", FNAME_WIDTH, entry_info->filename);
+
+		if (name_len < FNAME_WIDTH) {
+		    dot_len = FNAME_WIDTH - FILE_GAP - name_len;
+		    if (dot_len > 0) {
+			p = name_buff + name_len + 1;
+			while (dot_len-- > 0)
+			    *p++ = '.';
+		    }
+		} else {
+		    name_buff[FNAME_WIDTH] = '\0';
+		}
+
+		PUTS(name_buff);
+#else
+		PUTS(entry_info->filename);
+#endif
+		END(HTML_A);
+
+		if (entry_info->size) {
+#ifdef SH_EX			/* 1998/02/02 (Mon) 16:34:52 */
+		    if (entry_info->size < 1024)
+			sprintf(string_buffer, "%6ld bytes",
+				entry_info->size);
+		    else
+			sprintf(string_buffer, "%6ld Kb",
+				entry_info->size / 1024);
+#else
+		    if (entry_info->size < 1024)
+			sprintf(string_buffer, "  %lu bytes",
+				(unsigned long) entry_info->size);
+		    else
+			sprintf(string_buffer, "  %luKb",
+				(unsigned long) entry_info->size / 1024);
+#endif
+		    PUTS(string_buffer);
+		} else if (entry_info->linkname != 0) {
+		    PUTS(" -> ");
+		    PUTS(entry_info->linkname);
+		}
+
+		PUTC('\n');	/* end of this entry */
+#endif
+
+		free_entryinfo_struct_contents(entry_info);
+	    }
+	}
+	END(HTML_PRE);
+	END(HTML_BODY);
+	FREE_TARGET;
+	HTBTreeAndObject_free(bt);
+    }
+
+    FREE(lastpath);
+
+    if (WasInterrupted || data_soc != -1) {	/* should always be true */
+	/*
+	 * Without closing the data socket first, the response(NULL) later may
+	 * hang.  Some servers expect the client to fin/ack the close of the
+	 * data connection before proceeding with the conversation on the
+	 * control connection.  - kw
+	 */
+	CTRACE((tfp, "HTFTP: Closing data socket %d\n", data_soc));
+	status = NETCLOSE(data_soc);
+	if (status == -1)
+	    HTInetStatus("close");	/* Comment only */
+	data_soc = -1;
+    }
+
+    if (WasInterrupted || HTCheckForInterrupt()) {
+	_HTProgress(TRANSFER_INTERRUPTED);
+    }
+    return HT_LOADED;
+}
+
+/*
+ * Setup an FTP connection.
+ */
+static int setup_connection(const char *name,
+			    HTParentAnchor *anchor)
+{
+    int retry;			/* How many times tried? */
+    int status = HT_NO_CONNECTION;
+
+    CTRACE((tfp, "setup_connection(%s)\n", name));
+
+    /* set use_list to NOT since we don't know what kind of server
+     * this is yet.  And set the type to GENERIC
+     */
+    use_list = FALSE;
+    server_type = GENERIC_SERVER;
+    Broken_RETR = FALSE;
+
+#ifdef INET6
+    Broken_EPSV = FALSE;
+#endif
+
+    for (retry = 0; retry < 2; retry++) {	/* For timed out/broken connections */
+	status = get_connection(name, anchor);
+	if (status < 0) {
+	    break;
+	}
+
+	if (!ftp_local_passive) {
+	    status = get_listen_socket();
+	    if (status < 0) {
+		NETCLOSE(control->socket);
+		control->socket = -1;
+#ifdef INET6
+		if (have_socket)
+		    (void) close_master_socket();
+#else
+		close_master_socket();
+#endif /* INET6 */
+		/* HT_INTERRUPTED would fall through, if we could interrupt
+		   somehow in the middle of it, which we currently can't. */
+		break;
+	    }
+#ifdef REPEAT_PORT
+	    /*  Inform the server of the port number we will listen on
+	     */
+	    status = response(port_command);
+	    FREE(port_command);
+	    if (status == HT_INTERRUPTED) {
+		CTRACE((tfp, "HTFTP: Interrupted in response (port_command)\n"));
+		_HTProgress(CONNECTION_INTERRUPTED);
+		NETCLOSE(control->socket);
+		control->socket = -1;
+		close_master_socket();
+		status = HT_INTERRUPTED;
+		break;
+	    }
+	    if (status != 2) {	/* Could have timed out */
+		if (status < 0)
+		    continue;	/* try again - net error */
+		status = -status;	/* bad reply */
+		break;
+	    }
+	    CTRACE((tfp, "HTFTP: Port defined.\n"));
+#endif /* REPEAT_PORT */
+	} else {		/* Tell the server to be passive */
+	    char *command = NULL;
+	    const char *p = "?";
+	    int h0, h1, h2, h3, p0, p1;		/* Parts of reply */
+
+#ifdef INET6
+	    char dst[LINE_LENGTH + 1];
+#endif
+
+	    data_soc = status;
+
+#ifdef INET6
+	    /* see RFC 2428 */
+	    if (Broken_EPSV)
+		status = 1;
+	    else
+		status = send_cmd_1(p = "EPSV");
+	    if (status < 0)	/* retry or Bad return */
+		continue;
+	    else if (status != 2) {
+		status = send_cmd_1(p = "PASV");
+		if (status < 0) {	/* retry or Bad return */
+		    continue;
+		} else if (status != 2) {
+		    status = -status;	/* bad reply */
+		    break;
+		}
+	    }
+
+	    if (strcmp(p, "PASV") == 0) {
+		for (p = response_text; *p && *p != ','; p++) {
+		    ;		/* null body */
+		}
+
+		while (--p > response_text && '0' <= *p && *p <= '9') {
+		    ;		/* null body */
+		}
+		status = sscanf(p + 1, "%d,%d,%d,%d,%d,%d",
+				&h0, &h1, &h2, &h3, &p0, &p1);
+		if (status < 4) {
+		    fprintf(tfp, "HTFTP: PASV reply has no inet address!\n");
+		    status = HT_NO_CONNECTION;
+		    break;
+		}
+		passive_port = (PortNumber) ((p0 << 8) + p1);
+		sprintf(dst, "%d.%d.%d.%d", h0, h1, h2, h3);
+	    } else if (strcmp(p, "EPSV") == 0) {
+		char c0, c1, c2, c3;
+		LY_SOCKADDR ss;
+		LY_SOCKLEN sslen;
+
+		/*
+		 * EPSV bla (|||port|)
+		 */
+		for (p = response_text; *p && !isspace(UCH(*p)); p++) {
+		    ;		/* null body */
+		}
+		for ( /*nothing */ ;
+		     *p && *p != '(';
+		     p++) {	/*) */
+		    ;		/* null body */
+		}
+		status = sscanf(p, "(%c%c%c%d%c)", &c0, &c1, &c2, &p0, &c3);
+		if (status != 5) {
+		    fprintf(tfp, "HTFTP: EPSV reply has invalid format!\n");
+		    status = HT_NO_CONNECTION;
+		    break;
+		}
+		passive_port = (PortNumber) p0;
+
+		sslen = (LY_SOCKLEN) sizeof(ss);
+		if (getpeername(control->socket, SOCKADDR_OF(ss), &sslen) < 0) {
+		    fprintf(tfp, "HTFTP: getpeername(control) failed\n");
+		    status = HT_NO_CONNECTION;
+		    break;
+		}
+		if (getnameinfo(SOCKADDR_OF(ss),
+				sslen,
+				dst,
+				(socklen_t) sizeof(dst),
+				NULL, 0, NI_NUMERICHOST)) {
+		    fprintf(tfp, "HTFTP: getnameinfo failed\n");
+		    status = HT_NO_CONNECTION;
+		    break;
+		}
+	    }
+#else
+	    status = send_cmd_1("PASV");
+	    if (status != 2) {
+		if (status < 0)
+		    continue;	/* retry or Bad return */
+		status = -status;	/* bad reply */
+		break;
+	    }
+	    for (p = response_text; *p && *p != ','; p++) {
+		;		/* null body */
+	    }
+
+	    while (--p > response_text && '0' <= *p && *p <= '9') {
+		;		/* null body */
+	    }
+
+	    status = sscanf(p + 1, "%d,%d,%d,%d,%d,%d",
+			    &h0, &h1, &h2, &h3, &p0, &p1);
+	    if (status < 4) {
+		fprintf(tfp, "HTFTP: PASV reply has no inet address!\n");
+		status = HT_NO_CONNECTION;
+		break;
+	    }
+	    passive_port = (PortNumber) ((p0 << 8) + p1);
+#endif /* INET6 */
+	    CTRACE((tfp, "HTFTP: Server is listening on port %d\n",
+		    passive_port));
+
+	    /* Open connection for data:  */
+
+#ifdef INET6
+	    HTSprintf0(&command, "%s//%s:%d/", STR_FTP_URL, dst, passive_port);
+#else
+	    HTSprintf0(&command, "%s//%d.%d.%d.%d:%d/",
+		       STR_FTP_URL, h0, h1, h2, h3, passive_port);
+#endif
+	    status = HTDoConnect(command, "FTP data", passive_port, &data_soc);
+	    FREE(command);
+
+	    if (status < 0) {
+		(void) HTInetStatus(gettext("connect for data"));
+		NETCLOSE(data_soc);
+		break;
+	    }
+
+	    CTRACE((tfp, "FTP data connected, socket %d\n", data_soc));
+	}
+	status = 0;
+	break;			/* No more retries */
+
+    }				/* for retries */
+    CTRACE((tfp, "setup_connection returns %d\n", status));
+    return status;
+}
+
+/*	Retrieve File from Server
+ *	-------------------------
+ *
+ * On entry,
+ *	name		WWW address of a file: document, including hostname
+ * On exit,
+ *	returns		Socket number for file if good.
+ *			<0 if bad.
+ */
+int HTFTPLoad(const char *name,
+	      HTParentAnchor *anchor,
+	      HTFormat format_out,
+	      HTStream *sink)
+{
+    BOOL isDirectory = NO;
+    HTAtom *encoding = NULL;
+    int status, final_status;
+    int outstanding = 1;	/* outstanding control connection responses
+
+				   that we are willing to wait for, if we
+				   get to the point of reading data - kw */
+    HTFormat format;
+
+    CTRACE((tfp, "HTFTPLoad(%s) %s connection\n",
+	    name,
+	    (ftp_local_passive
+	     ? "passive"
+	     : "normal")));
+
+    HTReadProgress((off_t) 0, (off_t) 0);
+
+    status = setup_connection(name, anchor);
+    if (status < 0)
+	return status;		/* Failed with this code */
+
+    /*  Ask for the file:
+     */
+    {
+	char *filename = HTParse(name, "", PARSE_PATH + PARSE_PUNCTUATION);
+	char *fname = filename;	/* Save for subsequent free() */
+	char *vmsname = NULL;
+	BOOL binary;
+	const char *type = NULL;
+	char *types = NULL;
+	char *cp;
+
+	if (server_type == CMS_SERVER) {
+	    /* If the unescaped path has a %2f, reject it as illegal. - FM */
+	    if (((cp = strstr(filename, "%2")) != NULL) &&
+		TOUPPER(cp[2]) == 'F') {
+		FREE(fname);
+		init_help_message_cache();	/* to free memory */
+		NETCLOSE(control->socket);
+		control->socket = -1;
+		CTRACE((tfp,
+			"HTFTP: Rejecting path due to illegal escaped slash.\n"));
+		return -1;
+	    }
+	}
+
+	if (!*filename) {
+	    StrAllocCopy(filename, "/");
+	    type = "D";
+	} else if ((type = types = strrchr(filename, ';')) != NULL) {
+	    /*
+	     * Check and trim the type= parameter.  - FM
+	     */
+	    if (!strncasecomp((type + 1), "type=", 5)) {
+		switch (TOUPPER(*(type + 6))) {
+		case 'D':
+		    *types = '\0';
+		    type = "D";
+		    break;
+		case 'A':
+		    *types = '\0';
+		    type = "A";
+		    break;
+		case 'I':
+		    *types = '\0';
+		    type = "I";
+		    break;
+		default:
+		    type = "";
+		    break;
+		}
+		if (!*filename) {
+		    *filename = '/';
+		    *(filename + 1) = '\0';
+		}
+	    }
+	    if (*type != '\0') {
+		CTRACE((tfp, "HTFTP: type=%s\n", type));
+	    }
+	}
+	HTUnEscape(filename);
+	CTRACE((tfp, "HTFTP: UnEscaped %s\n", filename));
+	if (filename[1] == '~') {
+	    /*
+	     * Check if translation of HOME as tilde is supported,
+	     * and adjust filename if so. - FM
+	     */
+	    char *cp2 = NULL;
+	    char *fn = NULL;
+
+	    if ((cp2 = StrChr((filename + 1), '/')) != NULL) {
+		*cp2 = '\0';
+	    }
+	    status = send_cmd_1("PWD");
+	    if (status == 2 && response_text[5] == '/') {
+		status = send_cwd(filename + 1);
+		if (status == 2) {
+		    StrAllocCopy(fn, (filename + 1));
+		    if (cp2) {
+			*cp2 = '/';
+			if (fn[strlen(fn) - 1] != '/') {
+			    StrAllocCat(fn, cp2);
+			} else {
+			    StrAllocCat(fn, (cp2 + 1));
+			}
+			cp2 = NULL;
+		    }
+		    FREE(fname);
+		    fname = filename = fn;
+		}
+	    }
+	    if (cp2) {
+		*cp2 = '/';
+	    }
+	}
+	if (strlen(filename) > 3) {
+	    char *cp2;
+
+	    if (((cp2 = strrchr(filename, '.')) != NULL &&
+		 0 == strncasecomp(cp2, ".me", 3)) &&
+		(cp2[3] == '\0' || cp2[3] == ';')) {
+		/*
+		 * Don't treat this as application/x-Troff-me if it's a Unix
+		 * server but has the string "read.me", or if it's not a Unix
+		 * server.  - FM
+		 */
+		if ((server_type != UNIX_SERVER) ||
+		    (cp2 > (filename + 3) &&
+		     0 == strncasecomp((cp2 - 4), "read.me", 7))) {
+		    *cp2 = '\0';
+		    format = HTFileFormat(filename, &encoding, NULL);
+		    *cp2 = '.';
+		} else {
+		    format = HTFileFormat(filename, &encoding, NULL);
+		}
+	    } else {
+		format = HTFileFormat(filename, &encoding, NULL);
+	    }
+	} else {
+	    format = HTFileFormat(filename, &encoding, NULL);
+	}
+	format = HTCharsetFormat(format, anchor, -1);
+	binary = (BOOL) (encoding != WWW_ENC_8BIT &&
+			 encoding != WWW_ENC_7BIT);
+	if (!binary &&
+	/*
+	 * Force binary if we're in source, download or dump mode and this is
+	 * not a VM/CMS server, so we don't get CRLF instead of LF (or CR) for
+	 * newlines in text files.  Can't do this for VM/CMS or we'll get raw
+	 * EBCDIC.  - FM
+	 */
+	    (format_out == WWW_SOURCE ||
+	     format_out == WWW_DOWNLOAD ||
+	     format_out == WWW_DUMP) &&
+	    (server_type != CMS_SERVER))
+	    binary = TRUE;
+	if (!binary && type && *type == 'I') {
+	    /*
+	     * Force binary if we had ;type=I - FM
+	     */
+	    binary = TRUE;
+	} else if (binary && type && *type == 'A') {
+	    /*
+	     * Force ASCII if we had ;type=A - FM
+	     */
+	    binary = FALSE;
+	}
+	if (binary != control->is_binary) {
+	    /*
+	     * Act on our setting if not already set.  - FM
+	     */
+	    const char *mode = binary ? "I" : "A";
+
+	    status = send_cmd_2("TYPE", mode);
+	    if (status != 2) {
+		init_help_message_cache();	/* to free memory */
+		return ((status < 0) ? status : -status);
+	    }
+	    control->is_binary = binary;
+	}
+	switch (server_type) {
+	    /*
+	     * Handle what for Lynx are special case servers, e.g., for which
+	     * we respect RFC 1738, or which have known conflicts in suffix
+	     * mappings.  - FM
+	     */
+	case VMS_SERVER:
+	    {
+		char *cp1, *cp2;
+		BOOL included_device = FALSE;
+		BOOL found_tilde = FALSE;
+
+		/* Accept only Unix-style filename */
+		if (StrChr(filename, ':') != NULL ||
+		    StrChr(filename, '[') != NULL) {
+		    FREE(fname);
+		    init_help_message_cache();	/* to free memory */
+		    NETCLOSE(control->socket);
+		    control->socket = -1;
+		    CTRACE((tfp,
+			    "HTFTP: Rejecting path due to non-Unix-style syntax.\n"));
+		    return -1;
+		}
+		/* Handle any unescaped "/%2F" path */
+		if (!StrNCmp(filename, "//", 2)) {
+		    int i;
+
+		    included_device = TRUE;
+		    for (i = 0; filename[(i + 1)]; i++)
+			filename[i] = filename[(i + 1)];
+		    filename[i] = '\0';
+		    CTRACE((tfp, "HTFTP: Trimmed '%s'\n", filename));
+		    cp = HTVMS_name("", filename);
+		    CTRACE((tfp, "HTFTP: VMSized '%s'\n", cp));
+		    if ((cp1 = strrchr(cp, ']')) != NULL) {
+			strcpy(filename, ++cp1);
+			CTRACE((tfp, "HTFTP: Filename '%s'\n", filename));
+			*cp1 = '\0';
+			status = send_cwd(cp);
+			if (status != 2) {
+			    char *dotslash = 0;
+
+			    if ((cp1 = StrChr(cp, '[')) != NULL) {
+				*cp1++ = '\0';
+				status = send_cwd(cp);
+				if (status != 2) {
+				    FREE(fname);
+				    init_help_message_cache();	/* to free memory */
+				    NETCLOSE(control->socket);
+				    control->socket = -1;
+				    return ((status < 0) ? status : -status);
+				}
+				HTSprintf0(&dotslash, "[.%s", cp1);
+				status = send_cwd(dotslash);
+				FREE(dotslash);
+				if (status != 2) {
+				    FREE(fname);
+				    init_help_message_cache();	/* to free memory */
+				    NETCLOSE(control->socket);
+				    control->socket = -1;
+				    return ((status < 0) ? status : -status);
+				}
+			    } else {
+				FREE(fname);
+				init_help_message_cache();	/* to free memory */
+				NETCLOSE(control->socket);
+				control->socket = -1;
+				return ((status < 0) ? status : -status);
+			    }
+			}
+		    } else if ((cp1 = StrChr(cp, ':')) != NULL &&
+			       StrChr(cp, '[') == NULL &&
+			       StrChr(cp, ']') == NULL) {
+			cp1++;
+			if (*cp1 != '\0') {
+			    int cplen = (int) (cp1 - cp);
+
+			    strcpy(filename, cp1);
+			    CTRACE((tfp, "HTFTP: Filename '%s'\n", filename));
+			    HTSprintf0(&vmsname, "%.*s[%s]", cplen, cp, filename);
+			    status = send_cwd(vmsname);
+			    if (status != 2) {
+				HTSprintf(&vmsname, "%.*s[000000]", cplen, cp);
+				status = send_cwd(vmsname);
+				if (status != 2) {
+				    HTSprintf(&vmsname, "%.*s", cplen, cp);
+				    status = send_cwd(vmsname);
+				    if (status != 2) {
+					FREE(fname);
+					init_help_message_cache();
+					NETCLOSE(control->socket);
+					control->socket = -1;
+					return ((status < 0) ? status : -status);
+				    }
+				}
+			    } else {
+				HTSprintf0(&vmsname, "000000");
+				filename = vmsname;
+			    }
+			}
+		    } else if (0 == strcmp(cp, (filename + 1))) {
+			status = send_cwd(cp);
+			if (status != 2) {
+			    HTSprintf0(&vmsname, "%s:", cp);
+			    status = send_cwd(vmsname);
+			    if (status != 2) {
+				FREE(fname);
+				init_help_message_cache();	/* to free memory */
+				NETCLOSE(control->socket);
+				control->socket = -1;
+				return ((status < 0) ? status : -status);
+			    }
+			}
+			HTSprintf0(&vmsname, "000000");
+			filename = vmsname;
+		    }
+		}
+		/* Trim trailing slash if filename is not the top directory */
+		if (strlen(filename) > 1 && filename[strlen(filename) - 1] == '/')
+		    filename[strlen(filename) - 1] = '\0';
+
+#ifdef MAINTAIN_CONNECTION	/* Don't need this if always new connection - F.M. */
+		if (!included_device) {
+		    /* Get the current default VMS device:[directory] */
+		    status = send_cmd_1("PWD");
+		    if (status != 2) {
+			FREE(fname);
+			init_help_message_cache();	/* to free memory */
+			NETCLOSE(control->socket);
+			control->socket = -1;
+			return ((status < 0) ? status : -status);
+		    }
+		    /* Go to the VMS account's top directory */
+		    if ((cp = StrChr(response_text, '[')) != NULL &&
+			(cp1 = strrchr(response_text, ']')) != NULL) {
+			char *tmp = 0;
+			unsigned len = 4;
+
+			StrAllocCopy(tmp, cp);
+			if ((cp2 = StrChr(cp, '.')) != NULL && cp2 < cp1) {
+			    len += (cp2 - cp);
+			} else {
+			    len += (cp1 - cp);
+			}
+			tmp[len] = 0;
+			StrAllocCat(tmp, "]");
+
+			status = send_cwd(tmp);
+			FREE(tmp);
+
+			if (status != 2) {
+			    FREE(fname);
+			    init_help_message_cache();	/* to free memory */
+			    NETCLOSE(control->socket);
+			    control->socket = -1;
+			    return ((status < 0) ? status : -status);
+			}
+		    }
+		}
+#endif /* MAINTAIN_CONNECTION */
+
+		/* If we want the VMS account's top directory, list it now */
+		if (!(strcmp(filename, "/~")) ||
+		    (included_device && 0 == strcmp(filename, "000000")) ||
+		    (strlen(filename) == 1 && *filename == '/')) {
+		    isDirectory = YES;
+		    status = send_cmd_1("LIST");
+		    FREE(fname);
+		    if (status != 1) {
+			/* Action not started */
+			init_help_message_cache();	/* to free memory */
+			NETCLOSE(control->socket);
+			control->socket = -1;
+			return ((status < 0) ? status : -status);
+		    }
+		    /* Big goto! */
+		    goto listen;
+		}
+		/* Otherwise, go to appropriate directory and doctor filename */
+		if (!StrNCmp(filename, "/~", 2)) {
+		    filename += 2;
+		    found_tilde = TRUE;
+		}
+		CTRACE((tfp, "check '%s' to translate x/y/ to [.x.y]\n", filename));
+		if (!included_device &&
+		    (cp = StrChr(filename, '/')) != NULL &&
+		    (cp1 = strrchr(cp, '/')) != NULL &&
+		    (cp1 - cp) > 1) {
+		    char *tmp = 0;
+
+		    HTSprintf0(&tmp, "[.%.*s]", (int) (cp1 - cp - 1), cp + 1);
+
+		    CTRACE((tfp, "change path '%s'\n", tmp));
+		    while ((cp2 = strrchr(tmp, '/')) != NULL)
+			*cp2 = '.';
+		    CTRACE((tfp, "...to  path '%s'\n", tmp));
+
+		    status = send_cwd(tmp);
+		    FREE(tmp);
+
+		    if (status != 2) {
+			FREE(fname);
+			init_help_message_cache();	/* to free memory */
+			NETCLOSE(control->socket);
+			control->socket = -1;
+			return ((status < 0) ? status : -status);
+		    }
+		    filename = cp1 + 1;
+		} else {
+		    if (!included_device && !found_tilde) {
+			filename += 1;
+		    }
+		}
+		break;
+	    }
+	case CMS_SERVER:
+	    {
+		/*
+		 * If we want the CMS account's top directory, or a base SFS or
+		 * anonymous directory path (i.e., without a slash), list it
+		 * now.  FM
+		 */
+		if ((strlen(filename) == 1 && *filename == '/') ||
+		    ((0 == strncasecomp((filename + 1), "vmsysu:", 7)) &&
+		     (cp = StrChr((filename + 1), '.')) != NULL &&
+		     StrChr(cp, '/') == NULL) ||
+		    (0 == strncasecomp(filename + 1, "anonymou.", 9) &&
+		     StrChr(filename + 1, '/') == NULL)) {
+		    if (filename[1] != '\0') {
+			status = send_cwd(filename + 1);
+			if (status != 2) {
+			    /* Action not started */
+			    init_help_message_cache();	/* to free memory */
+			    NETCLOSE(control->socket);
+			    control->socket = -1;
+			    return ((status < 0) ? status : -status);
+			}
+		    }
+		    isDirectory = YES;
+		    if (use_list)
+			status = send_cmd_1("LIST");
+		    else
+			status = send_cmd_1("NLST");
+		    FREE(fname);
+		    if (status != 1) {
+			/* Action not started */
+			init_help_message_cache();	/* to free memory */
+			NETCLOSE(control->socket);
+			control->socket = -1;
+			return ((status < 0) ? status : -status);
+		    }
+		    /* Big goto! */
+		    goto listen;
+		}
+		filename++;
+
+		/* Otherwise, go to appropriate directory and adjust filename */
+		while ((cp = StrChr(filename, '/')) != NULL) {
+		    *cp++ = '\0';
+		    status = send_cwd(filename);
+		    if (status == 2) {
+			if (*cp == '\0') {
+			    isDirectory = YES;
+			    if (use_list)
+				status = send_cmd_1("LIST");
+			    else
+				status = send_cmd_1("NLST");
+			    FREE(fname);
+			    if (status != 1) {
+				/* Action not started */
+				init_help_message_cache();	/* to free memory */
+				NETCLOSE(control->socket);
+				control->socket = -1;
+				return ((status < 0) ? status : -status);
+			    }
+			    /* Clear any messages from the login directory */
+			    init_help_message_cache();
+			    /* Big goto! */
+			    goto listen;
+			}
+			filename = cp;
+		    }
+		}
+		break;
+	    }
+	default:
+	    /* Shift for any unescaped "/%2F" path */
+	    if (!StrNCmp(filename, "//", 2))
+		filename++;
+	    break;
+	}
+	/*
+	 * Act on a file or listing request, or try to figure out which we're
+	 * dealing with if we don't know yet.  - FM
+	 */
+	if (!(type) || (type && *type != 'D')) {
+	    /*
+	     * If we are retrieving a file we will (except for CMS) use
+	     * binary mode, which lets us use the size command supported by
+	     * ftp servers which implement RFC 3659.  Knowing the size lets
+	     * us in turn display ETA in the progress message -TD
+	     */
+	    if (control->is_binary) {
+		int code;
+
+		status = send_cmd_2("SIZE", filename);
+		if (status == 2) {
+#if !defined(HAVE_LONG_LONG) && defined(GUESS_PRI_off_t)
+		    long size;
+
+		    if (sscanf(response_text, "%d %ld", &code, &size) == 2) {
+			anchor->content_length = (off_t) size;
+		    }
+#else
+		    off_t size;
+		    if (sscanf(response_text, "%d %" SCN_off_t, &code, &size)
+			== 2) {
+			anchor->content_length = size;
+		    }
+#endif
+		}
+	    }
+	    status = send_cmd_2("RETR", filename);
+	    if (status >= 5) {
+		int check;
+
+		if (Broken_RETR) {
+		    CTRACE((tfp, "{{reconnecting...\n"));
+		    close_connection(control);
+		    check = setup_connection(name, anchor);
+		    CTRACE((tfp, "...done }}reconnecting\n"));
+		    if (check < 0)
+			return check;
+		}
+	    }
+	} else {
+	    status = 5;		/* Failed status set as flag. - FM */
+	}
+	if (status != 1) {	/* Failed : try to CWD to it */
+	    /* Clear any login messages if this isn't the login directory */
+	    if (strcmp(filename, "/"))
+		init_help_message_cache();
+
+	    status = send_cwd(filename);
+	    if (status == 2) {	/* Succeeded : let's NAME LIST it */
+		isDirectory = YES;
+		if (use_list)
+		    status = send_cmd_1("LIST");
+		else
+		    status = send_cmd_1("NLST");
+	    }
+	}
+	FREE(fname);
+	FREE(vmsname);
+	if (status != 1) {
+	    init_help_message_cache();	/* to free memory */
+	    NETCLOSE(control->socket);
+	    control->socket = -1;
+	    if (status < 0)
+		return status;
+	    else
+		return -status;
+	}
+    }
+
+  listen:
+    if (!ftp_local_passive) {
+	/* Wait for the connection */
+	LY_SOCKADDR soc_A;
+	LY_SOCKLEN soc_addrlen = (LY_SOCKLEN) sizeof(soc_A);
+
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Raccept((int) master_socket,
+			     SOCKADDR_OF(soc_A),
+			     &soc_addrlen);
+	else
+#endif /* SOCKS */
+	    status = accept((int) master_socket,
+			    SOCKADDR_OF(soc_A),
+			    &soc_addrlen);
+	if (status < 0) {
+	    init_help_message_cache();	/* to free memory */
+	    return HTInetStatus("accept");
+	}
+	CTRACE((tfp, "TCP: Accepted new socket %d\n", status));
+	data_soc = status;
+    }
+
+    if (isDirectory) {
+	if (server_type == UNIX_SERVER && !unsure_type &&
+	    !strcmp(response_text,
+		    "150 Opening ASCII mode data connection for /bin/dl.\n")) {
+	    CTRACE((tfp, "HTFTP: Treating as \"dls\" server.\n"));
+	    server_type = DLS_SERVER;
+	}
+	final_status = read_directory(anchor, name, format_out, sink);
+	if (final_status > 0) {
+	    if (server_type != CMS_SERVER)
+		if (outstanding-- > 0) {
+		    status = response(NULL);
+		    if (status < 0 ||
+			(status == 2 && !StrNCmp(response_text, "221", 3)))
+			outstanding = 0;
+		}
+	} else {		/* HT_INTERRUPTED */
+	    /* User may have pressed 'z' to give up because no
+	       packets got through, so let's not make them wait
+	       any longer - kw */
+	    outstanding = 0;
+	}
+
+	if (data_soc != -1) {	/* normally done in read_directory */
+	    CTRACE((tfp, "HTFTP: Closing data socket %d\n", data_soc));
+	    status = NETCLOSE(data_soc);
+	    if (status == -1)
+		HTInetStatus("close");	/* Comment only */
+	}
+	status = final_status;
+    } else {
+	int rv;
+	char *FileName = HTParse(name, "", PARSE_PATH + PARSE_PUNCTUATION);
+
+	/* Clear any login messages */
+	init_help_message_cache();
+
+	/* Fake a Content-Encoding for compressed files. - FM */
+	HTUnEscape(FileName);
+	if (!IsUnityEnc(encoding)) {
+	    /*
+	     * We already know from the call to HTFileFormat above that this is
+	     * a compressed file, no need to look at the filename again.  - kw
+	     */
+	    StrAllocCopy(anchor->content_type, format->name);
+	    StrAllocCopy(anchor->content_encoding, HTAtom_name(encoding));
+	    format = HTAtom_for("www/compressed");
+
+	} else {
+	    int rootlen;
+	    CompressFileType cft = HTCompressFileType(FileName, "._-", &rootlen);
+
+	    if (cft != cftNone) {
+		FileName[rootlen] = '\0';
+		format = HTFileFormat(FileName, &encoding, NULL);
+		format = HTCharsetFormat(format, anchor, -1);
+		StrAllocCopy(anchor->content_type, format->name);
+		format = HTAtom_for("www/compressed");
+	    }
+
+	    switch (cft) {
+	    case cftCompress:
+		StrAllocCopy(anchor->content_encoding, "x-compress");
+		break;
+	    case cftGzip:
+		StrAllocCopy(anchor->content_encoding, "x-gzip");
+		break;
+	    case cftDeflate:
+		StrAllocCopy(anchor->content_encoding, "x-deflate");
+		break;
+	    case cftBzip2:
+		StrAllocCopy(anchor->content_encoding, "x-bzip2");
+		break;
+	    case cftBrotli:
+		StrAllocCopy(anchor->content_encoding, "x-brotli");
+		break;
+	    case cftNone:
+		break;
+	    }
+	}
+	FREE(FileName);
+
+	_HTProgress(gettext("Receiving FTP file."));
+	rv = HTParseSocket(format, format_out, anchor, data_soc, sink);
+
+	HTInitInput(control->socket);
+	/* Reset buffering to control connection DD 921208 */
+
+	if (rv < 0) {
+	    if (rv == -2)	/* weird error, don't expect much response */
+		outstanding--;
+	    else if (rv == HT_INTERRUPTED || rv == -1)
+		/* User may have pressed 'z' to give up because no
+		   packets got through, so let's not make them wait
+		   longer - kw */
+		outstanding = 0;
+	    CTRACE((tfp, "HTFTP: Closing data socket %d\n", data_soc));
+	    status = NETCLOSE(data_soc);
+	} else {
+	    status = 2;		/* data_soc already closed in HTCopy - kw */
+	}
+
+	if (status < 0 && rv != HT_INTERRUPTED && rv != -1) {
+	    (void) HTInetStatus("close");	/* Comment only */
+	} else {
+	    if (rv != HT_LOADED && outstanding--) {
+		status = response(NULL);	/* Pick up final reply */
+		if (status != 2 && rv != HT_INTERRUPTED && rv != -1) {
+		    data_soc = -1;	/* invalidate it */
+		    init_help_message_cache();	/* to free memory */
+		    return HTLoadError(sink, 500, response_text);
+		} else if (status == 2 && !StrNCmp(response_text, "221", 3)) {
+		    outstanding = 0;
+		}
+	    }
+	}
+	final_status = HT_LOADED;
+    }
+    while (outstanding-- > 0 &&
+	   (status > 0)) {
+	status = response(NULL);
+	if (status == 2 && !StrNCmp(response_text, "221", 3))
+	    break;
+    }
+    data_soc = -1;		/* invalidate it */
+    CTRACE((tfp, "HTFTPLoad: normal end; "));
+    if (control->socket < 0) {
+	CTRACE((tfp, "control socket is %d\n", control->socket));
+    } else {
+	CTRACE((tfp, "closing control socket %d\n", control->socket));
+	status = NETCLOSE(control->socket);
+	if (status == -1)
+	    HTInetStatus("control connection close");	/* Comment only */
+    }
+    control->socket = -1;
+    init_help_message_cache();	/* to free memory */
+    /* returns HT_LOADED (always for file if we get here) or error */
+    return final_status;
+}				/* open_file_read */
+
+/*
+ *  This function frees any user entered password, so that
+ *  it must be entered again for a future request. - FM
+ */
+void HTClearFTPPassword(void)
+{
+    /*
+     * Need code to check cached documents from non-anonymous ftp accounts and
+     * do something to ensure that they no longer can be accessed without a new
+     * retrieval.  - FM
+     */
+
+    /*
+     * Now free the current user entered password, if any.  - FM
+     */
+    FREE(user_entered_password);
+}
+
+#endif /* ifndef DISABLE_FTP */