/* End writing
*/
PRIVATE int HTMIME_abort (HTStream * me, HTList * e)
{
int status = HT_ERROR;
if (me->target) status = (*me->target->isa->abort)(me->target, e);
HTTRACE(PROT_TRACE, "MIME........ ABORTING...\n");
HTChunk_delete(me->token);
HTChunk_delete(me->value);
HT_FREE(me);
return status;
}
/*
** Check whether the application provides us with a cookie or more.
*/
PRIVATE int HTCookie_beforeFilter (HTRequest * request, void * param, int mode)
{
if ((CookieMode & HT_COOKIE_SEND) && FindCookie) {
HTAssocList * cookies = (*FindCookie)(request, FindCookieContext);
if (cookies) {
HTChunk * cookie_header = HTChunk_new(64);
HTAssocList * cur = cookies;
HTAssoc * pres;
BOOL first=YES;
while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
if (!first) HTChunk_putc(cookie_header, ';');
HTChunk_puts(cookie_header, HTAssoc_name(pres));
HTChunk_putc(cookie_header, '=');
HTChunk_puts(cookie_header, HTAssoc_value(pres));
first = NO;
}
HTRequest_addExtraHeader(request, "Cookie", HTChunk_data(cookie_header));
HTChunk_delete(cookie_header);
/* Also delete the association list */
HTAssocList_delete(cookies);
}
}
return HT_OK;
}
/* 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;
}
/* Free a stream object
** --------------------
*/
PRIVATE int HTMIME_free (HTStream * me)
{
int status = HT_OK;
if (!me->transparent)
if (_stream2dispatchParsers(me) == HT_OK)
pumpData(me);
if (me->target) {
if ((status = (*me->target->isa->_free)(me->target))==HT_WOULD_BLOCK)
return HT_WOULD_BLOCK;
}
HTTRACE(PROT_TRACE, "MIME........ FREEING....\n");
HTChunk_delete(me->token);
HTChunk_delete(me->value);
HT_FREE(me);
return status;
}
PRIVATE int SGML_abort (HTStream * context, HTList * e)
{
(*context->actions->abort)(context->target, e);
HTChunk_delete(context->string);
HT_FREE(context);
return HT_ERROR;
}
PRIVATE int NewsPost_abort (HTStream * me, HTList * e)
{
if (me->target) (*me->target->isa->abort)(me->target, e);
HTChunk_delete(me->buffer);
HT_FREE(me);
HTTRACE(PROT_TRACE, "NewsPost.... ABORTING...\n");
return HT_ERROR;
}
int getURL_tcl(ClientData clientData, Tcl_Interp *interp,
int argc, char **argv)
{
if (argc >= 3) {
char *listcheck = argv[1];
char *url = argv[2];
char * traceflags = argc==4 ? argv[3] : "";
if (url && (strcmp(listcheck, "listrefs")==0)) {
/* Create a new robot object */
Robot *robot = Robot_new();
/* Turn on trace messages */
if (argc==4) HTSetTraceMessageMask(traceflags);
/* Set up the HTML parser */
{
HTList * converters = HTFormat_conversion();
HTMLInit(converters);
}
/* Find an anchor and load it */
robot->anchor = (HTParentAnchor *) HTAnchor_findAddress(url);
HTLoadAnchor((HTAnchor *) robot->anchor, robot->request);
/* Update TcL return */
Tcl_AppendResult(interp, Reference_List(robot), NULL);
Robot_delete(robot);
return TCL_OK;
}
Tcl_AppendResult(interp, bad_vars, NULL);
return TCL_ERROR;
}
if (argc == 2) {
char *url = argv[1];
if (url) {
/* Create a new robot object */
Robot *robot = Robot_new();
HTChunk *chunk = 0;
/* Find an anchor and load it */
HTRequest_setOutputFormat(robot->request, WWW_SOURCE);
chunk = HTLoadToChunk(url, robot->request);
/* Update TcL return */
Tcl_AppendResult(interp, HTChunkData(chunk), NULL);
Robot_delete(robot);
HTChunk_delete(chunk);
return TCL_OK;
}
Tcl_AppendResult(interp, bad_vars, NULL);
return TCL_ERROR;
}
Tcl_AppendResult(interp, err_string, argv[0], " [listrefs] url traceflags", NULL);
return TCL_ERROR;
}
PRIVATE int HTML_abort (HTStructured * me, HTList * e)
{
if (!me->started) HTextImp_build(me->text, HTEXT_BEGIN);
HTextImp_build(me->text, HTEXT_ABORT);
HTextImp_delete(me->text);
HTChunk_delete(me->title);
if (me->target) ABORT_TARGET(me);
HT_FREE(me);
return HT_ERROR;
}
PRIVATE int SGML_free (HTStream * context)
{
int status;
if ((status = (*context->actions->_free)(context->target)) != HT_OK)
return status;
HTChunk_delete(context->string);
HT_FREE(context);
return HT_OK;
}
PUBLIC int HTML_free (HTStructured * me)
{
if (!me->started) HTextImp_build(me->text, HTEXT_BEGIN);
if (me->comment_end) HTML_put_string(me, me->comment_end);
HTextImp_build(me->text, HTEXT_END);
HTextImp_delete(me->text);
HTChunk_delete(me->title);
if (me->target) FREE_TARGET(me);
HT_FREE(me);
return HT_OK;
}
PRIVATE int HTTPReceive_free (HTStream * me)
{
int status = HT_OK;
if (me->target) {
if ((status = (*me->target->isa->_free)(me->target)) == HT_WOULD_BLOCK)
return HT_WOULD_BLOCK;
}
HTChunk_delete(me->buffer);
HT_FREE(me);
return status;
}
/*
** Flushes data and frees stream object
*/
PRIVATE int NewsPost_free (HTStream * me)
{
int status;
if ((status = NewsPost_flush(me)) != HT_OK ||
(status = NewsPost_end(me)) != HT_OK ||
(status = (*me->target->isa->_free)(me->target)) != HT_OK)
return status;
HTChunk_delete(me->buffer);
HT_FREE(me);
return status;
}
PRIVATE int HTRule_free (HTStream * me)
{
if (me) {
int status = HTRule_flush(me);
HTTRACE(APP_TRACE, "Rules....... FREEING....\n");
HTChunk_delete(me->buffer);
HT_FREE(me);
return status;
}
return HT_ERROR;
}
PRIVATE int HTRule_abort (HTStream * me, HTList * e)
{
if (me) {
int status = HT_ERROR;
HTTRACE(APP_TRACE, "Rules....... ABORTING...\n");
HTChunk_delete(me->buffer);
HT_FREE(me);
return status;
}
return HT_ERROR;
}
PRIVATE void Cleanup (int status, HTSQL * sql, HTChunk * chunk)
{
HTChunk_delete(chunk);
HTSQL_delete(sql);
HTLibTerminate();
#ifdef VMS
exit(status ? status : 1);
#else
exit(status ? status : 0);
#endif
}
PRIVATE int terminate_handler (HTRequest * request, HTResponse * response,
void * param, int status)
{
if (status == HT_LOADED && result && HTChunk_data(result)) {
HTPrint("%s", HTChunk_data(result));
HTChunk_delete(result);
}
/* We are done with this request */
HTRequest_delete(request);
/* Terminate libwww */
HTProfile_delete();
exit(0);
}
int main (int argc, char ** argv)
{
int status = 0;
int arg;
int tokencount = 0;
BOOL formdata = NO;
HTChunk * keywords = NULL; /* From command line */
HTAssocList*formfields = NULL;
HTMethod method = METHOD_GET; /* Default value */
ComLine * cl = ComLine_new();
BOOL cache = NO; /* Use persistent cache */
BOOL flush = NO; /* flush the persistent cache */
char * cache_root = NULL;
/* Starts Mac GUSI socket library */
#ifdef GUSI
GUSISetup(GUSIwithSIOUXSockets);
GUSISetup(GUSIwithInternetSockets);
#endif
#ifdef __MWERKS__ /* STR */
InitGraf((Ptr) &qd.thePort);
InitFonts();
InitWindows();
InitMenus(); TEInit();
InitDialogs(nil);
InitCursor();
SIOUXSettings.asktosaveonclose = false;
argc=ccommand(&argv);
#endif
/* Initiate W3C Reference Library with a client profile */
HTProfile_newNoCacheClient(APP_NAME, APP_VERSION);
/* Need our own trace and print functions */
HTPrint_setCallback(printer);
HTTrace_setCallback(tracer);
/*
** Delete the default Username/password handler so that we can handle
** parameters handed to us from the command line. The default is set
** by the profile.
*/
HTAlert_deleteOpcode(HT_A_USER_PW);
HTAlert_add(PromptUsernameAndPassword, HT_A_USER_PW);
/*
** Add default content decoder. We insert a through line as it doesn't
** matter that we get an encoding that we don't know.
*/
HTFormat_addCoding("*", HTIdentityCoding, HTIdentityCoding, 0.3);
/* Scan command Line for parameters */
for (arg=1; arg<argc; arg++) {
if (*argv[arg] == '-') {
/* - alone => filter */
if (argv[arg][1] == '\0') {
cl->flags |= CL_FILTER;
/* -? or -help: show the command line help page */
} else if (!strcmp(argv[arg],"-?") || !strcmp(argv[arg],"-help")) {
cl->anchor = (HTParentAnchor *) HTAnchor_findAddress(W3C_HELP);
tokencount = 1;
/* non-interactive */
} else if (!strcmp(argv[arg], "-n")) {
HTAlert_setInteractive(NO);
/* Treat the keywords as form data with a <name> "=" <value> */
} else if (!strcmp(argv[arg], "-form")) {
formdata = YES;
/* from -- Initial represntation (only with filter) */
} else if (!strcmp(argv[arg], "-from")) {
cl->format = (arg+1 < argc && *argv[arg+1] != '-') ?
HTAtom_for(argv[++arg]) : WWW_HTML;
/* to -- Final representation */
} else if (!strcmp(argv[arg], "-to")) {
HTFormat format = (arg+1 < argc && *argv[arg+1] != '-') ?
HTAtom_for(argv[++arg]) : DEFAULT_FORMAT;
HTRequest_setOutputFormat(cl->request, format);
/* destination for PUT, POST etc. */
} else if (!strcmp(argv[arg], "-dest")) {
if (arg+1 < argc && *argv[arg+1] != '-') {
char * dest = HTParse(argv[++arg], cl->cwd, PARSE_ALL);
cl->dest = (HTParentAnchor *) HTAnchor_findAddress(dest);
HT_FREE(dest);
}
/* source please */
} else if (!strcmp(argv[arg], "-source")) {
HTRequest_setOutputFormat(cl->request, WWW_RAW);
/* log file */
} else if (!strcmp(argv[arg], "-l")) {
cl->logfile = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_LOG_FILE;
/* Max forward hops in case of TRACE request */
} else if (!strcmp(argv[arg], "-hops") ||
!strcmp(argv[arg], "-maxforwards")) {
int hops = (arg+1 < argc && *argv[arg+1] != '-') ?
atoi(argv[++arg]) : DEFAULT_HOPS;
if (hops >= 0) HTRequest_setMaxForwards(cl->request, hops);
/* automated authentication of format user:password@realm */
} else if (!strncmp(argv[arg], "-auth", 5)) {
char * credentials = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : NULL;
if (credentials) ParseCredentials(cl, credentials);
/* rule file */
} else if (!strcmp(argv[arg], "-r")) {
cl->rules = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_RULE_FILE;
/* output filename */
} else if (!strcmp(argv[arg], "-o")) {
cl->outputfile = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_OUTPUT_FILE;
/* timeout -- Change the default request timeout */
} else if (!strcmp(argv[arg], "-timeout")) {
int timeout = (arg+1 < argc && *argv[arg+1] != '-') ?
atoi(argv[++arg]) : DEFAULT_TIMEOUT;
if (timeout >= 1) cl->timer = timeout*MILLIES;
/* preemptive or non-preemptive access */
} else if (!strcmp(argv[arg], "-single")) {
HTRequest_setPreemptive(cl->request, YES);
/* content Length Counter */
} else if (!strcmp(argv[arg], "-cl")) {
cl->flags |= CL_COUNT;
/* print version and exit */
} else if (!strcmp(argv[arg], "-version")) {
VersionInfo(argv[0]);
Cleanup(cl, 0);
/* run in quiet mode */
} else if (!strcmp(argv[arg], "-q")) {
cl->flags |= CL_QUIET;
/* Start the persistent cache */
} else if (!strcmp(argv[arg], "-cache")) {
cache = YES;
/* Determine the cache root */
} else if (!strcmp(argv[arg], "-cacheroot")) {
cache_root = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : NULL;
/* Persistent cache flush */
} else if (!strcmp(argv[arg], "-flush")) {
flush = YES;
/* Do a cache validation */
} else if (!strcmp(argv[arg], "-validate")) {
cl->flags |= CL_VALIDATE;
/* Do an end-to-end cache-validation */
} else if (!strcmp(argv[arg], "-endvalidate")) {
cl->flags |= CL_END_VALIDATE;
/* Force complete reload */
} else if (!strcmp(argv[arg], "-nocache")) {
cl->flags |= CL_CACHE_FLUSH;
#ifdef WWWTRACE
/* trace flags */
} else if (!strncmp(argv[arg], "-v", 2)) {
HTSetTraceMessageMask(argv[arg]+2);
#endif
/* GET method */
} else if (!strcasecomp(argv[arg], "-get")) {
method = METHOD_GET;
/* HEAD method */
} else if (!strcasecomp(argv[arg], "-head")) {
method = METHOD_HEAD;
/* DELETE method */
} else if (!strcasecomp(argv[arg], "-delete")) {
method = METHOD_DELETE;
/* POST Method */
} else if (!strcasecomp(argv[arg], "-post")) {
method = METHOD_POST;
/* PUT Method */
} else if (!strcasecomp(argv[arg], "-put")) {
method = METHOD_PUT;
/* OPTIONS Method */
} else if (!strcasecomp(argv[arg], "-options")) {
method = METHOD_OPTIONS;
/* TRACE Method */
} else if (!strcasecomp(argv[arg], "-trace")) {
method = METHOD_TRACE;
} else {
if (SHOW_MSG) HTPrint("Bad Argument (%s)\n", argv[arg]);
}
} else { /* If no leading `-' then check for URL or keywords */
if (!tokencount) {
char * ref = HTParse(argv[arg], cl->cwd, PARSE_ALL);
cl->anchor = (HTParentAnchor *) HTAnchor_findAddress(ref);
tokencount = 1;
HT_FREE(ref);
} else if (formdata) { /* Keywords are form data */
char * string = argv[arg];
if (tokencount++ <= 1) formfields = HTAssocList_new();
HTParseFormInput(formfields, string);
} else { /* keywords are search tokens */
char * escaped = HTEscape(argv[arg], URL_XALPHAS);
if (tokencount++ <= 1)
keywords = HTChunk_new(128);
else
HTChunk_putc(keywords, ' ');
HTChunk_puts(keywords, HTStrip(escaped));
HT_FREE(escaped);
}
}
}
if (!tokencount && !cl->flags & CL_FILTER) {
VersionInfo(argv[0]);
Cleanup(cl, 0);
}
/* Should we use persistent cache? */
if (cache) {
HTCacheInit(cache_root, 20);
/* Should we start by flushing? */
if (flush) HTCache_flushAll();
}
/*
** Check whether we should do some kind of cache validation on
** the load
*/
if (cl->flags & CL_VALIDATE)
HTRequest_setReloadMode(cl->request, HT_CACHE_VALIDATE);
else if (cl->flags & CL_END_VALIDATE)
HTRequest_setReloadMode(cl->request, HT_CACHE_END_VALIDATE);
else if (cl->flags & CL_CACHE_FLUSH)
HTRequest_setReloadMode(cl->request, HT_CACHE_FLUSH);
/* Add progress notification */
if (cl->flags & CL_QUIET) HTAlert_deleteOpcode(HT_A_PROGRESS);
/* Output file specified? */
if (cl->outputfile) {
if ((cl->output = fopen(cl->outputfile, "wb")) == NULL) {
if (SHOW_MSG) HTPrint("Can't open `%s'\\n",cl->outputfile);
cl->output = OUTPUT;
}
}
/*
** Set up the output. Even though we don't use this explicit, it is
** required in order to show the stream stack that we know that we are
** getting raw data output on the output stream of the request object.
*/
HTRequest_setOutputStream(cl->request,
HTFWriter_new(cl->request, cl->output, YES));
/* Setting event timeout */
HTHost_setEventTimeout(cl->timer);
/*
** Make sure that the first request is flushed immediately and not
** buffered in the output buffer
*/
HTRequest_setFlush(cl->request, YES);
/* Log file specifed? */
if (cl->logfile) {
cl->log = HTLog_open(cl->logfile, YES, YES);
if (cl->log) HTNet_addAfter(HTLogFilter, NULL, cl->log, HT_ALL, HT_FILTER_LATE);
}
/* Just convert formats */
if (cl->flags & CL_FILTER) {
#ifdef STDIN_FILENO
HTRequest_setAnchor(cl->request, (HTAnchor *) cl->anchor);
HTRequest_setPreemptive(cl->request, YES);
HTLoadSocket(STDIN_FILENO, cl->request);
#endif
Cleanup(cl, 0);
}
/* Content Length Counter */
if (cl->flags & CL_COUNT) {
HTRequest_setOutputStream(cl->request,
HTContentCounter(HTBlackHole(),
cl->request, 0x2000));
}
/* Rule file specified? */
if (cl->rules) {
char * rules = HTParse(cl->rules, cl->cwd, PARSE_ALL);
if (!HTLoadRulesAutomatically(rules))
if (SHOW_MSG) HTPrint("Can't access rules\n");
HT_FREE(rules);
}
/* Add our own filter to update the history list */
HTNet_addAfter(terminate_handler, NULL, NULL, HT_ALL, HT_FILTER_LAST);
/* Start the request */
switch (method) {
case METHOD_GET:
if (formdata)
status = HTGetFormAnchor(formfields, (HTAnchor *) cl->anchor,
cl->request);
else if (keywords)
status = HTSearchAnchor(keywords, (HTAnchor *) cl->anchor,
cl->request);
else
status = HTLoadAnchor((HTAnchor *) cl->anchor, cl->request);
break;
case METHOD_HEAD:
if (formdata) {
HTRequest_setMethod(cl->request, METHOD_HEAD);
status = HTGetFormAnchor(formfields, (HTAnchor *) cl->anchor,
cl->request);
} else if (keywords) {
HTRequest_setMethod(cl->request, METHOD_HEAD);
status = HTSearchAnchor(keywords, (HTAnchor *) cl->anchor,
cl->request);
} else
status = HTHeadAnchor((HTAnchor *) cl->anchor, cl->request);
break;
case METHOD_DELETE:
status = HTDeleteAnchor((HTAnchor *) cl->anchor, cl->request);
break;
case METHOD_POST:
if (formdata) {
HTParentAnchor * posted = NULL;
#if 1
posted = HTPostFormAnchor(formfields, (HTAnchor *) cl->anchor,
cl->request);
status = posted ? YES : NO;
#else
/* If we want output to a chunk instead */
post_result = HTPostFormAnchorToChunk(formfields, (HTAnchor *) cl->anchor,
cl->request);
status = post_result ? YES : NO;
#endif
} else {
if (SHOW_MSG) HTPrint("Nothing to post to this address\n");
status = NO;
}
break;
case METHOD_PUT:
status = HTPutDocumentAnchor(cl->anchor, (HTAnchor *) cl->dest,
cl->request);
break;
case METHOD_OPTIONS:
status = HTOptionsAnchor((HTAnchor *) cl->anchor, cl->request);
break;
case METHOD_TRACE:
status = HTTraceAnchor((HTAnchor *) cl->anchor, cl->request);
break;
default:
if (SHOW_MSG) HTPrint("Don't know this method\n");
break;
}
if (keywords) HTChunk_delete(keywords);
if (formfields) HTAssocList_delete(formfields);
if (status != YES) {
if (SHOW_MSG) HTPrint("Sorry, can't access resource\n");
Cleanup(cl, -1);
}
/* Go into the event loop... */
HTEventList_loop(cl->request);
/* Only gets here if event loop fails */
Cleanup(cl, 0);
return 0;
}
PUBLIC BOOL HTBind_add (const char * suffix,
const char * representation,
const char * encoding,
const char * transfer,
const char * language,
double value)
{
HTBind * suff;
if (!suffix)
return NO;
if (!strcmp(suffix, "*"))
suff = &no_suffix;
else if (!strcmp(suffix, "*.*"))
suff = &unknown_suffix;
else {
HTList * suflist;
int hash;
const unsigned char * p;
/* Select list from hash table */
for (p=suffix, hash=0; *p; p++) {
hash = (hash * 3 + TOLOWER(*p)) % HT_L_HASH_SIZE;
}
if (!HTBindings) HTBind_init();
if (!HTBindings[hash]) HTBindings[hash] = HTList_new();
suflist = HTBindings[hash];
/* Look for existing binding */
{
HTList *cur = suflist;
while ((suff = (HTBind *) HTList_nextObject(cur)) != NULL) {
if (!strcmp(suff->suffix, suffix))
break;
}
}
/* If not found -- create a new node */
if (!suff) {
if ((suff = (HTBind *) HT_CALLOC(1, sizeof(HTBind))) == NULL)
HT_OUTOFMEM("HTBind_add");
HTList_addObject(suflist, (void *) suff);
StrAllocCopy(suff->suffix, suffix);
}
}
/* Set the appropriate values */
{
HTChunk * chunk = HTChunk_new(32);
char *ptr;
if (representation) {
HTChunk_puts(chunk, representation);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->type = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (encoding) {
HTChunk_puts(chunk, encoding);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->encoding = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (transfer) {
HTChunk_puts(chunk, transfer);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->transfer = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (language) {
HTChunk_puts(chunk, language);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->language = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
HTChunk_delete(chunk);
suff->quality = value;
}
return YES;
}
unsigned int BinURLInputStream::readBytes(XMLByte* const toFill
, const unsigned int maxToRead)
{
unsigned int retval = 0;
unsigned int bytesAsked = maxToRead;
unsigned int bytesForCopy = 0;
// Wipe out the old stuff from the destination buffer to fill.
memset((void*)toFill, 0x00, sizeof(XMLByte) * maxToRead);
// You can only read till the end of the remote resource file.
// So, adjust the count of bytes you want to read now.
if (fBytesProcessed + bytesAsked >= fRemoteFileSize)
{
bytesAsked = fRemoteFileSize - fBytesProcessed;
}
if (fBufferSize > 0)
bytesForCopy = fBufferSize - fBufferIndex;
if (bytesAsked <= bytesForCopy)
{
// ...then you can satisfy this request completely from fBuffer.
// Simply copy over the bytes to the destination array.
memcpy((void*) toFill, (void*) (fBuffer + fBufferIndex), bytesAsked);
fBufferIndex += bytesAsked;
if (fBufferIndex >= fBufferSize)
{
fBufferSize = 0;
fBufferIndex = 0;
}
fBytesProcessed += bytesAsked;
retval = bytesAsked;
}
else
{
// ...will need to read some more bytes out of the stream.
unsigned int bufToFillIndex = 0;
HTRequest* request = HTRequest_new();
HTChunk* result = NULL;
char ranges[64];
// First copy over what is left in fBuffer, before reading another
// chunk out of the stream.
if (bytesForCopy != 0)
{
memcpy((void*) toFill, (void*) (fBuffer + fBufferSize), bytesForCopy);
fBufferSize = 0;
fBufferIndex = 0;
fBytesProcessed += bytesForCopy;
bufToFillIndex = bytesForCopy;
retval = bytesForCopy;
}
unsigned int bytesRemainingForCopy = bytesAsked - bytesForCopy;
// Now read a new chunk from the stream. HTTP lets you specify the
// range of bytes that you would like.
sprintf(ranges, "%ld-%ld", fBytesProcessed,
fRemoteFileSize<(fBytesProcessed + URLISBUFMAXSIZE)? fRemoteFileSize - 1: fBytesProcessed + URLISBUFMAXSIZE - 1);
HTRequest_addRange(request, "bytes", ranges);
HTRequest_setOutputFormat(request, WWW_SOURCE);
result = HTLoadAnchorToChunk(fAnchor, request);
fBufferSize = HTChunk_size(result);
if (fBufferSize > 0)
{
// Store the read chunk in fBuffer.
memset((void*) fBuffer, 0x00, URLISBUFMAXSIZE);
memcpy((void*) fBuffer, (void*) HTChunk_data(result), fBufferSize);
fBufferIndex = 0;
}
HTRequest_delete(request);
HTChunk_delete(result);
// Now fill the destination buffer with the new data just read.
bytesForCopy = fBufferSize;
if (bytesRemainingForCopy > fBufferSize)
{
bytesRemainingForCopy = fBufferSize;
}
memcpy((void*) (toFill + bufToFillIndex),
(void*) fBuffer,
bytesRemainingForCopy);
// Update counters.
retval += bytesRemainingForCopy;
fBufferIndex += bytesRemainingForCopy;
fBytesProcessed += bytesRemainingForCopy;
}
return retval;
}
PUBLIC void CSParse_delete(CSParse_t * me)
{
HT_FREE(me->pParseContext);
HTChunk_delete(me->token);
HT_FREE(me);
}
