| /* | |
| * Copyright (c) 2016, The OpenThread Authors. | |
| * All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions are met: | |
| * 1. Redistributions of source code must retain the above copyright | |
| * notice, this list of conditions and the following disclaimer. | |
| * 2. Redistributions in binary form must reproduce the above copyright | |
| * notice, this list of conditions and the following disclaimer in the | |
| * documentation and/or other materials provided with the distribution. | |
| * 3. Neither the name of the copyright holder nor the | |
| * names of its contributors may be used to endorse or promote products | |
| * derived from this software without specific prior written permission. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE | |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
| * POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| #include "test_lowpan.hpp" | |
| #include "test_platform.h" | |
| #include "test_util.hpp" | |
| using namespace ot; | |
| using ot::Encoding::BigEndian::HostSwap16; | |
| namespace ot { | |
| otInstance *sInstance; | |
| Ip6::Ip6 *sIp6; | |
| ThreadNetif *sThreadNetif; | |
| Lowpan::Lowpan *sLowpan; | |
| void TestIphcVector::GetCompressedStream(uint8_t *aIphc, uint16_t &aIphcLength) | |
| { | |
| memcpy(aIphc, mIphcHeader.mData, mIphcHeader.mLength); | |
| memcpy(aIphc + mIphcHeader.mLength, mPayload.mData, mPayload.mLength); | |
| aIphcLength = mIphcHeader.mLength + mPayload.mLength; | |
| } | |
| void TestIphcVector::GetUncompressedStream(uint8_t *aIp6, uint16_t &aIp6Length) | |
| { | |
| aIp6Length = 0; | |
| memcpy(aIp6, reinterpret_cast<uint8_t *>(&mIpHeader), sizeof(mIpHeader)); | |
| aIp6Length += sizeof(mIpHeader); | |
| if (mExtHeader.mLength) | |
| { | |
| memcpy(aIp6 + aIp6Length, mExtHeader.mData, mExtHeader.mLength); | |
| aIp6Length += mExtHeader.mLength; | |
| } | |
| if (mIpTunneledHeader.GetPayloadLength()) | |
| { | |
| memcpy(aIp6 + aIp6Length, reinterpret_cast<uint8_t *>(&mIpTunneledHeader), sizeof(mIpTunneledHeader)); | |
| aIp6Length += sizeof(mIpTunneledHeader); | |
| } | |
| if (mUdpHeader.GetLength()) | |
| { | |
| memcpy(aIp6 + aIp6Length, reinterpret_cast<uint8_t *>(&mUdpHeader), sizeof(mUdpHeader)); | |
| aIp6Length += sizeof(mUdpHeader); | |
| } | |
| memcpy(aIp6 + aIp6Length, mPayload.mData, mPayload.mLength); | |
| aIp6Length += mPayload.mLength; | |
| } | |
| void TestIphcVector::GetUncompressedStream(Message &aMessage) | |
| { | |
| SuccessOrQuit(aMessage.Append(reinterpret_cast<uint8_t *>(&mIpHeader), sizeof(mIpHeader)), | |
| "6lo: Message::Append failed"); | |
| if (mExtHeader.mLength) | |
| { | |
| SuccessOrQuit(aMessage.Append(mExtHeader.mData, mExtHeader.mLength), | |
| "6lo: Message::Append failed"); | |
| } | |
| if (mIpTunneledHeader.GetPayloadLength()) | |
| { | |
| SuccessOrQuit(aMessage.Append(reinterpret_cast<uint8_t *>(&mIpTunneledHeader), sizeof(mIpTunneledHeader)), | |
| "6lo: Message::Append failed"); | |
| } | |
| if (mUdpHeader.GetLength()) | |
| { | |
| SuccessOrQuit(aMessage.Append(reinterpret_cast<uint8_t *>(&mUdpHeader), sizeof(mUdpHeader)), | |
| "6lo: Message::Append failed"); | |
| } | |
| SuccessOrQuit(aMessage.Append(mPayload.mData, mPayload.mLength), "6lo: Message::Append failed5"); | |
| } | |
| /** | |
| * This function initializes Thread Interface. | |
| * | |
| */ | |
| static void Init() | |
| { | |
| uint8_t meshLocalPrefix[] = {0xfd, 0x00, 0xca, 0xfe, 0xfa, 0xce, 0x12, 0x34}; | |
| sThreadNetif->GetMle().SetMeshLocalPrefix(meshLocalPrefix); | |
| // Emulate global prefixes with contextes. | |
| uint8_t mockNetworkData[] = | |
| { | |
| // Prefix 2001:2:0:1::/64 | |
| 0x03, 0x0e, // Prefix TLV | |
| 0x00, 0x40, | |
| 0x20, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, | |
| 0x07, 0x02, // 6LoWPAN Context ID TLV | |
| 0x11, 0x40, // Context ID = 1, C = TRUE | |
| // Prefix 2001:2:0:2::/64 | |
| 0x03, 0x0e, // Prefix TLV | |
| 0x00, 0x40, | |
| 0x20, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, | |
| 0x07, 0x02, // 6LoWPAN Context ID TLV | |
| 0x02, 0x40 // Context ID = 2, C = FALSE | |
| }; | |
| sThreadNetif->GetNetworkDataLeader().SetNetworkData(0, 0, true, mockNetworkData, sizeof(mockNetworkData)); | |
| } | |
| /** | |
| * This function performs compression or/and decompression based on the given test vector. | |
| * | |
| * @note Performing decompression and compression on the same LOWPAN_IPHC frame may give different result. | |
| * This situation may occur when sender does not use the best possible compression, | |
| * e.g. doesn't use LOWPAN_NHC for UDP - which is still valid. | |
| * | |
| * @param aVector Test vector that has to be tested. | |
| * @param aCompress Set to TRUE, if compression should be tested. | |
| * @param aDecompress Set to TRUE, if decomrpession should be tested. | |
| */ | |
| static void Test(TestIphcVector &aVector, bool aCompress, bool aDecompress) | |
| { | |
| Message *message = NULL; | |
| uint8_t result[512]; | |
| uint8_t iphc[512]; | |
| uint8_t ip6[512]; | |
| uint16_t iphcLength; | |
| uint16_t ip6Length; | |
| aVector.GetCompressedStream(iphc, iphcLength); | |
| aVector.GetUncompressedStream(ip6, ip6Length); | |
| printf("\n=== Test name: %s ===\n\n", aVector.mTestName); | |
| printf("Expected error -------------- %s\n", aVector.mError ? "yes" : "no"); | |
| printf("UDP present ----------------- %s\n", aVector.mUdpHeader.GetLength() ? "yes" : "no"); | |
| printf("Extension Headers present --- %s\n", aVector.mExtHeader.mLength ? "yes" : "no"); | |
| printf("IP-in-IP present ------------ %s\n", aVector.mIpTunneledHeader.GetPayloadLength() ? "yes" : "no"); | |
| printf("LOWPAN_IPHC length ---------- %d\n", aVector.mIphcHeader.mLength); | |
| printf("IPv6 uncompressed offset ---- %d\n\n", aVector.mPayloadOffset); | |
| printf("Expected IPv6 uncompressed packet: \n"); | |
| otTestPrintHex(ip6, ip6Length); | |
| printf("\n"); | |
| printf("Expected LOWPAN_IPHC compressed frame: \n"); | |
| otTestPrintHex(iphc, iphcLength); | |
| printf("\n"); | |
| if (aCompress) | |
| { | |
| VerifyOrQuit((message = sIp6->mMessagePool.New(Message::kTypeIp6, 0)) != NULL, | |
| "6lo: Ip6::NewMessage failed"); | |
| aVector.GetUncompressedStream(*message); | |
| int compressBytes = sLowpan->Compress(*message, aVector.mMacSource, aVector.mMacDestination, | |
| result); | |
| if (aVector.mError == OT_ERROR_NONE) | |
| { | |
| // Append payload to the LOWPAN_IPHC. | |
| message->Read(message->GetOffset(), | |
| message->GetLength() - message->GetOffset(), | |
| result + compressBytes); | |
| printf("Resulted LOWPAN_IPHC compressed frame: \n"); | |
| otTestPrintHex(result, compressBytes + message->GetLength() - message->GetOffset()); | |
| printf("\n"); | |
| VerifyOrQuit(compressBytes == aVector.mIphcHeader.mLength, "6lo: Lowpan::Compress failed"); | |
| VerifyOrQuit(message->GetOffset() == aVector.mPayloadOffset, "6lo: Lowpan::Compress failed"); | |
| VerifyOrQuit(memcmp(iphc, result, iphcLength) == 0, | |
| "6lo: Lowpan::Compress failed"); | |
| } | |
| else | |
| { | |
| VerifyOrQuit(compressBytes < 0, "6lo: Lowpan::Compress failed"); | |
| } | |
| message->Free(); | |
| message = NULL; | |
| } | |
| if (aDecompress) | |
| { | |
| VerifyOrQuit((message = sIp6->mMessagePool.New(Message::kTypeIp6, 0)) != NULL, | |
| "6lo: Ip6::NewMessage failed"); | |
| int decompressedBytes = sLowpan->Decompress(*message, aVector.mMacSource, aVector.mMacDestination, | |
| iphc, iphcLength, 0); | |
| message->Read(0, message->GetLength(), result); | |
| if (aVector.mError == OT_ERROR_NONE) | |
| { | |
| // Append payload to the IPv6 Packet. | |
| memcpy(result + message->GetLength(), iphc + decompressedBytes, | |
| iphcLength - static_cast<uint16_t>(decompressedBytes)); | |
| printf("Resulted IPv6 uncompressed packet: \n"); | |
| otTestPrintHex(result, message->GetLength() + iphcLength - decompressedBytes); | |
| printf("\n"); | |
| VerifyOrQuit(decompressedBytes == aVector.mIphcHeader.mLength, "6lo: Lowpan::Decompress failed"); | |
| VerifyOrQuit(message->GetOffset() == aVector.mPayloadOffset, "6lo: Lowpan::Decompress failed"); | |
| VerifyOrQuit(message->GetOffset() == message->GetLength(), "6lo: Lowpan::Decompress failed"); | |
| VerifyOrQuit(memcmp(ip6, result, ip6Length) == 0, "6lo: Lowpan::Decompress failed"); | |
| } | |
| else | |
| { | |
| VerifyOrQuit(decompressedBytes < 0, "6lo: Lowpan::Decompress failed"); | |
| } | |
| message->Free(); | |
| message = NULL; | |
| } | |
| printf("PASS\n\n"); | |
| } | |
| /*************************************************************************************************** | |
| * @section Test constants. | |
| **************************************************************************************************/ | |
| static const uint8_t sTestMacSourceDefaultLong[] = {0x00, 0x00, 0x5e, 0xef, 0x10, 0x22, 0x11, 0x00}; | |
| static const uint8_t sTestMacDestinationDefaultLong[] = {0x00, 0x00, 0x5e, 0xef, 0x10, 0xaa, 0xbb, 0xcc}; | |
| static uint16_t sTestMacSourceDefaultShort = 0x0000; | |
| static uint16_t sTestMacDestinationDefaultShort = 0xc003; | |
| static uint16_t sTestMacDestinationBroadcast = 0xffff; | |
| static const uint8_t sTestPayloadDefault[] = {0x80, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06}; | |
| /*************************************************************************************************** | |
| * @section Test cases. | |
| **************************************************************************************************/ | |
| static void TestFullyCompressableLongAddresses(void) | |
| { | |
| TestIphcVector testVector("Fully compressable IPv6 addresses using long MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x33, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestFullyCompressableShortAddresses(void) | |
| { | |
| TestIphcVector testVector("Fully compressable IPv6 addresses using short MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::ff:fe00:0000", | |
| "fe80::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x33, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestFullyCompressableShortLongAddresses(void) | |
| { | |
| TestIphcVector testVector("Fully compressable IPv6 addresses using short and long MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::ff:fe00:0000", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x33, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestFullyCompressableLongShortAddresses(void) | |
| { | |
| TestIphcVector testVector("Fully compressable IPv6 addresses using long and short MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x33, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestSourceUnspecifiedAddress(void) | |
| { | |
| TestIphcVector testVector("Unspecified source IPv6 address"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "::", | |
| "fe80::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x43, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestSource128bitDestination128bitAddresses(void) | |
| { | |
| TestIphcVector testVector("IPv6 addresses inline"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "2001:2:0:3:aaaa:bbbb:cccc:dddd", | |
| "2001:2:0:4::"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x00, 0x3a, 0x20, 0x01, 0x00, 0x02, 0x00, | |
| 0x00, 0x00, 0x03, 0xaa, 0xaa, 0xbb, 0xbb, 0xcc, | |
| 0xcc, 0xdd, 0xdd, 0x20, 0x01, 0x00, 0x02, 0x00, | |
| 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, | |
| 0x00, 0x00, 0x00 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestSource64bitDestination64bitLongAddresses(void) | |
| { | |
| TestIphcVector testVector("IPv6 addresses 64-bit using long MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1101", | |
| "fe80::200:5eef:10aa:bbcd"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x11, 0x3a, 0x02, 0x00, 0x5e, 0xef, 0x10, | |
| 0x22, 0x11, 0x01, 0x02, 0x00, 0x5e, 0xef, 0x10, | |
| 0xaa, 0xbb, 0xcd | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestSource64bitDestination64bitShortAddresses(void) | |
| { | |
| TestIphcVector testVector("IPv6 addresses 64-bit using short MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1101", | |
| "fe80::200:5eef:10aa:bbcd"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x11, 0x3a, 0x02, 0x00, 0x5e, 0xef, 0x10, | |
| 0x22, 0x11, 0x01, 0x02, 0x00, 0x5e, 0xef, 0x10, | |
| 0xaa, 0xbb, 0xcd | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestSource16bitDestination16bitAddresses(void) | |
| { | |
| TestIphcVector testVector("IPv6 addresses 16-bit using short MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::ff:fe00:0001", | |
| "fe80::ff:fe00:c004"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x22, 0x3a, 0x00, 0x01, 0xc0, 0x04}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestSourceCompressedDestination16bitAddresses(void) | |
| { | |
| TestIphcVector testVector("Fully compressable IPv6 source and destination 16-bit using long MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::ff:fe00:beaf"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x32, 0x3a, 0xbe, 0xaf}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestSourceCompressedDestination128bitAddresses(void) | |
| { | |
| TestIphcVector testVector("Fully compressable IPv6 source and destination inline using long MAC addresses"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "2001:2:0:4::"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x30, 0x3a, 0x20, 0x01, 0x00, 0x02, 0x00, | |
| 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, | |
| 0x00, 0x00, 0x00 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestMulticast128bitAddress(void) | |
| { | |
| TestIphcVector testVector("Multicast address inline"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "ff05::100:0030:0001"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x38, 0x3a, 0xff, 0x05, 0x00, 0x00, 0x00, | |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, | |
| 0x30, 0x00, 0x01 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestMulticast48bitAddress(void) | |
| { | |
| TestIphcVector testVector("Multicast address 48-bit"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "ff05::1:0030:0001"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x39, 0x3a, 0x05, 0x01, 0x00, 0x30, 0x00, | |
| 0x01 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestMulticast32bitAddress(void) | |
| { | |
| TestIphcVector testVector("Multicast address 32-bit"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "ff03::fc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x1a, 0x3a, 0x02, 0x00, 0x5e, 0xef, 0x10, | |
| 0x22, 0x11, 0x00, 0x03, 0x00, 0x00, 0xfc | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestMulticast8bitAddress(void) | |
| { | |
| TestIphcVector testVector("Multicast address 8-bit"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "ff02::2"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x3b, 0x3a, 0x02}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestStatefulSource64bitDestination64bitContext0(void) | |
| { | |
| TestIphcVector testVector("Stateful compression source and destination addresses 64-bit, context 0"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fd00:cafe:face:1234:abcd:ef01:2345:6789", | |
| "fd00:cafe:face:1234:c31d:a702:0d41:beef"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x55, 0x3a, 0xab, 0xcd, 0xef, 0x01, 0x23, | |
| 0x45, 0x67, 0x89, 0xc3, 0x1d, 0xa7, 0x02, 0x0d, | |
| 0x41, 0xbe, 0xef | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestStatefulSource64bitDestination64bitContext0IfContextInLine(void) | |
| { | |
| TestIphcVector testVector("Stateful compression source and destination addresses 64-bit, context 0 inline"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fd00:cafe:face:1234:abcd:ef01:2345:6789", | |
| "fd00:cafe:face:1234:c31d:a702:0d41:beef"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0xd5, 0x00, 0x3a, 0xab, 0xcd, 0xef, 0x01, 0x23, | |
| 0x45, 0x67, 0x89, 0xc3, 0x1d, 0xa7, 0x02, 0x0d, | |
| 0x41, 0xbe, 0xef | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform decompression test only. | |
| Test(testVector, false, true); | |
| } | |
| static void TestStatefulSource16bitDestination16bitContext0(void) | |
| { | |
| TestIphcVector testVector("Stateful compression source and destination addresses 16-bit, context 0"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fd00:cafe:face:1234::ff:fe00:fffc", | |
| "fd00:cafe:face:1234::ff:fe00:fffe"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x66, 0x3a, 0xff, 0xfc, 0xff, 0xfe}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestStatefulCompressableLongAddressesContext0(void) | |
| { | |
| TestIphcVector testVector("Stateful compression compressable long addresses, context 0"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fd00:cafe:face:1234:0200:5eef:1022:1100", | |
| "fd00:cafe:face:1234:0200:5eef:10aa:bbcc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x77, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestStatefulCompressableShortAddressesContext0(void) | |
| { | |
| TestIphcVector testVector("Stateful compression compressable short addresses, context 0"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "fd00:cafe:face:1234::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x77, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestStatefulCompressableLongShortAddressesContext0(void) | |
| { | |
| TestIphcVector testVector("Stateful compression compressable long and short addresses, context 0"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fd00:cafe:face:1234:0200:5eef:1022:1100", | |
| "fd00:cafe:face:1234::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x77, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestStatefulSource64bitDestination128bitContext1(void) | |
| { | |
| TestIphcVector testVector("Stateful compression source addresses 64-bit and destination inline, context 1"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "2001:2:0:1:abcd:ef01:2345:6789", | |
| "2001:2:0:3:c31d:a702:0d41:beef"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0xd0, 0x10, 0x3a, 0xab, 0xcd, 0xef, 0x01, 0x23, | |
| 0x45, 0x67, 0x89, 0x20, 0x01, 0x00, 0x02, 0x00, 0x00, | |
| 0x00, 0x03, 0xc3, 0x1d, 0xa7, 0x02, 0x0d, 0x41, 0xbe, | |
| 0xef | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestStatefulSource64bitDestination64bitContext1(void) | |
| { | |
| TestIphcVector testVector("Stateful compression source and destination addresses 64-bit, context 1"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "2001:2:0:1:abcd:ef01:2345:6789", | |
| "2001:2:0:1:c31d:a702:0d41:beef"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0xd5, 0x11, 0x3a, 0xab, 0xcd, 0xef, 0x01, 0x23, | |
| 0x45, 0x67, 0x89, 0xc3, 0x1d, 0xa7, 0x02, 0x0d, 0x41, | |
| 0xbe, 0xef | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestStatefulSourceDestinationInlineContext2CIDFalse(void) | |
| { | |
| TestIphcVector testVector("Stateful compression source and destination addresses inline, context 2 (C=FALSE)"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "2001:2:0:2:abcd:ef01:2345:6789", | |
| "2001:2:0:2:c31d:a702:0d41:beef"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x00, 0x3a, 0x20, 0x01, 0x00, 0x02, 0x00, | |
| 0x00, 0x00, 0x02, 0xab, 0xcd, 0xef, 0x01, 0x23, | |
| 0x45, 0x67, 0x89, 0x20, 0x01, 0x00, 0x02, 0x00, | |
| 0x00, 0x00, 0x02, 0xc3, 0x1d, 0xa7, 0x02, 0x0d, | |
| 0x41, 0xbe, 0xef | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression test only. | |
| Test(testVector, true, false); | |
| } | |
| static void TestStatefulMulticastDestination48bitContext0(void) | |
| { | |
| TestIphcVector testVector("Stateful compression multicast address, context 0"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fd00:cafe:face:1234:0200:5eef:1022:1100", | |
| "ff33:0040:fd00:cafe:face:1234:0000:0001"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x7c, 0x3a, 0x33, 0x00, 0x00, 0x00, 0x00, | |
| 0x01 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestTrafficClassFlowLabel3Bytes(void) | |
| { | |
| TestIphcVector testVector("Traffic Class and Flow Label 3 bytes"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x6011ac59, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x6a, 0x33, 0x41, 0xac, 0x59, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestTrafficClassFlowLabel1Byte(void) | |
| { | |
| TestIphcVector testVector("Traffic Class and Flow Label 1 byte"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60d00000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x72, 0x33, 0x43, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestTrafficClassFlowLabel1ByteEcnOnly(void) | |
| { | |
| TestIphcVector testVector("Traffic Class and Flow Label 1 byte with ecn only"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60100000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x72, 0x33, 0x40, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestTrafficClassFlowLabelInline(void) | |
| { | |
| TestIphcVector testVector("Traffic Class and Flow Label inline"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x6ea12345, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x62, 0x33, 0xBA, 0x01, 0x23, 0x45, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestHopLimit1(void) | |
| { | |
| TestIphcVector testVector("Hop Limit 1"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 1, | |
| "fe80::ff:fe00:0000", | |
| "fe80::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x79, 0x33, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestHopLimit255(void) | |
| { | |
| TestIphcVector testVector("Hop Limit 255"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 255, | |
| "fe80::ff:fe00:0000", | |
| "fe80::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7B, 0x33, 0x3a}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestHopLimitInline(void) | |
| { | |
| TestIphcVector testVector("Hop Limit Inline"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 63, | |
| "fe80::ff:fe00:0000", | |
| "fe80::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x78, 0x33, 0x3a, 0x3f}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestUdpSourceDestinationInline(void) | |
| { | |
| TestIphcVector testVector("UDP source and destination inline"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Setup UDP header. | |
| testVector.SetUDPHeader(5683, 5684, sizeof(sTestPayloadDefault) + 8, 0xbeef); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x33, 0xf0, 0x16, 0x33, 0x16, 0x34, 0xbe, 0xef}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestUdpSourceInlineDestination8bit(void) | |
| { | |
| TestIphcVector testVector("UDP source inline destination 8-bit"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Setup UDP header. | |
| testVector.SetUDPHeader(5683, 61441, sizeof(sTestPayloadDefault) + 8, 0xbeef); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x33, 0xf1, 0x16, 0x33, 0x01, 0xbe, 0xef}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestUdpSource8bitDestinationInline(void) | |
| { | |
| TestIphcVector testVector("UDP source 8-bit destination 8-bit"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Setup UDP header. | |
| testVector.SetUDPHeader(61695, 5683, sizeof(sTestPayloadDefault) + 8, 0xbeef); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x33, 0xf2, 0xff, 0x16, 0x33, 0xbe, 0xef}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestUdpFullyCompressed(void) | |
| { | |
| TestIphcVector testVector("UDP fully compressed"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Setup UDP header. | |
| testVector.SetUDPHeader(61616, 61631, sizeof(sTestPayloadDefault) + 8, 0xface); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x33, 0xf3, 0x0f, 0xfa, 0xce}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestUdpFullyCompressedMulticast(void) | |
| { | |
| TestIphcVector testVector("UDP fully compressed with IP multicast"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "ff02::1"); | |
| // Setup UDP header. | |
| testVector.SetUDPHeader(61616, 61631, sizeof(sTestPayloadDefault) + 8, 0xface); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x3b, 0x01, 0xf3, 0x0f, 0xfa, 0xce}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestUdpWithoutNhc(void) | |
| { | |
| TestIphcVector testVector("UDP without LOWPAN_NHC compression"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultShort); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoUdp, 64, | |
| "fe80::ff:fe00:0000", | |
| "fe80::ff:fe00:c003"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x33, 0x11}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(40); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform only decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestExtensionHeaderHopByHopNoPadding(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with no padding"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x04, 0x60, 0x11, 0x00, 0x0c}; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a, | |
| 0x06, 0x6d, 0x04, 0x60, 0x11, 0x00, 0x0c | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestExtensionHeaderHopByHopPad1(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with Pad1"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x03, 0x60, 0x11, 0x00, 0x00}; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a, | |
| 0x05, 0x6d, 0x03, 0x60, 0x11, 0x00 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestExtensionHeaderHopByHopPadN2(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN2"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x02, 0x60, 0x11, 0x01, 0x00}; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a, | |
| 0x04, 0x6d, 0x02, 0x60, 0x11 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestExtensionHeaderHopByHopPadN3(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN3"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x01, 0x60, 0x01, 0x01, 0x00}; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a, | |
| 0x03, 0x6d, 0x01, 0x60 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestExtensionHeaderHopByHopPadN4(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN4"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x3a, 0x00, 0x6d, 0x00, 0x01, 0x02, 0x00, 0x00}; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a, | |
| 0x02, 0x6d, 0x00 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(48); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestExtensionHeaderHopByHopPadN5(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN5"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 16, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x3a, 0x01, 0x6d, 0x07, 0x01, 0x02, 0x01, 0x00, | |
| 0x00, 0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00 | |
| }; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a, | |
| 0x09, 0x6d, 0x07, 0x01, 0x02, 0x01, 0x00, 0x00, | |
| 0x00, 0x33 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(56); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestExtensionHeaderHopByHopPadN6(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN6"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 24, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x3a, 0x02, 0x6d, 0x0e, 0x01, 0x02, 0x01, 0x00, | |
| 0x00, 0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00, | |
| 0x11, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00 | |
| }; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a, | |
| 0x10, 0x6d, 0x0e, 0x01, 0x02, 0x01, 0x00, 0x00, | |
| 0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00, 0x11, | |
| 0x00 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(64); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestExtensionHeaderHopByHopPadN7(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN7"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 24, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x3a, 0x02, 0x6d, 0x0d, 0x01, 0x02, 0x01, 0x00, | |
| 0x00, 0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00, | |
| 0x11, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00 | |
| }; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe0, 0x3a, | |
| 0x0f, 0x6d, 0x0d, 0x01, 0x02, 0x01, 0x00, 0x00, | |
| 0x00, 0x33, 0x01, 0x03, 0x00, 0x00, 0x00, 0x11 | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(64); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestExtensionHeaderHopByHopPadN2UdpFullyCompressed(void) | |
| { | |
| TestIphcVector testVector("Extension Header - Hop-by-Hop with PadN2 and UDP"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 16, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::1"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x11, 0x00, 0x6d, 0x02, 0x60, 0x11, 0x01, 0x00}; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Setup UDP header. | |
| testVector.SetUDPHeader(61616, 61631, sizeof(sTestPayloadDefault) + 8, 0xface); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0x01, 0xe1, 0x04, | |
| 0x6d, 0x02, 0x60, 0x11, 0xf3, 0x0f, 0xfa, 0xce | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(56); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestIpInIpHopByHopPadN2UdpSourceDestinationInline(void) | |
| { | |
| TestIphcVector testVector("IP-in-IP with Hop-by-Hop with PadN2 and UDP"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultShort); | |
| testVector.SetMacDestination(sTestMacDestinationBroadcast); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 56, Ip6::kProtoHopOpts, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff03::fc"); | |
| // Setup extension header. | |
| uint8_t extHeader[] = {0x29, 0x00, 0x6d, 0x02, 0x00, 0x11, 0x01, 0x00}; | |
| testVector.SetExtHeader(extHeader, sizeof(extHeader)); | |
| // Setup IPv6 tunneled header. | |
| testVector.SetIpTunneledHeader(0x60000000, sizeof(sTestPayloadDefault) + 8, Ip6::kProtoUdp, 64, | |
| "fd00:cafe:face:1234::ff:fe00:0000", | |
| "ff05::1"); | |
| // Setup UDP header. | |
| testVector.SetUDPHeader(5683, 5684, sizeof(sTestPayloadDefault) + 8, 0xbeef); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x7a, 0x03, 0x00, 0x00, 0xfc, 0xe1, 0x04, | |
| 0x6d, 0x02, 0x00, 0x11, 0xee, 0x7e, 0x7a, 0x05, | |
| 0x00, 0x00, 0x01, 0xf0, 0x16, 0x33, 0x16, 0x34, | |
| 0xbe, 0xef | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(96); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestIpInIpWithoutExtensionHeader(void) | |
| { | |
| TestIphcVector testVector("IP-in-IP without extension header"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Setup IPv6 header. | |
| testVector.SetIpHeader(0x60000000, sizeof(sTestPayloadDefault) + 40, Ip6::kProtoIp6, 64, | |
| "fe80::200:5eef:1022:1100", | |
| "ff03::1"); | |
| // Setup IPv6 tunneled header. | |
| testVector.SetIpTunneledHeader(0x60000000, sizeof(sTestPayloadDefault), Ip6::kProtoIcmp6, 1, | |
| "fe80::200:5eef:1022:1100", | |
| "fe80::200:5eef:10aa:bbcc"); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x3a, 0x03, 0x00, 0x00, 0x01, 0xee, 0x79, | |
| 0x33, 0x3a | |
| }; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetPayload(sTestPayloadDefault, sizeof(sTestPayloadDefault)); | |
| testVector.SetPayloadOffset(80); | |
| testVector.SetError(OT_ERROR_NONE); | |
| // Perform compression and decompression tests. | |
| Test(testVector, true, true); | |
| } | |
| static void TestErrorNoIphcDispatch(void) | |
| { | |
| TestIphcVector testVector("Invalid dispatch"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x40, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestErrorTruncatedIphc(void) | |
| { | |
| TestIphcVector testVector("Truncated LOWPAN_IPHC"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x00}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestErrorReservedValueDestination0100(void) | |
| { | |
| TestIphcVector testVector("Reserved value of M-DAC-DAM - 0100"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x34, 0x3A}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestErrorReservedValueDestination1101(void) | |
| { | |
| TestIphcVector testVector("Reserved value of M-DAC-DAM - 1101"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x3D, 0x3A}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestErrorReservedValueDestination1110(void) | |
| { | |
| TestIphcVector testVector("Reserved value of M-DAC-DAM - 1110"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x3E, 0x3A}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestErrorReservedValueDestination1111(void) | |
| { | |
| TestIphcVector testVector("Reserved value of M-DAC-DAM - 1111"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7a, 0x3F, 0x3A}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestErrorUnknownNhc(void) | |
| { | |
| TestIphcVector testVector("Unknown value of LOWPAN_NHC ID"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x33, 0x00}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestErrorReservedNhc5(void) | |
| { | |
| TestIphcVector testVector("Reserved value of LOWPAN_NHC EID - 0x05"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x33, 0xea}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| static void TestErrorReservedNhc6(void) | |
| { | |
| TestIphcVector testVector("Reserved value of LOWPAN_NHC EID - 0x06"); | |
| // Setup MAC addresses. | |
| testVector.SetMacSource(sTestMacSourceDefaultLong); | |
| testVector.SetMacDestination(sTestMacDestinationDefaultLong); | |
| // Set LOWPAN_IPHC header. | |
| uint8_t iphc[] = {0x7e, 0x33, 0xec}; | |
| testVector.SetIphcHeader(iphc, sizeof(iphc)); | |
| // Set payload and error. | |
| testVector.SetError(OT_ERROR_PARSE); | |
| // Perform decompression test. | |
| Test(testVector, false, true); | |
| } | |
| /*************************************************************************************************** | |
| * @section Main test. | |
| **************************************************************************************************/ | |
| void TestLowpanIphc(void) | |
| { | |
| sInstance = testInitInstance(); | |
| VerifyOrQuit(sInstance != NULL, "NULL instance"); | |
| sIp6 = &sInstance->mIp6; | |
| sThreadNetif = &sInstance->mThreadNetif; | |
| sLowpan = &sThreadNetif->GetLowpan(); | |
| Init(); | |
| // Stateless unicast addresses compression / decompression tests. | |
| TestFullyCompressableLongAddresses(); | |
| TestFullyCompressableShortAddresses(); | |
| TestFullyCompressableShortLongAddresses(); | |
| TestFullyCompressableLongShortAddresses(); | |
| TestSourceUnspecifiedAddress(); | |
| TestSource128bitDestination128bitAddresses(); | |
| TestSource64bitDestination64bitLongAddresses(); | |
| TestSource64bitDestination64bitShortAddresses(); | |
| TestSource16bitDestination16bitAddresses(); | |
| TestSourceCompressedDestination16bitAddresses(); | |
| TestSourceCompressedDestination128bitAddresses(); | |
| // Stateless multicast addresses compression / decompression tests. | |
| TestMulticast128bitAddress(); | |
| TestMulticast48bitAddress(); | |
| TestMulticast32bitAddress(); | |
| TestMulticast8bitAddress(); | |
| // Stateful unicast addresses compression / decompression tests. | |
| TestStatefulSource64bitDestination64bitContext0(); | |
| TestStatefulSource64bitDestination64bitContext0IfContextInLine(); | |
| TestStatefulSource16bitDestination16bitContext0(); | |
| TestStatefulCompressableLongAddressesContext0(); | |
| TestStatefulCompressableShortAddressesContext0(); | |
| TestStatefulCompressableLongShortAddressesContext0(); | |
| TestStatefulSource64bitDestination128bitContext1(); | |
| TestStatefulSource64bitDestination64bitContext1(); | |
| TestStatefulSourceDestinationInlineContext2CIDFalse(); | |
| // Stateful multicast addresses compression / decompression tests. | |
| TestStatefulMulticastDestination48bitContext0(); | |
| // Traffic Class and Flow Label compression / decompression tests. | |
| TestTrafficClassFlowLabel3Bytes(); | |
| TestTrafficClassFlowLabel1Byte(); | |
| TestTrafficClassFlowLabel1ByteEcnOnly(); | |
| TestTrafficClassFlowLabelInline(); | |
| // Hop Limit compression / decompression tests. | |
| TestHopLimit1(); | |
| TestHopLimit255(); | |
| TestHopLimitInline(); | |
| // UDP compression / decompression tests. | |
| TestUdpSourceDestinationInline(); | |
| TestUdpSourceInlineDestination8bit(); | |
| TestUdpSource8bitDestinationInline(); | |
| TestUdpFullyCompressed(); | |
| TestUdpFullyCompressedMulticast(); | |
| TestUdpWithoutNhc(); | |
| // Extension Headers compression / decompression tests. | |
| TestExtensionHeaderHopByHopNoPadding(); | |
| TestExtensionHeaderHopByHopPad1(); | |
| TestExtensionHeaderHopByHopPadN2(); | |
| TestExtensionHeaderHopByHopPadN3(); | |
| TestExtensionHeaderHopByHopPadN4(); | |
| TestExtensionHeaderHopByHopPadN5(); | |
| TestExtensionHeaderHopByHopPadN6(); | |
| TestExtensionHeaderHopByHopPadN7(); | |
| TestExtensionHeaderHopByHopPadN2UdpFullyCompressed(); | |
| // IP-in-IP compression / decompression tests. | |
| TestIpInIpHopByHopPadN2UdpSourceDestinationInline(); | |
| TestIpInIpWithoutExtensionHeader(); | |
| // Invalid frame to be decompressed. | |
| TestErrorNoIphcDispatch(); | |
| TestErrorTruncatedIphc(); | |
| TestErrorReservedValueDestination0100(); | |
| TestErrorReservedValueDestination1101(); | |
| TestErrorReservedValueDestination1110(); | |
| TestErrorReservedValueDestination1111(); | |
| TestErrorUnknownNhc(); | |
| TestErrorReservedNhc5(); | |
| TestErrorReservedNhc6(); | |
| testFreeInstance(sInstance); | |
| } | |
| } // namespace ot | |
| #ifdef ENABLE_TEST_MAIN | |
| int main(void) | |
| { | |
| TestLowpanIphc(); | |
| printf("All tests passed\n"); | |
| return 0; | |
| } | |
| #endif |