Struct ws_tool::frame::HeaderViewMut

pub struct HeaderViewMut<'a>(_);

mutable frame header

Implementations

impl<'a> HeaderViewMut<'a>

pub fn fin(&self) -> bool

get fin bit value

pub fn rsv1(&self) -> bool

get rsv1 bit value

pub fn rsv2(&self) -> bool

get rsv2 bit value

pub fn rsv3(&self) -> bool

get rsv3 bit value

pub fn opcode(&self) -> OpCode

return frame opcode

pub fn mask(&self) -> bool

get mask bit value

pub fn payload_len(&self) -> u64

return payload len

pub fn masking_key(&self) -> Option<[u8; 4]>

get frame mask key

Examples found in repository

src/frame.rs (line 463)

    pub fn new<'a, P: Into<PayloadMut<'a>>>(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload: P,
    ) -> Self {
        let mut payload: PayloadMut = payload.into();
        let payload_len = payload.len();
        let mut buf =
            HeaderViewMut::empty_payload(fin, rsv1, rsv2, rsv3, opcode, mask, payload_len);
        let start = buf.len();
        let end = start + payload_len;
        buf.resize(end, 0);
        let mut frame = ReadFrame(buf);
        let header = frame.header_mut();
        if mask {
            let key = header.masking_key().unwrap();
            payload.apply_mask(key);
        }
        payload.copy_to(&mut frame.0[start..end]);
        frame
    }

pub fn payload_idx(&self) -> (usize, usize)

return (headerlen, the whole frame len)

pub fn set_fin(&mut self, val: bool)

set fin bit

Examples found in repository

src/frame.rs (line 373)

    pub fn empty_payload(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload_len: usize,
    ) -> BytesMut {
        let mut header_len = 1;
        if mask {
            header_len += 4;
        }
        if payload_len <= 125 {
            header_len += 1;
        } else if payload_len <= 65535 {
            header_len += 3;
        } else {
            header_len += 9;
        }
        let mut buf = BytesMut::new();
        buf.resize(header_len, 0);
        let mut header = HeaderViewMut(&mut buf);
        header.set_fin(fin);
        header.set_rsv1(rsv1);
        header.set_rsv2(rsv2);
        header.set_rsv3(rsv3);
        header.set_opcode(opcode);
        if mask {
            header.set_mask(true);
            header.auto_mask();
        }
        header.set_payload_len(payload_len as u64);
        buf
    }

pub fn set_rsv1(&mut self, val: bool)

set rsv1 bit

Examples found in repository

src/frame.rs (line 374)

    pub fn empty_payload(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload_len: usize,
    ) -> BytesMut {
        let mut header_len = 1;
        if mask {
            header_len += 4;
        }
        if payload_len <= 125 {
            header_len += 1;
        } else if payload_len <= 65535 {
            header_len += 3;
        } else {
            header_len += 9;
        }
        let mut buf = BytesMut::new();
        buf.resize(header_len, 0);
        let mut header = HeaderViewMut(&mut buf);
        header.set_fin(fin);
        header.set_rsv1(rsv1);
        header.set_rsv2(rsv2);
        header.set_rsv3(rsv3);
        header.set_opcode(opcode);
        if mask {
            header.set_mask(true);
            header.auto_mask();
        }
        header.set_payload_len(payload_len as u64);
        buf
    }

pub fn set_rsv2(&mut self, val: bool)

set rsv2 bit

Examples found in repository

src/frame.rs (line 375)

    pub fn empty_payload(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload_len: usize,
    ) -> BytesMut {
        let mut header_len = 1;
        if mask {
            header_len += 4;
        }
        if payload_len <= 125 {
            header_len += 1;
        } else if payload_len <= 65535 {
            header_len += 3;
        } else {
            header_len += 9;
        }
        let mut buf = BytesMut::new();
        buf.resize(header_len, 0);
        let mut header = HeaderViewMut(&mut buf);
        header.set_fin(fin);
        header.set_rsv1(rsv1);
        header.set_rsv2(rsv2);
        header.set_rsv3(rsv3);
        header.set_opcode(opcode);
        if mask {
            header.set_mask(true);
            header.auto_mask();
        }
        header.set_payload_len(payload_len as u64);
        buf
    }

pub fn set_rsv3(&mut self, val: bool)

set rsv3 bit

Examples found in repository

src/frame.rs (line 376)

    pub fn empty_payload(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload_len: usize,
    ) -> BytesMut {
        let mut header_len = 1;
        if mask {
            header_len += 4;
        }
        if payload_len <= 125 {
            header_len += 1;
        } else if payload_len <= 65535 {
            header_len += 3;
        } else {
            header_len += 9;
        }
        let mut buf = BytesMut::new();
        buf.resize(header_len, 0);
        let mut header = HeaderViewMut(&mut buf);
        header.set_fin(fin);
        header.set_rsv1(rsv1);
        header.set_rsv2(rsv2);
        header.set_rsv3(rsv3);
        header.set_opcode(opcode);
        if mask {
            header.set_mask(true);
            header.auto_mask();
        }
        header.set_payload_len(payload_len as u64);
        buf
    }

pub fn set_opcode(&mut self, code: OpCode)

set opcode

Examples found in repository

src/frame.rs (line 377)

    pub fn empty_payload(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload_len: usize,
    ) -> BytesMut {
        let mut header_len = 1;
        if mask {
            header_len += 4;
        }
        if payload_len <= 125 {
            header_len += 1;
        } else if payload_len <= 65535 {
            header_len += 3;
        } else {
            header_len += 9;
        }
        let mut buf = BytesMut::new();
        buf.resize(header_len, 0);
        let mut header = HeaderViewMut(&mut buf);
        header.set_fin(fin);
        header.set_rsv1(rsv1);
        header.set_rsv2(rsv2);
        header.set_rsv3(rsv3);
        header.set_opcode(opcode);
        if mask {
            header.set_mask(true);
            header.auto_mask();
        }
        header.set_payload_len(payload_len as u64);
        buf
    }

src/codec/frame/mod.rs (line 271)

    pub fn check_frame(&mut self, unmasked_frame: ReadFrame) -> Result<Option<ReadFrame>, WsError> {
        let header = unmasked_frame.header();
        let opcode = header.opcode();
        match opcode {
            OpCode::Continue => {
                if !self.fragmented {
                    return Err(WsError::ProtocolError {
                        close_code: 1002,
                        error: ProtocolError::MissInitialFragmentedFrame,
                    });
                }
                let (header_len, _) = header.payload_idx();
                let fin = header.fin();
                let mut buf = unmasked_frame.0;
                buf.advance(header_len);
                self.fragmented_data.0.unsplit(buf);
                if fin {
                    // if String::from_utf8(fragmented_data.to_vec()).is_err() {
                    //     return Err(WsError::ProtocolError {
                    //         close_code: 1007,
                    //         error: ProtocolError::InvalidUtf8,
                    //     });
                    // }
                    let completed_frame = self
                        .fragmented_data
                        .replace(ReadFrame::empty(OpCode::Binary));
                    Ok(Some(completed_frame))
                } else {
                    Ok(None)
                }
            }
            OpCode::Text | OpCode::Binary => {
                if self.fragmented {
                    return Err(WsError::ProtocolError {
                        close_code: 1002,
                        error: ProtocolError::NotContinueFrameAfterFragmented,
                    });
                }
                if !header.fin() {
                    self.fragmented = true;
                    self.fragmented_type = opcode.clone();
                    self.fragmented_data.header_mut().set_opcode(opcode);
                    let header_len = header.payload_idx().0;
                    let mut buf = unmasked_frame.0;
                    buf.advance(header_len);
                    self.fragmented_data.0.unsplit(buf);
                    Ok(None)
                } else {
                    // if opcode == OpCode::Text
                    //     && String::from_utf8(frame.payload_data_unmask().to_vec()).is_err()
                    // {
                    //     return Err(WsError::ProtocolError {
                    //         close_code: 1007,
                    //         error: ProtocolError::InvalidUtf8,
                    //     });
                    // }
                    Ok(Some(unmasked_frame))
                }
            }
            OpCode::Close | OpCode::Ping | OpCode::Pong => {
                if !header.fin() {
                    return Err(WsError::ProtocolError {
                        close_code: 1002,
                        error: ProtocolError::FragmentedControlFrame,
                    });
                }
                let payload_len = header.payload_len();
                if payload_len > 125 {
                    let error = ProtocolError::ControlFrameTooBig(payload_len as usize);
                    return Err(WsError::ProtocolError {
                        close_code: 1002,
                        error,
                    });
                }
                if opcode == OpCode::Close {
                    if payload_len == 1 {
                        let error = ProtocolError::InvalidCloseFramePayload;
                        return Err(WsError::ProtocolError {
                            close_code: 1002,
                            error,
                        });
                    }
                    if payload_len >= 2 {
                        let payload = unmasked_frame.payload();

                        // check close code
                        let mut code_byte = [0u8; 2];
                        code_byte.copy_from_slice(&payload[..2]);
                        let code = u16::from_be_bytes(code_byte);
                        if code < 1000
                            || (1004..=1006).contains(&code)
                            || (1015..=2999).contains(&code)
                            || code >= 5000
                        {
                            let error = ProtocolError::InvalidCloseCode(code);
                            return Err(WsError::ProtocolError {
                                close_code: 1002,
                                error,
                            });
                        }

                        // utf-8 validation
                        if String::from_utf8(payload[2..].to_vec()).is_err() {
                            let error = ProtocolError::InvalidUtf8;
                            return Err(WsError::ProtocolError {
                                close_code: 1007,
                                error,
                            });
                        }
                    }
                }
                Ok(Some(unmasked_frame))
            }
            OpCode::ReservedNonControl | OpCode::ReservedControl => {
                Err(WsError::UnsupportedFrame(opcode))
            }
        }
    }

pub fn set_mask(&mut self, mask: bool)

NOTE if change mask bit after setting payload you need to set payload again to adjust data frame

Examples found in repository

src/frame.rs (line 379)

    pub fn empty_payload(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload_len: usize,
    ) -> BytesMut {
        let mut header_len = 1;
        if mask {
            header_len += 4;
        }
        if payload_len <= 125 {
            header_len += 1;
        } else if payload_len <= 65535 {
            header_len += 3;
        } else {
            header_len += 9;
        }
        let mut buf = BytesMut::new();
        buf.resize(header_len, 0);
        let mut header = HeaderViewMut(&mut buf);
        header.set_fin(fin);
        header.set_rsv1(rsv1);
        header.set_rsv2(rsv2);
        header.set_rsv3(rsv3);
        header.set_opcode(opcode);
        if mask {
            header.set_mask(true);
            header.auto_mask();
        }
        header.set_payload_len(payload_len as u64);
        buf
    }

pub fn set_payload_len(&mut self, len: u64) -> usize

set header payload lens

Examples found in repository

src/frame.rs (line 382)

    pub fn empty_payload(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload_len: usize,
    ) -> BytesMut {
        let mut header_len = 1;
        if mask {
            header_len += 4;
        }
        if payload_len <= 125 {
            header_len += 1;
        } else if payload_len <= 65535 {
            header_len += 3;
        } else {
            header_len += 9;
        }
        let mut buf = BytesMut::new();
        buf.resize(header_len, 0);
        let mut header = HeaderViewMut(&mut buf);
        header.set_fin(fin);
        header.set_rsv1(rsv1);
        header.set_rsv2(rsv2);
        header.set_rsv3(rsv3);
        header.set_opcode(opcode);
        if mask {
            header.set_mask(true);
            header.auto_mask();
        }
        header.set_payload_len(payload_len as u64);
        buf
    }

    impl_config! {}
}

/// owned header buf
#[derive(Debug, Clone)]
pub struct Header(pub(crate) BytesMut);

impl Header {
    impl_get! {}
    impl_set! {}
    impl_config! {}

    /// construct new header
    pub fn new<M: Into<Option<[u8; 4]>>>(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        mask_key: M,
        opcode: OpCode,
        payload_len: u64,
    ) -> Self {
        let mut buf = BytesMut::new();
        let mask_key = mask_key.into();
        Header::config(
            fin,
            rsv1,
            rsv2,
            rsv3,
            opcode,
            mask_key.is_some(),
            payload_len,
            &mut buf,
        );
        let mut header = Header(buf);
        if let Some(key) = mask_key {
            header.set_masking_key(key);
        }
        header
    }

    /// return read only header view
    pub fn view(&self) -> HeaderView {
        HeaderView(&self.0)
    }

    /// return mutable header view
    pub fn view_mut(&mut self) -> HeaderViewMut {
        HeaderViewMut(&mut self.0)
    }
}

/// owned read framed, usually from read frame from stream
#[derive(Debug, Clone)]
pub struct ReadFrame(pub(crate) BytesMut);

impl ReadFrame {
    /// construct read frame
    pub fn new<'a, P: Into<PayloadMut<'a>>>(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload: P,
    ) -> Self {
        let mut payload: PayloadMut = payload.into();
        let payload_len = payload.len();
        let mut buf =
            HeaderViewMut::empty_payload(fin, rsv1, rsv2, rsv3, opcode, mask, payload_len);
        let start = buf.len();
        let end = start + payload_len;
        buf.resize(end, 0);
        let mut frame = ReadFrame(buf);
        let header = frame.header_mut();
        if mask {
            let key = header.masking_key().unwrap();
            payload.apply_mask(key);
        }
        payload.copy_to(&mut frame.0[start..end]);
        frame
    }

    /// construct empty payload frame
    pub fn empty(opcdoe: OpCode) -> Self {
        Self::new(true, false, false, false, opcdoe, true, vec![])
    }

    /// replace old frame with other  buf and return it
    pub fn replace(&mut self, other: ReadFrame) -> ReadFrame {
        let frame_len = self.header().payload_idx().1;
        let ret = ReadFrame(self.0.split_to(frame_len));
        self.0.extend_from_slice(&other.0);
        ret
    }

    /// readonly header view of frame
    pub fn header(&self) -> HeaderView {
        HeaderView(&self.0)
    }

    /// mutable header view of frame
    pub fn header_mut(&mut self) -> HeaderViewMut {
        HeaderViewMut(&mut self.0)
    }

    /// immutable frame payload
    pub fn payload(&self) -> &[u8] {
        let (start, end) = self.header().payload_idx();
        &self.0[start..end]
    }

    /// consume frame and return (header,  payload)
    pub fn split(mut self) -> (Header, BytesMut) {
        let stop = self.header().payload_idx().0;
        let header = Header(self.0.split_to(stop));
        (header, self.0)
    }

    /// mutable reference of payload
    pub fn payload_mut(&mut self) -> &mut [u8] {
        let (start, end) = self.header().payload_idx();
        &mut self.0[start..end]
    }
}

/// borrowed data contains payload
#[derive(Debug, Clone)]
pub struct BorrowedFrame<'a> {
    pub(crate) header: Header,
    /// borrowed payload
    pub payload: Payload<'a>,
}

impl<'a> BorrowedFrame<'a> {
    /// immutable header view
    pub fn header(&self) -> HeaderView {
        self.header.view()
    }

    /// mutable header view
    pub fn header_mut(&mut self) -> HeaderViewMut {
        self.header.view_mut()
    }

    /// payload
    pub fn payload(&self) -> Payload {
        self.payload.clone()
    }
}

/// header for user p
#[derive(Debug, Clone)]
pub struct OwnedFrame {
    header: Header,
    payload: BytesMut,
}

impl OwnedFrame {
    /// construct new owned frame
    #[allow(clippy::too_many_arguments)]
    pub fn new<M: Into<Option<[u8; 4]>>>(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        mask_key: M,
        opcode: OpCode,
        mut payload: BytesMut,
        mask_payload: bool,
    ) -> Self {
        let header = Header::new(
            fin,
            rsv1,
            rsv2,
            rsv3,
            mask_key,
            opcode,
            payload.len() as u64,
        );
        if mask_payload {
            if let Some(key) = header.masking_key() {
                apply_mask_fast32(&mut payload, key);
            }
        };
        Self { header, payload }
    }

    /// immutable header view
    pub fn header(&self) -> HeaderView {
        self.header.view()
    }

    /// mutable header view
    pub fn header_mut(&mut self) -> HeaderViewMut {
        self.header.view_mut()
    }

    /// immutable payload
    pub fn payload(&self) -> &[u8] {
        &self.payload
    }

    /// mutable payload
    pub fn payload_mut(&mut self) -> &mut BytesMut {
        &mut self.payload
    }

    /// replace old payload
    pub fn replace(&mut self, new: BytesMut, mask_payload: bool) -> BytesMut {
        self.header_mut().set_payload_len(new.len() as u64);
        let old = self.payload.split_to(self.payload.len());
        self.payload = new;
        if mask_payload {
            if let Some(key) = self.header.masking_key() {
                apply_mask_fast32(&mut self.payload, key);
            }
        }
        old
    }

pub fn set_masking_key(&mut self, key: [u8; 4])

key header mask key

pub fn auto_mask(&mut self) -> Option<[u8; 4]>

auto generate mask key and apply it

Examples found in repository

src/frame.rs (line 380)

    pub fn empty_payload(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload_len: usize,
    ) -> BytesMut {
        let mut header_len = 1;
        if mask {
            header_len += 4;
        }
        if payload_len <= 125 {
            header_len += 1;
        } else if payload_len <= 65535 {
            header_len += 3;
        } else {
            header_len += 9;
        }
        let mut buf = BytesMut::new();
        buf.resize(header_len, 0);
        let mut header = HeaderViewMut(&mut buf);
        header.set_fin(fin);
        header.set_rsv1(rsv1);
        header.set_rsv2(rsv2);
        header.set_rsv3(rsv3);
        header.set_opcode(opcode);
        if mask {
            header.set_mask(true);
            header.auto_mask();
        }
        header.set_payload_len(payload_len as u64);
        buf
    }

pub fn empty_payload(
    fin: bool,
    rsv1: bool,
    rsv2: bool,
    rsv3: bool,
    opcode: OpCode,
    mask: bool,
    payload_len: usize
) -> BytesMut

return bytes contains expected frame header

Examples found in repository

src/frame.rs (line 456)

    pub fn new<'a, P: Into<PayloadMut<'a>>>(
        fin: bool,
        rsv1: bool,
        rsv2: bool,
        rsv3: bool,
        opcode: OpCode,
        mask: bool,
        payload: P,
    ) -> Self {
        let mut payload: PayloadMut = payload.into();
        let payload_len = payload.len();
        let mut buf =
            HeaderViewMut::empty_payload(fin, rsv1, rsv2, rsv3, opcode, mask, payload_len);
        let start = buf.len();
        let end = start + payload_len;
        buf.resize(end, 0);
        let mut frame = ReadFrame(buf);
        let header = frame.header_mut();
        if mask {
            let key = header.masking_key().unwrap();
            payload.apply_mask(key);
        }
        payload.copy_to(&mut frame.0[start..end]);
        frame
    }

pub fn config(
    fin: bool,
    rsv1: bool,
    rsv2: bool,
    rsv3: bool,
    opcode: OpCode,
    mask: bool,
    payload_len: u64,
    buf: &mut BytesMut
)

config mut buf as a valid header

NOTE this operation will override buf content, and try to extend if there is no enough len

Trait Implementations

impl<'a> Debug for HeaderViewMut<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.