MCBinaryData.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ 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.
 *
 *  AiBO+ 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MCBinaryData.hpp"

#include "3rdparty/archives/portable_iarchive.hpp"
#include "3rdparty/archives/portable_oarchive.hpp"
#include "MCDefs.hpp"
#include "MCLog.hpp"

#ifndef __AIBO_BUILD__
#include <qdatastream.h>
#include <qfile.h>
#include <qresource.h>
#endif

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/iterators/base64_from_binary.hpp>
#include <boost/archive/iterators/binary_from_base64.hpp>
#if __cplusplus >= 201103L || defined(__MINGW32__) || defined(__MINGW64__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreorder"
#if !defined(__clang__)
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
#endif
#include <boost/archive/iterators/transform_width.hpp>
#if __cplusplus >= 201103L || defined(__MINGW32__) || defined(__MINGW64__)
#pragma GCC diagnostic pop
#endif
#include <boost/serialization/vector.hpp>

#include <md5.h>

#include <stdlib.h>
#include <string.h>

#include <fstream>

namespace
{
using namespace boost::archive::iterators;

// Taken from:
// http://stackoverflow.com/questions/7053538/how-do-i-encode-a-string-to-base64-using-only-boost
uint base64_encode(unsigned char* dest, const unsigned char* src, uint len)
{
  typedef base64_from_binary<transform_width<const char *, 6, 8> > base64_enc;

  uint one_third_len = len/3;
  uint len_rounded_down = one_third_len*3;
  uint j = len_rounded_down + one_third_len;

  std::copy(base64_enc(src), base64_enc(src + len_rounded_down), dest);

  if (len_rounded_down != len)
  {
    char tail[3] = {0, 0, 0};
    uint i = 0;

    for (; i < len - len_rounded_down; ++i)
    {
      tail[i] = src[len_rounded_down+i];
    }
    std::copy(base64_enc(tail), base64_enc(tail + 3), dest + j);

    for (i = len + one_third_len + 1; i < j+4; ++i)
    {
      dest[i] = '=';
    }
    return i;
  }
  return j;
}

const char* base64_decode(unsigned char* dest, const char* src, uint* len)
{
  uint output_len = *len;
  typedef transform_width<binary_from_base64<const char*>, 8, 6> base64_dec;

  uint i = 0;

  MC_TRY_BEGIN
    base64_dec src_it(src);
    for(; i < output_len; ++i)
    {
      *dest++ = *src_it;
      ++src_it;
    }
  MC_CATCH_BEGIN
  MC_CATCH_END

  // This is a joke...but real bug in boost.
  // Remove the padding characters, cf. https://svn.boost.org/trac/boost/ticket/5629
  if (src[(int)*len-1] == '=')
  {
    --i;
    if (src[(int)*len-2] == '=')
      --i;
  }
  *len = i;
  return src + (i+2)/3*4; // bytes in = bytes out / 3 rounded up * 4
}
}

MCBinaryData::MCBinaryData() : Size(0), Position(0)
{
}


MCBinaryData::MCBinaryData(int size) : Size(0), Position(0)
{
  Allocate(size);
}


MCBinaryData::MCBinaryData(int size, unsigned char value) : Size(0), Position(0)
{
  Allocate(size);
  memset(&Data[0], (int)value, (size_t)size);
}


MCBinaryData::MCBinaryData(const MCBinaryData& other) : Size(0), Position(0)
{
  Clone(other);
}


MCBinaryData::MCBinaryData(MCBinaryData&& other) : Size(0), Position(0)
{
  *this = std::move(other);
  // Free the resources of other instance
  other.Free();
}


MCBinaryData::~MCBinaryData()
{
}


void MCBinaryData::Allocate(int size)
{
  // Deallocate the content
  Free();
  if (size <= 0)
    return;

  if (Size == size)
  {
    // Only clear the memory and position without reallocation
    Position = 0;
    Clear();
    return;
  }
  // Allocate new data
  Data.resize(size);
  Size = size;
  Position = 0;
  // Clear the memory
  Clear();
}


void MCBinaryData::Shrink(int size)
{
  if (size == 0)
  {
    Free();
    return;
  }
  if (size < 0 || size >= Size)
    return;

  Data.resize(size);
  Size = size;
  Position = 0;
}


void MCBinaryData::Free()
{
  // Free the data if it is owned
  // http://stackoverflow.com/questions/1111078/reduce-the-capacity-of-an-stl-vector
  std::vector<unsigned char>(Data).swap(Data);
  Size = 0;
  Position = 0;
}


void MCBinaryData::Clear()
{
  // Use the value 255 since 0 can be interpreted into valid content
  if (Size > 0)
    memset(&Data[0], 255, Size);
  Position = 0;
}


bool MCBinaryData::IsEmpty() const
{
  for (int i = 0; i < Size; ++i)
  {
    if (Data[i] != 255)
      return false;
  }
  return true;
}


void MCBinaryData::Set(unsigned char* data, int size)
{
  if (Size != size)
  {
    Free();
    Allocate(size);
  }
  memcpy(&Data[0], data, size);
  Size = size;
  Position = 0;
}


void MCBinaryData::Clone(const MCBinaryData& other)
{
  Free();
  Allocate(other.Size);
  Data = other.Data;
  Position = other.Position;
}


MCBinaryData* MCBinaryData::Clone()
{
  MCBinaryData* NewInstance = new MCBinaryData(Size);

  memcpy(&NewInstance->Data[0], &Data[0], Size);
  NewInstance->Position = Position;
  return NewInstance;
}


bool MCBinaryData::WriteData(MCBinaryData& target, int capacity)
{
  int Count = CopyData(target, capacity);

  if (Count > 0)
  {
    Position += Count;
    return true;
  }
  return false;
}


unsigned int MCBinaryData::CopyData(MCBinaryData& target, int capacity) const
{
  int Capacity = capacity < 0 ? target.Size : capacity;

  if (Capacity > Size-Position)
  {
    MC_WARNING("%d source bytes are needed, but only %d available to write binary data.",
               Capacity, Size-Position);
    return 0;
  }
  if (Capacity > target.Size-target.Position)
  {
    MC_WARNING("%d target bytes are needed, but only %d available to write binary data.",
               Capacity, target.Size-target.Position);
    return 0;
  }
  memcpy(&target.Data[target.Position], &Data[Position], Capacity);
  target.IncrementPosition(Capacity);
  return Capacity;
}


bool MCBinaryData::LoadFromFile(const std::string& file_name)
{
  std::ifstream InputFile(file_name.c_str(), std::ios::in | std::ios::binary);

  if (!InputFile.is_open())
  {
    MC_WARNING("File does not exist to load binary data: %s", file_name.c_str());
    return false;
  }
  InputFile.seekg(0, std::ios::end);
  Allocate((int)InputFile.tellg());
  InputFile.seekg(0, std::ios::beg);
  InputFile.read(reinterpret_cast<char*>(&Data[0]), Data.size());
  return InputFile.good();
}


#ifndef __AIBO_BUILD__
bool MCBinaryData::LoadFromQtResource(const QString& resource_str)
{
  QResource XmlResource(resource_str);
  QFile ClassifierFile(XmlResource.absoluteFilePath());
  QDataStream InputStream(&ClassifierFile);

  Allocate(ClassifierFile.size());
  if (!ClassifierFile.open(QIODevice::ReadOnly))
    return false;
  if (InputStream.readRawData((char*)GetData(), ClassifierFile.size()) < 0)
  {
    ClassifierFile.close();
    return false;
  }
  ClassifierFile.close();
  return true;
}
#endif


bool MCBinaryData::SaveToFile(const std::string& file_name) const
{
  std::ofstream OutputFile(file_name.c_str(), std::ios::out | std::ios::binary);

  if (!OutputFile.is_open())
  {
    MC_WARNING("Unable to create file to save binary data: %s", file_name.c_str());
    return false;
  }
  OutputFile.write(reinterpret_cast<const char*>(&Data[0]), Data.size());
  OutputFile.flush();
  return OutputFile.good();
}


MCBinaryData MCBinaryData::GenerateMd5Hash() const
{
  MCBinaryData Result(16);

  dlib::md5(GetData(), Size, Result.GetData());
  return Result;
}


void MCBinaryData::AddUChar(unsigned char new_char)
{
  if (Position == Size)
  {
    MC_WARNING("Can't encode unsigned char number since no space left.");
    return;
  }
  Data[Position] = new_char;
  Position++;
}


void MCBinaryData::AddInt16(int16_t new_int, bool reverse_order)
{
  if (Position+2 > Size)
  {
    MC_WARNING("Can't encode int16_t number since no space left.");
    return;
  }
  uint16_t TempInt = *reinterpret_cast<uint16_t*>(&new_int);

  if (reverse_order)
  {
    Data[Position+1] = (unsigned char)(TempInt / 256);
    Data[Position] = (unsigned char)(TempInt % 256);
  } else {
    Data[Position] = (unsigned char)(TempInt / 256);
    Data[Position+1] = (unsigned char)(TempInt % 256);
  }
  Position += 2;
}


void MCBinaryData::AddInt32(int32_t new_int, bool reverse_order)
{
  if (Position+4 > Size)
  {
    MC_WARNING("Can't encode int32_t number since no space left.");
    return;
  }
  uint32_t TempInt = *reinterpret_cast<uint32_t*>(&new_int);

  if (reverse_order)
  {
    Data[Position+3] = TempInt >> 24 & 0xff;
    Data[Position+2] = TempInt >> 16 & 0xff;
    Data[Position+1] = TempInt >> 8 & 0xff;
    Data[Position+0] = TempInt & 0xff;
  } else {
    Data[Position] = TempInt >> 24 & 0xff;
    Data[Position+1] = TempInt >> 16 & 0xff;
    Data[Position+2] = TempInt >> 8 & 0xff;
    Data[Position+3] = TempInt & 0xff;
  }
  Position += 4;
}


void MCBinaryData::AddString(const std::string& str)
{
  if (Position+(int)str.size() > Size)
  {
    MC_WARNING("Can't encode string since no space left.");
    return;
  }
  memcpy(&Data[Position], str.c_str(), str.size());
  Position += str.size();
}


unsigned char MCBinaryData::GetUChar()
{
  if (Position == Size)
  {
    MC_WARNING("Can't decode unsigned char since no space left.");
    return 0;
  }
  unsigned char Ret = Data[Position];

  Position++;
  return Ret;
}


int16_t MCBinaryData::GetInt16(bool reverse_order)
{
  if (Position+2 > Size)
  {
    MC_WARNING("Can't decode int16_t number since no space left.");
    return 0;
  }
  uint16_t Ret = 0;

  if (reverse_order)
  {
    Ret = Data[Position+1]*256+(uint16_t)Data[Position];
  } else {
    Ret = Data[Position]*256+(uint16_t)Data[Position+1];
  }
  Position += 2;
  return *reinterpret_cast<int16_t*>(&Ret);
}


int32_t MCBinaryData::GetInt32(bool reverse_order)
{
  if (Position+4 > Size)
  {
    MC_WARNING("Can't decode int32_t number since no space left.");
    return 0;
  }
  uint32_t Ret = 0;

  if (reverse_order)
  {
    Ret = (Data[Position+3] << 24)+(Data[Position+2] << 16)+(Data[Position+1] << 8)+Data[Position];
  } else {
    Ret = (Data[Position] << 24)+(Data[Position+1] << 16)+(Data[Position+2] << 8)+Data[Position+3];
  }
  Position += 4;
  return *reinterpret_cast<int32_t*>(&Ret);
}


bool MCBinaryData::ValidateString(unsigned int length, const std::string& additional_chars)
{
  if (Position+(int)length > Size)
  {
    MC_WARNING("Too long string is expected to decode (%d > %d)", length, Size-Position);
    return false;
  }
  for (unsigned int i = Position; i < Position+length; ++i)
  {
    bool Found = false;

    for (unsigned int i1 = 0; i1 < additional_chars.size(); ++i1)
    {
      if (Data[i] == additional_chars[i1])
      {
        Found = true;
        break;
      }
    }
    if (Found)
      continue;
    if (!(Data[i] >= 'a' && Data[i] <= 'z') && !(Data[i] >= 'A' && Data[i] <= 'Z') &&
        !(Data[i] >= '0' && Data[i] <= '9') && Data[i] != ' ')
    {
      return false;
    }
  }
  return true;
}


std::string MCBinaryData::GetString(unsigned int length, const std::string& additional_chars)
{
  if (!ValidateString(length, additional_chars))
  {
    return "";
  }
  std::string Result(length, 0);

  memcpy((char*)Result.c_str(), &Data[Position], length);
  IncrementPosition(length);
  return Result;
}


unsigned char* MCBinaryData::GetData() const
{
  return (unsigned char*)&Data[0];
}


int MCBinaryData::GetSize() const
{
  return Size;
}


const std::vector<unsigned char>& MCBinaryData::GetVectorData() const
{
  return Data;
}


int MCBinaryData::GetPosition() const
{
  return Position;
}


unsigned int MCBinaryData::GetRemainingCapacity(unsigned int capacity) const
{
  return (unsigned int)((Position+(int)capacity <= Size) ? capacity : Size-Position);
}


bool MCBinaryData::IsPositionAtEnd() const
{
  return Position == Size;
}


void MCBinaryData::SetPosition(unsigned int position)
{
  Position = MCMin((int)position, Size);
}


void MCBinaryData::IncrementPosition(unsigned int position)
{
  SetPosition(Position+position);
}


void MCBinaryData::ResetPosition()
{
  Position = 0;
}


std::string MCBinaryData::ToBase64() const
{
  if (Size <= 0)
    return "";

  MC::BinaryDataSPtr BinaryData(new MCBinaryData((int)((float)Size*1.4)));
  uint Result = base64_encode(BinaryData->GetData(), &Data[0], Size);

  return std::string((char*)BinaryData->GetData(), (int)Result);
}


void MCBinaryData::FromBase64(const std::string& base64_str)
{
  if (base64_str.empty())
    return;

  MC::BinaryDataSPtr BinaryData(new MCBinaryData(base64_str.size()));
  uint Result = base64_str.size();

  base64_decode(BinaryData->GetData(), base64_str.c_str(), &Result);
  Set(BinaryData->GetData(), (int)Result);
}


MCBinaryData& MCBinaryData::operator=(MCBinaryData&& other)
{
  if (this == &other)
    return *this;

  if (other.Size <= 0)
  {
    Free();
    return *this;
  }
  Position = other.Position;
  Size = other.Size;
  Data = std::move(other.Data);
  // Free the resources of other instance
  other.Free();
  return *this;
}


MCBinaryData& MCBinaryData::operator=(const MCBinaryData& other)
{
  if (*this == other)
    return *this;

  Clone(other);
  return *this;
}


bool MCBinaryData::operator==(const MCBinaryData& other) const
{
  bool Ret = true;

  // At least the size must be the same
  Ret = Ret && (Size == other.Size);
  for (int i = 0; i < Size && Ret; ++i)
  {
    Ret = Ret && (Data[i] == other.Data[i]);
  }
  return Ret;
}


bool MCBinaryData::operator!=(const MCBinaryData& other) const
{
  return !(*this == other);
}


template<class Archive>
void MCBinaryData::serialize(Archive& archive, const unsigned int version)
{
  MC_UNUSED(version);

  archive & Data;
  archive & Size;
  archive & Position;
}


// Explicit template instantiation
// http://stackoverflow.com/questions/2152002/how-do-i-force-a-particular-instance-of-a-c-template-to-instantiate
// Post by Alexander Poluektov
template void MCBinaryData::serialize<boost::archive::binary_iarchive>(boost::archive::binary_iarchive&,
                                                                       const unsigned int);
template void MCBinaryData::serialize<boost::archive::binary_oarchive>(boost::archive::binary_oarchive&,
                                                                       const unsigned int);
template void MCBinaryData::serialize<eos::portable_iarchive>(eos::portable_iarchive&, const unsigned int);
template void MCBinaryData::serialize<eos::portable_oarchive>(eos::portable_oarchive&, const unsigned int);