IntenseWebs/nginx
3
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2025-02-25 18:55:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

HTTP/3: server pushes.

Browse Source 
New directives are added:
- http3_max_concurrent_pushes
- http3_push
- http3_push_preload
This commit is contained in:
Roman Arutyunyan 2020-07-23 13:41:24 +03:00
parent 77384356ce
commit 6d064c94e0
7 changed files with 1020 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/http/ngx_http.h
View File

@ -93,6 +93,7 @@ ngx_int_t ngx_http_add_listen(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
void ngx_http_init_connection(ngx_connection_t *c);
void ngx_http_close_connection(ngx_connection_t *c);
u_char *ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len);
#if (NGX_HTTP_SSL && defined SSL_CTRL_SET_TLSEXT_HOSTNAME)
int ngx_http_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg);

3
src/http/ngx_http_request.c
View File

@ -55,7 +55,6 @@ static ngx_int_t ngx_http_post_action(ngx_http_request_t *r);
static void ngx_http_close_request(ngx_http_request_t *r, ngx_int_t error);
static void ngx_http_log_request(ngx_http_request_t *r);
static u_char *ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len);
static u_char *ngx_http_log_error_handler(ngx_http_request_t *r,
ngx_http_request_t *sr, u_char *buf, size_t len);
@ -3838,7 +3837,7 @@ ngx_http_close_connection(ngx_connection_t *c)
}
static u_char *
u_char *
ngx_http_log_error(ngx_log_t *log, u_char *buf, size_t len)
{
u_char *p;

21
src/http/v3/ngx_http_v3.h
View File

@ -50,6 +50,7 @@
#define NGX_HTTP_V3_DEFAULT_MAX_FIELD_SIZE 4096
#define NGX_HTTP_V3_DEFAULT_MAX_TABLE_CAPACITY 16384
#define NGX_HTTP_V3_DEFAULT_MAX_BLOCKED_STREAMS 16
#define NGX_HTTP_V3_DEFAULT_MAX_CONCURRENT_PUSHES 10
/* HTTP/3 errors */
#define NGX_HTTP_V3_ERR_NO_ERROR 0x100
@ -89,9 +90,17 @@ typedef struct {
size_t max_field_size;
size_t max_table_capacity;
ngx_uint_t max_blocked_streams;
ngx_uint_t max_concurrent_pushes;
} ngx_http_v3_srv_conf_t;
typedef struct {
ngx_flag_t push_preload;
ngx_flag_t push;
ngx_array_t *pushes;
} ngx_http_v3_loc_conf_t;
typedef struct {
ngx_str_t name;
ngx_str_t value;
@ -110,8 +119,15 @@ typedef struct {
typedef struct {
ngx_http_connection_t hc;
ngx_http_v3_dynamic_table_t table;
ngx_queue_t blocked;
ngx_uint_t nblocked;
ngx_queue_t pushing;
ngx_uint_t npushing;
uint64_t next_push_id;
uint64_t max_push_id;
ngx_uint_t settings_sent;
/* unsigned settings_sent:1; */
ngx_connection_t *known_streams[NGX_HTTP_V3_MAX_KNOWN_STREAM];
@ -144,6 +160,8 @@ uintptr_t ngx_http_v3_encode_header_pbi(u_char *p, ngx_uint_t index);
uintptr_t ngx_http_v3_encode_header_lpbi(u_char *p, ngx_uint_t index,
u_char *data, size_t len);
ngx_connection_t *ngx_http_v3_create_push_stream(ngx_connection_t *c,
uint64_t push_id);
ngx_int_t ngx_http_v3_ref_insert(ngx_connection_t *c, ngx_uint_t dynamic,
ngx_uint_t index, ngx_str_t *value);
ngx_int_t ngx_http_v3_insert(ngx_connection_t *c, ngx_str_t *name,
@ -163,6 +181,9 @@ ngx_int_t ngx_http_v3_check_insert_count(ngx_connection_t *c,
ngx_uint_t insert_count);
ngx_int_t ngx_http_v3_set_param(ngx_connection_t *c, uint64_t id,
uint64_t value);
ngx_int_t ngx_http_v3_set_max_push_id(ngx_connection_t *c,
uint64_t max_push_id);
ngx_int_t ngx_http_v3_cancel_push(ngx_connection_t *c, uint64_t push_id);
ngx_int_t ngx_http_v3_client_ref_insert(ngx_connection_t *c, ngx_uint_t dynamic,
ngx_uint_t index, ngx_str_t *value);

133
src/http/v3/ngx_http_v3_module.c
View File

@ -16,6 +16,10 @@ static ngx_int_t ngx_http_v3_add_variables(ngx_conf_t *cf);
static void *ngx_http_v3_create_srv_conf(ngx_conf_t *cf);
static char *ngx_http_v3_merge_srv_conf(ngx_conf_t *cf, void *parent,
void *child);
static void *ngx_http_v3_create_loc_conf(ngx_conf_t *cf);
static char *ngx_http_v3_merge_loc_conf(ngx_conf_t *cf, void *parent,
void *child);
static char *ngx_http_v3_push(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static ngx_command_t ngx_http_v3_commands[] = {
@ -41,6 +45,27 @@ static ngx_command_t ngx_http_v3_commands[] = {
offsetof(ngx_http_v3_srv_conf_t, max_blocked_streams),
NULL },
{ ngx_string("http3_max_concurrent_pushes"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
ngx_conf_set_num_slot,
NGX_HTTP_SRV_CONF_OFFSET,
offsetof(ngx_http_v3_srv_conf_t, max_concurrent_pushes),
NULL },
{ ngx_string("http3_push"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
ngx_http_v3_push,
NGX_HTTP_LOC_CONF_OFFSET,
0,
NULL },
{ ngx_string("http3_push_preload"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
ngx_conf_set_flag_slot,
NGX_HTTP_LOC_CONF_OFFSET,
offsetof(ngx_http_v3_loc_conf_t, push_preload),
NULL },
ngx_null_command
};
@ -55,8 +80,8 @@ static ngx_http_module_t ngx_http_v3_module_ctx = {
ngx_http_v3_create_srv_conf, /* create server configuration */
ngx_http_v3_merge_srv_conf, /* merge server configuration */
NULL, /* create location configuration */
NULL /* merge location configuration */
ngx_http_v3_create_loc_conf, /* create location configuration */
ngx_http_v3_merge_loc_conf /* merge location configuration */
};
@ -135,6 +160,7 @@ ngx_http_v3_create_srv_conf(ngx_conf_t *cf)
h3scf->max_field_size = NGX_CONF_UNSET_SIZE;
h3scf->max_table_capacity = NGX_CONF_UNSET_SIZE;
h3scf->max_blocked_streams = NGX_CONF_UNSET_UINT;
h3scf->max_concurrent_pushes = NGX_CONF_UNSET_UINT;
return h3scf;
}
@ -158,5 +184,108 @@ ngx_http_v3_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
prev->max_blocked_streams,
NGX_HTTP_V3_DEFAULT_MAX_BLOCKED_STREAMS);
ngx_conf_merge_uint_value(conf->max_concurrent_pushes,
prev->max_concurrent_pushes,
NGX_HTTP_V3_DEFAULT_MAX_CONCURRENT_PUSHES);
return NGX_CONF_OK;
}
static void *
ngx_http_v3_create_loc_conf(ngx_conf_t *cf)
{
ngx_http_v3_loc_conf_t *h3lcf;
h3lcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_v3_loc_conf_t));
if (h3lcf == NULL) {
return NULL;
}
/*
* set by ngx_pcalloc():
*
* h3lcf->pushes = NULL;
*/
h3lcf->push_preload = NGX_CONF_UNSET;
h3lcf->push = NGX_CONF_UNSET;
return h3lcf;
}
static char *
ngx_http_v3_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_v3_loc_conf_t *prev = parent;
ngx_http_v3_loc_conf_t *conf = child;
ngx_conf_merge_value(conf->push, prev->push, 1);
if (conf->push && conf->pushes == NULL) {
conf->pushes = prev->pushes;
}
ngx_conf_merge_value(conf->push_preload, prev->push_preload, 0);
return NGX_CONF_OK;
}
static char *
ngx_http_v3_push(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_v3_loc_conf_t *h3lcf = conf;
ngx_str_t *value;
ngx_http_complex_value_t *cv;
ngx_http_compile_complex_value_t ccv;
value = cf->args->elts;
if (ngx_strcmp(value[1].data, "off") == 0) {
if (h3lcf->pushes) {
return "\"off\" parameter cannot be used with URI";
}
if (h3lcf->push == 0) {
return "is duplicate";
}
h3lcf->push = 0;
return NGX_CONF_OK;
}
if (h3lcf->push == 0) {
return "URI cannot be used with \"off\" parameter";
}
h3lcf->push = 1;
if (h3lcf->pushes == NULL) {
h3lcf->pushes = ngx_array_create(cf->pool, 1,
sizeof(ngx_http_complex_value_t));
if (h3lcf->pushes == NULL) {
return NGX_CONF_ERROR;
}
}
cv = ngx_array_push(h3lcf->pushes);
if (cv == NULL) {
return NGX_CONF_ERROR;
}
ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
ccv.cf = cf;
ccv.value = &value[1];
ccv.complex_value = cv;
if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}

36
src/http/v3/ngx_http_v3_parse.c
View File

@ -933,6 +933,7 @@ ngx_http_v3_parse_control(ngx_connection_t *c, void *data, u_char ch)
sw_first_type,
sw_type,
sw_length,
sw_cancel_push,
sw_settings,
sw_max_push_id,
sw_skip
@ -988,6 +989,10 @@ ngx_http_v3_parse_control(ngx_connection_t *c, void *data, u_char ch)
switch (st->type) {
case NGX_HTTP_V3_FRAME_CANCEL_PUSH:
st->state = sw_cancel_push;
break;
case NGX_HTTP_V3_FRAME_SETTINGS:
st->state = sw_settings;
break;
@ -1004,6 +1009,26 @@ ngx_http_v3_parse_control(ngx_connection_t *c, void *data, u_char ch)
break;
case sw_cancel_push:
rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch);
if (--st->length == 0 && rc == NGX_AGAIN) {
return NGX_HTTP_V3_ERR_FRAME_ERROR;
}
if (rc != NGX_DONE) {
return rc;
}
rc = ngx_http_v3_cancel_push(c, st->vlint.value);
if (rc != NGX_OK) {
return rc;
}
st->state = sw_type;
break;
case sw_settings:
rc = ngx_http_v3_parse_settings(c, &st->settings, ch);
@ -1025,12 +1050,19 @@ ngx_http_v3_parse_control(ngx_connection_t *c, void *data, u_char ch)
case sw_max_push_id:
rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch);
if (--st->length == 0 && rc == NGX_AGAIN) {
return NGX_HTTP_V3_ERR_FRAME_ERROR;
}
if (rc != NGX_DONE) {
return rc;
}
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
"http3 parse MAX_PUSH_ID:%uL", st->vlint.value);
rc = ngx_http_v3_set_max_push_id(c, st->vlint.value);
if (rc != NGX_OK) {
return rc;
}
st->state = sw_type;
break;

704
src/http/v3/ngx_http_v3_request.c
View File

@ -11,18 +11,37 @@
/* static table indices */
#define NGX_HTTP_V3_HEADER_AUTHORITY 0
#define NGX_HTTP_V3_HEADER_PATH_ROOT 1
#define NGX_HTTP_V3_HEADER_CONTENT_LENGTH_ZERO 4
#define NGX_HTTP_V3_HEADER_DATE 6
#define NGX_HTTP_V3_HEADER_LAST_MODIFIED 10
#define NGX_HTTP_V3_HEADER_LOCATION 12
#define NGX_HTTP_V3_HEADER_METHOD_GET 17
#define NGX_HTTP_V3_HEADER_SCHEME_HTTP 22
#define NGX_HTTP_V3_HEADER_SCHEME_HTTPS 23
#define NGX_HTTP_V3_HEADER_STATUS_200 25
#define NGX_HTTP_V3_HEADER_ACCEPT_ENCODING 31
#define NGX_HTTP_V3_HEADER_CONTENT_TYPE_TEXT_PLAIN 53
#define NGX_HTTP_V3_HEADER_VARY_ACCEPT_ENCODING 59
#define NGX_HTTP_V3_HEADER_ACCEPT_LANGUAGE 72
#define NGX_HTTP_V3_HEADER_SERVER 92
#define NGX_HTTP_V3_HEADER_USER_AGENT 95
static ngx_int_t ngx_http_v3_process_pseudo_header(ngx_http_request_t *r,
ngx_str_t *name, ngx_str_t *value);
static ngx_int_t ngx_http_v3_push_resources(ngx_http_request_t *r,
ngx_chain_t ***out);
static ngx_int_t ngx_http_v3_push_resource(ngx_http_request_t *r,
ngx_str_t *path, ngx_chain_t ***out);
static ngx_int_t ngx_http_v3_create_push_request(
ngx_http_request_t *pr, ngx_str_t *path, uint64_t push_id);
static ngx_int_t ngx_http_v3_set_push_header(ngx_http_request_t *r,
const char *name, ngx_str_t *value);
static void ngx_http_v3_push_request_handler(ngx_event_t *ev);
static ngx_chain_t *ngx_http_v3_create_push_promise(ngx_http_request_t *r,
ngx_str_t *path, uint64_t push_id);
struct {
@ -431,7 +450,7 @@ ngx_http_v3_create_header(ngx_http_request_t *r)
ngx_buf_t *b;
ngx_str_t host;
ngx_uint_t i, port;
ngx_chain_t *hl, *cl, *bl;
ngx_chain_t *out, *hl, *cl, **ll;
ngx_list_part_t *part;
ngx_table_elt_t *header;
ngx_connection_t *c;
@ -443,6 +462,17 @@ ngx_http_v3_create_header(ngx_http_request_t *r)
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 create header");
out = NULL;
ll = &out;
if ((c->qs->id & NGX_QUIC_STREAM_UNIDIRECTIONAL) == 0
&& r->method != NGX_HTTP_HEAD)
{
if (ngx_http_v3_push_resources(r, &ll) != NGX_OK) {
return NULL;
}
}
len = ngx_http_v3_encode_header_block_prefix(NULL, 0, 0, 0);
if (r->headers_out.status == NGX_HTTP_OK) {
@ -796,6 +826,9 @@ ngx_http_v3_create_header(ngx_http_request_t *r)
hl->buf = b;
hl->next = cl;
*ll = hl;
ll = &cl->next;
if (r->headers_out.content_length_n >= 0 && !r->header_only) {
len = ngx_http_v3_encode_varlen_int(NULL, NGX_HTTP_V3_FRAME_DATA)
+ ngx_http_v3_encode_varlen_int(NULL,
@ -811,17 +844,18 @@ ngx_http_v3_create_header(ngx_http_request_t *r)
b->last = (u_char *) ngx_http_v3_encode_varlen_int(b->last,
r->headers_out.content_length_n);
bl = ngx_alloc_chain_link(c->pool);
if (bl == NULL) {
cl = ngx_alloc_chain_link(c->pool);
if (cl == NULL) {
return NULL;
}
bl->buf = b;
bl->next = NULL;
cl->next = bl;
cl->buf = b;
cl->next = NULL;
*ll = cl;
}
return hl;
return out;
}
@ -853,3 +887,659 @@ ngx_http_v3_create_trailers(ngx_http_request_t *r)
return cl;
}
static ngx_int_t
ngx_http_v3_push_resources(ngx_http_request_t *r, ngx_chain_t ***out)
{
u_char *start, *end, *last;
ngx_str_t path;
ngx_int_t rc;
ngx_uint_t i, push;
ngx_table_elt_t **h;
ngx_http_v3_loc_conf_t *h3lcf;
ngx_http_complex_value_t *pushes;
h3lcf = ngx_http_get_module_loc_conf(r, ngx_http_v3_module);
if (h3lcf->pushes) {
pushes = h3lcf->pushes->elts;
for (i = 0; i < h3lcf->pushes->nelts; i++) {
if (ngx_http_complex_value(r, &pushes[i], &path) != NGX_OK) {
return NGX_ERROR;
}
if (path.len == 0) {
continue;
}
if (path.len == 3 && ngx_strncmp(path.data, "off", 3) == 0) {
continue;
}
rc = ngx_http_v3_push_resource(r, &path, out);
if (rc == NGX_ERROR) {
return NGX_ERROR;
}
if (rc == NGX_ABORT) {
return NGX_OK;
}
/* NGX_OK, NGX_DECLINED */
}
}
if (!h3lcf->push_preload) {
return NGX_OK;
}
h = r->headers_out.link.elts;
for (i = 0; i < r->headers_out.link.nelts; i++) {
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http3 parse link: \"%V\"", &h[i]->value);
start = h[i]->value.data;
end = h[i]->value.data + h[i]->value.len;
next_link:
while (start < end && *start == ' ') { start++; }
if (start == end || *start++ != '<') {
continue;
}
while (start < end && *start == ' ') { start++; }
for (last = start; last < end && *last != '>'; last++) {
/* void */
}
if (last == start || last == end) {
continue;
}
path.len = last - start;
path.data = start;
start = last + 1;
while (start < end && *start == ' ') { start++; }
if (start == end) {
continue;
}
if (*start == ',') {
start++;
goto next_link;
}
if (*start++ != ';') {
continue;
}
last = ngx_strlchr(start, end, ',');
if (last == NULL) {
last = end;
}
push = 0;
for ( ;; ) {
while (start < last && *start == ' ') { start++; }
if (last - start >= 6
&& ngx_strncasecmp(start, (u_char *) "nopush", 6) == 0)
{
start += 6;
if (start == last || *start == ' ' || *start == ';') {
push = 0;
break;
}
goto next_param;
}
if (last - start >= 11
&& ngx_strncasecmp(start, (u_char *) "rel=preload", 11) == 0)
{
start += 11;
if (start == last || *start == ' ' || *start == ';') {
push = 1;
}
goto next_param;
}
if (last - start >= 4
&& ngx_strncasecmp(start, (u_char *) "rel=", 4) == 0)
{
start += 4;
while (start < last && *start == ' ') { start++; }
if (start == last || *start++ != '"') {
goto next_param;
}
for ( ;; ) {
while (start < last && *start == ' ') { start++; }
if (last - start >= 7
&& ngx_strncasecmp(start, (u_char *) "preload", 7) == 0)
{
start += 7;
if (start < last && (*start == ' ' || *start == '"')) {
push = 1;
break;
}
}
while (start < last && *start != ' ' && *start != '"') {
start++;
}
if (start == last) {
break;
}
if (*start == '"') {
break;
}
start++;
}
}
next_param:
start = ngx_strlchr(start, last, ';');
if (start == NULL) {
break;
}
start++;
}
if (push) {
while (path.len && path.data[path.len - 1] == ' ') {
path.len--;
}
}
if (push && path.len
&& !(path.len > 1 && path.data[0] == '/' && path.data[1] == '/'))
{
rc = ngx_http_v3_push_resource(r, &path, out);
if (rc == NGX_ERROR) {
return NGX_ERROR;
}
if (rc == NGX_ABORT) {
return NGX_OK;
}
/* NGX_OK, NGX_DECLINED */
}
if (last < end) {
start = last + 1;
goto next_link;
}
}
return NGX_OK;
}
static ngx_int_t
ngx_http_v3_push_resource(ngx_http_request_t *r, ngx_str_t *path,
ngx_chain_t ***ll)
{
uint64_t push_id;
ngx_int_t rc;
ngx_chain_t *cl;
ngx_connection_t *c;
ngx_http_v3_srv_conf_t *h3scf;
ngx_http_v3_connection_t *h3c;
c = r->connection;
h3c = c->qs->parent->data;
h3scf = ngx_http_get_module_srv_conf(r, ngx_http_v3_module);
ngx_log_debug5(NGX_LOG_DEBUG_HTTP, c->log, 0,
"http3 push \"%V\" pushing:%ui/%ui id:%uL/%uL",
path, h3c->npushing, h3scf->max_concurrent_pushes,
h3c->next_push_id, h3c->max_push_id);
if (!ngx_path_separator(path->data[0])) {
ngx_log_error(NGX_LOG_WARN, c->log, 0,
"non-absolute path \"%V\" not pushed", path);
return NGX_DECLINED;
}
if (h3c->next_push_id > h3c->max_push_id) {
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
"http3 abort pushes due to max_push_id");
return NGX_ABORT;
}
if (h3c->npushing >= h3scf->max_concurrent_pushes) {
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
"http3 abort pushes due to max_concurrent_pushes");
return NGX_ABORT;
}
push_id = h3c->next_push_id++;
rc = ngx_http_v3_create_push_request(r, path, push_id);
if (rc != NGX_OK) {
return rc;
}
cl = ngx_http_v3_create_push_promise(r, path, push_id);
if (cl == NULL) {
return NGX_ERROR;
}
for (**ll = cl; **ll; *ll = &(**ll)->next);
return NGX_OK;
}
static ngx_int_t
ngx_http_v3_create_push_request(ngx_http_request_t *pr, ngx_str_t *path,
uint64_t push_id)
{
ngx_pool_t *pool;
ngx_connection_t *c, *pc;
ngx_http_request_t *r;
ngx_http_log_ctx_t *ctx;
ngx_http_connection_t *hc;
ngx_http_core_srv_conf_t *cscf;
ngx_http_v3_connection_t *h3c;
pc = pr->connection;
r = NULL;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
"http3 create push request id:%uL", push_id);
c = ngx_http_v3_create_push_stream(pc, push_id);
if (c == NULL) {
return NGX_ABORT;
}
hc = ngx_palloc(c->pool, sizeof(ngx_http_connection_t));
if (hc == NULL) {
goto failed;
}
h3c = c->qs->parent->data;
ngx_memcpy(hc, h3c, sizeof(ngx_http_connection_t));
c->data = hc;
ctx = ngx_palloc(c->pool, sizeof(ngx_http_log_ctx_t));
if (ctx == NULL) {
goto failed;
}
ctx->connection = c;
ctx->request = NULL;
ctx->current_request = NULL;
c->log->handler = ngx_http_log_error;
c->log->data = ctx;
c->log->action = "processing pushed request headers";
c->log_error = NGX_ERROR_INFO;
r = ngx_http_create_request(c);
if (r == NULL) {
goto failed;
}
c->data = r;
ngx_str_set(&r->http_protocol, "HTTP/3.0");
r->method_name = ngx_http_core_get_method;
r->method = NGX_HTTP_GET;
cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
r->header_in = ngx_create_temp_buf(r->pool,
cscf->client_header_buffer_size);
if (r->header_in == NULL) {
goto failed;
}
if (ngx_list_init(&r->headers_in.headers, r->pool, 4,
sizeof(ngx_table_elt_t))
!= NGX_OK)
{
goto failed;
}
r->headers_in.connection_type = NGX_HTTP_CONNECTION_CLOSE;
r->schema.data = ngx_pstrdup(r->pool, &pr->schema);
if (r->schema.data == NULL) {
goto failed;
}
r->schema.len = pr->schema.len;
r->uri_start = ngx_pstrdup(r->pool, path);
if (r->uri_start == NULL) {
goto failed;
}
r->uri_end = r->uri_start + path->len;
if (ngx_http_parse_uri(r) != NGX_OK) {
goto failed;
}
if (ngx_http_process_request_uri(r) != NGX_OK) {
goto failed;
}
if (ngx_http_v3_set_push_header(r, "host", &pr->headers_in.server)
!= NGX_OK)
{
goto failed;
}
if (pr->headers_in.accept_encoding) {
if (ngx_http_v3_set_push_header(r, "accept-encoding",
&pr->headers_in.accept_encoding->value)
!= NGX_OK)
{
goto failed;
}
}
if (pr->headers_in.accept_language) {
if (ngx_http_v3_set_push_header(r, "accept-language",
&pr->headers_in.accept_language->value)
!= NGX_OK)
{
goto failed;
}
}
if (pr->headers_in.user_agent) {
if (ngx_http_v3_set_push_header(r, "user-agent",
&pr->headers_in.user_agent->value)
!= NGX_OK)
{
goto failed;
}
}
c->read->handler = ngx_http_v3_push_request_handler;
c->read->handler = ngx_http_v3_push_request_handler;
ngx_post_event(c->read, &ngx_posted_events);
return NGX_OK;
failed:
if (r) {
ngx_http_free_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
}
c->destroyed = 1;
pool = c->pool;
ngx_close_connection(c);
ngx_destroy_pool(pool);
return NGX_ERROR;
}
static ngx_int_t
ngx_http_v3_set_push_header(ngx_http_request_t *r, const char *name,
ngx_str_t *value)
{
u_char *p;
ngx_table_elt_t *h;
ngx_http_header_t *hh;
ngx_http_core_main_conf_t *cmcf;
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http3 push header \"%s\": \"%V\"", name, value);
cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
p = ngx_pnalloc(r->pool, value->len + 1);
if (p == NULL) {
return NGX_ERROR;
}
ngx_memcpy(p, value->data, value->len);
p[value->len] = '\0';
h = ngx_list_push(&r->headers_in.headers);
if (h == NULL) {
return NGX_ERROR;
}
h->key.data = (u_char *) name;
h->key.len = ngx_strlen(name);
h->hash = ngx_hash_key(h->key.data, h->key.len);
h->lowcase_key = (u_char *) name;
h->value.data = p;
h->value.len = value->len;
hh = ngx_hash_find(&cmcf->headers_in_hash, h->hash,
h->lowcase_key, h->key.len);
if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
return NGX_ERROR;
}
return NGX_OK;
}
static void
ngx_http_v3_push_request_handler(ngx_event_t *ev)
{
ngx_connection_t *c;
ngx_http_request_t *r;
c = ev->data;
r = c->data;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 push request handler");
ngx_http_process_request(r);
}
static ngx_chain_t *
ngx_http_v3_create_push_promise(ngx_http_request_t *r, ngx_str_t *path,
uint64_t push_id)
{
size_t n, len;
ngx_buf_t *b;
ngx_chain_t *hl, *cl;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http3 create push promise id:%uL", push_id);
len = ngx_http_v3_encode_varlen_int(NULL, push_id);
len += ngx_http_v3_encode_header_block_prefix(NULL, 0, 0, 0);
len += ngx_http_v3_encode_header_ri(NULL, 0,
NGX_HTTP_V3_HEADER_METHOD_GET);
len += ngx_http_v3_encode_header_lri(NULL, 0,
NGX_HTTP_V3_HEADER_AUTHORITY,
NULL, r->headers_in.server.len);
if (path->len == 1 && path->data[0] == '/') {
len += ngx_http_v3_encode_header_ri(NULL, 0,
NGX_HTTP_V3_HEADER_PATH_ROOT);
} else {
len += ngx_http_v3_encode_header_lri(NULL, 0,
NGX_HTTP_V3_HEADER_PATH_ROOT,
NULL, path->len);
}
if (r->schema.len == 5 && ngx_strncmp(r->schema.data, "https", 5) == 0) {
len += ngx_http_v3_encode_header_ri(NULL, 0,
NGX_HTTP_V3_HEADER_SCHEME_HTTPS);
} else if (r->schema.len == 4
&& ngx_strncmp(r->schema.data, "http", 4) == 0)
{
len += ngx_http_v3_encode_header_ri(NULL, 0,
NGX_HTTP_V3_HEADER_SCHEME_HTTP);
} else {
len += ngx_http_v3_encode_header_lri(NULL, 0,
NGX_HTTP_V3_HEADER_SCHEME_HTTP,
NULL, r->schema.len);
}
if (r->headers_in.accept_encoding) {
len += ngx_http_v3_encode_header_lri(NULL, 0,
NGX_HTTP_V3_HEADER_ACCEPT_ENCODING, NULL,
r->headers_in.accept_encoding->value.len);
}
if (r->headers_in.accept_language) {
len += ngx_http_v3_encode_header_lri(NULL, 0,
NGX_HTTP_V3_HEADER_ACCEPT_LANGUAGE, NULL,
r->headers_in.accept_language->value.len);
}
if (r->headers_in.user_agent) {
len += ngx_http_v3_encode_header_lri(NULL, 0,
NGX_HTTP_V3_HEADER_USER_AGENT, NULL,
r->headers_in.user_agent->value.len);
}
b = ngx_create_temp_buf(r->pool, len);
if (b == NULL) {
return NULL;
}
b->last = (u_char *) ngx_http_v3_encode_varlen_int(b->last, push_id);
b->last = (u_char *) ngx_http_v3_encode_header_block_prefix(b->last,
0, 0, 0);
b->last = (u_char *) ngx_http_v3_encode_header_ri(b->last, 0,
NGX_HTTP_V3_HEADER_METHOD_GET);
b->last = (u_char *) ngx_http_v3_encode_header_lri(b->last, 0,
NGX_HTTP_V3_HEADER_AUTHORITY,
r->headers_in.server.data,
r->headers_in.server.len);
if (path->len == 1 && path->data[0] == '/') {
b->last = (u_char *) ngx_http_v3_encode_header_ri(b->last, 0,
NGX_HTTP_V3_HEADER_PATH_ROOT);
} else {
b->last = (u_char *) ngx_http_v3_encode_header_lri(b->last, 0,
NGX_HTTP_V3_HEADER_PATH_ROOT,
path->data, path->len);
}
if (r->schema.len == 5 && ngx_strncmp(r->schema.data, "https", 5) == 0) {
b->last = (u_char *) ngx_http_v3_encode_header_ri(b->last, 0,
NGX_HTTP_V3_HEADER_SCHEME_HTTPS);
} else if (r->schema.len == 4
&& ngx_strncmp(r->schema.data, "http", 4) == 0)
{
b->last = (u_char *) ngx_http_v3_encode_header_ri(b->last, 0,
NGX_HTTP_V3_HEADER_SCHEME_HTTP);
} else {
b->last = (u_char *) ngx_http_v3_encode_header_lri(b->last, 0,
NGX_HTTP_V3_HEADER_SCHEME_HTTP,
r->schema.data, r->schema.len);
}
if (r->headers_in.accept_encoding) {
b->last = (u_char *) ngx_http_v3_encode_header_lri(b->last, 0,
NGX_HTTP_V3_HEADER_ACCEPT_ENCODING,
r->headers_in.accept_encoding->value.data,
r->headers_in.accept_encoding->value.len);
}
if (r->headers_in.accept_language) {
b->last = (u_char *) ngx_http_v3_encode_header_lri(b->last, 0,
NGX_HTTP_V3_HEADER_ACCEPT_LANGUAGE,
r->headers_in.accept_language->value.data,
r->headers_in.accept_language->value.len);
}
if (r->headers_in.user_agent) {
b->last = (u_char *) ngx_http_v3_encode_header_lri(b->last, 0,
NGX_HTTP_V3_HEADER_USER_AGENT,
r->headers_in.user_agent->value.data,
r->headers_in.user_agent->value.len);
}
cl = ngx_alloc_chain_link(r->pool);
if (cl == NULL) {
return NULL;
}
cl->buf = b;
cl->next = NULL;
n = b->last - b->pos;
len = ngx_http_v3_encode_varlen_int(NULL, NGX_HTTP_V3_FRAME_PUSH_PROMISE)
+ ngx_http_v3_encode_varlen_int(NULL, n);
b = ngx_create_temp_buf(r->pool, len);
if (b == NULL) {
return NULL;
}
b->last = (u_char *) ngx_http_v3_encode_varlen_int(b->last,
NGX_HTTP_V3_FRAME_PUSH_PROMISE);
b->last = (u_char *) ngx_http_v3_encode_varlen_int(b->last, n);
hl = ngx_alloc_chain_link(r->pool);
if (hl == NULL) {
return NULL;
}
hl->buf = b;
hl->next = cl;
return hl;
}

135
src/http/v3/ngx_http_v3_streams.c
View File

@ -21,10 +21,19 @@ typedef struct {
} ngx_http_v3_uni_stream_t;
typedef struct {
ngx_queue_t queue;
uint64_t id;
ngx_connection_t *connection;
ngx_uint_t *npushing;
} ngx_http_v3_push_t;
static void ngx_http_v3_close_uni_stream(ngx_connection_t *c);
static void ngx_http_v3_read_uni_stream_type(ngx_event_t *rev);
static void ngx_http_v3_uni_read_handler(ngx_event_t *rev);
static void ngx_http_v3_dummy_write_handler(ngx_event_t *wev);
static void ngx_http_v3_push_cleanup(void *data);
static ngx_connection_t *ngx_http_v3_get_uni_stream(ngx_connection_t *c,
ngx_uint_t type);
static ngx_int_t ngx_http_v3_send_settings(ngx_connection_t *c);
@ -50,6 +59,7 @@ ngx_http_v3_init_connection(ngx_connection_t *c)
h3c->hc = *hc;
ngx_queue_init(&h3c->blocked);
ngx_queue_init(&h3c->pushing);
c->data = h3c;
return NGX_OK;
@ -321,6 +331,70 @@ ngx_http_v3_dummy_write_handler(ngx_event_t *wev)
/* XXX async & buffered stream writes */
ngx_connection_t *
ngx_http_v3_create_push_stream(ngx_connection_t *c, uint64_t push_id)
{
u_char *p, buf[NGX_HTTP_V3_VARLEN_INT_LEN * 2];
size_t n;
ngx_connection_t *sc;
ngx_pool_cleanup_t *cln;
ngx_http_v3_push_t *push;
ngx_http_v3_connection_t *h3c;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
"http3 create push stream id:%uL", push_id);
sc = ngx_quic_open_stream(c, 0);
if (sc == NULL) {
return NULL;
}
p = buf;
p = (u_char *) ngx_http_v3_encode_varlen_int(p, NGX_HTTP_V3_STREAM_PUSH);
p = (u_char *) ngx_http_v3_encode_varlen_int(p, push_id);
n = p - buf;
if (sc->send(sc, buf, n) != (ssize_t) n) {
goto failed;
}
cln = ngx_pool_cleanup_add(sc->pool, sizeof(ngx_http_v3_push_t));
if (cln == NULL) {
goto failed;
}
h3c = c->qs->parent->data;
h3c->npushing++;
cln->handler = ngx_http_v3_push_cleanup;
push = cln->data;
push->id = push_id;
push->connection = sc;
push->npushing = &h3c->npushing;
ngx_queue_insert_tail(&h3c->pushing, &push->queue);
return sc;
failed:
ngx_http_v3_close_uni_stream(sc);
return NULL;
}
static void
ngx_http_v3_push_cleanup(void *data)
{
ngx_http_v3_push_t *push = data;
ngx_queue_remove(&push->queue);
(*push->npushing)--;
}
static ngx_connection_t *
ngx_http_v3_get_uni_stream(ngx_connection_t *c, ngx_uint_t type)
{
@ -682,3 +756,64 @@ ngx_http_v3_client_inc_insert_count(ngx_connection_t *c, ngx_uint_t inc)
return NGX_OK;
}
ngx_int_t
ngx_http_v3_set_max_push_id(ngx_connection_t *c, uint64_t max_push_id)
{
ngx_http_v3_connection_t *h3c;
h3c = c->qs->parent->data;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
"http3 MAX_PUSH_ID:%uL", max_push_id);
if (max_push_id < h3c->max_push_id) {
return NGX_HTTP_V3_ERR_ID_ERROR;
}
h3c->max_push_id = max_push_id;
return NGX_OK;
}
ngx_int_t
ngx_http_v3_cancel_push(ngx_connection_t *c, uint64_t push_id)
{
ngx_queue_t *q;
ngx_http_request_t *r;
ngx_http_v3_push_t *push;
ngx_http_v3_connection_t *h3c;
h3c = c->qs->parent->data;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
"http3 CANCEL_PUSH:%uL", push_id);
if (push_id >= h3c->next_push_id) {
return NGX_HTTP_V3_ERR_ID_ERROR;
}
for (q = ngx_queue_head(&h3c->pushing);
q != ngx_queue_sentinel(&h3c->pushing);
q = ngx_queue_next(&h3c->pushing))
{
push = (ngx_http_v3_push_t *) q;
if (push->id != push_id) {
continue;
}
r = push->connection->data;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"http3 cancel push");
ngx_http_finalize_request(r, NGX_HTTP_CLOSE);
break;
}
return NGX_OK;
}