/* FileCleanup
** -----------
** This function closes the connection and frees memory.
** Returns YES on OK, else NO
*/
PRIVATE int FileCleanup (HTRequest *req, int status)
{
HTNet * net = HTRequest_net(req);
file_info * file = (file_info *) HTNet_context(net);
HTStream * input = HTRequest_inputStream(req);
/* Free stream with data TO Local file system */
if (input) {
if (status == HT_INTERRUPTED)
(*input->isa->abort)(input, NULL);
else
(*input->isa->_free)(input);
HTRequest_setInputStream(req, NULL);
}
/*
** Remove if we have registered a timer function as a callback
*/
if (file->timer) {
HTTimer_delete(file->timer);
file->timer = NULL;
}
if (file) {
HT_FREE(file->local);
HT_FREE(file);
}
HTNet_delete(net, status);
return YES;
}
/* ServerCleanup
** -------------
** This function cleans up after the request
** Returns YES on OK, else NO
*/
PRIVATE int ServerCleanup (HTRequest * req, HTNet * net, int status)
{
https_info * http = (https_info *) HTNet_context(net);
HTStream * input = HTRequest_inputStream(req);
HTChannel * channel = HTNet_channel(net);
/* Free stream with data TO network */
if (input) {
if (status == HT_INTERRUPTED)
(*input->isa->abort)(input, NULL);
else
(*input->isa->_free)(input);
HTRequest_setInputStream(req, NULL);
}
/* Kill all remaining requests */
if (http->clients) {
HTList * cur = http->clients;
HTRequest * pres;
while ((pres = HTList_nextObject(cur)) != NULL)
HTRequest_kill(pres);
HTList_delete(http->clients);
}
/*
** Remove the net object and our own context structure for http.
** Also unregister all pending requests and close the connection
*/
HTChannel_setSemaphore(channel, 0);
HTNet_delete(net, HT_IGNORE);
HT_FREE(http);
return YES;
}
/* HTNewsCleanup
** -------------
** This function closes the connection and frees memory.
** Returns YES on OK, else NO
*/
PRIVATE int HTNewsCleanup (HTRequest * req, int status)
{
HTNet * net = HTRequest_net(req);
news_info *news = (news_info *) HTNet_context(net);
HTStream * input = HTRequest_inputStream(req);
/* Free stream with data TO network */
if (!HTRequest_isDestination(req))
HTRequest_removeDestination(req);
else if (input) {
if (status == HT_INTERRUPTED)
(*input->isa->abort)(input, NULL);
else
(*input->isa->_free)(input);
HTRequest_setInputStream(req, NULL);
}
/* Remove the request object and our own context structure for nntp */
HTNet_delete(net, status);
if (news) {
HT_FREE(news->name);
HTChunk_delete(news->cmd);
HT_FREE(news);
}
return YES;
}
PRIVATE int RawCleanup (HTRequest * request, int status)
{
HTNet * net = HTRequest_net(request);
raw_info * raw = (raw_info *) HTNet_context(net);
HTTRACE(PROT_TRACE, "Raw clean... Called with status %d, net %p\n" _ status _ net);
if (status == HT_INTERRUPTED) {
HTAlertCallback * cbf = HTAlert_find(HT_PROG_INTERRUPT);
if (cbf) (*cbf)(request, HT_PROG_INTERRUPT,
HT_MSG_NULL, NULL, NULL, NULL);
} else if (status == HT_TIMEOUT) {
HTAlertCallback * cbf = HTAlert_find(HT_PROG_TIMEOUT);
if (cbf) (*cbf)(request, HT_PROG_TIMEOUT,
HT_MSG_NULL, NULL, NULL, NULL);
}
/* Delete the Net object */
HTNet_delete(net, HT_ERROR);
HT_FREE(raw);
return YES;
}
PRIVATE int ServEvent (SOCKET soc, void * pVoid, HTEventType type)
{
https_info * http = (https_info *)pVoid;
int status = HT_ERROR;
HTNet * net = http->net;
HTRequest * request = HTNet_request(net);
if (!net || !request) {
HTTRACE(PROT_TRACE, "Serv HTTP... Invalid argument\n");
return HT_ERROR;
}
if (type == HTEvent_CLOSE) { /* Interrupted */
ServerCleanup(request, net, HT_INTERRUPTED);
return HT_OK;
} else
http = (https_info *) HTNet_context(net); /* Get existing copy */
/* Now jump into the machine. We know the state from the previous run */
while (1) {
switch (http->state) {
case HTTPS_BEGIN:
{
/*
** Create the request to handle the request and inherit the old
** context
*/
HTRequest * client = HTRequest_new();
void * context = HTRequest_context(request);
if (context) HTRequest_setContext(client, context);
HTRequest_setOutputConnected(client, NO);
HTRequest_setGnHd(client, HTRequest_gnHd(request));
HTRequest_setRsHd(client, HTRequest_rsHd(request));
HTRequest_setEnHd(client, HTRequest_enHd(request));
HTList_addObject(http->clients, client);
/*
** Create the HTTP output stream for generating the reply
** FROM the client request to the channel
*/
{
HTOutputStream * output = HTNet_getOutput(net, NULL, 0);
HTStream * app = HTTPReply_new(client, http,(HTStream*)output);
HTRequest_setOutputStream(client, app);
HTRequest_setOutputFormat(client, WWW_SOURCE);
}
http->state = HTTPS_NEED_REQUEST;
}
break;
case HTTPS_NEED_REQUEST:
if (type == HTEvent_READ || type == HTEvent_BEGIN) {
status = HTHost_read(net->host, net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_CLOSED)
http->state = HTTPS_OK;
else if (status==HT_LOADED || status==HT_PAUSE) {
http->state = HTTPS_LOAD_CLIENT;
} else
http->state = HTTPS_ERROR;
} else
http->state = HTTPS_ERROR;
break;
case HTTPS_LOAD_CLIENT:
{
HTRequest * client = HTList_removeFirstObject(http->clients);
HTLoad(client, NO);
http->state = HTTPS_BEGIN;
break;
}
case HTTPS_OK:
ServerCleanup(request, net, HT_IGNORE);
return HT_OK;
case HTTPS_ERROR:
ServerCleanup(request, net, HT_ERROR);
return HT_OK;
}
}
}
PRIVATE int NewsEvent (SOCKET soc, void * pVoid, HTEventType type)
{
news_info *news = (news_info *)pVoid;
int status = HT_ERROR;
HTNet * net = news->net;
HTRequest * request = HTNet_request(net);
HTParentAnchor * anchor = HTRequest_anchor(request);
char * url = HTAnchor_physical(anchor);
HTHost * host = HTNet_host(net);
/*
** Initiate a new nntp structure and bind to request structure
** This is actually state NNTP_BEGIN, but it can't be in the state
** machine as we need the structure first.
*/
if (type == HTEvent_CLOSE) { /* Interrupted */
HTRequest_addError(request, ERR_FATAL, NO, HTERR_INTERRUPTED,
NULL, 0, "HTLoadHTTP");
HTNewsCleanup(request, HT_INTERRUPTED);
return HT_OK;
} else
news = (news_info *) HTNet_context(net); /* Get existing copy */
/* Now jump into the machine. We know the state from the previous run */
while (1) {
switch (news->state) {
case NEWS_BEGIN:
news->state = (!strchr(url, '@') && strchr(url, '*')) ?
NEWS_SEEK_CACHE : NEWS_NEED_CONNECTION;
break;
case NEWS_SEEK_CACHE:
if (HTNewsCache_before(request, NULL, 0) == HT_LOADED)
news->state = NEWS_SUCCESS;
else
news->state = NEWS_NEED_CONNECTION;
break;
case NEWS_NEED_CONNECTION: /* Let's set up a connection */
if (!strncasecomp(url, "news:", 5)) {
HTUserProfile * up = HTRequest_userProfile(request);
char * newshost = HTUserProfile_news(up);
StrAllocCopy(news->name, url+5);
if (newshost) {
char *newshack = NULL; /* Then we can use HTParse :-) */
StrAllocCopy(newshack, "news://");
StrAllocCat(newshack, newshost);
status = HTHost_connect(host, net, (char *) newshack);
host = HTNet_host(net);
HT_FREE(newshack);
} else
news->state = NEWS_ERROR;
} else if (!strncasecomp(url, "nntp:", 5)) {
news->name = HTParse(url, "", PARSE_PATH);
status = HTHost_connect(host, net, url);
host = HTNet_host(net);
} else {
HTTRACE(PROT_TRACE, "News........ Huh?");
news->state = NEWS_ERROR;
}
if (status == HT_OK) {
BOOL greeting = NO;
/* Set up the persistent connection */
if (!HTNet_persistent(net)) {
HTNet_setPersistent(net, YES, HT_TP_SINGLE);
greeting = YES;
}
/*
** 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, "nntp")) {
HTRequest_addError(request, ERR_FATAL, NO, HTERR_CLASS,
NULL, 0, "HTLoadNews");
news->state = NEWS_ERROR;
break;
}
HTHost_setClass(host, "nntp");
}
/*
** 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 * rstream = HTNewsStatus_new(request, news, host);
HTNet_setReadStream(net, rstream);
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);
}
news->state = greeting ? NEWS_NEED_GREETING : NEWS_NEED_SWITCH;
} else if (status == HT_WOULD_BLOCK || status == HT_PENDING)
return HT_OK;
else
news->state = NEWS_ERROR;
break;
case NEWS_NEED_GREETING:
status = HTHost_read(HTNet_host(net), net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_LOADED) {
if (news->repcode/100 == 2)
news->state = NEWS_NEED_SWITCH;
else
news->state = NEWS_ERROR;
} else
news->state = NEWS_ERROR;
break;
case NEWS_NEED_SWITCH:
{
HTMethod method = HTRequest_method(request);
/*
** Find out what to ask the news server. Syntax of address is
** xxx@yyy Article
** <xxx@yyy> Same article
** xxxxx News group (no "@")
*/
if (method == METHOD_GET) {
if (strchr(url, '@')) { /* ARTICLE */
if (*(news->name) != '<') { /* Add '<' and '>' */
char *newart;
if ((newart = (char *) HT_MALLOC(strlen(news->name)+3)) == NULL)
HT_OUTOFMEM("HTLoadNews");
sprintf(newart, "<%s>", news->name);
HT_FREE(news->name);
news->name = newart;
}
news->state = NEWS_NEED_ARTICLE;
} else if (strchr(url, '*'))
news->state = NEWS_NEED_LIST;
else
news->state = NEWS_NEED_GROUP;
} else if (method == METHOD_POST)
news->state = NEWS_NEED_POST;
else {
HTRequest_addError(request, ERR_FATAL, NO,
HTERR_NOT_IMPLEMENTED,NULL, 0,"HTLoadNews");
news->state = NEWS_ERROR;
}
HTUnEscape(news->name);
HTCleanTelnetString(news->name);
}
break;
case NEWS_NEED_ARTICLE:
if (!news->sent) {
status = SendCommand(request, news, "ARTICLE", news->name);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_ERROR)
news->state = NEWS_ERROR;
news->format = WWW_MIME;
/*
** Set the default content type to plain text as news servers
** almost never send any useful information about the length
** of the body or the type - the success of MIME!
*/
HTAnchor_setFormat(anchor, WWW_PLAINTEXT);
news->sent = YES;
} else {
status = HTHost_read(HTNet_host(net), net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_OK)
news->state = NEWS_NEED_BODY;
else if (status == HT_LOADED) {
news->state = (news->repcode/100 == 2) ?
NEWS_SUCCESS : NEWS_ERROR;
} else
news->state = NEWS_ERROR;
news->sent = NO;
}
break;
#if HT_LISTGROUP
case NEWS_NEED_LGRP:
if (!news->sent) {
status = SendCommand(request, news, "LIST", "NEWSGROUPS");
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_ERROR)
news->state = NEWS_ERROR;
news->format = WWW_NNTP_LIST;
news->sent = YES;
} else {
status = HTHost_read(HTNet_host(net), net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_OK)
news->state = NEWS_NEED_BODY;
else if (status == HT_LOADED) {
news->state = (news->repcode/100 == 2) ?
NEWS_SUCCESS : NEWS_NEED_LIST;
} else
news->state = NEWS_ERROR;
news->sent = NO;
}
break;
#endif /* HT_LISTGROUP */
case NEWS_NEED_LIST:
if (!news->sent) {
status = SendCommand(request, news, "LIST", NULL);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_ERROR)
news->state = NEWS_ERROR;
news->format = WWW_NNTP_LIST;
news->sent = YES;
} else {
status = HTHost_read(HTNet_host(net), net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_OK)
news->state = NEWS_NEED_BODY;
else if (status == HT_LOADED) {
news->state = (news->repcode/100 == 2) ?
NEWS_SUCCESS : NEWS_ERROR;
} else
news->state = NEWS_ERROR;
news->sent = NO;
}
break;
case NEWS_NEED_GROUP:
if (!news->sent) {
status = SendCommand(request, news, "GROUP", news->name);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_ERROR)
news->state = NEWS_ERROR;
news->sent = YES;
} else {
status = HTHost_read(HTNet_host(net), net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_LOADED) {
if (news->repcode/100 == 2) {
if (sscanf(news->reply, "%d%d%d", &news->total,
&news->first, &news->last) == 3) {
if (MaxArt && news->total>MaxArt)
news->last = news->first-MaxArt;
news->current = news->first;
/* If no content in this group */
if (news->first == news->last) {
HTRequest_addError(request, ERR_FATAL, NO,
HTERR_NO_CONTENT,
NULL, 0, "HTLoadNews");
news->state = NEWS_NO_DATA;
break;
}
news->state = NEWS_NEED_XOVER;
} else
news->state = NEWS_ERROR;
} else
news->state = NEWS_ERROR;
} else
news->state = NEWS_ERROR;
news->sent = NO;
}
break;
case NEWS_NEED_XOVER:
if (!news->sent) {
char buf[20];
sprintf(buf, "%d-%d", news->first, news->last);
status = SendCommand(request, news, "XOVER", buf);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_ERROR)
news->state = NEWS_ERROR;
news->format = WWW_NNTP_OVER;
news->sent = YES;
} else {
status = HTHost_read(HTNet_host(net), net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_OK)
news->state = NEWS_NEED_BODY;
else if (status == HT_LOADED) {
if (news->repcode/100 == 2)
news->state = NEWS_SUCCESS;
else {
news->format = WWW_NNTP_HEAD;
news->state = NEWS_NEED_HEAD;
}
} else
news->state = NEWS_ERROR;
news->sent = NO;
}
break;
case NEWS_NEED_HEAD:
if (!news->sent) {
char buf[10];
sprintf(buf, "%d", news->current++);
status = SendCommand(request, news, "HEAD", buf);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_ERROR)
news->state = NEWS_ERROR;
news->sent = YES;
} else {
status = HTHost_read(HTNet_host(net), net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_LOADED) {
if (news->repcode/100 == 2) {
if (news->current > news->last)
news->state = NEWS_SUCCESS;
} else
news->state = NEWS_ERROR;
} else
news->state = NEWS_ERROR;
news->sent = NO;
}
break;
case NEWS_NEED_POST:
{
HTStream * oldinput = HTRequest_inputStream(request);
HTStream * newinput =
HTNewsPost_new(request, HTBuffer_new(oldinput, request,512));
HTRequest_setInputStream(request, newinput);
/* Remember to convert to CRLF */
}
news->state = NEWS_NEED_BODY;
break;
case NEWS_NEED_BODY:
if (type == HTEvent_WRITE || type == HTEvent_BEGIN) {
if (HTRequest_isDestination(request)) {
HTRequest * source = HTRequest_source(request);
HTNet * srcnet = HTRequest_net(source);
if (srcnet) {
HTHost_register(HTNet_host(srcnet), srcnet, HTEvent_READ);
HTHost_unregister(HTNet_host(srcnet), srcnet, HTEvent_WRITE);
}
return HT_OK;
}
/*
** Should we use the input stream directly or call the post
** callback function to send data down to the network?
*/
{
HTStream * input = HTRequest_inputStream(request);
HTPostCallback * pcbf = HTRequest_postCallback(request);
if (pcbf) {
status = pcbf(request, input);
if (status == HT_PAUSE || status == HT_LOADED)
type = HTEvent_READ;
} else {
status = (*input->isa->flush)(input);
type = HTEvent_READ;
}
if (status == HT_WOULD_BLOCK) return HT_OK;
}
status = request->PostCallback ?
request->PostCallback(request, request->input_stream) :
(*request->input_stream->isa->flush)(request->input_stream);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else
type = HTEvent_READ; /* Trick to ensure that we do READ */
} else if (type == HTEvent_READ) {
status = HTHost_read(HTNet_host(net), net);
if (status == HT_WOULD_BLOCK)
return HT_OK;
else if (status == HT_LOADED)
news->state = NEWS_SUCCESS;
else
news->state = NEWS_ERROR;
} else {
news->state = NEWS_ERROR;
}
break;
case NEWS_SUCCESS:
HTNewsCleanup(request, HT_LOADED);
return HT_OK;
break;
case NEWS_NO_DATA:
HTNewsCleanup(request, HT_NO_DATA);
return HT_OK;
break;
case NEWS_ERROR:
HTNewsCleanup(request, HT_NOT_FOUND);
return HT_OK;
break;
}
} /* End of while(1) */
}
