static h2_stream *resume_on_data(void *ctx, h2_stream *stream) { h2_session *session = (h2_session *)ctx; assert(session); assert(stream); if (h2_stream_is_suspended(stream)) { ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, stream->pool, "h2_stream(%ld-%d): suspended, checking for DATA", h2_mplx_get_id(stream->m), stream->id); if (h2_mplx_out_has_data_for(stream->m, h2_stream_get_id(stream))) { h2_stream_set_suspended(stream, 0); int rv = nghttp2_session_resume_data(session->ngh2, h2_stream_get_id(stream)); ap_log_cerror(APLOG_MARK, nghttp2_is_fatal(rv)? APLOG_ERR : APLOG_DEBUG, 0, session->c, "h2_stream(%ld-%d): resuming stream %s", session->id, stream->id, nghttp2_strerror(rv)); } } return NULL; }
static int resume_on_data(void *ctx, h2_stream *stream) { resume_ctx *rctx = (resume_ctx*)ctx; h2_session *session = rctx->session; AP_DEBUG_ASSERT(session); AP_DEBUG_ASSERT(stream); if (h2_stream_is_suspended(stream)) { if (h2_mplx_out_has_data_for(stream->m, stream->id)) { int rv; h2_stream_set_suspended(stream, 0); ++rctx->resume_count; rv = nghttp2_session_resume_data(session->ngh2, stream->id); ap_log_cerror(APLOG_MARK, nghttp2_is_fatal(rv)? APLOG_ERR : APLOG_DEBUG, 0, session->c, APLOGNO(02936) "h2_stream(%ld-%d): resuming stream %s", session->id, stream->id, nghttp2_strerror(rv)); } } return 1; }
/* return number of received (decrypted) bytes */ static ssize_t http2_send(struct connectdata *conn, int sockindex, const void *mem, size_t len, CURLcode *err) { /* * BIG TODO: Currently, we send request in this function, but this * function is also used to send request body. It would be nice to * add dedicated function for request. */ int rv; struct http_conn *httpc = &conn->proto.httpc; nghttp2_nv *nva; size_t nheader; size_t i; char *hdbuf = (char*)mem; char *end; nghttp2_data_provider data_prd; int32_t stream_id; (void)sockindex; infof(conn->data, "http2_send len=%zu\n", len); if(httpc->stream_id != -1) { /* If stream_id != -1, we have dispatched request HEADERS, and now are going to send or sending request body in DATA frame */ httpc->upload_mem = mem; httpc->upload_len = len; nghttp2_session_resume_data(httpc->h2, httpc->stream_id); rv = nghttp2_session_send(httpc->h2); if(nghttp2_is_fatal(rv)) { *err = CURLE_SEND_ERROR; return -1; } return len - httpc->upload_len; } /* Calculate number of headers contained in [mem, mem + len) */ /* Here, we assume the curl http code generate *correct* HTTP header field block */ nheader = 0; for(i = 0; i < len; ++i) { if(hdbuf[i] == 0x0a) { ++nheader; } } /* We counted additional 2 \n in the first and last line. We need 3 new headers: :method, :path and :scheme. Therefore we need one more space. */ nheader += 1; nva = malloc(sizeof(nghttp2_nv) * nheader); if(nva == NULL) { *err = CURLE_OUT_OF_MEMORY; return -1; } /* Extract :method, :path from request line */ end = strchr(hdbuf, ' '); nva[0].name = (unsigned char *)":method"; nva[0].namelen = (uint16_t)strlen((char *)nva[0].name); nva[0].value = (unsigned char *)hdbuf; nva[0].valuelen = (uint16_t)(end - hdbuf); nva[0].flags = NGHTTP2_NV_FLAG_NONE; hdbuf = end + 1; end = strchr(hdbuf, ' '); nva[1].name = (unsigned char *)":path"; nva[1].namelen = (uint16_t)strlen((char *)nva[1].name); nva[1].value = (unsigned char *)hdbuf; nva[1].valuelen = (uint16_t)(end - hdbuf); nva[1].flags = NGHTTP2_NV_FLAG_NONE; nva[2].name = (unsigned char *)":scheme"; nva[2].namelen = (uint16_t)strlen((char *)nva[2].name); if(conn->handler->flags & PROTOPT_SSL) nva[2].value = (unsigned char *)"https"; else nva[2].value = (unsigned char *)"http"; nva[2].valuelen = (uint16_t)strlen((char *)nva[2].value); nva[2].flags = NGHTTP2_NV_FLAG_NONE; hdbuf = strchr(hdbuf, 0x0a); ++hdbuf; for(i = 3; i < nheader; ++i) { end = strchr(hdbuf, ':'); assert(end); if(end - hdbuf == 4 && Curl_raw_nequal("host", hdbuf, 4)) { nva[i].name = (unsigned char *)":authority"; nva[i].namelen = (uint16_t)strlen((char *)nva[i].name); } else { nva[i].name = (unsigned char *)hdbuf; nva[i].namelen = (uint16_t)(end - hdbuf); } hdbuf = end + 1; for(; *hdbuf == ' '; ++hdbuf); end = strchr(hdbuf, 0x0d); assert(end); nva[i].value = (unsigned char *)hdbuf; nva[i].valuelen = (uint16_t)(end - hdbuf); nva[i].flags = NGHTTP2_NV_FLAG_NONE; hdbuf = end + 2; /* Inspect Content-Length header field and retrieve the request entity length so that we can set END_STREAM to the last DATA frame. */ if(nva[i].namelen == 14 && Curl_raw_nequal("content-length", (char*)nva[i].name, 14)) { size_t j; for(j = 0; j < nva[i].valuelen; ++j) { httpc->upload_left *= 10; httpc->upload_left += nva[i].value[j] - '0'; } infof(conn->data, "request content-length=%zu\n", httpc->upload_left); } } switch(conn->data->set.httpreq) { case HTTPREQ_POST: case HTTPREQ_POST_FORM: case HTTPREQ_PUT: data_prd.read_callback = data_source_read_callback; data_prd.source.ptr = NULL; stream_id = nghttp2_submit_request(httpc->h2, NULL, nva, nheader, &data_prd, NULL); break; default: stream_id = nghttp2_submit_request(httpc->h2, NULL, nva, nheader, NULL, NULL); } Curl_safefree(nva); if(stream_id < 0) { *err = CURLE_SEND_ERROR; return -1; } httpc->stream_id = stream_id; rv = nghttp2_session_send(httpc->h2); if(rv != 0) { *err = CURLE_SEND_ERROR; return -1; } if(httpc->stream_id != -1) { /* If whole HEADERS frame was sent off to the underlying socket, the nghttp2 library calls data_source_read_callback. But only it found that no data available, so it deferred the DATA transmission. Which means that nghttp2_session_want_write() returns 0 on http2_perform_getsock(), which results that no writable socket check is performed. To workaround this, we issue nghttp2_session_resume_data() here to bring back DATA transmission from deferred state. */ nghttp2_session_resume_data(httpc->h2, httpc->stream_id); } return len; }
/* return number of received (decrypted) bytes */ static ssize_t http2_send(struct connectdata *conn, int sockindex, const void *mem, size_t len, CURLcode *err) { /* * BIG TODO: Currently, we send request in this function, but this * function is also used to send request body. It would be nice to * add dedicated function for request. */ int rv; struct http_conn *httpc = &conn->proto.httpc; struct HTTP *stream = conn->data->req.protop; nghttp2_nv *nva; size_t nheader; size_t i; size_t authority_idx; char *hdbuf = (char*)mem; char *end; nghttp2_data_provider data_prd; int32_t stream_id; nghttp2_session *h2 = httpc->h2; (void)sockindex; DEBUGF(infof(conn->data, "http2_send len=%zu\n", len)); if(stream->stream_id != -1) { /* If stream_id != -1, we have dispatched request HEADERS, and now are going to send or sending request body in DATA frame */ stream->upload_mem = mem; stream->upload_len = len; nghttp2_session_resume_data(h2, stream->stream_id); rv = nghttp2_session_send(h2); if(nghttp2_is_fatal(rv)) { *err = CURLE_SEND_ERROR; return -1; } len -= stream->upload_len; /* Nullify here because we call nghttp2_session_send() and they might refer to the old buffer. */ stream->upload_mem = NULL; stream->upload_len = 0; if(stream->upload_left) { /* we are sure that we have more data to send here. Calling the following API will make nghttp2_session_want_write() return nonzero if remote window allows it, which then libcurl checks socket is writable or not. See http2_perform_getsock(). */ nghttp2_session_resume_data(h2, stream->stream_id); } DEBUGF(infof(conn->data, "http2_send returns %zu for stream %u\n", len, stream->stream_id)); return len; } /* Calculate number of headers contained in [mem, mem + len) */ /* Here, we assume the curl http code generate *correct* HTTP header field block */ nheader = 0; for(i = 0; i < len; ++i) { if(hdbuf[i] == 0x0a) { ++nheader; } } /* We counted additional 2 \n in the first and last line. We need 3 new headers: :method, :path and :scheme. Therefore we need one more space. */ nheader += 1; nva = malloc(sizeof(nghttp2_nv) * nheader); if(nva == NULL) { *err = CURLE_OUT_OF_MEMORY; return -1; } /* Extract :method, :path from request line */ end = strchr(hdbuf, ' '); nva[0].name = (unsigned char *)":method"; nva[0].namelen = (uint16_t)strlen((char *)nva[0].name); nva[0].value = (unsigned char *)hdbuf; nva[0].valuelen = (uint16_t)(end - hdbuf); nva[0].flags = NGHTTP2_NV_FLAG_NONE; hdbuf = end + 1; end = strchr(hdbuf, ' '); nva[1].name = (unsigned char *)":path"; nva[1].namelen = (uint16_t)strlen((char *)nva[1].name); nva[1].value = (unsigned char *)hdbuf; nva[1].valuelen = (uint16_t)(end - hdbuf); nva[1].flags = NGHTTP2_NV_FLAG_NONE; nva[2].name = (unsigned char *)":scheme"; nva[2].namelen = (uint16_t)strlen((char *)nva[2].name); if(conn->handler->flags & PROTOPT_SSL) nva[2].value = (unsigned char *)"https"; else nva[2].value = (unsigned char *)"http"; nva[2].valuelen = (uint16_t)strlen((char *)nva[2].value); nva[2].flags = NGHTTP2_NV_FLAG_NONE; hdbuf = strchr(hdbuf, 0x0a); ++hdbuf; authority_idx = 0; for(i = 3; i < nheader; ++i) { end = strchr(hdbuf, ':'); assert(end); if(end - hdbuf == 4 && Curl_raw_nequal("host", hdbuf, 4)) { authority_idx = i; nva[i].name = (unsigned char *)":authority"; nva[i].namelen = (uint16_t)strlen((char *)nva[i].name); } else { nva[i].name = (unsigned char *)hdbuf; nva[i].namelen = (uint16_t)(end - hdbuf); } hdbuf = end + 1; for(; *hdbuf == ' '; ++hdbuf); end = strchr(hdbuf, 0x0d); assert(end); nva[i].value = (unsigned char *)hdbuf; nva[i].valuelen = (uint16_t)(end - hdbuf); nva[i].flags = NGHTTP2_NV_FLAG_NONE; hdbuf = end + 2; /* Inspect Content-Length header field and retrieve the request entity length so that we can set END_STREAM to the last DATA frame. */ if(nva[i].namelen == 14 && Curl_raw_nequal("content-length", (char*)nva[i].name, 14)) { size_t j; stream->upload_left = 0; for(j = 0; j < nva[i].valuelen; ++j) { stream->upload_left *= 10; stream->upload_left += nva[i].value[j] - '0'; } DEBUGF(infof(conn->data, "request content-length=%" CURL_FORMAT_CURL_OFF_T "\n", stream->upload_left)); } } /* :authority must come before non-pseudo header fields */ if(authority_idx != 0 && authority_idx != AUTHORITY_DST_IDX) { nghttp2_nv authority = nva[authority_idx]; for(i = authority_idx; i > AUTHORITY_DST_IDX; --i) { nva[i] = nva[i - 1]; } nva[i] = authority; } switch(conn->data->set.httpreq) { case HTTPREQ_POST: case HTTPREQ_POST_FORM: case HTTPREQ_PUT: data_prd.read_callback = data_source_read_callback; data_prd.source.ptr = NULL; stream_id = nghttp2_submit_request(h2, NULL, nva, nheader, &data_prd, NULL); break; default: stream_id = nghttp2_submit_request(h2, NULL, nva, nheader, NULL, NULL); } free(nva); if(stream_id < 0) { DEBUGF(infof(conn->data, "http2_send() send error\n")); *err = CURLE_SEND_ERROR; return -1; } infof(conn->data, "Using Stream ID: %x (easy handle %p)\n", stream_id, conn->data); stream->stream_id = stream_id; /* put the SessionHandle in the hash with the stream_id as key */ if(!Curl_hash_add(&httpc->streamsh, &stream->stream_id, sizeof(stream_id), conn->data)) { failf(conn->data, "Couldn't add stream to hash!"); *err = CURLE_OUT_OF_MEMORY; return -1; } rv = nghttp2_session_send(h2); if(rv != 0) { *err = CURLE_SEND_ERROR; return -1; } if(stream->stream_id != -1) { /* If whole HEADERS frame was sent off to the underlying socket, the nghttp2 library calls data_source_read_callback. But only it found that no data available, so it deferred the DATA transmission. Which means that nghttp2_session_want_write() returns 0 on http2_perform_getsock(), which results that no writable socket check is performed. To workaround this, we issue nghttp2_session_resume_data() here to bring back DATA transmission from deferred state. */ nghttp2_session_resume_data(h2, stream->stream_id); } return len; }