--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Cache.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+
+namespace UCIS {
+	public class Cache<TKey, TValue> {
+		private Dictionary<TKey, WeakReference> _items;
+
+		public Cache() {
+			_items = new Dictionary<TKey, WeakReference>();
+		}
+
+		public int Count { get { return _items.Count; } }
+		public int getCount(bool checkAlive) {
+			Purge();
+			return _items.Count;
+		}
+
+		private void getItem(TKey key, out TValue value, out bool exists, out bool collected) {
+			WeakReference w;
+			lock (_items) {
+				if (!_items.TryGetValue(key, out w)) {
+					value = default(TValue);
+					exists = false;
+					collected = false;
+					return;
+				}
+				Object r = w.Target;
+				if (r == null) {
+					_items.Remove(key);
+					value = default(TValue);
+					exists = false;
+					collected = true;
+					return;
+				}
+				value = (TValue)r;
+				exists = true;
+				collected = false;
+				return;
+			}
+		}
+
+		public bool TryGetValue(TKey key, out TValue value) {
+			bool exists, collected;
+			getItem(key, out value, out exists, out collected);
+			return exists;
+		}
+
+		public void Purge() {
+			lock (_items) {
+				List<TKey> remove = new List<TKey>();
+				foreach (KeyValuePair<TKey, WeakReference> kvp in _items) {
+					if (!kvp.Value.IsAlive) remove.Add(kvp.Key);
+				}
+				foreach (TKey key in remove) {
+					_items.Remove(key);
+				}
+			}
+		}
+
+		public void Add(TKey key, TValue value) {
+			lock(_items) _items.Add(key, new WeakReference(value));
+		}
+
+		public bool Remove(TKey key) {
+			lock(_items) return _items.Remove(key);
+		}
+
+		public void Clear() {
+			_items.Clear();
+		}
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Cci/CciCommand.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,195 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UCIS.Pml;
+
+namespace UCIS.Cci {
+	public enum CciResultType {
+		Success,
+		Error,
+		Value,
+		Message,
+		List,
+		Pml,
+		Object,
+		Binary
+	}
+
+	public class CciResult {
+		private CciResultType _type;
+		private Object _value;
+
+		public CciResult(CciResultType type, Object value) {
+			_type = type;
+			_value = value;
+		}
+		public CciResult(CciResultType type) : this(type, null) { }
+		public CciResult(Exception ex) : this(CciResultType.Error, ex) { }
+		public CciResult(Pml.PmlElement pml) : this(CciResultType.Pml, pml) { }
+		public CciResult(byte[] binary) : this(CciResultType.Binary, binary) { }
+		public CciResult(string[] stringList) : this(CciResultType.List, stringList) { }
+		public CciResult(string message) : this(CciResultType.Message, message) { }
+
+		public override string ToString() {
+			if (_value == null) {
+				return _type.ToString();
+			} else {
+				return _type.ToString() + ": " + ValueToString();
+			}
+		}
+		public string ValueToString() {
+			if (_value == null) {
+				return "";
+			} else if (_value is string) {
+				return (string)_value;
+			} else if (_value is byte[]) {
+				return Encoding.UTF8.GetString((byte[])_value);
+			} else if (_value is PmlElement) {
+					return Pml.PmlTextWriter.GetMessageString((PmlElement)_value);
+			} else if (_value is IEnumerable<Object>) {
+				StringBuilder sb = new StringBuilder();
+				foreach (Object i in (Array)_value) sb.AppendLine(i.ToString());
+				return sb.ToString();
+			} else {
+				return _value.ToString();
+			}
+		}
+		public PmlElement ValueToPml() {
+			if (_value == null) return new PmlNull();
+			switch (_type) {
+				case CciResultType.Binary: return new PmlBinary((byte[])_value);
+				case CciResultType.Message:
+				case CciResultType.Object:
+				case CciResultType.Value:
+				case CciResultType.Error: return new PmlString(_value.ToString());
+				case CciResultType.Success: return new PmlInteger(1);
+				case CciResultType.List: {
+						PmlCollection c = new PmlCollection();
+						foreach (Object i in (Array)_value) c.Add(i.ToString());
+						return c;
+					}
+				case CciResultType.Pml: return (PmlElement)_value;
+				default: return new PmlString("Unknown type: " + _type.ToString());
+			}
+		}
+		public PmlElement ToPml() {
+			PmlDictionary d = new PmlDictionary();
+			//d.Add("Type", (int)_type);
+			d.Add("Type", (int)CciResultType.Message);
+			//d.Add("TypeName", _type.ToString());
+			d.Add("TypeName", "Message");
+			//d.Add("Value", ValueToPml());
+			d.Add("Value", ToString());
+			d.Add("String", ToString());
+			return d;
+		}
+
+		public CciResultType Type { get { return _type; } }
+		public Object Value { get { return _value; } }
+	}
+
+	public class CciCommand {
+		private string[] _command;
+		private int _offset;
+		private CciResult _result;
+
+		public CciCommand(string[] command) {
+			_command = command;
+			_offset = 0;
+			_result = null;
+		}
+
+		public int Offset { get { return _offset; } set { _offset = value; } }
+
+		public static CciCommand Parse(string command, bool urlEncode, bool cEscape, bool quotes) {
+			List<string> l = new List<string>();
+
+			StringBuilder part = new StringBuilder();
+			bool inQuotes = false;
+			int len = command.Length;
+			for (int i = 0; i < len; i++) {
+				char c = command[i];
+				if (quotes && !inQuotes && c == '"') {
+					inQuotes = true;
+				} else if (quotes && inQuotes && c == '"') {
+					inQuotes = false;
+				} else if (urlEncode && c == '%') {
+					part.Append(Uri.HexUnescape(command, ref i));
+					i--;
+				} else if (cEscape && c == '\\' && i + 1 < len) {
+					i++;
+					switch (command[i]) {
+						case 't': part.Append('\t'); break;
+						case 'n': part.Append('\n'); break;
+						case 'r': part.Append('\r'); break;
+						default: part.Append(command[i]); break;
+					}
+				} else if (!inQuotes && (c == ' ' || c == '\t')) {
+					if (part.Length > 0) l.Add(part.ToString());
+					part.Length = 0;
+				} else {
+					part.Append(c);
+				}
+			}
+			if (part.Length > 0) l.Add(part.ToString());
+
+			return new CciCommand(l.ToArray());
+		}
+
+		public PmlCollection ToPml() { return ToPml(0); }
+		public PmlCollection ToPml(int offset) {
+			PmlCollection c = new PmlCollection();
+			for (int i = _offset + offset; i < _command.Length; i++) c.Add(_command[i]);
+			return c;
+		}
+		public static CciCommand FromPml(PmlCollection pml) {
+			List<string> l = new List<string>();
+			foreach (PmlElement e in pml) l.Add(e.ToString());
+			return new CciCommand(l.ToArray());
+		}
+
+		public string Command {
+			get {
+				return _command[_offset];
+			}
+		}
+
+		public string GetArgument(int index) {
+			return _command[_offset + index + 1];
+		}
+
+		public CciCommand Jump(int offset) {
+			_offset += offset;
+			return this;
+		}
+
+		public int Count {
+			get {
+				return _command.Length - _offset - 1;
+			}
+		}
+
+		public CciResult Result {
+			get {
+				return _result;
+			}
+			set {
+				_result = value;
+			}
+		}
+
+		public CciCommand Return(CciResult result) {
+			_result = result;
+			return this;
+		}
+		public CciCommand Return(CciResultType type, Object value) { return Return(new CciResult(type, value)); }
+		public CciCommand Return() { return Return(CciResultType.Success); }
+		public CciCommand Return(int value) { return Return(CciResultType.Value, value); }
+		public CciCommand Return(CciResultType type) { return Return(type, null); }
+		public CciCommand Return(Exception ex) { return Return(CciResultType.Error, ex); }
+		public CciCommand Return(PmlElement pml) { return Return(CciResultType.Pml, pml); }
+		public CciCommand Return(byte[] binary) { return Return(CciResultType.Binary, binary); }
+		public CciCommand Return(string[] stringList) { return Return(CciResultType.List, stringList); }
+		public CciCommand Return(string message) { return Return(CciResultType.Message, message); }
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DBReader.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,103 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+
+namespace UCIS {
+	public class DBReader : IEnumerable, IEnumerator {
+		private IDbCommand _Command;
+		private IDataReader _Reader;
+		private object[] _CurrentRow;
+
+		internal DBReader(IDbCommand Command) {
+			_Command = Command;
+		}
+
+		public bool Read() {
+			if (_Reader == null) {
+				if (_Command == null) return false;
+				_Reader = _Command.ExecuteReader();
+			}
+			if (_Reader.Read()) {
+				return true;
+			} else {
+				Close();
+				return false;
+			}
+		}
+
+		public void Close() {
+			if (_Reader != null) _Reader.Close();
+			if (_Command != null) {
+				_Command.Connection.Close();
+				_Command.Dispose();
+			}
+			_Command = null;
+			_CurrentRow = null;
+			_Reader = null;
+		}
+
+		public object GetField() {
+			if (_Reader == null) {
+				return _Command.ExecuteScalar();
+			} else {
+				return _Reader.GetValue(0);
+			}
+		}
+
+		public object GetField(int Offset) {
+			if (_Reader == null) Read();
+			return _Reader.GetValue(Offset);
+		}
+		public object[] GetRow(bool GoNextRow) {
+			object[] Result = null;
+			if (_Reader == null) {
+				if (!Read()) return null;
+			}
+			Result = new object[_Reader.FieldCount];
+
+			_Reader.GetValues(Result);
+			if (GoNextRow) Read();
+			return Result;
+		}
+		public object[] GetRow() {
+			return GetRow(true);
+		}
+		public object[][] GetAllRows() {
+			List<object[]> Result = new List<object[]>();
+			object[] ResultArray = null;
+			if (_Reader == null) {
+				if (!Read()) return null;
+			}
+			do {
+				ResultArray = new object[_Reader.FieldCount];
+
+				_Reader.GetValues(ResultArray);
+				Result.Add(ResultArray);
+			}
+			while (_Reader.Read());
+			Close();
+			return Result.ToArray();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return this;
+		}
+		object IEnumerator.Current {
+			get { return _CurrentRow; }
+		}
+		bool IEnumerator.MoveNext() {
+			if (!Read()) return false;
+			_CurrentRow = GetRow(false);
+			return true;
+		}
+		void IEnumerator.Reset() {
+			throw new NotImplementedException();
+		}
+
+		public void Dispose() {
+			Close();
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Database.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,127 @@
+using System;
+using System.Reflection;
+using System.Data;
+using System.Data.Common;
+using System.Collections.Generic;
+
+namespace UCIS {
+	public class Database {
+		private delegate object ConstructorDelegate();
+		private ConstructorInfo _ConnectionConstructor;
+
+		public Database(Type DBConnectionType, string connectionString) {
+			this.ConnectionString = connectionString;
+			_ConnectionConstructor = DBConnectionType.GetConstructor(new Type[] { });
+		}
+
+		public string ConnectionString { get; set; }
+
+		public virtual IDbConnection GetConnection() {
+			lock (_ConnectionConstructor) {
+				IDbConnection conn = (IDbConnection)_ConnectionConstructor.Invoke(null);
+				conn.ConnectionString = ConnectionString;
+				conn.Open();
+				return conn;
+			}
+		}
+
+		public IDbCommand PrepareQuery(string Query, params object[] Parameters) {
+			int ParameterI = 0;
+			IDbConnection Connection = GetConnection();
+			try {
+				IDbCommand Command = Connection.CreateCommand();
+				Command.CommandType = CommandType.Text;
+				Command.CommandText = Query;
+				Command.Parameters.Clear();
+				foreach (object Parameter in Parameters) {
+					IDbDataParameter DBParameter = Command.CreateParameter();
+					DBParameter.Direction = ParameterDirection.Input;
+					DBParameter.ParameterName = "?" + ParameterI.ToString();
+					DBParameter.Value = Parameter;
+					Command.Parameters.Add(DBParameter);
+					ParameterI++;
+				}
+				if (ParameterI > 0) Command.Prepare();
+				return Command;
+			} catch (Exception ex) {
+				Connection.Close();
+				throw ex;
+			}
+		}
+
+		public int NonQuery(string QueryString, params object[] Parameters) {
+			IDbCommand Command = PrepareQuery(QueryString, Parameters);
+			try {
+				return Command.ExecuteNonQuery();
+			} finally {
+				Command.Connection.Close();
+			}
+		}
+
+		public object FetchField(string QueryString, params object[] Parameters) {
+			IDbCommand Command = PrepareQuery(QueryString, Parameters);
+			try {
+				return Command.ExecuteScalar();
+			} finally {
+				Command.Connection.Close();
+			}
+		}
+		public object[] FetchRow(string QueryString, params object[] Parameters) {
+			IDbCommand Command = PrepareQuery(QueryString, Parameters);
+			try {
+				IDataReader Reader = Command.ExecuteReader();
+				try {
+					if (!Reader.Read()) return null;
+					object[] Result = new object[Reader.FieldCount];
+					Reader.GetValues(Result);
+					return Result;
+				} finally {
+					Reader.Close();
+				}
+			} finally {
+				Command.Connection.Close();
+			}
+		}
+		public object[][] FetchRows(string QueryString, params object[] Parameters) {
+			IDbCommand Command = PrepareQuery(QueryString, Parameters);
+			try {
+				IDataReader Reader = Command.ExecuteReader();
+				try {
+					List<object[]> Result = new List<object[]>();
+					while (Reader.Read()) {
+						object[] ResultArray = new object[Reader.FieldCount];
+						Reader.GetValues(ResultArray);
+						Result.Add(ResultArray);
+					}
+					return Result.ToArray();
+				} finally {
+					Reader.Close();
+				}
+			} finally {
+				Command.Connection.Close();
+			}
+		}
+		public void ForEachRow(Action<Object[]> f, string QueryString, params object[] Parameters) {
+			IDbCommand Command = PrepareQuery(QueryString, Parameters);
+			try {
+				IDataReader Reader = Command.ExecuteReader();
+				try {
+					while (Reader.Read()) {
+						object[] ResultArray = new object[Reader.FieldCount];
+						Reader.GetValues(ResultArray);
+						f(ResultArray);
+					}
+				} finally {
+					Reader.Close();
+				}
+			} finally {
+				Command.Connection.Close();
+			}
+
+		}
+
+		/*public DBReader GetReader(string QueryString, params object[] Parameters) {
+			return new DBReader(PrepareQuery(QueryString, Parameters));
+		}*/
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Net/ConnectionList.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,133 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UCIS.Net {
+	public class NetworkConnectionList : ICollection<INetworkConnection> {
+		List<INetworkConnection> _list = new List<INetworkConnection>();
+
+		public ulong BytesWritten {
+			get {
+				ulong sum = 0;
+				lock (_list) foreach (INetworkConnection c in _list) sum += c.BytesWritten;
+				return sum;
+			}
+		}
+		public ulong BytesRead {
+			get {
+				ulong sum = 0;
+				lock (_list) foreach (INetworkConnection c in _list) sum += c.BytesRead;
+				return sum;
+			}
+		}
+		public NetworkConnectionList FindByHandler(Object Handler) {
+			NetworkConnectionList l = new NetworkConnectionList();
+			lock (_list) foreach (INetworkConnection c in _list) if (c.Handler == Handler) l.Add(c);
+			return l;
+		}
+		public NetworkConnectionList FindByHandlerType(Type HandlerType) {
+			NetworkConnectionList l = new NetworkConnectionList();
+			lock (_list) foreach (INetworkConnection c in _list) if (c.Handler.GetType() == HandlerType) l.Add(c);
+			return l;
+		}
+		public void CloseAll() {
+			foreach (INetworkConnection c in ToArray()) c.Close();
+		}
+
+		public void Add(INetworkConnection item) {
+			if (item == null) throw new ArgumentNullException("item");
+			lock (_list) _list.Add(item);
+			item.Closed += _ConnectionClosed;
+			if (!item.Connected) Remove(item);
+		}
+		public void Insert(int index, INetworkConnection item) {
+			throw new NotSupportedException();
+		}
+		public bool Remove(INetworkConnection item) {
+			if (item == null) throw new ArgumentNullException("item");
+			item.Closed -= _ConnectionClosed;
+			lock (_list) return _list.Remove(item);
+		}
+		public void RemoveAt(int index) {
+			lock (_list) {
+				INetworkConnection item = _list[index];
+				item.Closed -= _ConnectionClosed;
+				_list.Remove(item);
+			}
+		}
+		public int Count { get { lock (_list) return _list.Count; } }
+		public bool IsReadOnly { get { return false; } }
+		public bool Contains(INetworkConnection item) {
+			lock (_list) return _list.Contains(item);
+		}
+		public void Clear() {
+			lock (_list) {
+				foreach (INetworkConnection c in _list) c.Closed -= _ConnectionClosed;
+				_list.Clear();
+			}
+		}
+		public INetworkConnection this[int index] {
+			get { return _list[index]; }
+			set { throw new NotSupportedException(); }
+		}
+		public int IndexOf(INetworkConnection item) {
+			lock (_list) return _list.IndexOf(item);
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return new Enumerator(_list);
+		}
+		public IEnumerator<INetworkConnection> GetEnumerator() {
+			return new Enumerator(_list);
+		}
+
+		public void CopyTo(INetworkConnection[] array, int offset) {
+			lock (_list) _list.CopyTo(array, offset);
+		}
+
+		public INetworkConnection[] ToArray() {
+			lock (_list) return _list.ToArray();
+		}
+
+		private void _ConnectionClosed(Object sender, EventArgs e) {
+			if (sender == null || !(sender is INetworkConnection)) return;
+			Remove((INetworkConnection)sender);
+		}
+
+		private class Enumerator : IEnumerator<INetworkConnection> {
+			int index = 0;
+			INetworkConnection current = null;
+			IList<INetworkConnection> list;
+
+			public Enumerator(IList<INetworkConnection> list) {
+				this.list = list;
+			}
+
+			public void Reset() {
+				index = 0;
+			}
+			public bool MoveNext() {
+				lock (list) {
+					if (index < list.Count) {
+						current = list[index];
+						index++;
+						return true;
+					} else {
+						current = null;
+						return false;
+					}
+				}
+			}
+			public INetworkConnection Current {
+				get { return current; } 
+			}
+			object IEnumerator.Current {
+				get { return current; }
+			}
+			public void Dispose() {
+				current = null;
+				list = null;
+			}
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Net/HTTP.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+
+namespace UCIS.Net.HTTP {
+	public class HTTPServer : TCPServer.IModule {
+		public Dictionary<string, HTTPContent> Content = new Dictionary<string, HTTPContent>(StringComparer.InvariantCultureIgnoreCase);
+		public HTTPContent DefaultContent = null;
+
+		public bool Accept(TCPStream Stream) {
+			StreamReader StreamReader = new StreamReader(Stream, Encoding.ASCII);
+			String Line = StreamReader.ReadLine();
+			String[] Request = Line.Split(' ');
+
+			//Console.WriteLine("HTTP.Server.Accept Request: " + Line);
+
+			if (Request == null || Request.Length < 2 || Request[0] != "GET" || Request[1][0] != '/') {
+				//Console.WriteLine("HTTP.Server.Start Bad request");
+				SendError(Stream, 400);
+				return true;
+			}
+
+			Request = Request[1].Split(new Char[] { '?' }, 2);
+			HTTPContent content;
+			if (Content.TryGetValue(Request[0], out content)) {
+			} else if (DefaultContent != null) {
+				content = DefaultContent;
+			} else {
+				SendError(Stream, 404);
+				return true;
+			}
+			HTTPContext Context = new HTTPContext();
+			Context.Stream = Stream;
+			Context.Request = new HTTPRequest();
+			Context.Request.Method = Method.GET;
+			Context.Request.Path = Request[0];
+			if (Request.Length == 2) {
+				Context.Request.Query = Request[1];
+			} else {
+				Context.Request.Query = null;
+			}
+			HTTPContent.Result ServeResult = content.Serve(Context);
+
+			if (ServeResult == HTTPContent.Result.OK_KEEPALIVE) {
+				return false;
+			} else if (!(ServeResult == HTTPContent.Result.OK_CLOSE)) {
+				SendError(Stream, (int)ServeResult);
+			}
+			return true;
+		}
+
+		public static void SendError(Stream Stream, int ErrorCode) {
+			string ErrorText = null;
+			switch (ErrorCode) {
+				case 400:
+					ErrorText = "The request could not be understood by the server due to malformed syntax.";
+					break;
+				case 404:
+					ErrorText = "The requested file can not be found.";
+					break;
+				default:
+					ErrorText = "Unknown error code: " + ErrorCode.ToString() + ".";
+					break;
+			}
+			SendHeader(Stream, ErrorCode, "text/plain", ErrorText.Length);
+			WriteLine(Stream, ErrorText);
+			Thread.Sleep(100);
+			return;
+		}
+
+		public static void SendHeader(Stream Stream, int ResultCode, string ContentType) {
+			SendHeader(Stream, ResultCode, ContentType, -1);
+		}
+		public static void SendHeader(Stream Stream, int ResultCode, string ContentType, int ContentLength) {
+			//ResultCode = 200, ContentType = null, ContentLength = -1
+			string ResultString;
+			switch (ResultCode) {
+				case 200: ResultString = "OK"; break;
+				case 400: ResultString = "Bad Request"; break;
+				case 404: ResultString = "Not found"; break;
+				default: ResultString = "Unknown"; break;
+			}
+			WriteLine(Stream, "HTTP/1.1 " + ResultCode.ToString() + " " + ResultString);
+			WriteLine(Stream, "Expires: Mon, 26 Jul 1990 05:00:00 GMT");
+			WriteLine(Stream, "Cache-Control: no-store, no-cache, must-revalidate");
+			WriteLine(Stream, "Cache-Control: post-check=0, pre-check=0");
+			WriteLine(Stream, "Pragma: no-cache");
+			WriteLine(Stream, "Server: UCIS Simple Webserver");
+			WriteLine(Stream, "Connection: Close");
+			if ((ContentType != null)) WriteLine(Stream, "Content-Type: " + ContentType);
+			if (ContentLength != -1) WriteLine(Stream, "Content-Length: " + ContentLength.ToString());
+			WriteLine(Stream, "");
+		}
+
+		public static void WriteLine(Stream Stream, string Line) {
+			byte[] Buffer = null;
+			Buffer = Encoding.ASCII.GetBytes(Line);
+			Stream.Write(Buffer, 0, Buffer.Length);
+			Stream.WriteByte(13);
+			Stream.WriteByte(10);
+		}
+	}
+
+	public abstract class HTTPContent {
+		public abstract Result Serve(HTTPContext Context);
+		public enum Result : int {
+			OK_CLOSE = -2,
+			OK_KEEPALIVE = -1,
+			ERR_NOTFOUND = 404
+		}
+	}
+
+	public class HTTPFileContent : HTTPContent {
+		public string Filename { get; private set; }
+		public string ContentType { get; private set; }
+
+		public HTTPFileContent(string Filename) : this(Filename, "application/octet-stream") { }
+		public HTTPFileContent(string Filename, string ContentType) {
+			this.Filename = Filename;
+			this.ContentType = ContentType;
+		}
+
+		public override Result Serve(HTTPContext Context) {
+			if (!File.Exists(Filename)) return Result.ERR_NOTFOUND;
+
+			using (FileStream FileStream = File.OpenRead(Filename)) {
+				HTTPServer.SendHeader(Context.Stream, 200, ContentType, (int)FileStream.Length);
+				byte[] Buffer = new byte[1025];
+				while (FileStream.CanRead) {
+					int Length = FileStream.Read(Buffer, 0, Buffer.Length);
+					if (Length <= 0) break;
+					Context.Stream.Write(Buffer, 0, Length);
+				}
+			}
+			return Result.OK_CLOSE;
+		}
+	}
+
+	public class HTTPContext {
+		public HTTPRequest Request { get; internal set; }
+		public TCPStream Stream { get; internal set; }
+	}
+
+	public enum Method {
+		GET = 0,
+		HEAD = 1,
+		POST = 2,
+		PUT = 3
+	}
+
+	public class HTTPRequest {
+		public HTTP.Method Method { get; internal set; }
+		public string Path { get; internal set; }
+		public string Query { get; internal set; }
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Net/INetworkConnection.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,16 @@
+using System;
+using System.Net;
+
+namespace UCIS.Net {
+	public interface INetworkConnection {
+		event EventHandler Closed;
+		void Close();
+		bool Connected { get; }
+		ulong BytesWritten { get; }
+		ulong BytesRead { get; }
+		TimeSpan Age { get; }
+		EndPoint RemoteEndPoint { get; }
+		//Object Proxy { get; }
+		Object Handler { get; }
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Net/TCPServer.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,235 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Collections.Generic;
+
+namespace UCIS.Net {
+	public class TCPServer {
+		public class ModuleCollection : Dictionary<byte, IModule> {
+			public void Add(char Key, IModule Value) {
+				base.Add((byte)Key, Value);
+			}
+			public void Remove(char Key) {
+				base.Remove((byte)Key);
+			}
+		}
+
+		public class ClientAcceptedEventArgs : EventArgs {
+			private TCPStream _client;
+			internal ClientAcceptedEventArgs(TCPStream client) {
+				_client = client;
+			}
+			public TCPStream Client { get { return _client; } }
+		}
+
+		public event EventHandler<ClientAcceptedEventArgs> ClientAccepted;
+
+		private Socket _Listener;
+		private UCIS.ThreadPool _ThreadPool;
+		private NetworkConnectionList _Clients = new NetworkConnectionList();
+		private ModuleCollection _Modules = new ModuleCollection();
+		private IModule _CatchAllModule = null;
+		private Int32 _ThrottleCounter;
+		private Int32 _ThrottleBurst = 10;
+		private Int32 _ThrottleRate = 0;
+		private Timer _ThrottleTimer = null;
+
+		public TCPServer() {
+			_ThreadPool = UCIS.ThreadPool.DefaultPool;
+		}
+
+		public NetworkConnectionList Clients {
+			get { return _Clients; }
+		}
+
+		public ModuleCollection Modules {
+			get { return _Modules; }
+		}
+
+		public IModule CatchAllModule {
+			get {
+				return _CatchAllModule;
+			}
+			set {
+				_CatchAllModule = value;
+			}
+		}
+
+		public Int32 ThrottleRate {
+			get { return _ThrottleRate; }
+			set {
+				if (value < 0) throw new ArgumentOutOfRangeException("value");
+				_ThrottleRate = value;
+				if (_Listener == null) return;
+				if (value == 0 && _ThrottleTimer != null) {
+					_ThrottleTimer.Dispose();
+					_ThrottleTimer = null;
+				} else if (value > 0 && _ThrottleTimer == null) {
+					_ThrottleTimer = new Timer(ThrottleCallback, null, 1000, 1000);
+				}
+			}
+		}
+		public Int32 ThrottleBurst {
+			get { return _ThrottleBurst; }
+			set {
+				if (value < 1) throw new ArgumentOutOfRangeException("value");
+				_ThrottleBurst = value;
+			}
+		}
+
+		public EndPoint LocalEndPoint { get { return _Listener.LocalEndPoint; } }
+
+		public void Listen(int Port) {
+			Listen(AddressFamily.InterNetwork, Port);
+		}
+		public void Listen(AddressFamily af, int Port) {
+			Stop();
+
+			_Listener = new Socket(af, SocketType.Stream, ProtocolType.Tcp);
+
+			_Listener.Blocking = false;
+			_Listener.Bind(new IPEndPoint(af == AddressFamily.InterNetworkV6 ? IPAddress.IPv6Any : IPAddress.Any, Port));
+			_Listener.Listen(25);
+			_ThrottleCounter = _ThrottleBurst;
+			_Listener.BeginAccept(AcceptCallback, null);
+
+			if (_ThrottleRate > 0) {
+				_ThrottleTimer = new Timer(ThrottleCallback, null, 1000, 1000);
+			}
+		}
+
+		public void Stop() {
+			if (_ThrottleTimer != null) _ThrottleTimer.Dispose();
+			if (_Listener != null && _Listener.IsBound) _Listener.Close();
+			_Listener = null;
+		}
+
+		public void Close() {
+			Close(true);
+		}
+		public void Close(bool CloseClients) {
+			Stop();
+			if (CloseClients) {
+				_Clients.CloseAll();
+				if (_Clients.Count > 0) Console.WriteLine("TCPServer.Close: Warning: " + _Clients.Count.ToString() + " connections were not properly terminated.");
+			} else {
+				_Clients.Clear();
+			}
+		}
+
+		private void AcceptCallback(System.IAsyncResult ar) {
+			Client Client = null;
+			Socket Socket = null;
+			if (_Listener == null) return;
+			try {
+				Socket = _Listener.EndAccept(ar);
+			} catch (ObjectDisposedException) {
+				Console.WriteLine("TCPServer.AcceptCallback Listener object has been disposed. Aborting.");
+				return;
+			} catch (SocketException ex) {
+				Console.WriteLine("TCPServer.AcceptCallback SocketException: " + ex.Message);
+				Socket = null;
+			}
+			if (Socket != null) {
+				try {
+					Client = new Client(Socket, this);
+					_Clients.Add(Client);
+					if (ClientAccepted != null) ClientAccepted(this, new ClientAcceptedEventArgs(Client));
+					Client.Start(_ThreadPool);
+				} catch (Exception ex) {
+					Console.WriteLine(ex.ToString());
+				}
+			}
+			if (_ThrottleCounter > 0 || _ThrottleRate == 0) {
+				_ThrottleCounter--;
+				_Listener.BeginAccept(AcceptCallback, null);
+			}
+		}
+
+		private void ThrottleCallback(Object state) {
+			if (_Listener == null) return;
+			if (_ThrottleRate == 0) return;
+			if (_ThrottleCounter >= _ThrottleBurst) return;
+			if (_ThrottleCounter <= 0) {
+				_Listener.BeginAccept(AcceptCallback, null);
+			}
+			_ThrottleRate += _ThrottleRate;
+		}
+
+		public interface IModule {
+			// Return value: True = Close connection, False = keep alive
+			bool Accept(TCPStream Stream);
+		}
+
+		private class Client : TCPStream {
+			private TCPServer _Server;
+			private UCIS.ThreadPool.WorkItem _WorkItem;
+			private IModule _Module;
+			private byte _MagicNumber;
+
+			public TCPServer Server {
+				get { return _Server; }
+			}
+			public IModule Module {
+				get { return _Module; }
+			}
+
+			private void _Stream_Closed(object sender, EventArgs e) {
+				_WorkItem = null;
+				_Module = null;
+				_Server = null;
+				base.Closed -= _Stream_Closed;
+			}
+
+			internal Client(Socket Socket, TCPServer Server) : base(Socket) {
+				_Server = Server;
+				Socket.Blocking = true;
+				base.Closed += _Stream_Closed;
+				this.Tag = Server;
+			}
+
+			internal void Start(UCIS.ThreadPool Pool) {
+				_WorkItem = Pool.QueueWorkItem(WorkerProc, null);
+			}
+
+			private void WorkerProc(object state) {
+				bool CloseSocket = true;
+				try {
+					try {
+						base.Blocking = true;
+						//base.NoDelay = true;
+						base.ReadTimeout = 5000;
+						base.WriteBufferSize = 1024 * 10;
+						base.ReadBufferSize = 1024 * 10;
+						//Console.WriteLine("TCPServer: Accepted connection from " + base.Socket.RemoteEndPoint.ToString());
+						_MagicNumber = (byte)base.PeekByte();
+					} catch (TimeoutException ex) {
+						Console.WriteLine("TCPServer: Caught TimeoutException while reading magic number: " + ex.Message);
+						return;
+					}
+					if (_Server._Modules.TryGetValue(_MagicNumber, out _Module)) {
+						this.Tag = _Module;
+						CloseSocket = _Module.Accept(this);
+					} else if (_Server._CatchAllModule != null) {
+						this.Tag = _Server._CatchAllModule;
+						CloseSocket = _Server._CatchAllModule.Accept(this);
+					} else {
+						this.Tag = this;
+						Console.WriteLine("TCPServer: Unknown magic number: " + _MagicNumber.ToString());
+					}
+				} catch (ThreadAbortException) {
+					Console.WriteLine("TCPServer: Caught ThreadAbortException");
+				} catch (SocketException ex) {
+					Console.WriteLine("TCPServer: Caught SocketException: " + ex.Message);
+				} catch (Exception ex) {
+					Console.WriteLine("TCPServer: Caught Exception: " + ex.ToString());
+				} finally {
+					try {
+						if (CloseSocket) base.Close();
+					} catch { }
+				}
+			}
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Net/TCPStream.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,254 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace UCIS.Net {
+	public class TCPStream : Stream, INetworkConnection {
+		private static long _totalBytesRead = 0;
+		private static long _totalBytesWritten = 0;
+		public static ulong TotalBytesWritten { get { return (ulong)_totalBytesWritten; } set { _totalBytesWritten = (long)value; } }
+		public static ulong TotalBytesRead { get { return (ulong)_totalBytesRead; } set { _totalBytesRead = (long)value; } }
+
+		private Socket _Socket;
+		private byte _PeekByte;
+		private bool _HasPeekByte;
+		private ulong _BytesWritten;
+		private ulong _BytesRead;
+		private DateTime _StartTime;
+		private bool _Blocking;
+
+		public event EventHandler Closed;
+
+		public TCPStream(Socket Socket) {
+			_Socket = Socket;
+			_HasPeekByte = false;
+			_StartTime = DateTime.Now;
+			_Blocking = _Socket.Blocking;
+		}
+
+		public Socket Socket {
+			get { return _Socket; }
+		}
+
+		public DateTime CreationTime {
+			get { return _StartTime; }
+		}
+
+		public bool Blocking {
+			get { return _Blocking; }
+			set {
+				Socket.Blocking = value;
+				_Blocking = value;
+			}
+		}
+
+		public bool NoDelay {
+			get { return Socket.NoDelay; }
+			set { Socket.NoDelay = value; }
+		}
+
+		public override bool CanTimeout {
+			get { return true; }
+		}
+
+		public override int ReadTimeout {
+			get { return Socket.ReceiveTimeout; }
+			set { Socket.ReceiveTimeout = value; }
+		}
+
+		public override int WriteTimeout {
+			get { return Socket.SendTimeout; }
+			set { Socket.SendTimeout = value; }
+		}
+
+		public override int ReadByte() {
+			if (_HasPeekByte) {
+				_HasPeekByte = false;
+				return _PeekByte;
+			} else {
+				byte[] Buffer = new byte[1];
+				if (Read(Buffer, 0, 1) != 1) return -1;
+				return Buffer[0];
+			}
+		}
+
+		public override int Read(byte[] buffer, int offset, int size) {
+			int Count = 0;
+
+			if (size < 1) return 0;
+			if (_HasPeekByte) {
+				buffer[offset] = _PeekByte;
+				_HasPeekByte = false;
+				Count = 1;
+				offset += 1;
+				size -= 1;
+			}
+
+			try {
+				if (size > 0) Count += Socket.Receive(buffer, offset, size, SocketFlags.None);
+			} catch (SocketException ex) {
+				switch (ex.SocketErrorCode) {
+					case SocketError.WouldBlock:
+						_Socket.Blocking = _Blocking;
+						throw new TimeoutException("The receive operation would block", ex);
+					case SocketError.TimedOut:
+						throw new TimeoutException("The receive operation timed out", ex);
+					case SocketError.ConnectionReset:
+					case SocketError.Disconnecting:
+					case SocketError.NetworkDown:
+					case SocketError.NetworkReset:
+					case SocketError.NetworkUnreachable:
+					case SocketError.NotConnected:
+						Close();
+						throw new SocketException((int)ex.SocketErrorCode);
+					default:
+						throw new SocketException((int)ex.SocketErrorCode);
+				}
+			}
+
+			_BytesRead += (ulong)Count;
+			Interlocked.Add(ref _totalBytesRead, (long)Count);
+			return Count;
+		}
+
+		public int PeekByte() {
+			if (_HasPeekByte) {
+				return _PeekByte;
+			} else {
+				int Result = 0;
+				Result = ReadByte();
+				if (Result >= 0 && Result <= 255) {
+					_PeekByte = (byte)Result;
+					_HasPeekByte = true;
+				}
+				return Result;
+			}
+		}
+
+		public int WriteBufferSize {
+			get { return Socket.SendBufferSize; }
+			set { Socket.SendBufferSize = value; }
+		}
+
+		public int ReadBufferSize {
+			get { return Socket.ReceiveBufferSize; }
+			set { Socket.ReceiveBufferSize = value; }
+		}
+
+		public override bool CanRead {
+			get { return Socket.Connected && (Blocking || (Socket.Available > 0)); }
+		}
+
+		public override bool CanSeek {
+			get { return false; }
+		}
+
+		public override bool CanWrite {
+			get { return Socket.Connected; }
+		}
+
+		public override void Flush() {
+			//Do nothing
+			//_Socket.NoDelay = true;
+		}
+
+		public override long Length {
+			get {
+				throw new NotSupportedException();
+			}
+		}
+
+		public override long Position {
+			get {
+				throw new NotSupportedException();
+			}
+			set {
+				throw new NotSupportedException();
+			}
+		}
+
+		public override long Seek(long offset, SeekOrigin origin) {
+			throw new NotSupportedException();
+		}
+
+		public override void SetLength(long value) {
+			throw new NotSupportedException();
+		}
+
+		public override void Write(byte[] buffer, int offset, int size) {
+			int left = size;
+			if (_Socket == null) throw new ObjectDisposedException("socket");
+			try {
+				while (left > 0) {
+					int sent = _Socket.Send(buffer, offset, left, 0);
+					left -= sent;
+					offset += sent;
+				}
+			} catch (SocketException ex) {
+				switch (ex.SocketErrorCode) {
+					case SocketError.WouldBlock:
+						_Socket.Blocking = _Blocking;
+						throw new TimeoutException("The send operation would block", ex);
+					case SocketError.TimedOut:
+						throw new TimeoutException("The send operation timed out", ex);
+					case SocketError.ConnectionReset:
+					case SocketError.Disconnecting:
+					case SocketError.NetworkDown:
+					case SocketError.NetworkReset:
+					case SocketError.NetworkUnreachable:
+					case SocketError.NotConnected:
+						Close();
+						throw new SocketException((int)ex.SocketErrorCode);
+					default:
+						throw new SocketException((int)ex.SocketErrorCode);
+				}
+			}
+			_BytesWritten += (ulong)size;
+			Interlocked.Add(ref _totalBytesWritten, (long)size);
+		}
+
+		public override void Close() {
+			System.Net.Sockets.Socket s = Interlocked.Exchange(ref _Socket, null);
+			try {
+				if (s != null) {
+					try {
+						if (s.Connected) s.Shutdown(SocketShutdown.Both);
+					} catch { }
+					s.Close();
+				}
+			} finally {
+				base.Close();
+				if (Closed != null) Closed(this, new EventArgs());
+			}
+		}
+
+		public bool Connected {
+			get {
+				if (Socket == null) return false;
+				if (Socket.Connected) return true;
+				Close();
+				return false;
+			}
+		}
+
+		public object Tag { get; set; }
+
+		public ulong BytesWritten { get { return _BytesWritten; } }
+		public ulong BytesRead { get { return _BytesRead; } }
+		public TimeSpan Age { get { return DateTime.Now.Subtract(_StartTime); } }
+		public EndPoint RemoteEndPoint {
+			get {
+				if (_Socket == null || !_Socket.Connected) return null;
+				try {
+					return _Socket.RemoteEndPoint;
+				} catch (SocketException) {
+					return null;
+				}
+			}
+		}
+		//public Object Proxy { get { return null; } }
+		Object INetworkConnection.Handler { get { return Tag; } }
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Channels/ActivePmlChannel.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,107 @@
+using System;
+using UCIS.Pml;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace UCIS.Pml {
+	public abstract class ActivePmlChannel : IPmlChannel {
+		private AutoResetEvent _receiveEvent = new AutoResetEvent(false);
+		private ReadMessageAsyncResult _asyncWait = null;
+		private Queue<PmlElement> _queue = new Queue<PmlElement>();
+		private bool _isOpen = true;
+
+		public virtual bool IsOpen { get { return _isOpen; } }
+		public abstract void WriteMessage(PmlElement message);
+
+		public PmlElement ReadMessage() {
+			if (!IsOpen) throw new InvalidOperationException("The channel is not open");
+			if (_queue.Count == 0) {
+				_receiveEvent.WaitOne();
+				if (_queue.Count == 0) throw new OperationCanceledException("The operation did not complete");
+			} else if (_queue.Count == 1) {
+				_receiveEvent.Reset();
+			}
+			return _queue.Dequeue();
+		}
+
+		public IAsyncResult BeginReadMessage(AsyncCallback callback, object state) {
+			ReadMessageAsyncResult ar = new ReadMessageAsyncResult(state, callback);
+			if (!IsOpen) throw new InvalidOperationException("The channel is not open");
+			if (_asyncWait != null) throw new InvalidOperationException("Another asynchronous operation is in progress");
+			if (_queue.Count == 0) {
+				_asyncWait = ar;
+			} else {
+				if (_queue.Count == 1) _receiveEvent.Reset();
+				ar.Complete(true, _queue.Dequeue(), true);
+			}
+			return ar;
+		}
+
+		public PmlElement EndReadMessage(IAsyncResult asyncResult) {
+			ReadMessageAsyncResult ar = (ReadMessageAsyncResult)asyncResult;
+			if (ar.Error) new OperationCanceledException("The operation did not complete");
+			return ar.Message;
+		}
+
+		public virtual void Close() {
+			_isOpen = false;
+			ReadMessageAsyncResult asyncWait = Interlocked.Exchange<ReadMessageAsyncResult>(ref _asyncWait, null);
+			if (asyncWait != null) asyncWait.Complete(false, null, false);
+			_receiveEvent.Set();
+			_receiveEvent.Close();
+		}
+
+		public void Dispose() {
+			Close();
+		}
+
+		protected void PushReceivedMessage(PmlElement message) {
+			ReadMessageAsyncResult asyncWait = Interlocked.Exchange<ReadMessageAsyncResult>(ref _asyncWait, null);
+			if (asyncWait != null) {
+				asyncWait.Complete(true, message, false);
+			} else {
+				_queue.Enqueue(message);
+				_receiveEvent.Set();
+			}
+		}
+
+		private class ReadMessageAsyncResult : IAsyncResult {
+			private object state;
+			private AsyncCallback callback;
+			private bool completed;
+			private bool synchronously;
+			private ManualResetEvent waitHandle;
+
+			internal PmlElement Message;
+			internal bool Error;
+
+			public bool CompletedSynchronously { get { return synchronously; } }
+			public object AsyncState { get { return state; } }
+			public WaitHandle AsyncWaitHandle {
+				get {
+					if (waitHandle == null) waitHandle = new ManualResetEvent(completed);
+					return waitHandle;
+				}
+			}
+			public bool IsCompleted { get { return completed; } }
+
+			internal ReadMessageAsyncResult(object state, AsyncCallback callback) {
+				this.state = state;
+				this.callback = callback;
+				this.completed = false;
+				this.synchronously = false;
+				this.Message = null;
+				this.Error = false;
+				this.waitHandle = null;
+			}
+			internal void Complete(bool success, PmlElement message, bool synchronously) {
+				this.Message = message;
+				this.Error = !success;
+				this.synchronously = synchronously;
+				this.completed = true;
+				if (waitHandle != null) waitHandle.Set();
+				if (this.callback != null) this.callback.Invoke(this);
+			}
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Channels/IPmlChannel.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,22 @@
+using System;
+
+namespace UCIS.Pml {
+	/*public class PmlMessageReceivedEventArgs : EventArgs {
+		private PmlElement _message;
+		public PmlMessageReceivedEventArgs(PmlElement message) {
+			_message = message;
+		}
+		public PmlElement Message { get { return _message; } }
+	}*/
+	public interface IPmlChannel : IDisposable {
+		//event EventHandler MessageReceived;
+		//event EventHandler Closed;
+		bool IsOpen { get; }
+		void WriteMessage(PmlElement message);
+		void Close();
+
+		PmlElement ReadMessage();
+		IAsyncResult BeginReadMessage(AsyncCallback callback, object state);
+		PmlElement EndReadMessage(IAsyncResult asyncResult);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Channels/PassivePmlChannel.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,59 @@
+using System;
+using UCIS.Pml;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace UCIS.Pml {
+	public abstract class PassivePmlChannel : IPmlChannel {
+		private bool _isOpen = true;
+
+		public virtual bool IsOpen { get { return _isOpen; } }
+		public abstract void WriteMessage(PmlElement message);
+
+		public void Dispose() {
+			Close();
+		}
+		public virtual void Close() {
+			_isOpen = false;
+		}
+
+		public abstract PmlElement ReadMessage();
+
+		public IAsyncResult BeginReadMessage(AsyncCallback callback, object state) {
+			ReadMessageAsyncResult ar = new ReadMessageAsyncResult();
+			ar.Callback = callback;
+			ar.State = state;
+			UCIS.ThreadPool.RunCall(AsyncReadMessage, ar);
+			return ar;
+		}
+		public PmlElement EndReadMessage(IAsyncResult asyncResult) {
+			ReadMessageAsyncResult ar = (ReadMessageAsyncResult)asyncResult;
+			if (ar.Error != null) throw new Exception("The asynchronous operation could not be completed", ar.Error);
+			return ar.Message;
+		}
+
+		private struct ReadMessageAsyncResult : IAsyncResult {
+			internal object State;
+			internal PmlElement Message;
+			internal AsyncCallback Callback;
+			internal Exception Error;
+			internal bool Completed;
+
+			public bool CompletedSynchronously { get { return false; } }
+			public object AsyncState { get { return State; } }
+			public WaitHandle AsyncWaitHandle { get { return null; } }
+			public bool IsCompleted { get { return Completed; } }
+		}
+		private void AsyncReadMessage(object state) {
+			ReadMessageAsyncResult ar = (ReadMessageAsyncResult)state;
+			try {
+				ar.Message = ReadMessage();
+				ar.Error = null;
+			} catch (Exception ex) {
+				ar.Error = ex;
+			}
+			ar.Completed = true;
+			ar.Callback.Invoke(ar);
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Channels/PmlChannel.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace UCIS.Pml {
+	public class PmlChannel : ActivePmlChannel {
+		private IPmlRW _rw;
+		private bool _open;
+
+		public PmlChannel(IPmlRW rw) {
+			if (rw == null) throw new ArgumentNullException("rw");
+			_rw = rw;
+			_open = true;
+			ThreadPool.RunTask(worker, null);
+		}
+
+		public IPmlReader Reader { get { return _rw; } }
+		public IPmlWriter Writer { get { return _rw; } }
+
+		public new bool IsOpen { get { return _open; } }
+
+		public override void WriteMessage(PmlElement message) {
+			if (!_open) throw new InvalidOperationException("The channel is not open");
+			lock (_rw) _rw.WriteMessage(message);
+		}
+
+		public override void Close() {
+			if (!_open) return;
+			_open = false;
+			if (_rw != null) _rw = null;
+			base.Close();
+		}
+
+		private void worker(Object state) {
+			try {
+				while (_open) {
+					base.PushReceivedMessage(_rw.ReadMessage());
+				}
+			} catch (System.Net.Sockets.SocketException ex) {
+				Console.WriteLine("SocketException in PmlChannel.worker: " + ex.Message);
+			} catch (System.IO.EndOfStreamException ex) {
+				Console.WriteLine("EndOfStreamException in PmlChannel.worker: " + ex.Message);
+			} catch (Exception ex) {
+				Console.WriteLine(ex.ToString());
+			} finally {
+				Close();
+			}
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Channels/TCPPmlChannel.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,49 @@
+using System;
+using System.IO;
+using System.Net.Sockets;
+using UCIS.Net;
+
+namespace UCIS.Pml {
+	public class TCPPmlChannel : PassivePmlChannel {
+		private TCPStream _socket;
+		private IPmlRW _rw;
+		private bool _open = false;
+
+		public TCPPmlChannel(Socket socket) : this(new TCPStream(socket)) { }
+		public TCPPmlChannel(TCPStream socket) {
+			if (socket == null) throw new ArgumentNullException("socket");
+			_socket = socket;
+			_rw = new PmlBinaryRW(_socket);
+			_open = true;
+			//ThreadPool.RunTask(worker, null);
+		}
+
+		public override void WriteMessage(PmlElement message) {
+			if (!_open) throw new InvalidOperationException("The channel is not open");
+			lock (_rw) _rw.WriteMessage(message);
+		}
+
+		public override void Close() {
+			if (!_open) return;
+			_open = false;
+			if (_socket != null) try { _socket.Close(); } catch { }
+			base.Close();
+		}
+
+		public override PmlElement ReadMessage() {
+			return _rw.ReadMessage();
+		}
+
+		/*private void worker(Object state) {
+			try {
+				while (_open) {
+					base.PushReceivedMessage(_rw.ReadMessage());
+				}
+			} catch (Exception ex) {
+				Console.WriteLine(ex.ToString());
+			} finally {
+				Close();
+			}
+		}*/
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/Array.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,281 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+//using KvpType = System.Collections.Generic.KeyValuePair<string, UCIS.Pml.PmlElement>;
+using KvpType = UCIS.Pml.PmlArray.KeyValuePair;
+
+namespace UCIS.Pml {
+	public class PmlArray : PmlElement, IDictionary<string, PmlElement>, IList<KvpType>, IList<PmlElement>, ICollection<String> {
+		/* Internal variables */
+		private List<KvpType> _items = new List<KvpType>();
+		private int _indexed = 0;
+
+		/* Internal key-value pair structure */
+		public class KeyValuePair {
+			internal KeyValuePair(string key, PmlElement value) { this.Key = key; this.Value = value; }
+			public string Key { get; set; }
+			public PmlElement Value { get; set; }
+		}
+
+		/* Constructors */
+		public PmlArray() {
+		}
+		public PmlArray(params KeyValuePair<string, PmlElement>[] elements) {
+			foreach (KeyValuePair<string, PmlElement> item in elements) Add(item);
+		}
+		public PmlArray(IEnumerable<KeyValuePair<string, PmlElement>> elements) {
+			foreach (KeyValuePair<String, PmlElement> item in elements) Add(item);
+		}
+		public PmlArray(params PmlElement[] elements) {
+			foreach (PmlElement item in elements) Add(item);
+		}
+		public PmlArray(IEnumerable<PmlElement> elements) {
+			foreach (PmlElement item in elements) Add(item);
+		}
+		public PmlArray(String key1, PmlElement val1) {
+			Add(key1, val1);
+		}
+		public PmlArray(String key1, PmlElement val1, String key2, PmlElement val2) {
+			Add(key1, val1);
+			Add(key2, val2);
+		}
+		public PmlArray(String key1, PmlElement val1, String key2, PmlElement val2, String key3, PmlElement val3) {
+			Add(key1, val1);
+			Add(key2, val2);
+			Add(key3, val3);
+		}
+		public PmlArray(params Object[] interleavedKeyValue) {
+			for (int i = 0; i < interleavedKeyValue.Length; ) {
+				Add(interleavedKeyValue[i++] as String, interleavedKeyValue[i++]);
+			}
+		}
+		public PmlArray(String[] keys, params PmlElement[] values) {
+			if (keys.Length != values.Length) throw new ArgumentException("Length of keys array does not match length of values array");
+			for (int i = 0; i < keys.Length; i++) { Add(keys[i] as String, values[i]); }
+		}
+
+		public bool IsIndexed {
+			get {
+				if (_indexed == -1) {
+					_indexed = 0;
+					foreach (KvpType kvp in _items) {
+						if (kvp.Key != null && kvp.Key.Length > 0) {
+							_indexed = 1;
+							break;
+						}
+					}
+				}
+				return _indexed != 0;
+			}
+		}
+
+		/* PmlElement implementation */
+		protected override object GetValue() { return _items; }
+		public override PmlElement GetChild(string Name) { return GetItem(Name); }
+		public override PmlElement GetChild(int index) { return GetItem(index); }
+		public override object ToNumeric() { return _items.Count; }
+		public override PmlElementType Type { get { return PmlElementType.Dictionary; } }
+
+		/* Internal KVP lookup */
+		private KvpType GetKVP(string name) {
+			return _items.Find(delegate(KvpType kvp) { return (kvp.Key == name); });
+		}
+		private KvpType GetKVP(PmlElement value) {
+			return _items.Find(delegate(KvpType kvp) { return (kvp.Value == value); });
+		}
+		private KvpType GetKVP(int index) {
+			if (index < 0 || index >= _items.Count) return null;
+			return _items[index];
+		}
+
+		/* Item retrieval */
+		public PmlElement GetItem(string name) {
+			KvpType kvp = GetKVP(name);
+			return kvp == null ? null : kvp.Value;
+		}
+		public PmlElement GetItem(int index) {
+			if (index < 0 || index >= _items.Count) return null;
+			return _items[index].Value;
+		}
+		public bool TryGetValue(string key, out PmlElement value) {
+			value = GetItem(key);
+			return (value != null);
+		}
+
+		/* Array implementation */
+		public PmlElement this[string key] {
+			get { return GetItem(key); }
+			set {
+				Remove(key);
+				Add(key, value);
+			}
+		}
+		public KvpType this[int id] {
+			get { return GetKVP(id); }
+			set { _items[id] = value; }
+		}
+		PmlElement IList<PmlElement>.this[int id] {
+			get { return GetItem(id); }
+			set {
+				KvpType item = GetKVP(id);
+				item = new KvpType(item == null ? null : item.Key, value);
+				_items[id] = item;
+			}
+		}
+
+		/* Add implementations */
+		public void Add(KvpType kvp) { //Final Add method, handles all additions (except insertions!)
+			if (_indexed == 0 && kvp.Key != null && kvp.Key.Length > 0) _indexed = 1;
+			_items.Add(kvp);
+		}
+
+		public PmlElement Add(string Key, PmlElement Element) {
+			if (Element == null) Element = new PmlNull();
+			Add(new KvpType(Key, Element));
+			return Element;
+		}
+
+		public PmlElement Add(string key, Object value) {
+			PmlElement el;
+			if (value == null) {
+				el = new PmlNull();
+			} else if (value is PmlElement) {
+				el = value as PmlElement;
+			} else if (value is String) {
+				el = new PmlString(value as string);
+			} else if (value is Int32 || value is Int64) {
+				el = new PmlNumber((Int64)value);
+			} else if (value is UInt32 || value is UInt32) {
+				el = new PmlNumber((UInt64)value);
+			} else {
+				el = new PmlString(value.ToString());
+			}
+			return Add(key, el);
+		}
+		public PmlElement Add(string Key, string Element) { return Add(Key, new PmlString(Element)); }
+		public PmlElement Add(string Key, long Element) { return Add(Key, new PmlInteger(Element)); }
+		public PmlElement Add(string Key, ulong Element) { return Add(Key, new PmlInteger(Element)); }
+
+		public PmlElement Add(PmlElement Element) { return Add(null, Element); }
+		public PmlElement Add(object Element) { return Add(null, Element); }
+		public PmlElement Add(string Element) { return Add(new PmlString(Element)); }
+		public PmlElement Add(long Element) { return Add(new PmlInteger(Element)); }
+		public PmlElement Add(ulong Element) { return Add(new PmlInteger(Element)); }
+
+		public void Add(KeyValuePair<string, PmlElement> item) { Add(item.Key, item.Value); }
+
+		void ICollection<PmlElement>.Add(PmlElement item) { Add(item); }
+		void IDictionary<String, PmlElement>.Add(string key, PmlElement value) { Add(key, value); }
+
+		/* Insert implementations */
+		private void Insert(int index, KvpType kvp) {
+			if (kvp.Key != null && kvp.Key.Length > 0 && _indexed == 0) _indexed = 1;
+			_items.Insert(index, kvp);
+		}
+		void IList<KvpType>.Insert(int index, KvpType value) { Insert(index, value); }
+		void IList<PmlElement>.Insert(int index, PmlElement value) { Insert(index, new KvpType(null, value)); }
+
+		/* Remove */
+		public bool Remove(KvpType item) {
+			_indexed = -1;
+			return _items.Remove(item);
+		}
+		public void RemoveAt(int index) {
+			_indexed = -1;
+			_items.RemoveAt(index);
+		}
+		public bool Remove(PmlElement item) {
+			KvpType kvp = GetKVP(item);
+			if (kvp == null) return false;
+			return Remove(kvp);
+		}
+		public bool Remove(string Key) {
+			KvpType kvp = GetKVP(Key);
+			if (kvp == null) return false;
+			return Remove(kvp);
+		}
+		bool ICollection<KeyValuePair<string, PmlElement>>.Remove(KeyValuePair<string, PmlElement> kvp) { return Remove(kvp.Key); }
+
+		public void Clear() {
+			_indexed = 0;
+			_items.Clear();
+		}
+
+		/* Contains */
+		public bool Contains(PmlElement item) { return GetKVP(item) != null; }
+		public bool Contains(string key) { return GetKVP(key) != null; }
+		bool IDictionary<String, PmlElement>.ContainsKey(string key) { return Contains(key); }
+		bool ICollection<KvpType>.Contains(KvpType kvp) { return _items.Contains(kvp); }
+		bool ICollection<KeyValuePair<String, PmlElement>>.Contains(KeyValuePair<String, PmlElement> kvp) { return Contains(kvp.Key); }
+
+		/* Index lookup */
+		public int IndexOf(PmlElement value) { return _items.FindIndex(delegate(KvpType kvp) { return (kvp.Value == value); }); }
+		int IList<KvpType>.IndexOf(KvpType value) { return _items.IndexOf(value); }
+
+		/* Copy operations */
+		public void CopyTo(KvpType[] array, int offset) {
+			_items.CopyTo(array, offset);
+		}
+		public void CopyTo(PmlElement[] array, int offset) {
+			foreach (KvpType kvp in _items) array[offset++] = kvp.Value;
+		}
+		void ICollection<String>.CopyTo(string[] array, int offset) {
+			foreach (KvpType kvp in _items) array[offset++] = kvp.Key;
+		}
+		void ICollection<KeyValuePair<string, PmlElement>>.CopyTo(KeyValuePair<string, PmlElement>[] array, int offset) {
+			foreach (KvpType kvp in _items) array[offset++] = new KeyValuePair<string,PmlElement>(kvp.Key, kvp.Value);
+		}
+
+		/* Dictionary props */
+		public ICollection<PmlElement> Values { get { return this as ICollection<PmlElement>; } }
+		public ICollection<String> Keys { get { return this as ICollection<String>; } }
+
+		/* Stuf... */
+		public int Count { get { return _items.Count; } }
+		public bool IsReadOnly { get { return false; } }
+		void ICollection<String>.Add(string value) { throw new NotImplementedException(); }
+
+		/* Enumerators */
+		IEnumerator<KvpType> IEnumerable<KvpType>.GetEnumerator() { return _items.GetEnumerator(); }
+		IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }
+		public IEnumerator<PmlElement> GetEnumerator() { return new ValueEnumerator(this); }
+		IEnumerator<String> IEnumerable<String>.GetEnumerator() { return new KeyEnumerator(this); }
+		IEnumerator<KeyValuePair<string, PmlElement>> IEnumerable<KeyValuePair<string, PmlElement>>.GetEnumerator() { return new KvpEnumerator(this); }
+
+		private class KeyEnumerator : IEnumerator<String> {
+			protected IEnumerator<KvpType> _enum;
+			internal KeyEnumerator(PmlArray array) { _enum = array._items.GetEnumerator(); }
+			private KvpType KVP { get { return _enum.Current; } }
+			public bool MoveNext() { return _enum.MoveNext(); }
+			public void Reset() { _enum.Reset(); }
+			public void Dispose() { _enum.Dispose(); }
+			Object IEnumerator.Current { get { return Current; } }
+
+			public String Current { get { return KVP == null ? null : KVP.Key; } }
+		}
+		private class ValueEnumerator : IEnumerator<PmlElement> {
+			protected IEnumerator<KvpType> _enum;
+			internal ValueEnumerator(PmlArray array) { _enum = array._items.GetEnumerator(); }
+			private KvpType KVP { get { return _enum.Current; } }
+			public bool MoveNext() { return _enum.MoveNext(); }
+			public void Reset() { _enum.Reset(); }
+			public void Dispose() { _enum.Dispose(); }
+			Object IEnumerator.Current { get { return Current; } }
+
+			public PmlElement Current { get { return KVP == null ? null : KVP.Value; } }
+		}
+		private class KvpEnumerator : IEnumerator<KeyValuePair<String, PmlElement>> {
+			protected IEnumerator<KvpType> _enum;
+			internal KvpEnumerator(PmlArray array) { _enum = array._items.GetEnumerator(); }
+			private KvpType KVP { get { return _enum.Current; } }
+			public bool MoveNext() { return _enum.MoveNext(); }
+			public void Reset() { _enum.Reset(); }
+			public void Dispose() { _enum.Dispose(); }
+			Object IEnumerator.Current { get { return Current; } }
+
+			public KeyValuePair<String, PmlElement> Current { get {
+				return KVP == null ? default(KeyValuePair<String, PmlElement>) : new KeyValuePair<String, PmlElement>(KVP.Key, KVP.Value);
+			} }
+		}
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/Binary.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,31 @@
+using System;
+using System.Text;
+
+namespace UCIS.Pml {
+	public class PmlBinary : PmlElement {
+		private byte[] _Value;
+
+		public PmlBinary(byte[] Value) {
+			_Value = Value;
+		}
+
+		public override PmlType Type { get { return PmlType.Binary; } }
+
+		public override object ToObject() { return _Value; }
+		public override string ToString() { return Encoding.UTF8.GetString(_Value); }
+		public override bool ToBoolean() { return BitConverter.ToBoolean(_Value, 0); }
+		public override byte ToByte() { return _Value[0]; }
+		public override decimal ToDecimal() { return _Value.Length == 4 ? (Decimal)BitConverter.ToSingle(_Value, 0) : (Decimal)BitConverter.ToDouble(_Value, 0); }
+		public override double ToDouble() { return BitConverter.ToDouble(_Value, 0); }
+		public override short ToInt16() { return BitConverter.ToInt16(_Value, 0); }
+		public override int ToInt32() { return BitConverter.ToInt32(_Value, 0); }
+		public override long ToInt64() { return BitConverter.ToInt64(_Value, 0); }
+		public override sbyte ToSByte() { return (SByte)_Value[0]; }
+		public override float ToSingle() { return BitConverter.ToSingle(_Value, 0); }
+		public override ushort ToUInt16() { return BitConverter.ToUInt16(_Value, 0); }
+		public override uint ToUInt32() { return BitConverter.ToUInt32(_Value, 0); }
+		public override ulong ToUInt64() { return BitConverter.ToUInt64(_Value, 0); }
+		public override char ToChar() { return BitConverter.ToChar(_Value, 0); }
+		public override byte[] ToByteArray() { return _Value; }
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/Collection.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,74 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UCIS.Pml {
+	public class PmlCollection : PmlElement, ICollection<PmlElement> {
+			private List<PmlElement> pItems = new List<PmlElement>();
+
+			public PmlCollection() { 			}
+			public PmlCollection(params PmlElement[] Elements) {
+				pItems.AddRange(Elements);
+			}
+			public PmlCollection(IEnumerable<PmlElement> Elements) {
+				pItems.AddRange(Elements);
+			}
+
+			public PmlElement Add(PmlElement Element) {
+				pItems.Add(Element);
+				return Element;
+			}
+			public void Remove(PmlElement Element) {
+				pItems.Remove(Element);
+			}
+			public void RemoveAt(int Index) {
+				pItems.RemoveAt(Index);
+			}
+			public void Clear() {
+				pItems.Clear();
+			}
+			public bool Contains(PmlElement item) {
+				return pItems.Contains(item);
+			}
+			public void CopyTo(PmlElement[] array, int arrayIndex) {
+				pItems.CopyTo(array, arrayIndex);
+			}
+			public int Count { 				get { return pItems.Count; } 			}
+			public bool IsReadOnly { 				get { return false; } 			}
+			public IEnumerator<PmlElement> GetEnumerator() { 				return pItems.GetEnumerator(); 			}
+			IEnumerator IEnumerable.GetEnumerator() { 				return pItems.GetEnumerator(); 			}
+			bool ICollection<PmlElement>.Remove(PmlElement item) { 				return pItems.Remove(item); 			}
+			void ICollection<PmlElement>.Add(PmlElement item) { 				Add(item); 			}
+
+			public override PmlType Type { get { return PmlType.Collection; } }
+
+			public override object ToObject() { return pItems; }
+			public override string ToString() { return null; }
+			public override bool ToBoolean() { return pItems.Count > 0; }
+			public override byte ToByte() { return (Byte)pItems.Count; }
+			public override decimal ToDecimal() { return pItems.Count; }
+			public override double ToDouble() { return pItems.Count; }
+			public override short ToInt16() { return (Int16)pItems.Count; }
+			public override int ToInt32() { return pItems.Count; }
+			public override long ToInt64() { return pItems.Count; }
+			public override sbyte ToSByte() { return (SByte)pItems.Count; }
+			public override float ToSingle() { return pItems.Count; }
+			public override ushort ToUInt16() { return (UInt16)pItems.Count; }
+			public override uint ToUInt32() { return (UInt32)pItems.Count; }
+			public override ulong ToUInt64() { return (UInt64)pItems.Count; }
+			public override char ToChar() { return '\0'; }
+			public override byte[] ToByteArray() { return null; }
+
+			//public override PmlElement GetChild(string name) { return GetChild(name); }
+			public override PmlElement GetChild(int index) { return pItems[index]; }
+			public override IEnumerable<PmlElement> GetChildren() { return pItems; }
+			public override IEnumerable<KeyValuePair<String, PmlElement>> GetNamedChildren() {
+				KeyValuePair<String, PmlElement>[] kvps = new KeyValuePair<string, PmlElement>[pItems.Count];
+				for (int i = 0; i < kvps.Length; i++) kvps[i] = new KeyValuePair<string,PmlElement>(null, pItems[i]);
+				return kvps;
+			}
+			public override int GetChildCount() { return pItems.Count; }
+			public override void AddChild(string name, PmlElement value) { Add(value); }
+			public override void AddChild(PmlElement value) { Add(value); }
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/Dictionary.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,165 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UCIS.Pml {
+	public class PmlDictionary : PmlElement, IDictionary<string, PmlElement>, ICollection<PmlElement> {
+		private List<KeyValuePair<string, PmlElement>> pItems = new List<KeyValuePair<string, PmlElement>>();
+
+		public PmlDictionary() { }
+		public PmlDictionary(String[] keys, params PmlElement[] values) {
+			if (keys.Length != values.Length) throw new ArgumentException("keys.Length != values.Length", "values");
+			for (int i = 0; i < keys.Length; i++) Add(keys[i], values[i]);
+		}
+		public PmlDictionary(params KeyValuePair<string, PmlElement>[] Elements) {
+			foreach (KeyValuePair<string, PmlElement> Item in Elements) pItems.Add(Item);
+		}
+		public PmlDictionary(IEnumerable<KeyValuePair<string, PmlElement>> Elements) {
+			foreach (KeyValuePair<string, PmlElement> Item in Elements) pItems.Add(Item);
+		}
+
+		public override PmlElement GetChild(string Name) {
+			foreach (KeyValuePair<string, PmlElement> KVP in pItems) {
+				if (KVP.Key.Equals(Name, StringComparison.InvariantCultureIgnoreCase)) return KVP.Value;
+			}
+			return null;
+		}
+		public override PmlElement GetChild(int index) {
+			return pItems[index].Value;
+		}
+		public bool TryGetValue(string key, out PmlElement value) {
+			value = GetChild(key);
+			return (value != null);
+		}
+		public PmlElement this[string key] {
+			get { return GetChild(key); }
+			set {
+				Remove(key);
+				Add(key, value);
+			}
+		}
+
+		public PmlElement Add(string Key, PmlElement Element) {
+			if (Element == null) Element = new PmlNull();
+			pItems.Add(new KeyValuePair<string, PmlElement>(Key, Element));
+			return Element;
+		}
+		private void Add(KeyValuePair<string, PmlElement> item) {
+			pItems.Add(item);
+		}
+		public void Add(PmlElement item) {
+			Add("", item);
+		}
+
+		void IDictionary<string, PmlElement>.Add(string key, PmlElement value) {
+			Add(key, value);
+		}
+		void ICollection<KeyValuePair<string, PmlElement>>.Add(KeyValuePair<string, PmlElement> item) {
+			Add(item);
+		}
+
+		public bool Remove(PmlElement item) {
+			foreach (KeyValuePair<string, PmlElement> KVP in pItems) {
+				if (KVP.Value == item) {
+					pItems.Remove(KVP);
+					return true;
+				}
+			}
+			return false;
+		}
+		public bool Remove(string Key) {
+			foreach (KeyValuePair<string, PmlElement> KVP in pItems) {
+				if (KVP.Key.Equals(Key, StringComparison.InvariantCultureIgnoreCase)) {
+					pItems.Remove(KVP);
+					return true;
+				}
+			}
+			return false;
+		}
+		public bool Remove(KeyValuePair<string, PmlElement> item) {
+			return ((ICollection<KeyValuePair<string, PmlElement>>)pItems).Remove(item);
+		}
+
+		public int Count {
+			get { return pItems.Count; }
+		}
+
+		public void Clear() {
+			pItems.Clear();
+		}
+
+		public bool Contains(PmlElement item) {
+			foreach (KeyValuePair<string, PmlElement> KVP in pItems) {
+				if (KVP.Value == item) return true;
+			}
+			return false;
+		}
+		bool ICollection<KeyValuePair<string, PmlElement>>.Contains(KeyValuePair<string, PmlElement> item) {
+			return ((ICollection<KeyValuePair<string, PmlElement>>)pItems).Contains(item);
+		}
+		public bool ContainsKey(string key) {
+			foreach (KeyValuePair<string, PmlElement> KVP in pItems) {
+				if (KVP.Key.Equals(key, StringComparison.InvariantCultureIgnoreCase)) return true;
+			}
+			return false;
+		}
+
+		void ICollection<KeyValuePair<string, PmlElement>>.CopyTo(KeyValuePair<string, PmlElement>[] array, int arrayIndex) {
+			((ICollection<KeyValuePair<string, PmlElement>>)pItems).CopyTo(array, arrayIndex);
+		}
+		void ICollection<PmlElement>.CopyTo(PmlElement[] array, int arrayIndex) {
+			foreach (KeyValuePair<string, PmlElement> KVP in pItems) {
+				array[arrayIndex] = KVP.Value;
+				arrayIndex += 1;
+			}
+		}
+
+		public ICollection<string> Keys {
+			get {
+				List<string> Ret = new List<string>();
+				foreach (KeyValuePair<string, PmlElement> KVP in pItems) Ret.Add(KVP.Key);
+				return Ret;
+			}
+		}
+		public ICollection<PmlElement> Values {
+			get {
+				List<PmlElement> Ret = new List<PmlElement>();
+				foreach (KeyValuePair<string, PmlElement> KVP in pItems) Ret.Add(KVP.Value);
+				return Ret;
+			}
+		}
+		public IEnumerator<KeyValuePair<string, PmlElement>> GetEnumerator() { return pItems.GetEnumerator(); }
+		IEnumerator IEnumerable.GetEnumerator() { return pItems.GetEnumerator(); }
+		IEnumerator<PmlElement> IEnumerable<PmlElement>.GetEnumerator() { return Values.GetEnumerator(); }
+
+		public bool IsReadOnly { get { return false; } }
+
+
+		public override PmlType Type { get { return PmlType.Dictionary; } }
+
+		public override object ToObject() { return pItems; }
+		public override string ToString() { return null; }
+		public override bool ToBoolean() { return pItems.Count > 0; }
+		public override byte ToByte() { return (Byte)pItems.Count; }
+		public override decimal ToDecimal() { return pItems.Count; }
+		public override double ToDouble() { return pItems.Count; }
+		public override short ToInt16() { return (Int16)pItems.Count; }
+		public override int ToInt32() { return pItems.Count; }
+		public override long ToInt64() { return pItems.Count; }
+		public override sbyte ToSByte() { return (SByte)pItems.Count; }
+		public override float ToSingle() { return pItems.Count; }
+		public override ushort ToUInt16() { return (UInt16)pItems.Count; }
+		public override uint ToUInt32() { return (UInt32)pItems.Count; }
+		public override ulong ToUInt64() { return (UInt64)pItems.Count; }
+		public override char ToChar() { return '\0'; }
+		public override byte[] ToByteArray() { return null; }
+
+		//public override PmlElement GetChild(string name) { return GetChild(name); }
+		//public override PmlElement GetChild(int index) { return GetChild(index); }
+		public override IEnumerable<PmlElement> GetChildren() { return Values; }
+		public override IEnumerable<KeyValuePair<String, PmlElement>> GetNamedChildren() { return pItems; }
+		public override int GetChildCount() { return pItems.Count; }
+		public override void AddChild(string name, PmlElement value) { Add(name, value); }
+		public override void AddChild(PmlElement value) { Add(value); }
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/Element.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace UCIS.Pml {
+	/*public enum PmlElementType : byte {
+		Null = 0,
+
+		Dictionary = 1,
+		Collection = 2,
+
+		Binary = 10,
+		String = 11,
+
+		Integer = 20
+	}*/
+	public enum PmlType {
+		Null,
+		Dictionary,
+		Collection,
+		Binary,
+		String,
+		Integer,
+		//Number,
+	}
+	public abstract class PmlElement {
+		public abstract PmlType Type { get; }
+
+		public virtual PmlElement GetChild(string name) { return null; }
+		public virtual PmlElement GetChild(int index) { return null; }
+		public virtual IEnumerable<PmlElement> GetChildren() { return null; }
+		public virtual IEnumerable<KeyValuePair<String, PmlElement>> GetNamedChildren() { return null; }
+		public virtual int GetChildCount() { return 0; }
+		public virtual void AddChild(string name, PmlElement value) { throw new NotSupportedException(); }
+		public virtual void AddChild(PmlElement value) { throw new NotSupportedException(); }
+
+		public abstract object ToObject();
+		public abstract override string ToString();
+		public abstract bool ToBoolean();
+		public abstract byte ToByte();
+		public abstract decimal ToDecimal();
+		public abstract double ToDouble();
+		public abstract short ToInt16();
+		public abstract int ToInt32();
+		public abstract long ToInt64();
+		public abstract sbyte ToSByte();
+		public abstract float ToSingle();
+		public abstract ushort ToUInt16();
+		public abstract uint ToUInt32();
+		public abstract ulong ToUInt64();
+		public abstract char ToChar();
+		public abstract byte[] ToByteArray();
+
+		public static explicit operator string(PmlElement e) { return e == null ? null : e.ToString(); }
+		public static explicit operator bool(PmlElement e) { return e == null ? false : e.ToBoolean(); }
+		public static explicit operator byte(PmlElement e) { return e == null ? (byte)0 : e.ToByte(); }
+		public static explicit operator decimal(PmlElement e) { return e == null ? (decimal)0 : e.ToDecimal(); }
+		public static explicit operator double(PmlElement e) { return e == null ? (double)0 : e.ToDouble(); }
+		public static explicit operator short(PmlElement e) { return e == null ? (short)0 : e.ToInt16(); }
+		public static explicit operator int(PmlElement e) { return e == null ? (int)0 : e.ToInt32(); }
+		public static explicit operator long(PmlElement e) { return e == null ? (long)0 : e.ToInt64(); }
+		public static explicit operator sbyte(PmlElement e) { return e == null ? (sbyte)0 : e.ToSByte(); }
+		public static explicit operator float(PmlElement e) { return e == null ? (float)0 : e.ToSingle(); }
+		public static explicit operator ushort(PmlElement e) { return e == null ? (ushort)0 : e.ToUInt16(); }
+		public static explicit operator uint(PmlElement e) { return e == null ? (uint)0 : e.ToUInt32(); }
+		public static explicit operator ulong(PmlElement e) { return e == null ? (ulong)0 : e.ToUInt64(); }
+		public static explicit operator char(PmlElement e) { return e == null ? '\0' : e.ToChar(); }
+		public static explicit operator byte[](PmlElement e) { return e == null ? null : e.ToByteArray(); }
+
+		public static implicit operator PmlElement(String str) { return new PmlString(str); }
+		public static implicit operator PmlElement(UInt64 number) { return new PmlInteger(number); }
+		public static implicit operator PmlElement(UInt32 number) { return new PmlInteger(number); }
+		public static implicit operator PmlElement(Int64 number) { return new PmlInteger(number); }
+		public static implicit operator PmlElement(Int32 number) { return new PmlInteger(number); }
+		public static implicit operator PmlElement(Int16 number) { return new PmlInteger(number); }
+		public static implicit operator PmlElement(UInt16 number) { return new PmlInteger(number); }
+		public static implicit operator PmlElement(Byte number) { return new PmlInteger(number); }
+		//public static implicit operator PmlElement(Double number) { return new PmlNumber(number); }
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/Integer.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,52 @@
+using System;
+
+namespace UCIS.Pml {
+	public class PmlInteger : PmlElement {
+		private UInt64 pUValue;
+		private Int64 pSValue;
+		private bool pSigned;
+
+		public PmlInteger() {
+			pSValue = 0;
+			pSigned = true;
+		}
+		public PmlInteger(UInt64 Value) {
+			pUValue = Value;
+			pSigned = false;
+		}
+		public PmlInteger(Int64 Value) {
+			pSValue = Value;
+			pSigned = true;
+		}
+		public PmlInteger(string Value) {
+			if (Int64.TryParse(Value, out pSValue)) {
+				pSigned = true;
+			} else if (UInt64.TryParse(Value, out pUValue)) {
+				pSigned = false;
+			} else {
+				throw new FormatException();
+			}
+		}
+
+		public Boolean IsSigned { get { return pSigned; } }
+
+		public override PmlType Type { get { return PmlType.Integer; } }
+
+		public override object ToObject() { return pSigned ? (Object)pSValue : (Object)pUValue; }
+		public override string ToString() { return pSigned ? pSValue.ToString() : pUValue.ToString(); }
+		public override bool ToBoolean() { return pSigned ? (pSValue != 0) : (pUValue != 0); }
+		public override byte ToByte() { return pSigned ? (Byte)pSValue : (Byte)pUValue; }
+		public override decimal ToDecimal() { return pSigned ? (Decimal)pSValue : (Decimal)pUValue; }
+		public override double ToDouble() { return pSigned ? (Double)pSValue : (Double)pUValue; }
+		public override short ToInt16() { return pSigned ? (Int16)pSValue : (Int16)pUValue; }
+		public override int ToInt32() { return pSigned ? (Int32)pSValue : (Int32)pUValue; }
+		public override long ToInt64() { return pSigned ? pSValue : (Int64)pUValue; }
+		public override sbyte ToSByte() { return pSigned ? (SByte)pSValue : (SByte)pUValue; }
+		public override float ToSingle() { return pSigned ? (Single)pSValue : (Single)pUValue; }
+		public override ushort ToUInt16() { return pSigned ? (UInt16)pSValue : (UInt16)pUValue; }
+		public override uint ToUInt32() { return pSigned ? (UInt32)pSValue : (UInt32)pUValue; }
+		public override ulong ToUInt64() { return pSigned ? (UInt64)pSValue : pUValue; }
+		public override char ToChar() { return pSigned ? (Char)pSValue : (Char)pUValue; }
+		public override byte[] ToByteArray() { return pSigned ? BitConverter.GetBytes(pSValue) : BitConverter.GetBytes(pUValue); }
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/Number.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,37 @@
+using System;
+using System.Globalization;
+
+namespace UCIS.Pml {
+	public class PmlNumber : PmlElement {
+		private double _Value;
+
+		public PmlNumber() {
+			_Value = 0;
+		}
+		public PmlNumber(double Value) {
+			_Value = Value;
+		}
+		public PmlNumber(string Value) {
+			_Value = double.Parse(Value);
+		}
+
+		public override PmlType Type { get { return PmlType.Number; } }
+
+		public override object ToObject() { return _Value; }
+		public override string ToString() { return _Value.ToString("#,#", CultureInfo.InvariantCulture); }
+		public override bool ToBoolean() { return _Value != 0; }
+		public override byte ToByte() { return (Byte)_Value; }
+		public override decimal ToDecimal() { return (Decimal)_Value; }
+		public override double ToDouble() { return (Double)_Value; }
+		public override short ToInt16() { return (Int16)_Value; }
+		public override int ToInt32() { return (Int32)_Value; }
+		public override long ToInt64() { return (Int64)_Value; }
+		public override sbyte ToSByte() { return (SByte)_Value; }
+		public override float ToSingle() { return (Single)_Value; }
+		public override ushort ToUInt16() { return (UInt16)_Value; }
+		public override uint ToUInt32() { return (UInt32)_Value; }
+		public override ulong ToUInt64() { return (UInt64)_Value; }
+		public override char ToChar() { return (Char)_Value; }
+		public override byte[] ToByteArray() { return BitConverter.GetBytes(_Value); }
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/PmlNull.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,22 @@
+namespace UCIS.Pml {
+	public class PmlNull : PmlElement {
+		public override PmlType Type { get { return PmlType.Null; } }
+
+		public override object ToObject() { return null; }
+		public override string ToString() { return null; }
+		public override bool ToBoolean() { return false; }
+		public override byte ToByte() { return 0; }
+		public override decimal ToDecimal() { return 0; }
+		public override double ToDouble() { return 0; }
+		public override short ToInt16() { return 0; }
+		public override int ToInt32() { return 0; }
+		public override long ToInt64() { return 0; }
+		public override sbyte ToSByte() { return 0; }
+		public override float ToSingle() { return 0; }
+		public override ushort ToUInt16() { return 0; }
+		public override uint ToUInt32() { return 0; }
+		public override ulong ToUInt64() { return 0; }
+		public override char ToChar() { return '\0'; }
+		public override byte[] ToByteArray() { return null; }
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/Elements/PmlString.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,32 @@
+using System;
+using System.Text;
+using System.Globalization;
+
+namespace UCIS.Pml {
+	public class PmlString : PmlElement {
+		private string _Value;
+
+		public PmlString(string Value) {
+			_Value = Value;
+		}
+
+		public override PmlType Type { get { return PmlType.String; } }
+
+		public override object ToObject() { return _Value; }
+		public override string ToString() { return _Value; }
+		public override bool ToBoolean() { return Boolean.Parse(_Value); }
+		public override byte ToByte() { return Byte.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override decimal ToDecimal() { return Decimal.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override double ToDouble() { return Double.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override short ToInt16() { return Int16.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override int ToInt32() { return Int32.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override long ToInt64() { return Int64.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override sbyte ToSByte() { return SByte.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override float ToSingle() { return Single.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override ushort ToUInt16() { return UInt16.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override uint ToUInt32() { return UInt32.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override ulong ToUInt64() { return UInt64.Parse(_Value, CultureInfo.InvariantCulture); }
+		public override char ToChar() { return _Value[0]; }
+		public override byte[] ToByteArray() { return Encoding.UTF8.GetBytes(_Value); }
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/IPmlCommunicator.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace UCIS.Pml {
+	public class PmlCallReceivedEventArgs : EventArgs {
+		private PmlElement _request;
+		private PmlElement _reply;
+		private UInt32 _sid;
+		private bool _wantReply;
+
+		internal PmlCallReceivedEventArgs(PmlElement request, bool wantReply, UInt32 sid) {
+			_request = request;
+			_wantReply = wantReply;
+			_sid = sid;
+			_reply = null;
+		}
+		public bool WantReply {
+			get { return _wantReply; }
+		}
+		internal UInt32 SID {
+			get { return _sid; }
+		}
+		public PmlElement Reply {
+			get { return _reply; }
+			set { _reply = value; }
+		}
+		public PmlElement Request {
+			get { return _request; }
+		}
+	}
+	public abstract class PmlChannelRequestReceivedEventArgs : EventArgs {
+		public abstract IPmlChannel Accept();
+		public abstract void Reject();
+		public abstract PmlElement Data { get; }
+	}
+	public interface IPmlCommunicator {
+		event EventHandler<PmlCallReceivedEventArgs> CallReceived;
+		event EventHandler<PmlChannelRequestReceivedEventArgs> ChannelRequestReceived;
+
+		void Call(PmlElement message);
+		PmlElement Invoke(PmlElement message);
+
+		IAsyncResult BeginInvoke(PmlElement message, AsyncCallback callback, Object state);
+		PmlElement EndInvoke(IAsyncResult result);
+
+		IPmlChannel CreateChannel(PmlElement data);
+		IAsyncResult BeginCreateChannel(PmlElement data, AsyncCallback callback, Object state);
+		IPmlChannel EndCreateChannel(IAsyncResult result);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/IPmlRpc.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+namespace UCIS.Pml {
+	interface IPmlRpcServer {
+		IDictionary<string, Delegate> ExportedMethods { get; }
+		IDictionary<string, Object> ExportedObjects { get; }
+	}
+	interface IPmlRpcClient {
+		void Call(String method, params Object[] args);
+		void Invoke(String method, params Object[] args);
+		void BeginInvoke(String method, Object[] args, AsyncCallback callback, Object state);
+		Object EndInvoke(IAsyncResult result);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/LegacyPmlCommunicator.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,403 @@
+using System;
+using System.Threading;
+using System.Collections.Generic;
+using UCIS.Pml;
+
+namespace UCIS.Pml {
+	public class LegacyPmlCommunicator {
+		private class CSyncRequest {
+			internal PmlElement Reply;
+			internal ManualResetEvent ResetEvent = new ManualResetEvent(false);
+		}
+		public abstract class SessionBase {
+			private bool pActive;
+			private LegacyPmlCommunicator pConnection;
+			private UInt32 pSID;
+
+			public uint SID { get { return pSID; } }
+			public bool Active { get { return pActive; } }
+			public LegacyPmlCommunicator Communicator { get { return pConnection; } }
+
+			protected SessionBase(LegacyPmlCommunicator Connection) {
+				pConnection = Connection;
+			}
+
+			protected void Accept(UInt32 SID) {
+				if (pActive) throw new InvalidOperationException("Session is active");
+				pSID = SID;
+				lock (pConnection.pSessions) pConnection.pSessions.Add(pSID, this);
+				pActive = true;
+			}
+			protected void Request() {
+				Request(null);
+			}
+			protected void Request(PmlElement Message) {
+				if (pActive) throw new InvalidOperationException("Session is active");
+				pSID = pConnection.GetNextSessionId(true);
+				lock (pConnection.pSessions) pConnection.pSessions.Add(pSID, this);
+				pConnection.WriteSessionMessage(pSID, 0, Message);
+				pActive = true;
+			}
+
+			protected internal abstract void MessageIn(PmlElement Message);
+
+			protected void SendMessage(PmlElement Message) {
+				if (!pActive) throw new InvalidOperationException("Session is not active");
+				pConnection.WriteSessionMessage(pSID, 1, Message);
+			}
+
+			public void Close() {
+				Close(null);
+			}
+			public void Close(PmlElement Message) {
+				if (!pActive) return; // throw new InvalidOperationException("Session is not active");
+				pConnection.WriteSessionMessage(pSID, 2, Message);
+				ClosedA();
+			}
+
+			internal void ClosedA() {
+				pActive = false;
+				lock (pConnection.pSessions) pConnection.pSessions.Remove(pSID);
+			}
+
+			internal void ClosedB(PmlElement Message) {
+				pActive = false;
+				Closed(Message);
+			}
+
+			protected virtual void Closed(PmlElement Message) {
+			}
+		}
+		public class Session : SessionBase {
+			public event MessageReceivedEventHandler MessageReceived;
+			public delegate void MessageReceivedEventHandler(PmlElement Message);
+			public event SessionClosedEventHandler SessionClosed;
+			public delegate void SessionClosedEventHandler(PmlElement Message);
+
+			public Session(LegacyPmlCommunicator Connection) : base(Connection) { }
+
+			public new void Accept(UInt32 SID) {
+				base.Accept(SID);
+			}
+			public new void Request() {
+				Request(null);
+			}
+			public new void Request(PmlElement Message) {
+				base.Request(Message);
+			}
+
+			protected internal override void MessageIn(PmlElement Message) {
+				if (MessageReceived != null) MessageReceived(Message);
+			}
+
+			public new void SendMessage(PmlElement Message) {
+				base.SendMessage(Message);
+			}
+
+			protected override void Closed(PmlElement Message) {
+				if (SessionClosed != null) SessionClosed(Message);
+			}
+		}
+
+		private Dictionary<UInt32, SessionBase> pSessions = new Dictionary<UInt32, SessionBase>();
+		private UInt32 pNextSession;
+		private Dictionary<UInt32, CSyncRequest> pSyncRequests = new Dictionary<UInt32, CSyncRequest>();
+		private UInt32 pNextSyncRequest;
+
+		private IPmlChannel _channel;
+
+		public event MessageReceivedEventHandler MessageReceived;
+		public delegate void MessageReceivedEventHandler(PmlElement Message);
+		public event RequestReceivedEventHandler RequestReceived;
+		public delegate void RequestReceivedEventHandler(PmlElement Request, ref PmlElement Reply);
+		public event SessionRequestReceivedEventHandler SessionRequestReceived;
+		public delegate void SessionRequestReceivedEventHandler(PmlElement Request, uint SID);
+		public event EventHandler Closed;
+
+		public ICollection<SessionBase> Sessions { get { return (ICollection<SessionBase>)pSessions.Values; } }
+		public int SyncRequests { get { return pSyncRequests.Count; } }
+
+		public LegacyPmlCommunicator(IPmlChannel channel, bool autoStart) {
+			_channel = channel;
+			if (autoStart) Start();
+			//_channel.BeginReadMessage(messageReceived, null);
+			//_channel.MessageReceived += messageReceived;
+			//_channel.Closed += closed;
+		}
+		public void Start() {
+			_channel.BeginReadMessage(messageReceived, null);
+		}
+
+		public IPmlChannel Channel { get { return _channel; } }
+
+		public void Close() {
+			//_channel.MessageReceived -= messageReceived;
+			//_channel.Closed -= closed;
+			_channel.Close();
+		}
+
+		private void _WriteMessage(PmlElement Message) {
+			lock (_channel) {
+				if (_channel.IsOpen) {
+					_channel.WriteMessage(Message);
+				} else {
+					throw new InvalidOperationException("Could not write message: the channel is not open");
+				}
+			}
+		}
+
+		private UInt32 GetNextSessionId(bool IsSession) {
+			if (IsSession) {
+				lock (pSessions) {
+					do {
+						if (pNextSession == UInt32.MaxValue) {
+							pNextSession = 0;
+						} else {
+							pNextSession += (uint)1;
+						}
+					}
+					while (pSessions.ContainsKey(pNextSession));
+					return pNextSession;
+				}
+			} else {
+				lock (pSyncRequests) {
+					do {
+						if (pNextSyncRequest == UInt32.MaxValue) {
+							pNextSyncRequest = 0;
+						} else {
+							pNextSyncRequest += (uint)1;
+						}
+					}
+					while (pSyncRequests.ContainsKey(pNextSyncRequest));
+					return pNextSyncRequest;
+				}
+			}
+		}
+
+		protected void WriteSessionMessage(UInt32 SID, byte CMD, PmlElement MSG) {
+			PmlDictionary Msg2 = new PmlDictionary();
+			Msg2.Add("CMD", new PmlString("SES"));
+			Msg2.Add("SID", new PmlInteger(SID));
+			Msg2.Add("SCMD", new PmlInteger(CMD));
+			Msg2.Add("MSG", MSG);
+			_WriteMessage(Msg2);
+		}
+
+		protected void WriteSyncMessage(UInt32 SID, bool RPL, PmlElement MSG) {
+			PmlDictionary Msg2 = new PmlDictionary();
+			if (RPL) {
+				Msg2.Add("CMD", new PmlString("RPL"));
+			} else {
+				Msg2.Add("CMD", new PmlString("REQ"));
+			}
+			Msg2.Add("SID", new PmlInteger(SID));
+			Msg2.Add("MSG", MSG);
+			_WriteMessage(Msg2);
+		}
+
+		private void messageReceived(IAsyncResult ar) {
+			PmlElement Message;
+			try {
+				Message = _channel.EndReadMessage(ar);
+				_channel.BeginReadMessage(messageReceived, null);
+			} catch (InvalidOperationException ex) {
+				Console.WriteLine("InvalidOperationException in LegacyPmlCommunicator.messageReceived: " + ex.Message);
+				closed();
+				_channel.Close();
+				return;
+			} catch (Exception ex) {
+				Console.WriteLine(ex.ToString());
+				closed();
+				_channel.Close();
+				return;
+			}
+			int Ping = 0;
+			if (Message == null) {
+				if (Ping > 2) {
+					_channel.Close();
+					return;
+				} else {
+					_WriteMessage(new PmlString("PING"));
+				}
+				Ping += 1;
+			} else if (Message is PmlString) {
+				string Cmd = Message.ToString();
+				if (Cmd.Equals("PING")) {
+					_WriteMessage(new PmlString("PONG"));
+				} else if (Cmd.Equals("PONG")) {
+					Ping = 0;
+				}
+			} else if (Message is PmlDictionary) {
+				string Cmd = null;
+				Cmd = Message.GetChild("CMD").ToString();
+				if (Cmd.Equals("SES")) {
+					UInt32 SID = default(UInt32);
+					byte SCMD = 0;
+					SessionBase Session = default(SessionBase);
+					PmlElement InnerMsg = default(PmlElement);
+					SID = Message.GetChild("SID").ToUInt32();
+					SCMD = Message.GetChild("SCMD").ToByte();
+					InnerMsg = Message.GetChild("MSG");
+					lock (pSessions) {
+						if (pSessions.ContainsKey(SID)) {
+							Session = pSessions[SID];
+						} else {
+							Session = null;
+						}
+					}
+					if (SCMD == 0) {
+						if (Session == null) {
+							if (SessionRequestReceived != null) {
+								try {
+									SessionRequestReceived(InnerMsg, SID);
+								} catch (Exception ex) {
+									Console.WriteLine("Exception in LegacyPmlCommnuicator.messageReceived->SessionRequestReceived: " + ex.ToString());
+									WriteSessionMessage(SID, 2, null);
+								}
+							}
+						} else {
+							try {
+								Session.ClosedA();
+								Session.ClosedB(null);
+							} catch (Exception ex) {
+								Console.WriteLine("Exception in LegacyPmlCommnuicator.messageReceived->Session.ClosedA/B: " + ex.ToString());
+							}
+							WriteSessionMessage(SID, 2, null);
+						}
+					} else if (SCMD == 1) {
+						if (Session == null) {
+							WriteSessionMessage(SID, 2, null);
+						} else {
+							try {
+								Session.MessageIn(InnerMsg);
+							} catch (Exception ex) {
+								Console.WriteLine("Exception in LegacyPmlCommnuicator.messageReceived->Session.MessageIn: " + ex.ToString());
+								WriteSessionMessage(SID, 2, null);
+							}
+						}
+					} else if (SCMD == 2) {
+						if (Session != null) {
+							try {
+								Session.ClosedA();
+								Session.ClosedB(InnerMsg);
+							} catch (Exception ex) {
+								Console.WriteLine("Exception in LegacyPmlCommnuicator.messageReceived->Session.ClosedA/B: " + ex.ToString());
+							}
+						}
+					}
+				} else if (Cmd.Equals("RPL")) {
+					UInt32 SID = default(UInt32);
+					CSyncRequest SRequest = null;
+					SID = Message.GetChild("SID").ToUInt32();
+					lock (pSyncRequests) {
+						if (pSyncRequests.TryGetValue(SID, out SRequest)) {
+							pSyncRequests.Remove(SID);
+						} else {
+							Console.WriteLine("UCIS.PML.Connection.Worker Invalid request ID in reply: " + SID.ToString());
+						}
+					}
+					if (SRequest != null) {
+						SRequest.Reply = Message.GetChild("MSG");
+						SRequest.ResetEvent.Set();
+					}
+				} else if (Cmd.Equals("REQ")) {
+					UCIS.ThreadPool.RunCall(SyncRequestHandler, Message);
+					//System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(SyncRequestHandler), Message);
+				} else if (Cmd.Equals("MSG")) {
+					PmlElement InnerMsg = Message.GetChild("MSG");
+					if (MessageReceived != null) MessageReceived(InnerMsg);
+				} else {
+					throw new InvalidOperationException("Invalid operation");
+				}
+			}
+		}
+		private void closed() {
+			//_channel.MessageReceived -= messageReceived;
+			//_channel.Closed -= closed;
+			Console.WriteLine("UCIS.PML.Connection: Connection closed");
+			try {
+				SessionBase[] sessions;
+				lock (pSessions) {
+					sessions = new SessionBase[pSessions.Count];
+					pSessions.Values.CopyTo(sessions, 0);
+				}
+				foreach (SessionBase S in sessions) {
+					try {
+						S.ClosedB(null);
+					} catch (Exception ex) {
+						Console.WriteLine(ex.ToString());
+					}
+				}
+			} catch (Exception ex) {
+				Console.WriteLine(ex.ToString());
+			}
+			lock (pSessions) pSessions.Clear();
+			try {
+				CSyncRequest[] reqs;
+				lock (pSyncRequests) {
+					reqs = new CSyncRequest[pSyncRequests.Count];
+					pSyncRequests.Values.CopyTo(reqs, 0);
+				}
+				foreach (CSyncRequest T in reqs) {
+					T.ResetEvent.Set();
+				}
+			} catch (Exception ex) {
+				Console.WriteLine(ex.ToString());
+			}
+			lock (pSyncRequests) pSyncRequests.Clear();
+			if (Closed != null) Closed(this, new EventArgs());
+		}
+
+		private void SyncRequestHandler(object state) {
+			PmlDictionary Message = (PmlDictionary)state;
+			PmlElement Reply = null;
+			UInt32 SID = 0;
+			try {
+				SID = Message.GetChild("SID").ToUInt32();
+				PmlElement InnerMsg = Message.GetChild("MSG");
+				if (RequestReceived != null) {
+					RequestReceived(InnerMsg, ref Reply);
+				}
+			} catch (Exception ex) {
+				Reply = new PmlDictionary();
+				((PmlDictionary)Reply).Add("EXCEPTION", new PmlString(ex.ToString()));
+				Console.WriteLine(ex.ToString());
+			}
+			try {
+				WriteSyncMessage(SID, true, Reply);
+			} catch (Exception ex) {
+				Console.WriteLine("Exception: " + ex.ToString());
+			}
+		}
+
+		public PmlElement SyncRequest(PmlElement Request) {
+			return SyncRequest(Request, 30000);
+		}
+		public PmlElement SyncRequest(PmlElement Request, int Timeout) {
+			CSyncRequest SyncEvent = new CSyncRequest();
+			UInt32 SID = GetNextSessionId(false);
+			lock (pSyncRequests) pSyncRequests.Add(SID, SyncEvent);
+			try {
+				WriteSyncMessage(SID, false, Request);
+				if (!SyncEvent.ResetEvent.WaitOne(Timeout, false)) {
+					lock (pSyncRequests) pSyncRequests.Remove(SID);
+					throw new TimeoutException("The SyncRequest timed out (SID=" + SID.ToString() + ")");
+				}
+			} finally {
+				lock (pSyncRequests) pSyncRequests.Remove(SID);
+			}
+			return SyncEvent.Reply;
+		}
+
+		public void SendMessage(PmlElement Message) {
+			PmlDictionary Msg = new PmlDictionary();
+			Msg.Add("CMD", new PmlString("MSG"));
+			Msg.Add("MSG", Message);
+			_WriteMessage(Msg);
+		}
+
+		public void SendRawMessage(PmlElement Message) {
+			_WriteMessage(Message);
+		}
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/PmlBuilder.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace UCIS.Pml {
+	public class PmlBuilder {
+		private IPmlWriter pWriter;
+		private Stack<PmlElement> pStack = new Stack<PmlElement>();
+
+		public PmlBuilder(IPmlWriter Writer) {
+			pWriter = Writer;
+		}
+		public PmlBuilder() {
+			pWriter = null;
+		}
+
+		public IPmlWriter BaseWriter {
+			get { return pWriter; }
+			set { pWriter = value; }
+		}
+
+		private PmlElement AddChildElement(PmlElement Element, bool AddToStack) {
+			return AddChildElement(Element, AddToStack, null);
+		}
+		private PmlElement AddChildElement(PmlElement Element, bool AddToStack, string ChildName) {
+			PmlElement Parent;
+			if (pStack.Count > 0) {
+				Parent = pStack.Peek();
+				if (Parent is PmlDictionary) {
+					if (ChildName == null) throw new ArgumentNullException("ChildName", "Dictionary items need a Name");
+					((PmlDictionary)Parent).Add(ChildName, Element);
+				} else if (Parent is PmlCollection) {
+					if (ChildName != null) throw new ArgumentOutOfRangeException("ChildName", "Can not add named element to a Collection");
+					((PmlCollection)Parent).Add(Element);
+				} else {
+					throw new InvalidOperationException("Invalid Element type in stack: " + Parent.Type.ToString());
+				}
+			} else {
+				if (ChildName != null) {
+					throw new ArgumentOutOfRangeException("ChildName", "Can not create named element without container (Dictionary)");
+				} else if (!AddToStack) {
+					pWriter.WriteMessage(Element);
+				}
+			}
+			if (AddToStack) pStack.Push(Element);
+			return Element;
+		}
+
+		public PmlElement EndElement() {
+			if (pStack.Count > 0) {
+				PmlElement Element = pStack.Pop();
+				if (pStack.Count == 0) {
+					if (pWriter != null) pWriter.WriteMessage(Element);
+				}
+				return Element;
+			} else {
+				return null;
+			}
+		}
+		public PmlElement GetMessage() {
+			if (pStack.Count == 1) {
+				PmlElement Element = pStack.Pop();
+				return Element;
+			} else if (pStack.Count == 0) {
+				throw new InvalidOperationException("No stacked element. The top most element should not be ended. All elements, except Dictionary and Collection, are sent automatically.");
+			} else {
+				throw new InvalidOperationException("All elements, except for the top most element, should be ended.");
+			}
+		}
+
+		public PmlElement SendMessage() {
+			PmlElement Element;
+			if (pWriter == null) throw new NullReferenceException("Writer is not set");
+			Element = GetMessage();
+			pWriter.WriteMessage(Element);
+			return Element;
+		}
+
+		public PmlDictionary Dictionary() {
+			return (PmlDictionary)AddChildElement(new PmlDictionary(), true);
+		}
+		public PmlCollection Collection() {
+			return (PmlCollection)AddChildElement(new PmlCollection(), true);
+		}
+		public PmlString String(string Value) {
+			return (PmlString)AddChildElement(new PmlString(Value), false);
+		}
+		public PmlBinary Binary(byte[] Value) {
+			return (PmlBinary)AddChildElement(new PmlBinary(Value), false);
+		}
+		public PmlInteger Integer(UInt64 Value) {
+			return (PmlInteger)AddChildElement(new PmlInteger(Value), false);
+		}
+		public PmlInteger Integer(Int64 Value) {
+			return (PmlInteger)AddChildElement(new PmlInteger(Value), false);
+		}
+		public PmlNull Null() {
+			return (PmlNull)AddChildElement(new PmlNull(), false);
+		}
+		public PmlElement Element(PmlElement Child) {
+			return AddChildElement(Child, false);
+		}
+
+		public PmlDictionary Dictionary(string Name) {
+			return (PmlDictionary)AddChildElement(new PmlDictionary(), true, Name);
+		}
+		public PmlCollection Collection(string Name) {
+			return (PmlCollection)AddChildElement(new PmlCollection(), true, Name);
+		}
+		public PmlString String(string Name, string Value) {
+			return (PmlString)AddChildElement(new PmlString(Value), false, Name);
+		}
+		public PmlBinary Binary(string Name, byte[] Value) {
+			return (PmlBinary)AddChildElement(new PmlBinary(Value), false, Name);
+		}
+		public PmlInteger Integer(string Name, UInt64 Value) {
+			return (PmlInteger)AddChildElement(new PmlInteger(Value), false, Name);
+		}
+		public PmlInteger Integer(string Name, Int64 Value) {
+			return (PmlInteger)AddChildElement(new PmlInteger(Value), false, Name);
+		}
+		public PmlNull Null(string Name) {
+			return (PmlNull)AddChildElement(new PmlNull(), false, Name);
+		}
+		public PmlElement Element(string Name, PmlElement Child) {
+			return AddChildElement(Child, false, Name);
+		}
+	}
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/PmlCommunicator.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,342 @@
+using System;
+using System.Threading;
+using System.Collections.Generic;
+
+namespace UCIS.Pml {
+/*	class PmlCommunicator : IPmlCommunicator, IDisposable {
+		private IPmlChannel _channel;
+		private Dictionary<UInt32, IPmlSubChannel> _subchannels = new Dictionary<uint,IPmlSubChannel>();
+		private Random _random = new Random();
+
+		private enum CommandCode : int {
+			CallWithoutReply = 0,
+			CallWithReply = 1,
+			Message = 2,
+			ChannelRequest = 3,
+			ChannelAcknowledge = 4,
+			ChannelClose = 5,
+			Error = 6
+		}
+
+		private interface IPmlSubChannel {
+			void CloseIn();
+			void ErrorIn(PmlElement message);
+			void MessageIn(PmlElement message);
+		}
+
+		private class ChannelRequestWaitHandler : IAsyncResult {
+			internal AsyncCallback Callback = null;
+			internal Object CallbackState = null;
+			internal ManualResetEvent Event = null;
+			internal PmlSubChannel Channel = null;
+			internal bool Completed = false;
+
+			internal ChannelRequestWaitHandler(PmlSubChannel channel) {
+				Channel = channel;
+			}
+
+			internal void Complete() {
+				Completed = true;
+				if (Event != null) Event.Set();
+				if (Callback != null) Callback.Invoke(this);
+			}
+
+			public object AsyncState { get { return CallbackState; } }
+			public WaitHandle AsyncWaitHandle { get { return null; } }
+			public bool CompletedSynchronously { get { return false; } }
+			public bool IsCompleted { get { return Completed; } }
+		}
+		private class PmlSubChannel : ActivePmlChannel, IPmlSubChannel {
+			private enum ChannelState { Requesting, Acknowledged, Closed }
+
+			private PmlCommunicator _communicator;
+			private UInt32 _id;
+			private ChannelState _state;
+
+			internal PmlSubChannel(PmlCommunicator communicator, UInt32 sid) {
+				_communicator = communicator;
+				_id = sid;
+				_state = ChannelState.Requesting;
+			}
+
+			public override bool IsOpen { get { return _state == ChannelState.Acknowledged; } }
+
+			internal void AcknowledgeIn() {
+				if (_state != 0) throw new InvalidOperationException("The subchannel is not awaiting an acknowledgement");
+				_state = ChannelState.Acknowledged;
+			}
+			void IPmlSubChannel.CloseIn() {
+				_state = ChannelState.Closed;
+				_communicator._subchannels.Remove(_id);
+				base.Close();
+			}
+			void IPmlSubChannel.ErrorIn(PmlElement message) {
+				(this as IPmlSubChannel).CloseIn();
+			}
+			void IPmlSubChannel.MessageIn(PmlElement message) {
+				base.PushReceivedMessage(message);
+			}
+
+			internal void AcknowledgeOut() {
+				if (_state != 0) throw new InvalidOperationException("The subchannel is not awaiting an acknowledgement");
+				_state = ChannelState.Acknowledged;
+				_communicator.sendMessage(CommandCode.ChannelAcknowledge, _id, null);
+			}
+			internal void RejectOut() {
+				if (_state != 0) throw new InvalidOperationException("The subchannel is not awaiting an acknowledgement");
+				_state = ChannelState.Closed;
+				_communicator.sendMessage(CommandCode.ChannelClose, _id, null);
+			}
+
+			public override void SendMessage(PmlElement message) {
+				if (_state != ChannelState.Acknowledged) throw new InvalidOperationException("The subchannel is not open");
+				_communicator.sendMessage(CommandCode.Message, _id, message);
+			}
+			public override void Close() {
+				if (_state != ChannelState.Acknowledged) return;
+				_state = ChannelState.Closed;
+				_communicator.sendMessage(CommandCode.ChannelClose, _id, null);
+				_communicator._subchannels.Remove(_id);
+				base.Close();
+			}
+		}
+		private class PmlChannelRequestReceivedEventArgsA : PmlChannelRequestReceivedEventArgs {
+			private PmlCommunicator _communicator;
+			private PmlElement _data;
+			private PmlSubChannel _channel;
+			private bool _accepted;
+			private bool _rejected;
+			internal PmlChannelRequestReceivedEventArgsA(PmlCommunicator communicator, UInt32 sid, PmlElement message) {
+				_communicator = communicator;
+				_channel = new PmlSubChannel(communicator, sid);
+				_data = message;
+			}
+			public override IPmlChannel Accept() {
+				if (_accepted || _rejected) throw new InvalidOperationException("The channel has already been accepted or rejected");
+				_accepted = true;
+				_channel.AcknowledgeOut();
+				return _channel;
+			}
+			public override void Reject() {
+				if (_accepted) throw new InvalidOperationException("The channel has already been accepted");
+				if (_rejected) return;
+				_rejected = true;
+				_channel.RejectOut();
+			}
+			internal void RejectIfNotAccepted() {
+				if (!_accepted) Reject();
+			}
+			public override PmlElement Data {
+				get {
+					return _data;
+				}
+			}
+		}
+
+		private class PmlInvocation : IAsyncResult, IPmlSubChannel {
+			internal PmlCommunicator Communicator = null;
+			internal AsyncCallback Callback = null;
+			internal Object CallbackState = null;
+			internal bool Error = false;
+			internal bool Completed = false;
+			internal PmlElement Message = null;
+			internal ManualResetEvent Event = null;
+			internal UInt32 ID;
+
+			internal PmlInvocation(PmlCommunicator communicator, UInt32 id) {
+				Communicator = communicator;
+				ID = id;
+			}
+
+			void IPmlSubChannel.CloseIn() {
+				(this as IPmlSubChannel).ErrorIn(null);
+			}
+			void IPmlSubChannel.ErrorIn(PmlElement message) {
+				Error = true;
+				Communicator._subchannels.Remove(ID);
+				(this as IPmlSubChannel).MessageIn(message);
+			}
+			void IPmlSubChannel.MessageIn(PmlElement message) {
+				Message = message;
+				Completed = true;
+				if (Event != null) Event.Set();
+				if (Callback != null) Callback.Invoke(this);
+			}
+
+			public object AsyncState { get { return CallbackState; } }
+			public WaitHandle AsyncWaitHandle { get { return null; } }
+			public bool CompletedSynchronously { get { return false; } }
+			public bool IsCompleted { get { return Completed; } }
+		}
+
+		public event EventHandler<PmlCallReceivedEventArgs> CallReceived;
+		public event EventHandler<PmlChannelRequestReceivedEventArgs> ChannelRequestReceived;
+
+		public PmlCommunicator(IPmlChannel channel) {
+			_channel = channel;
+			_channel.Closed += channelClosed;
+		}
+
+		public void Dispose() {
+			_channel.Close();
+			_channel = null;
+			IPmlSubChannel[] A = new IPmlSubChannel[_subchannels.Count];
+			_subchannels.Values.CopyTo(A, 0);
+			foreach (IPmlSubChannel S in A) S.CloseIn();
+			_subchannels.Clear();
+			_subchannels = null;
+			_random = null;
+		}
+
+		private void channelClosed(Object sender, EventArgs e) {
+			Dispose();
+		}
+
+		public IPmlChannel Channel { get { return _channel; } }
+
+		public void Call(PmlElement message) {
+			sendMessage(0, 0, message); //Call without reply
+		}
+		public PmlElement Invoke(PmlElement message) {
+			return Invoke(message, 60000);
+		}
+		public PmlElement Invoke(PmlElement message, int timeout) {
+			UInt32 sid = getSessionID();
+			PmlInvocation inv = new PmlInvocation(this, sid);
+			inv.Event = new ManualResetEvent(false);
+			_subchannels.Add(sid, inv);
+			sendMessage(CommandCode.CallWithReply, sid, message);
+			inv.Event.WaitOne(timeout);
+			if (inv.Error) throw new Exception(message.ToString());
+			return inv.Message;
+		}
+
+		public IAsyncResult BeginInvoke(PmlElement message, AsyncCallback callback, Object state) {
+			UInt32 sid = getSessionID();
+			PmlInvocation inv = new PmlInvocation(this, sid);
+			inv.Callback = callback;
+			inv.CallbackState = state;
+			_subchannels.Add(sid, inv);
+			sendMessage(CommandCode.CallWithReply, sid, message);
+			return inv;
+		}
+		public PmlElement EndInvoke(IAsyncResult result) {
+			PmlInvocation ar = (PmlInvocation)result;
+			if (!ar.Completed) {
+				(_subchannels as IList<IPmlSubChannel>).Remove(ar);
+				throw new InvalidOperationException("The asynchronous operation has not completed");
+			} else if (ar.Error) {
+				throw new Exception(ar.Message.ToString());
+			} else {
+				return ar.Message;
+			}
+		}
+
+		public IPmlChannel CreateChannel(PmlElement data) {
+			UInt32 sid = getSessionID();
+			PmlSubChannel ch = new PmlSubChannel(this, sid);
+			ChannelRequestWaitHandler wh = new ChannelRequestWaitHandler(ch);
+			wh.Event = new ManualResetEvent(false);
+			_subchannels.Add(sid, ch);
+			sendMessage(CommandCode.ChannelRequest, sid, data);
+			wh.Event.WaitOne();
+			if (!ch.IsOpen) return null;
+			return ch;
+		}
+		public IAsyncResult BeginCreateChannel(PmlElement data, AsyncCallback callback, Object state) {
+			UInt32 sid = getSessionID();
+			PmlSubChannel ch = new PmlSubChannel(this, sid);
+			ChannelRequestWaitHandler wh = new ChannelRequestWaitHandler(ch);
+			wh.Callback = callback;
+			wh.CallbackState = state;
+			_subchannels.Add(sid, ch);
+			sendMessage(CommandCode.ChannelRequest, sid, data);
+			if (!ch.IsOpen) return null;
+			return wh;
+		}
+		public IPmlChannel EndCreateChannel(IAsyncResult result) {
+			ChannelRequestWaitHandler ar = (ChannelRequestWaitHandler)result;
+			if (!ar.Channel.IsOpen) return null;
+			return ar.Channel;
+		}
+
+		private UInt32 getSessionID() {
+			return (uint)_random.Next();
+		}
+
+		private void sendMessage(CommandCode cmd, uint sid, PmlElement message) {
+			PmlDictionary msg = new PmlDictionary();
+			msg.Add("c", (int)cmd);
+			if (cmd > 0) msg.Add("s", sid);
+			if (message != null) msg.Add("m", message);
+			_channel.SendMessage(msg);
+		}
+
+		private void invokeCallReceived(Object state) {
+			PmlCallReceivedEventArgs e = (PmlCallReceivedEventArgs)state;
+			try {
+				if (CallReceived != null) CallReceived(this, e);
+				if (e.WantReply) sendMessage(CommandCode.Message, e.SID, e.Reply);
+			} catch (Exception ex) {
+				if (e.WantReply) sendMessage(CommandCode.Error, e.SID, new PmlString(ex.ToString()));
+			}
+		}
+		private void invokeChannelRequestReceived(Object state) {
+			PmlChannelRequestReceivedEventArgsA e = (PmlChannelRequestReceivedEventArgsA)state;
+			if (ChannelRequestReceived != null) ChannelRequestReceived(this, e);
+			e.RejectIfNotAccepted();
+		}
+
+		private void messageReceived(Object sender, EventArgs e) {
+			IPmlSubChannel subChannel = null;
+			UInt32 sid = 0;
+			bool subChannelExists = false;
+			if (!(e.Message is PmlDictionary)) return;
+			PmlDictionary msg = (PmlDictionary)e.Message;
+			PmlElement cmdElement = msg.GetChild("c");
+			PmlElement sidElement = msg.GetChild("i");
+			PmlElement msgElement = msg.GetChild("m");
+			if (cmdElement == null) return;
+			if (sidElement != null) sid = sidElement.ToUInt32();
+			if (sidElement != null) subChannelExists = _subchannels.TryGetValue(sid, out subChannel);
+			if (!subChannelExists) subChannel = null;
+			switch ((CommandCode)cmdElement.ToInt32()) {
+				case CommandCode.CallWithoutReply:
+					if (CallReceived != null) ThreadPool.RunCall(invokeCallReceived, new PmlCallReceivedEventArgs(msgElement, false, 0));
+					break;
+				case CommandCode.CallWithReply:
+					if (CallReceived != null) ThreadPool.RunCall(invokeCallReceived, new PmlCallReceivedEventArgs(msgElement, true, sid));
+					else sendMessage(CommandCode.Error, sid, null);
+					break;
+				case CommandCode.Message: //Reply to call | subchannel message
+					if (subChannelExists) subChannel.MessageIn(msgElement);
+					else sendMessage(CommandCode.Error, sid, null);
+					break;
+				case CommandCode.ChannelRequest:
+					if (subChannelExists) {
+						sendMessage(CommandCode.Error, sid, null);
+						subChannel.CloseIn();
+					} else {
+						if (ChannelRequestReceived == null) sendMessage(CommandCode.ChannelClose, sid, null);
+						else ThreadPool.RunCall(invokeChannelRequestReceived, new PmlChannelRequestReceivedEventArgsA(this, sid, msgElement));
+					}
+					break;
+				case CommandCode.ChannelAcknowledge:
+					if (subChannelExists) {
+						if (subChannel is PmlSubChannel) (subChannel as PmlSubChannel).AcknowledgeIn();
+						else {
+							sendMessage(CommandCode.Error, sid, null); //Error
+							subChannel.CloseIn();
+						}
+					} else sendMessage(CommandCode.Error, sid, null); //Error
+					break;
+				case CommandCode.ChannelClose:
+					if (subChannelExists) subChannel.CloseIn();
+					break;
+				case CommandCode.Error:
+					if (subChannelExists) subChannel.ErrorIn(msgElement);
+					break;
+			}
+		}
+	}*/
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Pml/PmlCommunicator2.cs	Tue Sep 11 16:28:53 2012 +0200
@@ -0,0 +1,479 @@
+using System;
+using System.Threading;
+using System.Collections.Generic;
+using UCIS.Pml;
+
+namespace UCIS.Pml {
+	public class PmlCommunicator {
+		private class CSyncRequest {
+			internal PmlElement Reply;
+			internal ManualResetEvent ResetEvent = new ManualResetEvent(false);
+		}
+		private interface ISession {
+			void MessageIn(PmlElement message);
+			void CloseIn();
+			UInt32 ID { get; }
+		}
+		/*public abstract class SessionBase : ISession {
+			private bool pActive;
+			private PmlCommunicator _communicator;
+			private UInt32 _id;
+
+			public uint SID { get { return _id; } }
+			public bool Active { get { return pActive; } }
+			public PmlCommunicator Communicator { get { return _communicator; } }
+
+			protected SessionBase(PmlCommunicator Connection) {
+				_communicator = Connection;
+			}
+
+			protected void Accept(UInt32 sid) {
+				if (pActive) throw new InvalidOperationException("Session is active");
+				_id = sid;
+				lock (_communicator._sessions) _communicator._sessions.Add(_id, this);
+				pActive = true;
+			}
+			protected void Request() {
+				Request(null);
+			}
+			protected void Request(PmlElement Message) {
+				if (pActive) throw new InvalidOperationException("Session is active");
+				_id = _communicator.GetNextSessionId(true);
+				lock (_communicator._sessions) _communicator._sessions.Add(_id, this);
+				_communicator.WriteSessionMessage(_id, 0, Message);
+				pActive = true;
+			}
+
+			uint ISession.ID { get { return _id; } }
+			void ISession.MessageIn(PmlElement message) { this.MessageIn(message); }
+			void ISession.CloseIn() {
+				pActive = false;
+				_communicator.RemoveSession(this);
+				Closed(null);
+			}
+
+			protected internal abstract void MessageIn(PmlElement Message);
+
+			protected void SendMessage(PmlElement Message) {
+				if (!pActive) throw new InvalidOperationException("Session is not active");
+				_communicator.WriteSessionMessage(_id, 1, Message);
+			}
+
+			public void Close() {
+				if (!pActive) return;
+				pActive = false;
+				_communicator.WriteSessionMessage(_id, 2, null);
+				_communicator.RemoveSession(this);
+			}
+
+			protected virtual void Closed(PmlElement Message) { }
+		}
+		public class Session : SessionBase {
+			public event MessageReceivedEventHandler MessageReceived;
+			public delegate void MessageReceivedEventHandler(PmlElement Message);
+			public event SessionClosedEventHandler SessionClosed;
+			public delegate void SessionClosedEventHandler(PmlElement Message);
+
+			public Session(PmlCommunicator Connection) : base(Connection) { }
+
+			public new void Accept(UInt32 SID) {
+				base.Accept(SID);
+			}
+			public new void Request() {
+				Request(null);
+			}
+			public new void Request(PmlElement Message) {
+				base.Request(Message);
+			}
+
+			protected internal override void MessageIn(PmlElement Message) {
+				if (MessageReceived != null) MessageReceived(Message);
+			}
+
+			public new void SendMessage(PmlElement Message) {
+				base.SendMessage(Message);
+			}
+
+			protected override void Closed(PmlElement Message) {
+				if (SessionClosed != null) SessionClosed(Message);
+			}
+		}*/
+
+		private class PmlSubChannel : ActivePmlChannel, ISession {
+			private enum ChannelState { Requesting, Acknowledged, Closed }
+
+			private PmlCommunicator _communicator;
+			private UInt32 _id;
+			private ChannelState _state;
+
+			internal PmlSubChannel(PmlCommunicator communicator, UInt32 sid, bool accepted) {
+				_communicator = communicator;
+				_id = sid;
+				_state = accepted ? ChannelState.Acknowledged : ChannelState.Requesting;
+				if (accepted) _communicator.AddSession(this);
+			}
+
+			public override bool IsOpen { get { return _state == ChannelState.Acknowledged; } }
+
+			uint ISession.ID { get { return _id; } }
+			void ISession.CloseIn() {
+				_state = ChannelState.Closed;
+				_communicator.RemoveSession(this);
+				base.Close();
+			}
+			void ISession.MessageIn(PmlElement message) {
+				base.PushReceivedMessage(message);
+			}
+
+			public override void WriteMessage(PmlElement message) {
+				if (_state != ChannelState.Acknowledged) throw new InvalidOperationException("The subchannel is not open");
+				_communicator.WriteSessionMessage(_id, 1, message);
+			}
+			public override void Close() {
+				if (_state != ChannelState.Acknowledged) return;
+				_state = ChannelState.Closed;
+				_communicator.WriteSessionMessage(_id, 2, null);
+				_communicator.RemoveSession(this); 
+				base.Close();
+			}
+		}
+		private class PmlChannelRequestReceivedEventArgsA : PmlChannelRequestReceivedEventArgs {
+			private PmlCommunicator _communicator;
+			private PmlElement _data;
+			private bool _accepted, _rejected;
+			private UInt32 _sid;
+			internal PmlChannelRequestReceivedEventArgsA(PmlCommunicator communicator, UInt32 sid, PmlElement message) {
+				_communicator = communicator;
+				_data = message;
+				_sid = sid;
+				_accepted = _rejected = false;
+			}
+			public UInt32 AcceptSession() {
+				if (_accepted || _rejected) throw new InvalidOperationException("The channel has already been accepted or rejected");
+				_accepted = true;
+				return _sid;
+			}
+			public override IPmlChannel Accept() {
+				if (_accepted || _rejected) throw new InvalidOperationException("The channel has already been accepted or rejected");
+				_accepted = true;
+				return new PmlSubChannel(_communicator, _sid, true);
+			}
+			public override void Reject() {
+				if (_accepted) throw new InvalidOperationException("The channel has already been accepted");
+				if (_rejected) return;
+				_rejected = true;
+				_communicator.WriteSessionMessage(_sid, 2, null);
+				//_channel.RejectOut();
+			}
+			internal void RejectIfNotAccepted() {
+				if (!_accepted) Reject();
+			}
+			public override PmlElement Data {
+				get {
+					return _data;
+				}
+			}
+		}
+
+		public event EventHandler<PmlCallReceivedEventArgs> CallReceived;
+		public event EventHandler<PmlChannelRequestReceivedEventArgs> ChannelRequestReceived;
+		public event EventHandler Closed;
+
+		private Dictionary<UInt32, ISession> _sessions = new Dictionary<UInt32, ISession>();
+		private Dictionary<UInt32, CSyncRequest> _invocations = new Dictionary<UInt32, CSyncRequest>();
+		private UInt32 pNextSession;
+		private UInt32 pNextSyncRequest;
+
+		private bool _closed;
+		private IPmlChannel _channel;
+
+		public IPmlChannel Channel { get { return _channel; } }
+
+		public PmlCommunicator(IPmlChannel channel, bool autoStart) {
+			_channel = channel;
+			if (autoStart) Start();
+		}
+		public void Start() {
+			_channel.BeginReadMessage(messageReceived, null);
+		}
+		public void StartSync() {
+			while (true) {
+				try {
+					processMessage(_channel.ReadMessage());
+				} catch (InvalidOperationException ex) {
+					Console.WriteLine("InvalidOperationException in LegacyPmlCommunicator.messageReceived: " + ex.Message);
+					closed();
+					_channel.Close();
+					return;
+				} catch (Exception ex) {
+					Console.WriteLine(ex.ToString());
+					closed();
+					_channel.Close();
+					return;
+				}
+			}
+		}
+		public void Close() {
+			_channel.Close();
+		}
+		public void WriteRawMessage(PmlElement Message) {
+			_WriteMessage(Message);
+		}
+
+		private void _WriteMessage(PmlElement Message) {
+			lock (_channel) {
+				if (!_channel.IsOpen) throw new InvalidOperationException("Could not write message: the channel is not open");
+				_channel.WriteMessage(Message);
+			}
+		}
+		private void closed() {
+			_closed = true;
+			lock (_sessions) {
+				foreach (ISession S in _sessions.Values) {
+					try {
+						S.CloseIn();
+					} catch (Exception ex) {
+						Console.WriteLine(ex.ToString());
+					}
+				}
+				_sessions.Clear();
+			}
+			lock (_invocations) {
+				foreach (CSyncRequest T in _invocations.Values) {
+					T.ResetEvent.Set();
+				}
+				_invocations.Clear();
+			}
+			if (Closed != null) Closed(this, new EventArgs());
+		}
+
+		private void messageReceived(IAsyncResult ar) {
+			try {
+				PmlElement Message = _channel.EndReadMessage(ar);
+				processMessage(Message);
+				_channel.BeginReadMessage(messageReceived, null);
+			} catch (InvalidOperationException ex) {
+				Console.WriteLine("InvalidOperationException in LegacyPmlCommunicator.messageReceived: " + ex.Message);
+				closed();
+				_channel.Close();
+				return;
+			} catch (Exception ex) {
+				Console.WriteLine(ex.ToString());
+				closed();
+				_channel.Close();
+				return;
+			}
+		}
+		private void processMessage(PmlElement Message) {
+			if (Message is PmlString) {
+				string Cmd = Message.ToString();
+				if (Cmd.Equals("PING")) {
+					_WriteMessage(new PmlString("PONG"));
+				/*} else if (Cmd.Equals("PONG")) {
+					Ping = 0;*/
+				}
+			} else if (Message is PmlDictionary) {
+				string Cmd = Message.GetChild("CMD").ToString();
+				if (Cmd.Equals("SES")) {
+					processSessionMessage(Message);
+				} else if (Cmd.Equals("RPL")) {
+					UInt32 SID = Message.GetChild("SID").ToUInt32();
+					CSyncRequest SRequest = null;
+					lock (_invocations) {
+						if (_invocations.TryGetValue(SID, out SRequest)) {
+							_invocations.Remove(SID);
+						} else {
+							Console.WriteLine("UCIS.PML.Connection.Worker Invalid request ID in reply: " + SID.ToString());
+						}
+					}
+					if (SRequest != null) {
+						SRequest.Reply = Message.GetChild("MSG");
+						SRequest.ResetEvent.Set();
+					}
+				} else if (Cmd.Equals("REQ") || Cmd.Equals("MSG")) {
+					UCIS.ThreadPool.RunCall(processCall, Message);
+				} else {
+					Console.WriteLine("UCIS.PML.Connection.Worker Invalid command received");
+				}
+			}
+		}
+		private void processSessionMessage(PmlElement Message) {
+			UInt32 SID = Message.GetChild("SID").ToUInt32();
+			byte SCMD = Message.GetChild("SCMD").ToByte();
+			PmlElement InnerMsg = Message.GetChild("MSG");
+			ISession Session = null;
+			lock (_sessions) if (!_sessions.TryGetValue(SID, out Session)) Session = null;
+			switch (SCMD) {
+				case 0: //Request
+					if (Session != null) {
+						try {
+							Session.CloseIn();
+						} catch (Exception ex) {
+							Console.WriteLine("UCIS.Pml.PmlCommunicator.processSessionMessage-Request: exception in session.CloseIn: " + ex.ToString());
+						}
+						WriteSessionMessage(SID, 2, null);
+					} else if (ChannelRequestReceived != null) {
+						try {
+							PmlChannelRequestReceivedEventArgsA ea = new PmlChannelRequestReceivedEventArgsA(this, SID, InnerMsg);
+							ChannelRequestReceived(this, ea);
+							ea.RejectIfNotAccepted();
+						} catch (Exception ex) {
+							Console.WriteLine("UCIS.Pml.PmlCommunicator.processSessionMessage: exception in ChannelRequestReceived: " + ex.ToString());
+							WriteSessionMessage(SID, 2, null);
+						}
+					} else {
+						WriteSessionMessage(SID, 2, null);
+					}
+					break;
+				case 1: //Message
+					if (Session != null) {
+						try {
+							Session.MessageIn(InnerMsg);
+						} catch (Exception ex) {
+							Console.WriteLine("UCIS.Pml.PmlCommunicator.processSessionMessage: exception in session.MessageIn: " + ex.ToString());
+							WriteSessionMessage(SID, 2, null);
+						}
+					} else {
+						WriteSessionMessage(SID, 2, null);
+					}
+					break;
+				case 2: //Close
+					if (Session != null) {
+						try {
+							if (InnerMsg != null && !(InnerMsg is PmlNull)) Session.MessageIn(InnerMsg);
+						} catch (Exception ex) {
+							Console.WriteLine("UCIS.Pml.PmlCommunicator.processSessionMessage-Close: exception in session.MessageIn: " + ex.ToString());
+						} finally {
+							try {
+								Session.CloseIn();
+							} catch (Exception ex) {
+								Console.WriteLine("UCIS.Pml.PmlCommunicator.processSessionMessage: exception in session.CloseIn: " + ex.ToString());
+							}
+						}
+					}
+					break;
+			}
+		}
+		private void processCall(object state) {
+			PmlDictionary Message = (PmlDictionary)state;
+			bool wantReply = Message.ContainsKey("SID");
+			UInt32 SID = 0;
+			if (wantReply) SID = Message.GetChild("SID").ToUInt32();
+			PmlElement Reply = null;
+			try {
+				if (CallReceived != null) {
+					PmlCallReceivedEventArgs ea = new PmlCallReceivedEventArgs(Message.GetChild("MSG"), wantReply, SID);
+					CallReceived(this, ea);
+					Reply = ea.Reply;
+				}
+			} catch (Exception ex) {
+				Reply = new PmlDictionary();
+				((PmlDictionary)Reply).Add("EXCEPTION", new PmlString(ex.ToString()));
+				Console.WriteLine(ex.ToString());
+			} finally {
+				if (wantReply && Channel.IsOpen) {
+					try {
+						WriteSyncMessage(SID, true, Reply);
+					} catch (Exception ex) {
+						Console.WriteLine("UCIS.Pml.PmlCommunicator.processCall: exception: " + ex.ToString());
+						closed();
+						Channel.Close();
+					}
+				}
+			}
+		}
+
+		public void Call(PmlElement message) {
+			PmlDictionary Msg = new PmlDictionary();
+			Msg.Add("CMD", new PmlString("MSG"));
+			Msg.Add("MSG", message);
+			_WriteMessage(Msg);
+		}
+		public PmlElement Invoke(PmlElement message) {
+			return Invoke(message, 60000);
+		}
+		public PmlElement Invoke(PmlElement message, int timeout) {
+			if (_closed) throw new InvalidOperationException("Sorry, we're closed.");
+			CSyncRequest SyncEvent = new CSyncRequest();
+			UInt32 SID = GetNextSessionId(false);
+			lock (_invocations) _invocations.Add(SID, SyncEvent);
+			try {
+				WriteSyncMessage(SID, false, message);
+				if (!SyncEvent.ResetEvent.WaitOne(timeout, false)) {
+					if (!_closed) lock (_invocations) _invocations.Remove(SID);
+					throw new TimeoutException("The SyncRequest timed out (SID=" + SID.ToString() + ")");
+				}
+			} finally {
+				lock (_invocations) _invocations.Remove(SID);
+			}
+			return SyncEvent.Reply;
+		}
+
+		public IPmlChannel CreateChannel(PmlElement data) {
+			UInt32 sid = GetNextSessionId(true);
+			PmlSubChannel ch = new PmlSubChannel(this, sid, true);
+			WriteSessionMessage(sid, 0, data);
+			if (!ch.IsOpen) return null;
+			return ch;
+		}
+
+		private void AddSession(ISession session) {
+			if (_closed) return;
+			lock (_sessions) _sessions.Add(session.ID, session);
+		}
+		private void RemoveSession(UInt32 session) {
+			if (_closed) return;
+			lock (_sessions) _sessions.Remove(session);
+		}
+		private void RemoveSession(ISession session) {
+			RemoveSession(session.ID);
+		}
+
+		private UInt32 GetNextSessionId(bool IsSession) {
+			if (IsSession) {
+				lock (_sessions) {
+					do {
+						unchecked { pNextSession++; }
+					} while (_sessions.ContainsKey(pNextSession));
+					return pNextSession;
+				}
+			} else {
+				lock (_invocations) {
+					do {
+						unchecked { pNextSyncRequest++; }
+					} while (_invocations.ContainsKey(pNextSyncRequest));
+					return pNextSyncRequest;
+				}
+			}
+		}
+
+		protected void WriteSyncMessage(UInt32 SID, bool RPL, PmlElement MSG) {
+			PmlDictionary Msg2 = new PmlDictionary();
+			Msg2.Add("CMD", new PmlString(RPL ? "RPL" : "REQ"));
+			Msg2.Add("SID", new PmlInteger(SID));
+			Msg2.Add("MSG", MSG);
+			_WriteMessage(Msg2);
+		}
+		protected void WriteSessionMessage(UInt32 SID, byte CMD, PmlElement MSG) {
+			PmlDictionary Msg2 = new PmlDictionary();
+			Msg2.Add("CMD", new PmlString("SES"));
+			Msg2.Add("SID", new PmlInteger(SID));
+			Msg2.Add("SCMD", new PmlInteger(CMD));
+			if (MSG != null) Msg2.Add("MSG", MSG);
+			_WriteMessage(Msg2);
+		}
+
+
+
+		/* LegacyPmlCommunicator compatibility */
+		public PmlElement SyncRequest(PmlElement Request) {
+			return Invoke(Request);
+		}
+		public PmlElement SyncRequest(PmlElement Request, int Timeout) {
+			return Invoke(Request, Timeout);
+		}
+		public void SendMessage(PmlElement Message) {
+			Call(Message);
+		}
+	}
+}