434 lines
15 KiB
C++
434 lines
15 KiB
C++
#ifdef WITH_NGHTTP2
|
|
|
|
#include "Http2Parser.h"
|
|
|
|
static nghttp2_nv make_nv(const char* name, const char* value) {
|
|
nghttp2_nv nv;
|
|
nv.name = (uint8_t*)name;
|
|
nv.value = (uint8_t*)value;
|
|
nv.namelen = strlen(name);
|
|
nv.valuelen = strlen(value);
|
|
nv.flags = NGHTTP2_NV_FLAG_NONE;
|
|
return nv;
|
|
}
|
|
|
|
static nghttp2_nv make_nv2(const char* name, const char* value,
|
|
int namelen, int valuelen) {
|
|
nghttp2_nv nv;
|
|
nv.name = (uint8_t*)name;
|
|
nv.value = (uint8_t*)value;
|
|
nv.namelen = namelen; nv.valuelen = valuelen;
|
|
nv.flags = NGHTTP2_NV_FLAG_NONE;
|
|
return nv;
|
|
}
|
|
|
|
static void print_frame_hd(const nghttp2_frame_hd* hd) {
|
|
printd("[frame] length=%d type=%x flags=%x stream_id=%d\n",
|
|
(int)hd->length, (int)hd->type, (int)hd->flags, hd->stream_id);
|
|
}
|
|
static int on_header_callback(nghttp2_session *session,
|
|
const nghttp2_frame *frame,
|
|
const uint8_t *name, size_t namelen,
|
|
const uint8_t *value, size_t valuelen,
|
|
uint8_t flags, void *userdata);
|
|
static int on_data_chunk_recv_callback(nghttp2_session *session,
|
|
uint8_t flags, int32_t stream_id, const uint8_t *data,
|
|
size_t len, void *userdata);
|
|
static int on_frame_recv_callback(nghttp2_session *session,
|
|
const nghttp2_frame *frame, void *userdata);
|
|
/*
|
|
static ssize_t data_source_read_callback(nghttp2_session *session,
|
|
int32_t stream_id, uint8_t *buf, size_t length,
|
|
uint32_t *data_flags, nghttp2_data_source *source, void *userdata);
|
|
*/
|
|
|
|
|
|
Http2Parser::Http2Parser(http_session_type type) {
|
|
if (cbs == NULL) {
|
|
nghttp2_session_callbacks_new(&cbs);
|
|
nghttp2_session_callbacks_set_on_header_callback(cbs, on_header_callback);
|
|
nghttp2_session_callbacks_set_on_data_chunk_recv_callback(cbs, on_data_chunk_recv_callback);
|
|
nghttp2_session_callbacks_set_on_frame_recv_callback(cbs, on_frame_recv_callback);
|
|
}
|
|
if (type == HTTP_CLIENT) {
|
|
nghttp2_session_client_new(&session, cbs, this);
|
|
state = H2_SEND_MAGIC;
|
|
}
|
|
else if (type == HTTP_SERVER) {
|
|
nghttp2_session_server_new(&session, cbs, this);
|
|
state = H2_WANT_RECV;
|
|
}
|
|
//nghttp2_session_set_user_data(session, this);
|
|
submited = NULL;
|
|
parsed = NULL;
|
|
stream_id = -1;
|
|
stream_closed = 0;
|
|
|
|
nghttp2_settings_entry settings[] = {
|
|
{NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, 100}
|
|
};
|
|
nghttp2_submit_settings(session, NGHTTP2_FLAG_NONE, settings, ARRAY_SIZE(settings));
|
|
state = H2_SEND_SETTINGS;
|
|
|
|
//nghttp2_submit_ping(session, NGHTTP2_FLAG_NONE, NULL);
|
|
//state = H2_SEND_PING;
|
|
}
|
|
|
|
Http2Parser::~Http2Parser() {
|
|
if (session) {
|
|
nghttp2_session_del(session);
|
|
session = NULL;
|
|
}
|
|
}
|
|
|
|
int Http2Parser::GetSendData(char** data, size_t* len) {
|
|
// HTTP2_MAGIC,HTTP2_SETTINGS,HTTP2_HEADERS
|
|
*len = nghttp2_session_mem_send(session, (const uint8_t**)data);
|
|
printd("nghttp2_session_mem_send %d\n", *len);
|
|
if (*len != 0) return *len;
|
|
|
|
if (submited == NULL) return 0;
|
|
// HTTP2_DATA
|
|
if (state == H2_SEND_HEADERS) {
|
|
void* content = submited->Content();
|
|
int content_length = submited->ContentLength();
|
|
// HTTP2 DATA framehd
|
|
state = H2_SEND_DATA_FRAME_HD;
|
|
http2_frame_hd framehd;
|
|
framehd.length = content_length;
|
|
framehd.type = HTTP2_DATA;
|
|
framehd.flags = HTTP2_FLAG_END_STREAM;
|
|
framehd.stream_id = stream_id;
|
|
*data = (char*)frame_hdbuf;
|
|
*len = HTTP2_FRAME_HDLEN;
|
|
printd("HTTP2 SEND_DATA_FRAME_HD...\n");
|
|
if (submited->ContentType() == APPLICATION_GRPC) {
|
|
grpc_message_hd msghd;
|
|
msghd.flags = 0;
|
|
msghd.length = content_length;
|
|
printd("grpc_message_hd: flags=%d length=%d\n", msghd.flags, msghd.length);
|
|
|
|
if (type == HTTP_SERVER) {
|
|
// grpc server send grpc-status in HTTP2 header frame
|
|
framehd.flags = HTTP2_FLAG_NONE;
|
|
|
|
/*
|
|
// @test protobuf
|
|
// message StringMessage {
|
|
// string str = 1;
|
|
// }
|
|
int protobuf_taglen = 0;
|
|
int tag = PROTOBUF_MAKE_TAG(1, WIRE_TYPE_LENGTH_DELIMITED);
|
|
unsigned char* p = frame_hdbuf + HTTP2_FRAME_HDLEN + GRPC_MESSAGE_HDLEN;
|
|
int bytes = varint_encode(tag, p);
|
|
protobuf_taglen += bytes;
|
|
p += bytes;
|
|
bytes = varint_encode(content_length, p);
|
|
protobuf_taglen += bytes;
|
|
msghd.length += protobuf_taglen;
|
|
framehd.length += protobuf_taglen;
|
|
*len += protobuf_taglen;
|
|
*/
|
|
}
|
|
|
|
grpc_message_hd_pack(&msghd, frame_hdbuf + HTTP2_FRAME_HDLEN);
|
|
framehd.length += GRPC_MESSAGE_HDLEN;
|
|
*len += GRPC_MESSAGE_HDLEN;
|
|
}
|
|
http2_frame_hd_pack(&framehd, frame_hdbuf);
|
|
}
|
|
else if (state == H2_SEND_DATA_FRAME_HD) {
|
|
// HTTP2 DATA
|
|
void* content = submited->Content();
|
|
int content_length = submited->ContentLength();
|
|
if (content_length == 0) {
|
|
// skip send_data
|
|
goto send_done;
|
|
}
|
|
else {
|
|
printd("HTTP2 SEND_DATA... content_length=%d\n", content_length);
|
|
state = H2_SEND_DATA;
|
|
*data = (char*)content;
|
|
*len = content_length;
|
|
}
|
|
}
|
|
else if (state == H2_SEND_DATA) {
|
|
send_done:
|
|
state = H2_SEND_DONE;
|
|
if (submited->ContentType() == APPLICATION_GRPC) {
|
|
if (type == HTTP_SERVER && stream_closed) {
|
|
// grpc HEADERS grpc-status
|
|
printd("grpc HEADERS grpc-status: 0\n");
|
|
int flags = NGHTTP2_FLAG_END_STREAM | NGHTTP2_FLAG_END_HEADERS;
|
|
nghttp2_nv nv = make_nv("grpc-status", "0");
|
|
nghttp2_submit_headers(session, flags, stream_id, NULL, &nv, 1, NULL);
|
|
*len = nghttp2_session_mem_send(session, (const uint8_t**)data);
|
|
}
|
|
}
|
|
}
|
|
|
|
printd("GetSendData %d\n", *len);
|
|
return *len;
|
|
}
|
|
|
|
int Http2Parser::FeedRecvData(const char* data, size_t len) {
|
|
printd("nghttp2_session_mem_recv %d\n", len);
|
|
state = H2_WANT_RECV;
|
|
size_t ret = nghttp2_session_mem_recv(session, (const uint8_t*)data, len);
|
|
if (ret != len) {
|
|
error = ret;
|
|
}
|
|
return (int)ret;
|
|
}
|
|
|
|
int Http2Parser::SubmitRequest(HttpRequest* req) {
|
|
submited = req;
|
|
|
|
req->FillContentType();
|
|
req->FillContentLength();
|
|
if (req->ContentType() == APPLICATION_GRPC) {
|
|
req->method = HTTP_POST;
|
|
req->headers["te"] = "trailers";
|
|
req->headers["user-agent"] = "grpc-c++/1.16.0 grpc-c/6.0.0 (linux; nghttp2; hw)";
|
|
req->headers["accept-encoding"] = "identity";
|
|
req->headers["grpc-accept-encoding"] = "identity";
|
|
}
|
|
|
|
std::vector<nghttp2_nv> nvs;
|
|
char c_str[256] = {0};
|
|
req->ParseUrl();
|
|
nvs.push_back(make_nv(":method", http_method_str(req->method)));
|
|
nvs.push_back(make_nv(":path", req->path.c_str()));
|
|
nvs.push_back(make_nv(":scheme", req->scheme.c_str()));
|
|
if (req->port == 0 ||
|
|
req->port == DEFAULT_HTTP_PORT ||
|
|
req->port == DEFAULT_HTTPS_PORT) {
|
|
nvs.push_back(make_nv(":authority", req->host.c_str()));
|
|
}
|
|
else {
|
|
snprintf(c_str, sizeof(c_str), "%s:%d", req->host.c_str(), req->port);
|
|
nvs.push_back(make_nv(":authority", c_str));
|
|
}
|
|
const char* name;
|
|
const char* value;
|
|
for (auto& header : req->headers) {
|
|
name = header.first.c_str();
|
|
value = header.second.c_str();
|
|
hv_strlower((char*)name);
|
|
if (strcmp(name, "host") == 0) {
|
|
// :authority
|
|
continue;
|
|
}
|
|
if (strcmp(name, "connection") == 0) {
|
|
// HTTP2 default keep-alive
|
|
continue;
|
|
}
|
|
if (strcmp(name, "content-length") == 0) {
|
|
// HTTP2 have frame_hd.length
|
|
continue;
|
|
}
|
|
nvs.push_back(make_nv2(name, value, header.first.size(), header.second.size()));
|
|
}
|
|
int flags = NGHTTP2_FLAG_END_HEADERS;
|
|
// we set EOS on DATA frame
|
|
stream_id = nghttp2_submit_headers(session, flags, -1, NULL, &nvs[0], nvs.size(), NULL);
|
|
// avoid DATA_SOURCE_COPY, we do not use nghttp2_submit_data
|
|
// nghttp2_data_provider data_prd;
|
|
// data_prd.read_callback = data_source_read_callback;
|
|
//stream_id = nghttp2_submit_request(session, NULL, &nvs[0], nvs.size(), &data_prd, NULL);
|
|
state = H2_SEND_HEADERS;
|
|
return 0;
|
|
}
|
|
|
|
int Http2Parser::SubmitResponse(HttpResponse* res) {
|
|
submited = res;
|
|
|
|
res->FillContentType();
|
|
res->FillContentLength();
|
|
if (parsed && parsed->ContentType() == APPLICATION_GRPC) {
|
|
// correct content_type: application/grpc
|
|
if (res->ContentType() != APPLICATION_GRPC) {
|
|
res->content_type = APPLICATION_GRPC;
|
|
res->headers["content-type"] = http_content_type_str(APPLICATION_GRPC);
|
|
}
|
|
//res->headers["accept-encoding"] = "identity";
|
|
//res->headers["grpc-accept-encoding"] = "identity";
|
|
//res->headers["grpc-status"] = "0";
|
|
//res->status_code = HTTP_STATUS_OK;
|
|
}
|
|
|
|
std::vector<nghttp2_nv> nvs;
|
|
char c_str[256] = {0};
|
|
snprintf(c_str, sizeof(c_str), "%d", res->status_code);
|
|
nvs.push_back(make_nv(":status", c_str));
|
|
const char* name;
|
|
const char* value;
|
|
for (auto& header : res->headers) {
|
|
name = header.first.c_str();
|
|
value = header.second.c_str();
|
|
hv_strlower((char*)name);
|
|
if (strcmp(name, "connection") == 0) {
|
|
// HTTP2 default keep-alive
|
|
continue;
|
|
}
|
|
if (strcmp(name, "content-length") == 0) {
|
|
// HTTP2 have frame_hd.length
|
|
continue;
|
|
}
|
|
nvs.push_back(make_nv2(name, value, header.first.size(), header.second.size()));
|
|
}
|
|
int flags = NGHTTP2_FLAG_END_HEADERS;
|
|
// we set EOS on DATA frame
|
|
if (stream_id == -1) {
|
|
// upgrade
|
|
nghttp2_session_upgrade(session, NULL, 0, NULL);
|
|
stream_id = 1;
|
|
}
|
|
nghttp2_submit_headers(session, flags, stream_id, NULL, &nvs[0], nvs.size(), NULL);
|
|
// avoid DATA_SOURCE_COPY, we do not use nghttp2_submit_data
|
|
// data_prd.read_callback = data_source_read_callback;
|
|
//nghttp2_submit_response(session, stream_id, &nvs[0], nvs.size(), &data_prd);
|
|
state = H2_SEND_HEADERS;
|
|
return 0;
|
|
}
|
|
|
|
int Http2Parser::InitResponse(HttpResponse* res) {
|
|
res->Reset();
|
|
res->http_major = 2;
|
|
res->http_minor = 0;
|
|
parsed = res;
|
|
return 0;
|
|
}
|
|
|
|
int Http2Parser::InitRequest(HttpRequest* req) {
|
|
req->Reset();
|
|
req->http_major = 2;
|
|
req->http_minor = 0;
|
|
parsed = req;
|
|
return 0;
|
|
}
|
|
|
|
nghttp2_session_callbacks* Http2Parser::cbs = NULL;
|
|
|
|
int on_header_callback(nghttp2_session *session,
|
|
const nghttp2_frame *frame,
|
|
const uint8_t *_name, size_t namelen,
|
|
const uint8_t *_value, size_t valuelen,
|
|
uint8_t flags, void *userdata) {
|
|
printd("on_header_callback\n");
|
|
print_frame_hd(&frame->hd);
|
|
const char* name = (const char*)_name;
|
|
const char* value = (const char*)_value;
|
|
printd("%s: %s\n", name, value);
|
|
Http2Parser* hp = (Http2Parser*)userdata;
|
|
if (*name == ':') {
|
|
if (hp->parsed->type == HTTP_REQUEST) {
|
|
// :method :path :scheme :authority
|
|
HttpRequest* req = (HttpRequest*)hp->parsed;
|
|
if (strcmp(name, ":method") == 0) {
|
|
req->method = http_method_enum(value);
|
|
}
|
|
else if (strcmp(name, ":path") == 0) {
|
|
req->url = value;
|
|
}
|
|
else if (strcmp(name, ":scheme") == 0) {
|
|
req->headers["Scheme"] = value;
|
|
}
|
|
else if (strcmp(name, ":authority") == 0) {
|
|
req->headers["Host"] = value;
|
|
}
|
|
}
|
|
else if (hp->parsed->type == HTTP_RESPONSE) {
|
|
HttpResponse* res = (HttpResponse*)hp->parsed;
|
|
if (strcmp(name, ":status") == 0) {
|
|
res->status_code = (http_status)atoi(value);
|
|
if (res->http_cb) {
|
|
res->http_cb(res, HP_MESSAGE_BEGIN, NULL, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
hp->parsed->headers[name] = value;
|
|
if (strcmp(name, "content-type") == 0) {
|
|
hp->parsed->content_type = http_content_type_enum(value);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int on_data_chunk_recv_callback(nghttp2_session *session,
|
|
uint8_t flags, int32_t stream_id, const uint8_t *data,
|
|
size_t len, void *userdata) {
|
|
printd("on_data_chunk_recv_callback\n");
|
|
printd("stream_id=%d length=%d\n", stream_id, (int)len);
|
|
//printd("%.*s\n", (int)len, data);
|
|
Http2Parser* hp = (Http2Parser*)userdata;
|
|
|
|
if (hp->parsed->ContentType() == APPLICATION_GRPC) {
|
|
// grpc_message_hd
|
|
if (len >= GRPC_MESSAGE_HDLEN) {
|
|
grpc_message_hd msghd;
|
|
grpc_message_hd_unpack(&msghd, data);
|
|
printd("grpc_message_hd: flags=%d length=%d\n", msghd.flags, msghd.length);
|
|
data += GRPC_MESSAGE_HDLEN;
|
|
len -= GRPC_MESSAGE_HDLEN;
|
|
//printd("%.*s\n", (int)len, data);
|
|
}
|
|
}
|
|
if (hp->parsed->http_cb) {
|
|
hp->parsed->http_cb(hp->parsed, HP_BODY, (const char*)data, len);
|
|
} else {
|
|
hp->parsed->body.append((const char*)data, len);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int on_frame_recv_callback(nghttp2_session *session,
|
|
const nghttp2_frame *frame, void *userdata) {
|
|
printd("on_frame_recv_callback\n");
|
|
print_frame_hd(&frame->hd);
|
|
Http2Parser* hp = (Http2Parser*)userdata;
|
|
switch (frame->hd.type) {
|
|
case NGHTTP2_DATA:
|
|
hp->state = H2_RECV_DATA;
|
|
break;
|
|
case NGHTTP2_HEADERS:
|
|
hp->state = H2_RECV_HEADERS;
|
|
break;
|
|
case NGHTTP2_SETTINGS:
|
|
hp->state = H2_RECV_SETTINGS;
|
|
break;
|
|
case NGHTTP2_PING:
|
|
hp->state = H2_RECV_PING;
|
|
break;
|
|
case NGHTTP2_RST_STREAM:
|
|
case NGHTTP2_WINDOW_UPDATE:
|
|
// ignore
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
if (hp->state == H2_RECV_HEADERS && hp->parsed->http_cb) {
|
|
hp->parsed->http_cb(hp->parsed, HP_HEADERS_COMPLETE, NULL, 0);
|
|
}
|
|
if (frame->hd.stream_id >= hp->stream_id) {
|
|
hp->stream_id = frame->hd.stream_id;
|
|
hp->stream_closed = 0;
|
|
if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
|
|
printd("on_stream_closed stream_id=%d\n", hp->stream_id);
|
|
hp->stream_closed = 1;
|
|
hp->frame_type_when_stream_closed = frame->hd.type;
|
|
if (hp->state == H2_RECV_HEADERS || hp->state == H2_RECV_DATA) {
|
|
if (hp->parsed->http_cb) {
|
|
hp->parsed->http_cb(hp->parsed, HP_MESSAGE_COMPLETE, NULL, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|