FileIo.cpp

Go to the documentation of this file.

/* Copyright (C) 2013 Wildfire Games.
 * This file is part of 0 A.D.
 *
 * 0 A.D. 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.
 *
 * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * endian-safe binary file IO helpers.
 */

#include "precompiled.h"

#include "FileIo.h"
#include "ps/CLogger.h"
#include "ps/Filesystem.h"
#include "lib/byte_order.h"

#pragma pack(push, 1)

struct FileHeader
{
    char magic[4];
    u32 version_le;
    u32 payloadSize_le; // = file size - sizeof(FileHeader)
};
cassert(sizeof(FileHeader) == 12);

#pragma pack(pop)


//-----------------------------------------------------------------------------
// CFilePacker

CFilePacker::CFilePacker(u32 version, const char magic[4])
{
    // put header in our data array.
    // (its payloadSize_le will be updated on every Pack*() call)
    FileHeader header;
    strncpy(header.magic, magic, 4);    // not 0-terminated => no _s
    write_le32(&header.version_le, version);
    write_le32(&header.payloadSize_le, 0);
    m_writeBuffer.Append(&header, sizeof(FileHeader));
}


CFilePacker::~CFilePacker()
{
}


void CFilePacker::Write(const VfsPath& filename)
{
    const size_t payloadSize = m_writeBuffer.Size() - sizeof(FileHeader);
    const u32 payloadSize_le = to_le32(u32_from_larger(payloadSize));
    m_writeBuffer.Overwrite(&payloadSize_le, sizeof(payloadSize_le), 0+offsetof(FileHeader, payloadSize_le));

    // write out all data (including header)
    const Status st = g_VFS->CreateFile(filename, m_writeBuffer.Data(), m_writeBuffer.Size());
    if (st < 0)
    {
        LOGERROR(L"Failed to write file '%ls' with status '%lld'", filename.string().c_str(), (long long)st);
        throw PSERROR_File_WriteFailed();
    }
}


void CFilePacker::PackRaw(const void* rawData, size_t rawSize)
{
    m_writeBuffer.Append(rawData, rawSize);
}

void CFilePacker::PackSize(size_t value)
{
    const u32 value_le32 = to_le32(u32_from_larger(value));
    PackRaw(&value_le32, sizeof(value_le32));
}

void CFilePacker::PackString(const CStr& str)
{
    const size_t length = str.length();
    PackSize(length);
    PackRaw(str.c_str(), length);
}


//-----------------------------------------------------------------------------
// CFileUnpacker

CFileUnpacker::CFileUnpacker()
    : m_bufSize(0), m_unpackPos(0), m_version(0)
{
}


CFileUnpacker::~CFileUnpacker()
{
}


void CFileUnpacker::Read(const VfsPath& filename, const char magic[4])
{
    // if the file doesn't exist, LoadFile would raise an annoying error dialog.
    // since this (unfortunately) happens so often, we perform a separate
    // check and "just" raise an exception for the caller to handle.
    // (this is nicer than somehow squelching internal VFS error reporting)
    if(!VfsFileExists(filename))
        throw PSERROR_File_OpenFailed();

    // load the whole thing into memory
    if(g_VFS->LoadFile(filename, m_buf, m_bufSize) < 0)
        throw PSERROR_File_OpenFailed();

    // make sure we read enough for the header
    if(m_bufSize < sizeof(FileHeader))
    {
        m_buf.reset();
        m_bufSize = 0;
        throw PSERROR_File_ReadFailed();
    }

    // extract data from header
    FileHeader* header = (FileHeader*)m_buf.get();
    m_version = read_le32(&header->version_le);
    const size_t payloadSize = (size_t)read_le32(&header->payloadSize_le);

    // check we've got the right kind of file
    // .. and that we read exactly headerSize+payloadSize
    if(strncmp(header->magic, magic, 4) != 0 || m_bufSize != sizeof(FileHeader)+payloadSize)
    {
        m_buf.reset();
        m_bufSize = 0;
        throw PSERROR_File_InvalidType();
    }

    m_unpackPos = sizeof(FileHeader);
}


void CFileUnpacker::UnpackRaw(void* rawData, size_t rawDataSize)
{
    // fail if reading past end of stream
    if (m_unpackPos+rawDataSize > m_bufSize)
        throw PSERROR_File_UnexpectedEOF();

    void* src = m_buf.get() + m_unpackPos;
    memcpy(rawData, src, rawDataSize);
    m_unpackPos += rawDataSize;
}


size_t CFileUnpacker::UnpackSize()
{
    u32 value_le32;
    UnpackRaw(&value_le32, sizeof(value_le32));
    return (size_t)to_le32(value_le32);
}


void CFileUnpacker::UnpackString(CStr8& result)
{
    const size_t length = UnpackSize();

    // fail if reading past end of stream
    if (m_unpackPos+length > m_bufSize)
        throw PSERROR_File_UnexpectedEOF();

    result = CStr((char*)m_buf.get()+m_unpackPos, length);
    m_unpackPos += length;
}