2192 lines
58 KiB
C++
2192 lines
58 KiB
C++
/*/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
***** HeadSocket v0.1, created by Jan Pinter **** Minimalistic header only WebSocket server implementation in C++ *****
|
|
Sources: https://github.com/P-i-N/HeadSocket, contact: Pinter.Jan@gmail.com
|
|
PUBLIC DOMAIN - no warranty implied or offered, use this at your own risk
|
|
|
|
-----------------------------------------------------------------------------------------------------------------------
|
|
|
|
Usage:
|
|
- use this as a regular header file, but in EXACTLY one of your C++ files (ie. main.cpp) you must define
|
|
HEADSOCKET_IMPLEMENTATION beforehand, like this:
|
|
|
|
#define HEADSOCKET_IMPLEMENTATION
|
|
#include <headsocket.h>
|
|
|
|
/*/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#ifndef __HEADSOCKET_H__
|
|
#define __HEADSOCKET_H__
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <map>
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace headsocket {
|
|
|
|
/* Forward declarations */
|
|
class connection;
|
|
class basic_tcp_server;
|
|
class basic_tcp_client;
|
|
class tcp_client;
|
|
class async_tcp_client;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <typename T> using ptr = std::shared_ptr<T>;
|
|
typedef size_t id_t;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace detail {
|
|
|
|
/* Forward declarations */
|
|
struct connection_impl;
|
|
struct basic_tcp_server_impl;
|
|
struct basic_tcp_client_impl;
|
|
struct async_tcp_client_impl;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static bool handshake_websocket(connection &conn);
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct less_comparator
|
|
{
|
|
bool operator()(const std::string &s1, const std::string &s2) const
|
|
{
|
|
return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(), [](char c1, char c2) -> bool
|
|
{
|
|
return tolower(c1) < tolower(c2);
|
|
});
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class connection
|
|
{
|
|
public:
|
|
connection(const detail::connection_impl &impl);
|
|
~connection();
|
|
|
|
detail::connection_impl *impl() const { return _p.get(); }
|
|
|
|
bool is_valid() const;
|
|
id_t id() const;
|
|
|
|
size_t write(const void *ptr, size_t length);
|
|
size_t write(const std::string &text) { return write(text.c_str(), text.length()); }
|
|
size_t read(void *ptr, size_t length);
|
|
|
|
bool force_write(const void *ptr, size_t length);
|
|
bool force_read(void *ptr, size_t length);
|
|
|
|
bool read_line(std::string &output);
|
|
|
|
private:
|
|
std::unique_ptr<detail::connection_impl> _p;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
enum class opcode
|
|
{
|
|
continuation = 0x00,
|
|
text = 0x01,
|
|
binary = 0x02,
|
|
connection_close = 0x08,
|
|
ping = 0x09,
|
|
pong = 0x0A
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct data_block
|
|
{
|
|
opcode op;
|
|
size_t offset;
|
|
size_t length = 0;
|
|
bool is_completed = false;
|
|
|
|
data_block(opcode opc, size_t off)
|
|
: op(opc)
|
|
, offset(off)
|
|
{
|
|
|
|
}
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class basic_tcp_server : public std::enable_shared_from_this<basic_tcp_server>
|
|
{
|
|
public:
|
|
int port() const;
|
|
void stop();
|
|
bool is_running() const;
|
|
bool disconnect(ptr<basic_tcp_client> client);
|
|
bool disconnect(id_t id);
|
|
|
|
protected:
|
|
struct protected_tag { };
|
|
|
|
virtual void init() { }
|
|
|
|
explicit basic_tcp_server(int port);
|
|
virtual ~basic_tcp_server();
|
|
|
|
virtual bool handshake(connection &conn) = 0;
|
|
virtual ptr<basic_tcp_client> accept(connection &conn) = 0;
|
|
virtual void client_connected(ptr<basic_tcp_client> client) = 0;
|
|
virtual void client_disconnected(ptr<basic_tcp_client> client) = 0;
|
|
|
|
std::unique_ptr<detail::basic_tcp_server_impl> _p;
|
|
|
|
private:
|
|
template <typename T> friend class tcp_server;
|
|
|
|
void remove_disconnected() const;
|
|
|
|
size_t acquire_clients() const;
|
|
void release_clients() const;
|
|
|
|
ptr<basic_tcp_client> client_at(size_t index) const;
|
|
size_t num_clients() const;
|
|
|
|
void accept_thread();
|
|
void disconnect_thread();
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class basic_tcp_client
|
|
{
|
|
public:
|
|
enum { is_basic_tcp_client };
|
|
|
|
static const size_t invalid_operation = static_cast<size_t>(-1);
|
|
|
|
virtual ~basic_tcp_client();
|
|
|
|
bool disconnect();
|
|
bool is_connected() const;
|
|
|
|
ptr<basic_tcp_server> server() const;
|
|
id_t id() const;
|
|
|
|
protected:
|
|
struct protected_tag { };
|
|
|
|
friend class basic_tcp_server;
|
|
|
|
virtual void on_accept() { }
|
|
virtual void on_disconnect() { }
|
|
|
|
basic_tcp_client(const std::string &address, int port);
|
|
basic_tcp_client(ptr<basic_tcp_server> server, connection &conn);
|
|
|
|
std::unique_ptr<detail::basic_tcp_client_impl> _p;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
struct protected_tag { };
|
|
|
|
#define HEADSOCKET_SERVER(className, baseClassName) \
|
|
protected: \
|
|
explicit className(int port): baseClassName(port) { init(); } \
|
|
public: \
|
|
typedef baseClassName base_t; \
|
|
className(const protected_tag &, int port): className(port) { } \
|
|
static headsocket::ptr<className> create(int port) { return std::make_shared<className>(protected_tag{}, port); } \
|
|
protected: \
|
|
void init()
|
|
|
|
template <typename T>
|
|
class tcp_server : public basic_tcp_server
|
|
{
|
|
HEADSOCKET_SERVER(tcp_server, basic_tcp_server) { }
|
|
|
|
public:
|
|
typedef T client_t;
|
|
typedef ptr<client_t> client_ptr;
|
|
|
|
virtual ~tcp_server()
|
|
{
|
|
base_t::stop();
|
|
}
|
|
|
|
class enumerator
|
|
{
|
|
public:
|
|
explicit enumerator(const tcp_server &server)
|
|
: _server(server)
|
|
, _count(server.acquire_clients())
|
|
{
|
|
|
|
}
|
|
|
|
~enumerator()
|
|
{
|
|
_server.release_clients();
|
|
}
|
|
|
|
const tcp_server &server() const { return _server; }
|
|
size_t size() const { return _count; }
|
|
|
|
struct iterator
|
|
{
|
|
enumerator &e;
|
|
size_t index;
|
|
|
|
iterator(enumerator &enu, size_t idx)
|
|
: e(enu)
|
|
, index(idx)
|
|
{
|
|
|
|
}
|
|
|
|
bool operator==(const iterator &iter) const { return iter.index == index && &iter.e == &e; }
|
|
bool operator!=(const iterator &iter) const { return iter.index != index || &iter.e != &e; }
|
|
ptr<T> operator*() const { return std::dynamic_pointer_cast<T>(e.server().client_at(index)); }
|
|
|
|
iterator &operator++()
|
|
{
|
|
++index;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
iterator begin() { return iterator(*this, 0); }
|
|
iterator end() { return iterator(*this, _count); }
|
|
|
|
private:
|
|
const tcp_server &_server;
|
|
size_t _count;
|
|
};
|
|
|
|
enumerator clients() const { return enumerator(*this); }
|
|
|
|
protected:
|
|
bool handshake(connection &conn) override { return true; }
|
|
|
|
virtual void client_connected(client_ptr client) { }
|
|
|
|
virtual void client_disconnected(client_ptr client) { }
|
|
|
|
private:
|
|
enum { needs_basic_tcp_client = T::is_basic_tcp_client };
|
|
|
|
ptr<basic_tcp_client> accept(connection &conn) override
|
|
{
|
|
ptr<basic_tcp_client> newClient = T::create(shared_from_this(), conn);
|
|
return newClient->is_connected() ? newClient : nullptr;
|
|
}
|
|
|
|
void client_connected(ptr<basic_tcp_client> client) override
|
|
{
|
|
client_connected(std::dynamic_pointer_cast<T>(client));
|
|
}
|
|
|
|
void client_disconnected(ptr<basic_tcp_client> client) override
|
|
{
|
|
client_disconnected(std::dynamic_pointer_cast<T>(client));
|
|
}
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define __HEADSOCKET_CLIENT_STATIC_CTORS(className) \
|
|
className(const protected_tag &, const std::string &address, int port): className(address, port) { } \
|
|
className(const protected_tag &, headsocket::ptr<headsocket::basic_tcp_server> server, headsocket::connection &conn): className(server, conn) { } \
|
|
static headsocket::ptr<className> create(const std::string &address, int port) { return std::make_shared<className>(protected_tag{}, address, port); } \
|
|
static headsocket::ptr<className> create(headsocket::ptr<headsocket::basic_tcp_server> server, headsocket::connection &conn) { return std::make_shared<className>(protected_tag{}, server, conn); }
|
|
|
|
#define HEADSOCKET_CLIENT_BASE(className) \
|
|
protected: \
|
|
className(const std::string &address, int port); \
|
|
className(ptr<basic_tcp_server> server, connection &conn); \
|
|
public: \
|
|
__HEADSOCKET_CLIENT_STATIC_CTORS(className)
|
|
|
|
#define HEADSOCKET_CLIENT(className, baseClassName) \
|
|
protected: \
|
|
className(const std::string &address, int port): baseClassName(address, port) { } \
|
|
className(headsocket::ptr<headsocket::basic_tcp_server> server, headsocket::connection &conn): baseClassName(server, conn) { } \
|
|
public: \
|
|
__HEADSOCKET_CLIENT_STATIC_CTORS(className)
|
|
|
|
class tcp_client : public basic_tcp_client
|
|
{
|
|
HEADSOCKET_CLIENT_BASE(tcp_client)
|
|
|
|
public:
|
|
typedef basic_tcp_client base_t;
|
|
enum { is_tcp_client };
|
|
|
|
virtual ~tcp_client();
|
|
|
|
virtual size_t write(const void *ptr, size_t length);
|
|
virtual size_t read(void *ptr, size_t length);
|
|
|
|
bool force_write(const void *ptr, size_t length);
|
|
bool force_read(void *ptr, size_t length);
|
|
|
|
bool read_line(std::string &output);
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class async_tcp_client : public basic_tcp_client
|
|
{
|
|
HEADSOCKET_CLIENT_BASE(async_tcp_client)
|
|
|
|
public:
|
|
typedef basic_tcp_client base_t;
|
|
enum { is_async_tcp_client };
|
|
|
|
virtual ~async_tcp_client();
|
|
|
|
void push(const void *ptr, size_t length);
|
|
void push(const std::string &text);
|
|
size_t peek() const;
|
|
size_t pop(void *ptr, size_t length);
|
|
|
|
protected:
|
|
void on_accept() override { init_threads(); }
|
|
void on_disconnect() override { kill_threads(); }
|
|
|
|
virtual void init_threads();
|
|
|
|
virtual size_t async_write_handler(uint8_t *ptr, size_t length);
|
|
virtual size_t async_read_handler(uint8_t *ptr, size_t length);
|
|
|
|
virtual bool async_received_data(const data_block &db, uint8_t *ptr, size_t length) { return false; }
|
|
|
|
virtual void push(const void *ptr, size_t length, opcode opcode);
|
|
|
|
void kill_threads();
|
|
|
|
std::unique_ptr<detail::async_tcp_client_impl> _ap;
|
|
|
|
private:
|
|
void write_thread();
|
|
void read_thread();
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class web_socket_client : public async_tcp_client
|
|
{
|
|
HEADSOCKET_CLIENT_BASE(web_socket_client)
|
|
|
|
public:
|
|
static const size_t frame_size_limit = 128 * 1024;
|
|
|
|
typedef async_tcp_client base_t;
|
|
enum { is_web_socket_client };
|
|
|
|
virtual ~web_socket_client();
|
|
|
|
size_t peek(opcode *op) const;
|
|
|
|
protected:
|
|
size_t async_write_handler(uint8_t *ptr, size_t length) override;
|
|
size_t async_read_handler(uint8_t *ptr, size_t length) override;
|
|
|
|
private:
|
|
struct frame_header
|
|
{
|
|
bool fin;
|
|
opcode op;
|
|
bool masked;
|
|
size_t payload_length;
|
|
uint32_t masking_key;
|
|
|
|
size_t write(uint8_t *ptr, size_t length) const;
|
|
size_t read(const uint8_t *ptr, size_t length);
|
|
};
|
|
|
|
size_t _payload_size = 0;
|
|
frame_header _current_header;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <typename T>
|
|
class web_socket_server : public tcp_server<T>
|
|
{
|
|
HEADSOCKET_SERVER(web_socket_server, tcp_server<T>) { }
|
|
|
|
public:
|
|
virtual ~web_socket_server()
|
|
{
|
|
base_t::stop();
|
|
}
|
|
|
|
protected:
|
|
bool handshake(connection &conn) override { return detail::handshake_websocket(conn); }
|
|
|
|
private:
|
|
enum { needs_web_socket_client = T::is_web_socket_client };
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class http_server : public tcp_server<tcp_client>
|
|
{
|
|
HEADSOCKET_SERVER(http_server, tcp_server<tcp_client>) { }
|
|
|
|
public:
|
|
~http_server()
|
|
{
|
|
stop();
|
|
}
|
|
|
|
struct response
|
|
{
|
|
std::string content_type = "text/html";
|
|
std::string message = "";
|
|
};
|
|
|
|
struct parameter
|
|
{
|
|
std::string name;
|
|
std::string value;
|
|
bool boolean;
|
|
int integer;
|
|
double real;
|
|
};
|
|
|
|
typedef std::map<std::string, parameter, detail::less_comparator> parameters_t;
|
|
|
|
protected:
|
|
virtual bool request(const std::string &path, const parameters_t ¶ms, response &resp) { return false; }
|
|
|
|
private:
|
|
bool handshake(connection &conn) final override;
|
|
|
|
ptr<basic_tcp_client> accept(connection &conn) final override { return nullptr; }
|
|
void client_connected(client_ptr client) final override { }
|
|
void client_disconnected(client_ptr client) final override { }
|
|
};
|
|
|
|
}
|
|
|
|
#endif // __HEADSOCKET_H__
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef HEADSOCKET_IMPLEMENTATION
|
|
#ifndef __HEADSOCKET_H_IMPL__
|
|
#define __HEADSOCKET_H_IMPL__
|
|
|
|
#include <thread>
|
|
#include <atomic>
|
|
#include <iomanip>
|
|
#include <vector>
|
|
#include <mutex>
|
|
#include <condition_variable>
|
|
#include <memory>
|
|
#include <sstream>
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef HEADSOCKET_PLATFORM_OVERRIDE
|
|
#ifdef _WIN32
|
|
#define HEADSOCKET_PLATFORM_WINDOWS
|
|
#elif __ANDROID__
|
|
#define HEADSOCKET_PLATFORM_ANDROID
|
|
#define HEADSOCKET_PLATFORM_NIX
|
|
#elif __APPLE__
|
|
#include "TargetConditionals.h"
|
|
#ifdef TARGET_OS_MAC
|
|
#define HEADSOCKET_PLATFORM_MAC
|
|
#endif
|
|
#elif __linux
|
|
#define HEADSOCKET_PLATFORM_NIX
|
|
#elif __unix
|
|
#define HEADSOCKET_PLATFORM_NIX
|
|
#elif __posix
|
|
#define HEADSOCKET_PLATFORM_NIX
|
|
#else
|
|
#error Unsupported platform!
|
|
#endif
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if defined(HEADSOCKET_PLATFORM_WINDOWS)
|
|
#pragma comment(lib, "ws2_32.lib")
|
|
#include <winsock2.h>
|
|
#include <windows.h>
|
|
#include <ws2tcpip.h>
|
|
#include <functional>
|
|
|
|
#elif defined(HEADSOCKET_PLATFORM_ANDROID) || defined(HEADSOCKET_PLATFORM_NIX)
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/ip.h>
|
|
#include <unistd.h>
|
|
#include <netdb.h>
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define HEADSOCKET_LOCK_SUFFIX(var, suffix) std::lock_guard<decltype(var)> __scope_lock##suffix(var);
|
|
#define HEADSOCKET_LOCK_SUFFIX2(var, suffix) HEADSOCKET_LOCK_SUFFIX(var, suffix)
|
|
#define HEADSOCKET_LOCK(var) HEADSOCKET_LOCK_SUFFIX2(var, __LINE__)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace headsocket {
|
|
|
|
namespace detail {
|
|
#if defined(HEADSOCKET_PLATFORM_WINDOWS)
|
|
typedef SOCKET socket_type;
|
|
static const int socket_error = SOCKET_ERROR;
|
|
static const SOCKET invalid_socket = INVALID_SOCKET;
|
|
void close_socket(socket_type s) { closesocket(s); }
|
|
#define HEADSOCKET_SPRINTF sprintf_s
|
|
#elif defined(HEADSOCKET_PLATFORM_ANDROID) || defined(HEADSOCKET_PLATFORM_NIX)
|
|
typedef int socket_type;
|
|
static const int socket_error = -1;
|
|
static const int invalid_socket = -1;
|
|
void close_socket(socket_type s) { close(s); }
|
|
#define HEADSOCKET_SPRINTF sprintf
|
|
#endif
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace detail {
|
|
|
|
class sha1
|
|
{
|
|
public:
|
|
typedef uint32_t digest32_t[5];
|
|
typedef uint8_t digest8_t[20];
|
|
|
|
inline static uint32_t rotate_left(uint32_t value, size_t count) { return (value << count) ^ (value >> (32 - count)); }
|
|
|
|
sha1()
|
|
{
|
|
_digest[0] = 0x67452301;
|
|
_digest[1] = 0xEFCDAB89;
|
|
_digest[2] = 0x98BADCFE;
|
|
_digest[3] = 0x10325476;
|
|
_digest[4] = 0xC3D2E1F0;
|
|
}
|
|
|
|
~sha1()
|
|
{
|
|
|
|
}
|
|
|
|
void process_byte(uint8_t octet)
|
|
{
|
|
_block[_block_byte_index++] = octet;
|
|
++_byte_count;
|
|
|
|
if (_block_byte_index == 64)
|
|
{
|
|
_block_byte_index = 0;
|
|
process_block();
|
|
}
|
|
}
|
|
|
|
void process_block(const void *start, const void *end)
|
|
{
|
|
const uint8_t *begin = static_cast<const uint8_t *>(start);
|
|
|
|
while (begin != end)
|
|
process_byte(*begin++);
|
|
}
|
|
|
|
void process_bytes(const void *data, size_t len)
|
|
{
|
|
process_block(data, static_cast<const uint8_t *>(data) + len);
|
|
}
|
|
|
|
const uint32_t *get_digest(digest32_t digest)
|
|
{
|
|
size_t bitCount = _byte_count * 8;
|
|
process_byte(0x80);
|
|
|
|
if (_block_byte_index > 56)
|
|
{
|
|
while (_block_byte_index != 0)
|
|
process_byte(0);
|
|
|
|
while (_block_byte_index < 56)
|
|
process_byte(0);
|
|
}
|
|
else
|
|
while (_block_byte_index < 56)
|
|
process_byte(0);
|
|
|
|
process_byte(0);
|
|
process_byte(0);
|
|
process_byte(0);
|
|
process_byte(0);
|
|
|
|
for (int i = 24; i >= 0; i -= 8)
|
|
process_byte(static_cast<unsigned char>((bitCount >> i) & 0xFF));
|
|
|
|
memcpy(digest, _digest, 5 * sizeof(uint32_t));
|
|
return digest;
|
|
}
|
|
|
|
const uint8_t *get_digest_bytes(digest8_t digest)
|
|
{
|
|
digest32_t d32;
|
|
get_digest(d32);
|
|
size_t s[] = { 24, 16, 8, 0 };
|
|
|
|
for (size_t i = 0, j = 0; i < 20; ++i, j = i % 4)
|
|
digest[i] = ((d32[i >> 2] >> s[j]) & 0xFF);
|
|
|
|
return digest;
|
|
}
|
|
|
|
private:
|
|
void process_block()
|
|
{
|
|
uint32_t w[80], s[] = { 24, 16, 8, 0 };
|
|
|
|
for (size_t i = 0, j = 0; i < 64; ++i, j = i % 4)
|
|
w[i / 4] = j ? (w[i / 4] | (_block[i] << s[j])) : (_block[i] << s[j]);
|
|
|
|
for (size_t i = 16; i < 80; i++)
|
|
w[i] = rotate_left((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1);
|
|
|
|
digest32_t dig = { _digest[0], _digest[1], _digest[2], _digest[3], _digest[4] };
|
|
|
|
for (size_t f, k, i = 0; i < 80; ++i)
|
|
{
|
|
if (i < 20)
|
|
f = (dig[1] & dig[2]) | (~dig[1] & dig[3]), k = 0x5A827999;
|
|
else if (i < 40)
|
|
f = dig[1] ^ dig[2] ^ dig[3], k = 0x6ED9EBA1;
|
|
else if (i < 60)
|
|
f = (dig[1] & dig[2]) | (dig[1] & dig[3]) | (dig[2] & dig[3]), k = 0x8F1BBCDC;
|
|
else
|
|
f = dig[1] ^ dig[2] ^ dig[3], k = 0xCA62C1D6;
|
|
|
|
uint32_t temp = static_cast<uint32_t>(rotate_left(dig[0], 5) + f + dig[4] + k + w[i]);
|
|
dig[4] = dig[3];
|
|
dig[3] = dig[2];
|
|
dig[2] = rotate_left(dig[1], 30);
|
|
dig[1] = dig[0];
|
|
dig[0] = temp;
|
|
}
|
|
|
|
for (size_t i = 0; i < 5; ++i)
|
|
_digest[i] += dig[i];
|
|
}
|
|
|
|
digest32_t _digest;
|
|
uint8_t _block[64];
|
|
size_t _block_byte_index = 0;
|
|
size_t _byte_count = 0;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct utils
|
|
{
|
|
static std::string base64_encode(const void *ptr, size_t length)
|
|
{
|
|
static const char *encoding_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
static size_t mod_table[] = { 0, 2, 1 };
|
|
|
|
std::string result(4 * ((length + 2) / 3), '=');
|
|
|
|
if (ptr && length)
|
|
{
|
|
const uint8_t *input = reinterpret_cast<const uint8_t *>(ptr);
|
|
|
|
for (size_t i = 0, j = 0, triplet = 0; i < length; triplet = 0)
|
|
{
|
|
for (size_t k = 0; k < 3; ++k)
|
|
triplet = (triplet << 8) | (i < length ? static_cast<uint8_t>(input[i++]) : 0);
|
|
|
|
for (size_t k = 4; k--;)
|
|
result[j++] = encoding_table[(triplet >> k * 6) & 0x3F];
|
|
}
|
|
|
|
for (size_t i = 0; i < mod_table[length % 3]; i++)
|
|
result[result.length() - 1 - i] = '=';
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static size_t xor32(uint32_t key, void *ptr, size_t length)
|
|
{
|
|
uint8_t *data = reinterpret_cast<uint8_t *>(ptr);
|
|
uint8_t *mask = reinterpret_cast<uint8_t *>(&key);
|
|
|
|
for (size_t i = 0; i < length; ++i, ++data)
|
|
*data = (*data) ^ mask[i % 4];
|
|
|
|
return length;
|
|
}
|
|
|
|
static std::string url_encode(const std::string &str)
|
|
{
|
|
std::ostringstream result;
|
|
result.fill('0');
|
|
result << std::hex;
|
|
|
|
for (std::string::const_iterator i = str.begin(), n = str.end(); i != n; ++i)
|
|
{
|
|
auto c = (*i);
|
|
|
|
if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~')
|
|
result << c;
|
|
else
|
|
result << '%' << std::setw(2) << static_cast<int>(c);
|
|
}
|
|
|
|
return result.str();
|
|
}
|
|
|
|
static std::string url_decode(const std::string &str)
|
|
{
|
|
std::ostringstream result;
|
|
|
|
for (size_t i = 0, S = str.length(); i < S; ++i)
|
|
{
|
|
auto c = str[i];
|
|
|
|
if (c == '%')
|
|
{
|
|
char hexBuff[3] = { 0, 0, 0 };
|
|
hexBuff[0] = str[++i];
|
|
hexBuff[1] = str[++i];
|
|
|
|
int value;
|
|
sscanf(hexBuff, "%x", &value);
|
|
result << static_cast<char>(value);
|
|
}
|
|
else if (c == '+')
|
|
result << ' ';
|
|
else
|
|
result << c;
|
|
}
|
|
|
|
return result.str();
|
|
}
|
|
|
|
static uint16_t swap16bits(uint16_t x) { return ((x & 0x00FF) << 8) | ((x & 0xFF00) >> 8); }
|
|
|
|
static uint32_t swap32bits(uint32_t x)
|
|
{
|
|
return ((x & 0x000000FF) << 24) | ((x & 0x0000FF00) << 8) | ((x & 0x00FF0000) >> 8) | ((x & 0xFF000000) >> 24);
|
|
}
|
|
|
|
static uint64_t swap64bits(uint64_t x)
|
|
{
|
|
return
|
|
((x & 0x00000000000000FFULL) << 56) | ((x & 0x000000000000FF00ULL) << 40) | ((x & 0x0000000000FF0000ULL) << 24) |
|
|
((x & 0x00000000FF000000ULL) << 8) | ((x & 0x000000FF00000000ULL) >> 8) | ((x & 0x0000FF0000000000ULL) >> 24) |
|
|
((x & 0x00FF000000000000ULL) >> 40) | ((x & 0xFF00000000000000ULL) >> 56);
|
|
}
|
|
|
|
static std::string trim(const std::string &str)
|
|
{
|
|
size_t trimLeft = 0, trimRight = str.length() - 1;
|
|
|
|
while (trimLeft < str.length() && isspace(str[trimLeft]))
|
|
++trimLeft;
|
|
|
|
while (trimRight < str.length() && isspace(str[trimRight]))
|
|
--trimRight;
|
|
|
|
return (trimRight >= str.length() || trimLeft >= str.length() || trimRight < trimLeft)
|
|
? std::string("")
|
|
: str.substr(trimLeft, trimRight - trimLeft + 1);
|
|
}
|
|
|
|
static std::string cut_front(std::string &str, char delimiter = ' ', bool first = true, bool hungry = true)
|
|
{
|
|
std::string result;
|
|
|
|
auto pos = first ? str.find(delimiter) : str.rfind(delimiter);
|
|
if (pos == std::string::npos)
|
|
{
|
|
if (hungry)
|
|
{
|
|
result = str;
|
|
str = "";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = str.substr(0, pos);
|
|
str = str.substr(pos + 1);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static std::string cut_back(std::string &str, char delimiter = ' ', bool first = true, bool hungry = true)
|
|
{
|
|
std::string result;
|
|
|
|
auto pos = first ? str.rfind(delimiter) : str.find(delimiter);
|
|
if (pos == std::string::npos)
|
|
{
|
|
if (hungry)
|
|
{
|
|
result = str;
|
|
str = "";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = str.substr(pos + 1);
|
|
str = str.substr(0, pos);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct critical_section
|
|
{
|
|
mutable std::atomic_bool consumer_lock;
|
|
|
|
critical_section()
|
|
{
|
|
consumer_lock = false;
|
|
}
|
|
|
|
void lock() const { while (consumer_lock.exchange(true)); }
|
|
void unlock() const { consumer_lock = false; }
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
template <typename T, typename M = critical_section>
|
|
struct lockable_value : M
|
|
{
|
|
T value;
|
|
|
|
T *operator->() { return &value; }
|
|
const T *operator->() const { return &value; }
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct semaphore
|
|
{
|
|
mutable std::atomic_size_t count;
|
|
mutable std::mutex mutex;
|
|
mutable std::condition_variable cv;
|
|
|
|
semaphore()
|
|
{
|
|
count = 0;
|
|
}
|
|
|
|
void lock(size_t minCount = 0) const
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
cv.wait(lock, [&]()->bool { return count > minCount; });
|
|
lock.release();
|
|
}
|
|
|
|
void unlock()
|
|
{
|
|
mutex.unlock();
|
|
}
|
|
|
|
void notify()
|
|
{
|
|
{
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
++count;
|
|
}
|
|
|
|
cv.notify_one();
|
|
}
|
|
|
|
void consume() const
|
|
{
|
|
if (count)
|
|
--count;
|
|
}
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct data_block_buffer
|
|
{
|
|
std::vector<data_block> blocks;
|
|
std::vector<uint8_t> buffer;
|
|
|
|
data_block_buffer()
|
|
{
|
|
buffer.reserve(65536);
|
|
}
|
|
|
|
data_block &block_begin(opcode op)
|
|
{
|
|
blocks.emplace_back(op, buffer.size());
|
|
return blocks.back();
|
|
}
|
|
|
|
data_block &block_end()
|
|
{
|
|
blocks.back().is_completed = true;
|
|
return blocks.back();
|
|
}
|
|
|
|
void block_remove()
|
|
{
|
|
if (blocks.empty())
|
|
return;
|
|
|
|
buffer.resize(blocks.back().offset);
|
|
blocks.pop_back();
|
|
}
|
|
|
|
void write(const void *ptr, size_t length)
|
|
{
|
|
if (!length)
|
|
return;
|
|
|
|
buffer.resize(buffer.size() + length);
|
|
memcpy(buffer.data() + buffer.size() - length, reinterpret_cast<const char *>(ptr), length);
|
|
blocks.back().length += length;
|
|
}
|
|
|
|
size_t read(void *ptr, size_t length)
|
|
{
|
|
if (!ptr || blocks.empty() || !blocks.front().is_completed)
|
|
return 0;
|
|
|
|
data_block &db = blocks.front();
|
|
size_t result = db.length >= length ? length : db.length;
|
|
|
|
if (result)
|
|
{
|
|
memcpy(ptr, buffer.data() + db.offset, result);
|
|
buffer.erase(buffer.begin(), buffer.begin() + result);
|
|
}
|
|
|
|
if (!(db.length -= result))
|
|
blocks.erase(blocks.begin());
|
|
else
|
|
blocks.front().op = opcode::continuation;
|
|
|
|
if (result) for (auto &block : blocks) if (block.offset > db.offset)
|
|
block.offset -= result;
|
|
|
|
return result;
|
|
}
|
|
|
|
size_t peek(opcode *op = nullptr) const
|
|
{
|
|
if (blocks.empty() || !blocks.front().is_completed)
|
|
return 0;
|
|
|
|
if (op)
|
|
*op = blocks.front().op;
|
|
|
|
return blocks.front().length;
|
|
}
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool handshake_websocket(connection &conn)
|
|
{
|
|
std::string line, key;
|
|
|
|
while (conn.read_line(line))
|
|
{
|
|
if (line.empty())
|
|
break;
|
|
|
|
if (!memcmp(line.c_str(), "Sec-WebSocket-Key: ", 19))
|
|
key = line.substr(19);
|
|
}
|
|
|
|
if (key.empty())
|
|
return false;
|
|
|
|
key += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
|
|
|
|
detail::sha1 sha;
|
|
detail::sha1::digest8_t digest;
|
|
sha.process_bytes(key.c_str(), key.length());
|
|
|
|
std::string response = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ";
|
|
response += detail::utils::base64_encode(sha.get_digest_bytes(digest), 20);
|
|
response += "\r\n\r\n";
|
|
|
|
return conn.force_write(response.c_str(), response.length());
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef HEADSOCKET_PLATFORM_WINDOWS
|
|
void set_thread_name(const char *name)
|
|
{
|
|
}
|
|
#else
|
|
void set_thread_name(const char *name)
|
|
{
|
|
|
|
}
|
|
#endif
|
|
|
|
} // namespace detail;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace detail {
|
|
|
|
struct connection_impl
|
|
{
|
|
detail::socket_type socket = detail::invalid_socket;
|
|
sockaddr_in from;
|
|
size_t id = 0;
|
|
|
|
void assign(const connection_impl &impl)
|
|
{
|
|
socket = impl.socket;
|
|
from = impl.from;
|
|
id = impl.id;
|
|
}
|
|
|
|
void close()
|
|
{
|
|
if (socket != detail::invalid_socket)
|
|
{
|
|
detail::close_socket(socket);
|
|
socket = detail::invalid_socket;
|
|
}
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
connection::connection(const detail::connection_impl &impl)
|
|
: _p(std::make_unique<detail::connection_impl>())
|
|
{
|
|
_p->assign(impl);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
connection::~connection()
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool connection::is_valid() const { return _p->socket != detail::invalid_socket; }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t connection::id() const { return _p->id; }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t connection::write(const void *ptr, size_t length)
|
|
{
|
|
if (!is_valid())
|
|
return detail::socket_error;
|
|
|
|
if (!ptr || !length)
|
|
return 0;
|
|
|
|
int result = send(_p->socket, static_cast<const char *>(ptr), static_cast<int>(length), 0);
|
|
|
|
if (!result || result == detail::socket_error)
|
|
return 0;
|
|
|
|
return static_cast<size_t>(result);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool connection::force_write(const void *ptr, size_t length)
|
|
{
|
|
if (!is_valid())
|
|
return false;
|
|
|
|
if (!ptr)
|
|
return true;
|
|
|
|
const char *chPtr = static_cast<const char *>(ptr);
|
|
|
|
while (length)
|
|
{
|
|
int result = send(_p->socket, chPtr, static_cast<int>(length), 0);
|
|
|
|
if (!result || result == detail::socket_error)
|
|
return false;
|
|
|
|
length -= static_cast<size_t>(result);
|
|
chPtr += result;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t connection::read(void *ptr, size_t length)
|
|
{
|
|
if (!is_valid())
|
|
return detail::socket_error;
|
|
|
|
if (!ptr || !length)
|
|
return 0;
|
|
|
|
int result = recv(_p->socket, static_cast<char *>(ptr), static_cast<int>(length), 0);
|
|
|
|
if (!result || result == detail::socket_error)
|
|
return 0;
|
|
|
|
return static_cast<size_t>(result);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool connection::force_read(void *ptr, size_t length)
|
|
{
|
|
if (!is_valid())
|
|
return false;
|
|
|
|
if (!ptr)
|
|
return true;
|
|
|
|
char *chPtr = static_cast<char *>(ptr);
|
|
|
|
while (length)
|
|
{
|
|
int result = recv(_p->socket, chPtr, static_cast<int>(length), 0);
|
|
|
|
if (!result || result == detail::socket_error)
|
|
return false;
|
|
|
|
length -= static_cast<size_t>(result);
|
|
chPtr += result;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool connection::read_line(std::string &output)
|
|
{
|
|
if (!is_valid())
|
|
return false;
|
|
|
|
output = "";
|
|
|
|
while (true)
|
|
{
|
|
char ch;
|
|
int r = recv(_p->socket, &ch, 1, 0);
|
|
|
|
if (!r || r == detail::socket_error)
|
|
return false;
|
|
|
|
if (ch == '\n')
|
|
break;
|
|
else if (ch != '\r')
|
|
output += ch;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace detail {
|
|
|
|
struct basic_tcp_client_ref
|
|
{
|
|
size_t refCount = 0;
|
|
ptr<basic_tcp_client> client;
|
|
|
|
basic_tcp_client_ref(ptr<basic_tcp_client> c)
|
|
: client(c)
|
|
{
|
|
|
|
}
|
|
};
|
|
|
|
struct basic_tcp_server_impl
|
|
{
|
|
std::atomic_bool isRunning;
|
|
std::atomic_bool disconnectThreadQuit;
|
|
sockaddr_in local;
|
|
detail::lockable_value<std::vector<basic_tcp_client_ref>> connections;
|
|
detail::semaphore disconnectSemaphore;
|
|
int port = 0;
|
|
detail::socket_type serverSocket = invalid_socket;
|
|
std::unique_ptr<std::thread> acceptThread;
|
|
std::unique_ptr<std::thread> disconnectThread;
|
|
id_t nextClientID = 1;
|
|
|
|
basic_tcp_server_impl()
|
|
{
|
|
isRunning = false;
|
|
disconnectThreadQuit = false;
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
basic_tcp_server::basic_tcp_server(int port)
|
|
: _p(std::make_unique<detail::basic_tcp_server_impl>())
|
|
{
|
|
#ifdef HEADSOCKET_PLATFORM_WINDOWS
|
|
WSADATA wsaData;
|
|
WSAStartup(0x101, &wsaData);
|
|
#endif
|
|
|
|
_p->local.sin_family = AF_INET;
|
|
_p->local.sin_addr.s_addr = INADDR_ANY;
|
|
_p->local.sin_port = htons(static_cast<unsigned short>(port));
|
|
|
|
_p->serverSocket = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
|
int opt_enable = 1;
|
|
setsockopt(_p->serverSocket, SOL_SOCKET, SO_REUSEADDR, (const char*) &opt_enable, sizeof(int));
|
|
|
|
if (bind(_p->serverSocket, reinterpret_cast<sockaddr *>(&_p->local), sizeof(_p->local)) != 0)
|
|
return;
|
|
|
|
if (listen(_p->serverSocket, 8))
|
|
return;
|
|
|
|
_p->isRunning = true;
|
|
_p->port = port;
|
|
_p->acceptThread = std::make_unique<std::thread>(std::bind(&basic_tcp_server::accept_thread, this));
|
|
_p->disconnectThread = std::make_unique<std::thread>(std::bind(&basic_tcp_server::disconnect_thread, this));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
basic_tcp_server::~basic_tcp_server()
|
|
{
|
|
stop();
|
|
|
|
#ifdef HEADSOCKET_PLATFORM_WINDOWS
|
|
WSACleanup();
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
int basic_tcp_server::port() const { return _p->port; }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void basic_tcp_server::stop()
|
|
{
|
|
if (_p->isRunning.exchange(false))
|
|
{
|
|
detail::close_socket(_p->serverSocket);
|
|
|
|
{
|
|
acquire_clients();
|
|
|
|
for (size_t i = 0, S = num_clients(); i < S; ++i)
|
|
client_at(i)->disconnect();
|
|
|
|
release_clients();
|
|
}
|
|
|
|
if (_p->acceptThread)
|
|
{
|
|
_p->acceptThread->join();
|
|
_p->acceptThread = nullptr;
|
|
}
|
|
|
|
if (_p->disconnectThread)
|
|
{
|
|
_p->disconnectThreadQuit = true;
|
|
_p->disconnectSemaphore.notify();
|
|
|
|
_p->disconnectThread->join();
|
|
_p->disconnectThread = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool basic_tcp_server::is_running() const { return _p->isRunning; }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool basic_tcp_server::disconnect(ptr<basic_tcp_client> client)
|
|
{
|
|
bool found = false;
|
|
|
|
if (client)
|
|
{
|
|
{
|
|
HEADSOCKET_LOCK(_p->connections);
|
|
for (size_t i = 0, S = _p->connections->size(); i < S; ++i)
|
|
if (_p->connections->at(i).client == client)
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found && !client->disconnect())
|
|
{
|
|
client_disconnected(client);
|
|
_p->disconnectSemaphore.notify();
|
|
}
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool basic_tcp_server::disconnect(id_t id)
|
|
{
|
|
bool found = false;
|
|
|
|
if (id)
|
|
{
|
|
ptr<basic_tcp_client> client;
|
|
|
|
{
|
|
HEADSOCKET_LOCK(_p->connections);
|
|
for (size_t i = 0, S = _p->connections->size(); i < S; ++i)
|
|
if (_p->connections->at(i).client->id() == id)
|
|
{
|
|
client = _p->connections->at(i).client;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found && !client->disconnect())
|
|
{
|
|
client_disconnected(client);
|
|
_p->disconnectSemaphore.notify();
|
|
}
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
ptr<basic_tcp_client> basic_tcp_server::client_at(size_t index) const
|
|
{
|
|
HEADSOCKET_LOCK(_p->connections);
|
|
return index < _p->connections->size() ? _p->connections->at(index).client : nullptr;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t basic_tcp_server::num_clients() const
|
|
{
|
|
HEADSOCKET_LOCK(_p->connections);
|
|
return _p->connections->size();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t basic_tcp_server::acquire_clients() const
|
|
{
|
|
HEADSOCKET_LOCK(_p->connections);
|
|
|
|
for (auto &clientRef : _p->connections.value)
|
|
++clientRef.refCount;
|
|
|
|
return _p->connections->size();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void basic_tcp_server::release_clients() const
|
|
{
|
|
HEADSOCKET_LOCK(_p->connections);
|
|
|
|
for (auto &clientRef : _p->connections.value)
|
|
--clientRef.refCount;
|
|
|
|
remove_disconnected();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void basic_tcp_server::remove_disconnected() const
|
|
{
|
|
size_t i = 0;
|
|
|
|
while (i < _p->connections->size())
|
|
{
|
|
auto &clientRef = _p->connections.value[i];
|
|
|
|
if (!clientRef.client->is_connected() && clientRef.refCount == 0)
|
|
{
|
|
clientRef.client->on_disconnect();
|
|
_p->connections->erase(_p->connections->begin() + i);
|
|
}
|
|
else
|
|
++i;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void basic_tcp_server::accept_thread()
|
|
{
|
|
detail::set_thread_name("BaseTcpServer::acceptThread");
|
|
|
|
while (_p->isRunning)
|
|
{
|
|
detail::connection_impl conn_impl;
|
|
conn_impl.socket = ::accept(_p->serverSocket, reinterpret_cast<struct sockaddr *>(&conn_impl.from), nullptr);
|
|
conn_impl.id = _p->nextClientID++;
|
|
|
|
if (!_p->nextClientID)
|
|
++_p->nextClientID;
|
|
|
|
if (!_p->isRunning)
|
|
break;
|
|
|
|
if (conn_impl.socket != detail::invalid_socket)
|
|
{
|
|
connection conn(conn_impl);
|
|
|
|
ptr<basic_tcp_client> newClient;
|
|
bool failed = false;
|
|
|
|
if (handshake(conn))
|
|
{
|
|
if ((newClient = accept(conn)))
|
|
{
|
|
newClient->on_accept();
|
|
|
|
HEADSOCKET_LOCK(_p->connections);
|
|
_p->connections->push_back(newClient);
|
|
}
|
|
else {
|
|
failed = true;
|
|
}
|
|
}
|
|
else {
|
|
failed = true;
|
|
}
|
|
|
|
if (failed)
|
|
{
|
|
conn_impl.close();
|
|
--_p->nextClientID;
|
|
|
|
if (!_p->nextClientID)
|
|
--_p->nextClientID;
|
|
}
|
|
else
|
|
client_connected(newClient);
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void basic_tcp_server::disconnect_thread()
|
|
{
|
|
detail::set_thread_name("BaseTcpServer::disconnectThread");
|
|
|
|
while (!_p->disconnectThreadQuit)
|
|
{
|
|
{
|
|
HEADSOCKET_LOCK(_p->disconnectSemaphore);
|
|
HEADSOCKET_LOCK(_p->connections);
|
|
|
|
remove_disconnected();
|
|
_p->disconnectSemaphore.consume();
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace detail {
|
|
|
|
struct basic_tcp_client_impl
|
|
{
|
|
std::atomic_int refCount;
|
|
std::atomic_bool isConnected;
|
|
std::weak_ptr<basic_tcp_server> server;
|
|
connection conn = detail::connection_impl();
|
|
std::string address = "";
|
|
int port = 0;
|
|
|
|
basic_tcp_client_impl()
|
|
{
|
|
refCount = 0;
|
|
isConnected = false;
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
basic_tcp_client::basic_tcp_client(const std::string &address, int port)
|
|
: _p(std::make_unique<detail::basic_tcp_client_impl>())
|
|
{
|
|
struct addrinfo *result = nullptr, *ptr = nullptr, hints;
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
hints.ai_family = AF_UNSPEC;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
hints.ai_protocol = IPPROTO_TCP;
|
|
|
|
char buff[16];
|
|
HEADSOCKET_SPRINTF(buff, "%d", port);
|
|
|
|
if (getaddrinfo(address.c_str(), buff, &hints, &result))
|
|
return;
|
|
|
|
for (ptr = result; ptr != nullptr; ptr = ptr->ai_next)
|
|
{
|
|
_p->conn.impl()->socket = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
|
|
|
|
if (!_p->conn.is_valid())
|
|
return;
|
|
|
|
if (connect(_p->conn.impl()->socket, ptr->ai_addr, static_cast<int>(ptr->ai_addrlen)) == detail::socket_error)
|
|
{
|
|
detail::close_socket(_p->conn.impl()->socket);
|
|
_p->conn.impl()->socket = detail::invalid_socket;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
freeaddrinfo(result);
|
|
|
|
if (!_p->conn.is_valid())
|
|
return;
|
|
|
|
_p->address = address;
|
|
_p->port = port;
|
|
_p->isConnected = true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
basic_tcp_client::basic_tcp_client(ptr<basic_tcp_server> server, connection &conn)
|
|
: _p(std::make_unique<detail::basic_tcp_client_impl>())
|
|
{
|
|
_p->server = server;
|
|
_p->conn.impl()->assign(*(conn.impl()));
|
|
_p->isConnected = true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
basic_tcp_client::~basic_tcp_client()
|
|
{
|
|
disconnect();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool basic_tcp_client::disconnect()
|
|
{
|
|
bool wasConnected = _p->isConnected.exchange(false);
|
|
|
|
if (wasConnected)
|
|
{
|
|
_p->conn.impl()->close();
|
|
|
|
ptr<basic_tcp_server> s = server();
|
|
|
|
if (s)
|
|
s->disconnect(_p->conn.id());
|
|
}
|
|
|
|
return wasConnected;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool basic_tcp_client::is_connected() const { return _p->isConnected; }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
ptr<basic_tcp_server> basic_tcp_client::server() const { return _p->server.lock(); }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
id_t basic_tcp_client::id() const { return _p->conn.id(); }
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
tcp_client::tcp_client(const std::string &address, int port)
|
|
: base_t(address, port)
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
tcp_client::tcp_client(ptr<basic_tcp_server> server, connection &conn)
|
|
: base_t(server, conn)
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
tcp_client::~tcp_client()
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t tcp_client::write(const void *ptr, size_t length) { return _p->conn.write(ptr, length); }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t tcp_client::read(void *ptr, size_t length) { return _p->conn.read(ptr, length); }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool tcp_client::force_write(const void *ptr, size_t length) { return _p->conn.force_write(ptr, length); }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool tcp_client::force_read(void *ptr, size_t length) { return _p->conn.force_read(ptr, length); }
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool tcp_client::read_line(std::string &output) { return _p->conn.read_line(output); }
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace detail {
|
|
|
|
struct async_tcp_client_impl
|
|
{
|
|
detail::semaphore writeSemaphore;
|
|
detail::lockable_value<detail::data_block_buffer> writeBlocks;
|
|
detail::lockable_value<detail::data_block_buffer> readBlocks;
|
|
std::unique_ptr<std::thread> writeThread;
|
|
std::unique_ptr<std::thread> readThread;
|
|
std::atomic_int threadCounter = { 0 };
|
|
};
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
async_tcp_client::async_tcp_client(const std::string &address, int port)
|
|
: base_t(address, port)
|
|
, _ap(std::make_unique<detail::async_tcp_client_impl>())
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
async_tcp_client::async_tcp_client(ptr<basic_tcp_server> server, connection &conn)
|
|
: base_t(server, conn)
|
|
, _ap(new detail::async_tcp_client_impl())
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
async_tcp_client::~async_tcp_client()
|
|
{
|
|
disconnect();
|
|
|
|
_ap->writeSemaphore.notify();
|
|
_ap->writeThread->join();
|
|
_ap->readThread->join();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void async_tcp_client::push(const void *ptr, size_t length, opcode opcode)
|
|
{
|
|
if (!ptr)
|
|
return;
|
|
|
|
{
|
|
HEADSOCKET_LOCK(_ap->writeBlocks);
|
|
_ap->writeBlocks->block_begin(opcode);
|
|
_ap->writeBlocks->write(ptr, length);
|
|
_ap->writeBlocks->block_end();
|
|
}
|
|
|
|
_ap->writeSemaphore.notify();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void async_tcp_client::push(const void *ptr, size_t length)
|
|
{
|
|
push(ptr, length, opcode::binary);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void async_tcp_client::push(const std::string &text)
|
|
{
|
|
push(text.c_str(), text.length(), opcode::text);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t async_tcp_client::peek() const
|
|
{
|
|
HEADSOCKET_LOCK(_ap->readBlocks);
|
|
return _ap->readBlocks->peek(nullptr);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t async_tcp_client::pop(void *ptr, size_t length)
|
|
{
|
|
if (!ptr)
|
|
return invalid_operation;
|
|
|
|
if (!length)
|
|
return 0;
|
|
|
|
HEADSOCKET_LOCK(_ap->readBlocks);
|
|
return _ap->readBlocks->read(ptr, length);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void async_tcp_client::init_threads()
|
|
{
|
|
_ap->threadCounter = 0;
|
|
_ap->writeThread = std::make_unique<std::thread>(std::bind(&async_tcp_client::write_thread, this));
|
|
_ap->readThread = std::make_unique<std::thread>(std::bind(&async_tcp_client::read_thread, this));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void async_tcp_client::write_thread()
|
|
{
|
|
++_ap->threadCounter;
|
|
detail::set_thread_name("AsyncTcpClient::writeThread");
|
|
|
|
std::vector<uint8_t> buffer(1024 * 1024);
|
|
|
|
while (_p->isConnected)
|
|
{
|
|
size_t written = 0;
|
|
{
|
|
HEADSOCKET_LOCK(_ap->writeSemaphore);
|
|
|
|
if (!_p->isConnected)
|
|
break;
|
|
|
|
written = async_write_handler(buffer.data(), buffer.size());
|
|
}
|
|
|
|
if (written == invalid_operation)
|
|
break;
|
|
|
|
if (!written)
|
|
buffer.resize(buffer.size() * 2);
|
|
else
|
|
{
|
|
const char *cursor = reinterpret_cast<const char *>(buffer.data());
|
|
|
|
while (written)
|
|
{
|
|
int result = send(_p->conn.impl()->socket, cursor, static_cast<int>(written), 0);
|
|
|
|
if (!result || result == detail::socket_error)
|
|
break;
|
|
|
|
cursor += result;
|
|
written -= static_cast<size_t>(result);
|
|
}
|
|
}
|
|
}
|
|
|
|
kill_threads();
|
|
--_ap->threadCounter;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t async_tcp_client::async_write_handler(uint8_t *ptr, size_t length)
|
|
{
|
|
HEADSOCKET_LOCK(_ap->writeBlocks);
|
|
|
|
size_t toWrite = _ap->writeBlocks->peek(nullptr);
|
|
size_t toConsume = length > toWrite ? toWrite : length;
|
|
_ap->writeBlocks->read(ptr, toConsume);
|
|
|
|
if (toWrite == toConsume)
|
|
_ap->writeSemaphore.consume();
|
|
|
|
return toConsume;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t async_tcp_client::async_read_handler(uint8_t *ptr, size_t length)
|
|
{
|
|
HEADSOCKET_LOCK(_ap->readBlocks);
|
|
|
|
_ap->readBlocks->block_begin(opcode::binary);
|
|
_ap->readBlocks->write(ptr, length);
|
|
_ap->readBlocks->block_end();
|
|
|
|
return length;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void async_tcp_client::read_thread()
|
|
{
|
|
++_ap->threadCounter;
|
|
detail::set_thread_name("AsyncTcpClient::readThread");
|
|
|
|
std::vector<uint8_t> buffer(1024 * 1024);
|
|
size_t bufferBytes = 0, consumed = 0;
|
|
|
|
while (_p->isConnected)
|
|
{
|
|
while (true)
|
|
{
|
|
int result = static_cast<int>(bufferBytes);
|
|
|
|
if (!result || !consumed)
|
|
{
|
|
result = recv(
|
|
_p->conn.impl()->socket,
|
|
reinterpret_cast<char *>(buffer.data() + bufferBytes),
|
|
static_cast<int>(buffer.size() - bufferBytes),
|
|
0);
|
|
|
|
if (!result || result == detail::socket_error)
|
|
{
|
|
consumed = invalid_operation;
|
|
break;
|
|
}
|
|
|
|
bufferBytes += static_cast<size_t>(result);
|
|
}
|
|
|
|
consumed = async_read_handler(buffer.data(), bufferBytes);
|
|
|
|
if (!consumed)
|
|
{
|
|
if (bufferBytes == buffer.size())
|
|
buffer.resize(buffer.size() * 2);
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (consumed == invalid_operation)
|
|
break;
|
|
|
|
bufferBytes -= consumed;
|
|
|
|
if (bufferBytes)
|
|
memcpy(buffer.data(), buffer.data() + consumed, bufferBytes);
|
|
}
|
|
|
|
kill_threads();
|
|
--_ap->threadCounter;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void async_tcp_client::kill_threads()
|
|
{
|
|
if (std::this_thread::get_id() == _ap->readThread->get_id())
|
|
_ap->writeSemaphore.notify();
|
|
|
|
disconnect();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
web_socket_client::web_socket_client(const std::string &address, int port)
|
|
: base_t(address, port)
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
web_socket_client::web_socket_client(ptr<basic_tcp_server> server, connection &conn)
|
|
: base_t(server, conn)
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
web_socket_client::~web_socket_client()
|
|
{
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t web_socket_client::peek(opcode *op) const
|
|
{
|
|
HEADSOCKET_LOCK(_ap->readBlocks);
|
|
return _ap->readBlocks->peek(op);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t web_socket_client::async_write_handler(uint8_t *ptr, size_t length)
|
|
{
|
|
uint8_t *cursor = ptr;
|
|
HEADSOCKET_LOCK(_ap->writeBlocks);
|
|
|
|
while (length >= 16)
|
|
{
|
|
opcode op{};
|
|
size_t toWrite = _ap->writeBlocks->peek(&op);
|
|
size_t toConsume = (length - 15) > frame_size_limit ? frame_size_limit : (length - 15);
|
|
toConsume = toConsume > toWrite ? toWrite : toConsume;
|
|
|
|
frame_header header;
|
|
header.fin = (toWrite - toConsume) == 0;
|
|
header.op = op;
|
|
header.masked = false;
|
|
header.payload_length = toConsume;
|
|
|
|
size_t headerSize = header.write(cursor, length);
|
|
cursor += headerSize;
|
|
length -= headerSize;
|
|
_ap->writeBlocks->read(cursor, toConsume);
|
|
cursor += toConsume;
|
|
length -= toConsume;
|
|
|
|
if (header.fin)
|
|
_ap->writeSemaphore.consume();
|
|
|
|
if (!_ap->writeBlocks->peek(&op))
|
|
break;
|
|
}
|
|
|
|
return cursor - ptr;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t web_socket_client::async_read_handler(uint8_t *ptr, size_t length)
|
|
{
|
|
uint8_t *cursor = ptr;
|
|
HEADSOCKET_LOCK(_ap->readBlocks);
|
|
|
|
if (!_payload_size)
|
|
{
|
|
opcode prevOpcode = _current_header.op;
|
|
size_t headerSize = _current_header.read(cursor, length);
|
|
|
|
if (!headerSize)
|
|
return 0;
|
|
else if (headerSize == invalid_operation)
|
|
return invalid_operation;
|
|
|
|
_payload_size = _current_header.payload_length;
|
|
cursor += headerSize;
|
|
length -= headerSize;
|
|
|
|
if (_current_header.op != opcode::continuation)
|
|
_ap->readBlocks->block_begin(_current_header.op);
|
|
else
|
|
_current_header.op = prevOpcode;
|
|
}
|
|
|
|
if (_payload_size)
|
|
{
|
|
size_t toConsume = length >= _payload_size ? _payload_size : length;
|
|
|
|
if (toConsume)
|
|
{
|
|
_ap->readBlocks->write(cursor, toConsume);
|
|
_payload_size -= toConsume;
|
|
cursor += toConsume;
|
|
length -= toConsume;
|
|
}
|
|
}
|
|
|
|
if (!_payload_size)
|
|
{
|
|
if (_current_header.masked)
|
|
{
|
|
//data_block &db = _ap->readBlocks->blocks.back();
|
|
size_t len = _current_header.payload_length;
|
|
detail::utils::xor32(_current_header.masking_key, _ap->readBlocks->buffer.data() + _ap->readBlocks->buffer.size() - len, len);
|
|
}
|
|
|
|
if (_current_header.fin)
|
|
{
|
|
data_block &db = _ap->readBlocks->blocks.back();
|
|
|
|
switch (_current_header.op)
|
|
{
|
|
case opcode::ping:
|
|
push(_ap->readBlocks->buffer.data() + db.offset, db.length, opcode::pong);
|
|
break;
|
|
|
|
case opcode::text:
|
|
_ap->readBlocks->buffer.push_back(0);
|
|
++db.length;
|
|
break;
|
|
|
|
case opcode::connection_close:
|
|
kill_threads();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (_current_header.op == opcode::text || _current_header.op == opcode::binary)
|
|
{
|
|
_ap->readBlocks->block_end();
|
|
if (async_received_data(db, _ap->readBlocks->buffer.data() + db.offset, db.length))
|
|
_ap->readBlocks->block_remove();
|
|
}
|
|
}
|
|
}
|
|
|
|
return cursor - ptr;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
#define HAVE_ENOUGH_BYTES(num) if (length < num) return 0; else length -= num;
|
|
size_t web_socket_client::frame_header::read(const uint8_t *ptr, size_t length)
|
|
{
|
|
const uint8_t *cursor = ptr;
|
|
HAVE_ENOUGH_BYTES(2);
|
|
this->fin = ((*cursor) & 0x80) != 0;
|
|
this->op = static_cast<opcode>((*cursor++) & 0x0F);
|
|
|
|
this->masked = ((*cursor) & 0x80) != 0;
|
|
uint8_t byte = (*cursor++) & 0x7F;
|
|
|
|
if (byte < 126)
|
|
this->payload_length = byte;
|
|
else if (byte == 126)
|
|
{
|
|
HAVE_ENOUGH_BYTES(2);
|
|
this->payload_length = detail::utils::swap16bits(*(reinterpret_cast<const uint16_t *>(cursor)));
|
|
cursor += 2;
|
|
}
|
|
else if (byte == 127)
|
|
{
|
|
HAVE_ENOUGH_BYTES(8);
|
|
uint64_t length64 = detail::utils::swap64bits(*(reinterpret_cast<const uint64_t *>(cursor))) & 0x7FFFFFFFFFFFFFFFULL;
|
|
this->payload_length = static_cast<size_t>(length64);
|
|
cursor += 8;
|
|
}
|
|
|
|
if (this->masked)
|
|
{
|
|
HAVE_ENOUGH_BYTES(4);
|
|
this->masking_key = *(reinterpret_cast<const uint32_t *>(cursor));
|
|
cursor += 4;
|
|
}
|
|
|
|
return cursor - ptr;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
size_t web_socket_client::frame_header::write(uint8_t *ptr, size_t length) const
|
|
{
|
|
uint8_t *cursor = ptr;
|
|
HAVE_ENOUGH_BYTES(2);
|
|
*cursor = this->fin ? 0x80 : 0x00;
|
|
*cursor++ |= static_cast<uint8_t>(this->op);
|
|
|
|
*cursor = this->masked ? 0x80 : 0x00;
|
|
|
|
if (this->payload_length < 126)
|
|
*cursor++ |= static_cast<uint8_t>(this->payload_length);
|
|
else if (this->payload_length < 65536)
|
|
{
|
|
HAVE_ENOUGH_BYTES(2);
|
|
*cursor++ |= 126;
|
|
*reinterpret_cast<uint16_t *>(cursor) = detail::utils::swap16bits(static_cast<uint16_t>(this->payload_length));
|
|
cursor += 2;
|
|
}
|
|
else
|
|
{
|
|
HAVE_ENOUGH_BYTES(8);
|
|
*cursor++ |= 127;
|
|
*reinterpret_cast<uint64_t *>(cursor) = detail::utils::swap64bits(static_cast<uint64_t>(this->payload_length));
|
|
cursor += 8;
|
|
}
|
|
|
|
if (this->masked)
|
|
{
|
|
HAVE_ENOUGH_BYTES(4);
|
|
*reinterpret_cast<uint32_t *>(cursor) = this->masking_key;
|
|
cursor += 4;
|
|
}
|
|
|
|
return cursor - ptr;
|
|
}
|
|
#undef HAVE_ENOUGH_BYTES
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace detail {
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
bool http_server::handshake(connection &conn)
|
|
{
|
|
std::string requestLine;
|
|
|
|
if (!conn.read_line(requestLine))
|
|
return false;
|
|
|
|
std::string headerLine;
|
|
while (conn.read_line(headerLine))
|
|
{
|
|
if (headerLine.empty())
|
|
break;
|
|
}
|
|
|
|
std::string method = detail::utils::cut_front(requestLine);
|
|
std::string path = detail::utils::url_decode(detail::utils::cut_front(requestLine));
|
|
|
|
if (!path.empty() && path.front() == '/') path = path.substr(1);
|
|
if (!path.empty() && path.back() == '/') path = path.substr(0, path.length() - 1);
|
|
|
|
std::string params_get = detail::utils::cut_back(path, '?', false, false);
|
|
std::string version = detail::utils::cut_front(requestLine);
|
|
|
|
parameters_t params;
|
|
std::string param_str;
|
|
while (!(param_str = detail::utils::cut_front(params_get, '&')).empty())
|
|
{
|
|
parameter param;
|
|
param.name = detail::utils::cut_front(param_str, '=');
|
|
param.value = param_str;
|
|
param.integer = atoi(param_str.c_str());
|
|
param.real = atof(param_str.c_str());
|
|
param.boolean = (param.integer != 0) || (param_str == "true");
|
|
|
|
params[param.name] = param;
|
|
}
|
|
|
|
response resp;
|
|
if (path != "favicon.ico" && request(path, params, resp))
|
|
{
|
|
std::stringstream ss;
|
|
ss << version << " 200 OK\r\n";
|
|
ss << "Content-Type: " << resp.content_type << "\r\n";
|
|
ss << "Content-Length: " << resp.message.length() << "\r\n\r\n";
|
|
ss << resp.message;
|
|
|
|
conn.write(ss.str());
|
|
}
|
|
else
|
|
{
|
|
conn.write(version);
|
|
conn.write(" 404 Not Found\r\n");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
}
|
|
#endif
|
|
#endif
|