Coverage Report

Created: 2023-03-26 06:11

/src/nghttp2/lib/nghttp2_session.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * nghttp2 - HTTP/2 C Library
3
 *
4
 * Copyright (c) 2012 Tatsuhiro Tsujikawa
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining
7
 * a copy of this software and associated documentation files (the
8
 * "Software"), to deal in the Software without restriction, including
9
 * without limitation the rights to use, copy, modify, merge, publish,
10
 * distribute, sublicense, and/or sell copies of the Software, and to
11
 * permit persons to whom the Software is furnished to do so, subject to
12
 * the following conditions:
13
 *
14
 * The above copyright notice and this permission notice shall be
15
 * included in all copies or substantial portions of the Software.
16
 *
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
21
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24
 */
25
#include "nghttp2_session.h"
26
27
#include <string.h>
28
#include <stddef.h>
29
#include <stdio.h>
30
#include <assert.h>
31
#include <stdarg.h>
32
33
#include "nghttp2_helper.h"
34
#include "nghttp2_net.h"
35
#include "nghttp2_priority_spec.h"
36
#include "nghttp2_option.h"
37
#include "nghttp2_http.h"
38
#include "nghttp2_pq.h"
39
#include "nghttp2_debug.h"
40
41
/*
42
 * Returns non-zero if the number of outgoing opened streams is larger
43
 * than or equal to
44
 * remote_settings.max_concurrent_streams.
45
 */
46
static int
47
0
session_is_outgoing_concurrent_streams_max(nghttp2_session *session) {
48
0
  return session->remote_settings.max_concurrent_streams <=
49
0
         session->num_outgoing_streams;
50
0
}
51
52
/*
53
 * Returns non-zero if the number of incoming opened streams is larger
54
 * than or equal to
55
 * local_settings.max_concurrent_streams.
56
 */
57
static int
58
0
session_is_incoming_concurrent_streams_max(nghttp2_session *session) {
59
0
  return session->local_settings.max_concurrent_streams <=
60
0
         session->num_incoming_streams;
61
0
}
62
63
/*
64
 * Returns non-zero if the number of incoming opened streams is larger
65
 * than or equal to
66
 * session->pending_local_max_concurrent_stream.
67
 */
68
static int
69
0
session_is_incoming_concurrent_streams_pending_max(nghttp2_session *session) {
70
0
  return session->pending_local_max_concurrent_stream <=
71
0
         session->num_incoming_streams;
72
0
}
73
74
/*
75
 * Returns non-zero if |lib_error| is non-fatal error.
76
 */
77
0
static int is_non_fatal(int lib_error_code) {
78
0
  return lib_error_code < 0 && lib_error_code > NGHTTP2_ERR_FATAL;
79
0
}
80
81
0
int nghttp2_is_fatal(int lib_error_code) {
82
0
  return lib_error_code < NGHTTP2_ERR_FATAL;
83
0
}
84
85
0
static int session_enforce_http_messaging(nghttp2_session *session) {
86
0
  return (session->opt_flags & NGHTTP2_OPTMASK_NO_HTTP_MESSAGING) == 0;
87
0
}
88
89
/*
90
 * Returns nonzero if |frame| is trailer headers.
91
 */
92
static int session_trailer_headers(nghttp2_session *session,
93
                                   nghttp2_stream *stream,
94
0
                                   nghttp2_frame *frame) {
95
0
  if (!stream || frame->hd.type != NGHTTP2_HEADERS) {
96
0
    return 0;
97
0
  }
98
0
  if (session->server) {
99
0
    return frame->headers.cat == NGHTTP2_HCAT_HEADERS;
100
0
  }
101
102
0
  return frame->headers.cat == NGHTTP2_HCAT_HEADERS &&
103
0
         (stream->http_flags & NGHTTP2_HTTP_FLAG_EXPECT_FINAL_RESPONSE) == 0;
104
0
}
105
106
/* Returns nonzero if the |stream| is in reserved(remote) state */
107
static int state_reserved_remote(nghttp2_session *session,
108
0
                                 nghttp2_stream *stream) {
109
0
  return stream->state == NGHTTP2_STREAM_RESERVED &&
110
0
         !nghttp2_session_is_my_stream_id(session, stream->stream_id);
111
0
}
112
113
/* Returns nonzero if the |stream| is in reserved(local) state */
114
static int state_reserved_local(nghttp2_session *session,
115
0
                                nghttp2_stream *stream) {
116
0
  return stream->state == NGHTTP2_STREAM_RESERVED &&
117
0
         nghttp2_session_is_my_stream_id(session, stream->stream_id);
118
0
}
119
120
/*
121
 * Checks whether received stream_id is valid.  This function returns
122
 * 1 if it succeeds, or 0.
123
 */
124
static int session_is_new_peer_stream_id(nghttp2_session *session,
125
0
                                         int32_t stream_id) {
126
0
  return stream_id != 0 &&
127
0
         !nghttp2_session_is_my_stream_id(session, stream_id) &&
128
0
         session->last_recv_stream_id < stream_id;
129
0
}
130
131
static int session_detect_idle_stream(nghttp2_session *session,
132
0
                                      int32_t stream_id) {
133
  /* Assume that stream object with stream_id does not exist */
134
0
  if (nghttp2_session_is_my_stream_id(session, stream_id)) {
135
0
    if (session->last_sent_stream_id < stream_id) {
136
0
      return 1;
137
0
    }
138
0
    return 0;
139
0
  }
140
0
  if (session_is_new_peer_stream_id(session, stream_id)) {
141
0
    return 1;
142
0
  }
143
0
  return 0;
144
0
}
145
146
0
static int check_ext_type_set(const uint8_t *ext_types, uint8_t type) {
147
0
  return (ext_types[type / 8] & (1 << (type & 0x7))) > 0;
148
0
}
149
150
static int session_call_error_callback(nghttp2_session *session,
151
                                       int lib_error_code, const char *fmt,
152
0
                                       ...) {
153
0
  size_t bufsize;
154
0
  va_list ap;
155
0
  char *buf;
156
0
  int rv;
157
0
  nghttp2_mem *mem;
158
159
0
  if (!session->callbacks.error_callback &&
160
0
      !session->callbacks.error_callback2) {
161
0
    return 0;
162
0
  }
163
164
0
  mem = &session->mem;
165
166
0
  va_start(ap, fmt);
167
0
  rv = vsnprintf(NULL, 0, fmt, ap);
168
0
  va_end(ap);
169
170
0
  if (rv < 0) {
171
0
    return NGHTTP2_ERR_NOMEM;
172
0
  }
173
174
0
  bufsize = (size_t)(rv + 1);
175
176
0
  buf = nghttp2_mem_malloc(mem, bufsize);
177
0
  if (buf == NULL) {
178
0
    return NGHTTP2_ERR_NOMEM;
179
0
  }
180
181
0
  va_start(ap, fmt);
182
0
  rv = vsnprintf(buf, bufsize, fmt, ap);
183
0
  va_end(ap);
184
185
0
  if (rv < 0) {
186
0
    nghttp2_mem_free(mem, buf);
187
    /* vsnprintf may return error because of various things we can
188
       imagine, but typically we don't want to drop session just for
189
       debug callback. */
190
0
    DEBUGF("error_callback: vsnprintf failed. The template was %s\n", fmt);
191
0
    return 0;
192
0
  }
193
194
0
  if (session->callbacks.error_callback2) {
195
0
    rv = session->callbacks.error_callback2(session, lib_error_code, buf,
196
0
                                            (size_t)rv, session->user_data);
197
0
  } else {
198
0
    rv = session->callbacks.error_callback(session, buf, (size_t)rv,
199
0
                                           session->user_data);
200
0
  }
201
202
0
  nghttp2_mem_free(mem, buf);
203
204
0
  if (rv != 0) {
205
0
    return NGHTTP2_ERR_CALLBACK_FAILURE;
206
0
  }
207
208
0
  return 0;
209
0
}
210
211
static int session_terminate_session(nghttp2_session *session,
212
                                     int32_t last_stream_id,
213
0
                                     uint32_t error_code, const char *reason) {
214
0
  int rv;
215
0
  const uint8_t *debug_data;
216
0
  size_t debug_datalen;
217
218
0
  if (session->goaway_flags & NGHTTP2_GOAWAY_TERM_ON_SEND) {
219
0
    return 0;
220
0
  }
221
222
  /* Ignore all incoming frames because we are going to tear down the
223
     session. */
224
0
  session->iframe.state = NGHTTP2_IB_IGN_ALL;
225
226
0
  if (reason == NULL) {
227
0
    debug_data = NULL;
228
0
    debug_datalen = 0;
229
0
  } else {
230
0
    debug_data = (const uint8_t *)reason;
231
0
    debug_datalen = strlen(reason);
232
0
  }
233
234
0
  rv = nghttp2_session_add_goaway(session, last_stream_id, error_code,
235
0
                                  debug_data, debug_datalen,
236
0
                                  NGHTTP2_GOAWAY_AUX_TERM_ON_SEND);
237
238
0
  if (rv != 0) {
239
0
    return rv;
240
0
  }
241
242
0
  session->goaway_flags |= NGHTTP2_GOAWAY_TERM_ON_SEND;
243
244
0
  return 0;
245
0
}
246
247
int nghttp2_session_terminate_session(nghttp2_session *session,
248
0
                                      uint32_t error_code) {
249
0
  return session_terminate_session(session, session->last_proc_stream_id,
250
0
                                   error_code, NULL);
251
0
}
252
253
int nghttp2_session_terminate_session2(nghttp2_session *session,
254
                                       int32_t last_stream_id,
255
0
                                       uint32_t error_code) {
256
0
  return session_terminate_session(session, last_stream_id, error_code, NULL);
257
0
}
258
259
int nghttp2_session_terminate_session_with_reason(nghttp2_session *session,
260
                                                  uint32_t error_code,
261
0
                                                  const char *reason) {
262
0
  return session_terminate_session(session, session->last_proc_stream_id,
263
0
                                   error_code, reason);
264
0
}
265
266
int nghttp2_session_is_my_stream_id(nghttp2_session *session,
267
0
                                    int32_t stream_id) {
268
0
  int rem;
269
0
  if (stream_id == 0) {
270
0
    return 0;
271
0
  }
272
0
  rem = stream_id & 0x1;
273
0
  if (session->server) {
274
0
    return rem == 0;
275
0
  }
276
0
  return rem == 1;
277
0
}
278
279
nghttp2_stream *nghttp2_session_get_stream(nghttp2_session *session,
280
0
                                           int32_t stream_id) {
281
0
  nghttp2_stream *stream;
282
283
0
  stream = (nghttp2_stream *)nghttp2_map_find(&session->streams, stream_id);
284
285
0
  if (stream == NULL || (stream->flags & NGHTTP2_STREAM_FLAG_CLOSED) ||
286
0
      stream->state == NGHTTP2_STREAM_IDLE) {
287
0
    return NULL;
288
0
  }
289
290
0
  return stream;
291
0
}
292
293
nghttp2_stream *nghttp2_session_get_stream_raw(nghttp2_session *session,
294
0
                                               int32_t stream_id) {
295
0
  return (nghttp2_stream *)nghttp2_map_find(&session->streams, stream_id);
296
0
}
297
298
0
static void session_inbound_frame_reset(nghttp2_session *session) {
299
0
  nghttp2_inbound_frame *iframe = &session->iframe;
300
0
  nghttp2_mem *mem = &session->mem;
301
  /* A bit risky code, since if this function is called from
302
     nghttp2_session_new(), we rely on the fact that
303
     iframe->frame.hd.type is 0, so that no free is performed. */
304
0
  switch (iframe->frame.hd.type) {
305
0
  case NGHTTP2_DATA:
306
0
    break;
307
0
  case NGHTTP2_HEADERS:
308
0
    nghttp2_frame_headers_free(&iframe->frame.headers, mem);
309
0
    break;
310
0
  case NGHTTP2_PRIORITY:
311
0
    nghttp2_frame_priority_free(&iframe->frame.priority);
312
0
    break;
313
0
  case NGHTTP2_RST_STREAM:
314
0
    nghttp2_frame_rst_stream_free(&iframe->frame.rst_stream);
315
0
    break;
316
0
  case NGHTTP2_SETTINGS:
317
0
    nghttp2_frame_settings_free(&iframe->frame.settings, mem);
318
319
0
    nghttp2_mem_free(mem, iframe->iv);
320
321
0
    iframe->iv = NULL;
322
0
    iframe->niv = 0;
323
0
    iframe->max_niv = 0;
324
325
0
    break;
326
0
  case NGHTTP2_PUSH_PROMISE:
327
0
    nghttp2_frame_push_promise_free(&iframe->frame.push_promise, mem);
328
0
    break;
329
0
  case NGHTTP2_PING:
330
0
    nghttp2_frame_ping_free(&iframe->frame.ping);
331
0
    break;
332
0
  case NGHTTP2_GOAWAY:
333
0
    nghttp2_frame_goaway_free(&iframe->frame.goaway, mem);
334
0
    break;
335
0
  case NGHTTP2_WINDOW_UPDATE:
336
0
    nghttp2_frame_window_update_free(&iframe->frame.window_update);
337
0
    break;
338
0
  default:
339
    /* extension frame */
340
0
    if (check_ext_type_set(session->user_recv_ext_types,
341
0
                           iframe->frame.hd.type)) {
342
0
      nghttp2_frame_extension_free(&iframe->frame.ext);
343
0
    } else {
344
0
      switch (iframe->frame.hd.type) {
345
0
      case NGHTTP2_ALTSVC:
346
0
        if ((session->builtin_recv_ext_types & NGHTTP2_TYPEMASK_ALTSVC) == 0) {
347
0
          break;
348
0
        }
349
0
        nghttp2_frame_altsvc_free(&iframe->frame.ext, mem);
350
0
        break;
351
0
      case NGHTTP2_ORIGIN:
352
0
        if ((session->builtin_recv_ext_types & NGHTTP2_TYPEMASK_ORIGIN) == 0) {
353
0
          break;
354
0
        }
355
0
        nghttp2_frame_origin_free(&iframe->frame.ext, mem);
356
0
        break;
357
0
      }
358
0
    }
359
360
0
    break;
361
0
  }
362
363
0
  memset(&iframe->frame, 0, sizeof(nghttp2_frame));
364
0
  memset(&iframe->ext_frame_payload, 0, sizeof(nghttp2_ext_frame_payload));
365
366
0
  iframe->state = NGHTTP2_IB_READ_HEAD;
367
368
0
  nghttp2_buf_wrap_init(&iframe->sbuf, iframe->raw_sbuf,
369
0
                        sizeof(iframe->raw_sbuf));
370
0
  iframe->sbuf.mark += NGHTTP2_FRAME_HDLEN;
371
372
0
  nghttp2_buf_free(&iframe->lbuf, mem);
373
0
  nghttp2_buf_wrap_init(&iframe->lbuf, NULL, 0);
374
375
0
  iframe->raw_lbuf = NULL;
376
377
0
  iframe->payloadleft = 0;
378
0
  iframe->padlen = 0;
379
0
}
380
381
0
static void init_settings(nghttp2_settings_storage *settings) {
382
0
  settings->header_table_size = NGHTTP2_HD_DEFAULT_MAX_BUFFER_SIZE;
383
0
  settings->enable_push = 1;
384
0
  settings->max_concurrent_streams = NGHTTP2_DEFAULT_MAX_CONCURRENT_STREAMS;
385
0
  settings->initial_window_size = NGHTTP2_INITIAL_WINDOW_SIZE;
386
0
  settings->max_frame_size = NGHTTP2_MAX_FRAME_SIZE_MIN;
387
0
  settings->max_header_list_size = UINT32_MAX;
388
0
}
389
390
static void active_outbound_item_reset(nghttp2_active_outbound_item *aob,
391
0
                                       nghttp2_mem *mem) {
392
0
  DEBUGF("send: reset nghttp2_active_outbound_item\n");
393
0
  DEBUGF("send: aob->item = %p\n", aob->item);
394
0
  nghttp2_outbound_item_free(aob->item, mem);
395
0
  nghttp2_mem_free(mem, aob->item);
396
0
  aob->item = NULL;
397
0
  nghttp2_bufs_reset(&aob->framebufs);
398
0
  aob->state = NGHTTP2_OB_POP_ITEM;
399
0
}
400
401
int nghttp2_enable_strict_preface = 1;
402
403
static int session_new(nghttp2_session **session_ptr,
404
                       const nghttp2_session_callbacks *callbacks,
405
                       void *user_data, int server,
406
0
                       const nghttp2_option *option, nghttp2_mem *mem) {
407
0
  int rv;
408
0
  size_t nbuffer;
409
0
  size_t max_deflate_dynamic_table_size =
410
0
      NGHTTP2_HD_DEFAULT_MAX_DEFLATE_BUFFER_SIZE;
411
412
0
  if (mem == NULL) {
413
0
    mem = nghttp2_mem_default();
414
0
  }
415
416
0
  *session_ptr = nghttp2_mem_calloc(mem, 1, sizeof(nghttp2_session));
417
0
  if (*session_ptr == NULL) {
418
0
    rv = NGHTTP2_ERR_NOMEM;
419
0
    goto fail_session;
420
0
  }
421
422
0
  (*session_ptr)->mem = *mem;
423
0
  mem = &(*session_ptr)->mem;
424
425
  /* next_stream_id is initialized in either
426
     nghttp2_session_client_new2 or nghttp2_session_server_new2 */
427
428
0
  nghttp2_stream_init(&(*session_ptr)->root, 0, NGHTTP2_STREAM_FLAG_NONE,
429
0
                      NGHTTP2_STREAM_IDLE, NGHTTP2_DEFAULT_WEIGHT, 0, 0, NULL,
430
0
                      mem);
431
432
0
  (*session_ptr)->remote_window_size = NGHTTP2_INITIAL_CONNECTION_WINDOW_SIZE;
433
0
  (*session_ptr)->recv_window_size = 0;
434
0
  (*session_ptr)->consumed_size = 0;
435
0
  (*session_ptr)->recv_reduction = 0;
436
0
  (*session_ptr)->local_window_size = NGHTTP2_INITIAL_CONNECTION_WINDOW_SIZE;
437
438
0
  (*session_ptr)->goaway_flags = NGHTTP2_GOAWAY_NONE;
439
0
  (*session_ptr)->local_last_stream_id = (1u << 31) - 1;
440
0
  (*session_ptr)->remote_last_stream_id = (1u << 31) - 1;
441
442
0
  (*session_ptr)->pending_local_max_concurrent_stream =
443
0
      NGHTTP2_DEFAULT_MAX_CONCURRENT_STREAMS;
444
0
  (*session_ptr)->pending_enable_push = 1;
445
446
0
  if (server) {
447
0
    (*session_ptr)->server = 1;
448
0
  }
449
450
0
  init_settings(&(*session_ptr)->remote_settings);
451
0
  init_settings(&(*session_ptr)->local_settings);
452
453
0
  (*session_ptr)->max_incoming_reserved_streams =
454
0
      NGHTTP2_MAX_INCOMING_RESERVED_STREAMS;
455
456
  /* Limit max outgoing concurrent streams to sensible value */
457
0
  (*session_ptr)->remote_settings.max_concurrent_streams = 100;
458
459
0
  (*session_ptr)->max_send_header_block_length = NGHTTP2_MAX_HEADERSLEN;
460
0
  (*session_ptr)->max_outbound_ack = NGHTTP2_DEFAULT_MAX_OBQ_FLOOD_ITEM;
461
0
  (*session_ptr)->max_settings = NGHTTP2_DEFAULT_MAX_SETTINGS;
462
463
0
  if (option) {
464
0
    if ((option->opt_set_mask & NGHTTP2_OPT_NO_AUTO_WINDOW_UPDATE) &&
465
0
        option->no_auto_window_update) {
466
467
0
      (*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE;
468
0
    }
469
470
0
    if (option->opt_set_mask & NGHTTP2_OPT_PEER_MAX_CONCURRENT_STREAMS) {
471
472
0
      (*session_ptr)->remote_settings.max_concurrent_streams =
473
0
          option->peer_max_concurrent_streams;
474
0
    }
475
476
0
    if (option->opt_set_mask & NGHTTP2_OPT_MAX_RESERVED_REMOTE_STREAMS) {
477
478
0
      (*session_ptr)->max_incoming_reserved_streams =
479
0
          option->max_reserved_remote_streams;
480
0
    }
481
482
0
    if ((option->opt_set_mask & NGHTTP2_OPT_NO_RECV_CLIENT_MAGIC) &&
483
0
        option->no_recv_client_magic) {
484
485
0
      (*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_RECV_CLIENT_MAGIC;
486
0
    }
487
488
0
    if ((option->opt_set_mask & NGHTTP2_OPT_NO_HTTP_MESSAGING) &&
489
0
        option->no_http_messaging) {
490
491
0
      (*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_HTTP_MESSAGING;
492
0
    }
493
494
0
    if (option->opt_set_mask & NGHTTP2_OPT_USER_RECV_EXT_TYPES) {
495
0
      memcpy((*session_ptr)->user_recv_ext_types, option->user_recv_ext_types,
496
0
             sizeof((*session_ptr)->user_recv_ext_types));
497
0
    }
498
499
0
    if (option->opt_set_mask & NGHTTP2_OPT_BUILTIN_RECV_EXT_TYPES) {
500
0
      (*session_ptr)->builtin_recv_ext_types = option->builtin_recv_ext_types;
501
0
    }
502
503
0
    if ((option->opt_set_mask & NGHTTP2_OPT_NO_AUTO_PING_ACK) &&
504
0
        option->no_auto_ping_ack) {
505
0
      (*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_AUTO_PING_ACK;
506
0
    }
507
508
0
    if (option->opt_set_mask & NGHTTP2_OPT_MAX_SEND_HEADER_BLOCK_LENGTH) {
509
0
      (*session_ptr)->max_send_header_block_length =
510
0
          option->max_send_header_block_length;
511
0
    }
512
513
0
    if (option->opt_set_mask & NGHTTP2_OPT_MAX_DEFLATE_DYNAMIC_TABLE_SIZE) {
514
0
      max_deflate_dynamic_table_size = option->max_deflate_dynamic_table_size;
515
0
    }
516
517
0
    if ((option->opt_set_mask & NGHTTP2_OPT_NO_CLOSED_STREAMS) &&
518
0
        option->no_closed_streams) {
519
0
      (*session_ptr)->opt_flags |= NGHTTP2_OPTMASK_NO_CLOSED_STREAMS;
520
0
    }
521
522
0
    if (option->opt_set_mask & NGHTTP2_OPT_MAX_OUTBOUND_ACK) {
523
0
      (*session_ptr)->max_outbound_ack = option->max_outbound_ack;
524
0
    }
525
526
0
    if ((option->opt_set_mask & NGHTTP2_OPT_MAX_SETTINGS) &&
527
0
        option->max_settings) {
528
0
      (*session_ptr)->max_settings = option->max_settings;
529
0
    }
530
0
  }
531
532
0
  rv = nghttp2_hd_deflate_init2(&(*session_ptr)->hd_deflater,
533
0
                                max_deflate_dynamic_table_size, mem);
534
0
  if (rv != 0) {
535
0
    goto fail_hd_deflater;
536
0
  }
537
0
  rv = nghttp2_hd_inflate_init(&(*session_ptr)->hd_inflater, mem);
538
0
  if (rv != 0) {
539
0
    goto fail_hd_inflater;
540
0
  }
541
0
  rv = nghttp2_map_init(&(*session_ptr)->streams, mem);
542
0
  if (rv != 0) {
543
0
    goto fail_map;
544
0
  }
545
546
0
  nbuffer = ((*session_ptr)->max_send_header_block_length +
547
0
             NGHTTP2_FRAMEBUF_CHUNKLEN - 1) /
548
0
            NGHTTP2_FRAMEBUF_CHUNKLEN;
549
550
0
  if (nbuffer == 0) {
551
0
    nbuffer = 1;
552
0
  }
553
554
  /* 1 for Pad Field. */
555
0
  rv = nghttp2_bufs_init3(&(*session_ptr)->aob.framebufs,
556
0
                          NGHTTP2_FRAMEBUF_CHUNKLEN, nbuffer, 1,
557
0
                          NGHTTP2_FRAME_HDLEN + 1, mem);
558
0
  if (rv != 0) {
559
0
    goto fail_aob_framebuf;
560
0
  }
561
562
0
  active_outbound_item_reset(&(*session_ptr)->aob, mem);
563
564
0
  (*session_ptr)->callbacks = *callbacks;
565
0
  (*session_ptr)->user_data = user_data;
566
567
0
  session_inbound_frame_reset(*session_ptr);
568
569
0
  if (nghttp2_enable_strict_preface) {
570
0
    nghttp2_inbound_frame *iframe = &(*session_ptr)->iframe;
571
572
0
    if (server && ((*session_ptr)->opt_flags &
573
0
                   NGHTTP2_OPTMASK_NO_RECV_CLIENT_MAGIC) == 0) {
574
0
      iframe->state = NGHTTP2_IB_READ_CLIENT_MAGIC;
575
0
      iframe->payloadleft = NGHTTP2_CLIENT_MAGIC_LEN;
576
0
    } else {
577
0
      iframe->state = NGHTTP2_IB_READ_FIRST_SETTINGS;
578
0
    }
579
580
0
    if (!server) {
581
0
      (*session_ptr)->aob.state = NGHTTP2_OB_SEND_CLIENT_MAGIC;
582
0
      nghttp2_bufs_add(&(*session_ptr)->aob.framebufs, NGHTTP2_CLIENT_MAGIC,
583
0
                       NGHTTP2_CLIENT_MAGIC_LEN);
584
0
    }
585
0
  }
586
587
0
  return 0;
588
589
0
fail_aob_framebuf:
590
0
  nghttp2_map_free(&(*session_ptr)->streams);
591
0
fail_map:
592
0
  nghttp2_hd_inflate_free(&(*session_ptr)->hd_inflater);
593
0
fail_hd_inflater:
594
0
  nghttp2_hd_deflate_free(&(*session_ptr)->hd_deflater);
595
0
fail_hd_deflater:
596
0
  nghttp2_mem_free(mem, *session_ptr);
597
0
fail_session:
598
0
  return rv;
599
0
}
600
601
int nghttp2_session_client_new(nghttp2_session **session_ptr,
602
                               const nghttp2_session_callbacks *callbacks,
603
0
                               void *user_data) {
604
0
  return nghttp2_session_client_new3(session_ptr, callbacks, user_data, NULL,
605
0
                                     NULL);
606
0
}
607
608
int nghttp2_session_client_new2(nghttp2_session **session_ptr,
609
                                const nghttp2_session_callbacks *callbacks,
610
0
                                void *user_data, const nghttp2_option *option) {
611
0
  return nghttp2_session_client_new3(session_ptr, callbacks, user_data, option,
612
0
                                     NULL);
613
0
}
614
615
int nghttp2_session_client_new3(nghttp2_session **session_ptr,
616
                                const nghttp2_session_callbacks *callbacks,
617
                                void *user_data, const nghttp2_option *option,
618
0
                                nghttp2_mem *mem) {
619
0
  int rv;
620
0
  nghttp2_session *session;
621
622
0
  rv = session_new(&session, callbacks, user_data, 0, option, mem);
623
624
0
  if (rv != 0) {
625
0
    return rv;
626
0
  }
627
  /* IDs for use in client */
628
0
  session->next_stream_id = 1;
629
630
0
  *session_ptr = session;
631
632
0
  return 0;
633
0
}
634
635
int nghttp2_session_server_new(nghttp2_session **session_ptr,
636
                               const nghttp2_session_callbacks *callbacks,
637
0
                               void *user_data) {
638
0
  return nghttp2_session_server_new3(session_ptr, callbacks, user_data, NULL,
639
0
                                     NULL);
640
0
}
641
642
int nghttp2_session_server_new2(nghttp2_session **session_ptr,
643
                                const nghttp2_session_callbacks *callbacks,
644
0
                                void *user_data, const nghttp2_option *option) {
645
0
  return nghttp2_session_server_new3(session_ptr, callbacks, user_data, option,
646
0
                                     NULL);
647
0
}
648
649
int nghttp2_session_server_new3(nghttp2_session **session_ptr,
650
                                const nghttp2_session_callbacks *callbacks,
651
                                void *user_data, const nghttp2_option *option,
652
0
                                nghttp2_mem *mem) {
653
0
  int rv;
654
0
  nghttp2_session *session;
655
656
0
  rv = session_new(&session, callbacks, user_data, 1, option, mem);
657
658
0
  if (rv != 0) {
659
0
    return rv;
660
0
  }
661
  /* IDs for use in client */
662
0
  session->next_stream_id = 2;
663
664
0
  *session_ptr = session;
665
666
0
  return 0;
667
0
}
668
669
0
static int free_streams(nghttp2_map_entry *entry, void *ptr) {
670
0
  nghttp2_session *session;
671
0
  nghttp2_stream *stream;
672
0
  nghttp2_outbound_item *item;
673
0
  nghttp2_mem *mem;
674
675
0
  session = (nghttp2_session *)ptr;
676
0
  mem = &session->mem;
677
0
  stream = (nghttp2_stream *)entry;
678
0
  item = stream->item;
679
680
0
  if (item && !item->queued && item != session->aob.item) {
681
0
    nghttp2_outbound_item_free(item, mem);
682
0
    nghttp2_mem_free(mem, item);
683
0
  }
684
685
0
  nghttp2_stream_free(stream);
686
0
  nghttp2_mem_free(mem, stream);
687
688
0
  return 0;
689
0
}
690
691
0
static void ob_q_free(nghttp2_outbound_queue *q, nghttp2_mem *mem) {
692
0
  nghttp2_outbound_item *item, *next;
693
0
  for (item = q->head; item;) {
694
0
    next = item->qnext;
695
0
    nghttp2_outbound_item_free(item, mem);
696
0
    nghttp2_mem_free(mem, item);
697
0
    item = next;
698
0
  }
699
0
}
700
701
static int inflight_settings_new(nghttp2_inflight_settings **settings_ptr,
702
                                 const nghttp2_settings_entry *iv, size_t niv,
703
0
                                 nghttp2_mem *mem) {
704
0
  *settings_ptr = nghttp2_mem_malloc(mem, sizeof(nghttp2_inflight_settings));
705
0
  if (!*settings_ptr) {
706
0
    return NGHTTP2_ERR_NOMEM;
707
0
  }
708
709
0
  if (niv > 0) {
710
0
    (*settings_ptr)->iv = nghttp2_frame_iv_copy(iv, niv, mem);
711
0
    if (!(*settings_ptr)->iv) {
712
0
      nghttp2_mem_free(mem, *settings_ptr);
713
0
      return NGHTTP2_ERR_NOMEM;
714
0
    }
715
0
  } else {
716
0
    (*settings_ptr)->iv = NULL;
717
0
  }
718
719
0
  (*settings_ptr)->niv = niv;
720
0
  (*settings_ptr)->next = NULL;
721
722
0
  return 0;
723
0
}
724
725
static void inflight_settings_del(nghttp2_inflight_settings *settings,
726
0
                                  nghttp2_mem *mem) {
727
0
  if (!settings) {
728
0
    return;
729
0
  }
730
731
0
  nghttp2_mem_free(mem, settings->iv);
732
0
  nghttp2_mem_free(mem, settings);
733
0
}
734
735
0
void nghttp2_session_del(nghttp2_session *session) {
736
0
  nghttp2_mem *mem;
737
0
  nghttp2_inflight_settings *settings;
738
739
0
  if (session == NULL) {
740
0
    return;
741
0
  }
742
743
0
  mem = &session->mem;
744
745
0
  for (settings = session->inflight_settings_head; settings;) {
746
0
    nghttp2_inflight_settings *next = settings->next;
747
0
    inflight_settings_del(settings, mem);
748
0
    settings = next;
749
0
  }
750
751
0
  nghttp2_stream_free(&session->root);
752
753
  /* Have to free streams first, so that we can check
754
     stream->item->queued */
755
0
  nghttp2_map_each_free(&session->streams, free_streams, session);
756
0
  nghttp2_map_free(&session->streams);
757
758
0
  ob_q_free(&session->ob_urgent, mem);
759
0
  ob_q_free(&session->ob_reg, mem);
760
0
  ob_q_free(&session->ob_syn, mem);
761
762
0
  active_outbound_item_reset(&session->aob, mem);
763
0
  session_inbound_frame_reset(session);
764
0
  nghttp2_hd_deflate_free(&session->hd_deflater);
765
0
  nghttp2_hd_inflate_free(&session->hd_inflater);
766
0
  nghttp2_bufs_free(&session->aob.framebufs);
767
0
  nghttp2_mem_free(mem, session);
768
0
}
769
770
int nghttp2_session_reprioritize_stream(
771
    nghttp2_session *session, nghttp2_stream *stream,
772
0
    const nghttp2_priority_spec *pri_spec_in) {
773
0
  int rv;
774
0
  nghttp2_stream *dep_stream = NULL;
775
0
  nghttp2_priority_spec pri_spec_default;
776
0
  const nghttp2_priority_spec *pri_spec = pri_spec_in;
777
778
0
  assert(pri_spec->stream_id != stream->stream_id);
779
780
0
  if (!nghttp2_stream_in_dep_tree(stream)) {
781
0
    return 0;
782
0
  }
783
784
0
  if (pri_spec->stream_id != 0) {
785
0
    dep_stream = nghttp2_session_get_stream_raw(session, pri_spec->stream_id);
786
787
0
    if (!dep_stream &&
788
0
        session_detect_idle_stream(session, pri_spec->stream_id)) {
789
790
0
      nghttp2_priority_spec_default_init(&pri_spec_default);
791
792
0
      dep_stream = nghttp2_session_open_stream(
793
0
          session, pri_spec->stream_id, NGHTTP2_FLAG_NONE, &pri_spec_default,
794
0
          NGHTTP2_STREAM_IDLE, NULL);
795
796
0
      if (dep_stream == NULL) {
797
0
        return NGHTTP2_ERR_NOMEM;
798
0
      }
799
0
    } else if (!dep_stream || !nghttp2_stream_in_dep_tree(dep_stream)) {
800
0
      nghttp2_priority_spec_default_init(&pri_spec_default);
801
0
      pri_spec = &pri_spec_default;
802
0
    }
803
0
  }
804
805
0
  if (pri_spec->stream_id == 0) {
806
0
    dep_stream = &session->root;
807
0
  } else if (nghttp2_stream_dep_find_ancestor(dep_stream, stream)) {
808
0
    DEBUGF("stream: cycle detected, dep_stream(%p)=%d stream(%p)=%d\n",
809
0
           dep_stream, dep_stream->stream_id, stream, stream->stream_id);
810
811
0
    nghttp2_stream_dep_remove_subtree(dep_stream);
812
0
    rv = nghttp2_stream_dep_add_subtree(stream->dep_prev, dep_stream);
813
0
    if (rv != 0) {
814
0
      return rv;
815
0
    }
816
0
  }
817
818
0
  assert(dep_stream);
819
820
0
  if (dep_stream == stream->dep_prev && !pri_spec->exclusive) {
821
    /* This is minor optimization when just weight is changed. */
822
0
    nghttp2_stream_change_weight(stream, pri_spec->weight);
823
824
0
    return 0;
825
0
  }
826
827
0
  nghttp2_stream_dep_remove_subtree(stream);
828
829
  /* We have to update weight after removing stream from tree */
830
0
  stream->weight = pri_spec->weight;
831
832
0
  if (pri_spec->exclusive) {
833
0
    rv = nghttp2_stream_dep_insert_subtree(dep_stream, stream);
834
0
  } else {
835
0
    rv = nghttp2_stream_dep_add_subtree(dep_stream, stream);
836
0
  }
837
838
0
  if (rv != 0) {
839
0
    return rv;
840
0
  }
841
842
0
  return 0;
843
0
}
844
845
int nghttp2_session_add_item(nghttp2_session *session,
846
0
                             nghttp2_outbound_item *item) {
847
  /* TODO Return error if stream is not found for the frame requiring
848
     stream presence. */
849
0
  int rv = 0;
850
0
  nghttp2_stream *stream;
851
0
  nghttp2_frame *frame;
852
853
0
  frame = &item->frame;
854
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
855
856
0
  switch (frame->hd.type) {
857
0
  case NGHTTP2_DATA:
858
0
    if (!stream) {
859
0
      return NGHTTP2_ERR_STREAM_CLOSED;
860
0
    }
861
862
0
    if (stream->item) {
863
0
      return NGHTTP2_ERR_DATA_EXIST;
864
0
    }
865
866
0
    rv = nghttp2_stream_attach_item(stream, item);
867
868
0
    if (rv != 0) {
869
0
      return rv;
870
0
    }
871
872
0
    return 0;
873
0
  case NGHTTP2_HEADERS:
874
    /* We push request HEADERS and push response HEADERS to
875
       dedicated queue because their transmission is affected by
876
       SETTINGS_MAX_CONCURRENT_STREAMS */
877
    /* TODO If 2 HEADERS are submitted for reserved stream, then
878
       both of them are queued into ob_syn, which is not
879
       desirable. */
880
0
    if (frame->headers.cat == NGHTTP2_HCAT_REQUEST ||
881
0
        (stream && stream->state == NGHTTP2_STREAM_RESERVED)) {
882
0
      nghttp2_outbound_queue_push(&session->ob_syn, item);
883
0
      item->queued = 1;
884
0
      return 0;
885
0
      ;
886
0
    }
887
888
0
    nghttp2_outbound_queue_push(&session->ob_reg, item);
889
0
    item->queued = 1;
890
0
    return 0;
891
0
  case NGHTTP2_SETTINGS:
892
0
  case NGHTTP2_PING:
893
0
    nghttp2_outbound_queue_push(&session->ob_urgent, item);
894
0
    item->queued = 1;
895
0
    return 0;
896
0
  case NGHTTP2_RST_STREAM:
897
0
    if (stream) {
898
0
      stream->state = NGHTTP2_STREAM_CLOSING;
899
0
    }
900
0
    nghttp2_outbound_queue_push(&session->ob_reg, item);
901
0
    item->queued = 1;
902
0
    return 0;
903
0
  case NGHTTP2_PUSH_PROMISE: {
904
0
    nghttp2_headers_aux_data *aux_data;
905
0
    nghttp2_priority_spec pri_spec;
906
907
0
    aux_data = &item->aux_data.headers;
908
909
0
    if (!stream) {
910
0
      return NGHTTP2_ERR_STREAM_CLOSED;
911
0
    }
912
913
0
    nghttp2_priority_spec_init(&pri_spec, stream->stream_id,
914
0
                               NGHTTP2_DEFAULT_WEIGHT, 0);
915
916
0
    if (!nghttp2_session_open_stream(
917
0
            session, frame->push_promise.promised_stream_id,
918
0
            NGHTTP2_STREAM_FLAG_NONE, &pri_spec, NGHTTP2_STREAM_RESERVED,
919
0
            aux_data->stream_user_data)) {
920
0
      return NGHTTP2_ERR_NOMEM;
921
0
    }
922
923
    /* We don't have to call nghttp2_session_adjust_closed_stream()
924
       here, since stream->stream_id is local stream_id, and it does
925
       not affect closed stream count. */
926
927
0
    nghttp2_outbound_queue_push(&session->ob_reg, item);
928
0
    item->queued = 1;
929
930
0
    return 0;
931
0
  }
932
0
  case NGHTTP2_WINDOW_UPDATE:
933
0
    if (stream) {
934
0
      stream->window_update_queued = 1;
935
0
    } else if (frame->hd.stream_id == 0) {
936
0
      session->window_update_queued = 1;
937
0
    }
938
0
    nghttp2_outbound_queue_push(&session->ob_reg, item);
939
0
    item->queued = 1;
940
0
    return 0;
941
0
  default:
942
0
    nghttp2_outbound_queue_push(&session->ob_reg, item);
943
0
    item->queued = 1;
944
0
    return 0;
945
0
  }
946
0
}
947
948
int nghttp2_session_add_rst_stream(nghttp2_session *session, int32_t stream_id,
949
0
                                   uint32_t error_code) {
950
0
  int rv;
951
0
  nghttp2_outbound_item *item;
952
0
  nghttp2_frame *frame;
953
0
  nghttp2_stream *stream;
954
0
  nghttp2_mem *mem;
955
956
0
  mem = &session->mem;
957
0
  stream = nghttp2_session_get_stream(session, stream_id);
958
0
  if (stream && stream->state == NGHTTP2_STREAM_CLOSING) {
959
0
    return 0;
960
0
  }
961
962
  /* Cancel pending request HEADERS in ob_syn if this RST_STREAM
963
     refers to that stream. */
964
0
  if (!session->server && nghttp2_session_is_my_stream_id(session, stream_id) &&
965
0
      nghttp2_outbound_queue_top(&session->ob_syn)) {
966
0
    nghttp2_headers_aux_data *aux_data;
967
0
    nghttp2_frame *headers_frame;
968
969
0
    headers_frame = &nghttp2_outbound_queue_top(&session->ob_syn)->frame;
970
0
    assert(headers_frame->hd.type == NGHTTP2_HEADERS);
971
972
0
    if (headers_frame->hd.stream_id <= stream_id &&
973
0
        (uint32_t)stream_id < session->next_stream_id) {
974
975
0
      for (item = session->ob_syn.head; item; item = item->qnext) {
976
0
        aux_data = &item->aux_data.headers;
977
978
0
        if (item->frame.hd.stream_id < stream_id) {
979
0
          continue;
980
0
        }
981
982
        /* stream_id in ob_syn queue must be strictly increasing.  If
983
           we found larger ID, then we can break here. */
984
0
        if (item->frame.hd.stream_id > stream_id || aux_data->canceled) {
985
0
          break;
986
0
        }
987
988
0
        aux_data->error_code = error_code;
989
0
        aux_data->canceled = 1;
990
991
0
        return 0;
992
0
      }
993
0
    }
994
0
  }
995
996
0
  item = nghttp2_mem_malloc(mem, sizeof(nghttp2_outbound_item));
997
0
  if (item == NULL) {
998
0
    return NGHTTP2_ERR_NOMEM;
999
0
  }
1000
1001
0
  nghttp2_outbound_item_init(item);
1002
1003
0
  frame = &item->frame;
1004
1005
0
  nghttp2_frame_rst_stream_init(&frame->rst_stream, stream_id, error_code);
1006
0
  rv = nghttp2_session_add_item(session, item);
1007
0
  if (rv != 0) {
1008
0
    nghttp2_frame_rst_stream_free(&frame->rst_stream);
1009
0
    nghttp2_mem_free(mem, item);
1010
0
    return rv;
1011
0
  }
1012
0
  return 0;
1013
0
}
1014
1015
nghttp2_stream *nghttp2_session_open_stream(nghttp2_session *session,
1016
                                            int32_t stream_id, uint8_t flags,
1017
                                            nghttp2_priority_spec *pri_spec_in,
1018
                                            nghttp2_stream_state initial_state,
1019
0
                                            void *stream_user_data) {
1020
0
  int rv;
1021
0
  nghttp2_stream *stream;
1022
0
  nghttp2_stream *dep_stream = NULL;
1023
0
  int stream_alloc = 0;
1024
0
  nghttp2_priority_spec pri_spec_default;
1025
0
  nghttp2_priority_spec *pri_spec = pri_spec_in;
1026
0
  nghttp2_mem *mem;
1027
1028
0
  mem = &session->mem;
1029
0
  stream = nghttp2_session_get_stream_raw(session, stream_id);
1030
1031
0
  if (stream) {
1032
0
    assert(stream->state == NGHTTP2_STREAM_IDLE);
1033
0
    assert(nghttp2_stream_in_dep_tree(stream));
1034
0
    nghttp2_session_detach_idle_stream(session, stream);
1035
0
    rv = nghttp2_stream_dep_remove(stream);
1036
0
    if (rv != 0) {
1037
0
      return NULL;
1038
0
    }
1039
0
  } else {
1040
0
    stream = nghttp2_mem_malloc(mem, sizeof(nghttp2_stream));
1041
0
    if (stream == NULL) {
1042
0
      return NULL;
1043
0
    }
1044
1045
0
    stream_alloc = 1;
1046
0
  }
1047
1048
0
  if (pri_spec->stream_id != 0) {
1049
0
    dep_stream = nghttp2_session_get_stream_raw(session, pri_spec->stream_id);
1050
1051
0
    if (!dep_stream &&
1052
0
        session_detect_idle_stream(session, pri_spec->stream_id)) {
1053
      /* Depends on idle stream, which does not exist in memory.
1054
         Assign default priority for it. */
1055
0
      nghttp2_priority_spec_default_init(&pri_spec_default);
1056
1057
0
      dep_stream = nghttp2_session_open_stream(
1058
0
          session, pri_spec->stream_id, NGHTTP2_FLAG_NONE, &pri_spec_default,
1059
0
          NGHTTP2_STREAM_IDLE, NULL);
1060
1061
0
      if (dep_stream == NULL) {
1062
0
        if (stream_alloc) {
1063
0
          nghttp2_mem_free(mem, stream);
1064
0
        }
1065
1066
0
        return NULL;
1067
0
      }
1068
0
    } else if (!dep_stream || !nghttp2_stream_in_dep_tree(dep_stream)) {
1069
      /* If dep_stream is not part of dependency tree, stream will get
1070
         default priority.  This handles the case when
1071
         pri_spec->stream_id == stream_id.  This happens because we
1072
         don't check pri_spec->stream_id against new stream ID in
1073
         nghttp2_submit_request.  This also handles the case when idle
1074
         stream created by PRIORITY frame was opened.  Somehow we
1075
         first remove the idle stream from dependency tree.  This is
1076
         done to simplify code base, but ideally we should retain old
1077
         dependency.  But I'm not sure this adds values. */
1078
0
      nghttp2_priority_spec_default_init(&pri_spec_default);
1079
0
      pri_spec = &pri_spec_default;
1080
0
    }
1081
0
  }
1082
1083
0
  if (initial_state == NGHTTP2_STREAM_RESERVED) {
1084
0
    flags |= NGHTTP2_STREAM_FLAG_PUSH;
1085
0
  }
1086
1087
0
  if (stream_alloc) {
1088
0
    nghttp2_stream_init(stream, stream_id, flags, initial_state,
1089
0
                        pri_spec->weight,
1090
0
                        (int32_t)session->remote_settings.initial_window_size,
1091
0
                        (int32_t)session->local_settings.initial_window_size,
1092
0
                        stream_user_data, mem);
1093
1094
0
    rv = nghttp2_map_insert(&session->streams, &stream->map_entry);
1095
0
    if (rv != 0) {
1096
0
      nghttp2_stream_free(stream);
1097
0
      nghttp2_mem_free(mem, stream);
1098
0
      return NULL;
1099
0
    }
1100
0
  } else {
1101
0
    stream->flags = flags;
1102
0
    stream->state = initial_state;
1103
0
    stream->weight = pri_spec->weight;
1104
0
    stream->stream_user_data = stream_user_data;
1105
0
  }
1106
1107
0
  switch (initial_state) {
1108
0
  case NGHTTP2_STREAM_RESERVED:
1109
0
    if (nghttp2_session_is_my_stream_id(session, stream_id)) {
1110
      /* reserved (local) */
1111
0
      nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD);
1112
0
    } else {
1113
      /* reserved (remote) */
1114
0
      nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_WR);
1115
0
      ++session->num_incoming_reserved_streams;
1116
0
    }
1117
    /* Reserved stream does not count in the concurrent streams
1118
       limit. That is one of the DOS vector. */
1119
0
    break;
1120
0
  case NGHTTP2_STREAM_IDLE:
1121
    /* Idle stream does not count toward the concurrent streams limit.
1122
       This is used as anchor node in dependency tree. */
1123
0
    nghttp2_session_keep_idle_stream(session, stream);
1124
0
    break;
1125
0
  default:
1126
0
    if (nghttp2_session_is_my_stream_id(session, stream_id)) {
1127
0
      ++session->num_outgoing_streams;
1128
0
    } else {
1129
0
      ++session->num_incoming_streams;
1130
0
    }
1131
0
  }
1132
1133
0
  if (pri_spec->stream_id == 0) {
1134
0
    dep_stream = &session->root;
1135
0
  }
1136
1137
0
  assert(dep_stream);
1138
1139
0
  if (pri_spec->exclusive) {
1140
0
    rv = nghttp2_stream_dep_insert(dep_stream, stream);
1141
0
    if (rv != 0) {
1142
0
      return NULL;
1143
0
    }
1144
0
  } else {
1145
0
    nghttp2_stream_dep_add(dep_stream, stream);
1146
0
  }
1147
1148
0
  return stream;
1149
0
}
1150
1151
int nghttp2_session_close_stream(nghttp2_session *session, int32_t stream_id,
1152
0
                                 uint32_t error_code) {
1153
0
  int rv;
1154
0
  nghttp2_stream *stream;
1155
0
  nghttp2_mem *mem;
1156
0
  int is_my_stream_id;
1157
1158
0
  mem = &session->mem;
1159
0
  stream = nghttp2_session_get_stream(session, stream_id);
1160
1161
0
  if (!stream) {
1162
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
1163
0
  }
1164
1165
0
  DEBUGF("stream: stream(%p)=%d close\n", stream, stream->stream_id);
1166
1167
0
  if (stream->item) {
1168
0
    nghttp2_outbound_item *item;
1169
1170
0
    item = stream->item;
1171
1172
0
    rv = nghttp2_stream_detach_item(stream);
1173
1174
0
    if (rv != 0) {
1175
0
      return rv;
1176
0
    }
1177
1178
    /* If item is queued, it will be deleted when it is popped
1179
       (nghttp2_session_prep_frame() will fail).  If session->aob.item
1180
       points to this item, let active_outbound_item_reset()
1181
       free the item. */
1182
0
    if (!item->queued && item != session->aob.item) {
1183
0
      nghttp2_outbound_item_free(item, mem);
1184
0
      nghttp2_mem_free(mem, item);
1185
0
    }
1186
0
  }
1187
1188
  /* We call on_stream_close_callback even if stream->state is
1189
     NGHTTP2_STREAM_INITIAL. This will happen while sending request
1190
     HEADERS, a local endpoint receives RST_STREAM for that stream. It
1191
     may be PROTOCOL_ERROR, but without notifying stream closure will
1192
     hang the stream in a local endpoint.
1193
  */
1194
1195
0
  if (session->callbacks.on_stream_close_callback) {
1196
0
    if (session->callbacks.on_stream_close_callback(
1197
0
            session, stream_id, error_code, session->user_data) != 0) {
1198
1199
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
1200
0
    }
1201
0
  }
1202
1203
0
  is_my_stream_id = nghttp2_session_is_my_stream_id(session, stream_id);
1204
1205
  /* pushed streams which is not opened yet is not counted toward max
1206
     concurrent limits */
1207
0
  if ((stream->flags & NGHTTP2_STREAM_FLAG_PUSH)) {
1208
0
    if (!is_my_stream_id) {
1209
0
      --session->num_incoming_reserved_streams;
1210
0
    }
1211
0
  } else {
1212
0
    if (is_my_stream_id) {
1213
0
      --session->num_outgoing_streams;
1214
0
    } else {
1215
0
      --session->num_incoming_streams;
1216
0
    }
1217
0
  }
1218
1219
  /* Closes both directions just in case they are not closed yet */
1220
0
  stream->flags |= NGHTTP2_STREAM_FLAG_CLOSED;
1221
1222
0
  if ((session->opt_flags & NGHTTP2_OPTMASK_NO_CLOSED_STREAMS) == 0 &&
1223
0
      session->server && !is_my_stream_id &&
1224
0
      nghttp2_stream_in_dep_tree(stream)) {
1225
    /* On server side, retain stream at most MAX_CONCURRENT_STREAMS
1226
       combined with the current active incoming streams to make
1227
       dependency tree work better. */
1228
0
    nghttp2_session_keep_closed_stream(session, stream);
1229
0
  } else {
1230
0
    rv = nghttp2_session_destroy_stream(session, stream);
1231
0
    if (rv != 0) {
1232
0
      return rv;
1233
0
    }
1234
0
  }
1235
1236
0
  return 0;
1237
0
}
1238
1239
int nghttp2_session_destroy_stream(nghttp2_session *session,
1240
0
                                   nghttp2_stream *stream) {
1241
0
  nghttp2_mem *mem;
1242
0
  int rv;
1243
1244
0
  DEBUGF("stream: destroy closed stream(%p)=%d\n", stream, stream->stream_id);
1245
1246
0
  mem = &session->mem;
1247
1248
0
  if (nghttp2_stream_in_dep_tree(stream)) {
1249
0
    rv = nghttp2_stream_dep_remove(stream);
1250
0
    if (rv != 0) {
1251
0
      return rv;
1252
0
    }
1253
0
  }
1254
1255
0
  nghttp2_map_remove(&session->streams, stream->stream_id);
1256
0
  nghttp2_stream_free(stream);
1257
0
  nghttp2_mem_free(mem, stream);
1258
1259
0
  return 0;
1260
0
}
1261
1262
void nghttp2_session_keep_closed_stream(nghttp2_session *session,
1263
0
                                        nghttp2_stream *stream) {
1264
0
  DEBUGF("stream: keep closed stream(%p)=%d, state=%d\n", stream,
1265
0
         stream->stream_id, stream->state);
1266
1267
0
  if (session->closed_stream_tail) {
1268
0
    session->closed_stream_tail->closed_next = stream;
1269
0
    stream->closed_prev = session->closed_stream_tail;
1270
0
  } else {
1271
0
    session->closed_stream_head = stream;
1272
0
  }
1273
0
  session->closed_stream_tail = stream;
1274
1275
0
  ++session->num_closed_streams;
1276
0
}
1277
1278
void nghttp2_session_keep_idle_stream(nghttp2_session *session,
1279
0
                                      nghttp2_stream *stream) {
1280
0
  DEBUGF("stream: keep idle stream(%p)=%d, state=%d\n", stream,
1281
0
         stream->stream_id, stream->state);
1282
1283
0
  if (session->idle_stream_tail) {
1284
0
    session->idle_stream_tail->closed_next = stream;
1285
0
    stream->closed_prev = session->idle_stream_tail;
1286
0
  } else {
1287
0
    session->idle_stream_head = stream;
1288
0
  }
1289
0
  session->idle_stream_tail = stream;
1290
1291
0
  ++session->num_idle_streams;
1292
0
}
1293
1294
void nghttp2_session_detach_idle_stream(nghttp2_session *session,
1295
0
                                        nghttp2_stream *stream) {
1296
0
  nghttp2_stream *prev_stream, *next_stream;
1297
1298
0
  DEBUGF("stream: detach idle stream(%p)=%d, state=%d\n", stream,
1299
0
         stream->stream_id, stream->state);
1300
1301
0
  prev_stream = stream->closed_prev;
1302
0
  next_stream = stream->closed_next;
1303
1304
0
  if (prev_stream) {
1305
0
    prev_stream->closed_next = next_stream;
1306
0
  } else {
1307
0
    session->idle_stream_head = next_stream;
1308
0
  }
1309
1310
0
  if (next_stream) {
1311
0
    next_stream->closed_prev = prev_stream;
1312
0
  } else {
1313
0
    session->idle_stream_tail = prev_stream;
1314
0
  }
1315
1316
0
  stream->closed_prev = NULL;
1317
0
  stream->closed_next = NULL;
1318
1319
0
  --session->num_idle_streams;
1320
0
}
1321
1322
0
int nghttp2_session_adjust_closed_stream(nghttp2_session *session) {
1323
0
  size_t num_stream_max;
1324
0
  int rv;
1325
1326
0
  if (session->local_settings.max_concurrent_streams ==
1327
0
      NGHTTP2_DEFAULT_MAX_CONCURRENT_STREAMS) {
1328
0
    num_stream_max = session->pending_local_max_concurrent_stream;
1329
0
  } else {
1330
0
    num_stream_max = session->local_settings.max_concurrent_streams;
1331
0
  }
1332
1333
0
  DEBUGF("stream: adjusting kept closed streams num_closed_streams=%zu, "
1334
0
         "num_incoming_streams=%zu, max_concurrent_streams=%zu\n",
1335
0
         session->num_closed_streams, session->num_incoming_streams,
1336
0
         num_stream_max);
1337
1338
0
  while (session->num_closed_streams > 0 &&
1339
0
         session->num_closed_streams + session->num_incoming_streams >
1340
0
             num_stream_max) {
1341
0
    nghttp2_stream *head_stream;
1342
0
    nghttp2_stream *next;
1343
1344
0
    head_stream = session->closed_stream_head;
1345
1346
0
    assert(head_stream);
1347
1348
0
    next = head_stream->closed_next;
1349
1350
0
    rv = nghttp2_session_destroy_stream(session, head_stream);
1351
0
    if (rv != 0) {
1352
0
      return rv;
1353
0
    }
1354
1355
    /* head_stream is now freed */
1356
1357
0
    session->closed_stream_head = next;
1358
1359
0
    if (session->closed_stream_head) {
1360
0
      session->closed_stream_head->closed_prev = NULL;
1361
0
    } else {
1362
0
      session->closed_stream_tail = NULL;
1363
0
    }
1364
1365
0
    --session->num_closed_streams;
1366
0
  }
1367
1368
0
  return 0;
1369
0
}
1370
1371
0
int nghttp2_session_adjust_idle_stream(nghttp2_session *session) {
1372
0
  size_t max;
1373
0
  int rv;
1374
1375
  /* Make minimum number of idle streams 16, and maximum 100, which
1376
     are arbitrary chosen numbers. */
1377
0
  max = nghttp2_min(
1378
0
      100, nghttp2_max(
1379
0
               16, nghttp2_min(session->local_settings.max_concurrent_streams,
1380
0
                               session->pending_local_max_concurrent_stream)));
1381
1382
0
  DEBUGF("stream: adjusting kept idle streams num_idle_streams=%zu, max=%zu\n",
1383
0
         session->num_idle_streams, max);
1384
1385
0
  while (session->num_idle_streams > max) {
1386
0
    nghttp2_stream *head;
1387
0
    nghttp2_stream *next;
1388
1389
0
    head = session->idle_stream_head;
1390
0
    assert(head);
1391
1392
0
    next = head->closed_next;
1393
1394
0
    rv = nghttp2_session_destroy_stream(session, head);
1395
0
    if (rv != 0) {
1396
0
      return rv;
1397
0
    }
1398
1399
    /* head is now destroyed */
1400
1401
0
    session->idle_stream_head = next;
1402
1403
0
    if (session->idle_stream_head) {
1404
0
      session->idle_stream_head->closed_prev = NULL;
1405
0
    } else {
1406
0
      session->idle_stream_tail = NULL;
1407
0
    }
1408
1409
0
    --session->num_idle_streams;
1410
0
  }
1411
1412
0
  return 0;
1413
0
}
1414
1415
/*
1416
 * Closes stream with stream ID |stream_id| if both transmission and
1417
 * reception of the stream were disallowed. The |error_code| indicates
1418
 * the reason of the closure.
1419
 *
1420
 * This function returns 0 if it succeeds, or one of the following
1421
 * negative error codes:
1422
 *
1423
 * NGHTTP2_ERR_INVALID_ARGUMENT
1424
 *   The stream is not found.
1425
 * NGHTTP2_ERR_CALLBACK_FAILURE
1426
 *   The callback function failed.
1427
 */
1428
int nghttp2_session_close_stream_if_shut_rdwr(nghttp2_session *session,
1429
0
                                              nghttp2_stream *stream) {
1430
0
  if ((stream->shut_flags & NGHTTP2_SHUT_RDWR) == NGHTTP2_SHUT_RDWR) {
1431
0
    return nghttp2_session_close_stream(session, stream->stream_id,
1432
0
                                        NGHTTP2_NO_ERROR);
1433
0
  }
1434
0
  return 0;
1435
0
}
1436
1437
/*
1438
 * Returns nonzero if local endpoint allows reception of new stream
1439
 * from remote.
1440
 */
1441
0
static int session_allow_incoming_new_stream(nghttp2_session *session) {
1442
0
  return (session->goaway_flags &
1443
0
          (NGHTTP2_GOAWAY_TERM_ON_SEND | NGHTTP2_GOAWAY_SENT)) == 0;
1444
0
}
1445
1446
/*
1447
 * This function returns nonzero if session is closing.
1448
 */
1449
0
static int session_is_closing(nghttp2_session *session) {
1450
0
  return (session->goaway_flags & NGHTTP2_GOAWAY_TERM_ON_SEND) != 0 ||
1451
0
         (nghttp2_session_want_read(session) == 0 &&
1452
0
          nghttp2_session_want_write(session) == 0);
1453
0
}
1454
1455
/*
1456
 * Check that we can send a frame to the |stream|. This function
1457
 * returns 0 if we can send a frame to the |frame|, or one of the
1458
 * following negative error codes:
1459
 *
1460
 * NGHTTP2_ERR_STREAM_CLOSED
1461
 *   The stream is already closed.
1462
 * NGHTTP2_ERR_STREAM_SHUT_WR
1463
 *   The stream is half-closed for transmission.
1464
 * NGHTTP2_ERR_SESSION_CLOSING
1465
 *   This session is closing.
1466
 */
1467
static int session_predicate_for_stream_send(nghttp2_session *session,
1468
0
                                             nghttp2_stream *stream) {
1469
0
  if (stream == NULL) {
1470
0
    return NGHTTP2_ERR_STREAM_CLOSED;
1471
0
  }
1472
0
  if (session_is_closing(session)) {
1473
0
    return NGHTTP2_ERR_SESSION_CLOSING;
1474
0
  }
1475
0
  if (stream->shut_flags & NGHTTP2_SHUT_WR) {
1476
0
    return NGHTTP2_ERR_STREAM_SHUT_WR;
1477
0
  }
1478
0
  return 0;
1479
0
}
1480
1481
0
int nghttp2_session_check_request_allowed(nghttp2_session *session) {
1482
0
  return !session->server && session->next_stream_id <= INT32_MAX &&
1483
0
         (session->goaway_flags & NGHTTP2_GOAWAY_RECV) == 0 &&
1484
0
         !session_is_closing(session);
1485
0
}
1486
1487
/*
1488
 * This function checks request HEADERS frame, which opens stream, can
1489
 * be sent at this time.
1490
 *
1491
 * This function returns 0 if it succeeds, or one of the following
1492
 * negative error codes:
1493
 *
1494
 * NGHTTP2_ERR_START_STREAM_NOT_ALLOWED
1495
 *     New stream cannot be created because of GOAWAY: session is
1496
 *     going down or received last_stream_id is strictly less than
1497
 *     frame->hd.stream_id.
1498
 * NGHTTP2_ERR_STREAM_CLOSING
1499
 *     request HEADERS was canceled by RST_STREAM while it is in queue.
1500
 */
1501
static int session_predicate_request_headers_send(nghttp2_session *session,
1502
0
                                                  nghttp2_outbound_item *item) {
1503
0
  if (item->aux_data.headers.canceled) {
1504
0
    return NGHTTP2_ERR_STREAM_CLOSING;
1505
0
  }
1506
  /* If we are terminating session (NGHTTP2_GOAWAY_TERM_ON_SEND),
1507
     GOAWAY was received from peer, or session is about to close, new
1508
     request is not allowed. */
1509
0
  if ((session->goaway_flags & NGHTTP2_GOAWAY_RECV) ||
1510
0
      session_is_closing(session)) {
1511
0
    return NGHTTP2_ERR_START_STREAM_NOT_ALLOWED;
1512
0
  }
1513
0
  return 0;
1514
0
}
1515
1516
/*
1517
 * This function checks HEADERS, which is the first frame from the
1518
 * server, with the |stream| can be sent at this time.  The |stream|
1519
 * can be NULL.
1520
 *
1521
 * This function returns 0 if it succeeds, or one of the following
1522
 * negative error codes:
1523
 *
1524
 * NGHTTP2_ERR_STREAM_CLOSED
1525
 *     The stream is already closed or does not exist.
1526
 * NGHTTP2_ERR_STREAM_SHUT_WR
1527
 *     The transmission is not allowed for this stream (e.g., a frame
1528
 *     with END_STREAM flag set has already sent)
1529
 * NGHTTP2_ERR_INVALID_STREAM_ID
1530
 *     The stream ID is invalid.
1531
 * NGHTTP2_ERR_STREAM_CLOSING
1532
 *     RST_STREAM was queued for this stream.
1533
 * NGHTTP2_ERR_INVALID_STREAM_STATE
1534
 *     The state of the stream is not valid.
1535
 * NGHTTP2_ERR_SESSION_CLOSING
1536
 *     This session is closing.
1537
 * NGHTTP2_ERR_PROTO
1538
 *     Client side attempted to send response.
1539
 */
1540
static int session_predicate_response_headers_send(nghttp2_session *session,
1541
0
                                                   nghttp2_stream *stream) {
1542
0
  int rv;
1543
0
  rv = session_predicate_for_stream_send(session, stream);
1544
0
  if (rv != 0) {
1545
0
    return rv;
1546
0
  }
1547
0
  assert(stream);
1548
0
  if (!session->server) {
1549
0
    return NGHTTP2_ERR_PROTO;
1550
0
  }
1551
0
  if (nghttp2_session_is_my_stream_id(session, stream->stream_id)) {
1552
0
    return NGHTTP2_ERR_INVALID_STREAM_ID;
1553
0
  }
1554
0
  switch (stream->state) {
1555
0
  case NGHTTP2_STREAM_OPENING:
1556
0
    return 0;
1557
0
  case NGHTTP2_STREAM_CLOSING:
1558
0
    return NGHTTP2_ERR_STREAM_CLOSING;
1559
0
  default:
1560
0
    return NGHTTP2_ERR_INVALID_STREAM_STATE;
1561
0
  }
1562
0
}
1563
1564
/*
1565
 * This function checks HEADERS for reserved stream can be sent. The
1566
 * |stream| must be reserved state and the |session| is server side.
1567
 * The |stream| can be NULL.
1568
 *
1569
 * This function returns 0 if it succeeds, or one of the following
1570
 * error codes:
1571
 *
1572
 * NGHTTP2_ERR_STREAM_CLOSED
1573
 *   The stream is already closed.
1574
 * NGHTTP2_ERR_STREAM_SHUT_WR
1575
 *   The stream is half-closed for transmission.
1576
 * NGHTTP2_ERR_PROTO
1577
 *   The stream is not reserved state
1578
 * NGHTTP2_ERR_STREAM_CLOSED
1579
 *   RST_STREAM was queued for this stream.
1580
 * NGHTTP2_ERR_SESSION_CLOSING
1581
 *   This session is closing.
1582
 * NGHTTP2_ERR_START_STREAM_NOT_ALLOWED
1583
 *   New stream cannot be created because GOAWAY is already sent or
1584
 *   received.
1585
 * NGHTTP2_ERR_PROTO
1586
 *   Client side attempted to send push response.
1587
 */
1588
static int
1589
session_predicate_push_response_headers_send(nghttp2_session *session,
1590
0
                                             nghttp2_stream *stream) {
1591
0
  int rv;
1592
  /* TODO Should disallow HEADERS if GOAWAY has already been issued? */
1593
0
  rv = session_predicate_for_stream_send(session, stream);
1594
0
  if (rv != 0) {
1595
0
    return rv;
1596
0
  }
1597
0
  assert(stream);
1598
0
  if (!session->server) {
1599
0
    return NGHTTP2_ERR_PROTO;
1600
0
  }
1601
0
  if (stream->state != NGHTTP2_STREAM_RESERVED) {
1602
0
    return NGHTTP2_ERR_PROTO;
1603
0
  }
1604
0
  if (session->goaway_flags & NGHTTP2_GOAWAY_RECV) {
1605
0
    return NGHTTP2_ERR_START_STREAM_NOT_ALLOWED;
1606
0
  }
1607
0
  return 0;
1608
0
}
1609
1610
/*
1611
 * This function checks HEADERS, which is neither stream-opening nor
1612
 * first response header, with the |stream| can be sent at this time.
1613
 * The |stream| can be NULL.
1614
 *
1615
 * This function returns 0 if it succeeds, or one of the following
1616
 * negative error codes:
1617
 *
1618
 * NGHTTP2_ERR_STREAM_CLOSED
1619
 *     The stream is already closed or does not exist.
1620
 * NGHTTP2_ERR_STREAM_SHUT_WR
1621
 *     The transmission is not allowed for this stream (e.g., a frame
1622
 *     with END_STREAM flag set has already sent)
1623
 * NGHTTP2_ERR_STREAM_CLOSING
1624
 *     RST_STREAM was queued for this stream.
1625
 * NGHTTP2_ERR_INVALID_STREAM_STATE
1626
 *     The state of the stream is not valid.
1627
 * NGHTTP2_ERR_SESSION_CLOSING
1628
 *   This session is closing.
1629
 */
1630
static int session_predicate_headers_send(nghttp2_session *session,
1631
0
                                          nghttp2_stream *stream) {
1632
0
  int rv;
1633
0
  rv = session_predicate_for_stream_send(session, stream);
1634
0
  if (rv != 0) {
1635
0
    return rv;
1636
0
  }
1637
0
  assert(stream);
1638
1639
0
  switch (stream->state) {
1640
0
  case NGHTTP2_STREAM_OPENED:
1641
0
    return 0;
1642
0
  case NGHTTP2_STREAM_CLOSING:
1643
0
    return NGHTTP2_ERR_STREAM_CLOSING;
1644
0
  default:
1645
0
    if (nghttp2_session_is_my_stream_id(session, stream->stream_id)) {
1646
0
      return 0;
1647
0
    }
1648
0
    return NGHTTP2_ERR_INVALID_STREAM_STATE;
1649
0
  }
1650
0
}
1651
1652
/*
1653
 * This function checks PUSH_PROMISE frame |frame| with the |stream|
1654
 * can be sent at this time.  The |stream| can be NULL.
1655
 *
1656
 * This function returns 0 if it succeeds, or one of the following
1657
 * negative error codes:
1658
 *
1659
 * NGHTTP2_ERR_START_STREAM_NOT_ALLOWED
1660
 *     New stream cannot be created because GOAWAY is already sent or
1661
 *     received.
1662
 * NGHTTP2_ERR_PROTO
1663
 *     The client side attempts to send PUSH_PROMISE, or the server
1664
 *     sends PUSH_PROMISE for the stream not initiated by the client.
1665
 * NGHTTP2_ERR_STREAM_CLOSED
1666
 *     The stream is already closed or does not exist.
1667
 * NGHTTP2_ERR_STREAM_CLOSING
1668
 *     RST_STREAM was queued for this stream.
1669
 * NGHTTP2_ERR_STREAM_SHUT_WR
1670
 *     The transmission is not allowed for this stream (e.g., a frame
1671
 *     with END_STREAM flag set has already sent)
1672
 * NGHTTP2_ERR_PUSH_DISABLED
1673
 *     The remote peer disabled reception of PUSH_PROMISE.
1674
 * NGHTTP2_ERR_SESSION_CLOSING
1675
 *   This session is closing.
1676
 */
1677
static int session_predicate_push_promise_send(nghttp2_session *session,
1678
0
                                               nghttp2_stream *stream) {
1679
0
  int rv;
1680
1681
0
  if (!session->server) {
1682
0
    return NGHTTP2_ERR_PROTO;
1683
0
  }
1684
1685
0
  rv = session_predicate_for_stream_send(session, stream);
1686
0
  if (rv != 0) {
1687
0
    return rv;
1688
0
  }
1689
1690
0
  assert(stream);
1691
1692
0
  if (session->remote_settings.enable_push == 0) {
1693
0
    return NGHTTP2_ERR_PUSH_DISABLED;
1694
0
  }
1695
0
  if (stream->state == NGHTTP2_STREAM_CLOSING) {
1696
0
    return NGHTTP2_ERR_STREAM_CLOSING;
1697
0
  }
1698
0
  if (session->goaway_flags & NGHTTP2_GOAWAY_RECV) {
1699
0
    return NGHTTP2_ERR_START_STREAM_NOT_ALLOWED;
1700
0
  }
1701
0
  return 0;
1702
0
}
1703
1704
/*
1705
 * This function checks WINDOW_UPDATE with the stream ID |stream_id|
1706
 * can be sent at this time. Note that END_STREAM flag of the previous
1707
 * frame does not affect the transmission of the WINDOW_UPDATE frame.
1708
 *
1709
 * This function returns 0 if it succeeds, or one of the following
1710
 * negative error codes:
1711
 *
1712
 * NGHTTP2_ERR_STREAM_CLOSED
1713
 *     The stream is already closed or does not exist.
1714
 * NGHTTP2_ERR_STREAM_CLOSING
1715
 *     RST_STREAM was queued for this stream.
1716
 * NGHTTP2_ERR_INVALID_STREAM_STATE
1717
 *     The state of the stream is not valid.
1718
 * NGHTTP2_ERR_SESSION_CLOSING
1719
 *   This session is closing.
1720
 */
1721
static int session_predicate_window_update_send(nghttp2_session *session,
1722
0
                                                int32_t stream_id) {
1723
0
  nghttp2_stream *stream;
1724
1725
0
  if (session_is_closing(session)) {
1726
0
    return NGHTTP2_ERR_SESSION_CLOSING;
1727
0
  }
1728
1729
0
  if (stream_id == 0) {
1730
    /* Connection-level window update */
1731
0
    return 0;
1732
0
  }
1733
0
  stream = nghttp2_session_get_stream(session, stream_id);
1734
0
  if (stream == NULL) {
1735
0
    return NGHTTP2_ERR_STREAM_CLOSED;
1736
0
  }
1737
0
  if (stream->state == NGHTTP2_STREAM_CLOSING) {
1738
0
    return NGHTTP2_ERR_STREAM_CLOSING;
1739
0
  }
1740
0
  if (state_reserved_local(session, stream)) {
1741
0
    return NGHTTP2_ERR_INVALID_STREAM_STATE;
1742
0
  }
1743
0
  return 0;
1744
0
}
1745
1746
static int session_predicate_altsvc_send(nghttp2_session *session,
1747
0
                                         int32_t stream_id) {
1748
0
  nghttp2_stream *stream;
1749
1750
0
  if (session_is_closing(session)) {
1751
0
    return NGHTTP2_ERR_SESSION_CLOSING;
1752
0
  }
1753
1754
0
  if (stream_id == 0) {
1755
0
    return 0;
1756
0
  }
1757
1758
0
  stream = nghttp2_session_get_stream(session, stream_id);
1759
0
  if (stream == NULL) {
1760
0
    return NGHTTP2_ERR_STREAM_CLOSED;
1761
0
  }
1762
0
  if (stream->state == NGHTTP2_STREAM_CLOSING) {
1763
0
    return NGHTTP2_ERR_STREAM_CLOSING;
1764
0
  }
1765
1766
0
  return 0;
1767
0
}
1768
1769
0
static int session_predicate_origin_send(nghttp2_session *session) {
1770
0
  if (session_is_closing(session)) {
1771
0
    return NGHTTP2_ERR_SESSION_CLOSING;
1772
0
  }
1773
0
  return 0;
1774
0
}
1775
1776
/* Take into account settings max frame size and both connection-level
1777
   flow control here */
1778
static ssize_t
1779
nghttp2_session_enforce_flow_control_limits(nghttp2_session *session,
1780
                                            nghttp2_stream *stream,
1781
0
                                            ssize_t requested_window_size) {
1782
0
  DEBUGF("send: remote windowsize connection=%d, remote maxframsize=%u, "
1783
0
         "stream(id %d)=%d\n",
1784
0
         session->remote_window_size, session->remote_settings.max_frame_size,
1785
0
         stream->stream_id, stream->remote_window_size);
1786
1787
0
  return nghttp2_min(nghttp2_min(nghttp2_min(requested_window_size,
1788
0
                                             stream->remote_window_size),
1789
0
                                 session->remote_window_size),
1790
0
                     (int32_t)session->remote_settings.max_frame_size);
1791
0
}
1792
1793
/*
1794
 * Returns the maximum length of next data read. If the
1795
 * connection-level and/or stream-wise flow control are enabled, the
1796
 * return value takes into account those current window sizes. The remote
1797
 * settings for max frame size is also taken into account.
1798
 */
1799
static size_t nghttp2_session_next_data_read(nghttp2_session *session,
1800
0
                                             nghttp2_stream *stream) {
1801
0
  ssize_t window_size;
1802
1803
0
  window_size = nghttp2_session_enforce_flow_control_limits(
1804
0
      session, stream, NGHTTP2_DATA_PAYLOADLEN);
1805
1806
0
  DEBUGF("send: available window=%zd\n", window_size);
1807
1808
0
  return window_size > 0 ? (size_t)window_size : 0;
1809
0
}
1810
1811
/*
1812
 * This function checks DATA with the |stream| can be sent at this
1813
 * time.  The |stream| can be NULL.
1814
 *
1815
 * This function returns 0 if it succeeds, or one of the following
1816
 * negative error codes:
1817
 *
1818
 * NGHTTP2_ERR_STREAM_CLOSED
1819
 *     The stream is already closed or does not exist.
1820
 * NGHTTP2_ERR_STREAM_SHUT_WR
1821
 *     The transmission is not allowed for this stream (e.g., a frame
1822
 *     with END_STREAM flag set has already sent)
1823
 * NGHTTP2_ERR_STREAM_CLOSING
1824
 *     RST_STREAM was queued for this stream.
1825
 * NGHTTP2_ERR_INVALID_STREAM_STATE
1826
 *     The state of the stream is not valid.
1827
 * NGHTTP2_ERR_SESSION_CLOSING
1828
 *   This session is closing.
1829
 */
1830
static int nghttp2_session_predicate_data_send(nghttp2_session *session,
1831
0
                                               nghttp2_stream *stream) {
1832
0
  int rv;
1833
0
  rv = session_predicate_for_stream_send(session, stream);
1834
0
  if (rv != 0) {
1835
0
    return rv;
1836
0
  }
1837
0
  assert(stream);
1838
0
  if (nghttp2_session_is_my_stream_id(session, stream->stream_id)) {
1839
    /* Request body data */
1840
    /* If stream->state is NGHTTP2_STREAM_CLOSING, RST_STREAM was
1841
       queued but not yet sent. In this case, we won't send DATA
1842
       frames. */
1843
0
    if (stream->state == NGHTTP2_STREAM_CLOSING) {
1844
0
      return NGHTTP2_ERR_STREAM_CLOSING;
1845
0
    }
1846
0
    if (stream->state == NGHTTP2_STREAM_RESERVED) {
1847
0
      return NGHTTP2_ERR_INVALID_STREAM_STATE;
1848
0
    }
1849
0
    return 0;
1850
0
  }
1851
  /* Response body data */
1852
0
  if (stream->state == NGHTTP2_STREAM_OPENED) {
1853
0
    return 0;
1854
0
  }
1855
0
  if (stream->state == NGHTTP2_STREAM_CLOSING) {
1856
0
    return NGHTTP2_ERR_STREAM_CLOSING;
1857
0
  }
1858
0
  return NGHTTP2_ERR_INVALID_STREAM_STATE;
1859
0
}
1860
1861
static ssize_t session_call_select_padding(nghttp2_session *session,
1862
                                           const nghttp2_frame *frame,
1863
0
                                           size_t max_payloadlen) {
1864
0
  ssize_t rv;
1865
1866
0
  if (frame->hd.length >= max_payloadlen) {
1867
0
    return (ssize_t)frame->hd.length;
1868
0
  }
1869
1870
0
  if (session->callbacks.select_padding_callback) {
1871
0
    size_t max_paddedlen;
1872
1873
0
    max_paddedlen =
1874
0
        nghttp2_min(frame->hd.length + NGHTTP2_MAX_PADLEN, max_payloadlen);
1875
1876
0
    rv = session->callbacks.select_padding_callback(
1877
0
        session, frame, max_paddedlen, session->user_data);
1878
0
    if (rv < (ssize_t)frame->hd.length || rv > (ssize_t)max_paddedlen) {
1879
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
1880
0
    }
1881
0
    return rv;
1882
0
  }
1883
0
  return (ssize_t)frame->hd.length;
1884
0
}
1885
1886
/* Add padding to HEADERS or PUSH_PROMISE. We use
1887
   frame->headers.padlen in this function to use the fact that
1888
   frame->push_promise has also padlen in the same position. */
1889
static int session_headers_add_pad(nghttp2_session *session,
1890
0
                                   nghttp2_frame *frame) {
1891
0
  int rv;
1892
0
  ssize_t padded_payloadlen;
1893
0
  nghttp2_active_outbound_item *aob;
1894
0
  nghttp2_bufs *framebufs;
1895
0
  size_t padlen;
1896
0
  size_t max_payloadlen;
1897
1898
0
  aob = &session->aob;
1899
0
  framebufs = &aob->framebufs;
1900
1901
0
  max_payloadlen = nghttp2_min(NGHTTP2_MAX_PAYLOADLEN,
1902
0
                               frame->hd.length + NGHTTP2_MAX_PADLEN);
1903
1904
0
  padded_payloadlen =
1905
0
      session_call_select_padding(session, frame, max_payloadlen);
1906
1907
0
  if (nghttp2_is_fatal((int)padded_payloadlen)) {
1908
0
    return (int)padded_payloadlen;
1909
0
  }
1910
1911
0
  padlen = (size_t)padded_payloadlen - frame->hd.length;
1912
1913
0
  DEBUGF("send: padding selected: payloadlen=%zd, padlen=%zu\n",
1914
0
         padded_payloadlen, padlen);
1915
1916
0
  rv = nghttp2_frame_add_pad(framebufs, &frame->hd, padlen, 0);
1917
1918
0
  if (rv != 0) {
1919
0
    return rv;
1920
0
  }
1921
1922
0
  frame->headers.padlen = padlen;
1923
1924
0
  return 0;
1925
0
}
1926
1927
static size_t session_estimate_headers_payload(nghttp2_session *session,
1928
                                               const nghttp2_nv *nva,
1929
                                               size_t nvlen,
1930
0
                                               size_t additional) {
1931
0
  return nghttp2_hd_deflate_bound(&session->hd_deflater, nva, nvlen) +
1932
0
         additional;
1933
0
}
1934
1935
static int session_pack_extension(nghttp2_session *session, nghttp2_bufs *bufs,
1936
0
                                  nghttp2_frame *frame) {
1937
0
  ssize_t rv;
1938
0
  nghttp2_buf *buf;
1939
0
  size_t buflen;
1940
0
  size_t framelen;
1941
1942
0
  assert(session->callbacks.pack_extension_callback);
1943
1944
0
  buf = &bufs->head->buf;
1945
0
  buflen = nghttp2_min(nghttp2_buf_avail(buf), NGHTTP2_MAX_PAYLOADLEN);
1946
1947
0
  rv = session->callbacks.pack_extension_callback(session, buf->last, buflen,
1948
0
                                                  frame, session->user_data);
1949
0
  if (rv == NGHTTP2_ERR_CANCEL) {
1950
0
    return (int)rv;
1951
0
  }
1952
1953
0
  if (rv < 0 || (size_t)rv > buflen) {
1954
0
    return NGHTTP2_ERR_CALLBACK_FAILURE;
1955
0
  }
1956
1957
0
  framelen = (size_t)rv;
1958
1959
0
  frame->hd.length = framelen;
1960
1961
0
  assert(buf->pos == buf->last);
1962
0
  buf->last += framelen;
1963
0
  buf->pos -= NGHTTP2_FRAME_HDLEN;
1964
1965
0
  nghttp2_frame_pack_frame_hd(buf->pos, &frame->hd);
1966
1967
0
  return 0;
1968
0
}
1969
1970
/*
1971
 * This function serializes frame for transmission.
1972
 *
1973
 * This function returns 0 if it succeeds, or one of negative error
1974
 * codes, including both fatal and non-fatal ones.
1975
 */
1976
static int session_prep_frame(nghttp2_session *session,
1977
0
                              nghttp2_outbound_item *item) {
1978
0
  int rv;
1979
0
  nghttp2_frame *frame;
1980
0
  nghttp2_mem *mem;
1981
1982
0
  mem = &session->mem;
1983
0
  frame = &item->frame;
1984
1985
0
  switch (frame->hd.type) {
1986
0
  case NGHTTP2_DATA: {
1987
0
    size_t next_readmax;
1988
0
    nghttp2_stream *stream;
1989
1990
0
    stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
1991
1992
0
    if (stream) {
1993
0
      assert(stream->item == item);
1994
0
    }
1995
1996
0
    rv = nghttp2_session_predicate_data_send(session, stream);
1997
0
    if (rv != 0) {
1998
      // If stream was already closed, nghttp2_session_get_stream()
1999
      // returns NULL, but item is still attached to the stream.
2000
      // Search stream including closed again.
2001
0
      stream = nghttp2_session_get_stream_raw(session, frame->hd.stream_id);
2002
0
      if (stream) {
2003
0
        int rv2;
2004
2005
0
        rv2 = nghttp2_stream_detach_item(stream);
2006
2007
0
        if (nghttp2_is_fatal(rv2)) {
2008
0
          return rv2;
2009
0
        }
2010
0
      }
2011
2012
0
      return rv;
2013
0
    }
2014
    /* Assuming stream is not NULL */
2015
0
    assert(stream);
2016
0
    next_readmax = nghttp2_session_next_data_read(session, stream);
2017
2018
0
    if (next_readmax == 0) {
2019
2020
      /* This must be true since we only pop DATA frame item from
2021
         queue when session->remote_window_size > 0 */
2022
0
      assert(session->remote_window_size > 0);
2023
2024
0
      rv = nghttp2_stream_defer_item(stream,
2025
0
                                     NGHTTP2_STREAM_FLAG_DEFERRED_FLOW_CONTROL);
2026
2027
0
      if (nghttp2_is_fatal(rv)) {
2028
0
        return rv;
2029
0
      }
2030
2031
0
      session->aob.item = NULL;
2032
0
      active_outbound_item_reset(&session->aob, mem);
2033
0
      return NGHTTP2_ERR_DEFERRED;
2034
0
    }
2035
2036
0
    rv = nghttp2_session_pack_data(session, &session->aob.framebufs,
2037
0
                                   next_readmax, frame, &item->aux_data.data,
2038
0
                                   stream);
2039
0
    if (rv == NGHTTP2_ERR_PAUSE) {
2040
0
      return rv;
2041
0
    }
2042
0
    if (rv == NGHTTP2_ERR_DEFERRED) {
2043
0
      rv = nghttp2_stream_defer_item(stream, NGHTTP2_STREAM_FLAG_DEFERRED_USER);
2044
2045
0
      if (nghttp2_is_fatal(rv)) {
2046
0
        return rv;
2047
0
      }
2048
2049
0
      session->aob.item = NULL;
2050
0
      active_outbound_item_reset(&session->aob, mem);
2051
0
      return NGHTTP2_ERR_DEFERRED;
2052
0
    }
2053
0
    if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
2054
0
      rv = nghttp2_stream_detach_item(stream);
2055
2056
0
      if (nghttp2_is_fatal(rv)) {
2057
0
        return rv;
2058
0
      }
2059
2060
0
      rv = nghttp2_session_add_rst_stream(session, frame->hd.stream_id,
2061
0
                                          NGHTTP2_INTERNAL_ERROR);
2062
0
      if (nghttp2_is_fatal(rv)) {
2063
0
        return rv;
2064
0
      }
2065
0
      return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
2066
0
    }
2067
0
    if (rv != 0) {
2068
0
      int rv2;
2069
2070
0
      rv2 = nghttp2_stream_detach_item(stream);
2071
2072
0
      if (nghttp2_is_fatal(rv2)) {
2073
0
        return rv2;
2074
0
      }
2075
2076
0
      return rv;
2077
0
    }
2078
0
    return 0;
2079
0
  }
2080
0
  case NGHTTP2_HEADERS: {
2081
0
    nghttp2_headers_aux_data *aux_data;
2082
0
    size_t estimated_payloadlen;
2083
2084
0
    aux_data = &item->aux_data.headers;
2085
2086
0
    if (frame->headers.cat == NGHTTP2_HCAT_REQUEST) {
2087
      /* initial HEADERS, which opens stream */
2088
0
      nghttp2_stream *stream;
2089
2090
0
      stream = nghttp2_session_open_stream(
2091
0
          session, frame->hd.stream_id, NGHTTP2_STREAM_FLAG_NONE,
2092
0
          &frame->headers.pri_spec, NGHTTP2_STREAM_INITIAL,
2093
0
          aux_data->stream_user_data);
2094
2095
0
      if (stream == NULL) {
2096
0
        return NGHTTP2_ERR_NOMEM;
2097
0
      }
2098
2099
      /* We don't call nghttp2_session_adjust_closed_stream() here,
2100
         since we don't keep closed stream in client side */
2101
2102
0
      rv = session_predicate_request_headers_send(session, item);
2103
0
      if (rv != 0) {
2104
0
        return rv;
2105
0
      }
2106
2107
0
      if (session_enforce_http_messaging(session)) {
2108
0
        nghttp2_http_record_request_method(stream, frame);
2109
0
      }
2110
0
    } else {
2111
0
      nghttp2_stream *stream;
2112
2113
0
      stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
2114
2115
0
      if (stream && stream->state == NGHTTP2_STREAM_RESERVED) {
2116
0
        rv = session_predicate_push_response_headers_send(session, stream);
2117
0
        if (rv == 0) {
2118
0
          frame->headers.cat = NGHTTP2_HCAT_PUSH_RESPONSE;
2119
2120
0
          if (aux_data->stream_user_data) {
2121
0
            stream->stream_user_data = aux_data->stream_user_data;
2122
0
          }
2123
0
        }
2124
0
      } else if (session_predicate_response_headers_send(session, stream) ==
2125
0
                 0) {
2126
0
        frame->headers.cat = NGHTTP2_HCAT_RESPONSE;
2127
0
        rv = 0;
2128
0
      } else {
2129
0
        frame->headers.cat = NGHTTP2_HCAT_HEADERS;
2130
2131
0
        rv = session_predicate_headers_send(session, stream);
2132
0
      }
2133
2134
0
      if (rv != 0) {
2135
0
        return rv;
2136
0
      }
2137
0
    }
2138
2139
0
    estimated_payloadlen = session_estimate_headers_payload(
2140
0
        session, frame->headers.nva, frame->headers.nvlen,
2141
0
        NGHTTP2_PRIORITY_SPECLEN);
2142
2143
0
    if (estimated_payloadlen > session->max_send_header_block_length) {
2144
0
      return NGHTTP2_ERR_FRAME_SIZE_ERROR;
2145
0
    }
2146
2147
0
    rv = nghttp2_frame_pack_headers(&session->aob.framebufs, &frame->headers,
2148
0
                                    &session->hd_deflater);
2149
2150
0
    if (rv != 0) {
2151
0
      return rv;
2152
0
    }
2153
2154
0
    DEBUGF("send: before padding, HEADERS serialized in %zd bytes\n",
2155
0
           nghttp2_bufs_len(&session->aob.framebufs));
2156
2157
0
    rv = session_headers_add_pad(session, frame);
2158
2159
0
    if (rv != 0) {
2160
0
      return rv;
2161
0
    }
2162
2163
0
    DEBUGF("send: HEADERS finally serialized in %zd bytes\n",
2164
0
           nghttp2_bufs_len(&session->aob.framebufs));
2165
2166
0
    if (frame->headers.cat == NGHTTP2_HCAT_REQUEST) {
2167
0
      assert(session->last_sent_stream_id < frame->hd.stream_id);
2168
0
      session->last_sent_stream_id = frame->hd.stream_id;
2169
0
    }
2170
2171
0
    return 0;
2172
0
  }
2173
0
  case NGHTTP2_PRIORITY: {
2174
0
    if (session_is_closing(session)) {
2175
0
      return NGHTTP2_ERR_SESSION_CLOSING;
2176
0
    }
2177
    /* PRIORITY frame can be sent at any time and to any stream
2178
       ID. */
2179
0
    nghttp2_frame_pack_priority(&session->aob.framebufs, &frame->priority);
2180
2181
    /* Peer can send PRIORITY frame against idle stream to create
2182
       "anchor" in dependency tree.  Only client can do this in
2183
       nghttp2.  In nghttp2, only server retains non-active (closed
2184
       or idle) streams in memory, so we don't open stream here. */
2185
0
    return 0;
2186
0
  }
2187
0
  case NGHTTP2_RST_STREAM:
2188
0
    if (session_is_closing(session)) {
2189
0
      return NGHTTP2_ERR_SESSION_CLOSING;
2190
0
    }
2191
0
    nghttp2_frame_pack_rst_stream(&session->aob.framebufs, &frame->rst_stream);
2192
0
    return 0;
2193
0
  case NGHTTP2_SETTINGS: {
2194
0
    if (frame->hd.flags & NGHTTP2_FLAG_ACK) {
2195
0
      assert(session->obq_flood_counter_ > 0);
2196
0
      --session->obq_flood_counter_;
2197
      /* When session is about to close, don't send SETTINGS ACK.
2198
         We are required to send SETTINGS without ACK though; for
2199
         example, we have to send SETTINGS as a part of connection
2200
         preface. */
2201
0
      if (session_is_closing(session)) {
2202
0
        return NGHTTP2_ERR_SESSION_CLOSING;
2203
0
      }
2204
0
    }
2205
2206
0
    rv = nghttp2_frame_pack_settings(&session->aob.framebufs, &frame->settings);
2207
0
    if (rv != 0) {
2208
0
      return rv;
2209
0
    }
2210
0
    return 0;
2211
0
  }
2212
0
  case NGHTTP2_PUSH_PROMISE: {
2213
0
    nghttp2_stream *stream;
2214
0
    size_t estimated_payloadlen;
2215
2216
    /* stream could be NULL if associated stream was already
2217
       closed. */
2218
0
    stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
2219
2220
    /* predicate should fail if stream is NULL. */
2221
0
    rv = session_predicate_push_promise_send(session, stream);
2222
0
    if (rv != 0) {
2223
0
      return rv;
2224
0
    }
2225
2226
0
    assert(stream);
2227
2228
0
    estimated_payloadlen = session_estimate_headers_payload(
2229
0
        session, frame->push_promise.nva, frame->push_promise.nvlen, 0);
2230
2231
0
    if (estimated_payloadlen > session->max_send_header_block_length) {
2232
0
      return NGHTTP2_ERR_FRAME_SIZE_ERROR;
2233
0
    }
2234
2235
0
    rv = nghttp2_frame_pack_push_promise(
2236
0
        &session->aob.framebufs, &frame->push_promise, &session->hd_deflater);
2237
0
    if (rv != 0) {
2238
0
      return rv;
2239
0
    }
2240
0
    rv = session_headers_add_pad(session, frame);
2241
0
    if (rv != 0) {
2242
0
      return rv;
2243
0
    }
2244
2245
0
    assert(session->last_sent_stream_id + 2 <=
2246
0
           frame->push_promise.promised_stream_id);
2247
0
    session->last_sent_stream_id = frame->push_promise.promised_stream_id;
2248
2249
0
    return 0;
2250
0
  }
2251
0
  case NGHTTP2_PING:
2252
0
    if (frame->hd.flags & NGHTTP2_FLAG_ACK) {
2253
0
      assert(session->obq_flood_counter_ > 0);
2254
0
      --session->obq_flood_counter_;
2255
0
    }
2256
    /* PING frame is allowed to be sent unless termination GOAWAY is
2257
       sent */
2258
0
    if (session->goaway_flags & NGHTTP2_GOAWAY_TERM_ON_SEND) {
2259
0
      return NGHTTP2_ERR_SESSION_CLOSING;
2260
0
    }
2261
0
    nghttp2_frame_pack_ping(&session->aob.framebufs, &frame->ping);
2262
0
    return 0;
2263
0
  case NGHTTP2_GOAWAY:
2264
0
    rv = nghttp2_frame_pack_goaway(&session->aob.framebufs, &frame->goaway);
2265
0
    if (rv != 0) {
2266
0
      return rv;
2267
0
    }
2268
0
    session->local_last_stream_id = frame->goaway.last_stream_id;
2269
2270
0
    return 0;
2271
0
  case NGHTTP2_WINDOW_UPDATE:
2272
0
    rv = session_predicate_window_update_send(session, frame->hd.stream_id);
2273
0
    if (rv != 0) {
2274
0
      return rv;
2275
0
    }
2276
0
    nghttp2_frame_pack_window_update(&session->aob.framebufs,
2277
0
                                     &frame->window_update);
2278
0
    return 0;
2279
0
  case NGHTTP2_CONTINUATION:
2280
    /* We never handle CONTINUATION here. */
2281
0
    assert(0);
2282
0
    return 0;
2283
0
  default: {
2284
0
    nghttp2_ext_aux_data *aux_data;
2285
2286
    /* extension frame */
2287
2288
0
    aux_data = &item->aux_data.ext;
2289
2290
0
    if (aux_data->builtin == 0) {
2291
0
      if (session_is_closing(session)) {
2292
0
        return NGHTTP2_ERR_SESSION_CLOSING;
2293
0
      }
2294
2295
0
      return session_pack_extension(session, &session->aob.framebufs, frame);
2296
0
    }
2297
2298
0
    switch (frame->hd.type) {
2299
0
    case NGHTTP2_ALTSVC:
2300
0
      rv = session_predicate_altsvc_send(session, frame->hd.stream_id);
2301
0
      if (rv != 0) {
2302
0
        return rv;
2303
0
      }
2304
2305
0
      nghttp2_frame_pack_altsvc(&session->aob.framebufs, &frame->ext);
2306
2307
0
      return 0;
2308
0
    case NGHTTP2_ORIGIN:
2309
0
      rv = session_predicate_origin_send(session);
2310
0
      if (rv != 0) {
2311
0
        return rv;
2312
0
      }
2313
2314
0
      rv = nghttp2_frame_pack_origin(&session->aob.framebufs, &frame->ext);
2315
0
      if (rv != 0) {
2316
0
        return rv;
2317
0
      }
2318
2319
0
      return 0;
2320
0
    default:
2321
      /* Unreachable here */
2322
0
      assert(0);
2323
0
      return 0;
2324
0
    }
2325
0
  }
2326
0
  }
2327
0
}
2328
2329
nghttp2_outbound_item *
2330
0
nghttp2_session_get_next_ob_item(nghttp2_session *session) {
2331
0
  if (nghttp2_outbound_queue_top(&session->ob_urgent)) {
2332
0
    return nghttp2_outbound_queue_top(&session->ob_urgent);
2333
0
  }
2334
2335
0
  if (nghttp2_outbound_queue_top(&session->ob_reg)) {
2336
0
    return nghttp2_outbound_queue_top(&session->ob_reg);
2337
0
  }
2338
2339
0
  if (!session_is_outgoing_concurrent_streams_max(session)) {
2340
0
    if (nghttp2_outbound_queue_top(&session->ob_syn)) {
2341
0
      return nghttp2_outbound_queue_top(&session->ob_syn);
2342
0
    }
2343
0
  }
2344
2345
0
  if (session->remote_window_size > 0) {
2346
0
    return nghttp2_stream_next_outbound_item(&session->root);
2347
0
  }
2348
2349
0
  return NULL;
2350
0
}
2351
2352
nghttp2_outbound_item *
2353
0
nghttp2_session_pop_next_ob_item(nghttp2_session *session) {
2354
0
  nghttp2_outbound_item *item;
2355
2356
0
  item = nghttp2_outbound_queue_top(&session->ob_urgent);
2357
0
  if (item) {
2358
0
    nghttp2_outbound_queue_pop(&session->ob_urgent);
2359
0
    item->queued = 0;
2360
0
    return item;
2361
0
  }
2362
2363
0
  item = nghttp2_outbound_queue_top(&session->ob_reg);
2364
0
  if (item) {
2365
0
    nghttp2_outbound_queue_pop(&session->ob_reg);
2366
0
    item->queued = 0;
2367
0
    return item;
2368
0
  }
2369
2370
0
  if (!session_is_outgoing_concurrent_streams_max(session)) {
2371
0
    item = nghttp2_outbound_queue_top(&session->ob_syn);
2372
0
    if (item) {
2373
0
      nghttp2_outbound_queue_pop(&session->ob_syn);
2374
0
      item->queued = 0;
2375
0
      return item;
2376
0
    }
2377
0
  }
2378
2379
0
  if (session->remote_window_size > 0) {
2380
0
    return nghttp2_stream_next_outbound_item(&session->root);
2381
0
  }
2382
2383
0
  return NULL;
2384
0
}
2385
2386
static int session_call_before_frame_send(nghttp2_session *session,
2387
0
                                          nghttp2_frame *frame) {
2388
0
  int rv;
2389
0
  if (session->callbacks.before_frame_send_callback) {
2390
0
    rv = session->callbacks.before_frame_send_callback(session, frame,
2391
0
                                                       session->user_data);
2392
0
    if (rv == NGHTTP2_ERR_CANCEL) {
2393
0
      return rv;
2394
0
    }
2395
2396
0
    if (rv != 0) {
2397
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
2398
0
    }
2399
0
  }
2400
0
  return 0;
2401
0
}
2402
2403
static int session_call_on_frame_send(nghttp2_session *session,
2404
0
                                      nghttp2_frame *frame) {
2405
0
  int rv;
2406
0
  if (session->callbacks.on_frame_send_callback) {
2407
0
    rv = session->callbacks.on_frame_send_callback(session, frame,
2408
0
                                                   session->user_data);
2409
0
    if (rv != 0) {
2410
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
2411
0
    }
2412
0
  }
2413
0
  return 0;
2414
0
}
2415
2416
0
static int find_stream_on_goaway_func(nghttp2_map_entry *entry, void *ptr) {
2417
0
  nghttp2_close_stream_on_goaway_arg *arg;
2418
0
  nghttp2_stream *stream;
2419
2420
0
  arg = (nghttp2_close_stream_on_goaway_arg *)ptr;
2421
0
  stream = (nghttp2_stream *)entry;
2422
2423
0
  if (nghttp2_session_is_my_stream_id(arg->session, stream->stream_id)) {
2424
0
    if (arg->incoming) {
2425
0
      return 0;
2426
0
    }
2427
0
  } else if (!arg->incoming) {
2428
0
    return 0;
2429
0
  }
2430
2431
0
  if (stream->state != NGHTTP2_STREAM_IDLE &&
2432
0
      (stream->flags & NGHTTP2_STREAM_FLAG_CLOSED) == 0 &&
2433
0
      stream->stream_id > arg->last_stream_id) {
2434
    /* We are collecting streams to close because we cannot call
2435
       nghttp2_session_close_stream() inside nghttp2_map_each().
2436
       Reuse closed_next member.. bad choice? */
2437
0
    assert(stream->closed_next == NULL);
2438
0
    assert(stream->closed_prev == NULL);
2439
2440
0
    if (arg->head) {
2441
0
      stream->closed_next = arg->head;
2442
0
      arg->head = stream;
2443
0
    } else {
2444
0
      arg->head = stream;
2445
0
    }
2446
0
  }
2447
2448
0
  return 0;
2449
0
}
2450
2451
/* Closes non-idle and non-closed streams whose stream ID >
2452
   last_stream_id.  If incoming is nonzero, we are going to close
2453
   incoming streams.  Otherwise, close outgoing streams. */
2454
static int session_close_stream_on_goaway(nghttp2_session *session,
2455
                                          int32_t last_stream_id,
2456
0
                                          int incoming) {
2457
0
  int rv;
2458
0
  nghttp2_stream *stream, *next_stream;
2459
0
  nghttp2_close_stream_on_goaway_arg arg = {session, NULL, last_stream_id,
2460
0
                                            incoming};
2461
2462
0
  rv = nghttp2_map_each(&session->streams, find_stream_on_goaway_func, &arg);
2463
0
  assert(rv == 0);
2464
2465
0
  stream = arg.head;
2466
0
  while (stream) {
2467
0
    next_stream = stream->closed_next;
2468
0
    stream->closed_next = NULL;
2469
0
    rv = nghttp2_session_close_stream(session, stream->stream_id,
2470
0
                                      NGHTTP2_REFUSED_STREAM);
2471
2472
    /* stream may be deleted here */
2473
2474
0
    stream = next_stream;
2475
2476
0
    if (nghttp2_is_fatal(rv)) {
2477
      /* Clean up closed_next member just in case */
2478
0
      while (stream) {
2479
0
        next_stream = stream->closed_next;
2480
0
        stream->closed_next = NULL;
2481
0
        stream = next_stream;
2482
0
      }
2483
0
      return rv;
2484
0
    }
2485
0
  }
2486
2487
0
  return 0;
2488
0
}
2489
2490
0
static void reschedule_stream(nghttp2_stream *stream) {
2491
0
  stream->last_writelen = stream->item->frame.hd.length;
2492
2493
0
  nghttp2_stream_reschedule(stream);
2494
0
}
2495
2496
static int session_update_stream_consumed_size(nghttp2_session *session,
2497
                                               nghttp2_stream *stream,
2498
                                               size_t delta_size);
2499
2500
static int session_update_connection_consumed_size(nghttp2_session *session,
2501
                                                   size_t delta_size);
2502
2503
/*
2504
 * Called after a frame is sent.  This function runs
2505
 * on_frame_send_callback and handles stream closure upon END_STREAM
2506
 * or RST_STREAM.  This function does not reset session->aob.  It is a
2507
 * responsibility of session_after_frame_sent2.
2508
 *
2509
 * This function returns 0 if it succeeds, or one of the following
2510
 * negative error codes:
2511
 *
2512
 * NGHTTP2_ERR_NOMEM
2513
 *     Out of memory.
2514
 * NGHTTP2_ERR_CALLBACK_FAILURE
2515
 *     The callback function failed.
2516
 */
2517
0
static int session_after_frame_sent1(nghttp2_session *session) {
2518
0
  int rv;
2519
0
  nghttp2_active_outbound_item *aob = &session->aob;
2520
0
  nghttp2_outbound_item *item = aob->item;
2521
0
  nghttp2_bufs *framebufs = &aob->framebufs;
2522
0
  nghttp2_frame *frame;
2523
0
  nghttp2_stream *stream;
2524
2525
0
  frame = &item->frame;
2526
2527
0
  if (frame->hd.type == NGHTTP2_DATA) {
2528
0
    nghttp2_data_aux_data *aux_data;
2529
2530
0
    aux_data = &item->aux_data.data;
2531
2532
0
    stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
2533
    /* We update flow control window after a frame was completely
2534
       sent. This is possible because we choose payload length not to
2535
       exceed the window */
2536
0
    session->remote_window_size -= (int32_t)frame->hd.length;
2537
0
    if (stream) {
2538
0
      stream->remote_window_size -= (int32_t)frame->hd.length;
2539
0
    }
2540
2541
0
    if (stream && aux_data->eof) {
2542
0
      rv = nghttp2_stream_detach_item(stream);
2543
0
      if (nghttp2_is_fatal(rv)) {
2544
0
        return rv;
2545
0
      }
2546
2547
      /* Call on_frame_send_callback after
2548
         nghttp2_stream_detach_item(), so that application can issue
2549
         nghttp2_submit_data() in the callback. */
2550
0
      if (session->callbacks.on_frame_send_callback) {
2551
0
        rv = session_call_on_frame_send(session, frame);
2552
0
        if (nghttp2_is_fatal(rv)) {
2553
0
          return rv;
2554
0
        }
2555
0
      }
2556
2557
0
      if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
2558
0
        int stream_closed;
2559
2560
0
        stream_closed =
2561
0
            (stream->shut_flags & NGHTTP2_SHUT_RDWR) == NGHTTP2_SHUT_RDWR;
2562
2563
0
        nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_WR);
2564
2565
0
        rv = nghttp2_session_close_stream_if_shut_rdwr(session, stream);
2566
0
        if (nghttp2_is_fatal(rv)) {
2567
0
          return rv;
2568
0
        }
2569
        /* stream may be NULL if it was closed */
2570
0
        if (stream_closed) {
2571
0
          stream = NULL;
2572
0
        }
2573
0
      }
2574
0
      return 0;
2575
0
    }
2576
2577
0
    if (session->callbacks.on_frame_send_callback) {
2578
0
      rv = session_call_on_frame_send(session, frame);
2579
0
      if (nghttp2_is_fatal(rv)) {
2580
0
        return rv;
2581
0
      }
2582
0
    }
2583
2584
0
    return 0;
2585
0
  }
2586
2587
  /* non-DATA frame */
2588
2589
0
  if (frame->hd.type == NGHTTP2_HEADERS ||
2590
0
      frame->hd.type == NGHTTP2_PUSH_PROMISE) {
2591
0
    if (nghttp2_bufs_next_present(framebufs)) {
2592
0
      DEBUGF("send: CONTINUATION exists, just return\n");
2593
0
      return 0;
2594
0
    }
2595
0
  }
2596
0
  rv = session_call_on_frame_send(session, frame);
2597
0
  if (nghttp2_is_fatal(rv)) {
2598
0
    return rv;
2599
0
  }
2600
0
  switch (frame->hd.type) {
2601
0
  case NGHTTP2_HEADERS: {
2602
0
    nghttp2_headers_aux_data *aux_data;
2603
2604
0
    stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
2605
0
    if (!stream) {
2606
0
      return 0;
2607
0
    }
2608
2609
0
    switch (frame->headers.cat) {
2610
0
    case NGHTTP2_HCAT_REQUEST: {
2611
0
      stream->state = NGHTTP2_STREAM_OPENING;
2612
0
      if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
2613
0
        nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_WR);
2614
0
      }
2615
0
      rv = nghttp2_session_close_stream_if_shut_rdwr(session, stream);
2616
0
      if (nghttp2_is_fatal(rv)) {
2617
0
        return rv;
2618
0
      }
2619
      /* We assume aux_data is a pointer to nghttp2_headers_aux_data */
2620
0
      aux_data = &item->aux_data.headers;
2621
0
      if (aux_data->data_prd.read_callback) {
2622
        /* nghttp2_submit_data() makes a copy of aux_data->data_prd */
2623
0
        rv = nghttp2_submit_data(session, NGHTTP2_FLAG_END_STREAM,
2624
0
                                 frame->hd.stream_id, &aux_data->data_prd);
2625
0
        if (nghttp2_is_fatal(rv)) {
2626
0
          return rv;
2627
0
        }
2628
        /* TODO nghttp2_submit_data() may fail if stream has already
2629
           DATA frame item.  We might have to handle it here. */
2630
0
      }
2631
0
      return 0;
2632
0
    }
2633
0
    case NGHTTP2_HCAT_PUSH_RESPONSE:
2634
0
      stream->flags = (uint8_t)(stream->flags & ~NGHTTP2_STREAM_FLAG_PUSH);
2635
0
      ++session->num_outgoing_streams;
2636
    /* Fall through */
2637
0
    case NGHTTP2_HCAT_RESPONSE:
2638
0
      stream->state = NGHTTP2_STREAM_OPENED;
2639
    /* Fall through */
2640
0
    case NGHTTP2_HCAT_HEADERS:
2641
0
      if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
2642
0
        nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_WR);
2643
0
      }
2644
0
      rv = nghttp2_session_close_stream_if_shut_rdwr(session, stream);
2645
0
      if (nghttp2_is_fatal(rv)) {
2646
0
        return rv;
2647
0
      }
2648
      /* We assume aux_data is a pointer to nghttp2_headers_aux_data */
2649
0
      aux_data = &item->aux_data.headers;
2650
0
      if (aux_data->data_prd.read_callback) {
2651
0
        rv = nghttp2_submit_data(session, NGHTTP2_FLAG_END_STREAM,
2652
0
                                 frame->hd.stream_id, &aux_data->data_prd);
2653
0
        if (nghttp2_is_fatal(rv)) {
2654
0
          return rv;
2655
0
        }
2656
        /* TODO nghttp2_submit_data() may fail if stream has already
2657
           DATA frame item.  We might have to handle it here. */
2658
0
      }
2659
0
      return 0;
2660
0
    default:
2661
      /* Unreachable */
2662
0
      assert(0);
2663
0
      return 0;
2664
0
    }
2665
0
  }
2666
0
  case NGHTTP2_PRIORITY:
2667
0
    if (session->server) {
2668
0
      return 0;
2669
0
      ;
2670
0
    }
2671
2672
0
    stream = nghttp2_session_get_stream_raw(session, frame->hd.stream_id);
2673
2674
0
    if (!stream) {
2675
0
      if (!session_detect_idle_stream(session, frame->hd.stream_id)) {
2676
0
        return 0;
2677
0
      }
2678
2679
0
      stream = nghttp2_session_open_stream(
2680
0
          session, frame->hd.stream_id, NGHTTP2_FLAG_NONE,
2681
0
          &frame->priority.pri_spec, NGHTTP2_STREAM_IDLE, NULL);
2682
0
      if (!stream) {
2683
0
        return NGHTTP2_ERR_NOMEM;
2684
0
      }
2685
0
    } else {
2686
0
      rv = nghttp2_session_reprioritize_stream(session, stream,
2687
0
                                               &frame->priority.pri_spec);
2688
0
      if (nghttp2_is_fatal(rv)) {
2689
0
        return rv;
2690
0
      }
2691
0
    }
2692
2693
0
    rv = nghttp2_session_adjust_idle_stream(session);
2694
2695
0
    if (nghttp2_is_fatal(rv)) {
2696
0
      return rv;
2697
0
    }
2698
2699
0
    return 0;
2700
0
  case NGHTTP2_RST_STREAM:
2701
0
    rv = nghttp2_session_close_stream(session, frame->hd.stream_id,
2702
0
                                      frame->rst_stream.error_code);
2703
0
    if (nghttp2_is_fatal(rv)) {
2704
0
      return rv;
2705
0
    }
2706
0
    return 0;
2707
0
  case NGHTTP2_GOAWAY: {
2708
0
    nghttp2_goaway_aux_data *aux_data;
2709
2710
0
    aux_data = &item->aux_data.goaway;
2711
2712
0
    if ((aux_data->flags & NGHTTP2_GOAWAY_AUX_SHUTDOWN_NOTICE) == 0) {
2713
2714
0
      if (aux_data->flags & NGHTTP2_GOAWAY_AUX_TERM_ON_SEND) {
2715
0
        session->goaway_flags |= NGHTTP2_GOAWAY_TERM_SENT;
2716
0
      }
2717
2718
0
      session->goaway_flags |= NGHTTP2_GOAWAY_SENT;
2719
2720
0
      rv = session_close_stream_on_goaway(session, frame->goaway.last_stream_id,
2721
0
                                          1);
2722
2723
0
      if (nghttp2_is_fatal(rv)) {
2724
0
        return rv;
2725
0
      }
2726
0
    }
2727
2728
0
    return 0;
2729
0
  }
2730
0
  case NGHTTP2_WINDOW_UPDATE:
2731
0
    if (frame->hd.stream_id == 0) {
2732
0
      session->window_update_queued = 0;
2733
0
      if (session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE) {
2734
0
        rv = session_update_connection_consumed_size(session, 0);
2735
0
      } else {
2736
0
        rv = nghttp2_session_update_recv_connection_window_size(session, 0);
2737
0
      }
2738
2739
0
      if (nghttp2_is_fatal(rv)) {
2740
0
        return rv;
2741
0
      }
2742
2743
0
      return 0;
2744
0
    }
2745
2746
0
    stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
2747
0
    if (!stream) {
2748
0
      return 0;
2749
0
    }
2750
2751
0
    stream->window_update_queued = 0;
2752
2753
    /* We don't have to send WINDOW_UPDATE if END_STREAM from peer
2754
       is seen. */
2755
0
    if (stream->shut_flags & NGHTTP2_SHUT_RD) {
2756
0
      return 0;
2757
0
    }
2758
2759
0
    if (session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE) {
2760
0
      rv = session_update_stream_consumed_size(session, stream, 0);
2761
0
    } else {
2762
0
      rv =
2763
0
          nghttp2_session_update_recv_stream_window_size(session, stream, 0, 1);
2764
0
    }
2765
2766
0
    if (nghttp2_is_fatal(rv)) {
2767
0
      return rv;
2768
0
    }
2769
2770
0
    return 0;
2771
0
  default:
2772
0
    return 0;
2773
0
  }
2774
0
}
2775
2776
/*
2777
 * Called after a frame is sent and session_after_frame_sent1.  This
2778
 * function is responsible to reset session->aob.
2779
 *
2780
 * This function returns 0 if it succeeds, or one of the following
2781
 * negative error codes:
2782
 *
2783
 * NGHTTP2_ERR_NOMEM
2784
 *     Out of memory.
2785
 * NGHTTP2_ERR_CALLBACK_FAILURE
2786
 *     The callback function failed.
2787
 */
2788
0
static int session_after_frame_sent2(nghttp2_session *session) {
2789
0
  int rv;
2790
0
  nghttp2_active_outbound_item *aob = &session->aob;
2791
0
  nghttp2_outbound_item *item = aob->item;
2792
0
  nghttp2_bufs *framebufs = &aob->framebufs;
2793
0
  nghttp2_frame *frame;
2794
0
  nghttp2_mem *mem;
2795
0
  nghttp2_stream *stream;
2796
0
  nghttp2_data_aux_data *aux_data;
2797
2798
0
  mem = &session->mem;
2799
0
  frame = &item->frame;
2800
2801
0
  if (frame->hd.type != NGHTTP2_DATA) {
2802
2803
0
    if (frame->hd.type == NGHTTP2_HEADERS ||
2804
0
        frame->hd.type == NGHTTP2_PUSH_PROMISE) {
2805
2806
0
      if (nghttp2_bufs_next_present(framebufs)) {
2807
0
        framebufs->cur = framebufs->cur->next;
2808
2809
0
        DEBUGF("send: next CONTINUATION frame, %zu bytes\n",
2810
0
               nghttp2_buf_len(&framebufs->cur->buf));
2811
2812
0
        return 0;
2813
0
      }
2814
0
    }
2815
2816
0
    active_outbound_item_reset(&session->aob, mem);
2817
2818
0
    return 0;
2819
0
  }
2820
2821
  /* DATA frame */
2822
2823
0
  aux_data = &item->aux_data.data;
2824
2825
  /* On EOF, we have already detached data.  Please note that
2826
     application may issue nghttp2_submit_data() in
2827
     on_frame_send_callback (call from session_after_frame_sent1),
2828
     which attach data to stream.  We don't want to detach it. */
2829
0
  if (aux_data->eof) {
2830
0
    active_outbound_item_reset(aob, mem);
2831
2832
0
    return 0;
2833
0
  }
2834
2835
  /* Reset no_copy here because next write may not use this. */
2836
0
  aux_data->no_copy = 0;
2837
2838
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
2839
2840
  /* If session is closed or RST_STREAM was queued, we won't send
2841
     further data. */
2842
0
  if (nghttp2_session_predicate_data_send(session, stream) != 0) {
2843
0
    if (stream) {
2844
0
      rv = nghttp2_stream_detach_item(stream);
2845
2846
0
      if (nghttp2_is_fatal(rv)) {
2847
0
        return rv;
2848
0
      }
2849
0
    }
2850
2851
0
    active_outbound_item_reset(aob, mem);
2852
2853
0
    return 0;
2854
0
  }
2855
2856
0
  aob->item = NULL;
2857
0
  active_outbound_item_reset(&session->aob, mem);
2858
2859
0
  return 0;
2860
0
}
2861
2862
static int session_call_send_data(nghttp2_session *session,
2863
                                  nghttp2_outbound_item *item,
2864
0
                                  nghttp2_bufs *framebufs) {
2865
0
  int rv;
2866
0
  nghttp2_buf *buf;
2867
0
  size_t length;
2868
0
  nghttp2_frame *frame;
2869
0
  nghttp2_data_aux_data *aux_data;
2870
2871
0
  buf = &framebufs->cur->buf;
2872
0
  frame = &item->frame;
2873
0
  length = frame->hd.length - frame->data.padlen;
2874
0
  aux_data = &item->aux_data.data;
2875
2876
0
  rv = session->callbacks.send_data_callback(session, frame, buf->pos, length,
2877
0
                                             &aux_data->data_prd.source,
2878
0
                                             session->user_data);
2879
2880
0
  switch (rv) {
2881
0
  case 0:
2882
0
  case NGHTTP2_ERR_WOULDBLOCK:
2883
0
  case NGHTTP2_ERR_PAUSE:
2884
0
  case NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE:
2885
0
    return rv;
2886
0
  default:
2887
0
    return NGHTTP2_ERR_CALLBACK_FAILURE;
2888
0
  }
2889
0
}
2890
2891
static ssize_t nghttp2_session_mem_send_internal(nghttp2_session *session,
2892
                                                 const uint8_t **data_ptr,
2893
0
                                                 int fast_cb) {
2894
0
  int rv;
2895
0
  nghttp2_active_outbound_item *aob;
2896
0
  nghttp2_bufs *framebufs;
2897
0
  nghttp2_mem *mem;
2898
2899
0
  mem = &session->mem;
2900
0
  aob = &session->aob;
2901
0
  framebufs = &aob->framebufs;
2902
2903
  /* We may have idle streams more than we expect (e.g.,
2904
     nghttp2_session_change_stream_priority() or
2905
     nghttp2_session_create_idle_stream()).  Adjust them here. */
2906
0
  rv = nghttp2_session_adjust_idle_stream(session);
2907
0
  if (nghttp2_is_fatal(rv)) {
2908
0
    return rv;
2909
0
  }
2910
2911
0
  for (;;) {
2912
0
    switch (aob->state) {
2913
0
    case NGHTTP2_OB_POP_ITEM: {
2914
0
      nghttp2_outbound_item *item;
2915
2916
0
      item = nghttp2_session_pop_next_ob_item(session);
2917
0
      if (item == NULL) {
2918
0
        return 0;
2919
0
      }
2920
2921
0
      rv = session_prep_frame(session, item);
2922
0
      if (rv == NGHTTP2_ERR_PAUSE) {
2923
0
        return 0;
2924
0
      }
2925
0
      if (rv == NGHTTP2_ERR_DEFERRED) {
2926
0
        DEBUGF("send: frame transmission deferred\n");
2927
0
        break;
2928
0
      }
2929
0
      if (rv < 0) {
2930
0
        int32_t opened_stream_id = 0;
2931
0
        uint32_t error_code = NGHTTP2_INTERNAL_ERROR;
2932
2933
0
        DEBUGF("send: frame preparation failed with %s\n",
2934
0
               nghttp2_strerror(rv));
2935
        /* TODO If the error comes from compressor, the connection
2936
           must be closed. */
2937
0
        if (item->frame.hd.type != NGHTTP2_DATA &&
2938
0
            session->callbacks.on_frame_not_send_callback && is_non_fatal(rv)) {
2939
0
          nghttp2_frame *frame = &item->frame;
2940
          /* The library is responsible for the transmission of
2941
             WINDOW_UPDATE frame, so we don't call error callback for
2942
             it. */
2943
0
          if (frame->hd.type != NGHTTP2_WINDOW_UPDATE &&
2944
0
              session->callbacks.on_frame_not_send_callback(
2945
0
                  session, frame, rv, session->user_data) != 0) {
2946
2947
0
            nghttp2_outbound_item_free(item, mem);
2948
0
            nghttp2_mem_free(mem, item);
2949
2950
0
            return NGHTTP2_ERR_CALLBACK_FAILURE;
2951
0
          }
2952
0
        }
2953
        /* We have to close stream opened by failed request HEADERS
2954
           or PUSH_PROMISE. */
2955
0
        switch (item->frame.hd.type) {
2956
0
        case NGHTTP2_HEADERS:
2957
0
          if (item->frame.headers.cat == NGHTTP2_HCAT_REQUEST) {
2958
0
            opened_stream_id = item->frame.hd.stream_id;
2959
0
            if (item->aux_data.headers.canceled) {
2960
0
              error_code = item->aux_data.headers.error_code;
2961
0
            } else {
2962
              /* Set error_code to REFUSED_STREAM so that application
2963
                 can send request again. */
2964
0
              error_code = NGHTTP2_REFUSED_STREAM;
2965
0
            }
2966
0
          }
2967
0
          break;
2968
0
        case NGHTTP2_PUSH_PROMISE:
2969
0
          opened_stream_id = item->frame.push_promise.promised_stream_id;
2970
0
          break;
2971
0
        }
2972
0
        if (opened_stream_id) {
2973
          /* careful not to override rv */
2974
0
          int rv2;
2975
0
          rv2 = nghttp2_session_close_stream(session, opened_stream_id,
2976
0
                                             error_code);
2977
2978
0
          if (nghttp2_is_fatal(rv2)) {
2979
0
            return rv2;
2980
0
          }
2981
0
        }
2982
2983
0
        nghttp2_outbound_item_free(item, mem);
2984
0
        nghttp2_mem_free(mem, item);
2985
0
        active_outbound_item_reset(aob, mem);
2986
2987
0
        if (rv == NGHTTP2_ERR_HEADER_COMP) {
2988
          /* If header compression error occurred, should terminiate
2989
             connection. */
2990
0
          rv = nghttp2_session_terminate_session(session,
2991
0
                                                 NGHTTP2_INTERNAL_ERROR);
2992
0
        }
2993
0
        if (nghttp2_is_fatal(rv)) {
2994
0
          return rv;
2995
0
        }
2996
0
        break;
2997
0
      }
2998
2999
0
      aob->item = item;
3000
3001
0
      nghttp2_bufs_rewind(framebufs);
3002
3003
0
      if (item->frame.hd.type != NGHTTP2_DATA) {
3004
0
        nghttp2_frame *frame;
3005
3006
0
        frame = &item->frame;
3007
3008
0
        DEBUGF("send: next frame: payloadlen=%zu, type=%u, flags=0x%02x, "
3009
0
               "stream_id=%d\n",
3010
0
               frame->hd.length, frame->hd.type, frame->hd.flags,
3011
0
               frame->hd.stream_id);
3012
3013
0
        rv = session_call_before_frame_send(session, frame);
3014
0
        if (nghttp2_is_fatal(rv)) {
3015
0
          return rv;
3016
0
        }
3017
3018
0
        if (rv == NGHTTP2_ERR_CANCEL) {
3019
0
          int32_t opened_stream_id = 0;
3020
0
          uint32_t error_code = NGHTTP2_INTERNAL_ERROR;
3021
3022
0
          if (session->callbacks.on_frame_not_send_callback) {
3023
0
            if (session->callbacks.on_frame_not_send_callback(
3024
0
                    session, frame, rv, session->user_data) != 0) {
3025
0
              return NGHTTP2_ERR_CALLBACK_FAILURE;
3026
0
            }
3027
0
          }
3028
3029
          /* We have to close stream opened by canceled request
3030
             HEADERS or PUSH_PROMISE. */
3031
0
          switch (item->frame.hd.type) {
3032
0
          case NGHTTP2_HEADERS:
3033
0
            if (item->frame.headers.cat == NGHTTP2_HCAT_REQUEST) {
3034
0
              opened_stream_id = item->frame.hd.stream_id;
3035
              /* We don't have to check
3036
                 item->aux_data.headers.canceled since it has already
3037
                 been checked. */
3038
              /* Set error_code to REFUSED_STREAM so that application
3039
                 can send request again. */
3040
0
              error_code = NGHTTP2_REFUSED_STREAM;
3041
0
            }
3042
0
            break;
3043
0
          case NGHTTP2_PUSH_PROMISE:
3044
0
            opened_stream_id = item->frame.push_promise.promised_stream_id;
3045
0
            break;
3046
0
          }
3047
0
          if (opened_stream_id) {
3048
            /* careful not to override rv */
3049
0
            int rv2;
3050
0
            rv2 = nghttp2_session_close_stream(session, opened_stream_id,
3051
0
                                               error_code);
3052
3053
0
            if (nghttp2_is_fatal(rv2)) {
3054
0
              return rv2;
3055
0
            }
3056
0
          }
3057
3058
0
          active_outbound_item_reset(aob, mem);
3059
3060
0
          break;
3061
0
        }
3062
0
      } else {
3063
0
        DEBUGF("send: next frame: DATA\n");
3064
3065
0
        if (item->aux_data.data.no_copy) {
3066
0
          aob->state = NGHTTP2_OB_SEND_NO_COPY;
3067
0
          break;
3068
0
        }
3069
0
      }
3070
3071
0
      DEBUGF("send: start transmitting frame type=%u, length=%zd\n",
3072
0
             framebufs->cur->buf.pos[3],
3073
0
             framebufs->cur->buf.last - framebufs->cur->buf.pos);
3074
3075
0
      aob->state = NGHTTP2_OB_SEND_DATA;
3076
3077
0
      break;
3078
0
    }
3079
0
    case NGHTTP2_OB_SEND_DATA: {
3080
0
      size_t datalen;
3081
0
      nghttp2_buf *buf;
3082
3083
0
      buf = &framebufs->cur->buf;
3084
3085
0
      if (buf->pos == buf->last) {
3086
0
        DEBUGF("send: end transmission of a frame\n");
3087
3088
        /* Frame has completely sent */
3089
0
        if (fast_cb) {
3090
0
          rv = session_after_frame_sent2(session);
3091
0
        } else {
3092
0
          rv = session_after_frame_sent1(session);
3093
0
          if (rv < 0) {
3094
            /* FATAL */
3095
0
            assert(nghttp2_is_fatal(rv));
3096
0
            return rv;
3097
0
          }
3098
0
          rv = session_after_frame_sent2(session);
3099
0
        }
3100
0
        if (rv < 0) {
3101
          /* FATAL */
3102
0
          assert(nghttp2_is_fatal(rv));
3103
0
          return rv;
3104
0
        }
3105
        /* We have already adjusted the next state */
3106
0
        break;
3107
0
      }
3108
3109
0
      *data_ptr = buf->pos;
3110
0
      datalen = nghttp2_buf_len(buf);
3111
3112
      /* We increment the offset here. If send_callback does not send
3113
         everything, we will adjust it. */
3114
0
      buf->pos += datalen;
3115
3116
0
      return (ssize_t)datalen;
3117
0
    }
3118
0
    case NGHTTP2_OB_SEND_NO_COPY: {
3119
0
      nghttp2_stream *stream;
3120
0
      nghttp2_frame *frame;
3121
0
      int pause;
3122
3123
0
      DEBUGF("send: no copy DATA\n");
3124
3125
0
      frame = &aob->item->frame;
3126
3127
0
      stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
3128
0
      if (stream == NULL) {
3129
0
        DEBUGF("send: no copy DATA cancelled because stream was closed\n");
3130
3131
0
        active_outbound_item_reset(aob, mem);
3132
3133
0
        break;
3134
0
      }
3135
3136
0
      rv = session_call_send_data(session, aob->item, framebufs);
3137
0
      if (nghttp2_is_fatal(rv)) {
3138
0
        return rv;
3139
0
      }
3140
3141
0
      if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
3142
0
        rv = nghttp2_stream_detach_item(stream);
3143
3144
0
        if (nghttp2_is_fatal(rv)) {
3145
0
          return rv;
3146
0
        }
3147
3148
0
        rv = nghttp2_session_add_rst_stream(session, frame->hd.stream_id,
3149
0
                                            NGHTTP2_INTERNAL_ERROR);
3150
0
        if (nghttp2_is_fatal(rv)) {
3151
0
          return rv;
3152
0
        }
3153
3154
0
        active_outbound_item_reset(aob, mem);
3155
3156
0
        break;
3157
0
      }
3158
3159
0
      if (rv == NGHTTP2_ERR_WOULDBLOCK) {
3160
0
        return 0;
3161
0
      }
3162
3163
0
      pause = (rv == NGHTTP2_ERR_PAUSE);
3164
3165
0
      rv = session_after_frame_sent1(session);
3166
0
      if (rv < 0) {
3167
0
        assert(nghttp2_is_fatal(rv));
3168
0
        return rv;
3169
0
      }
3170
0
      rv = session_after_frame_sent2(session);
3171
0
      if (rv < 0) {
3172
0
        assert(nghttp2_is_fatal(rv));
3173
0
        return rv;
3174
0
      }
3175
3176
      /* We have already adjusted the next state */
3177
3178
0
      if (pause) {
3179
0
        return 0;
3180
0
      }
3181
3182
0
      break;
3183
0
    }
3184
0
    case NGHTTP2_OB_SEND_CLIENT_MAGIC: {
3185
0
      size_t datalen;
3186
0
      nghttp2_buf *buf;
3187
3188
0
      buf = &framebufs->cur->buf;
3189
3190
0
      if (buf->pos == buf->last) {
3191
0
        DEBUGF("send: end transmission of client magic\n");
3192
0
        active_outbound_item_reset(aob, mem);
3193
0
        break;
3194
0
      }
3195
3196
0
      *data_ptr = buf->pos;
3197
0
      datalen = nghttp2_buf_len(buf);
3198
3199
0
      buf->pos += datalen;
3200
3201
0
      return (ssize_t)datalen;
3202
0
    }
3203
0
    }
3204
0
  }
3205
0
}
3206
3207
ssize_t nghttp2_session_mem_send(nghttp2_session *session,
3208
0
                                 const uint8_t **data_ptr) {
3209
0
  int rv;
3210
0
  ssize_t len;
3211
3212
0
  *data_ptr = NULL;
3213
3214
0
  len = nghttp2_session_mem_send_internal(session, data_ptr, 1);
3215
0
  if (len <= 0) {
3216
0
    return len;
3217
0
  }
3218
3219
0
  if (session->aob.item) {
3220
    /* We have to call session_after_frame_sent1 here to handle stream
3221
       closure upon transmission of frames.  Otherwise, END_STREAM may
3222
       be reached to client before we call nghttp2_session_mem_send
3223
       again and we may get exceeding number of incoming streams. */
3224
0
    rv = session_after_frame_sent1(session);
3225
0
    if (rv < 0) {
3226
0
      assert(nghttp2_is_fatal(rv));
3227
0
      return (ssize_t)rv;
3228
0
    }
3229
0
  }
3230
3231
0
  return len;
3232
0
}
3233
3234
0
int nghttp2_session_send(nghttp2_session *session) {
3235
0
  const uint8_t *data = NULL;
3236
0
  ssize_t datalen;
3237
0
  ssize_t sentlen;
3238
0
  nghttp2_bufs *framebufs;
3239
3240
0
  framebufs = &session->aob.framebufs;
3241
3242
0
  for (;;) {
3243
0
    datalen = nghttp2_session_mem_send_internal(session, &data, 0);
3244
0
    if (datalen <= 0) {
3245
0
      return (int)datalen;
3246
0
    }
3247
0
    sentlen = session->callbacks.send_callback(session, data, (size_t)datalen,
3248
0
                                               0, session->user_data);
3249
0
    if (sentlen < 0) {
3250
0
      if (sentlen == NGHTTP2_ERR_WOULDBLOCK) {
3251
        /* Transmission canceled. Rewind the offset */
3252
0
        framebufs->cur->buf.pos -= datalen;
3253
3254
0
        return 0;
3255
0
      }
3256
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3257
0
    }
3258
    /* Rewind the offset to the amount of unsent bytes */
3259
0
    framebufs->cur->buf.pos -= datalen - sentlen;
3260
0
  }
3261
0
}
3262
3263
static ssize_t session_recv(nghttp2_session *session, uint8_t *buf,
3264
0
                            size_t len) {
3265
0
  ssize_t rv;
3266
0
  rv = session->callbacks.recv_callback(session, buf, len, 0,
3267
0
                                        session->user_data);
3268
0
  if (rv > 0) {
3269
0
    if ((size_t)rv > len) {
3270
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3271
0
    }
3272
0
  } else if (rv < 0 && rv != NGHTTP2_ERR_WOULDBLOCK && rv != NGHTTP2_ERR_EOF) {
3273
0
    return NGHTTP2_ERR_CALLBACK_FAILURE;
3274
0
  }
3275
0
  return rv;
3276
0
}
3277
3278
static int session_call_on_begin_frame(nghttp2_session *session,
3279
0
                                       const nghttp2_frame_hd *hd) {
3280
0
  int rv;
3281
3282
0
  if (session->callbacks.on_begin_frame_callback) {
3283
3284
0
    rv = session->callbacks.on_begin_frame_callback(session, hd,
3285
0
                                                    session->user_data);
3286
3287
0
    if (rv != 0) {
3288
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3289
0
    }
3290
0
  }
3291
3292
0
  return 0;
3293
0
}
3294
3295
static int session_call_on_frame_received(nghttp2_session *session,
3296
0
                                          nghttp2_frame *frame) {
3297
0
  int rv;
3298
0
  if (session->callbacks.on_frame_recv_callback) {
3299
0
    rv = session->callbacks.on_frame_recv_callback(session, frame,
3300
0
                                                   session->user_data);
3301
0
    if (rv != 0) {
3302
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3303
0
    }
3304
0
  }
3305
0
  return 0;
3306
0
}
3307
3308
static int session_call_on_begin_headers(nghttp2_session *session,
3309
0
                                         nghttp2_frame *frame) {
3310
0
  int rv;
3311
0
  DEBUGF("recv: call on_begin_headers callback stream_id=%d\n",
3312
0
         frame->hd.stream_id);
3313
0
  if (session->callbacks.on_begin_headers_callback) {
3314
0
    rv = session->callbacks.on_begin_headers_callback(session, frame,
3315
0
                                                      session->user_data);
3316
0
    if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
3317
0
      return rv;
3318
0
    }
3319
0
    if (rv != 0) {
3320
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3321
0
    }
3322
0
  }
3323
0
  return 0;
3324
0
}
3325
3326
static int session_call_on_header(nghttp2_session *session,
3327
                                  const nghttp2_frame *frame,
3328
0
                                  const nghttp2_hd_nv *nv) {
3329
0
  int rv = 0;
3330
0
  if (session->callbacks.on_header_callback2) {
3331
0
    rv = session->callbacks.on_header_callback2(
3332
0
        session, frame, nv->name, nv->value, nv->flags, session->user_data);
3333
0
  } else if (session->callbacks.on_header_callback) {
3334
0
    rv = session->callbacks.on_header_callback(
3335
0
        session, frame, nv->name->base, nv->name->len, nv->value->base,
3336
0
        nv->value->len, nv->flags, session->user_data);
3337
0
  }
3338
3339
0
  if (rv == NGHTTP2_ERR_PAUSE || rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
3340
0
    return rv;
3341
0
  }
3342
0
  if (rv != 0) {
3343
0
    return NGHTTP2_ERR_CALLBACK_FAILURE;
3344
0
  }
3345
3346
0
  return 0;
3347
0
}
3348
3349
static int session_call_on_invalid_header(nghttp2_session *session,
3350
                                          const nghttp2_frame *frame,
3351
0
                                          const nghttp2_hd_nv *nv) {
3352
0
  int rv;
3353
0
  if (session->callbacks.on_invalid_header_callback2) {
3354
0
    rv = session->callbacks.on_invalid_header_callback2(
3355
0
        session, frame, nv->name, nv->value, nv->flags, session->user_data);
3356
0
  } else if (session->callbacks.on_invalid_header_callback) {
3357
0
    rv = session->callbacks.on_invalid_header_callback(
3358
0
        session, frame, nv->name->base, nv->name->len, nv->value->base,
3359
0
        nv->value->len, nv->flags, session->user_data);
3360
0
  } else {
3361
0
    return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
3362
0
  }
3363
3364
0
  if (rv == NGHTTP2_ERR_PAUSE || rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
3365
0
    return rv;
3366
0
  }
3367
0
  if (rv != 0) {
3368
0
    return NGHTTP2_ERR_CALLBACK_FAILURE;
3369
0
  }
3370
3371
0
  return 0;
3372
0
}
3373
3374
static int
3375
session_call_on_extension_chunk_recv_callback(nghttp2_session *session,
3376
0
                                              const uint8_t *data, size_t len) {
3377
0
  int rv;
3378
0
  nghttp2_inbound_frame *iframe = &session->iframe;
3379
0
  nghttp2_frame *frame = &iframe->frame;
3380
3381
0
  if (session->callbacks.on_extension_chunk_recv_callback) {
3382
0
    rv = session->callbacks.on_extension_chunk_recv_callback(
3383
0
        session, &frame->hd, data, len, session->user_data);
3384
0
    if (rv == NGHTTP2_ERR_CANCEL) {
3385
0
      return rv;
3386
0
    }
3387
0
    if (rv != 0) {
3388
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3389
0
    }
3390
0
  }
3391
3392
0
  return 0;
3393
0
}
3394
3395
0
static int session_call_unpack_extension_callback(nghttp2_session *session) {
3396
0
  int rv;
3397
0
  nghttp2_inbound_frame *iframe = &session->iframe;
3398
0
  nghttp2_frame *frame = &iframe->frame;
3399
0
  void *payload = NULL;
3400
3401
0
  rv = session->callbacks.unpack_extension_callback(
3402
0
      session, &payload, &frame->hd, session->user_data);
3403
0
  if (rv == NGHTTP2_ERR_CANCEL) {
3404
0
    return rv;
3405
0
  }
3406
0
  if (rv != 0) {
3407
0
    return NGHTTP2_ERR_CALLBACK_FAILURE;
3408
0
  }
3409
3410
0
  frame->ext.payload = payload;
3411
3412
0
  return 0;
3413
0
}
3414
3415
/*
3416
 * Handles frame size error.
3417
 *
3418
 * This function returns 0 if it succeeds, or one of the following
3419
 * negative error codes:
3420
 *
3421
 * NGHTTP2_ERR_NOMEM
3422
 *   Out of memory.
3423
 */
3424
0
static int session_handle_frame_size_error(nghttp2_session *session) {
3425
  /* TODO Currently no callback is called for this error, because we
3426
     call this callback before reading any payload */
3427
0
  return nghttp2_session_terminate_session(session, NGHTTP2_FRAME_SIZE_ERROR);
3428
0
}
3429
3430
0
static uint32_t get_error_code_from_lib_error_code(int lib_error_code) {
3431
0
  switch (lib_error_code) {
3432
0
  case NGHTTP2_ERR_STREAM_CLOSED:
3433
0
    return NGHTTP2_STREAM_CLOSED;
3434
0
  case NGHTTP2_ERR_HEADER_COMP:
3435
0
    return NGHTTP2_COMPRESSION_ERROR;
3436
0
  case NGHTTP2_ERR_FRAME_SIZE_ERROR:
3437
0
    return NGHTTP2_FRAME_SIZE_ERROR;
3438
0
  case NGHTTP2_ERR_FLOW_CONTROL:
3439
0
    return NGHTTP2_FLOW_CONTROL_ERROR;
3440
0
  case NGHTTP2_ERR_REFUSED_STREAM:
3441
0
    return NGHTTP2_REFUSED_STREAM;
3442
0
  case NGHTTP2_ERR_PROTO:
3443
0
  case NGHTTP2_ERR_HTTP_HEADER:
3444
0
  case NGHTTP2_ERR_HTTP_MESSAGING:
3445
0
    return NGHTTP2_PROTOCOL_ERROR;
3446
0
  default:
3447
0
    return NGHTTP2_INTERNAL_ERROR;
3448
0
  }
3449
0
}
3450
3451
/*
3452
 * Calls on_invalid_frame_recv_callback if it is set to |session|.
3453
 *
3454
 * This function returns 0 if it succeeds, or one of the following
3455
 * negative error codes:
3456
 *
3457
 * NGHTTP2_ERR_CALLBACK_FAILURE
3458
 *   User defined callback function fails.
3459
 */
3460
static int session_call_on_invalid_frame_recv_callback(nghttp2_session *session,
3461
                                                       nghttp2_frame *frame,
3462
0
                                                       int lib_error_code) {
3463
0
  if (session->callbacks.on_invalid_frame_recv_callback) {
3464
0
    if (session->callbacks.on_invalid_frame_recv_callback(
3465
0
            session, frame, lib_error_code, session->user_data) != 0) {
3466
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3467
0
    }
3468
0
  }
3469
0
  return 0;
3470
0
}
3471
3472
static int session_handle_invalid_stream2(nghttp2_session *session,
3473
                                          int32_t stream_id,
3474
                                          nghttp2_frame *frame,
3475
0
                                          int lib_error_code) {
3476
0
  int rv;
3477
0
  rv = nghttp2_session_add_rst_stream(
3478
0
      session, stream_id, get_error_code_from_lib_error_code(lib_error_code));
3479
0
  if (rv != 0) {
3480
0
    return rv;
3481
0
  }
3482
0
  if (session->callbacks.on_invalid_frame_recv_callback) {
3483
0
    if (session->callbacks.on_invalid_frame_recv_callback(
3484
0
            session, frame, lib_error_code, session->user_data) != 0) {
3485
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3486
0
    }
3487
0
  }
3488
0
  return 0;
3489
0
}
3490
3491
static int session_handle_invalid_stream(nghttp2_session *session,
3492
                                         nghttp2_frame *frame,
3493
0
                                         int lib_error_code) {
3494
0
  return session_handle_invalid_stream2(session, frame->hd.stream_id, frame,
3495
0
                                        lib_error_code);
3496
0
}
3497
3498
static int session_inflate_handle_invalid_stream(nghttp2_session *session,
3499
                                                 nghttp2_frame *frame,
3500
0
                                                 int lib_error_code) {
3501
0
  int rv;
3502
0
  rv = session_handle_invalid_stream(session, frame, lib_error_code);
3503
0
  if (nghttp2_is_fatal(rv)) {
3504
0
    return rv;
3505
0
  }
3506
0
  return NGHTTP2_ERR_IGN_HEADER_BLOCK;
3507
0
}
3508
3509
/*
3510
 * Handles invalid frame which causes connection error.
3511
 */
3512
static int session_handle_invalid_connection(nghttp2_session *session,
3513
                                             nghttp2_frame *frame,
3514
                                             int lib_error_code,
3515
0
                                             const char *reason) {
3516
0
  if (session->callbacks.on_invalid_frame_recv_callback) {
3517
0
    if (session->callbacks.on_invalid_frame_recv_callback(
3518
0
            session, frame, lib_error_code, session->user_data) != 0) {
3519
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
3520
0
    }
3521
0
  }
3522
0
  return nghttp2_session_terminate_session_with_reason(
3523
0
      session, get_error_code_from_lib_error_code(lib_error_code), reason);
3524
0
}
3525
3526
static int session_inflate_handle_invalid_connection(nghttp2_session *session,
3527
                                                     nghttp2_frame *frame,
3528
                                                     int lib_error_code,
3529
0
                                                     const char *reason) {
3530
0
  int rv;
3531
0
  rv =
3532
0
      session_handle_invalid_connection(session, frame, lib_error_code, reason);
3533
0
  if (nghttp2_is_fatal(rv)) {
3534
0
    return rv;
3535
0
  }
3536
0
  return NGHTTP2_ERR_IGN_HEADER_BLOCK;
3537
0
}
3538
3539
/*
3540
 * Inflates header block in the memory pointed by |in| with |inlen|
3541
 * bytes. If this function returns NGHTTP2_ERR_PAUSE, the caller must
3542
 * call this function again, until it returns 0 or one of negative
3543
 * error code.  If |call_header_cb| is zero, the on_header_callback
3544
 * are not invoked and the function never return NGHTTP2_ERR_PAUSE. If
3545
 * the given |in| is the last chunk of header block, the |final| must
3546
 * be nonzero. If header block is successfully processed (which is
3547
 * indicated by the return value 0, NGHTTP2_ERR_PAUSE or
3548
 * NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE), the number of processed
3549
 * input bytes is assigned to the |*readlen_ptr|.
3550
 *
3551
 * This function return 0 if it succeeds, or one of the negative error
3552
 * codes:
3553
 *
3554
 * NGHTTP2_ERR_CALLBACK_FAILURE
3555
 *     The callback function failed.
3556
 * NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE
3557
 *     The callback returns this error code, indicating that this
3558
 *     stream should be RST_STREAMed.
3559
 * NGHTTP2_ERR_NOMEM
3560
 *     Out of memory.
3561
 * NGHTTP2_ERR_PAUSE
3562
 *     The callback function returned NGHTTP2_ERR_PAUSE
3563
 * NGHTTP2_ERR_HEADER_COMP
3564
 *     Header decompression failed
3565
 */
3566
static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame,
3567
                                size_t *readlen_ptr, uint8_t *in, size_t inlen,
3568
0
                                int final, int call_header_cb) {
3569
0
  ssize_t proclen;
3570
0
  int rv;
3571
0
  int inflate_flags;
3572
0
  nghttp2_hd_nv nv;
3573
0
  nghttp2_stream *stream;
3574
0
  nghttp2_stream *subject_stream;
3575
0
  int trailer = 0;
3576
3577
0
  *readlen_ptr = 0;
3578
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
3579
3580
0
  if (frame->hd.type == NGHTTP2_PUSH_PROMISE) {
3581
0
    subject_stream = nghttp2_session_get_stream(
3582
0
        session, frame->push_promise.promised_stream_id);
3583
0
  } else {
3584
0
    subject_stream = stream;
3585
0
    trailer = session_trailer_headers(session, stream, frame);
3586
0
  }
3587
3588
0
  DEBUGF("recv: decoding header block %zu bytes\n", inlen);
3589
0
  for (;;) {
3590
0
    inflate_flags = 0;
3591
0
    proclen = nghttp2_hd_inflate_hd_nv(&session->hd_inflater, &nv,
3592
0
                                       &inflate_flags, in, inlen, final);
3593
0
    if (nghttp2_is_fatal((int)proclen)) {
3594
0
      return (int)proclen;
3595
0
    }
3596
0
    if (proclen < 0) {
3597
0
      if (session->iframe.state == NGHTTP2_IB_READ_HEADER_BLOCK) {
3598
0
        if (subject_stream && subject_stream->state != NGHTTP2_STREAM_CLOSING) {
3599
          /* Adding RST_STREAM here is very important. It prevents
3600
             from invoking subsequent callbacks for the same stream
3601
             ID. */
3602
0
          rv = nghttp2_session_add_rst_stream(
3603
0
              session, subject_stream->stream_id, NGHTTP2_COMPRESSION_ERROR);
3604
3605
0
          if (nghttp2_is_fatal(rv)) {
3606
0
            return rv;
3607
0
          }
3608
0
        }
3609
0
      }
3610
0
      rv =
3611
0
          nghttp2_session_terminate_session(session, NGHTTP2_COMPRESSION_ERROR);
3612
0
      if (nghttp2_is_fatal(rv)) {
3613
0
        return rv;
3614
0
      }
3615
3616
0
      return NGHTTP2_ERR_HEADER_COMP;
3617
0
    }
3618
0
    in += proclen;
3619
0
    inlen -= (size_t)proclen;
3620
0
    *readlen_ptr += (size_t)proclen;
3621
3622
0
    DEBUGF("recv: proclen=%zd\n", proclen);
3623
3624
0
    if (call_header_cb && (inflate_flags & NGHTTP2_HD_INFLATE_EMIT)) {
3625
0
      rv = 0;
3626
0
      if (subject_stream) {
3627
0
        if (session_enforce_http_messaging(session)) {
3628
0
          rv = nghttp2_http_on_header(session, subject_stream, frame, &nv,
3629
0
                                      trailer);
3630
3631
0
          if (rv == NGHTTP2_ERR_IGN_HTTP_HEADER) {
3632
            /* Don't overwrite rv here */
3633
0
            int rv2;
3634
3635
0
            rv2 = session_call_on_invalid_header(session, frame, &nv);
3636
0
            if (rv2 == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
3637
0
              rv = NGHTTP2_ERR_HTTP_HEADER;
3638
0
            } else {
3639
0
              if (rv2 != 0) {
3640
0
                return rv2;
3641
0
              }
3642
3643
              /* header is ignored */
3644
0
              DEBUGF("recv: HTTP ignored: type=%u, id=%d, header %.*s: %.*s\n",
3645
0
                     frame->hd.type, frame->hd.stream_id, (int)nv.name->len,
3646
0
                     nv.name->base, (int)nv.value->len, nv.value->base);
3647
3648
0
              rv2 = session_call_error_callback(
3649
0
                  session, NGHTTP2_ERR_HTTP_HEADER,
3650
0
                  "Ignoring received invalid HTTP header field: frame type: "
3651
0
                  "%u, stream: %d, name: [%.*s], value: [%.*s]",
3652
0
                  frame->hd.type, frame->hd.stream_id, (int)nv.name->len,
3653
0
                  nv.name->base, (int)nv.value->len, nv.value->base);
3654
3655
0
              if (nghttp2_is_fatal(rv2)) {
3656
0
                return rv2;
3657
0
              }
3658
0
            }
3659
0
          }
3660
3661
0
          if (rv == NGHTTP2_ERR_HTTP_HEADER) {
3662
0
            DEBUGF("recv: HTTP error: type=%u, id=%d, header %.*s: %.*s\n",
3663
0
                   frame->hd.type, frame->hd.stream_id, (int)nv.name->len,
3664
0
                   nv.name->base, (int)nv.value->len, nv.value->base);
3665
3666
0
            rv = session_call_error_callback(
3667
0
                session, NGHTTP2_ERR_HTTP_HEADER,
3668
0
                "Invalid HTTP header field was received: frame type: "
3669
0
                "%u, stream: %d, name: [%.*s], value: [%.*s]",
3670
0
                frame->hd.type, frame->hd.stream_id, (int)nv.name->len,
3671
0
                nv.name->base, (int)nv.value->len, nv.value->base);
3672
3673
0
            if (nghttp2_is_fatal(rv)) {
3674
0
              return rv;
3675
0
            }
3676
3677
0
            rv = session_handle_invalid_stream2(session,
3678
0
                                                subject_stream->stream_id,
3679
0
                                                frame, NGHTTP2_ERR_HTTP_HEADER);
3680
0
            if (nghttp2_is_fatal(rv)) {
3681
0
              return rv;
3682
0
            }
3683
0
            return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
3684
0
          }
3685
0
        }
3686
0
        if (rv == 0) {
3687
0
          rv = session_call_on_header(session, frame, &nv);
3688
          /* This handles NGHTTP2_ERR_PAUSE and
3689
             NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE as well */
3690
0
          if (rv != 0) {
3691
0
            return rv;
3692
0
          }
3693
0
        }
3694
0
      }
3695
0
    }
3696
0
    if (inflate_flags & NGHTTP2_HD_INFLATE_FINAL) {
3697
0
      nghttp2_hd_inflate_end_headers(&session->hd_inflater);
3698
0
      break;
3699
0
    }
3700
0
    if ((inflate_flags & NGHTTP2_HD_INFLATE_EMIT) == 0 && inlen == 0) {
3701
0
      break;
3702
0
    }
3703
0
  }
3704
0
  return 0;
3705
0
}
3706
3707
/*
3708
 * Call this function when HEADERS frame was completely received.
3709
 *
3710
 * This function returns 0 if it succeeds, or one of negative error
3711
 * codes:
3712
 *
3713
 * NGHTTP2_ERR_CALLBACK_FAILURE
3714
 *     The callback function failed.
3715
 * NGHTTP2_ERR_NOMEM
3716
 *     Out of memory.
3717
 */
3718
static int session_end_stream_headers_received(nghttp2_session *session,
3719
                                               nghttp2_frame *frame,
3720
0
                                               nghttp2_stream *stream) {
3721
0
  int rv;
3722
0
  if ((frame->hd.flags & NGHTTP2_FLAG_END_STREAM) == 0) {
3723
0
    return 0;
3724
0
  }
3725
3726
0
  nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD);
3727
0
  rv = nghttp2_session_close_stream_if_shut_rdwr(session, stream);
3728
0
  if (nghttp2_is_fatal(rv)) {
3729
0
    return rv;
3730
0
  }
3731
3732
0
  return 0;
3733
0
}
3734
3735
0
static int session_after_header_block_received(nghttp2_session *session) {
3736
0
  int rv = 0;
3737
0
  nghttp2_frame *frame = &session->iframe.frame;
3738
0
  nghttp2_stream *stream;
3739
3740
  /* We don't call on_frame_recv_callback if stream has been closed
3741
     already or being closed. */
3742
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
3743
0
  if (!stream || stream->state == NGHTTP2_STREAM_CLOSING) {
3744
0
    return 0;
3745
0
  }
3746
3747
0
  if (session_enforce_http_messaging(session)) {
3748
0
    if (frame->hd.type == NGHTTP2_PUSH_PROMISE) {
3749
0
      nghttp2_stream *subject_stream;
3750
3751
0
      subject_stream = nghttp2_session_get_stream(
3752
0
          session, frame->push_promise.promised_stream_id);
3753
0
      if (subject_stream) {
3754
0
        rv = nghttp2_http_on_request_headers(subject_stream, frame);
3755
0
      }
3756
0
    } else {
3757
0
      assert(frame->hd.type == NGHTTP2_HEADERS);
3758
0
      switch (frame->headers.cat) {
3759
0
      case NGHTTP2_HCAT_REQUEST:
3760
0
        rv = nghttp2_http_on_request_headers(stream, frame);
3761
0
        break;
3762
0
      case NGHTTP2_HCAT_RESPONSE:
3763
0
      case NGHTTP2_HCAT_PUSH_RESPONSE:
3764
0
        rv = nghttp2_http_on_response_headers(stream);
3765
0
        break;
3766
0
      case NGHTTP2_HCAT_HEADERS:
3767
0
        if (stream->http_flags & NGHTTP2_HTTP_FLAG_EXPECT_FINAL_RESPONSE) {
3768
0
          assert(!session->server);
3769
0
          rv = nghttp2_http_on_response_headers(stream);
3770
0
        } else {
3771
0
          rv = nghttp2_http_on_trailer_headers(stream, frame);
3772
0
        }
3773
0
        break;
3774
0
      default:
3775
0
        assert(0);
3776
0
      }
3777
0
      if (rv == 0 && (frame->hd.flags & NGHTTP2_FLAG_END_STREAM)) {
3778
0
        rv = nghttp2_http_on_remote_end_stream(stream);
3779
0
      }
3780
0
    }
3781
0
    if (rv != 0) {
3782
0
      int32_t stream_id;
3783
3784
0
      if (frame->hd.type == NGHTTP2_PUSH_PROMISE) {
3785
0
        stream_id = frame->push_promise.promised_stream_id;
3786
0
      } else {
3787
0
        stream_id = frame->hd.stream_id;
3788
0
      }
3789
3790
0
      rv = session_handle_invalid_stream2(session, stream_id, frame,
3791
0
                                          NGHTTP2_ERR_HTTP_MESSAGING);
3792
0
      if (nghttp2_is_fatal(rv)) {
3793
0
        return rv;
3794
0
      }
3795
3796
0
      if (frame->hd.type == NGHTTP2_HEADERS &&
3797
0
          (frame->hd.flags & NGHTTP2_FLAG_END_STREAM)) {
3798
0
        nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD);
3799
        /* Don't call nghttp2_session_close_stream_if_shut_rdwr
3800
           because RST_STREAM has been submitted. */
3801
0
      }
3802
0
      return 0;
3803
0
    }
3804
0
  }
3805
3806
0
  rv = session_call_on_frame_received(session, frame);
3807
0
  if (nghttp2_is_fatal(rv)) {
3808
0
    return rv;
3809
0
  }
3810
3811
0
  if (frame->hd.type != NGHTTP2_HEADERS) {
3812
0
    return 0;
3813
0
  }
3814
3815
0
  return session_end_stream_headers_received(session, frame, stream);
3816
0
}
3817
3818
int nghttp2_session_on_request_headers_received(nghttp2_session *session,
3819
0
                                                nghttp2_frame *frame) {
3820
0
  int rv = 0;
3821
0
  nghttp2_stream *stream;
3822
0
  if (frame->hd.stream_id == 0) {
3823
0
    return session_inflate_handle_invalid_connection(
3824
0
        session, frame, NGHTTP2_ERR_PROTO, "request HEADERS: stream_id == 0");
3825
0
  }
3826
3827
  /* If client receives idle stream from server, it is invalid
3828
     regardless stream ID is even or odd.  This is because client is
3829
     not expected to receive request from server. */
3830
0
  if (!session->server) {
3831
0
    if (session_detect_idle_stream(session, frame->hd.stream_id)) {
3832
0
      return session_inflate_handle_invalid_connection(
3833
0
          session, frame, NGHTTP2_ERR_PROTO,
3834
0
          "request HEADERS: client received request");
3835
0
    }
3836
3837
0
    return NGHTTP2_ERR_IGN_HEADER_BLOCK;
3838
0
  }
3839
3840
0
  assert(session->server);
3841
3842
0
  if (!session_is_new_peer_stream_id(session, frame->hd.stream_id)) {
3843
0
    if (frame->hd.stream_id == 0 ||
3844
0
        nghttp2_session_is_my_stream_id(session, frame->hd.stream_id)) {
3845
0
      return session_inflate_handle_invalid_connection(
3846
0
          session, frame, NGHTTP2_ERR_PROTO,
3847
0
          "request HEADERS: invalid stream_id");
3848
0
    }
3849
3850
    /* RFC 7540 says if an endpoint receives a HEADERS with invalid
3851
     * stream ID (e.g, numerically smaller than previous), it MUST
3852
     * issue connection error with error code PROTOCOL_ERROR.  It is a
3853
     * bit hard to detect this, since we cannot remember all streams
3854
     * we observed so far.
3855
     *
3856
     * You might imagine this is really easy.  But no.  HTTP/2 is
3857
     * asynchronous protocol, and usually client and server do not
3858
     * share the complete picture of open/closed stream status.  For
3859
     * example, after server sends RST_STREAM for a stream, client may
3860
     * send trailer HEADERS for that stream.  If naive server detects
3861
     * that, and issued connection error, then it is a bug of server
3862
     * implementation since client is not wrong if it did not get
3863
     * RST_STREAM when it issued trailer HEADERS.
3864
     *
3865
     * At the moment, we are very conservative here.  We only use
3866
     * connection error if stream ID refers idle stream, or we are
3867
     * sure that stream is half-closed(remote) or closed.  Otherwise
3868
     * we just ignore HEADERS for now.
3869
     */
3870
0
    stream = nghttp2_session_get_stream_raw(session, frame->hd.stream_id);
3871
0
    if (stream && (stream->shut_flags & NGHTTP2_SHUT_RD)) {
3872
0
      return session_inflate_handle_invalid_connection(
3873
0
          session, frame, NGHTTP2_ERR_STREAM_CLOSED, "HEADERS: stream closed");
3874
0
    }
3875
3876
0
    return NGHTTP2_ERR_IGN_HEADER_BLOCK;
3877
0
  }
3878
0
  session->last_recv_stream_id = frame->hd.stream_id;
3879
3880
0
  if (session_is_incoming_concurrent_streams_max(session)) {
3881
0
    return session_inflate_handle_invalid_connection(
3882
0
        session, frame, NGHTTP2_ERR_PROTO,
3883
0
        "request HEADERS: max concurrent streams exceeded");
3884
0
  }
3885
3886
0
  if (!session_allow_incoming_new_stream(session)) {
3887
    /* We just ignore stream after GOAWAY was sent */
3888
0
    return NGHTTP2_ERR_IGN_HEADER_BLOCK;
3889
0
  }
3890
3891
0
  if (frame->headers.pri_spec.stream_id == frame->hd.stream_id) {
3892
0
    return session_inflate_handle_invalid_connection(
3893
0
        session, frame, NGHTTP2_ERR_PROTO, "request HEADERS: depend on itself");
3894
0
  }
3895
3896
0
  if (session_is_incoming_concurrent_streams_pending_max(session)) {
3897
0
    return session_inflate_handle_invalid_stream(session, frame,
3898
0
                                                 NGHTTP2_ERR_REFUSED_STREAM);
3899
0
  }
3900
3901
0
  stream = nghttp2_session_open_stream(
3902
0
      session, frame->hd.stream_id, NGHTTP2_STREAM_FLAG_NONE,
3903
0
      &frame->headers.pri_spec, NGHTTP2_STREAM_OPENING, NULL);
3904
0
  if (!stream) {
3905
0
    return NGHTTP2_ERR_NOMEM;
3906
0
  }
3907
3908
0
  rv = nghttp2_session_adjust_closed_stream(session);
3909
0
  if (nghttp2_is_fatal(rv)) {
3910
0
    return rv;
3911
0
  }
3912
3913
0
  session->last_proc_stream_id = session->last_recv_stream_id;
3914
3915
0
  rv = session_call_on_begin_headers(session, frame);
3916
0
  if (rv != 0) {
3917
0
    return rv;
3918
0
  }
3919
0
  return 0;
3920
0
}
3921
3922
int nghttp2_session_on_response_headers_received(nghttp2_session *session,
3923
                                                 nghttp2_frame *frame,
3924
0
                                                 nghttp2_stream *stream) {
3925
0
  int rv;
3926
  /* This function is only called if stream->state ==
3927
     NGHTTP2_STREAM_OPENING and stream_id is local side initiated. */
3928
0
  assert(stream->state == NGHTTP2_STREAM_OPENING &&
3929
0
         nghttp2_session_is_my_stream_id(session, frame->hd.stream_id));
3930
0
  if (frame->hd.stream_id == 0) {
3931
0
    return session_inflate_handle_invalid_connection(
3932
0
        session, frame, NGHTTP2_ERR_PROTO, "response HEADERS: stream_id == 0");
3933
0
  }
3934
0
  if (stream->shut_flags & NGHTTP2_SHUT_RD) {
3935
    /* half closed (remote): from the spec:
3936
3937
       If an endpoint receives additional frames for a stream that is
3938
       in this state it MUST respond with a stream error (Section
3939
       5.4.2) of type STREAM_CLOSED.
3940
3941
       We go further, and make it connection error.
3942
    */
3943
0
    return session_inflate_handle_invalid_connection(
3944
0
        session, frame, NGHTTP2_ERR_STREAM_CLOSED, "HEADERS: stream closed");
3945
0
  }
3946
0
  stream->state = NGHTTP2_STREAM_OPENED;
3947
0
  rv = session_call_on_begin_headers(session, frame);
3948
0
  if (rv != 0) {
3949
0
    return rv;
3950
0
  }
3951
0
  return 0;
3952
0
}
3953
3954
int nghttp2_session_on_push_response_headers_received(nghttp2_session *session,
3955
                                                      nghttp2_frame *frame,
3956
0
                                                      nghttp2_stream *stream) {
3957
0
  int rv = 0;
3958
0
  assert(stream->state == NGHTTP2_STREAM_RESERVED);
3959
0
  if (frame->hd.stream_id == 0) {
3960
0
    return session_inflate_handle_invalid_connection(
3961
0
        session, frame, NGHTTP2_ERR_PROTO,
3962
0
        "push response HEADERS: stream_id == 0");
3963
0
  }
3964
3965
0
  if (session->server) {
3966
0
    return session_inflate_handle_invalid_connection(
3967
0
        session, frame, NGHTTP2_ERR_PROTO,
3968
0
        "HEADERS: no HEADERS allowed from client in reserved state");
3969
0
  }
3970
3971
0
  if (session_is_incoming_concurrent_streams_max(session)) {
3972
0
    return session_inflate_handle_invalid_connection(
3973
0
        session, frame, NGHTTP2_ERR_PROTO,
3974
0
        "push response HEADERS: max concurrent streams exceeded");
3975
0
  }
3976
3977
0
  if (!session_allow_incoming_new_stream(session)) {
3978
    /* We don't accept new stream after GOAWAY was sent. */
3979
0
    return NGHTTP2_ERR_IGN_HEADER_BLOCK;
3980
0
  }
3981
3982
0
  if (session_is_incoming_concurrent_streams_pending_max(session)) {
3983
0
    return session_inflate_handle_invalid_stream(session, frame,
3984
0
                                                 NGHTTP2_ERR_REFUSED_STREAM);
3985
0
  }
3986
3987
0
  nghttp2_stream_promise_fulfilled(stream);
3988
0
  if (!nghttp2_session_is_my_stream_id(session, stream->stream_id)) {
3989
0
    --session->num_incoming_reserved_streams;
3990
0
  }
3991
0
  ++session->num_incoming_streams;
3992
0
  rv = session_call_on_begin_headers(session, frame);
3993
0
  if (rv != 0) {
3994
0
    return rv;
3995
0
  }
3996
0
  return 0;
3997
0
}
3998
3999
int nghttp2_session_on_headers_received(nghttp2_session *session,
4000
                                        nghttp2_frame *frame,
4001
0
                                        nghttp2_stream *stream) {
4002
0
  int rv = 0;
4003
0
  if (frame->hd.stream_id == 0) {
4004
0
    return session_inflate_handle_invalid_connection(
4005
0
        session, frame, NGHTTP2_ERR_PROTO, "HEADERS: stream_id == 0");
4006
0
  }
4007
0
  if ((stream->shut_flags & NGHTTP2_SHUT_RD)) {
4008
    /* half closed (remote): from the spec:
4009
4010
       If an endpoint receives additional frames for a stream that is
4011
       in this state it MUST respond with a stream error (Section
4012
       5.4.2) of type STREAM_CLOSED.
4013
4014
       we go further, and make it connection error.
4015
    */
4016
0
    return session_inflate_handle_invalid_connection(
4017
0
        session, frame, NGHTTP2_ERR_STREAM_CLOSED, "HEADERS: stream closed");
4018
0
  }
4019
0
  if (nghttp2_session_is_my_stream_id(session, frame->hd.stream_id)) {
4020
0
    if (stream->state == NGHTTP2_STREAM_OPENED) {
4021
0
      rv = session_call_on_begin_headers(session, frame);
4022
0
      if (rv != 0) {
4023
0
        return rv;
4024
0
      }
4025
0
      return 0;
4026
0
    }
4027
4028
0
    return NGHTTP2_ERR_IGN_HEADER_BLOCK;
4029
0
  }
4030
  /* If this is remote peer initiated stream, it is OK unless it
4031
     has sent END_STREAM frame already. But if stream is in
4032
     NGHTTP2_STREAM_CLOSING, we discard the frame. This is a race
4033
     condition. */
4034
0
  if (stream->state != NGHTTP2_STREAM_CLOSING) {
4035
0
    rv = session_call_on_begin_headers(session, frame);
4036
0
    if (rv != 0) {
4037
0
      return rv;
4038
0
    }
4039
0
    return 0;
4040
0
  }
4041
0
  return NGHTTP2_ERR_IGN_HEADER_BLOCK;
4042
0
}
4043
4044
0
static int session_process_headers_frame(nghttp2_session *session) {
4045
0
  int rv;
4046
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4047
0
  nghttp2_frame *frame = &iframe->frame;
4048
0
  nghttp2_stream *stream;
4049
4050
0
  rv = nghttp2_frame_unpack_headers_payload(&frame->headers, iframe->sbuf.pos);
4051
4052
0
  if (rv != 0) {
4053
0
    return nghttp2_session_terminate_session_with_reason(
4054
0
        session, NGHTTP2_PROTOCOL_ERROR, "HEADERS: could not unpack");
4055
0
  }
4056
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
4057
0
  if (!stream) {
4058
0
    frame->headers.cat = NGHTTP2_HCAT_REQUEST;
4059
0
    return nghttp2_session_on_request_headers_received(session, frame);
4060
0
  }
4061
4062
0
  if (stream->state == NGHTTP2_STREAM_RESERVED) {
4063
0
    frame->headers.cat = NGHTTP2_HCAT_PUSH_RESPONSE;
4064
0
    return nghttp2_session_on_push_response_headers_received(session, frame,
4065
0
                                                             stream);
4066
0
  }
4067
4068
0
  if (stream->state == NGHTTP2_STREAM_OPENING &&
4069
0
      nghttp2_session_is_my_stream_id(session, frame->hd.stream_id)) {
4070
0
    frame->headers.cat = NGHTTP2_HCAT_RESPONSE;
4071
0
    return nghttp2_session_on_response_headers_received(session, frame, stream);
4072
0
  }
4073
4074
0
  frame->headers.cat = NGHTTP2_HCAT_HEADERS;
4075
0
  return nghttp2_session_on_headers_received(session, frame, stream);
4076
0
}
4077
4078
int nghttp2_session_on_priority_received(nghttp2_session *session,
4079
0
                                         nghttp2_frame *frame) {
4080
0
  int rv;
4081
0
  nghttp2_stream *stream;
4082
4083
0
  if (frame->hd.stream_id == 0) {
4084
0
    return session_handle_invalid_connection(session, frame, NGHTTP2_ERR_PROTO,
4085
0
                                             "PRIORITY: stream_id == 0");
4086
0
  }
4087
4088
0
  if (frame->priority.pri_spec.stream_id == frame->hd.stream_id) {
4089
0
    return nghttp2_session_terminate_session_with_reason(
4090
0
        session, NGHTTP2_PROTOCOL_ERROR, "depend on itself");
4091
0
  }
4092
4093
0
  if (!session->server) {
4094
    /* Re-prioritization works only in server */
4095
0
    return session_call_on_frame_received(session, frame);
4096
0
  }
4097
4098
0
  stream = nghttp2_session_get_stream_raw(session, frame->hd.stream_id);
4099
4100
0
  if (!stream) {
4101
    /* PRIORITY against idle stream can create anchor node in
4102
       dependency tree. */
4103
0
    if (!session_detect_idle_stream(session, frame->hd.stream_id)) {
4104
0
      return 0;
4105
0
    }
4106
4107
0
    stream = nghttp2_session_open_stream(
4108
0
        session, frame->hd.stream_id, NGHTTP2_STREAM_FLAG_NONE,
4109
0
        &frame->priority.pri_spec, NGHTTP2_STREAM_IDLE, NULL);
4110
4111
0
    if (stream == NULL) {
4112
0
      return NGHTTP2_ERR_NOMEM;
4113
0
    }
4114
4115
0
    rv = nghttp2_session_adjust_idle_stream(session);
4116
0
    if (nghttp2_is_fatal(rv)) {
4117
0
      return rv;
4118
0
    }
4119
0
  } else {
4120
0
    rv = nghttp2_session_reprioritize_stream(session, stream,
4121
0
                                             &frame->priority.pri_spec);
4122
4123
0
    if (nghttp2_is_fatal(rv)) {
4124
0
      return rv;
4125
0
    }
4126
4127
0
    rv = nghttp2_session_adjust_idle_stream(session);
4128
0
    if (nghttp2_is_fatal(rv)) {
4129
0
      return rv;
4130
0
    }
4131
0
  }
4132
4133
0
  return session_call_on_frame_received(session, frame);
4134
0
}
4135
4136
0
static int session_process_priority_frame(nghttp2_session *session) {
4137
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4138
0
  nghttp2_frame *frame = &iframe->frame;
4139
4140
0
  nghttp2_frame_unpack_priority_payload(&frame->priority, iframe->sbuf.pos);
4141
4142
0
  return nghttp2_session_on_priority_received(session, frame);
4143
0
}
4144
4145
int nghttp2_session_on_rst_stream_received(nghttp2_session *session,
4146
0
                                           nghttp2_frame *frame) {
4147
0
  int rv;
4148
0
  nghttp2_stream *stream;
4149
0
  if (frame->hd.stream_id == 0) {
4150
0
    return session_handle_invalid_connection(session, frame, NGHTTP2_ERR_PROTO,
4151
0
                                             "RST_STREAM: stream_id == 0");
4152
0
  }
4153
4154
0
  if (session_detect_idle_stream(session, frame->hd.stream_id)) {
4155
0
    return session_handle_invalid_connection(session, frame, NGHTTP2_ERR_PROTO,
4156
0
                                             "RST_STREAM: stream in idle");
4157
0
  }
4158
4159
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
4160
0
  if (stream) {
4161
    /* We may use stream->shut_flags for strict error checking. */
4162
0
    nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD);
4163
0
  }
4164
4165
0
  rv = session_call_on_frame_received(session, frame);
4166
0
  if (rv != 0) {
4167
0
    return rv;
4168
0
  }
4169
0
  rv = nghttp2_session_close_stream(session, frame->hd.stream_id,
4170
0
                                    frame->rst_stream.error_code);
4171
0
  if (nghttp2_is_fatal(rv)) {
4172
0
    return rv;
4173
0
  }
4174
0
  return 0;
4175
0
}
4176
4177
0
static int session_process_rst_stream_frame(nghttp2_session *session) {
4178
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4179
0
  nghttp2_frame *frame = &iframe->frame;
4180
4181
0
  nghttp2_frame_unpack_rst_stream_payload(&frame->rst_stream, iframe->sbuf.pos);
4182
4183
0
  return nghttp2_session_on_rst_stream_received(session, frame);
4184
0
}
4185
4186
static int update_remote_initial_window_size_func(nghttp2_map_entry *entry,
4187
0
                                                  void *ptr) {
4188
0
  int rv;
4189
0
  nghttp2_update_window_size_arg *arg;
4190
0
  nghttp2_stream *stream;
4191
4192
0
  arg = (nghttp2_update_window_size_arg *)ptr;
4193
0
  stream = (nghttp2_stream *)entry;
4194
4195
0
  rv = nghttp2_stream_update_remote_initial_window_size(
4196
0
      stream, arg->new_window_size, arg->old_window_size);
4197
0
  if (rv != 0) {
4198
0
    return nghttp2_session_add_rst_stream(arg->session, stream->stream_id,
4199
0
                                          NGHTTP2_FLOW_CONTROL_ERROR);
4200
0
  }
4201
4202
  /* If window size gets positive, push deferred DATA frame to
4203
     outbound queue. */
4204
0
  if (stream->remote_window_size > 0 &&
4205
0
      nghttp2_stream_check_deferred_by_flow_control(stream)) {
4206
4207
0
    rv = nghttp2_stream_resume_deferred_item(
4208
0
        stream, NGHTTP2_STREAM_FLAG_DEFERRED_FLOW_CONTROL);
4209
4210
0
    if (nghttp2_is_fatal(rv)) {
4211
0
      return rv;
4212
0
    }
4213
0
  }
4214
0
  return 0;
4215
0
}
4216
4217
/*
4218
 * Updates the remote initial window size of all active streams.  If
4219
 * error occurs, all streams may not be updated.
4220
 *
4221
 * This function returns 0 if it succeeds, or one of the following
4222
 * negative error codes:
4223
 *
4224
 * NGHTTP2_ERR_NOMEM
4225
 *     Out of memory.
4226
 */
4227
static int
4228
session_update_remote_initial_window_size(nghttp2_session *session,
4229
0
                                          int32_t new_initial_window_size) {
4230
0
  nghttp2_update_window_size_arg arg;
4231
4232
0
  arg.session = session;
4233
0
  arg.new_window_size = new_initial_window_size;
4234
0
  arg.old_window_size = (int32_t)session->remote_settings.initial_window_size;
4235
4236
0
  return nghttp2_map_each(&session->streams,
4237
0
                          update_remote_initial_window_size_func, &arg);
4238
0
}
4239
4240
static int update_local_initial_window_size_func(nghttp2_map_entry *entry,
4241
0
                                                 void *ptr) {
4242
0
  int rv;
4243
0
  nghttp2_update_window_size_arg *arg;
4244
0
  nghttp2_stream *stream;
4245
0
  arg = (nghttp2_update_window_size_arg *)ptr;
4246
0
  stream = (nghttp2_stream *)entry;
4247
0
  rv = nghttp2_stream_update_local_initial_window_size(
4248
0
      stream, arg->new_window_size, arg->old_window_size);
4249
0
  if (rv != 0) {
4250
0
    return nghttp2_session_add_rst_stream(arg->session, stream->stream_id,
4251
0
                                          NGHTTP2_FLOW_CONTROL_ERROR);
4252
0
  }
4253
0
  if (!(arg->session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE) &&
4254
0
      stream->window_update_queued == 0 &&
4255
0
      nghttp2_should_send_window_update(stream->local_window_size,
4256
0
                                        stream->recv_window_size)) {
4257
4258
0
    rv = nghttp2_session_add_window_update(arg->session, NGHTTP2_FLAG_NONE,
4259
0
                                           stream->stream_id,
4260
0
                                           stream->recv_window_size);
4261
0
    if (rv != 0) {
4262
0
      return rv;
4263
0
    }
4264
4265
0
    stream->recv_window_size = 0;
4266
0
  }
4267
0
  return 0;
4268
0
}
4269
4270
/*
4271
 * Updates the local initial window size of all active streams.  If
4272
 * error occurs, all streams may not be updated.
4273
 *
4274
 * This function returns 0 if it succeeds, or one of the following
4275
 * negative error codes:
4276
 *
4277
 * NGHTTP2_ERR_NOMEM
4278
 *     Out of memory.
4279
 */
4280
static int
4281
session_update_local_initial_window_size(nghttp2_session *session,
4282
                                         int32_t new_initial_window_size,
4283
0
                                         int32_t old_initial_window_size) {
4284
0
  nghttp2_update_window_size_arg arg;
4285
0
  arg.session = session;
4286
0
  arg.new_window_size = new_initial_window_size;
4287
0
  arg.old_window_size = old_initial_window_size;
4288
0
  return nghttp2_map_each(&session->streams,
4289
0
                          update_local_initial_window_size_func, &arg);
4290
0
}
4291
4292
/*
4293
 * Apply SETTINGS values |iv| having |niv| elements to the local
4294
 * settings.  We assumes that all values in |iv| is correct, since we
4295
 * validated them in nghttp2_session_add_settings() already.
4296
 *
4297
 * This function returns 0 if it succeeds, or one of the following
4298
 * negative error codes:
4299
 *
4300
 * NGHTTP2_ERR_HEADER_COMP
4301
 *     The header table size is out of range
4302
 * NGHTTP2_ERR_NOMEM
4303
 *     Out of memory
4304
 */
4305
int nghttp2_session_update_local_settings(nghttp2_session *session,
4306
                                          nghttp2_settings_entry *iv,
4307
0
                                          size_t niv) {
4308
0
  int rv;
4309
0
  size_t i;
4310
0
  int32_t new_initial_window_size = -1;
4311
0
  uint32_t header_table_size = 0;
4312
0
  uint32_t min_header_table_size = UINT32_MAX;
4313
0
  uint8_t header_table_size_seen = 0;
4314
  /* For NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE, use the value last
4315
     seen.  For NGHTTP2_SETTINGS_HEADER_TABLE_SIZE, use both minimum
4316
     value and last seen value. */
4317
0
  for (i = 0; i < niv; ++i) {
4318
0
    switch (iv[i].settings_id) {
4319
0
    case NGHTTP2_SETTINGS_HEADER_TABLE_SIZE:
4320
0
      header_table_size_seen = 1;
4321
0
      header_table_size = iv[i].value;
4322
0
      min_header_table_size = nghttp2_min(min_header_table_size, iv[i].value);
4323
0
      break;
4324
0
    case NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE:
4325
0
      new_initial_window_size = (int32_t)iv[i].value;
4326
0
      break;
4327
0
    }
4328
0
  }
4329
0
  if (header_table_size_seen) {
4330
0
    if (min_header_table_size < header_table_size) {
4331
0
      rv = nghttp2_hd_inflate_change_table_size(&session->hd_inflater,
4332
0
                                                min_header_table_size);
4333
0
      if (rv != 0) {
4334
0
        return rv;
4335
0
      }
4336
0
    }
4337
4338
0
    rv = nghttp2_hd_inflate_change_table_size(&session->hd_inflater,
4339
0
                                              header_table_size);
4340
0
    if (rv != 0) {
4341
0
      return rv;
4342
0
    }
4343
0
  }
4344
0
  if (new_initial_window_size != -1) {
4345
0
    rv = session_update_local_initial_window_size(
4346
0
        session, new_initial_window_size,
4347
0
        (int32_t)session->local_settings.initial_window_size);
4348
0
    if (rv != 0) {
4349
0
      return rv;
4350
0
    }
4351
0
  }
4352
4353
0
  for (i = 0; i < niv; ++i) {
4354
0
    switch (iv[i].settings_id) {
4355
0
    case NGHTTP2_SETTINGS_HEADER_TABLE_SIZE:
4356
0
      session->local_settings.header_table_size = iv[i].value;
4357
0
      break;
4358
0
    case NGHTTP2_SETTINGS_ENABLE_PUSH:
4359
0
      session->local_settings.enable_push = iv[i].value;
4360
0
      break;
4361
0
    case NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS:
4362
0
      session->local_settings.max_concurrent_streams = iv[i].value;
4363
0
      break;
4364
0
    case NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE:
4365
0
      session->local_settings.initial_window_size = iv[i].value;
4366
0
      break;
4367
0
    case NGHTTP2_SETTINGS_MAX_FRAME_SIZE:
4368
0
      session->local_settings.max_frame_size = iv[i].value;
4369
0
      break;
4370
0
    case NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE:
4371
0
      session->local_settings.max_header_list_size = iv[i].value;
4372
0
      break;
4373
0
    case NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL:
4374
0
      session->local_settings.enable_connect_protocol = iv[i].value;
4375
0
      break;
4376
0
    }
4377
0
  }
4378
4379
0
  return 0;
4380
0
}
4381
4382
int nghttp2_session_on_settings_received(nghttp2_session *session,
4383
0
                                         nghttp2_frame *frame, int noack) {
4384
0
  int rv;
4385
0
  size_t i;
4386
0
  nghttp2_mem *mem;
4387
0
  nghttp2_inflight_settings *settings;
4388
4389
0
  mem = &session->mem;
4390
4391
0
  if (frame->hd.stream_id != 0) {
4392
0
    return session_handle_invalid_connection(session, frame, NGHTTP2_ERR_PROTO,
4393
0
                                             "SETTINGS: stream_id != 0");
4394
0
  }
4395
0
  if (frame->hd.flags & NGHTTP2_FLAG_ACK) {
4396
0
    if (frame->settings.niv != 0) {
4397
0
      return session_handle_invalid_connection(
4398
0
          session, frame, NGHTTP2_ERR_FRAME_SIZE_ERROR,
4399
0
          "SETTINGS: ACK and payload != 0");
4400
0
    }
4401
4402
0
    settings = session->inflight_settings_head;
4403
4404
0
    if (!settings) {
4405
0
      return session_handle_invalid_connection(
4406
0
          session, frame, NGHTTP2_ERR_PROTO, "SETTINGS: unexpected ACK");
4407
0
    }
4408
4409
0
    rv = nghttp2_session_update_local_settings(session, settings->iv,
4410
0
                                               settings->niv);
4411
4412
0
    session->inflight_settings_head = settings->next;
4413
4414
0
    inflight_settings_del(settings, mem);
4415
4416
0
    if (rv != 0) {
4417
0
      if (nghttp2_is_fatal(rv)) {
4418
0
        return rv;
4419
0
      }
4420
0
      return session_handle_invalid_connection(session, frame, rv, NULL);
4421
0
    }
4422
0
    return session_call_on_frame_received(session, frame);
4423
0
  }
4424
4425
0
  if (!session->remote_settings_received) {
4426
0
    session->remote_settings.max_concurrent_streams =
4427
0
        NGHTTP2_DEFAULT_MAX_CONCURRENT_STREAMS;
4428
0
    session->remote_settings_received = 1;
4429
0
  }
4430
4431
0
  for (i = 0; i < frame->settings.niv; ++i) {
4432
0
    nghttp2_settings_entry *entry = &frame->settings.iv[i];
4433
4434
0
    switch (entry->settings_id) {
4435
0
    case NGHTTP2_SETTINGS_HEADER_TABLE_SIZE:
4436
4437
0
      rv = nghttp2_hd_deflate_change_table_size(&session->hd_deflater,
4438
0
                                                entry->value);
4439
0
      if (rv != 0) {
4440
0
        if (nghttp2_is_fatal(rv)) {
4441
0
          return rv;
4442
0
        } else {
4443
0
          return session_handle_invalid_connection(
4444
0
              session, frame, NGHTTP2_ERR_HEADER_COMP, NULL);
4445
0
        }
4446
0
      }
4447
4448
0
      session->remote_settings.header_table_size = entry->value;
4449
4450
0
      break;
4451
0
    case NGHTTP2_SETTINGS_ENABLE_PUSH:
4452
4453
0
      if (entry->value != 0 && entry->value != 1) {
4454
0
        return session_handle_invalid_connection(
4455
0
            session, frame, NGHTTP2_ERR_PROTO,
4456
0
            "SETTINGS: invalid SETTINGS_ENBLE_PUSH");
4457
0
      }
4458
4459
0
      if (!session->server && entry->value != 0) {
4460
0
        return session_handle_invalid_connection(
4461
0
            session, frame, NGHTTP2_ERR_PROTO,
4462
0
            "SETTINGS: server attempted to enable push");
4463
0
      }
4464
4465
0
      session->remote_settings.enable_push = entry->value;
4466
4467
0
      break;
4468
0
    case NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS:
4469
4470
0
      session->remote_settings.max_concurrent_streams = entry->value;
4471
4472
0
      break;
4473
0
    case NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE:
4474
4475
      /* Update the initial window size of the all active streams */
4476
      /* Check that initial_window_size < (1u << 31) */
4477
0
      if (entry->value > NGHTTP2_MAX_WINDOW_SIZE) {
4478
0
        return session_handle_invalid_connection(
4479
0
            session, frame, NGHTTP2_ERR_FLOW_CONTROL,
4480
0
            "SETTINGS: too large SETTINGS_INITIAL_WINDOW_SIZE");
4481
0
      }
4482
4483
0
      rv = session_update_remote_initial_window_size(session,
4484
0
                                                     (int32_t)entry->value);
4485
4486
0
      if (nghttp2_is_fatal(rv)) {
4487
0
        return rv;
4488
0
      }
4489
4490
0
      if (rv != 0) {
4491
0
        return session_handle_invalid_connection(
4492
0
            session, frame, NGHTTP2_ERR_FLOW_CONTROL, NULL);
4493
0
      }
4494
4495
0
      session->remote_settings.initial_window_size = entry->value;
4496
4497
0
      break;
4498
0
    case NGHTTP2_SETTINGS_MAX_FRAME_SIZE:
4499
4500
0
      if (entry->value < NGHTTP2_MAX_FRAME_SIZE_MIN ||
4501
0
          entry->value > NGHTTP2_MAX_FRAME_SIZE_MAX) {
4502
0
        return session_handle_invalid_connection(
4503
0
            session, frame, NGHTTP2_ERR_PROTO,
4504
0
            "SETTINGS: invalid SETTINGS_MAX_FRAME_SIZE");
4505
0
      }
4506
4507
0
      session->remote_settings.max_frame_size = entry->value;
4508
4509
0
      break;
4510
0
    case NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE:
4511
4512
0
      session->remote_settings.max_header_list_size = entry->value;
4513
4514
0
      break;
4515
0
    case NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL:
4516
4517
0
      if (entry->value != 0 && entry->value != 1) {
4518
0
        return session_handle_invalid_connection(
4519
0
            session, frame, NGHTTP2_ERR_PROTO,
4520
0
            "SETTINGS: invalid SETTINGS_ENABLE_CONNECT_PROTOCOL");
4521
0
      }
4522
4523
0
      if (!session->server &&
4524
0
          session->remote_settings.enable_connect_protocol &&
4525
0
          entry->value == 0) {
4526
0
        return session_handle_invalid_connection(
4527
0
            session, frame, NGHTTP2_ERR_PROTO,
4528
0
            "SETTINGS: server attempted to disable "
4529
0
            "SETTINGS_ENABLE_CONNECT_PROTOCOL");
4530
0
      }
4531
4532
0
      session->remote_settings.enable_connect_protocol = entry->value;
4533
4534
0
      break;
4535
0
    }
4536
0
  }
4537
4538
0
  if (!noack && !session_is_closing(session)) {
4539
0
    rv = nghttp2_session_add_settings(session, NGHTTP2_FLAG_ACK, NULL, 0);
4540
4541
0
    if (rv != 0) {
4542
0
      if (nghttp2_is_fatal(rv)) {
4543
0
        return rv;
4544
0
      }
4545
4546
0
      return session_handle_invalid_connection(session, frame,
4547
0
                                               NGHTTP2_ERR_INTERNAL, NULL);
4548
0
    }
4549
0
  }
4550
4551
0
  return session_call_on_frame_received(session, frame);
4552
0
}
4553
4554
0
static int session_process_settings_frame(nghttp2_session *session) {
4555
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4556
0
  nghttp2_frame *frame = &iframe->frame;
4557
0
  size_t i;
4558
0
  nghttp2_settings_entry min_header_size_entry;
4559
4560
0
  if (iframe->max_niv) {
4561
0
    min_header_size_entry = iframe->iv[iframe->max_niv - 1];
4562
4563
0
    if (min_header_size_entry.value < UINT32_MAX) {
4564
      /* If we have less value, then we must have
4565
         SETTINGS_HEADER_TABLE_SIZE in i < iframe->niv */
4566
0
      for (i = 0; i < iframe->niv; ++i) {
4567
0
        if (iframe->iv[i].settings_id == NGHTTP2_SETTINGS_HEADER_TABLE_SIZE) {
4568
0
          break;
4569
0
        }
4570
0
      }
4571
4572
0
      assert(i < iframe->niv);
4573
4574
0
      if (min_header_size_entry.value != iframe->iv[i].value) {
4575
0
        iframe->iv[iframe->niv++] = iframe->iv[i];
4576
0
        iframe->iv[i] = min_header_size_entry;
4577
0
      }
4578
0
    }
4579
0
  }
4580
4581
0
  nghttp2_frame_unpack_settings_payload(&frame->settings, iframe->iv,
4582
0
                                        iframe->niv);
4583
4584
0
  iframe->iv = NULL;
4585
0
  iframe->niv = 0;
4586
0
  iframe->max_niv = 0;
4587
4588
0
  return nghttp2_session_on_settings_received(session, frame, 0 /* ACK */);
4589
0
}
4590
4591
int nghttp2_session_on_push_promise_received(nghttp2_session *session,
4592
0
                                             nghttp2_frame *frame) {
4593
0
  int rv;
4594
0
  nghttp2_stream *stream;
4595
0
  nghttp2_stream *promised_stream;
4596
0
  nghttp2_priority_spec pri_spec;
4597
4598
0
  if (frame->hd.stream_id == 0) {
4599
0
    return session_inflate_handle_invalid_connection(
4600
0
        session, frame, NGHTTP2_ERR_PROTO, "PUSH_PROMISE: stream_id == 0");
4601
0
  }
4602
0
  if (session->server || session->local_settings.enable_push == 0) {
4603
0
    return session_inflate_handle_invalid_connection(
4604
0
        session, frame, NGHTTP2_ERR_PROTO, "PUSH_PROMISE: push disabled");
4605
0
  }
4606
4607
0
  if (!nghttp2_session_is_my_stream_id(session, frame->hd.stream_id)) {
4608
0
    return session_inflate_handle_invalid_connection(
4609
0
        session, frame, NGHTTP2_ERR_PROTO, "PUSH_PROMISE: invalid stream_id");
4610
0
  }
4611
4612
0
  if (!session_allow_incoming_new_stream(session)) {
4613
    /* We just discard PUSH_PROMISE after GOAWAY was sent */
4614
0
    return NGHTTP2_ERR_IGN_HEADER_BLOCK;
4615
0
  }
4616
4617
0
  if (!session_is_new_peer_stream_id(session,
4618
0
                                     frame->push_promise.promised_stream_id)) {
4619
    /* The spec says if an endpoint receives a PUSH_PROMISE with
4620
       illegal stream ID is subject to a connection error of type
4621
       PROTOCOL_ERROR. */
4622
0
    return session_inflate_handle_invalid_connection(
4623
0
        session, frame, NGHTTP2_ERR_PROTO,
4624
0
        "PUSH_PROMISE: invalid promised_stream_id");
4625
0
  }
4626
4627
0
  if (session_detect_idle_stream(session, frame->hd.stream_id)) {
4628
0
    return session_inflate_handle_invalid_connection(
4629
0
        session, frame, NGHTTP2_ERR_PROTO, "PUSH_PROMISE: stream in idle");
4630
0
  }
4631
4632
0
  session->last_recv_stream_id = frame->push_promise.promised_stream_id;
4633
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
4634
0
  if (!stream || stream->state == NGHTTP2_STREAM_CLOSING ||
4635
0
      !session->pending_enable_push ||
4636
0
      session->num_incoming_reserved_streams >=
4637
0
          session->max_incoming_reserved_streams) {
4638
    /* Currently, client does not retain closed stream, so we don't
4639
       check NGHTTP2_SHUT_RD condition here. */
4640
4641
0
    rv = nghttp2_session_add_rst_stream(
4642
0
        session, frame->push_promise.promised_stream_id, NGHTTP2_CANCEL);
4643
0
    if (rv != 0) {
4644
0
      return rv;
4645
0
    }
4646
0
    return NGHTTP2_ERR_IGN_HEADER_BLOCK;
4647
0
  }
4648
4649
0
  if (stream->shut_flags & NGHTTP2_SHUT_RD) {
4650
0
    return session_inflate_handle_invalid_connection(
4651
0
        session, frame, NGHTTP2_ERR_STREAM_CLOSED,
4652
0
        "PUSH_PROMISE: stream closed");
4653
0
  }
4654
4655
0
  nghttp2_priority_spec_init(&pri_spec, stream->stream_id,
4656
0
                             NGHTTP2_DEFAULT_WEIGHT, 0);
4657
4658
0
  promised_stream = nghttp2_session_open_stream(
4659
0
      session, frame->push_promise.promised_stream_id, NGHTTP2_STREAM_FLAG_NONE,
4660
0
      &pri_spec, NGHTTP2_STREAM_RESERVED, NULL);
4661
4662
0
  if (!promised_stream) {
4663
0
    return NGHTTP2_ERR_NOMEM;
4664
0
  }
4665
4666
  /* We don't call nghttp2_session_adjust_closed_stream(), since we
4667
     don't keep closed stream in client side */
4668
4669
0
  session->last_proc_stream_id = session->last_recv_stream_id;
4670
0
  rv = session_call_on_begin_headers(session, frame);
4671
0
  if (rv != 0) {
4672
0
    return rv;
4673
0
  }
4674
0
  return 0;
4675
0
}
4676
4677
0
static int session_process_push_promise_frame(nghttp2_session *session) {
4678
0
  int rv;
4679
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4680
0
  nghttp2_frame *frame = &iframe->frame;
4681
4682
0
  rv = nghttp2_frame_unpack_push_promise_payload(&frame->push_promise,
4683
0
                                                 iframe->sbuf.pos);
4684
4685
0
  if (rv != 0) {
4686
0
    return nghttp2_session_terminate_session_with_reason(
4687
0
        session, NGHTTP2_PROTOCOL_ERROR, "PUSH_PROMISE: could not unpack");
4688
0
  }
4689
4690
0
  return nghttp2_session_on_push_promise_received(session, frame);
4691
0
}
4692
4693
int nghttp2_session_on_ping_received(nghttp2_session *session,
4694
0
                                     nghttp2_frame *frame) {
4695
0
  int rv = 0;
4696
0
  if (frame->hd.stream_id != 0) {
4697
0
    return session_handle_invalid_connection(session, frame, NGHTTP2_ERR_PROTO,
4698
0
                                             "PING: stream_id != 0");
4699
0
  }
4700
0
  if ((session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_PING_ACK) == 0 &&
4701
0
      (frame->hd.flags & NGHTTP2_FLAG_ACK) == 0 &&
4702
0
      !session_is_closing(session)) {
4703
    /* Peer sent ping, so ping it back */
4704
0
    rv = nghttp2_session_add_ping(session, NGHTTP2_FLAG_ACK,
4705
0
                                  frame->ping.opaque_data);
4706
0
    if (rv != 0) {
4707
0
      return rv;
4708
0
    }
4709
0
  }
4710
0
  return session_call_on_frame_received(session, frame);
4711
0
}
4712
4713
0
static int session_process_ping_frame(nghttp2_session *session) {
4714
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4715
0
  nghttp2_frame *frame = &iframe->frame;
4716
4717
0
  nghttp2_frame_unpack_ping_payload(&frame->ping, iframe->sbuf.pos);
4718
4719
0
  return nghttp2_session_on_ping_received(session, frame);
4720
0
}
4721
4722
int nghttp2_session_on_goaway_received(nghttp2_session *session,
4723
0
                                       nghttp2_frame *frame) {
4724
0
  int rv;
4725
4726
0
  if (frame->hd.stream_id != 0) {
4727
0
    return session_handle_invalid_connection(session, frame, NGHTTP2_ERR_PROTO,
4728
0
                                             "GOAWAY: stream_id != 0");
4729
0
  }
4730
  /* Spec says Endpoints MUST NOT increase the value they send in the
4731
     last stream identifier. */
4732
0
  if ((frame->goaway.last_stream_id > 0 &&
4733
0
       !nghttp2_session_is_my_stream_id(session,
4734
0
                                        frame->goaway.last_stream_id)) ||
4735
0
      session->remote_last_stream_id < frame->goaway.last_stream_id) {
4736
0
    return session_handle_invalid_connection(session, frame, NGHTTP2_ERR_PROTO,
4737
0
                                             "GOAWAY: invalid last_stream_id");
4738
0
  }
4739
4740
0
  session->goaway_flags |= NGHTTP2_GOAWAY_RECV;
4741
4742
0
  session->remote_last_stream_id = frame->goaway.last_stream_id;
4743
4744
0
  rv = session_call_on_frame_received(session, frame);
4745
4746
0
  if (nghttp2_is_fatal(rv)) {
4747
0
    return rv;
4748
0
  }
4749
4750
0
  return session_close_stream_on_goaway(session, frame->goaway.last_stream_id,
4751
0
                                        0);
4752
0
}
4753
4754
0
static int session_process_goaway_frame(nghttp2_session *session) {
4755
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4756
0
  nghttp2_frame *frame = &iframe->frame;
4757
4758
0
  nghttp2_frame_unpack_goaway_payload(&frame->goaway, iframe->sbuf.pos,
4759
0
                                      iframe->lbuf.pos,
4760
0
                                      nghttp2_buf_len(&iframe->lbuf));
4761
4762
0
  nghttp2_buf_wrap_init(&iframe->lbuf, NULL, 0);
4763
4764
0
  return nghttp2_session_on_goaway_received(session, frame);
4765
0
}
4766
4767
static int
4768
session_on_connection_window_update_received(nghttp2_session *session,
4769
0
                                             nghttp2_frame *frame) {
4770
  /* Handle connection-level flow control */
4771
0
  if (frame->window_update.window_size_increment == 0) {
4772
0
    return session_handle_invalid_connection(
4773
0
        session, frame, NGHTTP2_ERR_PROTO,
4774
0
        "WINDOW_UPDATE: window_size_increment == 0");
4775
0
  }
4776
4777
0
  if (NGHTTP2_MAX_WINDOW_SIZE - frame->window_update.window_size_increment <
4778
0
      session->remote_window_size) {
4779
0
    return session_handle_invalid_connection(session, frame,
4780
0
                                             NGHTTP2_ERR_FLOW_CONTROL, NULL);
4781
0
  }
4782
0
  session->remote_window_size += frame->window_update.window_size_increment;
4783
4784
0
  return session_call_on_frame_received(session, frame);
4785
0
}
4786
4787
static int session_on_stream_window_update_received(nghttp2_session *session,
4788
0
                                                    nghttp2_frame *frame) {
4789
0
  int rv;
4790
0
  nghttp2_stream *stream;
4791
4792
0
  if (session_detect_idle_stream(session, frame->hd.stream_id)) {
4793
0
    return session_handle_invalid_connection(session, frame, NGHTTP2_ERR_PROTO,
4794
0
                                             "WINDOW_UPDATE to idle stream");
4795
0
  }
4796
4797
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
4798
0
  if (!stream) {
4799
0
    return 0;
4800
0
  }
4801
0
  if (state_reserved_remote(session, stream)) {
4802
0
    return session_handle_invalid_connection(
4803
0
        session, frame, NGHTTP2_ERR_PROTO, "WINDOW_UPADATE to reserved stream");
4804
0
  }
4805
0
  if (frame->window_update.window_size_increment == 0) {
4806
0
    return session_handle_invalid_connection(
4807
0
        session, frame, NGHTTP2_ERR_PROTO,
4808
0
        "WINDOW_UPDATE: window_size_increment == 0");
4809
0
  }
4810
0
  if (NGHTTP2_MAX_WINDOW_SIZE - frame->window_update.window_size_increment <
4811
0
      stream->remote_window_size) {
4812
0
    return session_handle_invalid_stream(session, frame,
4813
0
                                         NGHTTP2_ERR_FLOW_CONTROL);
4814
0
  }
4815
0
  stream->remote_window_size += frame->window_update.window_size_increment;
4816
4817
0
  if (stream->remote_window_size > 0 &&
4818
0
      nghttp2_stream_check_deferred_by_flow_control(stream)) {
4819
4820
0
    rv = nghttp2_stream_resume_deferred_item(
4821
0
        stream, NGHTTP2_STREAM_FLAG_DEFERRED_FLOW_CONTROL);
4822
4823
0
    if (nghttp2_is_fatal(rv)) {
4824
0
      return rv;
4825
0
    }
4826
0
  }
4827
0
  return session_call_on_frame_received(session, frame);
4828
0
}
4829
4830
int nghttp2_session_on_window_update_received(nghttp2_session *session,
4831
0
                                              nghttp2_frame *frame) {
4832
0
  if (frame->hd.stream_id == 0) {
4833
0
    return session_on_connection_window_update_received(session, frame);
4834
0
  } else {
4835
0
    return session_on_stream_window_update_received(session, frame);
4836
0
  }
4837
0
}
4838
4839
0
static int session_process_window_update_frame(nghttp2_session *session) {
4840
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4841
0
  nghttp2_frame *frame = &iframe->frame;
4842
4843
0
  nghttp2_frame_unpack_window_update_payload(&frame->window_update,
4844
0
                                             iframe->sbuf.pos);
4845
4846
0
  return nghttp2_session_on_window_update_received(session, frame);
4847
0
}
4848
4849
int nghttp2_session_on_altsvc_received(nghttp2_session *session,
4850
0
                                       nghttp2_frame *frame) {
4851
0
  nghttp2_ext_altsvc *altsvc;
4852
0
  nghttp2_stream *stream;
4853
4854
0
  altsvc = frame->ext.payload;
4855
4856
  /* session->server case has been excluded */
4857
4858
0
  if (frame->hd.stream_id == 0) {
4859
0
    if (altsvc->origin_len == 0) {
4860
0
      return session_call_on_invalid_frame_recv_callback(session, frame,
4861
0
                                                         NGHTTP2_ERR_PROTO);
4862
0
    }
4863
0
  } else {
4864
0
    if (altsvc->origin_len > 0) {
4865
0
      return session_call_on_invalid_frame_recv_callback(session, frame,
4866
0
                                                         NGHTTP2_ERR_PROTO);
4867
0
    }
4868
4869
0
    stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
4870
0
    if (!stream) {
4871
0
      return 0;
4872
0
    }
4873
4874
0
    if (stream->state == NGHTTP2_STREAM_CLOSING) {
4875
0
      return 0;
4876
0
    }
4877
0
  }
4878
4879
0
  if (altsvc->field_value_len == 0) {
4880
0
    return session_call_on_invalid_frame_recv_callback(session, frame,
4881
0
                                                       NGHTTP2_ERR_PROTO);
4882
0
  }
4883
4884
0
  return session_call_on_frame_received(session, frame);
4885
0
}
4886
4887
int nghttp2_session_on_origin_received(nghttp2_session *session,
4888
0
                                       nghttp2_frame *frame) {
4889
0
  return session_call_on_frame_received(session, frame);
4890
0
}
4891
4892
0
static int session_process_altsvc_frame(nghttp2_session *session) {
4893
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4894
0
  nghttp2_frame *frame = &iframe->frame;
4895
4896
0
  nghttp2_frame_unpack_altsvc_payload(
4897
0
      &frame->ext, nghttp2_get_uint16(iframe->sbuf.pos), iframe->lbuf.pos,
4898
0
      nghttp2_buf_len(&iframe->lbuf));
4899
4900
  /* nghttp2_frame_unpack_altsvc_payload steals buffer from
4901
     iframe->lbuf */
4902
0
  nghttp2_buf_wrap_init(&iframe->lbuf, NULL, 0);
4903
4904
0
  return nghttp2_session_on_altsvc_received(session, frame);
4905
0
}
4906
4907
0
static int session_process_origin_frame(nghttp2_session *session) {
4908
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4909
0
  nghttp2_frame *frame = &iframe->frame;
4910
0
  nghttp2_mem *mem = &session->mem;
4911
0
  int rv;
4912
4913
0
  rv = nghttp2_frame_unpack_origin_payload(&frame->ext, iframe->lbuf.pos,
4914
0
                                           nghttp2_buf_len(&iframe->lbuf), mem);
4915
0
  if (rv != 0) {
4916
0
    if (nghttp2_is_fatal(rv)) {
4917
0
      return rv;
4918
0
    }
4919
    /* Ignore ORIGIN frame which cannot be parsed. */
4920
0
    return 0;
4921
0
  }
4922
4923
0
  return nghttp2_session_on_origin_received(session, frame);
4924
0
}
4925
4926
0
static int session_process_extension_frame(nghttp2_session *session) {
4927
0
  int rv;
4928
0
  nghttp2_inbound_frame *iframe = &session->iframe;
4929
0
  nghttp2_frame *frame = &iframe->frame;
4930
4931
0
  rv = session_call_unpack_extension_callback(session);
4932
0
  if (nghttp2_is_fatal(rv)) {
4933
0
    return rv;
4934
0
  }
4935
4936
  /* This handles the case where rv == NGHTTP2_ERR_CANCEL as well */
4937
0
  if (rv != 0) {
4938
0
    return 0;
4939
0
  }
4940
4941
0
  return session_call_on_frame_received(session, frame);
4942
0
}
4943
4944
int nghttp2_session_on_data_received(nghttp2_session *session,
4945
0
                                     nghttp2_frame *frame) {
4946
0
  int rv = 0;
4947
0
  nghttp2_stream *stream;
4948
4949
  /* We don't call on_frame_recv_callback if stream has been closed
4950
     already or being closed. */
4951
0
  stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
4952
0
  if (!stream || stream->state == NGHTTP2_STREAM_CLOSING) {
4953
    /* This should be treated as stream error, but it results in lots
4954
       of RST_STREAM. So just ignore frame against nonexistent stream
4955
       for now. */
4956
0
    return 0;
4957
0
  }
4958
4959
0
  if (session_enforce_http_messaging(session) &&
4960
0
      (frame->hd.flags & NGHTTP2_FLAG_END_STREAM)) {
4961
0
    if (nghttp2_http_on_remote_end_stream(stream) != 0) {
4962
0
      rv = nghttp2_session_add_rst_stream(session, stream->stream_id,
4963
0
                                          NGHTTP2_PROTOCOL_ERROR);
4964
0
      if (nghttp2_is_fatal(rv)) {
4965
0
        return rv;
4966
0
      }
4967
4968
0
      nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD);
4969
      /* Don't call nghttp2_session_close_stream_if_shut_rdwr because
4970
         RST_STREAM has been submitted. */
4971
0
      return 0;
4972
0
    }
4973
0
  }
4974
4975
0
  rv = session_call_on_frame_received(session, frame);
4976
0
  if (nghttp2_is_fatal(rv)) {
4977
0
    return rv;
4978
0
  }
4979
4980
0
  if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
4981
0
    nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD);
4982
0
    rv = nghttp2_session_close_stream_if_shut_rdwr(session, stream);
4983
0
    if (nghttp2_is_fatal(rv)) {
4984
0
      return rv;
4985
0
    }
4986
0
  }
4987
0
  return 0;
4988
0
}
4989
4990
/* For errors, this function only returns FATAL error. */
4991
0
static int session_process_data_frame(nghttp2_session *session) {
4992
0
  int rv;
4993
0
  nghttp2_frame *public_data_frame = &session->iframe.frame;
4994
0
  rv = nghttp2_session_on_data_received(session, public_data_frame);
4995
0
  if (nghttp2_is_fatal(rv)) {
4996
0
    return rv;
4997
0
  }
4998
0
  return 0;
4999
0
}
5000
5001
/*
5002
 * Now we have SETTINGS synchronization, flow control error can be
5003
 * detected strictly. If DATA frame is received with length > 0 and
5004
 * current received window size + delta length is strictly larger than
5005
 * local window size, it is subject to FLOW_CONTROL_ERROR, so return
5006
 * -1. Note that local_window_size is calculated after SETTINGS ACK is
5007
 * received from peer, so peer must honor this limit. If the resulting
5008
 * recv_window_size is strictly larger than NGHTTP2_MAX_WINDOW_SIZE,
5009
 * return -1 too.
5010
 */
5011
static int adjust_recv_window_size(int32_t *recv_window_size_ptr, size_t delta,
5012
0
                                   int32_t local_window_size) {
5013
0
  if (*recv_window_size_ptr > local_window_size - (int32_t)delta ||
5014
0
      *recv_window_size_ptr > NGHTTP2_MAX_WINDOW_SIZE - (int32_t)delta) {
5015
0
    return -1;
5016
0
  }
5017
0
  *recv_window_size_ptr += (int32_t)delta;
5018
0
  return 0;
5019
0
}
5020
5021
int nghttp2_session_update_recv_stream_window_size(nghttp2_session *session,
5022
                                                   nghttp2_stream *stream,
5023
                                                   size_t delta_size,
5024
0
                                                   int send_window_update) {
5025
0
  int rv;
5026
0
  rv = adjust_recv_window_size(&stream->recv_window_size, delta_size,
5027
0
                               stream->local_window_size);
5028
0
  if (rv != 0) {
5029
0
    return nghttp2_session_add_rst_stream(session, stream->stream_id,
5030
0
                                          NGHTTP2_FLOW_CONTROL_ERROR);
5031
0
  }
5032
  /* We don't have to send WINDOW_UPDATE if the data received is the
5033
     last chunk in the incoming stream. */
5034
  /* We have to use local_settings here because it is the constraint
5035
     the remote endpoint should honor. */
5036
0
  if (send_window_update &&
5037
0
      !(session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE) &&
5038
0
      stream->window_update_queued == 0 &&
5039
0
      nghttp2_should_send_window_update(stream->local_window_size,
5040
0
                                        stream->recv_window_size)) {
5041
0
    rv = nghttp2_session_add_window_update(session, NGHTTP2_FLAG_NONE,
5042
0
                                           stream->stream_id,
5043
0
                                           stream->recv_window_size);
5044
0
    if (rv != 0) {
5045
0
      return rv;
5046
0
    }
5047
5048
0
    stream->recv_window_size = 0;
5049
0
  }
5050
0
  return 0;
5051
0
}
5052
5053
int nghttp2_session_update_recv_connection_window_size(nghttp2_session *session,
5054
0
                                                       size_t delta_size) {
5055
0
  int rv;
5056
0
  rv = adjust_recv_window_size(&session->recv_window_size, delta_size,
5057
0
                               session->local_window_size);
5058
0
  if (rv != 0) {
5059
0
    return nghttp2_session_terminate_session(session,
5060
0
                                             NGHTTP2_FLOW_CONTROL_ERROR);
5061
0
  }
5062
0
  if (!(session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE) &&
5063
0
      session->window_update_queued == 0 &&
5064
0
      nghttp2_should_send_window_update(session->local_window_size,
5065
0
                                        session->recv_window_size)) {
5066
    /* Use stream ID 0 to update connection-level flow control
5067
       window */
5068
0
    rv = nghttp2_session_add_window_update(session, NGHTTP2_FLAG_NONE, 0,
5069
0
                                           session->recv_window_size);
5070
0
    if (rv != 0) {
5071
0
      return rv;
5072
0
    }
5073
5074
0
    session->recv_window_size = 0;
5075
0
  }
5076
0
  return 0;
5077
0
}
5078
5079
static int session_update_consumed_size(nghttp2_session *session,
5080
                                        int32_t *consumed_size_ptr,
5081
                                        int32_t *recv_window_size_ptr,
5082
                                        uint8_t window_update_queued,
5083
                                        int32_t stream_id, size_t delta_size,
5084
0
                                        int32_t local_window_size) {
5085
0
  int32_t recv_size;
5086
0
  int rv;
5087
5088
0
  if ((size_t)*consumed_size_ptr > NGHTTP2_MAX_WINDOW_SIZE - delta_size) {
5089
0
    return nghttp2_session_terminate_session(session,
5090
0
                                             NGHTTP2_FLOW_CONTROL_ERROR);
5091
0
  }
5092
5093
0
  *consumed_size_ptr += (int32_t)delta_size;
5094
5095
0
  if (window_update_queued == 0) {
5096
    /* recv_window_size may be smaller than consumed_size, because it
5097
       may be decreased by negative value with
5098
       nghttp2_submit_window_update(). */
5099
0
    recv_size = nghttp2_min(*consumed_size_ptr, *recv_window_size_ptr);
5100
5101
0
    if (nghttp2_should_send_window_update(local_window_size, recv_size)) {
5102
0
      rv = nghttp2_session_add_window_update(session, NGHTTP2_FLAG_NONE,
5103
0
                                             stream_id, recv_size);
5104
5105
0
      if (rv != 0) {
5106
0
        return rv;
5107
0
      }
5108
5109
0
      *recv_window_size_ptr -= recv_size;
5110
0
      *consumed_size_ptr -= recv_size;
5111
0
    }
5112
0
  }
5113
5114
0
  return 0;
5115
0
}
5116
5117
static int session_update_stream_consumed_size(nghttp2_session *session,
5118
                                               nghttp2_stream *stream,
5119
0
                                               size_t delta_size) {
5120
0
  return session_update_consumed_size(
5121
0
      session, &stream->consumed_size, &stream->recv_window_size,
5122
0
      stream->window_update_queued, stream->stream_id, delta_size,
5123
0
      stream->local_window_size);
5124
0
}
5125
5126
static int session_update_connection_consumed_size(nghttp2_session *session,
5127
0
                                                   size_t delta_size) {
5128
0
  return session_update_consumed_size(
5129
0
      session, &session->consumed_size, &session->recv_window_size,
5130
0
      session->window_update_queued, 0, delta_size, session->local_window_size);
5131
0
}
5132
5133
/*
5134
 * Checks that we can receive the DATA frame for stream, which is
5135
 * indicated by |session->iframe.frame.hd.stream_id|. If it is a
5136
 * connection error situation, GOAWAY frame will be issued by this
5137
 * function.
5138
 *
5139
 * If the DATA frame is allowed, returns 0.
5140
 *
5141
 * This function returns 0 if it succeeds, or one of the following
5142
 * negative error codes:
5143
 *
5144
 * NGHTTP2_ERR_IGN_PAYLOAD
5145
 *   The reception of DATA frame is connection error; or should be
5146
 *   ignored.
5147
 * NGHTTP2_ERR_NOMEM
5148
 *   Out of memory.
5149
 */
5150
0
static int session_on_data_received_fail_fast(nghttp2_session *session) {
5151
0
  int rv;
5152
0
  nghttp2_stream *stream;
5153
0
  nghttp2_inbound_frame *iframe;
5154
0
  int32_t stream_id;
5155
0
  const char *failure_reason;
5156
0
  uint32_t error_code = NGHTTP2_PROTOCOL_ERROR;
5157
5158
0
  iframe = &session->iframe;
5159
0
  stream_id = iframe->frame.hd.stream_id;
5160
5161
0
  if (stream_id == 0) {
5162
    /* The spec says that if a DATA frame is received whose stream ID
5163
       is 0, the recipient MUST respond with a connection error of
5164
       type PROTOCOL_ERROR. */
5165
0
    failure_reason = "DATA: stream_id == 0";
5166
0
    goto fail;
5167
0
  }
5168
5169
0
  if (session_detect_idle_stream(session, stream_id)) {
5170
0
    failure_reason = "DATA: stream in idle";
5171
0
    error_code = NGHTTP2_PROTOCOL_ERROR;
5172
0
    goto fail;
5173
0
  }
5174
5175
0
  stream = nghttp2_session_get_stream(session, stream_id);
5176
0
  if (!stream) {
5177
0
    stream = nghttp2_session_get_stream_raw(session, stream_id);
5178
0
    if (stream && (stream->shut_flags & NGHTTP2_SHUT_RD)) {
5179
0
      failure_reason = "DATA: stream closed";
5180
0
      error_code = NGHTTP2_STREAM_CLOSED;
5181
0
      goto fail;
5182
0
    }
5183
5184
0
    return NGHTTP2_ERR_IGN_PAYLOAD;
5185
0
  }
5186
0
  if (stream->shut_flags & NGHTTP2_SHUT_RD) {
5187
0
    failure_reason = "DATA: stream in half-closed(remote)";
5188
0
    error_code = NGHTTP2_STREAM_CLOSED;
5189
0
    goto fail;
5190
0
  }
5191
5192
0
  if (nghttp2_session_is_my_stream_id(session, stream_id)) {
5193
0
    if (stream->state == NGHTTP2_STREAM_CLOSING) {
5194
0
      return NGHTTP2_ERR_IGN_PAYLOAD;
5195
0
    }
5196
0
    if (stream->state != NGHTTP2_STREAM_OPENED) {
5197
0
      failure_reason = "DATA: stream not opened";
5198
0
      goto fail;
5199
0
    }
5200
0
    return 0;
5201
0
  }
5202
0
  if (stream->state == NGHTTP2_STREAM_RESERVED) {
5203
0
    failure_reason = "DATA: stream in reserved";
5204
0
    goto fail;
5205
0
  }
5206
0
  if (stream->state == NGHTTP2_STREAM_CLOSING) {
5207
0
    return NGHTTP2_ERR_IGN_PAYLOAD;
5208
0
  }
5209
0
  return 0;
5210
0
fail:
5211
0
  rv = nghttp2_session_terminate_session_with_reason(session, error_code,
5212
0
                                                     failure_reason);
5213
0
  if (nghttp2_is_fatal(rv)) {
5214
0
    return rv;
5215
0
  }
5216
0
  return NGHTTP2_ERR_IGN_PAYLOAD;
5217
0
}
5218
5219
static size_t inbound_frame_payload_readlen(nghttp2_inbound_frame *iframe,
5220
                                            const uint8_t *in,
5221
0
                                            const uint8_t *last) {
5222
0
  return nghttp2_min((size_t)(last - in), iframe->payloadleft);
5223
0
}
5224
5225
/*
5226
 * Resets iframe->sbuf and advance its mark pointer by |left| bytes.
5227
 */
5228
0
static void inbound_frame_set_mark(nghttp2_inbound_frame *iframe, size_t left) {
5229
0
  nghttp2_buf_reset(&iframe->sbuf);
5230
0
  iframe->sbuf.mark += left;
5231
0
}
5232
5233
static size_t inbound_frame_buf_read(nghttp2_inbound_frame *iframe,
5234
0
                                     const uint8_t *in, const uint8_t *last) {
5235
0
  size_t readlen;
5236
5237
0
  readlen =
5238
0
      nghttp2_min((size_t)(last - in), nghttp2_buf_mark_avail(&iframe->sbuf));
5239
5240
0
  iframe->sbuf.last = nghttp2_cpymem(iframe->sbuf.last, in, readlen);
5241
5242
0
  return readlen;
5243
0
}
5244
5245
/*
5246
 * Unpacks SETTINGS entry in iframe->sbuf.
5247
 */
5248
0
static void inbound_frame_set_settings_entry(nghttp2_inbound_frame *iframe) {
5249
0
  nghttp2_settings_entry iv;
5250
0
  nghttp2_settings_entry *min_header_table_size_entry;
5251
0
  size_t i;
5252
5253
0
  nghttp2_frame_unpack_settings_entry(&iv, iframe->sbuf.pos);
5254
5255
0
  switch (iv.settings_id) {
5256
0
  case NGHTTP2_SETTINGS_HEADER_TABLE_SIZE:
5257
0
  case NGHTTP2_SETTINGS_ENABLE_PUSH:
5258
0
  case NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS:
5259
0
  case NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE:
5260
0
  case NGHTTP2_SETTINGS_MAX_FRAME_SIZE:
5261
0
  case NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE:
5262
0
  case NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL:
5263
0
    break;
5264
0
  default:
5265
0
    DEBUGF("recv: unknown settings id=0x%02x\n", iv.settings_id);
5266
5267
0
    iframe->iv[iframe->niv++] = iv;
5268
5269
0
    return;
5270
0
  }
5271
5272
0
  for (i = 0; i < iframe->niv; ++i) {
5273
0
    if (iframe->iv[i].settings_id == iv.settings_id) {
5274
0
      iframe->iv[i] = iv;
5275
0
      break;
5276
0
    }
5277
0
  }
5278
5279
0
  if (i == iframe->niv) {
5280
0
    iframe->iv[iframe->niv++] = iv;
5281
0
  }
5282
5283
0
  if (iv.settings_id == NGHTTP2_SETTINGS_HEADER_TABLE_SIZE) {
5284
    /* Keep track of minimum value of SETTINGS_HEADER_TABLE_SIZE */
5285
0
    min_header_table_size_entry = &iframe->iv[iframe->max_niv - 1];
5286
5287
0
    if (iv.value < min_header_table_size_entry->value) {
5288
0
      min_header_table_size_entry->value = iv.value;
5289
0
    }
5290
0
  }
5291
0
}
5292
5293
/*
5294
 * Checks PADDED flags and set iframe->sbuf to read them accordingly.
5295
 * If padding is set, this function returns 1.  If no padding is set,
5296
 * this function returns 0.  On error, returns -1.
5297
 */
5298
static int inbound_frame_handle_pad(nghttp2_inbound_frame *iframe,
5299
0
                                    nghttp2_frame_hd *hd) {
5300
0
  if (hd->flags & NGHTTP2_FLAG_PADDED) {
5301
0
    if (hd->length < 1) {
5302
0
      return -1;
5303
0
    }
5304
0
    inbound_frame_set_mark(iframe, 1);
5305
0
    return 1;
5306
0
  }
5307
0
  DEBUGF("recv: no padding in payload\n");
5308
0
  return 0;
5309
0
}
5310
5311
/*
5312
 * Computes number of padding based on flags. This function returns
5313
 * the calculated length if it succeeds, or -1.
5314
 */
5315
0
static ssize_t inbound_frame_compute_pad(nghttp2_inbound_frame *iframe) {
5316
0
  size_t padlen;
5317
5318
  /* 1 for Pad Length field */
5319
0
  padlen = (size_t)(iframe->sbuf.pos[0] + 1);
5320
5321
0
  DEBUGF("recv: padlen=%zu\n", padlen);
5322
5323
  /* We cannot use iframe->frame.hd.length because of CONTINUATION */
5324
0
  if (padlen - 1 > iframe->payloadleft) {
5325
0
    return -1;
5326
0
  }
5327
5328
0
  iframe->padlen = padlen;
5329
5330
0
  return (ssize_t)padlen;
5331
0
}
5332
5333
/*
5334
 * This function returns the effective payload length in the data of
5335
 * length |readlen| when the remaning payload is |payloadleft|. The
5336
 * |payloadleft| does not include |readlen|. If padding was started
5337
 * strictly before this data chunk, this function returns -1.
5338
 */
5339
static ssize_t inbound_frame_effective_readlen(nghttp2_inbound_frame *iframe,
5340
                                               size_t payloadleft,
5341
0
                                               size_t readlen) {
5342
0
  size_t trail_padlen =
5343
0
      nghttp2_frame_trail_padlen(&iframe->frame, iframe->padlen);
5344
5345
0
  if (trail_padlen > payloadleft) {
5346
0
    size_t padlen;
5347
0
    padlen = trail_padlen - payloadleft;
5348
0
    if (readlen < padlen) {
5349
0
      return -1;
5350
0
    }
5351
0
    return (ssize_t)(readlen - padlen);
5352
0
  }
5353
0
  return (ssize_t)(readlen);
5354
0
}
5355
5356
ssize_t nghttp2_session_mem_recv(nghttp2_session *session, const uint8_t *in,
5357
0
                                 size_t inlen) {
5358
0
  const uint8_t *first = in, *last = in + inlen;
5359
0
  nghttp2_inbound_frame *iframe = &session->iframe;
5360
0
  size_t readlen;
5361
0
  ssize_t padlen;
5362
0
  int rv;
5363
0
  int busy = 0;
5364
0
  nghttp2_frame_hd cont_hd;
5365
0
  nghttp2_stream *stream;
5366
0
  size_t pri_fieldlen;
5367
0
  nghttp2_mem *mem;
5368
5369
0
  DEBUGF("recv: connection recv_window_size=%d, local_window=%d\n",
5370
0
         session->recv_window_size, session->local_window_size);
5371
5372
0
  mem = &session->mem;
5373
5374
  /* We may have idle streams more than we expect (e.g.,
5375
     nghttp2_session_change_stream_priority() or
5376
     nghttp2_session_create_idle_stream()).  Adjust them here. */
5377
0
  rv = nghttp2_session_adjust_idle_stream(session);
5378
0
  if (nghttp2_is_fatal(rv)) {
5379
0
    return rv;
5380
0
  }
5381
5382
0
  if (!nghttp2_session_want_read(session)) {
5383
0
    return (ssize_t)inlen;
5384
0
  }
5385
5386
0
  for (;;) {
5387
0
    switch (iframe->state) {
5388
0
    case NGHTTP2_IB_READ_CLIENT_MAGIC:
5389
0
      readlen = nghttp2_min(inlen, iframe->payloadleft);
5390
5391
0
      if (memcmp(&NGHTTP2_CLIENT_MAGIC[NGHTTP2_CLIENT_MAGIC_LEN -
5392
0
                                       iframe->payloadleft],
5393
0
                 in, readlen) != 0) {
5394
0
        return NGHTTP2_ERR_BAD_CLIENT_MAGIC;
5395
0
      }
5396
5397
0
      iframe->payloadleft -= readlen;
5398
0
      in += readlen;
5399
5400
0
      if (iframe->payloadleft == 0) {
5401
0
        session_inbound_frame_reset(session);
5402
0
        iframe->state = NGHTTP2_IB_READ_FIRST_SETTINGS;
5403
0
      }
5404
5405
0
      break;
5406
0
    case NGHTTP2_IB_READ_FIRST_SETTINGS:
5407
0
      DEBUGF("recv: [IB_READ_FIRST_SETTINGS]\n");
5408
5409
0
      readlen = inbound_frame_buf_read(iframe, in, last);
5410
0
      in += readlen;
5411
5412
0
      if (nghttp2_buf_mark_avail(&iframe->sbuf)) {
5413
0
        return in - first;
5414
0
      }
5415
5416
0
      if (iframe->sbuf.pos[3] != NGHTTP2_SETTINGS ||
5417
0
          (iframe->sbuf.pos[4] & NGHTTP2_FLAG_ACK)) {
5418
0
        rv = session_call_error_callback(
5419
0
            session, NGHTTP2_ERR_SETTINGS_EXPECTED,
5420
0
            "Remote peer returned unexpected data while we expected "
5421
0
            "SETTINGS frame.  Perhaps, peer does not support HTTP/2 "
5422
0
            "properly.");
5423
5424
0
        if (nghttp2_is_fatal(rv)) {
5425
0
          return rv;
5426
0
        }
5427
5428
0
        rv = nghttp2_session_terminate_session_with_reason(
5429
0
            session, NGHTTP2_PROTOCOL_ERROR, "SETTINGS expected");
5430
5431
0
        if (nghttp2_is_fatal(rv)) {
5432
0
          return rv;
5433
0
        }
5434
5435
0
        return (ssize_t)inlen;
5436
0
      }
5437
5438
0
      iframe->state = NGHTTP2_IB_READ_HEAD;
5439
5440
    /* Fall through */
5441
0
    case NGHTTP2_IB_READ_HEAD: {
5442
0
      int on_begin_frame_called = 0;
5443
5444
0
      DEBUGF("recv: [IB_READ_HEAD]\n");
5445
5446
0
      readlen = inbound_frame_buf_read(iframe, in, last);
5447
0
      in += readlen;
5448
5449
0
      if (nghttp2_buf_mark_avail(&iframe->sbuf)) {
5450
0
        return in - first;
5451
0
      }
5452
5453
0
      nghttp2_frame_unpack_frame_hd(&iframe->frame.hd, iframe->sbuf.pos);
5454
0
      iframe->payloadleft = iframe->frame.hd.length;
5455
5456
0
      DEBUGF("recv: payloadlen=%zu, type=%u, flags=0x%02x, stream_id=%d\n",
5457
0
             iframe->frame.hd.length, iframe->frame.hd.type,
5458
0
             iframe->frame.hd.flags, iframe->frame.hd.stream_id);
5459
5460
0
      if (iframe->frame.hd.length > session->local_settings.max_frame_size) {
5461
0
        DEBUGF("recv: length is too large %zu > %u\n", iframe->frame.hd.length,
5462
0
               session->local_settings.max_frame_size);
5463
5464
0
        rv = nghttp2_session_terminate_session_with_reason(
5465
0
            session, NGHTTP2_FRAME_SIZE_ERROR, "too large frame size");
5466
5467
0
        if (nghttp2_is_fatal(rv)) {
5468
0
          return rv;
5469
0
        }
5470
5471
0
        return (ssize_t)inlen;
5472
0
      }
5473
5474
0
      switch (iframe->frame.hd.type) {
5475
0
      case NGHTTP2_DATA: {
5476
0
        DEBUGF("recv: DATA\n");
5477
5478
0
        iframe->frame.hd.flags &=
5479
0
            (NGHTTP2_FLAG_END_STREAM | NGHTTP2_FLAG_PADDED);
5480
        /* Check stream is open. If it is not open or closing,
5481
           ignore payload. */
5482
0
        busy = 1;
5483
5484
0
        rv = session_on_data_received_fail_fast(session);
5485
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
5486
0
          return (ssize_t)inlen;
5487
0
        }
5488
0
        if (rv == NGHTTP2_ERR_IGN_PAYLOAD) {
5489
0
          DEBUGF("recv: DATA not allowed stream_id=%d\n",
5490
0
                 iframe->frame.hd.stream_id);
5491
0
          iframe->state = NGHTTP2_IB_IGN_DATA;
5492
0
          break;
5493
0
        }
5494
5495
0
        if (nghttp2_is_fatal(rv)) {
5496
0
          return rv;
5497
0
        }
5498
5499
0
        rv = inbound_frame_handle_pad(iframe, &iframe->frame.hd);
5500
0
        if (rv < 0) {
5501
0
          rv = nghttp2_session_terminate_session_with_reason(
5502
0
              session, NGHTTP2_PROTOCOL_ERROR,
5503
0
              "DATA: insufficient padding space");
5504
5505
0
          if (nghttp2_is_fatal(rv)) {
5506
0
            return rv;
5507
0
          }
5508
0
          return (ssize_t)inlen;
5509
0
        }
5510
5511
0
        if (rv == 1) {
5512
0
          iframe->state = NGHTTP2_IB_READ_PAD_DATA;
5513
0
          break;
5514
0
        }
5515
5516
0
        iframe->state = NGHTTP2_IB_READ_DATA;
5517
0
        break;
5518
0
      }
5519
0
      case NGHTTP2_HEADERS:
5520
5521
0
        DEBUGF("recv: HEADERS\n");
5522
5523
0
        iframe->frame.hd.flags &=
5524
0
            (NGHTTP2_FLAG_END_STREAM | NGHTTP2_FLAG_END_HEADERS |
5525
0
             NGHTTP2_FLAG_PADDED | NGHTTP2_FLAG_PRIORITY);
5526
5527
0
        rv = inbound_frame_handle_pad(iframe, &iframe->frame.hd);
5528
0
        if (rv < 0) {
5529
0
          rv = nghttp2_session_terminate_session_with_reason(
5530
0
              session, NGHTTP2_PROTOCOL_ERROR,
5531
0
              "HEADERS: insufficient padding space");
5532
0
          if (nghttp2_is_fatal(rv)) {
5533
0
            return rv;
5534
0
          }
5535
0
          return (ssize_t)inlen;
5536
0
        }
5537
5538
0
        if (rv == 1) {
5539
0
          iframe->state = NGHTTP2_IB_READ_NBYTE;
5540
0
          break;
5541
0
        }
5542
5543
0
        pri_fieldlen = nghttp2_frame_priority_len(iframe->frame.hd.flags);
5544
5545
0
        if (pri_fieldlen > 0) {
5546
0
          if (iframe->payloadleft < pri_fieldlen) {
5547
0
            busy = 1;
5548
0
            iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5549
0
            break;
5550
0
          }
5551
5552
0
          iframe->state = NGHTTP2_IB_READ_NBYTE;
5553
5554
0
          inbound_frame_set_mark(iframe, pri_fieldlen);
5555
5556
0
          break;
5557
0
        }
5558
5559
        /* Call on_begin_frame_callback here because
5560
           session_process_headers_frame() may call
5561
           on_begin_headers_callback */
5562
0
        rv = session_call_on_begin_frame(session, &iframe->frame.hd);
5563
5564
0
        if (nghttp2_is_fatal(rv)) {
5565
0
          return rv;
5566
0
        }
5567
5568
0
        on_begin_frame_called = 1;
5569
5570
0
        rv = session_process_headers_frame(session);
5571
0
        if (nghttp2_is_fatal(rv)) {
5572
0
          return rv;
5573
0
        }
5574
5575
0
        busy = 1;
5576
5577
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
5578
0
          return (ssize_t)inlen;
5579
0
        }
5580
5581
0
        if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
5582
0
          rv = nghttp2_session_add_rst_stream(
5583
0
              session, iframe->frame.hd.stream_id, NGHTTP2_INTERNAL_ERROR);
5584
0
          if (nghttp2_is_fatal(rv)) {
5585
0
            return rv;
5586
0
          }
5587
0
          iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK;
5588
0
          break;
5589
0
        }
5590
5591
0
        if (rv == NGHTTP2_ERR_IGN_HEADER_BLOCK) {
5592
0
          iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK;
5593
0
          break;
5594
0
        }
5595
5596
0
        iframe->state = NGHTTP2_IB_READ_HEADER_BLOCK;
5597
5598
0
        break;
5599
0
      case NGHTTP2_PRIORITY:
5600
0
        DEBUGF("recv: PRIORITY\n");
5601
5602
0
        iframe->frame.hd.flags = NGHTTP2_FLAG_NONE;
5603
5604
0
        if (iframe->payloadleft != NGHTTP2_PRIORITY_SPECLEN) {
5605
0
          busy = 1;
5606
5607
0
          iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5608
5609
0
          break;
5610
0
        }
5611
5612
0
        iframe->state = NGHTTP2_IB_READ_NBYTE;
5613
5614
0
        inbound_frame_set_mark(iframe, NGHTTP2_PRIORITY_SPECLEN);
5615
5616
0
        break;
5617
0
      case NGHTTP2_RST_STREAM:
5618
0
      case NGHTTP2_WINDOW_UPDATE:
5619
#ifdef DEBUGBUILD
5620
        switch (iframe->frame.hd.type) {
5621
        case NGHTTP2_RST_STREAM:
5622
          DEBUGF("recv: RST_STREAM\n");
5623
          break;
5624
        case NGHTTP2_WINDOW_UPDATE:
5625
          DEBUGF("recv: WINDOW_UPDATE\n");
5626
          break;
5627
        }
5628
#endif /* DEBUGBUILD */
5629
5630
0
        iframe->frame.hd.flags = NGHTTP2_FLAG_NONE;
5631
5632
0
        if (iframe->payloadleft != 4) {
5633
0
          busy = 1;
5634
0
          iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5635
0
          break;
5636
0
        }
5637
5638
0
        iframe->state = NGHTTP2_IB_READ_NBYTE;
5639
5640
0
        inbound_frame_set_mark(iframe, 4);
5641
5642
0
        break;
5643
0
      case NGHTTP2_SETTINGS:
5644
0
        DEBUGF("recv: SETTINGS\n");
5645
5646
0
        iframe->frame.hd.flags &= NGHTTP2_FLAG_ACK;
5647
5648
0
        if ((iframe->frame.hd.length % NGHTTP2_FRAME_SETTINGS_ENTRY_LENGTH) ||
5649
0
            ((iframe->frame.hd.flags & NGHTTP2_FLAG_ACK) &&
5650
0
             iframe->payloadleft > 0)) {
5651
0
          busy = 1;
5652
0
          iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5653
0
          break;
5654
0
        }
5655
5656
        /* Check the settings flood counter early to be safe */
5657
0
        if (session->obq_flood_counter_ >= session->max_outbound_ack &&
5658
0
            !(iframe->frame.hd.flags & NGHTTP2_FLAG_ACK)) {
5659
0
          return NGHTTP2_ERR_FLOODED;
5660
0
        }
5661
5662
0
        iframe->state = NGHTTP2_IB_READ_SETTINGS;
5663
5664
0
        if (iframe->payloadleft) {
5665
0
          nghttp2_settings_entry *min_header_table_size_entry;
5666
5667
          /* We allocate iv with additional one entry, to store the
5668
             minimum header table size. */
5669
0
          iframe->max_niv =
5670
0
              iframe->frame.hd.length / NGHTTP2_FRAME_SETTINGS_ENTRY_LENGTH + 1;
5671
5672
0
          if (iframe->max_niv - 1 > session->max_settings) {
5673
0
            rv = nghttp2_session_terminate_session_with_reason(
5674
0
                session, NGHTTP2_ENHANCE_YOUR_CALM,
5675
0
                "SETTINGS: too many setting entries");
5676
0
            if (nghttp2_is_fatal(rv)) {
5677
0
              return rv;
5678
0
            }
5679
0
            return (ssize_t)inlen;
5680
0
          }
5681
5682
0
          iframe->iv = nghttp2_mem_malloc(mem, sizeof(nghttp2_settings_entry) *
5683
0
                                                   iframe->max_niv);
5684
5685
0
          if (!iframe->iv) {
5686
0
            return NGHTTP2_ERR_NOMEM;
5687
0
          }
5688
5689
0
          min_header_table_size_entry = &iframe->iv[iframe->max_niv - 1];
5690
0
          min_header_table_size_entry->settings_id =
5691
0
              NGHTTP2_SETTINGS_HEADER_TABLE_SIZE;
5692
0
          min_header_table_size_entry->value = UINT32_MAX;
5693
5694
0
          inbound_frame_set_mark(iframe, NGHTTP2_FRAME_SETTINGS_ENTRY_LENGTH);
5695
0
          break;
5696
0
        }
5697
5698
0
        busy = 1;
5699
5700
0
        inbound_frame_set_mark(iframe, 0);
5701
5702
0
        break;
5703
0
      case NGHTTP2_PUSH_PROMISE:
5704
0
        DEBUGF("recv: PUSH_PROMISE\n");
5705
5706
0
        iframe->frame.hd.flags &=
5707
0
            (NGHTTP2_FLAG_END_HEADERS | NGHTTP2_FLAG_PADDED);
5708
5709
0
        rv = inbound_frame_handle_pad(iframe, &iframe->frame.hd);
5710
0
        if (rv < 0) {
5711
0
          rv = nghttp2_session_terminate_session_with_reason(
5712
0
              session, NGHTTP2_PROTOCOL_ERROR,
5713
0
              "PUSH_PROMISE: insufficient padding space");
5714
0
          if (nghttp2_is_fatal(rv)) {
5715
0
            return rv;
5716
0
          }
5717
0
          return (ssize_t)inlen;
5718
0
        }
5719
5720
0
        if (rv == 1) {
5721
0
          iframe->state = NGHTTP2_IB_READ_NBYTE;
5722
0
          break;
5723
0
        }
5724
5725
0
        if (iframe->payloadleft < 4) {
5726
0
          busy = 1;
5727
0
          iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5728
0
          break;
5729
0
        }
5730
5731
0
        iframe->state = NGHTTP2_IB_READ_NBYTE;
5732
5733
0
        inbound_frame_set_mark(iframe, 4);
5734
5735
0
        break;
5736
0
      case NGHTTP2_PING:
5737
0
        DEBUGF("recv: PING\n");
5738
5739
0
        iframe->frame.hd.flags &= NGHTTP2_FLAG_ACK;
5740
5741
0
        if (iframe->payloadleft != 8) {
5742
0
          busy = 1;
5743
0
          iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5744
0
          break;
5745
0
        }
5746
5747
0
        iframe->state = NGHTTP2_IB_READ_NBYTE;
5748
0
        inbound_frame_set_mark(iframe, 8);
5749
5750
0
        break;
5751
0
      case NGHTTP2_GOAWAY:
5752
0
        DEBUGF("recv: GOAWAY\n");
5753
5754
0
        iframe->frame.hd.flags = NGHTTP2_FLAG_NONE;
5755
5756
0
        if (iframe->payloadleft < 8) {
5757
0
          busy = 1;
5758
0
          iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5759
0
          break;
5760
0
        }
5761
5762
0
        iframe->state = NGHTTP2_IB_READ_NBYTE;
5763
0
        inbound_frame_set_mark(iframe, 8);
5764
5765
0
        break;
5766
0
      case NGHTTP2_CONTINUATION:
5767
0
        DEBUGF("recv: unexpected CONTINUATION\n");
5768
5769
        /* Receiving CONTINUATION in this state are subject to
5770
           connection error of type PROTOCOL_ERROR */
5771
0
        rv = nghttp2_session_terminate_session_with_reason(
5772
0
            session, NGHTTP2_PROTOCOL_ERROR, "CONTINUATION: unexpected");
5773
0
        if (nghttp2_is_fatal(rv)) {
5774
0
          return rv;
5775
0
        }
5776
5777
0
        return (ssize_t)inlen;
5778
0
      default:
5779
0
        DEBUGF("recv: extension frame\n");
5780
5781
0
        if (check_ext_type_set(session->user_recv_ext_types,
5782
0
                               iframe->frame.hd.type)) {
5783
0
          if (!session->callbacks.unpack_extension_callback) {
5784
            /* Silently ignore unknown frame type. */
5785
5786
0
            busy = 1;
5787
5788
0
            iframe->state = NGHTTP2_IB_IGN_PAYLOAD;
5789
5790
0
            break;
5791
0
          }
5792
5793
0
          busy = 1;
5794
5795
0
          iframe->state = NGHTTP2_IB_READ_EXTENSION_PAYLOAD;
5796
5797
0
          break;
5798
0
        } else {
5799
0
          switch (iframe->frame.hd.type) {
5800
0
          case NGHTTP2_ALTSVC:
5801
0
            if ((session->builtin_recv_ext_types & NGHTTP2_TYPEMASK_ALTSVC) ==
5802
0
                0) {
5803
0
              busy = 1;
5804
0
              iframe->state = NGHTTP2_IB_IGN_PAYLOAD;
5805
0
              break;
5806
0
            }
5807
5808
0
            DEBUGF("recv: ALTSVC\n");
5809
5810
0
            iframe->frame.hd.flags = NGHTTP2_FLAG_NONE;
5811
0
            iframe->frame.ext.payload = &iframe->ext_frame_payload.altsvc;
5812
5813
0
            if (session->server) {
5814
0
              busy = 1;
5815
0
              iframe->state = NGHTTP2_IB_IGN_PAYLOAD;
5816
0
              break;
5817
0
            }
5818
5819
0
            if (iframe->payloadleft < 2) {
5820
0
              busy = 1;
5821
0
              iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5822
0
              break;
5823
0
            }
5824
5825
0
            busy = 1;
5826
5827
0
            iframe->state = NGHTTP2_IB_READ_NBYTE;
5828
0
            inbound_frame_set_mark(iframe, 2);
5829
5830
0
            break;
5831
0
          case NGHTTP2_ORIGIN:
5832
0
            if (!(session->builtin_recv_ext_types & NGHTTP2_TYPEMASK_ORIGIN)) {
5833
0
              busy = 1;
5834
0
              iframe->state = NGHTTP2_IB_IGN_PAYLOAD;
5835
0
              break;
5836
0
            }
5837
5838
0
            DEBUGF("recv: ORIGIN\n");
5839
5840
0
            iframe->frame.ext.payload = &iframe->ext_frame_payload.origin;
5841
5842
0
            if (session->server || iframe->frame.hd.stream_id ||
5843
0
                (iframe->frame.hd.flags & 0xf0)) {
5844
0
              busy = 1;
5845
0
              iframe->state = NGHTTP2_IB_IGN_PAYLOAD;
5846
0
              break;
5847
0
            }
5848
5849
0
            iframe->frame.hd.flags = NGHTTP2_FLAG_NONE;
5850
5851
0
            if (iframe->payloadleft) {
5852
0
              iframe->raw_lbuf = nghttp2_mem_malloc(mem, iframe->payloadleft);
5853
5854
0
              if (iframe->raw_lbuf == NULL) {
5855
0
                return NGHTTP2_ERR_NOMEM;
5856
0
              }
5857
5858
0
              nghttp2_buf_wrap_init(&iframe->lbuf, iframe->raw_lbuf,
5859
0
                                    iframe->payloadleft);
5860
0
            } else {
5861
0
              busy = 1;
5862
0
            }
5863
5864
0
            iframe->state = NGHTTP2_IB_READ_ORIGIN_PAYLOAD;
5865
5866
0
            break;
5867
0
          default:
5868
0
            busy = 1;
5869
5870
0
            iframe->state = NGHTTP2_IB_IGN_PAYLOAD;
5871
5872
0
            break;
5873
0
          }
5874
0
        }
5875
0
      }
5876
5877
0
      if (!on_begin_frame_called) {
5878
0
        switch (iframe->state) {
5879
0
        case NGHTTP2_IB_IGN_HEADER_BLOCK:
5880
0
        case NGHTTP2_IB_IGN_PAYLOAD:
5881
0
        case NGHTTP2_IB_FRAME_SIZE_ERROR:
5882
0
        case NGHTTP2_IB_IGN_DATA:
5883
0
        case NGHTTP2_IB_IGN_ALL:
5884
0
          break;
5885
0
        default:
5886
0
          rv = session_call_on_begin_frame(session, &iframe->frame.hd);
5887
5888
0
          if (nghttp2_is_fatal(rv)) {
5889
0
            return rv;
5890
0
          }
5891
0
        }
5892
0
      }
5893
5894
0
      break;
5895
0
    }
5896
0
    case NGHTTP2_IB_READ_NBYTE:
5897
0
      DEBUGF("recv: [IB_READ_NBYTE]\n");
5898
5899
0
      readlen = inbound_frame_buf_read(iframe, in, last);
5900
0
      in += readlen;
5901
0
      iframe->payloadleft -= readlen;
5902
5903
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu, left=%zd\n", readlen,
5904
0
             iframe->payloadleft, nghttp2_buf_mark_avail(&iframe->sbuf));
5905
5906
0
      if (nghttp2_buf_mark_avail(&iframe->sbuf)) {
5907
0
        return in - first;
5908
0
      }
5909
5910
0
      switch (iframe->frame.hd.type) {
5911
0
      case NGHTTP2_HEADERS:
5912
0
        if (iframe->padlen == 0 &&
5913
0
            (iframe->frame.hd.flags & NGHTTP2_FLAG_PADDED)) {
5914
0
          pri_fieldlen = nghttp2_frame_priority_len(iframe->frame.hd.flags);
5915
0
          padlen = inbound_frame_compute_pad(iframe);
5916
0
          if (padlen < 0 ||
5917
0
              (size_t)padlen + pri_fieldlen > 1 + iframe->payloadleft) {
5918
0
            rv = nghttp2_session_terminate_session_with_reason(
5919
0
                session, NGHTTP2_PROTOCOL_ERROR, "HEADERS: invalid padding");
5920
0
            if (nghttp2_is_fatal(rv)) {
5921
0
              return rv;
5922
0
            }
5923
0
            return (ssize_t)inlen;
5924
0
          }
5925
0
          iframe->frame.headers.padlen = (size_t)padlen;
5926
5927
0
          if (pri_fieldlen > 0) {
5928
0
            if (iframe->payloadleft < pri_fieldlen) {
5929
0
              busy = 1;
5930
0
              iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
5931
0
              break;
5932
0
            }
5933
0
            iframe->state = NGHTTP2_IB_READ_NBYTE;
5934
0
            inbound_frame_set_mark(iframe, pri_fieldlen);
5935
0
            break;
5936
0
          } else {
5937
            /* Truncate buffers used for padding spec */
5938
0
            inbound_frame_set_mark(iframe, 0);
5939
0
          }
5940
0
        }
5941
5942
0
        rv = session_process_headers_frame(session);
5943
0
        if (nghttp2_is_fatal(rv)) {
5944
0
          return rv;
5945
0
        }
5946
5947
0
        busy = 1;
5948
5949
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
5950
0
          return (ssize_t)inlen;
5951
0
        }
5952
5953
0
        if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
5954
0
          rv = nghttp2_session_add_rst_stream(
5955
0
              session, iframe->frame.hd.stream_id, NGHTTP2_INTERNAL_ERROR);
5956
0
          if (nghttp2_is_fatal(rv)) {
5957
0
            return rv;
5958
0
          }
5959
0
          iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK;
5960
0
          break;
5961
0
        }
5962
5963
0
        if (rv == NGHTTP2_ERR_IGN_HEADER_BLOCK) {
5964
0
          iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK;
5965
0
          break;
5966
0
        }
5967
5968
0
        iframe->state = NGHTTP2_IB_READ_HEADER_BLOCK;
5969
5970
0
        break;
5971
0
      case NGHTTP2_PRIORITY:
5972
0
        rv = session_process_priority_frame(session);
5973
0
        if (nghttp2_is_fatal(rv)) {
5974
0
          return rv;
5975
0
        }
5976
5977
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
5978
0
          return (ssize_t)inlen;
5979
0
        }
5980
5981
0
        session_inbound_frame_reset(session);
5982
5983
0
        break;
5984
0
      case NGHTTP2_RST_STREAM:
5985
0
        rv = session_process_rst_stream_frame(session);
5986
0
        if (nghttp2_is_fatal(rv)) {
5987
0
          return rv;
5988
0
        }
5989
5990
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
5991
0
          return (ssize_t)inlen;
5992
0
        }
5993
5994
0
        session_inbound_frame_reset(session);
5995
5996
0
        break;
5997
0
      case NGHTTP2_PUSH_PROMISE:
5998
0
        if (iframe->padlen == 0 &&
5999
0
            (iframe->frame.hd.flags & NGHTTP2_FLAG_PADDED)) {
6000
0
          padlen = inbound_frame_compute_pad(iframe);
6001
0
          if (padlen < 0 || (size_t)padlen + 4 /* promised stream id */
6002
0
                                > 1 + iframe->payloadleft) {
6003
0
            rv = nghttp2_session_terminate_session_with_reason(
6004
0
                session, NGHTTP2_PROTOCOL_ERROR,
6005
0
                "PUSH_PROMISE: invalid padding");
6006
0
            if (nghttp2_is_fatal(rv)) {
6007
0
              return rv;
6008
0
            }
6009
0
            return (ssize_t)inlen;
6010
0
          }
6011
6012
0
          iframe->frame.push_promise.padlen = (size_t)padlen;
6013
6014
0
          if (iframe->payloadleft < 4) {
6015
0
            busy = 1;
6016
0
            iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
6017
0
            break;
6018
0
          }
6019
6020
0
          iframe->state = NGHTTP2_IB_READ_NBYTE;
6021
6022
0
          inbound_frame_set_mark(iframe, 4);
6023
6024
0
          break;
6025
0
        }
6026
6027
0
        rv = session_process_push_promise_frame(session);
6028
0
        if (nghttp2_is_fatal(rv)) {
6029
0
          return rv;
6030
0
        }
6031
6032
0
        busy = 1;
6033
6034
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6035
0
          return (ssize_t)inlen;
6036
0
        }
6037
6038
0
        if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
6039
0
          rv = nghttp2_session_add_rst_stream(
6040
0
              session, iframe->frame.push_promise.promised_stream_id,
6041
0
              NGHTTP2_INTERNAL_ERROR);
6042
0
          if (nghttp2_is_fatal(rv)) {
6043
0
            return rv;
6044
0
          }
6045
0
          iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK;
6046
0
          break;
6047
0
        }
6048
6049
0
        if (rv == NGHTTP2_ERR_IGN_HEADER_BLOCK) {
6050
0
          iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK;
6051
0
          break;
6052
0
        }
6053
6054
0
        iframe->state = NGHTTP2_IB_READ_HEADER_BLOCK;
6055
6056
0
        break;
6057
0
      case NGHTTP2_PING:
6058
0
        rv = session_process_ping_frame(session);
6059
0
        if (nghttp2_is_fatal(rv)) {
6060
0
          return rv;
6061
0
        }
6062
6063
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6064
0
          return (ssize_t)inlen;
6065
0
        }
6066
6067
0
        session_inbound_frame_reset(session);
6068
6069
0
        break;
6070
0
      case NGHTTP2_GOAWAY: {
6071
0
        size_t debuglen;
6072
6073
        /* 8 is Last-stream-ID + Error Code */
6074
0
        debuglen = iframe->frame.hd.length - 8;
6075
6076
0
        if (debuglen > 0) {
6077
0
          iframe->raw_lbuf = nghttp2_mem_malloc(mem, debuglen);
6078
6079
0
          if (iframe->raw_lbuf == NULL) {
6080
0
            return NGHTTP2_ERR_NOMEM;
6081
0
          }
6082
6083
0
          nghttp2_buf_wrap_init(&iframe->lbuf, iframe->raw_lbuf, debuglen);
6084
0
        }
6085
6086
0
        busy = 1;
6087
6088
0
        iframe->state = NGHTTP2_IB_READ_GOAWAY_DEBUG;
6089
6090
0
        break;
6091
0
      }
6092
0
      case NGHTTP2_WINDOW_UPDATE:
6093
0
        rv = session_process_window_update_frame(session);
6094
0
        if (nghttp2_is_fatal(rv)) {
6095
0
          return rv;
6096
0
        }
6097
6098
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6099
0
          return (ssize_t)inlen;
6100
0
        }
6101
6102
0
        session_inbound_frame_reset(session);
6103
6104
0
        break;
6105
0
      case NGHTTP2_ALTSVC: {
6106
0
        size_t origin_len;
6107
6108
0
        origin_len = nghttp2_get_uint16(iframe->sbuf.pos);
6109
6110
0
        DEBUGF("recv: origin_len=%zu\n", origin_len);
6111
6112
0
        if (origin_len > iframe->payloadleft) {
6113
0
          busy = 1;
6114
0
          iframe->state = NGHTTP2_IB_FRAME_SIZE_ERROR;
6115
0
          break;
6116
0
        }
6117
6118
0
        if (iframe->frame.hd.length > 2) {
6119
0
          iframe->raw_lbuf =
6120
0
              nghttp2_mem_malloc(mem, iframe->frame.hd.length - 2);
6121
6122
0
          if (iframe->raw_lbuf == NULL) {
6123
0
            return NGHTTP2_ERR_NOMEM;
6124
0
          }
6125
6126
0
          nghttp2_buf_wrap_init(&iframe->lbuf, iframe->raw_lbuf,
6127
0
                                iframe->frame.hd.length);
6128
0
        }
6129
6130
0
        busy = 1;
6131
6132
0
        iframe->state = NGHTTP2_IB_READ_ALTSVC_PAYLOAD;
6133
6134
0
        break;
6135
0
      }
6136
0
      default:
6137
        /* This is unknown frame */
6138
0
        session_inbound_frame_reset(session);
6139
6140
0
        break;
6141
0
      }
6142
0
      break;
6143
0
    case NGHTTP2_IB_READ_HEADER_BLOCK:
6144
0
    case NGHTTP2_IB_IGN_HEADER_BLOCK: {
6145
0
      ssize_t data_readlen;
6146
0
      size_t trail_padlen;
6147
0
      int final;
6148
#ifdef DEBUGBUILD
6149
      if (iframe->state == NGHTTP2_IB_READ_HEADER_BLOCK) {
6150
        DEBUGF("recv: [IB_READ_HEADER_BLOCK]\n");
6151
      } else {
6152
        DEBUGF("recv: [IB_IGN_HEADER_BLOCK]\n");
6153
      }
6154
#endif /* DEBUGBUILD */
6155
6156
0
      readlen = inbound_frame_payload_readlen(iframe, in, last);
6157
6158
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6159
0
             iframe->payloadleft - readlen);
6160
6161
0
      data_readlen = inbound_frame_effective_readlen(
6162
0
          iframe, iframe->payloadleft - readlen, readlen);
6163
6164
0
      if (data_readlen == -1) {
6165
        /* everything is padding */
6166
0
        data_readlen = 0;
6167
0
      }
6168
6169
0
      trail_padlen = nghttp2_frame_trail_padlen(&iframe->frame, iframe->padlen);
6170
6171
0
      final = (iframe->frame.hd.flags & NGHTTP2_FLAG_END_HEADERS) &&
6172
0
              iframe->payloadleft - (size_t)data_readlen == trail_padlen;
6173
6174
0
      if (data_readlen > 0 || (data_readlen == 0 && final)) {
6175
0
        size_t hd_proclen = 0;
6176
6177
0
        DEBUGF("recv: block final=%d\n", final);
6178
6179
0
        rv =
6180
0
            inflate_header_block(session, &iframe->frame, &hd_proclen,
6181
0
                                 (uint8_t *)in, (size_t)data_readlen, final,
6182
0
                                 iframe->state == NGHTTP2_IB_READ_HEADER_BLOCK);
6183
6184
0
        if (nghttp2_is_fatal(rv)) {
6185
0
          return rv;
6186
0
        }
6187
6188
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6189
0
          return (ssize_t)inlen;
6190
0
        }
6191
6192
0
        if (rv == NGHTTP2_ERR_PAUSE) {
6193
0
          in += hd_proclen;
6194
0
          iframe->payloadleft -= hd_proclen;
6195
6196
0
          return in - first;
6197
0
        }
6198
6199
0
        if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
6200
          /* The application says no more headers. We decompress the
6201
             rest of the header block but not invoke on_header_callback
6202
             and on_frame_recv_callback. */
6203
0
          in += hd_proclen;
6204
0
          iframe->payloadleft -= hd_proclen;
6205
6206
          /* Use promised stream ID for PUSH_PROMISE */
6207
0
          rv = nghttp2_session_add_rst_stream(
6208
0
              session,
6209
0
              iframe->frame.hd.type == NGHTTP2_PUSH_PROMISE
6210
0
                  ? iframe->frame.push_promise.promised_stream_id
6211
0
                  : iframe->frame.hd.stream_id,
6212
0
              NGHTTP2_INTERNAL_ERROR);
6213
0
          if (nghttp2_is_fatal(rv)) {
6214
0
            return rv;
6215
0
          }
6216
0
          busy = 1;
6217
0
          iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK;
6218
0
          break;
6219
0
        }
6220
6221
0
        in += readlen;
6222
0
        iframe->payloadleft -= readlen;
6223
6224
0
        if (rv == NGHTTP2_ERR_HEADER_COMP) {
6225
          /* GOAWAY is already issued */
6226
0
          if (iframe->payloadleft == 0) {
6227
0
            session_inbound_frame_reset(session);
6228
0
          } else {
6229
0
            busy = 1;
6230
0
            iframe->state = NGHTTP2_IB_IGN_PAYLOAD;
6231
0
          }
6232
0
          break;
6233
0
        }
6234
0
      } else {
6235
0
        in += readlen;
6236
0
        iframe->payloadleft -= readlen;
6237
0
      }
6238
6239
0
      if (iframe->payloadleft) {
6240
0
        break;
6241
0
      }
6242
6243
0
      if ((iframe->frame.hd.flags & NGHTTP2_FLAG_END_HEADERS) == 0) {
6244
6245
0
        inbound_frame_set_mark(iframe, NGHTTP2_FRAME_HDLEN);
6246
6247
0
        iframe->padlen = 0;
6248
6249
0
        if (iframe->state == NGHTTP2_IB_READ_HEADER_BLOCK) {
6250
0
          iframe->state = NGHTTP2_IB_EXPECT_CONTINUATION;
6251
0
        } else {
6252
0
          iframe->state = NGHTTP2_IB_IGN_CONTINUATION;
6253
0
        }
6254
0
      } else {
6255
0
        if (iframe->state == NGHTTP2_IB_READ_HEADER_BLOCK) {
6256
0
          rv = session_after_header_block_received(session);
6257
0
          if (nghttp2_is_fatal(rv)) {
6258
0
            return rv;
6259
0
          }
6260
0
        }
6261
0
        session_inbound_frame_reset(session);
6262
0
      }
6263
0
      break;
6264
0
    }
6265
0
    case NGHTTP2_IB_IGN_PAYLOAD:
6266
0
      DEBUGF("recv: [IB_IGN_PAYLOAD]\n");
6267
6268
0
      readlen = inbound_frame_payload_readlen(iframe, in, last);
6269
0
      iframe->payloadleft -= readlen;
6270
0
      in += readlen;
6271
6272
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6273
0
             iframe->payloadleft);
6274
6275
0
      if (iframe->payloadleft) {
6276
0
        break;
6277
0
      }
6278
6279
0
      switch (iframe->frame.hd.type) {
6280
0
      case NGHTTP2_HEADERS:
6281
0
      case NGHTTP2_PUSH_PROMISE:
6282
0
      case NGHTTP2_CONTINUATION:
6283
        /* Mark inflater bad so that we won't perform further decoding */
6284
0
        session->hd_inflater.ctx.bad = 1;
6285
0
        break;
6286
0
      default:
6287
0
        break;
6288
0
      }
6289
6290
0
      session_inbound_frame_reset(session);
6291
6292
0
      break;
6293
0
    case NGHTTP2_IB_FRAME_SIZE_ERROR:
6294
0
      DEBUGF("recv: [IB_FRAME_SIZE_ERROR]\n");
6295
6296
0
      rv = session_handle_frame_size_error(session);
6297
0
      if (nghttp2_is_fatal(rv)) {
6298
0
        return rv;
6299
0
      }
6300
6301
0
      assert(iframe->state == NGHTTP2_IB_IGN_ALL);
6302
6303
0
      return (ssize_t)inlen;
6304
0
    case NGHTTP2_IB_READ_SETTINGS:
6305
0
      DEBUGF("recv: [IB_READ_SETTINGS]\n");
6306
6307
0
      readlen = inbound_frame_buf_read(iframe, in, last);
6308
0
      iframe->payloadleft -= readlen;
6309
0
      in += readlen;
6310
6311
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6312
0
             iframe->payloadleft);
6313
6314
0
      if (nghttp2_buf_mark_avail(&iframe->sbuf)) {
6315
0
        break;
6316
0
      }
6317
6318
0
      if (readlen > 0) {
6319
0
        inbound_frame_set_settings_entry(iframe);
6320
0
      }
6321
0
      if (iframe->payloadleft) {
6322
0
        inbound_frame_set_mark(iframe, NGHTTP2_FRAME_SETTINGS_ENTRY_LENGTH);
6323
0
        break;
6324
0
      }
6325
6326
0
      rv = session_process_settings_frame(session);
6327
6328
0
      if (nghttp2_is_fatal(rv)) {
6329
0
        return rv;
6330
0
      }
6331
6332
0
      if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6333
0
        return (ssize_t)inlen;
6334
0
      }
6335
6336
0
      session_inbound_frame_reset(session);
6337
6338
0
      break;
6339
0
    case NGHTTP2_IB_READ_GOAWAY_DEBUG:
6340
0
      DEBUGF("recv: [IB_READ_GOAWAY_DEBUG]\n");
6341
6342
0
      readlen = inbound_frame_payload_readlen(iframe, in, last);
6343
6344
0
      if (readlen > 0) {
6345
0
        iframe->lbuf.last = nghttp2_cpymem(iframe->lbuf.last, in, readlen);
6346
6347
0
        iframe->payloadleft -= readlen;
6348
0
        in += readlen;
6349
0
      }
6350
6351
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6352
0
             iframe->payloadleft);
6353
6354
0
      if (iframe->payloadleft) {
6355
0
        assert(nghttp2_buf_avail(&iframe->lbuf) > 0);
6356
6357
0
        break;
6358
0
      }
6359
6360
0
      rv = session_process_goaway_frame(session);
6361
6362
0
      if (nghttp2_is_fatal(rv)) {
6363
0
        return rv;
6364
0
      }
6365
6366
0
      if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6367
0
        return (ssize_t)inlen;
6368
0
      }
6369
6370
0
      session_inbound_frame_reset(session);
6371
6372
0
      break;
6373
0
    case NGHTTP2_IB_EXPECT_CONTINUATION:
6374
0
    case NGHTTP2_IB_IGN_CONTINUATION:
6375
#ifdef DEBUGBUILD
6376
      if (iframe->state == NGHTTP2_IB_EXPECT_CONTINUATION) {
6377
        fprintf(stderr, "recv: [IB_EXPECT_CONTINUATION]\n");
6378
      } else {
6379
        fprintf(stderr, "recv: [IB_IGN_CONTINUATION]\n");
6380
      }
6381
#endif /* DEBUGBUILD */
6382
6383
0
      readlen = inbound_frame_buf_read(iframe, in, last);
6384
0
      in += readlen;
6385
6386
0
      if (nghttp2_buf_mark_avail(&iframe->sbuf)) {
6387
0
        return in - first;
6388
0
      }
6389
6390
0
      nghttp2_frame_unpack_frame_hd(&cont_hd, iframe->sbuf.pos);
6391
0
      iframe->payloadleft = cont_hd.length;
6392
6393
0
      DEBUGF("recv: payloadlen=%zu, type=%u, flags=0x%02x, stream_id=%d\n",
6394
0
             cont_hd.length, cont_hd.type, cont_hd.flags, cont_hd.stream_id);
6395
6396
0
      if (cont_hd.type != NGHTTP2_CONTINUATION ||
6397
0
          cont_hd.stream_id != iframe->frame.hd.stream_id) {
6398
0
        DEBUGF("recv: expected stream_id=%d, type=%d, but got stream_id=%d, "
6399
0
               "type=%u\n",
6400
0
               iframe->frame.hd.stream_id, NGHTTP2_CONTINUATION,
6401
0
               cont_hd.stream_id, cont_hd.type);
6402
0
        rv = nghttp2_session_terminate_session_with_reason(
6403
0
            session, NGHTTP2_PROTOCOL_ERROR,
6404
0
            "unexpected non-CONTINUATION frame or stream_id is invalid");
6405
0
        if (nghttp2_is_fatal(rv)) {
6406
0
          return rv;
6407
0
        }
6408
6409
0
        return (ssize_t)inlen;
6410
0
      }
6411
6412
      /* CONTINUATION won't bear NGHTTP2_PADDED flag */
6413
6414
0
      iframe->frame.hd.flags = (uint8_t)(
6415
0
          iframe->frame.hd.flags | (cont_hd.flags & NGHTTP2_FLAG_END_HEADERS));
6416
0
      iframe->frame.hd.length += cont_hd.length;
6417
6418
0
      busy = 1;
6419
6420
0
      if (iframe->state == NGHTTP2_IB_EXPECT_CONTINUATION) {
6421
0
        iframe->state = NGHTTP2_IB_READ_HEADER_BLOCK;
6422
6423
0
        rv = session_call_on_begin_frame(session, &cont_hd);
6424
6425
0
        if (nghttp2_is_fatal(rv)) {
6426
0
          return rv;
6427
0
        }
6428
0
      } else {
6429
0
        iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK;
6430
0
      }
6431
6432
0
      break;
6433
0
    case NGHTTP2_IB_READ_PAD_DATA:
6434
0
      DEBUGF("recv: [IB_READ_PAD_DATA]\n");
6435
6436
0
      readlen = inbound_frame_buf_read(iframe, in, last);
6437
0
      in += readlen;
6438
0
      iframe->payloadleft -= readlen;
6439
6440
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu, left=%zu\n", readlen,
6441
0
             iframe->payloadleft, nghttp2_buf_mark_avail(&iframe->sbuf));
6442
6443
0
      if (nghttp2_buf_mark_avail(&iframe->sbuf)) {
6444
0
        return in - first;
6445
0
      }
6446
6447
      /* Pad Length field is subject to flow control */
6448
0
      rv = nghttp2_session_update_recv_connection_window_size(session, readlen);
6449
0
      if (nghttp2_is_fatal(rv)) {
6450
0
        return rv;
6451
0
      }
6452
6453
0
      if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6454
0
        return (ssize_t)inlen;
6455
0
      }
6456
6457
      /* Pad Length field is consumed immediately */
6458
0
      rv =
6459
0
          nghttp2_session_consume(session, iframe->frame.hd.stream_id, readlen);
6460
6461
0
      if (nghttp2_is_fatal(rv)) {
6462
0
        return rv;
6463
0
      }
6464
6465
0
      if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6466
0
        return (ssize_t)inlen;
6467
0
      }
6468
6469
0
      stream = nghttp2_session_get_stream(session, iframe->frame.hd.stream_id);
6470
0
      if (stream) {
6471
0
        rv = nghttp2_session_update_recv_stream_window_size(
6472
0
            session, stream, readlen,
6473
0
            iframe->payloadleft ||
6474
0
                (iframe->frame.hd.flags & NGHTTP2_FLAG_END_STREAM) == 0);
6475
0
        if (nghttp2_is_fatal(rv)) {
6476
0
          return rv;
6477
0
        }
6478
0
      }
6479
6480
0
      busy = 1;
6481
6482
0
      padlen = inbound_frame_compute_pad(iframe);
6483
0
      if (padlen < 0) {
6484
0
        rv = nghttp2_session_terminate_session_with_reason(
6485
0
            session, NGHTTP2_PROTOCOL_ERROR, "DATA: invalid padding");
6486
0
        if (nghttp2_is_fatal(rv)) {
6487
0
          return rv;
6488
0
        }
6489
0
        return (ssize_t)inlen;
6490
0
      }
6491
6492
0
      iframe->frame.data.padlen = (size_t)padlen;
6493
6494
0
      iframe->state = NGHTTP2_IB_READ_DATA;
6495
6496
0
      break;
6497
0
    case NGHTTP2_IB_READ_DATA:
6498
0
      stream = nghttp2_session_get_stream(session, iframe->frame.hd.stream_id);
6499
6500
0
      if (!stream) {
6501
0
        busy = 1;
6502
0
        iframe->state = NGHTTP2_IB_IGN_DATA;
6503
0
        break;
6504
0
      }
6505
6506
0
      DEBUGF("recv: [IB_READ_DATA]\n");
6507
6508
0
      readlen = inbound_frame_payload_readlen(iframe, in, last);
6509
0
      iframe->payloadleft -= readlen;
6510
0
      in += readlen;
6511
6512
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6513
0
             iframe->payloadleft);
6514
6515
0
      if (readlen > 0) {
6516
0
        ssize_t data_readlen;
6517
6518
0
        rv = nghttp2_session_update_recv_connection_window_size(session,
6519
0
                                                                readlen);
6520
0
        if (nghttp2_is_fatal(rv)) {
6521
0
          return rv;
6522
0
        }
6523
6524
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6525
0
          return (ssize_t)inlen;
6526
0
        }
6527
6528
0
        rv = nghttp2_session_update_recv_stream_window_size(
6529
0
            session, stream, readlen,
6530
0
            iframe->payloadleft ||
6531
0
                (iframe->frame.hd.flags & NGHTTP2_FLAG_END_STREAM) == 0);
6532
0
        if (nghttp2_is_fatal(rv)) {
6533
0
          return rv;
6534
0
        }
6535
6536
0
        data_readlen = inbound_frame_effective_readlen(
6537
0
            iframe, iframe->payloadleft, readlen);
6538
6539
0
        if (data_readlen == -1) {
6540
          /* everything is padding */
6541
0
          data_readlen = 0;
6542
0
        }
6543
6544
0
        padlen = (ssize_t)readlen - data_readlen;
6545
6546
0
        if (padlen > 0) {
6547
          /* Padding is considered as "consumed" immediately */
6548
0
          rv = nghttp2_session_consume(session, iframe->frame.hd.stream_id,
6549
0
                                       (size_t)padlen);
6550
6551
0
          if (nghttp2_is_fatal(rv)) {
6552
0
            return rv;
6553
0
          }
6554
6555
0
          if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6556
0
            return (ssize_t)inlen;
6557
0
          }
6558
0
        }
6559
6560
0
        DEBUGF("recv: data_readlen=%zd\n", data_readlen);
6561
6562
0
        if (data_readlen > 0) {
6563
0
          if (session_enforce_http_messaging(session)) {
6564
0
            if (nghttp2_http_on_data_chunk(stream, (size_t)data_readlen) != 0) {
6565
0
              if (session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE) {
6566
                /* Consume all data for connection immediately here */
6567
0
                rv = session_update_connection_consumed_size(
6568
0
                    session, (size_t)data_readlen);
6569
6570
0
                if (nghttp2_is_fatal(rv)) {
6571
0
                  return rv;
6572
0
                }
6573
6574
0
                if (iframe->state == NGHTTP2_IB_IGN_DATA) {
6575
0
                  return (ssize_t)inlen;
6576
0
                }
6577
0
              }
6578
6579
0
              rv = nghttp2_session_add_rst_stream(
6580
0
                  session, iframe->frame.hd.stream_id, NGHTTP2_PROTOCOL_ERROR);
6581
0
              if (nghttp2_is_fatal(rv)) {
6582
0
                return rv;
6583
0
              }
6584
0
              busy = 1;
6585
0
              iframe->state = NGHTTP2_IB_IGN_DATA;
6586
0
              break;
6587
0
            }
6588
0
          }
6589
0
          if (session->callbacks.on_data_chunk_recv_callback) {
6590
0
            rv = session->callbacks.on_data_chunk_recv_callback(
6591
0
                session, iframe->frame.hd.flags, iframe->frame.hd.stream_id,
6592
0
                in - readlen, (size_t)data_readlen, session->user_data);
6593
0
            if (rv == NGHTTP2_ERR_PAUSE) {
6594
0
              return in - first;
6595
0
            }
6596
6597
0
            if (nghttp2_is_fatal(rv)) {
6598
0
              return NGHTTP2_ERR_CALLBACK_FAILURE;
6599
0
            }
6600
0
          }
6601
0
        }
6602
0
      }
6603
6604
0
      if (iframe->payloadleft) {
6605
0
        break;
6606
0
      }
6607
6608
0
      rv = session_process_data_frame(session);
6609
0
      if (nghttp2_is_fatal(rv)) {
6610
0
        return rv;
6611
0
      }
6612
6613
0
      session_inbound_frame_reset(session);
6614
6615
0
      break;
6616
0
    case NGHTTP2_IB_IGN_DATA:
6617
0
      DEBUGF("recv: [IB_IGN_DATA]\n");
6618
6619
0
      readlen = inbound_frame_payload_readlen(iframe, in, last);
6620
0
      iframe->payloadleft -= readlen;
6621
0
      in += readlen;
6622
6623
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6624
0
             iframe->payloadleft);
6625
6626
0
      if (readlen > 0) {
6627
        /* Update connection-level flow control window for ignored
6628
           DATA frame too */
6629
0
        rv = nghttp2_session_update_recv_connection_window_size(session,
6630
0
                                                                readlen);
6631
0
        if (nghttp2_is_fatal(rv)) {
6632
0
          return rv;
6633
0
        }
6634
6635
0
        if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6636
0
          return (ssize_t)inlen;
6637
0
        }
6638
6639
0
        if (session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE) {
6640
6641
          /* Ignored DATA is considered as "consumed" immediately. */
6642
0
          rv = session_update_connection_consumed_size(session, readlen);
6643
6644
0
          if (nghttp2_is_fatal(rv)) {
6645
0
            return rv;
6646
0
          }
6647
6648
0
          if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6649
0
            return (ssize_t)inlen;
6650
0
          }
6651
0
        }
6652
0
      }
6653
6654
0
      if (iframe->payloadleft) {
6655
0
        break;
6656
0
      }
6657
6658
0
      session_inbound_frame_reset(session);
6659
6660
0
      break;
6661
0
    case NGHTTP2_IB_IGN_ALL:
6662
0
      return (ssize_t)inlen;
6663
0
    case NGHTTP2_IB_READ_EXTENSION_PAYLOAD:
6664
0
      DEBUGF("recv: [IB_READ_EXTENSION_PAYLOAD]\n");
6665
6666
0
      readlen = inbound_frame_payload_readlen(iframe, in, last);
6667
0
      iframe->payloadleft -= readlen;
6668
0
      in += readlen;
6669
6670
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6671
0
             iframe->payloadleft);
6672
6673
0
      if (readlen > 0) {
6674
0
        rv = session_call_on_extension_chunk_recv_callback(
6675
0
            session, in - readlen, readlen);
6676
0
        if (nghttp2_is_fatal(rv)) {
6677
0
          return rv;
6678
0
        }
6679
6680
0
        if (rv != 0) {
6681
0
          busy = 1;
6682
6683
0
          iframe->state = NGHTTP2_IB_IGN_PAYLOAD;
6684
6685
0
          break;
6686
0
        }
6687
0
      }
6688
6689
0
      if (iframe->payloadleft > 0) {
6690
0
        break;
6691
0
      }
6692
6693
0
      rv = session_process_extension_frame(session);
6694
0
      if (nghttp2_is_fatal(rv)) {
6695
0
        return rv;
6696
0
      }
6697
6698
0
      session_inbound_frame_reset(session);
6699
6700
0
      break;
6701
0
    case NGHTTP2_IB_READ_ALTSVC_PAYLOAD:
6702
0
      DEBUGF("recv: [IB_READ_ALTSVC_PAYLOAD]\n");
6703
6704
0
      readlen = inbound_frame_payload_readlen(iframe, in, last);
6705
0
      if (readlen > 0) {
6706
0
        iframe->lbuf.last = nghttp2_cpymem(iframe->lbuf.last, in, readlen);
6707
6708
0
        iframe->payloadleft -= readlen;
6709
0
        in += readlen;
6710
0
      }
6711
6712
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6713
0
             iframe->payloadleft);
6714
6715
0
      if (iframe->payloadleft) {
6716
0
        assert(nghttp2_buf_avail(&iframe->lbuf) > 0);
6717
6718
0
        break;
6719
0
      }
6720
6721
0
      rv = session_process_altsvc_frame(session);
6722
0
      if (nghttp2_is_fatal(rv)) {
6723
0
        return rv;
6724
0
      }
6725
6726
0
      session_inbound_frame_reset(session);
6727
6728
0
      break;
6729
0
    case NGHTTP2_IB_READ_ORIGIN_PAYLOAD:
6730
0
      DEBUGF("recv: [IB_READ_ORIGIN_PAYLOAD]\n");
6731
6732
0
      readlen = inbound_frame_payload_readlen(iframe, in, last);
6733
6734
0
      if (readlen > 0) {
6735
0
        iframe->lbuf.last = nghttp2_cpymem(iframe->lbuf.last, in, readlen);
6736
6737
0
        iframe->payloadleft -= readlen;
6738
0
        in += readlen;
6739
0
      }
6740
6741
0
      DEBUGF("recv: readlen=%zu, payloadleft=%zu\n", readlen,
6742
0
             iframe->payloadleft);
6743
6744
0
      if (iframe->payloadleft) {
6745
0
        assert(nghttp2_buf_avail(&iframe->lbuf) > 0);
6746
6747
0
        break;
6748
0
      }
6749
6750
0
      rv = session_process_origin_frame(session);
6751
6752
0
      if (nghttp2_is_fatal(rv)) {
6753
0
        return rv;
6754
0
      }
6755
6756
0
      if (iframe->state == NGHTTP2_IB_IGN_ALL) {
6757
0
        return (ssize_t)inlen;
6758
0
      }
6759
6760
0
      session_inbound_frame_reset(session);
6761
6762
0
      break;
6763
0
    }
6764
6765
0
    if (!busy && in == last) {
6766
0
      break;
6767
0
    }
6768
6769
0
    busy = 0;
6770
0
  }
6771
6772
0
  assert(in == last);
6773
6774
0
  return in - first;
6775
0
}
6776
6777
0
int nghttp2_session_recv(nghttp2_session *session) {
6778
0
  uint8_t buf[NGHTTP2_INBOUND_BUFFER_LENGTH];
6779
0
  while (1) {
6780
0
    ssize_t readlen;
6781
0
    readlen = session_recv(session, buf, sizeof(buf));
6782
0
    if (readlen > 0) {
6783
0
      ssize_t proclen = nghttp2_session_mem_recv(session, buf, (size_t)readlen);
6784
0
      if (proclen < 0) {
6785
0
        return (int)proclen;
6786
0
      }
6787
0
      assert(proclen == readlen);
6788
0
    } else if (readlen == 0 || readlen == NGHTTP2_ERR_WOULDBLOCK) {
6789
0
      return 0;
6790
0
    } else if (readlen == NGHTTP2_ERR_EOF) {
6791
0
      return NGHTTP2_ERR_EOF;
6792
0
    } else if (readlen < 0) {
6793
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
6794
0
    }
6795
0
  }
6796
0
}
6797
6798
/*
6799
 * Returns the number of active streams, which includes streams in
6800
 * reserved state.
6801
 */
6802
0
static size_t session_get_num_active_streams(nghttp2_session *session) {
6803
0
  return nghttp2_map_size(&session->streams) - session->num_closed_streams -
6804
0
         session->num_idle_streams;
6805
0
}
6806
6807
0
int nghttp2_session_want_read(nghttp2_session *session) {
6808
0
  size_t num_active_streams;
6809
6810
  /* If this flag is set, we don't want to read. The application
6811
     should drop the connection. */
6812
0
  if (session->goaway_flags & NGHTTP2_GOAWAY_TERM_SENT) {
6813
0
    return 0;
6814
0
  }
6815
6816
0
  num_active_streams = session_get_num_active_streams(session);
6817
6818
  /* Unless termination GOAWAY is sent or received, we always want to
6819
     read incoming frames. */
6820
6821
0
  if (num_active_streams > 0) {
6822
0
    return 1;
6823
0
  }
6824
6825
  /* If there is no active streams and GOAWAY has been sent or
6826
     received, we are done with this session. */
6827
0
  return (session->goaway_flags &
6828
0
          (NGHTTP2_GOAWAY_SENT | NGHTTP2_GOAWAY_RECV)) == 0;
6829
0
}
6830
6831
0
int nghttp2_session_want_write(nghttp2_session *session) {
6832
  /* If these flag is set, we don't want to write any data. The
6833
     application should drop the connection. */
6834
0
  if (session->goaway_flags & NGHTTP2_GOAWAY_TERM_SENT) {
6835
0
    return 0;
6836
0
  }
6837
6838
  /*
6839
   * Unless termination GOAWAY is sent or received, we want to write
6840
   * frames if there is pending ones. If pending frame is request/push
6841
   * response HEADERS and concurrent stream limit is reached, we don't
6842
   * want to write them.
6843
   */
6844
0
  return session->aob.item || nghttp2_outbound_queue_top(&session->ob_urgent) ||
6845
0
         nghttp2_outbound_queue_top(&session->ob_reg) ||
6846
0
         (!nghttp2_pq_empty(&session->root.obq) &&
6847
0
          session->remote_window_size > 0) ||
6848
0
         (nghttp2_outbound_queue_top(&session->ob_syn) &&
6849
0
          !session_is_outgoing_concurrent_streams_max(session));
6850
0
}
6851
6852
int nghttp2_session_add_ping(nghttp2_session *session, uint8_t flags,
6853
0
                             const uint8_t *opaque_data) {
6854
0
  int rv;
6855
0
  nghttp2_outbound_item *item;
6856
0
  nghttp2_frame *frame;
6857
0
  nghttp2_mem *mem;
6858
6859
0
  mem = &session->mem;
6860
6861
0
  if ((flags & NGHTTP2_FLAG_ACK) &&
6862
0
      session->obq_flood_counter_ >= session->max_outbound_ack) {
6863
0
    return NGHTTP2_ERR_FLOODED;
6864
0
  }
6865
6866
0
  item = nghttp2_mem_malloc(mem, sizeof(nghttp2_outbound_item));
6867
0
  if (item == NULL) {
6868
0
    return NGHTTP2_ERR_NOMEM;
6869
0
  }
6870
6871
0
  nghttp2_outbound_item_init(item);
6872
6873
0
  frame = &item->frame;
6874
6875
0
  nghttp2_frame_ping_init(&frame->ping, flags, opaque_data);
6876
6877
0
  rv = nghttp2_session_add_item(session, item);
6878
6879
0
  if (rv != 0) {
6880
0
    nghttp2_frame_ping_free(&frame->ping);
6881
0
    nghttp2_mem_free(mem, item);
6882
0
    return rv;
6883
0
  }
6884
6885
0
  if (flags & NGHTTP2_FLAG_ACK) {
6886
0
    ++session->obq_flood_counter_;
6887
0
  }
6888
6889
0
  return 0;
6890
0
}
6891
6892
int nghttp2_session_add_goaway(nghttp2_session *session, int32_t last_stream_id,
6893
                               uint32_t error_code, const uint8_t *opaque_data,
6894
0
                               size_t opaque_data_len, uint8_t aux_flags) {
6895
0
  int rv;
6896
0
  nghttp2_outbound_item *item;
6897
0
  nghttp2_frame *frame;
6898
0
  uint8_t *opaque_data_copy = NULL;
6899
0
  nghttp2_goaway_aux_data *aux_data;
6900
0
  nghttp2_mem *mem;
6901
6902
0
  mem = &session->mem;
6903
6904
0
  if (nghttp2_session_is_my_stream_id(session, last_stream_id)) {
6905
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
6906
0
  }
6907
6908
0
  if (opaque_data_len) {
6909
0
    if (opaque_data_len + 8 > NGHTTP2_MAX_PAYLOADLEN) {
6910
0
      return NGHTTP2_ERR_INVALID_ARGUMENT;
6911
0
    }
6912
0
    opaque_data_copy = nghttp2_mem_malloc(mem, opaque_data_len);
6913
0
    if (opaque_data_copy == NULL) {
6914
0
      return NGHTTP2_ERR_NOMEM;
6915
0
    }
6916
0
    memcpy(opaque_data_copy, opaque_data, opaque_data_len);
6917
0
  }
6918
6919
0
  item = nghttp2_mem_malloc(mem, sizeof(nghttp2_outbound_item));
6920
0
  if (item == NULL) {
6921
0
    nghttp2_mem_free(mem, opaque_data_copy);
6922
0
    return NGHTTP2_ERR_NOMEM;
6923
0
  }
6924
6925
0
  nghttp2_outbound_item_init(item);
6926
6927
0
  frame = &item->frame;
6928
6929
  /* last_stream_id must not be increased from the value previously
6930
     sent */
6931
0
  last_stream_id = nghttp2_min(last_stream_id, session->local_last_stream_id);
6932
6933
0
  nghttp2_frame_goaway_init(&frame->goaway, last_stream_id, error_code,
6934
0
                            opaque_data_copy, opaque_data_len);
6935
6936
0
  aux_data = &item->aux_data.goaway;
6937
0
  aux_data->flags = aux_flags;
6938
6939
0
  rv = nghttp2_session_add_item(session, item);
6940
0
  if (rv != 0) {
6941
0
    nghttp2_frame_goaway_free(&frame->goaway, mem);
6942
0
    nghttp2_mem_free(mem, item);
6943
0
    return rv;
6944
0
  }
6945
0
  return 0;
6946
0
}
6947
6948
int nghttp2_session_add_window_update(nghttp2_session *session, uint8_t flags,
6949
                                      int32_t stream_id,
6950
0
                                      int32_t window_size_increment) {
6951
0
  int rv;
6952
0
  nghttp2_outbound_item *item;
6953
0
  nghttp2_frame *frame;
6954
0
  nghttp2_mem *mem;
6955
6956
0
  mem = &session->mem;
6957
0
  item = nghttp2_mem_malloc(mem, sizeof(nghttp2_outbound_item));
6958
0
  if (item == NULL) {
6959
0
    return NGHTTP2_ERR_NOMEM;
6960
0
  }
6961
6962
0
  nghttp2_outbound_item_init(item);
6963
6964
0
  frame = &item->frame;
6965
6966
0
  nghttp2_frame_window_update_init(&frame->window_update, flags, stream_id,
6967
0
                                   window_size_increment);
6968
6969
0
  rv = nghttp2_session_add_item(session, item);
6970
6971
0
  if (rv != 0) {
6972
0
    nghttp2_frame_window_update_free(&frame->window_update);
6973
0
    nghttp2_mem_free(mem, item);
6974
0
    return rv;
6975
0
  }
6976
0
  return 0;
6977
0
}
6978
6979
static void
6980
session_append_inflight_settings(nghttp2_session *session,
6981
0
                                 nghttp2_inflight_settings *settings) {
6982
0
  nghttp2_inflight_settings **i;
6983
6984
0
  for (i = &session->inflight_settings_head; *i; i = &(*i)->next)
6985
0
    ;
6986
6987
0
  *i = settings;
6988
0
}
6989
6990
int nghttp2_session_add_settings(nghttp2_session *session, uint8_t flags,
6991
0
                                 const nghttp2_settings_entry *iv, size_t niv) {
6992
0
  nghttp2_outbound_item *item;
6993
0
  nghttp2_frame *frame;
6994
0
  nghttp2_settings_entry *iv_copy;
6995
0
  size_t i;
6996
0
  int rv;
6997
0
  nghttp2_mem *mem;
6998
0
  nghttp2_inflight_settings *inflight_settings = NULL;
6999
7000
0
  mem = &session->mem;
7001
7002
0
  if (flags & NGHTTP2_FLAG_ACK) {
7003
0
    if (niv != 0) {
7004
0
      return NGHTTP2_ERR_INVALID_ARGUMENT;
7005
0
    }
7006
7007
0
    if (session->obq_flood_counter_ >= session->max_outbound_ack) {
7008
0
      return NGHTTP2_ERR_FLOODED;
7009
0
    }
7010
0
  }
7011
7012
0
  if (!nghttp2_iv_check(iv, niv)) {
7013
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7014
0
  }
7015
7016
0
  item = nghttp2_mem_malloc(mem, sizeof(nghttp2_outbound_item));
7017
0
  if (item == NULL) {
7018
0
    return NGHTTP2_ERR_NOMEM;
7019
0
  }
7020
7021
0
  if (niv > 0) {
7022
0
    iv_copy = nghttp2_frame_iv_copy(iv, niv, mem);
7023
0
    if (iv_copy == NULL) {
7024
0
      nghttp2_mem_free(mem, item);
7025
0
      return NGHTTP2_ERR_NOMEM;
7026
0
    }
7027
0
  } else {
7028
0
    iv_copy = NULL;
7029
0
  }
7030
7031
0
  if ((flags & NGHTTP2_FLAG_ACK) == 0) {
7032
0
    rv = inflight_settings_new(&inflight_settings, iv, niv, mem);
7033
0
    if (rv != 0) {
7034
0
      assert(nghttp2_is_fatal(rv));
7035
0
      nghttp2_mem_free(mem, iv_copy);
7036
0
      nghttp2_mem_free(mem, item);
7037
0
      return rv;
7038
0
    }
7039
0
  }
7040
7041
0
  nghttp2_outbound_item_init(item);
7042
7043
0
  frame = &item->frame;
7044
7045
0
  nghttp2_frame_settings_init(&frame->settings, flags, iv_copy, niv);
7046
0
  rv = nghttp2_session_add_item(session, item);
7047
0
  if (rv != 0) {
7048
    /* The only expected error is fatal one */
7049
0
    assert(nghttp2_is_fatal(rv));
7050
7051
0
    inflight_settings_del(inflight_settings, mem);
7052
7053
0
    nghttp2_frame_settings_free(&frame->settings, mem);
7054
0
    nghttp2_mem_free(mem, item);
7055
7056
0
    return rv;
7057
0
  }
7058
7059
0
  if (flags & NGHTTP2_FLAG_ACK) {
7060
0
    ++session->obq_flood_counter_;
7061
0
  } else {
7062
0
    session_append_inflight_settings(session, inflight_settings);
7063
0
  }
7064
7065
  /* Extract NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS and ENABLE_PUSH
7066
     here.  We use it to refuse the incoming stream and PUSH_PROMISE
7067
     with RST_STREAM. */
7068
7069
0
  for (i = niv; i > 0; --i) {
7070
0
    if (iv[i - 1].settings_id == NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS) {
7071
0
      session->pending_local_max_concurrent_stream = iv[i - 1].value;
7072
0
      break;
7073
0
    }
7074
0
  }
7075
7076
0
  for (i = niv; i > 0; --i) {
7077
0
    if (iv[i - 1].settings_id == NGHTTP2_SETTINGS_ENABLE_PUSH) {
7078
0
      session->pending_enable_push = (uint8_t)iv[i - 1].value;
7079
0
      break;
7080
0
    }
7081
0
  }
7082
7083
0
  for (i = niv; i > 0; --i) {
7084
0
    if (iv[i - 1].settings_id == NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL) {
7085
0
      session->pending_enable_connect_protocol = (uint8_t)iv[i - 1].value;
7086
0
      break;
7087
0
    }
7088
0
  }
7089
7090
0
  return 0;
7091
0
}
7092
7093
int nghttp2_session_pack_data(nghttp2_session *session, nghttp2_bufs *bufs,
7094
                              size_t datamax, nghttp2_frame *frame,
7095
                              nghttp2_data_aux_data *aux_data,
7096
0
                              nghttp2_stream *stream) {
7097
0
  int rv;
7098
0
  uint32_t data_flags;
7099
0
  ssize_t payloadlen;
7100
0
  ssize_t padded_payloadlen;
7101
0
  nghttp2_buf *buf;
7102
0
  size_t max_payloadlen;
7103
7104
0
  assert(bufs->head == bufs->cur);
7105
7106
0
  buf = &bufs->cur->buf;
7107
7108
0
  if (session->callbacks.read_length_callback) {
7109
7110
0
    payloadlen = session->callbacks.read_length_callback(
7111
0
        session, frame->hd.type, stream->stream_id, session->remote_window_size,
7112
0
        stream->remote_window_size, session->remote_settings.max_frame_size,
7113
0
        session->user_data);
7114
7115
0
    DEBUGF("send: read_length_callback=%zd\n", payloadlen);
7116
7117
0
    payloadlen = nghttp2_session_enforce_flow_control_limits(session, stream,
7118
0
                                                             payloadlen);
7119
7120
0
    DEBUGF("send: read_length_callback after flow control=%zd\n", payloadlen);
7121
7122
0
    if (payloadlen <= 0) {
7123
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
7124
0
    }
7125
7126
0
    if ((size_t)payloadlen > nghttp2_buf_avail(buf)) {
7127
      /* Resize the current buffer(s).  The reason why we do +1 for
7128
         buffer size is for possible padding field. */
7129
0
      rv = nghttp2_bufs_realloc(&session->aob.framebufs,
7130
0
                                (size_t)(NGHTTP2_FRAME_HDLEN + 1 + payloadlen));
7131
7132
0
      if (rv != 0) {
7133
0
        DEBUGF("send: realloc buffer failed rv=%d", rv);
7134
        /* If reallocation failed, old buffers are still in tact.  So
7135
           use safe limit. */
7136
0
        payloadlen = (ssize_t)datamax;
7137
7138
0
        DEBUGF("send: use safe limit payloadlen=%zd", payloadlen);
7139
0
      } else {
7140
0
        assert(&session->aob.framebufs == bufs);
7141
7142
0
        buf = &bufs->cur->buf;
7143
0
      }
7144
0
    }
7145
0
    datamax = (size_t)payloadlen;
7146
0
  }
7147
7148
  /* Current max DATA length is less then buffer chunk size */
7149
0
  assert(nghttp2_buf_avail(buf) >= datamax);
7150
7151
0
  data_flags = NGHTTP2_DATA_FLAG_NONE;
7152
0
  payloadlen = aux_data->data_prd.read_callback(
7153
0
      session, frame->hd.stream_id, buf->pos, datamax, &data_flags,
7154
0
      &aux_data->data_prd.source, session->user_data);
7155
7156
0
  if (payloadlen == NGHTTP2_ERR_DEFERRED ||
7157
0
      payloadlen == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE ||
7158
0
      payloadlen == NGHTTP2_ERR_PAUSE) {
7159
0
    DEBUGF("send: DATA postponed due to %s\n",
7160
0
           nghttp2_strerror((int)payloadlen));
7161
7162
0
    return (int)payloadlen;
7163
0
  }
7164
7165
0
  if (payloadlen < 0 || datamax < (size_t)payloadlen) {
7166
    /* This is the error code when callback is failed. */
7167
0
    return NGHTTP2_ERR_CALLBACK_FAILURE;
7168
0
  }
7169
7170
0
  buf->last = buf->pos + payloadlen;
7171
0
  buf->pos -= NGHTTP2_FRAME_HDLEN;
7172
7173
  /* Clear flags, because this may contain previous flags of previous
7174
     DATA */
7175
0
  frame->hd.flags = NGHTTP2_FLAG_NONE;
7176
7177
0
  if (data_flags & NGHTTP2_DATA_FLAG_EOF) {
7178
0
    aux_data->eof = 1;
7179
    /* If NGHTTP2_DATA_FLAG_NO_END_STREAM is set, don't set
7180
       NGHTTP2_FLAG_END_STREAM */
7181
0
    if ((aux_data->flags & NGHTTP2_FLAG_END_STREAM) &&
7182
0
        (data_flags & NGHTTP2_DATA_FLAG_NO_END_STREAM) == 0) {
7183
0
      frame->hd.flags |= NGHTTP2_FLAG_END_STREAM;
7184
0
    }
7185
0
  }
7186
7187
0
  if (data_flags & NGHTTP2_DATA_FLAG_NO_COPY) {
7188
0
    if (session->callbacks.send_data_callback == NULL) {
7189
0
      DEBUGF("NGHTTP2_DATA_FLAG_NO_COPY requires send_data_callback set\n");
7190
7191
0
      return NGHTTP2_ERR_CALLBACK_FAILURE;
7192
0
    }
7193
0
    aux_data->no_copy = 1;
7194
0
  }
7195
7196
0
  frame->hd.length = (size_t)payloadlen;
7197
0
  frame->data.padlen = 0;
7198
7199
0
  max_payloadlen = nghttp2_min(datamax, frame->hd.length + NGHTTP2_MAX_PADLEN);
7200
7201
0
  padded_payloadlen =
7202
0
      session_call_select_padding(session, frame, max_payloadlen);
7203
7204
0
  if (nghttp2_is_fatal((int)padded_payloadlen)) {
7205
0
    return (int)padded_payloadlen;
7206
0
  }
7207
7208
0
  frame->data.padlen = (size_t)(padded_payloadlen - payloadlen);
7209
7210
0
  nghttp2_frame_pack_frame_hd(buf->pos, &frame->hd);
7211
7212
0
  rv = nghttp2_frame_add_pad(bufs, &frame->hd, frame->data.padlen,
7213
0
                             aux_data->no_copy);
7214
0
  if (rv != 0) {
7215
0
    return rv;
7216
0
  }
7217
7218
0
  reschedule_stream(stream);
7219
7220
0
  if (frame->hd.length == 0 && (data_flags & NGHTTP2_DATA_FLAG_EOF) &&
7221
0
      (data_flags & NGHTTP2_DATA_FLAG_NO_END_STREAM)) {
7222
    /* DATA payload length is 0, and DATA frame does not bear
7223
       END_STREAM.  In this case, there is no point to send 0 length
7224
       DATA frame. */
7225
0
    return NGHTTP2_ERR_CANCEL;
7226
0
  }
7227
7228
0
  return 0;
7229
0
}
7230
7231
void *nghttp2_session_get_stream_user_data(nghttp2_session *session,
7232
0
                                           int32_t stream_id) {
7233
0
  nghttp2_stream *stream;
7234
0
  stream = nghttp2_session_get_stream(session, stream_id);
7235
0
  if (stream) {
7236
0
    return stream->stream_user_data;
7237
0
  } else {
7238
0
    return NULL;
7239
0
  }
7240
0
}
7241
7242
int nghttp2_session_set_stream_user_data(nghttp2_session *session,
7243
                                         int32_t stream_id,
7244
0
                                         void *stream_user_data) {
7245
0
  nghttp2_stream *stream;
7246
0
  nghttp2_frame *frame;
7247
0
  nghttp2_outbound_item *item;
7248
7249
0
  stream = nghttp2_session_get_stream(session, stream_id);
7250
0
  if (stream) {
7251
0
    stream->stream_user_data = stream_user_data;
7252
0
    return 0;
7253
0
  }
7254
7255
0
  if (session->server || !nghttp2_session_is_my_stream_id(session, stream_id) ||
7256
0
      !nghttp2_outbound_queue_top(&session->ob_syn)) {
7257
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7258
0
  }
7259
7260
0
  frame = &nghttp2_outbound_queue_top(&session->ob_syn)->frame;
7261
0
  assert(frame->hd.type == NGHTTP2_HEADERS);
7262
7263
0
  if (frame->hd.stream_id > stream_id ||
7264
0
      (uint32_t)stream_id >= session->next_stream_id) {
7265
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7266
0
  }
7267
7268
0
  for (item = session->ob_syn.head; item; item = item->qnext) {
7269
0
    if (item->frame.hd.stream_id < stream_id) {
7270
0
      continue;
7271
0
    }
7272
7273
0
    if (item->frame.hd.stream_id > stream_id) {
7274
0
      break;
7275
0
    }
7276
7277
0
    item->aux_data.headers.stream_user_data = stream_user_data;
7278
0
    return 0;
7279
0
  }
7280
7281
0
  return NGHTTP2_ERR_INVALID_ARGUMENT;
7282
0
}
7283
7284
0
int nghttp2_session_resume_data(nghttp2_session *session, int32_t stream_id) {
7285
0
  int rv;
7286
0
  nghttp2_stream *stream;
7287
0
  stream = nghttp2_session_get_stream(session, stream_id);
7288
0
  if (stream == NULL || !nghttp2_stream_check_deferred_item(stream)) {
7289
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7290
0
  }
7291
7292
0
  rv = nghttp2_stream_resume_deferred_item(stream,
7293
0
                                           NGHTTP2_STREAM_FLAG_DEFERRED_USER);
7294
7295
0
  if (nghttp2_is_fatal(rv)) {
7296
0
    return rv;
7297
0
  }
7298
7299
0
  return 0;
7300
0
}
7301
7302
0
size_t nghttp2_session_get_outbound_queue_size(nghttp2_session *session) {
7303
0
  return nghttp2_outbound_queue_size(&session->ob_urgent) +
7304
0
         nghttp2_outbound_queue_size(&session->ob_reg) +
7305
0
         nghttp2_outbound_queue_size(&session->ob_syn);
7306
  /* TODO account for item attached to stream */
7307
0
}
7308
7309
int32_t
7310
nghttp2_session_get_stream_effective_recv_data_length(nghttp2_session *session,
7311
0
                                                      int32_t stream_id) {
7312
0
  nghttp2_stream *stream;
7313
0
  stream = nghttp2_session_get_stream(session, stream_id);
7314
0
  if (stream == NULL) {
7315
0
    return -1;
7316
0
  }
7317
0
  return stream->recv_window_size < 0 ? 0 : stream->recv_window_size;
7318
0
}
7319
7320
int32_t
7321
nghttp2_session_get_stream_effective_local_window_size(nghttp2_session *session,
7322
0
                                                       int32_t stream_id) {
7323
0
  nghttp2_stream *stream;
7324
0
  stream = nghttp2_session_get_stream(session, stream_id);
7325
0
  if (stream == NULL) {
7326
0
    return -1;
7327
0
  }
7328
0
  return stream->local_window_size;
7329
0
}
7330
7331
int32_t nghttp2_session_get_stream_local_window_size(nghttp2_session *session,
7332
0
                                                     int32_t stream_id) {
7333
0
  nghttp2_stream *stream;
7334
0
  int32_t size;
7335
0
  stream = nghttp2_session_get_stream(session, stream_id);
7336
0
  if (stream == NULL) {
7337
0
    return -1;
7338
0
  }
7339
7340
0
  size = stream->local_window_size - stream->recv_window_size;
7341
7342
  /* size could be negative if local endpoint reduced
7343
     SETTINGS_INITIAL_WINDOW_SIZE */
7344
0
  if (size < 0) {
7345
0
    return 0;
7346
0
  }
7347
7348
0
  return size;
7349
0
}
7350
7351
int32_t
7352
0
nghttp2_session_get_effective_recv_data_length(nghttp2_session *session) {
7353
0
  return session->recv_window_size < 0 ? 0 : session->recv_window_size;
7354
0
}
7355
7356
int32_t
7357
0
nghttp2_session_get_effective_local_window_size(nghttp2_session *session) {
7358
0
  return session->local_window_size;
7359
0
}
7360
7361
0
int32_t nghttp2_session_get_local_window_size(nghttp2_session *session) {
7362
0
  return session->local_window_size - session->recv_window_size;
7363
0
}
7364
7365
int32_t nghttp2_session_get_stream_remote_window_size(nghttp2_session *session,
7366
0
                                                      int32_t stream_id) {
7367
0
  nghttp2_stream *stream;
7368
7369
0
  stream = nghttp2_session_get_stream(session, stream_id);
7370
0
  if (stream == NULL) {
7371
0
    return -1;
7372
0
  }
7373
7374
  /* stream->remote_window_size can be negative when
7375
     SETTINGS_INITIAL_WINDOW_SIZE is changed. */
7376
0
  return nghttp2_max(0, stream->remote_window_size);
7377
0
}
7378
7379
0
int32_t nghttp2_session_get_remote_window_size(nghttp2_session *session) {
7380
0
  return session->remote_window_size;
7381
0
}
7382
7383
uint32_t nghttp2_session_get_remote_settings(nghttp2_session *session,
7384
0
                                             nghttp2_settings_id id) {
7385
0
  switch (id) {
7386
0
  case NGHTTP2_SETTINGS_HEADER_TABLE_SIZE:
7387
0
    return session->remote_settings.header_table_size;
7388
0
  case NGHTTP2_SETTINGS_ENABLE_PUSH:
7389
0
    return session->remote_settings.enable_push;
7390
0
  case NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS:
7391
0
    return session->remote_settings.max_concurrent_streams;
7392
0
  case NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE:
7393
0
    return session->remote_settings.initial_window_size;
7394
0
  case NGHTTP2_SETTINGS_MAX_FRAME_SIZE:
7395
0
    return session->remote_settings.max_frame_size;
7396
0
  case NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE:
7397
0
    return session->remote_settings.max_header_list_size;
7398
0
  case NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL:
7399
0
    return session->remote_settings.enable_connect_protocol;
7400
0
  }
7401
7402
0
  assert(0);
7403
0
  abort(); /* if NDEBUG is set */
7404
0
}
7405
7406
uint32_t nghttp2_session_get_local_settings(nghttp2_session *session,
7407
0
                                            nghttp2_settings_id id) {
7408
0
  switch (id) {
7409
0
  case NGHTTP2_SETTINGS_HEADER_TABLE_SIZE:
7410
0
    return session->local_settings.header_table_size;
7411
0
  case NGHTTP2_SETTINGS_ENABLE_PUSH:
7412
0
    return session->local_settings.enable_push;
7413
0
  case NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS:
7414
0
    return session->local_settings.max_concurrent_streams;
7415
0
  case NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE:
7416
0
    return session->local_settings.initial_window_size;
7417
0
  case NGHTTP2_SETTINGS_MAX_FRAME_SIZE:
7418
0
    return session->local_settings.max_frame_size;
7419
0
  case NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE:
7420
0
    return session->local_settings.max_header_list_size;
7421
0
  case NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL:
7422
0
    return session->local_settings.enable_connect_protocol;
7423
0
  }
7424
7425
0
  assert(0);
7426
0
  abort(); /* if NDEBUG is set */
7427
0
}
7428
7429
static int nghttp2_session_upgrade_internal(nghttp2_session *session,
7430
                                            const uint8_t *settings_payload,
7431
                                            size_t settings_payloadlen,
7432
0
                                            void *stream_user_data) {
7433
0
  nghttp2_stream *stream;
7434
0
  nghttp2_frame frame;
7435
0
  nghttp2_settings_entry *iv;
7436
0
  size_t niv;
7437
0
  int rv;
7438
0
  nghttp2_priority_spec pri_spec;
7439
0
  nghttp2_mem *mem;
7440
7441
0
  mem = &session->mem;
7442
7443
0
  if ((!session->server && session->next_stream_id != 1) ||
7444
0
      (session->server && session->last_recv_stream_id >= 1)) {
7445
0
    return NGHTTP2_ERR_PROTO;
7446
0
  }
7447
0
  if (settings_payloadlen % NGHTTP2_FRAME_SETTINGS_ENTRY_LENGTH) {
7448
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7449
0
  }
7450
  /* SETTINGS frame contains too many settings */
7451
0
  if (settings_payloadlen / NGHTTP2_FRAME_SETTINGS_ENTRY_LENGTH
7452
0
        > session->max_settings) {
7453
0
    return NGHTTP2_ERR_TOO_MANY_SETTINGS;
7454
0
  }
7455
0
  rv = nghttp2_frame_unpack_settings_payload2(&iv, &niv, settings_payload,
7456
0
                                              settings_payloadlen, mem);
7457
0
  if (rv != 0) {
7458
0
    return rv;
7459
0
  }
7460
7461
0
  if (session->server) {
7462
0
    nghttp2_frame_hd_init(&frame.hd, settings_payloadlen, NGHTTP2_SETTINGS,
7463
0
                          NGHTTP2_FLAG_NONE, 0);
7464
0
    frame.settings.iv = iv;
7465
0
    frame.settings.niv = niv;
7466
0
    rv = nghttp2_session_on_settings_received(session, &frame, 1 /* No ACK */);
7467
0
  } else {
7468
0
    rv = nghttp2_submit_settings(session, NGHTTP2_FLAG_NONE, iv, niv);
7469
0
  }
7470
0
  nghttp2_mem_free(mem, iv);
7471
0
  if (rv != 0) {
7472
0
    return rv;
7473
0
  }
7474
7475
0
  nghttp2_priority_spec_default_init(&pri_spec);
7476
7477
0
  stream = nghttp2_session_open_stream(
7478
0
      session, 1, NGHTTP2_STREAM_FLAG_NONE, &pri_spec, NGHTTP2_STREAM_OPENING,
7479
0
      session->server ? NULL : stream_user_data);
7480
0
  if (stream == NULL) {
7481
0
    return NGHTTP2_ERR_NOMEM;
7482
0
  }
7483
7484
  /* We don't call nghttp2_session_adjust_closed_stream(), since this
7485
     should be the first stream open. */
7486
7487
0
  if (session->server) {
7488
0
    nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD);
7489
0
    session->last_recv_stream_id = 1;
7490
0
    session->last_proc_stream_id = 1;
7491
0
  } else {
7492
0
    nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_WR);
7493
0
    session->last_sent_stream_id = 1;
7494
0
    session->next_stream_id += 2;
7495
0
  }
7496
0
  return 0;
7497
0
}
7498
7499
int nghttp2_session_upgrade(nghttp2_session *session,
7500
                            const uint8_t *settings_payload,
7501
                            size_t settings_payloadlen,
7502
0
                            void *stream_user_data) {
7503
0
  int rv;
7504
0
  nghttp2_stream *stream;
7505
7506
0
  rv = nghttp2_session_upgrade_internal(session, settings_payload,
7507
0
                                        settings_payloadlen, stream_user_data);
7508
0
  if (rv != 0) {
7509
0
    return rv;
7510
0
  }
7511
7512
0
  stream = nghttp2_session_get_stream(session, 1);
7513
0
  assert(stream);
7514
7515
  /* We have no information about request header fields when Upgrade
7516
     was happened.  So we don't know the request method here.  If
7517
     request method is HEAD, we have a trouble because we may have
7518
     nonzero content-length header field in response headers, and we
7519
     will going to check it against the actual DATA frames, but we may
7520
     get mismatch because HEAD response body must be empty.  Because
7521
     of this reason, nghttp2_session_upgrade() was deprecated in favor
7522
     of nghttp2_session_upgrade2(), which has |head_request| parameter
7523
     to indicate that request method is HEAD or not. */
7524
0
  stream->http_flags |= NGHTTP2_HTTP_FLAG_METH_UPGRADE_WORKAROUND;
7525
0
  return 0;
7526
0
}
7527
7528
int nghttp2_session_upgrade2(nghttp2_session *session,
7529
                             const uint8_t *settings_payload,
7530
                             size_t settings_payloadlen, int head_request,
7531
0
                             void *stream_user_data) {
7532
0
  int rv;
7533
0
  nghttp2_stream *stream;
7534
7535
0
  rv = nghttp2_session_upgrade_internal(session, settings_payload,
7536
0
                                        settings_payloadlen, stream_user_data);
7537
0
  if (rv != 0) {
7538
0
    return rv;
7539
0
  }
7540
7541
0
  stream = nghttp2_session_get_stream(session, 1);
7542
0
  assert(stream);
7543
7544
0
  if (head_request) {
7545
0
    stream->http_flags |= NGHTTP2_HTTP_FLAG_METH_HEAD;
7546
0
  }
7547
7548
0
  return 0;
7549
0
}
7550
7551
int nghttp2_session_get_stream_local_close(nghttp2_session *session,
7552
0
                                           int32_t stream_id) {
7553
0
  nghttp2_stream *stream;
7554
7555
0
  stream = nghttp2_session_get_stream(session, stream_id);
7556
7557
0
  if (!stream) {
7558
0
    return -1;
7559
0
  }
7560
7561
0
  return (stream->shut_flags & NGHTTP2_SHUT_WR) != 0;
7562
0
}
7563
7564
int nghttp2_session_get_stream_remote_close(nghttp2_session *session,
7565
0
                                            int32_t stream_id) {
7566
0
  nghttp2_stream *stream;
7567
7568
0
  stream = nghttp2_session_get_stream(session, stream_id);
7569
7570
0
  if (!stream) {
7571
0
    return -1;
7572
0
  }
7573
7574
0
  return (stream->shut_flags & NGHTTP2_SHUT_RD) != 0;
7575
0
}
7576
7577
int nghttp2_session_consume(nghttp2_session *session, int32_t stream_id,
7578
0
                            size_t size) {
7579
0
  int rv;
7580
0
  nghttp2_stream *stream;
7581
7582
0
  if (stream_id == 0) {
7583
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7584
0
  }
7585
7586
0
  if (!(session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE)) {
7587
0
    return NGHTTP2_ERR_INVALID_STATE;
7588
0
  }
7589
7590
0
  rv = session_update_connection_consumed_size(session, size);
7591
7592
0
  if (nghttp2_is_fatal(rv)) {
7593
0
    return rv;
7594
0
  }
7595
7596
0
  stream = nghttp2_session_get_stream(session, stream_id);
7597
7598
0
  if (!stream) {
7599
0
    return 0;
7600
0
  }
7601
7602
0
  rv = session_update_stream_consumed_size(session, stream, size);
7603
7604
0
  if (nghttp2_is_fatal(rv)) {
7605
0
    return rv;
7606
0
  }
7607
7608
0
  return 0;
7609
0
}
7610
7611
0
int nghttp2_session_consume_connection(nghttp2_session *session, size_t size) {
7612
0
  int rv;
7613
7614
0
  if (!(session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE)) {
7615
0
    return NGHTTP2_ERR_INVALID_STATE;
7616
0
  }
7617
7618
0
  rv = session_update_connection_consumed_size(session, size);
7619
7620
0
  if (nghttp2_is_fatal(rv)) {
7621
0
    return rv;
7622
0
  }
7623
7624
0
  return 0;
7625
0
}
7626
7627
int nghttp2_session_consume_stream(nghttp2_session *session, int32_t stream_id,
7628
0
                                   size_t size) {
7629
0
  int rv;
7630
0
  nghttp2_stream *stream;
7631
7632
0
  if (stream_id == 0) {
7633
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7634
0
  }
7635
7636
0
  if (!(session->opt_flags & NGHTTP2_OPTMASK_NO_AUTO_WINDOW_UPDATE)) {
7637
0
    return NGHTTP2_ERR_INVALID_STATE;
7638
0
  }
7639
7640
0
  stream = nghttp2_session_get_stream(session, stream_id);
7641
7642
0
  if (!stream) {
7643
0
    return 0;
7644
0
  }
7645
7646
0
  rv = session_update_stream_consumed_size(session, stream, size);
7647
7648
0
  if (nghttp2_is_fatal(rv)) {
7649
0
    return rv;
7650
0
  }
7651
7652
0
  return 0;
7653
0
}
7654
7655
int nghttp2_session_set_next_stream_id(nghttp2_session *session,
7656
0
                                       int32_t next_stream_id) {
7657
0
  if (next_stream_id <= 0 ||
7658
0
      session->next_stream_id > (uint32_t)next_stream_id) {
7659
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7660
0
  }
7661
7662
0
  if (session->server) {
7663
0
    if (next_stream_id % 2) {
7664
0
      return NGHTTP2_ERR_INVALID_ARGUMENT;
7665
0
    }
7666
0
  } else if (next_stream_id % 2 == 0) {
7667
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7668
0
  }
7669
7670
0
  session->next_stream_id = (uint32_t)next_stream_id;
7671
0
  return 0;
7672
0
}
7673
7674
0
uint32_t nghttp2_session_get_next_stream_id(nghttp2_session *session) {
7675
0
  return session->next_stream_id;
7676
0
}
7677
7678
0
int32_t nghttp2_session_get_last_proc_stream_id(nghttp2_session *session) {
7679
0
  return session->last_proc_stream_id;
7680
0
}
7681
7682
nghttp2_stream *nghttp2_session_find_stream(nghttp2_session *session,
7683
0
                                            int32_t stream_id) {
7684
0
  if (stream_id == 0) {
7685
0
    return &session->root;
7686
0
  }
7687
7688
0
  return nghttp2_session_get_stream_raw(session, stream_id);
7689
0
}
7690
7691
0
nghttp2_stream *nghttp2_session_get_root_stream(nghttp2_session *session) {
7692
0
  return &session->root;
7693
0
}
7694
7695
0
int nghttp2_session_check_server_session(nghttp2_session *session) {
7696
0
  return session->server;
7697
0
}
7698
7699
int nghttp2_session_change_stream_priority(
7700
    nghttp2_session *session, int32_t stream_id,
7701
0
    const nghttp2_priority_spec *pri_spec) {
7702
0
  int rv;
7703
0
  nghttp2_stream *stream;
7704
0
  nghttp2_priority_spec pri_spec_copy;
7705
7706
0
  if (stream_id == 0 || stream_id == pri_spec->stream_id) {
7707
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7708
0
  }
7709
7710
0
  stream = nghttp2_session_get_stream_raw(session, stream_id);
7711
0
  if (!stream) {
7712
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7713
0
  }
7714
7715
0
  pri_spec_copy = *pri_spec;
7716
0
  nghttp2_priority_spec_normalize_weight(&pri_spec_copy);
7717
7718
0
  rv = nghttp2_session_reprioritize_stream(session, stream, &pri_spec_copy);
7719
7720
0
  if (nghttp2_is_fatal(rv)) {
7721
0
    return rv;
7722
0
  }
7723
7724
  /* We don't intentionally call nghttp2_session_adjust_idle_stream()
7725
     so that idle stream created by this function, and existing ones
7726
     are kept for application.  We will adjust number of idle stream
7727
     in nghttp2_session_mem_send or nghttp2_session_mem_recv is
7728
     called. */
7729
0
  return 0;
7730
0
}
7731
7732
int nghttp2_session_create_idle_stream(nghttp2_session *session,
7733
                                       int32_t stream_id,
7734
0
                                       const nghttp2_priority_spec *pri_spec) {
7735
0
  nghttp2_stream *stream;
7736
0
  nghttp2_priority_spec pri_spec_copy;
7737
7738
0
  if (stream_id == 0 || stream_id == pri_spec->stream_id ||
7739
0
      !session_detect_idle_stream(session, stream_id)) {
7740
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7741
0
  }
7742
7743
0
  stream = nghttp2_session_get_stream_raw(session, stream_id);
7744
0
  if (stream) {
7745
0
    return NGHTTP2_ERR_INVALID_ARGUMENT;
7746
0
  }
7747
7748
0
  pri_spec_copy = *pri_spec;
7749
0
  nghttp2_priority_spec_normalize_weight(&pri_spec_copy);
7750
7751
0
  stream =
7752
0
      nghttp2_session_open_stream(session, stream_id, NGHTTP2_STREAM_FLAG_NONE,
7753
0
                                  &pri_spec_copy, NGHTTP2_STREAM_IDLE, NULL);
7754
0
  if (!stream) {
7755
0
    return NGHTTP2_ERR_NOMEM;
7756
0
  }
7757
7758
  /* We don't intentionally call nghttp2_session_adjust_idle_stream()
7759
     so that idle stream created by this function, and existing ones
7760
     are kept for application.  We will adjust number of idle stream
7761
     in nghttp2_session_mem_send or nghttp2_session_mem_recv is
7762
     called. */
7763
0
  return 0;
7764
0
}
7765
7766
size_t
7767
0
nghttp2_session_get_hd_inflate_dynamic_table_size(nghttp2_session *session) {
7768
0
  return nghttp2_hd_inflate_get_dynamic_table_size(&session->hd_inflater);
7769
0
}
7770
7771
size_t
7772
0
nghttp2_session_get_hd_deflate_dynamic_table_size(nghttp2_session *session) {
7773
0
  return nghttp2_hd_deflate_get_dynamic_table_size(&session->hd_deflater);
7774
0
}
7775
7776
0
void nghttp2_session_set_user_data(nghttp2_session *session, void *user_data) {
7777
0
  session->user_data = user_data;
7778
0
}