int
WebSocketConnectHandler(const struct mg_connection *conn, void *cbdata)
{
struct mg_context *ctx = mg_get_context(conn);
int reject = 1;
int i;
mg_lock_context(ctx);
for (i = 0; i < MAX_WS_CLIENTS; i++) {
if (ws_clients[i].conn == NULL) {
ws_clients[i].conn = (struct mg_connection *)conn;
ws_clients[i].state = 1;
mg_set_user_connection_data(ws_clients[i].conn,
(void *)(ws_clients + i));
reject = 0;
break;
}
}
mg_unlock_context(ctx);
fprintf(stdout,
"Websocket client %s\r\n\r\n",
(reject ? "rejected" : "accepted"));
return reject;
}
static int
websocket_client_data_handler(struct mg_connection *conn,
int flags,
char *data,
size_t data_len,
void *user_data)
{
struct mg_context *ctx = mg_get_context(conn);
struct tclient_data *pclient_data =
(struct tclient_data *)mg_get_user_data(ctx);
(void)user_data; /* TODO: check this */
ck_assert(pclient_data != NULL);
ck_assert_int_eq(flags, (int)(128 | 1));
printf("Client received data from server: ");
fwrite(data, 1, data_len, stdout);
printf("\n");
pclient_data->data = malloc(data_len);
ck_assert(pclient_data->data != NULL);
memcpy(pclient_data->data, data, data_len);
pclient_data->len = data_len;
return 1;
}
static void websocket_client_close_handler(const struct mg_connection *conn, void * user_data)
{
struct mg_context *ctx = mg_get_context(conn);
struct tclient_data *pclient_data = (struct tclient_data *) mg_get_user_data(ctx);
printf("Client: Close handler\n");
pclient_data->closed++;
}
static void websocket_client_close_handler(const struct mg_connection *conn,
void *user_data)
{
struct mg_context *ctx = mg_get_context(conn);
struct tclient_data *pclient_data =
(struct tclient_data *)mg_get_user_data(ctx);
(void)user_data; /* TODO: check this */
ck_assert(pclient_data != NULL);
printf("Client: Close handler\n");
pclient_data->closed++;
}
int tier2_message::wait_for_response(interthread_communicator *listen_comm)
{
assert(requester != m_receiver);
//interthread_communicator *comm = m_owner->get_interthread_communicator(m_receiver, requester); -- m_owner is in limbo, hence untrustworthy!
assert(listen_comm);
assert(listen_comm->receiver() == requester);
if (!listen_comm)
return -1;
// check the message queue of the requester to see if the expected message already was returned before we called this!
if (requester->does_own(this))
{
switch(this->state())
{
case MSG_INITIALIZED:
case EXEC_COMMAND:
case WAIT_FOR_TRANSMIT:
case COMMENCE_TRANSMIT:
case READY_TO_RECEIVE_RESPONSE:
case RESPONSE_PENDING:
break;
case RESPONSE_COMPLETE:
case TASK_COMPLETED:
default:
// our message has already been answered / completed / aborted ... it's concluded anyway.
return 0;
}
}
while (mg_get_stop_flag(mg_get_context(listen_comm->receiver_socket())) == 0)
{
// make me wait for a message to arrive...
interthread_communicator::msg_pending_mode_t msg_mode = interthread_communicator::NO_MSG;
tier2_message *msg = listen_comm->pop_one_message(msg_mode);
// if the popped message is our response (and not some book-keeping sort of thing), we know we're done.
if (!msg)
{
return -1;
}
if (msg == this)
{
return 0;
}
}
return -1;
}
void
WebSocketCloseHandler(const struct mg_connection *conn, void *cbdata)
{
struct mg_context *ctx = mg_get_context(conn);
struct t_ws_client *client = mg_get_user_connection_data(conn);
ASSERT(client->conn == conn);
ASSERT(client->state >= 1);
mg_lock_context(ctx);
client->state = 0;
client->conn = NULL;
mg_unlock_context(ctx);
fprintf(stdout,
"Client droped from the set of webserver connections\r\n\r\n");
}
END_TEST
static int log_msg_func(const struct mg_connection *conn, const char *message)
{
struct mg_context *ctx;
char *ud;
ck_assert(conn != NULL);
ctx = mg_get_context(conn);
ck_assert(ctx != NULL);
ud = (char *)mg_get_user_data(ctx);
strncpy(ud, message, 255);
ud[255] = 0;
return 1;
}
static int
request_test_handler(struct mg_connection *conn, void *cbdata)
{
int i;
char chunk_data[32];
const struct mg_request_info *ri;
struct mg_context *ctx;
void *ud, *cud;
ctx = mg_get_context(conn);
ud = mg_get_user_data(ctx);
ri = mg_get_request_info(conn);
ck_assert(ri != NULL);
ck_assert(ctx == g_ctx);
ck_assert(ud == &g_ctx);
mg_set_user_connection_data(conn, (void *)6543);
cud = mg_get_user_connection_data(conn);
ck_assert_ptr_eq((void *)cud, (void *)6543);
ck_assert_ptr_eq((void *)cbdata, (void *)7);
strcpy(chunk_data, "123456789A123456789B123456789C");
mg_printf(conn,
"HTTP/1.1 200 OK\r\n"
"Transfer-Encoding: chunked\r\n"
"Content-Type: text/plain\r\n\r\n");
for (i = 1; i <= 10; i++) {
mg_printf(conn, "%x\r\n", i);
mg_write(conn, chunk_data, (unsigned)i);
mg_printf(conn, "\r\n");
}
mg_printf(conn, "0\r\n\r\n");
return 1;
}
