Skip to content

Instantly share code, notes, and snippets.

@esketit-git

esketit-git/server.cpp

Forked from ptitfred/server.cpp
Created August 11, 2021 11:49
Show Gist options
  • Save esketit-git/296bb9d960ea46630abadb37ad9a84ea to your computer and use it in GitHub Desktop.
Save esketit-git/296bb9d960ea46630abadb37ad9a84ea to your computer and use it in GitHub Desktop.
Download ZIP
C++ HTTP server
Raw
server.cpp
#include "server.hpp"
#include <iostream>
#include <fstream>
#include <sstream>
using std::cout;
using std::cerr;
using std::cin;
using std::endl;
using std::fstream;
using std::ios;
using std::string;
using std::stringstream;
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#define PREFIX "[SERV] "
namespace bbl {
int Server::_static_handle( void * cls, // Server*
struct MHD_Connection * connection,
const char * url,
const char * method,
const char * version,
const char * upload_data,
size_t * upload_data_size,
void ** ptr ) {
Server* server = (Server*) cls;
return server->_handle(connection, url, method, version, upload_data, upload_data_size, ptr);
}
int Server::_handle( struct MHD_Connection * connection,
const char * url,
const char * method,
const char * version,
const char * upload_data,
size_t * upload_data_size,
void ** ptr ) {
static int dummy;
// PUT and POST data must first be gathered
// But not yet implemented => 404
if (strcmp("PUT", method) == 0 || strcmp("POST", method) == 0) {
// Not yet handled => 404
cerr << PREFIX << method << " not yet handled..." << endl;
return MHD_NO;
}
if (&dummy != *ptr) {
/* The first time only the headers are valid,
do not respond in the first round... */
*ptr = &dummy;
return MHD_YES;
}
*ptr = NULL; /* clear context pointer */
result r = this->_handler->handle(method, url);
if (r.httpCode == MHD_HTTP_OK) {
struct MHD_Response * response;
int ret;
response = MHD_create_response_from_data( r.data.size(),
(void*) r.data.data(),
MHD_NO,
MHD_YES); // Ask MHD to copy data
MHD_add_response_header( response, "Content-Type", r.mimeType != "" ? r.mimeType.c_str() : "text/html");
if (r.encoding != "")
MHD_add_response_header( response, "Content-Encoding", r.encoding.c_str());
ret = MHD_queue_response(connection,
MHD_HTTP_OK, // 202
response);
MHD_destroy_response(response);
return ret;
} else {
return MHD_queue_response(connection, r.httpCode, NULL);
}
}
int Server::_static_filter(
void *cls, // Server*
const struct sockaddr * addr,
socklen_t addrlen) {
Server* server = (Server*) cls;
return server->_filter(addr, addrlen) ? MHD_YES : MHD_NO;
}
bool Server::_filter(const struct sockaddr * addr, socklen_t addrlen) {
// TODO filter non local addresses.
return true;
}
bool Server::start() {
cout << PREFIX << "Starting..." << endl;
this->_daemon = MHD_start_daemon(this->_threadPoolSize >0 ? MHD_USE_SELECT_INTERNALLY : MHD_USE_THREAD_PER_CONNECTION,
this->_port,
& (Server::_static_filter), this,
& (Server::_static_handle), this,
MHD_OPTION_THREAD_POOL_SIZE, this->_threadPoolSize,
MHD_OPTION_END);
if (this->_daemon == NULL)
return false;
cout << PREFIX << "port: " << this->_port << endl;
cout << PREFIX << "threads: " << this->_threadPoolSize << endl;
return true;
}
void Server::stop() {
MHD_stop_daemon(this->_daemon);
}
} // namespace ::bbl
class DefaultHandler : public bbl::Handler {
public:
DefaultHandler(const std::string& chroot) : _chroot(chroot), prefix("[DH ] ") {}
~DefaultHandler() {}
public:
bbl::result handle(const string& method, const string& url) {
cout << prefix << method << ":" << url << endl;
bbl::result r;
fs::path pPath( _chroot / url);
if ( !fs::exists( pPath ) ) {
cout << prefix << " Not found " << pPath.file_string() << endl;
r.httpCode = MHD_HTTP_NOT_FOUND;
return r;
}
if ( fs::is_directory( pPath ) && fs::exists( pPath / "index.html") ) {
pPath = pPath / "index.html";
}
const string sPath = pPath.file_string();
if ( fs::is_directory ( pPath ) ) {
// list files
cout << prefix << " Listing directory" << endl;
fs::directory_iterator end_iter;
stringstream buffer;
buffer << "<html><head><title>" << pPath.file_string() << "</title></head>" << endl;
buffer << "<body>" << endl;
buffer << "<h3>" << pPath.file_string() << "</h3>" << endl;
buffer << "</p>" << endl;
for ( fs::directory_iterator dir_itr( pPath );
dir_itr != end_iter;
++dir_itr ) {
string link = dir_itr->path().filename();
try {
buffer << "<a href='" << link << "'>" << link << "</a><br/>" << endl;
} catch ( const std::exception & ex ) {
cout << link << " " << ex.what() << endl;
}
}
buffer << "</p>" << endl;
buffer << "</body>" << endl;
buffer << "</html>" << endl;
r.httpCode = MHD_HTTP_OK;
r.mimeType = MIME_HTML;
r.data = buffer.str();
} else {
fstream file(sPath.c_str(), ios::binary | ios::ate | ios::in);
int size = file.tellg();
cout << prefix << " Serving " << sPath << " (" << size << " bytes)" << endl;
char* memblock = new char [size];
file.seekg (0, std::ios::beg);
file.read (memblock, size);
file.close();
r.httpCode = MHD_HTTP_OK;
r.data = string(memblock, size);
}
return r;
};
private:
string prefix;
fs::path _chroot;
};
int main(int argc, char** argv) {
if (argc != 4) {
cerr << "Usage : server port threadPoolSize webroot" << endl;
return 1;
}
bbl::Server s(atoi(argv[1]), atoi(argv[2]), new DefaultHandler(argv[3]));
s.start();
char c;
cin >> c;
s.stop();
}
Raw
server.hpp
#include <sys/types.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <stdarg.h>
#include <stdint.h>
#include <microhttpd.h>
#include <string>
namespace bbl {
struct result {
int httpCode;
std::string data;
std::string mimeType;
std::string encoding;
};
const std::string MIME_HTML = "text/html";
class Handler {
public:
virtual result handle(const std::string& method, const std::string& url) =0;
};
class Server {
public:
Server(int port, int threadPoolSize, Handler* handler) : _handler(handler), _port(port), _threadPoolSize(threadPoolSize) {}
~Server() { stop(); }
public:
bool start();
void stop();
private:
bool _filter( const struct sockaddr * addr,
socklen_t addrlen);
static int _static_filter(
void *cls, // Server*
const struct sockaddr * addr,
socklen_t addrlen);
/**
* <p>Barely delegates to _handler->handle(...).</p>
*/
int _handle(
struct MHD_Connection * connection,
const char * url,
const char * method,
const char * version,
const char * upload_data,
size_t * upload_data_size,
void ** ptr
);
/**
* <p>First parameter is a Server* ; other args are delegated to cls->_handle(...).</p>
*/
static int _static_handle(
void * cls, // Server*
struct MHD_Connection * connection,
const char * url,
const char * method,
const char * version,
const char * upload_data,
size_t * upload_data_size,
void ** ptr
);
private:
Handler* _handler;
int _port;
int _threadPoolSize;
struct MHD_Daemon * _daemon;
};
} // namespace bbl;
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment