Exemple #1
0
        /// <inheritdoc/>
        public Byte[] Encode(Response response)
        {
            DatagramWriter writer = new DatagramWriter();

            Serialize(writer, response, response.Code);
            return(writer.ToByteArray());
        }
Exemple #2
0
        /// <inheritdoc/>
        public Byte[] Encode(EmptyMessage message)
        {
            DatagramWriter writer = new DatagramWriter();

            Serialize(writer, message, Code.Empty);
            return(writer.ToByteArray());
        }
Exemple #3
0
        /// <inheritdoc/>
        public Byte[] Encode(Request request)
        {
            DatagramWriter writer = new DatagramWriter();

            Serialize(writer, request, request.Code);
            return(writer.ToByteArray());
        }
        public void Test32BitIntZero()
        {
            Int32 intIn = (Int32)0x00000000;

            DatagramWriter writer = new DatagramWriter();
            writer.Write(intIn, 32);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());
            Int32 intOut = reader.Read(32);

            Assert.AreEqual(intIn, intOut);
        }
        public void Test16BitInt()
        {
            Int32 intIn = (Int32)0x00004321;

            DatagramWriter writer = new DatagramWriter();
            writer.Write(intIn, 16);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());
            Int32 intOut = reader.Read(16);

            Assert.AreEqual(intIn, intOut);
        }
        public void Test8BitInt()
        {
            Int32 intIn = 0x00000021;

            DatagramWriter writer = new DatagramWriter();
            writer.Write(intIn, 8);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());
            Int32 intOut = reader.Read(8);

            Assert.AreEqual(intIn, intOut);
        }
Exemple #7
0
        public void Test4BitInt()
        {
            Int32 intIn = 0x0000005;

            DatagramWriter writer = new DatagramWriter();

            writer.Write(intIn, 4);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());
            Int32          intOut = reader.Read(4);

            Assert.AreEqual(intIn, intOut);
        }
Exemple #8
0
        public void Test16BitInt()
        {
            Int32 intIn = (Int32)0x00004321;

            DatagramWriter writer = new DatagramWriter();

            writer.Write(intIn, 16);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());
            Int32          intOut = reader.Read(16);

            Assert.AreEqual(intIn, intOut);
        }
Exemple #9
0
        public void Test32BitIntZero()
        {
            Int32 intIn = (Int32)0x00000000;

            DatagramWriter writer = new DatagramWriter();

            writer.Write(intIn, 32);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());
            Int32          intOut = reader.Read(32);

            Assert.AreEqual(intIn, intOut);
        }
Exemple #10
0
        public void TestAlignedBytes()
        {
            Byte[] bytesIn = System.Text.Encoding.UTF8.GetBytes("Some aligned bytes");

            DatagramWriter writer = new DatagramWriter();

            writer.WriteBytes(bytesIn);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());

            Byte[] bytesOut = reader.ReadBytesLeft();

            Assert.IsTrue(bytesIn.SequenceEqual(bytesOut));
        }
        public void Test32BitInt()
        {
            unchecked
            {
                Int32 intIn = (Int32)0x87654321;

                DatagramWriter writer = new DatagramWriter();
                writer.Write(intIn, 32);

                DatagramReader reader = new DatagramReader(writer.ToByteArray());
                Int32 intOut = reader.Read(32);

                Assert.AreEqual(intIn, intOut);
            }
        }
Exemple #12
0
        public void Test32BitInt()
        {
            unchecked
            {
                Int32 intIn = (Int32)0x87654321;

                DatagramWriter writer = new DatagramWriter();
                writer.Write(intIn, 32);

                DatagramReader reader = new DatagramReader(writer.ToByteArray());
                Int32          intOut = reader.Read(32);

                Assert.AreEqual(intIn, intOut);
            }
        }
Exemple #13
0
        public void TestByteOrder()
        {
            Int32 intIn = 1234567890;

            DatagramWriter writer = new DatagramWriter();

            writer.Write(intIn, 32);

            Byte[] data     = writer.ToByteArray();
            Int32  intTrans = System.Net.IPAddress.HostToNetworkOrder(BitConverter.ToInt32(data, 0));

            Assert.AreEqual(intIn, intTrans);

            DatagramReader reader = new DatagramReader(data);
            Int32          intOut = reader.Read(32);

            Assert.AreEqual(intIn, intOut);
        }
Exemple #14
0
        public void TestBytesLeftUnaligned()
        {
            Int32 bitCount = 7;
            Int32 bitsIn   = 0x55;

            Byte[] bytesIn = System.Text.Encoding.UTF8.GetBytes("Some aligned bytes");

            DatagramWriter writer = new DatagramWriter();

            writer.Write(bitsIn, bitCount);
            writer.WriteBytes(bytesIn);

            DatagramReader reader  = new DatagramReader(writer.ToByteArray());
            Int32          bitsOut = reader.Read(bitCount);

            Byte[] bytesOut = reader.ReadBytesLeft();

            Assert.AreEqual(bitsIn, bitsOut);
            Assert.IsTrue(bytesIn.SequenceEqual(bytesOut));
        }
Exemple #15
0
        public void TestGETRequestHeader()
        {
            Int32 versionIn   = 1;
            Int32 versionSz   = 2;
            Int32 typeIn      = 0; // Confirmable
            Int32 typeSz      = 2;
            Int32 optionCntIn = 1;
            Int32 optionCntSz = 4;
            Int32 codeIn      = 1; // GET Request
            Int32 codeSz      = 8;
            Int32 msgIdIn     = 0x1234;
            Int32 msgIdSz     = 16;

            DatagramWriter writer = new DatagramWriter();

            writer.Write(versionIn, versionSz);
            writer.Write(typeIn, typeSz);
            writer.Write(optionCntIn, optionCntSz);
            writer.Write(codeIn, codeSz);
            writer.Write(msgIdIn, msgIdSz);

            Byte[] data    = writer.ToByteArray();
            Byte[] dataRef = { 0x41, 0x01, 0x12, 0x34 };

            Assert.IsTrue(dataRef.SequenceEqual(data));

            DatagramReader reader       = new DatagramReader(data);
            Int32          versionOut   = reader.Read(versionSz);
            Int32          typeOut      = reader.Read(typeSz);
            Int32          optionCntOut = reader.Read(optionCntSz);
            Int32          codeOut      = reader.Read(codeSz);
            Int32          msgIdOut     = reader.Read(msgIdSz);

            Assert.AreEqual(versionIn, versionOut);
            Assert.AreEqual(typeIn, typeOut);
            Assert.AreEqual(optionCntIn, optionCntOut);
            Assert.AreEqual(codeIn, codeOut);
            Assert.AreEqual(msgIdIn, msgIdOut);
        }
Exemple #16
0
 /// <inheritdoc/>
 public Byte[] Encode(Request request)
 {
     DatagramWriter writer = new DatagramWriter();
     Serialize(writer, request, request.Code);
     return writer.ToByteArray();
 }
Exemple #17
0
 /// <inheritdoc/>
 public Byte[] Encode(Response response)
 {
     DatagramWriter writer = new DatagramWriter();
     Serialize(writer, response, response.Code);
     return writer.ToByteArray();
 }
        public void TestGETRequestHeader()
        {
            Int32 versionIn = 1;
            Int32 versionSz = 2;
            Int32 typeIn = 0; // Confirmable
            Int32 typeSz = 2;
            Int32 optionCntIn = 1;
            Int32 optionCntSz = 4;
            Int32 codeIn = 1; // GET Request
            Int32 codeSz = 8;
            Int32 msgIdIn = 0x1234;
            Int32 msgIdSz = 16;

            DatagramWriter writer = new DatagramWriter();
            writer.Write(versionIn, versionSz);
            writer.Write(typeIn, typeSz);
            writer.Write(optionCntIn, optionCntSz);
            writer.Write(codeIn, codeSz);
            writer.Write(msgIdIn, msgIdSz);

            Byte[] data = writer.ToByteArray();
            Byte[] dataRef = { 0x41, 0x01, 0x12, 0x34 };

            Assert.IsTrue(dataRef.SequenceEqual(data));

            DatagramReader reader = new DatagramReader(data);
            Int32 versionOut = reader.Read(versionSz);
            Int32 typeOut = reader.Read(typeSz);
            Int32 optionCntOut = reader.Read(optionCntSz);
            Int32 codeOut = reader.Read(codeSz);
            Int32 msgIdOut = reader.Read(msgIdSz);

            Assert.AreEqual(versionIn, versionOut);
            Assert.AreEqual(typeIn, typeOut);
            Assert.AreEqual(optionCntIn, optionCntOut);
            Assert.AreEqual(codeIn, codeOut);
            Assert.AreEqual(msgIdIn, msgIdOut);
        }
        public void TestBytesLeftUnaligned()
        {
            Int32 bitCount = 7;
            Int32 bitsIn = 0x55;
            Byte[] bytesIn = System.Text.Encoding.UTF8.GetBytes("Some aligned bytes");

            DatagramWriter writer = new DatagramWriter();
            writer.Write(bitsIn, bitCount);
            writer.WriteBytes(bytesIn);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());
            Int32 bitsOut = reader.Read(bitCount);
            Byte[] bytesOut = reader.ReadBytesLeft();

            Assert.AreEqual(bitsIn, bitsOut);
            Assert.IsTrue(bytesIn.SequenceEqual(bytesOut));
        }
Exemple #20
0
 /// <summary>
 /// Serializes a message.
 /// </summary>
 /// <param name="writer">the writer</param>
 /// <param name="message">the message to write</param>
 /// <param name="code">the code</param>
 protected abstract void Serialize(DatagramWriter writer, Message message, Int32 code);
Exemple #21
0
            protected override void Serialize(DatagramWriter writer, Message msg, Int32 code)
            {
                // create datagram writer to encode options
                DatagramWriter optWriter = new DatagramWriter();
                Int32 optionCount = 0;
                Int32 lastOptionNumber = 0;

                IEnumerable<Option> opts = msg.GetOptions();
                IList<Option> options = opts as IList<Option> ?? new List<Option>(opts);
                if (msg.Token != null && msg.Token.Length > 0 && !msg.HasOption(OptionType.Token))
                    options.Add(Option.Create(OptionType.Token, msg.Token));
                Utils.InsertionSort(options, delegate(Option o1, Option o2)
                {
                    return GetOptionNumber(o1.Type).CompareTo(GetOptionNumber(o2.Type));
                });

                foreach (Option opt in options)
                {
                    if (opt.IsDefault)
                        continue;

                    Int32 optNum = GetOptionNumber(opt.Type);
                    Int32 optionDelta = optNum - lastOptionNumber;

                    // ensure that option delta value can be encoded correctly
                    while (optionDelta > MaxOptionDelta)
                    {
                        // option delta is too large to be encoded:
                        // add fencepost options in order to reduce the option delta
                        // get fencepost option that is next to the last option
                        Int32 fencepostNumber = NextFencepost(lastOptionNumber);

                        // calculate fencepost delta
                        Int32 fencepostDelta = fencepostNumber - lastOptionNumber;
                        if (fencepostDelta <= 0)
                        {
                            if (log.IsWarnEnabled)
                                log.Warn("Fencepost liveness violated: delta = " + fencepostDelta);
                        }
                        if (fencepostDelta > MaxOptionDelta)
                        {
                            if (log.IsWarnEnabled)
                                log.Warn("Fencepost safety violated: delta = " + fencepostDelta);
                        }

                        // write fencepost option delta
                        optWriter.Write(fencepostDelta, OptionDeltaBits);
                        // fencepost have an empty value
                        optWriter.Write(0, OptionLengthBaseBits);

                        ++optionCount;
                        lastOptionNumber = fencepostNumber;
                        optionDelta -= fencepostDelta;
                    }

                    // write option delta
                    optWriter.Write(optionDelta, OptionDeltaBits);

                    // write option length
                    Int32 length = opt.Length;
                    if (length <= MaxOptionLengthBase)
                    {
                        // use option length base field only to encode
                        // option lengths less or equal than MAX_OPTIONLENGTH_BASE
                        optWriter.Write(length, OptionLengthBaseBits);
                    }
                    else
                    {
                        // use both option length base and extended field
                        // to encode option lengths greater than MAX_OPTIONLENGTH_BASE
                        Int32 baseLength = MaxOptionLengthBase + 1;
                        optWriter.Write(baseLength, OptionLengthBaseBits);

                        Int32 extLength = length - baseLength;
                        optWriter.Write(extLength, OptionLengthExtendedBits);
                    }

                    // write option value
                    optWriter.WriteBytes(opt.RawValue);

                    ++optionCount;
                    lastOptionNumber = optNum;
                }

                // write fixed-size CoAP headers
                writer.Write(Version, VersionBits);
                writer.Write((Int32)msg.Type, TypeBits);
                writer.Write(optionCount, OptionCountBits);
                writer.Write(code, CodeBits);
                writer.Write(msg.ID, IDBits);

                // write options
                writer.WriteBytes(optWriter.ToByteArray());

                //write payload
                writer.WriteBytes(msg.Payload);
            }
Exemple #22
0
 /// <inheritdoc/>
 public Byte[] Encode(EmptyMessage message)
 {
     DatagramWriter writer = new DatagramWriter();
     Serialize(writer, message, Code.Empty);
     return writer.ToByteArray();
 }
Exemple #23
0
 /// <summary>
 /// Serializes a message.
 /// </summary>
 /// <param name="writer">the writer</param>
 /// <param name="message">the message to write</param>
 /// <param name="code">the code</param>
 protected abstract void Serialize(DatagramWriter writer, Message message, Int32 code);
Exemple #24
0
            protected override void Serialize(DatagramWriter writer, Message msg, Int32 code)
            {
                // write fixed-size CoAP headers
                writer.Write(Version, VersionBits);
                writer.Write((Int32)msg.Type, TypeBits);
                writer.Write(msg.Token == null ? 0 : msg.Token.Length, TokenLengthBits);
                writer.Write(code, CodeBits);
                writer.Write(msg.ID, IDBits);

                // write token, which may be 0 to 8 bytes, given by token length field
                writer.WriteBytes(msg.Token);

                Int32 lastOptionNumber = 0;
                IEnumerable<Option> options = msg.GetOptions();

                foreach (Option opt in options)
                {
                    if (opt.Type == OptionType.Token)
                        continue;

                    // write 4-bit option delta
                    Int32 optNum = (Int32)opt.Type;
                    Int32 optionDelta = optNum - lastOptionNumber;
                    Int32 optionDeltaNibble = GetOptionNibble(optionDelta);
                    writer.Write(optionDeltaNibble, OptionDeltaBits);

                    // write 4-bit option length
                    Int32 optionLength = opt.Length;
                    Int32 optionLengthNibble = GetOptionNibble(optionLength);
                    writer.Write(optionLengthNibble, OptionLengthBits);

                    // write extended option delta field (0 - 2 bytes)
                    if (optionDeltaNibble == 13)
                    {
                        writer.Write(optionDelta - 13, 8);
                    }
                    else if (optionDeltaNibble == 14)
                    {
                        writer.Write(optionDelta - 269, 16);
                    }

                    // write extended option length field (0 - 2 bytes)
                    if (optionLengthNibble == 13)
                    {
                        writer.Write(optionLength - 13, 8);
                    }
                    else if (optionLengthNibble == 14)
                    {
                        writer.Write(optionLength - 269, 16);
                    }

                    // write option value
                    writer.WriteBytes(opt.RawValue);

                    // update last option number
                    lastOptionNumber = optNum;
                }

                Byte[] payload = msg.Payload;
                if (payload != null && payload.Length > 0)
                {
                    // if payload is present and of non-zero length, it is prefixed by
                    // an one-byte Payload Marker (0xFF) which indicates the end of
                    // options and the start of the payload
                    writer.WriteByte(PayloadMarker);
                    writer.WriteBytes(payload);
                }
            }
        public void TestByteOrder()
        {
            Int32 intIn = 1234567890;

            DatagramWriter writer = new DatagramWriter();
            writer.Write(intIn, 32);

            Byte[] data = writer.ToByteArray();
            Int32 intTrans = System.Net.IPAddress.HostToNetworkOrder(BitConverter.ToInt32(data, 0));

            Assert.AreEqual(intIn, intTrans);

            DatagramReader reader = new DatagramReader(data);
            Int32 intOut = reader.Read(32);

            Assert.AreEqual(intIn, intOut);
        }
Exemple #26
0
            protected override void Serialize(DatagramWriter writer, Message msg, Int32 code)
            {
                // create datagram writer to encode options
                DatagramWriter optWriter = new DatagramWriter();
                Int32 optionCount = 0;
                Int32 lastOptionNumber = 0;

                IEnumerable<Option> opts = msg.GetOptions();
                IList<Option> options = opts as IList<Option> ?? new List<Option>(opts);
                if (msg.Token != null && msg.Token.Length > 0 && !msg.HasOption(OptionType.Token))
                    options.Add(Option.Create(OptionType.Token, msg.Token));
                Utils.InsertionSort(options, delegate(Option o1, Option o2)
                {
                    return GetOptionNumber(o1.Type).CompareTo(GetOptionNumber(o2.Type));
                });

                foreach (Option opt in options)
                {
                    if (opt.IsDefault)
                        continue;

                    Int32 optNum = GetOptionNumber(opt.Type);
                    Int32 optionDelta = optNum - lastOptionNumber;

                    /*
                     * The Option Jump mechanism is used when the delta to the next option
                     * number is larger than 14.
                     */
                    if (optionDelta > MaxOptionDelta)
                    {
                        /*
                         * For the formats that include an Option Jump Value, the actual
                         * addition to the current Option number is computed as follows:
                         * Delta = ((Option Jump Value) + N) * 8 where N is 2 for the
                         * one-byte version and N is 258 for the two-byte version.
                         */
                        if (optionDelta < 30)
                        {
                            optWriter.Write(0xF1, SingleOptionJumpBits);
                            optionDelta -= 15;
                        }
                        else if (optionDelta < 2064)
                        {
                            Int32 optionJumpValue = (optionDelta / 8) - 2;
                            optionDelta -= (optionJumpValue + 2) * 8;
                            optWriter.Write(0xF2, SingleOptionJumpBits);
                            optWriter.Write(optionJumpValue, SingleOptionJumpBits);
                        }
                        else if (optionDelta < 526359)
                        {
                            optionDelta = Math.Min(optionDelta, 526344); // Limit to avoid overflow
                            Int32 optionJumpValue = (optionDelta / 8) - 258;
                            optionDelta -= (optionJumpValue + 258) * 8;
                            optWriter.Write(0xF3, SingleOptionJumpBits);
                            optWriter.Write(optionJumpValue, 2 * SingleOptionJumpBits);
                        }
                        else
                        {
                            throw new Exception("Option delta too large. Actual delta: " + optionDelta);
                        }
                    }

                    // write option delta
                    optWriter.Write(optionDelta, OptionDeltaBits);

                    // write option length
                    Int32 length = opt.Length;
                    if (length <= MaxOptionLengthBase)
                    {
                        // use option length base field only to encode
                        // option lengths less or equal than MAX_OPTIONLENGTH_BASE
                        optWriter.Write(length, OptionLengthBaseBits);
                    }
                    else if (length <= 1034)
                    {
                        /*
                         * When the Length field is set to 15, another byte is added as
                         * an 8-bit unsigned integer whose value is added to the 15,
                         * allowing option value lengths of 15-270 bytes. For option
                         * lengths beyond 270 bytes, we reserve the value 255 of an
                         * extension byte to mean
                         * "add 255, read another extension byte". Options that are
                         * longer than 1034 bytes MUST NOT be sent
                         */
                        optWriter.Write(15, OptionLengthBaseBits);

                        Int32 rounds = (length - 15) / 255;
                        for (Int32 i = 0; i < rounds; i++)
                        {
                            optWriter.Write(255, OptionLengthExtendedBits);
                        }
                        Int32 remainingLength = length - ((rounds * 255) + 15);
                        optWriter.Write(remainingLength, OptionLengthExtendedBits);
                    }
                    else
                    {
                        throw new Exception("Option length larger than allowed 1034. Actual length: " + length);
                    }

                    // write option value
                    if (length > 0)
                        optWriter.WriteBytes(opt.RawValue);

                    ++optionCount;
                    lastOptionNumber = optNum;
                }

                // write fixed-size CoAP headers
                writer.Write(Version, VersionBits);
                writer.Write((Int32)msg.Type, TypeBits);
                if (optionCount < 15)
                    writer.Write(optionCount, OptionCountBits);
                else
                    writer.Write(15, OptionCountBits);
                writer.Write(code, CodeBits);
                writer.Write(msg.ID, IDBits);

                // write options
                writer.WriteBytes(optWriter.ToByteArray());

                if (optionCount > 14)
                {
                    // end-of-options marker when there are more than 14 options
                    writer.Write(0xf0, 8);
                }

                //write payload
                writer.WriteBytes(msg.Payload);
            }
        public void TestAlignedBytes()
        {
            Byte[] bytesIn = System.Text.Encoding.UTF8.GetBytes("Some aligned bytes");

            DatagramWriter writer = new DatagramWriter();
            writer.WriteBytes(bytesIn);

            DatagramReader reader = new DatagramReader(writer.ToByteArray());
            Byte[] bytesOut = reader.ReadBytesLeft();

            Assert.IsTrue(bytesIn.SequenceEqual(bytesOut));
        }