2021-02-28 19:55:34 +00:00
|
|
|
//! WebSocket protocol implementation.
|
2017-10-08 05:41:02 +00:00
|
|
|
//!
|
2021-02-12 00:27:20 +00:00
|
|
|
//! To setup a WebSocket, first perform the WebSocket handshake then on success convert `Payload` into a
|
2021-01-04 11:27:32 +00:00
|
|
|
//! `WsStream` stream and then use `WsWriter` to communicate with the peer.
|
|
|
|
|
|
2018-10-05 19:47:22 +00:00
|
|
|
use std::io;
|
2017-10-08 04:48:00 +00:00
|
|
|
|
2021-01-04 11:27:32 +00:00
|
|
|
use derive_more::{Display, Error, From};
|
2018-10-05 19:47:22 +00:00
|
|
|
use http::{header, Method, StatusCode};
|
2018-12-06 22:32:52 +00:00
|
|
|
|
2021-02-28 19:55:34 +00:00
|
|
|
use crate::{
|
2021-04-13 10:16:12 +00:00
|
|
|
body::Body, error::ResponseError, header::HeaderValue, message::RequestHead,
|
|
|
|
|
response::Response, ResponseBuilder,
|
2021-02-28 19:55:34 +00:00
|
|
|
};
|
2017-10-08 04:48:00 +00:00
|
|
|
|
2018-10-05 19:47:22 +00:00
|
|
|
mod codec;
|
2019-12-11 13:20:20 +00:00
|
|
|
mod dispatcher;
|
2018-04-13 23:02:01 +00:00
|
|
|
mod frame;
|
2018-01-21 00:47:34 +00:00
|
|
|
mod mask;
|
2018-04-13 23:02:01 +00:00
|
|
|
mod proto;
|
2018-01-10 19:13:29 +00:00
|
|
|
|
2019-12-12 08:06:54 +00:00
|
|
|
pub use self::codec::{Codec, Frame, Item, Message};
|
2019-12-11 13:20:20 +00:00
|
|
|
pub use self::dispatcher::Dispatcher;
|
2018-10-10 20:20:00 +00:00
|
|
|
pub use self::frame::Parser;
|
2019-03-18 04:09:50 +00:00
|
|
|
pub use self::proto::{hash_key, CloseCode, CloseReason, OpCode};
|
2018-03-02 19:29:55 +00:00
|
|
|
|
2021-01-04 11:27:32 +00:00
|
|
|
/// WebSocket protocol errors.
|
|
|
|
|
#[derive(Debug, Display, From, Error)]
|
2018-03-02 19:29:55 +00:00
|
|
|
pub enum ProtocolError {
|
2021-01-04 11:27:32 +00:00
|
|
|
/// Received an unmasked frame from client.
|
|
|
|
|
#[display(fmt = "Received an unmasked frame from client.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
UnmaskedFrame,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
|
|
|
|
/// Received a masked frame from server.
|
|
|
|
|
#[display(fmt = "Received a masked frame from server.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
MaskedFrame,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
|
|
|
|
/// Encountered invalid opcode.
|
|
|
|
|
#[display(fmt = "Invalid opcode: {}.", _0)]
|
|
|
|
|
InvalidOpcode(#[error(not(source))] u8),
|
|
|
|
|
|
2018-02-27 18:09:24 +00:00
|
|
|
/// Invalid control frame length
|
2021-01-04 11:27:32 +00:00
|
|
|
#[display(fmt = "Invalid control frame length: {}.", _0)]
|
|
|
|
|
InvalidLength(#[error(not(source))] usize),
|
|
|
|
|
|
|
|
|
|
/// Bad opcode.
|
|
|
|
|
#[display(fmt = "Bad opcode.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
BadOpCode,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
2018-02-27 18:09:24 +00:00
|
|
|
/// A payload reached size limit.
|
2018-12-20 02:34:56 +00:00
|
|
|
#[display(fmt = "A payload reached size limit.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
Overflow,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
|
|
|
|
/// Continuation is not started.
|
2019-12-12 08:06:54 +00:00
|
|
|
#[display(fmt = "Continuation is not started.")]
|
|
|
|
|
ContinuationNotStarted,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
|
|
|
|
/// Received new continuation but it is already started.
|
|
|
|
|
#[display(fmt = "Received new continuation but it is already started.")]
|
2019-12-12 08:06:54 +00:00
|
|
|
ContinuationStarted,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
|
|
|
|
/// Unknown continuation fragment.
|
|
|
|
|
#[display(fmt = "Unknown continuation fragment: {}.", _0)]
|
|
|
|
|
ContinuationFragment(#[error(not(source))] OpCode),
|
|
|
|
|
|
|
|
|
|
/// I/O error.
|
|
|
|
|
#[display(fmt = "I/O error: {}", _0)]
|
2018-12-20 02:34:56 +00:00
|
|
|
Io(io::Error),
|
2018-02-27 18:09:24 +00:00
|
|
|
}
|
|
|
|
|
|
2018-03-02 19:29:55 +00:00
|
|
|
impl ResponseError for ProtocolError {}
|
2018-02-27 18:09:24 +00:00
|
|
|
|
2021-01-04 11:27:32 +00:00
|
|
|
/// WebSocket handshake errors
|
2018-12-20 02:34:56 +00:00
|
|
|
#[derive(PartialEq, Debug, Display)]
|
2018-03-02 19:29:55 +00:00
|
|
|
pub enum HandshakeError {
|
2021-01-04 11:27:32 +00:00
|
|
|
/// Only get method is allowed.
|
|
|
|
|
#[display(fmt = "Method not allowed.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
GetMethodRequired,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
2021-02-12 00:27:20 +00:00
|
|
|
/// Upgrade header if not set to WebSocket.
|
2021-01-04 11:27:32 +00:00
|
|
|
#[display(fmt = "WebSocket upgrade is expected.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
NoWebsocketUpgrade,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
|
|
|
|
/// Connection header is not set to upgrade.
|
|
|
|
|
#[display(fmt = "Connection upgrade is expected.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
NoConnectionUpgrade,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
|
|
|
|
/// WebSocket version header is not set.
|
|
|
|
|
#[display(fmt = "WebSocket version header is required.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
NoVersionHeader,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
2021-02-12 00:27:20 +00:00
|
|
|
/// Unsupported WebSocket version.
|
2021-02-28 19:55:34 +00:00
|
|
|
#[display(fmt = "Unsupported WebSocket version.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
UnsupportedVersion,
|
2021-01-04 11:27:32 +00:00
|
|
|
|
|
|
|
|
/// WebSocket key is not set or wrong.
|
|
|
|
|
#[display(fmt = "Unknown websocket key.")]
|
2018-02-27 18:09:24 +00:00
|
|
|
BadWebsocketKey,
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-02 19:29:55 +00:00
|
|
|
impl ResponseError for HandshakeError {
|
2021-04-13 10:16:12 +00:00
|
|
|
fn error_response(&self) -> Response<Body> {
|
2021-01-04 11:27:32 +00:00
|
|
|
match self {
|
2018-10-05 18:04:59 +00:00
|
|
|
HandshakeError::GetMethodRequired => Response::MethodNotAllowed()
|
2021-01-15 02:11:10 +00:00
|
|
|
.insert_header((header::ALLOW, "GET"))
|
2018-04-29 16:09:08 +00:00
|
|
|
.finish(),
|
2021-01-04 11:27:32 +00:00
|
|
|
|
2018-10-05 18:04:59 +00:00
|
|
|
HandshakeError::NoWebsocketUpgrade => Response::BadRequest()
|
2021-02-28 19:55:34 +00:00
|
|
|
.reason("No WebSocket Upgrade header found")
|
2018-04-13 23:02:01 +00:00
|
|
|
.finish(),
|
2021-01-04 11:27:32 +00:00
|
|
|
|
2018-10-05 18:04:59 +00:00
|
|
|
HandshakeError::NoConnectionUpgrade => Response::BadRequest()
|
2021-02-28 19:55:34 +00:00
|
|
|
.reason("No Connection upgrade")
|
2018-04-29 16:09:08 +00:00
|
|
|
.finish(),
|
2021-01-04 11:27:32 +00:00
|
|
|
|
2018-10-05 18:04:59 +00:00
|
|
|
HandshakeError::NoVersionHeader => Response::BadRequest()
|
2021-02-28 19:55:34 +00:00
|
|
|
.reason("WebSocket version header is required")
|
2018-04-13 23:02:01 +00:00
|
|
|
.finish(),
|
2021-01-04 11:27:32 +00:00
|
|
|
|
2018-10-05 18:04:59 +00:00
|
|
|
HandshakeError::UnsupportedVersion => Response::BadRequest()
|
2021-02-28 19:55:34 +00:00
|
|
|
.reason("Unsupported WebSocket version")
|
2018-04-29 16:09:08 +00:00
|
|
|
.finish(),
|
2021-01-04 11:27:32 +00:00
|
|
|
|
2018-10-05 18:04:59 +00:00
|
|
|
HandshakeError::BadWebsocketKey => {
|
|
|
|
|
Response::BadRequest().reason("Handshake error").finish()
|
|
|
|
|
}
|
2018-02-27 18:09:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-12 00:27:20 +00:00
|
|
|
/// Verify WebSocket handshake request and create handshake response.
|
2019-04-11 21:00:32 +00:00
|
|
|
pub fn handshake(req: &RequestHead) -> Result<ResponseBuilder, HandshakeError> {
|
2018-10-22 16:59:20 +00:00
|
|
|
verify_handshake(req)?;
|
|
|
|
|
Ok(handshake_response(req))
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-12 00:27:20 +00:00
|
|
|
/// Verify WebSocket handshake request.
|
2019-04-11 21:00:32 +00:00
|
|
|
pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
|
2017-10-08 04:48:00 +00:00
|
|
|
// WebSocket accepts only GET
|
2019-04-11 21:00:32 +00:00
|
|
|
if req.method != Method::GET {
|
2018-04-13 23:02:01 +00:00
|
|
|
return Err(HandshakeError::GetMethodRequired);
|
2017-10-08 04:48:00 +00:00
|
|
|
}
|
|
|
|
|
|
2021-02-12 00:27:20 +00:00
|
|
|
// Check for "UPGRADE" to WebSocket header
|
2017-10-10 06:07:32 +00:00
|
|
|
let has_hdr = if let Some(hdr) = req.headers().get(header::UPGRADE) {
|
|
|
|
|
if let Ok(s) = hdr.to_str() {
|
2019-03-18 05:56:13 +00:00
|
|
|
s.to_ascii_lowercase().contains("websocket")
|
2017-10-10 06:07:32 +00:00
|
|
|
} else {
|
|
|
|
|
false
|
|
|
|
|
}
|
2017-10-08 04:48:00 +00:00
|
|
|
} else {
|
|
|
|
|
false
|
|
|
|
|
};
|
|
|
|
|
if !has_hdr {
|
2018-04-13 23:02:01 +00:00
|
|
|
return Err(HandshakeError::NoWebsocketUpgrade);
|
2017-10-08 04:48:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Upgrade connection
|
2017-10-14 07:11:12 +00:00
|
|
|
if !req.upgrade() {
|
2018-04-13 23:02:01 +00:00
|
|
|
return Err(HandshakeError::NoConnectionUpgrade);
|
2017-10-08 04:48:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// check supported version
|
2018-05-17 19:20:20 +00:00
|
|
|
if !req.headers().contains_key(header::SEC_WEBSOCKET_VERSION) {
|
2018-04-13 23:02:01 +00:00
|
|
|
return Err(HandshakeError::NoVersionHeader);
|
2017-10-08 04:48:00 +00:00
|
|
|
}
|
|
|
|
|
let supported_ver = {
|
2018-02-28 22:16:55 +00:00
|
|
|
if let Some(hdr) = req.headers().get(header::SEC_WEBSOCKET_VERSION) {
|
2017-10-10 06:07:32 +00:00
|
|
|
hdr == "13" || hdr == "8" || hdr == "7"
|
|
|
|
|
} else {
|
|
|
|
|
false
|
2017-10-08 04:48:00 +00:00
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
if !supported_ver {
|
2018-04-13 23:02:01 +00:00
|
|
|
return Err(HandshakeError::UnsupportedVersion);
|
2017-10-08 04:48:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// check client handshake for validity
|
2018-02-28 22:16:55 +00:00
|
|
|
if !req.headers().contains_key(header::SEC_WEBSOCKET_KEY) {
|
2018-04-13 23:02:01 +00:00
|
|
|
return Err(HandshakeError::BadWebsocketKey);
|
2017-10-10 06:07:32 +00:00
|
|
|
}
|
2018-10-22 16:59:20 +00:00
|
|
|
Ok(())
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-12 00:27:20 +00:00
|
|
|
/// Create WebSocket handshake response.
|
2018-10-22 16:59:20 +00:00
|
|
|
///
|
|
|
|
|
/// This function returns handshake `Response`, ready to send to peer.
|
2019-04-11 21:00:32 +00:00
|
|
|
pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
|
2017-10-10 06:07:32 +00:00
|
|
|
let key = {
|
2018-02-28 22:16:55 +00:00
|
|
|
let key = req.headers().get(header::SEC_WEBSOCKET_KEY).unwrap();
|
2018-03-09 21:03:15 +00:00
|
|
|
proto::hash_key(key.as_ref())
|
2017-10-08 04:48:00 +00:00
|
|
|
};
|
|
|
|
|
|
2018-10-22 16:59:20 +00:00
|
|
|
Response::build(StatusCode::SWITCHING_PROTOCOLS)
|
2018-11-19 22:57:12 +00:00
|
|
|
.upgrade("websocket")
|
2021-01-15 02:11:10 +00:00
|
|
|
.insert_header((header::TRANSFER_ENCODING, "chunked"))
|
2021-02-28 19:55:34 +00:00
|
|
|
.insert_header((
|
|
|
|
|
header::SEC_WEBSOCKET_ACCEPT,
|
|
|
|
|
// key is known to be header value safe ascii
|
|
|
|
|
HeaderValue::from_bytes(&key).unwrap(),
|
|
|
|
|
))
|
2018-10-22 16:59:20 +00:00
|
|
|
.take()
|
2017-10-08 04:48:00 +00:00
|
|
|
}
|
|
|
|
|
|
2017-10-23 00:33:24 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
|
mod tests {
|
2017-11-16 06:06:28 +00:00
|
|
|
use super::*;
|
2018-12-06 23:03:01 +00:00
|
|
|
use crate::test::TestRequest;
|
2018-07-04 15:01:27 +00:00
|
|
|
use http::{header, Method};
|
2017-10-23 00:33:24 +00:00
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn test_handshake() {
|
2018-06-25 04:58:04 +00:00
|
|
|
let req = TestRequest::default().method(Method::POST).finish();
|
2018-04-29 16:09:08 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
HandshakeError::GetMethodRequired,
|
2020-12-23 01:28:17 +00:00
|
|
|
verify_handshake(req.head()).unwrap_err(),
|
2018-04-29 16:09:08 +00:00
|
|
|
);
|
2018-04-13 23:02:01 +00:00
|
|
|
|
2018-06-25 04:58:04 +00:00
|
|
|
let req = TestRequest::default().finish();
|
2018-04-29 16:09:08 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
HandshakeError::NoWebsocketUpgrade,
|
2020-12-23 01:28:17 +00:00
|
|
|
verify_handshake(req.head()).unwrap_err(),
|
2018-04-29 16:09:08 +00:00
|
|
|
);
|
2017-10-23 00:33:24 +00:00
|
|
|
|
2018-06-25 04:58:04 +00:00
|
|
|
let req = TestRequest::default()
|
2021-01-15 02:11:10 +00:00
|
|
|
.insert_header((header::UPGRADE, header::HeaderValue::from_static("test")))
|
2018-06-25 04:58:04 +00:00
|
|
|
.finish();
|
2018-04-29 16:09:08 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
HandshakeError::NoWebsocketUpgrade,
|
2020-12-23 01:28:17 +00:00
|
|
|
verify_handshake(req.head()).unwrap_err(),
|
2018-04-29 16:09:08 +00:00
|
|
|
);
|
2017-10-23 00:33:24 +00:00
|
|
|
|
2018-06-25 04:58:04 +00:00
|
|
|
let req = TestRequest::default()
|
2021-01-15 02:11:10 +00:00
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::UPGRADE,
|
|
|
|
|
header::HeaderValue::from_static("websocket"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
2018-12-06 22:32:52 +00:00
|
|
|
.finish();
|
2018-04-29 16:09:08 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
HandshakeError::NoConnectionUpgrade,
|
2020-12-23 01:28:17 +00:00
|
|
|
verify_handshake(req.head()).unwrap_err(),
|
2018-04-29 16:09:08 +00:00
|
|
|
);
|
2017-10-23 00:33:24 +00:00
|
|
|
|
2018-06-25 04:58:04 +00:00
|
|
|
let req = TestRequest::default()
|
2021-01-15 02:11:10 +00:00
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::UPGRADE,
|
|
|
|
|
header::HeaderValue::from_static("websocket"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
|
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::CONNECTION,
|
|
|
|
|
header::HeaderValue::from_static("upgrade"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
2018-12-06 22:32:52 +00:00
|
|
|
.finish();
|
2018-04-29 16:09:08 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
HandshakeError::NoVersionHeader,
|
2020-12-23 01:28:17 +00:00
|
|
|
verify_handshake(req.head()).unwrap_err(),
|
2018-04-29 16:09:08 +00:00
|
|
|
);
|
2017-10-23 00:33:24 +00:00
|
|
|
|
2018-06-25 04:58:04 +00:00
|
|
|
let req = TestRequest::default()
|
2021-01-15 02:11:10 +00:00
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::UPGRADE,
|
|
|
|
|
header::HeaderValue::from_static("websocket"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
|
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::CONNECTION,
|
|
|
|
|
header::HeaderValue::from_static("upgrade"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
|
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::SEC_WEBSOCKET_VERSION,
|
|
|
|
|
header::HeaderValue::from_static("5"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
2018-12-06 22:32:52 +00:00
|
|
|
.finish();
|
2018-04-29 16:09:08 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
HandshakeError::UnsupportedVersion,
|
2020-12-23 01:28:17 +00:00
|
|
|
verify_handshake(req.head()).unwrap_err(),
|
2018-04-29 16:09:08 +00:00
|
|
|
);
|
2017-10-23 00:33:24 +00:00
|
|
|
|
2018-06-25 04:58:04 +00:00
|
|
|
let req = TestRequest::default()
|
2021-01-15 02:11:10 +00:00
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::UPGRADE,
|
|
|
|
|
header::HeaderValue::from_static("websocket"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
|
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::CONNECTION,
|
|
|
|
|
header::HeaderValue::from_static("upgrade"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
|
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::SEC_WEBSOCKET_VERSION,
|
|
|
|
|
header::HeaderValue::from_static("13"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
2018-12-06 22:32:52 +00:00
|
|
|
.finish();
|
2018-04-29 16:09:08 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
HandshakeError::BadWebsocketKey,
|
2020-12-23 01:28:17 +00:00
|
|
|
verify_handshake(req.head()).unwrap_err(),
|
2018-04-29 16:09:08 +00:00
|
|
|
);
|
2017-10-23 00:33:24 +00:00
|
|
|
|
2018-06-25 04:58:04 +00:00
|
|
|
let req = TestRequest::default()
|
2021-01-15 02:11:10 +00:00
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::UPGRADE,
|
|
|
|
|
header::HeaderValue::from_static("websocket"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
|
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::CONNECTION,
|
|
|
|
|
header::HeaderValue::from_static("upgrade"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
|
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::SEC_WEBSOCKET_VERSION,
|
|
|
|
|
header::HeaderValue::from_static("13"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
|
|
|
|
.insert_header((
|
2018-06-25 04:58:04 +00:00
|
|
|
header::SEC_WEBSOCKET_KEY,
|
|
|
|
|
header::HeaderValue::from_static("13"),
|
2021-01-15 02:11:10 +00:00
|
|
|
))
|
2018-12-06 22:32:52 +00:00
|
|
|
.finish();
|
2018-04-13 23:02:01 +00:00
|
|
|
assert_eq!(
|
|
|
|
|
StatusCode::SWITCHING_PROTOCOLS,
|
2019-04-11 21:00:32 +00:00
|
|
|
handshake_response(req.head()).finish().status()
|
2018-04-13 23:02:01 +00:00
|
|
|
);
|
2017-10-23 00:33:24 +00:00
|
|
|
}
|
2018-02-27 18:09:24 +00:00
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
fn test_wserror_http_response() {
|
2021-04-13 10:16:12 +00:00
|
|
|
let resp = HandshakeError::GetMethodRequired.error_response();
|
2018-02-27 18:09:24 +00:00
|
|
|
assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
|
2021-04-13 10:16:12 +00:00
|
|
|
let resp = HandshakeError::NoWebsocketUpgrade.error_response();
|
2018-02-27 18:09:24 +00:00
|
|
|
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
|
2021-04-13 10:16:12 +00:00
|
|
|
let resp = HandshakeError::NoConnectionUpgrade.error_response();
|
2018-02-27 18:09:24 +00:00
|
|
|
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
|
2021-04-13 10:16:12 +00:00
|
|
|
let resp = HandshakeError::NoVersionHeader.error_response();
|
2018-02-27 18:09:24 +00:00
|
|
|
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
|
2021-04-13 10:16:12 +00:00
|
|
|
let resp = HandshakeError::UnsupportedVersion.error_response();
|
2018-02-27 18:09:24 +00:00
|
|
|
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
|
2021-04-13 10:16:12 +00:00
|
|
|
let resp = HandshakeError::BadWebsocketKey.error_response();
|
2018-02-27 18:09:24 +00:00
|
|
|
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
|
|
|
|
|
}
|
2017-10-23 00:33:24 +00:00
|
|
|
}
|
