/*
* Copyright (c) 2020 Red Hat, 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* $Id: //eng/vdo-releases/aluminum/src/c++/vdo/base/header.c#5 $
*/
#include "header.h"
#include "logger.h"
#include "permassert.h"
#include "statusCodes.h"
/**********************************************************************/
int validateVersion(VersionNumber expectedVersion,
VersionNumber actualVersion,
const char *componentName)
{
if (!areSameVersion(expectedVersion, actualVersion)) {
return logErrorWithStringError(VDO_UNSUPPORTED_VERSION,
"%s version mismatch,"
" expected %d.%d, got %d.%d",
componentName,
expectedVersion.majorVersion,
expectedVersion.minorVersion,
actualVersion.majorVersion,
actualVersion.minorVersion);
}
return VDO_SUCCESS;
}
/**********************************************************************/
int validateHeader(const Header *expectedHeader,
const Header *actualHeader,
bool exactSize,
const char *componentName)
{
if (expectedHeader->id != actualHeader->id) {
return logErrorWithStringError(VDO_INCORRECT_COMPONENT,
"%s ID mismatch, expected %d, got %d",
componentName,
expectedHeader->id,
actualHeader->id);
}
int result = validateVersion(expectedHeader->version,
actualHeader->version,
componentName);
if (result != VDO_SUCCESS) {
return result;
}
if ((expectedHeader->size > actualHeader->size)
|| (exactSize && (expectedHeader->size < actualHeader->size))) {
return logErrorWithStringError(VDO_UNSUPPORTED_VERSION,
"%s size mismatch, expected %zu, got %zu",
componentName,
expectedHeader->size,
actualHeader->size);
}
return VDO_SUCCESS;
}
/**********************************************************************/
int encodeHeader(const Header *header, Buffer *buffer)
{
if (!ensureAvailableSpace(buffer, ENCODED_HEADER_SIZE)) {
return UDS_BUFFER_ERROR;
}
int result = putUInt32LEIntoBuffer(buffer, header->id);
if (result != UDS_SUCCESS) {
return result;
}
result = encodeVersionNumber(header->version, buffer);
if (result != UDS_SUCCESS) {
return result;
}
return putUInt64LEIntoBuffer(buffer, header->size);
}
/**********************************************************************/
int encodeVersionNumber(VersionNumber version, Buffer *buffer)
{
PackedVersionNumber packed = packVersionNumber(version);
return putBytes(buffer, sizeof(packed), &packed);
}
/**********************************************************************/
int decodeHeader(Buffer *buffer, Header *header)
{
ComponentID id;
int result = getUInt32LEFromBuffer(buffer, &id);
if (result != UDS_SUCCESS) {
return result;
}
VersionNumber version;
result = decodeVersionNumber(buffer, &version);
if (result != UDS_SUCCESS) {
return result;
}
uint64_t size;
result = getUInt64LEFromBuffer(buffer, &size);
if (result != UDS_SUCCESS) {
return result;
}
*header = (Header) {
.id = id,
.version = version,
.size = size,
};
return UDS_SUCCESS;
}
/**********************************************************************/
int decodeVersionNumber(Buffer *buffer, VersionNumber *version)
{
PackedVersionNumber packed;
int result = getBytesFromBuffer(buffer, sizeof(packed), &packed);
if (result != UDS_SUCCESS) {
return result;
}
*version = unpackVersionNumber(packed);
return UDS_SUCCESS;
}