void HText_beginAnchor (HText * text, HTChildAnchor * anchor)
{
TextAnchor * a;
if (text && anchor) {
Robot * mr = (Robot *) HTRequest_context(text->request);
HTAnchor * dest = HTAnchor_followMainLink((HTAnchor *) anchor);
HTParentAnchor * dest_parent = HTAnchor_parent(dest);
char * uri = HTAnchor_address((HTAnchor *) dest_parent);
#if 0
if (SHOW_MSG) HTTrace("Robot....... Found `%s\' \n", uri ? uri : "NULL");
#endif
if (uri) {
HTList_addObject(mr->urilist, (void *) uri);
mr->count++;
}
if ((a = (TextAnchor *) HT_MALLOC(sizeof(*a))) == NULL)
HT_OUTOFMEM("HText_beginAnchor");
if (text->last_anchor) {
text->last_anchor->next = a;
} else {
text->first_anchor = a;
}
a->next = 0;
a->anchor = anchor;
text->last_anchor = a;
if (HTAnchor_followMainLink((HTAnchor*)anchor)) {
a->number = ++(text->anchors);
} else {
a->number = 0;
}
}
}
PRIVATE void rdf_delete_userData(void *userdata)
{
prolog_term parsed_result, status_term;
USERDATA *me = (USERDATA *)userdata;
HTRequest *request = me->request;
if (request) {
parsed_result =
((REQUEST_CONTEXT *)HTRequest_context(request))->request_result;
status_term =
((REQUEST_CONTEXT *)HTRequest_context(request))->status_term;
}
else return;
#ifdef LIBWWW_DEBUG
xsb_dbgmsg((LOG_DEBUG,"***In rdf_delete_userData(%s)", RequestID(request)));
#endif
#ifdef LIBWWW_DEBUG_VERBOSE
print_prolog_term(me->parsed_term, "Current parse value");
#endif
/* terminate the parsed prolog terms list */
extern_c2p_nil(me->parsed_term_tail);
/* pass the result to the outside world */
if (is_var(me->parsed_term))
extern_p2p_unify(parsed_result, me->parsed_term);
else
xsb_abort("[LIBWWW_REQUEST] Request %s: Arg 4 (Result) must be unbound variable",
RequestID(request));
HT_FREE(me);
#ifdef LIBWWW_DEBUG
xsb_dbgmsg((LOG_DEBUG,"***Request %s: freed the USERDATA object", RequestID(request)));
#endif
return;
}
PUBLIC BOOL UserProgress (HTRequest * request, HTAlertOpcode op,
int msgnum, const char * dfault, void * input,
HTAlertPar * reply)
{
char * msg = HTDialog_progressMessage(request, op, msgnum, dfault, input);
CRequest * req = (CRequest *) HTRequest_context(request);
ASSERT(request != NULL);
ASSERT(req != NULL);
CProgressCtrl * progress = req->GetProgressBar();
switch (op) {
case HT_PROG_READ:
{
long cl = HTAnchor_length(HTRequest_anchor(request));
if (cl > 0) {
long b_read = HTRequest_bodyRead(request);
double pro = (double) b_read/cl*100;
progress->SetPos((int) pro);
}
}
break;
case HT_PROG_WRITE:
{
long cl = HTAnchor_length(HTRequest_entityAnchor(request));
if (cl > 0) {
long b_written = HTRequest_bodyWritten(request);
double pro = (double) b_written/cl*100;
progress->SetPos((int) pro);
}
}
break;
}
// Update pane 0 of the status bar
if (msg) {
CWinComDoc * doc = req->m_pDoc;
if (doc) {
POSITION pos = doc->GetFirstViewPosition();
CView * view = doc->GetNextView( pos );
CMainFrame * mainframe = (CMainFrame *) view->GetParentFrame();
mainframe->m_wndStatusBar.SetPaneText(ID_SEPARATOR, msg);
}
HT_FREE(msg);
}
return YES;
}
HText * HText_new2 (HTRequest * request, HTParentAnchor * anchor,
HTStream * stream)
{
HText * me;
Robot * mr = (Robot *) HTRequest_context(request);
if ((me = (HText *) HT_CALLOC(1, sizeof(HText))) == NULL)
HT_OUTOFMEM("HText_new2");
/* Bind the HText object together with the Request Object */
me->request = request;
me->first_anchor = me->last_anchor = 0;
me->anchors = 0;
/* Add this HText object to our list */
mr->htext = me;
return me;
}
/* terminate_handler
** -----------------
** This function is registered to handle the result of the request
*/
PRIVATE int terminate_handler (HTRequest * request, HTResponse * response,
void * param, int status)
{
ComLine * cl = (ComLine *) HTRequest_context(request);
if (status == HT_LOADED) {
if (cl) {
if (cl->flags & CL_COUNT) {
HTPrint("Content Length found to be %ld\n",
HTAnchor_length(cl->anchor));
}
}
} else {
HTAlertCallback *cbf = HTAlert_find(HT_A_MESSAGE);
if (cbf) (*cbf)(request, HT_A_MESSAGE, HT_MSG_NULL, NULL,
HTRequest_error(request), NULL);
}
Cleanup(cl, (status/100 == 2) ? 0 : -1);
return HT_OK;
}
PRIVATE USERDATA *rdf_create_userData(HTRDF *parser,
HTRequest *request,
HTStream *target_stream)
{
USERDATA *me = NULL;
#ifdef LIBWWW_DEBUG
xsb_dbgmsg((LOG_DEBUG,"***Start rdf_create_userData: Request %s", RequestID(request)));
#endif
if (parser) {
/* make sure that MIME type is appropriate for RDF */
if (!verifyMIMEformat(request, RDFPARSE)) {
/*
HTStream * input = HTRequest_inputStream(request);
(*input->isa->abort)(input, NULL);
HTRequest_setInputStream(request,NULL);
HTRequest_kill(request);
return NULL;
*/
xsb_abort("[LIBWWW_REQUEST] Bug: Request type/MIME type mismatch");
}
if ((me = (USERDATA *) HT_CALLOC(1, sizeof(USERDATA))) == NULL)
HT_OUTOFMEM("libwww_parse_rdf");
me->delete_method = rdf_delete_userData;
me->parser = parser;
me->request = request;
me->target = target_stream;
me->parsed_term = extern_p2p_new();
extern_c2p_list(me->parsed_term);
me->parsed_term_tail = me->parsed_term;
}
#ifdef LIBWWW_DEBUG
xsb_dbgmsg((LOG_DEBUG,"***End rdf_create_userData: Request %s", RequestID(request)));
#endif
/* Hook up userdata to the request context */
((REQUEST_CONTEXT *)HTRequest_context(request))->userdata = (void *)me;
return me;
}
PRIVATE BOOL PromptUsernameAndPassword (HTRequest * request, HTAlertOpcode op,
int msgnum, const char * dfault,
void * input, HTAlertPar * reply)
{
ComLine * cl = (ComLine *) HTRequest_context(request);
char * realm = (char *) input;
if (request && cl) {
/*
** If we have a realm then check that it matches the realm
** that we got from the server.
*/
if (realm && cl->realm && !strcmp(cl->realm, realm)) {
HTAlert_setReplyMessage(reply, cl->user ? cl->user : "");
HTAlert_setReplySecret(reply, cl->password ? cl->password : "");
return YES;
} else {
BOOL status = HTPrompt(request, op, msgnum, dfault, input, reply);
return status ?
HTPromptPassword(request, op, HT_MSG_PW, dfault, input, reply) : NO;
}
}
return NO;
}
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;
}
}
}
