BOOL CHostBrowser::OnRead()
{
//CQuickLock oTransfersLock( Transfers.m_pSection );
// ED2K connections aren't handled here- they are in ED2KClient
if ( m_nProtocol == PROTOCOL_ED2K || m_nProtocol == PROTOCOL_DC ) return TRUE;
if ( ! IsInputExist() || ! IsOutputExist() ) return TRUE;
CTransfer::OnRead();
switch ( m_nState )
{
case hbsRequesting:
if ( ! ReadResponseLine() ) return FALSE;
if ( m_nState != hbsHeaders ) break;
case hbsHeaders:
if ( ! ReadHeaders() ) return FALSE;
if ( m_nState != hbsContent ) break;
case hbsContent:
return ReadContent();
}
return TRUE;
}
void PottsMeshReader<SPACE_DIM>::Reset()
{
CloseFiles();
OpenFiles();
ReadHeaders();
mNodesRead = 0;
mElementsRead = 0;
}
PottsMeshReader<SPACE_DIM>::PottsMeshReader(std::string pathBaseName)
: mFilesBaseName(pathBaseName),
mIndexFromZero(false), // initially assume that nodes are not numbered from zero
mNumNodes(0),
mNumElements(0),
mNodesRead(0),
mElementsRead(0),
mNumElementAttributes(0)
{
OpenFiles();
ReadHeaders();
}
void CZipCentralDir::Read()
{
ASSERT(m_pStorage);
WORD uCommentSize;
m_info.m_uCentrDirPos = Locate();
m_pStorage->m_pFile->Seek(m_info.m_uCentrDirPos, CZipAbstractFile::begin);
CZipAutoBuffer buf(CENTRALDIRSIZE);
int uRead = m_pStorage->m_pFile->Read(buf, CENTRALDIRSIZE);
if (uRead != CENTRALDIRSIZE)
ThrowError(CZipException::badZipFile);
memcpy(&m_szSignature, buf, 4);
memcpy(&m_info.m_uThisDisk, buf + 4, 2);
memcpy(&m_info.m_uDiskWithCD, buf + 6, 2);
memcpy(&m_info.m_uDiskEntriesNo,buf + 8, 2);
memcpy(&m_info.m_uEntriesNumber,buf + 10, 2);
memcpy(&m_info.m_uSize, buf + 12, 4);
memcpy(&m_info.m_uOffset, buf + 16, 4);
memcpy(&uCommentSize, buf + 20, 2);
buf.Release();
m_pStorage->UpdateSpanMode(m_info.m_uThisDisk);
// if m_uThisDisk is not zero, it is enough to say that it is a multi disk archive
ASSERT((!m_info.m_uThisDisk && (m_info.m_uEntriesNumber == m_info.m_uDiskEntriesNo) && !m_info.m_uDiskWithCD) || m_info.m_uThisDisk);
if (!m_pStorage->IsSpanMode() && !m_info.CheckIfOK_1())
ThrowError(CZipException::badZipFile);
if (uCommentSize)
{
m_pszComment.Allocate(uCommentSize);
uRead = m_pStorage->m_pFile->Read(m_pszComment, uCommentSize);
if (uRead != uCommentSize)
ThrowError(CZipException::badZipFile);
}
m_info.SetBytesBeforeZip(m_pStorage->IsSpanMode() != 0);
if (!m_info.CheckIfOK_2())
ThrowError(CZipException::badZipFile);
m_info.m_bOnDisk = true;
m_pStorage->ChangeDisk(m_info.m_uDiskWithCD);
if (!m_info.m_uSize)
return;
ReadHeaders();
}
void TrianglesMeshReader<ELEMENT_DIM, SPACE_DIM>::Reset()
{
CloseFiles();
mNodesRead = 0;
mElementsRead = 0;
mFacesRead = 0;
mBoundaryFacesRead = 0;
mCableElementsRead = 0;
mNclItemsRead = 0;
mEofException = false;
OpenFiles();
ReadHeaders();
}
void CCentralDir::Read()
{
ASSERT(m_pStorage);
m_uCentrDirPos = Locate();
m_pStorage->m_file.Seek(m_uCentrDirPos, CFile::begin);
CAutoBuffer buf(CENTRALDIRSIZE);
m_pStorage->m_file.Read(buf, CENTRALDIRSIZE);
memcpy(&m_szSignature, buf, 4);
memcpy(&m_uThisDisk, buf + 4, 2);
memcpy(&m_uDiskWithCD, buf + 6, 2);
memcpy(&m_uDiskEntriesNo, buf + 8, 2);
memcpy(&m_uEntriesNumber, buf + 10, 2);
memcpy(&m_uSize, buf + 12, 4);
memcpy(&m_uOffset, buf + 16, 4);
memcpy(&m_uCommentSize, buf + 20, 2);
buf.Release();
m_pStorage->UpdateSpanMode(m_uThisDisk);
// if m_uThisDisk is not zero, it is enough to say that it is multi archive
ASSERT((!m_uThisDisk && (m_uEntriesNumber == m_uDiskEntriesNo) && !m_uDiskWithCD) || m_uThisDisk);
if (!m_pStorage->IsSpanMode() && ((DWORD)m_uCentrDirPos < m_uOffset + m_uSize))
ThrowError(ZIP_BADZIPFILE);
if (m_uCommentSize)
{
m_pStorage->m_file.Read(m_szComment.GetBuffer(m_uCommentSize), m_uCommentSize);
m_szComment.ReleaseBuffer(m_uCommentSize);
}
m_uBytesBeforeZip = m_pStorage->IsSpanMode() ? 0 : m_uCentrDirPos - m_uSize - m_uOffset;
if ((!m_uSize && m_uEntriesNumber) || (!m_uEntriesNumber && m_uSize))
ThrowError(ZIP_BADZIPFILE);
m_bOnDisk = true;
m_pStorage->ChangeDisk(m_uDiskWithCD);
if (!m_uSize)
return;
ReadHeaders();
}
wxTarEntry *wxTarInputStream::GetNextEntry()
{
m_lasterror = ReadHeaders();
if (!IsOk())
return NULL;
wxTarEntryPtr entry(new wxTarEntry);
entry->SetMode(GetHeaderNumber(TAR_MODE));
entry->SetUserId(GetHeaderNumber(TAR_UID));
entry->SetGroupId(GetHeaderNumber(TAR_UID));
entry->SetSize(GetHeaderNumber(TAR_SIZE));
entry->SetOffset(m_offset);
entry->SetDateTime(GetHeaderDate(wxT("mtime")));
entry->SetAccessTime(GetHeaderDate(wxT("atime")));
entry->SetCreateTime(GetHeaderDate(wxT("ctime")));
entry->SetTypeFlag(*m_hdr->Get(TAR_TYPEFLAG));
bool isDir = entry->IsDir();
entry->SetLinkName(GetHeaderString(TAR_LINKNAME));
if (m_tarType != TYPE_OLDTAR) {
entry->SetUserName(GetHeaderString(TAR_UNAME));
entry->SetGroupName(GetHeaderString(TAR_GNAME));
entry->SetDevMajor(GetHeaderNumber(TAR_DEVMAJOR));
entry->SetDevMinor(GetHeaderNumber(TAR_DEVMINOR));
}
entry->SetName(GetHeaderPath(), wxPATH_UNIX);
if (isDir)
entry->SetIsDir();
if (m_HeaderRecs)
m_HeaderRecs->clear();
m_size = GetDataSize(*entry);
m_pos = 0;
return entry.release();
}
SimpleReaderBase::SimpleReaderBase(const string& fileName, const int& nHeaders,const char& separator,
const int& iDataTitles, const int& nVariablesForOneObject ,
const int& nLineHeaders, const string& headerRepeatKey)
{
m_pFile = new ifstream(fileName.c_str(), ios::in);
if(!m_pFile->is_open())
{
printf("\n Can't Open Map File !, %s", fileName.c_str());
return;
}
m_nHeders = nHeaders;
m_iDataTitles = iDataTitles;
m_nVarPerObj = nVariablesForOneObject;
m_HeaderRepeatKey = headerRepeatKey;
m_nLineHeaders = nLineHeaders;
m_Separator = separator;
m_pFile->precision(16);
ReadHeaders();
}
void au::SessionTokenTestConnection::Handshake()
{
auto self(shared_from_this());
request_->ssl_stream.async_handshake(
boost::asio::ssl::stream_base::server,
[this, self](
boost::system::error_code ec
)
{
if (ec)
{
std::cout << "Handshake: Got error: " << ec.message()
<< std::endl;
request_->Fail(HttpStatusCode::bad_request);
return;
}
ReadHeaders();
});
}
BOOL CHostBrowser::OnRead()
{
if ( m_pInput == NULL || m_pOutput == NULL ) return TRUE;
CTransfer::OnRead();
switch ( m_nState )
{
case hbsRequesting:
if ( ! ReadResponseLine() ) return FALSE;
if ( m_nState != hbsHeaders ) break;
case hbsHeaders:
if ( ! ReadHeaders() ) return FALSE;
if ( m_nState != hbsContent ) break;
case hbsContent:
return ReadContent();
}
return TRUE;
}
BOOL CRemote::OnRead()
{
if ( ! CTransfer::OnRead() ) return FALSE;
if ( m_sHandshake.IsEmpty() )
{
if ( GetInputLength() > 4096 || ! Settings.Remote.Enable )
{
Close();
return FALSE;
}
Read( m_sHandshake );
}
if ( ! m_sHandshake.IsEmpty() )
{
theApp.Message( MSG_DEBUG | MSG_FACILITY_INCOMING, L"%s >> REMOTE REQUEST: %s", (LPCTSTR)m_sAddress, (LPCTSTR)m_sHandshake );
return ReadHeaders();
}
return TRUE;
}
TrianglesMeshReader<ELEMENT_DIM, SPACE_DIM>::TrianglesMeshReader(std::string pathBaseName,
unsigned orderOfElements,
unsigned orderOfBoundaryElements,
bool readContainingElementForBoundaryElements)
: mFilesBaseName(pathBaseName),
mNodeItemWidth(0),
mElementItemWidth(0),
mFaceItemWidth(0),
mNumNodes(0),
mNumElements(0),
mNumFaces(0),
mNumCableElements(0),
mNodesRead(0),
mElementsRead(0),
mCableElementsRead(0),
mFacesRead(0),
mBoundaryFacesRead(0),
mNclItemsRead(0),
mNumNodeAttributes(0),
mNumElementAttributes(0),
mNumFaceAttributes(0),
mNumCableElementAttributes(0),
mOrderOfElements(orderOfElements),
mOrderOfBoundaryElements(orderOfBoundaryElements),
mEofException(false),
mReadContainingElementOfBoundaryElement(readContainingElementForBoundaryElements),
mFilesAreBinary(false),
mMeshIsHexahedral(false),
mNodeFileReadBuffer(NULL),
mElementFileReadBuffer(NULL),
mFaceFileReadBuffer(NULL),
mNodePermutationDefined(false)
{
// Only linear and quadratic elements
assert(orderOfElements==1 || orderOfElements==2);
if ( mOrderOfBoundaryElements == 2 && mReadContainingElementOfBoundaryElement)
{
EXCEPTION("Boundary element file should not have containing element info if it is quadratic");
}
if (mOrderOfElements==1)
{
mNodesPerElement = ELEMENT_DIM+1;
}
else
{
#define COVERAGE_IGNORE
assert(SPACE_DIM==ELEMENT_DIM);
#undef COVERAGE_IGNORE
mNodesPerElement = (ELEMENT_DIM+1)*(ELEMENT_DIM+2)/2;
}
if (mOrderOfBoundaryElements==1)
{
mNodesPerBoundaryElement = ELEMENT_DIM;
}
else
{
#define COVERAGE_IGNORE
assert(SPACE_DIM==ELEMENT_DIM);
#undef COVERAGE_IGNORE
mNodesPerBoundaryElement = ELEMENT_DIM*(ELEMENT_DIM+1)/2;
}
mIndexFromZero = false; // Initially assume that nodes are not numbered from zero
OpenFiles();
ReadHeaders();
}
nsresult nsEudoraCompose::CopyComposedMessage( nsCString& fromLine, nsIFile *pSrc, nsIOutputStream *pDst, SimpleBufferTonyRCopiedOnce& copy)
{
copy.m_bytesInBuf = 0;
copy.m_writeOffset = 0;
ReadFileState state;
state.pFile = pSrc;
state.offset = 0;
state.size = 0;
pSrc->GetFileSize( &state.size);
if (!state.size) {
IMPORT_LOG0( "*** Error, unexpected zero file size for composed message\n");
return( NS_ERROR_FAILURE);
}
nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(state.pInputStream), pSrc);
if (NS_FAILED( rv)) {
IMPORT_LOG0( "*** Error, unable to open composed message file\n");
return( NS_ERROR_FAILURE);
}
PRUint32 written;
rv = pDst->Write( fromLine.get(), fromLine.Length(), &written);
// well, isn't this a hoot!
// Read the headers from the new message, get the ones we like
// and write out only the headers we want from the new message,
// along with all of the other headers from the "old" message!
if (NS_SUCCEEDED( rv))
rv = FillMailBuffer( &state, copy);
if (NS_SUCCEEDED( rv))
rv = ReadHeaders( &state, copy, m_readHeaders);
if (NS_SUCCEEDED( rv)) {
rv = WriteHeaders( pDst, m_readHeaders);
}
// We need to go ahead and write out the rest of the copy buffer
// so that the following will properly copy the rest of the body
char lastChar = 0;
rv = EscapeFromSpaceLine(pDst, copy.m_pBuffer + copy.m_writeOffset, copy.m_pBuffer+copy.m_bytesInBuf);
if (copy.m_bytesInBuf)
lastChar = copy.m_pBuffer[copy.m_bytesInBuf - 1];
if (NS_SUCCEEDED(rv))
copy.m_writeOffset = copy.m_bytesInBuf;
while ((state.offset < state.size) && NS_SUCCEEDED( rv)) {
rv = FillMailBuffer( &state, copy);
if (NS_SUCCEEDED( rv)) {
rv = EscapeFromSpaceLine(pDst, copy.m_pBuffer + copy.m_writeOffset, copy.m_pBuffer+copy.m_bytesInBuf);
lastChar = copy.m_pBuffer[copy.m_bytesInBuf - 1];
if (NS_SUCCEEDED( rv))
copy.m_writeOffset = copy.m_bytesInBuf;
else
IMPORT_LOG0( "*** Error writing to destination mailbox\n");
}
}
state.pInputStream->Close();
if ((lastChar != 0x0A) && NS_SUCCEEDED( rv)) {
rv = pDst->Write( "\x0D\x0A", 2, &written);
if (written != 2)
rv = NS_ERROR_FAILURE;
}
return( rv);
}
// /////////////////////////////////////////////////////////////////////////
///
/// \brief Standard processing chain for single input buffer
///
/// Process buffer forms the heart of the framework to assist with implementing a
/// frame parser. This is the method that will call the protected virtual methods
/// of this class.
///
/// \return Frame parser status code, FrameParserNoError indicates success.
///
FrameParserStatus_t FrameParser_Base_c::ProcessBuffer(void)
{
FrameParserStatus_t Status;
//
// Handle discontinuity in input stream
//
if (CodedFrameParameters->StreamDiscontinuity)
{
PurgeQueuedPostDecodeParameterSettings();
FirstDecodeAfterInputJump = true;
SurplusDataInjected = CodedFrameParameters->FlushBeforeDiscontinuity;
ContinuousReverseJump = CodedFrameParameters->ContinuousReverseJump;
Player->CallInSequence(Stream, SequenceTypeImmediate, TIME_NOT_APPLICABLE, CodecFnOutputPartialDecodeBuffers);
}
//
// Do we have something to do with this buffer
//
if (BufferLength == 0)
{
//
// Check for a marker frame, identified by no flags and no data
//
if (!CodedFrameParameters->StreamDiscontinuity)
{
Buffer->IncrementReferenceCount(IdentifierProcessParseToDecode);
OutputRing->Insert((uintptr_t)Buffer);
}
return FrameParserNoError;
}
//
// Parse the headers
//
FrameToDecode = false;
Status = ReadHeaders();
if (Status != FrameParserNoError)
return Status;
//
// Do we still have something to do
//
if (!FrameToDecode)
return FrameParserNoError;
//
// Can we generate any queued index and pts values based on what we have seen
//
Status = ProcessQueuedPostDecodeParameterSettings();
if (Status != FrameParserNoError)
return Status;
//
// Calculate the display index/PTS values
//
Status = GeneratePostDecodeParameterSettings();
if (Status != FrameParserNoError)
return Status;
//
// Queue the frame for decode
//
Status = QueueFrameForDecode();
if (Status != FrameParserNoError)
return Status;
FirstDecodeAfterInputJump = false;
SurplusDataInjected = false;
ContinuousReverseJump = false;
//
return Status;
}
