Craig Tiller | d8df50c | 2015-06-12 07:53:56 -0700 | [diff] [blame] | 1 | /* |
| 2 | * |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 3 | * Copyright 2015-2016, Google Inc. |
Craig Tiller | d8df50c | 2015-06-12 07:53:56 -0700 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 34 | #include "src/core/lib/transport/chttp2/internal.h" |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 35 | |
| 36 | #include <string.h> |
| 37 | |
Craig Tiller | b2b4261 | 2015-11-20 12:02:17 -0800 | [diff] [blame] | 38 | #include <grpc/support/alloc.h> |
| 39 | #include <grpc/support/log.h> |
| 40 | #include <grpc/support/string_util.h> |
| 41 | |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 42 | #include "src/core/lib/profiling/timers.h" |
| 43 | #include "src/core/lib/transport/chttp2/http2_errors.h" |
| 44 | #include "src/core/lib/transport/chttp2/status_conversion.h" |
| 45 | #include "src/core/lib/transport/chttp2/timeout_encoding.h" |
| 46 | #include "src/core/lib/transport/static_metadata.h" |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 47 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 48 | static int init_frame_parser(grpc_exec_ctx *exec_ctx, |
| 49 | grpc_chttp2_transport_parsing *transport_parsing); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 50 | static int init_header_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 51 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing, |
| 52 | int is_continuation); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 53 | static int init_data_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 54 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 55 | static int init_rst_stream_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 56 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 57 | static int init_settings_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 58 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 59 | static int init_window_update_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 60 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing); |
| 61 | static int init_ping_parser(grpc_exec_ctx *exec_ctx, |
| 62 | grpc_chttp2_transport_parsing *transport_parsing); |
| 63 | static int init_goaway_parser(grpc_exec_ctx *exec_ctx, |
| 64 | grpc_chttp2_transport_parsing *transport_parsing); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 65 | static int init_skip_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 66 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing, |
| 67 | int is_header); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 68 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 69 | static int parse_frame_slice(grpc_exec_ctx *exec_ctx, |
| 70 | grpc_chttp2_transport_parsing *transport_parsing, |
| 71 | gpr_slice slice, int is_last); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 72 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 73 | void grpc_chttp2_prepare_to_read( |
| 74 | grpc_chttp2_transport_global *transport_global, |
| 75 | grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | cf1e319 | 2015-06-16 14:28:22 -0700 | [diff] [blame] | 76 | grpc_chttp2_stream_global *stream_global; |
| 77 | grpc_chttp2_stream_parsing *stream_parsing; |
| 78 | |
Craig Tiller | 0ba432d | 2015-10-09 16:57:11 -0700 | [diff] [blame] | 79 | GPR_TIMER_BEGIN("grpc_chttp2_prepare_to_read", 0); |
Craig Tiller | 1f41b6b | 2015-10-09 15:07:02 -0700 | [diff] [blame] | 80 | |
Craig Tiller | cec9eb9 | 2015-06-17 17:16:48 -0700 | [diff] [blame] | 81 | transport_parsing->next_stream_id = transport_global->next_stream_id; |
Craig Tiller | 3c53bb2 | 2015-11-10 14:24:36 +0000 | [diff] [blame] | 82 | transport_parsing->last_sent_max_table_size = |
| 83 | transport_global->settings[GRPC_SENT_SETTINGS] |
| 84 | [GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE]; |
Craig Tiller | cec9eb9 | 2015-06-17 17:16:48 -0700 | [diff] [blame] | 85 | |
Craig Tiller | cf1e319 | 2015-06-16 14:28:22 -0700 | [diff] [blame] | 86 | /* update the parsing view of incoming window */ |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 87 | while (grpc_chttp2_list_pop_unannounced_incoming_window_available( |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 88 | transport_global, transport_parsing, &stream_global, &stream_parsing)) { |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 89 | GRPC_CHTTP2_FLOW_MOVE_STREAM("parse", transport_parsing, stream_parsing, |
| 90 | incoming_window, stream_global, |
| 91 | unannounced_incoming_window_for_parse); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 92 | } |
Craig Tiller | 1f41b6b | 2015-10-09 15:07:02 -0700 | [diff] [blame] | 93 | |
Craig Tiller | 0ba432d | 2015-10-09 16:57:11 -0700 | [diff] [blame] | 94 | GPR_TIMER_END("grpc_chttp2_prepare_to_read", 0); |
Craig Tiller | cf1e319 | 2015-06-16 14:28:22 -0700 | [diff] [blame] | 95 | } |
Craig Tiller | 1937b06 | 2015-06-16 08:47:38 -0700 | [diff] [blame] | 96 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 97 | void grpc_chttp2_publish_reads( |
| 98 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_global *transport_global, |
| 99 | grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 100 | grpc_chttp2_stream_global *stream_global; |
| 101 | grpc_chttp2_stream_parsing *stream_parsing; |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 102 | int was_zero; |
| 103 | int is_zero; |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 104 | |
Craig Tiller | 4aa71a1 | 2015-06-15 13:00:55 -0700 | [diff] [blame] | 105 | /* transport_parsing->last_incoming_stream_id is used as |
| 106 | last-grpc_chttp2_stream-id when |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 107 | sending GOAWAY frame. |
| 108 | https://tools.ietf.org/html/draft-ietf-httpbis-http2-17#section-6.8 |
Craig Tiller | 4aa71a1 | 2015-06-15 13:00:55 -0700 | [diff] [blame] | 109 | says that last-grpc_chttp2_stream-id is peer-initiated grpc_chttp2_stream |
| 110 | ID. So, |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 111 | since we don't have server pushed streams, client should send |
| 112 | GOAWAY last-grpc_chttp2_stream-id=0 in this case. */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 113 | if (!transport_parsing->is_client) { |
| 114 | transport_global->last_incoming_stream_id = |
| 115 | transport_parsing->incoming_stream_id; |
| 116 | } |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 117 | |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 118 | /* update global settings */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 119 | if (transport_parsing->settings_updated) { |
| 120 | memcpy(transport_global->settings[GRPC_PEER_SETTINGS], |
| 121 | transport_parsing->settings, sizeof(transport_parsing->settings)); |
| 122 | transport_parsing->settings_updated = 0; |
| 123 | } |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 124 | |
| 125 | /* update settings based on ack if received */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 126 | if (transport_parsing->settings_ack_received) { |
| 127 | memcpy(transport_global->settings[GRPC_ACKED_SETTINGS], |
| 128 | transport_global->settings[GRPC_SENT_SETTINGS], |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 129 | GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t)); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 130 | transport_parsing->settings_ack_received = 0; |
Craig Tiller | 027a74c | 2015-11-10 08:37:46 +0000 | [diff] [blame] | 131 | transport_global->sent_local_settings = 0; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 132 | } |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 133 | |
| 134 | /* move goaway to the global state if we received one (it will be |
| 135 | published later */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 136 | if (transport_parsing->goaway_received) { |
| 137 | grpc_chttp2_add_incoming_goaway(exec_ctx, transport_global, |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 138 | (uint32_t)transport_parsing->goaway_error, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 139 | transport_parsing->goaway_text); |
| 140 | transport_parsing->goaway_text = gpr_empty_slice(); |
| 141 | transport_parsing->goaway_received = 0; |
| 142 | } |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 143 | |
Craig Tiller | 285b882 | 2015-06-17 15:58:13 -0700 | [diff] [blame] | 144 | /* propagate flow control tokens to global state */ |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 145 | was_zero = transport_global->outgoing_window <= 0; |
| 146 | GRPC_CHTTP2_FLOW_MOVE_TRANSPORT("parsed", transport_global, outgoing_window, |
| 147 | transport_parsing, outgoing_window); |
| 148 | is_zero = transport_global->outgoing_window <= 0; |
| 149 | if (was_zero && !is_zero) { |
| 150 | while (grpc_chttp2_list_pop_stalled_by_transport(transport_global, |
| 151 | &stream_global)) { |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 152 | grpc_chttp2_become_writable(transport_global, stream_global); |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 153 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 154 | } |
Craig Tiller | 285b882 | 2015-06-17 15:58:13 -0700 | [diff] [blame] | 155 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 156 | if (transport_parsing->incoming_window < |
| 157 | transport_global->connection_window_target * 3 / 4) { |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 158 | int64_t announce_bytes = transport_global->connection_window_target - |
| 159 | transport_parsing->incoming_window; |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 160 | GRPC_CHTTP2_FLOW_CREDIT_TRANSPORT("parsed", transport_global, |
| 161 | announce_incoming_window, announce_bytes); |
| 162 | GRPC_CHTTP2_FLOW_CREDIT_TRANSPORT("parsed", transport_parsing, |
| 163 | incoming_window, announce_bytes); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 164 | } |
Craig Tiller | 285b882 | 2015-06-17 15:58:13 -0700 | [diff] [blame] | 165 | |
Craig Tiller | 606d874 | 2015-06-15 06:58:50 -0700 | [diff] [blame] | 166 | /* for each stream that saw an update, fixup global state */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 167 | while (grpc_chttp2_list_pop_parsing_seen_stream( |
| 168 | transport_global, transport_parsing, &stream_global, &stream_parsing)) { |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 169 | if (stream_parsing->seen_error) { |
| 170 | stream_global->seen_error = 1; |
| 171 | grpc_chttp2_list_add_check_read_ops(transport_global, stream_global); |
Craig Tiller | f73fcd1 | 2015-06-16 16:25:26 -0700 | [diff] [blame] | 172 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 173 | |
| 174 | /* update outgoing flow control window */ |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 175 | was_zero = stream_global->outgoing_window <= 0; |
| 176 | GRPC_CHTTP2_FLOW_MOVE_STREAM("parsed", transport_global, stream_global, |
| 177 | outgoing_window, stream_parsing, |
| 178 | outgoing_window); |
| 179 | is_zero = stream_global->outgoing_window <= 0; |
| 180 | if (was_zero && !is_zero) { |
Craig Tiller | 0cb803d | 2016-03-02 22:17:24 -0800 | [diff] [blame] | 181 | grpc_chttp2_become_writable(transport_global, stream_global); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 182 | } |
| 183 | |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 184 | stream_global->max_recv_bytes -= (uint32_t)GPR_MIN( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 185 | stream_global->max_recv_bytes, stream_parsing->received_bytes); |
| 186 | stream_parsing->received_bytes = 0; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 187 | |
| 188 | /* publish incoming stream ops */ |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 189 | if (stream_global->incoming_frames.tail != NULL) { |
| 190 | stream_global->incoming_frames.tail->is_tail = 0; |
| 191 | } |
| 192 | if (stream_parsing->data_parser.incoming_frames.head != NULL) { |
| 193 | grpc_chttp2_list_add_check_read_ops(transport_global, stream_global); |
| 194 | } |
| 195 | grpc_chttp2_incoming_frame_queue_merge( |
| 196 | &stream_global->incoming_frames, |
| 197 | &stream_parsing->data_parser.incoming_frames); |
| 198 | if (stream_global->incoming_frames.tail != NULL) { |
| 199 | stream_global->incoming_frames.tail->is_tail = 1; |
| 200 | } |
| 201 | |
| 202 | if (!stream_global->published_initial_metadata && |
| 203 | stream_parsing->got_metadata_on_parse[0]) { |
| 204 | stream_parsing->got_metadata_on_parse[0] = 0; |
| 205 | stream_global->published_initial_metadata = 1; |
| 206 | GPR_SWAP(grpc_chttp2_incoming_metadata_buffer, |
| 207 | stream_parsing->metadata_buffer[0], |
| 208 | stream_global->received_initial_metadata); |
| 209 | grpc_chttp2_list_add_check_read_ops(transport_global, stream_global); |
| 210 | } |
| 211 | if (!stream_global->published_trailing_metadata && |
| 212 | stream_parsing->got_metadata_on_parse[1]) { |
| 213 | stream_parsing->got_metadata_on_parse[1] = 0; |
| 214 | stream_global->published_trailing_metadata = 1; |
| 215 | GPR_SWAP(grpc_chttp2_incoming_metadata_buffer, |
| 216 | stream_parsing->metadata_buffer[1], |
| 217 | stream_global->received_trailing_metadata); |
| 218 | grpc_chttp2_list_add_check_read_ops(transport_global, stream_global); |
| 219 | } |
| 220 | |
| 221 | if (stream_parsing->saw_rst_stream) { |
| 222 | if (stream_parsing->rst_stream_reason != GRPC_CHTTP2_NO_ERROR) { |
| 223 | grpc_status_code status_code = grpc_chttp2_http2_error_to_grpc_status( |
| 224 | (grpc_chttp2_error_code)stream_parsing->rst_stream_reason); |
| 225 | char *status_details; |
| 226 | gpr_slice slice_details; |
| 227 | gpr_asprintf(&status_details, "Received RST_STREAM err=%d", |
| 228 | stream_parsing->rst_stream_reason); |
| 229 | slice_details = gpr_slice_from_copied_string(status_details); |
| 230 | gpr_free(status_details); |
| 231 | grpc_chttp2_fake_status(exec_ctx, transport_global, stream_global, |
| 232 | status_code, &slice_details); |
| 233 | } |
| 234 | grpc_chttp2_mark_stream_closed(exec_ctx, transport_global, stream_global, |
| 235 | 1, 1); |
| 236 | } |
| 237 | |
| 238 | if (stream_parsing->received_close) { |
| 239 | grpc_chttp2_mark_stream_closed(exec_ctx, transport_global, stream_global, |
| 240 | 1, 0); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 241 | } |
| 242 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 243 | } |
| 244 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 245 | int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx, |
| 246 | grpc_chttp2_transport_parsing *transport_parsing, |
| 247 | gpr_slice slice) { |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 248 | uint8_t *beg = GPR_SLICE_START_PTR(slice); |
| 249 | uint8_t *end = GPR_SLICE_END_PTR(slice); |
| 250 | uint8_t *cur = beg; |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 251 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 252 | if (cur == end) return 1; |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 253 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 254 | switch (transport_parsing->deframe_state) { |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 255 | case GRPC_DTS_CLIENT_PREFIX_0: |
| 256 | case GRPC_DTS_CLIENT_PREFIX_1: |
| 257 | case GRPC_DTS_CLIENT_PREFIX_2: |
| 258 | case GRPC_DTS_CLIENT_PREFIX_3: |
| 259 | case GRPC_DTS_CLIENT_PREFIX_4: |
| 260 | case GRPC_DTS_CLIENT_PREFIX_5: |
| 261 | case GRPC_DTS_CLIENT_PREFIX_6: |
| 262 | case GRPC_DTS_CLIENT_PREFIX_7: |
| 263 | case GRPC_DTS_CLIENT_PREFIX_8: |
| 264 | case GRPC_DTS_CLIENT_PREFIX_9: |
| 265 | case GRPC_DTS_CLIENT_PREFIX_10: |
| 266 | case GRPC_DTS_CLIENT_PREFIX_11: |
| 267 | case GRPC_DTS_CLIENT_PREFIX_12: |
| 268 | case GRPC_DTS_CLIENT_PREFIX_13: |
| 269 | case GRPC_DTS_CLIENT_PREFIX_14: |
| 270 | case GRPC_DTS_CLIENT_PREFIX_15: |
| 271 | case GRPC_DTS_CLIENT_PREFIX_16: |
| 272 | case GRPC_DTS_CLIENT_PREFIX_17: |
| 273 | case GRPC_DTS_CLIENT_PREFIX_18: |
| 274 | case GRPC_DTS_CLIENT_PREFIX_19: |
| 275 | case GRPC_DTS_CLIENT_PREFIX_20: |
| 276 | case GRPC_DTS_CLIENT_PREFIX_21: |
| 277 | case GRPC_DTS_CLIENT_PREFIX_22: |
| 278 | case GRPC_DTS_CLIENT_PREFIX_23: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 279 | while (cur != end && transport_parsing->deframe_state != GRPC_DTS_FH_0) { |
| 280 | if (*cur != GRPC_CHTTP2_CLIENT_CONNECT_STRING[transport_parsing |
| 281 | ->deframe_state]) { |
| 282 | gpr_log(GPR_INFO, |
| 283 | "Connect string mismatch: expected '%c' (%d) got '%c' (%d) " |
| 284 | "at byte %d", |
| 285 | GRPC_CHTTP2_CLIENT_CONNECT_STRING[transport_parsing |
| 286 | ->deframe_state], |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 287 | (int)(uint8_t)GRPC_CHTTP2_CLIENT_CONNECT_STRING |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 288 | [transport_parsing->deframe_state], |
| 289 | *cur, (int)*cur, transport_parsing->deframe_state); |
| 290 | return 0; |
| 291 | } |
| 292 | ++cur; |
| 293 | ++transport_parsing->deframe_state; |
| 294 | } |
| 295 | if (cur == end) { |
| 296 | return 1; |
| 297 | } |
| 298 | /* fallthrough */ |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 299 | dts_fh_0: |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 300 | case GRPC_DTS_FH_0: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 301 | GPR_ASSERT(cur < end); |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 302 | transport_parsing->incoming_frame_size = ((uint32_t)*cur) << 16; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 303 | if (++cur == end) { |
| 304 | transport_parsing->deframe_state = GRPC_DTS_FH_1; |
| 305 | return 1; |
| 306 | } |
| 307 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 308 | case GRPC_DTS_FH_1: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 309 | GPR_ASSERT(cur < end); |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 310 | transport_parsing->incoming_frame_size |= ((uint32_t)*cur) << 8; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 311 | if (++cur == end) { |
| 312 | transport_parsing->deframe_state = GRPC_DTS_FH_2; |
| 313 | return 1; |
| 314 | } |
| 315 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 316 | case GRPC_DTS_FH_2: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 317 | GPR_ASSERT(cur < end); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 318 | transport_parsing->incoming_frame_size |= *cur; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 319 | if (++cur == end) { |
| 320 | transport_parsing->deframe_state = GRPC_DTS_FH_3; |
| 321 | return 1; |
| 322 | } |
| 323 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 324 | case GRPC_DTS_FH_3: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 325 | GPR_ASSERT(cur < end); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 326 | transport_parsing->incoming_frame_type = *cur; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 327 | if (++cur == end) { |
| 328 | transport_parsing->deframe_state = GRPC_DTS_FH_4; |
| 329 | return 1; |
| 330 | } |
| 331 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 332 | case GRPC_DTS_FH_4: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 333 | GPR_ASSERT(cur < end); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 334 | transport_parsing->incoming_frame_flags = *cur; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 335 | if (++cur == end) { |
| 336 | transport_parsing->deframe_state = GRPC_DTS_FH_5; |
| 337 | return 1; |
| 338 | } |
| 339 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 340 | case GRPC_DTS_FH_5: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 341 | GPR_ASSERT(cur < end); |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 342 | transport_parsing->incoming_stream_id = (((uint32_t)*cur) & 0x7f) << 24; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 343 | if (++cur == end) { |
| 344 | transport_parsing->deframe_state = GRPC_DTS_FH_6; |
| 345 | return 1; |
| 346 | } |
| 347 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 348 | case GRPC_DTS_FH_6: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 349 | GPR_ASSERT(cur < end); |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 350 | transport_parsing->incoming_stream_id |= ((uint32_t)*cur) << 16; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 351 | if (++cur == end) { |
| 352 | transport_parsing->deframe_state = GRPC_DTS_FH_7; |
| 353 | return 1; |
| 354 | } |
| 355 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 356 | case GRPC_DTS_FH_7: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 357 | GPR_ASSERT(cur < end); |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 358 | transport_parsing->incoming_stream_id |= ((uint32_t)*cur) << 8; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 359 | if (++cur == end) { |
| 360 | transport_parsing->deframe_state = GRPC_DTS_FH_8; |
| 361 | return 1; |
| 362 | } |
| 363 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 364 | case GRPC_DTS_FH_8: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 365 | GPR_ASSERT(cur < end); |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 366 | transport_parsing->incoming_stream_id |= ((uint32_t)*cur); |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 367 | transport_parsing->deframe_state = GRPC_DTS_FRAME; |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 368 | if (!init_frame_parser(exec_ctx, transport_parsing)) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 369 | return 0; |
| 370 | } |
| 371 | if (transport_parsing->incoming_stream_id) { |
| 372 | transport_parsing->last_incoming_stream_id = |
| 373 | transport_parsing->incoming_stream_id; |
| 374 | } |
| 375 | if (transport_parsing->incoming_frame_size == 0) { |
| 376 | if (!parse_frame_slice(exec_ctx, transport_parsing, gpr_empty_slice(), |
| 377 | 1)) { |
| 378 | return 0; |
| 379 | } |
| 380 | transport_parsing->incoming_stream = NULL; |
| 381 | if (++cur == end) { |
| 382 | transport_parsing->deframe_state = GRPC_DTS_FH_0; |
| 383 | return 1; |
| 384 | } |
| 385 | goto dts_fh_0; /* loop */ |
| 386 | } |
| 387 | if (++cur == end) { |
| 388 | return 1; |
| 389 | } |
| 390 | /* fallthrough */ |
Craig Tiller | ab63073 | 2015-06-25 11:20:01 -0700 | [diff] [blame] | 391 | case GRPC_DTS_FRAME: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 392 | GPR_ASSERT(cur < end); |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 393 | if ((uint32_t)(end - cur) == transport_parsing->incoming_frame_size) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 394 | if (!parse_frame_slice(exec_ctx, transport_parsing, |
| 395 | gpr_slice_sub_no_ref(slice, (size_t)(cur - beg), |
| 396 | (size_t)(end - beg)), |
| 397 | 1)) { |
| 398 | return 0; |
| 399 | } |
| 400 | transport_parsing->deframe_state = GRPC_DTS_FH_0; |
| 401 | transport_parsing->incoming_stream = NULL; |
| 402 | return 1; |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 403 | } else if ((uint32_t)(end - cur) > |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 404 | transport_parsing->incoming_frame_size) { |
| 405 | size_t cur_offset = (size_t)(cur - beg); |
| 406 | if (!parse_frame_slice( |
| 407 | exec_ctx, transport_parsing, |
| 408 | gpr_slice_sub_no_ref( |
| 409 | slice, cur_offset, |
| 410 | cur_offset + transport_parsing->incoming_frame_size), |
| 411 | 1)) { |
| 412 | return 0; |
| 413 | } |
| 414 | cur += transport_parsing->incoming_frame_size; |
| 415 | transport_parsing->incoming_stream = NULL; |
| 416 | goto dts_fh_0; /* loop */ |
| 417 | } else { |
| 418 | if (!parse_frame_slice(exec_ctx, transport_parsing, |
| 419 | gpr_slice_sub_no_ref(slice, (size_t)(cur - beg), |
| 420 | (size_t)(end - beg)), |
| 421 | 0)) { |
| 422 | return 0; |
| 423 | } |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 424 | transport_parsing->incoming_frame_size -= (uint32_t)(end - cur); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 425 | return 1; |
| 426 | } |
yang-g | b063c87 | 2015-10-07 11:40:13 -0700 | [diff] [blame] | 427 | GPR_UNREACHABLE_CODE(return 0); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 428 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 429 | |
yang-g | b063c87 | 2015-10-07 11:40:13 -0700 | [diff] [blame] | 430 | GPR_UNREACHABLE_CODE(return 0); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 431 | } |
| 432 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 433 | static int init_frame_parser(grpc_exec_ctx *exec_ctx, |
| 434 | grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 435 | if (transport_parsing->expect_continuation_stream_id != 0) { |
| 436 | if (transport_parsing->incoming_frame_type != |
| 437 | GRPC_CHTTP2_FRAME_CONTINUATION) { |
| 438 | gpr_log(GPR_ERROR, "Expected CONTINUATION frame, got frame type %02x", |
| 439 | transport_parsing->incoming_frame_type); |
| 440 | return 0; |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 441 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 442 | if (transport_parsing->expect_continuation_stream_id != |
| 443 | transport_parsing->incoming_stream_id) { |
| 444 | gpr_log(GPR_ERROR, |
| 445 | "Expected CONTINUATION frame for grpc_chttp2_stream %08x, got " |
| 446 | "grpc_chttp2_stream %08x", |
| 447 | transport_parsing->expect_continuation_stream_id, |
| 448 | transport_parsing->incoming_stream_id); |
| 449 | return 0; |
| 450 | } |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 451 | return init_header_frame_parser(exec_ctx, transport_parsing, 1); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 452 | } |
| 453 | switch (transport_parsing->incoming_frame_type) { |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 454 | case GRPC_CHTTP2_FRAME_DATA: |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 455 | return init_data_frame_parser(exec_ctx, transport_parsing); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 456 | case GRPC_CHTTP2_FRAME_HEADER: |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 457 | return init_header_frame_parser(exec_ctx, transport_parsing, 0); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 458 | case GRPC_CHTTP2_FRAME_CONTINUATION: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 459 | gpr_log(GPR_ERROR, "Unexpected CONTINUATION frame"); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 460 | return 0; |
| 461 | case GRPC_CHTTP2_FRAME_RST_STREAM: |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 462 | return init_rst_stream_parser(exec_ctx, transport_parsing); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 463 | case GRPC_CHTTP2_FRAME_SETTINGS: |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 464 | return init_settings_frame_parser(exec_ctx, transport_parsing); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 465 | case GRPC_CHTTP2_FRAME_WINDOW_UPDATE: |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 466 | return init_window_update_frame_parser(exec_ctx, transport_parsing); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 467 | case GRPC_CHTTP2_FRAME_PING: |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 468 | return init_ping_parser(exec_ctx, transport_parsing); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 469 | case GRPC_CHTTP2_FRAME_GOAWAY: |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 470 | return init_goaway_parser(exec_ctx, transport_parsing); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 471 | default: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 472 | gpr_log(GPR_ERROR, "Unknown frame type %02x", |
| 473 | transport_parsing->incoming_frame_type); |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 474 | return init_skip_frame_parser(exec_ctx, transport_parsing, 0); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 475 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 476 | } |
| 477 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 478 | static grpc_chttp2_parse_error skip_parser( |
| 479 | grpc_exec_ctx *exec_ctx, void *parser, |
| 480 | grpc_chttp2_transport_parsing *transport_parsing, |
| 481 | grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last) { |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 482 | return GRPC_CHTTP2_PARSE_OK; |
| 483 | } |
| 484 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 485 | static void skip_header(void *tp, grpc_mdelem *md) { GRPC_MDELEM_UNREF(md); } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 486 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 487 | static int init_skip_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 488 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing, |
| 489 | int is_header) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 490 | if (is_header) { |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 491 | uint8_t is_eoh = transport_parsing->expect_continuation_stream_id != 0; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 492 | transport_parsing->parser = grpc_chttp2_header_parser_parse; |
| 493 | transport_parsing->parser_data = &transport_parsing->hpack_parser; |
| 494 | transport_parsing->hpack_parser.on_header = skip_header; |
| 495 | transport_parsing->hpack_parser.on_header_user_data = NULL; |
| 496 | transport_parsing->hpack_parser.is_boundary = is_eoh; |
| 497 | transport_parsing->hpack_parser.is_eof = |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 498 | (uint8_t)(is_eoh ? transport_parsing->header_eof : 0); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 499 | } else { |
| 500 | transport_parsing->parser = skip_parser; |
| 501 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 502 | return 1; |
| 503 | } |
| 504 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 505 | void grpc_chttp2_parsing_become_skip_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 506 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 507 | init_skip_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 508 | exec_ctx, transport_parsing, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 509 | transport_parsing->parser == grpc_chttp2_header_parser_parse); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 510 | } |
| 511 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 512 | static grpc_chttp2_parse_error update_incoming_window( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 513 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 514 | grpc_chttp2_stream_parsing *stream_parsing) { |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 515 | uint32_t incoming_frame_size = transport_parsing->incoming_frame_size; |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 516 | if (incoming_frame_size > transport_parsing->incoming_window) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 517 | gpr_log(GPR_ERROR, "frame of size %d overflows incoming window of %d", |
| 518 | transport_parsing->incoming_frame_size, |
| 519 | transport_parsing->incoming_window); |
| 520 | return GRPC_CHTTP2_CONNECTION_ERROR; |
| 521 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 522 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 523 | if (incoming_frame_size > stream_parsing->incoming_window) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 524 | gpr_log(GPR_ERROR, "frame of size %d overflows incoming window of %d", |
| 525 | transport_parsing->incoming_frame_size, |
| 526 | stream_parsing->incoming_window); |
| 527 | return GRPC_CHTTP2_CONNECTION_ERROR; |
| 528 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 529 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 530 | GRPC_CHTTP2_FLOW_DEBIT_TRANSPORT("parse", transport_parsing, incoming_window, |
| 531 | incoming_frame_size); |
| 532 | GRPC_CHTTP2_FLOW_DEBIT_STREAM("parse", transport_parsing, stream_parsing, |
| 533 | incoming_window, incoming_frame_size); |
| 534 | stream_parsing->received_bytes += incoming_frame_size; |
Craig Tiller | 285b882 | 2015-06-17 15:58:13 -0700 | [diff] [blame] | 535 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 536 | grpc_chttp2_list_add_parsing_seen_stream(transport_parsing, stream_parsing); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 537 | |
| 538 | return GRPC_CHTTP2_PARSE_OK; |
| 539 | } |
| 540 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 541 | static int init_data_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 542 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 543 | grpc_chttp2_stream_parsing *stream_parsing = |
| 544 | grpc_chttp2_parsing_lookup_stream(transport_parsing, |
| 545 | transport_parsing->incoming_stream_id); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 546 | grpc_chttp2_parse_error err = GRPC_CHTTP2_PARSE_OK; |
Craig Tiller | 4aa71a1 | 2015-06-15 13:00:55 -0700 | [diff] [blame] | 547 | if (!stream_parsing || stream_parsing->received_close) |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 548 | return init_skip_frame_parser(exec_ctx, transport_parsing, 0); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 549 | if (err == GRPC_CHTTP2_PARSE_OK) { |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 550 | err = update_incoming_window(exec_ctx, transport_parsing, stream_parsing); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 551 | } |
| 552 | if (err == GRPC_CHTTP2_PARSE_OK) { |
| 553 | err = grpc_chttp2_data_parser_begin_frame( |
| 554 | &stream_parsing->data_parser, transport_parsing->incoming_frame_flags); |
| 555 | } |
| 556 | switch (err) { |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 557 | case GRPC_CHTTP2_PARSE_OK: |
| 558 | transport_parsing->incoming_stream = stream_parsing; |
| 559 | transport_parsing->parser = grpc_chttp2_data_parser_parse; |
| 560 | transport_parsing->parser_data = &stream_parsing->data_parser; |
| 561 | return 1; |
| 562 | case GRPC_CHTTP2_STREAM_ERROR: |
| 563 | stream_parsing->received_close = 1; |
Craig Tiller | 5dc3b30 | 2015-06-15 16:06:50 -0700 | [diff] [blame] | 564 | stream_parsing->saw_rst_stream = 1; |
| 565 | stream_parsing->rst_stream_reason = GRPC_CHTTP2_PROTOCOL_ERROR; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 566 | gpr_slice_buffer_add( |
| 567 | &transport_parsing->qbuf, |
| 568 | grpc_chttp2_rst_stream_create(transport_parsing->incoming_stream_id, |
| 569 | GRPC_CHTTP2_PROTOCOL_ERROR)); |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 570 | return init_skip_frame_parser(exec_ctx, transport_parsing, 0); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 571 | case GRPC_CHTTP2_CONNECTION_ERROR: |
| 572 | return 0; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 573 | } |
yang-g | b063c87 | 2015-10-07 11:40:13 -0700 | [diff] [blame] | 574 | GPR_UNREACHABLE_CODE(return 0); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 575 | } |
| 576 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 577 | static void free_timeout(void *p) { gpr_free(p); } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 578 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 579 | static void on_initial_header(void *tp, grpc_mdelem *md) { |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 580 | grpc_chttp2_transport_parsing *transport_parsing = tp; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 581 | grpc_chttp2_stream_parsing *stream_parsing = |
| 582 | transport_parsing->incoming_stream; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 583 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 584 | GPR_TIMER_BEGIN("on_initial_header", 0); |
| 585 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 586 | GPR_ASSERT(stream_parsing); |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 587 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 588 | GRPC_CHTTP2_IF_TRACING(gpr_log( |
| 589 | GPR_INFO, "HTTP:%d:HDR:%s: %s: %s", stream_parsing->id, |
| 590 | transport_parsing->is_client ? "CLI" : "SVR", |
| 591 | grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value))); |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 592 | |
Craig Tiller | b2b4261 | 2015-11-20 12:02:17 -0800 | [diff] [blame] | 593 | if (md->key == GRPC_MDSTR_GRPC_STATUS && md != GRPC_MDELEM_GRPC_STATUS_0) { |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 594 | /* TODO(ctiller): check for a status like " 0" */ |
| 595 | stream_parsing->seen_error = 1; |
| 596 | } |
| 597 | |
Craig Tiller | b2b4261 | 2015-11-20 12:02:17 -0800 | [diff] [blame] | 598 | if (md->key == GRPC_MDSTR_GRPC_TIMEOUT) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 599 | gpr_timespec *cached_timeout = grpc_mdelem_get_user_data(md, free_timeout); |
| 600 | if (!cached_timeout) { |
| 601 | /* not already parsed: parse it now, and store the result away */ |
| 602 | cached_timeout = gpr_malloc(sizeof(gpr_timespec)); |
| 603 | if (!grpc_chttp2_decode_timeout(grpc_mdstr_as_c_string(md->value), |
| 604 | cached_timeout)) { |
| 605 | gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'", |
| 606 | grpc_mdstr_as_c_string(md->value)); |
Craig Tiller | 25fd571 | 2015-12-09 08:58:47 -0800 | [diff] [blame] | 607 | *cached_timeout = gpr_inf_future(GPR_TIMESPAN); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 608 | } |
| 609 | grpc_mdelem_set_user_data(md, free_timeout, cached_timeout); |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 610 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 611 | grpc_chttp2_incoming_metadata_buffer_set_deadline( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 612 | &stream_parsing->metadata_buffer[0], |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 613 | gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), *cached_timeout)); |
| 614 | GRPC_MDELEM_UNREF(md); |
| 615 | } else { |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 616 | grpc_chttp2_incoming_metadata_buffer_add( |
| 617 | &stream_parsing->metadata_buffer[0], md); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 618 | } |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 619 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 620 | grpc_chttp2_list_add_parsing_seen_stream(transport_parsing, stream_parsing); |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 621 | |
| 622 | GPR_TIMER_END("on_initial_header", 0); |
| 623 | } |
| 624 | |
| 625 | static void on_trailing_header(void *tp, grpc_mdelem *md) { |
| 626 | grpc_chttp2_transport_parsing *transport_parsing = tp; |
| 627 | grpc_chttp2_stream_parsing *stream_parsing = |
| 628 | transport_parsing->incoming_stream; |
| 629 | |
| 630 | GPR_TIMER_BEGIN("on_trailing_header", 0); |
| 631 | |
| 632 | GPR_ASSERT(stream_parsing); |
| 633 | |
| 634 | GRPC_CHTTP2_IF_TRACING(gpr_log( |
| 635 | GPR_INFO, "HTTP:%d:TRL:%s: %s: %s", stream_parsing->id, |
| 636 | transport_parsing->is_client ? "CLI" : "SVR", |
| 637 | grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value))); |
| 638 | |
Craig Tiller | b2b4261 | 2015-11-20 12:02:17 -0800 | [diff] [blame] | 639 | if (md->key == GRPC_MDSTR_GRPC_STATUS && md != GRPC_MDELEM_GRPC_STATUS_0) { |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 640 | /* TODO(ctiller): check for a status like " 0" */ |
| 641 | stream_parsing->seen_error = 1; |
| 642 | } |
| 643 | |
| 644 | grpc_chttp2_incoming_metadata_buffer_add(&stream_parsing->metadata_buffer[1], |
| 645 | md); |
| 646 | |
| 647 | grpc_chttp2_list_add_parsing_seen_stream(transport_parsing, stream_parsing); |
| 648 | |
| 649 | GPR_TIMER_END("on_trailing_header", 0); |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 650 | } |
| 651 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 652 | static int init_header_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 653 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing, |
| 654 | int is_continuation) { |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 655 | uint8_t is_eoh = (transport_parsing->incoming_frame_flags & |
| 656 | GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0; |
Craig Tiller | b951df1 | 2015-06-18 15:46:58 -0700 | [diff] [blame] | 657 | int via_accept = 0; |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 658 | grpc_chttp2_stream_parsing *stream_parsing; |
| 659 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 660 | /* TODO(ctiller): when to increment header_frames_received? */ |
| 661 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 662 | if (is_eoh) { |
| 663 | transport_parsing->expect_continuation_stream_id = 0; |
| 664 | } else { |
| 665 | transport_parsing->expect_continuation_stream_id = |
| 666 | transport_parsing->incoming_stream_id; |
| 667 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 668 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 669 | if (!is_continuation) { |
| 670 | transport_parsing->header_eof = (transport_parsing->incoming_frame_flags & |
| 671 | GRPC_CHTTP2_DATA_FLAG_END_STREAM) != 0; |
| 672 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 673 | |
| 674 | /* could be a new grpc_chttp2_stream or an existing grpc_chttp2_stream */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 675 | stream_parsing = grpc_chttp2_parsing_lookup_stream( |
| 676 | transport_parsing, transport_parsing->incoming_stream_id); |
| 677 | if (stream_parsing == NULL) { |
| 678 | if (is_continuation) { |
| 679 | gpr_log(GPR_ERROR, |
| 680 | "grpc_chttp2_stream disbanded before CONTINUATION received"); |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 681 | return init_skip_frame_parser(exec_ctx, transport_parsing, 1); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 682 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 683 | if (transport_parsing->is_client) { |
| 684 | if ((transport_parsing->incoming_stream_id & 1) && |
| 685 | transport_parsing->incoming_stream_id < |
| 686 | transport_parsing->next_stream_id) { |
| 687 | /* this is an old (probably cancelled) grpc_chttp2_stream */ |
| 688 | } else { |
| 689 | gpr_log(GPR_ERROR, |
| 690 | "ignoring new grpc_chttp2_stream creation on client"); |
| 691 | } |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 692 | return init_skip_frame_parser(exec_ctx, transport_parsing, 1); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 693 | } else if (transport_parsing->last_incoming_stream_id > |
| 694 | transport_parsing->incoming_stream_id) { |
| 695 | gpr_log(GPR_ERROR, |
| 696 | "ignoring out of order new grpc_chttp2_stream request on server; " |
| 697 | "last grpc_chttp2_stream " |
| 698 | "id=%d, new grpc_chttp2_stream id=%d", |
| 699 | transport_parsing->last_incoming_stream_id, |
| 700 | transport_parsing->incoming_stream_id); |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 701 | return init_skip_frame_parser(exec_ctx, transport_parsing, 1); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 702 | } else if ((transport_parsing->incoming_stream_id & 1) == 0) { |
| 703 | gpr_log(GPR_ERROR, |
| 704 | "ignoring grpc_chttp2_stream with non-client generated index %d", |
| 705 | transport_parsing->incoming_stream_id); |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 706 | return init_skip_frame_parser(exec_ctx, transport_parsing, 1); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 707 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 708 | stream_parsing = transport_parsing->incoming_stream = |
| 709 | grpc_chttp2_parsing_accept_stream( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 710 | exec_ctx, transport_parsing, transport_parsing->incoming_stream_id); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 711 | if (stream_parsing == NULL) { |
| 712 | gpr_log(GPR_ERROR, "grpc_chttp2_stream not accepted"); |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 713 | return init_skip_frame_parser(exec_ctx, transport_parsing, 1); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 714 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 715 | via_accept = 1; |
| 716 | } else { |
| 717 | transport_parsing->incoming_stream = stream_parsing; |
| 718 | } |
| 719 | GPR_ASSERT(stream_parsing != NULL && (via_accept == 0 || via_accept == 1)); |
| 720 | if (stream_parsing->received_close) { |
| 721 | gpr_log(GPR_ERROR, "skipping already closed grpc_chttp2_stream header"); |
| 722 | transport_parsing->incoming_stream = NULL; |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 723 | return init_skip_frame_parser(exec_ctx, transport_parsing, 1); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 724 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 725 | transport_parsing->parser = grpc_chttp2_header_parser_parse; |
| 726 | transport_parsing->parser_data = &transport_parsing->hpack_parser; |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 727 | switch (stream_parsing->header_frames_received) { |
| 728 | case 0: |
| 729 | transport_parsing->hpack_parser.on_header = on_initial_header; |
| 730 | break; |
| 731 | case 1: |
| 732 | transport_parsing->hpack_parser.on_header = on_trailing_header; |
| 733 | break; |
| 734 | case 2: |
| 735 | gpr_log(GPR_ERROR, "too many header frames received"); |
| 736 | return init_skip_frame_parser(exec_ctx, transport_parsing, 1); |
| 737 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 738 | transport_parsing->hpack_parser.on_header_user_data = transport_parsing; |
| 739 | transport_parsing->hpack_parser.is_boundary = is_eoh; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 740 | transport_parsing->hpack_parser.is_eof = |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 741 | (uint8_t)(is_eoh ? transport_parsing->header_eof : 0); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 742 | if (!is_continuation && (transport_parsing->incoming_frame_flags & |
| 743 | GRPC_CHTTP2_FLAG_HAS_PRIORITY)) { |
| 744 | grpc_chttp2_hpack_parser_set_has_priority(&transport_parsing->hpack_parser); |
| 745 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 746 | return 1; |
| 747 | } |
| 748 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 749 | static int init_window_update_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 750 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 751 | int ok = GRPC_CHTTP2_PARSE_OK == grpc_chttp2_window_update_parser_begin_frame( |
| 752 | &transport_parsing->simple.window_update, |
| 753 | transport_parsing->incoming_frame_size, |
| 754 | transport_parsing->incoming_frame_flags); |
| 755 | if (transport_parsing->incoming_stream_id) { |
| 756 | transport_parsing->incoming_stream = grpc_chttp2_parsing_lookup_stream( |
| 757 | transport_parsing, transport_parsing->incoming_stream_id); |
| 758 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 759 | transport_parsing->parser = grpc_chttp2_window_update_parser_parse; |
| 760 | transport_parsing->parser_data = &transport_parsing->simple.window_update; |
| 761 | return ok; |
| 762 | } |
| 763 | |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 764 | static int init_ping_parser(grpc_exec_ctx *exec_ctx, |
| 765 | grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 766 | int ok = GRPC_CHTTP2_PARSE_OK == grpc_chttp2_ping_parser_begin_frame( |
| 767 | &transport_parsing->simple.ping, |
| 768 | transport_parsing->incoming_frame_size, |
| 769 | transport_parsing->incoming_frame_flags); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 770 | transport_parsing->parser = grpc_chttp2_ping_parser_parse; |
| 771 | transport_parsing->parser_data = &transport_parsing->simple.ping; |
| 772 | return ok; |
| 773 | } |
| 774 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 775 | static int init_rst_stream_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 776 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 777 | int ok = GRPC_CHTTP2_PARSE_OK == grpc_chttp2_rst_stream_parser_begin_frame( |
| 778 | &transport_parsing->simple.rst_stream, |
| 779 | transport_parsing->incoming_frame_size, |
| 780 | transport_parsing->incoming_frame_flags); |
| 781 | transport_parsing->incoming_stream = grpc_chttp2_parsing_lookup_stream( |
| 782 | transport_parsing, transport_parsing->incoming_stream_id); |
| 783 | if (!transport_parsing->incoming_stream) { |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 784 | return init_skip_frame_parser(exec_ctx, transport_parsing, 0); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 785 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 786 | transport_parsing->parser = grpc_chttp2_rst_stream_parser_parse; |
| 787 | transport_parsing->parser_data = &transport_parsing->simple.rst_stream; |
| 788 | return ok; |
| 789 | } |
| 790 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 791 | static int init_goaway_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 792 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 793 | int ok = GRPC_CHTTP2_PARSE_OK == grpc_chttp2_goaway_parser_begin_frame( |
| 794 | &transport_parsing->goaway_parser, |
| 795 | transport_parsing->incoming_frame_size, |
| 796 | transport_parsing->incoming_frame_flags); |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 797 | transport_parsing->parser = grpc_chttp2_goaway_parser_parse; |
| 798 | transport_parsing->parser_data = &transport_parsing->goaway_parser; |
| 799 | return ok; |
| 800 | } |
| 801 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 802 | static int init_settings_frame_parser( |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 803 | grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing) { |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 804 | int ok; |
| 805 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 806 | if (transport_parsing->incoming_stream_id != 0) { |
| 807 | gpr_log(GPR_ERROR, "settings frame received for grpc_chttp2_stream %d", |
| 808 | transport_parsing->incoming_stream_id); |
| 809 | return 0; |
| 810 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 811 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 812 | ok = GRPC_CHTTP2_PARSE_OK == grpc_chttp2_settings_parser_begin_frame( |
| 813 | &transport_parsing->simple.settings, |
| 814 | transport_parsing->incoming_frame_size, |
| 815 | transport_parsing->incoming_frame_flags, |
| 816 | transport_parsing->settings); |
| 817 | if (!ok) { |
| 818 | return 0; |
| 819 | } |
| 820 | if (transport_parsing->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) { |
| 821 | transport_parsing->settings_ack_received = 1; |
Craig Tiller | 3c53bb2 | 2015-11-10 14:24:36 +0000 | [diff] [blame] | 822 | grpc_chttp2_hptbl_set_max_bytes( |
| 823 | &transport_parsing->hpack_parser.table, |
| 824 | transport_parsing->last_sent_max_table_size); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 825 | } |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 826 | transport_parsing->parser = grpc_chttp2_settings_parser_parse; |
| 827 | transport_parsing->parser_data = &transport_parsing->simple.settings; |
| 828 | return ok; |
| 829 | } |
| 830 | |
| 831 | /* |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 832 | static int is_window_update_legal(int64_t window_update, int64_t window) { |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 833 | return window + window_update < MAX_WINDOW; |
| 834 | } |
| 835 | */ |
| 836 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 837 | static int parse_frame_slice(grpc_exec_ctx *exec_ctx, |
| 838 | grpc_chttp2_transport_parsing *transport_parsing, |
| 839 | gpr_slice slice, int is_last) { |
| 840 | grpc_chttp2_stream_parsing *stream_parsing = |
| 841 | transport_parsing->incoming_stream; |
| 842 | switch (transport_parsing->parser(exec_ctx, transport_parsing->parser_data, |
| 843 | transport_parsing, stream_parsing, slice, |
| 844 | is_last)) { |
Craig Tiller | d20efd2 | 2015-06-12 16:17:09 -0700 | [diff] [blame] | 845 | case GRPC_CHTTP2_PARSE_OK: |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 846 | if (stream_parsing) { |
| 847 | grpc_chttp2_list_add_parsing_seen_stream(transport_parsing, |
| 848 | stream_parsing); |
| 849 | } |
Craig Tiller | 3719f07 | 2015-06-12 17:19:51 -0700 | [diff] [blame] | 850 | return 1; |
| 851 | case GRPC_CHTTP2_STREAM_ERROR: |
Craig Tiller | 9d35a1f | 2015-11-02 14:16:12 -0800 | [diff] [blame] | 852 | grpc_chttp2_parsing_become_skip_parser(exec_ctx, transport_parsing); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 853 | if (stream_parsing) { |
| 854 | stream_parsing->saw_rst_stream = 1; |
| 855 | stream_parsing->rst_stream_reason = GRPC_CHTTP2_PROTOCOL_ERROR; |
| 856 | gpr_slice_buffer_add( |
| 857 | &transport_parsing->qbuf, |
| 858 | grpc_chttp2_rst_stream_create(transport_parsing->incoming_stream_id, |
| 859 | GRPC_CHTTP2_PROTOCOL_ERROR)); |
| 860 | } |
Craig Tiller | 3719f07 | 2015-06-12 17:19:51 -0700 | [diff] [blame] | 861 | return 1; |
| 862 | case GRPC_CHTTP2_CONNECTION_ERROR: |
| 863 | return 0; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 864 | } |
yang-g | b063c87 | 2015-10-07 11:40:13 -0700 | [diff] [blame] | 865 | GPR_UNREACHABLE_CODE(return 0); |
Craig Tiller | 3719f07 | 2015-06-12 17:19:51 -0700 | [diff] [blame] | 866 | } |