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;
}
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;
}
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);
}
}
/* 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;
}
/* 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;
}
PUBLIC char * HTDialog_progressMessage (HTRequest * request, HTAlertOpcode op,
int msgnum, const char * dfault,
void * input)
{
char * result = NULL;
switch (op) {
case HT_PROG_DNS:
StrAllocMCopy(&result, "Looking up ",
input ? (char *) input : "",
NULL);
break;
case HT_PROG_CONNECT:
StrAllocMCopy(&result, "Contacting ",
input ? (char *) input : "",
NULL);
break;
case HT_PROG_ACCEPT:
StrAllocCopy(result, "Waiting for connection...");
break;
case HT_PROG_LOGIN:
StrAllocCopy(result, "Logging in...");
break;
case HT_PROG_READ:
if (request) {
long cl = HTAnchor_length(HTRequest_anchor(request));
if (cl > 0) {
long b_read = HTRequest_bodyRead(request);
double pro = (double) b_read/cl*100;
char buf[10];
char pct[10];
HTNumToStr((unsigned long) cl, buf, 10);
sprintf(pct, "%d%%", (int) pro);
StrAllocMCopy(&result, "Read (", pct, " of ", buf, ")", NULL);
} else {
long b_read = HTRequest_bytesRead(request);
int * raw_read = input ? (int *) input : NULL;
if (b_read > 0) {
char buf[10];
HTNumToStr(b_read, buf, 10);
StrAllocMCopy(&result, "Read ", buf, "bytes", NULL);
} else if (raw_read && *raw_read>0) {
char buf[10];
HTNumToStr(*raw_read, buf, 10);
StrAllocMCopy(&result, "Read ", buf, "bytes", NULL);
} else {
StrAllocCopy(result, "Reading...");
}
}
}
break;
case HT_PROG_WRITE:
if (request && HTMethod_hasEntity(HTRequest_method(request))) {
HTParentAnchor *anchor=HTRequest_anchor(HTRequest_source(request));
long cl = HTAnchor_length(anchor);
if (cl > 0) {
long b_write = HTRequest_bodyWritten(request);
double pro = (double) b_write/cl*100;
char buf[10];
char pct[10];
HTNumToStr((unsigned long) cl, buf, 10);
sprintf(pct, "%d%%", (int) pro);
StrAllocMCopy(&result, "Writing (", pct, " of ", buf, ")", NULL);
} else {
long b_written = HTRequest_bytesWritten(request);
int * raw_written = input ? (int *) input : NULL;
if (b_written > 0) {
char buf[10];
HTNumToStr(b_written>0 ? b_written : 0, buf, 10);
StrAllocMCopy(&result, "Writing ", buf, "bytes", NULL);
} if (raw_written && *raw_written>0) {
char buf[10];
HTNumToStr(*raw_written, buf, 10);
StrAllocMCopy(&result, "Writing ", buf, "bytes", NULL);
} else {
StrAllocCopy(result, "Writing...");
}
}
}
break;
case HT_PROG_DONE:
StrAllocCopy(result, "Done!");
break;
case HT_PROG_INTERRUPT:
StrAllocCopy(result, "Interrupted!");
break;
case HT_PROG_OTHER:
StrAllocCopy(result, "Working - please wait...");
break;
case HT_PROG_TIMEOUT:
StrAllocCopy(result, "Request timeout - server did not respond.");
break;
default:
StrAllocCopy(result, "UNKNOWN PROGRESS STATE");
break;
}
return result;
}
