bool XMLReader::Read() { if (mWhitespaceHandling == kWhitespaceHandlingNone) { while (ReadInternal()) { if (mNodeType != kWhitespace) { return true; } } return false; } else { return ReadInternal(); } }
virtual bool Read(uint8* Destination, int64 BytesToRead) override { #if MANAGE_FILE_HANDLES if( IsManaged() ) { ActivateSlot(); int64 BytesRead = ReadInternal(Destination, BytesToRead); FileOffset += BytesRead; return BytesRead == BytesToRead; } else #endif { return ReadInternal(Destination, BytesToRead) == BytesToRead; } }
bool DirectoryBlobReader::Read(u64 offset, u64 length, u8* buffer) { // TODO: We don't handle raw access to the encrypted area of Wii discs correctly. const std::set<DiscContent>& contents = m_is_wii ? m_nonpartition_contents : m_gamecube_pseudopartition.GetContents(); return ReadInternal(offset, length, buffer, contents); }
nsresult SourceBufferResource::Read(char* aBuffer, uint32_t aCount, uint32_t* aBytes) { SBR_DEBUGV("Read(aBuffer=%p, aCount=%u, aBytes=%p)", aBuffer, aCount, aBytes); ReentrantMonitorAutoEnter mon(mMonitor); return ReadInternal(aBuffer, aCount, aBytes, /* aMayBlock = */ true); }
byte idZeroRunLengthCompressor::ReadByte() { // See if we need to possibly read more data if ( zeroCount == 0 ) { int value = ReadInternal(); if ( value == -1 ) { assert( 0 ); } if ( value != 0 ) { return (byte)value; // Return non zero values immediately } // Read the number of zeroes zeroCount = ReadInternal(); } assert( zeroCount > 0 ); zeroCount--; return 0; }
bool DirectoryBlobReader::ReadWiiDecrypted(u64 offset, u64 size, u8* buffer, u64 partition_offset) { if (!m_is_wii) return false; auto it = m_partitions.find(partition_offset); if (it == m_partitions.end()) return false; return ReadInternal(offset, size, buffer, it->second.GetContents()); }
nsresult SourceBufferResource::ReadAtInternal(int64_t aOffset, char* aBuffer, uint32_t aCount, uint32_t* aBytes, bool aMayBlock) { mMonitor.AssertCurrentThreadIn(); nsresult rv = SeekInternal(aOffset); if (NS_FAILED(rv)) { return rv; } return ReadInternal(aBuffer, aCount, aBytes, aMayBlock); }
// Sync methods int64_t StdStreamAdapter::Read(uint8_t *pbBuffer, int64_t cbBuffer) { if (m_iBackingStream.get() == nullptr) { // unavailable throw exceptions::RMSCryptoIOException( exceptions::RMSCryptoIOException::OperationUnavailable, "Operation unavailable!"); } lock_guard<mutex> locker(*m_locker); return ReadInternal(pbBuffer, cbBuffer); }
int RageFileObjInflate::SeekInternal( int iPos ) { /* Optimization: if offset is the end of the file, it's a lseek(0,SEEK_END). Don't * decode anything. */ if( iPos >= m_iUncompressedSize ) { m_iFilePos = m_iUncompressedSize; m_pFile->Seek( m_pFile->GetFileSize() ); decomp_buf_ptr = decomp_buf; decomp_buf_avail = 0; inflateReset( m_pInflate ); return m_iUncompressedSize; } if( iPos < m_iFilePos ) { inflateReset( m_pInflate ); decomp_buf_ptr = decomp_buf; decomp_buf_avail = 0; m_pFile->Seek( 0 ); m_iFilePos = 0; } int iOffset = iPos - m_iFilePos; /* Can this be optimized? */ char buf[1024*4]; while( iOffset ) { int got = ReadInternal( buf, min( (int) sizeof(buf), iOffset ) ); if( got == -1 ) return -1; if( got == 0 ) break; iOffset -= got; } return m_iFilePos; }
FileInputStream::SizeType FileInputStream::read(void* destBuffer, SizeType maxBytesToRead) { if (!OpenedOk()) { LOG(Warning) << "Trying to read from an invalid stream."; NOTREACHED() << "Do not read from an invalid stream."; return 0; } DCHECK(destBuffer != NULL && maxBytesToRead >= 0); if (m_needToSeek) { if (detail::setFileInputStreamPosition(m_handle, m_currentPosition) < 0) return 0; m_needToSeek = false; } size_t num = ReadInternal(destBuffer, static_cast<size_t>(maxBytesToRead)); m_currentPosition += num; return static_cast<SizeType>(num); }
uint8 ReadStream::ReadByte() { uint8 val; ReadInternal(&val, sizeof(val)); return val; }
ssize_t TextStream::Read (char *buf, size_t n) { size_t inleft = buflen; char *inbuf = bufptr; char *outbuf = buf; size_t outleft = n; ssize_t nread; size_t r; do { if (cd != (GIConv) -1) { if (g_iconv (cd, &inbuf, &inleft, &outbuf, &outleft) == (size_t) -1) { switch (errno) { case E2BIG: // not enough space available in the output buffer goto out; case EINVAL: // incomplete multibyte character sequence goto out; case EILSEQ: // illegal multibyte sequence return -1; default: // unknown error, fail return -1; } } } else { r = MIN (inleft, outleft); memcpy (outbuf, inbuf, r); outleft -= r; outbuf += r; inleft -= r; inbuf += r; } if (outleft == 0 || eof) break; // buffer more data if (inleft > 0) memmove (buffer, inbuf, inleft); inbuf = buffer + inleft; if ((nread = ReadInternal (inbuf, sizeof (buffer) - inleft)) <= 0) { eof = true; break; } inleft += nread; inbuf = buffer; } while (true); if (eof && cd != (GIConv) -1) g_iconv (cd, NULL, NULL, &outbuf, &outleft); out: buflen = inleft; bufptr = inbuf; return (outbuf - buf); }
bool TextStream::ReadBOM (bool force) { Encoding encoding = UNKNOWN; gunichar2 bom; ssize_t nread; // prefetch the first chunk of data in order to determine encoding if ((nread = ReadInternal (buffer, sizeof (buffer))) == -1) { Close (); return false; } bufptr = buffer; buflen = nread; if (nread >= 2) { memcpy (&bom, buffer, 2); switch (bom) { case ANTIBOM: encoding = UTF16_BE; buflen -= 2; bufptr += 2; break; case BOM: encoding = UTF16_LE; buflen -= 2; bufptr += 2; break; case 0: if (nread >= 4) { memcpy (&bom, buffer + 2, 2); if (bom == ANTIBOM) { encoding = UTF32_BE; buflen -= 4; bufptr += 4; } else if (bom == BOM) { encoding = UTF32_LE; buflen -= 4; bufptr += 4; } } break; default: encoding = UTF8; break; } } else { // assume utf-8 encoding = UTF8; } if (encoding == UNKNOWN) { if (!force) { Close (); return false; } encoding = UTF8; } if (encoding != UTF8 && (cd = g_iconv_open ("UTF-8", encoding_names[encoding])) == (GIConv) -1) { Close (); return false; } eof = false; return true; }
unsigned File::Read(void* dest, unsigned size) { if (!IsOpen()) { // If file not open, do not log the error further here to prevent spamming the stderr stream return 0; } if (mode_ == FILE_WRITE) { ATOMIC_LOGERROR("File not opened for reading"); return 0; } if (size + position_ > size_) size = size_ - position_; if (!size) return 0; #ifdef __ANDROID__ if (assetHandle_ && !compressed_) { // If not using a compressed package file, buffer file reads on Android for better performance if (!readBuffer_) { readBuffer_ = new unsigned char[READ_BUFFER_SIZE]; readBufferOffset_ = 0; readBufferSize_ = 0; } unsigned sizeLeft = size; unsigned char* destPtr = (unsigned char*)dest; while (sizeLeft) { if (readBufferOffset_ >= readBufferSize_) { readBufferSize_ = Min(size_ - position_, READ_BUFFER_SIZE); readBufferOffset_ = 0; ReadInternal(readBuffer_.Get(), readBufferSize_); } unsigned copySize = Min((readBufferSize_ - readBufferOffset_), sizeLeft); memcpy(destPtr, readBuffer_.Get() + readBufferOffset_, copySize); destPtr += copySize; sizeLeft -= copySize; readBufferOffset_ += copySize; position_ += copySize; } return size; } #endif if (compressed_) { unsigned sizeLeft = size; unsigned char* destPtr = (unsigned char*)dest; while (sizeLeft) { if (!readBuffer_ || readBufferOffset_ >= readBufferSize_) { unsigned char blockHeaderBytes[4]; ReadInternal(blockHeaderBytes, sizeof blockHeaderBytes); MemoryBuffer blockHeader(&blockHeaderBytes[0], sizeof blockHeaderBytes); unsigned unpackedSize = blockHeader.ReadUShort(); unsigned packedSize = blockHeader.ReadUShort(); if (!readBuffer_) { readBuffer_ = new unsigned char[unpackedSize]; inputBuffer_ = new unsigned char[LZ4_compressBound(unpackedSize)]; } /// \todo Handle errors ReadInternal(inputBuffer_.Get(), packedSize); LZ4_decompress_fast((const char*)inputBuffer_.Get(), (char*)readBuffer_.Get(), unpackedSize); readBufferSize_ = unpackedSize; readBufferOffset_ = 0; } unsigned copySize = Min((readBufferSize_ - readBufferOffset_), sizeLeft); memcpy(destPtr, readBuffer_.Get() + readBufferOffset_, copySize); destPtr += copySize; sizeLeft -= copySize; readBufferOffset_ += copySize; position_ += copySize; } return size; } // Need to reassign the position due to internal buffering when transitioning from writing to reading if (readSyncNeeded_) { SeekInternal(position_ + offset_); readSyncNeeded_ = false; } if (!ReadInternal(dest, size)) { // Return to the position where the read began SeekInternal(position_ + offset_); ATOMIC_LOGERROR("Error while reading from file " + GetName()); return 0; } writeSyncNeeded_ = true; position_ += size; return size; }
SISPLUGIN_EXPORT long SISPluginReadCard( unsigned long ulVersion, /**< In: SW-version of the middleware */ void *pPCSCfunctions, /**< In: pointer to a tPCSCfunctions struct */ const char *csReaderName, /**< In: the reader name as returned by SCardListReaders() */ SCARDHANDLE *phCard, /**< In: handle to the card if it was succesful or 0 when it failed */ unsigned char *pucData, /**< Out: returns the 404 bytes of the SIS-card */ unsigned long ulReserved, /**< In: reserved for future extensions */ void *pReserved /**< In/Out: reserved for future extensions */ ) { eIDMW::MWLOG(eIDMW::LEV_DEBUG, eIDMW::MOD_SIS, L"SISPluginReadCard(%d) called", *phCard); SCARD_IO_REQUEST ioSendPci, ioRecvPci; tPCSCfunctions *pPCSCfuncs = (tPCSCfunctions *) pPCSCfunctions; DWORD ulProto = SCARD_PROTOCOL_T0; long lRet = -11111; if (ulVersion/100 != 1) return lRet; //only version 1.xx supported memset(pucData, 0, 404); #ifdef __APPLE__ if (0 != *phCard) { pPCSCfuncs->pCardDisconnect(*phCard, SCARD_RESET_CARD); *phCard = 0; } #endif if (0 == *phCard) { lRet = ConnectInSyncMode(pPCSCfuncs, csReaderName, phCard, &ulProto); eIDMW::MWLOG(eIDMW::LEV_DEBUG, eIDMW::MOD_SIS, L" ConnectInSyncMode return = 0x%0x",lRet); if (SCARD_S_SUCCESS != lRet) return lRet; } ioSendPci.cbPciLength = sizeof(SCARD_IO_REQUEST); ioRecvPci.cbPciLength = sizeof(SCARD_IO_REQUEST); ioSendPci.dwProtocol = ulProto; ioRecvPci.dwProtocol = ulProto; lRet = pPCSCfuncs->pCardBeginTransaction(*phCard); if (SCARD_S_SUCCESS == lRet) { lRet = ReadInternal(pPCSCfuncs, *phCard, &ioSendPci, &ioRecvPci, 0, 404, pucData); eIDMW::MWLOG(eIDMW::LEV_DEBUG, eIDMW::MOD_SIS, L" ReadInternal return = 0x%0x",lRet); BackToAsyncMode(pPCSCfuncs, csReaderName, phCard); pPCSCfuncs->pCardEndTransaction(*phCard, SCARD_LEAVE_CARD); } // Check if it's a SIS card if (0 == lRet && (0xA0 != pucData[21] || 0x00 != pucData[22] || 0x00 != pucData[23] || 0x00 != pucData[24] || 0x33 != pucData[25])) { lRet = SCARD_E_CARD_UNSUPPORTED; } return lRet; }