static int websock_server_data(struct mg_connection *conn,
int bits,
char *data,
size_t data_len,
void *udata)
{
(void)bits;
ck_assert_ptr_eq((void *)udata, (void *)7531);
printf("Server: Got %u bytes from the client\n", (unsigned)data_len);
if (data_len < 3 || 0 != memcmp(data, "bye", 3)) {
/* Send websocket acknowledge message */
mg_lock_connection(conn);
mg_websocket_write(conn,
WEBSOCKET_OPCODE_TEXT,
websocket_acknowledge_msg,
websocket_acknowledge_msg_len);
mg_unlock_connection(conn);
} else {
/* Send websocket acknowledge message */
mg_lock_connection(conn);
mg_websocket_write(conn,
WEBSOCKET_OPCODE_TEXT,
websocket_goodbye_msg,
websocket_goodbye_msg_len);
mg_unlock_connection(conn);
}
return 1; /* return 1 to keep the connetion open */
}
static int
websock_server_data(struct mg_connection *conn,
int bits,
char *data,
size_t data_len,
void *udata)
{
(void)bits;
ck_assert_ptr_eq((void *)udata, (void *)7531);
printf("Server: Got %u bytes from the client\n", (unsigned)data_len);
if (data_len == 3 && !memcmp(data, "bye", 3)) {
/* Send websocket goodbye message */
mg_lock_connection(conn);
mg_websocket_write(conn,
WEBSOCKET_OPCODE_TEXT,
websocket_goodbye_msg,
websocket_goodbye_msg_len);
mg_unlock_connection(conn);
} else if (data_len == 5 && !memcmp(data, "data1", 5)) {
mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, "ok1", 3);
mg_unlock_connection(conn);
} else if (data_len == 5 && !memcmp(data, "data2", 5)) {
mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, "ok 2", 4);
mg_unlock_connection(conn);
} else if (data_len == 5 && !memcmp(data, "data3", 5)) {
mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, "ok - 3", 6);
mg_unlock_connection(conn);
} else {
#if defined(__MINGW32__) || defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunreachable-code"
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#endif
ck_abort_msg("Got unexpected message from websocket client");
return 0;
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#if defined(__MINGW32__) || defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
}
return 1; /* return 1 to keep the connetion open */
}
// Arguments:
// flags: first byte of websocket frame, see websocket RFC,
// http://tools.ietf.org/html/rfc6455, section 5.2
// data, data_len: payload data. Mask, if any, is already applied.
int UIHelper::websocket_data_handler(mg_connection *conn, int flags,
char *data, size_t data_len) {
(void) flags; // Unused
// Returning zero means stoping websocket conversation.
// Close the conversation if client has sent us "exit" string.
if (memcmp(data, "exit", 4) == 0)
return 0;
if (strcmp(mg_get_request_info(conn)->uri,"/searchdbquery") == 0)
{
string message(data,data_len);
string query;
Json::Value jValue;
Json::Reader JReader;
printf("Message: %s\n",message.c_str() );
if( JReader.parse(message, jValue) ){
try{
query = jValue.get("query","").asString();
}
catch (exception &e){
cout << "Exception!:" << e.what() << endl;
}
}
else {
printf("Parse error :%s\n",JReader.getFormatedErrorMessages().c_str());
}
if (query.length()){
Json::Value result;
instance->dbconnector->query(&query, &result);
Json::StyledWriter writer;
string result_str = writer.write(result);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, result_str.c_str(), result_str.length()+1);
}
}
else
{
//TODO: Echo temporarily
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, data, data_len);
}
printf("data returned for %s \n",mg_get_request_info(conn)->uri);
return 1;
}
void *ws_server_thread(void *parm)
{
wsserver::ws_connection* ws_conn = static_cast<wsserver::ws_connection*>(parm);
mg_connection *conn = ws_conn->conn;
wsserver* object = static_cast<wsserver*>(mg_get_request_info(conn)->user_data);
int timer = 0;
if(object->getDebug()) post("ws_server_thread %d\n", ws_conn->index);
/* While the connection is open, send periodic updates */
while(!ws_conn->closing) {
usleep(object->mClientUpdateRateMs * 1000);
timer++;
WDL_MutexLock(&ws_conn->mutex);
if (ws_conn->update && ws_conn->newdatafromserver)
{
if (!ws_conn->closing)
{
if (ws_conn->fromserver.GetLength())
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, ws_conn->fromserver.Get(), ws_conn->fromserver.GetLength());
ws_conn->newdatafromserver = false;
}
}
/* Send periodic PING to assure websocket remains connected, except if we are closing */
if (timer%100 == 0 && !ws_conn->closing)
mg_websocket_write(conn, WEBSOCKET_OPCODE_PING, NULL, 0);
}
if(object->getDebug()) post("ws_server_thread %d exiting\n", ws_conn->index);
WDL_MutexLock(&ws_conn->mutex);
// reset connection information to allow reuse by new client
ws_conn->update = 0;
ws_conn->index = -1;
ws_conn->newdatafromserver = false;
ws_conn->newdatatoserver = true;
ws_conn->fromserver.Set("");
if(ws_conn->toserver.Get()) ws_conn->toserver.SetFormatted(MAX_STRING, "dx");
ws_conn->conn = NULL;
ws_conn->closing = 2;
return NULL;
}
void processCmd(mg_connection* conn, char* cmd, size_t cmdLen)
{
// Null-terminate the command and add END_OF_BUF_CHAR to the end of
// the cmd buffer. This makes it easier to parse the command
// token-by-token.
cmd[cmdLen] = '\0';
cmd[cmdLen+1] = END_OF_BUF_CHAR;
char* cmdName = firstToken(cmd);
if (strcmp("ping", cmdName) == 0) {
char response[] = "OK";
mg_websocket_write(conn, 1, response, sizeof(response)-1);
}
else if (strcmp("keydownup", cmdName) == 0) {
char* keyName = nextToken(cmd);
keypress::keyDownUp(keyName);
}
else if (strcmp("keyseq", cmdName) == 0) {
char* keyName = nextToken(cmd);
keypress::keySequence(keyName);
}
else if (strcmp("keydown", cmdName) == 0) {
char* keyName = nextToken(cmd);
keypress::keyDown(keyName);
}
else if (strcmp("keyup", cmdName) == 0) {
char* keyName = nextToken(cmd);
keypress::keyUp(keyName);
}
else {
printf("Unhandled cmd \"%s\"\n", cmdName);
}
}
static void iterate_callback(struct mg_connection *c, void *param) {
if (c->is_websocket) {
char buf[20];
int len = snprintf(buf, sizeof(buf), "%d", * (int *) param);
mg_websocket_write(c, 1, buf, len);
}
}
// sent direct to mg_connection
void send_meta_mc(struct mg_connection *mc, u1_t cmd, u4_t p1, u4_t p2)
{
meta_t meta;
meta_set(&meta, cmd, p1, p2);
mg_websocket_write(mc, WS_OPCODE_BINARY, (char*) &meta, 4+2+8);
}
static int iterate_callback(struct mg_connection *c) {
if (c->is_websocket) {
char buf[20];
int len = snprintf(buf, sizeof(buf), "%d", * (int *) c->callback_param);
mg_websocket_write(c, 1, buf, len);
}
return MG_REQUEST_PROCESSED;
}
static int mpd_notify_callback(struct mg_connection *c, enum mg_event ev) {
size_t n;
if(!c->is_websocket)
return MG_TRUE;
if(c->callback_param)
{
/* error message? */
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"error\",\"data\":\"%s\"}",
(const char *)c->callback_param);
mg_websocket_write(c, 1, mpd.buf, n);
return MG_TRUE;
}
if(!c->connection_param)
c->connection_param = calloc(1, sizeof(struct t_mpd_client_session));
struct t_mpd_client_session *s = (struct t_mpd_client_session *)c->connection_param;
if(mpd.conn_state != MPD_CONNECTED) {
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"disconnected\"}");
mg_websocket_write(c, 1, mpd.buf, n);
}
else
{
mg_websocket_write(c, 1, mpd.buf, mpd.buf_size);
if(s->song_id != mpd.song_id)
{
n = mpd_put_current_song(mpd.buf);
mg_websocket_write(c, 1, mpd.buf, n);
s->song_id = mpd.song_id;
}
if(s->queue_version != mpd.queue_version)
{
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"update_queue\"}");
mg_websocket_write(c, 1, mpd.buf, n);
s->queue_version = mpd.queue_version;
}
}
return MG_TRUE;
}
void web_engine::push_message(const char *message)
{
for (simple_list_wrapper<mg_connection> *curitem = m_websockets.first(); curitem != NULL; curitem = curitem->next())
{
int status = mg_websocket_write(curitem->object(), WEBSOCKET_OPCODE_TEXT, message, strlen(message));
if (status==0) m_websockets.detach(*curitem); // remove inactive clients
}
}
static void websocket_ready_handler(struct mg_connection* conn) {
clientSetMutex.lock();
clientSet.insert(conn);
clientSetMutex.unlock();
mg_websocket_write(conn, 0x1, "{\"type\": 0, \"value\":\"server ready\"}");
debugPrintf("Connection 0x%x: Opened for websocket\n", (unsigned int)(uintptr_t)conn);
clientWantsImage = 1;
}
static void send_to_all_websockets(const char * data, int data_len) {
int i;
for (i=0;i<MAX_NUM_OF_WEBSOCKS;i++) {
if (socketList[i] && (socketList[i]->webSockState==2)) {
mg_websocket_write(socketList[i]->conn, WEBSOCKET_OPCODE_TEXT, data, data_len);
}
}
}
void websocket_server_ready(struct mg_connection * conn, void * _ignored)
#endif
{
printf("Server: Websocket ready\n");
/* Send websocket welcome message */
mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, websocket_welcome_msg, websocket_welcome_msg_len);
mg_unlock_connection(conn);
}
int Server::ServeWebsocketRequest(struct mg_connection *conn)
{
// Most browsers send an empty "heartbeat" to keep the connection open
if (conn->content_len == 0)
return MG_TRUE;
// Echo
printf("Websocket %p request %s of len %d\n", conn, conn->content, conn->content_len);
mg_websocket_write(conn, 1, conn->content, conn->content_len);
return MG_TRUE;
}
int websocket_server_data(struct mg_connection * conn, int bits, char *data, size_t data_len, void *_ignored)
#endif
{
printf("Server: Got %u bytes from the client\n", data_len);
if (data_len<3 || 0!=memcmp(data, "bye", 3)) {
/* Send websocket acknowledge message */
mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, websocket_acknowledge_msg, websocket_acknowledge_msg_len);
mg_unlock_connection(conn);
} else {
/* Send websocket acknowledge message */
mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, websocket_goodbye_msg, websocket_goodbye_msg_len);
mg_unlock_connection(conn);
}
return 1; /* return 1 to keep the connetion open */
}
// Web Socket Handlers
// ----------------------------------------------------------------------------
void websocket_ready_handler(mg_connection *conn)
{
//mg_request_info *pRequestInfo = mg_get_request_info(conn);
//
std::cout << "Mongoose has started" << std::endl;
const char *message = "Server Ready !!";
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, message, strlen(message));
}
// Arguments:
// flags: first byte of websocket frame, see websocket RFC,
// http://tools.ietf.org/html/rfc6455, section 5.2
// data, data_len: payload data. Mask, if any, is already applied.
int web_engine::websocket_data_handler(struct mg_connection *conn, int flags,
char *data, size_t data_len)
{
// just Echo example for now
if ((flags & 0x0f) == WEBSOCKET_OPCODE_TEXT)
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, data, data_len);
// Returning zero means stoping websocket conversation.
// Close the conversation if client has sent us "exit" string.
return memcmp(data, "exit", 4);
}
void web_engine::close()
{
m_exiting_core = 1;
osd_sleep(osd_ticks_per_second()/5);
for (simple_list_wrapper<mg_connection> *curitem = m_websockets.first(); curitem != NULL; curitem = curitem->next())
{
mg_websocket_write(curitem->object(), WEBSOCKET_OPCODE_CONNECTION_CLOSE, NULL, 0);
}
// Stop the server.
mg_stop(m_ctx);
}
void web_engine::push_message(const char *message)
{
struct mg_connection *c;
if (m_server!=NULL) {
// Iterate over all connections, and push current time message to websocket ones.
for (c = mg_next(m_server, NULL); c != NULL; c = mg_next(m_server, c)) {
if (c->is_websocket) {
mg_websocket_write(c, 1, message, strlen(message));
}
}
}
}
static void push_message(struct mg_server *server, time_t current_time) {
struct mg_connection *c;
char buf[20];
int len = sprintf(buf, "%lu", (unsigned long) current_time);
// Iterate over all connections, and push current time message to websocket ones.
for (c = mg_next(server, NULL); c != NULL; c = mg_next(server, c)) {
if (c->is_websocket) {
mg_websocket_write(c, 1, buf, len);
}
}
}
void WebAccess::slotFramePageChanged(int pageNum)
{
if (m_conn == NULL)
return;
VCWidget *frame = (VCWidget *)sender();
QString wsMessage = QString("%1|FRAME|%2").arg(frame->id()).arg(pageNum);
QByteArray ba = wsMessage.toUtf8();
mg_websocket_write(m_conn, WEBSOCKET_OPCODE_TEXT, ba.data(), ba.length());
}
// This handler is called for each incoming websocket frame, one or more
// times for connection lifetime.
static int handler(struct mg_connection *conn) {
static const char oops[] = "HTTP/1.0 200 OK\r\n\r\nwebsocket data expected\n";
if (!conn->is_websocket) {
mg_write(conn, oops, sizeof(oops) - 1);
return 1;
}
mg_websocket_write(conn, 1, conn->content, conn->content_len);
return conn->content_len == 4 && !memcmp(conn->content, "exit", 4);
}
void WebSocket::send(string data, int opcode)
{
if (isClosed()) {
return;
}
mutex.lock();
if (!mg_websocket_write(connection, opcode, data.c_str(), data.size())) {
closed = true;
}
mutex.unlock();
}
// sent direct to mg_connection
void send_msg_mc(struct mg_connection *mc, const char *msg, ...)
{
va_list ap;
char *s;
va_start(ap, msg);
vasprintf(&s, msg, ap);
va_end(ap);
printf("send_msg_mc: <%s>\n", s);
mg_websocket_write(mc, WS_OPCODE_BINARY, s, strlen(s));
free(s);
}
void
WebSocketReadyHandler(struct mg_connection *conn, void *cbdata)
{
const char *text = "Hello from the websocket ready handler";
struct t_ws_client *client = mg_get_user_connection_data(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, text, strlen(text));
fprintf(stdout, "Greeting message sent to websocket client\r\n\r\n");
ASSERT(client->conn == conn);
ASSERT(client->state == 1);
client->state = 2;
}
static int send_reply(struct mg_connection *conn) {
if (conn->is_websocket) {
// This handler is called for each incoming websocket frame, one or more
// times for connection lifetime.
// Echo websocket data back to the client.
mg_websocket_write(conn, 1, conn->content, conn->content_len);
return conn->content_len == 4 && !memcmp(conn->content, "exit", 4) ?
MG_FALSE : MG_TRUE;
} else {
mg_send_file(conn, "index.html", NULL);
return MG_MORE;
}
}
int WebController::PushClientData(int opCode, const char *data , size_t data_len){
struct mg_connection *c = NULL;
int nrOfClients = 0;
// Iterate over all connections, and push current time message to websocket ones.
for (c = mg_next(server, c); c != NULL; c = mg_next(server, c)) {
if (c->is_websocket) {
mg_websocket_write(c, opCode, data, data_len);
nrOfClients++;
}
}
return nrOfClients;
}
static void websock_server_ready(struct mg_connection *conn, void *udata)
{
ck_assert_ptr_eq((void *)udata, (void *)7531);
printf("Server: Websocket ready\n");
/* Send websocket welcome message */
mg_lock_connection(conn);
mg_websocket_write(conn,
WEBSOCKET_OPCODE_TEXT,
websocket_welcome_msg,
websocket_welcome_msg_len);
mg_unlock_connection(conn);
printf("Server: Websocket ready X\n");
}
int ext_send_msg(int rx_chan, bool debug, const char *msg, ...)
{
va_list ap;
char *s;
conn_t *conn = ext_users[rx_chan].conn;
if (!conn || !conn->mc) return -1;
va_start(ap, msg);
vasprintf(&s, msg, ap);
va_end(ap);
if (debug) printf("ext_send_msg: RX%d-%p <%s>\n", rx_chan, conn, s);
mg_websocket_write(conn->mc, WS_OPCODE_BINARY, s, strlen(s));
free(s);
return 0;
}
bool App::onEvent(const GEvent& event) {
// Handle super-class events
if (GApp::onEvent(event)) { return true; }
if ((event.type == GEventType::KEY_DOWN) && (event.key.keysym.sym == 'p')) {
// Send a message to the clients
clientSetMutex.lock();
for (Set<struct mg_connection*>::Iterator it = clientSet.begin(); it.isValid(); ++it) {
mg_connection* conn = *it;
mg_websocket_write(conn, 0x1, "{\"type\": 0, \"value\": \"how are you?\"}");
}
clientSetMutex.unlock();
return true;
}
return false;
}
