In rust and rust-websocket, how to keep the connection for each client persion? if one client, one thread, can reach 10k connections in single server machine?

I'm upgrading from 0.17 to 0.19 and it looks like splitting a generic client (one that supports both WS and WSS) into its Sender and Receiver components is no longer possible because SslStream doesn't implement Splittable. Up to now splitting the client has been the idiomatic way to do things (at least in the examples) - is there a way around this limitation?

Because of the outdated Openssl I get

error: native library `openssl` is being linked to by more than one version of the same package, but it can only be linked once; try updating or pinning your dependencies to ensure that this package only shows up once

  openssl-sys v0.9.6
  openssl-sys v0.7.17

with other crates I want to use. Is that planned or possible?

According to http://tools.ietf.org/html/rfc6455#section-4.1 connect should take a host, port, resource name, and a secure flag, along with a list of protocols and extensions to be used. Currently, it accepts a Url object.

"A client will need to supply a /host/, /port/, /resource name/, and a /secure/ flag, which are the components of a WebSocket URI as discussed in Section 3, along with a list of /protocols/ and /extensions/ to be used."

I currently can't run the client example with a secure web socket

error: no method named `split` found for type `websocket::Client<openssl::ssl::SslStream<std::net::TcpStream>>` in the current scope
  --> src\main.rs:30:43
   |
30 |   let (mut receiver, mut sender) = client.split().unwrap();
   |                                           ^^^^^
   |
   = note: the method `split` exists but the following trait bounds were not satisfied: `openssl::ssl::SslStream<std::net::TcpStream> : websocket::stream::Splittable`

not sure if I'm doing this wrong, but I just use .connect_secure(None) instead of .connect_insecure()

rust-websocket development is prone to hiatuses, and users are complaining.

Maybe the repository should be just turned into an organization, with multiple contributes having granted access to publish to crates.io?

My local build fails with:

native library openssl is being linked to by more than one package, and can only be linked to by one package openssl-sys v0.7.0 openssl-sys v0.6.7

Hacking the library to depend on 0.6.7 fixes the build, for now at least.

With the recent tokio reform, tokio-core has been deprecated in favour of the tokio crate. It would be nice to migrate over; There have been some breaking changes, but at first glance it doesn't seem like it'll be too hard.

Currently as I'm seeing it, an attacker could hold a thread responding to requests hostage as long as they want. I can of course terminate threads after a certain time but this probably has some dangerous side-effects that I don't ever want to happen.

Hi everyone!

When I opened this crate the readme states

Note: Maintainership of this project is slugglish. You may want to use tungstenite or tokio-tungstenite instead.

Is it worth making pull requests for this project or do you suggest to move on to another project?

This seemed like a good place for this. I wanted to flesh out a few things I was thinking about. There are many websocket libraries out there today but this one is the coolest, and it can be cooler! There are many missing features and pain points of the library that I wanted to discuss and I thought I would list them here. We should also include some features from other libraries and become the best ws library out there!

Features:

• HTTP Server integration
  • Take hyper requests and turn them into websockets
  • integration with hyper and others can be kept under a feature.
  • easier routing
• custom headers
  • Cookies is probably useful, etc.
• non-blocking
  • simple, use the net2 crate
• mio support
  • easy, but API should be decided first
• protocols
  • easy, needs API change
• bare bones
  • easier user control of the dataframe sent over the wire
  • a lot of this is just more documentation
• thread pool
  • probably behind a feature toggle, not a priority, seems useful
• autobahn tests
  • add permessage-deflate

Pain Points:

• maybe using hyper is overkill. still not 100% sure.
  • http-muncher or httparse + some header library might be OK
  • we really don't need anything more than stdlib, see websocket-stream
  • we might be able to get away with maybe 1 dependency
• not so precise error handling scheme, although this is a low priority
• more documentation
• more fluent API
  • this is mostly true but I think there are some places that could be more readable
• less unecessary copying (there is still some going on!)

Future:

• I'm a worried about supporting future revisions to the standard, the code now isn't so flexible.

This mostly spawned out of me trying to fix #53, and I thought we should discuss some API before I sink more time into it. If we're all clear on what we want it to look like we can easily split up work and people can more easily contribute.

So @cyderize to start off do you think this list is complete? I have some API ideas I'll post soon.

Hi

I am trying to implement "half-blocking" mode. That is blocking write & non-blocking read. Currently I use following code together with tungstenite. Blocking write is done using "write_inner". TcpStream is from "mio" crate.

Unfortunately, it does not work reliably. I am getting various errors at handshake & later time.

I'd like to ask. If rust-websocket could be used to implement working scheme like that?

struct TcpCustomStream {
    s: TcpStream,

    block: bool,
    poll: Poll,
    events: Events,
}

impl TcpCustomStream {
    pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<Self> {
        let a = if let Some(x) = addr.to_socket_addrs()?.next() {
            x
        } else {
            return Err(std::io::Error::new(
                std::io::ErrorKind::Other,
                "Tcp connect call failed",
            ));
        };
        match TcpStream::connect(a) {
            Ok(mut x) => {
                let poll = Poll::new()?;
                let events = Events::with_capacity(128);

                // Register the socket with `Poll`
                poll.registry()
                    .register(&mut x, Token(0), Interest::WRITABLE)?;

                Ok(Self {
                    s: x,
                    poll,
                    events,
                    block: true,
                })
            }
            Err(x) => Err(x),
        }
    }

    pub fn set_nonblocking(&mut self) -> io::Result<()> {
        self.block = false;
        Ok(())
    }

    pub fn wait_write(&mut self) -> io::Result<()> {
        loop {
            //println!("tcp wait_write poll");
            self.poll.poll(&mut self.events, None)?;

            for event in &self.events {
                if event.token() == Token(0) && event.is_writable() {
                    // The socket connected (probably, it could still be a spurious
                    // wakeup)
                    //println!("tcp wait_write ready");
                    return Ok(());
                }
            }
        }
    }

}

impl std::io::Read for TcpCustomStream {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        loop {
            match self.s.read(buf) {
                Err(x) if self.block && would_block(&x) => {
                    //println!("tcp read would_block {:?}", x);
                    thread::yield_now();
                }
                // x @ Err(_) => {
                //     //println!("tcp read err {:?}", x);
                //     break x;
                // }
                x => break x,
            }
        }
    }
}

impl std::io::Write for TcpCustomStream {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        match self.s.write(buf) {
            // x @ Err(_) => {
            //     println!("tcp write err {:?}", x);
            //     x
            // }
            x => x,
        }
    }
    fn flush(&mut self) -> std::io::Result<()> {
        self.s.flush()
    }
}

... skipped
pub struct Client {
    socket: Option<WebSocket<TcpCustomStream>>,
}

fn would_block(err: &std::io::Error) -> bool {
    match err {
        x if (x.kind() == io::ErrorKind::WouldBlock)
            || (x.kind() == std::io::ErrorKind::Interrupted) =>
        {
            true
        }
        _ => false,
    }
}

impl Client {
    pub fn new() -> Self {
        Self {
            socket: None,
        }
    }

    pub fn connect<'a>(&mut self, uri_str: &'a str) -> Result<(), std::io::Error> {
        println!("Client started");

        let (mut client, _) = {
            let mut c = 10;
            loop {
                let req = Uri::from_maybe_shared(uri_str.to_string()).map_err(|_| {
                    std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid connect URI")
                })?;

                let host_port = req
                    .authority()
                    .ok_or(std::io::Error::new(
                        std::io::ErrorKind::InvalidInput,
                        "Invalid connect URI",
                    ))?
                    .as_str();

                let stream = TcpCustomStream::connect(host_port)?;
                println!("Client connected");

                match client(req, stream) {
                    Err(x) => {
                        println!("Connect {:?}", x);
                        if c == 1 {
                            return Err(std::io::Error::new(
                                std::io::ErrorKind::Other,
                                format!("Cannot connect to {}", uri_str),
                            ));
                        }
                        c -= 1;
                        thread::sleep(std::time::Duration::from_millis(1000));
                    }
                    Ok(x) => break x,
                }
            }
        };
        println!("WSClient connected");

        client.get_mut().set_nonblocking()?;
        println!("Set nonblocking mode");

        self.socket = Some(client);

        Ok(())
    }

    fn write_inner(socket: &mut WebSocket<TcpCustomStream>, m: Message) -> Result<(), Error> {
        match socket.write_message(m) {
            Err(tungstenite::Error::Io(e)) if would_block(&e) => {
                //println!("cl write would_block");
                return loop {
                    socket.get_mut().wait_write()?;
                    match socket.write_pending() {
                        Err(tungstenite::Error::Io(e)) if would_block(&e) => continue,
                        x => break x,
                    }
                };
            }
            x => {
                //println!("cl write {:?}", x);
                x
            }
        }
    }

i am implementing multi-threaded websocket client server chat application. On client side i am using rust-websocket library, while on the server side i am not using this library rather manually reading from the socket(TcpStream) connection.

On server side i am trying to read the data as let buf = socket.read_u16::<BigEndian>()?; where read_u16 is from byteorder::io::ReadBytesExt. it work fine for the text message sent by the client, The issue starts when we try to close any client by sending close message to the server as below,

let close_msg = Message::close();
let res = sender.send_message(&close_msg);

while reading this message on server side, with let buf = socket.read_u16::<BigEndian>()?; , it is successful on mac, but while in Linux it fails with wouldblock error i.e:

thread 'tokio-runtime-worker' panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 11, kind: WouldBlock, message: "Resource temporarily unavailable" }

On other hand if we send as close message using ping,

let close_msg = Message::ping(vec![1u8]);;
let res = sender.send_message(&close_msg);

then it don't give the above error and is successful on linux . I didn't understand why it behave different on mac and linux , can anyone please help?

websocket-client in rust,but websocket-server use C++,but client can't connect to server

error:thread 'main' panicked at 'called Result::unwrap() on an Err value: Other(HttpError(Io(Custom { kind: UnexpectedEof, error: "end of stream before headers finished" })))'

I got "websocket protocol error" from "recev_messages" method when the server program deployed on the Cloud, but this problem won't be seen on Native

Is there any possible ideas?

Hi there! I am using the websocket crate in one of my projects and I got a hint that I am depending on hyper version 0.10.6, which is vulnerable to RUSTSEC-2021-0079 and RUSTSEC-2021-0078. As it turns out the dependency was introduced through this library. I've looked into this and a potential fix would be to bump the hyper version to >=0.14.10, but this would introduce quite a few changes to this library as hyper changed it's whole header API (and more).