![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to serializer.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / platform|
Return to serializer.cpp CVS log | Up to [truecrypt] / truecrypt / platform |
1.1 root 1: /*
2: Copyright (c) 2008 TrueCrypt Foundation. All rights reserved.
3:
1.1.1.5 ! root 4: Governed by the TrueCrypt License 2.8 the full text of which is contained
1.1 root 5: in the file License.txt included in TrueCrypt binary and source code
6: distribution 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:
1.1.1.5 ! root 143: for (size_t i = 0; i < listSize; i++)
1.1 root 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:
1.1.1.5 ! root 165: for (size_t i = 0; i < listSize; i++)
1.1 root 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 archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.