WIP Update lib to 2.37

ModernKeePassLib/Collections/AutoTypeConfig.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2014 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

ModernKeePassLib/Collections/ProtectedBinaryDictionary.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2014 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

ModernKeePassLib/Collections/ProtectedBinarySet.cs

@@ -0,0 +1,174 @@
+/*
+  KeePass Password Safe - The Open-Source Password Manager
+  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+
+using ModernKeePassLib.Delegates;
+using ModernKeePassLib.Security;
+
+namespace ModernKeePassLib.Collections
+{
+	internal sealed class ProtectedBinarySet : IEnumerable<KeyValuePair<int, ProtectedBinary>>
+	{
+		private Dictionary<int, ProtectedBinary> m_d =
+			new Dictionary<int, ProtectedBinary>();
+
+		public ProtectedBinarySet()
+		{
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return m_d.GetEnumerator();
+		}
+
+		public IEnumerator<KeyValuePair<int, ProtectedBinary>> GetEnumerator()
+		{
+			return m_d.GetEnumerator();
+		}
+
+		public void Clear()
+		{
+			m_d.Clear();
+		}
+
+		private int GetFreeID()
+		{
+			int i = m_d.Count;
+			while(m_d.ContainsKey(i)) { ++i; }
+			Debug.Assert(i == m_d.Count); // m_d.Count should be free
+			return i;
+		}
+
+		public ProtectedBinary Get(int iID)
+		{
+			ProtectedBinary pb;
+			if(m_d.TryGetValue(iID, out pb)) return pb;
+
+			// Debug.Assert(false); // No assert
+			return null;
+		}
+
+		public int Find(ProtectedBinary pb)
+		{
+			if(pb == null) { Debug.Assert(false); return -1; }
+
+			// Fast search by reference
+			foreach(KeyValuePair<int, ProtectedBinary> kvp in m_d)
+			{
+				if(object.ReferenceEquals(pb, kvp.Value))
+				{
+					Debug.Assert(pb.Equals(kvp.Value));
+					return kvp.Key;
+				}
+			}
+
+			// Slow search by content
+			foreach(KeyValuePair<int, ProtectedBinary> kvp in m_d)
+			{
+				if(pb.Equals(kvp.Value)) return kvp.Key;
+			}
+
+			// Debug.Assert(false); // No assert
+			return -1;
+		}
+
+		public void Set(int iID, ProtectedBinary pb)
+		{
+			if(iID < 0) { Debug.Assert(false); return; }
+			if(pb == null) { Debug.Assert(false); return; }
+
+			m_d[iID] = pb;
+		}
+
+		public void Add(ProtectedBinary pb)
+		{
+			if(pb == null) { Debug.Assert(false); return; }
+
+			int i = Find(pb);
+			if(i >= 0) return; // Exists already
+
+			i = GetFreeID();
+			m_d[i] = pb;
+		}
+
+		public void AddFrom(ProtectedBinaryDictionary d)
+		{
+			if(d == null) { Debug.Assert(false); return; }
+
+			foreach(KeyValuePair<string, ProtectedBinary> kvp in d)
+			{
+				Add(kvp.Value);
+			}
+		}
+
+		public void AddFrom(PwGroup pg)
+		{
+			if(pg == null) { Debug.Assert(false); return; }
+
+			EntryHandler eh = delegate(PwEntry pe)
+			{
+				if(pe == null) { Debug.Assert(false); return true; }
+
+				AddFrom(pe.Binaries);
+				foreach(PwEntry peHistory in pe.History)
+				{
+					if(peHistory == null) { Debug.Assert(false); continue; }
+					AddFrom(peHistory.Binaries);
+				}
+
+				return true;
+			};
+
+			pg.TraverseTree(TraversalMethod.PreOrder, null, eh);
+		}
+
+		public ProtectedBinary[] ToArray()
+		{
+			int n = m_d.Count;
+			ProtectedBinary[] v = new ProtectedBinary[n];
+
+			foreach(KeyValuePair<int, ProtectedBinary> kvp in m_d)
+			{
+				if((kvp.Key < 0) || (kvp.Key >= n))
+				{
+					Debug.Assert(false);
+					throw new InvalidOperationException();
+				}
+
+				v[kvp.Key] = kvp.Value;
+			}
+
+			for(int i = 0; i < n; ++i)
+			{
+				if(v[i] == null)
+				{
+					Debug.Assert(false);
+					throw new InvalidOperationException();
+				}
+			}
+
+			return v;
+		}
+	}
+}

ModernKeePassLib/Collections/ProtectedStringDictionary.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2014 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -283,11 +283,7 @@ namespace ModernKeePassLib.Collections
 
 		public List<string> GetKeys()
 		{
-			List<string> v = new List<string>();
-
-			foreach(string strKey in m_vStrings.Keys) v.Add(strKey);
-
-			return v;
+			return new List<string>(m_vStrings.Keys);
 		}
 
 		public void EnableProtection(string strField, bool bProtect)
@@ -299,7 +295,8 @@ namespace ModernKeePassLib.Collections
 			{
 				byte[] pbData = ps.ReadUtf8();
 				Set(strField, new ProtectedString(bProtect, pbData));
-				MemUtil.ZeroByteArray(pbData);
+
+				if(bProtect) MemUtil.ZeroByteArray(pbData);
 			}
 		}
 	}

ModernKeePassLib/Collections/PwObjectList.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2014 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

ModernKeePassLib/Collections/PwObjectPool.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2014 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -18,12 +18,14 @@
 */
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Text;
 using System.Diagnostics;
+using System.Text;
 
 using ModernKeePassLib.Delegates;
 using ModernKeePassLib.Interfaces;
+using ModernKeePassLib.Utility;
 
 #if KeePassLibSD
 using KeePassLibSD;
@@ -77,4 +79,154 @@ namespace ModernKeePassLib.Collections
 			return true;
 		}
 	}
+
+	internal sealed class PwObjectPoolEx
+	{
+		private Dictionary<PwUuid, ulong> m_dUuidToId =
+			new Dictionary<PwUuid, ulong>();
+		private Dictionary<ulong, IStructureItem> m_dIdToItem =
+			new Dictionary<ulong, IStructureItem>();
+
+		private PwObjectPoolEx()
+		{
+		}
+
+		public static PwObjectPoolEx FromGroup(PwGroup pg)
+		{
+			PwObjectPoolEx p = new PwObjectPoolEx();
+
+			if(pg == null) { Debug.Assert(false); return p; }
+
+			ulong uFreeId = 2; // 0 = "not found", 1 is a hole
+
+			p.m_dUuidToId[pg.Uuid] = uFreeId;
+			p.m_dIdToItem[uFreeId] = pg;
+			uFreeId += 2; // Make hole
+
+			p.AddGroupRec(pg, ref uFreeId);
+			return p;
+		}
+
+		private void AddGroupRec(PwGroup pg, ref ulong uFreeId)
+		{
+			if(pg == null) { Debug.Assert(false); return; }
+
+			ulong uId = uFreeId;
+
+			// Consecutive entries must have consecutive IDs
+			foreach(PwEntry pe in pg.Entries)
+			{
+				Debug.Assert(!m_dUuidToId.ContainsKey(pe.Uuid));
+				Debug.Assert(!m_dIdToItem.ContainsValue(pe));
+
+				m_dUuidToId[pe.Uuid] = uId;
+				m_dIdToItem[uId] = pe;
+				++uId;
+			}
+			++uId; // Make hole
+
+			// Consecutive groups must have consecutive IDs
+			foreach(PwGroup pgSub in pg.Groups)
+			{
+				Debug.Assert(!m_dUuidToId.ContainsKey(pgSub.Uuid));
+				Debug.Assert(!m_dIdToItem.ContainsValue(pgSub));
+
+				m_dUuidToId[pgSub.Uuid] = uId;
+				m_dIdToItem[uId] = pgSub;
+				++uId;
+			}
+			++uId; // Make hole
+
+			foreach(PwGroup pgSub in pg.Groups)
+			{
+				AddGroupRec(pgSub, ref uId);
+			}
+
+			uFreeId = uId;
+		}
+
+		public ulong GetIdByUuid(PwUuid pwUuid)
+		{
+			if(pwUuid == null) { Debug.Assert(false); return 0; }
+
+			ulong uId;
+			m_dUuidToId.TryGetValue(pwUuid, out uId);
+			return uId;
+		}
+
+		public IStructureItem GetItemByUuid(PwUuid pwUuid)
+		{
+			if(pwUuid == null) { Debug.Assert(false); return null; }
+
+			ulong uId;
+			if(!m_dUuidToId.TryGetValue(pwUuid, out uId)) return null;
+			Debug.Assert(uId != 0);
+
+			return GetItemById(uId);
+		}
+
+		public IStructureItem GetItemById(ulong uId)
+		{
+			IStructureItem p;
+			m_dIdToItem.TryGetValue(uId, out p);
+			return p;
+		}
+	}
+
+	internal sealed class PwObjectBlock<T> : IEnumerable<T>
+		where T : class, ITimeLogger, IStructureItem, IDeepCloneable<T>
+	{
+		private List<T> m_l = new List<T>();
+
+		public T PrimaryItem
+		{
+			get { return ((m_l.Count > 0) ? m_l[0] : null); }
+		}
+
+		private DateTime m_dtLocationChanged = TimeUtil.SafeMinValueUtc;
+		public DateTime LocationChanged
+		{
+			get { return m_dtLocationChanged; }
+		}
+
+		private PwObjectPoolEx m_poolAssoc = null;
+		public PwObjectPoolEx PoolAssoc
+		{
+			get { return m_poolAssoc; }
+		}
+
+		public PwObjectBlock()
+		{
+		}
+
+#if DEBUG
+		public override string ToString()
+		{
+			return ("PwObjectBlock, Count = " + m_l.Count.ToString());
+		}
+#endif
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return m_l.GetEnumerator();
+		}
+
+		public IEnumerator<T> GetEnumerator()
+		{
+			return m_l.GetEnumerator();
+		}
+
+		public void Add(T t, DateTime dtLoc, PwObjectPoolEx pool)
+		{
+			if(t == null) { Debug.Assert(false); return; }
+
+			m_l.Add(t);
+
+			if(dtLoc > m_dtLocationChanged)
+			{
+				m_dtLocationChanged = dtLoc;
+				m_poolAssoc = pool;
+			}
+		}
+	}
 }

ModernKeePassLib/Collections/StringDictionaryEx.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2014 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -32,14 +32,14 @@ using KeePassLibSD;
 namespace ModernKeePassLib.Collections
 {
 	public sealed class StringDictionaryEx : IDeepCloneable<StringDictionaryEx>,
-		IEnumerable<KeyValuePair<string, string>>
+		IEnumerable<KeyValuePair<string, string>>, IEquatable<StringDictionaryEx>
 	{
-		private SortedDictionary<string, string> m_vDict =
+		private SortedDictionary<string, string> m_dict =
 			new SortedDictionary<string, string>();
 
 		public int Count
 		{
-			get { return m_vDict.Count; }
+			get { return m_dict.Count; }
 		}
 
 		public StringDictionaryEx()
@@ -48,39 +48,53 @@ namespace ModernKeePassLib.Collections
 
 		IEnumerator IEnumerable.GetEnumerator()
 		{
-			return m_vDict.GetEnumerator();
+			return m_dict.GetEnumerator();
 		}
 
 		public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
 		{
-			return m_vDict.GetEnumerator();
+			return m_dict.GetEnumerator();
 		}
 
 		public StringDictionaryEx CloneDeep()
 		{
-			StringDictionaryEx plNew = new StringDictionaryEx();
+			StringDictionaryEx sdNew = new StringDictionaryEx();
 
-			foreach(KeyValuePair<string, string> kvpStr in m_vDict)
-				plNew.Set(kvpStr.Key, kvpStr.Value);
+			foreach(KeyValuePair<string, string> kvp in m_dict)
+				sdNew.m_dict[kvp.Key] = kvp.Value; // Strings are immutable
 
-			return plNew;
+			return sdNew;
+		}
+
+		public bool Equals(StringDictionaryEx sdOther)
+		{
+			if(sdOther == null) { Debug.Assert(false); return false; }
+
+			if(m_dict.Count != sdOther.m_dict.Count) return false;
+
+			foreach(KeyValuePair<string, string> kvp in sdOther.m_dict)
+			{
+				string str = Get(kvp.Key);
+				if((str == null) || (str != kvp.Value)) return false;
+			}
+
+			return true;
 		}
 
 		public string Get(string strName)
 		{
-			Debug.Assert(strName != null); if(strName == null) throw new ArgumentNullException("strName");
+			if(strName == null) { Debug.Assert(false); throw new ArgumentNullException("strName"); }
 
 			string s;
-			if(m_vDict.TryGetValue(strName, out s)) return s;
-
+			if(m_dict.TryGetValue(strName, out s)) return s;
 			return null;
 		}
 
 		public bool Exists(string strName)
 		{
-			Debug.Assert(strName != null); if(strName == null) throw new ArgumentNullException("strName");
+			if(strName == null) { Debug.Assert(false); throw new ArgumentNullException("strName"); }
 
-			return m_vDict.ContainsKey(strName);
+			return m_dict.ContainsKey(strName);
 		}
 
 		/// <summary>
@@ -92,25 +106,25 @@ namespace ModernKeePassLib.Collections
 		/// parameters is <c>null</c>.</exception>
 		public void Set(string strField, string strNewValue)
 		{
-			Debug.Assert(strField != null); if(strField == null) throw new ArgumentNullException("strField");
-			Debug.Assert(strNewValue != null); if(strNewValue == null) throw new ArgumentNullException("strNewValue");
+			if(strField == null) { Debug.Assert(false); throw new ArgumentNullException("strField"); }
+			if(strNewValue == null) { Debug.Assert(false); throw new ArgumentNullException("strNewValue"); }
 
-			m_vDict[strField] = strNewValue;
+			m_dict[strField] = strNewValue;
 		}
 
 		/// <summary>
 		/// Delete a string.
 		/// </summary>
 		/// <param name="strField">Name of the string field to delete.</param>
-		/// <returns>Returns <c>true</c> if the field has been successfully
-		/// removed, otherwise the return value is <c>false</c>.</returns>
+		/// <returns>Returns <c>true</c>, if the field has been successfully
+		/// removed. Otherwise, the return value is <c>false</c>.</returns>
 		/// <exception cref="System.ArgumentNullException">Thrown if the input
 		/// parameter is <c>null</c>.</exception>
 		public bool Remove(string strField)
 		{
-			Debug.Assert(strField != null); if(strField == null) throw new ArgumentNullException("strField");
+			if(strField == null) { Debug.Assert(false); throw new ArgumentNullException("strField"); }
 
-			return m_vDict.Remove(strField);
+			return m_dict.Remove(strField);
 		}
 	}
 }

ModernKeePassLib/Collections/VariantDictionary.cs

@@ -0,0 +1,415 @@
+/*
+  KeePass Password Safe - The Open-Source Password Manager
+  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+
+using ModernKeePassLib.Resources;
+using ModernKeePassLib.Utility;
+
+namespace ModernKeePassLib.Collections
+{
+	public class VariantDictionary 
+	{
+		private const ushort VdVersion = 0x0100;
+		private const ushort VdmCritical = 0xFF00;
+		private const ushort VdmInfo = 0x00FF;
+
+		private Dictionary<string, object> m_d = new Dictionary<string, object>();
+
+		private enum VdType : byte
+		{
+			None = 0,
+
+			// Byte = 0x02,
+			// UInt16 = 0x03,
+			UInt32 = 0x04,
+			UInt64 = 0x05,
+
+			// Signed mask: 0x08
+			Bool = 0x08,
+			// SByte = 0x0A,
+			// Int16 = 0x0B,
+			Int32 = 0x0C,
+			Int64 = 0x0D,
+
+			// Float = 0x10,
+			// Double = 0x11,
+			// Decimal = 0x12,
+
+			// Char = 0x17, // 16-bit Unicode character
+			String = 0x18,
+
+			// Array mask: 0x40
+			ByteArray = 0x42
+		}
+
+		public int Count
+		{
+			get { return m_d.Count; }
+		}
+
+		public VariantDictionary()
+		{
+			Debug.Assert((VdmCritical & VdmInfo) == ushort.MinValue);
+			Debug.Assert((VdmCritical | VdmInfo) == ushort.MaxValue);
+		}
+
+		private bool Get<T>(string strName, out T t)
+		{
+			t = default(T);
+
+			if(string.IsNullOrEmpty(strName)) { Debug.Assert(false); return false; }
+
+			object o;
+			if(!m_d.TryGetValue(strName, out o)) return false; // No assert
+
+			if(o == null) { Debug.Assert(false); return false; }
+			if(o.GetType() != typeof(T)) { Debug.Assert(false); return false; }
+
+			t = (T)o;
+			return true;
+		}
+
+		private void SetStruct<T>(string strName, T t)
+			where T : struct
+		{
+			if(string.IsNullOrEmpty(strName)) { Debug.Assert(false); return; }
+
+#if DEBUG
+			T tEx;
+			Get<T>(strName, out tEx); // Assert same type
+#endif
+
+			m_d[strName] = t;
+		}
+
+		private void SetRef<T>(string strName, T t)
+			where T : class
+		{
+			if(string.IsNullOrEmpty(strName)) { Debug.Assert(false); return; }
+			if(t == null) { Debug.Assert(false); return; }
+
+#if DEBUG
+			T tEx;
+			Get<T>(strName, out tEx); // Assert same type
+#endif
+
+			m_d[strName] = t;
+		}
+
+		public bool Remove(string strName)
+		{
+			if(string.IsNullOrEmpty(strName)) { Debug.Assert(false); return false; }
+
+			return m_d.Remove(strName);
+		}
+
+		public void CopyTo(VariantDictionary d)
+		{
+			if(d == null) { Debug.Assert(false); return; }
+
+			// Do not clear the target
+			foreach(KeyValuePair<string, object> kvp in m_d)
+			{
+				d.m_d[kvp.Key] = kvp.Value;
+			}
+		}
+
+		public Type GetTypeOf(string strName)
+		{
+			if(string.IsNullOrEmpty(strName)) { Debug.Assert(false); return null; }
+
+			object o;
+			m_d.TryGetValue(strName, out o);
+			if(o == null) return null; // No assert
+
+			return o.GetType();
+		}
+
+		public uint GetUInt32(string strName, uint uDefault)
+		{
+			uint u;
+			if(Get<uint>(strName, out u)) return u;
+			return uDefault;
+		}
+
+		public void SetUInt32(string strName, uint uValue)
+		{
+			SetStruct<uint>(strName, uValue);
+		}
+
+		public ulong GetUInt64(string strName, ulong uDefault)
+		{
+			ulong u;
+			if(Get<ulong>(strName, out u)) return u;
+			return uDefault;
+		}
+
+		public void SetUInt64(string strName, ulong uValue)
+		{
+			SetStruct<ulong>(strName, uValue);
+		}
+
+		public bool GetBool(string strName, bool bDefault)
+		{
+			bool b;
+			if(Get<bool>(strName, out b)) return b;
+			return bDefault;
+		}
+
+		public void SetBool(string strName, bool bValue)
+		{
+			SetStruct<bool>(strName, bValue);
+		}
+
+		public int GetInt32(string strName, int iDefault)
+		{
+			int i;
+			if(Get<int>(strName, out i)) return i;
+			return iDefault;
+		}
+
+		public void SetInt32(string strName, int iValue)
+		{
+			SetStruct<int>(strName, iValue);
+		}
+
+		public long GetInt64(string strName, long lDefault)
+		{
+			long l;
+			if(Get<long>(strName, out l)) return l;
+			return lDefault;
+		}
+
+		public void SetInt64(string strName, long lValue)
+		{
+			SetStruct<long>(strName, lValue);
+		}
+
+		public string GetString(string strName)
+		{
+			string str;
+			Get<string>(strName, out str);
+			return str;
+		}
+
+		public void SetString(string strName, string strValue)
+		{
+			SetRef<string>(strName, strValue);
+		}
+
+		public byte[] GetByteArray(string strName)
+		{
+			byte[] pb;
+			Get<byte[]>(strName, out pb);
+			return pb;
+		}
+
+		public void SetByteArray(string strName, byte[] pbValue)
+		{
+			SetRef<byte[]>(strName, pbValue);
+		}
+
+		/// <summary>
+		/// Create a deep copy.
+		/// </summary>
+		public virtual object Clone()
+		{
+			VariantDictionary vdNew = new VariantDictionary();
+
+			foreach(KeyValuePair<string, object> kvp in m_d)
+			{
+				object o = kvp.Value;
+				if(o == null) { Debug.Assert(false); continue; }
+
+				Type t = o.GetType();
+				if(t == typeof(byte[]))
+				{
+					byte[] p = (byte[])o;
+					byte[] pNew = new byte[p.Length];
+					if(p.Length > 0) Array.Copy(p, pNew, p.Length);
+
+					o = pNew;
+				}
+
+				vdNew.m_d[kvp.Key] = o;
+			}
+
+			return vdNew;
+		}
+
+		public static byte[] Serialize(VariantDictionary p)
+		{
+			if(p == null) { Debug.Assert(false); return null; }
+
+			byte[] pbRet;
+			using(MemoryStream ms = new MemoryStream())
+			{
+				MemUtil.Write(ms, MemUtil.UInt16ToBytes(VdVersion));
+
+				foreach(KeyValuePair<string, object> kvp in p.m_d)
+				{
+					string strName = kvp.Key;
+					if(string.IsNullOrEmpty(strName)) { Debug.Assert(false); continue; }
+					byte[] pbName = StrUtil.Utf8.GetBytes(strName);
+
+					object o = kvp.Value;
+					if(o == null) { Debug.Assert(false); continue; }
+
+					Type t = o.GetType();
+					VdType vt = VdType.None;
+					byte[] pbValue = null;
+					if(t == typeof(uint))
+					{
+						vt = VdType.UInt32;
+						pbValue = MemUtil.UInt32ToBytes((uint)o);
+					}
+					else if(t == typeof(ulong))
+					{
+						vt = VdType.UInt64;
+						pbValue = MemUtil.UInt64ToBytes((ulong)o);
+					}
+					else if(t == typeof(bool))
+					{
+						vt = VdType.Bool;
+						pbValue = new byte[1];
+						pbValue[0] = ((bool)o ? (byte)1 : (byte)0);
+					}
+					else if(t == typeof(int))
+					{
+						vt = VdType.Int32;
+						pbValue = MemUtil.Int32ToBytes((int)o);
+					}
+					else if(t == typeof(long))
+					{
+						vt = VdType.Int64;
+						pbValue = MemUtil.Int64ToBytes((long)o);
+					}
+					else if(t == typeof(string))
+					{
+						vt = VdType.String;
+						pbValue = StrUtil.Utf8.GetBytes((string)o);
+					}
+					else if(t == typeof(byte[]))
+					{
+						vt = VdType.ByteArray;
+						pbValue = (byte[])o;
+					}
+					else { Debug.Assert(false); continue; } // Unknown type
+
+					ms.WriteByte((byte)vt);
+					MemUtil.Write(ms, MemUtil.Int32ToBytes(pbName.Length));
+					MemUtil.Write(ms, pbName);
+					MemUtil.Write(ms, MemUtil.Int32ToBytes(pbValue.Length));
+					MemUtil.Write(ms, pbValue);
+				}
+
+				ms.WriteByte((byte)VdType.None);
+				pbRet = ms.ToArray();
+			}
+
+			return pbRet;
+		}
+
+		public static VariantDictionary Deserialize(byte[] pb)
+		{
+			if(pb == null) { Debug.Assert(false); return null; }
+
+			VariantDictionary d = new VariantDictionary();
+			using(MemoryStream ms = new MemoryStream(pb, false))
+			{
+				ushort uVersion = MemUtil.BytesToUInt16(MemUtil.Read(ms, 2));
+				if((uVersion & VdmCritical) > (VdVersion & VdmCritical))
+					throw new FormatException(KLRes.FileNewVerReq);
+
+				while(true)
+				{
+					int iType = ms.ReadByte();
+					if(iType < 0) throw new EndOfStreamException(KLRes.FileCorrupted);
+					byte btType = (byte)iType;
+					if(btType == (byte)VdType.None) break;
+
+					int cbName = MemUtil.BytesToInt32(MemUtil.Read(ms, 4));
+					byte[] pbName = MemUtil.Read(ms, cbName);
+					if(pbName.Length != cbName)
+						throw new EndOfStreamException(KLRes.FileCorrupted);
+					string strName = StrUtil.Utf8.GetString(pbName, 0, pbName.Length);
+
+					int cbValue = MemUtil.BytesToInt32(MemUtil.Read(ms, 4));
+					byte[] pbValue = MemUtil.Read(ms, cbValue);
+					if(pbValue.Length != cbValue)
+						throw new EndOfStreamException(KLRes.FileCorrupted);
+
+					switch(btType)
+					{
+						case (byte)VdType.UInt32:
+							if(cbValue == 4)
+								d.SetUInt32(strName, MemUtil.BytesToUInt32(pbValue));
+							else { Debug.Assert(false); }
+							break;
+
+						case (byte)VdType.UInt64:
+							if(cbValue == 8)
+								d.SetUInt64(strName, MemUtil.BytesToUInt64(pbValue));
+							else { Debug.Assert(false); }
+							break;
+
+						case (byte)VdType.Bool:
+							if(cbValue == 1)
+								d.SetBool(strName, (pbValue[0] != 0));
+							else { Debug.Assert(false); }
+							break;
+
+						case (byte)VdType.Int32:
+							if(cbValue == 4)
+								d.SetInt32(strName, MemUtil.BytesToInt32(pbValue));
+							else { Debug.Assert(false); }
+							break;
+
+						case (byte)VdType.Int64:
+							if(cbValue == 8)
+								d.SetInt64(strName, MemUtil.BytesToInt64(pbValue));
+							else { Debug.Assert(false); }
+							break;
+
+						case (byte)VdType.String:
+							d.SetString(strName, StrUtil.Utf8.GetString(pbValue, 0, pbValue.Length));
+							break;
+
+						case (byte)VdType.ByteArray:
+							d.SetByteArray(strName, pbValue);
+							break;
+
+						default:
+							Debug.Assert(false); // Unknown type
+							break;
+					}
+				}
+
+				Debug.Assert(ms.ReadByte() < 0);
+			}
+
+			return d;
+		}
+	}
+}