276 lines
8 KiB
C++
276 lines
8 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <atomic>
|
|
#include <cerrno>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <mutex>
|
|
#include <thread>
|
|
#include <assert.h>
|
|
|
|
#include <Poco/MemoryStream.h>
|
|
#include <Poco/Net/SocketAddress.h>
|
|
#include <Poco/Util/ServerApplication.h>
|
|
#include <Poco/StringTokenizer.h>
|
|
#include <Poco/Runnable.h>
|
|
#include <Poco/Thread.h>
|
|
|
|
#include "Socket.hpp"
|
|
#include "ServerSocket.hpp"
|
|
#if ENABLE_SSL
|
|
#include "SslSocket.hpp"
|
|
#endif
|
|
#include "WebSocketHandler.hpp"
|
|
|
|
using Poco::MemoryInputStream;
|
|
using Poco::StringTokenizer;
|
|
|
|
constexpr int HttpPortNumber = 9191;
|
|
constexpr int SslPortNumber = 9193;
|
|
|
|
class SimpleResponseClient : public WebSocketHandler
|
|
{
|
|
public:
|
|
SimpleResponseClient() : WebSocketHandler()
|
|
{
|
|
}
|
|
|
|
virtual void handleIncomingMessage() override
|
|
{
|
|
LOG_TRC("incoming WebSocket message");
|
|
if (_wsState == WSState::HTTP)
|
|
{
|
|
auto socket = _socket.lock();
|
|
|
|
int number = 0;
|
|
Poco::MemoryInputStream message(&socket->_inBuffer[0], socket->_inBuffer.size());
|
|
Poco::Net::HTTPRequest req;
|
|
req.read(message);
|
|
|
|
// if we succeeded - remove that from our input buffer
|
|
// FIXME: We should check if this is GET or POST. For GET, we only
|
|
// can have a single request (headers only). For POST, we can/should
|
|
// use Poco HTMLForm to parse the post message properly.
|
|
// Otherwise, we should catch exceptions from the previous read/parse
|
|
// and assume we don't have sufficient data, so we wait some more.
|
|
socket->_inBuffer.clear();
|
|
|
|
LOG_DBG("URI: " << req.getURI());
|
|
|
|
Poco::StringTokenizer tokens(req.getURI(), "/?");
|
|
if (tokens.count() == 4)
|
|
{
|
|
std::string subpool = tokens[2];
|
|
number = std::stoi(tokens[3]);
|
|
|
|
// complex algorithmic core:
|
|
number = number + 1;
|
|
|
|
std::string numberString = std::to_string(number);
|
|
std::ostringstream oss;
|
|
oss << "HTTP/1.1 200 OK\r\n"
|
|
<< "Date: Once, Upon a time GMT\r\n" // Mon, 27 Jul 2009 12:28:53 GMT
|
|
<< "Server: madeup string (Linux)\r\n"
|
|
<< "Content-Length: " << numberString.size() << "\r\n"
|
|
<< "Content-Type: text/plain\r\n"
|
|
<< "Connection: Closed\r\n"
|
|
<< "\r\n"
|
|
<< numberString;
|
|
;
|
|
std::string str = oss.str();
|
|
socket->_outBuffer.insert(socket->_outBuffer.end(), str.begin(), str.end());
|
|
return;
|
|
}
|
|
else if (tokens.count() == 2 && tokens[1] == "ws")
|
|
{
|
|
|
|
upgradeToWebSocket(req);
|
|
return;
|
|
}
|
|
}
|
|
|
|
WebSocketHandler::handleIncomingMessage();
|
|
}
|
|
|
|
virtual void handleMessage(const bool fin, const WSOpCode code, std::vector<char> &data) override
|
|
{
|
|
std::cerr << "Message: fin? " << fin << " code " << code << " data size " << data.size();
|
|
if (code == WSOpCode::Text)
|
|
{
|
|
std::string text(data.begin(), data.end());
|
|
std::cerr << " text is '" << text << "'\n";
|
|
|
|
return;
|
|
}
|
|
else
|
|
std::cerr << " binary\n";
|
|
|
|
std::vector<char> reply;
|
|
if (data.size() == sizeof(size_t))
|
|
{
|
|
// ping pong test
|
|
assert (data.size() >= sizeof(size_t));
|
|
size_t *countPtr = reinterpret_cast<size_t *>(&data[0]);
|
|
size_t count = *countPtr;
|
|
count++;
|
|
std::cerr << "count is " << count << "\n";
|
|
reply.insert(reply.end(), reinterpret_cast<char *>(&count),
|
|
reinterpret_cast<char *>(&count) + sizeof(count));
|
|
}
|
|
else
|
|
{
|
|
// echo tests
|
|
reply.insert(reply.end(), data.begin(), data.end());
|
|
}
|
|
|
|
sendMessage(reply.data(), reply.size(), code);
|
|
}
|
|
};
|
|
|
|
// FIXME: use Poco Thread instead (?)
|
|
|
|
/// Generic thread class.
|
|
class Thread
|
|
{
|
|
public:
|
|
Thread(const std::function<void(std::atomic<bool>&)>& cb) :
|
|
_cb(cb),
|
|
_stop(false)
|
|
{
|
|
_thread = std::thread([this]() { _cb(_stop); });
|
|
}
|
|
|
|
Thread(Thread&& other) = delete;
|
|
const Thread& operator=(Thread&& other) = delete;
|
|
|
|
~Thread()
|
|
{
|
|
stop();
|
|
if (_thread.joinable())
|
|
{
|
|
_thread.join();
|
|
}
|
|
}
|
|
|
|
void stop()
|
|
{
|
|
_stop = true;
|
|
}
|
|
|
|
private:
|
|
const std::function<void(std::atomic<bool>&)> _cb;
|
|
std::atomic<bool> _stop;
|
|
std::thread _thread;
|
|
};
|
|
|
|
Poco::Net::SocketAddress addrHttp("127.0.0.1", HttpPortNumber);
|
|
Poco::Net::SocketAddress addrSsl("127.0.0.1", SslPortNumber);
|
|
|
|
void server(const Poco::Net::SocketAddress& addr, SocketPoll& clientPoller,
|
|
std::unique_ptr<SocketFactory> sockFactory)
|
|
{
|
|
// Start server.
|
|
auto server = std::make_shared<ServerSocket>(clientPoller, std::move(sockFactory));
|
|
if (!server->bind(addr))
|
|
{
|
|
const std::string msg = "Failed to bind. (errno: ";
|
|
throw std::runtime_error(msg + std::strerror(errno) + ")");
|
|
}
|
|
|
|
if (!server->listen())
|
|
{
|
|
const std::string msg = "Failed to listen. (errno: ";
|
|
throw std::runtime_error(msg + std::strerror(errno) + ")");
|
|
}
|
|
|
|
SocketPoll serverPoll;
|
|
|
|
serverPoll.insertNewSocket(server);
|
|
|
|
std::cout << "Listening." << std::endl;
|
|
for (;;)
|
|
{
|
|
serverPoll.poll(30000);
|
|
}
|
|
}
|
|
|
|
class LOOLNB : public Poco::Util::ServerApplication
|
|
{
|
|
public:
|
|
int main(const std::vector<std::string>& args) override
|
|
{
|
|
const char* logLevel = std::getenv("LOOL_LOGLEVEL");
|
|
std::map<std::string, std::string> props;
|
|
if (logLevel)
|
|
Log::initialize("loolnb", logLevel ? logLevel : "",
|
|
false, false, props);
|
|
|
|
#if ENABLE_SSL
|
|
// TODO: These would normally come from config.
|
|
SslContext::initialize("/etc/loolwsd/cert.pem",
|
|
"/etc/loolwsd/key.pem",
|
|
"/etc/loolwsd/ca-chain.cert.pem");
|
|
#endif
|
|
|
|
// Used to poll client sockets.
|
|
SocketPoll poller;
|
|
|
|
// Start the client polling thread.
|
|
Thread threadPoll([&poller](std::atomic<bool>& stop)
|
|
{
|
|
while (!stop)
|
|
{
|
|
poller.poll(5000);
|
|
}
|
|
});
|
|
|
|
class PlainSocketFactory : public SocketFactory
|
|
{
|
|
std::shared_ptr<Socket> create(const int fd) override
|
|
{
|
|
return StreamSocket::create<StreamSocket>(fd, std::unique_ptr<SocketHandlerInterface>{ new SimpleResponseClient });
|
|
}
|
|
};
|
|
|
|
#if ENABLE_SSL
|
|
class SslSocketFactory : public SocketFactory
|
|
{
|
|
std::shared_ptr<Socket> create(const int fd) override
|
|
{
|
|
return StreamSocket::create<SslStreamSocket>(fd, std::unique_ptr<SocketHandlerInterface>{ new SimpleResponseClient });
|
|
}
|
|
};
|
|
|
|
// Start the server.
|
|
if (!args.empty() && args.back() == "ssl")
|
|
server(addrSsl, poller, std::unique_ptr<SocketFactory>{new SslSocketFactory});
|
|
else
|
|
#endif
|
|
server(addrHttp, poller, std::unique_ptr<SocketFactory>{new PlainSocketFactory});
|
|
|
|
std::cout << "Shutting down server." << std::endl;
|
|
|
|
threadPoll.stop();
|
|
|
|
#if ENABLE_SSL
|
|
SslContext::uninitialize();
|
|
#endif
|
|
|
|
(void)args;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
POCO_SERVER_MAIN(LOOLNB)
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|