wsocket 0.3.1

Lighweight, fast and native WebSocket implementation for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use std::io;
use std::string::FromUtf8Error;

#[cfg(all(feature = "handshake", feature = "client"))]
use hyper::StatusCode;
use thiserror::Error;

use crate::Close;
use crate::CloseCode;

pub type WSocketResult<T> = Result<T, WSocketError>;

#[derive(Error, Debug)]
pub enum WSocketError {
  #[error("unknown opcode `{0}`")]
  UnknownOpCode(u8),
  #[error("unknown close code `{0}`")]
  UnknownCloseCode(u16),
  #[error("reserve bit must be `0`")]
  ReserveBitMustBeNull,
  #[error("control frame must not be fragmented")]
  ControlFrameMustNotBeFragmented,
  #[error("control frame must have a payload length of 125 bytes or less")]
  ControlFrameMustHaveAPayloadLengthOf125BytesOrLess,
  #[error("payload too large")]
  PayloadTooLarge,
  #[error("io error")]
  Io(
    #[source]
    #[from]
    io::Error,
  ),
  #[error("not connected")]
  NotConnected,
  #[error("connection closed")]
  ConnectionClosed(Close),
  #[error("framed messages are not supported")]
  FramedMessagesAreNotSupported,
  #[error("text frames are not supported")]
  TextFramesAreNotSupported,
  #[error("invalid utf8")]
  InvalidUtf8(
    #[source]
    #[from]
    FromUtf8Error,
  ),
  #[error("invalid close close `{0}`")]
  InvalidCloseCode(u16),
  #[cfg(all(feature = "handshake", feature = "client"))]
  #[error("invalid status code `{actual}`, expected {expected}")]
  InvalidStatusCode {
    actual: StatusCode,
    expected: StatusCode,
  },
  #[error("invalid websocket http upgrade header")]
  InvalidUpgradeHeader,
  #[error("invalid websocket http connection header")]
  InvalidConnectionHeader,
  #[cfg(any(feature = "upgrade", all(feature = "client", feature = "handshake")))]
  #[error("hyper error")]
  Hyper(
    #[source]
    #[from]
    hyper::Error,
  ),
  #[error("missing sec web socket key")]
  MissingSecWebSocketKey,
  #[error("unsupported sec websocket version")]
  UnsupportedSecWebsocketVersion,
}

impl WSocketError {
  pub(crate) fn is_io_error(&self) -> bool {
    matches!(self, WSocketError::Io(_))
  }

  pub(crate) fn close_code(&self) -> Option<CloseCode> {
    match self {
      Self::UnknownOpCode(_) => Some(CloseCode::ProtocolError),
      Self::UnknownCloseCode(_) => Some(CloseCode::ProtocolError),
      Self::ReserveBitMustBeNull => Some(CloseCode::Unsupported),
      Self::ControlFrameMustNotBeFragmented => Some(CloseCode::Unsupported),
      Self::ControlFrameMustHaveAPayloadLengthOf125BytesOrLess => Some(CloseCode::ProtocolError),
      Self::PayloadTooLarge => Some(CloseCode::MessageTooBig),
      Self::Io(_) => Some(CloseCode::Abnormal),
      Self::NotConnected => None,
      Self::ConnectionClosed(_) => None,
      Self::FramedMessagesAreNotSupported => Some(CloseCode::Unsupported),
      Self::TextFramesAreNotSupported => Some(CloseCode::Unsupported),
      Self::InvalidUtf8(_) => Some(CloseCode::InvalidPayload),
      Self::InvalidCloseCode(_) => None,
      #[cfg(all(feature = "handshake", feature = "client"))]
      Self::InvalidStatusCode { .. } => None,
      Self::InvalidUpgradeHeader => None,
      Self::InvalidConnectionHeader => None,
      #[cfg(any(feature = "upgrade", all(feature = "client", feature = "handshake")))]
      Self::Hyper(_) => None,
      Self::MissingSecWebSocketKey => None,
      Self::UnsupportedSecWebsocketVersion => None,
    }
  }
}