ext/CrashServer/CrashHandler/SendRpt/Serializer.cpp

   1 // Copyright 2014 Idol Software, Inc.
   2 //
   3 // This file is part of Doctor Dump SDK.
   4 //
   5 // Doctor Dump SDK is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU Lesser General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU Lesser General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Lesser General Public License
  16 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 #include "StdAfx.h"
  19 #include "Serializer.h"
  20
  21 CString Serializer::GetHex() const
  22 {
  23     CString res;
  24     for (size_t i = 0, size = m_storage.size(); i < size; ++i)
  25         res.AppendFormat(_T("%02X"), (DWORD)m_storage[i]);
  26     return res;
  27 }
  28
  29 Serializer::Serializer() : m_buf(NULL), m_size(0) {}
  30
  31 Serializer::Serializer(const CString& hex)
  32 {
  33     size_t bufLen = hex.GetLength() / 2;
  34     for (size_t i = 0; i < bufLen; ++i)
  35     {
  36         DWORD t;
  37         if (1 != swscanf_s((LPCTSTR)hex + i * 2, L"%02X", &t))
  38             throw std::runtime_error("invalid buffer");
  39         m_storage.push_back((BYTE)t);
  40     }
  41     m_buf = &m_storage[0];
  42     m_size = m_storage.size();
  43 }
  44
  45 Serializer::Serializer(const BYTE* buf, size_t size) : m_buf(buf), m_size(size) {}
  46
  47 Serializer& Serializer::SerSimpleType(BYTE* ptr, size_t size)
  48 {
  49     if (m_buf)
  50     {
  51         if (m_size < size)
  52             throw std::runtime_error("invalid buffer");
  53         memcpy(ptr, m_buf, size);
  54         m_buf += size;
  55         m_size -= size;
  56     }
  57     else
  58     {
  59         m_storage.insert(m_storage.end(), ptr, ptr + size);
  60     }
  61     return *this;
  62 }
  63
  64 Serializer& Serializer::operator << (CStringA& val)
  65 {
  66     DWORD len = val.GetLength();
  67     SerSimpleType((BYTE*)&len, sizeof(len));
  68     SerSimpleType((BYTE*)val.GetBuffer(len), len * sizeof(char));
  69     val.ReleaseBuffer(len);
  70     return *this;
  71 }
  72
  73 Serializer& Serializer::operator << (CStringW& val)
  74 {
  75     DWORD len = val.GetLength();
  76     SerSimpleType((BYTE*)&len, sizeof(len));
  77     SerSimpleType((BYTE*)val.GetBuffer(len), len * sizeof(wchar_t));
  78     val.ReleaseBuffer(len);
  79     return *this;
  80 }
  81
  82 Serializer& operator << (Serializer& ser, MINIDUMP_EXCEPTION_INFORMATION& val)
  83 {
  84     ser.SerSimpleType((BYTE*)&val.ExceptionPointers, sizeof(val.ExceptionPointers));
  85     return ser << val.ThreadId << val.ClientPointers;
  86 }
  87
  88 template <typename T1, typename T2>
  89 Serializer& operator << (Serializer& ser, std::pair<T1, T2>& val)
  90 {
  91     return ser << val.first << val.second;
  92 }
  93
  94 template <typename T>
  95 Serializer& operator << (Serializer& ser, std::vector<T>& val)
  96 {
  97     size_t size = val.size();
  98     ser.SerSimpleType((BYTE*)&size, sizeof(size));
  99     if (ser.IsReading())
 100         val.resize(size);
 101     for (size_t i = 0;  i < val.size(); ++i)
 102         ser << val[i];
 103     return ser;
 104 }
 105
 106 template <typename K, typename V>
 107 Serializer& operator << (Serializer& ser, std::map<K, V>& val)
 108 {
 109     size_t size = val.size();
 110     ser.SerSimpleType((BYTE*)&size, sizeof(size));
 111     if (ser.IsReading())
 112     {
 113         for (size_t i = 0;  i < size; ++i)
 114         {
 115             std::pair<K, V> item;
 116             ser << item;
 117             val.insert(item);
 118         }
 119     }
 120     else
 121     {
 122         for (std::map<K, V>::iterator it = val.begin(); it != val.end(); ++it)
 123         {
 124             std::pair<K, V> item = *it;
 125             ser << item;
 126         }
 127     }
 128     return ser;
 129 }
 130
 131 Serializer& operator << (Serializer& ser, Config& cfg)
 132 {
 133     return ser << cfg.Prefix
 134         << cfg.AppName
 135         << cfg.Company
 136         << cfg.PrivacyPolicyUrl
 137         << cfg.V[0] << cfg.V[1] << cfg.V[2] << cfg.V[3]
 138         << cfg.Hotfix
 139         << cfg.ApplicationGUID
 140         << cfg.ServiceMode
 141         << cfg.LeaveDumpFilesInTempFolder
 142         << cfg.OpenProblemInBrowser
 143         << cfg.UseWER
 144         << cfg.SubmitterID
 145         << cfg.SendAdditionalDataWithoutApproval
 146         << cfg.FullDumpType
 147         << cfg.ProcessName
 148         << cfg.LangFilePath
 149         << cfg.SendRptPath
 150         << cfg.DbgHelpPath
 151         << cfg.FilesToAttach
 152         << cfg.UserInfo
 153         << cfg.CustomInfo;
 154 }
 155
 156 Serializer& operator << (Serializer& ser, Params& param)
 157 {
 158     return ser << param.Process
 159         << param.ProcessId
 160         << param.ExceptInfo
 161         << param.WasAssert
 162         << param.ReportReady
 163         << param.Group;
 164 }