Lines Matching refs:data
171 struct Curl_easy *data)
174 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
176 if(!data || !data->req.p.http) {
177 failf(data, "initialization failure, transfer not http initialized");
200 H3_STREAM_LCTX(data) = stream;
204 static void h3_data_done(struct Curl_cfilter *cf, struct Curl_easy *data)
207 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
211 CURL_TRC_CF(data, cf, "[%"PRId64"] easy handle is done", stream->id);
225 H3_STREAM_LCTX(data) = NULL;
230 struct Curl_easy *data,
236 if(H3_STREAM_ID(data) == stream_id) {
237 return data;
240 DEBUGASSERT(data->multi);
241 for(sdata = data->multi->easyp; sdata; sdata = sdata->next) {
242 if((sdata->conn == data->conn) && H3_STREAM_ID(sdata) == stream_id) {
251 struct Curl_easy *data)
253 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
260 if(data->state.select_bits != bits) {
261 data->state.select_bits = bits;
262 Curl_expire(data, 0, EXPIRE_RUN_NOW);
272 struct Curl_easy *data;
290 struct Curl_easy *data)
293 pktx->data = data;
300 struct Curl_easy *data,
303 struct Curl_easy *data,
332 const void *data, size_t datalen)
338 ssize_t rc = write(ctx->qlogfd, data, datalen);
349 struct Curl_easy *data,
363 (void)data;
391 struct Curl_easy *data,
394 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
412 CURL_TRC_CF(data, cf, "[%" PRId64 "] ACK %zu bytes of DATA",
429 struct Curl_easy *data = stream_user_data;
431 (void)data;
435 CURL_TRC_CF(data, cf, "[%" PRId64 "] read_stream(len=%zu) -> %zd",
438 if(!data) {
486 struct Curl_easy *data = stream_user_data;
491 (void)data;
500 CURL_TRC_CF(data, cf, "[%" PRId64 "] quic close(err=%"
517 struct Curl_easy *data = stream_user_data;
522 (void)data;
525 CURL_TRC_CF(data, cf, "[%" PRId64 "] reset -> %d", stream_id, rv);
569 struct Curl_easy *data = CF_DATA_CURRENT(cf);
581 s_data = get_stream_easy(cf, data, stream_id);
584 CURL_TRC_CF(data, cf, "[%" PRId64 "] unblock quic flow", stream_id);
586 h3_drain_stream(cf, data);
613 result = Curl_rand(NULL, cid->data, cidlen);
693 struct Curl_easy *data,
701 pktx_init(&local_pktx, cf, data);
714 failf(data, "ngtcp2_conn_handle_expiry returned error: %s",
719 result = cf_progress_ingress(cf, data, pktx);
722 result = cf_progress_egress(cf, data, pktx);
734 Curl_expire(data, timeout / NGTCP2_MILLISECONDS, EXPIRE_QUIC);
741 struct Curl_easy *data,
750 Curl_pollset_check(data, ps, ctx->q.sockfd, &want_recv, &want_send);
752 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
756 CF_DATA_SAVE(save, cf, data);
765 Curl_pollset_set(data, ps, ctx->q.sockfd, want_recv, want_send);
775 struct Curl_easy *data = stream_user_data;
776 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
789 CURL_TRC_CF(data, cf, "[%" PRId64 "] RESET: error %" PRId64,
793 CURL_TRC_CF(data, cf, "[%" PRId64 "] CLOSED", stream->id);
795 h3_drain_stream(cf, data);
800 * write_resp_raw() copies response data in raw format to the `data`'s
802 * `data`'s overflow buffer.
805 struct Curl_easy *data,
809 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
839 struct Curl_easy *data = stream_user_data;
840 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
849 result = write_resp_raw(cf, data, buf, buflen, TRUE);
851 CURL_TRC_CF(data, cf, "[%" PRId64 "] DATA len=%zu, ERROR receiving %d",
855 CURL_TRC_CF(data, cf, "[%" PRId64 "] DATA len=%zu", stream->id, buflen);
856 h3_drain_stream(cf, data);
880 struct Curl_easy *data = stream_user_data;
881 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
891 result = write_resp_raw(cf, data, "\r\n", 2, FALSE);
896 CURL_TRC_CF(data, cf, "[%" PRId64 "] end_headers, status=%d",
901 h3_drain_stream(cf, data);
913 struct Curl_easy *data = stream_user_data;
914 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
936 CURL_TRC_CF(data, cf, "[%" PRId64 "] status: %s", stream_id, line);
937 result = write_resp_raw(cf, data, line, ncopy, FALSE);
944 CURL_TRC_CF(data, cf, "[%" PRId64 "] header: %.*s: %.*s",
947 result = write_resp_raw(cf, data, h3name.base, h3name.len, FALSE);
951 result = write_resp_raw(cf, data, ": ", 2, FALSE);
955 result = write_resp_raw(cf, data, h3val.base, h3val.len, FALSE);
959 result = write_resp_raw(cf, data, "\r\n", 2, FALSE);
991 struct Curl_easy *data = stream_user_data;
994 (void)data;
998 CURL_TRC_CF(data, cf, "[%" PRId64 "] reset -> %d", stream_id, rv);
1085 struct Curl_easy *data,
1093 failf(data,
1099 failf(data,
1113 /* incoming data frames on the h3 stream */
1114 static ssize_t cf_ngtcp2_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
1118 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
1125 CF_DATA_SAVE(save, cf, data);
1132 pktx_init(&pktx, cf, data);
1143 CURL_TRC_CF(data, cf, "[%" PRId64 "] read recvbuf(len=%zu) "
1147 report_consumed_data(cf, data, nread);
1150 if(cf_progress_ingress(cf, data, &pktx)) {
1161 CURL_TRC_CF(data, cf, "[%" PRId64 "] read recvbuf(len=%zu) "
1165 report_consumed_data(cf, data, nread);
1169 h3_drain_stream(cf, data);
1173 nread = recv_closed_stream(cf, data, stream, err);
1181 if(cf_progress_egress(cf, data, &pktx)) {
1186 CURLcode result2 = check_and_set_expiry(cf, data, &pktx);
1192 CURL_TRC_CF(data, cf, "[%" PRId64 "] cf_recv(len=%zu) -> %zd, %d",
1203 struct Curl_easy *data = stream_user_data;
1204 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
1211 * This is a delta. We have kept this data in `sendbuf` for
1237 struct Curl_easy *data = stream_user_data;
1238 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
1249 /* nghttp3 keeps references to the sendbuf data until it is ACKed
1281 CURL_TRC_CF(data, cf, "[%" PRId64 "] read req body -> AGAIN",
1286 CURL_TRC_CF(data, cf, "[%" PRId64 "] read req body -> "
1301 struct Curl_easy *data,
1318 *err = h3_data_setup(cf, data);
1321 stream = H3_STREAM_CTX(data);
1332 /* need more data */
1337 *err = Curl_http_req_to_h2(&h2_headers, stream->h1.req, data);
1362 rc = ngtcp2_conn_open_bidi_stream(ctx->qconn, &stream->id, data);
1364 failf(data, "can get bidi streams");
1369 switch(data->state.httpreq) {
1375 if(data->state.infilesize != -1)
1376 stream->upload_left = data->state.infilesize;
1378 /* data sending without specifying the data amount up front */
1394 nva, nheader, preader, data);
1398 CURL_TRC_CF(data, cf, "h3sid[%"PRId64"] failed to send, "
1402 CURL_TRC_CF(data, cf, "h3sid[%"PRId64"] failed to send -> %d (%s)",
1411 if(Curl_trc_is_verbose(data)) {
1412 infof(data, "[HTTP/3] [%" PRId64 "] OPENED stream for %s",
1413 stream->id, data->state.url);
1415 infof(data, "[HTTP/3] [%" PRId64 "] [%.*s: %.*s]", stream->id,
1427 static ssize_t cf_ngtcp2_send(struct Curl_cfilter *cf, struct Curl_easy *data,
1431 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
1437 CF_DATA_SAVE(save, cf, data);
1441 pktx_init(&pktx, cf, data);
1444 result = cf_progress_ingress(cf, data, &pktx);
1451 sent = h3_stream_open(cf, data, buf, len, err);
1453 CURL_TRC_CF(data, cf, "failed to open stream -> %d", *err);
1456 stream = H3_STREAM_CTX(data);
1459 /* the data in `buf` has already been submitted or added to the
1465 failf(data, "HTTP/3 send again with decreased length");
1478 * We silently discard the data sent, since this is not a transport
1480 CURL_TRC_CF(data, cf, "[%" PRId64 "] discarding data"
1486 CURL_TRC_CF(data, cf, "[%" PRId64 "] send_body(len=%zu) "
1494 CURL_TRC_CF(data, cf, "[%" PRId64 "] cf_send, add to "
1504 result = cf_progress_egress(cf, data, &pktx);
1515 CURL_TRC_CF(data, cf, "[%" PRId64 "] cf_send(len=%zu), "
1523 result = check_and_set_expiry(cf, data, &pktx);
1528 CURL_TRC_CF(data, cf, "[%" PRId64 "] cf_send(len=%zu) -> %zd, %d",
1535 struct Curl_easy *data)
1543 return Curl_vquic_tls_verify_peer(&ctx->tls, cf, data, &ctx->peer);
1566 CURL_TRC_CF(pktx->data, pktx->cf, "ingress, read_pkt -> %s (%d)",
1590 struct Curl_easy *data,
1600 pktx_init(&local_pktx, cf, data);
1607 result = Curl_vquic_tls_before_recv(&ctx->tls, cf, data);
1613 result = vquic_recv_packets(cf, data, &ctx->q, pkts_chunk,
1620 result = cf_progress_egress(cf, data, pktx);
1663 failf(x->data, "nghttp3_conn_writev_stream returned error: %s",
1688 struct h3_stream_ctx *stream = H3_STREAM_CTX(x->data);
1691 CURL_TRC_CF(x->data, x->cf, "[%" PRId64 "] block quic flow",
1705 /* ngtcp2 wants to send more. update the flow of the stream whose data
1712 failf(x->data, "ngtcp2_conn_writev_stream returned error: %s",
1722 /* we add the amount of data bytes to the flow windows */
1725 failf(x->data, "nghttp3_conn_add_write_offset returned error: %s\n",
1742 struct Curl_easy *data,
1754 pktx_init(&local_pktx, cf, data);
1762 curlcode = vquic_flush(cf, data, &ctx->q);
1765 Curl_expire(data, 1, EXPIRE_QUIC);
1797 curlcode = vquic_send(cf, data, &ctx->q, gsolen);
1800 Curl_expire(data, 1, EXPIRE_QUIC);
1819 curlcode = vquic_send_tail_split(cf, data, &ctx->q,
1823 Curl_expire(data, 1, EXPIRE_QUIC);
1836 curlcode = vquic_send(cf, data, &ctx->q, gsolen);
1839 Curl_expire(data, 1, EXPIRE_QUIC);
1855 * to receive more data from the connection.
1858 const struct Curl_easy *data)
1860 const struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
1866 struct Curl_easy *data,
1872 h3_drain_stream(cf, data);
1873 Curl_expire(data, 0, EXPIRE_RUN_NOW);
1879 struct Curl_easy *data,
1886 CF_DATA_SAVE(save, cf, data);
1893 result = h3_data_pause(cf, data, (arg1 != 0));
1896 h3_data_done(cf, data);
1899 h3_data_done(cf, data);
1902 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
1911 struct h3_stream_ctx *stream = H3_STREAM_CTX(data);
1912 CURL_TRC_CF(data, cf, "data idle");
1914 result = check_and_set_expiry(cf, data, NULL);
1916 CURL_TRC_CF(data, cf, "data idle, check_and_set_expiry -> %d", result);
1948 static void cf_ngtcp2_close(struct Curl_cfilter *cf, struct Curl_easy *data)
1953 CF_DATA_SAVE(save, cf, data);
1959 CURL_TRC_CF(data, cf, "close");
1960 pktx_init(&pktx, cf, data);
1977 static void cf_ngtcp2_destroy(struct Curl_cfilter *cf, struct Curl_easy *data)
1982 CF_DATA_SAVE(save, cf, data);
1983 CURL_TRC_CF(data, cf, "destroy");
1995 struct Curl_easy *data)
2001 failf(data, "ngtcp2_crypto_boringssl_configure_client_context failed");
2006 failf(data, "ngtcp2_crypto_quictls_configure_client_context failed");
2012 failf(data, "ngtcp2_crypto_gnutls_configure_client_session failed");
2017 failf(data, "ngtcp2_crypto_wolfssl_configure_client_context failed");
2028 struct Curl_easy *data,
2049 result = Curl_vquic_tls_init(&ctx->tls, cf, data, &ctx->peer,
2056 result = Curl_rand(data, ctx->dcid.data, NGTCP2_MAX_CIDLEN);
2061 result = Curl_rand(data, ctx->scid.data, NGTCP2_MAX_CIDLEN);
2065 (void)Curl_qlogdir(data, ctx->scid.data, NGTCP2_MAX_CIDLEN, &qfd);
2067 quic_settings(ctx, data, pktx);
2073 Curl_cf_socket_peek(cf->next, data, &ctx->q.sockfd,
2112 struct Curl_easy *data,
2128 result = Curl_conn_cf_connect(cf->next, data, blocking, done);
2135 pktx_init(&pktx, cf, data);
2137 CF_DATA_SAVE(save, cf, data);
2141 CURL_TRC_CF(data, cf, "waiting for reconnect time");
2147 result = cf_connect_start(cf, data, &pktx);
2150 result = cf_progress_egress(cf, data, &pktx);
2155 result = cf_progress_ingress(cf, data, &pktx);
2159 result = cf_progress_egress(cf, data, &pktx);
2165 CURL_TRC_CF(data, cf, "handshake complete after %dms",
2167 result = qng_verify_peer(cf, data);
2169 CURL_TRC_CF(data, cf, "peer verified");
2192 Curl_cf_socket_peek(cf->next, data, NULL, NULL,
2194 infof(data, "QUIC connect to %s port %u failed: %s",
2199 result = check_and_set_expiry(cf, data, &pktx);
2202 CURL_TRC_CF(data, cf, "connect -> %d, done=%d", result, *done);
2208 struct Curl_easy *data,
2219 CF_DATA_SAVE(save, cf, data);
2225 *pres1 = Curl_multi_max_concurrent_streams(data->multi);
2226 CURL_TRC_CF(data, cf, "query max_conncurrent -> %d", *pres1);
2254 cf->next->cft->query(cf->next, data, query, pres1, pres2) :
2259 struct Curl_easy *data,
2267 CF_DATA_SAVE(save, cf, data);
2290 if(!cf->next || !cf->next->cft->is_alive(cf->next, data, input_pending))
2297 not in use by any other transfer, there shouldn't be any data here,
2300 result = cf_progress_ingress(cf, data, NULL);
2301 CURL_TRC_CF(data, cf, "is_alive, progress ingress -> %d", result);
2329 struct Curl_easy *data,
2337 (void)data;
2350 result = Curl_cf_udp_create(&udp_cf, data, conn, ai, TRNSPRT_QUIC);
2363 Curl_conn_cf_discard_sub(cf, udp_cf, data, TRUE);
2370 bool Curl_conn_is_ngtcp2(const struct Curl_easy *data,
2376 (void)data;