QPID-128 Initial import of the C# sources.

git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk/qpid@479211 13f79535-47bb-0310-9956-ffa450edef68

10 files changed, 551 insertions, 0 deletions

diff --git a/dotnet/Qpid.Client/Client/Handler/BasicDeliverMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/BasicDeliverMethodHandler.cs
new file mode 100644
index 0000000000..d6e196c8dd
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/BasicDeliverMethodHandler.cs
@@ -0,0 +1,42 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using log4net;
+using Qpid.Client.Message;
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+using Qpid.Framing;
+
+namespace Qpid.Client.Handler
+{
+    public class BasicDeliverMethodHandler : IStateAwareMethodListener
+    {
+        private static readonly ILog _logger = LogManager.GetLogger(typeof(BasicDeliverMethodHandler));
+
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            UnprocessedMessage msg = new UnprocessedMessage();
+            msg.DeliverBody = (BasicDeliverBody) evt.Method;
+            msg.ChannelId = evt.ChannelId;
+            _logger.Debug("New JmsDeliver method received");
+            evt.ProtocolSession.UnprocessedMessageReceived(msg);
+        }
+    }
+}
diff --git a/dotnet/Qpid.Client/Client/Handler/BasicReturnMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/BasicReturnMethodHandler.cs
new file mode 100644
index 0000000000..78526f906f
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/BasicReturnMethodHandler.cs
@@ -0,0 +1,44 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using log4net;
+using Qpid.Client.Message;
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+using Qpid.Framing;
+
+namespace Qpid.Client.Handler
+{
+    public class BasicReturnMethodHandler : IStateAwareMethodListener
+    {
+        private static readonly ILog _logger = LogManager.GetLogger(typeof(BasicReturnMethodHandler));
+
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt) 
+        {
+            _logger.Debug("New JmsBounce method received");
+            UnprocessedMessage msg = new UnprocessedMessage();
+            msg.DeliverBody = null;
+            msg.BounceBody = (BasicReturnBody) evt.Method;
+            msg.ChannelId = evt.ChannelId;
+
+            evt.ProtocolSession.UnprocessedMessageReceived(msg);
+        }
+    }
+}
diff --git a/dotnet/Qpid.Client/Client/Handler/ChannelCloseMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/ChannelCloseMethodHandler.cs
new file mode 100644
index 0000000000..1031f804a6
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/ChannelCloseMethodHandler.cs
@@ -0,0 +1,57 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using log4net;
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+using Qpid.Framing;
+
+namespace Qpid.Client.Handler
+{
+    public class ChannelCloseMethodHandler : IStateAwareMethodListener
+    {
+        private static readonly ILog _logger = LogManager.GetLogger(typeof(ChannelCloseMethodHandler));
+
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            _logger.Debug("ChannelClose method received");
+            ChannelCloseBody method = (ChannelCloseBody) evt.Method;
+
+            int errorCode = method.ReplyCode;
+            string reason = method.ReplyText;
+            if (_logger.IsDebugEnabled)
+            {
+                _logger.Debug("Channel close reply code: " + errorCode + ", reason: " + reason);
+            }
+
+            AMQFrame frame = ChannelCloseOkBody.CreateAMQFrame(evt.ChannelId);
+            evt.ProtocolSession.WriteFrame(frame);
+            //if (errorCode != AMQConstant.REPLY_SUCCESS.getCode())
+            // HACK
+            if (errorCode != 200)
+            {
+                _logger.Debug("Channel close received with errorCode " + errorCode + ", throwing exception");
+                evt.ProtocolSession.AMQConnection.ExceptionReceived(new AMQChannelClosedException(errorCode, "Error: " + reason));
+            }
+            evt.ProtocolSession.ChannelClosed(evt.ChannelId, errorCode, reason);
+        }
+    }
+}
+
diff --git a/dotnet/Qpid.Client/Client/Handler/ConnectionCloseMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/ConnectionCloseMethodHandler.cs
new file mode 100644
index 0000000000..c3acc0b098
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/ConnectionCloseMethodHandler.cs
@@ -0,0 +1,53 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using System;
+using log4net;
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+using Qpid.Framing;
+
+namespace Qpid.Client.Handler
+{
+    public class ConnectionCloseMethodHandler : IStateAwareMethodListener
+    {
+        private static readonly ILog _logger = LogManager.GetLogger(typeof(ConnectionCloseMethodHandler));
+
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            _logger.Debug("ConnectionClose frame received");
+            ConnectionCloseBody method = (ConnectionCloseBody) evt.Method;
+
+            int errorCode = method.ReplyCode;
+            String reason = method.ReplyText;
+
+            evt.ProtocolSession.WriteFrame(ConnectionCloseOkBody.CreateAMQFrame(evt.ChannelId));
+            stateManager.ChangeState(AMQState.CONNECTION_CLOSED);
+            if (errorCode != 200)
+            {
+                _logger.Debug("Connection close received with error code " + errorCode);
+                throw new AMQConnectionClosedException(errorCode, "Error: " + reason);
+            }
+
+            // this actually closes the connection in the case where it is not an error.
+            evt.ProtocolSession.CloseProtocolSession();
+        }
+    }
+}
diff --git a/dotnet/Qpid.Client/Client/Handler/ConnectionCloseOkHandler.cs b/dotnet/Qpid.Client/Client/Handler/ConnectionCloseOkHandler.cs
new file mode 100644
index 0000000000..0cd60457ea
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/ConnectionCloseOkHandler.cs
@@ -0,0 +1,40 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using log4net;
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+using Qpid.Framing;
+
+namespace Qpid.Client.Handler
+{
+    public class ConnectionCloseOkHandler : IStateAwareMethodListener
+    {
+        private static readonly ILog _logger = LogManager.GetLogger(typeof(ConnectionCloseOkHandler));
+
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            _logger.Debug("ConnectionCloseOk frame received");
+            ConnectionCloseOkBody method = (ConnectionCloseOkBody)evt.Method;
+            stateManager.ChangeState(AMQState.CONNECTION_CLOSED);
+        }
+    }
+}
+
diff --git a/dotnet/Qpid.Client/Client/Handler/ConnectionOpenOkMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/ConnectionOpenOkMethodHandler.cs
new file mode 100644
index 0000000000..b43e2700f6
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/ConnectionOpenOkMethodHandler.cs
@@ -0,0 +1,34 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+
+namespace Qpid.Client.Handler
+{
+    public class ConnectionOpenOkMethodHandler : IStateAwareMethodListener
+    {
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            stateManager.ChangeState(AMQState.CONNECTION_OPEN);
+        }
+    }
+}
+
diff --git a/dotnet/Qpid.Client/Client/Handler/ConnectionRedirectMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/ConnectionRedirectMethodHandler.cs
new file mode 100644
index 0000000000..4437290f5c
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/ConnectionRedirectMethodHandler.cs
@@ -0,0 +1,67 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using log4net;
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+
+namespace Qpid.Client.Handler
+{
+    public class ConnectionRedirectMethodHandler : IStateAwareMethodListener
+    {
+        private static readonly ILog _logger = LogManager.GetLogger(typeof(ConnectionRedirectMethodHandler));
+
+        private const int DEFAULT_REDIRECT_PORT = 5672;
+
+        private static ConnectionRedirectMethodHandler _handler = new ConnectionRedirectMethodHandler();
+
+        public static ConnectionRedirectMethodHandler GetInstance()
+        {
+            return _handler;
+        }
+
+        private ConnectionRedirectMethodHandler()
+        {
+        }
+
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            /*_logger.Info("ConnectionRedirect frame received");
+            ConnectionRedirectBody method = (ConnectionRedirectBody) evt.Method;
+
+            // the host is in the form hostname:port with the port being optional
+            int portIndex = method.Host.IndexOf(':');
+            String host;
+            int port;
+            if (portIndex == -1)
+            {
+                host = method.Host;
+                port = DEFAULT_REDIRECT_PORT;
+            }
+            else
+            {
+                host = method.Host.Substring(0, portIndex);
+                port = Int32.Parse(method.Host.Substring(portIndex + 1));
+            }
+            evt.ProtocolSession.Failover(host, port);*/
+        }
+    }
+}
+
diff --git a/dotnet/Qpid.Client/Client/Handler/ConnectionSecureMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/ConnectionSecureMethodHandler.cs
new file mode 100644
index 0000000000..7c0fbd8f40
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/ConnectionSecureMethodHandler.cs
@@ -0,0 +1,36 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+using Qpid.Framing;
+
+namespace Qpid.Client.Handler
+{
+    public class ConnectionSecureMethodHandler : IStateAwareMethodListener
+    {
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            AMQFrame response = ConnectionSecureOkBody.CreateAMQFrame(evt.ChannelId, null);
+            evt.ProtocolSession.WriteFrame(response);
+        }
+    }
+}
+
diff --git a/dotnet/Qpid.Client/Client/Handler/ConnectionStartMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/ConnectionStartMethodHandler.cs
new file mode 100644
index 0000000000..2bba8662bb
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/ConnectionStartMethodHandler.cs
@@ -0,0 +1,113 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using System;
+using System.Text;
+using log4net;
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+using Qpid.Framing;
+
+namespace Qpid.Client.Handler
+{
+    public class ConnectionStartMethodHandler : IStateAwareMethodListener
+    {
+        private static readonly ILog _log = LogManager.GetLogger(typeof(ConnectionStartMethodHandler));
+
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            ConnectionStartBody body = (ConnectionStartBody) evt.Method;
+            AMQProtocolSession ps = evt.ProtocolSession;
+            string username = ps.Username;
+            string password = ps.Password;
+
+            try
+            {
+                if (body.Mechanisms == null)
+                {
+                    throw new AMQException("mechanism not specified in ConnectionStart method frame");
+                }
+                string allMechanisms = Encoding.ASCII.GetString(body.Mechanisms);
+                string[] mechanisms = allMechanisms.Split(' ');
+                string selectedMechanism = null;
+                foreach (string mechanism in mechanisms)
+                {
+                    if (mechanism.Equals("PLAIN"))
+                    {
+                        selectedMechanism = mechanism;
+                        break;
+                    }
+                }
+        
+                if (selectedMechanism == null)
+                {
+                    throw new AMQException("No supported security mechanism found, passed: " + mechanisms);
+                }
+
+                // we always write out a null authzid which we don't currently use
+                byte[] plainData = new byte[1 + ps.Username.Length + 1 + ps.Password.Length];
+                Encoding.UTF8.GetBytes(username, 0, username.Length, plainData, 1);
+                Encoding.UTF8.GetBytes(password, 0, password.Length, plainData, username.Length + 2);
+                if (body.Locales == null)
+                {
+                    throw new AMQException("Locales is not defined in Connection Start method");
+                }
+                string allLocales = Encoding.ASCII.GetString(body.Locales);
+                string[] locales = allLocales.Split(new char[] { ' ' });
+                string selectedLocale;
+                if (locales != null && locales.Length > 0)
+                {
+                    selectedLocale = locales[0];
+                }
+                else
+                {
+                    throw new AMQException("No locales sent from server, passed: " + locales);
+                }
+
+                stateManager.ChangeState(AMQState.CONNECTION_NOT_TUNED);
+                FieldTable clientProperties = new FieldTable();
+                clientProperties["product"] = "Qpid.NET";
+                clientProperties["version"] = "1.0";
+                clientProperties["platform"] = GetFullSystemInfo();
+                AMQFrame frame = ConnectionStartOkBody.CreateAMQFrame(evt.ChannelId, clientProperties, selectedMechanism,
+                                                                      plainData, selectedLocale);
+                ps.WriteFrame(frame);
+            }
+            catch (Exception e)
+            {
+                throw new AMQException(_log, "Unable to decode data: " + e, e);
+            }
+        }
+
+        private string GetFullSystemInfo()
+        {
+            /*StringBuffer fullSystemInfo = new StringBuffer();
+            fullSystemInfo.append(System.getProperty("java.runtime.name"));
+            fullSystemInfo.append(", " + System.getProperty("java.runtime.version"));
+            fullSystemInfo.append(", " + System.getProperty("java.vendor"));
+            fullSystemInfo.append(", " + System.getProperty("os.arch"));
+            fullSystemInfo.append(", " + System.getProperty("os.name"));
+            fullSystemInfo.append(", " + System.getProperty("os.version"));
+            fullSystemInfo.append(", " + System.getProperty("sun.os.patch.level"));*/
+            // TODO: add in details here
+            return ".NET 1.1 Client";
+        }
+    }
+}
diff --git a/dotnet/Qpid.Client/Client/Handler/ConnectionTuneMethodHandler.cs b/dotnet/Qpid.Client/Client/Handler/ConnectionTuneMethodHandler.cs
new file mode 100644
index 0000000000..8b276c09e9
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Handler/ConnectionTuneMethodHandler.cs
@@ -0,0 +1,65 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+using System;
+using log4net;
+using Qpid.Client.Protocol;
+using Qpid.Client.State;
+using Qpid.Framing;
+
+namespace Qpid.Client.Handler
+{
+    public class ConnectionTuneMethodHandler : IStateAwareMethodListener
+    {
+        private static readonly ILog _logger = LogManager.GetLogger(typeof(ConnectionTuneMethodHandler));
+
+        public void MethodReceived(AMQStateManager stateManager, AMQMethodEvent evt)
+        {
+            _logger.Debug("ConnectionTune frame received");
+            ConnectionTuneBody frame = (ConnectionTuneBody) evt.Method;
+            AMQProtocolSession session = evt.ProtocolSession;
+
+            ConnectionTuneParameters parameters = session.ConnectionTuneParameters;
+            if (parameters == null)
+            {
+                parameters = new ConnectionTuneParameters();
+            }
+
+            _logger.Info(String.Format("ConnectionTune.heartbeat = {0}.", frame.Heartbeat));
+
+            parameters.FrameMax = frame.FrameMax;
+            parameters.FrameMax = 65535;
+            //params.setChannelMax(frame.channelMax);
+            parameters.Heartbeat = frame.Heartbeat;
+            session.ConnectionTuneParameters = parameters;
+
+            stateManager.ChangeState(AMQState.CONNECTION_NOT_OPENED);
+            session.WriteFrame(ConnectionTuneOkBody.CreateAMQFrame(
+                                   evt.ChannelId, frame.ChannelMax, 65535, frame.Heartbeat));
+            session.WriteFrame(ConnectionOpenBody.CreateAMQFrame(
+                                   evt.ChannelId, session.AMQConnection.VirtualHost, null, true));
+
+            if (frame.Heartbeat > 0)
+            {
+                evt.ProtocolSession.AMQConnection.StartHeartBeatThread(frame.Heartbeat);
+            }
+        }
+    }
+}