Platform/Serializer.cpp

   1 /*
   2  Copyright (c) 2008 TrueCrypt Developers Association. All rights reserved.
   3
   4  Governed by the TrueCrypt License 3.0 the full text of which is contained in
   5  the file License.txt included in TrueCrypt binary and source code distribution
   6  packages.
   7 */
   8
   9 #include "Exception.h"
  10 #include "ForEach.h"
  11 #include "Memory.h"
  12 #include "Serializer.h"
  13
  14 namespace TrueCrypt
  15 {
  16         template <typename T>
  17         T Serializer::Deserialize ()
  18         {
  19                 uint64 size;
  20                 DataStream->ReadCompleteBuffer (BufferPtr ((byte *) &size, sizeof (size)));
  21
  22                 if (Endian::Big (size) != sizeof (T))
  23                         throw ParameterIncorrect (SRC_POS);
  24
  25                 T data;
  26                 DataStream->ReadCompleteBuffer (BufferPtr ((byte *) &data, sizeof (data)));
  27
  28                 return Endian::Big (data);
  29         }
  30
  31         void Serializer::Deserialize (const string &name, bool &data)
  32         {
  33                 ValidateName (name);
  34                 data = Deserialize <byte> () == 1;
  35         }
  36
  37         void Serializer::Deserialize (const string &name, byte &data)
  38         {
  39                 ValidateName (name);
  40                 data = Deserialize <byte> ();
  41         }
  42
  43         void Serializer::Deserialize (const string &name, int32 &data)
  44         {
  45                 ValidateName (name);
  46                 data = (int32) Deserialize <uint32> ();
  47         }
  48
  49         void Serializer::Deserialize (const string &name, int64 &data)
  50         {
  51                 ValidateName (name);
  52                 data = (int64) Deserialize <uint64> ();
  53         }
  54
  55         void Serializer::Deserialize (const string &name, uint32 &data)
  56         {
  57                 ValidateName (name);
  58                 data = Deserialize <uint32> ();
  59         }
  60
  61         void Serializer::Deserialize (const string &name, uint64 &data)
  62         {
  63                 ValidateName (name);
  64                 data = Deserialize <uint64> ();
  65         }
  66
  67         void Serializer::Deserialize (const string &name, string &data)
  68         {
  69                 ValidateName (name);
  70                 data = DeserializeString ();
  71         }
  72
  73         void Serializer::Deserialize (const string &name, wstring &data)
  74         {
  75                 ValidateName (name);
  76                 data = DeserializeWString ();
  77         }
  78
  79         void Serializer::Deserialize (const string &name, const BufferPtr &data)
  80         {
  81                 ValidateName (name);
  82
  83                 uint64 size = Deserialize <uint64> ();
  84                 if (data.Size() != size)
  85                         throw ParameterIncorrect (SRC_POS);
  86
  87                 DataStream->ReadCompleteBuffer (data);
  88         }
  89
  90         bool Serializer::DeserializeBool (const string &name)
  91         {
  92                 bool data;
  93                 Deserialize (name, data);
  94                 return data;
  95         }
  96
  97         int32 Serializer::DeserializeInt32 (const string &name)
  98         {
  99                 ValidateName (name);
 100                 return Deserialize <uint32> ();
 101         }
 102
 103         int64 Serializer::DeserializeInt64 (const string &name)
 104         {
 105                 ValidateName (name);
 106                 return Deserialize <uint64> ();
 107         }
 108
 109         uint32 Serializer::DeserializeUInt32 (const string &name)
 110         {
 111                 ValidateName (name);
 112                 return Deserialize <uint32> ();
 113         }
 114
 115         uint64 Serializer::DeserializeUInt64 (const string &name)
 116         {
 117                 ValidateName (name);
 118                 return Deserialize <uint64> ();
 119         }
 120
 121         string Serializer::DeserializeString ()
 122         {
 123                 uint64 size = Deserialize <uint64> ();
 124
 125                 vector <char> data ((size_t) size);
 126                 DataStream->ReadCompleteBuffer (BufferPtr ((byte *) &data[0], (size_t) size));
 127
 128                 return string (&data[0]);
 129         }
 130
 131         string Serializer::DeserializeString (const string &name)
 132         {
 133                 ValidateName (name);
 134                 return DeserializeString ();
 135         }
 136
 137         list <string> Serializer::DeserializeStringList (const string &name)
 138         {
 139                 ValidateName (name);
 140                 list <string> deserializedList;
 141                 uint64 listSize = Deserialize <uint64> ();
 142
 143                 for (size_t i = 0; i < listSize; i++)
 144                         deserializedList.push_back (DeserializeString ());
 145
 146                 return deserializedList;
 147         }
 148
 149         wstring Serializer::DeserializeWString ()
 150         {
 151                 uint64 size = Deserialize <uint64> ();
 152
 153                 vector <wchar_t> data ((size_t) size / sizeof (wchar_t));
 154                 DataStream->ReadCompleteBuffer (BufferPtr ((byte *) &data[0], (size_t) size));
 155
 156                 return wstring (&data[0]);
 157         }
 158
 159         list <wstring> Serializer::DeserializeWStringList (const string &name)
 160         {
 161                 ValidateName (name);
 162                 list <wstring> deserializedList;
 163                 uint64 listSize = Deserialize <uint64> ();
 164
 165                 for (size_t i = 0; i < listSize; i++)
 166                         deserializedList.push_back (DeserializeWString ());
 167
 168                 return deserializedList;
 169         }
 170
 171         wstring Serializer::DeserializeWString (const string &name)
 172         {
 173                 ValidateName (name);
 174                 return DeserializeWString ();
 175         }
 176
 177         template <typename T>
 178         void Serializer::Serialize (T data)
 179         {
 180                 uint64 size = Endian::Big (uint64 (sizeof (data)));
 181                 DataStream->Write (ConstBufferPtr ((byte *) &size, sizeof (size)));
 182
 183                 data = Endian::Big (data);
 184                 DataStream->Write (ConstBufferPtr ((byte *) &data, sizeof (data)));
 185         }
 186
 187         void Serializer::Serialize (const string &name, bool data)
 188         {
 189                 SerializeString (name);
 190                 byte d = data ? 1 : 0;
 191                 Serialize (d);
 192         }
 193
 194         void Serializer::Serialize (const string &name, byte data)
 195         {
 196                 SerializeString (name);
 197                 Serialize (data);
 198         }
 199
 200         void Serializer::Serialize (const string &name, const char *data)
 201         {
 202                 Serialize (name, string (data));
 203         }
 204
 205         void Serializer::Serialize (const string &name, int32 data)
 206         {
 207                 SerializeString (name);
 208                 Serialize ((uint32) data);
 209         }
 210
 211         void Serializer::Serialize (const string &name, int64 data)
 212         {
 213                 SerializeString (name);
 214                 Serialize ((uint64) data);
 215         }
 216
 217         void Serializer::Serialize (const string &name, uint32 data)
 218         {
 219                 SerializeString (name);
 220                 Serialize (data);
 221         }
 222
 223         void Serializer::Serialize (const string &name, uint64 data)
 224         {
 225                 SerializeString (name);
 226                 Serialize (data);
 227         }
 228
 229         void Serializer::Serialize (const string &name, const string &data)
 230         {
 231                 SerializeString (name);
 232                 SerializeString (data);
 233         }
 234
 235         void Serializer::Serialize (const string &name, const wchar_t *data)
 236         {
 237                 Serialize (name, wstring (data));
 238         }
 239
 240         void Serializer::Serialize (const string &name, const wstring &data)
 241         {
 242                 SerializeString (name);
 243                 SerializeWString (data);
 244         }
 245
 246         void Serializer::Serialize (const string &name, const list <string> &stringList)
 247         {
 248                 SerializeString (name);
 249
 250                 uint64 listSize = stringList.size();
 251                 Serialize (listSize);
 252
 253                 foreach (const string &item, stringList)
 254                         SerializeString (item);
 255         }
 256
 257         void Serializer::Serialize (const string &name, const list <wstring> &stringList)
 258         {
 259                 SerializeString (name);
 260
 261                 uint64 listSize = stringList.size();
 262                 Serialize (listSize);
 263
 264                 foreach (const wstring &item, stringList)
 265                         SerializeWString (item);
 266         }
 267
 268         void Serializer::Serialize (const string &name, const ConstBufferPtr &data)
 269         {
 270                 SerializeString (name);
 271
 272                 uint64 size = data.Size();
 273                 Serialize (size);
 274
 275                 DataStream->Write (data);
 276         }
 277
 278         void Serializer::SerializeString (const string &data)
 279         {
 280                 Serialize ((uint64) data.size() + 1);
 281                 DataStream->Write (ConstBufferPtr ((byte *) (data.data() ? data.data() : data.c_str()), data.size() + 1));
 282         }
 283
 284         void Serializer::SerializeWString (const wstring &data)
 285         {
 286                 uint64 size = (data.size() + 1) * sizeof (wchar_t);
 287                 Serialize (size);
 288                 DataStream->Write (ConstBufferPtr ((byte *) (data.data() ? data.data() : data.c_str()), (size_t) size));
 289         }
 290
 291         void Serializer::ValidateName (const string &name)
 292         {
 293                 string dName = DeserializeString();
 294                 if (dName != name)
 295                 {
 296                         throw ParameterIncorrect (SRC_POS);
 297                 }
 298         }
 299 }