[GME-commit] GMESRC/GME/Include/xercesc/util/NetAccessors/WinSock BinHTTPURLInputStream.cpp, NONE, 1.1 BinHTTPURLInputStream.hpp, NONE, 1.1 WinSockNetAccessor.cpp, NONE, 1.1 WinSockNetAccessor.hpp, NONE, 1.1
Log messages of CVS commits
gme-commit at list.isis.vanderbilt.edu
Tue Feb 19 14:16:30 CST 2008
- Previous message: [GME-commit] GMESRC/GME/Include/xercesc/util/MsgLoaders/ICU/resources Makefile.in, NONE, 1.1 en_US.txt, NONE, 1.1 res-file-list-unix.txt, NONE, 1.1 res-file-list-wins.txt, NONE, 1.1 res-file-list.txt, NONE, 1.1 resources.mak, NONE, 1.1
- Next message: [GME-commit] GMESRC/GME/Include/xercesc/util/NetAccessors/libWWW BinURLInputStream.cpp, NONE, 1.1 BinURLInputStream.hpp, NONE, 1.1 LibWWWNetAccessor.cpp, NONE, 1.1 LibWWWNetAccessor.hpp, NONE, 1.1 Makefile.in, NONE, 1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Update of /project/gme-repository/GMESRC/GME/Include/xercesc/util/NetAccessors/WinSock
In directory escher:/tmp/cvs-serv26529/util/NetAccessors/WinSock
Added Files:
BinHTTPURLInputStream.cpp BinHTTPURLInputStream.hpp
WinSockNetAccessor.cpp WinSockNetAccessor.hpp
Log Message:
Xerces2.7 includes checkin.
CVS User: Zoltan Molnar, ISIS (zolmol)
--- NEW FILE: BinHTTPURLInputStream.hpp ---
/*
* Copyright 1999-2000,2004 The Apache Software Foundation.
*
* Licensed 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: BinHTTPURLInputStream.hpp,v 1.1 2008/02/19 20:16:28 zolmol Exp $
*/
#if !defined(BINHTTPURLINPUTSTREAM_HPP)
#define BINHTTPURLINPUTSTREAM_HPP
#include <xercesc/util/XMLURL.hpp>
#include <xercesc/util/XMLExceptMsgs.hpp>
#include <xercesc/util/BinInputStream.hpp>
#include <xercesc/util/Mutexes.hpp>
#include <xercesc/util/XMLNetAccessor.hpp>
//
// This class implements the BinInputStream interface specified by the XML
// parser.
//
struct hostent;
struct sockaddr;
XERCES_CPP_NAMESPACE_BEGIN
class XMLUTIL_EXPORT BinHTTPURLInputStream : public BinInputStream
{
public :
BinHTTPURLInputStream(const XMLURL& urlSource, const XMLNetHTTPInfo* httpInfo=0);
~BinHTTPURLInputStream();
unsigned int curPos() const;
unsigned int readBytes
(
XMLByte* const toFill
, const unsigned int maxToRead
);
static void Cleanup();
private :
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
BinHTTPURLInputStream(const BinHTTPURLInputStream&);
BinHTTPURLInputStream& operator=(const BinHTTPURLInputStream&);
// -----------------------------------------------------------------------
// Private data members
//
// fSocketHandle
// The socket representing the connection to the remote file.
// We deliberately did not define the type to be SOCKET, so as to
// avoid bringing in any Windows header into this file.
// fBytesProcessed
// Its a rolling count of the number of bytes processed off this
// input stream.
// fBuffer
// Holds the http header, plus the first part of the actual
// data. Filled at the time the stream is opened, data goes
// out to user in response to readBytes().
// fBufferPos, fBufferEnd
// Pointers into fBuffer, showing start and end+1 of content
// that readBytes must return.
// -----------------------------------------------------------------------
MemoryManager* fMemoryManager;
unsigned int fSocketHandle;
unsigned int fBytesProcessed;
char fBuffer[4000];
char * fBufferEnd;
char * fBufferPos;
static bool fInitialized;
static XMLMutex* fInitMutex;
static void Initialize(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
inline static hostent* gethostbyname(const char* name);
inline static unsigned long inet_addr(const char* cp);
inline static hostent* gethostbyaddr(const char* addr,int len,int type);
inline static unsigned short htons(unsigned short hostshort);
inline static unsigned int socket(int af,int type,int protocol);
inline static int connect(unsigned int s,const sockaddr* name,int namelen);
inline static int send(unsigned int s,const char* buf,int len,int flags);
inline static int recv(unsigned int s,char* buf,int len,int flags);
inline static int shutdown(unsigned int s,int how);
inline static int closesocket(unsigned int socket);
};
inline unsigned int BinHTTPURLInputStream::curPos() const
{
return fBytesProcessed;
}
XERCES_CPP_NAMESPACE_END
#endif // BINHTTPURLINPUTSTREAM_HPP
--- NEW FILE: BinHTTPURLInputStream.cpp ---
/*
* Copyright 1999-2000,2004 The Apache Software Foundation.
*
* Licensed 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: BinHTTPURLInputStream.cpp,v 1.1 2008/02/19 20:16:28 zolmol Exp $
*/
#define INCL_WINSOCK_API_TYPEDEFS 1
#include <winsock2.h>
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLNetAccessor.hpp>
#include <xercesc/util/NetAccessors/WinSock/BinHTTPURLInputStream.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLExceptMsgs.hpp>
#include <xercesc/util/Janitor.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/Base64.hpp>
XERCES_CPP_NAMESPACE_BEGIN
class SocketJanitor
{
public:
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
SocketJanitor(SOCKET* toDelete) : fData(toDelete) {}
~SocketJanitor() { reset(); }
SOCKET* get() const { return fData; }
SOCKET* release() { SOCKET* p = fData; fData = 0; return p; }
void reset(SOCKET* p = 0) { if(fData) closesocket(*fData); fData=p; }
bool isDataNull() { return (fData == 0); }
private :
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
SocketJanitor();
SocketJanitor(const SocketJanitor&);
SocketJanitor& operator=(const SocketJanitor&);
// -----------------------------------------------------------------------
// Private data members
//
// fData
// This is the pointer to the socket that must be closed when
// this object is destroyed.
// -----------------------------------------------------------------------
SOCKET* fData;
};
static HMODULE gWinsockLib = NULL;
static LPFN_GETHOSTBYNAME gWSgethostbyname = NULL;
static LPFN_INET_ADDR gWSinet_addr = NULL;
static LPFN_GETHOSTBYADDR gWSgethostbyaddr = NULL;
static LPFN_HTONS gWShtons = NULL;
static LPFN_SOCKET gWSsocket = NULL;
static LPFN_CONNECT gWSconnect = NULL;
static LPFN_SEND gWSsend = NULL;
static LPFN_RECV gWSrecv = NULL;
static LPFN_SHUTDOWN gWSshutdown = NULL;
static LPFN_CLOSESOCKET gWSclosesocket = NULL;
static LPFN_WSACLEANUP gWSACleanup = NULL;
bool BinHTTPURLInputStream::fInitialized = false;
XMLMutex* BinHTTPURLInputStream::fInitMutex = 0;
void BinHTTPURLInputStream::Initialize(MemoryManager* const manager) {
//
// Initialize the WinSock library here.
//
WORD wVersionRequested;
WSADATA wsaData;
LPFN_WSASTARTUP startup = NULL;
if(gWinsockLib == NULL) {
gWinsockLib = LoadLibrary(_T("WSOCK32"));
if(gWinsockLib == NULL) {
ThrowXMLwithMemMgr(NetAccessorException, XMLExcepts::NetAcc_InitFailed, manager);
}
else {
startup = (LPFN_WSASTARTUP) GetProcAddress(gWinsockLib,"WSAStartup");
gWSACleanup = (LPFN_WSACLEANUP) GetProcAddress(gWinsockLib,"WSACleanup");
gWSgethostbyname = (LPFN_GETHOSTBYNAME) GetProcAddress(gWinsockLib,"gethostbyname");
gWSinet_addr = (LPFN_INET_ADDR) GetProcAddress(gWinsockLib,"inet_addr");
gWSgethostbyaddr = (LPFN_GETHOSTBYADDR) GetProcAddress(gWinsockLib,"gethostbyaddr");
gWShtons = (LPFN_HTONS) GetProcAddress(gWinsockLib,"htons");
gWSsocket = (LPFN_SOCKET) GetProcAddress(gWinsockLib,"socket");
gWSconnect = (LPFN_CONNECT) GetProcAddress(gWinsockLib,"connect");
gWSsend = (LPFN_SEND) GetProcAddress(gWinsockLib,"send");
gWSrecv = (LPFN_RECV) GetProcAddress(gWinsockLib,"recv");
gWSshutdown = (LPFN_SHUTDOWN) GetProcAddress(gWinsockLib,"shutdown");
gWSclosesocket = (LPFN_CLOSESOCKET) GetProcAddress(gWinsockLib,"closesocket");
if(startup == NULL ||
gWSACleanup == NULL ||
gWSgethostbyname == NULL ||
gWSinet_addr == NULL ||
gWSgethostbyaddr == NULL ||
gWShtons == NULL ||
gWSsocket == NULL ||
gWSconnect == NULL ||
gWSsend == NULL ||
gWSrecv == NULL ||
gWSshutdown == NULL ||
gWSclosesocket == NULL)
{
gWSACleanup = NULL;
Cleanup();
ThrowXMLwithMemMgr(NetAccessorException, XMLExcepts::NetAcc_InitFailed, manager);
}
}
}
wVersionRequested = MAKEWORD( 2, 2 );
int err = (*startup)(wVersionRequested, &wsaData);
if (err != 0)
{
// Call WSAGetLastError() to get the last error.
ThrowXMLwithMemMgr(NetAccessorException, XMLExcepts::NetAcc_InitFailed, manager);
}
fInitialized = true;
}
void BinHTTPURLInputStream::Cleanup() {
if(fInitialized)
{
if(gWSACleanup) (*gWSACleanup)();
gWSACleanup = NULL;
FreeLibrary(gWinsockLib);
gWinsockLib = NULL;
gWSgethostbyname = NULL;
gWSinet_addr = NULL;
gWSgethostbyaddr = NULL;
gWShtons = NULL;
gWSsocket = NULL;
gWSconnect = NULL;
gWSsend = NULL;
gWSrecv = NULL;
gWSshutdown = NULL;
gWSclosesocket = NULL;
fInitialized = false;
delete fInitMutex;
fInitMutex = 0;
}
}
hostent* BinHTTPURLInputStream::gethostbyname(const char* name)
{
return (*gWSgethostbyname)(name);
}
unsigned long BinHTTPURLInputStream::inet_addr(const char* cp)
{
return (*gWSinet_addr)(cp);
}
hostent* BinHTTPURLInputStream::gethostbyaddr(const char* addr,int len,int type)
{
return (*gWSgethostbyaddr)(addr,len,type);
}
unsigned short BinHTTPURLInputStream::htons(unsigned short hostshort)
{
return (*gWShtons)(hostshort);
}
unsigned int BinHTTPURLInputStream::socket(int af,int type,int protocol)
{
return (*gWSsocket)(af,type,protocol);
}
int BinHTTPURLInputStream::connect(unsigned int s,const sockaddr* name,int namelen)
{
return (*gWSconnect)(s,name,namelen);
}
int BinHTTPURLInputStream::send(unsigned int s,const char* buf,int len,int flags)
{
return (*gWSsend)(s,buf,len,flags);
}
int BinHTTPURLInputStream::recv(unsigned int s,char* buf,int len,int flags)
{
return (*gWSrecv)(s,buf,len,flags);
}
int BinHTTPURLInputStream::shutdown(unsigned int s,int how)
{
return (*gWSshutdown)(s,how);
}
int BinHTTPURLInputStream::closesocket(unsigned int socket)
{
return (*gWSclosesocket)(socket);
}
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();
}
BinHTTPURLInputStream::~BinHTTPURLInputStream()
{
shutdown(fSocketHandle, SD_BOTH);
closesocket(fSocketHandle);
}
//
// readBytes
//
unsigned int BinHTTPURLInputStream::readBytes(XMLByte* const toFill
, const unsigned int maxToRead)
{
unsigned int len = fBufferEnd - 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.
//
len = recv((SOCKET) fSocketHandle, (char *) toFill, maxToRead, 0);
if (len == SOCKET_ERROR)
{
// Call WSAGetLastError() to get the error number.
ThrowXMLwithMemMgr(NetAccessorException, XMLExcepts::NetAcc_ReadSocket, fMemoryManager);
}
}
fBytesProcessed += len;
return len;
}
XERCES_CPP_NAMESPACE_END
--- NEW FILE: WinSockNetAccessor.cpp ---
/*
* Copyright 1999-2000,2004 The Apache Software Foundation.
*
* Licensed 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: WinSockNetAccessor.cpp,v 1.1 2008/02/19 20:16:28 zolmol Exp $
*/
#define _WINSOCKAPI_
#include <windows.h>
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLExceptMsgs.hpp>
#include <xercesc/util/NetAccessors/WinSock/BinHTTPURLInputStream.hpp>
#include <xercesc/util/NetAccessors/WinSock/WinSockNetAccessor.hpp>
XERCES_CPP_NAMESPACE_BEGIN
const XMLCh WinSockNetAccessor::fgMyName[] =
{
chLatin_W, chLatin_i, chLatin_n, chLatin_S, chLatin_o, chLatin_c,
chLatin_k, chLatin_N, chLatin_e, chLatin_t, chLatin_A, chLatin_c,
chLatin_c, chLatin_e, chLatin_s, chLatin_s, chLatin_o, chLatin_r,
chNull
};
WinSockNetAccessor::WinSockNetAccessor()
{
}
WinSockNetAccessor::~WinSockNetAccessor()
{
// Cleanup code for the WinSock library here.
BinHTTPURLInputStream::Cleanup();
}
BinInputStream* WinSockNetAccessor::makeNew(const XMLURL& urlSource, const XMLNetHTTPInfo* httpInfo /*=0*/)
{
XMLURL::Protocols protocol = urlSource.getProtocol();
switch(protocol)
{
case XMLURL::HTTP:
{
BinHTTPURLInputStream* retStrm =
new (urlSource.getMemoryManager()) BinHTTPURLInputStream(urlSource, httpInfo);
return retStrm;
break;
}
//
// These are the only protocols we support now. So throw and
// unsupported protocol exception for the others.
//
default :
ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_UnsupportedProto, urlSource.getMemoryManager());
break;
}
return 0;
}
XERCES_CPP_NAMESPACE_END
--- NEW FILE: WinSockNetAccessor.hpp ---
/*
* Copyright 1999-2000,2004 The Apache Software Foundation.
*
* Licensed 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: WinSockNetAccessor.hpp,v 1.1 2008/02/19 20:16:28 zolmol Exp $
*/
#if !defined(WINSOCKNETACCESSOR_HPP)
#define WINSOCKNETACCESSOR_HPP
#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/util/XMLURL.hpp>
#include <xercesc/util/BinInputStream.hpp>
#include <xercesc/util/XMLNetAccessor.hpp>
XERCES_CPP_NAMESPACE_BEGIN
//
// This class is the wrapper for the WinSock library which provides
// support for sockets. Its being used here to add the ability to
// use HTTP URL's as the system id's in the XML decl clauses.
//
class XMLUTIL_EXPORT WinSockNetAccessor : public XMLNetAccessor
{
public :
WinSockNetAccessor();
~WinSockNetAccessor();
virtual BinInputStream* makeNew(const XMLURL& urlSource, const XMLNetHTTPInfo* httpInfo=0);
virtual const XMLCh* getId() const;
private :
static const XMLCh fgMyName[];
WinSockNetAccessor(const WinSockNetAccessor&);
WinSockNetAccessor& operator=(const WinSockNetAccessor&);
}; // WinSockNetAccessor
inline const XMLCh* WinSockNetAccessor::getId() const
{
return fgMyName;
}
XERCES_CPP_NAMESPACE_END
#endif // WINSOCKNETACCESSOR_HPP
- Previous message: [GME-commit] GMESRC/GME/Include/xercesc/util/MsgLoaders/ICU/resources Makefile.in, NONE, 1.1 en_US.txt, NONE, 1.1 res-file-list-unix.txt, NONE, 1.1 res-file-list-wins.txt, NONE, 1.1 res-file-list.txt, NONE, 1.1 resources.mak, NONE, 1.1
- Next message: [GME-commit] GMESRC/GME/Include/xercesc/util/NetAccessors/libWWW BinURLInputStream.cpp, NONE, 1.1 BinURLInputStream.hpp, NONE, 1.1 LibWWWNetAccessor.cpp, NONE, 1.1 LibWWWNetAccessor.hpp, NONE, 1.1 Makefile.in, NONE, 1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the GME-commit
mailing list