RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const char* const expression, const int start, const int end) { XMLCh* tmpBuf = XMLString::transcode(expression, fMemoryManager); ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager); return tokenize(tmpBuf, start, end); }
// --------------------------------------------------------------------------- // IconvGNUTransService: The protected virtual transcoding service API // --------------------------------------------------------------------------- XMLTranscoder* IconvGNUTransService::makeNewXMLTranscoder ( const XMLCh* const encodingName , XMLTransService::Codes& resValue , const XMLSize_t blockSize , MemoryManager* const manager ) { resValue = XMLTransService::UnsupportedEncoding; IconvGNUTranscoder *newTranscoder = NULL; char *encLocal = XMLString::transcode(encodingName, manager); ArrayJanitor<char> janBuf(encLocal, manager); iconv_t cd_from, cd_to; cd_from = iconv_open (fUnicodeCP, encLocal); if (cd_from == (iconv_t)-1) { resValue = XMLTransService::SupportFilesNotFound; return NULL; } cd_to = iconv_open (encLocal, fUnicodeCP); if (cd_to == (iconv_t)-1) { resValue = XMLTransService::SupportFilesNotFound; iconv_close (cd_from); return NULL; } newTranscoder = new (manager) IconvGNUTranscoder (encodingName, blockSize, cd_from, cd_to, uChSize(), UBO(), manager); if (newTranscoder) resValue = XMLTransService::Ok; return newTranscoder; }
// --------------------------------------------------------------------------- // RegularExpression: Matching methods // --------------------------------------------------------------------------- bool RegularExpression::matches(const char* const expression , MemoryManager* const manager) { XMLCh* tmpBuf = XMLString::transcode(expression, manager); ArrayJanitor<XMLCh> janBuf(tmpBuf, manager); return matches(tmpBuf, 0, XMLString::stringLen(tmpBuf), 0, manager); }
// --------------------------------------------------------------------------- // RegularExpression: Constructors and Destructors // --------------------------------------------------------------------------- RegularExpression::RegularExpression(const char* const pattern, MemoryManager* const manager) :fHasBackReferences(false), fFixedStringOnly(false), fNoGroups(0), fMinLength(0), fNoClosures(0), fOptions(0), fBMPattern(0), fPattern(0), fFixedString(0), fOperations(0), fTokenTree(0), fFirstChar(0), fOpFactory(manager), fTokenFactory(0), fMemoryManager(manager) { try { XMLCh* tmpBuf = XMLString::transcode(pattern, fMemoryManager); ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager); setPattern(tmpBuf); } catch(const OutOfMemoryException&) { throw; } catch (...) { cleanUp(); throw; } }
bool RegularExpression::matches(const char* const expression, const int start, const int end, Match* const pMatch , MemoryManager* const manager) { XMLCh* tmpBuf = XMLString::transcode(expression, manager); ArrayJanitor<XMLCh> janBuf(tmpBuf, manager); return matches(tmpBuf, start, end, pMatch, manager); }
bool IconvGNULCPTranscoder::transcode(const char* const toTranscode , XMLCh* const toFill , const XMLSize_t maxChars , MemoryManager* const manager) { // Check for a couple of psycho corner cases if (!toTranscode || !maxChars) { toFill[0] = 0; return true; } if (!*toTranscode) { toFill[0] = 0; return true; } XMLSize_t wLent = calcRequiredSize(toTranscode); if (wLent > maxChars) wLent = maxChars; char tmpWBuff[gTempBuffArraySize]; char *wideCharBuf = 0; char *wBufPtr = 0; ArrayJanitor<char> janBuf(wBufPtr, manager); size_t len = wLent * uChSize(); if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) { if (len > gTempBuffArraySize) { wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len]; janBuf.reset(wBufPtr, manager); wideCharBuf = wBufPtr; } else wideCharBuf = tmpWBuff; } else wideCharBuf = (char *) toFill; size_t flen = strlen(toTranscode); // wLent; char *ptr = wideCharBuf; size_t rc; { XMLMutexLock lockConverter(&fMutex); rc = iconvFrom(toTranscode, &flen, &ptr, len); } if (rc == (size_t)-1) { return false; } if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) mbsToXML (wideCharBuf, toFill, wLent); toFill[wLent] = 0x00; return true; }
// ----------------------------------------------------------------------- // RegularExpression: Replace methods // ----------------------------------------------------------------------- XMLCh* RegularExpression::replace(const char* const matchString, const char* const replaceString){ XMLCh* tmpBuf = XMLString::transcode(matchString, fMemoryManager); ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager); XMLCh* tmpBuf2 = XMLString::transcode(replaceString, fMemoryManager); ArrayJanitor<XMLCh> janBuf2(tmpBuf2, fMemoryManager); return replace(tmpBuf, tmpBuf2, 0, XMLString::stringLen(tmpBuf)); }
XMLCh* IconvGNULCPTranscoder::transcode(const char* const toTranscode, MemoryManager* const manager) { if (!toTranscode) return 0; XMLCh* retVal = 0; if (!*toTranscode) { retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1]; retVal[0] = 0; return retVal; } XMLSize_t wLent = calcRequiredSize(toTranscode, manager); if (wLent == 0) { retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1]; retVal[0] = 0; return retVal; } char tmpWBuff[gTempBuffArraySize]; char *wideCharBuf = 0; char *wBufPtr = 0; ArrayJanitor<char> janBuf(wBufPtr, manager); size_t len = wLent * uChSize(); retVal = (XMLCh*) manager->allocate((wLent + 1) * sizeof(XMLCh));//new XMLCh[wLent + 1]; if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) { if (len > gTempBuffArraySize) { wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len]; janBuf.reset(wBufPtr, manager); wideCharBuf = wBufPtr; } else wideCharBuf = tmpWBuff; } else wideCharBuf = (char *) retVal; size_t flen = strlen(toTranscode); char *ptr = wideCharBuf; size_t rc; { XMLMutexLock lockConverter(&fMutex); rc = iconvFrom(toTranscode, &flen, &ptr, len); } if (rc == (size_t) -1) { return NULL; } if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) mbsToXML (wideCharBuf, retVal, wLent); retVal[wLent] = 0x00; return retVal; }
char* IconvGNULCPTranscoder::transcode(const XMLCh* const toTranscode, MemoryManager* const manager) { if (!toTranscode) return 0; char* retVal = 0; if (!*toTranscode) { retVal = (char*) manager->allocate(sizeof(char));//new char[1]; retVal[0] = 0; return retVal; } XMLSize_t wLent = getWideCharLength(toTranscode); // Calc needed size. XMLSize_t neededLen = calcRequiredSize (toTranscode, manager); if (neededLen == 0) return 0; // allocate output buffer retVal = (char*) manager->allocate((neededLen + 1) * sizeof(char));//new char[neededLen + 1]; // prepare the original char tmpWBuff[gTempBuffArraySize]; char *wideCharBuf = 0; char *wBufPtr = 0; ArrayJanitor<char> janBuf(wBufPtr, manager); size_t len = wLent * uChSize(); if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) { if (len > gTempBuffArraySize) { wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len]; janBuf.reset(wBufPtr, manager); wideCharBuf = wBufPtr; } else wideCharBuf = tmpWBuff; xmlToMbs (toTranscode, wideCharBuf, wLent); } else wideCharBuf = (char *) toTranscode; // perform conversion char* ptr = retVal; size_t rc; { XMLMutexLock lockConverter(&fMutex); rc = iconvTo(wideCharBuf, &len, &ptr, neededLen); } if (rc == (size_t)-1) { return 0; } retVal[neededLen] = 0; return retVal; }
// --------------------------------------------------------------------------- // IconvGNUTranscoder: Implementation of the virtual transcoder API // --------------------------------------------------------------------------- XMLSize_t IconvGNUTranscoder::transcodeFrom ( const XMLByte* const srcData , const XMLSize_t srcCount , XMLCh* const toFill , const XMLSize_t maxChars , XMLSize_t& bytesEaten , unsigned char* const charSizes ) { // Transcode TO XMLCh const char* startSrc = (const char*) srcData; const char* endSrc = (const char*) srcData + srcCount; char tmpWBuff[gTempBuffArraySize]; char *startTarget = 0; char *wBufPtr = 0; ArrayJanitor<char> janBuf(wBufPtr, getMemoryManager()); size_t len = maxChars * uChSize(); if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) { if (len > gTempBuffArraySize) { wBufPtr = (char*) getMemoryManager()->allocate(len * sizeof(char));//new char[len]; janBuf.reset(wBufPtr, getMemoryManager()); startTarget = wBufPtr; } else startTarget = tmpWBuff; } else startTarget = (char *) toFill; // Do character-by-character transcoding char *orgTarget = startTarget; size_t srcLen = srcCount; size_t prevSrcLen = srcLen; unsigned int toReturn = 0; bytesEaten = 0; XMLMutexLock lockConverter(&fMutex); for (size_t cnt = 0; cnt < maxChars && srcLen; cnt++) { size_t rc = iconvFrom(startSrc, &srcLen, &orgTarget, uChSize()); if (rc == (size_t)-1) { if (errno != E2BIG || prevSrcLen == srcLen) { ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager()); } } charSizes[cnt] = prevSrcLen - srcLen; prevSrcLen = srcLen; bytesEaten += charSizes[cnt]; startSrc = endSrc - srcLen; toReturn++; } if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) mbsToXML (startTarget, toFill, toReturn); return toReturn; }
bool IconvGNULCPTranscoder::transcode( const XMLCh* const toTranscode , char* const toFill , const XMLSize_t maxBytes , MemoryManager* const manager) { // Watch for a couple of pyscho corner cases if (!toTranscode || !maxBytes) { toFill[0] = 0; return true; } if (!*toTranscode) { toFill[0] = 0; return true; } XMLSize_t wLent = getWideCharLength(toTranscode); if (wLent > maxBytes) wLent = maxBytes; // Fill the "unicode" string char tmpWBuff[gTempBuffArraySize]; char *wideCharBuf = 0; char *wBufPtr = 0; ArrayJanitor<char> janBuf(wBufPtr, manager); size_t len = wLent * uChSize(); if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) { if (len > gTempBuffArraySize) { wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len]; janBuf.reset(wBufPtr, manager); wideCharBuf = wBufPtr; } else wideCharBuf = tmpWBuff; xmlToMbs (toTranscode, wideCharBuf, wLent); } else wideCharBuf = (char *) toTranscode; // Ok, go ahead and try the transcoding. If it fails, then ... char *ptr = toFill; size_t rc; { XMLMutexLock lockConverter(&fMutex); rc = iconvTo(wideCharBuf, &len, &ptr, maxBytes); } if (rc == (size_t)-1) { return false; } // Cap it off *ptr = 0; return true; }
XERCES_CPP_NAMESPACE_BEGIN URLAccessBinInputStream::URLAccessBinInputStream(const XMLURL& urlSource) : mBytesProcessed(0), mURLReference(NULL), mBuffer(NULL), mBufPos(NULL), mBufAvailable(0) { OSStatus status = noErr; // Get the full URL from the source char* url = XMLString::transcode(urlSource.getURLText(), urlSource.getMemoryManager()); ArrayJanitor<char> janBuf(url, urlSource.getMemoryManager()); // Create a URL reference from the URL status = URLNewReference(url, &mURLReference); // Begin the transfer if (status == noErr) status = URLOpen( mURLReference, NULL, // FSSpec* (not reading to file) 0, // URLOpenFlags NULL, // URLNotifyUPP 0, // URLEventMask 0); // userContext // If we failed, we throw switch (status) { case noErr: break; case kURLInvalidURLError: ThrowXML(MalformedURLException, XMLExcepts::URL_MalformedURL); break; case kURLUnsupportedSchemeError: ThrowXML(MalformedURLException, XMLExcepts::URL_UnsupportedProto); break; default: ThrowXML1(NetAccessorException, XMLExcepts::NetAcc_ConnSocket, urlSource.getURLText()); break; } }
XMLSize_t IconvGNULCPTranscoder::calcRequiredSize(const XMLCh* const srcText , MemoryManager* const manager) { if (!srcText) return 0; XMLSize_t wLent = getWideCharLength(srcText); if (wLent == 0) return 0; char tmpWBuff[gTempBuffArraySize]; char *wBuf = 0; char *wBufPtr = 0; ArrayJanitor<char> janBuf(wBufPtr, manager); size_t len = wLent * uChSize(); if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) { if (len > gTempBuffArraySize) { wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len]; janBuf.reset(wBufPtr, manager); wBuf = wBufPtr; } else wBuf = tmpWBuff; xmlToMbs (srcText, wBuf, wLent); } else wBuf = (char *) srcText; char tmpBuff[gTempBuffArraySize]; size_t totalLen = 0; char *srcEnd = wBuf + wLent * uChSize(); XMLMutexLock lockConverter(&fMutex); for (;;) { char *pTmpArr = tmpBuff; const char *ptr = srcEnd - len; size_t rc = iconvTo(ptr, &len, &pTmpArr, gTempBuffArraySize); if (rc == (size_t) -1 && errno != E2BIG) { ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, manager); /* return 0; */ } rc = pTmpArr - tmpBuff; totalLen += rc; if (rc == 0 || len == 0) break; } return totalLen; }
XMLSize_t IconvGNUTranscoder::transcodeTo ( const XMLCh* const srcData , const XMLSize_t srcCount , XMLByte* const toFill , const XMLSize_t maxBytes , XMLSize_t& charsEaten , const UnRepOpts /*options*/ ) { // Transcode FROM XMLCh char tmpWBuff[gTempBuffArraySize]; char *startSrc = tmpWBuff; char *wBufPtr = 0; ArrayJanitor<char> janBuf(wBufPtr, getMemoryManager()); size_t len = srcCount * uChSize(); if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) { if (len > gTempBuffArraySize) { wBufPtr = (char*) getMemoryManager()->allocate(len * sizeof(char));//new char[len]; janBuf.reset(wBufPtr, getMemoryManager()); startSrc = wBufPtr; } else startSrc = tmpWBuff; xmlToMbs (srcData, startSrc, srcCount); } else startSrc = (char *) srcData; char* startTarget = (char *) toFill; size_t srcLen = len; size_t rc; { XMLMutexLock lockConverter(&fMutex); rc = iconvTo (startSrc, &srcLen, &startTarget, maxBytes); } if (rc == (size_t)-1 && errno != E2BIG) { ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager()); } charsEaten = srcCount - srcLen / uChSize(); return startTarget - (char *)toFill; }
BinHTTPURLInputStream::BinHTTPURLInputStream(const XMLURL& urlSource, const XMLNetHTTPInfo* httpInfo /*=0*/) : fSocketHandle(0) , fBytesProcessed(0) { if(!fInitialized) { if (!fInitMutex) { XMLMutex* tmpMutex = new XMLMutex(XMLPlatformUtils::fgMemoryManager); if (XMLPlatformUtils::compareAndSwap((void**)&fInitMutex, tmpMutex, 0)) { // Someone beat us to it, so let's clean up ours delete tmpMutex; } } XMLMutexLock lock(fInitMutex); if (!fInitialized) { Initialize(urlSource.getMemoryManager()); } } fMemoryManager = urlSource.getMemoryManager(); // // Pull all of the parts of the URL out of th urlSource object, and transcode them // and transcode them back to ASCII. // const XMLCh* hostName = urlSource.getHost(); char* hostNameAsCharStar = XMLString::transcode(hostName, urlSource.getMemoryManager()); ArrayJanitor<char> janBuf1(hostNameAsCharStar, urlSource.getMemoryManager()); const XMLCh* path = urlSource.getPath(); char* pathAsCharStar = XMLString::transcode(path, urlSource.getMemoryManager()); ArrayJanitor<char> janBuf2(pathAsCharStar, urlSource.getMemoryManager()); const XMLCh* fragment = urlSource.getFragment(); char* fragmentAsCharStar = 0; if (fragment) fragmentAsCharStar = XMLString::transcode(fragment, urlSource.getMemoryManager()); ArrayJanitor<char> janBuf3(fragmentAsCharStar, urlSource.getMemoryManager()); const XMLCh* query = urlSource.getQuery(); char* queryAsCharStar = 0; if (query) queryAsCharStar = XMLString::transcode(query, urlSource.getMemoryManager()); ArrayJanitor<char> janBuf4(queryAsCharStar, urlSource.getMemoryManager()); unsigned short portNumber = (unsigned short) urlSource.getPortNum(); // // Set up a socket. // struct hostent* hostEntPtr = 0; struct sockaddr_in sa; if ((hostEntPtr = gethostbyname(hostNameAsCharStar)) == NULL) { unsigned long numAddress = inet_addr(hostNameAsCharStar); if (numAddress == INADDR_NONE) { // Call WSAGetLastError() to get the error number. ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_TargetResolution, hostName, fMemoryManager); } if ((hostEntPtr = gethostbyaddr((const char *) &numAddress, sizeof(unsigned long), AF_INET)) == NULL) { // Call WSAGetLastError() to get the error number. ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_TargetResolution, hostName, fMemoryManager); } } memcpy((void *) &sa.sin_addr, (const void *) hostEntPtr->h_addr, hostEntPtr->h_length); sa.sin_family = hostEntPtr->h_addrtype; sa.sin_port = htons(portNumber); SOCKET s = socket(hostEntPtr->h_addrtype, SOCK_STREAM, 0); if (s == INVALID_SOCKET) { // Call WSAGetLastError() to get the error number. ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_CreateSocket, urlSource.getURLText(), fMemoryManager); } SocketJanitor janSock(&s); if (connect(s, (struct sockaddr *) &sa, sizeof(sa)) == SOCKET_ERROR) { // Call WSAGetLastError() to get the error number. ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ConnSocket, urlSource.getURLText(), fMemoryManager); } // Set a flag so we know that the headers have not been read yet. bool fHeaderRead = false; // The port is open and ready to go. // Build up the http GET command to send to the server. // To do: We should really support http 1.1. This implementation // is weak. memset(fBuffer, 0, sizeof(fBuffer)); if(httpInfo==0) strcpy(fBuffer, "GET "); else { switch(httpInfo->fHTTPMethod) { case XMLNetHTTPInfo::GET: strcpy(fBuffer, "GET "); break; case XMLNetHTTPInfo::PUT: strcpy(fBuffer, "PUT "); break; case XMLNetHTTPInfo::POST: strcpy(fBuffer, "POST "); break; } } strcat(fBuffer, pathAsCharStar); if (queryAsCharStar != 0) { // Tack on a ? before the fragment strcat(fBuffer,"?"); strcat(fBuffer, queryAsCharStar); } if (fragmentAsCharStar != 0) { strcat(fBuffer, fragmentAsCharStar); } strcat(fBuffer, " HTTP/1.0\r\n"); strcat(fBuffer, "Host: "); strcat(fBuffer, hostNameAsCharStar); if (portNumber != 80) { strcat(fBuffer, ":"); int i = strlen(fBuffer); _itoa(portNumber, fBuffer+i, 10); } strcat(fBuffer, "\r\n"); const XMLCh* username = urlSource.getUser(); const XMLCh* password = urlSource.getPassword(); if (username && password) { XMLBuffer userPass(256, fMemoryManager); userPass.append(username); userPass.append(chColon); userPass.append(password); char* userPassAsCharStar = XMLString::transcode(userPass.getRawBuffer(), fMemoryManager); ArrayJanitor<char> janBuf(userPassAsCharStar, fMemoryManager); unsigned int len; XMLByte* encodedData = Base64::encode((XMLByte *)userPassAsCharStar, strlen(userPassAsCharStar), &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(unsigned int i=0;i<len;i++) if(encodedData[i]!=chLF) *cursor++=encodedData[i]; *cursor++=0; strcat(fBuffer, "Authorization: Basic "); strcat(fBuffer, (char*)authData); strcat(fBuffer, "\r\n"); } } if(httpInfo!=0 && httpInfo->fHeaders!=0) strncat(fBuffer,httpInfo->fHeaders,httpInfo->fHeadersLen); strcat(fBuffer, "\r\n"); // Send the http request int lent = strlen(fBuffer); int aLent = 0; if ((aLent = send(s, fBuffer, lent, 0)) != lent) { // Call WSAGetLastError() to get the error number. ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_WriteSocket, urlSource.getURLText(), fMemoryManager); } if(httpInfo!=0 && httpInfo->fPayload!=0) { int aLent = 0; if ((aLent = send(s, httpInfo->fPayload, httpInfo->fPayloadLen, 0)) != httpInfo->fPayloadLen) { // Call WSAGetLastError() to get the error number. ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_WriteSocket, urlSource.getURLText(), fMemoryManager); } } // // get the response, check the http header for errors from the server. // memset(fBuffer, 0, sizeof(fBuffer)); aLent = recv(s, fBuffer, sizeof(fBuffer)-1, 0); if (aLent == SOCKET_ERROR || aLent == 0) { // Call WSAGetLastError() to get the error number. ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, urlSource.getURLText(), fMemoryManager); } fBufferEnd = fBuffer+aLent; *fBufferEnd = 0; do { // Find the break between the returned http header and any data. // (Delimited by a blank line) // Hang on to any data for use by the first read from this BinHTTPURLInputStream. // fBufferPos = strstr(fBuffer, "\r\n\r\n"); if (fBufferPos != 0) { fBufferPos += 4; *(fBufferPos-2) = 0; fHeaderRead = true; } else { fBufferPos = strstr(fBuffer, "\n\n"); if (fBufferPos != 0) { fBufferPos += 2; *(fBufferPos-1) = 0; fHeaderRead = true; } else { // // Header is not yet read, do another recv() to get more data... aLent = recv(s, fBufferEnd, (sizeof(fBuffer) - 1) - (fBufferEnd - fBuffer), 0); if (aLent == SOCKET_ERROR || aLent == 0) { // Call WSAGetLastError() to get the error number. ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, urlSource.getURLText(), fMemoryManager); } fBufferEnd = fBufferEnd + aLent; *fBufferEnd = 0; } } } while(fHeaderRead == false); // Make sure the header includes an HTTP 200 OK response. // char *p = strstr(fBuffer, "HTTP"); if (p == 0) { ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, urlSource.getURLText(), fMemoryManager); } p = strchr(p, ' '); if (p == 0) { ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, urlSource.getURLText(), fMemoryManager); } int httpResponse = atoi(p); if (httpResponse != 200) { // Most likely a 404 Not Found error. // Should recognize and handle the forwarding responses. // ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::File_CouldNotOpenFile, urlSource.getURLText(), fMemoryManager); } fSocketHandle = (unsigned int) *janSock.release(); }
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); }
// --------------------------------------------------------------------------- // RegularExpression: Tokenize methods // --------------------------------------------------------------------------- RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const char* const expression) { XMLCh* tmpBuf = XMLString::transcode(expression, fMemoryManager); ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager); return tokenize(tmpBuf, 0, XMLString::stringLen(tmpBuf)); }