diff --git a/tests/cts/net/jni/Android.mk b/tests/cts/net/jni/Android.mk index 727a44d315..ccb1278f94 100644 --- a/tests/cts/net/jni/Android.mk +++ b/tests/cts/net/jni/Android.mk @@ -36,7 +36,7 @@ include $(CLEAR_VARS) LOCAL_MODULE := libnativemultinetwork_jni # Don't include this package in any configuration by default. LOCAL_MODULE_TAGS := optional -LOCAL_SRC_FILES := NativeMultinetworkJni.c +LOCAL_SRC_FILES := NativeMultinetworkJni.cpp LOCAL_CFLAGS := -Wall -Werror -Wno-format LOCAL_C_INCLUDES := $(JNI_H_INCLUDE) LOCAL_SHARED_LIBRARIES := libandroid libnativehelper_compat_libc++ liblog diff --git a/tests/cts/net/jni/NativeMultinetworkJni.c b/tests/cts/net/jni/NativeMultinetworkJni.c deleted file mode 100644 index 2fa529191d..0000000000 --- a/tests/cts/net/jni/NativeMultinetworkJni.c +++ /dev/null @@ -1,237 +0,0 @@ -/* - * Copyright (C) 2010 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - -#define LOG_TAG "MultinetworkApiTest" -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define UNUSED(X) ((void) (X)) - -static const char kHostname[] = "connectivitycheck.android.com"; - - -JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runGetaddrinfoCheck( - JNIEnv* env, jclass class, jlong nethandle) { - UNUSED(env); - UNUSED(class); - net_handle_t handle = (net_handle_t) nethandle; - struct addrinfo *res = NULL; - - errno = 0; - int rval = android_getaddrinfofornetwork(handle, kHostname, NULL, NULL, &res); - const int saved_errno = errno; - freeaddrinfo(res); - - ALOGD("android_getaddrinfofornetwork(%" PRIu64 ", %s) returned rval=%d errno=%d", - handle, kHostname, rval, saved_errno); - return rval == 0 ? 0 : -saved_errno; -} - -JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetprocnetwork( - JNIEnv* env, jclass class, jlong nethandle) { - UNUSED(env); - UNUSED(class); - net_handle_t handle = (net_handle_t) nethandle; - - errno = 0; - int rval = android_setprocnetwork(handle); - const int saved_errno = errno; - ALOGD("android_setprocnetwork(%" PRIu64 ") returned rval=%d errno=%d", - handle, rval, saved_errno); - return rval == 0 ? 0 : -saved_errno; -} - -JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetsocknetwork( - JNIEnv* env, jclass class, jlong nethandle) { - UNUSED(env); - UNUSED(class); - net_handle_t handle = (net_handle_t) nethandle; - - errno = 0; - int fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); - if (fd < 0) { - ALOGD("socket() failed, errno=%d", errno); - return -errno; - } - - errno = 0; - int rval = android_setsocknetwork(handle, fd); - const int saved_errno = errno; - ALOGD("android_setprocnetwork(%" PRIu64 ", %d) returned rval=%d errno=%d", - handle, fd, rval, saved_errno); - close(fd); - return rval == 0 ? 0 : -saved_errno; -} - -// Use sizeof("x") - 1 because we need a compile-time constant, and strlen("x") -// isn't guaranteed to fold to a constant. -static const int kSockaddrStrLen = INET6_ADDRSTRLEN + sizeof("[]:65535") - 1; - -void sockaddr_ntop(const struct sockaddr *sa, socklen_t salen, char *dst, const size_t size) { - char addrstr[INET6_ADDRSTRLEN]; - char portstr[sizeof("65535")]; - char buf[kSockaddrStrLen+1]; - - int ret = getnameinfo(sa, salen, - addrstr, sizeof(addrstr), - portstr, sizeof(portstr), - NI_NUMERICHOST | NI_NUMERICSERV); - if (ret == 0) { - snprintf(buf, sizeof(buf), - (sa->sa_family == AF_INET6) ? "[%s]:%s" : "%s:%s", - addrstr, portstr); - } else { - sprintf(buf, "???"); - } - - strlcpy(dst, buf, size); -} - -JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runDatagramCheck( - JNIEnv* env, jclass class, jlong nethandle) { - UNUSED(env); - UNUSED(class); - const struct addrinfo kHints = { - .ai_flags = AI_ADDRCONFIG, - .ai_family = AF_UNSPEC, - .ai_socktype = SOCK_DGRAM, - .ai_protocol = IPPROTO_UDP, - }; - struct addrinfo *res = NULL; - net_handle_t handle = (net_handle_t) nethandle; - - static const char kPort[] = "443"; - int rval = android_getaddrinfofornetwork(handle, kHostname, kPort, &kHints, &res); - if (rval != 0) { - ALOGD("android_getaddrinfofornetwork(%llu, %s) returned rval=%d errno=%d", - handle, kHostname, rval, errno); - freeaddrinfo(res); - return -errno; - } - - // Rely upon getaddrinfo sorting the best destination to the front. - int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); - if (fd < 0) { - ALOGD("socket(%d, %d, %d) failed, errno=%d", - res->ai_family, res->ai_socktype, res->ai_protocol, errno); - freeaddrinfo(res); - return -errno; - } - - rval = android_setsocknetwork(handle, fd); - ALOGD("android_setprocnetwork(%llu, %d) returned rval=%d errno=%d", - handle, fd, rval, errno); - if (rval != 0) { - close(fd); - freeaddrinfo(res); - return -errno; - } - - char addrstr[kSockaddrStrLen+1]; - sockaddr_ntop(res->ai_addr, res->ai_addrlen, addrstr, sizeof(addrstr)); - ALOGD("Attempting connect() to %s ...", addrstr); - - rval = connect(fd, res->ai_addr, res->ai_addrlen); - if (rval != 0) { - close(fd); - freeaddrinfo(res); - return -errno; - } - freeaddrinfo(res); - - struct sockaddr_storage src_addr; - socklen_t src_addrlen = sizeof(src_addr); - if (getsockname(fd, (struct sockaddr *)&src_addr, &src_addrlen) != 0) { - close(fd); - return -errno; - } - sockaddr_ntop((const struct sockaddr *)&src_addr, sizeof(src_addr), addrstr, sizeof(addrstr)); - ALOGD("... from %s", addrstr); - - // Don't let reads or writes block indefinitely. - const struct timeval timeo = { 2, 0 }; // 2 seconds - setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo)); - setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo)); - - // For reference see: - // https://tools.ietf.org/html/draft-tsvwg-quic-protocol-01#section-6.1 - uint8_t quic_packet[] = { - 0x0c, // public flags: 64bit conn ID, 8bit sequence number - 0, 0, 0, 0, 0, 0, 0, 0, // 64bit connection ID - 0x01, // sequence number - 0x00, // private flags - 0x07, // type: regular frame type "PING" - }; - - arc4random_buf(quic_packet + 1, 8); // random connection ID - - uint8_t response[1500]; - ssize_t sent, rcvd; - static const int MAX_RETRIES = 5; - int i, errnum = 0; - - for (i = 0; i < MAX_RETRIES; i++) { - sent = send(fd, quic_packet, sizeof(quic_packet), 0); - if (sent < (ssize_t)sizeof(quic_packet)) { - errnum = errno; - ALOGD("send(QUIC packet) returned sent=%zd, errno=%d", sent, errnum); - close(fd); - return -errnum; - } - - rcvd = recv(fd, response, sizeof(response), 0); - if (rcvd > 0) { - break; - } else { - errnum = errno; - ALOGD("[%d/%d] recv(QUIC response) returned rcvd=%zd, errno=%d", - i + 1, MAX_RETRIES, rcvd, errnum); - } - } - if (rcvd < sent) { - ALOGD("QUIC UDP %s: sent=%zd but rcvd=%zd, errno=%d", kPort, sent, rcvd, errnum); - if (rcvd <= 0) { - ALOGD("Does this network block UDP port %s?", kPort); - } - close(fd); - return -EPROTO; - } - - int conn_id_cmp = memcmp(quic_packet + 1, response + 1, 8); - if (conn_id_cmp != 0) { - ALOGD("sent and received connection IDs do not match"); - close(fd); - return -EPROTO; - } - - // TODO: log, and compare to the IP address encoded in the - // response, since this should be a public reset packet. - - close(fd); - return 0; -} diff --git a/tests/cts/net/jni/NativeMultinetworkJni.cpp b/tests/cts/net/jni/NativeMultinetworkJni.cpp new file mode 100644 index 0000000000..332148bf39 --- /dev/null +++ b/tests/cts/net/jni/NativeMultinetworkJni.cpp @@ -0,0 +1,510 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#define LOG_TAG "MultinetworkApiTest" +#include + +#include +#include +#include +#include +#include +#include +#include /* poll */ +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +#define EXPECT_GE(env, actual, expected, msg) \ + do { \ + if (actual < expected) { \ + jniThrowExceptionFmt(env, "java/lang/AssertionError", \ + "%s:%d: %s EXPECT_GE: expected %d, got %d", \ + __FILE__, __LINE__, expected, actual); \ + } \ + } while (0) + +#define EXPECT_GT(env, actual, expected, msg) \ + do { \ + if (actual <= expected) { \ + jniThrowExceptionFmt(env, "java/lang/AssertionError", \ + "%s:%d: %s EXPECT_GT: expected %d, got %d", \ + __FILE__, __LINE__, msg, expected, actual); \ + } \ + } while (0) + +#define EXPECT_EQ(env, expected, actual, msg) \ + do { \ + if (actual != expected) { \ + jniThrowExceptionFmt(env, "java/lang/AssertionError", \ + "%s:%d: %s EXPECT_EQ: expected %d, got %d", \ + __FILE__, __LINE__, msg, expected, actual); \ + } \ + } while (0) + +static const int MAXPACKET = 8 * 1024; +static const int TIMEOUT_MS = 2000; +static const char kHostname[] = "connectivitycheck.android.com"; +static const char kNxDomainName[] = "test1-nx.metric.gstatic.com"; +static const char kGoogleName[] = "www.google.com"; + +int makeQuery(const char* name, int qtype, uint8_t* buf, size_t buflen) { + return res_mkquery(ns_o_query, name, ns_c_in, qtype, NULL, 0, NULL, buf, buflen); +} + +int getAsyncResponse(JNIEnv* env, int fd, int timeoutMs, int* rcode, uint8_t* buf, size_t bufLen) { + struct pollfd wait_fd = { .fd = fd, .events = POLLIN }; + + poll(&wait_fd, 1, timeoutMs); + if (wait_fd.revents & POLLIN) { + int n = android_res_nresult(fd, rcode, buf, bufLen); + // Verify that android_res_nresult() closed the fd + char dummy; + EXPECT_EQ(env, -1, read(fd, &dummy, sizeof dummy), "res_nresult check for closing fd"); + EXPECT_EQ(env, EBADF, errno, "res_nresult check for errno"); + return n; + } + + return -EREMOTEIO; +} + +int extractIpAddressAnswers(uint8_t* buf, size_t bufLen, int family) { + ns_msg handle; + if (ns_initparse((const uint8_t*) buf, bufLen, &handle) < 0) { + return -EREMOTEIO; + } + const int ancount = ns_msg_count(handle, ns_s_an); + ns_rr rr; + for (int i = 0; i < ancount; i++) { + if (ns_parserr(&handle, ns_s_an, i, &rr) < 0) { + continue; + } + const uint8_t* rdata = ns_rr_rdata(rr); + char buffer[INET6_ADDRSTRLEN]; + if (inet_ntop(family, (const char*) rdata, buffer, sizeof(buffer)) == NULL) { + return -errno; + } + } + return 0; +} + +int expectAnswersValid(JNIEnv* env, int fd, int family, int expectedRcode) { + int rcode = -1; + uint8_t buf[MAXPACKET] = {}; + int res = getAsyncResponse(env, fd, TIMEOUT_MS, &rcode, buf, MAXPACKET); + if (res < 0) { + return res; + } + if(rcode != expectedRcode) { + ALOGD("rcode:%d, expectedRcode = %d", rcode, expectedRcode); + return -EREMOTEIO; + } + + if (expectedRcode == ns_r_noerror && res > 0) { + return extractIpAddressAnswers(buf, res, family); + } + return 0; +} + +int expectAnswersNotValid(JNIEnv* env, int fd, int expectedErrno) { + int rcode = -1; + uint8_t buf[MAXPACKET] = {}; + int res = getAsyncResponse(env, fd, TIMEOUT_MS, &rcode, buf, MAXPACKET); + if (res != expectedErrno) { + ALOGD("res:%d, expectedErrno = %d", res, expectedErrno); + return (res > 0) ? -EREMOTEIO : res; + } + return 0; +} + +extern "C" +JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runResNqueryCheck( + JNIEnv* env, jclass, jlong nethandle) { + net_handle_t handle = (net_handle_t) nethandle; + + // V4 + int fd = android_res_nquery(handle, kHostname, ns_c_in, ns_t_a, 0); + EXPECT_GE(env, fd, 0, "v4 res_nquery"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_noerror), + "v4 res_nquery check answers"); + + // V4 NXDOMAIN + fd = android_res_nquery(handle, kNxDomainName, ns_c_in, ns_t_a, + ANDROID_RESOLV_NO_CACHE_LOOKUP); + EXPECT_GE(env, fd, 0, "v4 res_nquery NXDOMAIN"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_nxdomain), + "v4 res_nquery NXDOMAIN check answers"); + + // V6 + fd = android_res_nquery(handle, kHostname, ns_c_in, ns_t_aaaa, 0); + EXPECT_GE(env, fd, 0, "v6 res_nquery"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_noerror), + "v6 res_nquery check answers"); + + // V6 NXDOMAIN + fd = android_res_nquery(handle, kNxDomainName, ns_c_in, ns_t_aaaa, + ANDROID_RESOLV_NO_CACHE_LOOKUP); + EXPECT_GE(env, fd, 0, "v6 res_nquery NXDOMAIN"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_nxdomain), + "v6 res_nquery NXDOMAIN check answers"); + + return 0; +} + +extern "C" +JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runResNsendCheck( + JNIEnv* env, jclass, jlong nethandle) { + net_handle_t handle = (net_handle_t) nethandle; + // V4 + uint8_t buf1[MAXPACKET] = {}; + + int len1 = makeQuery(kGoogleName, ns_t_a, buf1, sizeof(buf1)); + EXPECT_GT(env, len1, 0, "v4 res_mkquery 1st"); + + uint8_t buf2[MAXPACKET] = {}; + int len2 = makeQuery(kHostname, ns_t_a, buf2, sizeof(buf2)); + EXPECT_GT(env, len2, 0, "v4 res_mkquery 2nd"); + + int fd1 = android_res_nsend(handle, buf1, len1, 0); + EXPECT_GE(env, fd1, 0, "v4 res_nsend 1st"); + int fd2 = android_res_nsend(handle, buf2, len2, 0); + EXPECT_GE(env, fd2, 0, "v4 res_nsend 2nd"); + + EXPECT_EQ(env, 0, expectAnswersValid(env, fd2, AF_INET, ns_r_noerror), + "v4 res_nsend 2nd check answers"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET, ns_r_noerror), + "v4 res_nsend 1st check answers"); + + // V4 NXDOMAIN + memset(buf1, 0, sizeof(buf1)); + len1 = makeQuery(kNxDomainName, ns_t_a, buf1, sizeof(buf1)); + EXPECT_GT(env, len1, 0, "v4 res_mkquery NXDOMAIN"); + fd1 = android_res_nsend(handle, buf1, len1, ANDROID_RESOLV_NO_CACHE_LOOKUP); + EXPECT_GE(env, fd1, 0, "v4 res_nsend NXDOMAIN"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET, ns_r_nxdomain), + "v4 res_nsend NXDOMAIN check answers"); + + // V6 + memset(buf1, 0, sizeof(buf1)); + memset(buf2, 0, sizeof(buf2)); + len1 = makeQuery(kGoogleName, ns_t_aaaa, buf1, sizeof(buf1)); + EXPECT_GT(env, len1, 0, "v6 res_mkquery 1st"); + len2 = makeQuery(kHostname, ns_t_aaaa, buf2, sizeof(buf2)); + EXPECT_GT(env, len2, 0, "v6 res_mkquery 2nd"); + + fd1 = android_res_nsend(handle, buf1, len1, 0); + EXPECT_GE(env, fd1, 0, "v6 res_nsend 1st"); + fd2 = android_res_nsend(handle, buf2, len2, 0); + EXPECT_GE(env, fd2, 0, "v6 res_nsend 2nd"); + + EXPECT_EQ(env, 0, expectAnswersValid(env, fd2, AF_INET6, ns_r_noerror), + "v6 res_nsend 2nd check answers"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET6, ns_r_noerror), + "v6 res_nsend 1st check answers"); + + // // V6 NXDOMAIN + memset(buf1, 0, sizeof(buf1)); + len1 = makeQuery(kNxDomainName, ns_t_aaaa, buf1, sizeof(buf1)); + EXPECT_GT(env, len1, 0, "v6 res_mkquery NXDOMAIN"); + fd1 = android_res_nsend(handle, buf1, len1, ANDROID_RESOLV_NO_CACHE_LOOKUP); + EXPECT_GE(env, fd1, 0, "v6 res_nsend NXDOMAIN"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET6, ns_r_nxdomain), + "v6 res_nsend NXDOMAIN check answers"); + + return 0; +} + +extern "C" +JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runResNcancelCheck( + JNIEnv* env, jclass, jlong nethandle) { + net_handle_t handle = (net_handle_t) nethandle; + + int fd = android_res_nquery(handle, kGoogleName, ns_c_in, ns_t_a, 0); + int rcode = -1; + uint8_t buf[MAXPACKET] = {}; + android_res_cancel(fd); + android_res_cancel(fd); + + EXPECT_EQ(env, -EBADF, android_res_nresult(fd, &rcode, buf, MAXPACKET), "res_cancel"); + return 0; +} + +extern "C" +JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runResNapiMalformedCheck( + JNIEnv* env, jclass, jlong nethandle) { + net_handle_t handle = (net_handle_t) nethandle; + + // It is the equivalent of "dig . a", Query with an empty name. + int fd = android_res_nquery(handle, "", ns_c_in, ns_t_a, 0); + EXPECT_GE(env, fd, 0, "res_nquery root"); + EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_noerror), + "res_nquery root check answers"); + + // Label limit 63 + std::string exceedingLabelQuery = "www." + std::string(70, 'g') + ".com"; + // Name limit 255 + std::string exceedingDomainQuery = "www." + std::string(255, 'g') + ".com"; + + fd = android_res_nquery(handle, exceedingLabelQuery.c_str(), ns_c_in, ns_t_a, 0); + EXPECT_EQ(env, -EMSGSIZE, fd, "res_nquery exceedingLabelQuery"); + fd = android_res_nquery(handle, exceedingDomainQuery.c_str(), ns_c_in, ns_t_a, 0); + EXPECT_EQ(env, -EMSGSIZE, fd, "res_nquery exceedingDomainQuery"); + + uint8_t buf[10] = {}; + // empty BLOB + fd = android_res_nsend(handle, buf, 10, 0); + EXPECT_GE(env, fd, 0, "res_nsend empty BLOB"); + EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL), + "res_nsend empty BLOB check answers"); + + uint8_t largeBuf[2 * MAXPACKET] = {}; + // A buffer larger than 8KB + fd = android_res_nsend(handle, largeBuf, sizeof(largeBuf), 0); + EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend buffer larger than 8KB"); + + // 1000 bytes filled with 0. This returns EMSGSIZE because FrameworkListener limits the size of + // commands to 1024 bytes. TODO: b/126307309 + fd = android_res_nsend(handle, largeBuf, 1000, 0); + EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend 1000 bytes filled with 0"); + + // 500 bytes filled with 0 + fd = android_res_nsend(handle, largeBuf, 500, 0); + EXPECT_GE(env, fd, 0, "res_nsend 500 bytes filled with 0"); + EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL), + "res_nsend 500 bytes filled with 0 check answers"); + + // 1000 bytes filled with 0xFF + uint8_t ffBuf[1001] = {}; + memset(ffBuf, 0xFF, sizeof(ffBuf)); + ffBuf[1000] = '\0'; + fd = android_res_nsend(handle, ffBuf, sizeof(ffBuf), 0); + EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend 1000 bytes filled with 0xFF"); + + // 500 bytes filled with 0xFF + ffBuf[501] = '\0'; + fd = android_res_nsend(handle, ffBuf, 500, 0); + EXPECT_GE(env, fd, 0, "res_nsend 500 bytes filled with 0xFF"); + EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL), + "res_nsend 500 bytes filled with 0xFF check answers"); + + return 0; +} + +extern "C" +JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runGetaddrinfoCheck( + JNIEnv*, jclass, jlong nethandle) { + net_handle_t handle = (net_handle_t) nethandle; + struct addrinfo *res = NULL; + + errno = 0; + int rval = android_getaddrinfofornetwork(handle, kHostname, NULL, NULL, &res); + const int saved_errno = errno; + freeaddrinfo(res); + + ALOGD("android_getaddrinfofornetwork(%" PRIu64 ", %s) returned rval=%d errno=%d", + handle, kHostname, rval, saved_errno); + return rval == 0 ? 0 : -saved_errno; +} + +extern "C" +JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetprocnetwork( + JNIEnv*, jclass, jlong nethandle) { + net_handle_t handle = (net_handle_t) nethandle; + + errno = 0; + int rval = android_setprocnetwork(handle); + const int saved_errno = errno; + ALOGD("android_setprocnetwork(%" PRIu64 ") returned rval=%d errno=%d", + handle, rval, saved_errno); + return rval == 0 ? 0 : -saved_errno; +} + +extern "C" +JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetsocknetwork( + JNIEnv*, jclass, jlong nethandle) { + net_handle_t handle = (net_handle_t) nethandle; + + errno = 0; + int fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); + if (fd < 0) { + ALOGD("socket() failed, errno=%d", errno); + return -errno; + } + + errno = 0; + int rval = android_setsocknetwork(handle, fd); + const int saved_errno = errno; + ALOGD("android_setprocnetwork(%" PRIu64 ", %d) returned rval=%d errno=%d", + handle, fd, rval, saved_errno); + close(fd); + return rval == 0 ? 0 : -saved_errno; +} + +// Use sizeof("x") - 1 because we need a compile-time constant, and strlen("x") +// isn't guaranteed to fold to a constant. +static const int kSockaddrStrLen = INET6_ADDRSTRLEN + sizeof("[]:65535") - 1; + +void sockaddr_ntop(const struct sockaddr *sa, socklen_t salen, char *dst, const size_t size) { + char addrstr[INET6_ADDRSTRLEN]; + char portstr[sizeof("65535")]; + char buf[kSockaddrStrLen+1]; + + int ret = getnameinfo(sa, salen, + addrstr, sizeof(addrstr), + portstr, sizeof(portstr), + NI_NUMERICHOST | NI_NUMERICSERV); + if (ret == 0) { + snprintf(buf, sizeof(buf), + (sa->sa_family == AF_INET6) ? "[%s]:%s" : "%s:%s", + addrstr, portstr); + } else { + sprintf(buf, "???"); + } + + strlcpy(dst, buf, size); +} + +extern "C" +JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runDatagramCheck( + JNIEnv*, jclass, jlong nethandle) { + const struct addrinfo kHints = { + .ai_flags = AI_ADDRCONFIG, + .ai_family = AF_UNSPEC, + .ai_socktype = SOCK_DGRAM, + .ai_protocol = IPPROTO_UDP, + }; + struct addrinfo *res = NULL; + net_handle_t handle = (net_handle_t) nethandle; + + static const char kPort[] = "443"; + int rval = android_getaddrinfofornetwork(handle, kHostname, kPort, &kHints, &res); + if (rval != 0) { + ALOGD("android_getaddrinfofornetwork(%llu, %s) returned rval=%d errno=%d", + handle, kHostname, rval, errno); + freeaddrinfo(res); + return -errno; + } + + // Rely upon getaddrinfo sorting the best destination to the front. + int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); + if (fd < 0) { + ALOGD("socket(%d, %d, %d) failed, errno=%d", + res->ai_family, res->ai_socktype, res->ai_protocol, errno); + freeaddrinfo(res); + return -errno; + } + + rval = android_setsocknetwork(handle, fd); + ALOGD("android_setprocnetwork(%llu, %d) returned rval=%d errno=%d", + handle, fd, rval, errno); + if (rval != 0) { + close(fd); + freeaddrinfo(res); + return -errno; + } + + char addrstr[kSockaddrStrLen+1]; + sockaddr_ntop(res->ai_addr, res->ai_addrlen, addrstr, sizeof(addrstr)); + ALOGD("Attempting connect() to %s ...", addrstr); + + rval = connect(fd, res->ai_addr, res->ai_addrlen); + if (rval != 0) { + close(fd); + freeaddrinfo(res); + return -errno; + } + freeaddrinfo(res); + + struct sockaddr_storage src_addr; + socklen_t src_addrlen = sizeof(src_addr); + if (getsockname(fd, (struct sockaddr *)&src_addr, &src_addrlen) != 0) { + close(fd); + return -errno; + } + sockaddr_ntop((const struct sockaddr *)&src_addr, sizeof(src_addr), addrstr, sizeof(addrstr)); + ALOGD("... from %s", addrstr); + + // Don't let reads or writes block indefinitely. + const struct timeval timeo = { 2, 0 }; // 2 seconds + setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo)); + setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo)); + + // For reference see: + // https://tools.ietf.org/html/draft-tsvwg-quic-protocol-01#section-6.1 + uint8_t quic_packet[] = { + 0x0c, // public flags: 64bit conn ID, 8bit sequence number + 0, 0, 0, 0, 0, 0, 0, 0, // 64bit connection ID + 0x01, // sequence number + 0x00, // private flags + 0x07, // type: regular frame type "PING" + }; + + arc4random_buf(quic_packet + 1, 8); // random connection ID + + uint8_t response[1500]; + ssize_t sent, rcvd; + static const int MAX_RETRIES = 5; + int i, errnum = 0; + + for (i = 0; i < MAX_RETRIES; i++) { + sent = send(fd, quic_packet, sizeof(quic_packet), 0); + if (sent < (ssize_t)sizeof(quic_packet)) { + errnum = errno; + ALOGD("send(QUIC packet) returned sent=%zd, errno=%d", sent, errnum); + close(fd); + return -errnum; + } + + rcvd = recv(fd, response, sizeof(response), 0); + if (rcvd > 0) { + break; + } else { + errnum = errno; + ALOGD("[%d/%d] recv(QUIC response) returned rcvd=%zd, errno=%d", + i + 1, MAX_RETRIES, rcvd, errnum); + } + } + if (rcvd < sent) { + ALOGD("QUIC UDP %s: sent=%zd but rcvd=%zd, errno=%d", kPort, sent, rcvd, errnum); + if (rcvd <= 0) { + ALOGD("Does this network block UDP port %s?", kPort); + } + close(fd); + return -EPROTO; + } + + int conn_id_cmp = memcmp(quic_packet + 1, response + 1, 8); + if (conn_id_cmp != 0) { + ALOGD("sent and received connection IDs do not match"); + close(fd); + return -EPROTO; + } + + // TODO: log, and compare to the IP address encoded in the + // response, since this should be a public reset packet. + + close(fd); + return 0; +} diff --git a/tests/cts/net/src/android/net/cts/MultinetworkApiTest.java b/tests/cts/net/src/android/net/cts/MultinetworkApiTest.java index b2c9d9b26a..c3e65b7bd2 100644 --- a/tests/cts/net/src/android/net/cts/MultinetworkApiTest.java +++ b/tests/cts/net/src/android/net/cts/MultinetworkApiTest.java @@ -43,6 +43,12 @@ public class MultinetworkApiTest extends AndroidTestCase { private static native int runSetprocnetwork(long networkHandle); private static native int runSetsocknetwork(long networkHandle); private static native int runDatagramCheck(long networkHandle); + private static native int runResNapiMalformedCheck(long networkHandle); + private static native int runResNcancelCheck(long networkHandle); + private static native int runResNqueryCheck(long networkHandle); + private static native int runResNsendCheck(long networkHandle); + + private ConnectivityManager mCM; @@ -175,4 +181,14 @@ public class MultinetworkApiTest extends AndroidTestCase { fail(); } catch (IllegalArgumentException e) {} } + + public void testResNApi() { + for (Network network : getTestableNetworks()) { + // Throws AssertionError directly in jni function if test fail. + runResNqueryCheck(network.getNetworkHandle()); + runResNsendCheck(network.getNetworkHandle()); + runResNcancelCheck(network.getNetworkHandle()); + runResNapiMalformedCheck(network.getNetworkHandle()); + } + } }