Tools/WinSN5.0Ver.iso/NETSCAP.50/WIN1998.ZIP/ns/lib/libnet/mkftp.c

C/C++ Source or Header | 1998-04-08 | 133.8 KB | 4,730 lines

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */
/* state machine to read FTP sites
 *
 * Designed and originally implemented by Lou Montulli '94
 *
 * State machine to implement File Transfer Protocol,
 * all the protocol state machines work basically the same way.
 */

#include "rosetta.h"
#include "mkutils.h"

#define FTP_PORT 21

#define FTP_MODE_UNKNOWN 0
#define FTP_MODE_ASCII   1
#define FTP_MODE_BINARY  2

#include "mkftp.h"
#include "glhist.h"
#include "mkgeturl.h"
#include "mkparse.h"
#include "mktcp.h"
#include "mksort.h"
#include "mkfsort.h"   /* file sorting */
#include "mkformat.h"
#include "mkfile.h"
#include "merrors.h"
#include "shist.h"
#include "ssl.h"
#include "prtime.h"
#include "pwcacapi.h"
#include "secnav.h"

#ifdef XP_OS2 /* DSR072196 */
#include "os2sock.h"
#endif /* XP_OS2 */

#ifdef XP_UNIX
#if !defined(__osf__) && !defined(AIXV3) && !defined(_HPUX_SOURCE) && !defined(__386BSD__) && !defined(__linux) && !defined(SCO_SV)
#include <sys/filio.h>
#endif
#endif /* XP_UNIX */

#include "xp_error.h"
#include "prefapi.h"

/* for XP_GetString() */
#include "xpgetstr.h"
extern int XP_HTML_FTPERROR_NOLOGIN;
extern int XP_HTML_FTPERROR_TRANSFER;
extern int XP_PROGRESS_RECEIVE_FTPDIR;
extern int XP_PROGRESS_RECEIVE_FTPFILE;
extern int XP_PROGRESS_READFILE;
extern int XP_PROGRESS_FILEDONE;
extern int XP_PROMPT_ENTER_PASSWORD;
extern int MK_COULD_NOT_PUT_FILE;
extern int MK_TCP_READ_ERROR;
extern int MK_TCP_WRITE_ERROR;
extern int MK_UNABLE_TO_ACCEPT_SOCKET;
extern int MK_UNABLE_TO_CHANGE_FTP_MODE;
extern int MK_UNABLE_TO_CREATE_SOCKET;
extern int MK_UNABLE_TO_LOCATE_FILE;
extern int MK_UNABLE_TO_OPEN_FILE;
extern int MK_UNABLE_TO_SEND_PORT_COMMAND;
extern int MK_UNABLE_TO_DELETE_DIRECTORY;
extern int MK_COULD_NOT_CREATE_DIRECTORY;
extern int XP_ERRNO_EWOULDBLOCK;
extern int MK_OUT_OF_MEMORY;
extern int MK_DISK_FULL;
extern int XP_COULD_NOT_LOGIN_TO_FTP_SERVER;
extern int XP_ERROR_COULD_NOT_MAKE_CONNECTION_NON_BLOCKING;
extern int XP_POSTING_FILE;
extern int XP_TITLE_DIRECTORY_OF_ETC;
extern int XP_UPTO_HIGHER_LEVEL_DIRECTORY ;


#define PUTSTRING(s)           (*cd->stream->put_block) \
                                 (cd->stream, s, XP_STRLEN(s))
#define PUTBLOCK(b,l)         (*cd->stream->put_block) \
                                (cd->stream, b, l)
#define COMPLETE_STREAM   (*cd->stream->complete) \
                                 (cd->stream)
#define ABORT_STREAM(s)   (*cd->stream->abort) \
                                 (cd->stream, s)


#define FTP_GENERIC_TYPE     0
#define FTP_UNIX_TYPE        1
#define FTP_DCTS_TYPE        2
#define FTP_NCSA_TYPE        3
#define FTP_PETER_LEWIS_TYPE 4
#define FTP_MACHTEN_TYPE     5
#define FTP_CMS_TYPE         6
#define FTP_TCPC_TYPE        7
#define FTP_VMS_TYPE         8
#define FTP_NT_TYPE          9

#define OUTPUT_BUFFER_SIZE 2048

PRIVATE XP_List * connection_list=0;  /* a pointer to a list of open connections */

PRIVATE Bool       net_use_pasv=TRUE;
PRIVATE char *    ftp_last_password=0;
PRIVATE char *    ftp_last_password_host=0;
PRIVATE XP_Bool    net_send_email_address_as_password=FALSE;

#define PC_FTP_PASSWORD_KEY "pass"
#define PC_FTP_MODULE_KEY   "ftp"

typedef struct _FTPConnection {
    char   *hostname;       /* hostname string (may contain :port) */
    PRFileDesc *csock;          /* control socket */
    int     server_type;    /* type of server */
    int     cur_mode;       /* ascii, binary, unknown */
    Bool use_list;       /* use LIST? (or NLST) */
    Bool busy;           /* is the connection in use already? */
    Bool no_pasv;        /* should we NOT use pasv mode since is doesn't work? */
    Bool prev_cache;     /* did this connection come from the cache? */
    Bool no_restart;     /* do we know that restarts don't work? */
} FTPConnection;

/* define the states of the machine
 */
typedef enum _FTPStates {
FTP_WAIT_FOR_RESPONSE,
FTP_CONTROL_CONNECT,
FTP_CONTROL_CONNECT_WAIT,
FTP_SEND_USERNAME,
FTP_SEND_USERNAME_RESPONSE,
FTP_GET_PASSWORD,
FTP_GET_PASSWORD_RESPONSE,
FTP_SEND_PASSWORD,
FTP_SEND_PASSWORD_RESPONSE,
FTP_SEND_ACCT,
FTP_SEND_ACCT_RESPONSE,
FTP_SEND_REST_ZERO,
FTP_SEND_REST_ZERO_RESPONSE,
FTP_SEND_SYST,
FTP_SEND_SYST_RESPONSE,
FTP_SEND_MAC_BIN,
FTP_SEND_MAC_BIN_RESPONSE,
FTP_SEND_PWD,
FTP_SEND_PWD_RESPONSE,
FTP_SEND_PASV,
FTP_SEND_PASV_RESPONSE,
FTP_PASV_DATA_CONNECT,
FTP_PASV_DATA_CONNECT_WAIT,
FTP_FIGURE_OUT_WHAT_TO_DO,
FTP_SEND_DELETE_FILE,
FTP_SEND_DELETE_FILE_RESPONSE,
FTP_SEND_DELETE_DIR,
FTP_SEND_DELETE_DIR_RESPONSE,
FTP_SEND_MKDIR,
FTP_SEND_MKDIR_RESPONSE,
FTP_SEND_PORT,
FTP_SEND_PORT_RESPONSE,
FTP_GET_FILE_TYPE,
FTP_SEND_BIN,
FTP_SEND_BIN_RESPONSE,
FTP_SEND_ASCII,
FTP_SEND_ASCII_RESPONSE,
FTP_GET_FILE_SIZE,
FTP_GET_FILE_SIZE_RESPONSE,
FTP_GET_FILE_MDTM,
FTP_GET_FILE_MDTM_RESPONSE,
FTP_GET_FILE,
FTP_BEGIN_PUT,
FTP_BEGIN_PUT_RESPONSE,
FTP_DO_PUT,
FTP_SEND_REST,
FTP_SEND_REST_RESPONSE,
FTP_SEND_RETR,
FTP_SEND_RETR_RESPONSE,
FTP_SEND_CWD,
FTP_SEND_CWD_RESPONSE,
FTP_SEND_LIST_OR_NLST,
FTP_SEND_LIST_OR_NLST_RESPONSE,
FTP_SETUP_STREAM,
FTP_WAIT_FOR_ACCEPT,
FTP_START_READ_FILE,
FTP_READ_CACHE,
FTP_READ_FILE,
FTP_START_READ_DIRECTORY,
FTP_READ_DIRECTORY,
FTP_PRINT_DIR,
FTP_DONE,
FTP_ERROR_DONE,
FTP_FREE_DATA
} FTPStates;

typedef struct _FTPConData {
    FTPStates     next_state;        /* the next state of the machine */
    Bool          pause_for_read;    /* should we pause (return) for read? */

    NET_StreamClass *stream;         /* the outgoing data stream */

    FTPConnection   *cc;  /* information about the control connection */

    PRFileDesc *dsock;                /* data socket */
    PRFileDesc *listen_sock;          /* socket to listen on */
    Bool    restart;              /* is this a restarted fetch? */
    Bool    use_list;             /* use LIST or NLST */
    Bool    pasv_mode;            /* using pasv mode? */
    Bool    is_directory;         /* is the url a directory? */
    Bool    retr_already_failed;  /* did RETR fail? */
    Bool    store_password;          /* cache password? */
    char   *data_buf;             /* unprocessed data from the socket */
    int32   data_buf_size;        /* size of the unprocesed data */

    Bool use_default_path;        /* set if we should use PWD to figure out
                                   * current path and use that
                                   */

    /* used by response */
    FTPStates   next_state_after_response;  /* the next state after
                                             * full response recieved */
    int         response_code;              /* code returned in response */
    char       *return_msg;                 /* message from response */
    int         cont_response;              /* a continuation code */

    char   *data_con_address;     /* address and port for PASV data connection*/
    char   *filename;             /* name of the file we are getting */
    char   *file_to_post;         /* local filename to put */
    XP_File file_to_post_fp;      /* filepointer */
    char   *post_file_to;         /* If non-NULL, specifies the destination of
                                     the source file, file_to_post.  If NULL,
                                     generate the destination name automatically
                                     from file_to_post. */
    int32   total_size_of_files_to_post;   /* total bytes */
    char   *path;                 /* path as returned by MKParse */
    int     type;                 /* a type indicator for the file */
    char   *username;             /* the username if not anonymous */
    char   *password;             /* the password if not anonymous */

    char   *cwd_message_buffer;   /* used to print out server help messages */
    char   *login_message_buffer; /* used to print out server help messages */

    char   *output_buffer;          /* buffer before sending to PUTSTRING */

    SortStruct *sort_base;        /* base pointer to Qsorting list */

    Bool destroy_graph_progress;  /* do we need to destroy graph progress? */
    Bool destroy_file_upload_progress_dialog;  /* do we need to destroy the dialog? */
    Bool calling_netlib_all_the_time;  /* is SetCallNetlibAllTheTime set? */
    int32   original_content_length; /* the content length at the time of
                                      * calling graph progress
                                      */

    TCP_ConData *tcp_con_data;     /* Data pointer for tcp connect
                                    * state machine */

    int32   buff_size;             /* used by ftp_send_file */
    int32   amt_of_buff_wrt;       /* amount of data already written
                                    * used by ftp_send_file()
                                    */
    void   *write_post_data_data;
    XP_File partial_cache_fp;      /* pointer to partial cache file */
} FTPConData;

/* forward decls */
static const char *pref_email_as_ftp_password = "security.email_as_ftp_password";
PRIVATE int32 net_ProcessFTP(ActiveEntry * ce);

/* function prototypes
 */
PRIVATE NET_FileEntryInfo * net_parse_dir_entry (char *entry, int server_type);

/* call this to enable/disable FTP PASV mode.
 * Note: PASV mode is on by default
 */
PUBLIC void
NET_UsePASV(Bool do_it)
{
    net_use_pasv = do_it;
}

/* callback routine invoked by prefapi when the pref value changes */
/* fix Mac missing prototype warnings */
MODULE_PRIVATE int PR_CALLBACK
net_ftp_pref_changed(const char * newpref, void * data);

MODULE_PRIVATE int PR_CALLBACK
net_ftp_pref_changed(const char * newpref, void * data)
{
    PREF_GetBoolPref(pref_email_as_ftp_password, &net_send_email_address_as_password);
    return PREF_NOERROR;
}

PRIVATE XP_Bool
net_get_send_email_address_as_password(void)
{
#ifdef XP_WIN
    static XP_Bool    net_read_FTP_password_pref = FALSE;

    if (!net_read_FTP_password_pref) {
        PREF_GetBoolPref(pref_email_as_ftp_password, &net_send_email_address_as_password);
        PREF_RegisterCallback(pref_email_as_ftp_password, net_ftp_pref_changed, NULL);
        net_read_FTP_password_pref = TRUE;
    }
#endif

    return net_send_email_address_as_password;
}

#if defined(XP_MAC) || defined(XP_UNIX)
/* call this with TRUE to enable the sending of the email
 * address as the default user "anonymous" password.
 * The default is OFF.
 */
PUBLIC void
NET_SendEmailAddressAsFTPPassword(Bool do_it)
{
    net_send_email_address_as_password = (XP_Bool)do_it;
}
#endif

PRIVATE NET_StreamClass *
net_ftp_make_stream(FO_Present_Types format_out,
                    URL_Struct *URL_s,
                    MWContext *window_id)
{
    MWContext *stream_context;

#ifdef MOZILLA_CLIENT
    /* if the context can't handle HTML then we
     * need to generate an HTML dialog to handle
     * the message
     */
    if(URL_s->files_to_post && EDT_IS_EDITOR(window_id))
      {
        Chrome chrome_struct;
        XP_MEMSET(&chrome_struct, 0, sizeof(Chrome));
        chrome_struct.is_modal = TRUE;
        chrome_struct.allow_close = TRUE;
        chrome_struct.allow_resize = TRUE;
        chrome_struct.show_scrollbar = TRUE;
        chrome_struct.w_hint = 400;
        chrome_struct.h_hint = 300;
#ifdef XP_MAC
        /* on Mac, topmost windows are floating windows not dialogs */
        chrome_struct.topmost = FALSE;
        /* disable commands to change to minimal menu bar; */
        /* avoids confusion about which commands are present */
        chrome_struct.disable_commands = TRUE;
#else
        chrome_struct.topmost = TRUE;
#endif

        stream_context = FE_MakeNewWindow(window_id,
        NULL,
        NULL,
        &chrome_struct);
        if(!stream_context)
            return (NULL);
      }
    else
#endif /* MOZILLA_CLIENT */
      {
        stream_context = window_id;
      }

    return(NET_StreamBuilder(format_out, URL_s, stream_context));

}

PRIVATE int
net_ftp_show_error(ActiveEntry *ce, char *line)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    /* show the error
     */
    StrAllocCopy(ce->URL_s->content_type, TEXT_HTML);
    ce->URL_s->expires = 1; /* immediate expire date */
    cd->stream = net_ftp_make_stream(ce->format_out, ce->URL_s, ce->window_id);

    if(cd->stream)
      {
        XP_STRCPY(cd->output_buffer, XP_GetString(XP_HTML_FTPERROR_TRANSFER));
        if(ce->status > -1)
            ce->status = PUTSTRING(cd->output_buffer);
        if(line && ce->status > -1)
            ce->status = PUTSTRING(cd->return_msg);
        XP_STRCPY(cd->output_buffer, "</PRE>");
        if(ce->status > -1)
            ce->status = PUTSTRING(cd->output_buffer);
      }

    cd->next_state = FTP_ERROR_DONE;
    return MK_INTERRUPTED;
}

/* get a reply from the server
 */
PRIVATE int
net_ftp_response (ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;
    int result_code;        /* numerical result code from server */
    int status;
    char cont_char;
    char * line;

    status = NET_BufferedReadLine(cd->cc->csock, &line, &cd->data_buf,
                        &cd->data_buf_size, &cd->pause_for_read);

    if(status == 0)
      {
        /* this shouldn't really happen, but...
         */
         cd->next_state = cd->next_state_after_response;
         cd->pause_for_read = FALSE; /* don't pause */
        return(0);
      }
    else if(status < 0)
      {
        int rv = PR_GetError();

        if (rv == PR_WOULD_BLOCK_ERROR)
          {
            cd->pause_for_read = TRUE;
            return(0);
          }

        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_TCP_READ_ERROR, rv);

        /* return TCP error
         */
        return MK_TCP_READ_ERROR;
      }
    else if(!line)
      {
         return status; /* wait for line */
      }

    TRACEMSG(("    Rx: %s", line));

    /* Login messages or CWD messages
     * Their so handy, those help messages are :)
     */
    if(cd->cc->server_type == FTP_UNIX_TYPE && !XP_STRNCMP(line, "250-",4))
      {
        StrAllocCat(cd->cwd_message_buffer, line+4);
        StrAllocCat(cd->cwd_message_buffer, "\n");  /* nasty */
      }
    else if(!XP_STRNCMP(line,"230-",4) || !XP_STRNCMP(line,"220-",4))
      {
        StrAllocCat(cd->login_message_buffer, line+4);
        StrAllocCat(cd->login_message_buffer, "\n");  /* nasty */
      }
    else if(cd->cont_response == 230)
      {
         /* this does the same thing as the one directly above it
         * but it checks for 230 response code instead
           * this is to fix buggy ftp servers that don't follow specs
         */
        if(XP_STRNCMP(line, "230", 3))
          {
            /* make sure it's not  "230 Guest login ok...
             */
            StrAllocCat(cd->login_message_buffer, line);
            StrAllocCat(cd->login_message_buffer, "\n");  /* nasty */
          }
      }

     result_code = 0;          /* defualts */
     cont_char = ' ';  /* defualts */
     sscanf(line, "%d%c", &result_code, &cont_char);

     if(cd->cont_response == -1)
       {
         if (cont_char == '-')  /* start continuation */
             cd->cont_response = result_code;

         StrAllocCopy(cd->return_msg, line+4);
       }
     else
       {    /* continuing */
           if (cd->cont_response == result_code && cont_char == ' ')
             cd->cont_response = -1;    /* ended */

         StrAllocCat(cd->return_msg, "\n");
         if(XP_STRLEN(line) > 3)
           {
             if(isdigit(line[0]))
                 StrAllocCat(cd->return_msg, line+4);
             else
                 StrAllocCat(cd->return_msg, line);
           }
         else
           {
             StrAllocCat(cd->return_msg, line);
           }
       }

     if(cd->cont_response == -1)  /* all done with this response? */
       {
          cd->next_state = cd->next_state_after_response;
          cd->pause_for_read = FALSE; /* don't pause */
       }
     if(result_code == 551)
       {
         return net_ftp_show_error(ce, line + 4);
       }

    cd->response_code = result_code/100;

    return(1);  /* everything ok */
}

PRIVATE int
net_send_username(FTPConData * cd)
{

    /* look for the word UNIX in the hello message
     * if it is there assume a unix server that can
     * use the LIST command
     */
    if(cd->return_msg && strcasestr(cd->return_msg, "UNIX"))
      {
        cd->cc->server_type = FTP_UNIX_TYPE;
        cd->cc->use_list = TRUE;
      }

    if (cd->username)
      {
        PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "USER %.256s%c%c", cd->username, CR, LF);
      }
    else
      {
        PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "USER anonymous%c%c", CR, LF);
      }

    TRACEMSG(("FTP Rx: %.256s", cd->output_buffer));

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_USERNAME_RESPONSE;
    cd->pause_for_read = TRUE;

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_username_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if (cd->response_code == 3)  /* Send password */
      {
        if(!cd->password)
            cd->next_state = FTP_GET_PASSWORD;
        else
            cd->next_state = FTP_SEND_PASSWORD;
      }
    else if (cd->response_code == 2) /* Logged in */
      {
          if( cd->cc->no_restart )
              cd->next_state = FTP_SEND_SYST;
          else
              cd->next_state = FTP_SEND_REST_ZERO;
      }
    else
      {
        /* show the error
         */
         StrAllocCopy(ce->URL_s->content_type, TEXT_HTML);
        ce->URL_s->expires = 1; /* immediate expire date */
        cd->stream = net_ftp_make_stream(ce->format_out, ce->URL_s, ce->window_id);

        if(cd->stream)
          {
            PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, XP_GetString(XP_HTML_FTPERROR_NOLOGIN)) ;
            if(ce->status > -1)
                ce->status = PUTSTRING(cd->output_buffer);
            if(cd->return_msg && ce->status > -1)
                ce->status = PUTSTRING(cd->return_msg);
            PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "</PRE>");
            if(ce->status > -1)
                ce->status = PUTSTRING(cd->output_buffer);

            if(ce->status > -1)
                   COMPLETE_STREAM;
            else
                ABORT_STREAM(ce->status);

            FREE(cd->stream);
            cd->stream = NULL;
          }

        cd->next_state = FTP_ERROR_DONE;

        /* make sure error_msg is empty */
        FREE_AND_CLEAR(ce->URL_s->error_msg);

        return MK_UNABLE_TO_LOGIN;

      }

    return(0); /* good */
}


PRIVATE int
net_send_password(FTPConData * cd)
{

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE,
                "PASS %.256s%c%c",
                NET_UnEscape(cd->password),
                CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_PASSWORD_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE char *
gen_ftp_password_key(char *address, char *username)
{
    char *rv=NULL;

    if(!address || !username)
        return NULL;

    StrAllocCopy(rv, address);
    StrAllocCat(rv, "\t");
    StrAllocCat(rv, username);

    return rv;
}

PRIVATE int
net_send_password_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if (cd->response_code == 3)
      {
        cd->next_state = FTP_SEND_ACCT;
      }
    else if (cd->response_code == 2) /* logged in */
      {
          if(cd->store_password && cd->username)
          {
            /* store the password in the cache */
            char *key = gen_ftp_password_key(ce->URL_s->address, cd->username);

            if(key)
            {
                PCNameValueArray * array = PC_NewNameValueArray();

                PC_AddToNameValueArray(array, PC_FTP_PASSWORD_KEY, cd->password);

                PC_StorePasswordNameValueArray(PC_FTP_MODULE_KEY, key, array);

                XP_FREE(key);

                PC_FreeNameValueArray(array);
            }
          }

          if( cd->cc->no_restart )
              cd->next_state = FTP_SEND_SYST;
          else
              cd->next_state = FTP_SEND_REST_ZERO;
      }
    else
      {
        FREEIF(ftp_last_password_host);
        FREEIF(ftp_last_password);

        cd->next_state = FTP_ERROR_DONE;
        FE_Alert(ce->window_id, cd->return_msg ? cd->return_msg :
                                 XP_GetString( XP_COULD_NOT_LOGIN_TO_FTP_SERVER ) );
        /* no error status message in this case
         */
        return MK_UNABLE_TO_LOGIN;  /* negative return code */
      }

    return(0); /* good */
}


PRIVATE int
net_send_acct(FTPConData * cd)
{

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "ACCT noaccount%c%c", CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_ACCT_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_acct_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if (cd->response_code == 2)
      {
          if( cd->cc->no_restart )
              cd->next_state = FTP_SEND_SYST;
          else
              cd->next_state = FTP_SEND_REST_ZERO;
      }
    else
      {
        cd->next_state = FTP_ERROR_DONE;
        FE_Alert(ce->window_id, cd->return_msg ? cd->return_msg :
                                 XP_GetString( XP_COULD_NOT_LOGIN_TO_FTP_SERVER ) );
        /* no error status message in this case
         */
        return MK_UNABLE_TO_LOGIN;  /* negative return code */
      }

    return(0); /* good */
}

PRIVATE int
net_send_rest_zero(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "REST 0%c%c", CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_REST_ZERO_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_rest_zero_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if( cd->response_code == 3 )
    {
        TRACEMSG(("Server can do restarts!"));
        ce->URL_s->server_can_do_restart = TRUE;
        cd->cc->no_restart = FALSE;
    }
    else
    {
        TRACEMSG(("Server can NOT do restarts!"));
        ce->URL_s->server_can_do_restart = FALSE;
        cd->cc->no_restart = TRUE;
    }

    cd->next_state = FTP_SEND_SYST;
    return 0;
}

PRIVATE int
net_send_syst(FTPConData * cd)
{


    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "SYST%c%c", CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_SYST_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}


PRIVATE int
net_send_syst_response(FTPConData * cd)
{
    if (cd->response_code == 2)
      {
        TRACEMSG(("SYST response: %s",cd->return_msg));

        /* default next state will be to try PASV mode
         *
         * TEST: set this default next state to FTP_SEND_PORT
         * to test the non-pasv mode ftp
         */
        if(cd->use_default_path)
            cd->next_state = FTP_SEND_PWD;
        else
            cd->next_state = FTP_FIGURE_OUT_WHAT_TO_DO;

                /* we got a line -- what kind of server are we talking to? */
        if (!XP_STRNCMP(cd->return_msg, "UNIX Type: L8 MAC-OS MachTen", 28))
          {
            cd->cc->server_type = FTP_MACHTEN_TYPE;
            cd->cc->use_list = TRUE;
          }
        else if (XP_STRSTR(cd->return_msg, "UNIX") != NULL)
          {
             cd->cc->server_type = FTP_UNIX_TYPE;
             cd->cc->use_list = TRUE;
          }
        else if (XP_STRSTR(cd->return_msg, "Windows_NT") != NULL)
          {
             cd->cc->server_type = FTP_NT_TYPE;
             cd->cc->use_list = TRUE;
          }
        else if (XP_STRNCMP(cd->return_msg, "VMS", 3) == 0)
          {
             cd->cc->server_type = FTP_VMS_TYPE;
             cd->cc->use_list = TRUE;
          }
        else if ((XP_STRNCMP(cd->return_msg, "VM/CMS", 6) == 0)
                                 || (XP_STRNCMP(cd->return_msg, "VM ", 3) == 0))
          {
             cd->cc->server_type = FTP_CMS_TYPE;
          }
        else if (XP_STRNCMP(cd->return_msg, "DCTS", 4) == 0)
          {
             cd->cc->server_type = FTP_DCTS_TYPE;
          }
        else if (XP_STRSTR(cd->return_msg, "MAC-OS TCP/Connect II") != NULL)
          {
             cd->cc->server_type = FTP_TCPC_TYPE;
              cd->next_state = FTP_SEND_PWD;
          }
        else if (XP_STRNCMP(cd->return_msg, "MACOS Peter's Server", 20) == 0)
          {
             cd->cc->server_type = FTP_PETER_LEWIS_TYPE;
             cd->cc->use_list = TRUE;
             cd->next_state = FTP_SEND_MAC_BIN;
          }
        else if(cd->cc->server_type == FTP_GENERIC_TYPE)
          {
              cd->next_state = FTP_SEND_PWD;
          }
      }
    else
      {
        cd->next_state = FTP_SEND_PWD;
      }

    TRACEMSG(("Set server type to: %d\n",cd->cc->server_type));

    return(0);  /* good */

}

PRIVATE int
net_send_mac_bin(FTPConData * cd)
{

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "MACB%c%c", CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_MAC_BIN_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}


PRIVATE int
net_send_mac_bin_response(FTPConData * cd)
{
    if(cd->response_code == 2)
      {  /* succesfully set mac binary */
        if(cd->cc->server_type == FTP_UNIX_TYPE)
            cd->cc->server_type = FTP_NCSA_TYPE;  /* we were unsure here */
      }

    cd->next_state = FTP_FIGURE_OUT_WHAT_TO_DO;

    return(0); /* continue */
}

PRIVATE
int
net_figure_out_what_to_do(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    switch(ce->URL_s->method)
      {
        case URL_MKDIR_METHOD:
            cd->next_state = FTP_SEND_MKDIR;
            break;

        case URL_DELETE_METHOD:
            cd->next_state = FTP_SEND_DELETE_FILE;
            break;

        case URL_PUT_METHOD:
            /* trim the path to the last slash */
            {
                char * slash = XP_STRRCHR(cd->path, '/');
                if(slash)
                    *slash = '\0';
            }
            /* fall through */
            goto get_method_case;

        case URL_POST_METHOD:
            /* we support POST if files_to_post
             * is filed in
             */
            XP_ASSERT(ce->URL_s->files_to_post);
            /* fall through */

        case URL_GET_METHOD:
get_method_case:  /* ack! goto alert */

            /* don't send PASV if the server cant do it */
            if(cd->cc->no_pasv || !net_use_pasv)
                cd->next_state = FTP_SEND_PORT;
            else
                cd->next_state = FTP_SEND_PASV;
            break;

        default:
            XP_ASSERT(0);
      }

    return(0);
}

PRIVATE int
net_send_mkdir(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    PR_snprintf(cd->output_buffer,
                OUTPUT_BUFFER_SIZE,
                "MKD %s"CRLF,
                cd->path);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_MKDIR_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_mkdir_response(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if (cd->response_code !=2)
      {
        /* error */
        ce->URL_s->error_msg = NET_ExplainErrorDetails(
                                                MK_COULD_NOT_CREATE_DIRECTORY,
                                                cd->path);
        return(MK_COULD_NOT_CREATE_DIRECTORY);
      }

    /* success */

    cd->next_state = FTP_DONE;

    return(0);
}


PRIVATE int
net_send_delete_file(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    PR_snprintf(cd->output_buffer,
                OUTPUT_BUFFER_SIZE,
                "DELE %s"CRLF,
                cd->path);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_DELETE_FILE_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_delete_file_response(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if (cd->response_code !=2)
      {
        /* error */
        /* try and delete it as a file */
        cd->next_state = FTP_SEND_DELETE_DIR;
        return(0);
      }

    /* success */

    cd->next_state = FTP_DONE;

    return(0);
}

PRIVATE int
net_send_delete_dir(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    PR_snprintf(cd->output_buffer,
                OUTPUT_BUFFER_SIZE,
                "RMD %s"CRLF,
                cd->path);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_DELETE_DIR_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_delete_dir_response(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if (cd->response_code !=2)
      {
        /* error */
        ce->URL_s->error_msg = NET_ExplainErrorDetails(
                                                MK_UNABLE_TO_DELETE_DIRECTORY,
                                                cd->path);
        return(MK_UNABLE_TO_DELETE_DIRECTORY);
      }

    /* success */

    cd->next_state = FTP_DONE;

    return(0);
}

PRIVATE int
net_send_pwd(FTPConData * cd)
{
    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "PWD%c%c", CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_PWD_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_pwd_response(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;
    char *cp = XP_STRCHR(cd->return_msg+5,'"');

    if(cp)
        *cp = '\0';

    /* default next state */
    /* don't send PASV if the server cant do it */
    cd->next_state = FTP_FIGURE_OUT_WHAT_TO_DO;

    if (cd->cc->server_type == FTP_TCPC_TYPE)
      {
        cd->cc->server_type = (cd->return_msg[1] == '/' ?
                                FTP_NCSA_TYPE : FTP_TCPC_TYPE);
      }
    else if(cd->cc->server_type == FTP_GENERIC_TYPE)
      {
        if (cd->return_msg[1] == '/')
          {
            /* path names beginning with / imply Unix,
             * right?
             */
              cd->cc->server_type = FTP_UNIX_TYPE;
              cd->cc->use_list = TRUE;
              cd->next_state = FTP_SEND_MAC_BIN;  /* see if it's a mac */
           }
         else if (cd->return_msg[XP_STRLEN(cd->return_msg)-1] == ']')
           {
             /* path names ending with ] imply VMS, right? */
             cd->cc->server_type = FTP_VMS_TYPE;
             cd->cc->use_list = TRUE;
           }
      }

    /* use the path returned by PWD if use_default_path is set
     * don't do this for vms hosts
     */
    if(cd->use_default_path && cd->cc->server_type != FTP_VMS_TYPE)
      {
        char *path = XP_STRTOK(&cd->return_msg[1], "\"");
        char *ptr;
        char *existing_path = cd->path;

        /* NT can return a drive letter.  We can't
         * deal with a drive letter right now
         * so we need to just strip the drive letter
         */
        if(*path != '/') {
          ptr = XP_STRCHR(path, '/');
          /* If that didn't work, look for a backslash (e.g., OS/2) */
          if( ptr == (char *)0 ) {
              ptr = XP_STRCHR(path, '\\');
              /* If that worked, then go flip the slashes so the URL is legal */
              if( ptr != (char *)0 ) {
                  char *p;
                  for( p = ptr; *p != '\0'; p++ ){
                      if( *p == '\\' ) {
                          *p = '/';
                      }
                  }
              }
          }
        }
        else
          ptr = path;

        if(ptr)
          {
            char * new_url;

            cd->path = NULL;
            StrAllocCopy(cd->path, ptr);

            if(existing_path && existing_path[0] != '\0')
               {
                  /* if the new path has a / on the
                 * end remove it since the
                 * existing path already has
                 * a slash at the beginning
                 */
                if(cd->path[0] != '\0')
                  {
                    char *end = &cd->path[XP_STRLEN(cd->path)-1];
                    if(*end == '/')
                        *end = '\0';
                  }
                StrAllocCat(cd->path, existing_path);
               }

            /* strip the path part from the URL
             * and add the new path
             */
            new_url = NET_ParseURL(ce->URL_s->address,
                                   GET_PROTOCOL_PART | GET_USERNAME_PART | GET_HOST_PART);

            StrAllocCat(new_url, cd->path);

            FREE(ce->URL_s->address);

            ce->URL_s->address = new_url;
          }


        /* make sure we don't do this again for some reason */
        cd->use_default_path = FALSE;
      }

     if (cd->cc->server_type == FTP_NCSA_TYPE ||
                        cd->cc->server_type == FTP_TCPC_TYPE ||
                        cd->cc->server_type == FTP_PETER_LEWIS_TYPE)
         cd->next_state = FTP_SEND_MAC_BIN;

     return(0); /* good */
}


PRIVATE int
net_send_pasv(FTPConData * cd)
{

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "PASV%c%c", CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_PASV_RESPONSE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}


PRIVATE int
net_send_pasv_response(FTPConData * cd)
{
    int    h0, h1, h2, h3;
    int32  p0, p1;
    int32  pasv_port;
    char  *cp;
    int    status;

    if (cd->response_code !=2)
      {
        cd->next_state = FTP_SEND_PORT; /* default next state */
        cd->pasv_mode = FALSE;
        cd->cc->no_pasv = TRUE;  /* pasv doesn't work don't try it again */
        return(0); /* continue */
      }

    cd->cc->no_pasv = FALSE;  /* pasv does work */

    TRACEMSG(("PASV response: %s\n",cd->return_msg));

    /* find first comma or end of line */
    for(cp=cd->return_msg; *cp && *cp != ','; cp++)
        ; /* null body */

    /* find the begining of digits */
    while (--cp > cd->return_msg && '0' <= *cp && *cp <= '9')
        ; /* null body */

    /* go past the '(' when the return is of the
     * form (128,234,563,356,356)
     */
    if(*cp < '0' || *cp > '9')
        cp++;

    status = sscanf(cp,
#ifdef __alpha
        "%d,%d,%d,%d,%d,%d",
#else
        "%d,%d,%d,%d,%ld,%ld",
#endif
        &h0, &h1, &h2, &h3, &p0, &p1);
    if (status<6)
      {
        TRACEMSG(("FTP: PASV reply has no inet address!\n"));
        cd->next_state = FTP_SEND_PORT; /* default next state */
        cd->pasv_mode = FALSE;
        return(0); /* continue */
      }

    pasv_port = ((int32) (p0<<8)) + p1;
    TRACEMSG(("FTP: Server is listening on port %d\n", pasv_port));

    /* Open connection for data:
     */
    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "%d.%d.%d.%d:%ld",h0,h1,h2,h3,pasv_port);
    StrAllocCopy(cd->data_con_address, cd->output_buffer);

    cd->next_state = FTP_PASV_DATA_CONNECT;

    return(0); /* OK */
}


PRIVATE int
net_send_port(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;
    int    status;
    PRNetAddr pr_addr;
    PRSocketOptionData opt;
    PRStatus sock_status;

    TRACEMSG(("Entering get_listen_socket with control socket: %d\n", cd->cc->csock));

    cd->pasv_mode = FALSE;  /* not using pasv mode if we get here */

    /*  Create internet socket
    */
    cd->listen_sock = PR_NewTCPSocket();

    if(cd->listen_sock == NULL)
      {
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_CREATE_SOCKET);
        return MK_UNABLE_TO_CREATE_SOCKET;
      }

#if defined(XP_WIN16) || (defined(XP_OS2) && !defined(XP_OS2_DOUGSOCK))
    opt.option = PR_SockOpt_Linger;
    opt.value.linger.polarity = PR_TRUE;
    opt.value.linger.linger = PR_INTERVAL_NO_WAIT;
    PR_SetSocketOption(cd->listen_sock, &opt);
#endif
      /* lets try to set the socket non blocking
       * so that we can do multi threading
       */
    opt.option = PR_SockOpt_Nonblocking;
    opt.value.non_blocking = PR_TRUE;
    sock_status = PR_SetSocketOption(cd->listen_sock, &opt);
    if (sock_status != PR_SUCCESS)
        NET_Progress(ce->window_id,
                     XP_GetString( XP_ERROR_COULD_NOT_MAKE_CONNECTION_NON_BLOCKING ) );

HG31456

    /* init the addr, leave port zero to let bind allocate one */
    PR_InitializeNetAddr(PR_IpAddrAny, 0, &pr_addr);

    status = PR_GetSockName(cd->cc->csock, &pr_addr);
    if (status != PR_SUCCESS)
      {
        TRACEMSG(("Failure in getsockname for control connection: %d\n",
                                cd->cc->csock));
        return -1;
      }

    status=PR_Bind(cd->listen_sock, &pr_addr);
    if (status != PR_SUCCESS)
    {
        TRACEMSG(("Failure in bind for listen socket: %d\n", cd->listen_sock));
           return -1;
    }

    /* TRACEMSG(("FTP: This host is %s\n", PR_NetAddrToString(&pr_addr))); */

    /* get the name again to find out the port */
    status = PR_GetSockName(cd->listen_sock, &pr_addr);
    if (status != PR_SUCCESS)
        return -1;

    /* TRACEMSG(("FTP: bound to %s\n",PR_NetAddrToString(&pr_addr))); */

    /*  Now we must tell the other side where to connect
     */
    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "PORT %d,%d,%d,%d,%d,%d%c%c",
            (int)* ((unsigned char*) (&pr_addr.inet.ip)+0),
            (int)* ((unsigned char*) (&pr_addr.inet.ip)+1),
            (int)* ((unsigned char*) (&pr_addr.inet.ip)+2),
            (int)* ((unsigned char*) (&pr_addr.inet.ip)+3),
            (int)* ((unsigned char*) (&pr_addr.inet.port)+0),
            (int)* ((unsigned char*) (&pr_addr.inet.port)+1),
            CR, LF);

    /*  Inform TCP that we will accept connections
     */
    if (PR_Listen(cd->listen_sock, 1) < 0)
      {
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_LISTEN_ON_SOCKET);
        return MK_UNABLE_TO_LISTEN_ON_SOCKET;
      }

    TRACEMSG(("TCP: listen socket(), bind() and listen() all OK.\n"));

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_PORT_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    /* Inform the server of the port number we will listen on
     * The port_command came from above
     */
    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));

} /* get_listen */

PRIVATE int
net_send_port_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if (cd->response_code !=2)
      {
        TRACEMSG(("FTP: Bad response (port_command: %s)\n",cd->return_msg));
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_SEND_PORT_COMMAND);

        return MK_UNABLE_TO_SEND_PORT_COMMAND;
      }

    /* else */

    cd->next_state = FTP_GET_FILE_TYPE;
    return(0); /* good */
}

/* figure out what file transfer type to use
 * and set the next state to set it if it needs
 * set or else begin the transfer if it's already
 * set correctly
 */
PRIVATE int
net_get_ftp_file_type(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    NET_cinfo * cinfo_struct;

    /* figure out if we are puttting a file
     * and if we are figure out which
     * file we are doing now
     */
    if(ce->URL_s->files_to_post &&
        ce->URL_s->files_to_post[0] != 0)
      {
        /* files_to_post is an array of filename pointers
         * find the last one in the list and
         * remove it once done.
         */
        char **array = ce->URL_s->files_to_post;
        int i;

        if(!cd->total_size_of_files_to_post)
          {
              /* If we don't know the total size
             * of all the files we are posting
             * figure it out now
             */
            XP_StatStruct stat_entry;

            for(i=0; array[i]; i++)
              {
                if(XP_Stat(array[i],
                           &stat_entry, xpFileToPost) != -1)
                    cd->total_size_of_files_to_post += stat_entry.st_size;
              }

            /* start the graph progress now since we know the size
              */
            ce->URL_s->content_length = cd->total_size_of_files_to_post;
            FE_GraphProgressInit(ce->window_id, ce->URL_s, ce->URL_s->content_length);
            cd->destroy_graph_progress = TRUE;
            cd->original_content_length = ce->URL_s->content_length;

#ifdef EDITOR
            /* Don't show the dialog if the data is being delivered to a plug-in */
            if (CLEAR_CACHE_BIT(ce->format_out) != FO_PLUGIN)
            {
                FE_SaveDialogCreate(ce->window_id, i, ED_SAVE_DLG_PUBLISH );
                cd->destroy_file_upload_progress_dialog = TRUE;
            }
#endif /* EDITOR */
          }

        /* posting files is started as a POST METHOD
         * eventually though, after posting the files
         * we end up with a directory listing which
         * should be treated as a GET METHOD.  Change
         * the method now so that the cache doesn't
         * get confused about the method as it caches
         * the directory listing at the end
         */
        if(ce->URL_s->method == URL_POST_METHOD)
            ce->URL_s->method = URL_GET_METHOD;

        for(i=0; array[i] != 0; i++)
            ; /* null body */

        if(i < 1)
          {
            /* no files left to post
             * quit
             */
            cd->next_state = FTP_DONE;
            return(0);
          }

        FREEIF(cd->file_to_post);
        cd->file_to_post = array[i-1];
        array[i-1] = 0;

    /* Use post_to data if specified in the URL struct. */
    if (ce->URL_s->post_to && ce->URL_s->post_to[i-1]) {
      FREEIF(cd->post_file_to);
      cd->post_file_to = ce->URL_s->post_to[i-1];
      ce->URL_s->post_to[i-1] = 0;
    }


        cinfo_struct = NET_cinfo_find_type(cd->file_to_post);

        /* use binary mode always except for "text" types
         * don't use ASCII for default types
         */
        if(!cinfo_struct->is_default
            && !strncasecomp(cinfo_struct->type, "text",4))
          {
            if(cd->cc->cur_mode != FTP_MODE_ASCII)
                cd->next_state = FTP_SEND_ASCII;
            else
                cd->next_state = FTP_SEND_CWD;
          }
        else
          {
            if(cd->cc->cur_mode != FTP_MODE_BINARY)
                cd->next_state = FTP_SEND_BIN;
            else
                cd->next_state = FTP_SEND_CWD;
          }

        return(0);  /* continue */
      }
    else if(ce->URL_s->method == URL_PUT_METHOD)
      {
        cd->next_state = FTP_SEND_BIN;
        return(0);
      }

    if(cd->type == FTP_MODE_UNKNOWN)
      {  /* use extensions to determine the type */

        NET_cinfo * enc = NET_cinfo_find_enc(cd->filename);
        cinfo_struct = NET_cinfo_find_type(cd->filename);

        TRACEMSG(("%s", cinfo_struct->is_default ?
                            "Default cinfo type found" : ""));

        TRACEMSG(("Current FTP transfer mode is: %d", cd->cc->cur_mode));

        /* use binary mode always except for "text" types
         * don't use ASCII for default types
         *
         * if it has an encoding value, transfer as binary
         */
        if(!cinfo_struct->is_default
            && !strncasecomp(cinfo_struct->type, "text",4)
            && (!enc || !enc->encoding))
          {
            if(cd->cc->cur_mode != FTP_MODE_ASCII)
                cd->next_state = FTP_SEND_ASCII;
            else
                cd->next_state = FTP_GET_FILE_SIZE;
          }
        else
          {
            if(cd->cc->cur_mode != FTP_MODE_BINARY)
                cd->next_state = FTP_SEND_BIN;
            else
                cd->next_state = FTP_GET_FILE_SIZE;
          }
      }
    else
      {  /* use the specified type */
        if(cd->cc->cur_mode == cd->type)
          {
            cd->next_state = FTP_GET_FILE_SIZE;
          }
        else
          {
            if(cd->type == FTP_MODE_ASCII)
                cd->next_state = FTP_SEND_ASCII;
            else
                cd->next_state = FTP_SEND_BIN;
          }
      }


    return(0);  /* continue */
}

PRIVATE int
net_send_bin(FTPConData * cd)
{

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "TYPE I%c%c", CR, LF);
    cd->cc->cur_mode = FTP_MODE_BINARY;

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_BIN_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}


PRIVATE int
net_send_ascii(FTPConData * cd)
{

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "TYPE A%c%c", CR, LF);
    cd->cc->cur_mode = FTP_MODE_ASCII;

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_ASCII_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_bin_or_ascii_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if (cd->response_code != 2)
      {
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_CHANGE_FTP_MODE);
        return MK_UNABLE_TO_CHANGE_FTP_MODE;
      }

    /* else */
    if(cd->file_to_post || ce->URL_s->method == URL_PUT_METHOD)
        cd->next_state = FTP_SEND_CWD;
    else
        cd->next_state = FTP_GET_FILE_SIZE;

    return(0); /* good */
}

PRIVATE int
net_get_ftp_file_size(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if (cd->cc->server_type == FTP_VMS_TYPE)
      {
        /* skip this since I'm not sure how it should work on VMS
         */
        cd->next_state = FTP_GET_FILE; /* we can skip the mdtm request, too */
        return(0);
      }

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "SIZE %.1024s%c%c", cd->path, CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_GET_FILE_SIZE_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_get_ftp_file_size_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if(cd->response_code == 2 && cd->return_msg)
      {
          int32 cl = atol(cd->return_msg);
        /* The response looks like  "160452"
         * where "160452" is the size in bytes.
         */

          if( cd->restart )
          {
              TRACEMSG(("Verifying content length: was %ld, is %ld", ce->URL_s->real_content_length, cl));
              if( ce->URL_s->real_content_length != cl )
              {
                  TRACEMSG(("Doesn't match!  Clearing restart flag."));
                  cd->restart = FALSE;
                  ce->URL_s->content_length = cl;
                  ce->URL_s->real_content_length = cl;
              }
              else
              {
                  TRACEMSG(("Length didn't change."));
              }
          }
          else
          {
              ce->URL_s->content_length = cl;
              ce->URL_s->real_content_length = cl;
              TRACEMSG(("Set content length: %ld",  ce->URL_s->content_length));
          }
      }
    else
      {
        /* unknown length */
          ce->URL_s->content_length = 0;
        ce->URL_s->real_content_length = 0;
        cd->restart = FALSE;
      }

    cd->next_state = FTP_GET_FILE_MDTM;

    return(0);
}

PRIVATE int
net_get_ftp_file_mdtm(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if (cd->cc->server_type == FTP_VMS_TYPE)
      {
        /* skip this since I'm not sure how it should work on VMS
         */
        cd->next_state = FTP_GET_FILE;
        return(0);
      }

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "MDTM %.1024s%c%c", cd->path, CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_GET_FILE_MDTM_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_get_ftp_file_mdtm_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if(cd->response_code == 2 && cd->return_msg)
    {
        /*
         * The time is returned in ISO 3307 "Representation
         * of the Time of Day" format. This format is YYYYMMDDHHmmSS or
         * YYYYMMDDHHmmSS.xxx, where
         *         YYYY    is the year
         *         MM      is the month (01-12)
         *         DD      is the day of the month (01-31)
         *         HH      is the hour of the day (00-23)
         *         mm      is the minute of the hour (00-59)
         *         SS      is the second of the hour (00-59)
         *         xxx     if present, is a fractional second and may be any length
         * Time is expressed in UTC (GMT), not local time.
         */
#ifndef NSPR20
        PRTime ts;
        int64 t, s2us, st;
#else
        PRExplodedTime ts;
        int64 s2us, st;
        PRTime t;
#endif /* NSPR20 */
        time_t tt;

        TRACEMSG(("Parsing MDTM \"%.1024s\"", cd->return_msg, CR, LF));

        ts.tm_year = (cd->return_msg[0] - '0') * 1000 +
                     (cd->return_msg[1] - '0') *  100 +
                     (cd->return_msg[2] - '0') *   10 +
                     (cd->return_msg[3] - '0');
#ifndef NSPR20
        ts.tm_mon = ((cd->return_msg[4] - '0') * 10 + (cd->return_msg[5] - '0')) - 1;
#else
        ts.tm_month = ((cd->return_msg[4] - '0') * 10 + (cd->return_msg[5] - '0')) - 1;
#endif /* NSPR20 */
        ts.tm_mday = (cd->return_msg[6] - '0') * 10 + (cd->return_msg[7] - '0');
        ts.tm_hour = (cd->return_msg[8] - '0') * 10 + (cd->return_msg[9] - '0');
        ts.tm_min  = (cd->return_msg[10] - '0') * 10 + (cd->return_msg[11] - '0');
        ts.tm_sec  = (cd->return_msg[12] - '0') * 10 + (cd->return_msg[13] - '0');
        ts.tm_usec = 0;

        /*
         * if( '.' == cd->return_msg[14] )
         * {
         *     long int i = 1000000;
         *     char *p = &cd->return_msg[15];
         *     while( isdigit(*p) )
         *     {
         *         ts.tm_usec += (*p - '0') * i;
         *         i /= 10;
         *         p++;
         *     }
         * }
         */

#ifndef NSPR20
        t = PR_ComputeTime(&ts);
#else
        t = PR_ImplodeTime(&ts);
#endif /* NSPR20 */
        LL_I2L(s2us, PR_USEC_PER_SEC);
        LL_DIV(st, t, s2us);
        LL_L2I(tt, st);

#ifdef DEBUG
        {
            char line[256];
#ifndef NSPR20
            PRTime et;
            int64 t2;
#else
            PRExplodedTime et;
            PRTime t2;
#endif /* NSPR20 */
            LL_MUL(t2, st, s2us);
#ifndef NSPR20
            PR_ExplodeTime(&et, t2);
#else
            PR_ExplodeTime(t2, PR_GMTParameters, &et);
#endif /* NSPR20 */
            PR_FormatTimeUSEnglish(line, sizeof(line), "%Y%m%d%H%M%S", &et);
            TRACEMSG(("Parse check: mdtm is \"%s\"", line));
        }
#endif

        if( cd->restart && (ce->URL_s->last_modified != 0) )
        {
            TRACEMSG(("Verifying last modified date: was %ld, is %ld",
                      ce->URL_s->last_modified, tt));
            if( ce->URL_s->last_modified != tt )
            {
                TRACEMSG(("Doesn't match!  Clearing restart flag."));
                cd->restart = FALSE;
                ce->URL_s->last_modified = tt;
            }
            else
            {
                TRACEMSG(("Time of last modification didn't change."));
            }
        }
        else
        {
            ce->URL_s->last_modified = tt;
            TRACEMSG(("set last modified: %ld", ce->URL_s->last_modified));
        }
    }

    cd->next_state = FTP_GET_FILE;

    return(0);
}

PRIVATE int
net_get_ftp_file(FTPConData * cd)
{

    /* if this is a VMS server then we need to
     * do some special things to map a UNIX syntax
     * ftp url to a VMS type file syntax
     */
    if (cd->cc->server_type == FTP_VMS_TYPE)
      {
          cd->restart = FALSE;
        /* If we want the VMS account's top directory speed to it
         */
        if (cd->path[0] == '\0' || (cd->path[0] == '/' && cd->path[1]== '\0'))
          {
            cd->is_directory = YES;
            cd->next_state = FTP_SEND_LIST_OR_NLST;
          }
        else if(!XP_STRCHR(cd->path, '/'))
          {
            /* if we want a file out of the top directory skip the PWD
             */
            cd->next_state = FTP_SEND_RETR;
          }
        else
          {
            cd->next_state = FTP_SEND_CWD;
          }

      }
    else
      {  /* non VMS */
        /* if we have already done the RETR or
         * if the path ends with a slash
         */
        if(cd->retr_already_failed ||
            '/' == cd->path[XP_STRLEN(cd->path)-1])
            cd->next_state = FTP_SEND_CWD;
        else
        {
            if( cd->restart ) cd->next_state = FTP_SEND_REST;
            else              cd->next_state = FTP_SEND_RETR;
        }
      }

    return(0); /* continue */
}

PRIVATE int
net_send_cwd(FTPConData * cd)
{

    if (cd->cc->server_type == FTP_VMS_TYPE)
      {
        char *cp, *cp1;
        /** Try to go to the appropriate directory and doctor filename **/
        if ((cp=XP_STRRCHR(cd->path, '/'))!=NULL)
          {
            *cp = '\0';
            PR_snprintf(cd->output_buffer,
                       OUTPUT_BUFFER_SIZE,
                       "CWD [%.1024s]" CRLF,
                       cd->path);
            *cp = '/';  /* set it back so it is left unmodified */

            /* turn slashes into '.' */
            while ((cp1=XP_STRCHR(cd->output_buffer, '/')) != NULL)
                *cp1 = '.';
          }
        else
          {
            PR_snprintf(cd->output_buffer,
                       OUTPUT_BUFFER_SIZE,
                       "CWD [.%.1024s]" CRLF,
                       cd->path);
          }
      } /* if FTP_VMS_TYPE */
    else
      {  /* non VMS server */
        PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "CWD %.1024s" CRLF, cd->path);
      }

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_CWD_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_cwd_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if (cd->response_code == 2) /* Successed : let's NAME LIST it */
      {

        if(cd->file_to_post)
          {
            cd->next_state = FTP_BEGIN_PUT;
            return(0); /* good */
          }
        else if(ce->URL_s->method == URL_PUT_METHOD)
          {
            cd->next_state = FTP_BEGIN_PUT;
            return(0); /* good */
          }

        ce->URL_s->is_directory = TRUE;
        cd->restart = FALSE;

        if (cd->cc->server_type == FTP_VMS_TYPE)
          {
            if(*cd->filename)
                cd->next_state = FTP_SEND_RETR;
            else
                 cd->next_state = FTP_SEND_LIST_OR_NLST;
            return(0); /* good */
          }

        /* non VMS server */
        /* we are in the correct directory and we
         * already failed on the RETR so lets
         * LIST or NLST it
         */
        cd->next_state = FTP_SEND_LIST_OR_NLST;
        return(0); /* good */
      }

    /* else */
    ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_LOCATE_FILE,
                                                    *cd->path ? cd->path : "/");

    return MK_UNABLE_TO_LOCATE_FILE;  /* error */
}

PRIVATE int
net_begin_put(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;
    char *path, *filename;

    if(cd->file_to_post)
      {
       /* Use post_file_to as destination filename, if supplied. */
       /* All path info in post_file_to is thrown away.  Assumed to
          be in same directory. */
       if (cd->post_file_to) {
            path = XP_STRDUP(cd->post_file_to);
               if(!path)
                  return(MK_OUT_OF_MEMORY);
             filename = XP_STRRCHR(path, '/');
       }
       else {
            path = XP_STRDUP(cd->file_to_post);
            if(!path)
                return(MK_OUT_OF_MEMORY);
#if defined(XP_WIN) || defined(XP_OS2)               /* IBM - SAH */
            filename = XP_STRRCHR(path, '\\');
#else
            filename = XP_STRRCHR(path, '/');
#endif
       }
      }
    else
      {
        path = NET_ParseURL(ce->URL_s->address, GET_PATH_PART);
        if(!path)
            return(MK_OUT_OF_MEMORY);
        filename = XP_STRRCHR(path, '/');
      }

    if(!filename)
        filename = path;
    else
        filename++; /* go past delimiter */

    PR_snprintf(cd->output_buffer,
               OUTPUT_BUFFER_SIZE,
               "STOR %.1024s" CRLF,
               filename);

#ifdef EDITOR
    if(cd->destroy_file_upload_progress_dialog)
        FE_SaveDialogSetFilename(ce->window_id, filename);
#endif /* EDITOR */

    FREE(path);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_BEGIN_PUT_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}


PRIVATE int
net_begin_put_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if (cd->response_code != 1)
      {
        /* failed */
        ce->URL_s->error_msg = NET_ExplainErrorDetails(
                                MK_COULD_NOT_PUT_FILE,
                                cd->file_to_post ?
                                        cd->file_to_post : ce->URL_s->address,
                                cd->return_msg ? cd->return_msg : "");
        return(MK_COULD_NOT_PUT_FILE);
      }

    NET_ClearReadSelect(ce->window_id, ce->socket);
    ce->socket = cd->dsock;
    ce->con_sock = cd->dsock;

#if defined(XP_WIN16) || (defined(XP_OS2) && !defined(XP_OS2_DOUGSOCK)) /* stuff not for windows since setsockopt doesnt work */
    {
        PRSocketOptionData opt;
          /* turn the linger off so that we don't
           * wait but we don't abort either
           * since aborting will lose quede data
           */
        opt.option = PR_SockOpt_Linger;
        opt.value.linger.polarity = PR_FALSE;
        opt.value.linger.linger = PR_INTERVAL_NO_WAIT;
        PR_SetSocketOption(cd->listen_sock, &opt);
    }
#endif /* XP_WIN16 */

    /* set connect select because we are writting
     * not reading
     */
    if(cd->pasv_mode)
        NET_SetConnectSelect(ce->window_id, ce->socket);
#ifdef XP_WIN
    cd->calling_netlib_all_the_time = TRUE;
    NET_SetCallNetlibAllTheTime(ce->window_id, "mkftp");
#endif


  /* Maybe should change string if cd->post_file_to */
    PR_snprintf(cd->output_buffer,
               OUTPUT_BUFFER_SIZE,
                XP_GetString( XP_POSTING_FILE ),
               cd->file_to_post);

    NET_Progress(ce->window_id, cd->output_buffer);

    if(cd->pasv_mode)
      {
        cd->next_state = FTP_DO_PUT;
      }
    else
      { /* non PASV */
        cd->next_state = FTP_WAIT_FOR_ACCEPT;
      }

    return(0);

}

/* finally send the file
 */
PRIVATE int
net_do_put(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    /* Default to adding crlf if ftp ASCII mode. */
    XP_Bool add_crlf = (cd->cc->cur_mode == FTP_MODE_ASCII);


    if(!cd->write_post_data_data)
      {
        /* first time through */

        /* if file_to_post is filled in then
         * throw the name into the post data
         * so that we can use the WritePostData
         * function
         */
        if(cd->file_to_post)
          {
            ce->URL_s->post_data = cd->file_to_post;
            ce->URL_s->post_data_is_file = TRUE;
          }
      }

    /* If the add_crlf field is set in the URL struct, find the
       entry corresponding to the current file being posted. */
    if (ce->URL_s->files_to_post && ce->URL_s->add_crlf) {
      int n = 0;
      while (ce->URL_s->files_to_post[n]) {
        n++;
      }
      /* n should now point after the last entry in files_to_post,
         which is the current file being uploaded. */
      add_crlf = ce->URL_s->add_crlf[n];
    }

    /* returns 0 on done and negative on error
     * positive if it needs to continue.
     */
    ce->status = NET_WritePostData(ce->window_id, ce->URL_s,
                                  ce->socket,
                                  &cd->write_post_data_data,
                                                  add_crlf);

    cd->pause_for_read = TRUE;

    if(ce->status == 0)
      {
        /* normal done
         */
           NET_ClearConnectSelect(ce->window_id, ce->socket);
#ifdef XP_WIN
        if(cd->calling_netlib_all_the_time)
        {
            cd->calling_netlib_all_the_time = FALSE;
            NET_ClearCallNetlibAllTheTime(ce->window_id, "mkftp");
        }
#endif
           ce->socket = cd->cc->csock;
           ce->con_sock = NULL;
           NET_SetReadSelect(ce->window_id, ce->socket);

        PR_Close(cd->dsock);
        cd->dsock = NULL;

        if(cd->destroy_graph_progress)
          {
            FE_GraphProgressDestroy(ce->window_id,
                                    ce->URL_s,
                                    cd->original_content_length,
                                    ce->bytes_received);
            cd->destroy_graph_progress = FALSE;
          }

           /* go read the response since we need to
            * get the "226 sucessful transfer" message
            * out of the read queue in order to cache
            * connections properly
            */
           cd->next_state = FTP_WAIT_FOR_RESPONSE;

        if(cd->file_to_post)
          {
            ce->URL_s->post_data = 0;
            ce->URL_s->post_data_is_file = FALSE;
            FREE_AND_CLEAR(cd->file_to_post);
          }

    if (cd->post_file_to)
      {
      FREE_AND_CLEAR(cd->post_file_to);
      }

        /* after getting the server response start
         * over again if there are more
         * files to send or to do a new directory
         * listing...
         */
          cd->next_state_after_response = FTP_DONE;


        /* if this was the last file, check the history
         * to see if the window is currently displaying an ftp
         * listing.  If it is update the listing.  If it isnt
         * quit.
         */
        if(ce->URL_s->files_to_post)
          {
            if(ce->URL_s->files_to_post[0])
              {
                /* more files, keep going */
                cd->next_state_after_response = FTP_FIGURE_OUT_WHAT_TO_DO;
              }
      /* Don't want to show a directory when remote editing a FTP page, bug 50942 */
            else if (!EDT_IS_EDITOR(ce->window_id))
                {
                /* no more files, figure out if we should
                 * show an index
                 */
#ifdef MOZILLA_CLIENT
                  History_entry * his = SHIST_GetCurrent(&ce->window_id->hist);
#else
                History_entry * his = NULL;
#endif /* MOZILLA_CLIENT */

                if(his && !strncasecomp(his->address, "ftp:", 4))
                    {
                    /* go get the index of the directory */
                    cd->next_state_after_response = FTP_FIGURE_OUT_WHAT_TO_DO;
                    }
              }
          }
      }
    else if(ce->status > 0)
      {
        ce->bytes_received += ce->status;
        FE_GraphProgress(ce->window_id,
                         ce->URL_s,
                         ce->bytes_received,
                         ce->status,
                         ce->URL_s->content_length);
        FE_SetProgressBarPercent(ce->window_id,
                                 (long)(((double)ce->bytes_received*100) / (double)(uint32)ce->URL_s->content_length) );
      }

    return(ce->status);
}

PRIVATE int
net_send_rest(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE, "REST %ld%c%c",
                ce->URL_s->content_length, CR, LF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_REST_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Rx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_rest_response(ActiveEntry *ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if(cd->response_code == 3 && cd->return_msg)
    {
        TRACEMSG(("Restarting!  Yay!"));
    }
    else
    {
        TRACEMSG(("Didn't understand the REST command."));
        cd->cc->no_restart = TRUE;
        cd->restart = FALSE;
    }

    cd->next_state = FTP_SEND_RETR;
    return(0);
}


PRIVATE int
net_send_retr(FTPConData * cd)
{

    if(cd->cc->server_type == FTP_VMS_TYPE)
        PR_snprintf(cd->output_buffer,
                   OUTPUT_BUFFER_SIZE,
                   "RETR %.1024s" CRLF,
                   cd->filename);
    else
        PR_snprintf(cd->output_buffer,
                    OUTPUT_BUFFER_SIZE,
                    "RETR %.1024s" CRLF,
                    cd->path);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_RETR_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}


PRIVATE int
net_send_retr_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *) ce->con_data;

    if(cd->response_code != 1)
      {
        if(cd->cc->server_type == FTP_VMS_TYPE)
          {
            ce->URL_s->error_msg = NET_ExplainErrorDetails(
                                                  MK_UNABLE_TO_LOCATE_FILE,
                                                  *cd->path ? cd->path : "/");
            return(MK_UNABLE_TO_LOCATE_FILE);
          }
        else
          { /* non VMS */

#ifdef DOUBLE_PASV
            /* this will use a new PASV connection
             * for each command even if the one only
             * failed and didn't transmit
             */
            /* close the old pasv connection */
            NETCLOSE(cd->dsock);
            /* invalidate the old pasv connection */
            cd->dsock = NULL;

            cd->next_state = FTP_SEND_PASV; /* send it again */
            cd->retr_already_failed = TRUE;
#else
            /* we need to use this to make the mac FTPD work
             */
            /* old way */
            cd->next_state = FTP_SEND_CWD;
#endif /* DOUBLE_PASV */
          }
      }
    else
      {   /* successful RETR */
        cd->next_state = FTP_SETUP_STREAM;
      }

    return(0); /* continue */
}

PRIVATE int
net_send_list_or_nlst(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if(cd->cc->use_list)
        XP_STRCPY(cd->output_buffer, "LIST" CRLF);
    else
        XP_STRCPY(cd->output_buffer, "NLST" CRLF);

    cd->next_state = FTP_WAIT_FOR_RESPONSE;
    cd->next_state_after_response = FTP_SEND_LIST_OR_NLST_RESPONSE;
    cd->pause_for_read = TRUE;

    TRACEMSG(("FTP Tx: %s", cd->output_buffer));

    return((int) NET_BlockingWrite(cd->cc->csock,
                             cd->output_buffer,
                             XP_STRLEN(cd->output_buffer)));
}

PRIVATE int
net_send_list_or_nlst_response(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if(cd->response_code == 1)
      {  /* succesful list or nlst */
        cd->is_directory = TRUE;
        cd->restart = FALSE;
        cd->next_state = FTP_SETUP_STREAM;

        /* add a slash to the end of the uRL if it doesnt' have one now
         */
        if(ce->URL_s->address[XP_STRLEN(ce->URL_s->address)-1] != '/')
          {
            /* update the global history before modification
             */
#ifdef MOZILLA_CLIENT
            GH_UpdateGlobalHistory(ce->URL_s);
#endif /* MOZILLA_CLIENT */
            StrAllocCat(ce->URL_s->address, "/");
            ce->URL_s->address_modified = TRUE;
          }

        return(0); /* good */
      }

    ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_LOCATE_FILE,
                                                  *cd->path ? cd->path : "/");
    return(MK_UNABLE_TO_LOCATE_FILE);
}


PRIVATE int
net_setup_ftp_stream(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    /* set up the data stream now
     */
    if(cd->is_directory)
      {
         char * pUrl ;
        int status;

         status = PREF_CopyCharPref("protocol.mimefor.ftp",&pUrl);

         if (status >= 0 && pUrl) {
             StrAllocCopy(ce->URL_s->content_type, pUrl);
             XP_FREE(pUrl);
         } else {
              StrAllocCopy(ce->URL_s->content_type, APPLICATION_HTTP_INDEX);
         }

        cd->stream = net_ftp_make_stream(ce->format_out, ce->URL_s, ce->window_id);
      }
    else
      {
        if(!ce->URL_s->preset_content_type || !ce->URL_s->content_type )
          {
            NET_cinfo * cinfo_struct = NET_cinfo_find_type(cd->filename);
             StrAllocCopy(ce->URL_s->content_type, cinfo_struct->type);

            cinfo_struct = NET_cinfo_find_enc(cd->filename);
             StrAllocCopy(ce->URL_s->content_encoding, cinfo_struct->encoding);
          }

        cd->stream = net_ftp_make_stream(ce->format_out, ce->URL_s, ce->window_id);
      }

    if (!cd->stream)
      {
        cd->next_state = FTP_ERROR_DONE;
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_CONVERT);
        return(MK_UNABLE_TO_CONVERT);
      }

HG69136

    if(cd->pasv_mode)
      {
        if(cd->is_directory)
           cd->next_state = FTP_START_READ_DIRECTORY;
        else
           cd->next_state = FTP_START_READ_FILE;
      }
    else
      { /* non PASV */
        cd->next_state = FTP_WAIT_FOR_ACCEPT;
      }

    /* start the graph progress indicator
     */
    FE_GraphProgressInit(ce->window_id, ce->URL_s, ce->URL_s->real_content_length);
    cd->destroy_graph_progress = TRUE;
    cd->original_content_length = ce->URL_s->real_content_length;

    return(0); /* continue */
}

PRIVATE int
net_wait_for_ftp_accept(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;
    PRNetAddr pr_addr;

/* make this non-blocking sometime */

    /* Wait for the connection
     */
#define ACCEPT_TIMEOUT 20
    cd->dsock = PR_Accept(cd->listen_sock, &pr_addr, ACCEPT_TIMEOUT);

    if (cd->dsock == NULL)
      {
        if(PR_GetError() == PR_WOULD_BLOCK_ERROR)
          {
            cd->pause_for_read = TRUE; /* pause */
            NET_ClearReadSelect(ce->window_id, ce->socket);
            ce->socket = cd->listen_sock;
            NET_SetReadSelect(ce->window_id, ce->socket);
            return(0);
          }
        else
          {
            ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_ACCEPT_SOCKET);
            return MK_UNABLE_TO_ACCEPT_SOCKET;
          }
      }

    TRACEMSG(("FTP: Accepted new socket %d\n", cd->dsock));

    if(cd->file_to_post || ce->URL_s->method == URL_POST_METHOD)
      {
        ce->socket = cd->dsock;
        NET_SetConnectSelect(ce->window_id, ce->socket);
        cd->next_state = FTP_DO_PUT;
      }
    else if (cd->is_directory)
      {
        cd->next_state = FTP_START_READ_DIRECTORY;
      }
    else
      {
        cd->next_state = FTP_START_READ_FILE;
      }

    return(0);
}

PRIVATE int
net_ftp_push_partial_cache_file(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    int32 write_ready, status;

    write_ready = (*cd->stream->is_write_ready)(cd->stream);

    if( 0 == write_ready )
      {
        cd->pause_for_read = TRUE;
        return(0);  /* wait until we are ready to write */
      }

    write_ready = MIN(write_ready, NET_Socket_Buffer_Size);

    status = XP_FileRead(NET_Socket_Buffer, write_ready, cd->partial_cache_fp);

    if( status < 0 )
    {
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_TCP_READ_ERROR, SOCKET_ERRNO);
        return MK_TCP_READ_ERROR;
    }
    else if( status == 0 )
    {
        /* All done, switch over to incoming data */
        TRACEMSG(("Closing FTP cache file"));
        NET_Progress(ce->window_id, XP_GetString(XP_PROGRESS_FILEDONE));
        NET_ClearFileReadSelect(ce->window_id, XP_Fileno(cd->partial_cache_fp));
        XP_FileClose(cd->partial_cache_fp);
        cd->partial_cache_fp = NULL;
        ce->socket = cd->dsock;
        NET_SetReadSelect(ce->window_id, ce->socket);
        ce->local_file = FALSE;
        cd->next_state = FTP_READ_FILE;
        NET_Progress (ce->window_id, XP_GetString(XP_PROGRESS_RECEIVE_FTPFILE));
        return 0;
    }
    else
    {
        /* write the data */
        TRACEMSG(("Transferring %ld bytes from cache file.", status));
        ce->bytes_received += status;
        FE_GraphProgress(ce->window_id, ce->URL_s, ce->bytes_received, status, ce->URL_s->real_content_length);
        FE_SetProgressBarPercent(ce->window_id, (long)(((double)ce->bytes_received*100) / (double)(uint32)ce->URL_s->real_content_length) );
        status = (*cd->stream->put_block)(cd->stream, NET_Socket_Buffer, status);
        cd->pause_for_read = TRUE;
        return status;
    }
}

PRIVATE int
net_start_ftp_read_file(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if( cd->restart )
    {
        char *cache_file = ce->URL_s->cache_file;
        XP_File fp;

        TRACEMSG(("Opening FTP cache file"));

        if( (NULL == cache_file) || (NULL == (fp = XP_FileOpen(cache_file, xpCache, XP_FILE_READ_BIN))) )
        {
            ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_UNABLE_TO_OPEN_FILE, cache_file);
            return MK_UNABLE_TO_OPEN_FILE;
        }

        NET_ClearReadSelect(ce->window_id, ce->socket);
        /* ce->socket = XP_Fileno(fp); */
        ce->socket = NULL;
        NET_SetFileReadSelect(ce->window_id, XP_Fileno(fp));
        ce->local_file = TRUE;
        cd->next_state = FTP_READ_CACHE;
        cd->partial_cache_fp = fp;
        NET_Progress(ce->window_id, XP_GetString(XP_PROGRESS_READFILE));
        return net_ftp_push_partial_cache_file(ce);
    }

    /* nothing much to be done */
    cd->next_state = FTP_READ_FILE;
    cd->pause_for_read = TRUE;

    NET_ClearReadSelect(ce->window_id, ce->socket);
    ce->socket = cd->dsock;
    NET_SetReadSelect(ce->window_id, ce->socket);

    NET_Progress (ce->window_id, XP_GetString(XP_PROGRESS_RECEIVE_FTPFILE));

    return(0); /* continue */
}

PRIVATE int
net_ftp_read_file(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;
    int status;
    unsigned int write_ready, read_size;

    /* check to see if the stream is ready for writing
     */
    write_ready = (*cd->stream->is_write_ready)(cd->stream);

    if(!write_ready)
      {
        cd->pause_for_read = TRUE;
        return(0);  /* wait until we are ready to write */
      }
    else if(write_ready < (unsigned int) NET_Socket_Buffer_Size)
      {
        read_size = write_ready;
      }
    else
      {
        read_size = NET_Socket_Buffer_Size;
      }

    status = PR_Read(cd->dsock, NET_Socket_Buffer, read_size);

    if(status > 0)
      {
        ce->bytes_received += status;
        FE_GraphProgress(ce->window_id, ce->URL_s, ce->bytes_received, status, ce->URL_s->real_content_length);
        if (ce->URL_s->real_content_length == 0)
            FE_SetProgressBarPercent(ce->window_id, 0);
        else
            FE_SetProgressBarPercent(ce->window_id, (long)(((double)ce->bytes_received*100) / (double)(uint32)ce->URL_s->real_content_length) );
        status = PUTBLOCK(NET_Socket_Buffer, status);
        cd->pause_for_read = TRUE;
      }
    else if(status == 0)
      {
        /* go read the response since we need to
         * get the "226 sucessful transfer" message
         * out of the read queue in order to cache
         * connections properly
         */
        cd->next_state = FTP_WAIT_FOR_RESPONSE;
        cd->next_state_after_response = FTP_DONE;

        if(cd->dsock != NULL)
          {
            NET_ClearReadSelect(ce->window_id, cd->dsock);
            PR_Close(cd->dsock);
            cd->dsock = NULL;
          }

        /* set select on the control socket */
        ce->socket = cd->cc->csock;
        NET_SetReadSelect(ce->window_id, ce->socket);
        /* try and read the response immediately,
         * so don't pause for read
         *
         * cd->pause_for_read = TRUE;
         */

        return(MK_DATA_LOADED);
      }
    else
      {
        /* status less than zero
         */
          int rv = PR_GetError();

        if (rv == PR_WOULD_BLOCK_ERROR)
          {
            cd->pause_for_read = TRUE;
            return 0;
          }
          status = (rv < 0) ? rv : (-rv);
      }

   return(status);
}

PRIVATE int
net_start_ftp_read_dir(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;
    char buf[512];
    char *line;

    cd->sort_base = NET_SortInit();

    NET_Progress (ce->window_id, XP_GetString(XP_PROGRESS_RECEIVE_FTPDIR));

    if (*cd->path != '\0')  /* Not Empty path: */
      {
        int end;

        end = XP_STRLEN(cd->path)-1;
        /* if the path ends with a slash kill it.
         * that includes the path "/"
         */
        if(cd->path[end] == '/')
          {
             cd->path[end] = 0; /* kill the last slash */
          }
      }

    if(cd->login_message_buffer) /* Don't check !(*cd->path) here or this
                                    message never shows up.  It's supposed to
                                    be shown the first time you connect to
                                    this server, whether you started at the
                                    root or not. */
      {

        /* print it out like so:  101: message line 1
         *                        101: message line 2, etc...
          */
        line = XP_STRTOK(cd->login_message_buffer, "\n");
        while(ce->status >= 0 && line)
        {
            XP_STRCPY(buf, "101: ");
            XP_STRNCAT_SAFE (buf, line, sizeof(buf)-8);
            XP_STRCAT (buf, CRLF);

            ce->status = PUTSTRING(buf);

            line = XP_STRTOK(NULL, "\n");
        }

        /* if there is also a cwd message add a blank line */
        if(ce->status >= 0 && cd->cwd_message_buffer)
        {
            XP_STRCPY(buf, "101: "CRLF);
            ce->status = PUTSTRING(buf);
        }
    }

    if(cd->cwd_message_buffer)
    {
        /* print it out like so:  101: message line 1
         *                        101: message line 2, etc...
          */
        char *end_line = XP_STRCHR(cd->cwd_message_buffer, '\n');
        if(end_line)
            *end_line = '\0';
        line = cd->cwd_message_buffer;

        while(ce->status >= 0 && line)
        {
            XP_STRCPY(buf, "101: ");
            XP_STRNCAT_SAFE (buf, line, sizeof(buf)-8);
            XP_STRCAT (buf, CRLF);

            ce->status = PUTSTRING(buf);

            if(end_line)
            {
                line = end_line+1;
                end_line = XP_STRCHR(line, '\n');
                if(end_line)
                    *end_line = '\0';
            }
            else
            {
                line = NULL;
            }
        }
    }

    /* clear the buffer so we can use it on the data sock */
    FREE_AND_CLEAR(cd->data_buf);
    cd->data_buf_size = 0;

    cd->next_state = FTP_READ_DIRECTORY;

    /* clear the select on the control socket
     */
    NET_ClearReadSelect(ce->window_id, ce->socket);
    ce->socket = cd->dsock;
    NET_SetReadSelect(ce->window_id, ce->socket);

    return(0); /* continue */
}

PRIVATE int
net_ftp_read_dir(ActiveEntry * ce)
{

    char * line;
    NET_FileEntryInfo * entry_info;
    FTPConData * cd = (FTPConData *)ce->con_data;

    ce->status = NET_BufferedReadLine(cd->dsock, &line, &cd->data_buf,
                    &cd->data_buf_size, &cd->pause_for_read);

    if(ce->status == 0)
      {
        cd->next_state = FTP_PRINT_DIR;
        return(ce->status);
      }
    else if(ce->status < 0)
      {
        if(cd->stream && (*cd->stream->is_write_ready)(cd->stream))
            NET_PrintDirectory(&cd->sort_base, cd->stream, cd->path, ce->URL_s);

        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_TCP_READ_ERROR, ce->status);

        /* return TCP error
         */
        return MK_TCP_READ_ERROR;
      }

    /* not exactly right but really close
     */
    if(ce->status > 1)
      {
        ce->bytes_received += ce->status;
        FE_GraphProgress(ce->window_id, ce->URL_s, ce->bytes_received, ce->status, ce->URL_s->content_length);
      }

    if(!line)
        return(0); /* no line ready */

    TRACEMSG(("MKFTP: Line in %s is %s\n", cd->path, line));

    entry_info = net_parse_dir_entry(line, cd->cc->server_type);

    if(!entry_info)
      {
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_OUT_OF_MEMORY);
        return(MK_OUT_OF_MEMORY);
      }

    if(entry_info->display)
      {
        TRACEMSG(("Adding file to sort list: %s\n", entry_info->filename));
        NET_SortAdd(cd->sort_base, (void *)entry_info);
      }
    else
      {
        NET_FreeEntryInfoStruct(entry_info);
      }

    return(ce->status);
}

PRIVATE int
net_ftp_print_dir(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    if(!cd->calling_netlib_all_the_time)
    {

        cd->calling_netlib_all_the_time = TRUE;
        NET_SetCallNetlibAllTheTime(ce->window_id, "mkftp");
    }

    if(cd->stream
       && (ce->status = (*cd->stream->is_write_ready)(cd->stream)) != 0)
    {
        ce->status = NET_PrintDirectory(&cd->sort_base, cd->stream, cd->path, ce->URL_s);

        /* go read the response since we need to
         * get the "226 sucessful transfer" message
         * out of the read queue in order to cache
         * connections properly
         */
        cd->next_state = FTP_WAIT_FOR_RESPONSE;
        cd->next_state_after_response = FTP_DONE;

        /* clear select on the data sock and set select on the control sock
         */
        if(cd->dsock != NULL)
          {
            NET_ClearReadSelect(ce->window_id, cd->dsock);
            PR_Close(cd->dsock);
            cd->dsock = NULL;
          }

        ce->socket = cd->cc->csock;
        NET_SetReadSelect(ce->window_id, cd->cc->csock);

        return(ce->status);
      }
    else
      {
        /* come back into this state and try again later */
        /* @@@ busy wait */
        cd->pause_for_read = TRUE;
        return(0);
      }
}

/*
 * is_ls_date() --
 *      Return 1 if the ptr points to a string of the form:
 *              "Sep  1  1990 " or
 *              "Sep 11 11:59 " or
 *              "Dec 12 1989  " or
 *              "FCv 23 1990  " ...
 */
PRIVATE Bool
net_is_ls_date (char *s)
{
    /* must start with three alpha characters */
    if (!isalpha(*s++) || !isalpha(*s++) || !isalpha(*s++))
        return FALSE;

    /* space */
    if (*s++ != ' ')
        return FALSE;

    /* space or digit */
    if ((*s != ' ') && !isdigit(*s))
        return FALSE;
    s++;

    /* digit */
    if (!isdigit(*s++))
        return FALSE;

    /* space */
    if (*s++ != ' ')
        return FALSE;

    /* space or digit */
    if ((*s != ' ') && !isdigit(*s))
        return FALSE;
    s++;

    /* digit */
    if (!isdigit(*s++))
        return FALSE;

    /* colon or digit */
    if ((*s != ':') && !isdigit(*s))
        return FALSE;
    s++;

    /* digit */
    if (!isdigit(*s++))
        return FALSE;

    /* space or digit */
    if ((*s != ' ') && !isdigit(*s))
        return FALSE;
    s++;

    /* space */
    if (*s++ != ' ')
        return FALSE;

    return TRUE;
} /* is_ls_date() */

/*
 *  Converts a date string from 'ls -l' to a time_t number
 *
 *              "Sep  1  1990 " or
 *              "Sep 11 11:59 " or
 *              "Dec 12 1989  " or
 *              "FCv 23 1990  " ...
 *
 *  Returns 0 on error.
 */
PRIVATE time_t net_convert_unix_date (char * datestr)
{
    struct tm *time_info;         /* Points to static tm structure */
    char *bcol = datestr;         /* Column begin */
    char *ecol;                   /* Column end */
    long tval;
    int cnt;
    time_t curtime = time(NULL);

    if ((time_info = gmtime(&curtime)) == NULL)
      {
        return (time_t) 0;
      }

    time_info->tm_isdst = -1;                 /* Disable summer time */
    for (cnt=0; cnt<3; cnt++)                 /* Month */
        *bcol++ = toupper(*bcol);

    if ((time_info->tm_mon = NET_MonthNo(datestr)) < 0)
        return (time_t) 0;

    ecol = bcol;                        /* Day */
    while (*ecol++ == ' ') ;            /* Spool to other side of day */
    while (*ecol++ != ' ') ;
    *--ecol = '\0';

    time_info->tm_mday = atoi(bcol);
    time_info->tm_wday = 0;
    time_info->tm_yday = 0;
    bcol = ++ecol;                                   /* Year */
    if ((ecol = XP_STRCHR(bcol, ':')) == NULL)
      {
        time_info->tm_year = atoi(bcol)-1900;
        time_info->tm_sec = 0;
        time_info->tm_min = 0;
        time_info->tm_hour = 0;
      }
    else
      {                                 /* Time */
        /* If the time is given as hh:mm, then the file is less than 1 year
         *    old, but we might shift calandar year. This is avoided by checking
         *    if the date parsed is future or not.
         */
        *ecol = '\0';
        time_info->tm_sec = 0;
        time_info->tm_min = atoi(++ecol);           /* Right side of ':' */
        time_info->tm_hour = atoi(bcol);         /* Left side of ':' */
        if (mktime(time_info) > curtime)
            --time_info->tm_year;
      }
    return ((tval = mktime(time_info)) == -1 ? (time_t) 0 : tval);
}

/* a dos date/time string looks like this
 * 04-06-95  02:03PM
 * 07-13-95  11:39AM
 */
PRIVATE time_t
net_parse_dos_date_time (char * datestr)
{
    struct tm *time_info;         /* Points to static tm structure */
    long tval;
    time_t curtime = time(NULL);

    if ((time_info = gmtime(&curtime)) == NULL)
      {
        return (time_t) 0;
      }

    time_info->tm_isdst = -1;                 /* Disable summer time */

    time_info->tm_mon = (datestr[1]-'0')-1;

    time_info->tm_mday = (((datestr[3]-'0')*10) + datestr[4]-'0');
    time_info->tm_year = (((datestr[6]-'0')*10) + datestr[7]-'0');
    time_info->tm_hour = (((datestr[10]-'0')*10) + datestr[11]-'0');
    if(datestr[15] == 'P')
        time_info->tm_hour += 12;
    time_info->tm_min = (((datestr[13]-'0')*10) + datestr[14]-'0');

    time_info->tm_wday = 0;
    time_info->tm_yday = 0;
    time_info->tm_sec = 0;

    return ((tval = mktime(time_info)) == -1 ? (time_t) 0 : tval);
}

/*
 *  Converts a date string from vms to a time_t number
 *  This is needed in order to put out the date using the same format
 *  for all directory listings.
 *
 *  Returns 0 on error
 */
PRIVATE time_t net_convert_vms_date (char * datestr)
{
    struct tm *time_info;           /* Points to static tm structure */
    char *col;
    long tval;
    time_t curtime = time(NULL);

    if ((time_info = gmtime(&curtime)) == NULL)
        return (time_t) 0;

    time_info->tm_isdst = -1;                 /* Disable summer time */

    if ((col = XP_STRTOK(datestr, "-")) == NULL)
        return (time_t) 0;

    time_info->tm_mday = atoi(col);                   /* Day */
    time_info->tm_wday = 0;
    time_info->tm_yday = 0;

    if ((col = XP_STRTOK(NULL, "-")) == NULL || (time_info->tm_mon = NET_MonthNo(col)) < 0)
        return (time_t) 0;

    if ((col = XP_STRTOK(NULL, " ")) == NULL)               /* Year */
        return (time_t) 0;

    time_info->tm_year = atoi(col)-1900;

    if ((col = XP_STRTOK(NULL, ":")) == NULL)               /* Hour */
        return (time_t) 0;

    time_info->tm_hour = atoi(col);

    if ((col = XP_STRTOK(NULL, " ")) == NULL)               /* Mins */
        return (time_t) 0;

    time_info->tm_min = atoi(col);
    time_info->tm_sec = 0;

    return ((tval = mktime(time_info)) < 0 ? (time_t) 0 : tval);
}


/*
 * parse_ls_line() --
 *      Extract the name, size, and date from an ls -l line.
 *
 * ls -l listing
 *
 * drwxr-xr-x    2 montulli eng          512 Nov  8 23:23 CVS
 * -rw-r--r--    1 montulli eng         2244 Nov  8 23:23 Imakefile
 * -rw-r--r--    1 montulli eng        14615 Nov  9 17:03 Makefile
 *
 * or a dl listing
 *
 * cs.news/              =  ICSI Computing Systems Newsletter
 * dash/                 -  DASH group documents and software
 * elisp/                -  Emacs lisp code
 *
 */
PRIVATE void
net_parse_ls_line (char *line, NET_FileEntryInfo *entry_info)
{
    int32   base=1;
    int32   size_num=0;
    char    save_char;
    char   *ptr;

    for (ptr = &line[XP_STRLEN(line) - 1];
            (ptr > line+13) && (!XP_IS_SPACE(*ptr) || !net_is_ls_date(ptr-12)); ptr--)
                ; /* null body */
    save_char = *ptr;
    *ptr = '\0';
    if (ptr > line+13)
      {
        entry_info->date = net_convert_unix_date(ptr-12);
      }
    else
      {
        /* must be a dl listing
         */
        /* unterminate the line */
        *ptr = save_char;
        /* find the first whitespace and  terminate
         */
        for(ptr=line; *ptr != '\0'; ptr++)
            if(XP_IS_SPACE(*ptr))
              {
                *ptr = '\0';
                break;
              }
        entry_info->filename = NET_Escape(line, URL_PATH);

        return;
      }

    /* escape and copy
     */
    entry_info->filename = NET_Escape(ptr+1, URL_PATH);

    /* parse size
     */
    if(ptr > line+15)
      {
        ptr -= 14;
        while (isdigit(*ptr))
          {
            size_num += ((int32) (*ptr - '0')) * base;
            base *= 10;
            ptr--;
          }

        entry_info->size = size_num;
      }

} /* parse_ls_line() */

/*
 * net_parse_vms_dir_entry()
 *      Format the name, date, and size from a VMS LIST line
 *      into the EntryInfo structure
 */
PRIVATE void
net_parse_vms_dir_entry (char *line, NET_FileEntryInfo *entry_info)
{
        int i, j;
        int32 ialloc;
        char *cp, *cpd, *cps, date[64], *sp = " ";
        time_t NowTime;
        static char ThisYear[32];
        static Bool HaveYear = FALSE;

        /**  Get rid of blank lines, and information lines.  **/
        /**  Valid lines have the ';' version number token.  **/
        if (!XP_STRLEN(line) || (cp=XP_STRCHR(line, ';')) == NULL)
          {
            entry_info->display = FALSE;
            return;
          }

        /** Cut out file or directory name at VMS version number. **/
        *cp++ ='\0';
        /* escape and copy
          */
        entry_info->filename = NET_Escape(line, URL_PATH);

        /** Cast VMS file and directory names to lowercase. **/
        for (i=0; entry_info->filename[i]; i++)
            entry_info->filename[i] = tolower(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=XP_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';

        /* Save the current year.
         * It could be wrong on New Year's Eve.
         */
        if (!HaveYear)
           {
            NowTime = time(NULL);
            XP_STRCPY(ThisYear, (char *)ctime(&NowTime)+20);
            ThisYear[4] = '\0';
            HaveYear = TRUE;
          }

        /* get the date.
         */
        if ((cpd=XP_STRCHR(cp, '-')) != NULL &&
                XP_STRLEN(cpd) > 9 && isdigit(*(cpd-1)) &&
                isalpha(*(cpd+1)) && *(cpd+4) == '-')
          {

            /* Month
             */
            *(cpd+4) = '\0';
            *(cpd+2) = tolower(*(cpd+2));
            *(cpd+3) = tolower(*(cpd+3));
            XP_SPRINTF(date, "%.32s ", cpd+1);
            *(cpd+4) = '-';

            /** Day **/
            *cpd = '\0';
            if (isdigit(*(cpd-2)))
                XP_SPRINTF(date+4, "%.32s ", cpd-2);
            else
                XP_SPRINTF(date+4, " %.32s ", cpd-1);
            *cpd = '-';

            /** Time or Year **/
            if (!XP_STRNCMP(ThisYear, cpd+5, 4) && XP_STRLEN(cpd) > 15 && *(cpd+12) == ':')
              {
                *(cpd+15) = '\0';
                XP_SPRINTF(date+7, "%.32s", cpd+10);
                *(cpd+15) = ' ';
              }
            else
              {
                *(cpd+9) = '\0';
                XP_SPRINTF(date+7, " %.32s", cpd+5);
                *(cpd+9) = ' ';
              }

            entry_info->date = net_convert_vms_date(date);
          }

        /* get the size
         */
        if ((cpd=XP_STRCHR(cp, '/')) != NULL)
          {
            /* Appears be in used/allocated format */
            cps = cpd;
            while (isdigit(*(cps-1)))
                cps--;
            if (cps < cpd)
                *cpd = '\0';
            entry_info->size = atol(cps);
            cps = cpd+1;
            while (isdigit(*cps))
                cps++;
            *cps = '\0';
            ialloc = atoi(cpd+1);
            /* Check if used is in blocks or bytes */
            if (entry_info->size <= ialloc)
                entry_info->size *= 512;
          }
        else if ((cps=XP_STRTOK(cp, sp)) != NULL)
          {
            /* We just initialized on the version number
             * Now let's find a lone, size number
             */
            while ((cps=XP_STRTOK(NULL, sp)) != NULL)
              {
                 cpd = cps;
                 while (isdigit(*cpd))
                     cpd++;
                 if (*cpd == '\0')
                   {
                     /* Assume it's blocks */
                     entry_info->size = atol(cps) * 512;
                     break;
                   }
               }
          }

        /** Wrap it up **/
        TRACEMSG(("MKFTP: VMS filename: %s  date: %d  size: %ld\n",
                         entry_info->filename, entry_info->date, entry_info->size));
        return;

} /* net_parse_vms_dir_entry() */

/*
 *     parse_dir_entry()
 *      Given a line of LIST/NLST output in entry, return results
 *      and a file/dir name in entry_info struct
 *
 */
PRIVATE NET_FileEntryInfo *
net_parse_dir_entry (char *entry, int server_type)
{
        NET_FileEntryInfo *entry_info;
        int  i;
        int  len;
        Bool remove_size=FALSE;

        entry_info = NET_CreateFileEntryInfoStruct();
        if(!entry_info)
            return(NULL);

        entry_info->display = TRUE;

        /* do special case for ambiguous NT servers
         *
         * ftp.microsoft.com is an NT server with UNIX ls -l
         * syntax.  But most NT servers use the DOS dir syntax.
         * If there is a space at position 8 then it's a DOS dir syntax
         */
        if(server_type == FTP_NT_TYPE && !XP_IS_SPACE(entry[8]))
            server_type = FTP_UNIX_TYPE;

        switch (server_type)
        {
            case FTP_UNIX_TYPE:
            case FTP_PETER_LEWIS_TYPE:
            case FTP_MACHTEN_TYPE:
                /* interpret and edit LIST output from Unix server */

                if(!XP_STRNCMP(entry, "total ", 6)
                        || (XP_STRSTR(entry, "Permission denied") != NULL)
                            ||     (XP_STRSTR(entry, "not available") != NULL))
                  {
                    entry_info->display=FALSE;
                    return(entry_info);
                  }

                len = XP_STRLEN(entry);

                if( '+' == entry[0] )
                {
                    /*
                     * EPLF: see http://pobox.com/~djb/proto/eplf.txt
                     * "+i8388621.29609,m824255902,/,\tdev"
                     * "+i8388621.44468,m839956783,r,s10376,\tRFCEPLF"
                     *
                     * A plus, a bunch of comma-separated facts, a tab,
                     * and then the name.  Facts include m for mdtm (as
                     * seconds since the Unix epoch), s for size, r for
                     * (readable) file, and / for (listable) directory.
                     */
                    char *tab = XP_STRCHR(entry, '\t');
                    char *begin, *end;
                    remove_size = TRUE; /* It'll be put back if we have data */
                    if( (char *)0 == tab ) break;
                    for( begin = &entry[1]; begin < tab; begin = &end[1])
                    {
                        end = XP_STRCHR(begin, ',');
                        if( (char *)0 == end ) break;
                        switch( *begin )
                        {
                            case 'm':
                                *end = '\0';
                                entry_info->date = XP_ATOI(&begin[1]);
                                *end = ',';
                                break;
                            case 's':
                                *end = '\0';
                                entry_info->size = XP_ATOI(&begin[1]);
                                *end = ',';
                                remove_size = FALSE;
                                break;
                            case 'r':
                                entry_info->special_type = NET_FILE_TYPE;
                                break;
                            case '/':
                                entry_info->special_type = NET_DIRECTORY;
                                break;
                            default:
                                break;
                        }
                    }

                    entry_info->filename = NET_Escape(&tab[1], URL_PATH);
                    break;
                }
                else
                /* check first character of ls -l output */
                if (toupper(entry[0]) == 'D')
                  {
                    /* it's a directory */
                    entry_info->special_type = NET_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
                     */
                    entry_info->special_type = NET_SYM_LINK;
                    remove_size=TRUE; /* size is not useful */

                    /* strip off " -> pathname" */
                    for (i = len - 1; (i > 3) && (!XP_IS_SPACE(entry[i])
                    || (entry[i-1] != '>')
                    || (entry[i-2] != '-')
                    || (entry[i-3] != ' ')); i--)
                             ; /* null body */
                    if (i > 3)
                      {
                        entry[i-3] = '\0';
                        len = i - 3;
                      }
                  } /* link */

                net_parse_ls_line(entry, entry_info);

                if(!XP_STRCMP(entry_info->filename,"..") || !XP_STRCMP(entry_info->filename,"."))
                    entry_info->display=FALSE;

                /* add a trailing slash to all directories */
                if(entry_info->special_type == NET_DIRECTORY)
                    StrAllocCat(entry_info->filename, "/");

                /* goto the bottom and get real type */
                break;

            case FTP_VMS_TYPE:
                /* Interpret and edit LIST output from VMS server */
                /* and convert information lines to zero length.  */
                net_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 = XP_STRLEN(entry_info->filename);
                if ((len > 4) && !XP_STRCMP(&entry_info->filename[len-4], ".dir"))
                  {
                    entry_info->filename[len-4] = '\0';
                    entry_info->special_type = NET_DIRECTORY;
                    remove_size=TRUE; /* size is not useful */
                    /* add trailing slash to directories
                     */
                    StrAllocCat(entry_info->filename, "/");
                  }
                /* goto the bottom and get real type */
                break;

            case FTP_CMS_TYPE:
                /* can't be directory... */
                /*
                 * "entry" already equals the correct filename
                 */
                /* escape and copy
                  */
                entry_info->filename = NET_Escape(entry, URL_PATH);
                /* goto the bottom and get real type */
                break;

            case FTP_NCSA_TYPE:
            case FTP_TCPC_TYPE:
                /* directories identified by trailing "/" characters */
                /* escape and copy
                  */
                entry_info->filename = NET_Escape(entry, URL_PATH);
                len = XP_STRLEN(entry);
                if (entry[len-1] == '/')
                  {
                    entry_info->special_type = NET_DIRECTORY;
                    remove_size=TRUE; /* size is not useful */
                  }
                  /* goto the bottom and get real type */
                break;

            case FTP_NT_TYPE:
                /* windows NT DOS dir syntax.
                 * looks like:
                 *            1         2         3         4         5
                 *  012345678901234567890123456789012345678901234567890
                 *  06-29-95  03:05PM       <DIR>          muntemp
                 *  05-02-95  10:03AM               961590 naxp11e.zip
                 *
                 *  The date time directory indicator and filename
                 *  are always in a fixed position.  The file
                  *  size always ends at position 37.
                 */
                  {
                    char *date, *size_s, *name;

                    if(XP_STRLEN(entry) > 37)
                      {
                        date = entry;
                        entry[17] = '\0';
                        size_s = &entry[18];
                        entry[38] = '\0';
                        name = &entry[39];

                        if(XP_STRSTR(size_s, "<DIR>"))
                            entry_info->special_type = NET_DIRECTORY;
                        else
                            entry_info->size = atol(XP_StripLine(size_s));

                        entry_info->date = net_parse_dos_date_time(date);

                        StrAllocCopy(entry_info->filename, name);
                      }
                    else
                      {
                        StrAllocCopy(entry_info->filename, entry);
                      }
                  }
                break;

            default:
                /* we cant tell if it is a directory since we only
                 * did an NLST
                 */
                /* escape and copy
                  */
                entry_info->filename = NET_Escape(entry, URL_PATH);
                return(entry_info); /* mostly empty info */
                /* break; Not needed */

        } /* switch (server_type) */


    if(remove_size && entry_info->size)
      {
        entry_info->size = 0;
      }

    /* get real types eventually */
    if(!entry_info->special_type)
      {
        entry_info->cinfo = NET_cinfo_find_type(entry_info->filename);
      }

    return(entry_info);

} /* net_parse_dir_entry */

PRIVATE int
net_get_ftp_password(ActiveEntry *ce)
{
    FTPConData *cd = (FTPConData *) ce->con_data;

    if(!cd->password)
      {
        char * host_string = NET_ParseURL(ce->URL_s->address, GET_HOST_PART);

#ifndef MCC_PROXY
        if(ftp_last_password
                && ftp_last_password_host
                    && !XP_STRCMP(ftp_last_password_host, host_string))
          {
            StrAllocCopy(cd->password, ftp_last_password);
          }
        else
#endif
          {
            /* check for cached password */
            char *key = gen_ftp_password_key(ce->URL_s->address, cd->username);

            if(key)
            {
                PCNameValueArray * array = PC_CheckForStoredPasswordArray(PC_FTP_MODULE_KEY, key);

                if(array)
                    cd->password = PC_FindInNameValueArray(array, PC_FTP_PASSWORD_KEY);

                PC_FreeNameValueArray(array);

                FREE(key);
            }

            if(!cd->password)
            {
                PR_snprintf(cd->output_buffer, OUTPUT_BUFFER_SIZE,
                            XP_GetString(XP_PROMPT_ENTER_PASSWORD),
                            host_string);
                cd->password = (char *)PC_PromptPassword(ce->window_id,
                                                     cd->output_buffer,
                                                     &cd->store_password,
                                                     FALSE /* not secure */);

                if(!cd->password)
                  {
                    FREE(host_string);
                    return(MK_INTERRUPTED);  /* user canceled */
                  }
            }

            StrAllocCopy(ftp_last_password_host, host_string);
            StrAllocCopy(ftp_last_password, cd->password);
          }

        FREE(host_string);
      }

    cd->next_state = FTP_SEND_PASSWORD;

    return 0;
}

PRIVATE int
net_get_ftp_password_response(FTPConData *cd)
{
    /* not used yet
     */
    return 0; /* #### what should return value be? */
}

/* the load initializeation routine for FTP.
 *
 * this sets up all the data structures and begin's the
 * connection by calling processFTP
 */
PRIVATE int32
net_FTPLoad (ActiveEntry * ce)
{
    char * host = NET_ParseURL(ce->URL_s->address, GET_HOST_PART);
    char * unamePwd = NET_ParseURL(ce->URL_s->address, GET_USERNAME_PART | GET_PASSWORD_PART);
    char *username,*colon,*password=NULL;
    char * filename;
    char * semi_colon;
    FTPConData * cd = XP_NEW(FTPConData);

    if(!cd)
      {
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_OUT_OF_MEMORY);
        ce->status = MK_OUT_OF_MEMORY;
        return(MK_OUT_OF_MEMORY);
      }

    /* get the username & password out of the combo string */
    if( (colon = XP_STRCHR(unamePwd, ':')) != NULL ) {
        *colon='\0';
        username=XP_STRDUP(unamePwd);
        password=XP_STRDUP(colon+1);
        *colon=':';
        XP_FREE(unamePwd);
    } else {
        username=unamePwd;
    }

    ce->con_data = (FTPConData *)cd;

    /* init the connection data struct
     */
    XP_MEMSET(cd, 0, sizeof(FTPConData));
    cd->dsock         = NULL;
    cd->listen_sock   = NULL;
    cd->pasv_mode     = TRUE;
    cd->is_directory  = FALSE;
    cd->next_state_after_response = FTP_ERROR_DONE;
    cd->cont_response     = -1;

    /* @@@@ hope we never need a buffer larger than this
     */
    cd->output_buffer = (char *) XP_ALLOC(OUTPUT_BUFFER_SIZE);
    if(!cd->output_buffer)
      {
        FREE(cd);
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_OUT_OF_MEMORY);
        ce->status = MK_OUT_OF_MEMORY;
        return(MK_OUT_OF_MEMORY);
      }

    if (username && *username) {
        StrAllocCopy(cd->username, username);
        if (password && *password)
            StrAllocCopy(cd->password, password);
    } else {
        const char * user = NULL;
        XP_FREEIF(username);
        username = NULL;
        XP_FREEIF(password);
        password = NULL;

#ifdef MOZ_MAIL_NEWS
#ifdef MOZILLA_CLIENT
        if(net_get_send_email_address_as_password())
            user = FE_UsersMailAddress();
#endif
#endif /* MOZ_MAIL_NEWS */

        if(user && *user)
          {
            StrAllocCopy(cd->password, user);

            /* make sure it has an @ sign in it or else the ftp
             * server won't like it
             */
            if(!XP_STRCHR(cd->password, '@'))
                StrAllocCat(cd->password, "@");
          }
        else
          {
            StrAllocCopy(cd->password, "mozilla@");
          }
    }

    /* get the path */
    cd->path = NET_ParseURL(ce->URL_s->address, GET_PATH_PART);

    if(!cd->path)
      {
        FREE(ce->con_data);
        FREE(cd->output_buffer);
        ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_OUT_OF_MEMORY);
        ce->status = MK_OUT_OF_MEMORY;
        return(MK_OUT_OF_MEMORY);
      }

    NET_UnEscape(cd->path);

    if(*cd->path == '\0')
      {
        TRACEMSG(("Found ftp url with NO PATH"));

        cd->use_default_path = TRUE;
      }
    else
      {
        /* terminate at an "\r" or "\n" in the string
         * this prevents URL's of the form "foo\nDELE foo"
         */
        XP_STRTOK(cd->path, "\r");
        XP_STRTOK(cd->path, "\n");
      }

    /* if the path begins with /./
     * use pwd to get the sub path
     * and append the end to it
     */
    if(!XP_STRNCMP(cd->path, "/./", 3) || !XP_STRCMP(cd->path, "/."))
      {
        char * tmp = cd->path;

        cd->use_default_path = TRUE;

        /* skip the "/." and leave a slash at the beginning */
        cd->path = XP_STRDUP(cd->path+2);
        XP_FREE(tmp);

        if(!cd->path)
          {
            FREE(ce->con_data);
            FREE(cd->output_buffer);
            ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_OUT_OF_MEMORY);
            ce->status = MK_OUT_OF_MEMORY;
            return(MK_OUT_OF_MEMORY);
          }
      }

    /* set the default type for use later
     */
    cd->type = FTP_MODE_UNKNOWN;

    TRACEMSG(("content length: %d, real content length: %d",
           ce->URL_s->content_length, ce->URL_s->real_content_length));
    if( (ce->URL_s->real_content_length > ce->URL_s->content_length) &&
        (NULL != ce->URL_s->cache_file) )
    {
        cd->restart = TRUE;
        TRACEMSG(("Considering a restart."));
    }

    /* look for the extra type information at the end per
     * the RFC 1630.  It will be delimited by a ';'
     */
    if((semi_colon = XP_STRRCHR(cd->path, ';')) != NULL)
      {
        /* just switch on the character at the end of this whole
         * thing since it must be the type to use
         */
        switch(semi_colon[XP_STRLEN(semi_colon)-1])
          {
            case 'a':
            case 'A':
                cd->type = FTP_MODE_ASCII;
                TRACEMSG(("Explicitly setting type ASCII"));
                break;

            case 'i':
            case 'I':
                cd->type = FTP_MODE_BINARY;
                TRACEMSG(("Explicitly setting type BINARY"));
                break;
          }

        /* chop off the bits after the semi colon
         */
        *semi_colon = '\0';

        /* also chop of the semi colon from the real URL */
        XP_STRTOK(ce->URL_s->address, ";");
      }

    /* find the filename in the path */
    filename = XP_STRRCHR(cd->path, '/');
    if(!filename)
        filename = cd->path;
    else
        filename++;  /* go past slash */

    cd->filename = 0;
    StrAllocCopy(cd->filename, filename);

    /* Try and find an open connection to this
     * server that is not currently being used
     */
    if(connection_list)
      {
        FTPConnection * tmp_con;
        XP_List * list_entry = connection_list;

        while((tmp_con = (FTPConnection *)XP_ListNextObject(list_entry)) != NULL)
          {
            /* if the hostnames match up exactly and the connection
             * is not busy at the moment then reuse this connection.
             */
            if(!tmp_con->busy && !XP_STRCMP(tmp_con->hostname, host))
              {
                cd->cc = tmp_con;
                ce->socket = cd->cc->csock;  /* set select on the control socket */
                NET_SetReadSelect(ce->window_id, cd->cc->csock);
                cd->cc->prev_cache = TRUE;  /* this was from the cache */
                break;
              }
          }
      }
    else
      {
    /* initialize the connection list
     */
        connection_list = XP_ListNew();
      }

    if(!cd->cc)
      {

        TRACEMSG(("cached connection not found making new FTP connection"));

        /* build a control connection structure so we
         * can store the data as we go along
         */
        cd->cc = XP_NEW(FTPConnection);
        if(!cd->cc)
          {
            XP_FREE(host);  /* free from way up above */
            XP_FREEIF(username);
            XP_FREEIF(password);
            ce->URL_s->error_msg = NET_ExplainErrorDetails(MK_OUT_OF_MEMORY);
            return(MK_OUT_OF_MEMORY);
          }

        cd->cc->hostname = 0;
        StrAllocCopy(cd->cc->hostname, host);
        /* set the mode of the control connection unknown
         */
        cd->cc->cur_mode = FTP_MODE_UNKNOWN;
        cd->cc->csock = NULL;
        cd->cc->server_type = FTP_GENERIC_TYPE;
        cd->cc->use_list = FALSE;
        cd->cc->no_pasv  = FALSE;

        cd->cc->prev_cache = FALSE;  /* this wasn't from the cache */
        cd->cc->no_restart = FALSE; /* as far as we know so far */

        /* add this structure to the connection list even
         * though it's not really valid yet.
         * we will fill it in as we go and if
         * an error occurs will will remove it from the
         * list.  No one else will be able to use it since
         * we will mark it busy.
         */
        XP_ListAddObjectToEnd(connection_list, cd->cc);

        /* set this connection busy so no one else can use it
         */
        cd->cc->busy = TRUE;

        /* gate the maximum number of cached connections
         * to one
         */
        if(XP_ListCount(connection_list) > 1)
          {
            XP_List * list_ptr = connection_list->next;
            FTPConnection * con;

            while(list_ptr)
              {
                con = (FTPConnection *) list_ptr->object;
                list_ptr = list_ptr->next;
                if(!con->busy)
                  {
                    XP_ListRemoveObject(connection_list, con);
                    PR_Close(con->csock);
                    /* dont reduce the number of
                     * open connections since cached ones
                     * dont count as active
                     */
                    FREEIF(con->hostname);
                    XP_FREE(con);
                    break;
                  }
              }
          }

        cd->next_state = FTP_CONTROL_CONNECT;
      }
    else
      {
        TRACEMSG(("Found cached FTP connection! YES!!! "));

        /* don't send PASV if the server cant do it */
        if(cd->cc->no_pasv || !net_use_pasv)
            cd->next_state = FTP_SEND_PORT;
        else
            cd->next_state = FTP_SEND_PASV;

        if( cd->cc->no_restart )
            ce->URL_s->server_can_do_restart = FALSE;
        else
            ce->URL_s->server_can_do_restart = TRUE;

        /* set this connection busy so no one else can use it
         */
        cd->cc->busy = TRUE;
        /* add this connection to the number that is open
         * since it is now active
         */
        NET_TotalNumberOfOpenConnections++;
      }

    XP_FREE(host);  /* free from way up above */
    XP_FREEIF(username);
    XP_FREEIF(password);
    TRACEMSG(("Server can do restarts: %s", ce->URL_s->server_can_do_restart ?
              "TRUE" : "FALSE"));
    return(net_ProcessFTP(ce));
}


/* the main state machine control routine.  Calls
 * the individual state processors
 *
 * returns -1 when all done or 0 or positive all other times
 */
PRIVATE int32
net_ProcessFTP(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    cd->pause_for_read = FALSE;

    while(!cd->pause_for_read)
      {
        TRACEMSG(("In ProcessFTP switch loop with state: %d \n", cd->next_state));

        switch(cd->next_state) {

          case FTP_WAIT_FOR_RESPONSE:
            ce->status = net_ftp_response(ce);
            break;

          /* begin login states */
          case FTP_CONTROL_CONNECT:
            ce->status = NET_BeginConnect(ce->URL_s->address,
                                          ce->URL_s->IPAddressString,
                                         "FTP",
                                            FTP_PORT,
                                         &cd->cc->csock,
                                         FALSE,
                                         &cd->tcp_con_data,
                                         ce->window_id,
                                         &ce->URL_s->error_msg,
                                          ce->socks_host,
                                          ce->socks_port);
            ce->socket = cd->cc->csock;

            if(cd->cc->csock != NULL)
                NET_TotalNumberOfOpenConnections++;

            cd->pause_for_read = TRUE;

            if(ce->status == MK_CONNECTED)
              {
                cd->next_state = FTP_WAIT_FOR_RESPONSE;
                cd->next_state_after_response = FTP_SEND_USERNAME;
                NET_SetReadSelect(ce->window_id, cd->cc->csock);
              }
            else if(ce->status > -1)
              {
                cd->next_state = FTP_CONTROL_CONNECT_WAIT;
                ce->con_sock = cd->cc->csock;  /* set con sock so we can select on it */
                NET_SetConnectSelect(ce->window_id, ce->con_sock);

              }
            break;

          case FTP_CONTROL_CONNECT_WAIT:
            ce->status = NET_FinishConnect(ce->URL_s->address,
                                          "FTP",
                                            FTP_PORT,
                                          &cd->cc->csock,
                                          &cd->tcp_con_data,
                                          ce->window_id,
                                          &ce->URL_s->error_msg);

            cd->pause_for_read = TRUE;

            if(ce->status == MK_CONNECTED)
              {
                cd->next_state = FTP_WAIT_FOR_RESPONSE;
                cd->next_state_after_response = FTP_SEND_USERNAME;
                NET_ClearConnectSelect(ce->window_id, ce->con_sock);
                ce->con_sock = NULL;  /* reset con sock so we don't select on it */
                NET_SetReadSelect(ce->window_id, ce->socket);
              }
            else
              {
                /* the not yet connected state */

                /* unregister the old CE_SOCK from the select list
                  * and register the new value in the case that it changes
                  */
                if(ce->con_sock != cd->cc->csock)
                  {
                    NET_ClearConnectSelect(ce->window_id, ce->con_sock);
                    ce->con_sock = cd->cc->csock;
                    NET_SetConnectSelect(ce->window_id, ce->con_sock);
                  }
              }
            break;

          case FTP_SEND_USERNAME:
            ce->status = net_send_username((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_USERNAME_RESPONSE:
            ce->status = net_send_username_response(ce);
            break;

          case FTP_GET_PASSWORD:
            ce->status = net_get_ftp_password(ce);
            break;

          case FTP_GET_PASSWORD_RESPONSE:
            /* currently skipped
             */
            ce->status = net_get_ftp_password_response((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_PASSWORD:
            ce->status = net_send_password((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_PASSWORD_RESPONSE:
            ce->status = net_send_password_response(ce);
            break;

          case FTP_SEND_ACCT:
            ce->status = net_send_acct((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_ACCT_RESPONSE:
            ce->status = net_send_acct_response(ce);
            break;

          case FTP_SEND_REST_ZERO:
            ce->status = net_send_rest_zero(ce);
            break;

          case FTP_SEND_REST_ZERO_RESPONSE:
            ce->status = net_send_rest_zero_response(ce);
            break;

          case FTP_SEND_SYST:
            ce->status = net_send_syst((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_SYST_RESPONSE:
            ce->status = net_send_syst_response((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_MAC_BIN:
            ce->status = net_send_mac_bin((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_MAC_BIN_RESPONSE:
            ce->status = net_send_mac_bin_response((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_PWD:
            ce->status = net_send_pwd((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_PWD_RESPONSE:
            ce->status = net_send_pwd_response(ce);
            break;
        /* end login states */

          case FTP_FIGURE_OUT_WHAT_TO_DO:
            ce->status = net_figure_out_what_to_do(ce);
            break;

          case FTP_SEND_MKDIR:
            ce->status = net_send_mkdir(ce);
            break;

          case FTP_SEND_MKDIR_RESPONSE:
            ce->status = net_send_mkdir_response(ce);
            break;

          case FTP_SEND_DELETE_FILE:
            ce->status = net_send_delete_file(ce);
            break;

          case FTP_SEND_DELETE_FILE_RESPONSE:
            ce->status = net_send_delete_file_response(ce);
            break;

          case FTP_SEND_DELETE_DIR:
            ce->status = net_send_delete_dir(ce);
            break;

          case FTP_SEND_DELETE_DIR_RESPONSE:
            ce->status = net_send_delete_dir_response(ce);
            break;

          case FTP_SEND_PASV:
            ce->status = net_send_pasv((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_PASV_RESPONSE:
            ce->status = net_send_pasv_response((FTPConData *)ce->con_data);
            break;

          case FTP_PASV_DATA_CONNECT:
            ce->status = NET_BeginConnect(cd->data_con_address,
                                          NULL,
                                         "FTP Data Connection",
                                           FTP_PORT,
                                         &cd->dsock,
                                         FALSE,
                                         &cd->tcp_con_data,
                                         ce->window_id,
                                         &ce->URL_s->error_msg,
                                          ce->socks_host,
                                          ce->socks_port);

            if(ce->status == MK_CONNECTED)
              {
                cd->next_state = FTP_GET_FILE_TYPE;
              }
            else if(ce->status > -1)
              {
                cd->pause_for_read = TRUE;
                cd->next_state = FTP_PASV_DATA_CONNECT_WAIT;
                ce->con_sock = cd->dsock;  /* set con sock so we can select on it */
                NET_SetConnectSelect(ce->window_id, ce->con_sock);
              }
            break;

          case FTP_PASV_DATA_CONNECT_WAIT:
                ce->status = NET_FinishConnect(cd->data_con_address,
                                              "FTP Data Connection",
                                              FTP_PORT,
                                              &cd->dsock,
                                              &cd->tcp_con_data,
                                              ce->window_id,
                                              &ce->URL_s->error_msg);
                TRACEMSG(("FTP: got pasv data connection on port #%d\n",cd->cc->csock));

                if(ce->status == MK_CONNECTED)
                  {
                    cd->next_state = FTP_GET_FILE_TYPE;
                    NET_ClearConnectSelect(ce->window_id, ce->con_sock);
                    ce->con_sock = NULL;  /* reset con sock so we don't select on it */
                  }
                else
                  {
                    ce->con_sock = cd->dsock; /* it might change */
                    cd->pause_for_read = TRUE;
                  }
            break;

          case FTP_SEND_PORT:
            ce->status = net_send_port(ce);
            break;

          case FTP_SEND_PORT_RESPONSE:
            ce->status = net_send_port_response(ce);
            break;

          /* This is the state that gets called after
           * login and port/pasv are done
           */
          case FTP_GET_FILE_TYPE:
            ce->status = net_get_ftp_file_type(ce);
            break;

          case FTP_SEND_BIN:
            ce->status = net_send_bin((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_ASCII:
            ce->status = net_send_ascii((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_BIN_RESPONSE:
          case FTP_SEND_ASCII_RESPONSE:
            ce->status = net_send_bin_or_ascii_response(ce);
            break;

          case FTP_GET_FILE_SIZE:
            ce->status = net_get_ftp_file_size(ce);
            break;

          case FTP_GET_FILE_SIZE_RESPONSE:
            ce->status = net_get_ftp_file_size_response(ce);
            break;

          case FTP_GET_FILE_MDTM:
            ce->status = net_get_ftp_file_mdtm(ce);
            break;

          case FTP_GET_FILE_MDTM_RESPONSE:
            ce->status = net_get_ftp_file_mdtm_response(ce);
            break;

          case FTP_GET_FILE:
            ce->status = net_get_ftp_file((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_REST:
            ce->status = net_send_rest(ce);
            break;

          case FTP_SEND_REST_RESPONSE:
            ce->status = net_send_rest_response(ce);
            break;

          case FTP_SEND_RETR:
            ce->status = net_send_retr((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_RETR_RESPONSE:
            ce->status = net_send_retr_response(ce);
            break;

          case FTP_SEND_CWD:
            ce->status = net_send_cwd((FTPConData *)ce->con_data);
            break;

          case FTP_SEND_CWD_RESPONSE:
            ce->status = net_send_cwd_response(ce);
            break;

          case FTP_BEGIN_PUT:
            ce->status = net_begin_put(ce);
            break;

          case FTP_BEGIN_PUT_RESPONSE:
            ce->status = net_begin_put_response(ce);
            break;

          case FTP_DO_PUT:
            ce->status = net_do_put(ce);
            break;

          case FTP_SEND_LIST_OR_NLST:
            ce->status = net_send_list_or_nlst(ce);
            break;

          case FTP_SEND_LIST_OR_NLST_RESPONSE:
            ce->status = net_send_list_or_nlst_response(ce);
            break;

          case FTP_SETUP_STREAM:
            ce->status = net_setup_ftp_stream(ce);
            break;

          case FTP_WAIT_FOR_ACCEPT:
            ce->status = net_wait_for_ftp_accept(ce);
            break;

          case FTP_READ_CACHE:
            ce->status = net_ftp_push_partial_cache_file(ce);
            break;

          case FTP_START_READ_FILE:
            ce->status = net_start_ftp_read_file(ce);
            break;

          case FTP_READ_FILE:
            ce->status = net_ftp_read_file(ce);
            break;

          case FTP_START_READ_DIRECTORY:
            ce->status = net_start_ftp_read_dir(ce);
            break;

          case FTP_READ_DIRECTORY:

            ce->status = net_ftp_read_dir(ce);
            break;

          case FTP_PRINT_DIR:
            ce->status = net_ftp_print_dir(ce);
            break;

          case FTP_DONE:
            if(cd->stream)
                COMPLETE_STREAM;

            /* Make sure that any previous cache entry is not locked anymore */
            NET_ChangeCacheFileLock(ce->URL_s, FALSE);

            /* don't close the control sock since we need
             * it for connection caching
             */
            if(cd->dsock != NULL)
              {
                NET_ClearReadSelect(ce->window_id, cd->dsock);
                TRACEMSG(("Closing and clearing sock cd->dsock: %d", cd->dsock));
                PR_Close(cd->dsock);
                cd->dsock = NULL;
              }

            if(cd->listen_sock != NULL)
              {
                TRACEMSG(("Closing and clearing sock cd->listen_sock: %d", cd->listen_sock));
                NET_ClearReadSelect(ce->window_id, cd->listen_sock);
                PR_Close(cd->listen_sock);
                /* not counted as a connection */
              }

            cd->next_state = FTP_FREE_DATA;

            cd->cc->busy = FALSE;  /* we are no longer using the connection */
            NET_ClearReadSelect(ce->window_id, cd->cc->csock);

            /* we can't reuse VMS control connections since they are screwed up
                */
            if(cd->cc->server_type == FTP_VMS_TYPE)
              {
                /* remove the connection from the cache list
                 * and free the data
                 */
                XP_ListRemoveObject(connection_list, cd->cc);
                FREEIF(cd->cc->hostname);
                if(cd->cc->csock != NULL)
                  {
                    TRACEMSG(("Closing and clearing sock cd->cc->csock: %d", cd->cc->csock));
                    PR_Close(cd->cc->csock);
                    cd->cc->csock = NULL;
                  }
                XP_FREE(cd->cc);
                cd->cc = 0;
              }

            /* remove the cached connection from the total number
             * counted, since it is no longer active
             */
            NET_TotalNumberOfOpenConnections--;

            break;

          case FTP_ERROR_DONE:
            if(cd->sort_base)
              {
                 /* we have to do this to get it free'd
                  */
         if(cd->stream && (*cd->stream->is_write_ready)(cd->stream))
                     NET_PrintDirectory(&cd->sort_base, cd->stream, cd->path, ce->URL_s);
              }

            if(cd->stream && cd->stream->data_object)
            {
                ABORT_STREAM(ce->status);
                /* (ABORT_STREAM frees cd->stream->data_object:) */
                cd->stream->data_object = NULL;
            }

            /* lock the object in cache if we can restart it */
            /* This way even if it's huge, we can restart. */
            TRACEMSG(("FTP aborting!  content_length = %ld, real_content_length = %ld\n",
                      ce->URL_s->content_length, ce->URL_s->real_content_length));
            TRACEMSG(("  bytes_received = %ld\n", ce->bytes_received));
            if(ce->URL_s->server_can_do_restart)
                NET_ChangeCacheFileLock(ce->URL_s, TRUE);

            if(cd->dsock != NULL)
              {
                NET_ClearConnectSelect(ce->window_id, cd->dsock);
                NET_ClearReadSelect(ce->window_id, cd->dsock);
                NET_ClearDNSSelect(ce->window_id, cd->dsock);

#ifdef XP_WIN
                if(cd->calling_netlib_all_the_time)
                {
                    cd->calling_netlib_all_the_time = FALSE;
                    NET_ClearCallNetlibAllTheTime(ce->window_id, "mkftp");
                }
#endif /* XP_WIN */

                TRACEMSG(("Closing and clearing sock cd->dsock: %d", cd->dsock));
                PR_Close(cd->dsock);
                cd->dsock = NULL;
              }

            if(cd->file_to_post_fp)
              {
                XP_FileClose(cd->file_to_post_fp);
                cd->file_to_post_fp = 0;
              }

            if(cd->cc->csock != NULL)
              {
                NET_ClearConnectSelect(ce->window_id, cd->cc->csock);
                NET_ClearReadSelect(ce->window_id, cd->cc->csock);
                NET_ClearDNSSelect(ce->window_id, cd->cc->csock);
                TRACEMSG(("Closing and clearing sock cd->cc->csock: %d", cd->cc->csock));
                PR_Close(cd->cc->csock);
                cd->cc->csock = NULL;
                NET_TotalNumberOfOpenConnections--;
              }

            if(cd->listen_sock != NULL)
              {
                TRACEMSG(("Closing and clearing sock cd->listen_sock: %d", cd->listen_sock));
                NET_ClearReadSelect(ce->window_id, cd->listen_sock);
                PR_Close(cd->listen_sock);
                /* not counted as a connection */
              }


            /* check if this connection came from the cache or if it was
             * a new connection.  If it was new lets start it over again
             */
            if(cd->cc->prev_cache
                && ce->status != MK_INTERRUPTED
                  && ce->status != MK_UNABLE_TO_CONVERT
                    && ce->status != MK_OUT_OF_MEMORY
                    && ce->status != MK_DISK_FULL)
              {
                cd->cc->prev_cache = NO;
                cd->next_state = FTP_CONTROL_CONNECT;
                cd->pasv_mode = TRUE;  /* until we learn otherwise */
                cd->pause_for_read = FALSE;
                ce->status = 0;  /* keep going */
                cd->cc->cur_mode = FTP_MODE_UNKNOWN;
              }
            else
              {
                cd->next_state = FTP_FREE_DATA;

                /* remove the connection from the cache list
                 * and free the data
                 */
                XP_ListRemoveObject(connection_list, cd->cc);
                FREEIF(cd->cc->hostname);
                XP_FREE(cd->cc);
              }

            break;

          case FTP_FREE_DATA:
                if(cd->calling_netlib_all_the_time)
                  {
                    NET_ClearCallNetlibAllTheTime(ce->window_id, "mkftp");
                    cd->calling_netlib_all_the_time = FALSE;
                  }

                if(cd->destroy_graph_progress)
                    FE_GraphProgressDestroy(ce->window_id,
                                            ce->URL_s,
                                            cd->original_content_length,
                                            ce->bytes_received);
#ifdef EDITOR
                if(cd->destroy_file_upload_progress_dialog) {
                    /* Convert from netlib errors to editor errors. */
                    ED_FileError error = ED_ERROR_NONE;
                    if ( ce->status < 0 )
                        error = ED_ERROR_PUBLISHING;
                    FE_SaveDialogDestroy(ce->window_id, error, ce->URL_s->post_data);
                    /*  FE_SaveDialogDestroy(ce->window_id, ce->status, cd->file_to_post); */
                }
#endif /* EDITOR */
                FREEIF(cd->cwd_message_buffer);
                FREEIF(cd->login_message_buffer);
                FREEIF(cd->data_buf)
                FREEIF(cd->return_msg)
                FREEIF(cd->data_con_address)
                FREEIF(cd->filename)
                FREEIF(cd->path)
                FREEIF(cd->username)
                FREEIF(cd->password)
                FREEIF(cd->stream);  /* don't forget the stream */
                FREEIF(cd->output_buffer);
                if(cd->tcp_con_data)
                    NET_FreeTCPConData(cd->tcp_con_data);


                XP_FREE(cd);

                /* gate the maximum number of cached connections
                  * to one
                 */
                if(XP_ListCount(connection_list) > 1)
                  {
                    XP_List * list_ptr = connection_list->next;
                    FTPConnection * con;

                    while(list_ptr)
                      {
                        con = (FTPConnection *) list_ptr->object;
                        list_ptr = list_ptr->next;
                        if(!con->busy)
                          {
                            XP_ListRemoveObject(connection_list, con);

                            if(con->csock != NULL)
                              {
                                PR_Close(con->csock);
                                /* dont reduce the number of
                                 * open connections since cached ones
                                  * dont count as active
                                 */
                              }
                            FREEIF(con->hostname);
                            XP_FREE(con);
                            break;
                          }
                      }
                  }

                return(-1);

              default:
                TRACEMSG(("Bad state in ProcessFTP\n"));
                return(-1);
         } /* end switch */

       if(ce->status < 0 && cd->next_state != FTP_FREE_DATA)
          {
            cd->pause_for_read = FALSE;
            cd->next_state = FTP_ERROR_DONE;
          }
    } /* end while */

    return(ce->status);
}

/* abort the connection in progress
 */
PRIVATE int32
net_InterruptFTP(ActiveEntry * ce)
{
    FTPConData * cd = (FTPConData *)ce->con_data;

    cd->next_state = FTP_ERROR_DONE;
    ce->status = MK_INTERRUPTED;
    cd->cc->prev_cache = FALSE;  /* to keep it from reconnecting */

    return(net_ProcessFTP(ce));
}

/* Free any connections or memory that are cached
 */
PRIVATE void
net_CleanupFTP(void)
{
    if(connection_list)
      {
        FTPConnection * tmp_con;

        while((tmp_con = (FTPConnection *)XP_ListRemoveTopObject(connection_list)) != NULL)
          {
            if(!tmp_con->busy)
              {
                FREE(tmp_con->hostname);       /* hostname string */
                if(tmp_con->csock != NULL)
                  {
                    PR_Close(tmp_con->csock);      /* control socket */
                    tmp_con->csock = NULL;
                    /* don't count cached connections as open ones
                     */
                  }
                FREE(tmp_con);
              }
          }
      }

    return;
}


MODULE_PRIVATE void
NET_InitFTPProtocol(void)
{
    static NET_ProtoImpl ftp_proto_impl;

    ftp_proto_impl.init = net_FTPLoad;
    ftp_proto_impl.process = net_ProcessFTP;
    ftp_proto_impl.interrupt = net_InterruptFTP;
    ftp_proto_impl.cleanup = net_CleanupFTP;

    NET_RegisterProtocolImplementation(&ftp_proto_impl, FTP_TYPE_URL);
}