bool websocket_transport::send_message(wamp_message&& message)
{
BONEFISH_TRACE("sending message: %1%", message_type_to_string(message.get_type()));
expandable_buffer buffer = m_serializer->serialize(message);
auto opcode = (m_serializer->get_type() == wamp_serializer_type::JSON)
? websocketpp::frame::opcode::TEXT
: websocketpp::frame::opcode::BINARY;
m_server->send(m_handle, buffer.data(), buffer.size(), opcode);
return true;
}
static gboolean wispr_result(GWebResult *result, gpointer user_data)
{
struct wispr_session *wispr = user_data;
const guint8 *chunk;
gsize length;
guint16 status;
gdouble elapsed;
g_web_result_get_chunk(result, &chunk, &length);
if (length > 0) {
//printf("%s\n", (char *) chunk);
g_web_parser_feed_data(wispr->parser, chunk, length);
return TRUE;
}
g_web_parser_end_data(wispr->parser);
status = g_web_result_get_status(result);
g_print("status: %03u\n", status);
elapsed = g_timer_elapsed(timer, NULL);
g_print("elapse: %f seconds\n", elapsed);
if (wispr->msg.message_type < 0) {
const char *redirect;
if (status != 302)
goto done;
if (g_web_result_get_header(result, "Location",
&redirect) == FALSE)
goto done;
printf("Redirect URL: %s\n", redirect);
printf("\n");
wispr->request = g_web_request_get(wispr->web, redirect,
wispr_result, wispr);
return FALSE;
}
printf("Message type: %s (%d)\n",
message_type_to_string(wispr->msg.message_type),
wispr->msg.message_type);
printf("Response code: %s (%d)\n",
response_code_to_string(wispr->msg.response_code),
wispr->msg.response_code);
if (wispr->msg.access_procedure != NULL)
printf("Access procedure: %s\n", wispr->msg.access_procedure);
if (wispr->msg.access_location != NULL)
printf("Access location: %s\n", wispr->msg.access_location);
if (wispr->msg.location_name != NULL)
printf("Location name: %s\n", wispr->msg.location_name);
if (wispr->msg.login_url != NULL)
printf("Login URL: %s\n", wispr->msg.login_url);
if (wispr->msg.abort_login_url != NULL)
printf("Abort login URL: %s\n", wispr->msg.abort_login_url);
if (wispr->msg.logoff_url != NULL)
printf("Logoff URL: %s\n", wispr->msg.logoff_url);
printf("\n");
if (status != 200 && status != 302 && status != 404)
goto done;
if (wispr->msg.message_type == 100) {
if (wispr->username == NULL) {
user_input("Username", FALSE, username_callback, wispr);
return FALSE;
}
if (wispr->password == NULL) {
user_input("Password", TRUE, password_callback, wispr);
return FALSE;
}
g_idle_add(execute_login, wispr);
return FALSE;
} else if (wispr->msg.message_type == 120 ||
wispr->msg.message_type == 140) {
int code = wispr->msg.response_code;
printf("Login process: %s\n",
code == 50 ? "SUCCESS" : "FAILURE");
}
if (status == 302) {
const char *redirect;
if (g_web_result_get_header(result, "Location",
&redirect) == FALSE)
goto done;
printf("\n");
printf("Redirect URL: %s\n", redirect);
printf("\n");
wispr->request = g_web_request_get(wispr->web, redirect,
wispr_result, wispr);
return FALSE;
}
done:
g_main_loop_quit(main_loop);
return FALSE;
}
static bool wispr_manage_message(GWebResult *result,
struct connman_wispr_portal_context *wp_context)
{
DBG("Message type: %s (%d)",
message_type_to_string(wp_context->wispr_msg.message_type),
wp_context->wispr_msg.message_type);
DBG("Response code: %s (%d)",
response_code_to_string(wp_context->wispr_msg.response_code),
wp_context->wispr_msg.response_code);
if (wp_context->wispr_msg.access_procedure)
DBG("Access procedure: %s",
wp_context->wispr_msg.access_procedure);
if (wp_context->wispr_msg.access_location)
DBG("Access location: %s",
wp_context->wispr_msg.access_location);
if (wp_context->wispr_msg.location_name)
DBG("Location name: %s",
wp_context->wispr_msg.location_name);
if (wp_context->wispr_msg.login_url)
DBG("Login URL: %s", wp_context->wispr_msg.login_url);
if (wp_context->wispr_msg.abort_login_url)
DBG("Abort login URL: %s",
wp_context->wispr_msg.abort_login_url);
if (wp_context->wispr_msg.logoff_url)
DBG("Logoff URL: %s", wp_context->wispr_msg.logoff_url);
switch (wp_context->wispr_msg.message_type) {
case 100:
DBG("Login required");
wp_context->wispr_result = CONNMAN_WISPR_RESULT_LOGIN;
if (__connman_agent_request_login_input(wp_context->service,
wispr_portal_request_wispr_login,
wp_context) != -EINPROGRESS)
wispr_portal_error(wp_context);
else
return true;
break;
case 120: /* Falling down */
case 140:
if (wp_context->wispr_msg.response_code == 50) {
wp_context->wispr_result = CONNMAN_WISPR_RESULT_ONLINE;
g_free(wp_context->wispr_username);
wp_context->wispr_username = NULL;
g_free(wp_context->wispr_password);
wp_context->wispr_password = NULL;
g_free(wp_context->wispr_formdata);
wp_context->wispr_formdata = NULL;
wispr_portal_request_portal(wp_context);
return true;
} else
wispr_portal_error(wp_context);
break;
default:
break;
}
return false;
}
void wamp_message_processor::process_message(
const std::unique_ptr<wamp_message>& message,
std::unique_ptr<wamp_transport>&& transport,
wamp_connection_base* connection)
{
BONEFISH_TRACE("processing message: %1%", message_type_to_string(message->get_type()));
switch (message->get_type())
{
case wamp_message_type::AUTHENTICATE:
break;
case wamp_message_type::CALL:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_call_message* call_message = static_cast<wamp_call_message*>(message.get());
router->process_call_message(connection->get_session_id(), call_message);
}
break;
}
case wamp_message_type::CANCEL:
break;
case wamp_message_type::ERROR:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_error_message* error_message = static_cast<wamp_error_message*>(message.get());
router->process_error_message(connection->get_session_id(), error_message);
}
break;
}
case wamp_message_type::GOODBYE:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_goodbye_message* goodbye_message = static_cast<wamp_goodbye_message*>(message.get());
router->process_goodbye_message(connection->get_session_id(), goodbye_message);
router->detach_session(connection->get_session_id());
}
connection->clear_data();
break;
}
case wamp_message_type::HELLO:
{
wamp_hello_message* hello_message = static_cast<wamp_hello_message*>(message.get());
std::shared_ptr<wamp_router> router = m_routers->get_router(hello_message->get_realm());
if (!router) {
std::unique_ptr<wamp_abort_message> abort_message(new wamp_abort_message);
abort_message->set_reason("wamp.error.no_such_realm");
transport->send_message(std::move(*abort_message));
} else {
wamp_session_id id;
auto generator = router->get_session_id_generator();
do {
id = generator->generate();
} while(router->has_session(id));
connection->set_session_id(id);
connection->set_realm(hello_message->get_realm());
// We need to setup the sessions roles before attaching the session
// so that we know whether or not to also attach the session to the
// dealer and the broker.
wamp_hello_details hello_details;
hello_details.unmarshal(hello_message->get_details());
auto session = std::make_shared<wamp_session>(
id, hello_message->get_realm(), std::move(transport));
session->set_roles(hello_details.get_roles());
router->attach_session(session);
router->process_hello_message(id, hello_message);
}
break;
}
case wamp_message_type::PUBLISH:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_publish_message* publish_message = static_cast<wamp_publish_message*>(message.get());
router->process_publish_message(connection->get_session_id(), publish_message);
}
break;
}
case wamp_message_type::REGISTER:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_register_message* register_message = static_cast<wamp_register_message*>(message.get());
router->process_register_message(connection->get_session_id(), register_message);
}
break;
}
case wamp_message_type::SUBSCRIBE:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_subscribe_message* subscribe_message = static_cast<wamp_subscribe_message*>(message.get());
router->process_subscribe_message(connection->get_session_id(), subscribe_message);
}
break;
}
case wamp_message_type::UNREGISTER:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_unregister_message* unregister_message = static_cast<wamp_unregister_message*>(message.get());
router->process_unregister_message(connection->get_session_id(), unregister_message);
}
break;
}
case wamp_message_type::UNSUBSCRIBE:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_unsubscribe_message* unsubscribe_message = static_cast<wamp_unsubscribe_message*>(message.get());
router->process_unsubscribe_message(connection->get_session_id(), unsubscribe_message);
}
break;
}
case wamp_message_type::YIELD:
{
std::shared_ptr<wamp_router> router = m_routers->get_router(connection->get_realm());
if (router) {
wamp_yield_message* yield_message = static_cast<wamp_yield_message*>(message.get());
router->process_yield_message(connection->get_session_id(), yield_message);
}
break;
}
default:
break;
}
}
