blob: 074170a6e2c33b164a28cceeed2555aa4d48c9f4 [file] [log] [blame]
/*
* Copyright (C) 2018 The Android Open Source Project
*
* 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.
*/
#define LOG_TAG "libprotoutil"
#include <android/util/ProtoFileReader.h>
#include <cutils/log.h>
#include <cinttypes>
#include <type_traits>
#include <unistd.h>
namespace android {
namespace util {
/**
* Get the amount of data remaining in the file in fd, or -1 if the file size can't be measured.
* It's not the whole file, but this allows us to skip any preamble that might have already
* been passed over.
*/
ssize_t get_file_size(int fd) {
off_t current = lseek(fd, 0, SEEK_CUR);
if (current < 0) {
return -1;
}
off_t end = lseek(fd, 0, SEEK_END);
if (end < 0) {
return -1;
}
off_t err = lseek(fd, current, SEEK_SET);
if (err < 0) {
ALOGW("get_file_size could do SEEK_END but not SEEK_SET. We might have skipped data.");
return -1;
}
return (ssize_t)(end-current);
}
// =========================================================================
ProtoFileReader::ProtoFileReader(int fd)
:mFd(fd),
mStatus(NO_ERROR),
mSize(get_file_size(fd)),
mPos(0),
mOffset(0),
mChunkSize(sizeof(mBuffer)) {
}
ProtoFileReader::~ProtoFileReader() {
}
ssize_t
ProtoFileReader::size() const
{
return (ssize_t)mSize;
}
size_t
ProtoFileReader::bytesRead() const
{
return mPos;
}
uint8_t const*
ProtoFileReader::readBuffer()
{
return hasNext() ? mBuffer + mOffset : NULL;
}
size_t
ProtoFileReader::currentToRead()
{
return mMaxOffset - mOffset;
}
bool
ProtoFileReader::hasNext()
{
return ensure_data();
}
uint8_t
ProtoFileReader::next()
{
if (!ensure_data()) {
// Shouldn't get to here. Always call hasNext() before calling next().
return 0;
}
return mBuffer[mOffset++];
}
uint64_t
ProtoFileReader::readRawVarint()
{
uint64_t val = 0, shift = 0;
while (true) {
if (!hasNext()) {
ALOGW("readRawVarint() called without hasNext() called first.");
mStatus = NOT_ENOUGH_DATA;
return 0;
}
uint8_t byte = next();
val |= (INT64_C(0x7F) & byte) << shift;
if ((byte & 0x80) == 0) break;
shift += 7;
}
return val;
}
void
ProtoFileReader::move(size_t amt)
{
while (mStatus == NO_ERROR && amt > 0) {
if (!ensure_data()) {
return;
}
const size_t chunk = mMaxOffset - mOffset < amt ? amt : mMaxOffset - mOffset;
mOffset += chunk;
amt -= chunk;
}
}
status_t
ProtoFileReader::getError() const {
return mStatus;
}
bool
ProtoFileReader::ensure_data() {
if (mStatus != NO_ERROR) {
return false;
}
if (mOffset < mMaxOffset) {
return true;
}
ssize_t amt = TEMP_FAILURE_RETRY(read(mFd, mBuffer, mChunkSize));
if (amt == 0) {
return false;
} else if (amt < 0) {
mStatus = -errno;
return false;
} else {
mOffset = 0;
mMaxOffset = amt;
return true;
}
}
} // util
} // android