src/xercesc/util/NetAccessors/BinHTTPInputStreamCommon.cpp - xerces-c - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /*
  * $Id: BinFileInputStream.cpp 553903 2007-07-06 14:43:42Z amassari $
  */


 // ---------------------------------------------------------------------------
 //  Includes
 // ---------------------------------------------------------------------------

 #if HAVE_CONFIG_H
 #  include <config.h>
 #endif

 #include <stdlib.h>
 #include <string.h>

 #include <xercesc/util/NetAccessors/BinHTTPInputStreamCommon.hpp>

 #include <xercesc/util/XMLString.hpp>
 #include <xercesc/util/XMLExceptMsgs.hpp>
 #include <xercesc/util/Janitor.hpp>
 #include <xercesc/util/TransService.hpp>
 #include <xercesc/util/PlatformUtils.hpp>
 #include <xercesc/util/Base64.hpp>

 XERCES_CPP_NAMESPACE_BEGIN

 BinHTTPInputStreamCommon::BinHTTPInputStreamCommon(MemoryManager *manager)
       : fBytesProcessed(0)
       , fBuffer(1023, manager)
 	  , fBufferPos(0)
       , fContentType(0)
 	  , fEncoding(0)
       , fMemoryManager(manager)
 {
 }


 BinHTTPInputStreamCommon::~BinHTTPInputStreamCommon()
 {
     if(fContentType) fMemoryManager->deallocate(fContentType);
     if(fEncoding) fMemoryManager->deallocate(fEncoding);
 }

 static const char *CRLF = "\r\n";

 void BinHTTPInputStreamCommon::createHTTPRequest(const XMLURL &urlSource, const XMLNetHTTPInfo *httpInfo, CharBuffer &buffer)
 {
     static const char *GET = "GET ";
     static const char *PUT = "PUT ";
     static const char *POST = "POST ";
     static const char *HTTP10 = " HTTP/1.0\r\n";
     static const char *HOST = "Host: ";
     static const char *AUTHORIZATION = "Authorization: Basic ";
     static const char *COLON = ":";

     XMLTransService::Codes failReason;
     const XMLSize_t blockSize = 2048;

     XMLTranscoder* trans = XMLPlatformUtils::fgTransService->makeNewTranscoderFor("ISO8859-1", failReason, blockSize, fMemoryManager);
     Janitor<XMLTranscoder> janTrans(trans);

     TranscodeToStr hostName(urlSource.getHost(), trans, fMemoryManager);
     TranscodeToStr path(urlSource.getPath(), trans, fMemoryManager);
     TranscodeToStr fragment(urlSource.getFragment(), trans, fMemoryManager);
     TranscodeToStr query(urlSource.getQuery(), trans, fMemoryManager);

     // Build up the http GET command to send to the server.
     // To do:  We should really support http 1.1.  This implementation
     //         is weak.
     if(httpInfo) {
         switch(httpInfo->fHTTPMethod) {
         case XMLNetHTTPInfo::GET:   buffer.append(GET); break;
         case XMLNetHTTPInfo::PUT:   buffer.append(PUT); break;
         case XMLNetHTTPInfo::POST:  buffer.append(POST); break;
         }
     }
     else {
         buffer.append(GET);
     }

     if(path.str() != 0) {
         buffer.append((char*)path.str());
     }
     else {
         buffer.append("/");
     }

     if(query.str() != 0) {
         buffer.append("?");
         buffer.append((char*)query.str());
     }

     if(fragment.str() != 0) {
         buffer.append((char*)fragment.str());
     }
     buffer.append(HTTP10);

     buffer.append(HOST);
     buffer.append((char*)hostName.str());
     if(urlSource.getPortNum() != 80)
     {
         buffer.append(COLON);
         buffer.appendDecimalNumber(urlSource.getPortNum());
     }
     buffer.append(CRLF);

     const XMLCh *username = urlSource.getUser();
     const XMLCh *password = urlSource.getPassword();
     if(username && password) {
         XMLBuffer userPassBuf(256, fMemoryManager);
         userPassBuf.append(username);
         userPassBuf.append(chColon);
         userPassBuf.append(password);

         TranscodeToStr userPass(userPassBuf.getRawBuffer(), trans, fMemoryManager);

         XMLSize_t len;
         XMLByte* encodedData = Base64::encode(userPass.str(), userPass.length(), &len, fMemoryManager);
         ArrayJanitor<XMLByte> janBuf2(encodedData, fMemoryManager);

         if(encodedData) {
             // HTTP doesn't want the 0x0A separating the data in chunks of 76 chars per line
             XMLByte* authData = (XMLByte*)fMemoryManager->allocate((len+1)*sizeof(XMLByte));
             ArrayJanitor<XMLByte> janBuf(authData, fMemoryManager);
             XMLByte *cursor = authData;
             for(XMLSize_t i = 0; i < len; ++i)
                 if(encodedData[i] != chLF)
                     *cursor++ = encodedData[i];
             *cursor++ = 0;
             buffer.append(AUTHORIZATION);
             buffer.append((char*)authData);
             buffer.append(CRLF);
         }
     }

     if(httpInfo && httpInfo->fHeaders)
         buffer.append(httpInfo->fHeaders, httpInfo->fHeadersLen);

     buffer.append(CRLF);
 }

 XMLCh *BinHTTPInputStreamCommon::findHeader(const char *name)
 {
     XMLSize_t len = strlen(name);

     char *p = strstr(fBuffer.getRawBuffer(), name);
     while(p != 0) {
         if(*(p - 1) == '\n' &&
             *(p + len) == ':' &&
             *(p + len + 1) == ' ') {

             p += len + 2;

             char *endP = strstr(p, CRLF);
             if(endP == 0) {
                 for(endP = p; *endP != 0; ++endP) ;
             }

             // Transcode from iso-8859-1
             TranscodeFromStr value((XMLByte*)p, endP - p, "ISO8859-1", fMemoryManager);
             return value.adopt();
         }

         p = strstr(p + 1, name);
     }

     return 0;
 }

 int BinHTTPInputStreamCommon::sendRequest(const XMLURL &url, const XMLNetHTTPInfo *httpInfo)
 {
     //
     //  Constants in ASCII to send/check in the HTTP request/response
     //

     static const char *CRLF2X = "\r\n\r\n";
     static const char *LF2X = "\n\n";

     // The port is open and ready to go.
     // Build up the http GET command to send to the server.
     CharBuffer requestBuffer(1023, fMemoryManager);
     createHTTPRequest(url, httpInfo, requestBuffer);

     // Send the http request
     if(!send(requestBuffer.getRawBuffer(), requestBuffer.getLen())) {
         ThrowXMLwithMemMgr1(NetAccessorException,
                             XMLExcepts::NetAcc_WriteSocket, url.getURLText(), fMemoryManager);
     }

     if(httpInfo && httpInfo->fPayload) {
         if(!send(httpInfo->fPayload, httpInfo->fPayloadLen)) {
             ThrowXMLwithMemMgr1(NetAccessorException,
                                 XMLExcepts::NetAcc_WriteSocket, url.getURLText(), fMemoryManager);
         }
     }

     //
     // get the response, check the http header for errors from the server.
     //
     char tmpBuf[1024];
     int ret;

     fBuffer.reset();
     while(true) {
         ret = receive(tmpBuf, sizeof(tmpBuf));
         if(ret == -1) {
             ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager);
         }

         // connection closed
         if(ret == 0)
             break;

         fBuffer.append(tmpBuf, ret);

         fBufferPos = strstr(fBuffer.getRawBuffer(), CRLF2X);
         if(fBufferPos != 0) {
             fBufferPos += 4;
             *(fBufferPos - 2) = 0;
             break;
         }

         fBufferPos = strstr(fBuffer.getRawBuffer(), LF2X);
         if(fBufferPos != 0) {
             fBufferPos += 2;
             *(fBufferPos - 1) = 0;
             break;
         }
     }

     // Parse the response status
     char *p = strstr(fBuffer.getRawBuffer(), "HTTP");
     if(p == 0) {
         ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager);
     }

     p = strchr(p, chSpace);
     if(p == 0) {
         ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager);
     }

     return atoi(p);
 }

 const XMLCh *BinHTTPInputStreamCommon::getContentType() const
 {
     if(fContentType == 0) {
         // mutable
         const_cast<BinHTTPInputStreamCommon*>(this)->fContentType =
         const_cast<BinHTTPInputStreamCommon*>(this)->findHeader("Content-Type");
     }
     return fContentType;
 }

 const XMLCh *BinHTTPInputStreamCommon::getEncoding() const
 {
 	if(fEncoding == 0) {
 		const XMLCh* contentTypeHeader = getContentType();
 		if(contentTypeHeader)
 		{
 			const XMLCh szCharsetEquals[] = {chLatin_c, chLatin_h, chLatin_a, chLatin_r, chLatin_s, chLatin_e, chLatin_t, chEqual, chNull };

 			BaseRefVectorOf<XMLCh>* tokens=XMLString::tokenizeString(contentTypeHeader, chSemiColon, fMemoryManager);
 			for(XMLSize_t i=0;i<tokens->size();i++)
 			{
 				XMLString::removeWS(tokens->elementAt(i), fMemoryManager);
 				if(XMLString::startsWithI(tokens->elementAt(i), szCharsetEquals))
 				{
 					// mutable
 					const XMLCh* encodingName=tokens->elementAt(i)+XMLString::stringLen(szCharsetEquals);
 					const_cast<BinHTTPInputStreamCommon*>(this)->fEncoding = XMLString::replicate(encodingName, fMemoryManager);
 					break;
 				}
 			}
 			// if the charset=value entry was not present, check if we should use a default value
 			if(fEncoding==0 && tokens->size()>0)
 			{
 				const XMLCh szTextSlash[] = { chLatin_t, chLatin_e, chLatin_x, chLatin_t, chForwardSlash, chNull };
 				const XMLCh szXml[] = {chLatin_x, chLatin_m, chLatin_l, chNull };
 				const XMLCh szXmlDash[] = {chLatin_x, chLatin_m, chLatin_l, chDash, chNull };

 				XMLBuffer contentType(XMLString::stringLen(contentTypeHeader), fMemoryManager);
 				contentType.set(tokens->elementAt(0));

 				XMLCh* strType = contentType.getRawBuffer();
 				XMLString::removeWS(strType, fMemoryManager);
 				if(XMLString::startsWithI(strType, szTextSlash))
 				{
 					// text/* has a default encoding of iso-8859-1

 					// text/xml, text/xml-external-parsed-entity, or a subtype like text/AnythingAtAll+xml
 					// has a default encoding of us-ascii
 					XMLCh* subType = strType+XMLString::stringLen(szTextSlash);

 					BaseRefVectorOf<XMLCh>* tokens=XMLString::tokenizeString(subType, chPlus, fMemoryManager);
 					for(XMLSize_t i=0;i<tokens->size();i++)
 					{
 						XMLCh* part=tokens->elementAt(i);
 						if(XMLString::compareIStringASCII(part, szXml)==0 || XMLString::startsWithI(part, szXmlDash))
 						{
 							const_cast<BinHTTPInputStreamCommon*>(this)->fEncoding = XMLString::replicate(XMLUni::fgUSASCIIEncodingString, fMemoryManager);
 							break;
 						}
 					}
 					if(fEncoding==0)
 						const_cast<BinHTTPInputStreamCommon*>(this)->fEncoding = XMLString::replicate(XMLUni::fgISO88591EncodingString, fMemoryManager);
 					delete tokens;
 				}
 			}
 			delete tokens;
 		}
 	}
     return fEncoding;
 }

 XMLSize_t BinHTTPInputStreamCommon::readBytes(XMLByte* const    toFill,
                                               const XMLSize_t    maxToRead)
 {
     XMLSize_t len = fBuffer.getRawBuffer() + fBuffer.getLen() - fBufferPos;
     if(len > 0)
     {
         // If there's any data left over in the buffer into which we first
         //   read from the server (to get the http header), return that.
         if (len > maxToRead)
             len = maxToRead;
         memcpy(toFill, fBufferPos, len);
         fBufferPos += len;
     }
     else
     {
         // There was no data in the local buffer.
         // Read some from the socket, straight into our caller's buffer.
         //
         int cbRead = receive((char *)toFill, maxToRead);
         if (cbRead == -1)
         {
             ThrowXMLwithMemMgr(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, fMemoryManager);
         }
         len = cbRead;
     }

     fBytesProcessed += len;
     return len;
 }

 XERCES_CPP_NAMESPACE_END
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/*
	* $Id: BinFileInputStream.cpp 553903 2007-07-06 14:43:42Z amassari $
	*/


	// ---------------------------------------------------------------------------
	// Includes
	// ---------------------------------------------------------------------------

	#if HAVE_CONFIG_H
	# include <config.h>
	#endif

	#include <stdlib.h>
	#include <string.h>

	#include <xercesc/util/NetAccessors/BinHTTPInputStreamCommon.hpp>

	#include <xercesc/util/XMLString.hpp>
	#include <xercesc/util/XMLExceptMsgs.hpp>
	#include <xercesc/util/Janitor.hpp>
	#include <xercesc/util/TransService.hpp>
	#include <xercesc/util/PlatformUtils.hpp>
	#include <xercesc/util/Base64.hpp>

	XERCES_CPP_NAMESPACE_BEGIN

	BinHTTPInputStreamCommon::BinHTTPInputStreamCommon(MemoryManager *manager)
	: fBytesProcessed(0)
	, fBuffer(1023, manager)
	, fBufferPos(0)
	, fContentType(0)
	, fEncoding(0)
	, fMemoryManager(manager)
	{
	}


	BinHTTPInputStreamCommon::~BinHTTPInputStreamCommon()
	{
	if(fContentType) fMemoryManager->deallocate(fContentType);
	if(fEncoding) fMemoryManager->deallocate(fEncoding);
	}

	static const char *CRLF = "\r\n";

	void BinHTTPInputStreamCommon::createHTTPRequest(const XMLURL &urlSource, const XMLNetHTTPInfo *httpInfo, CharBuffer &buffer)
	{
	static const char *GET = "GET ";
	static const char *PUT = "PUT ";
	static const char *POST = "POST ";
	static const char *HTTP10 = " HTTP/1.0\r\n";
	static const char *HOST = "Host: ";
	static const char *AUTHORIZATION = "Authorization: Basic ";
	static const char *COLON = ":";

	XMLTransService::Codes failReason;
	const XMLSize_t blockSize = 2048;

	XMLTranscoder* trans = XMLPlatformUtils::fgTransService->makeNewTranscoderFor("ISO8859-1", failReason, blockSize, fMemoryManager);
	Janitor<XMLTranscoder> janTrans(trans);

	TranscodeToStr hostName(urlSource.getHost(), trans, fMemoryManager);
	TranscodeToStr path(urlSource.getPath(), trans, fMemoryManager);
	TranscodeToStr fragment(urlSource.getFragment(), trans, fMemoryManager);
	TranscodeToStr query(urlSource.getQuery(), trans, fMemoryManager);

	// Build up the http GET command to send to the server.
	// To do: We should really support http 1.1. This implementation
	// is weak.
	if(httpInfo) {
	switch(httpInfo->fHTTPMethod) {
	case XMLNetHTTPInfo::GET: buffer.append(GET); break;
	case XMLNetHTTPInfo::PUT: buffer.append(PUT); break;
	case XMLNetHTTPInfo::POST: buffer.append(POST); break;
	}
	}
	else {
	buffer.append(GET);
	}

	if(path.str() != 0) {
	buffer.append((char*)path.str());
	}
	else {
	buffer.append("/");
	}

	if(query.str() != 0) {
	buffer.append("?");
	buffer.append((char*)query.str());
	}

	if(fragment.str() != 0) {
	buffer.append((char*)fragment.str());
	}
	buffer.append(HTTP10);

	buffer.append(HOST);
	buffer.append((char*)hostName.str());
	if(urlSource.getPortNum() != 80)
	{
	buffer.append(COLON);
	buffer.appendDecimalNumber(urlSource.getPortNum());
	}
	buffer.append(CRLF);

	const XMLCh *username = urlSource.getUser();
	const XMLCh *password = urlSource.getPassword();
	if(username && password) {
	XMLBuffer userPassBuf(256, fMemoryManager);
	userPassBuf.append(username);
	userPassBuf.append(chColon);
	userPassBuf.append(password);

	TranscodeToStr userPass(userPassBuf.getRawBuffer(), trans, fMemoryManager);

	XMLSize_t len;
	XMLByte* encodedData = Base64::encode(userPass.str(), userPass.length(), &len, fMemoryManager);
	ArrayJanitor<XMLByte> janBuf2(encodedData, fMemoryManager);

	if(encodedData) {
	// HTTP doesn't want the 0x0A separating the data in chunks of 76 chars per line
	XMLByte* authData = (XMLByte)fMemoryManager->allocate((len+1)sizeof(XMLByte));
	ArrayJanitor<XMLByte> janBuf(authData, fMemoryManager);
	XMLByte *cursor = authData;
	for(XMLSize_t i = 0; i < len; ++i)
	if(encodedData[i] != chLF)
	*cursor++ = encodedData[i];
	*cursor++ = 0;
	buffer.append(AUTHORIZATION);
	buffer.append((char*)authData);
	buffer.append(CRLF);
	}
	}

	if(httpInfo && httpInfo->fHeaders)
	buffer.append(httpInfo->fHeaders, httpInfo->fHeadersLen);

	buffer.append(CRLF);
	}

	XMLCh BinHTTPInputStreamCommon::findHeader(const char name)
	{
	XMLSize_t len = strlen(name);

	char *p = strstr(fBuffer.getRawBuffer(), name);
	while(p != 0) {
	if(*(p - 1) == '\n' &&
	*(p + len) == ':' &&
	*(p + len + 1) == ' ') {

	p += len + 2;

	char *endP = strstr(p, CRLF);
	if(endP == 0) {
	for(endP = p; *endP != 0; ++endP) ;
	}

	// Transcode from iso-8859-1
	TranscodeFromStr value((XMLByte*)p, endP - p, "ISO8859-1", fMemoryManager);
	return value.adopt();
	}

	p = strstr(p + 1, name);
	}

	return 0;
	}

	int BinHTTPInputStreamCommon::sendRequest(const XMLURL &url, const XMLNetHTTPInfo *httpInfo)
	{
	//
	// Constants in ASCII to send/check in the HTTP request/response
	//

	static const char *CRLF2X = "\r\n\r\n";
	static const char *LF2X = "\n\n";

	// The port is open and ready to go.
	// Build up the http GET command to send to the server.
	CharBuffer requestBuffer(1023, fMemoryManager);
	createHTTPRequest(url, httpInfo, requestBuffer);

	// Send the http request
	if(!send(requestBuffer.getRawBuffer(), requestBuffer.getLen())) {
	ThrowXMLwithMemMgr1(NetAccessorException,
	XMLExcepts::NetAcc_WriteSocket, url.getURLText(), fMemoryManager);
	}

	if(httpInfo && httpInfo->fPayload) {
	if(!send(httpInfo->fPayload, httpInfo->fPayloadLen)) {
	ThrowXMLwithMemMgr1(NetAccessorException,
	XMLExcepts::NetAcc_WriteSocket, url.getURLText(), fMemoryManager);
	}
	}

	//
	// get the response, check the http header for errors from the server.
	//
	char tmpBuf[1024];
	int ret;

	fBuffer.reset();
	while(true) {
	ret = receive(tmpBuf, sizeof(tmpBuf));
	if(ret == -1) {
	ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager);
	}

	// connection closed
	if(ret == 0)
	break;

	fBuffer.append(tmpBuf, ret);

	fBufferPos = strstr(fBuffer.getRawBuffer(), CRLF2X);
	if(fBufferPos != 0) {
	fBufferPos += 4;
	*(fBufferPos - 2) = 0;
	break;
	}

	fBufferPos = strstr(fBuffer.getRawBuffer(), LF2X);
	if(fBufferPos != 0) {
	fBufferPos += 2;
	*(fBufferPos - 1) = 0;
	break;
	}
	}

	// Parse the response status
	char *p = strstr(fBuffer.getRawBuffer(), "HTTP");
	if(p == 0) {
	ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager);
	}

	p = strchr(p, chSpace);
	if(p == 0) {
	ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, url.getURLText(), fMemoryManager);
	}

	return atoi(p);
	}

	const XMLCh *BinHTTPInputStreamCommon::getContentType() const
	{
	if(fContentType == 0) {
	// mutable
	const_cast<BinHTTPInputStreamCommon*>(this)->fContentType =
	const_cast<BinHTTPInputStreamCommon*>(this)->findHeader("Content-Type");
	}
	return fContentType;
	}

	const XMLCh *BinHTTPInputStreamCommon::getEncoding() const
	{
	if(fEncoding == 0) {
	const XMLCh* contentTypeHeader = getContentType();
	if(contentTypeHeader)
	{
	const XMLCh szCharsetEquals[] = {chLatin_c, chLatin_h, chLatin_a, chLatin_r, chLatin_s, chLatin_e, chLatin_t, chEqual, chNull };

	BaseRefVectorOf<XMLCh>* tokens=XMLString::tokenizeString(contentTypeHeader, chSemiColon, fMemoryManager);
	for(XMLSize_t i=0;i<tokens->size();i++)
	{
	XMLString::removeWS(tokens->elementAt(i), fMemoryManager);
	if(XMLString::startsWithI(tokens->elementAt(i), szCharsetEquals))
	{
	// mutable
	const XMLCh* encodingName=tokens->elementAt(i)+XMLString::stringLen(szCharsetEquals);
	const_cast<BinHTTPInputStreamCommon*>(this)->fEncoding = XMLString::replicate(encodingName, fMemoryManager);
	break;
	}
	}
	// if the charset=value entry was not present, check if we should use a default value
	if(fEncoding==0 && tokens->size()>0)
	{
	const XMLCh szTextSlash[] = { chLatin_t, chLatin_e, chLatin_x, chLatin_t, chForwardSlash, chNull };
	const XMLCh szXml[] = {chLatin_x, chLatin_m, chLatin_l, chNull };
	const XMLCh szXmlDash[] = {chLatin_x, chLatin_m, chLatin_l, chDash, chNull };

	XMLBuffer contentType(XMLString::stringLen(contentTypeHeader), fMemoryManager);
	contentType.set(tokens->elementAt(0));

	XMLCh* strType = contentType.getRawBuffer();
	XMLString::removeWS(strType, fMemoryManager);
	if(XMLString::startsWithI(strType, szTextSlash))
	{
	// text/* has a default encoding of iso-8859-1

	// text/xml, text/xml-external-parsed-entity, or a subtype like text/AnythingAtAll+xml
	// has a default encoding of us-ascii
	XMLCh* subType = strType+XMLString::stringLen(szTextSlash);

	BaseRefVectorOf<XMLCh>* tokens=XMLString::tokenizeString(subType, chPlus, fMemoryManager);
	for(XMLSize_t i=0;i<tokens->size();i++)
	{
	XMLCh* part=tokens->elementAt(i);
	if(XMLString::compareIStringASCII(part, szXml)==0 \|\| XMLString::startsWithI(part, szXmlDash))
	{
	const_cast<BinHTTPInputStreamCommon*>(this)->fEncoding = XMLString::replicate(XMLUni::fgUSASCIIEncodingString, fMemoryManager);
	break;
	}
	}
	if(fEncoding==0)
	const_cast<BinHTTPInputStreamCommon*>(this)->fEncoding = XMLString::replicate(XMLUni::fgISO88591EncodingString, fMemoryManager);
	delete tokens;
	}
	}
	delete tokens;
	}
	}
	return fEncoding;
	}

	XMLSize_t BinHTTPInputStreamCommon::readBytes(XMLByte* const toFill,
	const XMLSize_t maxToRead)
	{
	XMLSize_t len = fBuffer.getRawBuffer() + fBuffer.getLen() - fBufferPos;
	if(len > 0)
	{
	// If there's any data left over in the buffer into which we first
	// read from the server (to get the http header), return that.
	if (len > maxToRead)
	len = maxToRead;
	memcpy(toFill, fBufferPos, len);
	fBufferPos += len;
	}
	else
	{
	// There was no data in the local buffer.
	// Read some from the socket, straight into our caller's buffer.
	//
	int cbRead = receive((char *)toFill, maxToRead);
	if (cbRead == -1)
	{
	ThrowXMLwithMemMgr(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, fMemoryManager);
	}
	len = cbRead;
	}

	fBytesProcessed += len;
	return len;
	}

	XERCES_CPP_NAMESPACE_END