96 lines
3.3 KiB
C++
96 lines
3.3 KiB
C++
#include "util/fingerprint.hpp"
|
|
#include "util/exception.hpp"
|
|
#include "util/exception_utils.hpp"
|
|
#include "util/version.hpp"
|
|
|
|
#include <boost/assert.hpp>
|
|
#include <boost/crc.hpp>
|
|
|
|
#include <cstring>
|
|
|
|
#include <algorithm>
|
|
#include <string>
|
|
|
|
namespace osrm
|
|
{
|
|
namespace util
|
|
{
|
|
|
|
/**
|
|
* Constructs a valid fingerprint for the current (running) version of OSRM.
|
|
* This can be compared to one read from a file to determine whether the
|
|
* current code is compatible with the file being read.
|
|
*/
|
|
FingerPrint FingerPrint::GetValid()
|
|
{
|
|
FingerPrint fingerprint;
|
|
|
|
// 4 chars, 'O','S','R','N' - note the N instead of M, v1 of the fingerprint
|
|
// used M, so we add one and use N to indicate the newer fingerprint magic number.
|
|
// Bump this value if the fingerprint format ever changes.
|
|
fingerprint.magic_number = {{'O', 'S', 'R', 'N'}};
|
|
fingerprint.major_version = OSRM_VERSION_MAJOR;
|
|
fingerprint.minor_version = OSRM_VERSION_MINOR;
|
|
fingerprint.patch_version = OSRM_VERSION_PATCH;
|
|
fingerprint.checksum = fingerprint.CalculateChecksum();
|
|
|
|
return fingerprint;
|
|
}
|
|
|
|
int FingerPrint::GetMajorVersion() const { return major_version; }
|
|
int FingerPrint::GetMinorVersion() const { return minor_version; }
|
|
int FingerPrint::GetPatchVersion() const { return patch_version; }
|
|
|
|
/**
|
|
* Calculates the CRC8 of the FingerPrint struct, using all bytes except the
|
|
* final `checksum` field, which should be last in the struct (this function
|
|
* checks that it is)
|
|
*/
|
|
std::uint8_t FingerPrint::CalculateChecksum() const
|
|
{
|
|
// Verify that the checksum is a single byte (because we're returning an 8 bit checksum)
|
|
// This assumes that a byte == 8 bits, which is mostly true these days unless you're doing
|
|
// something really weird
|
|
static_assert(sizeof(checksum) == 1, "Checksum needs to be a single byte");
|
|
const constexpr int CRC_BITS = 8;
|
|
|
|
// This constant comes from
|
|
// https://en.wikipedia.org/wiki/Polynomial_representations_of_cyclic_redundancy_checks
|
|
// CRC-8-CCITT normal polynomial value.
|
|
const constexpr int CRC_POLYNOMIAL = 0x07;
|
|
boost::crc_optimal<CRC_BITS, CRC_POLYNOMIAL> crc8;
|
|
|
|
// Verify that the checksum is the last field, because we're going to CRC all the bytes
|
|
// leading up to it
|
|
static_assert(offsetof(FingerPrint, checksum) == sizeof(FingerPrint) - sizeof(checksum),
|
|
"Checksum must be the final field in the Fingerprint struct");
|
|
|
|
// Calculate checksum of all bytes except the checksum byte, which is at the end.
|
|
crc8.process_bytes(this, sizeof(FingerPrint) - sizeof(checksum));
|
|
|
|
return crc8.checksum();
|
|
}
|
|
|
|
/**
|
|
* Verifies that the fingerprint has the expected magic number, and the checksum is correct.
|
|
*/
|
|
bool FingerPrint::IsValid() const
|
|
{
|
|
// Note: == on std::array compares contents, which is what we want here.
|
|
return magic_number == GetValid().magic_number && checksum == CalculateChecksum();
|
|
}
|
|
|
|
/**
|
|
* Determines whether two fingerprints are data compatible.
|
|
* Our compatibility rules say that we maintain data compatibility for all PATCH versions.
|
|
* A difference in either the MAJOR or MINOR version fields means the data is considered
|
|
* incompatible.
|
|
*/
|
|
bool FingerPrint::IsDataCompatible(const FingerPrint &other) const
|
|
{
|
|
return IsValid() && other.major_version == major_version &&
|
|
other.minor_version == minor_version;
|
|
}
|
|
}
|
|
}
|