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; } }