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