From 0485be36a4696b8df11bca8022c2643cbe390b21 Mon Sep 17 00:00:00 2001 From: Abtin Keshavarzian Date: Fri, 5 Sep 2025 13:27:53 -0700 Subject: [PATCH] [nat64] replace `Translator::Result` with `Error` (#11898) 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. --- src/core/net/ip6.cpp | 16 ++-- src/core/net/nat64_translator.cpp | 56 ++++++-------- src/core/net/nat64_translator.hpp | 38 +++------- tests/nexus/test_nat64_translator.cpp | 19 ++--- tests/unit/test_nat64.cpp | 103 +++++++++++--------------- 5 files changed, 90 insertions(+), 142 deletions(-) diff --git a/src/core/net/ip6.cpp b/src/core/net/ip6.cpp index cb229783e..262428822 100644 --- a/src/core/net/ip6.cpp +++ b/src/core/net/ip6.cpp @@ -1005,15 +1005,15 @@ Error Ip6::PassToHost(OwnedPtr &aMessagePtr, IgnoreError(RemoveMplOption(*messagePtr)); #if OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE - switch (Get().TranslateFromIp6(*messagePtr)) + error = Get().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()); diff --git a/src/core/net/nat64_translator.cpp b/src/core/net/nat64_translator.cpp index d582266ec..af71384a1 100644 --- a/src/core/net/nat64_translator.cpp +++ b/src/core/net/nat64_translator.cpp @@ -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 aMessagePtr) { - Error error; + Error error = kErrorDrop; - VerifyOrExit(TranslateToIp6(*aMessagePtr) == kForward, error = kErrorDrop); + SuccessOrExit(TranslateIp4ToIp6(*aMessagePtr)); error = Get().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 diff --git a/src/core/net/nat64_translator.hpp b/src/core/net/nat64_translator.hpp index 8aa85bd14..16686651b 100644 --- a/src/core/net/nat64_translator.hpp +++ b/src/core/net/nat64_translator.hpp @@ -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 diff --git a/tests/nexus/test_nat64_translator.cpp b/tests/nexus/test_nat64_translator.cpp index 061696640..092af4c8f 100644 --- a/tests/nexus/test_nat64_translator.cpp +++ b/tests/nexus/test_nat64_translator.cpp @@ -349,7 +349,6 @@ void TestNat64Mapping(void) Nat64::Translator::AddressMappingIterator iterator; Nat64::Translator::AddressMapping mapping; OwnedPtr 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().TranslateFromIp6(*message); - VerifyOrQuit(result == Nat64::Translator::kForward); + SuccessOrQuit(node.Get().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().TranslateFromIp6(*message); - VerifyOrQuit(result == Nat64::Translator::kForward); + SuccessOrQuit(node.Get().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().TranslateFromIp6(*message); - VerifyOrQuit(result == Nat64::Translator::kForward); + SuccessOrQuit(node.Get().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().TranslateFromIp6(*message); - VerifyOrQuit(result == Nat64::Translator::kForward); + SuccessOrQuit(node.Get().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().TranslateFromIp6(*message); - VerifyOrQuit(result == Nat64::Translator::kForward); + SuccessOrQuit(node.Get().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().TranslateFromIp6(*message); - VerifyOrQuit(result == Nat64::Translator::kForward); + SuccessOrQuit(node.Get().TranslateIp6ToIp4(*message)); SuccessOrQuit(ip4Headers.ParseFrom(*message)); VerifyOrQuit(ip4Headers.GetDestinationAddress() == ip4Addr); diff --git a/tests/unit/test_nat64.cpp b/tests/unit/test_nat64.cpp index 4f4a9df03..0f2bad71c 100644 --- a/tests/unit/test_nat64.cpp +++ b/tests/unit/test_nat64.cpp @@ -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().NewMessage(0); - Translator::Result result; + Message *message = sInstance->Get().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().TranslateFromIp6(*message); - Log("Result: %s (expecting:%s)", ResultToString(result), ResultToString(aResult)); - VerifyOrQuit(result == aResult); + error = sInstance->Get().TranslateIp6ToIp4(*message); + Log("Error: %s (expecting:%s)", ErrorToString(error), ErrorToString(aError)); + VerifyOrQuit(error == aError); if (aIp4Message != nullptr) { @@ -163,26 +143,26 @@ template 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 -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().NewMessage(0); - Translator::Result result; + Message *message = sInstance->Get().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().TranslateToIp6(*message); - Log("Result: %s (expecting:%s)", ResultToString(result), ResultToString(aResult)); - VerifyOrQuit(result == aResult); + error = sInstance->Get().TranslateIp4ToIp6(*message); + Log("Error: %s (expecting:%s)", ErrorToString(error), ErrorToString(aError)); + VerifyOrQuit(error == aError); if (aIp6Message != nullptr) { @@ -207,15 +187,15 @@ template 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 -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().SetIp4Cidr(cidr)); sInstance->Get().SetNat64Prefix(prefix); + sInstance->Get().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);