CRCChecker.cpp

Go to the documentation of this file.

// ======================================================================
// \title  CRCChecker.cpp
// \author ortega
// \brief  cpp file for a crc32 checker
//
// \copyright
// Copyright 2009-2020, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
// ======================================================================

#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Types/Assert.hpp>
#include <Fw/Types/FileNameString.hpp>
#include <Fw/Types/SerialBuffer.hpp>
#include <Os/File.hpp>
#include <Os/FileSystem.hpp>
#include <Utils/CRCChecker.hpp>
#include <Utils/Hash/Hash.hpp>

namespace Utils {
crc_stat_t create_checksum_file(const char* const fname) {
    FW_ASSERT(fname != nullptr);

    FwSizeType i;
    FwSizeType blocks;
    FwSizeType remaining_bytes;
    FwSizeType filesize;
    Os::File f;
    Os::FileSystem::Status fs_stat;
    Os::File::Status stat;
    Utils::Hash hash;
    U32 checksum;
    FwSizeType bytes_to_read;
    FwSizeType bytes_to_write;
    Fw::FileNameString hashFilename;
    U8 block_data[CRC_FILE_READ_BLOCK];

    fs_stat = Os::FileSystem::getFileSize(fname, filesize);
    if (fs_stat != Os::FileSystem::OP_OK) {
        return FAILED_FILE_SIZE;
    }

    // Open file
    stat = f.open(fname, Os::File::OPEN_READ);
    if (stat != Os::File::OP_OK) {
        return FAILED_FILE_OPEN;
    }

    // Read file
    bytes_to_read = CRC_FILE_READ_BLOCK;
    blocks = filesize / CRC_FILE_READ_BLOCK;
    for (i = 0; i < blocks; i++) {
        stat = f.read(block_data, bytes_to_read);
        if (stat != Os::File::OP_OK || bytes_to_read != CRC_FILE_READ_BLOCK) {
            f.close();
            return FAILED_FILE_READ;
        }

        hash.update(block_data, bytes_to_read);
    }

    remaining_bytes = filesize % CRC_FILE_READ_BLOCK;
    bytes_to_read = remaining_bytes;
    if (remaining_bytes > 0) {
        stat = f.read(block_data, bytes_to_read);
        if (stat != Os::File::OP_OK || bytes_to_read != remaining_bytes) {
            f.close();
            return FAILED_FILE_READ;
        }

        hash.update(block_data, remaining_bytes);
    }

    // close file
    f.close();

    // generate checksum
    hash.finalize(checksum);

    // open checksum file. The filename is caller-supplied input: an overlong name is a reportable
    // failure, not a coding error, so it must not assert.
    Fw::FormatStatus formatStatus = hashFilename.format("%s%s", fname, HASH_EXTENSION_STRING);
    if (formatStatus != Fw::FormatStatus::SUCCESS) {
        return FAILED_FILE_NAME_TOO_LONG;
    }

    stat = f.open(hashFilename.toChar(), Os::File::OPEN_WRITE);
    if (stat != Os::File::OP_OK) {
        return FAILED_FILE_CRC_OPEN;
    }

    // Write checksum file. Serialize the value rather than writing the raw U32 bytes so that the
    // file contents do not depend on the endianness of the processor.
    U8 checksum_data[sizeof(checksum)] = {};
    Fw::SerialBuffer checksum_buffer(checksum_data, sizeof(checksum_data));
    Fw::SerializeStatus ser_stat = checksum_buffer.serializeFrom(checksum);
    FW_ASSERT(Fw::FW_SERIALIZE_OK == ser_stat, static_cast<FwAssertArgType>(ser_stat));

    bytes_to_write = checksum_buffer.getSize();
    stat = f.write(checksum_buffer.getBuffAddr(), bytes_to_write);
    if (stat != Os::File::OP_OK || sizeof(checksum) != bytes_to_write) {
        f.close();
        return FAILED_FILE_CRC_WRITE;
    }

    // close checksum file
    f.close();

    return PASSED_FILE_CRC_WRITE;
}

crc_stat_t read_crc32_from_file(const char* const fname, U32& checksum_from_file) {
    Os::File f;
    Os::File::Status stat;
    Fw::FileNameString hashFilename;
    FW_ASSERT(fname != nullptr);
    // open checksum file. See create_checksum_file(): overlong names are reported, not asserted.
    Fw::FormatStatus formatStatus = hashFilename.format("%s%s", fname, HASH_EXTENSION_STRING);
    if (formatStatus != Fw::FormatStatus::SUCCESS) {
        return FAILED_FILE_NAME_TOO_LONG;
    }

    stat = f.open(hashFilename.toChar(), Os::File::OPEN_READ);
    if (stat != Os::File::OP_OK) {
        return FAILED_FILE_CRC_OPEN;
    }

    // Read checksum file
    U8 checksum_data[sizeof(checksum_from_file)] = {};
    FwSizeType checksum_from_file_size = static_cast<FwSizeType>(sizeof(checksum_from_file));
    stat = f.read(checksum_data, checksum_from_file_size);
    if (stat != Os::File::OP_OK || checksum_from_file_size != sizeof(checksum_from_file)) {
        f.close();
        return FAILED_FILE_CRC_READ;
    }

    // Deserialize the value to match the serialized form written by create_checksum_file
    Fw::SerialBuffer checksum_buffer(checksum_data, sizeof(checksum_data));
    checksum_buffer.fill();
    Fw::SerializeStatus ser_stat = checksum_buffer.deserializeTo(checksum_from_file);
    FW_ASSERT(Fw::FW_SERIALIZE_OK == ser_stat, static_cast<FwAssertArgType>(ser_stat));

    // close checksum file
    f.close();
    return PASSED_FILE_CRC_CHECK;
}

crc_stat_t verify_checksum(const char* const fname, U32& expected, U32& actual) {
    FW_ASSERT(fname != nullptr);

    FwSizeType i;
    FwSizeType blocks;
    FwSizeType remaining_bytes;
    FwSizeType filesize;
    Os::File f;
    Os::FileSystem::Status fs_stat;
    Os::File::Status stat;
    Utils::Hash hash;
    U32 checksum;
    U32 checksum_from_file;
    FwSizeType bytes_to_read;
    U8 block_data[CRC_FILE_READ_BLOCK];

    fs_stat = Os::FileSystem::getFileSize(fname, filesize);
    if (fs_stat != Os::FileSystem::OP_OK) {
        return FAILED_FILE_SIZE;
    }

    // Open file
    stat = f.open(fname, Os::File::OPEN_READ);
    if (stat != Os::File::OP_OK) {
        return FAILED_FILE_OPEN;
    }

    // Read file
    bytes_to_read = CRC_FILE_READ_BLOCK;
    blocks = filesize / CRC_FILE_READ_BLOCK;
    for (i = 0; i < blocks; i++) {
        stat = f.read(block_data, bytes_to_read);
        if (stat != Os::File::OP_OK || bytes_to_read != CRC_FILE_READ_BLOCK) {
            f.close();
            return FAILED_FILE_READ;
        }

        hash.update(block_data, static_cast<FwSizeType>(bytes_to_read));
    }

    remaining_bytes = filesize % CRC_FILE_READ_BLOCK;
    bytes_to_read = remaining_bytes;
    if (remaining_bytes > 0) {
        stat = f.read(block_data, bytes_to_read);
        if (stat != Os::File::OP_OK || bytes_to_read != remaining_bytes) {
            f.close();
            return FAILED_FILE_READ;
        }

        hash.update(block_data, remaining_bytes);
    }

    // close file
    f.close();
    // generate checksum
    hash.finalize(checksum);

    crc_stat_t crcstat = read_crc32_from_file(fname, checksum_from_file);
    if (crcstat != PASSED_FILE_CRC_CHECK) {
        return crcstat;
    }

    // compare checksums
    if (checksum != checksum_from_file) {
        expected = checksum_from_file;
        actual = checksum;
        return FAILED_FILE_CRC_CHECK;
    }

    expected = checksum_from_file;
    actual = checksum;
    return PASSED_FILE_CRC_CHECK;
}

}  // namespace Utils