Update README.md
[nemesis.git] / 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 }
This page took 0.032457 seconds and 3 git commands to generate. Download a nemesis OSX (sierra+high sierra, tested/working) binary, with fuse-ext3 via e2fsprogs, at this link. application and installer are signed by screwjack, llc. must install fuse with macFUSE layer first.