htgopher.c

www工具包

		    cont = me->CSO ? GopherCSOLine(me, me->buffer) :
			GopherMenuLine(me, me->buffer);
		    if (cont == NO) return HT_LOADED;
		} else
		    me->junk = NO;			   /* back to normal */
	    }
	    me->buflen = 0;
	    me->state = EOL_BEGIN;
	} else if (*b == CR) {
	    me->state = EOL_FCR;
	} else if (*b == LF && me->buflen) {
	    if (!me->junk) {
		BOOL cont;
		*(me->buffer+me->buflen) = '\0';
		cont = me->CSO ? GopherCSOLine(me, me->buffer) :
		    GopherMenuLine(me, me->buffer);
		if (cont == NO) return HT_LOADED;
	    } else
		me->junk = NO;				   /* back to normal */
	    me->buflen = 0;
	    me->state = EOL_BEGIN;
	} else {
	    *(me->buffer+me->buflen++) = *b;
	    if (me->buflen >= MAX_GOPHER_LINE) {
		HTTRACE(PROT_TRACE, "Gopher...... Line too long - ignored\n");
		me->buflen = 0;
		me->junk = YES;
	    }
	}
	b++;
    }
    return HT_OK;
}

PRIVATE int GopherMenu_put_string (HTStream * me, const char* s)
{
    return GopherMenu_put_block(me, s, (int) strlen(s));
}

PRIVATE int GopherMenu_put_character (HTStream * me, char c)
{
    return GopherMenu_put_block(me, &c, 1);
}

PRIVATE int GopherMenu_flush (HTStream * me)
{    
    return (*me->target->isa->flush)(me->target);
}

PRIVATE int GopherMenu_free (HTStream * me)
{
    int status = HT_OK;
    GopherBottom(me);
    if ((status = (*me->target->isa->_free)(me->target)) == HT_WOULD_BLOCK)
	return HT_WOULD_BLOCK;
    HT_FREE(me);
    return HT_OK;
}

PRIVATE int GopherMenu_abort (HTStream * me, HTList * e)
{
    (*me->target->isa->abort)(me->target, e);
    HT_FREE(me);
    HTTRACE(PROT_TRACE, "Gopher...... ABORTING...\n");
    return HT_ERROR;
}

/*	Goper Menu Stream
**	-----------------
*/
PRIVATE const HTStreamClass GopherMenuClass =
{		
    "GopherMenu",
    GopherMenu_flush,
    GopherMenu_free,
    GopherMenu_abort,
    GopherMenu_put_character,
    GopherMenu_put_string,
    GopherMenu_put_block
};

/*
**  Stream for creating a HTML object out of a Gopher Menu object
*/
PRIVATE HTStream * GopherMenu_new (HTRequest * request, char *url, BOOL CSO)
{
    HTStream * me;
    if ((me = (HTStream  *) HT_CALLOC(1, sizeof(HTStream))) == NULL)
        HT_OUTOFMEM("GopherMenu_new");
    me->isa = &GopherMenuClass;
    me->target = HTMLGenerator(request, NULL, WWW_HTML,
			       HTRequest_outputFormat(request),
			       HTRequest_outputStream(request));
    HTAnchor_setFormat(HTRequest_anchor(request), WWW_HTML);
    me->request = request;    
    me->state = EOL_BEGIN;
    me->url = url;
    me->CSO = CSO;
    GopherTitle(me);
    return me;
}

/* ------------------------------------------------------------------------- */
/*				GOPHER STATE MACHINE			     */
/* ------------------------------------------------------------------------- */

/*	GopherCleanup
**	-------------
**      This function closes the connection and frees memory.
**      Returns YES if OK, else NO
*/
PRIVATE BOOL GopherCleanup (HTRequest * request, int status)
{
    HTNet * net = HTRequest_net(request);
    gopher_info * gopher = (gopher_info *) HTNet_context(net);
    HTStream * input = HTRequest_inputStream(request);

    /* Free stream with data TO network */
    if (input) {
	if (status == HT_INTERRUPTED)
	    (*input->isa->abort)(input, NULL);
	else
	    (*input->isa->_free)(input);
    }

    /* Remove the request object and our own context structure for gopher */
    HTNet_delete(net, status);
    if (gopher) {
	HT_FREE(gopher->cmd);
	HT_FREE(gopher);
    }
    return YES;
}

/*	Display a Gopher Index document
**	-------------------------------
**	We create a small HTML object as we have no network activity
*/
PRIVATE void display_index (HTRequest * request)
{
    HTParentAnchor * anchor = HTRequest_anchor(request);
    HTStructured *target = HTMLGenerator(request, NULL, WWW_HTML,
					 HTRequest_outputFormat(request),
					 HTRequest_outputStream(request));

    /* Update anchor information */
    HTAnchor_setFormat(anchor, WWW_HTML);
    HTAnchor_setTitle(anchor, "Searchable Gopher Index");
    /* @@@ We don't set Content-Length */

    START(HTML_HTML);
    START(HTML_HEAD);
    START(HTML_TITLE);
    PUTS("Searchable Gopher Index");
    END(HTML_TITLE);
    END(HTML_HEAD);
    START(HTML_BODY);

    START(HTML_H1);
    PUTS("Searchable Gopher Index");
    END(HTML_H1);
    START(HTML_ISINDEX);
    END(HTML_BODY);
    END(HTML_HTML);
    (*target->isa->_free)(target);
}


/*      Display a CSO index document
**      -------------------------------
**	We create a small HTML object as we have no network activity
*/
PRIVATE void display_cso (HTRequest * request)
{
    HTParentAnchor * anchor = HTRequest_anchor(request);
    HTStructured *target = HTMLGenerator(request, NULL, WWW_HTML,
					 HTRequest_outputFormat(request),
					 HTRequest_outputStream(request));

    /* Update anchor information */
    HTAnchor_setFormat(anchor, WWW_HTML);
    HTAnchor_setTitle(anchor, "Searchable SCO Index");
    /* @@@ We don't set Content-Length */

    START(HTML_HTML);
    START(HTML_HEAD);
    START(HTML_TITLE);
    PUTS("Searchable Index of a CSO Name Server");
    END(HTML_TITLE);
    END(HTML_HEAD);
    START(HTML_BODY);

    START(HTML_H1);
    PUTS("Searchable Index of a CSO Name Server");
    END(HTML_H1);
    PUTS("A CSO Name Server usually provides directory information about people.");
    START(HTML_ISINDEX);
    END(HTML_BODY);
    END(HTML_HTML);
    (*target->isa->_free)(target);
}

/*	HTLoadGopher
**	------------
**	Given a hypertext address, this routine loads a gopher document
**
** On entry,
**      request		This is the request structure
** On Exit
**	returns		HT_ERROR	Error has occured in call back
**			HT_OK		Call back was OK
*/
PRIVATE int GopherEvent (SOCKET soc, void * pVoid, HTEventType type);

PUBLIC int HTLoadGopher (SOCKET soc, HTRequest * request)
{
    gopher_info * gopher;
    HTNet * net = HTRequest_net(request);
    HTParentAnchor * anchor = HTRequest_anchor(request);
    char * url = HTAnchor_physical(anchor);
    
    /*
    ** Initiate a new gopher structure and bind to request structure
    ** This is actually state GOPHER_BEGIN, but it can't be in the state
    ** machine as we need the structure first.
    */
    HTTRACE(PROT_TRACE, "Gopher...... Looking for `%s\'\n" _ url);
    if ((gopher = (gopher_info *) HT_CALLOC(1, sizeof(gopher_info))) == NULL)
	HT_OUTOFMEM("HTLoadGopher");
    gopher->type = GT_MENU;
    gopher->state = GOPHER_BEGIN;
    gopher->net = net;
    HTNet_setContext(net, gopher);
    HTNet_setEventCallback(net, GopherEvent);
    HTNet_setEventParam(net, gopher);  /* callbacks get http* */

    return GopherEvent(soc, gopher, HTEvent_BEGIN);		/* get it started - ops is ignored */
}

PRIVATE int GopherEvent (SOCKET soc, void * pVoid, HTEventType type)
{
    gopher_info * gopher = (gopher_info *)pVoid;
    int status = HT_ERROR;
    HTNet * net = gopher->net;
    HTRequest * request = HTNet_request(net);
    HTParentAnchor * anchor = HTRequest_anchor(request);
    HTHost * host = HTNet_host(net);
    char * url = HTAnchor_physical(anchor);
    
    if (type == HTEvent_CLOSE) {			      /* Interrupted */
	GopherCleanup(request, HT_INTERRUPTED);
	return HT_OK;
    } else
	gopher = (gopher_info *) HTNet_context(net);	/* Get existing copy */

    /* Now jump into the machine. We know the state from the previous run */
    while (1) {
	switch (gopher->state) {

	  case GOPHER_BEGIN:	     /* Get entity type, and selector string */
	    {
		char *path = HTParse(url, "", PARSE_PATH);
		char *selector = path;
		char *query = NULL;
		char *separator = NULL;
		if (*selector) gopher->type = (HTGopherType) *selector++;
		if (gopher->type == GT_INDEX) {
		    HTAnchor_setIndex(anchor);			 /* Is index */
		    query = strchr(selector, '?');

		    /* Display local cover page only if no search requested */
		    if (!query || !*(query+1)) {       /* No search required */
			display_index(request);
			gopher->state = GOPHER_GOT_DATA;
			HT_FREE(path);
			break;
		    } else {
			*query++ = 0; 				 /* Skip '?' */
			separator = "\t";
		    }
		} else if (gopher->type == GT_CSO) {
		    HTAnchor_setIndex(anchor);		/* Search is allowed */
		    query = strchr(selector, '?'); /* Look for search string */
		    
		    /* Display local cover page only if no search requested */
		    if (!query || !*(query+1)) {       /* No search required */
			display_cso(request);
			gopher->state = GOPHER_GOT_DATA;
			HT_FREE(path);
			break;
		    } else {
			*query++ = 0; 				 /* Skip '?' */
			*selector = 0;
			separator = "query ";
		    }
		}

		/* Now generate the final command */
		{
		    char crlf[3];
		    StrAllocCopy(gopher->cmd, selector);
		    if (query) {
			char *p;
			for (p=query; *p; p++)   /* Remove plus signs 921006 */
			    if (*p == '+') *p = ' ';
			StrAllocCat(gopher->cmd, separator);
			StrAllocCat(gopher->cmd, query);
		    }
		    HTUnEscape(gopher->cmd);
		    HTCleanTelnetString(gopher->cmd);   /* Prevent sec holes */
		    *crlf = CR;			       /* Telnet termination */
		    *(crlf+1) = LF;
		    *(crlf+2) = '\0';
		    StrAllocCat(gopher->cmd, crlf);
		}
		HT_FREE(path);
		gopher->state = GOPHER_NEED_CONNECTION;
	    }
	    break;

	  case GOPHER_NEED_CONNECTION:
	    status = HTHost_connect(host, net, url, GOPHER_PORT);
	    host = HTNet_host(net);
	    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.
		*/
		{
		    HTHost * host = HTNet_host(net);
		    char * s_class = HTHost_class(host);
		    if (s_class && strcasecomp(s_class, "gopher")) {
			HTRequest_addError(request, ERR_FATAL, NO, HTERR_CLASS,
					   NULL, 0, "HTLoadGopher");
			gopher->state = GOPHER_ERROR;
			break;
		    }
		    HTHost_setClass(host, "gopher");
		}

		/* 
		** Create the stream pipe FROM the channel to the application.
		** The target for the input stream pipe is set up using the
		** stream stack.
		*/
		{
		    if (gopher->type == GT_MENU || gopher->type == GT_INDEX)
			net->readStream = GopherMenu_new(request, url, NO);
		    else if (gopher->type == GT_CSO)
			net->readStream = GopherMenu_new(request, url, YES);
		    else
			net->readStream = HTStreamStack(WWW_UNKNOWN,
					       HTRequest_outputFormat(request),
					       HTRequest_outputStream(request),
					       request, NO);
		    HTRequest_setOutputConnected(request, YES);
		}

		/*
		** Create the stream pipe TO the channel from the application
		** and hook it up to the request object
		*/
		{
		    HTOutputStream * output = HTNet_getOutput(net, NULL, 0);
		    HTRequest_setInputStream(request, (HTStream *) output);
		}
		gopher->state = GOPHER_NEED_REQUEST;

	    } else if (status == HT_WOULD_BLOCK)
		return HT_OK;
	    else
		gopher->state = GOPHER_ERROR;
	    break;

	  case GOPHER_NEED_REQUEST:
	    HTTRACE(PROT_TRACE, "Gopher Tx... `%s\'" _ gopher->cmd);
	    {	
		HTStream * input = HTRequest_inputStream(request);
		status = (*input->isa->put_block)
		    (input, gopher->cmd, strlen(gopher->cmd));
		if (status == HT_WOULD_BLOCK)
		    return HT_OK;
		else if (status == HT_ERROR)
		    gopher->state = GOPHER_ERROR;
		else
		    gopher->state = GOPHER_NEED_RESPONSE;
	    }
	    break;

	  case GOPHER_NEED_RESPONSE:
	    status = HTHost_read(net->host, net);
	    if (status == HT_WOULD_BLOCK)
		return HT_OK;
	    else if (status == HT_LOADED || status == HT_CLOSED)
		gopher->state = GOPHER_GOT_DATA;
	    else
		gopher->state = GOPHER_ERROR;
	    break;

	  case GOPHER_GOT_DATA:
	    GopherCleanup(request, HT_LOADED);
	    return HT_OK;
	    break;

	  case GOPHER_NO_DATA:
	    GopherCleanup(request, HT_NO_DATA);
	    return HT_OK;
	    break;

	  case GOPHER_ERROR:
	    GopherCleanup(request, HT_ERROR);
	    return HT_OK;
	    break;
	}
    }  /* while(1) */
}