internal void Reset()
		{
			m_incomingMessageType = NetIncomingMessageType.Error;
			m_readPosition = 0;
			m_receivedMessageType = NetMessageType.LibraryError;
			m_senderConnection = null;
			m_bitLength = 0;
			m_isFragment = false;
		}

 internal NetIncomingMessage CreateIncomingMessage(NetIncomingMessageType tp, int minimumByteSize)
 {
     NetIncomingMessage retval;
     if (m_incomingMessagesPool == null || !m_incomingMessagesPool.TryDequeue(out retval))
         retval = new NetIncomingMessage(tp);
     else
         retval.m_incomingMessageType = tp;
     retval.m_data = GetStorage(minimumByteSize);
     return retval;
 }

		/// <summary>
		/// NetPeerConfiguration constructor
		/// </summary>
		public NetPeerConfiguration(string appIdentifier)
		{
			if (string.IsNullOrEmpty(appIdentifier))
				throw new NetException("App identifier must be at least one character long");
			m_appIdentifier = appIdentifier.ToString(System.Globalization.CultureInfo.InvariantCulture);

			//
			// default values
			//
			m_disabledTypes = NetIncomingMessageType.ConnectionApproval | NetIncomingMessageType.UnconnectedData | NetIncomingMessageType.VerboseDebugMessage | NetIncomingMessageType.ConnectionLatencyUpdated;
			m_networkThreadName = "Lidgren network thread";
			m_localAddress = IPAddress.Any;
			m_broadcastAddress = IPAddress.Broadcast;
			var ip = NetUtility.GetBroadcastAddress();
			if (ip != null)
			{
				m_broadcastAddress = ip;
			}
			m_port = 0;
			m_receiveBufferSize = 131071;
			m_sendBufferSize = 131071;
			m_acceptIncomingConnections = false;
			m_maximumConnections = 32;
			m_defaultOutgoingMessageCapacity = 16;
			m_pingInterval = 4.0f;
			m_connectionTimeout = 25.0f;
			m_useMessageRecycling = true;
			m_resendHandshakeInterval = 3.0f;
			m_maximumHandshakeAttempts = 5;
			m_autoFlushSendQueue = true;

			// Maximum transmission unit
			// Ethernet can take 1500 bytes of payload, so lets stay below that.
			// The aim is for a max full packet to be 1440 bytes (30 x 48 bytes, lower than 1468)
			// -20 bytes IP header
			//  -8 bytes UDP header
			//  -4 bytes to be on the safe side and align to 8-byte boundary
			// Total 1408 bytes
			// Note that lidgren headers (5 bytes) are not included here; since it's part of the "mtu payload"
			m_maximumTransmissionUnit = 1408;
			m_autoExpandMTU = false;
			m_expandMTUFrequency = 2.0f;
			m_expandMTUFailAttempts = 5;

			m_loss = 0.0f;
			m_minimumOneWayLatency = 0.0f;
			m_randomOneWayLatency = 0.0f;
			m_duplicates = 0.0f;

			m_isLocked = false;
		}

 internal NetIncomingMessage(NetIncomingMessageType tp)
 {
     m_incomingMessageType = tp;
 }

        /// <summary>
        /// NetPeerConfiguration constructor
        /// </summary>
        public NetPeerConfiguration(string appIdentifier)
        {
            if (string.IsNullOrEmpty(appIdentifier))
                throw new NetException("App identifier must be at least one character long");
            m_appIdentifier = appIdentifier.ToString(System.Globalization.CultureInfo.InvariantCulture);

            //
            // default values
            //
            m_disabledTypes = NetIncomingMessageType.ConnectionApproval | NetIncomingMessageType.UnconnectedData | NetIncomingMessageType.VerboseDebugMessage | NetIncomingMessageType.ConnectionLatencyUpdated | NetIncomingMessageType.NatIntroductionSuccess;
            m_networkThreadName = "Lidgren network thread";
            m_localAddress = IPAddress.Any;
            m_broadcastAddress = IPAddress.Broadcast;
            var ip = NetUtility.GetBroadcastAddress();
            if (ip != null)
            {
                m_broadcastAddress = ip;
            }
            m_port = 0;
            m_receiveBufferSize = 131071;
            m_sendBufferSize = 131071;
            m_acceptIncomingConnections = false;
            m_maximumConnections = 32;
            m_defaultOutgoingMessageCapacity = 16;
            m_pingInterval = 4.0f;
            m_connectionTimeout = 25.0f;
            m_useMessageRecycling = true;
            m_resendHandshakeInterval = 3.0f;
            m_maximumHandshakeAttempts = 5;
            m_autoFlushSendQueue = true;

            m_maximumTransmissionUnit = kDefaultMTU;
            m_autoExpandMTU = false;
            m_expandMTUFrequency = 2.0f;
            m_expandMTUFailAttempts = 5;

            m_loss = 0.0f;
            m_minimumOneWayLatency = 0.0f;
            m_randomOneWayLatency = 0.0f;
            m_duplicates = 0.0f;

            m_isLocked = false;
        }

 /// <summary>
 /// Enables or disables receiving of the specified type of message
 /// </summary>
 public void SetMessageTypeEnabled(NetIncomingMessageType type, bool enabled)
 {
     if (enabled)
         m_disabledTypes &= (~type);
     else
         m_disabledTypes |= type;
 }

 /// <summary>
 /// Gets if receiving of the specified type of message is enabled
 /// </summary>
 public bool IsMessageTypeEnabled(NetIncomingMessageType type)
 {
     return !((m_disabledTypes & type) == type);
 }

 /// <summary>
 /// Enables receiving of the specified type of message
 /// </summary>
 public void EnableMessageType(NetIncomingMessageType type)
 {
     m_disabledTypes &= (~type);
 }

 /// <summary>
 /// Disables receiving of the specified type of message
 /// </summary>
 public void DisableMessageType(NetIncomingMessageType type)
 {
     m_disabledTypes |= type;
 }

		internal NetIncomingMessage CreateIncomingMessage(NetIncomingMessageType tp, byte[] copyFrom, int offset, int copyLength)
		{
			NetIncomingMessage retval;
			if (m_incomingMessagesPool.TryDequeue(out retval))
				retval.Reset();
			else
				retval = new NetIncomingMessage();

			NetException.Assert(retval.m_status == NetIncomingMessageReleaseStatus.NotReleased);

			retval.m_data = GetStorage(copyLength);
			Buffer.BlockCopy(copyFrom, offset, retval.m_data, 0, copyLength);

			retval.m_bitLength = copyLength * 8;
			retval.m_incomingType = tp;
			retval.m_senderConnection = null;
			retval.m_senderEndpoint = null;

			return retval;
		}

		/// <summary>
		/// Creates an incoming message with the required capacity for releasing to the application
		/// </summary>
		internal NetIncomingMessage CreateIncomingMessage(NetIncomingMessageType tp, string text)
		{
			NetIncomingMessage retval;
			if (string.IsNullOrEmpty(text))
			{
				retval = CreateIncomingMessage(tp, 1);
				retval.Write(string.Empty);
				return retval;
			}

			int numBytes = System.Text.Encoding.UTF8.GetByteCount(text);
			retval = CreateIncomingMessage(tp, numBytes + (numBytes > 127 ? 2 : 1));
			retval.Write(text);

			return retval;
		}

 public UnhandledMessageEventArgs(NetIncomingMessageType myMessageType, int myLengthBytes)
 {
     messageType = myMessageType;
     lengthBytes = myLengthBytes;
 }

		public bool CanCreateContext(NetIncomingMessageType messageType)
		{
			return messageType == NetIncomingMessageType.StatusChanged || messageType == NetIncomingMessageType.Data;
		}