Go to file
Bartel Sielski 60c50cdea2
handshake(server): Make 'create_response_with_body' function more generic
This makes using it possible when the request and response body types differ.

Signed-off-by: bartel <bartel.sielski@gmail.com>
2024-04-23 16:45:36 +02:00
.github Update MSRV to 1.60 and check on the CI 2023-12-08 11:59:01 +01:00
autobahn Revert "Add `permessage-deflate` support" 2023-03-23 00:15:53 +01:00
benches Rework write 100k bench to have a slow writes & even slower flushes 2023-05-30 18:26:25 +01:00
examples Rename methods to `read`, `send`, `write` & `flush` 2023-05-27 13:19:13 +01:00
fuzz Rename methods to `read`, `send`, `write` & `flush` 2023-05-27 13:19:13 +01:00
scripts Revert "Add `permessage-deflate` support" 2023-03-23 00:15:53 +01:00
src handshake(server): Make 'create_response_with_body' function more generic 2024-04-23 16:45:36 +02:00
tests Add builder for additional header values (#400) 2024-02-12 20:56:15 +01:00
.gitignore Rename methods to `read`, `send`, `write` & `flush` 2023-05-27 13:19:13 +01:00
CHANGELOG.md Update 0.21.0 changelog 2023-12-12 13:10:10 +01:00
Cargo.toml Update MSRV to 1.60 and check on the CI 2023-12-08 11:59:01 +01:00
LICENSE-APACHE Relicense under MIT + Apache-2.0. 2017-04-11 16:18:09 +02:00
LICENSE-MIT Relicense under MIT + Apache-2.0. 2017-04-11 16:18:09 +02:00
README.md Update Autobahn Test Suite page 2023-10-16 19:36:40 -07:00
rustfmt.toml Fix clippy warnings and deprecated settings 2021-07-21 10:43:44 +09:00

README.md

Tungstenite

Lightweight stream-based WebSocket implementation for Rust.

use std::net::TcpListener;
use std::thread::spawn;
use tungstenite::accept;

/// A WebSocket echo server
fn main () {
    let server = TcpListener::bind("127.0.0.1:9001").unwrap();
    for stream in server.incoming() {
        spawn (move || {
            let mut websocket = accept(stream.unwrap()).unwrap();
            loop {
                let msg = websocket.read().unwrap();

                // We do not want to send back ping/pong messages.
                if msg.is_binary() || msg.is_text() {
                    websocket.send(msg).unwrap();
                }
            }
        });
    }
}

Take a look at the examples section to see how to write a simple client/server.

NOTE: tungstenite-rs is more like a barebone to build reliable modern networking applications using WebSockets. If you're looking for a modern production-ready "batteries included" WebSocket library that allows you to efficiently use non-blocking sockets and do "full-duplex" communication, take a look at tokio-tungstenite.

MIT licensed Apache-2.0 licensed Crates.io Build Status

Documentation

Introduction

This library provides an implementation of WebSockets, RFC6455. It allows for both synchronous (like TcpStream) and asynchronous usage and is easy to integrate into any third-party event loops including MIO. The API design abstracts away all the internals of the WebSocket protocol but still makes them accessible for those who wants full control over the network.

Why Tungstenite?

It's formerly WS2, the 2nd implementation of WS. WS2 is the chemical formula of tungsten disulfide, the tungstenite mineral.

Features

Tungstenite provides a complete implementation of the WebSocket specification. TLS is supported on all platforms using native-tls or rustls. The following features are available:

  • native-tls
  • native-tls-vendored
  • rustls-tls-native-roots
  • rustls-tls-webpki-roots

Choose the one that is appropriate for your needs.

By default no TLS feature is activated, so make sure you use one of the TLS features, otherwise you won't be able to communicate with the TLS endpoints.

There is no support for permessage-deflate at the moment, but the PRs are welcome 😉

Testing

Tungstenite is thoroughly tested and passes the Autobahn Test Suite for WebSockets. It is also covered by internal unit tests as well as possible.

Contributing

Please report bugs and make feature requests here.