quiche.c@ 98341

最後變更在這個檔案從98341是 95312,由 vboxsync 提交於 3 年前
libs/{curl,libxml2}: OSE export fixes, bugref:8515
屬性 svn:eol-style 設為 `native`
檔案大小: 24.2 KB

行
1	/***************************************************************************
2	* _ _ ____ _
3	* Project ___\| \| \| \| _ \\| \|
4	* / __\| \| \| \| \|_) \| \|
5	* \| (__\| \|_\| \| _ <\| \|___
6	* \___\|\___/\|_\| \_\_____\|
7	*
8	* Copyright (C) 1998 - 2022, Daniel Stenberg, <[email protected]>, 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	***************************************************************************/
22
23	#include "curl_setup.h"
24
25	#ifdef USE_QUICHE
26	#include <quiche.h>
27	#include <openssl/err.h>
28	#include <openssl/ssl.h>
29	#include "urldata.h"
30	#include "sendf.h"
31	#include "strdup.h"
32	#include "rand.h"
33	#include "quic.h"
34	#include "strcase.h"
35	#include "multiif.h"
36	#include "connect.h"
37	#include "strerror.h"
38	#include "vquic.h"
39	#include "transfer.h"
40	#include "h2h3.h"
41	#include "vtls/openssl.h"
42	#include "vtls/keylog.h"
43
44	/* The last 3 #include files should be in this order */
45	#include "curl_printf.h"
46	#include "curl_memory.h"
47	#include "memdebug.h"
48
49	#define DEBUG_HTTP3
50	/* #define DEBUG_QUICHE */
51	#ifdef DEBUG_HTTP3
52	#define H3BUGF(x) x
53	#else
54	#define H3BUGF(x) do { } while(0)
55	#endif
56
57	#define QUIC_MAX_STREAMS (256*1024)
58	#define QUIC_MAX_DATA (110241024)
59	#define QUIC_IDLE_TIMEOUT (60 * 1000) /* milliseconds */
60
61	static CURLcode process_ingress(struct Curl_easy *data,
62	curl_socket_t sockfd,
63	struct quicsocket *qs);
64
65	static CURLcode flush_egress(struct Curl_easy *data, curl_socket_t sockfd,
66	struct quicsocket *qs);
67
68	static CURLcode http_request(struct Curl_easy data, const void mem,
69	size_t len);
70	static Curl_recv h3_stream_recv;
71	static Curl_send h3_stream_send;
72
73	static int quiche_getsock(struct Curl_easy *data,
74	struct connectdata conn, curl_socket_t socks)
75	{
76	struct SingleRequest *k = &data->req;
77	int bitmap = GETSOCK_BLANK;
78
79	socks[0] = conn->sock[FIRSTSOCKET];
80
81	/* in a HTTP/2 connection we can basically always get a frame so we should
82	always be ready for one */
83	bitmap \|= GETSOCK_READSOCK(FIRSTSOCKET);
84
85	/* we're still uploading or the HTTP/2 layer wants to send data */
86	if((k->keepon & (KEEP_SEND\|KEEP_SEND_PAUSE)) == KEEP_SEND)
87	bitmap \|= GETSOCK_WRITESOCK(FIRSTSOCKET);
88
89	return bitmap;
90	}
91
92	static CURLcode qs_disconnect(struct Curl_easy *data,
93	struct quicsocket *qs)
94	{
95	DEBUGASSERT(qs);
96	if(qs->conn) {
97	(void)quiche_conn_close(qs->conn, TRUE, 0, NULL, 0);
98	/* flushing the egress is not a failsafe way to deliver all the
99	outstanding packets, but we also don't want to get stuck here... */
100	(void)flush_egress(data, qs->sockfd, qs);
101	quiche_conn_free(qs->conn);
102	qs->conn = NULL;
103	}
104	if(qs->h3config)
105	quiche_h3_config_free(qs->h3config);
106	if(qs->h3c)
107	quiche_h3_conn_free(qs->h3c);
108	if(qs->cfg) {
109	quiche_config_free(qs->cfg);
110	qs->cfg = NULL;
111	}
112	return CURLE_OK;
113	}
114
115	static CURLcode quiche_disconnect(struct Curl_easy *data,
116	struct connectdata *conn,
117	bool dead_connection)
118	{
119	struct quicsocket *qs = conn->quic;
120	(void)dead_connection;
121	return qs_disconnect(data, qs);
122	}
123
124	void Curl_quic_disconnect(struct Curl_easy *data,
125	struct connectdata *conn,
126	int tempindex)
127	{
128	if(conn->transport == TRNSPRT_QUIC)
129	qs_disconnect(data, &conn->hequic[tempindex]);
130	}
131
132	static unsigned int quiche_conncheck(struct Curl_easy *data,
133	struct connectdata *conn,
134	unsigned int checks_to_perform)
135	{
136	(void)data;
137	(void)conn;
138	(void)checks_to_perform;
139	return CONNRESULT_NONE;
140	}
141
142	static CURLcode quiche_do(struct Curl_easy data, bool done)
143	{
144	struct HTTP *stream = data->req.p.http;
145	stream->h3req = FALSE; /* not sent */
146	return Curl_http(data, done);
147	}
148
149	static const struct Curl_handler Curl_handler_http3 = {
150	"HTTPS", /* scheme */
151	ZERO_NULL, /* setup_connection */
152	quiche_do, /* do_it */
153	Curl_http_done, /* done */
154	ZERO_NULL, /* do_more */
155	ZERO_NULL, /* connect_it */
156	ZERO_NULL, /* connecting */
157	ZERO_NULL, /* doing */
158	quiche_getsock, /* proto_getsock */
159	quiche_getsock, /* doing_getsock */
160	ZERO_NULL, /* domore_getsock */
161	quiche_getsock, /* perform_getsock */
162	quiche_disconnect, /* disconnect */
163	ZERO_NULL, /* readwrite */
164	quiche_conncheck, /* connection_check */
165	ZERO_NULL, /* attach connection */
166	PORT_HTTP, /* defport */
167	CURLPROTO_HTTPS, /* protocol */
168	CURLPROTO_HTTP, /* family */
169	PROTOPT_SSL \| PROTOPT_STREAM /* flags */
170	};
171
172	#ifdef DEBUG_QUICHE
173	static void quiche_debug_log(const char line, void argp)
174	{
175	(void)argp;
176	fprintf(stderr, "%s\n", line);
177	}
178	#endif
179
180	static void keylog_callback(const SSL ssl, const char line)
181	{
182	(void)ssl;
183	Curl_tls_keylog_write_line(line);
184	}
185
186	static SSL_CTX quic_ssl_ctx(struct Curl_easy data)
187	{
188	SSL_CTX *ssl_ctx = SSL_CTX_new(TLS_method());
189
190	SSL_CTX_set_alpn_protos(ssl_ctx,
191	(const uint8_t *)QUICHE_H3_APPLICATION_PROTOCOL,
192	sizeof(QUICHE_H3_APPLICATION_PROTOCOL) - 1);
193
194	SSL_CTX_set_default_verify_paths(ssl_ctx);
195
196	/* Open the file if a TLS or QUIC backend has not done this before. */
197	Curl_tls_keylog_open();
198	if(Curl_tls_keylog_enabled()) {
199	SSL_CTX_set_keylog_callback(ssl_ctx, keylog_callback);
200	}
201
202	{
203	struct connectdata *conn = data->conn;
204	const char * const ssl_cafile = conn->ssl_config.CAfile;
205	const char * const ssl_capath = conn->ssl_config.CApath;
206
207	if(conn->ssl_config.verifypeer) {
208	SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER, NULL);
209	/* tell OpenSSL where to find CA certificates that are used to verify
210	the server's certificate. */
211	if(!SSL_CTX_load_verify_locations(ssl_ctx, ssl_cafile, ssl_capath)) {
212	/* Fail if we insist on successfully verifying the server. */
213	failf(data, "error setting certificate verify locations:"
214	" CAfile: %s CApath: %s",
215	ssl_cafile ? ssl_cafile : "none",
216	ssl_capath ? ssl_capath : "none");
217	return NULL;
218	}
219	infof(data, " CAfile: %s", ssl_cafile ? ssl_cafile : "none");
220	infof(data, " CApath: %s", ssl_capath ? ssl_capath : "none");
221	}
222	}
223	return ssl_ctx;
224	}
225
226	static int quic_init_ssl(struct quicsocket qs, struct connectdata conn)
227	{
228	/* this will need some attention when HTTPS proxy over QUIC get fixed */
229	const char * const hostname = conn->host.name;
230
231	DEBUGASSERT(!qs->ssl);
232	qs->ssl = SSL_new(qs->sslctx);
233
234	SSL_set_app_data(qs->ssl, qs);
235
236	/* set SNI */
237	SSL_set_tlsext_host_name(qs->ssl, hostname);
238	return 0;
239	}
240
241
242	CURLcode Curl_quic_connect(struct Curl_easy *data,
243	struct connectdata *conn, curl_socket_t sockfd,
244	int sockindex,
245	const struct sockaddr *addr, socklen_t addrlen)
246	{
247	CURLcode result;
248	struct quicsocket *qs = &conn->hequic[sockindex];
249	char ipbuf[40];
250	int port;
251
252	#ifdef DEBUG_QUICHE
253	/* initialize debug log callback only once */
254	static int debug_log_init = 0;
255	if(!debug_log_init) {
256	quiche_enable_debug_logging(quiche_debug_log, NULL);
257	debug_log_init = 1;
258	}
259	#endif
260
261	(void)addr;
262	(void)addrlen;
263
264	qs->sockfd = sockfd;
265	qs->cfg = quiche_config_new(QUICHE_PROTOCOL_VERSION);
266	if(!qs->cfg) {
267	failf(data, "can't create quiche config");
268	return CURLE_FAILED_INIT;
269	}
270
271	quiche_config_set_max_idle_timeout(qs->cfg, QUIC_IDLE_TIMEOUT);
272	quiche_config_set_initial_max_data(qs->cfg, QUIC_MAX_DATA);
273	quiche_config_set_initial_max_stream_data_bidi_local(qs->cfg, QUIC_MAX_DATA);
274	quiche_config_set_initial_max_stream_data_bidi_remote(qs->cfg,
275	QUIC_MAX_DATA);
276	quiche_config_set_initial_max_stream_data_uni(qs->cfg, QUIC_MAX_DATA);
277	quiche_config_set_initial_max_streams_bidi(qs->cfg, QUIC_MAX_STREAMS);
278	quiche_config_set_initial_max_streams_uni(qs->cfg, QUIC_MAX_STREAMS);
279	quiche_config_set_application_protos(qs->cfg,
280	(uint8_t *)
281	QUICHE_H3_APPLICATION_PROTOCOL,
282	sizeof(QUICHE_H3_APPLICATION_PROTOCOL)
283	- 1);
284
285	qs->sslctx = quic_ssl_ctx(data);
286	if(!qs->sslctx)
287	return CURLE_QUIC_CONNECT_ERROR;
288
289	if(quic_init_ssl(qs, conn))
290	return CURLE_QUIC_CONNECT_ERROR;
291
292	result = Curl_rand(data, qs->scid, sizeof(qs->scid));
293	if(result)
294	return result;
295
296	qs->conn = quiche_conn_new_with_tls((const uint8_t *) qs->scid,
297	sizeof(qs->scid), NULL, 0, addr, addrlen,
298	qs->cfg, qs->ssl, false);
299	if(!qs->conn) {
300	failf(data, "can't create quiche connection");
301	return CURLE_OUT_OF_MEMORY;
302	}
303
304	/* Known to not work on Windows */
305	#if !defined(WIN32) && defined(HAVE_QUICHE_CONN_SET_QLOG_FD)
306	{
307	int qfd;
308	(void)Curl_qlogdir(data, qs->scid, sizeof(qs->scid), &qfd);
309	if(qfd != -1)
310	quiche_conn_set_qlog_fd(qs->conn, qfd,
311	"qlog title", "curl qlog");
312	}
313	#endif
314
315	result = flush_egress(data, sockfd, qs);
316	if(result)
317	return result;
318
319	/* extract the used address as a string */
320	if(!Curl_addr2string((struct sockaddr*)addr, addrlen, ipbuf, &port)) {
321	char buffer[STRERROR_LEN];
322	failf(data, "ssrem inet_ntop() failed with errno %d: %s",
323	SOCKERRNO, Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
324	return CURLE_BAD_FUNCTION_ARGUMENT;
325	}
326
327	infof(data, "Connect socket %d over QUIC to %s:%ld",
328	sockfd, ipbuf, port);
329
330	Curl_persistconninfo(data, conn, NULL, -1);
331
332	/* for connection reuse purposes: */
333	conn->ssl[FIRSTSOCKET].state = ssl_connection_complete;
334
335	{
336	unsigned char alpn_protocols[] = QUICHE_H3_APPLICATION_PROTOCOL;
337	unsigned alpn_len, offset = 0;
338
339	/* Replace each ALPN length prefix by a comma. */
340	while(offset < sizeof(alpn_protocols) - 1) {
341	alpn_len = alpn_protocols[offset];
342	alpn_protocols[offset] = ',';
343	offset += 1 + alpn_len;
344	}
345
346	infof(data, "Sent QUIC client Initial, ALPN: %s",
347	alpn_protocols + 1);
348	}
349
350	return CURLE_OK;
351	}
352
353	static CURLcode quiche_has_connected(struct Curl_easy *data,
354	struct connectdata *conn,
355	int sockindex,
356	int tempindex)
357	{
358	CURLcode result;
359	struct quicsocket *qs = conn->quic = &conn->hequic[tempindex];
360
361	conn->recv[sockindex] = h3_stream_recv;
362	conn->send[sockindex] = h3_stream_send;
363	conn->handler = &Curl_handler_http3;
364	conn->bits.multiplex = TRUE; /* at least potentially multiplexed */
365	conn->httpversion = 30;
366	conn->bundle->multiuse = BUNDLE_MULTIPLEX;
367
368	if(conn->ssl_config.verifyhost) {
369	X509 *server_cert;
370	server_cert = SSL_get_peer_certificate(qs->ssl);
371	if(!server_cert) {
372	return CURLE_PEER_FAILED_VERIFICATION;
373	}
374	result = Curl_ossl_verifyhost(data, conn, server_cert);
375	X509_free(server_cert);
376	if(result)
377	return result;
378	infof(data, "Verified certificate just fine");
379	}
380	else
381	infof(data, "Skipped certificate verification");
382
383	qs->h3config = quiche_h3_config_new();
384	if(!qs->h3config)
385	return CURLE_OUT_OF_MEMORY;
386
387	/* Create a new HTTP/3 connection on the QUIC connection. */
388	qs->h3c = quiche_h3_conn_new_with_transport(qs->conn, qs->h3config);
389	if(!qs->h3c) {
390	result = CURLE_OUT_OF_MEMORY;
391	goto fail;
392	}
393	if(conn->hequic[1-tempindex].cfg) {
394	qs = &conn->hequic[1-tempindex];
395	quiche_config_free(qs->cfg);
396	quiche_conn_free(qs->conn);
397	qs->cfg = NULL;
398	qs->conn = NULL;
399	}
400	return CURLE_OK;
401	fail:
402	quiche_h3_config_free(qs->h3config);
403	quiche_h3_conn_free(qs->h3c);
404	return result;
405	}
406
407	/*
408	* This function gets polled to check if this QUIC connection has connected.
409	*/
410	CURLcode Curl_quic_is_connected(struct Curl_easy *data,
411	struct connectdata *conn,
412	int sockindex,
413	bool *done)
414	{
415	CURLcode result;
416	struct quicsocket *qs = &conn->hequic[sockindex];
417	curl_socket_t sockfd = conn->tempsock[sockindex];
418
419	result = process_ingress(data, sockfd, qs);
420	if(result)
421	goto error;
422
423	result = flush_egress(data, sockfd, qs);
424	if(result)
425	goto error;
426
427	if(quiche_conn_is_established(qs->conn)) {
428	*done = TRUE;
429	result = quiche_has_connected(data, conn, 0, sockindex);
430	DEBUGF(infof(data, "quiche established connection"));
431	}
432
433	return result;
434	error:
435	qs_disconnect(data, qs);
436	return result;
437	}
438
439	static CURLcode process_ingress(struct Curl_easy *data, int sockfd,
440	struct quicsocket *qs)
441	{
442	ssize_t recvd;
443	uint8_t buf = (uint8_t )data->state.buffer;
444	size_t bufsize = data->set.buffer_size;
445	struct sockaddr_storage from;
446	socklen_t from_len;
447	quiche_recv_info recv_info;
448
449	DEBUGASSERT(qs->conn);
450
451	/* in case the timeout expired */
452	quiche_conn_on_timeout(qs->conn);
453
454	do {
455	from_len = sizeof(from);
456
457	recvd = recvfrom(sockfd, buf, bufsize, 0,
458	(struct sockaddr *)&from, &from_len);
459
460	if((recvd < 0) && ((SOCKERRNO == EAGAIN) \|\| (SOCKERRNO == EWOULDBLOCK)))
461	break;
462
463	if(recvd < 0) {
464	failf(data, "quiche: recvfrom() unexpectedly returned %zd "
465	"(errno: %d, socket %d)", recvd, SOCKERRNO, sockfd);
466	return CURLE_RECV_ERROR;
467	}
468
469	recv_info.from = (struct sockaddr *) &from;
470	recv_info.from_len = from_len;
471
472	recvd = quiche_conn_recv(qs->conn, buf, recvd, &recv_info);
473	if(recvd == QUICHE_ERR_DONE)
474	break;
475
476	if(recvd < 0) {
477	if(QUICHE_ERR_TLS_FAIL == recvd) {
478	long verify_ok = SSL_get_verify_result(qs->ssl);
479	if(verify_ok != X509_V_OK) {
480	failf(data, "SSL certificate problem: %s",
481	X509_verify_cert_error_string(verify_ok));
482
483	return CURLE_PEER_FAILED_VERIFICATION;
484	}
485	}
486
487	failf(data, "quiche_conn_recv() == %zd", recvd);
488
489	return CURLE_RECV_ERROR;
490	}
491	} while(1);
492
493	return CURLE_OK;
494	}
495
496	/*
497	* flush_egress drains the buffers and sends off data.
498	* Calls failf() on errors.
499	*/
500	static CURLcode flush_egress(struct Curl_easy *data, int sockfd,
501	struct quicsocket *qs)
502	{
503	ssize_t sent;
504	uint8_t out[1200];
505	int64_t timeout_ns;
506	quiche_send_info send_info;
507
508	do {
509	sent = quiche_conn_send(qs->conn, out, sizeof(out), &send_info);
510	if(sent == QUICHE_ERR_DONE)
511	break;
512
513	if(sent < 0) {
514	failf(data, "quiche_conn_send returned %zd", sent);
515	return CURLE_SEND_ERROR;
516	}
517
518	sent = send(sockfd, out, sent, 0);
519	if(sent < 0) {
520	failf(data, "send() returned %zd", sent);
521	return CURLE_SEND_ERROR;
522	}
523	} while(1);
524
525	/* time until the next timeout event, as nanoseconds. */
526	timeout_ns = quiche_conn_timeout_as_nanos(qs->conn);
527	if(timeout_ns)
528	/* expire uses milliseconds */
529	Curl_expire(data, (timeout_ns + 999999) / 1000000, EXPIRE_QUIC);
530
531	return CURLE_OK;
532	}
533
534	struct h3h1header {
535	char *dest;
536	size_t destlen; /* left to use */
537	size_t nlen; /* used */
538	};
539
540	static int cb_each_header(uint8_t *name, size_t name_len,
541	uint8_t *value, size_t value_len,
542	void *argp)
543	{
544	struct h3h1header headers = (struct h3h1header )argp;
545	size_t olen = 0;
546
547	if((name_len == 7) && !strncmp(H2H3_PSEUDO_STATUS, (char *)name, 7)) {
548	msnprintf(headers->dest,
549	headers->destlen, "HTTP/3 %.*s\n",
550	(int) value_len, value);
551	}
552	else if(!headers->nlen) {
553	return CURLE_HTTP3;
554	}
555	else {
556	msnprintf(headers->dest,
557	headers->destlen, "%.s: %.s\n",
558	(int)name_len, name, (int) value_len, value);
559	}
560	olen = strlen(headers->dest);
561	headers->destlen -= olen;
562	headers->nlen += olen;
563	headers->dest += olen;
564	return 0;
565	}
566
567	static ssize_t h3_stream_recv(struct Curl_easy *data,
568	int sockindex,
569	char *buf,
570	size_t buffersize,
571	CURLcode *curlcode)
572	{
573	ssize_t recvd = -1;
574	ssize_t rcode;
575	struct connectdata *conn = data->conn;
576	struct quicsocket *qs = conn->quic;
577	curl_socket_t sockfd = conn->sock[sockindex];
578	quiche_h3_event *ev;
579	int rc;
580	struct h3h1header headers;
581	struct HTTP *stream = data->req.p.http;
582	headers.dest = buf;
583	headers.destlen = buffersize;
584	headers.nlen = 0;
585
586	if(process_ingress(data, sockfd, qs)) {
587	infof(data, "h3_stream_recv returns on ingress");
588	*curlcode = CURLE_RECV_ERROR;
589	return -1;
590	}
591
592	if(qs->h3_recving) {
593	/* body receiving state */
594	rcode = quiche_h3_recv_body(qs->h3c, qs->conn, stream->stream3_id,
595	(unsigned char *)buf, buffersize);
596	if(rcode <= 0) {
597	recvd = -1;
598	qs->h3_recving = FALSE;
599	/* fall through into the while loop below */
600	}
601	else
602	recvd = rcode;
603	}
604
605	while(recvd < 0) {
606	int64_t s = quiche_h3_conn_poll(qs->h3c, qs->conn, &ev);
607	if(s < 0)
608	/* nothing more to do */
609	break;
610
611	if(s != stream->stream3_id) {
612	/* another transfer, ignore for now */
613	infof(data, "Got h3 for stream %u, expects %u",
614	s, stream->stream3_id);
615	continue;
616	}
617
618	switch(quiche_h3_event_type(ev)) {
619	case QUICHE_H3_EVENT_HEADERS:
620	rc = quiche_h3_event_for_each_header(ev, cb_each_header, &headers);
621	if(rc) {
622	*curlcode = rc;
623	failf(data, "Error in HTTP/3 response header");
624	break;
625	}
626	recvd = headers.nlen;
627	break;
628	case QUICHE_H3_EVENT_DATA:
629	if(!stream->firstbody) {
630	/* add a header-body separator CRLF */
631	buf[0] = '\r';
632	buf[1] = '\n';
633	buf += 2;
634	buffersize -= 2;
635	stream->firstbody = TRUE;
636	recvd = 2; /* two bytes already */
637	}
638	else
639	recvd = 0;
640	rcode = quiche_h3_recv_body(qs->h3c, qs->conn, s, (unsigned char *)buf,
641	buffersize);
642	if(rcode <= 0) {
643	recvd = -1;
644	break;
645	}
646	qs->h3_recving = TRUE;
647	recvd += rcode;
648	break;
649
650	case QUICHE_H3_EVENT_RESET:
651	streamclose(conn, "Stream reset");
652	*curlcode = CURLE_PARTIAL_FILE;
653	return -1;
654
655	case QUICHE_H3_EVENT_FINISHED:
656	streamclose(conn, "End of stream");
657	recvd = 0; /* end of stream */
658	break;
659	default:
660	break;
661	}
662
663	quiche_h3_event_free(ev);
664	}
665	if(flush_egress(data, sockfd, qs)) {
666	*curlcode = CURLE_SEND_ERROR;
667	return -1;
668	}
669
670	*curlcode = (-1 == recvd)? CURLE_AGAIN : CURLE_OK;
671	if(recvd >= 0)
672	/* Get this called again to drain the event queue */
673	Curl_expire(data, 0, EXPIRE_QUIC);
674
675	data->state.drain = (recvd >= 0) ? 1 : 0;
676	return recvd;
677	}
678
679	static ssize_t h3_stream_send(struct Curl_easy *data,
680	int sockindex,
681	const void *mem,
682	size_t len,
683	CURLcode *curlcode)
684	{
685	ssize_t sent;
686	struct connectdata *conn = data->conn;
687	struct quicsocket *qs = conn->quic;
688	curl_socket_t sockfd = conn->sock[sockindex];
689	struct HTTP *stream = data->req.p.http;
690
691	if(!stream->h3req) {
692	CURLcode result = http_request(data, mem, len);
693	if(result) {
694	*curlcode = CURLE_SEND_ERROR;
695	return -1;
696	}
697	sent = len;
698	}
699	else {
700	sent = quiche_h3_send_body(qs->h3c, qs->conn, stream->stream3_id,
701	(uint8_t *)mem, len, FALSE);
702	if(sent == QUICHE_H3_ERR_DONE) {
703	sent = 0;
704	}
705	else if(sent < 0) {
706	*curlcode = CURLE_SEND_ERROR;
707	return -1;
708	}
709	}
710
711	if(flush_egress(data, sockfd, qs)) {
712	*curlcode = CURLE_SEND_ERROR;
713	return -1;
714	}
715
716	*curlcode = CURLE_OK;
717	return sent;
718	}
719
720	/*
721	* Store quiche version info in this buffer.
722	*/
723	void Curl_quic_ver(char *p, size_t len)
724	{
725	(void)msnprintf(p, len, "quiche/%s", quiche_version());
726	}
727
728	/* Index where :authority header field will appear in request header
729	field list. */
730	#define AUTHORITY_DST_IDX 3
731
732	static CURLcode http_request(struct Curl_easy data, const void mem,
733	size_t len)
734	{
735	struct connectdata *conn = data->conn;
736	struct HTTP *stream = data->req.p.http;
737	size_t nheader;
738	int64_t stream3_id;
739	quiche_h3_header *nva = NULL;
740	struct quicsocket *qs = conn->quic;
741	CURLcode result = CURLE_OK;
742	struct h2h3req *hreq = NULL;
743
744	stream->h3req = TRUE; /* senf off! */
745
746	result = Curl_pseudo_headers(data, mem, len, &hreq);
747	if(result)
748	goto fail;
749	nheader = hreq->entries;
750
751	nva = malloc(sizeof(quiche_h3_header) * nheader);
752	if(!nva) {
753	result = CURLE_OUT_OF_MEMORY;
754	goto fail;
755	}
756	else {
757	unsigned int i;
758	for(i = 0; i < nheader; i++) {
759	nva[i].name = (unsigned char *)hreq->header[i].name;
760	nva[i].name_len = hreq->header[i].namelen;
761	nva[i].value = (unsigned char *)hreq->header[i].value;
762	nva[i].value_len = hreq->header[i].valuelen;
763	}
764	}
765
766	switch(data->state.httpreq) {
767	case HTTPREQ_POST:
768	case HTTPREQ_POST_FORM:
769	case HTTPREQ_POST_MIME:
770	case HTTPREQ_PUT:
771	if(data->state.infilesize != -1)
772	stream->upload_left = data->state.infilesize;
773	else
774	/* data sending without specifying the data amount up front */
775	stream->upload_left = -1; /* unknown, but not zero */
776
777	stream3_id = quiche_h3_send_request(qs->h3c, qs->conn, nva, nheader,
778	stream->upload_left ? FALSE: TRUE);
779	if((stream3_id >= 0) && data->set.postfields) {
780	ssize_t sent = quiche_h3_send_body(qs->h3c, qs->conn, stream3_id,
781	(uint8_t *)data->set.postfields,
782	stream->upload_left, TRUE);
783	if(sent <= 0) {
784	failf(data, "quiche_h3_send_body failed");
785	result = CURLE_SEND_ERROR;
786	}
787	stream->upload_left = 0; /* nothing left to send */
788	}
789	break;
790	default:
791	stream3_id = quiche_h3_send_request(qs->h3c, qs->conn, nva, nheader,
792	TRUE);
793	break;
794	}
795
796	Curl_safefree(nva);
797
798	if(stream3_id < 0) {
799	H3BUGF(infof(data, "quiche_h3_send_request returned %d",
800	stream3_id));
801	result = CURLE_SEND_ERROR;
802	goto fail;
803	}
804
805	infof(data, "Using HTTP/3 Stream ID: %x (easy handle %p)",
806	stream3_id, (void *)data);
807	stream->stream3_id = stream3_id;
808
809	Curl_pseudo_free(hreq);
810	return CURLE_OK;
811
812	fail:
813	free(nva);
814	Curl_pseudo_free(hreq);
815	return result;
816	}
817
818	/*
819	* Called from transfer.c:done_sending when we stop HTTP/3 uploading.
820	*/
821	CURLcode Curl_quic_done_sending(struct Curl_easy *data)
822	{
823	struct connectdata *conn = data->conn;
824	DEBUGASSERT(conn);
825	if(conn->handler == &Curl_handler_http3) {
826	/* only for HTTP/3 transfers */
827	ssize_t sent;
828	struct HTTP *stream = data->req.p.http;
829	struct quicsocket *qs = conn->quic;
830	stream->upload_done = TRUE;
831	sent = quiche_h3_send_body(qs->h3c, qs->conn, stream->stream3_id,
832	NULL, 0, TRUE);
833	if(sent < 0)
834	return CURLE_SEND_ERROR;
835	}
836
837	return CURLE_OK;
838	}
839
840	/*
841	* Called from http.c:Curl_http_done when a request completes.
842	*/
843	void Curl_quic_done(struct Curl_easy *data, bool premature)
844	{
845	(void)data;
846	(void)premature;
847	}
848
849	/*
850	* Called from transfer.c:data_pending to know if we should keep looping
851	* to receive more data from the connection.
852	*/
853	bool Curl_quic_data_pending(const struct Curl_easy *data)
854	{
855	(void)data;
856	return FALSE;
857	}
858
859	#endif

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/curl-7.83.1/lib/vquic/quiche.c@ 98341

以其他格式下載: