1 /*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17
18 #define LOG_TAG "MultinetworkApiTest"
19
20 #include <arpa/inet.h>
21 #include <arpa/nameser.h>
22 #include <errno.h>
23 #include <inttypes.h>
24 #include <jni.h>
25 #include <netdb.h>
26 #include <poll.h> /* poll */
27 #include <resolv.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <sys/socket.h>
32 #include <sys/time.h>
33
34 #include <string>
35
36 #include <android/log.h>
37 #include <android/multinetwork.h>
38 #include <nativehelper/JNIHelp.h>
39
40 #define LOGD(fmt, ...) \
41 __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, fmt, ##__VA_ARGS__)
42
43 // Since the tests in this file commonly pass expression statements as parameters to these macros,
44 // get the returned value of the statements to avoid statement double-called.
45 #define EXPECT_GE(env, actual_stmt, expected_stmt, msg) \
46 do { \
47 const auto expected = (expected_stmt); \
48 const auto actual = (actual_stmt); \
49 if (actual < expected) { \
50 jniThrowExceptionFmt(env, "java/lang/AssertionError", \
51 "%s:%d: %s EXPECT_GE: expected %d, got %d", \
52 __FILE__, __LINE__, msg, expected, actual); \
53 } \
54 } while (0)
55
56 #define EXPECT_GT(env, actual_stmt, expected_stmt, msg) \
57 do { \
58 const auto expected = (expected_stmt); \
59 const auto actual = (actual_stmt); \
60 if (actual <= expected) { \
61 jniThrowExceptionFmt(env, "java/lang/AssertionError", \
62 "%s:%d: %s EXPECT_GT: expected %d, got %d", \
63 __FILE__, __LINE__, msg, expected, actual); \
64 } \
65 } while (0)
66
67 #define EXPECT_EQ(env, expected_stmt, actual_stmt, msg) \
68 do { \
69 const auto expected = (expected_stmt); \
70 const auto actual = (actual_stmt); \
71 if (actual != expected) { \
72 jniThrowExceptionFmt(env, "java/lang/AssertionError", \
73 "%s:%d: %s EXPECT_EQ: expected %d, got %d", \
74 __FILE__, __LINE__, msg, expected, actual); \
75 } \
76 } while (0)
77
78 static const int MAXPACKET = 8 * 1024;
79 static const int TIMEOUT_MS = 15000;
80 static const char kHostname[] = "connectivitycheck.android.com";
81 static const char kNxDomainName[] = "test1-nx.metric.gstatic.com";
82 static const char kGoogleName[] = "www.google.com";
83
makeQuery(const char * name,int qtype,uint8_t * buf,size_t buflen)84 int makeQuery(const char* name, int qtype, uint8_t* buf, size_t buflen) {
85 return res_mkquery(ns_o_query, name, ns_c_in, qtype, NULL, 0, NULL, buf, buflen);
86 }
87
getAsyncResponse(JNIEnv * env,int fd,int timeoutMs,int * rcode,uint8_t * buf,size_t bufLen)88 int getAsyncResponse(JNIEnv* env, int fd, int timeoutMs, int* rcode, uint8_t* buf, size_t bufLen) {
89 struct pollfd wait_fd = { .fd = fd, .events = POLLIN };
90
91 poll(&wait_fd, 1, timeoutMs);
92 if (wait_fd.revents & POLLIN) {
93 int n = android_res_nresult(fd, rcode, buf, bufLen);
94 // Verify that android_res_nresult() closed the fd
95 char dummy;
96 EXPECT_EQ(env, -1, read(fd, &dummy, sizeof(dummy)), "res_nresult check for closing fd");
97 EXPECT_EQ(env, EBADF, errno, "res_nresult check for errno");
98 return n;
99 }
100
101 return -ETIMEDOUT;
102 }
103
extractIpAddressAnswers(uint8_t * buf,size_t bufLen,int family)104 int extractIpAddressAnswers(uint8_t* buf, size_t bufLen, int family) {
105 ns_msg handle;
106 if (ns_initparse((const uint8_t*) buf, bufLen, &handle) < 0) {
107 return -errno;
108 }
109 const int ancount = ns_msg_count(handle, ns_s_an);
110 // Answer count = 0 is valid(e.g. response of query with root)
111 if (!ancount) {
112 return 0;
113 }
114 ns_rr rr;
115 bool hasValidAns = false;
116 for (int i = 0; i < ancount; i++) {
117 if (ns_parserr(&handle, ns_s_an, i, &rr) < 0) {
118 // If there is no valid answer, test will fail.
119 continue;
120 }
121
122 const int rtype = ns_rr_type(rr);
123 if (family == AF_INET) {
124 // If there is no expected address type, test will fail.
125 if (rtype != ns_t_a) continue;
126 } else if (family == AF_INET6) {
127 // If there is no expected address type, test will fail.
128 if (rtype != ns_t_aaaa) continue;
129 } else {
130 return -EAFNOSUPPORT;
131 }
132
133 const uint8_t* rdata = ns_rr_rdata(rr);
134 char buffer[INET6_ADDRSTRLEN];
135 if (inet_ntop(family, (const char*) rdata, buffer, sizeof(buffer)) == NULL) {
136 return -errno;
137 }
138 hasValidAns = true;
139 }
140 return hasValidAns ? 0 : -EBADMSG;
141 }
142
expectAnswersValid(JNIEnv * env,int fd,int family,int expectedRcode)143 int expectAnswersValid(JNIEnv* env, int fd, int family, int expectedRcode) {
144 int rcode = -1;
145 uint8_t buf[MAXPACKET] = {};
146 int res = getAsyncResponse(env, fd, TIMEOUT_MS, &rcode, buf, MAXPACKET);
147 if (res < 0) {
148 return res;
149 }
150
151 EXPECT_EQ(env, expectedRcode, rcode, "rcode is not expected");
152
153 if (expectedRcode == ns_r_noerror && res > 0) {
154 return extractIpAddressAnswers(buf, res, family);
155 }
156 return 0;
157 }
158
expectAnswersNotValid(JNIEnv * env,int fd,int expectedErrno)159 int expectAnswersNotValid(JNIEnv* env, int fd, int expectedErrno) {
160 int rcode = -1;
161 uint8_t buf[MAXPACKET] = {};
162 int res = getAsyncResponse(env, fd, TIMEOUT_MS, &rcode, buf, MAXPACKET);
163 if (res != expectedErrno) {
164 LOGD("res:%d, expectedErrno = %d", res, expectedErrno);
165 return (res > 0) ? -EREMOTEIO : res;
166 }
167 return 0;
168 }
169
170 extern "C"
Java_android_net_cts_MultinetworkApiTest_runResNqueryCheck(JNIEnv * env,jclass,jlong nethandle)171 JNIEXPORT void Java_android_net_cts_MultinetworkApiTest_runResNqueryCheck(
172 JNIEnv* env, jclass, jlong nethandle) {
173 net_handle_t handle = (net_handle_t) nethandle;
174
175 // V4
176 int fd = android_res_nquery(handle, kHostname, ns_c_in, ns_t_a, 0);
177 EXPECT_GE(env, fd, 0, "v4 res_nquery");
178 EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_noerror),
179 "v4 res_nquery check answers");
180
181 // V6
182 fd = android_res_nquery(handle, kHostname, ns_c_in, ns_t_aaaa, 0);
183 EXPECT_GE(env, fd, 0, "v6 res_nquery");
184 EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET6, ns_r_noerror),
185 "v6 res_nquery check answers");
186 }
187
188 extern "C"
Java_android_net_cts_MultinetworkApiTest_runResNsendCheck(JNIEnv * env,jclass,jlong nethandle)189 JNIEXPORT void Java_android_net_cts_MultinetworkApiTest_runResNsendCheck(
190 JNIEnv* env, jclass, jlong nethandle) {
191 net_handle_t handle = (net_handle_t) nethandle;
192 // V4
193 uint8_t buf1[MAXPACKET] = {};
194
195 int len1 = makeQuery(kGoogleName, ns_t_a, buf1, sizeof(buf1));
196 EXPECT_GT(env, len1, 0, "v4 res_mkquery 1st");
197
198 uint8_t buf2[MAXPACKET] = {};
199 int len2 = makeQuery(kHostname, ns_t_a, buf2, sizeof(buf2));
200 EXPECT_GT(env, len2, 0, "v4 res_mkquery 2nd");
201
202 int fd1 = android_res_nsend(handle, buf1, len1, 0);
203 EXPECT_GE(env, fd1, 0, "v4 res_nsend 1st");
204 int fd2 = android_res_nsend(handle, buf2, len2, 0);
205 EXPECT_GE(env, fd2, 0, "v4 res_nsend 2nd");
206
207 EXPECT_EQ(env, 0, expectAnswersValid(env, fd2, AF_INET, ns_r_noerror),
208 "v4 res_nsend 2nd check answers");
209 EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET, ns_r_noerror),
210 "v4 res_nsend 1st check answers");
211
212 // V6
213 memset(buf1, 0, sizeof(buf1));
214 memset(buf2, 0, sizeof(buf2));
215 len1 = makeQuery(kGoogleName, ns_t_aaaa, buf1, sizeof(buf1));
216 EXPECT_GT(env, len1, 0, "v6 res_mkquery 1st");
217 len2 = makeQuery(kHostname, ns_t_aaaa, buf2, sizeof(buf2));
218 EXPECT_GT(env, len2, 0, "v6 res_mkquery 2nd");
219
220 fd1 = android_res_nsend(handle, buf1, len1, 0);
221 EXPECT_GE(env, fd1, 0, "v6 res_nsend 1st");
222 fd2 = android_res_nsend(handle, buf2, len2, 0);
223 EXPECT_GE(env, fd2, 0, "v6 res_nsend 2nd");
224
225 EXPECT_EQ(env, 0, expectAnswersValid(env, fd2, AF_INET6, ns_r_noerror),
226 "v6 res_nsend 2nd check answers");
227 EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET6, ns_r_noerror),
228 "v6 res_nsend 1st check answers");
229 }
230
231 extern "C"
Java_android_net_cts_MultinetworkApiTest_runResNnxDomainCheck(JNIEnv * env,jclass,jlong nethandle)232 JNIEXPORT void Java_android_net_cts_MultinetworkApiTest_runResNnxDomainCheck(
233 JNIEnv* env, jclass, jlong nethandle) {
234 net_handle_t handle = (net_handle_t) nethandle;
235
236 // res_nquery V4 NXDOMAIN
237 int fd = android_res_nquery(handle, kNxDomainName, ns_c_in, ns_t_a, 0);
238 EXPECT_GE(env, fd, 0, "v4 res_nquery NXDOMAIN");
239 EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_nxdomain),
240 "v4 res_nquery NXDOMAIN check answers");
241
242 // res_nquery V6 NXDOMAIN
243 fd = android_res_nquery(handle, kNxDomainName, ns_c_in, ns_t_aaaa, 0);
244 EXPECT_GE(env, fd, 0, "v6 res_nquery NXDOMAIN");
245 EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET6, ns_r_nxdomain),
246 "v6 res_nquery NXDOMAIN check answers");
247
248 uint8_t buf[MAXPACKET] = {};
249 // res_nsend V4 NXDOMAIN
250 int len = makeQuery(kNxDomainName, ns_t_a, buf, sizeof(buf));
251 EXPECT_GT(env, len, 0, "v4 res_mkquery NXDOMAIN");
252 fd = android_res_nsend(handle, buf, len, 0);
253 EXPECT_GE(env, fd, 0, "v4 res_nsend NXDOMAIN");
254 EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_nxdomain),
255 "v4 res_nsend NXDOMAIN check answers");
256
257 // res_nsend V6 NXDOMAIN
258 memset(buf, 0, sizeof(buf));
259 len = makeQuery(kNxDomainName, ns_t_aaaa, buf, sizeof(buf));
260 EXPECT_GT(env, len, 0, "v6 res_mkquery NXDOMAIN");
261 fd = android_res_nsend(handle, buf, len, 0);
262 EXPECT_GE(env, fd, 0, "v6 res_nsend NXDOMAIN");
263 EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET6, ns_r_nxdomain),
264 "v6 res_nsend NXDOMAIN check answers");
265 }
266
267
268 extern "C"
Java_android_net_cts_MultinetworkApiTest_runResNcancelCheck(JNIEnv * env,jclass,jlong nethandle)269 JNIEXPORT void Java_android_net_cts_MultinetworkApiTest_runResNcancelCheck(
270 JNIEnv* env, jclass, jlong nethandle) {
271 net_handle_t handle = (net_handle_t) nethandle;
272
273 int fd = android_res_nquery(handle, kGoogleName, ns_c_in, ns_t_a, 0);
274 errno = 0;
275 android_res_cancel(fd);
276 int err = errno;
277 EXPECT_EQ(env, 0, err, "res_cancel");
278 // DO NOT call cancel or result with the same fd more than once,
279 // otherwise it will hit fdsan double-close fd.
280 }
281
282 extern "C"
Java_android_net_cts_MultinetworkApiTest_runResNapiMalformedCheck(JNIEnv * env,jclass,jlong nethandle)283 JNIEXPORT void Java_android_net_cts_MultinetworkApiTest_runResNapiMalformedCheck(
284 JNIEnv* env, jclass, jlong nethandle) {
285 net_handle_t handle = (net_handle_t) nethandle;
286
287 // It is the equivalent of "dig . a", Query with an empty name.
288 int fd = android_res_nquery(handle, "", ns_c_in, ns_t_a, 0);
289 EXPECT_GE(env, fd, 0, "res_nquery root");
290 EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_noerror),
291 "res_nquery root check answers");
292
293 // Label limit 63
294 std::string exceedingLabelQuery = "www." + std::string(70, 'g') + ".com";
295 // Name limit 255
296 std::string exceedingDomainQuery = "www." + std::string(255, 'g') + ".com";
297
298 fd = android_res_nquery(handle, exceedingLabelQuery.c_str(), ns_c_in, ns_t_a, 0);
299 EXPECT_EQ(env, -EMSGSIZE, fd, "res_nquery exceedingLabelQuery");
300 fd = android_res_nquery(handle, exceedingDomainQuery.c_str(), ns_c_in, ns_t_aaaa, 0);
301 EXPECT_EQ(env, -EMSGSIZE, fd, "res_nquery exceedingDomainQuery");
302
303 uint8_t buf[10] = {};
304 // empty BLOB
305 fd = android_res_nsend(handle, buf, 10, 0);
306 EXPECT_GE(env, fd, 0, "res_nsend empty BLOB");
307 EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL),
308 "res_nsend empty BLOB check answers");
309
310 uint8_t largeBuf[2 * MAXPACKET] = {};
311 // A buffer larger than 8KB
312 fd = android_res_nsend(handle, largeBuf, sizeof(largeBuf), 0);
313 EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend buffer larger than 8KB");
314
315 // 5000 bytes filled with 0. This returns EMSGSIZE because FrameworkListener limits the size of
316 // commands to 4096 bytes.
317 fd = android_res_nsend(handle, largeBuf, 5000, 0);
318 EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend 5000 bytes filled with 0");
319
320 // 500 bytes filled with 0
321 fd = android_res_nsend(handle, largeBuf, 500, 0);
322 EXPECT_GE(env, fd, 0, "res_nsend 500 bytes filled with 0");
323 EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL),
324 "res_nsend 500 bytes filled with 0 check answers");
325
326 // 5000 bytes filled with 0xFF
327 uint8_t ffBuf[5001] = {};
328 memset(ffBuf, 0xFF, sizeof(ffBuf));
329 ffBuf[5000] = '\0';
330 fd = android_res_nsend(handle, ffBuf, sizeof(ffBuf), 0);
331 EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend 5000 bytes filled with 0xFF");
332
333 // 500 bytes filled with 0xFF
334 ffBuf[500] = '\0';
335 fd = android_res_nsend(handle, ffBuf, 501, 0);
336 EXPECT_GE(env, fd, 0, "res_nsend 500 bytes filled with 0xFF");
337 EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL),
338 "res_nsend 500 bytes filled with 0xFF check answers");
339 }
340
341 extern "C"
Java_android_net_cts_MultinetworkApiTest_runGetaddrinfoCheck(JNIEnv *,jclass,jlong nethandle)342 JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runGetaddrinfoCheck(
343 JNIEnv*, jclass, jlong nethandle) {
344 net_handle_t handle = (net_handle_t) nethandle;
345 struct addrinfo *res = NULL;
346
347 errno = 0;
348 int rval = android_getaddrinfofornetwork(handle, kHostname, NULL, NULL, &res);
349 const int saved_errno = errno;
350 freeaddrinfo(res);
351
352 LOGD("android_getaddrinfofornetwork(%" PRIu64 ", %s) returned rval=%d errno=%d",
353 handle, kHostname, rval, saved_errno);
354 return rval == 0 ? 0 : -saved_errno;
355 }
356
357 extern "C"
Java_android_net_cts_MultinetworkApiTest_runSetprocnetwork(JNIEnv *,jclass,jlong nethandle)358 JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetprocnetwork(
359 JNIEnv*, jclass, jlong nethandle) {
360 net_handle_t handle = (net_handle_t) nethandle;
361
362 errno = 0;
363 int rval = android_setprocnetwork(handle);
364 const int saved_errno = errno;
365 LOGD("android_setprocnetwork(%" PRIu64 ") returned rval=%d errno=%d",
366 handle, rval, saved_errno);
367 return rval == 0 ? 0 : -saved_errno;
368 }
369
370 extern "C"
Java_android_net_cts_MultinetworkApiTest_runSetsocknetwork(JNIEnv *,jclass,jlong nethandle)371 JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetsocknetwork(
372 JNIEnv*, jclass, jlong nethandle) {
373 net_handle_t handle = (net_handle_t) nethandle;
374
375 errno = 0;
376 int fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
377 if (fd < 0) {
378 LOGD("socket() failed, errno=%d", errno);
379 return -errno;
380 }
381
382 errno = 0;
383 int rval = android_setsocknetwork(handle, fd);
384 const int saved_errno = errno;
385 LOGD("android_setprocnetwork(%" PRIu64 ", %d) returned rval=%d errno=%d",
386 handle, fd, rval, saved_errno);
387 close(fd);
388 return rval == 0 ? 0 : -saved_errno;
389 }
390
391 // Use sizeof("x") - 1 because we need a compile-time constant, and strlen("x")
392 // isn't guaranteed to fold to a constant.
393 static const int kSockaddrStrLen = INET6_ADDRSTRLEN + sizeof("[]:65535") - 1;
394
sockaddr_ntop(const struct sockaddr * sa,socklen_t salen,char * dst,const size_t size)395 void sockaddr_ntop(const struct sockaddr *sa, socklen_t salen, char *dst, const size_t size) {
396 char addrstr[INET6_ADDRSTRLEN];
397 char portstr[sizeof("65535")];
398 char buf[kSockaddrStrLen+1];
399
400 int ret = getnameinfo(sa, salen,
401 addrstr, sizeof(addrstr),
402 portstr, sizeof(portstr),
403 NI_NUMERICHOST | NI_NUMERICSERV);
404 if (ret == 0) {
405 snprintf(buf, sizeof(buf),
406 (sa->sa_family == AF_INET6) ? "[%s]:%s" : "%s:%s",
407 addrstr, portstr);
408 } else {
409 sprintf(buf, "???");
410 }
411
412 strlcpy(dst, buf, size);
413 }
414
415 extern "C"
Java_android_net_cts_MultinetworkApiTest_runDatagramCheck(JNIEnv *,jclass,jlong nethandle)416 JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runDatagramCheck(
417 JNIEnv*, jclass, jlong nethandle) {
418 const struct addrinfo kHints = {
419 .ai_flags = AI_ADDRCONFIG,
420 .ai_family = AF_UNSPEC,
421 .ai_socktype = SOCK_DGRAM,
422 .ai_protocol = IPPROTO_UDP,
423 };
424 struct addrinfo *res = NULL;
425 net_handle_t handle = (net_handle_t) nethandle;
426
427 static const char kPort[] = "443";
428 int rval = android_getaddrinfofornetwork(handle, kHostname, kPort, &kHints, &res);
429 if (rval != 0) {
430 LOGD("android_getaddrinfofornetwork(%llu, %s) returned rval=%d errno=%d",
431 handle, kHostname, rval, errno);
432 freeaddrinfo(res);
433 return -errno;
434 }
435
436 // Rely upon getaddrinfo sorting the best destination to the front.
437 int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
438 if (fd < 0) {
439 LOGD("socket(%d, %d, %d) failed, errno=%d",
440 res->ai_family, res->ai_socktype, res->ai_protocol, errno);
441 freeaddrinfo(res);
442 return -errno;
443 }
444
445 rval = android_setsocknetwork(handle, fd);
446 LOGD("android_setprocnetwork(%llu, %d) returned rval=%d errno=%d",
447 handle, fd, rval, errno);
448 if (rval != 0) {
449 close(fd);
450 freeaddrinfo(res);
451 return -errno;
452 }
453
454 char addrstr[kSockaddrStrLen+1];
455 sockaddr_ntop(res->ai_addr, res->ai_addrlen, addrstr, sizeof(addrstr));
456 LOGD("Attempting connect() to %s ...", addrstr);
457
458 rval = connect(fd, res->ai_addr, res->ai_addrlen);
459 if (rval != 0) {
460 close(fd);
461 freeaddrinfo(res);
462 return -errno;
463 }
464 freeaddrinfo(res);
465
466 struct sockaddr_storage src_addr;
467 socklen_t src_addrlen = sizeof(src_addr);
468 if (getsockname(fd, (struct sockaddr *)&src_addr, &src_addrlen) != 0) {
469 close(fd);
470 return -errno;
471 }
472 sockaddr_ntop((const struct sockaddr *)&src_addr, sizeof(src_addr), addrstr, sizeof(addrstr));
473 LOGD("... from %s", addrstr);
474
475 // Don't let reads or writes block indefinitely.
476 const struct timeval timeo = { 2, 0 }; // 2 seconds
477 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
478 setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
479
480 // For reference see:
481 // https://datatracker.ietf.org/doc/html/draft-ietf-quic-invariants
482 uint8_t quic_packet[1200] = {
483 0xc0, // long header
484 0xaa, 0xda, 0xca, 0xca, // reserved-space version number
485 0x08, // destination connection ID length
486 0, 0, 0, 0, 0, 0, 0, 0, // 64bit connection ID
487 0x00, // source connection ID length
488 };
489
490 arc4random_buf(quic_packet + 6, 8); // random connection ID
491
492 uint8_t response[1500];
493 ssize_t sent, rcvd;
494 static const int MAX_RETRIES = 5;
495 int i, errnum = 0;
496
497 for (i = 0; i < MAX_RETRIES; i++) {
498 sent = send(fd, quic_packet, sizeof(quic_packet), 0);
499 if (sent < (ssize_t)sizeof(quic_packet)) {
500 errnum = errno;
501 LOGD("send(QUIC packet) returned sent=%zd, errno=%d", sent, errnum);
502 close(fd);
503 return -errnum;
504 }
505
506 rcvd = recv(fd, response, sizeof(response), 0);
507 if (rcvd > 0) {
508 break;
509 } else {
510 errnum = errno;
511 LOGD("[%d/%d] recv(QUIC response) returned rcvd=%zd, errno=%d",
512 i + 1, MAX_RETRIES, rcvd, errnum);
513 }
514 }
515 if (rcvd < 15) {
516 LOGD("QUIC UDP %s: sent=%zd but rcvd=%zd, errno=%d", kPort, sent, rcvd, errnum);
517 if (rcvd <= 0) {
518 LOGD("Does this network block UDP port %s?", kPort);
519 }
520 close(fd);
521 return -EPROTO;
522 }
523
524 int conn_id_cmp = memcmp(quic_packet + 6, response + 7, 8);
525 if (conn_id_cmp != 0) {
526 LOGD("sent and received connection IDs do not match");
527 close(fd);
528 return -EPROTO;
529 }
530
531 // TODO: Replace this quick 'n' dirty test with proper QUIC-capable code.
532
533 close(fd);
534 return 0;
535 }
536