Harden Nearby Connections WifiLan bandwidth upgrade

PiperOrigin-RevId: 937051504

internal/platform/BUILD

@@ -80,8 +80,6 @@ cc_library(
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/meta:type_traits",
-        "@com_google_absl//absl/status",
-        "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
         "@com_google_absl//absl/strings:string_view",

internal/platform/service_address.cc

@@ -14,11 +14,17 @@
 
 #include "internal/platform/service_address.h"
 
+#include <cstdint>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "connections/implementation/proto/offline_wire_formats.pb.h"
 
 namespace nearby {
+namespace {
+constexpr absl::string_view kIpv6LoopbackAddress(
+    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1", 16);
+}  // namespace
 
 void ServiceAddressToProto(
     const ServiceAddress& service_address,
@@ -42,4 +48,31 @@ bool ServiceAddressFromProto(
   return true;
 }
 
+bool ServiceAddress::IsLoopbackAddress() const {
+  if (address.size() == 4) {
+    // IPv4 loopback: 127.0.0.0/8
+    return address[0] == 127;
+  } else if (address.size() == 16) {
+    // IPv6 loopback: ::1
+    return absl::string_view(address.data(), address.size()) ==
+           kIpv6LoopbackAddress;
+  }
+  return false;
+}
+
+bool ServiceAddress::IsLinkLocalAddress() const {
+  if (address.size() == 4) {
+    // IPv4 link-local: 169.254.0.0/16
+    uint8_t b0 = static_cast<uint8_t>(address[0]);
+    uint8_t b1 = static_cast<uint8_t>(address[1]);
+    return b0 == 169 && b1 == 254;
+  } else if (address.size() == 16) {
+    // IPv6 link-local: fe80::/10
+    uint8_t b0 = static_cast<uint8_t>(address[0]);
+    uint8_t b1 = static_cast<uint8_t>(address[1]);
+    return b0 == 0xfe && (b1 & 0xc0) == 0x80;
+  }
+  return false;
+}
+
 }  // namespace nearby

internal/platform/service_address.h

@@ -16,7 +16,6 @@
 #define THIRD_PARTY_NEARBY_INTERNAL_PLATFORM_SERVICE_ADDRESS_H_
 
 #include <cstdint>
-#include <ostream>
 #include <string>
 #include <vector>
 
@@ -33,6 +32,14 @@ struct ServiceAddress {
   uint16_t port;
 
   bool operator==(const ServiceAddress& other) const = default;
+
+  // Returns true if the address is a loopback address (IPv4 127.0.0.0/8 or
+  // IPv6 ::1).
+  bool IsLoopbackAddress() const;
+
+  // Returns true if the address is a link-local address (IPv4 169.254.0.0/16 or
+  // IPv6 fe80::/10).
+  bool IsLinkLocalAddress() const;
 };
 
 // Support logging of ServiceAddress.

internal/platform/service_address_test.cc

@@ -118,5 +118,104 @@ TEST(ServiceAddressTest, ServiceAddressEquality) {
   EXPECT_EQ(service_address5, service_address6);
 }
 
+TEST(ServiceAddressTest, IsLoopbackAddressIPv4) {
+  ServiceAddress service_address = {
+      .address = {127, 0, 0, 1},
+      .port = 8080,
+  };
+  EXPECT_TRUE(service_address.IsLoopbackAddress());
+
+  ServiceAddress not_loopback = {
+      .address = {10, 0, 0, 1},
+      .port = 8080,
+  };
+  EXPECT_FALSE(not_loopback.IsLoopbackAddress());
+}
+
+TEST(ServiceAddressTest, IsLoopbackAddressIPv6) {
+  ServiceAddress service_address = {
+      .address = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+      .port = 8080,
+  };
+  EXPECT_TRUE(service_address.IsLoopbackAddress());
+
+  ServiceAddress not_loopback = {
+      .address = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2},
+      .port = 8080,
+  };
+  EXPECT_FALSE(not_loopback.IsLoopbackAddress());
+}
+
+TEST(ServiceAddressTest, IsLinkLocalAddressIPv4) {
+  ServiceAddress service_address = {
+      .address = {static_cast<char>(169), static_cast<char>(254), 0, 1},
+      .port = 8080,
+  };
+  EXPECT_TRUE(service_address.IsLinkLocalAddress());
+
+  ServiceAddress not_link_local = {
+      .address = {169, static_cast<char>(253), 0, 1},
+      .port = 8080,
+  };
+  EXPECT_FALSE(not_link_local.IsLinkLocalAddress());
+
+  ServiceAddress not_link_local_b0 = {
+      .address = {100, static_cast<char>(254), 0, 1},
+      .port = 8080,
+  };
+  EXPECT_FALSE(not_link_local_b0.IsLinkLocalAddress());
+}
+
+TEST(ServiceAddressTest, IsLinkLocalAddressIPv6) {
+  ServiceAddress service_address = {
+      .address = {static_cast<char>(0xfe), static_cast<char>(0x80), 0, 0, 0, 0,
+                  0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+      .port = 8080,
+  };
+  EXPECT_TRUE(service_address.IsLinkLocalAddress());
+
+  ServiceAddress not_link_local = {
+      .address = {static_cast<char>(0xfd), static_cast<char>(0x80), 0, 0, 0, 0,
+                  0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+      .port = 8080,
+  };
+  EXPECT_FALSE(not_link_local.IsLinkLocalAddress());
+
+  ServiceAddress not_link_local_b1 = {
+      .address = {static_cast<char>(0xfe), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                  0, 0, 1},
+      .port = 8080,
+  };
+  EXPECT_FALSE(not_link_local_b1.IsLinkLocalAddress());
+}
+
+TEST(ServiceAddressTest, IsLoopbackAddressInvalidLength) {
+  ServiceAddress service_address = {
+      .address = {127, 0, 0},
+      .port = 8080,
+  };
+  EXPECT_FALSE(service_address.IsLoopbackAddress());
+
+  ServiceAddress empty_address = {
+      .address = {},
+      .port = 8080,
+  };
+  EXPECT_FALSE(empty_address.IsLoopbackAddress());
+}
+
+TEST(ServiceAddressTest, IsLinkLocalAddressInvalidLength) {
+  ServiceAddress service_address = {
+      .address = {static_cast<char>(169), static_cast<char>(254), 0},
+      .port = 8080,
+  };
+  EXPECT_FALSE(service_address.IsLinkLocalAddress());
+
+  ServiceAddress empty_address = {
+      .address = {},
+      .port = 8080,
+  };
+  EXPECT_FALSE(empty_address.IsLinkLocalAddress());
+}
+
 }  // namespace
 }  // namespace nearby