VirtualBox

source: vbox/trunk/src/libs/curl-8.7.1/lib/vquic/vquic.c@ 104773

Last change on this file since 104773 was 104083, checked in by vboxsync, 11 months ago

curl-8.7.1: Applied and adjusted our curl changes to 8.4.0. bugref:10639
  • Property svn:eol-style set to native
File size: 19.6 KB
Line 
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24
25/* WIP, experimental: use recvmmsg() on linux
26 * we have no configure check, yet
27 * and also it is only available for _GNU_SOURCE, which
28 * we do not use otherwise.
29#define HAVE_SENDMMSG
30 */
31#if defined(HAVE_SENDMMSG)
32#define _GNU_SOURCE
33#include <sys/socket.h>
34#undef _GNU_SOURCE
35#endif
36
37#include "curl_setup.h"
38
39#ifdef HAVE_FCNTL_H
40#include <fcntl.h>
41#endif
42#include "urldata.h"
43#include "bufq.h"
44#include "dynbuf.h"
45#include "cfilters.h"
46#include "curl_trc.h"
47#include "curl_msh3.h"
48#include "curl_ngtcp2.h"
49#include "curl_osslq.h"
50#include "curl_quiche.h"
51#include "rand.h"
52#include "vquic.h"
53#include "vquic_int.h"
54#include "strerror.h"
55
56/* The last 3 #include files should be in this order */
57#include "curl_printf.h"
58#include "curl_memory.h"
59#include "memdebug.h"
60
61
62#ifdef ENABLE_QUIC
63
64#ifdef O_BINARY
65#define QLOGMODE O_WRONLY|O_CREAT|O_BINARY
66#else
67#define QLOGMODE O_WRONLY|O_CREAT
68#endif
69
70#define NW_CHUNK_SIZE (64 * 1024)
71#define NW_SEND_CHUNKS 2
72
73
74void Curl_quic_ver(char *p, size_t len)
75{
76#if defined(USE_NGTCP2) && defined(USE_NGHTTP3)
77 Curl_ngtcp2_ver(p, len);
78#elif defined(USE_OPENSSL_QUIC) && defined(USE_NGHTTP3)
79 Curl_osslq_ver(p, len);
80#elif defined(USE_QUICHE)
81 Curl_quiche_ver(p, len);
82#elif defined(USE_MSH3)
83 Curl_msh3_ver(p, len);
84#endif
85}
86
87CURLcode vquic_ctx_init(struct cf_quic_ctx *qctx)
88{
89 Curl_bufq_init2(&qctx->sendbuf, NW_CHUNK_SIZE, NW_SEND_CHUNKS,
90 BUFQ_OPT_SOFT_LIMIT);
91#if defined(__linux__) && defined(UDP_SEGMENT) && defined(HAVE_SENDMSG)
92 qctx->no_gso = FALSE;
93#else
94 qctx->no_gso = TRUE;
95#endif
96#ifdef DEBUGBUILD
97 {
98 char *p = getenv("CURL_DBG_QUIC_WBLOCK");
99 if(p) {
100 long l = strtol(p, NULL, 10);
101 if(l >= 0 && l <= 100)
102 qctx->wblock_percent = (int)l;
103 }
104 }
105#endif
106 vquic_ctx_update_time(qctx);
107
108 return CURLE_OK;
109}
110
111void vquic_ctx_free(struct cf_quic_ctx *qctx)
112{
113 Curl_bufq_free(&qctx->sendbuf);
114}
115
116void vquic_ctx_update_time(struct cf_quic_ctx *qctx)
117{
118 qctx->last_op = Curl_now();
119}
120
121static CURLcode send_packet_no_gso(struct Curl_cfilter *cf,
122 struct Curl_easy *data,
123 struct cf_quic_ctx *qctx,
124 const uint8_t *pkt, size_t pktlen,
125 size_t gsolen, size_t *psent);
126
127static CURLcode do_sendmsg(struct Curl_cfilter *cf,
128 struct Curl_easy *data,
129 struct cf_quic_ctx *qctx,
130 const uint8_t *pkt, size_t pktlen, size_t gsolen,
131 size_t *psent)
132{
133#ifdef HAVE_SENDMSG
134 struct iovec msg_iov;
135 struct msghdr msg = {0};
136 ssize_t sent;
137#if defined(__linux__) && defined(UDP_SEGMENT)
138 uint8_t msg_ctrl[32];
139 struct cmsghdr *cm;
140#endif
141
142 *psent = 0;
143 msg_iov.iov_base = (uint8_t *)pkt;
144 msg_iov.iov_len = pktlen;
145 msg.msg_iov = &msg_iov;
146 msg.msg_iovlen = 1;
147
148#if defined(__linux__) && defined(UDP_SEGMENT)
149 if(pktlen > gsolen) {
150 /* Only set this, when we need it. macOS, for example,
151 * does not seem to like a msg_control of length 0. */
152 msg.msg_control = msg_ctrl;
153 assert(sizeof(msg_ctrl) >= CMSG_SPACE(sizeof(uint16_t)));
154 msg.msg_controllen = CMSG_SPACE(sizeof(uint16_t));
155 cm = CMSG_FIRSTHDR(&msg);
156 cm->cmsg_level = SOL_UDP;
157 cm->cmsg_type = UDP_SEGMENT;
158 cm->cmsg_len = CMSG_LEN(sizeof(uint16_t));
159 *(uint16_t *)(void *)CMSG_DATA(cm) = gsolen & 0xffff;
160 }
161#endif
162
163
164 while((sent = sendmsg(qctx->sockfd, &msg, 0)) == -1 && SOCKERRNO == EINTR)
165 ;
166
167 if(sent == -1) {
168 switch(SOCKERRNO) {
169 case EAGAIN:
170#if EAGAIN != EWOULDBLOCK
171 case EWOULDBLOCK:
172#endif
173 return CURLE_AGAIN;
174 case EMSGSIZE:
175 /* UDP datagram is too large; caused by PMTUD. Just let it be lost. */
176 break;
177 case EIO:
178 if(pktlen > gsolen) {
179 /* GSO failure */
180 failf(data, "sendmsg() returned %zd (errno %d); disable GSO", sent,
181 SOCKERRNO);
182 qctx->no_gso = TRUE;
183 return send_packet_no_gso(cf, data, qctx, pkt, pktlen, gsolen, psent);
184 }
185 FALLTHROUGH();
186 default:
187 failf(data, "sendmsg() returned %zd (errno %d)", sent, SOCKERRNO);
188 return CURLE_SEND_ERROR;
189 }
190 }
191 else {
192 assert(pktlen == (size_t)sent);
193 }
194#else
195 ssize_t sent;
196 (void)gsolen;
197
198 *psent = 0;
199
200 while((sent = send(qctx->sockfd,
201 (const char *)pkt, (SEND_TYPE_ARG3)pktlen, 0)) == -1 &&
202 SOCKERRNO == EINTR)
203 ;
204
205 if(sent == -1) {
206 if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK) {
207 return CURLE_AGAIN;
208 }
209 else {
210 failf(data, "send() returned %zd (errno %d)", sent, SOCKERRNO);
211 if(SOCKERRNO != EMSGSIZE) {
212 return CURLE_SEND_ERROR;
213 }
214 /* UDP datagram is too large; caused by PMTUD. Just let it be
215 lost. */
216 }
217 }
218#endif
219 (void)cf;
220 *psent = pktlen;
221
222 return CURLE_OK;
223}
224
225static CURLcode send_packet_no_gso(struct Curl_cfilter *cf,
226 struct Curl_easy *data,
227 struct cf_quic_ctx *qctx,
228 const uint8_t *pkt, size_t pktlen,
229 size_t gsolen, size_t *psent)
230{
231 const uint8_t *p, *end = pkt + pktlen;
232 size_t sent;
233
234 *psent = 0;
235
236 for(p = pkt; p < end; p += gsolen) {
237 size_t len = CURLMIN(gsolen, (size_t)(end - p));
238 CURLcode curlcode = do_sendmsg(cf, data, qctx, p, len, len, &sent);
239 if(curlcode != CURLE_OK) {
240 return curlcode;
241 }
242 *psent += sent;
243 }
244
245 return CURLE_OK;
246}
247
248static CURLcode vquic_send_packets(struct Curl_cfilter *cf,
249 struct Curl_easy *data,
250 struct cf_quic_ctx *qctx,
251 const uint8_t *pkt, size_t pktlen,
252 size_t gsolen, size_t *psent)
253{
254 CURLcode result;
255#ifdef DEBUGBUILD
256 /* simulate network blocking/partial writes */
257 if(qctx->wblock_percent > 0) {
258 unsigned char c;
259 Curl_rand(data, &c, 1);
260 if(c >= ((100-qctx->wblock_percent)*256/100)) {
261 CURL_TRC_CF(data, cf, "vquic_flush() simulate EWOULDBLOCK");
262 return CURLE_AGAIN;
263 }
264 }
265#endif
266 if(qctx->no_gso && pktlen > gsolen) {
267 result = send_packet_no_gso(cf, data, qctx, pkt, pktlen, gsolen, psent);
268 }
269 else {
270 result = do_sendmsg(cf, data, qctx, pkt, pktlen, gsolen, psent);
271 }
272 if(!result)
273 qctx->last_io = qctx->last_op;
274 return result;
275}
276
277CURLcode vquic_flush(struct Curl_cfilter *cf, struct Curl_easy *data,
278 struct cf_quic_ctx *qctx)
279{
280 const unsigned char *buf;
281 size_t blen, sent;
282 CURLcode result;
283 size_t gsolen;
284
285 while(Curl_bufq_peek(&qctx->sendbuf, &buf, &blen)) {
286 gsolen = qctx->gsolen;
287 if(qctx->split_len) {
288 gsolen = qctx->split_gsolen;
289 if(blen > qctx->split_len)
290 blen = qctx->split_len;
291 }
292
293 result = vquic_send_packets(cf, data, qctx, buf, blen, gsolen, &sent);
294 CURL_TRC_CF(data, cf, "vquic_send(len=%zu, gso=%zu) -> %d, sent=%zu",
295 blen, gsolen, result, sent);
296 if(result) {
297 if(result == CURLE_AGAIN) {
298 Curl_bufq_skip(&qctx->sendbuf, sent);
299 if(qctx->split_len)
300 qctx->split_len -= sent;
301 }
302 return result;
303 }
304 Curl_bufq_skip(&qctx->sendbuf, sent);
305 if(qctx->split_len)
306 qctx->split_len -= sent;
307 }
308 return CURLE_OK;
309}
310
311CURLcode vquic_send(struct Curl_cfilter *cf, struct Curl_easy *data,
312 struct cf_quic_ctx *qctx, size_t gsolen)
313{
314 qctx->gsolen = gsolen;
315 return vquic_flush(cf, data, qctx);
316}
317
318CURLcode vquic_send_tail_split(struct Curl_cfilter *cf, struct Curl_easy *data,
319 struct cf_quic_ctx *qctx, size_t gsolen,
320 size_t tail_len, size_t tail_gsolen)
321{
322 DEBUGASSERT(Curl_bufq_len(&qctx->sendbuf) > tail_len);
323 qctx->split_len = Curl_bufq_len(&qctx->sendbuf) - tail_len;
324 qctx->split_gsolen = gsolen;
325 qctx->gsolen = tail_gsolen;
326 CURL_TRC_CF(data, cf, "vquic_send_tail_split: [%zu gso=%zu][%zu gso=%zu]",
327 qctx->split_len, qctx->split_gsolen,
328 tail_len, qctx->gsolen);
329 return vquic_flush(cf, data, qctx);
330}
331
332#ifdef HAVE_SENDMMSG
333static CURLcode recvmmsg_packets(struct Curl_cfilter *cf,
334 struct Curl_easy *data,
335 struct cf_quic_ctx *qctx,
336 size_t max_pkts,
337 vquic_recv_pkt_cb *recv_cb, void *userp)
338{
339#define MMSG_NUM 64
340 struct iovec msg_iov[MMSG_NUM];
341 struct mmsghdr mmsg[MMSG_NUM];
342 uint8_t bufs[MMSG_NUM][2*1024];
343 struct sockaddr_storage remote_addr[MMSG_NUM];
344 size_t total_nread, pkts;
345 int mcount, i, n;
346 char errstr[STRERROR_LEN];
347 CURLcode result = CURLE_OK;
348
349 DEBUGASSERT(max_pkts > 0);
350 pkts = 0;
351 total_nread = 0;
352 while(pkts < max_pkts) {
353 n = (int)CURLMIN(MMSG_NUM, max_pkts);
354 memset(&mmsg, 0, sizeof(mmsg));
355 for(i = 0; i < n; ++i) {
356 msg_iov[i].iov_base = bufs[i];
357 msg_iov[i].iov_len = (int)sizeof(bufs[i]);
358 mmsg[i].msg_hdr.msg_iov = &msg_iov[i];
359 mmsg[i].msg_hdr.msg_iovlen = 1;
360 mmsg[i].msg_hdr.msg_name = &remote_addr[i];
361 mmsg[i].msg_hdr.msg_namelen = sizeof(remote_addr[i]);
362 }
363
364 while((mcount = recvmmsg(qctx->sockfd, mmsg, n, 0, NULL)) == -1 &&
365 SOCKERRNO == EINTR)
366 ;
367 if(mcount == -1) {
368 if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK) {
369 CURL_TRC_CF(data, cf, "ingress, recvmmsg -> EAGAIN");
370 goto out;
371 }
372 if(!cf->connected && SOCKERRNO == ECONNREFUSED) {
373 struct ip_quadruple ip;
374 Curl_cf_socket_peek(cf->next, data, NULL, NULL, &ip);
375 failf(data, "QUIC: connection to %s port %u refused",
376 ip.remote_ip, ip.remote_port);
377 result = CURLE_COULDNT_CONNECT;
378 goto out;
379 }
380 Curl_strerror(SOCKERRNO, errstr, sizeof(errstr));
381 failf(data, "QUIC: recvmsg() unexpectedly returned %d (errno=%d; %s)",
382 mcount, SOCKERRNO, errstr);
383 result = CURLE_RECV_ERROR;
384 goto out;
385 }
386
387 CURL_TRC_CF(data, cf, "recvmmsg() -> %d packets", mcount);
388 pkts += mcount;
389 for(i = 0; i < mcount; ++i) {
390 total_nread += mmsg[i].msg_len;
391 result = recv_cb(bufs[i], mmsg[i].msg_len,
392 mmsg[i].msg_hdr.msg_name, mmsg[i].msg_hdr.msg_namelen,
393 0, userp);
394 if(result)
395 goto out;
396 }
397 }
398
399out:
400 if(total_nread || result)
401 CURL_TRC_CF(data, cf, "recvd %zu packets with %zu bytes -> %d",
402 pkts, total_nread, result);
403 return result;
404}
405
406#elif defined(HAVE_SENDMSG)
407static CURLcode recvmsg_packets(struct Curl_cfilter *cf,
408 struct Curl_easy *data,
409 struct cf_quic_ctx *qctx,
410 size_t max_pkts,
411 vquic_recv_pkt_cb *recv_cb, void *userp)
412{
413 struct iovec msg_iov;
414 struct msghdr msg;
415 uint8_t buf[64*1024];
416 struct sockaddr_storage remote_addr;
417 size_t total_nread, pkts;
418 ssize_t nread;
419 char errstr[STRERROR_LEN];
420 CURLcode result = CURLE_OK;
421
422 msg_iov.iov_base = buf;
423 msg_iov.iov_len = (int)sizeof(buf);
424
425 memset(&msg, 0, sizeof(msg));
426 msg.msg_iov = &msg_iov;
427 msg.msg_iovlen = 1;
428
429 DEBUGASSERT(max_pkts > 0);
430 for(pkts = 0, total_nread = 0; pkts < max_pkts;) {
431 msg.msg_name = &remote_addr;
432 msg.msg_namelen = sizeof(remote_addr);
433 while((nread = recvmsg(qctx->sockfd, &msg, 0)) == -1 &&
434 SOCKERRNO == EINTR)
435 ;
436 if(nread == -1) {
437 if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK) {
438 goto out;
439 }
440 if(!cf->connected && SOCKERRNO == ECONNREFUSED) {
441 struct ip_quadruple ip;
442 Curl_cf_socket_peek(cf->next, data, NULL, NULL, &ip);
443 failf(data, "QUIC: connection to %s port %u refused",
444 ip.remote_ip, ip.remote_port);
445 result = CURLE_COULDNT_CONNECT;
446 goto out;
447 }
448 Curl_strerror(SOCKERRNO, errstr, sizeof(errstr));
449 failf(data, "QUIC: recvmsg() unexpectedly returned %zd (errno=%d; %s)",
450 nread, SOCKERRNO, errstr);
451 result = CURLE_RECV_ERROR;
452 goto out;
453 }
454
455 ++pkts;
456 total_nread += (size_t)nread;
457 result = recv_cb(buf, (size_t)nread, msg.msg_name, msg.msg_namelen,
458 0, userp);
459 if(result)
460 goto out;
461 }
462
463out:
464 if(total_nread || result)
465 CURL_TRC_CF(data, cf, "recvd %zu packets with %zu bytes -> %d",
466 pkts, total_nread, result);
467 return result;
468}
469
470#else /* HAVE_SENDMMSG || HAVE_SENDMSG */
471static CURLcode recvfrom_packets(struct Curl_cfilter *cf,
472 struct Curl_easy *data,
473 struct cf_quic_ctx *qctx,
474 size_t max_pkts,
475 vquic_recv_pkt_cb *recv_cb, void *userp)
476{
477 uint8_t buf[64*1024];
478 int bufsize = (int)sizeof(buf);
479 struct sockaddr_storage remote_addr;
480 socklen_t remote_addrlen = sizeof(remote_addr);
481 size_t total_nread, pkts;
482 ssize_t nread;
483 char errstr[STRERROR_LEN];
484 CURLcode result = CURLE_OK;
485
486 DEBUGASSERT(max_pkts > 0);
487 for(pkts = 0, total_nread = 0; pkts < max_pkts;) {
488 while((nread = recvfrom(qctx->sockfd, (char *)buf, bufsize, 0,
489 (struct sockaddr *)&remote_addr,
490 &remote_addrlen)) == -1 &&
491 SOCKERRNO == EINTR)
492 ;
493 if(nread == -1) {
494 if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK) {
495 CURL_TRC_CF(data, cf, "ingress, recvfrom -> EAGAIN");
496 goto out;
497 }
498 if(!cf->connected && SOCKERRNO == ECONNREFUSED) {
499 struct ip_quadruple ip;
500 Curl_cf_socket_peek(cf->next, data, NULL, NULL, &ip);
501 failf(data, "QUIC: connection to %s port %u refused",
502 ip.remote_ip, ip.remote_port);
503 result = CURLE_COULDNT_CONNECT;
504 goto out;
505 }
506 Curl_strerror(SOCKERRNO, errstr, sizeof(errstr));
507 failf(data, "QUIC: recvfrom() unexpectedly returned %zd (errno=%d; %s)",
508 nread, SOCKERRNO, errstr);
509 result = CURLE_RECV_ERROR;
510 goto out;
511 }
512
513 ++pkts;
514 total_nread += (size_t)nread;
515 result = recv_cb(buf, (size_t)nread, &remote_addr, remote_addrlen,
516 0, userp);
517 if(result)
518 goto out;
519 }
520
521out:
522 if(total_nread || result)
523 CURL_TRC_CF(data, cf, "recvd %zu packets with %zu bytes -> %d",
524 pkts, total_nread, result);
525 return result;
526}
527#endif /* !HAVE_SENDMMSG && !HAVE_SENDMSG */
528
529CURLcode vquic_recv_packets(struct Curl_cfilter *cf,
530 struct Curl_easy *data,
531 struct cf_quic_ctx *qctx,
532 size_t max_pkts,
533 vquic_recv_pkt_cb *recv_cb, void *userp)
534{
535 CURLcode result;
536#if defined(HAVE_SENDMMSG)
537 result = recvmmsg_packets(cf, data, qctx, max_pkts, recv_cb, userp);
538#elif defined(HAVE_SENDMSG)
539 result = recvmsg_packets(cf, data, qctx, max_pkts, recv_cb, userp);
540#else
541 result = recvfrom_packets(cf, data, qctx, max_pkts, recv_cb, userp);
542#endif
543 if(!result) {
544 if(!qctx->got_first_byte) {
545 qctx->got_first_byte = TRUE;
546 qctx->first_byte_at = qctx->last_op;
547 }
548 qctx->last_io = qctx->last_op;
549 }
550 return result;
551}
552
553/*
554 * If the QLOGDIR environment variable is set, open and return a file
555 * descriptor to write the log to.
556 *
557 * This function returns error if something failed outside of failing to
558 * create the file. Open file success is deemed by seeing if the returned fd
559 * is != -1.
560 */
561CURLcode Curl_qlogdir(struct Curl_easy *data,
562 unsigned char *scid,
563 size_t scidlen,
564 int *qlogfdp)
565{
566 const char *qlog_dir = getenv("QLOGDIR");
567 *qlogfdp = -1;
568 if(qlog_dir) {
569 struct dynbuf fname;
570 CURLcode result;
571 unsigned int i;
572 Curl_dyn_init(&fname, DYN_QLOG_NAME);
573 result = Curl_dyn_add(&fname, qlog_dir);
574 if(!result)
575 result = Curl_dyn_add(&fname, "/");
576 for(i = 0; (i < scidlen) && !result; i++) {
577 char hex[3];
578 msnprintf(hex, 3, "%02x", scid[i]);
579 result = Curl_dyn_add(&fname, hex);
580 }
581 if(!result)
582 result = Curl_dyn_add(&fname, ".sqlog");
583
584 if(!result) {
585 int qlogfd = open(Curl_dyn_ptr(&fname), QLOGMODE,
586 data->set.new_file_perms);
587 if(qlogfd != -1)
588 *qlogfdp = qlogfd;
589 }
590 Curl_dyn_free(&fname);
591 if(result)
592 return result;
593 }
594
595 return CURLE_OK;
596}
597
598CURLcode Curl_cf_quic_create(struct Curl_cfilter **pcf,
599 struct Curl_easy *data,
600 struct connectdata *conn,
601 const struct Curl_addrinfo *ai,
602 int transport)
603{
604 (void)transport;
605 DEBUGASSERT(transport == TRNSPRT_QUIC);
606#if defined(USE_NGTCP2) && defined(USE_NGHTTP3)
607 return Curl_cf_ngtcp2_create(pcf, data, conn, ai);
608#elif defined(USE_OPENSSL_QUIC) && defined(USE_NGHTTP3)
609 return Curl_cf_osslq_create(pcf, data, conn, ai);
610#elif defined(USE_QUICHE)
611 return Curl_cf_quiche_create(pcf, data, conn, ai);
612#elif defined(USE_MSH3)
613 return Curl_cf_msh3_create(pcf, data, conn, ai);
614#else
615 *pcf = NULL;
616 (void)data;
617 (void)conn;
618 (void)ai;
619 return CURLE_NOT_BUILT_IN;
620#endif
621}
622
623bool Curl_conn_is_http3(const struct Curl_easy *data,
624 const struct connectdata *conn,
625 int sockindex)
626{
627#if defined(USE_NGTCP2) && defined(USE_NGHTTP3)
628 return Curl_conn_is_ngtcp2(data, conn, sockindex);
629#elif defined(USE_OPENSSL_QUIC) && defined(USE_NGHTTP3)
630 return Curl_conn_is_osslq(data, conn, sockindex);
631#elif defined(USE_QUICHE)
632 return Curl_conn_is_quiche(data, conn, sockindex);
633#elif defined(USE_MSH3)
634 return Curl_conn_is_msh3(data, conn, sockindex);
635#else
636 return ((conn->handler->protocol & PROTO_FAMILY_HTTP) &&
637 (conn->httpversion == 30));
638#endif
639}
640
641CURLcode Curl_conn_may_http3(struct Curl_easy *data,
642 const struct connectdata *conn)
643{
644 if(conn->transport == TRNSPRT_UNIX) {
645 /* cannot do QUIC over a unix domain socket */
646 return CURLE_QUIC_CONNECT_ERROR;
647 }
648 if(!(conn->handler->flags & PROTOPT_SSL)) {
649 failf(data, "HTTP/3 requested for non-HTTPS URL");
650 return CURLE_URL_MALFORMAT;
651 }
652#ifndef CURL_DISABLE_PROXY
653 if(conn->bits.socksproxy) {
654 failf(data, "HTTP/3 is not supported over a SOCKS proxy");
655 return CURLE_URL_MALFORMAT;
656 }
657 if(conn->bits.httpproxy && conn->bits.tunnel_proxy) {
658 failf(data, "HTTP/3 is not supported over a HTTP proxy");
659 return CURLE_URL_MALFORMAT;
660 }
661#endif
662
663 return CURLE_OK;
664}
665
666#else /* ENABLE_QUIC */
667
668CURLcode Curl_conn_may_http3(struct Curl_easy *data,
669 const struct connectdata *conn)
670{
671 (void)conn;
672 (void)data;
673 DEBUGF(infof(data, "QUIC is not supported in this build"));
674 return CURLE_NOT_BUILT_IN;
675}
676
677#endif /* !ENABLE_QUIC */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette