CURLcode Curl_http2_switched(struct connectdata *conn,
const char *mem, size_t nread)
{
CURLcode result;
struct http_conn *httpc = &conn->proto.httpc;
int rv;
struct SessionHandle *data = conn->data;
struct HTTP *stream = conn->data->req.protop;
result = Curl_http2_setup(conn);
if(result)
return result;
httpc->recv_underlying = (recving)conn->recv[FIRSTSOCKET];
httpc->send_underlying = (sending)conn->send[FIRSTSOCKET];
conn->recv[FIRSTSOCKET] = http2_recv;
conn->send[FIRSTSOCKET] = http2_send;
if(conn->data->req.upgr101 == UPGR101_RECEIVED) {
/* stream 1 is opened implicitly on upgrade */
stream->stream_id = 1;
/* queue SETTINGS frame (again) */
rv = nghttp2_session_upgrade(httpc->h2, httpc->binsettings,
httpc->binlen, NULL);
if(rv != 0) {
failf(data, "nghttp2_session_upgrade() failed: %s(%d)",
nghttp2_strerror(rv), rv);
return CURLE_HTTP2;
}
}
else {
/* stream ID is unknown at this point */
stream->stream_id = -1;
rv = nghttp2_submit_settings(httpc->h2, NGHTTP2_FLAG_NONE, NULL, 0);
if(rv != 0) {
failf(data, "nghttp2_submit_settings() failed: %s(%d)",
nghttp2_strerror(rv), rv);
return CURLE_HTTP2;
}
}
rv = (int)nghttp2_session_mem_recv(httpc->h2, (const uint8_t*)mem, nread);
if(rv != (int)nread) {
failf(data, "nghttp2_session_mem_recv() failed: %s(%d)",
nghttp2_strerror(rv), rv);
return CURLE_HTTP2;
}
/* Try to send some frames since we may read SETTINGS already. */
rv = nghttp2_session_send(httpc->h2);
if(rv != 0) {
failf(data, "nghttp2_session_send() failed: %s(%d)",
nghttp2_strerror(rv), rv);
return CURLE_HTTP2;
}
return CURLE_OK;
}
/* Serialize the frame and send (or buffer) the data to
bufferevent. */
static int session_send(http2_session_data *session_data) {
int rv;
rv = nghttp2_session_send(session_data->session);
if (rv != 0) {
warnx("Fatal error: %s", nghttp2_strerror(rv));
return -1;
}
return 0;
}
apr_status_t h2_session_write(h2_session *session, apr_interval_time_t timeout)
{
apr_status_t status = APR_EAGAIN;
h2_response *response = NULL;
int have_written = 0;
assert(session);
/* Check that any pending window updates are sent. */
status = h2_session_update_windows(session);
if (status == APR_SUCCESS) {
have_written = 1;
}
else if (status != APR_EAGAIN) {
return status;
}
/* If we have responses ready, submit them now. */
while ((response = h2_session_pop_response(session)) != NULL) {
h2_stream *stream = h2_session_get_stream(session, response->stream_id);
if (stream) {
status = h2_session_handle_response(session, stream, response);
have_written = 1;
}
h2_response_destroy(response);
response = NULL;
}
h2_session_resume_streams_with_data(session);
if (!have_written && timeout > 0 && !h2_session_want_write(session)) {
status = h2_mplx_out_trywait(session->mplx, timeout, session->iowait);
}
h2_session_resume_streams_with_data(session);
if (h2_session_want_write(session)) {
status = APR_SUCCESS;
int rv = nghttp2_session_send(session->ngh2);
if (rv != 0) {
ap_log_cerror( APLOG_MARK, APLOG_INFO, 0, session->c,
"h2_session: send: %s", nghttp2_strerror(rv));
if (nghttp2_is_fatal(rv)) {
h2_session_abort_int(session, rv);
status = APR_ECONNABORTED;
}
}
have_written = 1;
}
if (have_written) {
h2_conn_io_flush(&session->io);
}
reap_zombies(session);
return status;
}
static apr_status_t h2_session_abort_int(h2_session *session, int reason)
{
AP_DEBUG_ASSERT(session);
if (!session->aborted) {
session->aborted = 1;
if (session->ngh2) {
if (!reason) {
nghttp2_submit_goaway(session->ngh2, NGHTTP2_FLAG_NONE,
session->max_stream_received,
reason, NULL, 0);
nghttp2_session_send(session->ngh2);
h2_conn_io_flush(&session->io);
}
else {
const char *err = nghttp2_strerror(reason);
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"session(%ld): aborting session, reason=%d %s",
session->id, reason, err);
if (NGHTTP2_ERR_EOF == reason) {
/* This is our way of indication that the connection is
* gone. No use to send any GOAWAY frames. */
nghttp2_session_terminate_session(session->ngh2, reason);
}
else {
/* The connection might still be there and we shut down
* with GOAWAY and reason information. */
nghttp2_submit_goaway(session->ngh2, NGHTTP2_FLAG_NONE,
session->max_stream_received,
reason, (const uint8_t *)err,
strlen(err));
nghttp2_session_send(session->ngh2);
h2_conn_io_flush(&session->io);
}
}
}
h2_mplx_abort(session->mplx);
}
return APR_SUCCESS;
}
/*
* Performs the network I/O.
*/
static void exec_io(struct Connection *connection) {
int rv;
rv = nghttp2_session_recv(connection->session);
if (rv != 0) {
diec("nghttp2_session_recv", rv);
}
rv = nghttp2_session_send(connection->session);
if (rv != 0) {
diec("nghttp2_session_send", rv);
}
}
static
void pingconn(evutil_socket_t s, short evt, void *raw)
{
session *sess = raw;
if(nghttp2_submit_ping(sess->S.h2sess, NGHTTP2_FLAG_NONE, NULL) ||
nghttp2_session_send(sess->S.h2sess))
{
fprintf(stderr, "Ping failed\n");
cleanup_session(&sess->S);
}
}
static
void newconn(struct evconnlistener *lev, evutil_socket_t sock, struct sockaddr *cli, int socklen, void *raw)
{
server *serv = raw;
session *sess;
printf("New client\n");
sess = calloc(1, sizeof(*sess));
if(sess) {
sess->serv = serv;
sess->S.build_stream = buildstream;
sess->S.cleanup = &cleanup_session;
/* periodic timer */
sess->pingtimer = event_new(serv->base, -1, EV_PERSIST, pingconn, sess);
assert(sess->pingtimer);
sess->S.bev = bufferevent_socket_new(serv->base, sock, BEV_OPT_CLOSE_ON_FREE);
if(sess->S.bev) {
h2session_setup_bev(&sess->S);
bufferevent_enable(sess->S.bev, EV_READ);
if(prepare_h2_session(sess)) {
bufferevent_free(sess->S.bev);
free(sess);
printf("Client failed\n");
return;
} else {
nghttp2_settings_entry iv[] = {
{NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, 100},
{NGHTTP2_SETTINGS_ENABLE_PUSH, 0}
};
int rv;
if ((rv=nghttp2_submit_settings(sess->S.h2sess, NGHTTP2_FLAG_NONE, iv, ARRLEN(iv))) ||
(rv=nghttp2_session_send(sess->S.h2sess)))
{
printf("submit error: %s", nghttp2_strerror(rv));
cleanup_session(&sess->S);
} else {
const struct timeval itvl = {5,0};
printf("Connection ready\n");
evtimer_add(sess->pingtimer, &itvl);
}
}
}
}
if(!sess || !sess->S.bev) {
fprintf(stderr, "No memory\n");
free(sess);
close(sock);
return;
}
}
static
void wakeup_count(evutil_socket_t s, short evt, void *raw)
{
request *req = raw;
printf("Counter wakeup\n");
req->cansend = 1;
if(h2stream_can_write(&req->R))
{
fprintf(stderr, "Failed to resume counter\n");
return;
}
if(nghttp2_session_send(req->R.sess->h2sess)) {
fprintf(stderr, "Failed to flush counter stream\n");
}
}
/* 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;
}
/*
* If the read would block (EWOULDBLOCK) we return -1. Otherwise we return
* a regular CURLcode value.
*/
static ssize_t http2_recv(struct connectdata *conn, int sockindex,
char *mem, size_t len, CURLcode *err)
{
CURLcode rc;
ssize_t rv;
ssize_t nread;
struct http_conn *httpc = &conn->proto.httpc;
(void)sockindex; /* we always do HTTP2 on sockindex 0 */
if(httpc->closed) {
/* Reset to FALSE to prevent infinite loop in readwrite_data
function. */
httpc->closed = FALSE;
return 0;
}
/* Nullify here because we call nghttp2_session_send() and they
might refer to the old buffer. */
httpc->upload_mem = NULL;
httpc->upload_len = 0;
if(httpc->bodystarted &&
httpc->nread_header_recvbuf < httpc->header_recvbuf->size_used) {
size_t left =
httpc->header_recvbuf->size_used - httpc->nread_header_recvbuf;
size_t ncopy = len < left ? len : left;
memcpy(mem, httpc->header_recvbuf->buffer + httpc->nread_header_recvbuf,
ncopy);
httpc->nread_header_recvbuf += ncopy;
return ncopy;
}
if(httpc->data) {
nread = len < httpc->datalen ? len : httpc->datalen;
memcpy(mem, httpc->data, nread);
httpc->data += nread;
httpc->datalen -= nread;
infof(conn->data, "%zu data written\n", nread);
if(httpc->datalen == 0) {
httpc->data = NULL;
httpc->datalen = 0;
}
return nread;
}
conn->proto.httpc.mem = mem;
conn->proto.httpc.len = len;
infof(conn->data, "http2_recv: %d bytes buffer\n",
conn->proto.httpc.len);
rc = 0;
nread = ((Curl_recv*)httpc->recv_underlying)(conn, FIRSTSOCKET,
httpc->inbuf, H2_BUFSIZE, &rc);
if(rc == CURLE_AGAIN) {
*err = rc;
return -1;
}
if(nread == -1) {
failf(conn->data, "Failed receiving HTTP2 data");
*err = rc;
return 0;
}
infof(conn->data, "nread=%zd\n", nread);
rv = nghttp2_session_mem_recv(httpc->h2,
(const uint8_t *)httpc->inbuf, nread);
if(nghttp2_is_fatal((int)rv)) {
failf(conn->data, "nghttp2_session_mem_recv() returned %d:%s\n",
rv, nghttp2_strerror((int)rv));
*err = CURLE_RECV_ERROR;
return 0;
}
infof(conn->data, "nghttp2_session_mem_recv() returns %zd\n", rv);
/* Always send pending frames in nghttp2 session, because
nghttp2_session_mem_recv() may queue new frame */
rv = nghttp2_session_send(httpc->h2);
if(rv != 0) {
*err = CURLE_SEND_ERROR;
return 0;
}
if(len != httpc->len) {
return len - conn->proto.httpc.len;
}
/* If stream is closed, return 0 to signal the http routine to close
the connection */
if(httpc->closed) {
/* Reset to FALSE to prevent infinite loop in readwrite_data
function. */
httpc->closed = FALSE;
return 0;
}
*err = CURLE_AGAIN;
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;
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;
}
/*
* If the read would block (EWOULDBLOCK) we return -1. Otherwise we return
* a regular CURLcode value.
*/
static ssize_t http2_recv(struct connectdata *conn, int sockindex,
char *mem, size_t len, CURLcode *err)
{
CURLcode result = CURLE_OK;
ssize_t rv;
ssize_t nread;
struct http_conn *httpc = &conn->proto.httpc;
struct SessionHandle *data = conn->data;
struct HTTP *stream = data->req.protop;
(void)sockindex; /* we always do HTTP2 on sockindex 0 */
/* If stream is closed, return 0 to signal the http routine to close
the connection. We need to handle stream closure here,
otherwise, we may be going to read from underlying connection,
and gets EAGAIN, and we will get stuck there. */
if(stream->memlen == 0 && stream->closed) {
return http2_handle_stream_close(httpc, data, stream, err);
}
/* Nullify here because we call nghttp2_session_send() and they
might refer to the old buffer. */
stream->upload_mem = NULL;
stream->upload_len = 0;
/*
* At this point 'stream' is just in the SessionHandle the connection
* identifies as its owner at this time.
*/
if(stream->bodystarted &&
stream->nread_header_recvbuf < stream->header_recvbuf->size_used) {
/* If there is body data pending for this stream to return, do that */
size_t left =
stream->header_recvbuf->size_used - stream->nread_header_recvbuf;
size_t ncopy = MIN(len, left);
memcpy(mem, stream->header_recvbuf->buffer + stream->nread_header_recvbuf,
ncopy);
stream->nread_header_recvbuf += ncopy;
infof(data, "http2_recv: Got %d bytes from header_recvbuf\n",
(int)ncopy);
return ncopy;
}
infof(data, "http2_recv: %d bytes buffer at %p (stream %u)\n",
len, mem, stream->stream_id);
if((data->state.drain) && stream->memlen) {
DEBUGF(infof(data, "http2_recv: DRAIN %zu bytes stream %u!! (%p => %p)\n",
stream->memlen, stream->stream_id,
stream->mem, mem));
if(mem != stream->mem) {
/* if we didn't get the same buffer this time, we must move the data to
the beginning */
memmove(mem, stream->mem, stream->memlen);
stream->len = len - stream->memlen;
stream->mem = mem;
}
}
else if(stream->pausedata) {
nread = MIN(len, stream->pauselen);
memcpy(mem, stream->pausedata, nread);
stream->pausedata += nread;
stream->pauselen -= nread;
infof(data, "%zu data bytes written\n", nread);
if(stream->pauselen == 0) {
DEBUGF(infof(data, "Unpaused by stream %u\n", stream->stream_id));
assert(httpc->pause_stream_id == stream->stream_id);
httpc->pause_stream_id = 0;
stream->pausedata = NULL;
stream->pauselen = 0;
}
infof(data, "http2_recv: returns unpaused %zd bytes on stream %u\n",
nread, stream->stream_id);
return nread;
}
else if(httpc->pause_stream_id) {
/* If a stream paused nghttp2_session_mem_recv previously, and has
not processed all data, it still refers to the buffer in
nghttp2_session. If we call nghttp2_session_mem_recv(), we may
overwrite that buffer. To avoid that situation, just return
here with CURLE_AGAIN. This could be busy loop since data in
socket is not read. But it seems that usually streams are
notified with its drain property, and socket is read again
quickly. */
*err = CURLE_AGAIN;
return -1;
}
else {
char *inbuf;
/* remember where to store incoming data for this stream and how big the
buffer is */
stream->mem = mem;
stream->len = len;
stream->memlen = 0;
if(httpc->inbuflen == 0) {
nread = ((Curl_recv *)httpc->recv_underlying)(
conn, FIRSTSOCKET, httpc->inbuf, H2_BUFSIZE, &result);
if(result == CURLE_AGAIN) {
*err = result;
return -1;
}
if(nread == -1) {
failf(data, "Failed receiving HTTP2 data");
*err = result;
return 0;
}
if(nread == 0) {
failf(data, "Unexpected EOF");
*err = CURLE_RECV_ERROR;
return -1;
}
DEBUGF(infof(data, "nread=%zd\n", nread));
httpc->inbuflen = nread;
inbuf = httpc->inbuf;
}
else {
nread = httpc->inbuflen - httpc->nread_inbuf;
inbuf = httpc->inbuf + httpc->nread_inbuf;
DEBUGF(infof(data, "Use data left in connection buffer, nread=%zd\n",
nread));
}
rv = nghttp2_session_mem_recv(httpc->h2, (const uint8_t *)inbuf, nread);
if(nghttp2_is_fatal((int)rv)) {
failf(data, "nghttp2_session_mem_recv() returned %d:%s\n",
rv, nghttp2_strerror((int)rv));
*err = CURLE_RECV_ERROR;
return 0;
}
DEBUGF(infof(data, "nghttp2_session_mem_recv() returns %zd\n", rv));
if(nread == rv) {
DEBUGF(infof(data, "All data in connection buffer processed\n"));
httpc->inbuflen = 0;
httpc->nread_inbuf = 0;
}
else {
httpc->nread_inbuf += rv;
DEBUGF(infof(data, "%zu bytes left in connection buffer\n",
httpc->inbuflen - httpc->nread_inbuf));
}
/* Always send pending frames in nghttp2 session, because
nghttp2_session_mem_recv() may queue new frame */
rv = nghttp2_session_send(httpc->h2);
if(rv != 0) {
*err = CURLE_SEND_ERROR;
return 0;
}
}
if(stream->memlen) {
ssize_t retlen = stream->memlen;
infof(data, "http2_recv: returns %zd for stream %u\n",
retlen, stream->stream_id);
stream->memlen = 0;
if(httpc->pause_stream_id == stream->stream_id) {
/* data for this stream is returned now, but this stream caused a pause
already so we need it called again asap */
DEBUGF(infof(data, "Data returned for PAUSED stream %u\n",
stream->stream_id));
}
else
data->state.drain = 0; /* this stream is hereby drained */
return retlen;
}
/* If stream is closed, return 0 to signal the http routine to close
the connection */
if(stream->closed) {
return http2_handle_stream_close(httpc, data, stream, err);
}
*err = CURLE_AGAIN;
DEBUGF(infof(data, "http2_recv returns AGAIN for stream %u\n",
stream->stream_id));
return -1;
}
apr_status_t h2_session_write(h2_session *session, apr_interval_time_t timeout)
{
apr_status_t status = APR_EAGAIN;
h2_stream *stream = NULL;
int flush_output = 0;
AP_DEBUG_ASSERT(session);
/* Check that any pending window updates are sent. */
status = h2_session_update_windows(session);
if (status == APR_SUCCESS) {
flush_output = 1;
}
else if (status != APR_EAGAIN) {
return status;
}
if (h2_session_want_write(session)) {
int rv;
status = APR_SUCCESS;
rv = nghttp2_session_send(session->ngh2);
if (rv != 0) {
ap_log_cerror( APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_session: send: %s", nghttp2_strerror(rv));
if (nghttp2_is_fatal(rv)) {
h2_session_abort_int(session, rv);
status = APR_ECONNABORTED;
}
}
flush_output = 1;
}
/* If we have responses ready, submit them now. */
while ((stream = h2_mplx_next_submit(session->mplx,
session->streams)) != NULL) {
status = h2_session_handle_response(session, stream);
flush_output = 1;
}
if (h2_session_resume_streams_with_data(session) > 0) {
flush_output = 1;
}
if (!flush_output && timeout > 0 && !h2_session_want_write(session)) {
status = h2_mplx_out_trywait(session->mplx, timeout, session->iowait);
if (status != APR_TIMEUP
&& h2_session_resume_streams_with_data(session) > 0) {
flush_output = 1;
}
else {
/* nothing happened to ongoing streams, do some house-keeping */
}
}
if (h2_session_want_write(session)) {
int rv;
status = APR_SUCCESS;
rv = nghttp2_session_send(session->ngh2);
if (rv != 0) {
ap_log_cerror( APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_session: send2: %s", nghttp2_strerror(rv));
if (nghttp2_is_fatal(rv)) {
h2_session_abort_int(session, rv);
status = APR_ECONNABORTED;
}
}
flush_output = 1;
}
if (flush_output) {
h2_conn_io_flush(&session->io);
}
return status;
}
int nghttp2client_connect(httpclient *pclient, char *url, int port, http2_ssl_custom_conf_t *ssl_config, const struct URI *uri)
{
struct Connection connection;
nghttp2_session_callbacks *callbacks;
int rv;
int ret = 0;
struct Request req;
request_init(&req, uri);
if (0 == (ret = nghttp2s_client_conn(pclient, url, port, ssl_config))) {
pclient->remote_port = HTTPS_PORT;
nghttp2_socket.fd = pclient->fd.fd;
} else {
printf("https_client_conn failed %d\r\n", ret);
/* Resource cleanup */
mbedtls_ssl_close_notify( &(pclient->ssl) );
mbedtls_net_free( &pclient->fd );
mbedtls_x509_crt_free( &(ssl_config->verify_source.cacertl) );
mbedtls_ssl_free( &(pclient->ssl) );
mbedtls_ssl_config_free( &(ssl_config->conf) );
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
request_free(&req);
return ret;
}
//set_tcp_nodelay(nghttp2_socket.fd);
connection.ssl = &(pclient->ssl);
rv = nghttp2_session_callbacks_new(&callbacks);
if (rv != 0) {
printf("nghttp2_session_callbacks_new1 %d", rv);
}
setup_nghttp2_callbacks(callbacks);
rv = nghttp2_session_client_new(&connection.session, callbacks, &connection);
nghttp2_session_callbacks_del(callbacks);
if (rv != 0) {
printf("nghttp2_session_client_new2 %d", rv);
}
nghttp2_submit_settings(connection.session, NGHTTP2_FLAG_NONE, NULL, 0);
/* Submit the HTTP request to the outbound queue. */
submit_request(&connection, &req);
/* Event loop */
while (1) {
int read_flag = 0;
int write_flag = 0;
write_flag = nghttp2_session_want_write(connection.session);
if (write_flag) {
int rv = nghttp2_session_send(connection.session);
printf("nghttp2_session_send %d\r\n", rv);
if (rv < 0) {
write_flag = 0;
//break;
}
}
read_flag = nghttp2_session_want_read(connection.session);
if (read_flag) {
int rv = nghttp2_session_recv(connection.session);
printf("nghttp2_session_recv %d\r\n", rv);
if (rv < 0) {
read_flag = 0;
//break;
}
}
printf("write_flag = %d, read_flag = %d\r\n", write_flag, read_flag);
if ((read_flag == 0) && (write_flag == 0)) {
printf("No active stream!\r\n");
break;
}
}
/* Resource cleanup */
nghttp2_session_del(connection.session);
mbedtls_ssl_close_notify( &(pclient->ssl) );
mbedtls_net_free( &pclient->fd );
mbedtls_x509_crt_free( &(ssl_config->verify_source.cacertl) );
mbedtls_ssl_free( &(pclient->ssl) );
mbedtls_ssl_config_free( &(ssl_config->conf) );
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
request_free(&req);
return 0;
}
CURLcode Curl_http2_switched(struct connectdata *conn,
const char *mem, size_t nread)
{
CURLcode result;
struct http_conn *httpc = &conn->proto.httpc;
int rv;
ssize_t nproc;
struct SessionHandle *data = conn->data;
struct HTTP *stream = conn->data->req.protop;
result = Curl_http2_setup(conn);
if(result)
return result;
httpc->recv_underlying = (recving)conn->recv[FIRSTSOCKET];
httpc->send_underlying = (sending)conn->send[FIRSTSOCKET];
conn->recv[FIRSTSOCKET] = http2_recv;
conn->send[FIRSTSOCKET] = http2_send;
if(conn->data->req.upgr101 == UPGR101_RECEIVED) {
/* stream 1 is opened implicitly on upgrade */
stream->stream_id = 1;
/* queue SETTINGS frame (again) */
rv = nghttp2_session_upgrade(httpc->h2, httpc->binsettings,
httpc->binlen, NULL);
if(rv != 0) {
failf(data, "nghttp2_session_upgrade() failed: %s(%d)",
nghttp2_strerror(rv), rv);
return CURLE_HTTP2;
}
nghttp2_session_set_stream_user_data(httpc->h2,
stream->stream_id,
conn->data);
}
else {
/* stream ID is unknown at this point */
stream->stream_id = -1;
rv = nghttp2_submit_settings(httpc->h2, NGHTTP2_FLAG_NONE, NULL, 0);
if(rv != 0) {
failf(data, "nghttp2_submit_settings() failed: %s(%d)",
nghttp2_strerror(rv), rv);
return CURLE_HTTP2;
}
}
/* we are going to copy mem to httpc->inbuf. This is required since
mem is part of buffer pointed by stream->mem, and callbacks
called by nghttp2_session_mem_recv() will write stream specific
data into stream->mem, overwriting data already there. */
if(H2_BUFSIZE < nread) {
failf(data, "connection buffer size is too small to store data following "
"HTTP Upgrade response header: buflen=%zu, datalen=%zu",
H2_BUFSIZE, nread);
return CURLE_HTTP2;
}
infof(conn->data, "Copying HTTP/2 data in stream buffer to connection buffer"
" after upgrade: len=%zu\n",
nread);
memcpy(httpc->inbuf, mem, nread);
httpc->inbuflen = nread;
nproc = nghttp2_session_mem_recv(httpc->h2, (const uint8_t *)httpc->inbuf,
httpc->inbuflen);
if(nghttp2_is_fatal((int)nproc)) {
failf(data, "nghttp2_session_mem_recv() failed: %s(%d)",
nghttp2_strerror((int)nproc), (int)nproc);
return CURLE_HTTP2;
}
DEBUGF(infof(data, "nghttp2_session_mem_recv() returns %zd\n", nproc));
if((ssize_t)nread == nproc) {
httpc->inbuflen = 0;
httpc->nread_inbuf = 0;
}
else {
httpc->nread_inbuf += nproc;
}
/* Try to send some frames since we may read SETTINGS already. */
rv = nghttp2_session_send(httpc->h2);
if(rv != 0) {
failf(data, "nghttp2_session_send() failed: %s(%d)",
nghttp2_strerror(rv), rv);
return CURLE_HTTP2;
}
return CURLE_OK;
}
static void run_nghttp2_session_send(void) {
nghttp2_session *session;
nghttp2_session_callbacks callbacks;
nghttp2_nv nv[] = {MAKE_NV(":host", "example.org"),
MAKE_NV(":scheme", "https")};
nghttp2_data_provider data_prd;
nghttp2_settings_entry iv[2];
my_user_data ud;
int rv;
memset(&callbacks, 0, sizeof(nghttp2_session_callbacks));
callbacks.send_callback = null_send_callback;
data_prd.read_callback = fixed_length_data_source_read_callback;
ud.data_source_length = 64 * 1024;
iv[0].settings_id = NGHTTP2_SETTINGS_HEADER_TABLE_SIZE;
iv[0].value = 4096;
iv[1].settings_id = NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS;
iv[1].value = 100;
rv = nghttp2_session_client_new3(&session, &callbacks, &ud, NULL,
nghttp2_mem_fm());
if (rv != 0) {
goto client_new_fail;
}
rv = nghttp2_submit_request(session, NULL, nv, ARRLEN(nv), &data_prd, NULL);
if (rv < 0) {
goto fail;
}
rv = nghttp2_submit_headers(session, NGHTTP2_FLAG_NONE, -1, NULL, nv,
ARRLEN(nv), NULL);
if (rv < 0) {
goto fail;
}
rv = nghttp2_session_send(session);
if (rv != 0) {
goto fail;
}
/* The HEADERS submitted by the previous nghttp2_submit_headers will
have stream ID 3. Send HEADERS to that stream. */
rv = nghttp2_submit_headers(session, NGHTTP2_FLAG_NONE, 3, NULL, nv,
ARRLEN(nv), NULL);
if (rv != 0) {
goto fail;
}
rv = nghttp2_submit_data(session, NGHTTP2_FLAG_END_STREAM, 3, &data_prd);
if (rv != 0) {
goto fail;
}
rv = nghttp2_session_send(session);
if (rv != 0) {
goto fail;
}
rv = nghttp2_submit_rst_stream(session, NGHTTP2_FLAG_NONE, 3, NGHTTP2_CANCEL);
if (rv != 0) {
goto fail;
}
rv = nghttp2_session_send(session);
if (rv != 0) {
goto fail;
}
/* Sending against half-closed stream */
rv = nghttp2_submit_headers(session, NGHTTP2_FLAG_NONE, 3, NULL, nv,
ARRLEN(nv), NULL);
if (rv != 0) {
goto fail;
}
rv = nghttp2_submit_data(session, NGHTTP2_FLAG_END_STREAM, 3, &data_prd);
if (rv != 0) {
goto fail;
}
rv = nghttp2_submit_ping(session, NGHTTP2_FLAG_NONE, NULL);
if (rv != 0) {
goto fail;
}
rv = nghttp2_submit_settings(session, NGHTTP2_FLAG_NONE, iv, 2);
if (rv != 0) {
goto fail;
}
rv = nghttp2_session_send(session);
if (rv != 0) {
goto fail;
}
rv = nghttp2_submit_goaway(session, NGHTTP2_FLAG_NONE, 100, NGHTTP2_NO_ERROR,
NULL, 0);
if (rv != 0) {
goto fail;
}
rv = nghttp2_session_send(session);
if (rv != 0) {
goto fail;
}
fail:
nghttp2_session_del(session);
client_new_fail:;
}
