Initial commit

eidheim · eidheim · commit 28ece529bf5a · 2014-08-02T11:38:13.000+02:00
diff --git a/README.md b/README.md
@@ -1,2 +1,44 @@
-Simple-WebSocket-Server
-=======================
+Simple-Web-Server
+=================
+
+A very simple, fast, multithreaded, platform independent WebSocket (WS) and WebSocket Secure (WSS) server implemented using C++11 and Boost.Asio. Created to be an easy way to make WebSocket endpoints in C++.
+
+See also https://github.com/eidheim/Simple-Web-Server for an easy way to make REST resources available from C++ applications. 
+
+### Features
+
+* Thread pool
+* Platform independent
+* WebSocket Secure support
+* Simple way to add WebSocket endpoints using regex for path, and anonymous functions
+* C++ bindings to the following OpenSSL methods: Base64, MD5, SHA1, SHA256 and SHA512 (found in crypt.hpp)
+
+###Usage
+
+See main_ws.cpp or main_wss.cpp for example usage. 
+
+### Dependencies
+
+Boost C++ libraries must be installed, go to http://www.boost.org for download and instructions. 
+
+OpenSSL libraries from https://www.openssl.org are required. 
+
+Will update to use C++17 networking instead in the future when it is supported by g++. 
+
+### Compile and run
+
+Compile with a C++11 compiler supporting regex (for instance g++ 4.9):
+
+#### WS
+
+g++ -O3 -std=c++11 -lboost_system -lcrypto main_ws.cpp -o ws_server
+
+Then to run the server: ./ws_server
+
+#### WSS
+
+g++ -O3 -std=c++11 -lboost_system -lssl -lcrypto main_wss.cpp -o wss_server
+
+Before running the server, an RSA private key (server.key) and an SSL certificate (server.crt) must be created. Follow, for instance, the instructions given here (for a self-signed certificate): http://www.akadia.com/services/ssh_test_certificate.html
+
+Then to run the server: ./wss_server
diff --git a/crypt.hpp b/crypt.hpp
@@ -0,0 +1,112 @@
+#ifndef CRYPT_HPP
+#define	CRYPT_HPP
+
+#include <openssl/evp.h>
+#include <openssl/buffer.h>
+
+#include <openssl/sha.h>
+#include <openssl/md5.h>
+
+#include <string>
+#include <vector>
+#include <cmath>
+
+namespace SimpleWeb {
+    namespace Crypt {
+        namespace Base64 {
+            std::string encode(const std::string& ascii) {            
+                BIO *bio, *b64;
+                BUF_MEM *bptr;
+
+                b64 = BIO_new(BIO_f_base64());
+                bio = BIO_new(BIO_s_mem());
+                BIO_push(b64, bio);
+                BIO_get_mem_ptr(b64, &bptr);
+
+                //Write directly to base64-string buffer to avoid copy
+                std::string base64;
+                int base64_length=round(4*ceil((double)ascii.length()/3.0));
+                base64.resize(base64_length);
+                bptr->length=0;
+                bptr->max=base64_length+1;
+                bptr->data=&base64[0];
+
+                BIO_write(b64, ascii.data(), ascii.length());
+                BIO_flush(b64);
+
+                //To not keep &base64[0] through BIO_free_all(b64)
+                bptr->length=0;
+                bptr->max=0;
+                bptr->data=nullptr;
+
+                BIO_free_all(b64);
+
+                return base64;
+            };
+            std::string decode(const std::string& base64) {
+                std::string ascii;
+                //Resize resulting ascii-string, however, the size is a up to two bytes too large.
+                ascii.resize((6*base64.length())/8);
+                BIO *b64, *bio;
+
+                b64 = BIO_new(BIO_f_base64());
+                BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL);
+                bio = BIO_new_mem_buf((char*)&base64[0], base64.length());
+                bio = BIO_push(b64, bio);
+
+                int decoded_length = BIO_read(bio, &ascii[0], ascii.length());
+                ascii.resize(decoded_length);
+
+                BIO_free_all(b64);
+
+                return ascii;
+            }; 
+        }
+
+        std::string MD5(const std::string& text) {
+            std::string encoded;
+            encoded.resize(128/8);
+
+            MD5_CTX context;
+            MD5_Init(&context);
+            MD5_Update(&context, (char*)&text[0], text.length());
+            MD5_Final((unsigned char*)&encoded[0], &context);
+            return encoded;
+        }
+
+        std::string SHA1(const std::string& text) {
+            std::string encoded;
+            encoded.resize(160/8);
+
+            SHA_CTX context;
+            SHA1_Init(&context);
+            SHA1_Update(&context, (char*)&text[0], text.length());
+            SHA1_Final((unsigned char*)&encoded[0], &context);
+            return encoded;
+        }
+
+        std::string SHA256(const std::string& text) {
+            std::string encoded;
+            encoded.resize(256/8);
+
+            SHA256_CTX context;
+            SHA256_Init(&context);
+            SHA256_Update(&context, (char*)&text[0], text.length());
+            SHA256_Final((unsigned char*)&encoded[0], &context);
+            return encoded;
+        }
+
+        std::string SHA512(const std::string& text) {
+            std::string encoded;
+            encoded.resize(512/8);
+
+            SHA512_CTX context;
+            SHA512_Init(&context);
+            SHA512_Update(&context, (char*)&text[0], text.length());
+            SHA512_Final((unsigned char*)&encoded[0], &context);
+            return encoded;
+        }
+    }
+}
+#endif	/* CRYPT_HPP */
+
diff --git a/main_ws.cpp b/main_ws.cpp
@@ -0,0 +1,83 @@
+#include "server_ws.hpp"
+
+using namespace std;
+using namespace SimpleWeb;
+
+int main() {
+    //WebSocket (WS)-server at port 8080 using 4 threads
+    Server<WS> server(8080, 4);
+    
+    //Example 1: echo WebSocket endpoint
+    //  Added debug messages for example use of the callbacks
+    //  Test with the following JavaScript:
+    //    var ws=new WebSocket("ws://localhost:8080/echo");
+    //    ws.onmessage=function(evt){console.log(evt.data);};
+    //    ws.send("test");
+    auto& callbacks_echo=server.endpoint["^/echo/?$"];
+    
+    callbacks_echo.onmessage=[&server](Connection& connection) {
+        //To receive message from client as string (message_stream.str())
+        stringstream message_stream;
+        *connection.message >> message_stream.rdbuf();
+        
+        string response=message_stream.str()+" from "+to_string((size_t)connection.id);
+        
+        stringstream response_stream;
+        response_stream << response;
+        
+        //server.send is an asynchronous function
+        server.send(connection.id, response_stream, [](const boost::system::error_code& ec){
+            if(!ec)
+                cout << "Message sent successfully" << endl;
+            else {
+                cout << "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
+                cout << "Error: " << ec << ", error message: " << ec.message() << endl;
+           }
+        });
+    };
+    
+    callbacks_echo.onopen=[&server](Connection& connection) {
+        cout << "Opened connection to " << (size_t)connection.id << endl;
+    };
+    
+    //See RFC 6455 7.4.1. for status codes
+    callbacks_echo.onclose=[](Connection& connection, int status) {
+        cout << "Closed connection to " << (size_t)connection.id << " 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
+    callbacks_echo.onerror=[](Connection& connection, const boost::system::error_code& ec) {
+        cout << "Error in connection " << (size_t)connection.id << ". ";
+        cout << "Error: " << ec << ", error message: " << ec.message() << endl;
+    };
+    
+
+    //Example 2: Echo to all WebSocket endpoints
+    //  Sending received messages to all connected clients
+    //  Test with the following JavaScript on more than one browser windows:
+    //    var ws=new WebSocket("ws://localhost:8080/echo_all");
+    //    ws.onmessage=function(evt){console.log(evt.data);};
+    //    ws.send("test");
+    auto& callbacks_echo_all=server.endpoint["^/echo_all/?$"];
+    callbacks_echo_all.onmessage=[&server](Connection& connection) {
+        //To receive message from client as string (message_stream.str())
+        stringstream message_stream;
+        *connection.message >> message_stream.rdbuf();
+        
+        string response=message_stream.str()+" from "+to_string((size_t)connection.id);
+        
+        for(auto connection_id: server.get_connection_ids()) {
+            stringstream response_stream;
+            response_stream << response;
+            
+            //server.send is an asynchronous function
+            server.send(connection_id, response_stream);
+        }
+    };
+    
+    //Start WS-server
+    server.start();
+    
+    return 0;
+}
diff --git a/main_wss.cpp b/main_wss.cpp
@@ -0,0 +1,83 @@
+#include "server_wss.hpp"
+
+using namespace std;
+using namespace SimpleWeb;
+
+int main() {
+    //WebSocket Secure (WSS)-server at port 8080 using 4 threads
+    Server<WSS> server(8080, 4, "server.crt", "server.key");
+    
+    //Example 1: echo WebSocket Secure endpoint
+    //  Added debug messages for example use of the callbacks
+    //  Test with the following JavaScript:
+    //    var wss=new WebSocket("wss://localhost:8080/echo");
+    //    wss.onmessage=function(evt){console.log(evt.data);};
+    //    wss.send("test");
+    auto& callbacks_echo=server.endpoint["^/echo/?$"];
+    
+    callbacks_echo.onmessage=[&server](Connection& connection) {
+        //To receive message from client as string (message_stream.str())
+        stringstream message_stream;
+        *connection.message >> message_stream.rdbuf();
+        
+        string response=message_stream.str()+" from "+to_string((size_t)connection.id);
+        
+        stringstream response_stream;
+        response_stream << response;
+        
+        //server.send is an asynchronous function
+        server.send(connection.id, response_stream, [](const boost::system::error_code& ec){
+            if(!ec)
+                cout << "Message sent successfully" << endl;
+            else {
+                cout << "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
+                cout << "Error: " << ec << ", error message: " << ec.message() << endl;
+           }
+        });
+    };
+    
+    callbacks_echo.onopen=[&server](Connection& connection) {
+        cout << "Opened connection to " << (size_t)connection.id << endl;
+    };
+    
+    //See RFC 6455 7.4.1. for status codes
+    callbacks_echo.onclose=[](Connection& connection, int status) {
+        cout << "Closed connection to " << (size_t)connection.id << " 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
+    callbacks_echo.onerror=[](Connection& connection, const boost::system::error_code& ec) {
+        cout << "Error in connection " << (size_t)connection.id << ". ";
+        cout << "Error: " << ec << ", error message: " << ec.message() << endl;
+    };
+    
+
+    //Example 2: Echo to all WebSocket Secure endpoints
+    //  Sending received messages to all connected clients
+    //  Test with the following JavaScript on more than one browser windows:
+    //    var wss=new WebSocket("wss://localhost:8080/echo_all");
+    //    wss.onmessage=function(evt){console.log(evt.data);};
+    //    wss.send("test");
+    auto& callbacks_echo_all=server.endpoint["^/echo_all/?$"];
+    callbacks_echo_all.onmessage=[&server](Connection& connection) {
+        //To receive message from client as string (message_stream.str())
+        stringstream message_stream;
+        *connection.message >> message_stream.rdbuf();
+        
+        string response=message_stream.str()+" from "+to_string((size_t)connection.id);
+        
+        for(auto connection_id: server.get_connection_ids()) {
+            stringstream response_stream;
+            response_stream << response;
+            
+            //server.send is an asynchronous function
+            server.send(connection_id, response_stream);
+        }
+    };
+    
+    //Start WSS-server
+    server.start();
+    
+    return 0;
+}
diff --git a/server_ws.hpp b/server_ws.hpp
diff --git a/server_wss.hpp b/server_wss.hpp
