void DirectIP::OnKeyDown(const ::SDL_KeyboardEvent& key) { switch(key.keysym.sym) { case SDLK_UP: if(!addr.empty()) SetNextActivity(new Fade(new Game(true, addr, connection_ptr()), world, eye), true); break; case SDLK_DOWN: if(!addr.empty()) SetNextActivity(new Fade(new Game(false, addr, connection_ptr()), world, eye), true); break; case SDLK_ESCAPE: SetNextActivity(new Fade(new Menu, world, eye), true); break; default: break; } // Hantera input, sortera bort oönskade tecken. HandleInput(key, addr); addr = StripCharacters(addr, "abcdefghijklmnopqrstuvwxyz,!?+-:/ ="); if(addr.size() >= max_addr_len) addr = addr.substr(0, max_addr_len); world[0] = object_ptr(new Text(addr, Letter(Size(0.05,0.07,0.0), 0.03, 2.5, Color(0,0,0)), Point(2.4, 2, 1+MILLI), Size(1.3, 0.2,0), Color(0.3,0.3,0.3), Rotation(), false)); }
connection_ptr Engine::get_connection(int fd) { boost::mutex::scoped_lock lock(connection_mutex); connection_map::iterator it = connections.find(fd); if (it == connections.end()) return connection_ptr(); return it->second; }
void mltds_ct_con_finalize(value connection) { CS_CONNECTION* conn = connection_ptr(connection); ct_close(conn, CS_FORCE_CLOSE); ct_con_drop(conn); }
void on_close(connection_ptr con) { m_con = connection_ptr(); con->stop_heartbeat(); con->alog().at(log::alevel::DEVEL)<<"client was disconnected sid "<< con->m_endpoint.m_strSid <<log::endl; }
typename endpoint<connection,config>::connection_ptr endpoint<connection,config>::create_connection() { m_alog.write(log::alevel::devel,"create_connection"); //scoped_lock_type lock(m_state_lock); /*if (m_state == STOPPING || m_state == STOPPED) { return connection_ptr(); }*/ //scoped_lock_type guard(m_mutex); // Create a connection on the heap and manage it using a shared pointer connection_ptr con = lib::make_shared<connection_type>(m_is_server, m_user_agent, lib::ref(m_alog), lib::ref(m_elog), lib::ref(m_rng)); connection_weak_ptr w(con); // Create a weak pointer on the heap using that shared_ptr. // Cast that weak pointer to void* and manage it using another shared_ptr // connection_hdl hdl(reinterpret_cast<void*>(new connection_weak_ptr(con))); con->set_handle(w); // Copy default handlers from the endpoint con->set_open_handler(m_open_handler); con->set_close_handler(m_close_handler); con->set_fail_handler(m_fail_handler); con->set_ping_handler(m_ping_handler); con->set_pong_handler(m_pong_handler); con->set_pong_timeout_handler(m_pong_timeout_handler); con->set_interrupt_handler(m_interrupt_handler); con->set_http_handler(m_http_handler); con->set_validate_handler(m_validate_handler); con->set_message_handler(m_message_handler); if (m_open_handshake_timeout_dur != config::timeout_open_handshake) { con->set_open_handshake_timeout(m_open_handshake_timeout_dur); } if (m_close_handshake_timeout_dur != config::timeout_close_handshake) { con->set_close_handshake_timeout(m_close_handshake_timeout_dur); } if (m_pong_timeout_dur != config::timeout_pong) { con->set_pong_timeout(m_pong_timeout_dur); } if (m_max_message_size != config::max_message_size) { con->set_max_message_size(m_max_message_size); } con->set_max_http_body_size(m_max_http_body_size); lib::error_code ec; ec = transport_type::init(con); if (ec) { m_elog.write(log::elevel::fatal,ec.message()); return connection_ptr(); } return con; }
connection_ptr ConnectionManager::Find(const sock_t sockfd) { map<sock_t, connection_ptr>::iterator iter = m_connection_map.find(sockfd); if(iter == m_connection_map.end()) return connection_ptr(); return iter->second; }
typename endpoint<connection,config>::connection_ptr endpoint<connection,config>::create_connection() { m_alog.write(log::alevel::devel,"create_connection"); //scoped_lock_type lock(m_state_lock); /*if (m_state == STOPPING || m_state == STOPPED) { return connection_ptr(); }*/ // Create a connection on the heap and manage it using a shared pointer connection_ptr con(new connection_type(m_is_server,m_user_agent,m_alog, m_elog, m_rng)); connection_weak_ptr w(con); // Create a weak pointer on the heap using that shared_ptr. // Cast that weak pointer to void* and manage it using another shared_ptr // connection_hdl hdl(reinterpret_cast<void*>(new connection_weak_ptr(con))); // con->set_handle(hdl); // con->set_handle(w); // Copy default handlers from the endpoint con->set_open_handler(m_open_handler); con->set_close_handler(m_close_handler); con->set_fail_handler(m_fail_handler); con->set_ping_handler(m_ping_handler); con->set_pong_handler(m_pong_handler); con->set_pong_timeout_handler(m_pong_timeout_handler); con->set_interrupt_handler(m_interrupt_handler); con->set_http_handler(m_http_handler); con->set_validate_handler(m_validate_handler); con->set_message_handler(m_message_handler); con->set_termination_handler( lib::bind( &type::remove_connection, this, lib::placeholders::_1 ) ); lib::error_code ec; ec = transport_type::init(con); if (ec) { m_elog.write(log::elevel::fatal,ec.message()); return connection_ptr(); } scoped_lock_type lock(m_mutex); m_connections.insert(con); return con; }
connection_ptr Engine::open_connection(std::string host, int port) { std::string port_str = boost::lexical_cast<std::string>(port); int fd = SocketUtils::socket_connection_new(host.c_str(), port_str.c_str(), 0); if (fd < 0) return connection_ptr(); SocketUtils::make_socket_non_blocking(fd); connection_ptr conn = add_connection(fd); return conn; }
CAMLprim value mltds_ct_connect(value connection, value servername) { CAMLparam2(connection, servername); retval_inspect( "ct_connect", ct_connect(connection_ptr(connection), String_val(servername), string_length(servername))); CAMLreturn(Val_unit); }
/* Since only one option is meaningful, simplify to a bool */ CAMLprim value mltds_ct_close( value conn, value force ) { CAMLparam2(conn, force); CS_INT option = CS_UNUSED; if ( Bool_val(force) ) option = CS_FORCE_CLOSE; retval_inspect( "ct_close", ct_close(connection_ptr(conn), option) ); CAMLreturn(Val_unit); }
acceptor::acceptor( boost::asio::io_service& IOservice, const std::string& host, unsigned short port, unsigned maxConnections, const net::LocalEndpointConfig& localEndpointConfig_, const types::AddressRestriction& addressRestriction_, GlobalConnectionList& globalList, _Wolframe::ServerHandler& srvHandler ) : m_IOservice( IOservice ), m_strand( m_IOservice ), m_acceptor( m_IOservice ), m_connList( maxConnections, globalList ), m_localEndpointConfig( localEndpointConfig_ ), m_addressRestriction( addressRestriction_ ), m_srvHandler( srvHandler ) { // Open the acceptor(s) with the option to reuse the address (i.e. SO_REUSEADDR). boost::asio::ip::tcp::endpoint endpoint; try { boost::asio::ip::tcp::resolver resolver( m_IOservice ); boost::asio::ip::tcp::resolver::query query( host, "7661" ); endpoint = *resolver.resolve( query ); } catch ( std::exception& e ) { LOG_FATAL << "Unable to resolve host '" << host << "' (" << e.what() << ")"; exit( ErrorCode::FAILURE ); } endpoint.port( port ); LocalEndpointR local( new LocalTCPendpoint( host, port, m_localEndpointConfig)); ConnectionHandler *handler = m_srvHandler.newConnection( local); m_newConnection = connection_ptr( new connection( m_IOservice, &m_connList, handler )); try { m_acceptor.open( endpoint.protocol() ); m_acceptor.set_option( boost::asio::ip::tcp::acceptor::reuse_address( true )); m_acceptor.bind( endpoint ); m_acceptor.listen(); } catch ( std::exception& e ) { LOG_FATAL << "Unable to listen on " << endpoint << " (" << e.what() << ")"; exit( ErrorCode::FAILURE ); } m_identifier = m_acceptor.local_endpoint().address().to_string() + ":" + boost::lexical_cast<std::string>( m_acceptor.local_endpoint().port() ); m_acceptor.async_accept( m_newConnection->socket(), m_strand.wrap( boost::bind( &acceptor::handleAccept, this, boost::asio::placeholders::error ))); LOG_INFO << "Accepting connections on " << m_identifier; }
CAMLprim value mltds_ct_con_setstring(value conn, value field, value newval) { CAMLparam3(conn, field, newval); retval_inspect( "ct_con_props", ct_con_props(connection_ptr(conn), CS_SET, conprop_of_value(field), String_val(newval), string_length(newval), NULL)); CAMLreturn(Val_unit); }
CAMLprim value mltds_ct_cmd_alloc(value conn) { CAMLparam1(conn); CS_COMMAND* command; CAMLlocal1(result); retval_inspect( "ct_cmd_alloc", ct_cmd_alloc(connection_ptr(conn), &command) ); result = alloc_custom(&command_operations, sizeof(CS_COMMAND*), 0, 1); command_ptr(result) = command; CAMLreturn(result); }
CAMLprim value mltds_ct_con_alloc(value context) { CAMLparam1(context); CS_CONNECTION* conn; CAMLlocal1(result); retval_inspect( "ct_con_alloc", ct_con_alloc(context_ptr(context), &conn) ); retval_inspect( "ct_diag", ct_diag(conn, CS_INIT, CS_UNUSED, CS_UNUSED, NULL) ); result = alloc_custom(&connection_operations, sizeof(CS_CONNECTION*), 0, 1); connection_ptr(result) = conn; CAMLreturn(result); }
connection_ptr Engine::add_connection(int fd) { int s; struct epoll_event event; event.data.fd = fd; event.events = EPOLLIN | EPOLLET; s = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event); if (s == -1) { DLOG(ERROR) << "Error in epoll_ctl"; return connection_ptr(); } connection_ptr conn = boost::make_shared<Connection>(fd); conn->me = conn; connection_mutex.lock(); connections[fd] = conn; connection_mutex.unlock(); return conn; }
CAMLexport value mltds_add_messages_client(value vconnection, value vlist) { CAMLparam2(vconnection, vlist); CS_CONNECTION* conn = connection_ptr(vconnection); CS_INT msgcount; CS_INT msgno; retval_inspect( "ct_diag", ct_diag(conn, CS_STATUS, CS_CLIENTMSG_TYPE, CS_UNUSED, &msgcount)); for(msgno = msgcount; msgno > 0; msgno--) vlist = cons(get_client_message(conn, msgno), vlist); retval_inspect( "ct_diag", ct_diag(conn, CS_CLEAR, CS_CLIENTMSG_TYPE, CS_UNUSED, NULL)); CAMLreturn(vlist); }