espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-08-05 02:17:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

[nat64] replace Translator::Result with Error (#11898)

Browse Source 
This change replaces the `Translator::Result` enum with the standard
`Error` type to report the outcome of a translation attempt. This
simplifies the implementation and aligns it with the rest of the
codebase.

The mapping from the old `Result` to the new `Error` is as follows:
- `kForward` is replaced by `kErrorNone`
- `kDrop` is replaced by `kErrorDrop`
- `kNotTranslated` is replaced by `kErrorAbort`

The `kErrorAbort` return value signals to the caller that no
translation was performed, and it can proceed with normal processing
of the message.

Additionally, the translation methods are renamed for better clarity.
This commit is contained in:
Abtin Keshavarzian
2025-09-05 13:27:53 -07:00
committed by GitHub
parent da9babdc66
commit 0485be36a4
5 changed files with 90 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/net/ip6.cpp
+8 -8
View File
@@ -1005,15 +1005,15 @@ Error Ip6::PassToHost(OwnedPtr<Message> &aMessagePtr,
IgnoreError(RemoveMplOption(*messagePtr));
#if OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE
switch (Get<Nat64::Translator>().TranslateFromIp6(*messagePtr))
error = Get<Nat64::Translator>().TranslateIp6ToIp4(*messagePtr);
if (error == kErrorAbort) // `kErrorAbort` indicates no translation was needed or performed.
{
case Nat64::Translator::kNotTranslated:
break;
case Nat64::Translator::kDrop:
ExitNow(error = kErrorDrop);
case Nat64::Translator::kForward:
error = kErrorNone;
}
else
{
SuccessOrExit(error);
VerifyOrExit(mIp4ReceiveCallback.IsSet(), error = kErrorNoRoute);
// Pass message to callback transferring its ownership.
mIp4ReceiveCallback.Invoke(messagePtr.Release());
src/core/net/nat64_translator.cpp
+22 -34
View File
@@ -65,6 +65,7 @@ const char *StateToString(State aState)
Translator::Translator(Instance &aInstance)
: InstanceLocator(aInstance)
, mEnabled(false)
, mState(State::kStateDisabled)
, mMappingPool(aInstance)
, mTimer(aInstance)
@@ -93,9 +94,9 @@ Message *Translator::NewIp4Message(const Message::Settings &aSettings)
Error Translator::SendMessage(OwnedPtr<Message> aMessagePtr)
{
Error error;
Error error = kErrorDrop;
VerifyOrExit(TranslateToIp6(*aMessagePtr) == kForward, error = kErrorDrop);
SuccessOrExit(TranslateIp4ToIp6(*aMessagePtr));
error = Get<Ip6::Ip6>().SendRaw(aMessagePtr.PassOwnership());
exit:
@@ -112,16 +113,16 @@ uint16_t Translator::GetDestinationPortOrIcmp4Id(const Ip4::Headers &aIp4Headers
return aIp4Headers.IsIcmp4() ? aIp4Headers.GetIcmpHeader().GetId() : aIp4Headers.GetDestinationPort();
}
Translator::Result Translator::TranslateFromIp6(Message &aMessage)
Error Translator::TranslateIp6ToIp4(Message &aMessage)
{
Result result = kDrop;
Error error = kErrorNone;
DropReason dropReason = kReasonUnknown;
Ip6::Headers ip6Headers;
Ip4::Header ip4Header;
uint16_t srcPortOrId = 0;
Mapping *mapping = nullptr;
VerifyOrExit(mState == kStateActive, result = kNotTranslated);
VerifyOrExit(mState == kStateActive, error = kErrorAbort);
// `ParseFrom()` will do basic checks for the message, including
// the message length and IP protocol version.
@@ -129,12 +130,12 @@ Translator::Result Translator::TranslateFromIp6(Message &aMessage)
{
LogWarn("Outgoing datagram is not a valid IPv6 datagram, drop");
dropReason = kReasonIllegalPacket;
ExitNow(result = kDrop);
ExitNow(error = kErrorDrop);
}
if (!ip6Headers.GetDestinationAddress().MatchesPrefix(mNat64Prefix))
{
ExitNow(result = kNotTranslated);
ExitNow(error = kErrorAbort);
}
mapping = mActiveMappings.FindMatching(ip6Headers);
@@ -149,7 +150,7 @@ Translator::Result Translator::TranslateFromIp6(Message &aMessage)
LogWarn("Failed to get a mapping for %s (mapping pool full?)",
ip6Headers.GetSourceAddress().ToString().AsCString());
dropReason = kReasonNoMapping;
ExitNow(result = kDrop);
ExitNow(error = kErrorDrop);
}
mapping->Touch(ip6Headers.GetIpProto());
@@ -176,25 +177,21 @@ Translator::Result Translator::TranslateFromIp6(Message &aMessage)
ip4Header.SetProtocol(Ip4::kProtoUdp);
ip6Headers.SetSourcePort(srcPortOrId);
aMessage.Write(0, ip6Headers.GetUdpHeader());
result = kForward;
break;
case Ip6::kProtoTcp:
ip4Header.SetProtocol(Ip4::kProtoTcp);
ip6Headers.SetSourcePort(srcPortOrId);
aMessage.Write(0, ip6Headers.GetTcpHeader());
result = kForward;
break;
case Ip6::kProtoIcmp6:
ip4Header.SetProtocol(Ip4::kProtoIcmp);
SuccessOrExit(TranslateIcmp6(aMessage, srcPortOrId));
result = kForward;
break;
default:
dropReason = kReasonUnsupportedProto;
ExitNow(result = kDrop);
ExitNow(error = kErrorDrop);
}
// `result` here must be kForward based on the switch above.
// TODO: Implement the logic for replying ICMP messages.
ip4Header.SetTotalLength(sizeof(Ip4::Header) + aMessage.GetLength() - aMessage.GetOffset());
@@ -207,7 +204,7 @@ Translator::Result Translator::TranslateFromIp6(Message &aMessage)
// This should never happen since the IPv4 header is shorter
// than the IPv6 header.
LogCrit("failed to prepend IPv4 head to translated message");
ExitNow(result = kDrop);
ExitNow(error = kErrorDrop);
}
aMessage.SetType(Message::kTypeIp4);
@@ -216,34 +213,29 @@ Translator::Result Translator::TranslateFromIp6(Message &aMessage)
mapping->mCounters.Count6To4Packet(ip6Headers);
exit:
if (result == kDrop)
if (error == kErrorDrop)
{
mErrorCounters.mCount6To4[dropReason]++;
}
return result;
return error;
}
Translator::Result Translator::TranslateToIp6(Message &aMessage)
Error Translator::TranslateIp4ToIp6(Message &aMessage)
{
Result result = kDrop;
Error error = kErrorNone;
DropReason dropReason = kReasonUnknown;
Ip6::Header ip6Header;
Ip4::Headers ip4Headers;
uint16_t dstPortOrId = 0;
Mapping *mapping = nullptr;
// `ParseFrom()` may return an error value when the incoming
// message is an IPv4 datagram. If the message is already an IPv6
// datagram, forward it directly.
VerifyOrExit(ip6Header.ParseFrom(aMessage) != kErrorNone, result = kNotTranslated);
VerifyOrExit(mState == kStateActive, result = kDrop);
VerifyOrExit(mState == kStateActive, error = kErrorDrop);
if (ip4Headers.ParseFrom(aMessage) != kErrorNone)
{
dropReason = kReasonIllegalPacket;
ExitNow(result = kDrop);
ExitNow(error = kErrorDrop);
}
mapping = mActiveMappings.FindMatching(ip4Headers);
@@ -252,7 +244,7 @@ Translator::Result Translator::TranslateToIp6(Message &aMessage)
{
LogWarn("No mapping found for the IPv4 address");
dropReason = kReasonNoMapping;
ExitNow(result = kDrop);
ExitNow(error = kErrorDrop);
}
mapping->Touch(ip4Headers.GetIpProto());
@@ -283,25 +275,21 @@ Translator::Result Translator::TranslateToIp6(Message &aMessage)
ip6Header.SetNextHeader(Ip6::kProtoUdp);
ip4Headers.SetDestinationPort(dstPortOrId);
aMessage.Write(0, ip4Headers.GetUdpHeader());
result = kForward;
break;
case Ip4::kProtoTcp:
ip6Header.SetNextHeader(Ip6::kProtoTcp);
ip4Headers.SetDestinationPort(dstPortOrId);
aMessage.Write(0, ip4Headers.GetTcpHeader());
result = kForward;
break;
case Ip4::kProtoIcmp:
ip6Header.SetNextHeader(Ip6::kProtoIcmp6);
SuccessOrExit(TranslateIcmp4(aMessage, dstPortOrId));
result = kForward;
break;
default:
dropReason = kReasonUnsupportedProto;
ExitNow(result = kDrop);
ExitNow(error = kErrorDrop);
}
// result here must be kForward based on the switch above.
// TODO: Implement the logic for replying ICMP datagrams.
ip6Header.SetPayloadLength(aMessage.GetLength() - aMessage.GetOffset());
@@ -313,7 +301,7 @@ Translator::Result Translator::TranslateToIp6(Message &aMessage)
// This might happen when the platform failed to reserve
// enough space before the original IPv4 datagram.
LogWarn("Failed to prepend IPv6 head to translated message");
ExitNow(result = kDrop);
ExitNow(error = kErrorDrop);
}
aMessage.SetType(Message::kTypeIp6);
@@ -322,12 +310,12 @@ Translator::Result Translator::TranslateToIp6(Message &aMessage)
mapping->mCounters.Count4To6Packet(ip4Headers);
exit:
if (result == kDrop)
if (error == kErrorDrop)
{
mErrorCounters.mCount4To6[dropReason]++;
}
return result;
return error;
}
Translator::Mapping::InfoString Translator::Mapping::ToString(void) const
src/core/net/nat64_translator.hpp
+12 -26
View File
@@ -78,16 +78,6 @@ public:
typedef otNat64DropReason DropReason; ///< Drop reason.
typedef otNat64ErrorCounters ErrorCounters; ///< Error counters.
/**
* The possible results of NAT64 translation.
*/
enum Result : uint8_t
{
kNotTranslated, ///< Not translated (e.g., Outgoing msg using a non-NAT64 prefix, or incoming is already IPv6).
kForward, ///< Successfully translated and the translated message should be forwarded.
kDrop, ///< Silently drop the message.
};
/**
* An iterator to iterate over `AddressMapping` entries.
*/
@@ -190,30 +180,26 @@ public:
Message *NewIp4Message(const Message::Settings &aSettings);
/**
* Translates an IPv4 datagram to IPv6 datagram. Note the datagram and datagramLength might be adjusted.
* Note the message can have 20 bytes reserved before the message to avoid potential copy operations. If the message
* is already an IPv6 datagram, `Result::kNotTranslated` will be returned and @p aMessage won't be modified.
* Translates an IPv4 message to an IPv6 message.
*
* @param[in,out] aMessage the message to be processed.
* @param[in,out] aMessage The message to be processed.
*
* @retval kNotTranslated The message is already an IPv6 datagram. @p aMessage is not updated.
* @retval kForward The caller should continue forwarding the datagram.
* @retval kDrop The caller should drop the datagram silently.
* @retval kErrorNone The message was successfully translated from IPv4 to IPv6.
* @retval kErrorDrop The message should be dropped, e.g., it is malformed or translation failed.
*/
Result TranslateToIp6(Message &message);
Error TranslateIp4ToIp6(Message &aMessage);
/**
* Translates an IPv6 datagram to IPv4 datagram. Note the datagram and datagramLength might be adjusted.
* If the message is not targeted to NAT64-mapped address, `Result::kNotTranslated` will be returned and @p aMessage
* won't be modified.
* Translates an IPv6 message to an IPv4 message.
*
* @param[in,out] aMessage the message to be processed.
* @param[in,out] aMessage The message to be processed.
*
* @retval kNotTranslated The datagram is not sending to the configured NAT64 prefix.
* @retval kForward The caller should continue forwarding the datagram.
* @retval kDrop The caller should drop the datagram silently.
* @retval kErrorNone The message was successfully translated from IPv6 to IPv4.
* @retval kErrorDrop The message should be dropped, e.g., it is malformed or translation failed.
* @retval kErrorAbort No translation was performed or required (e.g., NAT64 is disabled, the message is not
* destined for a NAT64-mapped address). In this case, the message is not modified.
*/
Result TranslateFromIp6(Message &aMessage);
Error TranslateIp6ToIp4(Message &aMessage);
/**
* Sets the CIDR used when setting the source address of the outgoing translated IPv4 datagrams. A valid CIDR must
tests/nexus/test_nat64_translator.cpp
+6 -13
View File
@@ -349,7 +349,6 @@ void TestNat64Mapping(void)
Nat64::Translator::AddressMappingIterator iterator;
Nat64::Translator::AddressMapping mapping;
OwnedPtr<Message> message;
Nat64::Translator::Result result;
Ip6::Address ip6Addr;
Ip6::Address ip6Addr2;
Ip4::Address ip4Addr;
@@ -390,8 +389,7 @@ void TestNat64Mapping(void)
message.Reset(PrepareMessage(node, ip6Addr, ip4Addr, kSrcPort, kDstPort, kPayloadLength));
result = node.Get<Nat64::Translator>().TranslateFromIp6(*message);
VerifyOrQuit(result == Nat64::Translator::kForward);
SuccessOrQuit(node.Get<Nat64::Translator>().TranslateIp6ToIp4(*message));
SuccessOrQuit(ip4Headers.ParseFrom(*message));
VerifyOrQuit(ip4Headers.GetDestinationAddress() == ip4Addr);
@@ -420,8 +418,7 @@ void TestNat64Mapping(void)
message.Reset(PrepareMessage(node, ip6Addr, ip4Addr, kSrcPort, kDstPort, kPayloadLength * 2));
result = node.Get<Nat64::Translator>().TranslateFromIp6(*message);
VerifyOrQuit(result == Nat64::Translator::kForward);
SuccessOrQuit(node.Get<Nat64::Translator>().TranslateIp6ToIp4(*message));
SuccessOrQuit(ip4Headers.ParseFrom(*message));
VerifyOrQuit(ip4Headers.GetDestinationAddress() == ip4Addr);
@@ -452,8 +449,7 @@ void TestNat64Mapping(void)
message.Reset(PrepareMessage(node, ip6Addr2, ip4Addr, kSrcPort, kDstPort, kPayloadLength));
result = node.Get<Nat64::Translator>().TranslateFromIp6(*message);
VerifyOrQuit(result == Nat64::Translator::kForward);
SuccessOrQuit(node.Get<Nat64::Translator>().TranslateIp6ToIp4(*message));
SuccessOrQuit(ip4Headers.ParseFrom(*message));
VerifyOrQuit(ip4Headers.GetDestinationAddress() == ip4Addr);
@@ -490,8 +486,7 @@ void TestNat64Mapping(void)
message.Reset(PrepareMessage(node, ip6Addr, ip4Addr, kSrcPort, kDstPort, kPayloadLength));
result = node.Get<Nat64::Translator>().TranslateFromIp6(*message);
VerifyOrQuit(result == Nat64::Translator::kForward);
SuccessOrQuit(node.Get<Nat64::Translator>().TranslateIp6ToIp4(*message));
SuccessOrQuit(ip4Headers.ParseFrom(*message));
VerifyOrQuit(ip4Headers.GetDestinationAddress() == ip4Addr);
@@ -525,8 +520,7 @@ void TestNat64Mapping(void)
message.Reset(PrepareMessage(node, ip6Addr2, ip4Addr, kSrcPort, kDstPort, kPayloadLength));
result = node.Get<Nat64::Translator>().TranslateFromIp6(*message);
VerifyOrQuit(result == Nat64::Translator::kForward);
SuccessOrQuit(node.Get<Nat64::Translator>().TranslateIp6ToIp4(*message));
SuccessOrQuit(ip4Headers.ParseFrom(*message));
VerifyOrQuit(ip4Headers.GetDestinationAddress() == ip4Addr);
@@ -566,8 +560,7 @@ void TestNat64Mapping(void)
message.Reset(PrepareMessage(node, ip6Addr, ip4Addr, kSrcPort, kDstPort, kPayloadLength));
result = node.Get<Nat64::Translator>().TranslateFromIp6(*message);
VerifyOrQuit(result == Nat64::Translator::kForward);
SuccessOrQuit(node.Get<Nat64::Translator>().TranslateIp6ToIp4(*message));
SuccessOrQuit(ip4Headers.ParseFrom(*message));
VerifyOrQuit(ip4Headers.GetDestinationAddress() == ip4Addr);
tests/unit/test_nat64.cpp
+42 -61
View File
@@ -110,35 +110,15 @@ void VerifyMessage(const Message &aMessage, const uint8_t *aExpectedContent, uin
VerifyOrQuit(aMessage.CompareBytes(0, aExpectedContent, aExpectedLength));
}
const char *ResultToString(Translator::Result aResult)
void Verify6To4(const char *aTestName,
const uint8_t *aIp6Message,
const uint16_t aIp6Length,
const uint8_t *aIp4Message,
uint16_t aIp4Length,
Error aError)
{
const char *string = "Invalid";
switch (aResult)
{
case Translator::kNotTranslated:
string = "NotTranslated";
break;
case Translator::kForward:
string = "Forward";
break;
case Translator::kDrop:
string = "Drop";
break;
}
return string;
}
void Verify6To4(const char *aTestName,
const uint8_t *aIp6Message,
const uint16_t aIp6Length,
const uint8_t *aIp4Message,
uint16_t aIp4Length,
Translator::Result aResult)
{
Message *message = sInstance->Get<Ip6::Ip6>().NewMessage(0);
Translator::Result result;
Message *message = sInstance->Get<Ip6::Ip6>().NewMessage(0);
Error error;
Log("- - - - - - - - - - - - - - - - - - - - - - - - - ");
Log("Translate IPv6 to IPv4: %s", aTestName);
@@ -148,9 +128,9 @@ void Verify6To4(const char *aTestName,
DumpIp6Message("IPv6 message", *message);
result = sInstance->Get<Translator>().TranslateFromIp6(*message);
Log("Result: %s (expecting:%s)", ResultToString(result), ResultToString(aResult));
VerifyOrQuit(result == aResult);
error = sInstance->Get<Translator>().TranslateIp6ToIp4(*message);
Log("Error: %s (expecting:%s)", ErrorToString(error), ErrorToString(aError));
VerifyOrQuit(error == aError);
if (aIp4Message != nullptr)
{
@@ -163,26 +143,26 @@ template <uint16_t kIp6Length, uint16_t kIp4Length>
void Verify6To4(const char *aTestName,
const uint8_t (&aIp6Message)[kIp6Length],
const uint8_t (&aIp4Message)[kIp4Length],
Translator::Result aResult)
Error aError)
{
Verify6To4(aTestName, aIp6Message, kIp6Length, aIp4Message, kIp4Length, aResult);
Verify6To4(aTestName, aIp6Message, kIp6Length, aIp4Message, kIp4Length, aError);
}
template <uint16_t kIp6Length>
void Verify6To4(const char *aTestName, const uint8_t (&aIp6Message)[kIp6Length], Translator::Result aResult)
void Verify6To4(const char *aTestName, const uint8_t (&aIp6Message)[kIp6Length], Error aError)
{
Verify6To4(aTestName, aIp6Message, kIp6Length, nullptr, 0, aResult);
Verify6To4(aTestName, aIp6Message, kIp6Length, nullptr, 0, aError);
}
void Verify4To6(const char *aTestName,
const uint8_t *aIp4Message,
uint16_t aIp4Length,
const uint8_t *aIp6Message,
uint16_t aIp6Length,
Translator::Result aResult)
void Verify4To6(const char *aTestName,
const uint8_t *aIp4Message,
uint16_t aIp4Length,
const uint8_t *aIp6Message,
uint16_t aIp6Length,
Error aError)
{
Message *message = sInstance->Get<Ip6::Ip6>().NewMessage(0);
Translator::Result result;
Message *message = sInstance->Get<Ip6::Ip6>().NewMessage(0);
Error error;
Log("- - - - - - - - - - - - - - - - - - - - - - - - - ");
Log("Translate IPv4 to IPv6: %s", aTestName);
@@ -192,9 +172,9 @@ void Verify4To6(const char *aTestName,
DumpIp4Message("IPv4 message", *message);
result = sInstance->Get<Translator>().TranslateToIp6(*message);
Log("Result: %s (expecting:%s)", ResultToString(result), ResultToString(aResult));
VerifyOrQuit(result == aResult);
error = sInstance->Get<Translator>().TranslateIp4ToIp6(*message);
Log("Error: %s (expecting:%s)", ErrorToString(error), ErrorToString(aError));
VerifyOrQuit(error == aError);
if (aIp6Message != nullptr)
{
@@ -207,15 +187,15 @@ template <uint16_t kIp4Length, uint16_t kIp6Length>
void Verify4To6(const char *aTestName,
const uint8_t (&aIp4Message)[kIp4Length],
const uint8_t (&aIp6Message)[kIp6Length],
Translator::Result aResult)
Error aError)
{
Verify4To6(aTestName, aIp4Message, kIp4Length, aIp6Message, kIp6Length, aResult);
Verify4To6(aTestName, aIp4Message, kIp4Length, aIp6Message, kIp6Length, aError);
}
template <uint16_t kIp4Length>
void Verify4To6(const char *aTestName, const uint8_t (&aIp4Message)[kIp4Length], Translator::Result aResult)
void Verify4To6(const char *aTestName, const uint8_t (&aIp4Message)[kIp4Length], Error aError)
{
Verify4To6(aTestName, aIp4Message, kIp4Length, nullptr, 0, aResult);
Verify4To6(aTestName, aIp4Message, kIp4Length, nullptr, 0, aError);
}
//----------------------------------------------------------------------------------------------------------------------
@@ -250,7 +230,7 @@ void TestNat64Translation(void)
0x4d, 192, 168, 123, 1, 172, 16, 243, 197, 0xab, 0xcd,
0x12, 0x34, 0x00, 0x0c, 0xa1, 0x8d, 0x61, 0x62, 0x63, 0x64};
Verify6To4("Valid v6 UDP", kIp6Packet, kIp4Packet, Translator::kForward);
Verify6To4("Valid v6 UDP", kIp6Packet, kIp4Packet, kErrorNone);
}
{
@@ -265,7 +245,7 @@ void TestNat64Translation(void)
0x00, 0x00, 0x00, 0x01, 0xab, 0xcd, 0x12, 0x34, 0x00, 0x0c, 0xe3, 0x31, 0x61, 0x62, 0x63, 0x64,
};
Verify4To6("Valid v4 UDP", kIp4Packet, kIp6Packet, Translator::kForward);
Verify4To6("Valid v4 UDP", kIp4Packet, kIp6Packet, kErrorNone);
}
{
@@ -282,7 +262,7 @@ void TestNat64Translation(void)
0x12, 0x34, 0x87, 0x65, 0x43, 0x21, 0x12, 0x34, 0x56, 0x78, 0x50,
0x10, 0x00, 0x01, 0x1e, 0x54, 0x00, 0x00, 0x61, 0x62, 0x63, 0x64};
Verify6To4("Valid v6 TCP", kIp6Packet, kIp4Packet, Translator::kForward);
Verify6To4("Valid v6 TCP", kIp6Packet, kIp4Packet, kErrorNone);
}
{
@@ -299,7 +279,7 @@ void TestNat64Translation(void)
0x12, 0x34, 0x56, 0x78, 0x50, 0x10, 0x00, 0x01, 0x5f, 0xf8, 0x00, 0x00, 0x61, 0x62, 0x63, 0x64,
};
Verify4To6("Valid v4 TCP", kIp4Packet, kIp6Packet, Translator::kForward);
Verify4To6("Valid v4 TCP", kIp4Packet, kIp6Packet, kErrorNone);
}
{
@@ -314,7 +294,7 @@ void TestNat64Translation(void)
0x5d, 192, 168, 123, 1, 172, 16, 243, 197, 0x08, 0x00,
0x88, 0x7c, 0xaa, 0xbb, 0x00, 0x01, 0x61, 0x62, 0x63, 0x64};
Verify6To4("Valid v6 ICMP ping", kIp6Packet, kIp4Packet, Translator::kForward);
Verify6To4("Valid v6 ICMP ping", kIp6Packet, kIp4Packet, kErrorNone);
}
{
@@ -329,7 +309,7 @@ void TestNat64Translation(void)
0x00, 0x00, 0x00, 0x01, 0x81, 0x00, 0x75, 0x59, 0xaa, 0xbb, 0x00, 0x01, 0x61, 0x62, 0x63, 0x64,
};
Verify4To6("Valid v4 ICMP ping", kIp4Packet, kIp6Packet, Translator::kForward);
Verify4To6("Valid v4 ICMP ping", kIp4Packet, kIp6Packet, kErrorNone);
}
{
@@ -338,7 +318,7 @@ void TestNat64Translation(void)
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xfd, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 172, 16, 243};
Verify6To4("Invalid v6", kIp6Packet, Translator::kDrop);
Verify6To4("Invalid v6", kIp6Packet, kErrorDrop);
}
{
@@ -346,7 +326,7 @@ void TestNat64Translation(void)
const uint8_t kIp4Packet[] = {0x45, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x11,
0xa0, 0x4c, 172, 16, 243, 197, 192, 168, 123};
Verify4To6("Invalid v4", kIp4Packet, Translator::kDrop);
Verify4To6("Invalid v4", kIp4Packet, kErrorDrop);
}
{
@@ -355,7 +335,7 @@ void TestNat64Translation(void)
0x4c, 172, 16, 243, 197, 192, 168, 123, 2, 0xab, 0xcd,
0x12, 0x34, 0x00, 0x0c, 0xa1, 0x8c, 0x61, 0x62, 0x63, 0x64};
Verify4To6("No v4 mapping", kIp4Packet, Translator::kDrop);
Verify4To6("No v4 mapping", kIp4Packet, kErrorDrop);
}
Log("End of TestNat64Translation");
@@ -382,6 +362,7 @@ void TestNat64Counters(void)
SuccessOrQuit(sInstance->Get<Translator>().SetIp4Cidr(cidr));
sInstance->Get<Translator>().SetNat64Prefix(prefix);
sInstance->Get<Translator>().SetEnabled(true);
// Step 1: Make the mapping table dirty.
{
@@ -396,7 +377,7 @@ void TestNat64Counters(void)
0x4d, 192, 168, 123, 1, 172, 16, 243, 197, 0xab, 0xcd,
0x12, 0x34, 0x00, 0x0c, 0xa1, 0x8d, 0x61, 0x62, 0x63, 0x64};
Verify6To4("First translation", kIp6Packet, kIp4Packet, Translator::kForward);
Verify6To4("First translation", kIp6Packet, kIp4Packet, kErrorNone);
}
iter.Init(*sInstance);
@@ -435,7 +416,7 @@ void TestNat64Counters(void)
0x4d, 192, 168, 124, 1, 172, 16, 243, 197, 0xab, 0xcd,
0x12, 0x34, 0x00, 0x0c, 0xa0, 0x8d, 0x61, 0x62, 0x63, 0x64};
Verify6To4("Translation with new mapping", kIp6Packet, kIp4Packet, Translator::kForward);
Verify6To4("Translation with new mapping", kIp6Packet, kIp4Packet, kErrorNone);
}
iter.Init(*sInstance);