| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/http2/decoder/decode_http2_structures.h" | |
| 6 | |
| 7 #include <string.h> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "net/http2/decoder/decode_buffer.h" | |
| 11 #include "net/http2/http2_constants.h" | |
| 12 | |
| 13 namespace net { | |
| 14 | |
| 15 // Http2FrameHeader decoding: | |
| 16 | |
| 17 void DoDecode(Http2FrameHeader* out, DecodeBuffer* b) { | |
| 18 DCHECK_NE(nullptr, out); | |
| 19 DCHECK_NE(nullptr, b); | |
| 20 DCHECK_LE(Http2FrameHeader::EncodedSize(), b->Remaining()); | |
| 21 out->payload_length = b->DecodeUInt24(); | |
| 22 out->type = static_cast<Http2FrameType>(b->DecodeUInt8()); | |
| 23 out->flags = static_cast<Http2FrameFlag>(b->DecodeUInt8()); | |
| 24 out->stream_id = b->DecodeUInt31(); | |
| 25 } | |
| 26 | |
| 27 bool MaybeDecode(Http2FrameHeader* out, DecodeBuffer* b) { | |
| 28 DCHECK_NE(nullptr, out); | |
| 29 DCHECK_NE(nullptr, b); | |
| 30 if (b->Remaining() >= Http2FrameHeader::EncodedSize()) { | |
| 31 DoDecode(out, b); | |
| 32 return true; | |
| 33 } | |
| 34 return false; | |
| 35 } | |
| 36 | |
| 37 bool SlowDecode(Http2FrameHeader* out, DecodeBuffer* b, uint32_t* offset) { | |
| 38 DCHECK_NE(nullptr, out); | |
| 39 DCHECK_NE(nullptr, b); | |
| 40 DCHECK_NE(nullptr, offset); | |
| 41 DCHECK_GT(Http2FrameHeader::EncodedSize(), *offset); | |
| 42 if (b->SlowDecodeUInt24(0 /* field_offset */, offset, &out->payload_length) && | |
| 43 b->SlowDecodeEnum(1 /* field_size */, 3 /* field_offset */, offset, | |
| 44 &out->type) && | |
| 45 b->SlowDecodeEnum(1 /* field_size */, 4 /* field_offset */, offset, | |
| 46 &out->flags) && | |
| 47 b->SlowDecodeUInt31(5 /* field_offset */, offset, &out->stream_id)) { | |
| 48 DCHECK_EQ(Http2FrameHeader::EncodedSize(), *offset); | |
| 49 return true; | |
| 50 } | |
| 51 DCHECK_GT(Http2FrameHeader::EncodedSize(), *offset); | |
| 52 return false; | |
| 53 } | |
| 54 | |
| 55 // Http2PriorityFields decoding: | |
| 56 | |
| 57 void DoDecode(Http2PriorityFields* out, DecodeBuffer* b) { | |
| 58 DCHECK_NE(nullptr, out); | |
| 59 DCHECK_NE(nullptr, b); | |
| 60 DCHECK_LE(Http2PriorityFields::EncodedSize(), b->Remaining()); | |
| 61 uint32_t stream_id_and_flag = b->DecodeUInt32(); | |
| 62 out->stream_dependency = stream_id_and_flag & StreamIdMask(); | |
| 63 if (out->stream_dependency == stream_id_and_flag) { | |
| 64 out->is_exclusive = false; | |
| 65 } else { | |
| 66 out->is_exclusive = true; | |
| 67 } | |
| 68 // Note that chars are automatically promoted to ints during arithmetic, | |
| 69 // so 255 + 1 doesn't end up as zero. | |
| 70 out->weight = b->DecodeUInt8() + 1; | |
| 71 } | |
| 72 | |
| 73 bool MaybeDecode(Http2PriorityFields* out, DecodeBuffer* b) { | |
| 74 DCHECK_NE(nullptr, out); | |
| 75 DCHECK_NE(nullptr, b); | |
| 76 if (b->Remaining() >= Http2PriorityFields::EncodedSize()) { | |
| 77 DoDecode(out, b); | |
| 78 return true; | |
| 79 } | |
| 80 return false; | |
| 81 } | |
| 82 | |
| 83 bool SlowDecode(Http2PriorityFields* out, DecodeBuffer* b, uint32_t* offset) { | |
| 84 DCHECK_NE(nullptr, out); | |
| 85 DCHECK_NE(nullptr, b); | |
| 86 DCHECK_NE(nullptr, offset); | |
| 87 DCHECK_GT(Http2PriorityFields::EncodedSize(), *offset); | |
| 88 const uint32_t start_offset = *offset; | |
| 89 if (b->SlowDecodeUInt32(0 /* field_offset */, offset, | |
| 90 &out->stream_dependency) && | |
| 91 b->SlowDecodeUnsignedInt(1, // field_size | |
| 92 4, // field_offset | |
| 93 offset, &out->weight)) { | |
| 94 DCHECK_EQ(Http2PriorityFields::EncodedSize(), *offset); | |
| 95 if (start_offset < *offset) { | |
| 96 // First time here. Extract is_exclusive from stream_dependency. | |
| 97 const uint32_t stream_id_only = out->stream_dependency & StreamIdMask(); | |
| 98 if (out->stream_dependency != stream_id_only) { | |
| 99 out->stream_dependency = stream_id_only; | |
| 100 out->is_exclusive = true; | |
| 101 } else { | |
| 102 out->is_exclusive = false; | |
| 103 } | |
| 104 // Need to add one to the weight field because the encoding is 0-255, but | |
| 105 // interpreted as 1-256. | |
| 106 ++(out->weight); | |
| 107 } | |
| 108 return true; | |
| 109 } | |
| 110 DCHECK_GT(Http2PriorityFields::EncodedSize(), *offset); | |
| 111 return false; | |
| 112 } | |
| 113 | |
| 114 // Http2RstStreamFields decoding: | |
| 115 | |
| 116 void DoDecode(Http2RstStreamFields* out, DecodeBuffer* b) { | |
| 117 DCHECK_NE(nullptr, out); | |
| 118 DCHECK_NE(nullptr, b); | |
| 119 DCHECK_LE(Http2RstStreamFields::EncodedSize(), b->Remaining()); | |
| 120 out->error_code = static_cast<Http2ErrorCode>(b->DecodeUInt32()); | |
| 121 } | |
| 122 | |
| 123 bool MaybeDecode(Http2RstStreamFields* out, DecodeBuffer* b) { | |
| 124 DCHECK_NE(nullptr, out); | |
| 125 DCHECK_NE(nullptr, b); | |
| 126 if (b->Remaining() >= Http2RstStreamFields::EncodedSize()) { | |
| 127 DoDecode(out, b); | |
| 128 return true; | |
| 129 } | |
| 130 return false; | |
| 131 } | |
| 132 | |
| 133 bool SlowDecode(Http2RstStreamFields* out, DecodeBuffer* b, uint32_t* offset) { | |
| 134 DCHECK_NE(nullptr, out); | |
| 135 DCHECK_NE(nullptr, b); | |
| 136 DCHECK_NE(nullptr, offset); | |
| 137 DCHECK_GT(Http2RstStreamFields::EncodedSize(), *offset); | |
| 138 | |
| 139 if (b->SlowDecodeEnum(4 /* field_size */, 0 /* field_offset */, offset, | |
| 140 &out->error_code)) { | |
| 141 DCHECK_EQ(Http2RstStreamFields::EncodedSize(), *offset); | |
| 142 return true; | |
| 143 } | |
| 144 DCHECK_GT(Http2RstStreamFields::EncodedSize(), *offset); | |
| 145 return false; | |
| 146 } | |
| 147 | |
| 148 // Http2SettingFields decoding: | |
| 149 | |
| 150 void DoDecode(Http2SettingFields* out, DecodeBuffer* b) { | |
| 151 DCHECK_NE(nullptr, out); | |
| 152 DCHECK_NE(nullptr, b); | |
| 153 DCHECK_LE(Http2SettingFields::EncodedSize(), b->Remaining()); | |
| 154 out->parameter = static_cast<Http2SettingsParameter>(b->DecodeUInt16()); | |
| 155 out->value = b->DecodeUInt32(); | |
| 156 } | |
| 157 | |
| 158 bool MaybeDecode(Http2SettingFields* out, DecodeBuffer* b) { | |
| 159 DCHECK_NE(nullptr, out); | |
| 160 DCHECK_NE(nullptr, b); | |
| 161 if (b->Remaining() >= Http2SettingFields::EncodedSize()) { | |
| 162 DoDecode(out, b); | |
| 163 return true; | |
| 164 } | |
| 165 return false; | |
| 166 } | |
| 167 | |
| 168 bool SlowDecode(Http2SettingFields* out, DecodeBuffer* b, uint32_t* offset) { | |
| 169 DCHECK_NE(nullptr, out); | |
| 170 DCHECK_NE(nullptr, b); | |
| 171 DCHECK_NE(nullptr, offset); | |
| 172 DCHECK_LT(*offset, Http2SettingFields::EncodedSize()); | |
| 173 | |
| 174 if (b->SlowDecodeEnum(2 /* field_size */, 0 /* field_offset */, offset, | |
| 175 &out->parameter) && | |
| 176 b->SlowDecodeUInt32(2 /* field_offset */, offset, &out->value)) { | |
| 177 DCHECK_EQ(Http2SettingFields::EncodedSize(), *offset); | |
| 178 return true; | |
| 179 } | |
| 180 DCHECK_LT(*offset, Http2SettingFields::EncodedSize()); | |
| 181 return false; | |
| 182 } | |
| 183 | |
| 184 // Http2PushPromiseFields decoding: | |
| 185 | |
| 186 void DoDecode(Http2PushPromiseFields* out, DecodeBuffer* b) { | |
| 187 DCHECK_NE(nullptr, out); | |
| 188 DCHECK_NE(nullptr, b); | |
| 189 DCHECK_LE(Http2PushPromiseFields::EncodedSize(), b->Remaining()); | |
| 190 out->promised_stream_id = b->DecodeUInt31(); | |
| 191 } | |
| 192 | |
| 193 bool MaybeDecode(Http2PushPromiseFields* out, DecodeBuffer* b) { | |
| 194 DCHECK_NE(nullptr, out); | |
| 195 DCHECK_NE(nullptr, b); | |
| 196 if (b->Remaining() >= Http2PushPromiseFields::EncodedSize()) { | |
| 197 DoDecode(out, b); | |
| 198 return true; | |
| 199 } | |
| 200 return false; | |
| 201 } | |
| 202 | |
| 203 bool SlowDecode(Http2PushPromiseFields* out, | |
| 204 DecodeBuffer* b, | |
| 205 uint32_t* offset) { | |
| 206 DCHECK_NE(nullptr, out); | |
| 207 DCHECK_NE(nullptr, b); | |
| 208 DCHECK_NE(nullptr, offset); | |
| 209 DCHECK_LT(*offset, Http2PushPromiseFields::EncodedSize()); | |
| 210 if (b->SlowDecodeUInt31(0 /* field_offset */, offset, | |
| 211 &out->promised_stream_id)) { | |
| 212 DCHECK_EQ(Http2PushPromiseFields::EncodedSize(), *offset); | |
| 213 return true; | |
| 214 } | |
| 215 DCHECK_LT(*offset, Http2PushPromiseFields::EncodedSize()); | |
| 216 return false; | |
| 217 } | |
| 218 | |
| 219 // Http2PingFields decoding: | |
| 220 | |
| 221 void DoDecode(Http2PingFields* out, DecodeBuffer* b) { | |
| 222 DCHECK_NE(nullptr, out); | |
| 223 DCHECK_NE(nullptr, b); | |
| 224 DCHECK_LE(Http2PingFields::EncodedSize(), b->Remaining()); | |
| 225 memcpy(out->opaque_data, b->cursor(), Http2PingFields::EncodedSize()); | |
| 226 b->AdvanceCursor(Http2PingFields::EncodedSize()); | |
| 227 } | |
| 228 | |
| 229 bool MaybeDecode(Http2PingFields* out, DecodeBuffer* b) { | |
| 230 DCHECK_NE(nullptr, out); | |
| 231 DCHECK_NE(nullptr, b); | |
| 232 if (b->Remaining() >= Http2PingFields::EncodedSize()) { | |
| 233 DoDecode(out, b); | |
| 234 return true; | |
| 235 } | |
| 236 return false; | |
| 237 } | |
| 238 | |
| 239 bool SlowDecode(Http2PingFields* out, DecodeBuffer* b, uint32_t* offset) { | |
| 240 DCHECK_NE(nullptr, out); | |
| 241 DCHECK_NE(nullptr, b); | |
| 242 DCHECK_NE(nullptr, offset); | |
| 243 DCHECK_LT(*offset, Http2PingFields::EncodedSize()); | |
| 244 while (*offset < Http2PingFields::EncodedSize()) { | |
| 245 if (b->Empty()) { | |
| 246 return false; | |
| 247 } | |
| 248 out->opaque_data[(*offset)++] = b->DecodeUInt8(); | |
| 249 } | |
| 250 return true; | |
| 251 } | |
| 252 | |
| 253 // Http2GoAwayFields decoding: | |
| 254 | |
| 255 void DoDecode(Http2GoAwayFields* out, DecodeBuffer* b) { | |
| 256 DCHECK_NE(nullptr, out); | |
| 257 DCHECK_NE(nullptr, b); | |
| 258 DCHECK_LE(Http2GoAwayFields::EncodedSize(), b->Remaining()); | |
| 259 out->last_stream_id = b->DecodeUInt31(); | |
| 260 out->error_code = static_cast<Http2ErrorCode>(b->DecodeUInt32()); | |
| 261 } | |
| 262 | |
| 263 bool MaybeDecode(Http2GoAwayFields* out, DecodeBuffer* b) { | |
| 264 DCHECK_NE(nullptr, out); | |
| 265 DCHECK_NE(nullptr, b); | |
| 266 if (b->Remaining() >= Http2GoAwayFields::EncodedSize()) { | |
| 267 DoDecode(out, b); | |
| 268 return true; | |
| 269 } | |
| 270 return false; | |
| 271 } | |
| 272 | |
| 273 bool SlowDecode(Http2GoAwayFields* out, DecodeBuffer* b, uint32_t* offset) { | |
| 274 DCHECK_NE(nullptr, out); | |
| 275 DCHECK_NE(nullptr, b); | |
| 276 DCHECK_NE(nullptr, offset); | |
| 277 DCHECK_LT(*offset, Http2GoAwayFields::EncodedSize()); | |
| 278 if (b->SlowDecodeUInt31(0 /* field_offset */, offset, &out->last_stream_id) && | |
| 279 b->SlowDecodeEnum(4 /* field_size */, 4 /* field_offset */, offset, | |
| 280 &out->error_code)) { | |
| 281 DCHECK_EQ(Http2GoAwayFields::EncodedSize(), *offset); | |
| 282 return true; | |
| 283 } | |
| 284 DCHECK_LT(*offset, Http2GoAwayFields::EncodedSize()); | |
| 285 return false; | |
| 286 } | |
| 287 | |
| 288 // Http2WindowUpdateFields decoding: | |
| 289 | |
| 290 void DoDecode(Http2WindowUpdateFields* out, DecodeBuffer* b) { | |
| 291 DCHECK_NE(nullptr, out); | |
| 292 DCHECK_NE(nullptr, b); | |
| 293 DCHECK_LE(Http2WindowUpdateFields::EncodedSize(), b->Remaining()); | |
| 294 out->window_size_increment = b->DecodeUInt31(); | |
| 295 } | |
| 296 | |
| 297 bool MaybeDecode(Http2WindowUpdateFields* out, DecodeBuffer* b) { | |
| 298 DCHECK_NE(nullptr, out); | |
| 299 DCHECK_NE(nullptr, b); | |
| 300 if (b->Remaining() >= Http2WindowUpdateFields::EncodedSize()) { | |
| 301 DoDecode(out, b); | |
| 302 return true; | |
| 303 } | |
| 304 return false; | |
| 305 } | |
| 306 | |
| 307 bool SlowDecode(Http2WindowUpdateFields* out, | |
| 308 DecodeBuffer* b, | |
| 309 uint32_t* offset) { | |
| 310 DCHECK_NE(nullptr, out); | |
| 311 DCHECK_NE(nullptr, b); | |
| 312 DCHECK_NE(nullptr, offset); | |
| 313 DCHECK_LT(*offset, Http2WindowUpdateFields::EncodedSize()); | |
| 314 if (b->SlowDecodeUInt31(0 /* field_offset */, offset, | |
| 315 &out->window_size_increment)) { | |
| 316 DCHECK_EQ(Http2WindowUpdateFields::EncodedSize(), *offset); | |
| 317 return true; | |
| 318 } | |
| 319 DCHECK_LT(*offset, Http2WindowUpdateFields::EncodedSize()); | |
| 320 return false; | |
| 321 } | |
| 322 | |
| 323 // Http2AltSvcFields decoding: | |
| 324 | |
| 325 void DoDecode(Http2AltSvcFields* out, DecodeBuffer* b) { | |
| 326 DCHECK_NE(nullptr, out); | |
| 327 DCHECK_NE(nullptr, b); | |
| 328 DCHECK_LE(Http2AltSvcFields::EncodedSize(), b->Remaining()); | |
| 329 out->origin_length = b->DecodeUInt16(); | |
| 330 } | |
| 331 | |
| 332 bool MaybeDecode(Http2AltSvcFields* out, DecodeBuffer* b) { | |
| 333 DCHECK_NE(nullptr, out); | |
| 334 DCHECK_NE(nullptr, b); | |
| 335 if (b->Remaining() >= Http2AltSvcFields::EncodedSize()) { | |
| 336 DoDecode(out, b); | |
| 337 return true; | |
| 338 } | |
| 339 return false; | |
| 340 } | |
| 341 | |
| 342 bool SlowDecode(Http2AltSvcFields* out, DecodeBuffer* b, uint32_t* offset) { | |
| 343 DCHECK_NE(nullptr, out); | |
| 344 DCHECK_NE(nullptr, b); | |
| 345 DCHECK_NE(nullptr, offset); | |
| 346 DCHECK_LT(*offset, Http2AltSvcFields::EncodedSize()); | |
| 347 if (b->SlowDecodeUInt16(0 /* field_offset */, offset, &out->origin_length)) { | |
| 348 DCHECK_EQ(Http2AltSvcFields::EncodedSize(), *offset); | |
| 349 return true; | |
| 350 } | |
| 351 DCHECK_LT(*offset, Http2AltSvcFields::EncodedSize()); | |
| 352 return false; | |
| 353 } | |
| 354 | |
| 355 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2554683003:
Revert of Add new HTTP/2 and HPACK decoder in net/http2/. (Closed)
