core: Handle ProxySelector IllegalArgumentException (#13053)

Fixes #13052.

Android’s DefaultProxySelector.select() can throw
IllegalArgumentException when a configured proxy port is invalid,
causing an unchecked exception to escape the DNS resolver task.

This change wraps that exception in an IOException with the message
"Failed when selecting a proxy", preserving the original cause. The
resolver’s existing error handling reports UNAVAILABLE.

Author: kkmurthyt21

core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java

@@ -206,7 +206,12 @@ private ProxiedSocketAddress detectProxy(InetSocketAddress targetAddr) throws IO
       return null;
     }
 
-    List<Proxy> proxies = proxySelector.select(uri);
+    List<Proxy> proxies;
+    try {
+      proxies = proxySelector.select(uri);
+    } catch (IllegalArgumentException e) {
+      throw new IOException("Failed when selecting a proxy", e);
+    }
     // ProxySelector.select(URI) is contractually required to return a non-null, non-empty list.
     // Surface the offending implementation's class name so a broken ProxySelector can be fixed.
     if (proxies == null || proxies.isEmpty()) {

core/src/test/java/io/grpc/internal/DnsNameResolverTest.java

@@ -64,7 +64,9 @@
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
+import java.net.ProxySelector;
 import java.net.SocketAddress;
+import java.net.URI;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -546,6 +548,36 @@ public List<InetAddress> resolveAddress(String host) throws Exception {
         .isInstanceOf(IOException.class);
   }
 
+  @Test
+  public void resolve_proxySelectorThrowsIllegalArgumentException() throws Exception {
+    IllegalArgumentException cause =
+        new IllegalArgumentException("port out of range: 899858473");
+    ProxySelector proxySelector = mock(ProxySelector.class);
+    when(proxySelector.select(any(URI.class))).thenThrow(cause);
+    ProxyDetectorImpl.AuthenticationProvider authenticator =
+        mock(ProxyDetectorImpl.AuthenticationProvider.class);
+    ProxyDetector proxyDetector = new ProxyDetectorImpl(() -> proxySelector, authenticator);
+    RetryingNameResolver resolver = newResolver(
+        "addr.fake:1234", 443, proxyDetector, Stopwatch.createUnstarted());
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    dnsResolver.setAddressResolver(mockAddressResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeExecutor.runDueTasks()).isEqualTo(1);
+
+    verify(mockListener).onResult2(resultCaptor.capture());
+    verifyNoMoreInteractions(mockListener);
+    Status status = resultCaptor.getValue().getAddressesOrError().getStatus();
+    assertThat(status.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(status.getDescription()).isEqualTo("Unable to resolve host addr.fake");
+    assertThat(status.getCause()).isInstanceOf(IOException.class);
+    assertThat(status.getCause().getMessage()).isEqualTo("Failed when selecting a proxy");
+    assertSame(cause, status.getCause().getCause());
+    verify(proxySelector).select(any(URI.class));
+    verifyNoMoreInteractions(mockAddressResolver, authenticator);
+  }
+
   // Load balancer rejects the empty addresses.
   @Test
   public void resolve_emptyResult_notAccepted() throws Exception {

core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java

@@ -21,6 +21,7 @@
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
@@ -214,4 +215,17 @@ public void throwsWhenProxySelectorReturnsNullList() throws Exception {
     assertTrue(e.getMessage(), e.getMessage().contains("null"));
     assertTrue(e.getMessage(), e.getMessage().contains(proxySelector.getClass().getName()));
   }
+
+  @Test
+  public void throwsWhenProxySelectorThrowsIllegalArgumentException() throws Exception {
+    IllegalArgumentException cause =
+        new IllegalArgumentException("port out of range: 899858473");
+    when(proxySelector.select(any(URI.class))).thenThrow(cause);
+
+    IOException exception =
+        assertThrows(IOException.class, () -> proxyDetector.proxyFor(destination));
+
+    assertSame(cause, exception.getCause());
+    assertEquals("Failed when selecting a proxy", exception.getMessage());
+  }
 }