示例#1
0
        // TODO: delete lingering fragments?
        protected override void HandleMapData(BinaryDataReader reader)
        {
            int packetId = reader.ReadInt32();
            int offset   = reader.ReadUInt16();
            int length   = reader.ReadUInt16();

            FragmentBuffer fragbuf;

            if (mapFrags.TryGetValue(packetId, out fragbuf))
            {
                fragbuf.Add(offset, reader.ReadRemaining());
                if (fragbuf.IsComplete)
                {
                    mapFrags.Remove(packetId);
                    var fragReader = new BinaryDataReader(fragbuf.Content);
                    Receive(fragReader.ReadMapUpdateEvent());
                }
            }
            else if (offset != 0 || reader.Length - 8 < length)
            {
                fragbuf = new FragmentBuffer(length);
                fragbuf.Add(offset, reader.ReadRemaining());
                mapFrags[packetId] = fragbuf;
            }
            else
            {
                Receive(reader.ReadMapUpdateEvent());
            }
        }
        private void HandleFragment(byte[] packetData, IPEndPoint from, LCMDataInputStream ins)
        {
            int msgSeqNumber   = ins.ReadInt32();
            int msgSize        = ins.ReadInt32() & unchecked ((int)0xffffffff);
            int fragmentOffset = ins.ReadInt32() & unchecked ((int)0xffffffff);
            int fragmentId     = ins.ReadInt16() & 0xffff;
            int fragmentsInMsg = ins.ReadInt16() & 0xffff;

            // read entire packet payload
            byte[] payload = new byte[ins.Available];
            ins.ReadFully(payload);

            if (ins.Available > 0)
            {
                System.Console.Error.WriteLine("Unread data! " + ins.Available);
            }

            int dataStart = 0;
            int fragSize  = payload.Length;

            FragmentBuffer fbuf;

            fragBufs.TryGetValue(from.Serialize(), out fbuf);

            if (fbuf != null && ((fbuf.msgSeqNumber != msgSeqNumber) || (fbuf.data_size != msgSize)))
            {
                fragBufs.Remove(fbuf.from);
                fbuf = null;
            }

            if (fbuf == null && fragmentId == 0)
            {
                // extract channel name
                int channelLen = 0;
                for (; channelLen < payload.Length; channelLen++)
                {
                    if (payload[channelLen] == 0)
                    {
                        break;
                    }
                }

                dataStart = channelLen + 1;
                fragSize -= (channelLen + 1);
                string tempStr;
                tempStr = System.Text.Encoding.GetEncoding("US-ASCII").GetString(payload);
                string channel = new string(tempStr.ToCharArray(), 0, channelLen);

                fbuf = new FragmentBuffer(from.Serialize(), channel, msgSeqNumber, msgSize, fragmentsInMsg);

                fragBufs.Add(fbuf.from, fbuf);
            }

            if (fbuf == null)
            {
                // TODO
                return;
            }

            if (fragmentOffset + fragSize > fbuf.data_size)
            {
                System.Console.Error.WriteLine("LC: dropping invalid fragment");
                fragBufs.Remove(fbuf.from);
                return;
            }

            Array.Copy(payload, dataStart, fbuf.data, fragmentOffset, fragSize);
            fbuf.fragments_remaining--;

            if (0 == fbuf.fragments_remaining)
            {
                lcm.ReceiveMessage(fbuf.channel, fbuf.data, 0, fbuf.data_size);
                fragBufs.Remove(fbuf.from);
            }
        }
        private void HandleFragment(byte[] packetData, IPEndPoint from, LCMDataInputStream ins)
		{
			int msgSeqNumber = ins.ReadInt32();
			int msgSize = ins.ReadInt32() & unchecked((int) 0xffffffff);
			int fragmentOffset = ins.ReadInt32() & unchecked((int) 0xffffffff);
			int fragmentId = ins.ReadInt16() & 0xffff;
			int fragmentsInMsg = ins.ReadInt16() & 0xffff;
			
			// read entire packet payload
			byte[] payload = new byte[ins.Available];
			ins.ReadFully(payload);
			
			if (ins.Available > 0)
			{
				System.Console.Error.WriteLine("Unread data! " + ins.Available);
			}
			
			int dataStart = 0;
			int fragSize = payload.Length;
			
			FragmentBuffer fbuf;
            fragBufs.TryGetValue(from.Serialize(), out fbuf);
			
			if (fbuf != null && ((fbuf.msgSeqNumber != msgSeqNumber) || (fbuf.data_size != msgSize)))
			{
                fragBufs.Remove(fbuf.from);
				fbuf = null;
			}
			
			if (fbuf == null && fragmentId == 0)
			{	
				// extract channel name
				int channelLen = 0;
				for (; channelLen < payload.Length; channelLen++)
				{
					if (payload[channelLen] == 0)
					{
						break;
					}
				}

				dataStart = channelLen + 1;
				fragSize -= (channelLen + 1);
				string tempStr;
				tempStr = System.Text.Encoding.GetEncoding("US-ASCII").GetString(payload);
				string channel = new string(tempStr.ToCharArray(), 0, channelLen);

                fbuf = new FragmentBuffer(from.Serialize(), channel, msgSeqNumber, msgSize, fragmentsInMsg);

                fragBufs.Add(fbuf.from, fbuf);
			}
			
			if (fbuf == null)
			{
				// TODO
				return ;
			}
			
			if (fragmentOffset + fragSize > fbuf.data_size)
			{
				System.Console.Error.WriteLine("LC: dropping invalid fragment");
                fragBufs.Remove(fbuf.from);
				return ;
			}
			
			Array.Copy(payload, dataStart, fbuf.data, fragmentOffset, fragSize);
			fbuf.fragments_remaining--;
			
			if (0 == fbuf.fragments_remaining)
			{
				lcm.ReceiveMessage(fbuf.channel, fbuf.data, 0, fbuf.data_size);
                fragBufs.Remove(fbuf.from);
			}
		}
 public void StartFragmentBufferRecord()
 {
     fragment_buffer_record = true;
     FragmentBuffer.Clear();
 }
        public void TestBasicConstruction()
        {
            // Test each of the 3 supported constructors, i.e.
            // 1.   FragmentBuffer<int>();
            // 2.   FragmentBuffer<int>(int[], offset, length);
            // 3.   FragmentBuffer<int>(FrameBuffer<int>, offset, length);

            // 1.
            {
                var fb = new FragmentBuffer <int>();
                fb.Count.Should().Be(0, "we created an empty buffer");
                fb.Should().Equal(new int[0]);
            }

            // 2.
            {
                var source = new[] { 1, 2, 3, 4, 5 };
                var offset = 0;
                var length = source.Length;

                var fb = new FragmentBuffer <int>(source, offset, length);
                fb.Count.Should().Be(length);
                fb.Offset.Should().Be(offset);
                fb.Should().Equal(1, 2, 3, 4, 5);

                offset = 1;
                length = source.Length - 2;
                fb     = new FragmentBuffer <int>(source, offset, length);
                fb.Count.Should().Be(length);
                fb.Offset.Should().Be(offset);
                fb.Should().Equal(2, 3, 4);
            }

            // 3.
            {
                var source = new FragmentBuffer <int>(new[] { 1, 2, 3, 4, 5 }, 0, 5);
                var offset = 0;
                var length = source.Count;

                var fb = new FragmentBuffer <int>(source, offset, length);
                fb.Count.Should().Be(length);
                fb.Offset.Should().Be(offset);
                fb.Should().Equal(1, 2, 3, 4, 5);

                offset = 1;
                length = source.Count - 2;
                fb     = new FragmentBuffer <int>(source, offset, length);
                fb.Count.Should().Be(length);
                fb.Offset.Should().Be(offset);
                fb.Should().Equal(2, 3, 4);
            }

            // Test Exceptions
            {
                Action <int[], int, int> construct2 = (s, o, l) => new FragmentBuffer <int>(s, o, l);
                construct2.ShouldThrow <ArgumentNullException, int[], int, int>(null, 1, 1, "source can't be null");
                construct2.ShouldThrow <ArgumentOutOfRangeException, int[], int, int>(new int[5], -1, 1, "offset can't be negative");
                construct2.ShouldThrow <ArgumentOutOfRangeException, int[], int, int>(new int[5], 1, -1, "length can't be negative");
                construct2.ShouldThrow <InvalidOperationException, int[], int, int>(new int[5], 3, 3, "offset + length must be smaller than source");

                Action <FragmentBuffer <int>, int, int> construct3 = (s, o, l) => new FragmentBuffer <int>(s, o, l);
                var fb = new FragmentBuffer <int>(new int[5], 0, 5);
                construct3.ShouldThrow <ArgumentNullException, FragmentBuffer <int>, int, int>(null, 1, 1, "source can't be null");
                construct3.ShouldThrow <ArgumentOutOfRangeException, FragmentBuffer <int>, int, int>(fb, -1, 1, "offset can't be negative");
                construct3.ShouldThrow <ArgumentOutOfRangeException, FragmentBuffer <int>, int, int>(fb, 1, -1, "length can't be negative");
                construct3.ShouldThrow <InvalidOperationException, FragmentBuffer <int>, int, int>(fb, 3, 3, "offset + length must be smaller than source");
            }
        }