Implement HostResolver using getaddrinfo

Author: lauzadis

runtime/runtime-core/common/test/aws/smithy/kotlin/runtime/net/HostResolverTest.kt

@@ -0,0 +1,90 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package aws.smithy.kotlin.runtime.net
+
+import kotlinx.coroutines.test.runTest
+import kotlin.test.*
+
+class HostResolverTest {
+    @Test
+    fun testResolveLocalhost() = runTest {
+        val addresses = HostResolver.Default.resolve("localhost")
+        assertTrue(addresses.isNotEmpty())
+
+        addresses.forEach { addr ->
+            assertEquals("localhost", addr.hostname)
+            when (val ip = addr.address) {
+                is IpV4Addr -> {
+                    assertEquals(4, ip.octets.size)
+                    // localhost should resolve to 127.0.0.1
+                    assertContentEquals(byteArrayOf(127, 0, 0, 1), ip.octets)
+                }
+                is IpV6Addr -> {
+                    assertEquals(16, ip.octets.size)
+                    // ::1 in IPv6
+                    val expectedIpv6 = ByteArray(16) { 0 }
+                    expectedIpv6[15] = 1
+                    assertContentEquals(expectedIpv6, ip.octets)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testResolveIpv4Address() = runTest {
+        val addresses = HostResolver.Default.resolve("127.0.0.1")
+        assertTrue(addresses.isNotEmpty())
+
+        addresses.forEach { addr ->
+            assertTrue(addr.address is IpV4Addr)
+            assertContentEquals(byteArrayOf(127, 0, 0, 1), addr.address.octets)
+        }
+    }
+
+    @Test
+    fun testResolveIpv6Address() = runTest {
+        val addresses = HostResolver.Default.resolve("::1")
+        assertTrue(addresses.isNotEmpty())
+
+        addresses.forEach { addr ->
+            assertTrue(addr.address is IpV6Addr)
+            val expectedBytes = ByteArray(16) { 0 }
+            expectedBytes[15] = 1
+            assertContentEquals(expectedBytes, addr.address.octets)
+        }
+    }
+
+    @Test
+    fun testResolveExampleDomain() = runTest {
+        val addresses = HostResolver.Default.resolve("example.com")
+        assertNotNull(addresses)
+        assertTrue(addresses.isNotEmpty())
+
+        addresses.forEach { addr ->
+            assertEquals("example.com", addr.hostname)
+            when (val ip = addr.address) {
+                is IpV4Addr -> assertEquals(4, ip.octets.size)
+                is IpV6Addr -> assertEquals(16, ip.octets.size)
+            }
+        }
+    }
+
+    @Test
+    fun testResolveInvalidDomain() = runTest {
+        assertFails {
+            HostResolver.Default.resolve("this-domain-definitely-does-not-exist-12345.local")
+        }
+    }
+
+    @Test
+    fun testNoopMethods() {
+        // Test no-op methods don't throw
+        val dummyAddr = HostAddress("test.com", IpV4Addr(ByteArray(4)))
+        val resolver = HostResolver.Default
+        resolver.reportFailure(dummyAddr)
+        resolver.purgeCache(null)
+        resolver.purgeCache(dummyAddr)
+    }
+}

runtime/runtime-core/native/src/aws/smithy/kotlin/runtime/net/HostResolverNative.kt

@@ -4,19 +4,67 @@
  */
 package aws.smithy.kotlin.runtime.net
 
-import aws.smithy.kotlin.runtime.InternalApi
+import kotlinx.cinterop.*
+import platform.posix.*
 
 internal actual object DefaultHostResolver : HostResolver {
-    actual override suspend fun resolve(hostname: String): List<HostAddress> {
-        TODO("Not yet implemented")
+    actual override suspend fun resolve(hostname: String): List<HostAddress> = memScoped {
+        val hints = alloc<addrinfo>().apply {
+            ai_family = AF_UNSPEC     // Allow both IPv4 and IPv6
+            ai_socktype = SOCK_STREAM // TCP stream sockets
+            ai_flags = AI_PASSIVE     // For wildcard IP address
+        }
+
+        val result = allocPointerTo<addrinfo>()
+
+        // Perform the DNS lookup
+        val status = getaddrinfo(hostname, null, hints.ptr, result.ptr)
+        if (status != 0) {
+            throw RuntimeException("Failed to resolve host $hostname: ${gai_strerror(status)?.toKString()}")
+        }
+
+        val addresses = mutableListOf<HostAddress>()
+        var current = result.value
+
+        while (current != null) {
+            val sockaddr = current.pointed.ai_addr!!.pointed
+
+            @OptIn(UnsafeNumber::class)
+            when (sockaddr.sa_family.toInt()) {
+                AF_INET -> {
+                    val addr = sockaddr.reinterpret<sockaddr_in>()
+                    val ipBytes = ByteArray(4)
+                    memcpy(ipBytes.refTo(0), addr.sin_addr.ptr, 4uL)
+
+                    addresses.add(HostAddress(
+                        hostname = hostname,
+                        address = IpV4Addr(ipBytes)
+                    ))
+                }
+                AF_INET6 -> {
+                    val addr = sockaddr.reinterpret<sockaddr_in6>()
+                    val ipBytes = ByteArray(16)
+                    memcpy(ipBytes.refTo(0), addr.sin6_addr.ptr, 16.convert())
+                    addresses.add(HostAddress(
+                        hostname = hostname,
+                        address = IpV6Addr(ipBytes)
+                    ))
+                }
+            }
+            current = current.pointed.ai_next
+        }
+
+        // Free the getaddrinfo results
+        freeaddrinfo(result.value)
+
+        addresses
     }
 
     actual override fun reportFailure(addr: HostAddress) {
-        TODO("Not yet implemented")
+        // No-op, same as JVM implementation
     }
 
-    @InternalApi
     actual override fun purgeCache(addr: HostAddress?) {
-        TODO("Not yet implemented")
+        // No-op, same as JVM implementation
     }
-}
+}