1 // Copyright (c) 2023 Huawei Device Co., Ltd. 2 // Licensed under the Apache License, Version 2.0 (the "License"); 3 // you may not use this file except in compliance with the License. 4 // You may obtain a copy of the License at 5 // 6 // http://www.apache.org/licenses/LICENSE-2.0 7 // 8 // Unless required by applicable law or agreed to in writing, software 9 // distributed under the License is distributed on an "AS IS" BASIS, 10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 // See the License for the specific language governing permissions and 12 // limitations under the License. 13 14 use std::cmp::min; 15 16 use crate::h2::frame::{FrameFlags, FrameType, Payload, Priority, Setting}; 17 use crate::h2::{Frame, Goaway, HpackEncoder, Settings}; 18 19 // TODO: Classify encoder errors per RFC specifications into categories like 20 // stream or connection errors. Identify specific error types such as 21 // Frame_size_error/Protocol Error. 22 const DEFAULT_MAX_FRAME_SIZE: usize = 16384; 23 24 const DEFAULT_HEADER_TABLE_SIZE: usize = 4096; 25 26 #[derive(Debug)] 27 pub enum FrameEncoderErr { 28 EncodingData, 29 UnexpectedPayloadType, 30 NoCurrentFrame, 31 InternalError, 32 HeadersNotEnd, 33 } 34 35 #[derive(PartialEq, Debug)] 36 enum FrameEncoderState { 37 // The initial state for the frame encoder. 38 Idle, 39 // The initial state for encoding the HEADERS frame, including the frame header and the Field 40 // Block Fragment. 41 EncodingHeadersFrame, 42 // The state for encoding the payload of the HEADERS frame, including the header block 43 // fragment. 44 EncodingHeadersPayload, 45 // The state for encoding the padding octets for the HEADERS frame, if the PADDED flag is set. 46 EncodingHeadersPadding, 47 // TODO compare to max_header_list_size 48 // The state for encoding CONTINUATION frames if the header block exceeds the max_frame_size. 49 EncodingContinuationFrames, 50 // The final state, indicating that the HEADERS frame and any necessary CONTINUATION frames 51 // have been fully encoded. 52 HeadersComplete, 53 // The initial state for encoding the DATA frame, including the frame header and the Pad 54 // Length field (if PADDED flag is set). 55 EncodingDataHeader, 56 // The state for encoding the actual data payload of the DATA frame. 57 EncodingDataPayload, 58 // The state for encoding the padding octets for the DATA frame, if the PADDED flag is set. 59 EncodingDataPadding, 60 // The initial state for encoding the SETTINGS frame, including the frame header. 61 EncodingSettingsFrame, 62 // The state for encoding the SETTINGS frame payload. 63 EncodingSettingsPayload, 64 // The initial state for encoding the GOAWAY frame, including the frame header. 65 EncodingGoawayFrame, 66 // The state for encoding the GOAWAY frame payload. 67 EncodingGoawayPayload, 68 // The initial state for encoding the WINDOW_UPDATE frame, including the frame header. 69 EncodingWindowUpdateFrame, 70 // The state for encoding the WINDOW_UPDATE frame payload. 71 EncodingWindowUpdatePayload, 72 // The initial state for encoding the PRIORITY frame, including the frame header. 73 EncodingPriorityFrame, 74 // The state for encoding Priority frame payload. 75 EncodingPriorityPayload, 76 // The initial state for encoding the RST_STREAM frame, including the frame header. 77 EncodingRstStreamFrame, 78 // The state for encoding the RST_STREAM frame payload. 79 EncodingRstStreamPayload, 80 // The initial state for encoding the PING frame, including the frame header. 81 EncodingPingFrame, 82 // The state for encoding the PING frame payload. 83 EncodingPingPayload, 84 // The final state, indicating that the DATA frame has been fully encoded. 85 DataComplete, 86 } 87 88 /// A structure for encoding frames into bytes, supporting the serialization of 89 /// HTTP/2 Frames. It maintains the state of the current frame being encoded and 90 /// also handles the fragmentation of frames. 91 pub struct FrameEncoder { 92 current_frame: Option<Frame>, 93 // `max_frame_size` is actually useless in the Encoder for headers frame and continuation 94 // frame, because the frame length does not exceed the length of the 95 // `header_payload_buffer` 96 max_frame_size: usize, 97 max_header_list_size: usize, 98 hpack_encoder: HpackEncoder, 99 state: FrameEncoderState, 100 encoded_bytes: usize, 101 data_offset: usize, 102 // `remaining_header_payload` will always be smaller than the minimum max_frame_size, 103 // because the `header_payload_buffer` length is the minimum max_frame_size. 104 remaining_header_payload: usize, 105 remaining_payload_bytes: usize, 106 is_end_stream: bool, 107 is_end_headers: bool, 108 header_payload_buffer: Vec<u8>, 109 header_payload_index: usize, 110 } 111 112 impl FrameEncoder { 113 /// Constructs a new `FrameEncoder` with specified maximum frame size and 114 /// maximum header list size. new(max_frame_size: usize, use_huffman: bool) -> Self115 pub fn new(max_frame_size: usize, use_huffman: bool) -> Self { 116 FrameEncoder { 117 current_frame: None, 118 max_frame_size, 119 max_header_list_size: usize::MAX, 120 hpack_encoder: HpackEncoder::new(DEFAULT_HEADER_TABLE_SIZE, use_huffman), 121 state: FrameEncoderState::Idle, 122 encoded_bytes: 0, 123 data_offset: 0, 124 remaining_header_payload: 0, 125 remaining_payload_bytes: 0, 126 is_end_stream: false, 127 is_end_headers: false, 128 // Initialized to default max frame size(16384). 129 header_payload_buffer: vec![0; DEFAULT_MAX_FRAME_SIZE], 130 header_payload_index: 0, 131 } 132 } 133 134 /// Sets the current frame to be encoded by the `FrameEncoder`. The state of 135 /// the encoder is updated based on the payload type of the frame. set_frame(&mut self, frame: Frame) -> Result<(), FrameEncoderErr>136 pub fn set_frame(&mut self, frame: Frame) -> Result<(), FrameEncoderErr> { 137 self.is_end_stream = frame.flags().is_end_stream(); 138 self.is_end_headers = frame.flags().is_end_headers(); 139 self.current_frame = Some(frame); 140 // Reset the encoded bytes counter 141 self.encoded_bytes = 0; 142 143 // Set the initial state based on the frame payload type 144 match &self.current_frame { 145 Some(frame) => match frame.payload() { 146 Payload::Headers(headers) => { 147 if !self.is_end_headers { 148 return Err(FrameEncoderErr::HeadersNotEnd); 149 } 150 self.hpack_encoder.set_parts(headers.get_parts()); 151 self.header_payload_index = 0; 152 // TODO: Handle potential scenario where HPACK encoding may not be able to 153 // complete output in one go. 154 let payload_size = self.hpack_encoder.encode(&mut self.header_payload_buffer); 155 self.remaining_header_payload = payload_size; 156 self.state = FrameEncoderState::EncodingHeadersFrame; 157 } 158 Payload::Priority(_) => self.state = FrameEncoderState::EncodingPriorityFrame, 159 Payload::RstStream(_) => self.state = FrameEncoderState::EncodingRstStreamFrame, 160 Payload::Ping(_) => self.state = FrameEncoderState::EncodingPingFrame, 161 Payload::Data(data) => { 162 self.state = { 163 self.data_offset = 0; 164 self.remaining_payload_bytes = data.size(); 165 FrameEncoderState::EncodingDataHeader 166 } 167 } 168 Payload::Settings(_) => self.state = FrameEncoderState::EncodingSettingsFrame, 169 Payload::Goaway(_) => self.state = FrameEncoderState::EncodingGoawayFrame, 170 Payload::WindowUpdate(_) => { 171 self.state = FrameEncoderState::EncodingWindowUpdateFrame 172 } 173 _ => {} 174 }, 175 None => self.state = FrameEncoderState::Idle, 176 } 177 Ok(()) 178 } 179 180 /// Encodes the current frame into the given buffer. The state of the 181 /// encoder determines which part of the frame is currently being encoded. 182 /// This function returns the number of bytes written to the buffer or an 183 /// error if the encoding process fails. encode(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>184 pub fn encode(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 185 let mut written_bytes = 0; 186 187 while written_bytes < buf.len() { 188 match self.state { 189 FrameEncoderState::Idle 190 | FrameEncoderState::HeadersComplete 191 | FrameEncoderState::DataComplete => { 192 break; 193 } 194 FrameEncoderState::EncodingHeadersFrame => { 195 let bytes = self.encode_headers_frame(&mut buf[written_bytes..])?; 196 written_bytes += bytes; 197 if self.state == FrameEncoderState::EncodingHeadersFrame { 198 break; 199 } 200 } 201 FrameEncoderState::EncodingHeadersPayload => { 202 let bytes = self.encode_headers_payload(&mut buf[written_bytes..])?; 203 written_bytes += bytes; 204 if self.state == FrameEncoderState::EncodingHeadersPayload { 205 break; 206 } 207 } 208 FrameEncoderState::EncodingHeadersPadding => { 209 let bytes = self.encode_padding(&mut buf[written_bytes..])?; 210 written_bytes += bytes; 211 if self.state == FrameEncoderState::EncodingHeadersPadding { 212 break; 213 } 214 } 215 FrameEncoderState::EncodingContinuationFrames => { 216 let bytes = self.encode_continuation_frames(&mut buf[written_bytes..])?; 217 written_bytes += bytes; 218 if self.state == FrameEncoderState::EncodingContinuationFrames { 219 break; 220 } 221 } 222 FrameEncoderState::EncodingDataHeader => { 223 let bytes = self.encode_data_header(&mut buf[written_bytes..])?; 224 written_bytes += bytes; 225 if self.state == FrameEncoderState::EncodingDataHeader { 226 break; 227 } 228 } 229 FrameEncoderState::EncodingDataPayload => { 230 let bytes = self.encode_data_payload(&mut buf[written_bytes..])?; 231 written_bytes += bytes; 232 if self.state == FrameEncoderState::EncodingDataPayload { 233 break; 234 } 235 } 236 FrameEncoderState::EncodingDataPadding => { 237 let bytes = self.encode_padding(&mut buf[written_bytes..])?; 238 written_bytes += bytes; 239 if self.state == FrameEncoderState::EncodingDataPadding { 240 break; 241 } 242 } 243 FrameEncoderState::EncodingSettingsFrame => { 244 let bytes = self.encode_settings_frame(&mut buf[written_bytes..])?; 245 written_bytes += bytes; 246 if self.state == FrameEncoderState::EncodingSettingsFrame { 247 break; 248 } 249 } 250 FrameEncoderState::EncodingGoawayFrame => { 251 let bytes = self.encode_goaway_frame(&mut buf[written_bytes..])?; 252 written_bytes += bytes; 253 if self.state == FrameEncoderState::EncodingGoawayFrame { 254 break; 255 } 256 } 257 FrameEncoderState::EncodingWindowUpdateFrame => { 258 let bytes = self.encode_window_update_frame(&mut buf[written_bytes..])?; 259 written_bytes += bytes; 260 if self.state == FrameEncoderState::EncodingWindowUpdateFrame { 261 break; 262 } 263 } 264 FrameEncoderState::EncodingSettingsPayload => { 265 let bytes = self.encode_settings_payload(&mut buf[written_bytes..])?; 266 written_bytes += bytes; 267 if self.state == FrameEncoderState::EncodingSettingsPayload { 268 break; 269 } 270 } 271 FrameEncoderState::EncodingGoawayPayload => { 272 let bytes = self.encode_goaway_payload(&mut buf[written_bytes..])?; 273 written_bytes += bytes; 274 if self.state == FrameEncoderState::EncodingGoawayPayload { 275 break; 276 } 277 } 278 FrameEncoderState::EncodingWindowUpdatePayload => { 279 let bytes = self.encode_window_update_payload(&mut buf[written_bytes..])?; 280 written_bytes += bytes; 281 if self.state == FrameEncoderState::EncodingWindowUpdatePayload { 282 break; 283 } 284 } 285 FrameEncoderState::EncodingPriorityFrame => { 286 let bytes = self.encode_priority_frame(&mut buf[written_bytes..])?; 287 written_bytes += bytes; 288 if self.state == FrameEncoderState::EncodingPriorityFrame { 289 break; 290 } 291 } 292 FrameEncoderState::EncodingPriorityPayload => { 293 let bytes = self.encode_priority_payload(&mut buf[written_bytes..])?; 294 written_bytes += bytes; 295 if self.state == FrameEncoderState::EncodingPriorityPayload { 296 break; 297 } 298 } 299 FrameEncoderState::EncodingRstStreamFrame => { 300 let bytes = self.encode_rst_stream_frame(&mut buf[written_bytes..])?; 301 written_bytes += bytes; 302 if self.state == FrameEncoderState::EncodingRstStreamFrame { 303 break; 304 } 305 } 306 FrameEncoderState::EncodingRstStreamPayload => { 307 let bytes = self.encode_rst_stream_payload(&mut buf[written_bytes..])?; 308 written_bytes += bytes; 309 if self.state == FrameEncoderState::EncodingRstStreamPayload { 310 break; 311 } 312 } 313 FrameEncoderState::EncodingPingFrame => { 314 let bytes = self.encode_ping_frame(&mut buf[written_bytes..])?; 315 written_bytes += bytes; 316 if self.state == FrameEncoderState::EncodingPingFrame { 317 break; 318 } 319 } 320 FrameEncoderState::EncodingPingPayload => { 321 let bytes = self.encode_ping_payload(&mut buf[written_bytes..])?; 322 written_bytes += bytes; 323 if self.state == FrameEncoderState::EncodingPingPayload { 324 break; 325 } 326 } 327 } 328 } 329 330 Ok(written_bytes) 331 } 332 333 /// Updates the provided setting for the current frame if it is a `Settings` 334 /// frame. update_setting(&mut self, setting: Setting)335 pub fn update_setting(&mut self, setting: Setting) { 336 if let Some(frame) = &mut self.current_frame { 337 if let Payload::Settings(settings) = frame.payload_mut() { 338 settings.update_setting(setting); 339 } 340 } 341 } 342 343 /// Sets the maximum frame size for the current encoder instance. update_max_frame_size(&mut self, size: usize)344 pub fn update_max_frame_size(&mut self, size: usize) { 345 self.max_frame_size = size; 346 } 347 348 /// Sets the maximum header table size for the current encoder instance. 349 // TODO enable update header table size. update_header_table_size(&mut self, size: usize)350 pub fn update_header_table_size(&mut self, size: usize) { 351 self.hpack_encoder.update_max_dynamic_table_size(size) 352 } 353 354 // TODO enable update max header list size. update_max_header_list_size(&mut self, size: usize)355 pub(crate) fn update_max_header_list_size(&mut self, size: usize) { 356 self.max_header_list_size = size; 357 } 358 finish_current_frame(&mut self)359 fn finish_current_frame(&mut self) { 360 self.header_payload_index = 0; 361 self.is_end_stream = false; 362 self.current_frame = None; 363 self.is_end_headers = false; 364 self.remaining_header_payload = 0; 365 self.encoded_bytes = 0; 366 } 367 read_rest_payload(&mut self)368 fn read_rest_payload(&mut self) { 369 self.header_payload_index = 0; 370 let payload_size = self.hpack_encoder.encode(&mut self.header_payload_buffer); 371 self.remaining_header_payload = payload_size; 372 } 373 try_retrieve_current_frame(&self) -> Result<&Frame, FrameEncoderErr>374 fn try_retrieve_current_frame(&self) -> Result<&Frame, FrameEncoderErr> { 375 if let Some(frame) = &self.current_frame { 376 return Ok(frame); 377 } 378 Err(FrameEncoderErr::NoCurrentFrame) 379 } 380 encode_headers_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>381 fn encode_headers_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 382 let frame = self.try_retrieve_current_frame()?; 383 if let Payload::Headers(_) = frame.payload() { 384 // HTTP/2 frame header size is 9 bytes. 385 let frame_header_size = 9; 386 let remaining_header_bytes = if self.encoded_bytes >= frame_header_size { 387 0 388 } else { 389 frame_header_size - self.encoded_bytes 390 }; 391 let bytes_to_write = remaining_header_bytes.min(buf.len()); 392 393 self.iterate_headers_header(frame, buf, bytes_to_write)?; 394 self.encoded_bytes += bytes_to_write; 395 let bytes_written = bytes_to_write; 396 let mut payload_bytes_written = 0; 397 398 if self.encoded_bytes >= frame_header_size { 399 payload_bytes_written = 400 self.write_payload(&mut buf[bytes_written..], self.remaining_header_payload); 401 self.encoded_bytes += payload_bytes_written; 402 self.headers_header_status(); 403 } 404 405 Ok(bytes_written + payload_bytes_written) 406 } else { 407 Err(FrameEncoderErr::UnexpectedPayloadType) 408 } 409 } 410 headers_header_status(&mut self)411 fn headers_header_status(&mut self) { 412 // Headers encoding does not need to consider max_frame_size 413 // because header_payload_buffer must be smaller than max_frame_size. 414 self.state = if self.header_payload_index < self.remaining_header_payload { 415 FrameEncoderState::EncodingHeadersPayload 416 } else if self.hpack_encoder.is_finished() { 417 // set_frame ensures that headers must be is_end_headers 418 self.finish_current_frame(); 419 FrameEncoderState::HeadersComplete 420 } else { 421 self.read_rest_payload(); 422 FrameEncoderState::EncodingContinuationFrames 423 } 424 } 425 iterate_headers_header( &self, frame: &Frame, buf: &mut [u8], len: usize, ) -> Result<(), FrameEncoderErr>426 fn iterate_headers_header( 427 &self, 428 frame: &Frame, 429 buf: &mut [u8], 430 len: usize, 431 ) -> Result<(), FrameEncoderErr> { 432 for (buf_index, item) in buf.iter_mut().enumerate().take(len) { 433 let header_byte_index = self.encoded_bytes + buf_index; 434 match header_byte_index { 435 // The first 3 bytes represent the payload length in the frame header. 436 0..=2 => { 437 let payload_len = self.remaining_header_payload; 438 *item = ((payload_len >> (16 - (8 * header_byte_index))) & 0xFF) as u8; 439 } 440 // The 4th byte represents the frame type in the frame header. 441 3 => { 442 *item = FrameType::Headers as u8; 443 } 444 // The 5th byte represents the frame flags in the frame header. 445 4 => { 446 if self.hpack_encoder.is_finished() { 447 *item = frame.flags().bits(); 448 } else { 449 // If not finished, it is followed by a Continuation frame. 450 *item = frame.flags().bits() & 0xFB 451 } 452 } 453 // The last 4 bytes (6th to 9th) represent the stream identifier in the 454 // frame header. 455 5..=8 => { 456 let stream_id_byte_index = header_byte_index - 5; 457 *item = (frame.stream_id() >> (24 - (8 * stream_id_byte_index))) as u8; 458 } 459 _ => { 460 return Err(FrameEncoderErr::InternalError); 461 } 462 } 463 } 464 Ok(()) 465 } 466 encode_headers_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>467 fn encode_headers_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 468 let frame = self.try_retrieve_current_frame()?; 469 if let Payload::Headers(_) = frame.payload() { 470 if buf.is_empty() { 471 return Ok(0); 472 } 473 474 let payload_bytes_written = self.write_payload(buf, self.remaining_header_payload); 475 self.encoded_bytes += payload_bytes_written; 476 477 // Updates the state based on the encoding progress 478 self.headers_header_status(); 479 480 Ok(payload_bytes_written) 481 } else { 482 Err(FrameEncoderErr::UnexpectedPayloadType) 483 } 484 } 485 encode_continuation_frames(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>486 fn encode_continuation_frames(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 487 let frame = self.try_retrieve_current_frame()?; 488 489 if let Payload::Headers(_) = frame.payload() { 490 let available_space = buf.len(); 491 let frame_header_size = 9; 492 // TODO allow available_space < 9 493 if available_space < frame_header_size { 494 return Ok(0); 495 } 496 // Encodes CONTINUATION frame header. 497 // And this value is always the remaining_header_payload. 498 let continuation_frame_len = self.remaining_header_payload.min(self.max_frame_size); 499 for (buf_index, item) in buf.iter_mut().enumerate().take(3) { 500 *item = ((continuation_frame_len >> (16 - (8 * buf_index))) & 0xFF) as u8; 501 } 502 buf[3] = FrameType::Continuation as u8; 503 let mut new_flags = FrameFlags::empty(); 504 if self.remaining_header_payload <= self.max_frame_size 505 && self.hpack_encoder.is_finished() 506 && self.is_end_headers 507 { 508 // Sets the END_HEADER flag on the last CONTINUATION frame. 509 new_flags.set_end_headers(true); 510 } 511 buf[4] = new_flags.bits(); 512 513 for buf_index in 0..4 { 514 let stream_id_byte_index = buf_index; 515 buf[5 + buf_index] = (frame.stream_id() >> (24 - (8 * stream_id_byte_index))) as u8; 516 } 517 518 // Encodes CONTINUATION frame payload. 519 let payload_bytes_written = 520 self.write_payload(&mut buf[frame_header_size..], continuation_frame_len); 521 self.encoded_bytes += payload_bytes_written; 522 523 // Updates the state based on the encoding progress. 524 self.headers_header_status(); 525 526 Ok(frame_header_size + payload_bytes_written) 527 } else { 528 Err(FrameEncoderErr::UnexpectedPayloadType) 529 } 530 } 531 encode_data_header(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>532 fn encode_data_header(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 533 let frame = self.try_retrieve_current_frame()?; 534 if let Payload::Data(_) = frame.payload() { 535 // HTTP/2 frame header size is 9 bytes. 536 let frame_header_size = 9; 537 let remaining_header_bytes = if self.encoded_bytes >= frame_header_size { 538 0 539 } else { 540 frame_header_size - self.encoded_bytes 541 }; 542 let bytes_to_write = remaining_header_bytes.min(buf.len()); 543 544 self.iterate_data_header( 545 frame, 546 buf, 547 min(self.remaining_payload_bytes, self.max_frame_size), 548 bytes_to_write, 549 )?; 550 551 self.encoded_bytes += bytes_to_write; 552 if self.encoded_bytes == frame_header_size { 553 // data frame header is finished, reset encoded_bytes. 554 self.encoded_bytes = 0; 555 self.state = FrameEncoderState::EncodingDataPayload; 556 } 557 Ok(bytes_to_write) 558 } else { 559 Err(FrameEncoderErr::UnexpectedPayloadType) 560 } 561 } 562 iterate_data_header( &self, frame: &Frame, buf: &mut [u8], payload_len: usize, len: usize, ) -> Result<(), FrameEncoderErr>563 fn iterate_data_header( 564 &self, 565 frame: &Frame, 566 buf: &mut [u8], 567 payload_len: usize, 568 len: usize, 569 ) -> Result<(), FrameEncoderErr> { 570 for (buf_index, item) in buf.iter_mut().enumerate().take(len) { 571 let header_byte_index = self.encoded_bytes + buf_index; 572 match header_byte_index { 573 // The first 3 bytes represent the payload length in the frame header. 574 0..=2 => { 575 *item = ((payload_len >> (16 - (8 * header_byte_index))) & 0xFF) as u8; 576 } 577 // The 4th byte represents the frame type in the frame header. 578 3 => { 579 *item = frame.payload().frame_type() as u8; 580 } 581 // The 5th byte represents the frame flags in the frame header. 582 4 => { 583 if self.remaining_payload_bytes <= self.max_frame_size { 584 *item = frame.flags().bits(); 585 } else { 586 // When max_frame_size is exceeded, a data frame cannot send all data. 587 *item = frame.flags().bits() & 0xFE; 588 } 589 } 590 // The last 4 bytes (6th to 9th) represent the stream identifier in the 591 // frame header. 592 5..=8 => { 593 let stream_id_byte_index = header_byte_index - 5; 594 *item = (frame.stream_id() >> (24 - (8 * stream_id_byte_index))) as u8; 595 } 596 _ => { 597 return Err(FrameEncoderErr::InternalError); 598 } 599 } 600 } 601 Ok(()) 602 } 603 encode_data_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>604 fn encode_data_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 605 let frame = self.try_retrieve_current_frame()?; 606 if let Payload::Data(data_frame) = frame.payload() { 607 let payload = data_frame.data(); 608 let writen_bytes = self.encode_slice(buf, payload); 609 self.data_offset += writen_bytes; 610 self.remaining_payload_bytes -= writen_bytes; 611 612 self.state = if self.remaining_payload_bytes == 0 { 613 self.data_offset = 0; 614 FrameEncoderState::DataComplete 615 } else if self.data_offset == self.max_frame_size { 616 self.data_offset = 0; 617 FrameEncoderState::EncodingDataHeader 618 } else { 619 FrameEncoderState::EncodingDataPayload 620 }; 621 622 Ok(writen_bytes) 623 } else { 624 Err(FrameEncoderErr::UnexpectedPayloadType) 625 } 626 } 627 encode_padding(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>628 fn encode_padding(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 629 let frame = self.try_retrieve_current_frame()?; 630 631 if frame.flags().is_padded() { 632 let padding_len = if let Payload::Data(data_frame) = frame.payload() { 633 data_frame.data().len() 634 } else { 635 return Err(FrameEncoderErr::UnexpectedPayloadType); 636 }; 637 638 let remaining_padding_bytes = padding_len - self.encoded_bytes; 639 let bytes_to_write = remaining_padding_bytes.min(buf.len()); 640 641 for item in buf.iter_mut().take(bytes_to_write) { 642 // Padding bytes are filled with 0. 643 *item = 0; 644 } 645 646 self.encoded_bytes += bytes_to_write; 647 648 if self.encoded_bytes == padding_len { 649 self.state = FrameEncoderState::DataComplete; 650 } 651 652 Ok(bytes_to_write) 653 } else { 654 Ok(0) // No padding to encode, so return 0 bytes written. 655 } 656 } 657 encode_goaway_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>658 fn encode_goaway_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 659 let frame = self.try_retrieve_current_frame()?; 660 661 if let Payload::Goaway(_) = frame.payload() { 662 let frame_header_size = 9; 663 let remaining_header_bytes = if self.encoded_bytes >= frame_header_size { 664 0 665 } else { 666 frame_header_size - self.encoded_bytes 667 }; 668 let bytes_to_write = remaining_header_bytes.min(buf.len()); 669 self.iterate_goaway_header(frame, buf, bytes_to_write)?; 670 self.encoded_bytes += bytes_to_write; 671 if self.encoded_bytes == frame_header_size { 672 self.state = FrameEncoderState::EncodingGoawayPayload; 673 } 674 Ok(bytes_to_write) 675 } else { 676 Err(FrameEncoderErr::UnexpectedPayloadType) 677 } 678 } 679 iterate_goaway_header( &self, frame: &Frame, buf: &mut [u8], len: usize, ) -> Result<(), FrameEncoderErr>680 fn iterate_goaway_header( 681 &self, 682 frame: &Frame, 683 buf: &mut [u8], 684 len: usize, 685 ) -> Result<(), FrameEncoderErr> { 686 for (buf_index, item) in buf.iter_mut().enumerate().take(len) { 687 let header_byte_index = self.encoded_bytes + buf_index; 688 match header_byte_index { 689 0..=2 => { 690 if let Payload::Goaway(goaway_payload) = frame.payload() { 691 let payload_size = goaway_payload.encoded_len(); 692 *item = ((payload_size >> (8 * (2 - header_byte_index))) & 0xFF) as u8; 693 } else { 694 return Err(FrameEncoderErr::UnexpectedPayloadType); 695 } 696 } 697 3 => { 698 *item = FrameType::Goaway as u8; 699 } 700 4 => { 701 *item = frame.flags().bits(); 702 } 703 5..=8 => { 704 let stream_id_byte_index = header_byte_index - 5; 705 *item = (frame.stream_id() >> (24 - (8 * stream_id_byte_index))) as u8; 706 } 707 _ => { 708 return Err(FrameEncoderErr::InternalError); 709 } 710 } 711 } 712 Ok(()) 713 } 714 encode_goaway_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>715 fn encode_goaway_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 716 let frame = self.try_retrieve_current_frame()?; 717 if let Payload::Goaway(goaway) = frame.payload() { 718 let payload_size = goaway.encoded_len(); 719 let remaining_payload_bytes = 720 payload_size.saturating_sub(self.encoded_bytes.saturating_sub(9)); 721 let bytes_to_write = remaining_payload_bytes.min(buf.len()); 722 723 self.iterate_goaway_payload(goaway, buf, bytes_to_write)?; 724 self.encoded_bytes += bytes_to_write; 725 if self.encoded_bytes == 9 + payload_size { 726 self.state = FrameEncoderState::DataComplete; 727 } 728 729 Ok(bytes_to_write) 730 } else { 731 Err(FrameEncoderErr::UnexpectedPayloadType) 732 } 733 } 734 iterate_goaway_payload( &self, goaway: &Goaway, buf: &mut [u8], len: usize, ) -> Result<(), FrameEncoderErr>735 fn iterate_goaway_payload( 736 &self, 737 goaway: &Goaway, 738 buf: &mut [u8], 739 len: usize, 740 ) -> Result<(), FrameEncoderErr> { 741 for (buf_index, buf_item) in buf.iter_mut().enumerate().take(len) { 742 let payload_byte_index = self.encoded_bytes - 9 + buf_index; 743 match payload_byte_index { 744 0..=3 => { 745 let last_stream_id_byte_index = payload_byte_index; 746 *buf_item = (goaway.get_last_stream_id() 747 >> (24 - (8 * last_stream_id_byte_index))) 748 as u8; 749 } 750 4..=7 => { 751 let error_code_byte_index = payload_byte_index - 4; 752 *buf_item = 753 (goaway.get_error_code() >> (24 - (8 * error_code_byte_index))) as u8; 754 } 755 _ => { 756 let debug_data_index = payload_byte_index - 8; 757 if debug_data_index < goaway.get_debug_data().len() { 758 *buf_item = goaway.get_debug_data()[debug_data_index]; 759 } else { 760 return Err(FrameEncoderErr::InternalError); 761 } 762 } 763 } 764 } 765 Ok(()) 766 } 767 encode_window_update_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>768 fn encode_window_update_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 769 let frame = self.try_retrieve_current_frame()?; 770 if let Payload::WindowUpdate(_) = frame.payload() { 771 // HTTP/2 frame header size is 9 bytes. 772 let frame_header_size = 9; 773 let remaining_header_bytes = if self.encoded_bytes >= frame_header_size { 774 0 775 } else { 776 frame_header_size - self.encoded_bytes 777 }; 778 let bytes_to_write = remaining_header_bytes.min(buf.len()); 779 self.iterate_window_update_header(frame, buf, bytes_to_write)?; 780 self.encoded_bytes += bytes_to_write; 781 if self.encoded_bytes == frame_header_size { 782 self.state = FrameEncoderState::EncodingWindowUpdatePayload; 783 // Resets the encoded_bytes counter here. 784 self.encoded_bytes = 0; 785 } 786 Ok(bytes_to_write) 787 } else { 788 Err(FrameEncoderErr::UnexpectedPayloadType) 789 } 790 } 791 iterate_window_update_header( &self, frame: &Frame, buf: &mut [u8], len: usize, ) -> Result<(), FrameEncoderErr>792 fn iterate_window_update_header( 793 &self, 794 frame: &Frame, 795 buf: &mut [u8], 796 len: usize, 797 ) -> Result<(), FrameEncoderErr> { 798 for (buf_index, item) in buf.iter_mut().enumerate().take(len) { 799 let header_byte_index = self.encoded_bytes + buf_index; 800 match header_byte_index { 801 // The first 3 bytes represent the payload length in the frame header. For 802 // WindowUpdate frame, this is always 4 bytes. 803 0..=1 => { 804 *item = 0; 805 } 806 2 => { 807 // Window Update frame payload size is always 4 bytes. 808 *item = 4; 809 } 810 // The 4th byte represents the frame type in the frame header. 811 3 => { 812 *item = FrameType::WindowUpdate as u8; 813 } 814 // The 5th byte represents the frame flags in the frame header. 815 4 => { 816 *item = frame.flags().bits(); 817 } 818 // The last 4 bytes (6th to 9th) represent the stream identifier in the 819 // frame header. 820 5..=8 => { 821 let stream_id_byte_index = header_byte_index - 5; 822 *item = (frame.stream_id() >> (24 - (8 * stream_id_byte_index))) as u8; 823 } 824 _ => { 825 return Err(FrameEncoderErr::InternalError); 826 } 827 } 828 } 829 Ok(()) 830 } 831 encode_window_update_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>832 fn encode_window_update_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 833 let frame = self.try_retrieve_current_frame()?; 834 if let Payload::WindowUpdate(window_update) = frame.payload() { 835 let payload_size = 4usize; 836 let remaining_payload_bytes = 837 payload_size.saturating_sub(self.encoded_bytes.saturating_sub(9usize)); 838 let bytes_to_write = remaining_payload_bytes.min(buf.len()); 839 for (buf_index, buf_item) in buf.iter_mut().enumerate().take(bytes_to_write) { 840 let payload_byte_index = self 841 .encoded_bytes 842 .saturating_sub(9) 843 .saturating_add(buf_index); 844 let increment_byte_index = payload_byte_index; 845 *buf_item = 846 (window_update.get_increment() >> (24 - (8 * increment_byte_index))) as u8; 847 } 848 self.encoded_bytes += bytes_to_write; 849 if self.encoded_bytes == payload_size { 850 self.state = FrameEncoderState::DataComplete; 851 } 852 853 Ok(bytes_to_write) 854 } else { 855 Err(FrameEncoderErr::UnexpectedPayloadType) 856 } 857 } 858 encode_settings_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>859 fn encode_settings_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 860 let frame = self.try_retrieve_current_frame()?; 861 if let Payload::Settings(settings) = frame.payload() { 862 let frame_header_size = 9; 863 let remaining_header_bytes = if self.encoded_bytes >= frame_header_size { 864 0 865 } else { 866 frame_header_size - self.encoded_bytes 867 }; 868 let bytes_to_write = remaining_header_bytes.min(buf.len()); 869 self.iterate_settings_header( 870 frame, 871 buf, 872 settings.get_settings().len() * 6, 873 bytes_to_write, 874 )?; 875 self.encoded_bytes += bytes_to_write; 876 if self.encoded_bytes == frame_header_size { 877 self.state = FrameEncoderState::EncodingSettingsPayload; 878 } 879 Ok(bytes_to_write) 880 } else { 881 Err(FrameEncoderErr::UnexpectedPayloadType) 882 } 883 } 884 iterate_settings_header( &self, frame: &Frame, buf: &mut [u8], payload_len: usize, len: usize, ) -> Result<(), FrameEncoderErr>885 fn iterate_settings_header( 886 &self, 887 frame: &Frame, 888 buf: &mut [u8], 889 payload_len: usize, 890 len: usize, 891 ) -> Result<(), FrameEncoderErr> { 892 for buf_index in 0..len { 893 let header_byte_index = self.encoded_bytes + buf_index; 894 match header_byte_index { 895 // The first 3 bytes represent the payload length in the frame header. 896 0..=2 => { 897 buf[buf_index] = ((payload_len >> (16 - (8 * buf_index))) & 0xFF) as u8; 898 } 899 // The 4th byte represents the frame type in the frame header. 900 3 => { 901 buf[3] = FrameType::Settings as u8; 902 } 903 // The 5th byte represents the frame flags in the frame header. 904 4 => { 905 buf[4] = frame.flags().bits(); 906 } 907 // The last 4 bytes (6th to 9th) represent the stream identifier in the 908 // frame header. For SETTINGS frames, this should 909 // always be 0. 910 5..=8 => { 911 // Stream ID should be 0 for SETTINGS frames. 912 buf[buf_index] = 0; 913 } 914 _ => { 915 return Err(FrameEncoderErr::InternalError); 916 } 917 } 918 } 919 Ok(()) 920 } 921 encode_settings_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>922 fn encode_settings_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 923 let frame = self.try_retrieve_current_frame()?; 924 if let Payload::Settings(settings) = frame.payload() { 925 let settings_len = settings.get_settings().len() * 6; 926 let remaining_payload_bytes = 927 settings_len.saturating_sub(self.encoded_bytes.saturating_sub(9)); 928 let bytes_to_write = remaining_payload_bytes.min(buf.len()); 929 self.iterate_settings_payload(settings, buf, bytes_to_write)?; 930 self.encoded_bytes += bytes_to_write; 931 if self.encoded_bytes == 9 + settings_len { 932 self.state = FrameEncoderState::DataComplete; 933 } 934 935 Ok(bytes_to_write) 936 } else { 937 Err(FrameEncoderErr::UnexpectedPayloadType) 938 } 939 } 940 iterate_settings_payload( &self, settings: &Settings, buf: &mut [u8], len: usize, ) -> Result<(), FrameEncoderErr>941 fn iterate_settings_payload( 942 &self, 943 settings: &Settings, 944 buf: &mut [u8], 945 len: usize, 946 ) -> Result<(), FrameEncoderErr> { 947 for (buf_index, buf_item) in buf.iter_mut().enumerate().take(len) { 948 let payload_byte_index = self.encoded_bytes - 9 + buf_index; 949 let setting_index = payload_byte_index / 6; 950 let setting_byte_index = payload_byte_index % 6; 951 952 if let Some(setting) = settings.get_settings().get(setting_index) { 953 let (id, value) = match setting { 954 Setting::HeaderTableSize(v) => (0x1, *v), 955 Setting::EnablePush(v) => (0x2, *v as u32), 956 Setting::MaxConcurrentStreams(v) => (0x3, *v), 957 Setting::InitialWindowSize(v) => (0x4, *v), 958 Setting::MaxFrameSize(v) => (0x5, *v), 959 Setting::MaxHeaderListSize(v) => (0x6, *v), 960 }; 961 match setting_byte_index { 962 0..=1 => { 963 *buf_item = ((id >> (8 * (1 - setting_byte_index))) & 0xFF) as u8; 964 } 965 2..=5 => { 966 let shift_amount = 8 * (3 - (setting_byte_index - 2)); 967 *buf_item = ((value >> shift_amount) & 0xFF) as u8; 968 } 969 _ => { 970 return Err(FrameEncoderErr::InternalError); 971 } 972 } 973 } else { 974 return Err(FrameEncoderErr::InternalError); 975 } 976 } 977 Ok(()) 978 } 979 encode_priority_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>980 fn encode_priority_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 981 let frame = self.try_retrieve_current_frame()?; 982 if let Payload::Priority(_) = frame.payload() { 983 // HTTP/2 frame header size is 9 bytes. 984 let frame_header_size = 9; 985 let remaining_header_bytes = if self.encoded_bytes >= frame_header_size { 986 0 987 } else { 988 frame_header_size - self.encoded_bytes 989 }; 990 let bytes_to_write = remaining_header_bytes.min(buf.len()); 991 992 self.iterate_priority_header(frame, buf, bytes_to_write)?; 993 self.encoded_bytes += bytes_to_write; 994 if self.encoded_bytes == frame_header_size { 995 self.state = FrameEncoderState::EncodingPriorityPayload; 996 } 997 Ok(bytes_to_write) 998 } else { 999 Err(FrameEncoderErr::UnexpectedPayloadType) 1000 } 1001 } 1002 iterate_priority_header( &self, frame: &Frame, buf: &mut [u8], len: usize, ) -> Result<(), FrameEncoderErr>1003 fn iterate_priority_header( 1004 &self, 1005 frame: &Frame, 1006 buf: &mut [u8], 1007 len: usize, 1008 ) -> Result<(), FrameEncoderErr> { 1009 for (buf_index, item) in buf.iter_mut().enumerate().take(len) { 1010 let header_byte_index = self.encoded_bytes + buf_index; 1011 match header_byte_index { 1012 // The first 3 bytes represent the payload length in the frame header. 1013 0..=2 => { 1014 let payload_len = 5; 1015 *item = ((payload_len >> (16 - (8 * header_byte_index))) & 0xFF) as u8; 1016 } 1017 // The 4th byte represents the frame type in the frame header. 1018 3 => { 1019 *item = frame.payload().frame_type() as u8; 1020 } 1021 // The 5th byte represents the frame flags in the frame header. 1022 4 => { 1023 *item = frame.flags().bits(); 1024 } 1025 // The last 4 bytes (6th to 9th) represent the stream identifier in the 1026 // frame header. 1027 5..=8 => { 1028 let stream_id_byte_index = header_byte_index - 5; 1029 *item = (frame.stream_id() >> (24 - (8 * stream_id_byte_index))) as u8; 1030 } 1031 _ => { 1032 return Err(FrameEncoderErr::InternalError); 1033 } 1034 } 1035 } 1036 Ok(()) 1037 } 1038 encode_priority_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>1039 fn encode_priority_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 1040 let frame = self.try_retrieve_current_frame()?; 1041 if let Payload::Priority(priority) = frame.payload() { 1042 // HTTP/2 frame header size is 9 bytes. 1043 let frame_header_size = 9; 1044 let remaining_payload_bytes = 5 - (self.encoded_bytes - frame_header_size); 1045 let bytes_to_write = remaining_payload_bytes.min(buf.len()); 1046 1047 self.iterate_priority_payload(priority, buf, frame_header_size, bytes_to_write)?; 1048 self.encoded_bytes += bytes_to_write; 1049 if self.encoded_bytes == frame_header_size + 5 { 1050 self.state = FrameEncoderState::DataComplete 1051 } 1052 1053 Ok(bytes_to_write) 1054 } else { 1055 Err(FrameEncoderErr::UnexpectedPayloadType) 1056 } 1057 } 1058 iterate_priority_payload( &self, priority: &Priority, buf: &mut [u8], frame_header_size: usize, len: usize, ) -> Result<(), FrameEncoderErr>1059 fn iterate_priority_payload( 1060 &self, 1061 priority: &Priority, 1062 buf: &mut [u8], 1063 frame_header_size: usize, 1064 len: usize, 1065 ) -> Result<(), FrameEncoderErr> { 1066 for (buf_index, buf_item) in buf.iter_mut().enumerate().take(len) { 1067 let payload_byte_index = self 1068 .encoded_bytes 1069 .saturating_sub(frame_header_size) 1070 .saturating_add(buf_index); 1071 match payload_byte_index { 1072 0 => { 1073 *buf_item = (priority.get_exclusive() as u8) << 7 1074 | ((priority.get_stream_dependency() >> 24) & 0x7F) as u8; 1075 } 1076 1..=3 => { 1077 let stream_dependency_byte_index = payload_byte_index - 1; 1078 *buf_item = (priority.get_stream_dependency() 1079 >> (16 - (8 * stream_dependency_byte_index))) 1080 as u8; 1081 } 1082 4 => { 1083 // The last byte is the weight. 1084 *buf_item = priority.get_weight(); 1085 } 1086 _ => { 1087 return Err(FrameEncoderErr::InternalError); 1088 } 1089 } 1090 } 1091 Ok(()) 1092 } 1093 encode_rst_stream_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>1094 fn encode_rst_stream_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 1095 let frame = self.try_retrieve_current_frame()?; 1096 let frame_header_size = 9; 1097 if self.encoded_bytes >= frame_header_size { 1098 return Ok(0); 1099 } 1100 1101 let bytes_to_write = (frame_header_size - self.encoded_bytes).min(buf.len()); 1102 1103 for (buf_index, item) in buf.iter_mut().enumerate().take(bytes_to_write) { 1104 let header_byte_index = self.encoded_bytes + buf_index; 1105 match header_byte_index { 1106 0..=2 => { 1107 let payload_len = 4; 1108 *item = ((payload_len >> (16 - (8 * buf_index))) & 0xFF) as u8; 1109 } 1110 3 => { 1111 *item = FrameType::RstStream as u8; 1112 } 1113 4 => { 1114 *item = frame.flags().bits(); 1115 } 1116 5..=8 => { 1117 let stream_id = frame.stream_id(); 1118 *item = ((stream_id >> (24 - (8 * (buf_index - 5)))) & 0xFF) as u8; 1119 } 1120 _ => { 1121 return Err(FrameEncoderErr::InternalError); 1122 } 1123 } 1124 } 1125 self.encoded_bytes += bytes_to_write; 1126 1127 if self.encoded_bytes == frame_header_size { 1128 self.state = FrameEncoderState::EncodingRstStreamPayload; 1129 } 1130 1131 Ok(bytes_to_write) 1132 } 1133 encode_rst_stream_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>1134 fn encode_rst_stream_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 1135 let frame = self.try_retrieve_current_frame()?; 1136 if let Payload::RstStream(rst_stream) = frame.payload() { 1137 let frame_header_size = 9; 1138 if self.encoded_bytes < frame_header_size { 1139 return Ok(0); 1140 } 1141 1142 let payload_size = 4; 1143 let encoded_payload_bytes = self.encoded_bytes - frame_header_size; 1144 1145 if encoded_payload_bytes >= payload_size { 1146 return Ok(0); 1147 } 1148 1149 let bytes_to_write = (payload_size - encoded_payload_bytes).min(buf.len()); 1150 1151 for (buf_index, item) in buf.iter_mut().enumerate().take(bytes_to_write) { 1152 let payload_byte_index = encoded_payload_bytes + buf_index; 1153 *item = ((rst_stream.error_code() >> (24 - (8 * payload_byte_index))) & 0xFF) as u8; 1154 } 1155 1156 self.encoded_bytes += bytes_to_write; 1157 1158 if self.encoded_bytes == frame_header_size + payload_size { 1159 self.state = FrameEncoderState::DataComplete; 1160 } 1161 1162 Ok(bytes_to_write) 1163 } else { 1164 Err(FrameEncoderErr::UnexpectedPayloadType) 1165 } 1166 } 1167 encode_ping_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>1168 fn encode_ping_frame(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 1169 let frame = self.try_retrieve_current_frame()?; 1170 if let Payload::Ping(_) = frame.payload() { 1171 let frame_header_size = 9; 1172 let remaining_header_bytes = if self.encoded_bytes >= frame_header_size { 1173 0 1174 } else { 1175 frame_header_size - self.encoded_bytes 1176 }; 1177 let bytes_to_write = remaining_header_bytes.min(buf.len()); 1178 self.iterate_ping_header(frame, buf, bytes_to_write)?; 1179 self.encoded_bytes += bytes_to_write; 1180 if self.encoded_bytes == frame_header_size { 1181 self.state = FrameEncoderState::EncodingPingPayload; 1182 } 1183 Ok(bytes_to_write) 1184 } else { 1185 Err(FrameEncoderErr::UnexpectedPayloadType) 1186 } 1187 } 1188 iterate_ping_header( &self, frame: &Frame, buf: &mut [u8], len: usize, ) -> Result<(), FrameEncoderErr>1189 fn iterate_ping_header( 1190 &self, 1191 frame: &Frame, 1192 buf: &mut [u8], 1193 len: usize, 1194 ) -> Result<(), FrameEncoderErr> { 1195 for buf_index in 0..len { 1196 let header_byte_index = self.encoded_bytes + buf_index; 1197 match header_byte_index { 1198 // The first 3 bytes represent the payload length in the frame header. 1199 0..=2 => { 1200 // PING payload is always 8 bytes. 1201 let payload_len = 8; 1202 buf[buf_index] = ((payload_len >> (16 - (8 * buf_index))) & 0xFF) as u8; 1203 } 1204 // The 4th byte represents the frame type in the frame header. 1205 3 => { 1206 buf[3] = FrameType::Ping as u8; 1207 } 1208 // The 5th byte represents the frame flags in the frame header. 1209 4 => { 1210 buf[4] = frame.flags().bits(); 1211 } 1212 // The last 4 bytes (6th to 9th) represent the stream identifier in the 1213 // frame header. For PING frames, this should always 1214 // be 0. 1215 5..=8 => { 1216 // Stream ID should be 0 for PING frames. 1217 buf[buf_index] = 0; 1218 } 1219 _ => { 1220 return Err(FrameEncoderErr::InternalError); 1221 } 1222 } 1223 } 1224 Ok(()) 1225 } 1226 encode_ping_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr>1227 fn encode_ping_payload(&mut self, buf: &mut [u8]) -> Result<usize, FrameEncoderErr> { 1228 let frame = self.try_retrieve_current_frame()?; 1229 1230 if let Payload::Ping(ping) = frame.payload() { 1231 // PING payload is always 8 bytes. 1232 let payload_size = 8usize; 1233 let remaining_payload_bytes = 1234 payload_size.saturating_sub(self.encoded_bytes.saturating_sub(9usize)); 1235 let bytes_to_write = remaining_payload_bytes.min(buf.len()); 1236 for (buf_index, buf_item) in buf.iter_mut().enumerate().take(bytes_to_write) { 1237 let payload_byte_index = self 1238 .encoded_bytes 1239 .saturating_sub(9) 1240 .saturating_add(buf_index); 1241 *buf_item = ping.data[payload_byte_index]; 1242 } 1243 self.encoded_bytes += bytes_to_write; 1244 if self.encoded_bytes == 9 + 8 { 1245 self.state = FrameEncoderState::DataComplete; 1246 } 1247 1248 Ok(bytes_to_write) 1249 } else { 1250 Err(FrameEncoderErr::UnexpectedPayloadType) 1251 } 1252 } 1253 encode_slice(&self, buf: &mut [u8], data: &[u8]) -> usize1254 fn encode_slice(&self, buf: &mut [u8], data: &[u8]) -> usize { 1255 let start = self.data_offset; 1256 let allow_to_write = (self.max_frame_size - start).min(self.remaining_payload_bytes); 1257 let bytes_to_write = allow_to_write.min(buf.len()); 1258 1259 buf[..bytes_to_write].copy_from_slice(&data[start..start + bytes_to_write]); 1260 bytes_to_write 1261 } 1262 1263 // Helper method for writing the payload from the buffer to the output buffer. write_payload(&mut self, buf: &mut [u8], payload_len: usize) -> usize1264 fn write_payload(&mut self, buf: &mut [u8], payload_len: usize) -> usize { 1265 let bytes_to_write = buf.len().min(payload_len - self.header_payload_index); 1266 buf[..bytes_to_write].copy_from_slice( 1267 &self.header_payload_buffer 1268 [self.header_payload_index..self.header_payload_index + bytes_to_write], 1269 ); 1270 self.header_payload_index += bytes_to_write; 1271 bytes_to_write 1272 } 1273 } 1274 1275 #[cfg(test)] 1276 mod ut_frame_encoder { 1277 use super::*; 1278 use crate::error::HttpError; 1279 use crate::h2::frame::{ 1280 Data, FrameFlags, Goaway, Headers, Ping, Priority, RstStream, Settings, WindowUpdate, 1281 }; 1282 use crate::h2::{Parts, PseudoHeaders}; 1283 1284 /// UT test cases for `FrameEncoder` encoding `DATA` frame. 1285 /// 1286 /// # Brief 1287 /// 1. Creates a `FrameEncoder`. 1288 /// 2. Creates a `Frame` with `Payload::Data`. 1289 /// 3. Sets the frame for the encoder. 1290 /// 4. Encodes the frame using buffer segments. 1291 /// 5. Checks whether the result is correct. 1292 #[test] ut_data_frame_encoding()1293 fn ut_data_frame_encoding() { 1294 let mut encoder = FrameEncoder::new(4096, false); 1295 let data_payload = b"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh".to_vec(); 1296 1297 let data_frame = Frame::new( 1298 131, 1299 FrameFlags::new(0), 1300 Payload::Data(Data::new(data_payload.clone())), 1301 ); 1302 1303 encoder.set_frame(data_frame).unwrap(); 1304 1305 let mut first_buf = [0u8; 2]; 1306 let mut second_buf = [0u8; 38]; 1307 1308 let first_encoded = encoder.encode(&mut first_buf).unwrap(); 1309 let second_encoded = encoder.encode(&mut second_buf).unwrap(); 1310 1311 assert_eq!(first_encoded, 2); 1312 assert_eq!(second_encoded, 38); 1313 assert_eq!(first_buf[0], 0); 1314 assert_eq!(first_buf[1], 0); 1315 assert_eq!(second_buf[0], data_payload.len() as u8); 1316 assert_eq!(second_buf[6], 131); 1317 1318 for &item in second_buf.iter().skip(7).take(30) { 1319 assert_eq!(item, 104); 1320 } 1321 } 1322 1323 /// UT test cases for `FrameEncoder` encoding `HEADERS` frame. 1324 /// 1325 /// # Brief 1326 /// 1. Creates a `FrameEncoder`. 1327 /// 2. Creates a `Frame` with `Payload::Headers`. 1328 /// 3. Sets the frame for the encoder. 1329 /// 4. Encodes the frame using buffer segments. 1330 /// 5. Checks whether the result is correct. 1331 #[test] ut_headers_frame_encoding()1332 fn ut_headers_frame_encoding() { 1333 let mut frame_encoder = FrameEncoder::new(4096, false); 1334 1335 let mut new_parts = Parts::new(); 1336 new_parts.pseudo.set_method(Some("GET".to_string())); 1337 new_parts.pseudo.set_scheme(Some("https".to_string())); 1338 new_parts.pseudo.set_path(Some("/code".to_string())); 1339 new_parts 1340 .pseudo 1341 .set_authority(Some("example.com".to_string())); 1342 let mut frame_flag = FrameFlags::empty(); 1343 frame_flag.set_end_headers(true); 1344 frame_flag.set_end_stream(true); 1345 let frame = Frame::new(1, frame_flag, Payload::Headers(Headers::new(new_parts))); 1346 1347 // Set the current frame for the encoder 1348 frame_encoder.set_frame(frame).unwrap(); 1349 1350 let mut buf = vec![0; 50]; 1351 let first_encoded = frame_encoder.encode(&mut buf).unwrap(); 1352 assert_eq!(first_encoded, 22 + 9); 1353 assert_eq!(buf[0], 0); 1354 assert_eq!(buf[2], 22); 1355 assert_eq!(buf[3], 0x1); 1356 assert_eq!(buf[4], 5); 1357 assert_eq!(buf[8], 1); 1358 1359 assert_eq!(frame_encoder.state, FrameEncoderState::HeadersComplete); 1360 } 1361 1362 /// UT test cases for `FrameEncoder` encoding `SETTINGS` frame. 1363 /// 1364 /// # Brief 1365 /// 1. Creates a `FrameEncoder`. 1366 /// 2. Creates a `Frame` with `Payload::Settings`. 1367 /// 3. Sets the frame for the encoder. 1368 /// 4. Encodes the frame using buffer segments. 1369 /// 5. Checks whether the result is correct. 1370 #[test] ut_settings_frame_encoding()1371 fn ut_settings_frame_encoding() { 1372 let mut encoder = FrameEncoder::new(4096, false); 1373 let settings_payload = vec![ 1374 Setting::HeaderTableSize(4096), 1375 Setting::EnablePush(true), 1376 Setting::MaxConcurrentStreams(100), 1377 Setting::InitialWindowSize(65535), 1378 Setting::MaxFrameSize(16384), 1379 Setting::MaxHeaderListSize(8192), 1380 ]; 1381 1382 let settings = Settings::new(settings_payload.clone()); 1383 1384 let settings_frame = Frame::new(0, FrameFlags::new(0), Payload::Settings(settings)); 1385 1386 let mut first_buf = [0u8; 9]; 1387 let mut second_buf = [0u8; 30]; 1388 let mut third_buf = [0u8; 6]; 1389 encoder.set_frame(settings_frame).unwrap(); 1390 1391 let first_encoded = encoder.encode(&mut first_buf).unwrap(); 1392 assert_eq!(encoder.state, FrameEncoderState::EncodingSettingsPayload); 1393 let second_encoded = encoder.encode(&mut second_buf).unwrap(); 1394 let third_encoded = encoder.encode(&mut third_buf).unwrap(); 1395 1396 assert_eq!(encoder.state, FrameEncoderState::DataComplete); 1397 // Updated expected value for first_encoded 1398 assert_eq!(first_encoded, 9); 1399 assert_eq!(second_encoded, 30); 1400 // Updated expected value for third_encoded 1401 assert_eq!(third_encoded, 6); 1402 1403 // Validate the encoded settings 1404 let mut expected_encoded_settings = [0u8; 60]; 1405 for (i, setting) in settings_payload.iter().enumerate() { 1406 let offset = i * 6; 1407 let (id, value) = match setting { 1408 Setting::HeaderTableSize(v) => (0x1, *v), 1409 Setting::EnablePush(v) => (0x2, *v as u32), 1410 Setting::MaxConcurrentStreams(v) => (0x3, *v), 1411 Setting::InitialWindowSize(v) => (0x4, *v), 1412 Setting::MaxFrameSize(v) => (0x5, *v), 1413 Setting::MaxHeaderListSize(v) => (0x6, *v), 1414 }; 1415 expected_encoded_settings[offset] = (id >> 8) as u8; 1416 expected_encoded_settings[offset + 1] = (id & 0xFF) as u8; 1417 expected_encoded_settings[offset + 2] = (value >> 24) as u8; 1418 expected_encoded_settings[offset + 3] = ((value >> 16) & 0xFF) as u8; 1419 expected_encoded_settings[offset + 4] = ((value >> 8) & 0xFF) as u8; 1420 expected_encoded_settings[offset + 5] = (value & 0xFF) as u8; 1421 } 1422 1423 let actual_encoded_settings = [&second_buf[..], &third_buf[..]].concat(); 1424 for i in 0..35 { 1425 assert_eq!(expected_encoded_settings[i], actual_encoded_settings[i]); 1426 } 1427 } 1428 1429 /// UT test cases for `FrameEncoder` encoding `PING` frame. 1430 /// 1431 /// # Brief 1432 /// 1. Creates a `FrameEncoder`. 1433 /// 2. Creates a `Frame` with `Payload::Ping`. 1434 /// 3. Sets the frame for the encoder. 1435 /// 4. Encodes the frame using buffer segments. 1436 /// 5. Checks whether the result is correct. 1437 #[test] ut_ping_frame_encoding()1438 fn ut_ping_frame_encoding() { 1439 let mut encoder = FrameEncoder::new(4096, false); 1440 let ping_payload = [1, 2, 3, 4, 5, 6, 7, 8]; 1441 1442 let ping_frame = Frame::new( 1443 0, 1444 FrameFlags::new(0), 1445 Payload::Ping(Ping { data: ping_payload }), 1446 ); 1447 1448 encoder.set_frame(ping_frame).unwrap(); 1449 1450 let mut first_buf = [0u8; 9]; 1451 let mut second_buf = [0u8; 8]; 1452 1453 let first_encoded = encoder.encode(&mut first_buf).unwrap(); 1454 let second_encoded = encoder.encode(&mut second_buf).unwrap(); 1455 1456 assert_eq!(first_encoded, 9); 1457 assert_eq!(second_encoded, 8); 1458 1459 assert_eq!(first_buf[0], 0); 1460 assert_eq!(first_buf[1], 0); 1461 // payload length 1462 assert_eq!(first_buf[2], 8); 1463 assert_eq!(first_buf[3], FrameType::Ping as u8); 1464 // flags 1465 assert_eq!(first_buf[4], 0); 1466 // stream id 1467 assert_eq!(first_buf[5], 0); 1468 // stream id 1469 assert_eq!(first_buf[6], 0); 1470 // stream id 1471 assert_eq!(first_buf[7], 0); 1472 // stream id 1473 assert_eq!(first_buf[8], 0); 1474 1475 for i in 0..8 { 1476 assert_eq!(second_buf[i], ping_payload[i]); 1477 } 1478 } 1479 1480 /// UT test case for FrameEncoder encoding a sequence of frames: Headers, 1481 /// Data, Headers. 1482 /// 1483 /// # Brief 1484 /// 1. Creates a FrameEncoder. 1485 /// 2. Creates multiple frames including Headers and Data frames. 1486 /// 3. Sets each frame for the encoder and encodes them using buffer 1487 /// segments. 1488 /// 4. Checks whether the encoding results are correct. 1489 #[test] ut_continue_frame_encoding()1490 fn ut_continue_frame_encoding() { 1491 let mut encoder = FrameEncoder::new(4096, false); 1492 1493 let mut new_parts = Parts::new(); 1494 new_parts.pseudo.set_method(Some("GET".to_string())); 1495 new_parts.pseudo.set_scheme(Some("https".to_string())); 1496 new_parts.pseudo.set_path(Some("/code".to_string())); 1497 new_parts 1498 .pseudo 1499 .set_authority(Some("example.com".to_string())); 1500 let mut frame_flag = FrameFlags::empty(); 1501 frame_flag.set_end_headers(true); 1502 frame_flag.set_end_stream(false); 1503 let frame_1 = Frame::new( 1504 1, 1505 frame_flag.clone(), 1506 Payload::Headers(Headers::new(new_parts.clone())), 1507 ); 1508 1509 let data_payload = b"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh".to_vec(); 1510 let data_frame = Frame::new( 1511 1, 1512 FrameFlags::new(1), 1513 Payload::Data(Data::new(data_payload)), 1514 ); 1515 1516 let frame_2 = Frame::new( 1517 1, 1518 frame_flag.clone(), 1519 Payload::Headers(Headers::new(new_parts.clone())), 1520 ); 1521 1522 encoder.set_frame(frame_1).unwrap(); 1523 let mut first_buf = [0u8; 50]; 1524 let first_encoding = encoder.encode(&mut first_buf).unwrap(); 1525 1526 encoder.set_frame(data_frame).unwrap(); 1527 let mut second_buf = [0u8; 50]; 1528 let second_encoding = encoder.encode(&mut second_buf).unwrap(); 1529 1530 encoder.set_frame(frame_2).unwrap(); 1531 let mut third_buf = [0u8; 50]; 1532 let third_encoding = encoder.encode(&mut third_buf).unwrap(); 1533 1534 assert_eq!(first_encoding, 31); 1535 assert_eq!(second_encoding, 40); 1536 assert_eq!(third_encoding, 13); 1537 1538 assert_eq!(first_buf[2], 22); 1539 assert_eq!(second_buf[2], 31); 1540 assert_eq!(third_buf[2], 4); 1541 } 1542 1543 /// UT test cases for `FrameEncoder` encoding `RST_STREAM` frame. 1544 /// 1545 /// # Brief 1546 /// 1. Creates a `FrameEncoder`. 1547 /// 2. Creates a `Frame` with `Payload::RstStream`. 1548 /// 3. Sets the frame for the encoder. 1549 /// 4. Encodes the frame using buffer segments. 1550 /// 5. Checks whether the result is correct. 1551 #[test] ut_rst_stream_frame_encoding()1552 fn ut_rst_stream_frame_encoding() { 1553 let mut frame_encoder = FrameEncoder::new(4096, false); 1554 1555 let error_code = 12345678; 1556 let rst_stream_payload = Payload::RstStream(RstStream::new(error_code)); 1557 1558 let frame_flags = FrameFlags::empty(); 1559 let frame = Frame::new( 1560 // Stream ID can be non-zero for RST_STREAM frames 1561 1, 1562 frame_flags, 1563 rst_stream_payload, 1564 ); 1565 1566 // Set the current frame for the encoder 1567 frame_encoder.set_frame(frame).unwrap(); 1568 1569 let mut buf = vec![0; 50]; 1570 let first_encoded = frame_encoder.encode(&mut buf).unwrap(); 1571 // 9 bytes for header, 4 bytes for payload 1572 assert_eq!(first_encoded, 9 + 4); 1573 assert_eq!(buf[0], 0); 1574 // payload length should be 4 for RST_STREAM frames 1575 assert_eq!(buf[2], 4); 1576 assert_eq!(buf[3], FrameType::RstStream as u8); 1577 // frame flags should be 0 for RST_STREAM frames 1578 assert_eq!(buf[4], 0); 1579 // stream ID should be 1 for this test case 1580 assert_eq!(buf[8], 1); 1581 1582 // Check if encoded error code is correct 1583 assert_eq!(&buf[9..13], &error_code.to_be_bytes()); 1584 1585 assert_eq!(frame_encoder.state, FrameEncoderState::DataComplete); 1586 } 1587 1588 /// UT test cases for `FrameEncoder` encoding `WINDOW_UPDATE` frame. 1589 /// 1590 /// # Brief 1591 /// 1. Creates a `FrameEncoder`. 1592 /// 2. Creates a `Frame` with `Payload::WindowUpdate`. 1593 /// 3. Sets the frame for the encoder. 1594 /// 4. Encodes the frame using buffer segments. 1595 /// 5. Checks whether the result is correct. 1596 #[test] ut_window_update_frame_encoding()1597 fn ut_window_update_frame_encoding() { 1598 let mut frame_encoder = FrameEncoder::new(4096, false); 1599 1600 let window_size_increment = 12345678; 1601 let window_update_payload = Payload::WindowUpdate(WindowUpdate::new(window_size_increment)); 1602 1603 let frame_flags = FrameFlags::empty(); 1604 let frame = Frame::new( 1605 // Stream ID can be zero for WINDOW_UPDATE frames. 1606 0, 1607 frame_flags, 1608 window_update_payload, 1609 ); 1610 1611 // Sets the current frame for the encoder. 1612 frame_encoder.set_frame(frame).unwrap(); 1613 1614 let mut buf = vec![0; 50]; 1615 let first_encoded = frame_encoder.encode(&mut buf).unwrap(); 1616 // 9 bytes for header, 4 bytes for payload. 1617 assert_eq!(first_encoded, 9 + 4); 1618 assert_eq!(buf[0], 0); 1619 // Payload length should be 4 for WINDOW_UPDATE frames. 1620 assert_eq!(buf[2], 4); 1621 assert_eq!(buf[3], FrameType::WindowUpdate as u8); 1622 // Frame flags should be 0 for WINDOW_UPDATE frames. 1623 assert_eq!(buf[4], 0); 1624 // Stream ID should be 0 for this test case. 1625 assert_eq!(buf[8], 0); 1626 1627 // Checks if encoded window size increment is correct. 1628 assert_eq!(&buf[9..13], &window_size_increment.to_be_bytes()); 1629 1630 assert_eq!(frame_encoder.state, FrameEncoderState::DataComplete); 1631 } 1632 1633 /// UT test case for FrameEncoder encoding `PRIORITY` frame. 1634 /// 1635 /// # Brief 1636 /// 1. Creates a FrameEncoder. 1637 /// 2. Creates a Frame with Payload::Priority. 1638 /// 3. Sets the frame for the encoder. 1639 /// 4. Encodes the frame using buffer segments. 1640 /// 5. Checks whether the result is correct. 1641 #[test] ut_priority_frame_encoding()1642 fn ut_priority_frame_encoding() { 1643 let mut encoder = FrameEncoder::new(4096, false); 1644 // Maximum value for a 31-bit integer 1645 let stream_dependency = 0x7FFFFFFF; 1646 let priority_payload = Priority::new(true, stream_dependency, 15); 1647 1648 let priority_frame = 1649 Frame::new(131, FrameFlags::new(0), Payload::Priority(priority_payload)); 1650 1651 encoder.set_frame(priority_frame).unwrap(); 1652 1653 let mut buf = [0u8; 14]; 1654 1655 let encoded = encoder.encode(&mut buf).unwrap(); 1656 1657 assert_eq!(encoded, 14); 1658 // Payload length (most significant byte) 1659 assert_eq!(buf[0], 0); 1660 // Payload length (middle byte) 1661 assert_eq!(buf[1], 0); 1662 // Payload length (least significant byte) 1663 assert_eq!(buf[2], 5); 1664 // Frame flags 1665 assert_eq!(buf[3], FrameType::Priority as u8); 1666 assert_eq!(buf[4], 0); 1667 // Stream ID (most significant byte) 1668 assert_eq!(buf[5], 0); 1669 // Stream ID (middle bytes) 1670 assert_eq!(buf[6], 0); 1671 // Stream ID (middle bytes) 1672 assert_eq!(buf[7], 0); 1673 // Stream ID (least significant byte) 1674 assert_eq!(buf[8], 131); 1675 // Exclusive flag and most significant byte of stream dependency 1676 assert_eq!(buf[9], (0x80 | ((stream_dependency >> 24) & 0x7F)) as u8); 1677 // Stream dependency (middle bytes) 1678 assert_eq!(buf[10], ((stream_dependency >> 16) & 0xFF) as u8); 1679 // Stream dependency (middle bytes) 1680 assert_eq!(buf[11], ((stream_dependency >> 8) & 0xFF) as u8); 1681 // Stream dependency (least significant byte) 1682 assert_eq!(buf[12], (stream_dependency & 0xFF) as u8); 1683 // Weight 1684 assert_eq!(buf[13], 15); 1685 } 1686 1687 /// UT test cases for `FrameEncoder` encoding `GOAWAY` frame. 1688 /// 1689 /// # Brief 1690 /// 1. Creates a `FrameEncoder`. 1691 /// 2. Creates a `Frame` with `Payload::Goaway`. 1692 /// 3. Sets the frame for the encoder. 1693 /// 4. Encodes the frame and its payload using buffer segments. 1694 /// 5. Checks whether the result is correct. 1695 #[test] ut_goaway_frame_encoding()1696 fn ut_goaway_frame_encoding() { 1697 // 1. Creates a `FrameEncoder`. 1698 let mut encoder = FrameEncoder::new(4096, false); 1699 1700 // 2. Creates a `Frame` with `Payload::Goaway`. 1701 let last_stream_id = 1; 1702 let error_code = 1; 1703 let debug_data = vec![1, 2, 3, 4, 5]; 1704 let goaway_frame = Frame::new( 1705 131, 1706 FrameFlags::new(0), 1707 Payload::Goaway(Goaway::new(error_code, last_stream_id, debug_data.clone())), 1708 ); 1709 1710 // 3. Sets the frame for the encoder. 1711 encoder.set_frame(goaway_frame).unwrap(); 1712 1713 // 4. Encodes the frame and its payload using buffer segments. 1714 let mut first_buf = [0u8; 9]; 1715 let mut second_buf = [0u8; 13]; 1716 let first_encoded = encoder.encode(&mut first_buf).unwrap(); 1717 let second_encoded = encoder.encode(&mut second_buf).unwrap(); 1718 1719 // 5. Checks whether the result is correct. 1720 assert_eq!(first_encoded, 9); 1721 assert_eq!(second_encoded, 13); 1722 1723 // Validate the encoded GOAWAY frame. 1724 let mut expected_encoded_goaway = [0u8; 13]; 1725 expected_encoded_goaway[0..4].copy_from_slice(&last_stream_id.to_be_bytes()); 1726 expected_encoded_goaway[4..8].copy_from_slice(&error_code.to_be_bytes()); 1727 1728 expected_encoded_goaway[8..13].copy_from_slice(&debug_data[..]); 1729 1730 // payload length should be 13 bytes 1731 assert_eq!(first_buf[0..3], [0u8, 0, 13]); 1732 assert_eq!(first_buf[3], FrameType::Goaway as u8); 1733 // flags 1734 assert_eq!(first_buf[4], 0); 1735 1736 // Validate the encoded Last-Stream-ID, Error Code, and debug data 1737 assert_eq!(second_buf[..], expected_encoded_goaway[..]); 1738 } 1739 1740 /// UT test cases for `FrameEncoder::update_max_frame_size`. 1741 /// 1742 /// # Brief 1743 /// 1. Creates a `FrameEncoder`. 1744 /// 2. Updates the maximum frame size. 1745 /// 3. Checks whether the maximum frame size was updated correctly. 1746 #[test] ut_update_max_frame_size()1747 fn ut_update_max_frame_size() { 1748 let mut encoder = FrameEncoder::new(4096, false); 1749 encoder.update_max_frame_size(8192); 1750 assert_eq!(encoder.max_frame_size, 8192); 1751 } 1752 1753 /// UT test cases for `FrameEncoder::update_setting`. 1754 /// 1755 /// # Brief 1756 /// 1. Creates a `FrameEncoder`. 1757 /// 2. Creates a `Setting` variant. 1758 /// 3. Creates a `Frame` with `Payload::Settings`. 1759 /// 4. Sets the frame for the encoder. 1760 /// 5. Updates the setting. 1761 /// 6. Checks whether the setting was updated correctly. 1762 #[test] ut_update_setting()1763 fn ut_update_setting() { 1764 let mut encoder = FrameEncoder::new(4096, false); 1765 let settings_payload = vec![Setting::MaxFrameSize(4096)]; 1766 let settings = Settings::new(settings_payload); 1767 let settings_frame = Frame::new(0, FrameFlags::new(0), Payload::Settings(settings)); 1768 1769 encoder.set_frame(settings_frame).unwrap(); 1770 let new_setting = Setting::MaxFrameSize(8192); 1771 encoder.update_setting(new_setting.clone()); 1772 1773 if let Some(frame) = &mut encoder.current_frame { 1774 if let Payload::Settings(settings) = frame.payload_mut() { 1775 let updated_settings = settings.get_settings(); 1776 assert!(updated_settings.iter().any(|s| *s == new_setting)); 1777 } 1778 } 1779 } 1780 1781 /// UT test cases for `FrameEncoder` encoding continuation frames. 1782 /// 1783 /// # Brief 1784 /// 1. Creates a `FrameEncoder`. 1785 /// 2. Creates a `Frame` with `Payload::Headers` and sets the flags. 1786 /// 3. Sets the frame for the encoder. 1787 /// 4. Encodes the continuation frames using a buffer. 1788 /// 5. Checks whether the result is correct. 1789 #[test] ut_encode_continuation_frames()1790 fn ut_encode_continuation_frames() { 1791 let mut frame_encoder = FrameEncoder::new(4096, false); 1792 let mut new_parts = Parts::new(); 1793 assert!(new_parts.is_empty()); 1794 new_parts.pseudo.set_method(Some("GET".to_string())); 1795 new_parts.pseudo.set_scheme(Some("https".to_string())); 1796 new_parts.pseudo.set_path(Some("/code".to_string())); 1797 new_parts 1798 .pseudo 1799 .set_authority(Some("example.com".to_string())); 1800 1801 let mut frame_flag = FrameFlags::empty(); 1802 frame_flag.set_end_headers(true); 1803 frame_flag.set_end_stream(false); 1804 let frame = Frame::new( 1805 1, 1806 frame_flag.clone(), 1807 Payload::Headers(Headers::new(new_parts.clone())), 1808 ); 1809 1810 frame_encoder.set_frame(frame).unwrap(); 1811 frame_encoder.state = FrameEncoderState::EncodingContinuationFrames; 1812 let mut buf = [0u8; 5000]; 1813 1814 assert!(frame_encoder.encode_continuation_frames(&mut buf).is_ok()); 1815 1816 let mut frame_flag = FrameFlags::empty(); 1817 frame_flag.set_end_headers(true); 1818 let frame = Frame::new( 1819 1, 1820 frame_flag, 1821 Payload::Headers(Headers::new(new_parts.clone())), 1822 ); 1823 1824 frame_encoder.set_frame(frame).unwrap(); 1825 frame_encoder.state = FrameEncoderState::EncodingContinuationFrames; 1826 assert!(frame_encoder.encode_continuation_frames(&mut buf).is_ok()); 1827 1828 let mut frame_flag = FrameFlags::empty(); 1829 frame_flag.set_end_headers(true); 1830 let frame = Frame::new(1, frame_flag, Payload::Ping(Ping::new([0; 8]))); 1831 1832 frame_encoder.set_frame(frame).unwrap(); 1833 frame_encoder.state = FrameEncoderState::EncodingContinuationFrames; 1834 assert!(frame_encoder.encode_continuation_frames(&mut buf).is_err()); 1835 } 1836 1837 /// UT test cases for `FrameEncoder` encoding padded data. 1838 /// 1839 /// # Brief 1840 /// 1. Creates a `FrameEncoder`. 1841 /// 2. Creates a `Frame` with `Payload::Data` and sets the flags. 1842 /// 3. Sets the frame for the encoder. 1843 /// 4. Encodes the padding using a buffer. 1844 /// 5. Checks whether the result is correct. 1845 #[test] ut_encode_padding()1846 fn ut_encode_padding() { 1847 let mut frame_encoder = FrameEncoder::new(4096, false); 1848 1849 // Creates a padded data frame. 1850 let mut frame_flags = FrameFlags::empty(); 1851 frame_flags.set_end_headers(true); 1852 frame_flags.set_padded(true); 1853 let data_payload = vec![0u8; 500]; 1854 let data_frame = Frame::new( 1855 1, 1856 frame_flags.clone(), 1857 Payload::Data(Data::new(data_payload)), 1858 ); 1859 1860 // Sets the frame to the frame_encoder and test padding encoding. 1861 frame_encoder.set_frame(data_frame).unwrap(); 1862 frame_encoder.state = FrameEncoderState::EncodingDataPadding; 1863 let mut buf = [0u8; 600]; 1864 assert!(frame_encoder.encode_padding(&mut buf).is_ok()); 1865 1866 let headers_payload = Payload::Headers(Headers::new(Parts::new())); 1867 let headers_frame = Frame::new(1, frame_flags.clone(), headers_payload); 1868 frame_encoder.set_frame(headers_frame).unwrap(); 1869 frame_encoder.state = FrameEncoderState::EncodingDataPadding; 1870 assert!(frame_encoder.encode_padding(&mut buf).is_err()); 1871 1872 frame_encoder.current_frame = None; 1873 assert!(frame_encoder.encode_padding(&mut buf).is_err()); 1874 } 1875 1876 /// UT test cases for `FrameEncoder` encoding data frame. 1877 /// 1878 /// # Brief 1879 /// 1. Creates a `FrameEncoder`. 1880 /// 2. Creates a `Frame` smaller than max_frame_size with `Payload::Data` 1881 /// and sets the flags. 1882 /// 3. Sets the frame for the encoder. 1883 /// 4. Encode the data frame with a buf. 1884 /// 5. Checks whether the result is correct. 1885 #[test] ut_encode_small_data_frame()1886 fn ut_encode_small_data_frame() { 1887 let mut encoder = FrameEncoder::new(100, false); 1888 let data_payload = vec![b'a'; 10]; 1889 let mut buf = [0u8; 10]; 1890 encode_small_frame(&mut encoder, &mut buf, data_payload.clone()); 1891 1892 // buf is larger than frame but smaller than max_frame_size; 1893 let mut buf = [0u8; 50]; 1894 encode_small_frame(&mut encoder, &mut buf, data_payload.clone()); 1895 1896 // buf is larger than max_frame_size; 1897 let mut buf = [0u8; 200]; 1898 encode_small_frame(&mut encoder, &mut buf, data_payload); 1899 } 1900 encode_small_frame(encoder: &mut FrameEncoder, buf: &mut [u8], data_payload: Vec<u8>)1901 fn encode_small_frame(encoder: &mut FrameEncoder, buf: &mut [u8], data_payload: Vec<u8>) { 1902 let data_frame = Frame::new( 1903 1, 1904 FrameFlags::new(1), 1905 Payload::Data(Data::new(data_payload)), 1906 ); 1907 encoder.set_frame(data_frame).unwrap(); 1908 1909 let mut result = [b'0'; 10 + 9]; 1910 let total = assert_encoded_data(encoder, &mut result, buf); 1911 assert_eq!(total, 10 + 9); 1912 assert_eq!(result[4], 0x1); 1913 assert_eq!(encoder.state, FrameEncoderState::DataComplete); 1914 } 1915 1916 /// UT test cases for `FrameEncoder` encoding data frame. 1917 /// 1918 /// # Brief 1919 /// 1. Creates a `FrameEncoder`. 1920 /// 2. Creates a `Frame` larger than max_frame_size with `Payload::Data` and 1921 /// sets the flags. 1922 /// 3. Sets the frame for the encoder. 1923 /// 4. Encode the data frame with a buf. 1924 /// 5. Checks whether the result is correct. 1925 #[test] ut_encode_large_data_frame()1926 fn ut_encode_large_data_frame() { 1927 let mut encoder = FrameEncoder::new(100, false); 1928 let data_payload = vec![b'a'; 1024]; 1929 let mut buf = [0u8; 10]; 1930 1931 let data_frame = Frame::new( 1932 1, 1933 FrameFlags::new(0), 1934 Payload::Data(Data::new(data_payload.clone())), 1935 ); 1936 let mut result = [b'0'; 1024 + 9 * 11]; 1937 encoder.set_frame(data_frame).unwrap(); 1938 1939 let total = assert_encoded_data(&mut encoder, &mut result, &mut buf); 1940 // This is because the data frame flag is 0. 1941 assert_eq!(result[4 + 10 * (9 + 100)], 0x0); 1942 assert_eq!(total, 1024 + 9 * 11); 1943 for index in 0..=9 { 1944 assert_eq!(result[4 + index * (9 + 100)], 0x0); 1945 } 1946 assert_eq!(encoder.state, FrameEncoderState::DataComplete); 1947 1948 // finished 1949 let data_frame = Frame::new( 1950 1, 1951 FrameFlags::new(1), 1952 Payload::Data(Data::new(data_payload)), 1953 ); 1954 let mut result = [b'0'; 1024 + 9 * 11]; 1955 encoder.set_frame(data_frame).unwrap(); 1956 1957 let total = assert_encoded_data(&mut encoder, &mut result, &mut buf); 1958 // This is because the data frame flag is 0. 1959 assert_eq!(result[4 + 10 * (9 + 100)], 0x1); 1960 assert_eq!(total, 1024 + 9 * 11); 1961 for index in 0..=9 { 1962 assert_eq!(result[4 + index * (9 + 100)], 0x0); 1963 } 1964 assert_eq!(encoder.state, FrameEncoderState::DataComplete); 1965 } 1966 assert_encoded_data(encoder: &mut FrameEncoder, result: &mut [u8], buf: &mut [u8]) -> usize1967 fn assert_encoded_data(encoder: &mut FrameEncoder, result: &mut [u8], buf: &mut [u8]) -> usize { 1968 let mut total = 0; 1969 loop { 1970 let size = encoder.encode(buf).unwrap(); 1971 result[total..total + size].copy_from_slice(&buf[..size]); 1972 total += size; 1973 if size == 0 { 1974 break; 1975 } 1976 } 1977 total 1978 } 1979 } 1980