You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
377 lines
8.5 KiB
377 lines
8.5 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
#include "hsSTLStream.h" |
|
|
|
hsVectorStream::hsVectorStream() : fEnd(0) |
|
{ |
|
} |
|
|
|
hsVectorStream::hsVectorStream(UInt32 chunkSize) |
|
{ |
|
fVector.reserve(chunkSize); |
|
} |
|
|
|
hsVectorStream::~hsVectorStream() |
|
{ |
|
} |
|
|
|
hsBool hsVectorStream::AtEnd() |
|
{ |
|
return (fBytesRead >= fEnd); |
|
} |
|
|
|
UInt32 hsVectorStream::Read(UInt32 byteCount, void *buffer) |
|
{ |
|
if (fBytesRead + byteCount > fEnd) |
|
{ |
|
// hsStatusMessageF("Reading past end of hsVectorStream (read %u of %u requested bytes)", fEnd-fBytesRead, byteCount); |
|
byteCount = fEnd - fBytesRead; |
|
} |
|
|
|
memcpy(buffer, &fVector[fBytesRead], byteCount); |
|
|
|
fBytesRead += byteCount; |
|
fPosition += byteCount; |
|
|
|
return byteCount; |
|
} |
|
|
|
UInt32 hsVectorStream::Write(UInt32 byteCount, const void* buffer) |
|
{ |
|
// If we are at the end of the vector, we can just do a block insert of the data |
|
if (fPosition == fVector.size()) |
|
fVector.insert(fVector.end(), (Byte*)buffer, (Byte*)buffer+byteCount); |
|
// If we are in the middle, I don't know how to just overwrite a block of the vector. |
|
// So, we make sure there is enough space and copy the elements one by one |
|
else |
|
{ |
|
fVector.reserve(fPosition+byteCount); |
|
for (UInt32 i = 0; i < byteCount; i++) |
|
fVector[fPosition+i] = ((Byte*)buffer)[i]; |
|
} |
|
|
|
fPosition += byteCount; |
|
|
|
if (fPosition > fEnd) |
|
fEnd = fPosition; |
|
|
|
return byteCount; |
|
} |
|
|
|
void hsVectorStream::Skip(UInt32 deltaByteCount) |
|
{ |
|
fBytesRead += deltaByteCount; |
|
fPosition += deltaByteCount; |
|
} |
|
|
|
void hsVectorStream::Rewind() |
|
{ |
|
fBytesRead = 0; |
|
fPosition = 0; |
|
} |
|
|
|
void hsVectorStream::FastFwd() |
|
{ |
|
fBytesRead = fPosition = fEnd; |
|
} |
|
|
|
void hsVectorStream::Truncate() |
|
{ |
|
fVector.erase(fVector.begin()+fPosition, fVector.end()); |
|
fEnd = fPosition-1; |
|
} |
|
|
|
UInt32 hsVectorStream::GetEOF() |
|
{ |
|
return fEnd; |
|
} |
|
|
|
void hsVectorStream::CopyToMem(void* mem) |
|
{ |
|
memcpy(mem, &fVector[0], fEnd); |
|
} |
|
|
|
void hsVectorStream::Erase(UInt32 bytes) |
|
{ |
|
hsAssert(fPosition+bytes <= fEnd, "Erasing past end of stream"); |
|
|
|
fVector.erase(fVector.begin()+fPosition, fVector.begin()+fPosition+bytes); |
|
fEnd -= bytes; |
|
} |
|
|
|
void hsVectorStream::Reset() |
|
{ |
|
fBytesRead = 0; |
|
fPosition = 0; |
|
fEnd = 0; |
|
fVector.clear(); |
|
} |
|
|
|
const void *hsVectorStream::GetData() |
|
{ |
|
if (fVector.size() > 0) |
|
return &fVector[0]; |
|
else |
|
return nil; |
|
} |
|
|
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#ifdef HS_BUILD_FOR_WIN32 |
|
|
|
hsNamedPipeStream::hsNamedPipeStream(UInt8 flags, UInt32 timeout) : |
|
fFlags(flags), |
|
fPipe(INVALID_HANDLE_VALUE), |
|
fReadMode(false), |
|
fTimeout(timeout) |
|
{ |
|
memset(&fOverlap, 0, sizeof(OVERLAPPED)); |
|
fOverlap.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL); |
|
} |
|
|
|
hsNamedPipeStream::~hsNamedPipeStream() |
|
{ |
|
CloseHandle(fOverlap.hEvent); |
|
fOverlap.hEvent = INVALID_HANDLE_VALUE; |
|
} |
|
|
|
hsBool hsNamedPipeStream::WaitForClientConnect() |
|
{ |
|
// Look for a client connect (this should return zero since it's overlapped) |
|
BOOL ret = ConnectNamedPipe(fPipe, &fOverlap); |
|
if (ret) |
|
return true; |
|
else |
|
{ |
|
switch (GetLastError()) |
|
{ |
|
// Waiting for client to connect |
|
case ERROR_IO_PENDING: |
|
if (WaitForSingleObject(fOverlap.hEvent, fTimeout) == WAIT_OBJECT_0) |
|
return true; |
|
break; |
|
|
|
// Client is already connected |
|
case ERROR_PIPE_CONNECTED: |
|
// if (SetEvent(fOverlap.hEvent)) |
|
return true; |
|
break; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
hsBool hsNamedPipeStream::Open(const char *name, const char *mode) |
|
{ |
|
wchar* wName = hsStringToWString(name); |
|
wchar* wMode = hsStringToWString(mode); |
|
hsBool ret = Open(wName, wMode); |
|
delete [] wName; |
|
delete [] wMode; |
|
return ret; |
|
} |
|
|
|
hsBool hsNamedPipeStream::Open(const wchar *name, const wchar *mode) |
|
{ |
|
if (wcschr(mode, L'w')) |
|
{ |
|
fReadMode = false; |
|
|
|
// Try to create the pipe |
|
fPipe = CreateNamedPipeW(name, |
|
PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED, |
|
PIPE_TYPE_BYTE, |
|
1, |
|
1024, |
|
1024, |
|
fTimeout, |
|
NULL); |
|
|
|
if (fPipe != INVALID_HANDLE_VALUE) |
|
return true; |
|
} |
|
else if (wcschr(mode, L'r')) |
|
{ |
|
fReadMode = true; |
|
|
|
fPipe = CreateFileW(name, |
|
GENERIC_READ, |
|
0, // no sharing |
|
NULL, // no security attributes |
|
OPEN_EXISTING, // opens existing pipe |
|
FILE_FLAG_OVERLAPPED, // default attributes |
|
NULL); // no template file |
|
|
|
if (fPipe != INVALID_HANDLE_VALUE) |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
hsBool hsNamedPipeStream::Close() |
|
{ |
|
if (fPipe == INVALID_HANDLE_VALUE) |
|
return false; |
|
|
|
if (fReadMode) |
|
{ |
|
CloseHandle(fPipe); // Close our end of the pipe |
|
fPipe = INVALID_HANDLE_VALUE; |
|
} |
|
else |
|
{ |
|
FlushFileBuffers(fPipe); // Make sure the client is done reading |
|
DisconnectNamedPipe(fPipe); // Disconnect the pipe from the client |
|
CloseHandle(fPipe); // Close our end of the pipe |
|
fPipe = INVALID_HANDLE_VALUE; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
hsBool hsNamedPipeStream::ICheckOverlappedResult(BOOL result, UInt32 &numTransferred) |
|
{ |
|
// Read/Write succeeded, return now |
|
if (result) |
|
return true; |
|
// Read failed because the operation is taking a while. Wait for it |
|
else if (GetLastError() == ERROR_IO_PENDING) |
|
{ |
|
if (WaitForSingleObject(fOverlap.hEvent, fTimeout) == WAIT_OBJECT_0) |
|
{ |
|
BOOL oResult = GetOverlappedResult(fPipe, &fOverlap, &numTransferred, FALSE); |
|
if (oResult) |
|
return true; |
|
hsAssert(oResult, "GetOverlappedResult failed"); |
|
} |
|
else |
|
hsAssert(0, "Wait failed"); |
|
} |
|
else |
|
hsAssert(0, "Read/Write failed"); |
|
|
|
return false; |
|
} |
|
|
|
hsBool hsNamedPipeStream::IRead(UInt32 byteCount, void *buffer, UInt32 &numRead) |
|
{ |
|
numRead = 0; |
|
|
|
if (fPipe != INVALID_HANDLE_VALUE && fReadMode) |
|
{ |
|
BOOL result = ReadFile(fPipe, buffer, byteCount, &numRead, &fOverlap); |
|
if (ICheckOverlappedResult(result, numRead)) |
|
return true; |
|
} |
|
|
|
// If we got here, the pipe is probably broken. Throw if it is enabled. |
|
if (fFlags & kThrowOnError) |
|
throw this; |
|
|
|
return false; |
|
} |
|
|
|
hsBool hsNamedPipeStream::IWrite(UInt32 byteCount, const void *buffer, UInt32 &numWritten) |
|
{ |
|
numWritten = 0; |
|
|
|
if (fPipe != INVALID_HANDLE_VALUE && !fReadMode) |
|
{ |
|
BOOL result = WriteFile(fPipe, buffer, byteCount, &numWritten, &fOverlap); |
|
if (ICheckOverlappedResult(result, numWritten)) |
|
return true; |
|
} |
|
|
|
// If we got here, the pipe is probably broken. Throw if it is enabled. |
|
if (fFlags & kThrowOnError) |
|
throw this; |
|
|
|
return false; |
|
} |
|
|
|
UInt32 hsNamedPipeStream::Read(UInt32 byteCount, void *buffer) |
|
{ |
|
UInt32 totalRead = 0; |
|
|
|
// Read until we get all our data or an error |
|
UInt32 numRead = 0; |
|
while (IRead(byteCount-totalRead, (void*)((UInt32)buffer+totalRead), numRead)) |
|
{ |
|
totalRead += numRead; |
|
|
|
if (totalRead >= byteCount) |
|
return totalRead; |
|
} |
|
|
|
return totalRead; |
|
} |
|
|
|
UInt32 hsNamedPipeStream::Write(UInt32 byteCount, const void *buffer) |
|
{ |
|
UInt32 totalWritten = 0; |
|
|
|
// Write until we get all our data or an error |
|
UInt32 numWritten = 0; |
|
while (IWrite(byteCount-totalWritten, (const void*)((UInt32)buffer+totalWritten), numWritten)) |
|
{ |
|
totalWritten += numWritten; |
|
|
|
if (totalWritten >= byteCount) |
|
return totalWritten; |
|
} |
|
|
|
return totalWritten; |
|
} |
|
|
|
#ifdef __SGI_STL_PORT |
|
using std::min; |
|
#endif |
|
|
|
void hsNamedPipeStream::Skip(UInt32 deltaByteCount) |
|
{ |
|
char buf[256]; |
|
|
|
// Read until we get all our data or an error |
|
UInt32 totalRead = 0; |
|
UInt32 numRead = 0; |
|
while (IRead(min((UInt32)256L, deltaByteCount-totalRead), buf, numRead)) |
|
{ |
|
totalRead += numRead; |
|
|
|
if (totalRead >= deltaByteCount) |
|
return; |
|
} |
|
|
|
} |
|
|
|
void hsNamedPipeStream::Rewind() |
|
{ |
|
hsAssert(0, "Rewind not allowed on a pipe"); |
|
} |
|
|
|
#endif // HS_BUILD_FOR_WIN32
|
|
|