tests/tests/net/jni/NativeMultinetworkJni.c - platform/cts - Gitiles

 /*
  * 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(%llu, %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(%llu) 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(%llu, %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#section-6.1
     uint8_t quic_packet[1200] = {
         0x0d,                    // public flags:
                                  //   - version present (0x01),
                                  //   - 64bit connection ID (0x0c),
                                  //   - 1 byte packet number (0x00)
         0, 0, 0, 0, 0, 0, 0, 0,  // 64bit connection ID
         0xaa, 0xda, 0xca, 0xaa,  // reserved-space version number
         1,                       // 1 byte packet number
         0x00,                    // private flags
         0x07,                    // PING frame (cuz why not)
     };

     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 < 9) {
         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: Replace this quick 'n' dirty test with proper QUIC-capable code.

     close(fd);
     return 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(%llu, %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(%llu) 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(%llu, %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#section-6.1
	uint8_t quic_packet[1200] = {
	0x0d, // public flags:
	// - version present (0x01),
	// - 64bit connection ID (0x0c),
	// - 1 byte packet number (0x00)
	0, 0, 0, 0, 0, 0, 0, 0, // 64bit connection ID
	0xaa, 0xda, 0xca, 0xaa, // reserved-space version number
	1, // 1 byte packet number
	0x00, // private flags
	0x07, // PING frame (cuz why not)
	};

	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 < 9) {
	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: Replace this quick 'n' dirty test with proper QUIC-capable code.

	close(fd);
	return 0;
	}