/// Return a HTML document with some JavaScript creating

/// a WebSocket connection.

{

void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response)

{

response.setChunkedTransferEncoding(true);

response.setContentType("text/html");

std::ostream& ostr = response.send();

ostr << "<html>";

ostr << "<head>";

ostr << "<title>WebSocketServer</title>";

ostr << "<script type=\"text/javascript\">";

ostr << "function WebSocketTest()";

ostr << "{";

ostr << " if (\"WebSocket\" in window)";

ostr << " {";

ostr << " var ws = new WebSocket(\"ws://" << request.serverAddress().toString() << "/ws\");";

ostr << " ws.onopen = function()";

ostr << " {";

ostr << " ws.send(\"Hello, world!\");";

ostr << " };";

ostr << " ws.onmessage = function(evt)";

ostr << " { ";

ostr << " var msg = evt.data;";

ostr << " alert(\"Message received: \" + msg);";

ostr << " ws.close();";

ostr << " };";

ostr << " ws.onclose = function()";

ostr << " { ";

ostr << " alert(\"WebSocket closed.\");";

ostr << " };";

ostr << " }";

ostr << " else";

ostr << " {";

ostr << " alert(\"This browser does not support WebSockets.\");";

ostr << " }";

ostr << "}";

ostr << "</script>";

ostr << "</head>";

ostr << "<body>";

ostr << " <h1>WebSocket Server</h1>";

ostr << " <p><a href=\"javascript:WebSocketTest()\">Run WebSocket Script</a></p>";

ostr << "</body>";

ostr << "</html>";

}

/// Handle a WebSocket connection.

{

void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response)

{

Application& app = Application::instance();

try

{

WebSocket ws(request, response);

app.logger().information("WebSocket connection established.");

char buffer[1024];

int flags;

int n;

do

{

n = ws.receiveFrame(buffer, sizeof(buffer), flags);

app.logger().information(Poco::format("Frame received (length=%d, flags=0x%x).", n, unsigned(flags)));

ws.sendFrame(buffer, n, flags);

}

while (n > 0 || (flags & WebSocket::FRAME_OP_BITMASK) != WebSocket::FRAME_OP_CLOSE);

app.logger().information("WebSocket connection closed.");

}

catch (WebSocketException& exc)

{

app.logger().log(exc);

switch (exc.code())

{

case WebSocket::WS_ERR_HANDSHAKE_UNSUPPORTED_VERSION:

response.set("Sec-WebSocket-Version", WebSocket::WEBSOCKET_VERSION);

// fallthrough

case WebSocket::WS_ERR_NO_HANDSHAKE:

case WebSocket::WS_ERR_HANDSHAKE_NO_VERSION:

case WebSocket::WS_ERR_HANDSHAKE_NO_KEY:

response.setStatusAndReason(HTTPResponse::HTTP_BAD_REQUEST);

response.setContentLength(0);

response.send();

break;

}

}

}

{

HTTPRequestHandler* createRequestHandler(const HTTPServerRequest& request)

{

Application& app = Application::instance();

app.logger().information("Request from "

+ request.clientAddress().toString()

+ ": "

+ request.getMethod()

+ " "

+ request.getURI()

+ " "

+ request.getVersion());

for (HTTPServerRequest::ConstIterator it = request.begin(); it != request.end(); ++it)

{

app.logger().information(it->first + ": " + it->second);

}

if(request.find("Upgrade") != request.end() && Poco::icompare(request["Upgrade"], "websocket") == 0)

return new WebSocketRequestHandler;

else

return new PageRequestHandler;

}

/// The main application class.

///

/// This class handles command-line arguments and

/// configuration files.

/// Start the WebSocketServer executable with the help

/// option (/help on Windows, --help on Unix) for

/// the available command line options.

///

/// To use the sample configuration file (WebSocketServer.properties),

/// copy the file to the directory where the WebSocketServer executable

/// resides. If you start the debug version of the WebSocketServer

/// (WebSocketServerd[.exe]), you must also create a copy of the configuration

/// file named WebSocketServerd.properties. In the configuration file, you

/// can specify the port on which the server is listening (default

/// 9980) and the format of the date/time string sent back to the client.

///

/// To test the WebSocketServer you can use any web browser (http://localhost:9980/).

{

WebSocketServer(): _helpRequested(false)

{

}

~WebSocketServer()

{

}

void initialize(Application& self)

{

loadConfiguration(); // load default configuration files, if present

ServerApplication::initialize(self);

}

void uninitialize()

{

ServerApplication::uninitialize();

}

void defineOptions(OptionSet& options)

{

ServerApplication::defineOptions(options);

options.addOption(

Option("help", "h", "display help information on command line arguments")

.required(false)

.repeatable(false));

}

void handleOption(const std::string& name, const std::string& value)

{

ServerApplication::handleOption(name, value);

if (name == "help")

_helpRequested = true;

}

void displayHelp()

{

HelpFormatter helpFormatter(options());

helpFormatter.setCommand(commandName());

helpFormatter.setUsage("OPTIONS");

helpFormatter.setHeader("A sample HTTP server supporting the WebSocket protocol.");

helpFormatter.format(std::cout);

}

int main(const std::vector<std::string>& args)

{

if (_helpRequested)

{

displayHelp();

}

else

{

// get parameters from configuration file

unsigned short port = (unsigned short) config().getInt("WebSocketServer.port", 9980);

// set-up a server socket

ServerSocket svs(port);

// set-up a HTTPServer instance

HTTPServer srv(new RequestHandlerFactory, svs, new HTTPServerParams);

// start the HTTPServer

srv.start();

// wait for CTRL-C or kill

waitForTerminationRequest();

// Stop the HTTPServer

srv.stop();

}

return Application::EXIT_OK;

}

bool _helpRequested;