/* HTNewsDir_new
** ----------
** Creates a structured stream object and sets up the initial HTML stuff
** Returns the newsdir object if OK, else NULL
*/
PUBLIC HTNewsDir * HTNewsDir_new (HTRequest * request, const char * title,
HTNewsDirKey key, BOOL cache)
{
HTNewsDir *dir;
if (!request) return NULL;
/* Create object */
if ((dir = (HTNewsDir *) HT_CALLOC(1, sizeof (HTNewsDir))) == NULL)
HT_OUTOFMEM("HTNewsDir_new");
dir->target = HTMLGenerator(request, NULL, WWW_HTML,
HTRequest_outputFormat(request),
HTRequest_outputStream(request));
HTAnchor_setFormat(HTRequest_anchor(request), WWW_HTML);
dir->request = request;
dir->key = key;
dir->lastLevel = -1; /* Added by MP. */
/* Get the newsgroup(s) name; added by MP. */
{
char* url = HTAnchor_physical(HTRequest_anchor(request));
char* p = url+strlen(url);
while (p > url && p[-1] != ':' && p[-1] != '/' && p[-1] != '\\')
p--;
StrAllocCopy (dir->name, p);
}
if (key != HT_NDK_NONE) { /* Thread is unsorted */
int total = HTNews_maxArticles();
dir->array = HTArray_new(total > 0 ? total : 128);
}
/* If we are asked to prepare a cache entry then create the cache array */
if (cache) {
int total = HTNews_maxArticles();
dir->cache = HTArray_new(total > 0 ? total : 128);
}
/* Start the HTML stuff */
{
HTStructured *target = dir->target;
const char *msg = title ? title : "News Listing";
START(HTML_HTML);
START(HTML_HEAD);
START(HTML_TITLE);
PUTS(msg);
END(HTML_TITLE);
END(HTML_HEAD);
START(HTML_BODY);
START(HTML_H1);
PUTS(msg);
END(HTML_H1);
}
return dir;
}
PUBLIC HTStream * HTBoundary (HTRequest * request,
void * param,
HTFormat input_format,
HTFormat output_format,
HTStream * output_stream)
{
HTResponse * response = HTRequest_response(request);
HTParentAnchor * anchor = HTRequest_anchor(request);
HTAssocList * type_param = response ?
HTResponse_formatParam(response) :
HTAnchor_formatParam(anchor);
char * boundary = HTAssocList_findObject(type_param, "boundary");
if (boundary) {
HTStream * me;
if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL)
HT_OUTOFMEM("HTBoundary");
me->isa = &HTBoundaryClass;
me->request = request;
me->format = output_format;
me->orig_target = output_stream;
me->debug = HTRequest_debugStream(request);
me->state = EOL_FLF;
StrAllocCopy(me->boundary, boundary); /* Local copy */
me->bpos = me->boundary;
HTTRACE(STREAM_TRACE, "Boundary.... Stream created with boundary '%s\'\n" _ me->boundary);
return me;
} else {
HTTRACE(STREAM_TRACE, "Boundary.... UNKNOWN boundary!\n");
return HTErrorStream();
}
}
/*
** Proxy and Gateway BEFORE filter
** -------------------------------
** Checks for registerd proxy servers or gateways and sees whether this
** request should be redirected to a proxy or a gateway. Proxies have
** higher priority than gateways so we look for them first!
** For HTTP/1.0 and HTTP/1.1 we may only send a full URL (including the
** host portion) to proxy servers. Therefore, we tell the Library whether
** to use the full URL or the traditional HTTP one without the host part.
*/
PUBLIC int HTProxyFilter (HTRequest * request, void * param, int mode)
{
HTParentAnchor * anchor = HTRequest_anchor(request);
char * addr = HTAnchor_physical(anchor);
char * physical = NULL;
if ((physical = HTProxy_find(addr))) {
HTRequest_setFullURI(request, YES); /* For now */
HTRequest_setProxy(request, physical);
HT_FREE(physical);
#if 0
/* Don't paste the URLs together anymore */
StrAllocCat(physical, addr);
HTAnchor_setPhysical(anchor, physical);
#endif
} else if ((physical = HTGateway_find(addr))) {
/*
** A gateway URL is crated by chopping off any leading "/" to make the
** host into part of path
*/
char * path =
HTParse(addr, "", PARSE_HOST + PARSE_PATH + PARSE_PUNCTUATION);
char * gatewayed = HTParse((*path=='/') ? path+1 : path, physical, PARSE_ALL);
HTAnchor_setPhysical(anchor, gatewayed);
HT_FREE(path);
HT_FREE(gatewayed);
HTRequest_setFullURI(request, NO);
HTRequest_deleteProxy(request);
} else {
HTRequest_setFullURI(request, NO); /* For now */
HTRequest_deleteProxy(request);
}
return HT_OK;
}
/* Structured Text object
** ----------------------
**
** The structured stream can generate either presentation,
** or plain text, or HTML.
*/
PRIVATE HTStructured * HTML_new (HTRequest * request,
void * param,
HTFormat input_format,
HTFormat output_format,
HTStream * output_stream)
{
HTStructured * me = NULL;
if (request) {
if ((me = (HTStructured *) HT_CALLOC(1, sizeof(HTStructured))) == NULL)
HT_OUTOFMEM("HTML_new");
me->isa = &HTMLPresentation;
me->dtd = HTML_dtd();
me->request = request;
me->node_anchor = HTRequest_anchor(request);
me->title = HTChunk_new(128);
me->comment_start = NULL;
me->comment_end = NULL;
me->target = output_stream;
me->sp = me->stack + MAX_NESTING - 1;
/* Create the text object */
me->text = HTextImp_new(me->request, me->node_anchor, me->target);
}
return me;
}
/*
** Check the Memory Cache (History list) BEFORE filter
** ---------------------------------------------------
** Check if document is already loaded. The user can define whether
** the history list should follow normal expiration or work as a
** traditional history list where expired documents are not updated.
** We don't check for anything but existence proof of a document
** associated with the anchor as the definition is left to the application
*/
PUBLIC int HTMemoryCacheFilter (HTRequest * request, void * param, int mode)
{
HTReload validation = HTRequest_reloadMode(request);
HTParentAnchor * anchor = HTRequest_anchor(request);
void * document = HTAnchor_document(anchor);
/*
** We only check the memory cache if it's a GET method
*/
if (HTRequest_method(request) != METHOD_GET) {
HTTRACE(CACHE_TRACE, "Mem Cache... We only check GET methods\n");
return HT_OK;
}
/*
** If we are asked to flush the persistent cache then there is no reason
** to do anything here - we're flushing it anyway. Also if no document
** then just exit from this filter.
*/
if (!document || validation > HT_CACHE_FLUSH_MEM) {
HTTRACE(CACHE_TRACE, "Mem Cache... No fresh document...\n");
return HT_OK;
}
/*
** If we have a document object associated with this anchor then we also
** have the object in the history list. Depending on what the user asked,
** we can add a cache validator
*/
if (document && validation != HT_CACHE_FLUSH_MEM) {
HTTRACE(CACHE_TRACE, "Mem Cache... Document already in memory\n");
return HT_LOADED;
}
return HT_OK;
}
PRIVATE int HTSC_putBlock (HTStream * me, const char * b, int l)
{
me->cur_size += l;
/*
** If we get a buffer overflow and we are going to PUT or POST the document
** then ask the user whether it is OK to proceed buffering. Otherwise we
** must give up the request. In all other cases we stop if the buffer fills
** up.
*/
if (!me->ignore && me->max_size > 0 && me->cur_size > me->max_size) {
HTMethod method = HTRequest_method(me->request);
if (HTMethod_hasEntity(method)) {
HTAlertCallback *cbf = HTAlert_find(HT_A_CONFIRM);
if ((cbf && (*cbf)(me->request, HT_A_CONFIRM, HT_MSG_BIG_PUT,
NULL, NULL, NULL)))
me->ignore = YES;
else
me->give_up = YES;
} else {
me->give_up = YES;
}
} else if (!me->ensure) {
HTParentAnchor * anchor = HTRequest_anchor(me->request);
int cl = HTAnchor_length(anchor);
if (cl > 0) HTChunk_ensure(me->chunk, cl);
me->ensure = YES;
}
if (!me->give_up) {
HTChunk_putb(me->chunk, b, l);
return HT_OK;
}
return HT_ERROR;
}
/* HTMIME_anchor2response
* Copies the anchor HTTP headers into a response object by means
* of the generic _dispatchParsers function. Written so that we can
* copy the HTTP headers stored in the cache to the response object.
*/
PRIVATE void HTMIME_anchor2response (HTRequest * req)
{
char * token;
char * value;
HTAssocList * header;
HTAssoc * pres;
HTResponse * res;
HTParentAnchor * anchor;
if (!req)
return;
anchor = HTRequest_anchor (req);
header = HTAnchor_header (anchor);
if (!anchor || !header)
return;
while ((pres = (HTAssoc *) HTAssocList_nextObject (header)))
{
token = HTAssoc_name (pres);
value = HTAssoc_value (pres);
_dispatchParsers (req, token, value);
}
/*
** Notify the response object not to delete the lists that we
** have inherited from the anchor object
*/
res = HTRequest_response (req);
HTResponse_isCached (res, YES);
}
/*
** Before filter: Check whether we have a cache entry for this host
*/
PUBLIC int HTNewsCache_before (HTRequest * request, void * context, int mode)
{
char * url = HTAnchor_address((HTAnchor *) HTRequest_anchor(request));
HTNewsCache * element = HTNewsCache_find(request, url);
HT_FREE(url);
/*
** If we have found a cache object then create a new dir obejct and fill
** it with data from the cache
*/
if (element) {
char * title = GetNewsGroupTitle(request);
HTNewsDir * dir = HTNewsDir_new(request, title, list_key, NO);
void ** data = NULL;
char * line = (char *) HTArray_firstObject(element->cache, data);
while (line) {
HTNewsDir_addGroupElement(dir, line, NO);
line = (char *) HTArray_nextObject(element->cache, data);
}
/*
** After filling the new dir object we write it out and free it again
*/
HTNewsDir_free(dir);
HT_FREE(title);
return HT_LOADED;
}
return HT_OK;
}
PRIVATE int terminate_handler (HTRequest * request, HTResponse * response,
void * param, int status)
{
HTParentAnchor * anchor = HTRequest_anchor(request);
HTAssocList * headers = HTAnchor_header(anchor);
/*
** Write out the remaining list of headers that we not already store
** in the index file.
*/
if (headers) {
HTAssocList * cur = headers;
HTAssoc * pres;
while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
char * name = HTAssoc_name(pres);
char * value = HTAssoc_value(pres);
/* Now see if we have a match for this header field */
if (match && HTStrCaseMatch(match, name))
HTPrint("%s: %s\n", name, value);
}
}
/* stop the event loop */
HTEventList_stopLoop ();
/* stop here */
return HT_ERROR;
}
BinURLInputStream::BinURLInputStream(const XMLURL& urlSource)
: fBuffer(0)
, fBufferSize(0)
, fBufferIndex(0)
, fRemoteFileSize(0)
, fAnchor(0)
, fBytesProcessed(0)
, fMemoryManager(urlSource.getMemoryManager())
{
fBuffer = (XMLByte*) fMemoryManager->allocate
(
URLISBUFMAXSIZE * sizeof(XMLByte)
);//new XMLByte[URLISBUFMAXSIZE];
const XMLCh* uri = urlSource.getURLText();
char* uriAsCharStar = localTranscode(uri, fMemoryManager);
//
// First find the size of the remote resource being asked for.
// We use the ContentCounter stream provided by libWWW.
//
fAnchor = HTAnchor_findAddress(uriAsCharStar);
HTRequest* request = HTRequest_new();
HTRequest_setOutputFormat(request, WWW_SOURCE);
HTStream* counterStrm = HTContentCounter(HTBlackHole(), request, 0xFFFF);
BOOL status = HTLoadToStream(uriAsCharStar, counterStrm, request);
if (status == YES)
{
HTParentAnchor * anchor = HTRequest_anchor(request);
fRemoteFileSize=HTAnchor_length(anchor);
if(fRemoteFileSize < 0)
{
// Patch by Artur Klauser
// When a redirection is processed in libWWW, it seems that
// HTAnchor_length(anchor) == -1 on the original anchor, whereas
// HTResponse_length(response) gives the correct content length of
// the redirection target. This has confused fRemoteFileSize and it was
// not checked for a -1 response at all.
HTResponse * response = HTRequest_response (request);
fRemoteFileSize = HTResponse_length(response);
if (fRemoteFileSize < 0) {
ThrowXMLwithMemMgr(NetAccessorException, XMLExcepts::NetAcc_LengthError, fMemoryManager);
}
}
}
// Cleanup, before you throw any errors.
fMemoryManager->deallocate(uriAsCharStar);
HTRequest_delete(request);
// Don't know whether I am supposed to delete counterStrm.
if (status == NO)
{
ThrowXMLwithMemMgr(NetAccessorException, XMLExcepts::NetAcc_LengthError, fMemoryManager);
}
}
PRIVATE int CSParseUser_free (HTStream * me)
{
/* CSParse_deleteUser(me->pCSParse); */
char * addr = HTAnchor_address((HTAnchor *)HTRequest_anchor(me->request));
CSLoadedUser_add(CSParse_getUser(me->pCSParse), addr);
HT_FREE(addr);
CSParse_free(me);
HT_FREE(me);
return HT_OK;
}
/* Create a new transfer coder and insert it into stream chain
** -----------------------------------------------------------
** Creating the content decoding stack is not based on quality factors as
** we don't have the freedom as with content types. Specify whether you
** you want encoding or decoding using the BOOL "encode" flag.
*/
PUBLIC HTStream * HTContentTransferCodingStack (HTEncoding encoding,
HTStream * target,
HTRequest * request,
void * param,
BOOL encode)
{
HTList * coders[2];
HTStream * top = target;
HTCoding * pres = NULL;
int cnt;
if (!encoding || !request) {
HTTRACE(CORE_TRACE, "C-T-E..... Nothing applied...\n");
return target ? target : HTErrorStream();
}
/*
** We use the same encoders/decoders as for Transfer-Encodings
*/
coders[0] = HTRequest_transfer(request);
coders[1] = HTTransferCoders;
HTTRACE(CORE_TRACE, "C-T-E....... Looking for %s\n" _ HTAtom_name(encoding));
for (cnt=0; cnt < 2; cnt++) {
HTList * cur = coders[cnt];
while ((pres = (HTCoding *) HTList_nextObject(cur))) {
if (pres->encoding == encoding) {
HTTRACE(CORE_TRACE, "C-T-E....... Found...\n");
if (encode) {
if (pres->encoder)
top = (*pres->encoder)(request, param, encoding, top);
break;
} else if (pres->decoder) {
top = (*pres->decoder)(request, param, encoding, top);
break;
}
}
}
}
/*
** If this is not a unity coding and we didn't find any coders
** that could handle it then put in a local file save stream
** instead of the stream that we got.
*/
if (!HTFormat_isUnityTransfer(encoding) && target==top) {
if (encode) {
HTTRACE(CORE_TRACE, "C-T-E....... NOT FOUND - removing encoding!\n");
HTAnchor_setContentTransferEncoding(HTRequest_anchor(request), NULL);
} else {
HTTRACE(CORE_TRACE, "C-T-E....... NOT FOUND - error!\n");
top = HTBlackHole();
}
}
return top;
}
/* Take action using a system command
** ----------------------------------
** Creates temporary file, writes to it and then executes system
** command (maybe an external viewer) when EOF has been reached. The
** stream finds a suitable name of the temporary file which preserves the
** suffix. This way, the system command can find out the file type from
** the name of the temporary file name.
*/
PUBLIC HTStream* HTSaveAndExecute (HTRequest * request,
void * param,
HTFormat input_format,
HTFormat output_format,
HTStream * output_stream)
{
FILE * fp = NULL;
char * filename = NULL;
HTUserProfile * up = HTRequest_userProfile(request);
char * tmproot = HTUserProfile_tmp(up);
if (HTLib_secure()) {
HTRequest_addError(request, ERR_NON_FATAL, NO, HTERR_UNAUTHORIZED,
NULL, 0, "HTSaveLocally");
return HTErrorStream();
}
if (!tmproot) {
HTTRACE(STREAM_TRACE, "Save File... turned off");
return HTErrorStream();
}
/* Let's find a hash name for this file without asking user */
{
HTParentAnchor *anchor = (HTParentAnchor *) HTRequest_anchor(request);
char *suffix = HTBind_getSuffix(anchor);
filename = get_filename(tmproot, HTAnchor_physical(anchor), suffix, NO);
HT_FREE(suffix);
if (filename) {
if ((fp = fopen(filename, "wb")) == NULL) {
HTRequest_addError(request, ERR_NON_FATAL, NO, HTERR_NO_FILE,
filename, strlen(filename),"HTSaveAndExecute");
HT_FREE(filename);
return HTErrorStream();
}
} else {
HTTRACE(STREAM_TRACE, "Save File... No file name\n");
return HTErrorStream();
}
}
/* Now we are ready for creating the file writer stream */
if (fp) {
HTStream * me = HTFileSave_new(request, fp, NO);
me->filename = filename;
if (param) {
if ((me->end_command = (char *) HT_MALLOC((strlen((char *) param) + 10 + 3*strlen(filename)))) == NULL)
HT_OUTOFMEM("SaveAndExecute");
sprintf (me->end_command,
(char *)param, filename, filename, filename);
}
return me;
}
HT_FREE(filename);
return HTErrorStream();
}
/*
** Check the response to see if we got a cookie or more.
** If so then figure out what to do with it (prompt user, store, etc.)
*/
PRIVATE int HTCookie_afterFilter (HTRequest * request, HTResponse * response,
void * param, int status)
{
if ((CookieMode & HT_COOKIE_ACCEPT) && SetCookie) {
HTCookieHolder * holder = HTCookieHolder_find(request);
if (holder) {
HTList * cookies = holder->cookies;
HTCookie * pres;
while ((pres = (HTCookie *) HTAssocList_nextObject(cookies))) {
/* Should we check to see if hosts match? */
if (CookieMode & (HT_COOKIE_SAME_HOST|HT_COOKIE_SAME_DOMAIN)) {
char * cookie_host = HTCookie_domain(pres);
if (cookie_host) {
int res;
char * addr = HTAnchor_address((HTAnchor *) HTRequest_anchor(request));
char * host = HTParse(addr, "", PARSE_HOST);
if (CookieMode & HT_COOKIE_SAME_DOMAIN)
res = tailcasecomp(cookie_host, host);
else
res = strcasecomp(cookie_host, host);
if (res != 0) {
HTTRACE(APP_TRACE, "Cookie...... Host `%s\' doesn't match what is sent in cookie `%s\'\n" _ host _ cookie_host);
HT_FREE(addr);
continue;
}
HT_FREE(addr);
}
}
/* Should we prompt the user? */
if (CookieMode & HT_COOKIE_PROMPT) {
HTAlertCallback * prompt = HTAlert_find(HT_A_CONFIRM);
if (prompt) {
if ((*prompt)(request, HT_A_CONFIRM, HT_MSG_ACCEPT_COOKIE,
NULL, NULL, NULL) != YES)
continue;
} else
continue;
}
/* Call the application with our new cookie */
(*SetCookie)(request, pres, SetCookieContext);
}
/* Delete cookie holder */
HTCookieHolder_delete(holder);
}
}
return HT_OK;
}
/*
** After filter: Update the cache entry for this host
*/
PUBLIC int HTNewsCache_after (HTRequest * request, HTResponse * response,
void * context, int status)
{
HTArray * array = (HTArray *) context;
HTTRACE(PROT_TRACE, "News Cache.. AFTER filter\n");
if (request && array) {
char * url = HTAnchor_address((HTAnchor *) HTRequest_anchor(request));
HTNewsCache_update(request, url, array);
HT_FREE(url);
}
return HT_OK;
}
PUBLIC HTStream* HTPlainPresent (HTRequest * request,
void * param,
HTFormat input_format,
HTFormat output_format,
HTStream * output_stream)
{
HTStream * me;
if ((me = (HTStream *) HT_CALLOC(1, sizeof(HTStream))) == NULL)
HT_OUTOFMEM("HTPlain_new");
me->isa = &HTPlain;
me->text = HTextImp_new(request, HTRequest_anchor(request), output_stream);
HTextImp_build(me->text, HTEXT_BEGIN);
return me;
}
/* Helper function added by MP. */
PRIVATE char* GetNewsGroupTitle (HTRequest* request)
{
char * url = HTAnchor_physical(HTRequest_anchor(request));
char * title = NULL;
if (strrchr(url, '*'))
StrAllocCopy(title, "Newsgroups: ");
else
StrAllocCopy(title, "Newsgroup: ");
if (!strncasecomp(url, "news:", 5))
StrAllocCat(title, url+5);
else
StrAllocCat(title, HTParse(url, "", PARSE_PATH));
return title;
}
/*
** Rule Translation BEFORE Filter
** ------------------------------
** If we have a set of rules loaded (see the Rule manager) then check
** before each request whether how that should be translated. The trick
** is that a parent anchor has a "address" which is the part from the URL
** we used when we created the anchor. However, it also have a "physical
** address" which is the place we are actually going to look for the
** resource. Hence this filter translates the physical address
** (if any translations are found)
*/
PUBLIC int HTRuleFilter (HTRequest * request, void * param, int mode)
{
HTList * list = HTRule_global();
HTParentAnchor * anchor = HTRequest_anchor(request);
char * addr = HTAnchor_physical(anchor);
char * physical = HTRule_translate(list, addr, NO);
if (!physical) {
HTRequest_addError(request, ERR_FATAL, NO, HTERR_FORBIDDEN,
NULL, 0, "HTRuleFilter");
return HT_ERROR;
}
HTAnchor_setPhysical(anchor, physical);
HT_FREE(physical);
return HT_OK;
}
/*
** Error and Information AFTER filter
** ----------------------------------
** It checks the status code from a request and generates an
** error/information message if required.
*/
PUBLIC int HTInfoFilter (HTRequest * request, HTResponse * response,
void * param, int status)
{
HTParentAnchor * anchor = HTRequest_anchor(request);
char * uri = HTAnchor_address((HTAnchor*) anchor);
switch (status) {
case HT_RETRY: {
HTAlertCallback *cbf = HTAlert_find(HT_A_MESSAGE);
if (cbf) (*cbf)(request, HT_A_MESSAGE, HT_MSG_NULL, NULL,
HTRequest_error(request), NULL);
HTTRACE(PROT_TRACE, "Load End.... NOT AVAILABLE, RETRY AT %ld\n" _
HTResponse_retryTime(response));
}
break;
case HT_NO_DATA:
{
/*
** The document was empty
*/
HTAlertCallback *cbf = HTAlert_find(HT_A_MESSAGE);
if (cbf) (*cbf)(request, HT_A_MESSAGE, HT_MSG_NULL, NULL,
HTRequest_error(request), NULL);
HTTRACE(PROT_TRACE, "Load End.... EMPTY: No content `%s\'\n" _
uri ? uri : "<UNKNOWN>");
break;
}
case HT_LOADED:
HTTRACE(PROT_TRACE, "Load End.... OK: `%s\'\n" _ uri);
break;
default:
{
/*
** See if we have a function registered for outputting errors.
** If so then call it and present the message to the user
*/
HTAlertCallback *cbf = HTAlert_find(HT_A_MESSAGE);
if (cbf) (*cbf)(request, HT_A_MESSAGE, HT_MSG_NULL, NULL,
HTRequest_error(request), NULL);
HTTRACE(PROT_TRACE, "Load End.... Request ended with code %d\n" _ status);
break;
}
}
HT_FREE(uri);
return HT_OK;
}
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;
}
PUBLIC int HTLoadFile (SOCKET soc, HTRequest * request)
{
file_info *file; /* Specific access information */
HTNet * net = HTRequest_net(request);
HTParentAnchor * anchor = HTRequest_anchor(request);
HTTRACE(PROT_TRACE, "HTLoadFile.. Looking for `%s\'\n" _
HTAnchor_physical(anchor));
if ((file = (file_info *) HT_CALLOC(1, sizeof(file_info))) == NULL)
HT_OUTOFMEM("HTLoadFILE");
file->state = FS_BEGIN;
file->net = net;
HTNet_setContext(net, file);
HTNet_setEventCallback(net, FileEvent);
HTNet_setEventParam(net, file); /* callbacks get http* */
return FileEvent(soc, file, HTEvent_BEGIN); /* get it started - ops is ignored */
}
/* HTAA_beforeFilter
** ------------------
** Make a lookup in the URL tree to find any context for this node,
** If no context is found then we assume that we don't know anything about
** this URL and hence we don't call any BEFORE filters at all.
** Return HT_OK or whatever callback returns
*/
PUBLIC int HTAA_beforeFilter (HTRequest * request, void * param, int mode)
{
char * url = HTAnchor_address((HTAnchor *) HTRequest_anchor(request));
const char * realm = HTRequest_realm(request);
HTAAElement * element = HTAA_findElement(NO, realm, url);
HT_FREE(url);
/* If we have an element then call the before filter with this scheme */
if (element) {
HTAAModule * module = HTAA_findModule(element->scheme);
if (module) {
HTTRACE(AUTH_TRACE, "Auth Engine. Found BEFORE filter %p\n" _
module->before);
return (*module->before)(request, element->context, mode);
}
}
return HT_OK;
}
/*
** A small BEFORE filter that just finds a cache entry unconditionally
** and loads the entry. All freshness and any other constraints are
** ignored.
*/
PRIVATE int HTCacheLoadFilter (HTRequest * request, void * param, int mode)
{
HTParentAnchor * anchor = HTRequest_anchor(request);
char * default_name;
HTCache * cache;
default_name = HTRequest_defaultPutName (request);
cache = HTCache_find(anchor, default_name);
HTTRACE(STREAM_TRACE, "Cache Load.. loading partial cache entry\n");
if (cache) {
char * name = HTCache_name(cache);
HTAnchor_setPhysical(anchor, name);
HTCache_addHit(cache);
HT_FREE(name);
}
return HT_OK;
}
/*
** my_headers : shows anchor's headers
** Parameters : HTRequest * request
*/
PRIVATE void my_headers (HTRequest *request) {
HTAssoc * h = NULL;
HTAssocList * headers = NULL;
HTParentAnchor * anchor = NULL;
HTPrint ("%s: Searching headers...\n",APP_NAME);
anchor = HTRequest_anchor (request);
headers = HTAnchor_header(anchor);
HTPrint ("\tanchor %s\n",(anchor)?"OK":"NULL");
h = HTAssocList_nextObject(headers);
while (anchor && headers && h ) {
HTPrint ("\t%s : %s\n",HTAssoc_name(h),HTAssoc_value(h));
h = HTAssocList_nextObject(headers);
}
}
/* Add entry to the referer log file
** ---------------------------------
**
** which is almost equivalent to Common Logformat. Permissions on UNIX
** are modified by umask.
**
** Returns YES if OK, NO on error
*/
PUBLIC BOOL HTLog_addReferer (HTLog * log, HTRequest * request, int status)
{
if (log && log->fp && request) {
HTParentAnchor * parent_anchor = HTRequest_parent(request);
if (parent_anchor) {
char * me = HTAnchor_address((HTAnchor *) HTRequest_anchor(request));
char * parent = HTAnchor_address((HTAnchor *) parent_anchor);
HTTRACE(APP_TRACE, "Log......... Writing Referer log\n");
if (me && parent && *parent) {
fprintf(log->fp, "%s -> %s\n", parent, me);
}
HT_FREE(me);
HT_FREE(parent);
log->accesses++;
return (fflush(log->fp) != EOF); /* Actually update it on disk */
}
}
return NO;
}
/* Add entry to the log file
** -------------------------
** Format: <HOST> - - <DATE> <METHOD> <URI> <RESULT> <CONTENT_LENTGH>
** which is almost equivalent to Common Logformat. Permissions on UNIX
** are modified by umask.
**
** Returns YES if OK, NO on error
**
** BUG: No result code is produced :-( Should be taken from HTError.c
*/
PUBLIC BOOL HTLog_addCLF (HTLog * log, HTRequest * request, int status)
{
if (log && log->fp) {
time_t now = time(NULL);
HTParentAnchor * anchor = HTRequest_anchor(request);
char * uri = HTAnchor_address((HTAnchor *) anchor);
HTTRACE(APP_TRACE, "Log......... Writing CLF log\n");
fprintf(log->fp, "localhost - - [%s] %s %s %d %ld\n",
HTDateTimeStr(&now, log->localtime),
HTMethod_name(HTRequest_method(request)),
uri ? uri : "<null>", /* Bill Rizzi */
abs(status),
HTAnchor_length(anchor));
HT_FREE(uri);
log->accesses++;
return (fflush(log->fp) != EOF); /* Actually update it on disk */
}
return NO;
}
PUBLIC int HTLoadNews (SOCKET soc, HTRequest * request)
{
news_info *news;
HTParentAnchor *anchor = HTRequest_anchor(request);
HTNet * net = HTRequest_net(request);
char * url = HTAnchor_physical(anchor);
HTTRACE(PROT_TRACE, "NNTP........ Looking for `%s\'\n" _ url);
if ((news = (news_info *) HT_CALLOC(1, sizeof(news_info))) == NULL)
HT_OUTOFMEM("HTLoadNews");
news->cmd = HTChunk_new(128);
news->state = NEWS_BEGIN;
news->net = net;
HTNet_setContext(net, news);
HTNet_setEventCallback(net, NewsEvent);
HTNet_setEventParam(net, news); /* callbacks get http* */
return NewsEvent(soc, news, HTEvent_BEGIN); /* get it started - ops is ignored */
}
/* NewsPost_start
** --------------
** NNTP needs two extra headers: "From" and "Newsgroups".
** Take the newsgroups from the Postweb model as destinations for this
** anchor.
** Return YES if OK else NO
*/
PRIVATE BOOL NewsPost_start (HTStream * me, HTRequest * request)
{
char linebuf[128]; /* @@@ */
HTChunk *header = me->buffer;
HTUserProfile * up = HTRequest_userProfile(request);
const char * mailaddress = HTUserProfile_email(up);
if (mailaddress) {
sprintf(linebuf, "From: %s%c%c", mailaddress, CR, LF);
HTChunk_puts(header, linebuf);
}
/*
** Find all the newsgroups we are posting to by looking at all the
** destinations from the source of this request.
** First the main link and then the sub links
*/
HTChunk_puts(header, "Newsgroups :");
if (HTRequest_isDestination(request)) {
HTRequest *src_req = HTRequest_source(request);
HTParentAnchor *src_anchor = HTRequest_anchor(src_req);
HTLink *link = HTAnchor_mainLink((HTAnchor *) src_anchor);
HTAnchor *dest = HTLink_destination(link);
HTMethod method = HTLink_method(link);
if (link && method == METHOD_POST &&
HTLink_result(link) == HT_LINK_NONE) {
char *desturl = HTAnchor_physical((HTParentAnchor *) dest);
char *access = HTParse(desturl, "", PARSE_ACCESS);
if (!strcasecomp(access, "news") || !strcasecomp(access, "nntp")) {
char *newsgroup = HTParse(desturl, "", PARSE_PATH);
HTUnEscape(newsgroup);
HTCleanTelnetString(newsgroup);
HTChunk_puts(header, newsgroup);
HT_FREE(newsgroup);
}
HT_FREE(access);
}
/* DO FOR ALL SUB ANCHOR DESTINATION S AS WELL */
}
HTTRACE(PROT_TRACE, "News Tx..... %s" _ HTChunk_data(header));
return YES;
}
/* HTTP09Request
** -------------
** Makes a HTTP/0.9 request
*/
PRIVATE int HTTP09Request (HTStream * me, HTRequest * request)
{
HTParentAnchor * anchor = HTRequest_anchor(request);
char * addr = HTAnchor_physical(anchor);
if (!me->url) me->url = HTParse(addr, "", PARSE_PATH|PARSE_PUNCTUATION);
if (me->state == 0) {
int status = PUTS("GET ");
if (status != HT_OK) return status;
me->state++;
}
if (me->state == 1) {
int status = PUTS(me->url);
if (status != HT_OK) return status;
me->state++;
}
PUTC(CR);
PUTC(LF);
HTTRACE(PROT_TRACE, "HTTP........ Generating HTTP/0.9 Request\n");
return HT_OK;
}
/*
** This is our handle to the server reply stream when data is coming
** back from our "client" request. It is responsible for setting up the
** remaining streams in order to produce a complete HTTP output.
** If we have a HTTP 1.x response then forward untouched.
*/
PRIVATE int MakeReplyPipe (HTStream * me, HTRequest * client)
{
char * response_line = NULL;
/* Generate the Response line */
{
HTAlertCallback *cbf = HTAlert_find(HT_A_MESSAGE);
if (cbf) {
HTAlertPar * reply = HTAlert_newReply();
if ((*cbf)(client, HT_A_MESSAGE, HT_MSG_NULL, NULL,
HTRequest_error(client), reply))
response_line = HTAlert_replyMessage(reply);
HTAlert_deleteReply(reply);
}
if (response_line) {
PUTS(response_line);
HT_FREE(response_line);
} else {
PUTS(HTTP_VERSION);
PUTS(" 500 Internal");
PUTC(CR);
PUTC(LF);
}
}
/*
** We now have to create the rest of the response stream. We see whether
** there is a data object or not by looking at the Content Type of the
** client anchor.
*/
{
HTParentAnchor * anchor = HTRequest_anchor(client);
HTFormat format = HTAnchor_format(anchor);
me->target = (format == WWW_UNKNOWN) ?
HTTPResponse_new(client, me->target, YES, HTTP_11) :
HTMIMERequest_new(client,
HTTPResponse_new(client,me->target, NO, HTTP_11), YES);
}
return HT_OK;
}
