source/ps/FileIo.cpp

   1 /* Copyright (C) 2019 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /*
  19  * endian-safe binary file IO helpers.
  20  */
  21
  22 #include "precompiled.h"
  23
  24 #include "FileIo.h"
  25 #include "ps/CLogger.h"
  26 #include "ps/CStr.h"
  27 #include "ps/Filesystem.h"
  28 #include "lib/byte_order.h"
  29
  30 #pragma pack(push, 1)
  31
  32 struct FileHeader
  33 {
  34         char magic[4];
  35         u32 version_le;
  36         u32 payloadSize_le;     // = file size - sizeof(FileHeader)
  37 };
  38 cassert(sizeof(FileHeader) == 12);
  39
  40 #pragma pack(pop)
  41
  42
  43 //-----------------------------------------------------------------------------
  44 // CFilePacker
  45
  46 CFilePacker::CFilePacker(u32 version, const char magic[4])
  47 {
  48         // put header in our data array.
  49         // (its payloadSize_le will be updated on every Pack*() call)
  50         FileHeader header;
  51         std::copy(magic, magic + 4, header.magic);
  52         write_le32(&header.version_le, version);
  53         write_le32(&header.payloadSize_le, 0);
  54         m_writeBuffer.Append(&header, sizeof(FileHeader));
  55 }
  56
  57
  58 CFilePacker::~CFilePacker()
  59 {
  60 }
  61
  62
  63 void CFilePacker::Write(const VfsPath& filename)
  64 {
  65         const size_t payloadSize = m_writeBuffer.Size() - sizeof(FileHeader);
  66         const u32 payloadSize_le = to_le32(u32_from_larger(payloadSize));
  67         m_writeBuffer.Overwrite(&payloadSize_le, sizeof(payloadSize_le), 0+offsetof(FileHeader, payloadSize_le));
  68
  69         // write out all data (including header)
  70         const Status st = g_VFS->CreateFile(filename, m_writeBuffer.Data(), m_writeBuffer.Size());
  71         if (st < 0)
  72         {
  73                 LOGERROR("Failed to write file '%s' with status '%lld'", filename.string8(), (long long)st);
  74                 throw PSERROR_File_WriteFailed();
  75         }
  76 }
  77
  78
  79 void CFilePacker::PackRaw(const void* rawData, size_t rawSize)
  80 {
  81         m_writeBuffer.Append(rawData, rawSize);
  82 }
  83
  84 void CFilePacker::PackSize(size_t value)
  85 {
  86         const u32 value_le32 = to_le32(u32_from_larger(value));
  87         PackRaw(&value_le32, sizeof(value_le32));
  88 }
  89
  90 void CFilePacker::PackString(const CStr& str)
  91 {
  92         const size_t length = str.length();
  93         PackSize(length);
  94         PackRaw(str.c_str(), length);
  95 }
  96
  97
  98 //-----------------------------------------------------------------------------
  99 // CFileUnpacker
 100
 101 CFileUnpacker::CFileUnpacker()
 102         : m_bufSize(0), m_unpackPos(0), m_version(0)
 103 {
 104 }
 105
 106
 107 CFileUnpacker::~CFileUnpacker()
 108 {
 109 }
 110
 111
 112 void CFileUnpacker::Read(const VfsPath& filename, const char magic[4])
 113 {
 114         // if the file doesn't exist, LoadFile would raise an annoying error dialog.
 115         // since this (unfortunately) happens so often, we perform a separate
 116         // check and "just" raise an exception for the caller to handle.
 117         // (this is nicer than somehow squelching internal VFS error reporting)
 118         if(!VfsFileExists(filename))
 119                 throw PSERROR_File_OpenFailed();
 120
 121         // load the whole thing into memory
 122         if(g_VFS->LoadFile(filename, m_buf, m_bufSize) < 0)
 123                 throw PSERROR_File_OpenFailed();
 124
 125         // make sure we read enough for the header
 126         if(m_bufSize < sizeof(FileHeader))
 127         {
 128                 m_buf.reset();
 129                 m_bufSize = 0;
 130                 throw PSERROR_File_ReadFailed();
 131         }
 132
 133         // extract data from header
 134         FileHeader* header = (FileHeader*)m_buf.get();
 135         m_version = read_le32(&header->version_le);
 136         const size_t payloadSize = (size_t)read_le32(&header->payloadSize_le);
 137
 138         // check we've got the right kind of file
 139         // .. and that we read exactly headerSize+payloadSize
 140         if(strncmp(header->magic, magic, 4) != 0 || m_bufSize != sizeof(FileHeader)+payloadSize)
 141         {
 142                 m_buf.reset();
 143                 m_bufSize = 0;
 144                 throw PSERROR_File_InvalidType();
 145         }
 146
 147         m_unpackPos = sizeof(FileHeader);
 148 }
 149
 150
 151 void CFileUnpacker::UnpackRaw(void* rawData, size_t rawDataSize)
 152 {
 153         // fail if reading past end of stream
 154         if (m_unpackPos+rawDataSize > m_bufSize)
 155                 throw PSERROR_File_UnexpectedEOF();
 156
 157         void* src = m_buf.get() + m_unpackPos;
 158         memcpy(rawData, src, rawDataSize);
 159         m_unpackPos += rawDataSize;
 160 }
 161
 162
 163 size_t CFileUnpacker::UnpackSize()
 164 {
 165         u32 value_le32;
 166         UnpackRaw(&value_le32, sizeof(value_le32));
 167         return (size_t)to_le32(value_le32);
 168 }
 169
 170
 171 void CFileUnpacker::UnpackString(CStr8& result)
 172 {
 173         const size_t length = UnpackSize();
 174
 175         // fail if reading past end of stream
 176         if (m_unpackPos+length > m_bufSize)
 177                 throw PSERROR_File_UnexpectedEOF();
 178
 179         result = CStr((char*)m_buf.get()+m_unpackPos, length);
 180         m_unpackPos += length;
 181 }