blob: 02f7f317eef281b9520386cac2f9b202978cb2a0 [file] [log] [blame]
// Copyright 2008 Google Inc.
// Author: Lincoln Smith
//
// 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.
#include <config.h>
#include "headerparser.h"
#include "logging.h"
#include "varint_bigendian.h"
#include "vcdiff_defs.h"
namespace open_vcdiff {
// *** Methods for ParseableChunk
void ParseableChunk::Advance(size_t number_of_bytes) {
if (number_of_bytes > UnparsedSize()) {
LOG(DFATAL) << "Internal error: position advanced by " << number_of_bytes
<< " bytes, current unparsed size " << UnparsedSize()
<< LOG_ENDL;
position_ = end_;
return;
}
position_ += number_of_bytes;
}
void ParseableChunk::SetPosition(const char* position) {
if (position < start_) {
LOG(DFATAL) << "Internal error: new data position " << position
<< " is beyond start of data " << start_ << LOG_ENDL;
position_ = start_;
return;
}
if (position > end_) {
LOG(DFATAL) << "Internal error: new data position " << position
<< " is beyond end of data " << end_ << LOG_ENDL;
position_ = end_;
return;
}
position_ = position;
}
void ParseableChunk::FinishExcept(size_t number_of_bytes) {
if (number_of_bytes > UnparsedSize()) {
LOG(DFATAL) << "Internal error: specified number of remaining bytes "
<< number_of_bytes << " is greater than unparsed data size "
<< UnparsedSize() << LOG_ENDL;
Finish();
return;
}
position_ = end_ - number_of_bytes;
}
// *** Methods for VCDiffHeaderParser
VCDiffHeaderParser::VCDiffHeaderParser(const char* header_start,
const char* data_end)
: parseable_chunk_(header_start, data_end - header_start),
return_code_(RESULT_SUCCESS),
delta_encoding_length_(0),
delta_encoding_start_(NULL) { }
bool VCDiffHeaderParser::ParseByte(unsigned char* value) {
if (RESULT_SUCCESS != return_code_) {
return false;
}
if (parseable_chunk_.Empty()) {
return_code_ = RESULT_END_OF_DATA;
return false;
}
*value = static_cast<unsigned char>(*parseable_chunk_.UnparsedData());
parseable_chunk_.Advance(1);
return true;
}
bool VCDiffHeaderParser::ParseInt32(const char* variable_description,
int32_t* value) {
if (RESULT_SUCCESS != return_code_) {
return false;
}
int32_t parsed_value =
VarintBE<int32_t>::Parse(parseable_chunk_.End(),
parseable_chunk_.UnparsedDataAddr());
switch (parsed_value) {
case RESULT_ERROR:
LOG(ERROR) << "Expected " << variable_description
<< "; found invalid variable-length integer" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
case RESULT_END_OF_DATA:
return_code_ = RESULT_END_OF_DATA;
return false;
default:
*value = parsed_value;
return true;
}
}
// When an unsigned 32-bit integer is expected, parse a signed 64-bit value
// instead, then check the value limit. The uint32_t type can't be parsed
// directly because two negative values are given special meanings (RESULT_ERROR
// and RESULT_END_OF_DATA) and could not be expressed in an unsigned format.
bool VCDiffHeaderParser::ParseUInt32(const char* variable_description,
uint32_t* value) {
if (RESULT_SUCCESS != return_code_) {
return false;
}
int64_t parsed_value =
VarintBE<int64_t>::Parse(parseable_chunk_.End(),
parseable_chunk_.UnparsedDataAddr());
switch (parsed_value) {
case RESULT_ERROR:
LOG(ERROR) << "Expected " << variable_description
<< "; found invalid variable-length integer" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
case RESULT_END_OF_DATA:
return_code_ = RESULT_END_OF_DATA;
return false;
default:
if (parsed_value > 0xFFFFFFFF) {
LOG(ERROR) << "Value of " << variable_description << "(" << parsed_value
<< ") is too large for unsigned 32-bit integer" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
*value = static_cast<uint32_t>(parsed_value);
return true;
}
}
// A VCDChecksum represents an unsigned 32-bit value returned by adler32(),
// but isn't a uint32_t.
bool VCDiffHeaderParser::ParseChecksum(const char* variable_description,
VCDChecksum* value) {
uint32_t parsed_value = 0;
if (!ParseUInt32(variable_description, &parsed_value)) {
return false;
}
*value = static_cast<VCDChecksum>(parsed_value);
return true;
}
bool VCDiffHeaderParser::ParseSize(const char* variable_description,
size_t* value) {
int32_t parsed_value = 0;
if (!ParseInt32(variable_description, &parsed_value)) {
return false;
}
*value = static_cast<size_t>(parsed_value);
return true;
}
bool VCDiffHeaderParser::ParseSourceSegmentLengthAndPosition(
size_t from_size,
const char* from_boundary_name,
const char* from_name,
size_t* source_segment_length,
size_t* source_segment_position) {
// Verify the length and position values
if (!ParseSize("source segment length", source_segment_length)) {
return false;
}
// Guard against overflow by checking source length first
if (*source_segment_length > from_size) {
LOG(ERROR) << "Source segment length (" << *source_segment_length
<< ") is larger than " << from_name << " (" << from_size
<< ")" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
if (!ParseSize("source segment position", source_segment_position)) {
return false;
}
if ((*source_segment_position >= from_size) &&
(*source_segment_length > 0)) {
LOG(ERROR) << "Source segment position (" << *source_segment_position
<< ") is past " << from_boundary_name
<< " (" << from_size << ")" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
const size_t source_segment_end = *source_segment_position +
*source_segment_length;
if (source_segment_end > from_size) {
LOG(ERROR) << "Source segment end position (" << source_segment_end
<< ") is past " << from_boundary_name
<< " (" << from_size << ")" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
return true;
}
bool VCDiffHeaderParser::ParseWinIndicatorAndSourceSegment(
size_t dictionary_size,
size_t decoded_target_size,
bool allow_vcd_target,
unsigned char* win_indicator,
size_t* source_segment_length,
size_t* source_segment_position) {
if (!ParseByte(win_indicator)) {
return false;
}
unsigned char source_target_flags =
*win_indicator & (VCD_SOURCE | VCD_TARGET);
switch (source_target_flags) {
case VCD_SOURCE:
return ParseSourceSegmentLengthAndPosition(dictionary_size,
"end of dictionary",
"dictionary",
source_segment_length,
source_segment_position);
case VCD_TARGET:
if (!allow_vcd_target) {
LOG(ERROR) << "Delta file contains VCD_TARGET flag, which is not "
"allowed by current decoder settings" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
return ParseSourceSegmentLengthAndPosition(decoded_target_size,
"current target position",
"target file",
source_segment_length,
source_segment_position);
case VCD_SOURCE | VCD_TARGET:
LOG(ERROR) << "Win_Indicator must not have both VCD_SOURCE"
" and VCD_TARGET set" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
default:
return true;
}
}
bool VCDiffHeaderParser::ParseWindowLengths(size_t* target_window_length) {
if (delta_encoding_start_) {
LOG(DFATAL) << "Internal error: VCDiffHeaderParser::ParseWindowLengths "
"was called twice for the same delta window" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
if (!ParseSize("length of the delta encoding", &delta_encoding_length_)) {
return false;
}
delta_encoding_start_ = UnparsedData();
if (!ParseSize("size of the target window", target_window_length)) {
return false;
}
return true;
}
const char* VCDiffHeaderParser::EndOfDeltaWindow() const {
if (!delta_encoding_start_) {
LOG(DFATAL) << "Internal error: VCDiffHeaderParser::GetDeltaWindowEnd "
"was called before ParseWindowLengths" << LOG_ENDL;
return NULL;
}
return delta_encoding_start_ + delta_encoding_length_;
}
bool VCDiffHeaderParser::ParseDeltaIndicator() {
unsigned char delta_indicator;
if (!ParseByte(&delta_indicator)) {
return false;
}
if (delta_indicator & (VCD_DATACOMP | VCD_INSTCOMP | VCD_ADDRCOMP)) {
LOG(ERROR) << "Secondary compression of delta file sections "
"is not supported" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
return true;
}
bool VCDiffHeaderParser::ParseSectionLengths(
bool has_checksum,
size_t* add_and_run_data_length,
size_t* instructions_and_sizes_length,
size_t* addresses_length,
VCDChecksum* checksum) {
ParseSize("length of data for ADDs and RUNs", add_and_run_data_length);
ParseSize("length of instructions section", instructions_and_sizes_length);
ParseSize("length of addresses for COPYs", addresses_length);
if (has_checksum) {
ParseChecksum("Adler32 checksum value", checksum);
}
if (RESULT_SUCCESS != return_code_) {
return false;
}
if (!delta_encoding_start_) {
LOG(DFATAL) << "Internal error: VCDiffHeaderParser::ParseSectionLengths "
"was called before ParseWindowLengths" << LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
const size_t delta_encoding_header_length =
UnparsedData() - delta_encoding_start_;
if (delta_encoding_length_ !=
(delta_encoding_header_length +
*add_and_run_data_length +
*instructions_and_sizes_length +
*addresses_length)) {
LOG(ERROR) << "The length of the delta encoding does not match "
"the size of the header plus the sizes of the data sections"
<< LOG_ENDL;
return_code_ = RESULT_ERROR;
return false;
}
return true;
}
} // namespace open_vcdiff