if (status == HT_WOULD_BLOCK)		    return HT_WOULD_BLOCK;		else if (status == HT_LOADED) {		    if (ctrl->repcode/100 == 2)			ctrl->substate = NEED_SEGMENT;		    else			ctrl->substate = SUB_ERROR;		} else		    ctrl->substate = SUB_ERROR;		ctrl->sent = NO;	    }	    break;	case NEED_STREAM:	    HTTRACE(PROT_TRACE, "FTP Get Data now in state NEED_STREAM\n");	    /* 	    ** Create the stream pipe FROM the channel to the application.	    ** The target for the input stream pipe is set up using the	    ** stream stack.	    */	    {		HTStream * target = FTP_DIR(data) ?		    HTFTPDir_new(request, ctrl->server, data->type) :		    HTStreamStack(HTAnchor_format(HTRequest_anchor(request)),				  HTRequest_outputFormat(request),				  HTRequest_outputStream(request),				  request, YES);		HTNet_setReadStream(dnet, target);		HTRequest_setOutputConnected(request, YES);	    }	    data_is_active = YES;	    ctrl->substate = NEED_BODY;	    break;	  case NEED_BODY:	      HTTRACE(PROT_TRACE, "FTP Get Data now in state NEED_BODY\n");	      if (data_is_active) {		  if (HTRequest_method(request) == METHOD_PUT) {		      HTParentAnchor * entity = HTRequest_entityAnchor(request);		      const char * document = (const char *) HTAnchor_document(entity);		      int length = (int)HTAnchor_length(entity);		      HTStream * output = 			  (HTStream *)HTChannel_output(HTNet_host(dnet)->channel);		      pcbf = HTRequest_postCallback(request);		      if (pcbf) {			status = (*pcbf)(request, output);		      } else {			status = (*output->isa->put_block)(output,							   document,							   length);			if (status == HT_OK) {			  status = HT_LOADED;			}		      }		      if (status == HT_WOULD_BLOCK) {			  return HT_WOULD_BLOCK;		      } else if ( status == HT_LOADED ) {			ctrl->substate = SUB_SUCCESS;			data->complete |= 3;		      } else if ( status == HT_OK ) {			return HT_WOULD_BLOCK;		      } else {			  ctrl->substate = SUB_ERROR;			  data->stream_error = YES;		      }		      continue;		  } else {		  status = HTHost_read(HTNet_host(dnet), dnet);		  }		  if (status == HT_WOULD_BLOCK)		      return HT_WOULD_BLOCK;		  else if (status == HT_LOADED || status == HT_CLOSED || status == HT_OK) {		      HTDoClose(dnet);		      data->complete |= 1; 		      if (data->complete >= 3)			  ctrl->substate = SUB_SUCCESS;		      else			  data_is_active = NO;		  } else {		      ctrl->substate = SUB_ERROR;		      data->stream_error = YES;		  }	      } else {		  status = HTHost_read(HTNet_host(cnet), cnet);		  if (status == HT_WOULD_BLOCK)		      return HT_WOULD_BLOCK;		  else if (status == HT_LOADED || status == HT_CLOSED) {		      if (ctrl->repcode/100 == 2) {			  data->complete |= 2;			  if (data->complete >= 3)			      ctrl->substate = SUB_SUCCESS;			  else			      data_is_active = YES;		      } else			  ctrl->substate = SUB_ERROR;		  } else		      ctrl->substate = SUB_ERROR;	      }	      break;	  case SUB_ERROR:	    HTTRACE(PROT_TRACE, "FTP Get Data now in state SUB_ERROR\n");	    HTRequest_addError(request, ERR_FATAL, NO, HTERR_NOT_FOUND,			       NULL, 0, "HTFTPGetData");	    ctrl->substate = 0;	    HT_FREE(segment);	    return HT_ERROR;	    break;	  case SUB_SUCCESS:	    HTTRACE(PROT_TRACE, "FTP Get Data now in state SUB_SUCCESS\n");	    ctrl->substate = 0;	    HT_FREE(segment);	    return HT_LOADED;	    break;	}    }}/* ------------------------------------------------------------------------- *//*	Retrieve File from Server as an atomic action. **	-----------------------------------------------**	Given a hypertext address, this routine loads a document.**** On entry,**      request		This is the request structure**	returns		HT_ERROR	Error has occured in call back**			HT_OK		Call back was OK*/PRIVATE int FTPEvent (SOCKET soc, void * pVoid, HTEventType type);PUBLIC int HTLoadFTP (SOCKET soc, HTRequest * request){    HTNet * cnet = HTRequest_net(request);    ftp_ctrl * ctrl = NULL;    ftp_data * data = NULL;    HTParentAnchor * anchor = HTRequest_anchor(request);    char * url = HTAnchor_physical(anchor);    /*    ** Initiate a new FTP ctrl and data structure and bind to request structure    ** This is actually state FTP_BEGIN, but it can't be in the state    ** machine as we need the structure first.    */    HTTRACE(PROT_TRACE, "FTP......... Looking for `%s\'\n" _ url);    if ((ctrl = (ftp_ctrl *) HT_CALLOC(1, sizeof(ftp_ctrl))) == NULL ||	(data = (ftp_data *) HT_CALLOC(1, sizeof(ftp_data))) == NULL)	HT_OUTOFMEM("HTLoadFTP");    ctrl->cmd = HTChunk_new(128);    ctrl->state = FTP_BEGIN;    ctrl->server = FTP_UNSURE;    ctrl->dnet = HTNet_dup(cnet);    ctrl->cnet = cnet;    HTNet_setContext(cnet, ctrl);    HTNet_setEventCallback(cnet, FTPEvent);    HTNet_setEventParam(cnet, ctrl);    HTNet_setRawBytesCount(ctrl->dnet, YES);    /* for now, the dnet comes back to the same place    ** - vestigial from when the callback was from the request object    */    HTNet_setContext(ctrl->dnet, data);    HTNet_setEventCallback(ctrl->dnet, FTPEvent);    HTNet_setEventParam(ctrl->dnet, ctrl);    return FTPEvent(soc, ctrl, HTEvent_BEGIN);}PRIVATE int FTPEvent (SOCKET soc, void * pVoid, HTEventType type){    ftp_ctrl * ctrl = (ftp_ctrl *) pVoid;    ftp_data * data = (ftp_data *) HTNet_context(ctrl->dnet);    int status = HT_ERROR;    HTNet * cnet = ctrl->cnet;    HTRequest * request = HTNet_request(cnet);    HTParentAnchor * anchor = HTRequest_anchor(request);    char * url = HTAnchor_physical(anchor);    HTHost *host = HTNet_host(cnet);    if (type == HTEvent_CLOSE) {			      /* Interrupted */        if (soc == HTNet_socket(cnet) && data->complete<1)	    FTPCleanup(request, HT_INTERRUPTED);	else	    FTPCleanup(request, HT_LOADED);	return HT_OK;    } else if (type == HTEvent_TIMEOUT) {	/*	** Don't time out the control connection if we are actually recieving data	** on the data connection	*/	if (!(soc == HTNet_socket(cnet) && !(data->complete & 1) && HTNet_bytesRead(ctrl->dnet)>0)) {	    HTRequest_addError(request, ERR_FATAL, NO, HTERR_TIME_OUT, NULL, 0, "HTLoadHTTP");	    FTPCleanup(request, HT_TIMEOUT);	}	return HT_OK;    } else {	ctrl = (ftp_ctrl *) HTNet_context(cnet);	/* Get existing copy */	data = (ftp_data *) HTNet_context(ctrl->dnet);    }    /* Now jump into the machine. We know the state from the previous run */    while (1) {	switch (ctrl->state) {	  case FTP_BEGIN:	      HTTRACE(PROT_TRACE, "FTP Event... now in state FTP_BEGIN\n");	      /* Only handle GET requests for now */	      if (HTRequest_method(request) != METHOD_GET &&	          HTRequest_method(request) != METHOD_PUT ) {		  HTTRACE(PROT_TRACE, "FTP Event... This module only supports the GET or PUT methods\n");		  ctrl->state = FTP_ERROR;		  break;	      }	      HTFTPParseURL(request, url, ctrl, data);	      /* The following is added by Neil Griffin, GAIN Software */	      /*	      ** If the user hasn't specified a permanent transfer type, then	      ** use the transfer type specified at the end of the URL.	      */	      if (g_FTPTransferMode == FTP_DEFAULT_TRANSFER_MODE) {		  switch (data->type) {		  case 'a' : data->type = 'A'; break;		  case 'A' : data->type = 'A'; break;		  case 'i' : data->type = 'I'; break;		  case 'I' : data->type = 'I'; break;		  case 'd' : FTPListType(data, ctrl->server); break;		  case 'D' : FTPListType(data, ctrl->server); break;		  default  : data->type = 'I'; break;		  }		  /* Otherwise, use the permanent transfer type specified by the user. */	      } else {		  switch (g_FTPTransferMode) {		  case FTP_ASCII_TRANSFER_MODE  : data->type = 'A'; break;		  case FTP_BINARY_TRANSFER_MODE : data->type = 'I'; break;		  case FTP_DIR_TRANSFER_MODE    : FTPListType(data, ctrl->server); break;		  default                       : data->type = 'I'; break;		  }	      }	      HTTRACE(PROT_TRACE, "FTP Event... Transfer mode set to '%c'\n" _ data->type);	      /*	      **  See if we can get any hints to what we might expect content wise.	      */	      if (!FTP_DIR(data)) HTBind_getAnchorBindings(anchor);              /* Ready for next state */              ctrl->state = FTP_NEED_CCON;              break;	case FTP_NEED_CCON:	    HTTRACE(PROT_TRACE, "FTP Event... now in state FTP_NEED_CONN\n");	    status = HTHost_connect(host, cnet, url);	    host = HTNet_host(cnet);	    if (status == HT_OK) {		/*		** Check the protocol class to see if we have connected to a		** the right class of server, in this case HTTP.		*/		{		    char * s_class = HTHost_class(host);		    if (s_class && strcasecomp(s_class, "ftp")) {			HTRequest_addError(request, ERR_FATAL, NO, HTERR_CLASS,					   NULL, 0, "HTLoadNews");			ctrl->state = FTP_ERROR;			break;		    }		    HTHost_setClass(host, "ftp");		}		/* Check persistent connection */		if (HTNet_persistent(cnet)) {		    ctrl->server = HTHost_version(host);		    HTTRACE(PROT_TRACE, "FTP Server.. Cache says type %d server\n" _ 				ctrl->server);		    ctrl->reset = 1;		} else		    HTNet_setPersistent(cnet, YES, HT_TP_SINGLE);		/* 		** Create the stream pipe FROM the channel to the application.		** The target for the input stream pipe is set up using the		** stream stack.		*/		{		    HTStream * readstream = FTPStatus_new(request, ctrl, host);		    HTNet_setReadStream(cnet, readstream);		}		/*		** Create the stream pipe TO the channel from the application		** and hook it up to the request object		*/		{		    HTOutputStream * output = HTNet_getOutput(cnet, NULL, 0);		    HTRequest_setInputStream(request, (HTStream *) output);		}		/*		** Set up concurrent read/write if this request isn't the		** source for a PUT or POST. As source we don't start reading		** before all destinations are ready. If destination then		** register the input stream and get ready for read		*/		if (HTRequest_isPostWeb(request)) {		    HTEvent * event = HTNet_event(cnet);		    HTEvent_register(HTNet_socket(cnet), HTEvent_READ, event);		    HTRequest_linkDestination(request);		}		ctrl->state = FTP_NEED_LOGIN;	    } else if (status == HT_WOULD_BLOCK || status == HT_PENDING)		return HT_OK;	    else		ctrl->state = FTP_ERROR;	       /* Error or interrupt */	    break;	  case FTP_NEED_LOGIN:	    HTTRACE(PROT_TRACE, "FTP Event... now in state FTP_NEED_LOGIN\n");	    status = HTFTPLogin(request, cnet, ctrl); 	    if (status == HT_WOULD_BLOCK) return HT_OK;	    ctrl->state = (status == HT_OK) ? FTP_NEED_DCON : FTP_ERROR;	    break;	  case FTP_NEED_DCON:	    HTTRACE(PROT_TRACE, "FTP Event... now in state FTP_NEED_DCON\n");	    status = HTFTPDataConnection(request, cnet, ctrl, data);	    if (status == HT_WOULD_BLOCK) return HT_OK;	    if (status == HT_OK)		ctrl->state = (data->type=='N') ?		    FTP_NEED_SERVER : FTP_NEED_DATA;	    else		ctrl->state = FTP_ERROR;	    break;	  case FTP_NEED_DATA:	    HTTRACE(PROT_TRACE, "FTP Event... now in state FTP_NEED_DATA\n");	    status = HTFTPGetData(request, cnet, soc, ctrl, data); 	    if (status == HT_WOULD_BLOCK) return HT_OK;	    if (status == HT_LOADED)		ctrl->state = FTP_SUCCESS;	    else if (status == HT_OK)		ctrl->state = FTP_NEED_DCON;	    else if (HTRequest_method(request) == METHOD_PUT)		ctrl->state = FTP_ERROR;	    else if (!FTP_DIR(data) && !data->stream_error) {		FTPListType(data, ctrl->server);		ctrl->state = FTP_NEED_SERVER;         /* Try a dir instead? */	    } else		ctrl->state = FTP_ERROR;	    break;	  case FTP_NEED_SERVER:	    HTTRACE(PROT_TRACE, "FTP Event... now in state FTP_NEED_SERVER\n");	    status = HTFTPServerInfo(request, cnet, ctrl, data);	    if (status == HT_WOULD_BLOCK) return HT_OK;	    ctrl->state = FTP_NEED_DATA;	    break;	  case FTP_SUCCESS:	    HTTRACE(PROT_TRACE, "FTP Event... now in state FTP_SUCCESS\n");	    FTPCleanup(request, HT_LOADED);	    return HT_OK;	    break;	    	  case FTP_ERROR:	    HTTRACE(PROT_TRACE, "FTP Event... now in state FTP_ERROR\n");	    FTPCleanup(request, HT_ERROR);	    return HT_OK;	    break;	}    } /* End of while(1) */}PUBLIC void HTFTP_setTransferMode(FTPTransferMode mode){    g_FTPTransferMode = mode;}PUBLIC FTPTransferMode HTFTP_transferMode (void){    return g_FTPTransferMode;}PUBLIC void HTFTP_setControlMode (FTPControlMode mode){    g_FTPControlMode = mode;}PUBLIC FTPControlMode HTFTP_controlMode (void){    return g_FTPControlMode;}