LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge changes from topic "NDK DNS API CTS" am: 0e45542141 am: 33e10a1a85

Browse Source 
am: c417fde69d

Change-Id: Icaae7eec2432195d0497ecf621d43275bdf33a82
This commit is contained in:
Luke Huang
2019-02-27 04:49:51 -08:00
committed by android-build-merger
parent 29235ec92f c417fde69d
commit 259949b062
4 changed files with 527 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/cts/net/jni/Android.mk
View File

@@ -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

237
tests/cts/net/jni/NativeMultinetworkJni.c
View File

@@ -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 <utils/Log.h>
#include <arpa/inet.h>
#include <errno.h>
#include <inttypes.h>
#include <jni.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <android/multinetwork.h>
#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;
}

510
tests/cts/net/jni/NativeMultinetworkJni.cpp Normal file
View File

@@ -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 <utils/Log.h>
#include <arpa/inet.h>
#include <arpa/nameser.h>
#include <errno.h>
#include <inttypes.h>
#include <jni.h>
#include <netdb.h>
#include <poll.h> /* poll */
#include <resolv.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <string>
#include <android/multinetwork.h>
#include <nativehelper/JNIHelp.h>
#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;
}

16
tests/cts/net/src/android/net/cts/MultinetworkApiTest.java
View File

@@ -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());
}
}
}