Return to serializer.cpp CVS log

Up to [truecrypt] / truecrypt / platform

Annotation of truecrypt/platform/serializer.cpp, revision 1.1.1.6

1.1       root        1: /*
1.1.1.6 ! root        2:  Copyright (c) 2008 TrueCrypt Developers Association. All rights reserved.
1.1       root        3: 
1.1.1.6 ! root        4:  Governed by the TrueCrypt License 2.8 the full text of which is contained in
        !             5:  the file License.txt included in TrueCrypt binary and source code distribution
        !             6:  packages.
1.1       root        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.