While receiving message that is split among multiple frames, websocket client threats them as individual messages. Other websocket libraries reasamble the messages correctly so i know it isn't something wrong with the server binary i'm connecting to. Possible relavant place in code: https://github.com/eidheim/Simple-WebSocket-Server/blob/master/client_ws.hpp#L565 It doesn't check either if FIN bit or 0x00 opcode(continue message?) It would be nice if the library reassembled messages or at least provided us a feedback that it isn't a complete message at least, since AFAIK there can't be other messages incoming until the first one arrives.

Example sent from server:

{
  "Key": "data"
}

Example received in Simple-Websocket-Client: message 1:

{
  "K

message 2:

ey":"data"

message 3:

}

EDIT: This has no relation with message size, the server binary that runs websocket server just likes fragmented messages...

From my understanding of your code, each time a message is received, the data is copied to a fresh message object. So the data stored in the message won't change or increase: it could be a simple string instead of an istream. Then, the length field would be superfluous. In fact, the Message class could even inherit from std::string.

The benefits would be a much easier manipulation of the message and most of the time at least one less copy of it.

I could propose a patch if this make sense to you.

I'm not sure why I would be getting this issue, but if I have multiple simultaneous connections, onmessage seems to all be directed on to the last connection, and not the connection it originated from.

Is there something wrong with my code?

Related to #11.

Following the ws_example.cpp the code below shows that sending multiple responses to a client is not handled properly. I want to be able to send multiple responses to the client so it can process them separately. Am I using the library incorrectly or is this a concurrency issue? The example seems to be independent of the variable NUM_THREADS, I think the problem is how the send function on the server handles the streams.

#include "server_ws.hpp"
#include "client_ws.hpp"

#define NUM_THREADS 4

using namespace std;

typedef SimpleWeb::SocketServer<SimpleWeb::WS> WsServer;
typedef SimpleWeb::SocketClient<SimpleWeb::WS> WsClient;

void send_message(WsServer* server, shared_ptr<WsServer::Connection> connection, std::string msg)
{
  cout << "Server: Sending Message: "  << msg << endl;
  auto send_stream=make_shared<WsServer::SendStream>();
  *send_stream << msg;
  //server.send is an asynchronous function
  server->send(connection, send_stream, [server, connection](const boost::system::error_code& ec){
      if(ec) {
      cout << "Server: Error sending message. " <<
      //See http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference.html, Error Codes for error code meanings
      "Error: " << ec << ", error message: " << ec.message() << endl;
      }
      });
}

int main() {
  //WebSocket (WS)-server at port 8080 using 4 threads
  WsServer server(8080, NUM_THREADS);

  auto& test=server.endpoint["^/test/?$"];

  test.onmessage=[&server](shared_ptr<WsServer::Connection> connection, shared_ptr<WsServer::Message> message) {
    auto message_str=message->string();
    cout << "Server: Message received: \"" << message_str << "\" from " << (size_t)connection.get() << endl;
    send_message(&server, connection, "test1");
    send_message(&server, connection, "test2");
  };

  test.onopen=[](shared_ptr<WsServer::Connection> connection) {
    cout << "Server: Opened connection " << (size_t)connection.get() << endl;
  };

  //See RFC 6455 7.4.1. for status codes
  test.onclose=[](shared_ptr<WsServer::Connection> connection, int status, const string& reason) {
    cout << "Server: Closed connection " << (size_t)connection.get() << " with status code " << status << endl;
  };

  //See http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference.html, Error Codes for error code meanings
  test.onerror=[](shared_ptr<WsServer::Connection> connection, const boost::system::error_code& ec) {
    cout << "Server: Error in connection " << (size_t)connection.get() << ". " << 
      "Error: " << ec << ", error message: " << ec.message() << endl;
  };



  thread server_thread([&server](){
      //Start WS-server
      server.start();
      });

  //Wait for server to start so that the client can connect
  this_thread::sleep_for(chrono::seconds(1));

  WsClient client("localhost:8080/test");
  client.onmessage=[&client](shared_ptr<WsClient::Message> message) {
    auto message_str=message->string();

    cout << "Client: Message received:" << message_str << endl;
  };

  client.onopen=[&client]() {
    cout << "Client: Opened connection" << endl;

    string message="Hello";
    cout << "Client: Sending message: \"" << message << "\"" << endl;

    auto send_stream=make_shared<WsClient::SendStream>();
    *send_stream << message;
    client.send(send_stream);
  };

  client.onclose=[](int status, const string& reason) {
    cout << "Client: Closed connection with status code " << status << endl;
  };

  //See http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference.html, Error Codes for error code meanings
  client.onerror=[](const boost::system::error_code& ec) {
    cout << "Client: Error: " << ec << ", error message: " << ec.message() << endl;
  };

  client.start();

  server_thread.join();

  return 0;
}

I simply did

git clone https://github.com/eidheim/Simple-WebSocket-Server.git

Then compiled in linux

g++ -O3 -std=c++1y ws_examples.cpp -lboost_system -lcrypto -lpthread -o ws_examples

Wrote a sample JS client as specified in documentation

<!Doctype html>
<html>
    <head>
        <title>
            Web Socket 
        </title>
   </head>
<body>
    <script>

var ws=new WebSocket("ws://localhost:8080/echo");
ws.onmessage=function(evt){console.log(evt.data);};
ws.send("test");


    </script>
</body>
</html>

But when I run client and server, It gives error

Uncaught InvalidStateError: Failed to execute 'send' on 'WebSocket': Still in CONNECTING state. WebSocket connection to 'ws://localhost:8080/echo' failed: Connection closed before receiving a handshake response

Can you please direct where is things going wrong ?

Ubuntu 14 Boost 0.9.8 No trace was received on server side

Hi there,

looking at client_ws.hpp, it is not clear to me whether the "ping" between client and server will go on in the background, while onmessage() does its work (see "read_message_content" -- it appears as if either the ping or the onmessage function run, but not both).

My use-case may involve quite long times without any user-defined interaction between client and server (from minutes to days), while the data obtained from the server is processed within the onmessage function. This is for an application involving distributed parametric optimisation, so data transfers are generally small -- a few kilobytes -- but evaluation times may be quite long.

So, do I need to send my calculation into the background in its own thread and if so, do I need to take care of the synchronization of the final client.send() command issued by this thread ? After all the ping will continue in any case, if I do "expensive" calculations in a thread.

I would also like to understand what action is taken by client and server if the ping does not get an answer for a predefined number of submissions or time. Will this result in an onerror() call?

In any case, thanks for a great library!

Kind Regards, Beet

When sending multiple (large) messages, oftentimes the send fails with odd messages about protocol corruption.

Haven't dug into the code too deeply, but it seems this can be a possible issue. Any thoughts for workarounds?

In order to rule out the possibility that this issue had anything to do with message content, I generated a file that was 75k of the letter h. I then sent a message containing that payload from the server to the client.

The server acted as if nothing was wrong, but nothing happened at the client, so I sent it again.

This time, the client received the message. Then I sent it again.

This time, the client closed the connection:

Closed Connection with code: 26728 Reason: hhhhhhü⌂ ☺%╘ ☺%╘hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

I find that I get this behavior with 70000 h's, but 60000 h's works just fine.

I'm building a cross-platform app and I noticed this behavior while using Visual Studio 2015 on Windows Server 2012. I haven't tested it out on gcc yet, but I will do so next time I'm in Linux mode.

Here's a gist containing the code I'm using.

WssClient::start and later network error, on_error enters and WssClient::start executes again, on_open comes in. When you send a message, on_error occurs, and again when WssClient::start, it goes on_open. When you send a message, on_error occurs again.

I know, you are not so much into supporting non C++11-standard compilers, so I can understand if you don't want to pull in the first commit 560cb90 (which looks a bit ugly).

The commit 6f6c1c9 should be important on any compiler (I am wondering, why this is compiling with other versions as std::mutex isn't copy- or movable and therefore Endpoint can't be used in an std::map<> like this).

cfa4f1f is a minor fix, for a problem, which is caused, by using a global io_service, which lives longer than the WebsocketServer instance. After calling io_service::stop() the acceptor gets notified of the stop, which ends in an access violation because he tries to call accept() on a deleted object.

For the wss_examples I get the following error:

Undefined symbols for architecture x86_64:
  "_ERR_remove_thread_state", referenced from:
      boost::asio::ssl::detail::openssl_init_base::do_init::~do_init() in wss_examples.cpp.o
  "_TLSv1_1_client_method", referenced from:
      boost::asio::ssl::context::context(boost::asio::ssl::context_base::method) in wss_examples.cpp.o
  "_TLSv1_1_method", referenced from:
      boost::asio::ssl::context::context(boost::asio::ssl::context_base::method) in wss_examples.cpp.o
  "_TLSv1_1_server_method", referenced from:
      boost::asio::ssl::context::context(boost::asio::ssl::context_base::method) in wss_examples.cpp.o
  "_TLSv1_2_client_method", referenced from:
      boost::asio::ssl::context::context(boost::asio::ssl::context_base::method) in wss_examples.cpp.o
  "_TLSv1_2_method", referenced from:
      boost::asio::ssl::context::context(boost::asio::ssl::context_base::method) in wss_examples.cpp.o
  "_TLSv1_2_server_method", referenced from:
      boost::asio::ssl::context::context(boost::asio::ssl::context_base::method) in wss_examples.cpp.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[2]: *** [wss_examples] Error 1
make[1]: *** [CMakeFiles/wss_examples.dir/all] Error 2
make: *** [all] Error 2

Any ideas for a fix? Trying to address #18

According to the Websocket RFC, a Pong frame sent in response to a Ping frame must have identical "Application data" as found in the message body of the Ping frame being replied to.

The current implementation always sends an empty Pong message. Problems arise when communicating with other implementations conforming to the RFC, which would discard an empty Pong message, in case the original Ping message wasn't empty.

This pull request contains a fix to this issue.

Hi, thank you for this library!

I'm trying to use the library with ASIO but, although it's installed in my system, cmake fails.

My environment: OS: Archlinux compiler: clang cmake version: 3.10.3

Steps to reproduce:

git clone https://github.com/eidheim/Simple-WebSocket-Server/
cd Simple-WebSocket-Server
mkdir build
cd build
cmake -DUSE_STANDALONE_ASIO=ON ..

Error: Standalone Asio not found

But ls /usr/include/asio* returns:

/usr/include/asio.hpp

/usr/include/asio:
associated_allocator.hpp     basic_socket.hpp              buffered_stream.hpp            defer.hpp                      handler_invoke_hook.hpp    is_write_buffered.hpp          serial_port_base.hpp         strand.hpp                 unyield.hpp
associated_executor.hpp      basic_socket_iostream.hpp     buffered_write_stream_fwd.hpp  detail                         handler_type.hpp           local                          serial_port.hpp              streambuf.hpp              use_future.hpp
async_result.hpp             basic_socket_streambuf.hpp    buffered_write_stream.hpp      dispatch.hpp                   high_resolution_timer.hpp  packaged_task.hpp              serial_port_service.hpp      stream_socket_service.hpp  uses_executor.hpp
basic_datagram_socket.hpp    basic_streambuf_fwd.hpp       buffer.hpp                     error_code.hpp                 impl                       placeholders.hpp               signal_set.hpp               system_context.hpp         version.hpp
basic_deadline_timer.hpp     basic_streambuf.hpp           buffers_iterator.hpp           error.hpp                      io_context.hpp             posix                          signal_set_service.hpp       system_error.hpp           waitable_timer_service.hpp
basic_io_object.hpp          basic_stream_socket.hpp       completion_condition.hpp       execution_context.hpp          io_context_strand.hpp      post.hpp                       socket_acceptor_service.hpp  system_executor.hpp        wait_traits.hpp
basic_raw_socket.hpp         basic_waitable_timer.hpp      connect.hpp                    executor.hpp                   io_service.hpp             raw_socket_service.hpp         socket_base.hpp              system_timer.hpp           windows
basic_seq_packet_socket.hpp  bind_executor.hpp             coroutine.hpp                  executor_work_guard.hpp        io_service_strand.hpp      read_at.hpp                    spawn.hpp                    thread.hpp                 write_at.hpp
basic_serial_port.hpp        buffered_read_stream_fwd.hpp  datagram_socket_service.hpp    generic                        ip                         read.hpp                       ssl                          thread_pool.hpp            write.hpp
basic_signal_set.hpp         buffered_read_stream.hpp      deadline_timer.hpp             handler_alloc_hook.hpp         is_executor.hpp            read_until.hpp                 ssl.hpp                      time_traits.hpp            yield.hpp
basic_socket_acceptor.hpp    buffered_stream_fwd.hpp       deadline_timer_service.hpp     handler_continuation_hook.hpp  is_read_buffered.hpp       seq_packet_socket_service.hpp  steady_timer.hpp             ts

Hence asio.hpp is present and the whole asio library too.

How can I fix this? (My guess is that the problem is related to cmake somehow)

Thank you

Hello, @eidheim

First, thanks to make this Simple WebSocket.

I needed to send binary mode. I found the article, https://github.com/eidheim/Simple-WebSocket-Server/issues/30, about this, and applied to my project.

FYI, here is my wrappers. Furthermore, I wish to consider these warpping functions, and merged into SimpleWeb::SocketServer.

Sincerely, YeonHo Park from South Korea. Thanks.

using WsServer = SimpleWeb::SocketServer<SimpleWeb::WS>;
WsServer m_ws_server;
   void SendText( shared_ptr<WsServer::Connection> connection,
                  const std::string& message,
                  const std::function<void( const error_code& )>& callback = nullptr );
   void SendBinary( shared_ptr<WsServer::Connection> connection,
                    const std::shared_ptr<WsServer::SendStream>& send_stream,
                    const std::function<void( const error_code& )>& callback = nullptr );
   void BroadcastBinary( const std::shared_ptr<WsServer::SendStream>& send_stream,
                         const std::function<void( const error_code& )>& callback = nullptr );
   void BroadcastText( const std::string& message_to_send,
                       const std::function<void( const error_code& )>& callback = nullptr );

void Websocket::SendText( shared_ptr<WsServer::Connection> connection,
                          const std::string& message,
                          const std::function<void( const error_code& )>& callback )
{
   auto send_stream = make_shared<WsServer::SendStream>();
   *send_stream << message;
   connection->send( send_stream, callback, 129 ); // fin_rsv_opcode: 129 = one fragment & text.
}

void Websocket::SendBinary( shared_ptr<WsServer::Connection> connection,
                            const std::shared_ptr<WsServer::SendStream>& send_stream,
                            const std::function<void( const error_code& )>& callback )
{
   connection->send( send_stream, callback, 130 ); // fin_rsv_opcode: 130 = one fragment & binary.
}

void Websocket::BroadcastBinary( const std::shared_ptr<WsServer::SendStream>& send_stream,
                                 const std::function<void( const error_code& )>& callback )
{
   for( auto& a_connection : m_ws_server.get_connections() )
      SendBinary( a_connection, send_stream, callback );
}

void Websocket::BroadcastText( const string& message_to_send, 
                               const std::function<void( const error_code& )>& callback )
{
   for( auto& a_connection : m_ws_server.get_connections() )
      SendText( a_connection, message_to_send, callback );
}

// example.
auto send_stream = make_shared<WsServer::SendStream>();
*send_stream << YOUR_BINARY_DATA;
Websocket::getInstance()->BroadcastBinary( send_stream );

Got this error testing wss client

terminate called after throwing an instance of 'boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::system::system_error> >'
  what():  context: asio.ssl error
Aborted

$ ssh -V OpenSSH_7.2p2 Ubuntu-4ubuntu2.4, OpenSSL 1.0.2g 1 Mar 2016

$ dpkg -s libboost-dev | grep 'Version' Version: 1.58.0.1ubuntu1

When client disconnect the send function throws an exception in 'cancel_timeout()' - 'std::unique_lockstd::mutex lock(timer_mutex);' row. The exception is: "Exception thrown at 0x09643473 (msvcp140d.dll) in mtsrv.dev.exe: 0xC0000005: Access violation reading location 0xDDDDDDDD."

This happens when client disconnected at the same time when server is sending data.