ReadBytes() public method

Reads the specified number of bytes and returns true for success
public ReadBytes ( int numberOfBytes, byte &result ) : bool
numberOfBytes int
result byte
return bool
示例#1
0
 public void Read(NetBuffer im)
 {
     MessagePacketId = im.ReadInt64();
     Number          = im.ReadInt32();
     int length      = im.ReadInt32();
     if (length != 0)
     {
         Bytes = im.ReadBytes(length);
     }
 }
示例#2
0
 public void Read(NetBuffer im)
 {
     PluginName  = im.ReadString();
     MethodName  = im.ReadString();
     RspType     = im.ReadByte();
     if (RspType == StringDataType)
     {
         StringCommandRsp = im.ReadString();
     }
     else if (RspType == BinaryDataType)
     {
         int l = im.ReadInt32();
         BinaryCommandRsp = im.ReadBytes(l);
     }
 }
示例#3
0
		/// <summary>
		/// Read this message from the packet buffer
		/// </summary>
		/// <returns>new read pointer position</returns>
		internal void ReadFrom(NetBuffer buffer, IPEndPoint endpoint)
		{
			m_senderEndPoint = endpoint;

			// read header
			byte header = buffer.ReadByte();
			m_type = (NetMessageLibraryType)(header & 7);
			m_sequenceChannel = (NetChannel)(header >> 3);
			m_sequenceNumber = buffer.ReadUInt16();

			int payLen = (int)buffer.ReadVariableUInt32();

			// copy payload into message buffer
			m_data.EnsureBufferSize(payLen * 8);
			buffer.ReadBytes(m_data.Data, 0, payLen);
			m_data.Reset(0, payLen * 8);

			return;
		}
示例#4
0
        /// <summary>
        /// Read this message from the packet buffer
        /// </summary>
        /// <returns>new read pointer position</returns>
        internal void ReadFrom(NetBuffer buffer, IPEndPoint endpoint)
        {
            m_senderEndPoint = endpoint;

            // read header
            byte header = buffer.ReadByte();

            m_type            = (NetMessageLibraryType)(header & 7);
            m_sequenceChannel = (NetChannel)(header >> 3);
            m_sequenceNumber  = buffer.ReadUInt16();

            int payLen = (int)buffer.ReadVariableUInt32();

            // copy payload into message buffer
            m_data.EnsureBufferSize(payLen * 8);
            buffer.ReadBytes(m_data.Data, 0, payLen);
            m_data.Reset(0, payLen * 8);

            return;
        }
示例#5
0
        /// <summary>
        /// Read this message from the packet buffer
        /// </summary>
        /// <returns>new read pointer position</returns>
        internal bool ReadFrom(NetBuffer buffer, NetworkEndPoint endpoint)
        {
            m_senderEndPoint = endpoint;

            // read header
            byte header;

            // ignore zero padding in the beginning until we get something non-zero
            do
            {
                if (buffer.BytesRemaining == 0)
                {
                    return(false);
                }
                header = buffer.ReadByte();
            } while (header == 0);

            m_type            = (NetMessageLibraryType)(header & 7);
            m_sequenceChannel = (NetChannel)(header >> 3);

            //TODO: do not read seqno for unreliable, just set it to 0 (DAVID)
            m_sequenceNumber = buffer.ReadUInt16();

            int payLen = (int)buffer.ReadVariableUInt32();

            if (payLen > buffer.BytesRemaining)
            {
                return(false);                                            // bad packet
            }
            // copy payload into message buffer
            m_data.EnsureBufferSizeInBytes(payLen);
            buffer.ReadBytes(m_data.Data, 0, payLen);
            m_data.Reset(0, payLen * 8);

            return(true);
        }
示例#6
0
		static unsafe void Main(string[] args)
		{
			// JIT stuff
			NetBuffer msg = new NetBuffer(20);
			msg.Write((short)short.MaxValue);
			
			// Go
			double timeStart = NetTime.Now;

			msg = new NetBuffer(20);
			for (int n = 0; n < 10000; n++)
			{
				msg.Reset();

				msg.Write((short)short.MaxValue);
				msg.Write((short)short.MinValue);
				msg.Write((short)-42);

				msg.Write(421);
				msg.Write((byte)7);
				msg.Write(-42.8f);

				if (msg.LengthBytes != 15)
					throw new Exception("Bad message length");

				msg.Write("duke of earl");

				int bytesWritten;
				bytesWritten = msg.WriteVariableInt32(-1);
				bytesWritten = msg.WriteVariableInt32(5);
				bytesWritten = msg.WriteVariableInt32(-18);
				bytesWritten = msg.WriteVariableInt32(42);
				bytesWritten = msg.WriteVariableInt32(-420);

				msg.Write((uint)9991);

				// byte boundary kept until here

				msg.Write(true);
				msg.Write((uint)3, 5);
				msg.Write(8.111f);
				msg.Write("again");
				byte[] arr = new byte[] { 1, 6, 12, 24 };
				msg.Write(arr);
				msg.Write((byte)7, 7);
				msg.Write(Int32.MinValue);
				msg.Write(UInt32.MaxValue);
				msg.WriteRangedSingle(21.0f, -10, 50, 12);

				// test reduced bit signed writing
				msg.Write(15, 5);
				msg.Write(2, 5);
				msg.Write(0, 5);
				msg.Write(-1, 5);
				msg.Write(-2, 5);
				msg.Write(-15, 5);

				msg.Write(UInt64.MaxValue);
				msg.Write(Int64.MaxValue);
				msg.Write(Int64.MinValue);

				msg.Write(42);
				msg.WritePadBits();

				int numBits = msg.WriteRangedInteger(0, 10, 5);
				if (numBits != 4)
					throw new Exception("Ack WriteRangedInteger failed");

				// verify
				msg.Position = 0;

				short a = msg.ReadInt16();
				short b = msg.ReadInt16();
				short c = msg.ReadInt16();

				if (a != short.MaxValue || b != short.MinValue || c != -42)
					throw new Exception("Ack thpth short failed");

				if (msg.ReadInt32() != 421)
					throw new Exception("Ack thphth 1");
				if (msg.ReadByte() != (byte)7)
					throw new Exception("Ack thphth 2");
				if (msg.ReadSingle() != -42.8f)
					throw new Exception("Ack thphth 3");
				if (msg.ReadString() != "duke of earl")
					throw new Exception("Ack thphth 4");

				if (msg.ReadVariableInt32() != -1) throw new Exception("ReadVariableInt32 failed 1");
				if (msg.ReadVariableInt32() != 5) throw new Exception("ReadVariableInt32 failed 2");
				if (msg.ReadVariableInt32() != -18) throw new Exception("ReadVariableInt32 failed 3");
				if (msg.ReadVariableInt32() != 42) throw new Exception("ReadVariableInt32 failed 4");
				if (msg.ReadVariableInt32() != -420) throw new Exception("ReadVariableInt32 failed 5");

				if (msg.ReadUInt32() != 9991)
					throw new Exception("Ack thphth 4.5");

				if (msg.ReadBoolean() != true)
					throw new Exception("Ack thphth 5");
				if (msg.ReadUInt32(5) != (uint)3)
					throw new Exception("Ack thphth 6");
				if (msg.ReadSingle() != 8.111f)
					throw new Exception("Ack thphth 7");
				if (msg.ReadString() != "again")
					throw new Exception("Ack thphth 8");
				byte[] rrr = msg.ReadBytes(4);
				if (rrr[0] != arr[0] || rrr[1] != arr[1] || rrr[2] != arr[2] || rrr[3] != arr[3])
					throw new Exception("Ack thphth 9");
				if (msg.ReadByte(7) != 7)
					throw new Exception("Ack thphth 10");
				if (msg.ReadInt32() != Int32.MinValue)
					throw new Exception("Ack thphth 11");
				if (msg.ReadUInt32() != UInt32.MaxValue)
					throw new Exception("Ack thphth 12");

				float v = msg.ReadRangedSingle(-10, 50, 12);
				// v should be close to, but not necessarily exactly, 21.0f
				if ((float)Math.Abs(21.0f - v) > 0.1f)
					throw new Exception("Ack thphth *RangedSingle() failed");

				if (msg.ReadInt32(5) != 15)
					throw new Exception("Ack thphth ReadInt32 1");
				if (msg.ReadInt32(5) != 2)
					throw new Exception("Ack thphth ReadInt32 2");
				if (msg.ReadInt32(5) != 0)
					throw new Exception("Ack thphth ReadInt32 3");
				if (msg.ReadInt32(5) != -1)
					throw new Exception("Ack thphth ReadInt32 4");
				if (msg.ReadInt32(5) != -2)
					throw new Exception("Ack thphth ReadInt32 5");
				if (msg.ReadInt32(5) != -15)
					throw new Exception("Ack thphth ReadInt32 6");

				UInt64 longVal = msg.ReadUInt64();
				if (longVal != UInt64.MaxValue)
					throw new Exception("Ack thphth UInt64");
				if (msg.ReadInt64() != Int64.MaxValue)
					throw new Exception("Ack thphth Int64");
				if (msg.ReadInt64() != Int64.MinValue)
					throw new Exception("Ack thphth Int64");

				if (msg.ReadInt32() != 42)
					throw new Exception("Ack thphth end");

				msg.SkipPadBits();

				if (msg.ReadRangedInteger(0, 10) != 5)
					throw new Exception("Ack thphth ranged integer");
			}

			// test writevariableuint64
			NetBuffer largeBuffer = new NetBuffer(100 * 8);
			UInt64[] largeNumbers = new ulong[100];
			for (int i = 0; i < 100; i++)
			{
				largeNumbers[i] = ((ulong)NetRandom.Instance.NextUInt() << 32) | (ulong)NetRandom.Instance.NextUInt();
				largeBuffer.WriteVariableUInt64(largeNumbers[i]);
			}

			largeBuffer.Position = 0;
			for (int i = 0; i < 100; i++)
			{
				UInt64 ln = largeBuffer.ReadVariableUInt64();
				if (ln != largeNumbers[i])
					throw new Exception("large fail");
			}

			//
			// Extended tests on padbits
			//
			for (int i = 1; i < 31; i++)
			{
				NetBuffer buf = new NetBuffer();
				buf.Write((int)1, i);

				if (buf.LengthBits != i)
					throw new Exception("Bad length!");

				buf.WritePadBits();
				int wholeBytes = buf.LengthBits / 8;
				if (wholeBytes * 8 != buf.LengthBits)
					throw new Exception("WritePadBits failed! Length is " + buf.LengthBits);
			}

			NetBuffer small = new NetBuffer(100);
			byte[] rnd = new byte[24];
			int[] bits = new int[24];
			for (int i = 0; i < 24; i++)
			{
				rnd[i] = (byte)NetRandom.Instance.Next(0, 65);
				bits[i] = NetUtility.BitsToHoldUInt((uint)rnd[i]);

				small.Write(rnd[i], bits[i]);
			}

			small.Position = 0;
			for (int i = 0; i < 24; i++)
			{
				byte got = small.ReadByte(bits[i]);
				if (got != rnd[i])
					throw new Exception("Failed small allocation test");
			}

			double timeEnd = NetTime.Now;
			double timeSpan = timeEnd - timeStart;

			Console.WriteLine("Trivial tests passed in " + (timeSpan * 1000.0) + " milliseconds");

			Console.WriteLine("Creating client and server for live testing...");

			NetConfiguration config = new NetConfiguration("unittest");
			config.Port = 14242;
			NetServer server = new NetServer(config);
			NetBuffer serverBuffer = new NetBuffer();
			server.Start();

			config = new NetConfiguration("unittest");
			NetClient client = new NetClient(config);
			client.SetMessageTypeEnabled(NetMessageType.Receipt, true);
			NetBuffer clientBuffer = client.CreateBuffer();
			client.Start();

			client.Connect("127.0.0.1", 14242);

			List<string> events = new List<string>();

			double end = double.MaxValue;
			double disconnect = double.MaxValue;

			while (NetTime.Now < end)
			{
				double now = NetTime.Now;

				NetMessageType nmt;
				NetConnection sender;

				//
				// client
				//
				if (client.ReadMessage(clientBuffer, out nmt))
				{
					switch (nmt)
					{
						case NetMessageType.StatusChanged:
							Console.WriteLine("Client: " + client.Status + " (" + clientBuffer.ReadString() + ")");
							events.Add("CStatus " + client.Status);
							if (client.Status == NetConnectionStatus.Connected)
							{
								// send reliable message
								NetBuffer buf = client.CreateBuffer();
								buf.Write(true);
								buf.Write((int)52, 7);
								buf.Write("Hallon");

								client.SendMessage(buf, NetChannel.ReliableInOrder1, new NetBuffer("kokos"));
							}

							if (client.Status == NetConnectionStatus.Disconnected)
								end = NetTime.Now + 1.0; // end in one second

							break;
						case NetMessageType.Receipt:
							events.Add("CReceipt " + clientBuffer.ReadString());
							break;
						case NetMessageType.ConnectionRejected:
						case NetMessageType.BadMessageReceived:
							throw new Exception("Failed: " + nmt);
						case NetMessageType.DebugMessage:
							// silently ignore
							break;
						default:
							// ignore
							Console.WriteLine("Ignored: " + nmt);
							break;
					}
				}

				//
				// server
				//
				if (server.ReadMessage(serverBuffer, out nmt, out sender))
				{
					switch (nmt)
					{
						case NetMessageType.StatusChanged:
							events.Add("SStatus " + sender.Status);
							Console.WriteLine("Server: " + sender.Status + " (" + serverBuffer.ReadString() + ")");
							break;
						case NetMessageType.ConnectionRejected:
						case NetMessageType.BadMessageReceived:
							throw new Exception("Failed: " + nmt);
						case NetMessageType.Data:
							events.Add("DataRec " + serverBuffer.LengthBits);
							bool shouldBeTrue = serverBuffer.ReadBoolean();
							int shouldBeFifthTwo = serverBuffer.ReadInt32(7);
							string shouldBeHallon = serverBuffer.ReadString();

							if (shouldBeTrue != true ||
								shouldBeFifthTwo != 52 ||
								shouldBeHallon != "Hallon")
								throw new Exception("Bad data transmission");

							disconnect = now + 1.0;
							break;
						case NetMessageType.DebugMessage:
							// silently ignore
							break;
						default:
							// ignore
							Console.WriteLine("Ignored: " + nmt);
							break;
					}
				}

				if (now > disconnect)
				{
					server.Connections[0].Disconnect("Bye", 0.1f);
					disconnect = double.MaxValue;
				}
			}

			// verify events
			string[] expected = new string[] {
				"CStatus Connecting",
				"SStatus Connecting",
				"CStatus Connected",
				"SStatus Connected",
				"DataRec 64",
				"CReceipt kokos",
				"SStatus Disconnecting",
				"CStatus Disconnecting",
				"SStatus Disconnected",
				"CStatus Disconnected"
			};

			if (events.Count != expected.Length)
				throw new Exception("Mismatch in events count! Expected " + expected.Length + ", got " + events.Count);

			for(int i=0;i<expected.Length;i++)
			{
				if (events[i] != expected[i])
					throw new Exception("Event " + i + " (" + expected[i] + ") mismatched!");
			}

			Console.WriteLine("All tests successful");

			Console.ReadKey();

			server.Shutdown("App exiting");
			client.Shutdown("App exiting");
		}
示例#7
0
 public void Read(NetBuffer im)
 {
     MetaData    = im.ReadString();
     int l       = im.ReadInt32();
     Data        = im.ReadBytes(l);
 }
示例#8
0
        /*
        ================
        CL_ParseSnapshot

        If the snapshot is parsed properly, it will be copied to
        cl.snap and saved in cl.snapshots[].  If the snapshot is invalid
        for any reason, no changes to the state will be made at all.
        ================
        */
        void ParseSnapshot(NetBuffer msg)
        {
            // read in the new snapshot to a temporary buffer
            // we will only copy to cl.snap if it is valid
            clSnapshot_t newsnap = new clSnapshot_t();
            clSnapshot_t old;

            // we will have read any new server commands in this
            // message before we got to svc_snapshot
            newsnap.ServerCommandNum = clc.serverCommandSequence;
            newsnap.serverTime = msg.ReadInt32();
            newsnap.messageNum = clc.serverMessageSequence;

            int deltaNum = msg.ReadByte();

            if (deltaNum <= 0)
            {
                newsnap.deltaNum = -1;
            }
            else
                newsnap.deltaNum = newsnap.messageNum - deltaNum;
            newsnap.snapFlags = msg.ReadByte();

            // If the frame is delta compressed from data that we
            // no longer have available, we must suck up the rest of
            // the frame, but not use it, then ask for a non-compressed
            // message
            if (newsnap.deltaNum <= 0)
            {
                newsnap.valid = true;   // uncompressed frame
                old = null;
            }
            else
            {
                old = cl.snapshots[newsnap.deltaNum & 31];
                if (!old.valid)
                {
                    // should never happen
                    Common.Instance.WriteLine("ParseSnapshot: Delta from invalid frame (not supposed to happen!).");
                }
                else if (old.messageNum != newsnap.deltaNum)
                {
                    // The frame that the server did the delta from
                    // is too old, so we can't reconstruct it properly.
                    Common.Instance.WriteLine("ParseSnapshot: Delta frame too old.");
                }
                else if (cl.parseEntitiesNum - old.parseEntitiesNum > 2048 - 128)
                {
                    Common.Instance.WriteLine("ParseSnapshot: Delta parseEntitiesNum too old");
                }
                else
                    newsnap.valid = true;   // valid delta parse
            }

            // read areamask
            int len = msg.ReadByte();
            newsnap.areamask = msg.ReadBytes(32);
            // read playerinfo
            if (old != null)
            {
                Net.ReadDeltaPlayerstate(msg, old.ps, newsnap.ps);
            }
            else
                Net.ReadDeltaPlayerstate(msg, null, newsnap.ps);

            // read packet entities
            ParsePacketEntities(msg, old, newsnap);

            // if not valid, dump the entire thing now that it has
            // been properly read
            if (!newsnap.valid)
                return;

            // clear the valid flags of any snapshots between the last
            // received and this one, so if there was a dropped packet
            // it won't look like something valid to delta from next
            // time we wrap around in the buffer
            int oldMessageNum = cl.snap.messageNum + 1;
            if (newsnap.messageNum - oldMessageNum >= 32)
            {
                oldMessageNum = newsnap.messageNum - 31;
            }
            for (; oldMessageNum < newsnap.messageNum; oldMessageNum++ )
            {
                cl.snapshots[oldMessageNum & 31].valid = false;
            }

            // copy to the current good spot
            cl.snap = newsnap;
            cl.snap.ping = 999;
            // calculate ping time
            for (int i = 0; i < 32; i++)
            {
                int packetNum = (clc.netchan.outgoingSequence - 1 - i) & 31;
                if (cl.snap.ps.commandTime >= cl.outPackets[packetNum].p_serverTime)
                {
                    cl.snap.ping = realtime - cl.outPackets[packetNum].p_realtime;
                    break;
                }
            }

            // save the frame off in the backup array for later delta comparisons
            cl.snapshots[cl.snap.messageNum & 31] = cl.snap;

            //Common.Instance.WriteLine("   Snapshot:{0} delta:{1} ping:{2}", cl.snap.messageNum, cl.snap.deltaNum, cl.snap.ping);
            cl.newSnapshots = true;
        }
示例#9
0
        protected override NetBuffer ProcessInboundMessage(NetBuffer message)
        {
            switch(cryptoState)
            {
                case CryptoHostState.Connected:
                    {
                        int code = message.ReadInt32();
                        if (code == RSA_KEY_MESSAGE)
                        {
                            XmlSerializer s = new XmlSerializer(typeof(RSAParameters));
                            string b = message.ReadString();
                            StringReader reader = new StringReader(b);
                            RSAKey = (RSAParameters)s.Deserialize(reader);
                            RSA = new RSACryptoServiceProvider();
                            RSA.ImportParameters(RSAKey);

                            NetBuffer msg = new NetBuffer();
                            msg.Write((Int32)CRYPTO_SECRET_MESSAGE);

                            byte[] secret = RSA.Encrypt(MakeSecret(),false);
                            msg.Write((Int32)secret.Length);
                            msg.Write(secret);
                            client.SendMessage(msg,NetChannel.ReliableInOrder1);
                            cryptoState = CryptoHostState.SentSecret;
                        }
                        else
                        {
                            cryptoState = CryptoHostState.Invalid;
                            client.Disconnect("Bad Crypto");
                        }
                    }
                    return null;

                case CryptoHostState.SentSecret:
                    {
                        int code = message.ReadInt32();
                        if (code == CRYPTO_SECRET_VERIFY)
                        {
                            // set em as real and let the base class call any events it needs to
                            string verify = new UTF8Encoding().GetString(DecryptBuffer(message.ReadBytes(message.ReadInt32())));

                            NetBuffer b = new NetBuffer();
                            b.Write(CRYPTO_SECRET_VERIFY);
                            byte[] cryptoBuffer = EncryptBuffer(new UTF8Encoding().GetBytes(verify));
                            b.Write(cryptoBuffer.Length);
                            b.Write(cryptoBuffer);
                            client.SendMessage(b, NetChannel.ReliableInOrder1);

                            cryptoState = CryptoHostState.SentVerify;
                        }
                        else
                        {
                            cryptoState = CryptoHostState.Invalid;
                            client.Disconnect("Bad Crypto");
                        }
                    }
                   return null;

                case CryptoHostState.SentVerify:
                    {
                        int code = message.ReadInt32();
                        if (code == CRYPTO_ACCEPT)
                        {
                            cryptoState = CryptoHostState.Authenticated;
                            base.Connected(message);
                        }
                        else
                        {
                            cryptoState = CryptoHostState.Invalid;
                            client.Disconnect("Bad Crypto");
                        }
                    }
                    return null;

                case CryptoHostState.Authenticated:
                    return new NetBuffer(DecryptBuffer(message.ReadBytes(message.LengthBytes)));
            }
            return message;
        }
示例#10
0
        protected override NetBuffer ProcessOutboundMessage(NetBuffer message)
        {
            if (cryptoState == CryptoHostState.Authenticated)
                return new NetBuffer(EncryptBuffer(message.ReadBytes(message.LengthBytes)));

            return message;
        }
示例#11
0
 protected virtual NetBuffer DecryptMessage( CryptoHostConnection connection, NetBuffer buffer )
 {
     return new NetBuffer(connection.DecryptBuffer(buffer.ReadBytes(buffer.LengthBytes)));
 }
示例#12
0
 protected override NetBuffer ProcessOutboundMessage(NetConnection to, NetBuffer message)
 {
     if (CryptoClients.ContainsKey(to))
     {
         CryptoHostConnection connection = CryptoClients[to];
         if (connection.state == CryptoHostState.Authenticated)
             return new NetBuffer(connection.EncryptBuffer(message.ReadBytes(message.LengthBytes)));
     }
     return message;
 }
示例#13
0
        protected override NetBuffer ProcessInboundMessage(NetConnection from, NetBuffer message)
        {
            CryptoHostConnection connection;
            if (CryptoClients.ContainsKey(from))
                connection = CryptoClients[from];
            else
                return message;

            int code = -1;

            switch (connection.state)
            {
                case CryptoHostState.Authenticated:
                    return DecryptMessage(connection, message);

                case CryptoHostState.Invalid:
                    return null;

                case CryptoHostState.InitalConnect:
                    {
                        // should be the response with a random key encoded with the shit
                        code = message.ReadInt32();
                        if (code == CRYPTO_SECRET_MESSAGE)
                        {
                            connection.state = CryptoHostState.GotSecret;
                            connection.SetSecret(RSA.Decrypt(message.ReadBytes(message.ReadInt32()),false));
                            connection.secretVerifyString = new Random().Next().ToString();

                            // crypto the random string with the secret and send it back
                            NetBuffer b = new NetBuffer();
                            b.Write(CRYPTO_SECRET_VERIFY);
                            byte[] cryptoBuffer = connection.EncryptBuffer(new UTF8Encoding().GetBytes(connection.secretVerifyString));
                            b.Write(cryptoBuffer.Length);
                            b.Write(cryptoBuffer);
                            server.SendMessage(b, from, NetChannel.ReliableInOrder1);
                        }
                        else
                        {
                            NetBuffer errorBuffer = new NetBuffer();
                            errorBuffer.Write(CRYPTO_DENY);
                            errorBuffer.Write("Invalid Secret");
                            server.SendMessage(errorBuffer, from, NetChannel.ReliableInOrder1);
                            from.Disconnect("CryptoError", 1);
                            connection.state = CryptoHostState.Invalid;
                        }
                        return null;
                    }

                case CryptoHostState.GotSecret:
                    {
                        // should be the response with the properly encrypted sample
                        code = message.ReadInt32();
                        if (code == CRYPTO_SECRET_VERIFY)
                        {
                            // set em as real and let the base class call any events it needs to
                            string verify = new UTF8Encoding().GetString(connection.DecryptBuffer(message.ReadBytes(message.ReadInt32())));

                            if (verify == connection.secretVerifyString)
                            {
                                connection.state = CryptoHostState.Authenticated;
                                NetBuffer b = new NetBuffer();
                                b.Write(CRYPTO_ACCEPT);
                                server.SendMessage(b, from, NetChannel.ReliableInOrder1);
                                base.UserConnected(from);
                                return null;
                            }
                        }

                        NetBuffer errorBuffer = new NetBuffer();
                        errorBuffer.Write(CRYPTO_DENY);
                        errorBuffer.Write("Invalid Verify");
                        server.SendMessage(errorBuffer, from, NetChannel.ReliableInOrder1);
                        from.Disconnect("CryptoError", 1);
                        connection.state = CryptoHostState.Invalid;
                        return null;
                    }
            }
            return message;
        }