void udp_socket::bind(udp::endpoint const& ep, error_code& ec) { if (m_ipv4_sock.is_open()) m_ipv4_sock.close(ec); if (m_ipv6_sock.is_open()) m_ipv6_sock.close(ec); if (ep.address().is_v4()) { m_ipv4_sock.open(udp::v4(), ec); if (ec) return; m_ipv4_sock.bind(ep, ec); if (ec) return; m_ipv4_sock.async_receive_from(asio::buffer(m_v4_buf, sizeof(m_v4_buf)) , m_v4_ep, boost::bind(&udp_socket::on_read, this, &m_ipv4_sock, _1, _2)); } else { m_ipv6_sock.set_option(v6only(true), ec); if (ec) return; m_ipv6_sock.bind(ep, ec); if (ec) return; m_ipv6_sock.async_receive_from(asio::buffer(m_v6_buf, sizeof(m_v6_buf)) , m_v6_ep, boost::bind(&udp_socket::on_read, this, &m_ipv6_sock, _1, _2)); } m_bind_port = ep.port(); }
ManagementClient::ManagementClient(ManagementInformationBase& mib, const udp::endpoint& clientEndpoint, u_int8_t wirelessStateUpdateInterval, u_int8_t locationUpdateInterval, Logger& logger) : mib(mib), clientEndpoint(clientEndpoint), logger(logger) { /** * Check that source port is not an ephemeral port which would * change every time a client sendto()s to MGMT */ if (clientEndpoint.port() >= 32768 && clientEndpoint.port() <= 61000) logger.error("Client uses an ephemeral port that will change every time it sends data and this will confuse my state management!"); /** * Initialise state strings map */ clientStateStringMap.insert(std::make_pair(ManagementClient::OFFLINE, "OFFLINE")); clientStateStringMap.insert(std::make_pair(ManagementClient::ONLINE, "ONLINE")); /** * Initialise type strings map */ clientTypeStringMap.insert(std::make_pair(ManagementClient::UNKNOWN, "Unknown")); clientTypeStringMap.insert(std::make_pair(ManagementClient::GN, "GeoNetworking")); clientTypeStringMap.insert(std::make_pair(ManagementClient::FAC, "Facilities")); clientTypeStringMap.insert(std::make_pair(ManagementClient::LTE, "Long Term Evolution")); /** * Initialise this client's state and type */ state = ManagementClient::OFFLINE; type = ManagementClient::UNKNOWN; /** * We are not waiting a reply from this client now */ repliedToTheLastPacket = true; }
void udp_socket::wrap(udp::endpoint const& ep, char const* p, int len, error_code& ec) { CHECK_MAGIC; using namespace libtorrent::detail; char header[20]; char* h = header; write_uint16(0, h); // reserved write_uint8(0, h); // fragment write_uint8(ep.address().is_v4()?1:4, h); // atyp write_address(ep.address(), h); write_uint16(ep.port(), h); boost::array<asio::const_buffer, 2> iovec; iovec[0] = asio::const_buffer(header, h - header); iovec[1] = asio::const_buffer(p, len); #if TORRENT_USE_IPV6 if (m_proxy_addr.address().is_v4() && m_ipv4_sock.is_open()) #endif m_ipv4_sock.send_to(iovec, m_proxy_addr, 0, ec); #if TORRENT_USE_IPV6 else m_ipv6_sock.send_to(iovec, m_proxy_addr, 0, ec); #endif }
string EndpointToString(const udp::endpoint &endpoint) { string strIp = endpoint.address().to_string(); unsigned int dwPort = endpoint.port(); char szIpPort[32] = {0}; sprintf(szIpPort, "%s:%d", strIp.c_str(), dwPort); return szIpPort; }
node_entry(udp::endpoint ep) : addr(ep.address()) , port(ep.port()) , timeout_count(0xffff) , rtt(0xffff) , id(0) { #ifdef TORRENT_DHT_VERBOSE_LOGGING first_seen = time_now(); #endif }
node_entry(node_id const& id_, udp::endpoint ep, int roundtriptime = 0xffff, bool pinged = false) : addr(ep.address()) , port(ep.port()) , timeout_count(pinged ? 0 : 0xffff) , rtt(roundtriptime) , id(id_) { #ifdef TORRENT_DHT_VERBOSE_LOGGING first_seen = time_now(); #endif }
void rpc_manager::invoke(int message_id, udp::endpoint target_addr , observer_ptr o) { INVARIANT_CHECK; if (m_destructing) { o->abort(); return; } msg m; m.message_id = message_id; m.reply = false; m.id = m_our_id; m.addr = target_addr; TORRENT_ASSERT(!m_transactions[m_next_transaction_id]); #ifdef TORRENT_DEBUG int potential_new_id = m_next_transaction_id; #endif #ifndef BOOST_NO_EXCEPTIONS try { #endif m.transaction_id.clear(); std::back_insert_iterator<std::string> out(m.transaction_id); io::write_uint16(m_next_transaction_id, out); o->send(m); o->sent = time_now(); #if TORRENT_USE_IPV6 o->target_addr = target_addr.address(); #else o->target_addr = target_addr.address().to_v4(); #endif o->port = target_addr.port(); #ifdef TORRENT_DHT_VERBOSE_LOGGING TORRENT_LOG(rpc) << "Invoking " << messages::ids[message_id] << " -> " << target_addr; #endif m_send(m); new_transaction_id(o); #ifndef BOOST_NO_EXCEPTIONS } catch (std::exception& e) { // m_send may fail with "no route to host" TORRENT_ASSERT(potential_new_id == m_next_transaction_id); o->abort(); } #endif }
node_entry::node_entry(udp::endpoint ep) : last_queried(min_time()) , id(0) , a(ep.address().to_v4().to_bytes()) , p(ep.port()) , rtt(0xffff) , timeout_count(0xff) { #ifdef TORRENT_DHT_VERBOSE_LOGGING first_seen = aux::time_now(); #endif }
void DatagramTransceiver::sendMessage(const QString &msg, const udp::endpoint& remote_endpoint) { bool write_in_progress = m_write_msgs.empty() == false; MessageToSend* struct_msg = new MessageToSend; struct_msg->destination_endpoint.address(remote_endpoint.address()); struct_msg->destination_endpoint.port(remote_endpoint.port()); struct_msg->msg = msg; m_write_msgs.push_back(struct_msg); if (write_in_progress == false) doSend(); }
node_entry::node_entry(node_id const& id_, udp::endpoint ep , int roundtriptime , bool pinged) : last_queried(pinged ? aux::time_now() : min_time()) , id(id_) , a(ep.address().to_v4().to_bytes()) , p(ep.port()) , rtt(roundtriptime & 0xffff) , timeout_count(pinged ? 0 : 0xff) { #ifdef TORRENT_DHT_VERBOSE_LOGGING first_seen = aux::time_now(); #endif }
void udp_socket::bind(udp::endpoint const& ep, error_code& ec) { CHECK_MAGIC; TORRENT_ASSERT(is_single_thread()); TORRENT_ASSERT(m_abort == false); if (m_abort) { ec = boost::asio::error::operation_aborted; return; } if (m_ipv4_sock.is_open()) m_ipv4_sock.close(ec); #if TORRENT_USE_IPV6 if (m_ipv6_sock.is_open()) m_ipv6_sock.close(ec); #endif if (ep.address().is_v4()) { m_ipv4_sock.open(udp::v4(), ec); if (ec) return; m_ipv4_sock.bind(ep, ec); if (ec) return; udp::socket::non_blocking_io ioc(true); m_ipv4_sock.io_control(ioc, ec); if (ec) return; setup_read(&m_ipv4_sock); } #if TORRENT_USE_IPV6 else { #ifdef IPV6_V6ONLY m_ipv6_sock.set_option(v6only(true), ec); if (ec) return; #endif m_ipv6_sock.bind(ep, ec); if (ec) return; udp::socket::non_blocking_io ioc(true); m_ipv6_sock.io_control(ioc, ec); if (ec) return; setup_read(&m_ipv6_sock); } #endif #ifdef TORRENT_DEBUG m_started = true; #endif m_bind_port = ep.port(); }
void udp_socket::send(udp::endpoint const& ep, char const* p, int len, error_code& ec) { CHECK_MAGIC; TORRENT_ASSERT(is_open()); // if the sockets are closed, the udp_socket is closing too if (!is_open()) return; if (m_tunnel_packets) { // send udp packets through SOCKS5 server wrap(ep, p, len, ec); return; } if (m_queue_packets) { m_queue.push_back(queued_packet()); queued_packet& qp = m_queue.back(); qp.ep = ep; qp.buf.insert(qp.buf.begin(), p, p + len); return; } #if TORRENT_USE_IPV6 if (ep.address().is_v4() && m_ipv4_sock.is_open()) #endif m_ipv4_sock.send_to(asio::buffer(p, len), ep, 0, ec); #if TORRENT_USE_IPV6 else m_ipv6_sock.send_to(asio::buffer(p, len), ep, 0, ec); #endif }
void udp_socket::bind(udp::endpoint const& ep, error_code& ec) { CHECK_MAGIC; mutex_t::scoped_lock l(m_mutex); TORRENT_ASSERT(m_abort == false); if (m_abort) return; if (m_ipv4_sock.is_open()) m_ipv4_sock.close(ec); #if TORRENT_USE_IPV6 if (m_ipv6_sock.is_open()) m_ipv6_sock.close(ec); #endif if (ep.address().is_v4()) { m_ipv4_sock.open(udp::v4(), ec); if (ec) return; m_ipv4_sock.bind(ep, ec); if (ec) return; if (m_v4_outstanding == 0) { ++m_v4_outstanding; m_ipv4_sock.async_receive_from(asio::buffer(m_v4_buf, sizeof(m_v4_buf)) , m_v4_ep, boost::bind(&udp_socket::on_read, this, &m_ipv4_sock, _1, _2)); } } #if TORRENT_USE_IPV6 else { m_ipv6_sock.set_option(v6only(true), ec); if (ec) return; m_ipv6_sock.bind(ep, ec); if (ec) return; if (m_v6_outstanding == 0) { ++m_v6_outstanding; m_ipv6_sock.async_receive_from(asio::buffer(m_v6_buf, sizeof(m_v6_buf)) , m_v6_ep, boost::bind(&udp_socket::on_read, this, &m_ipv6_sock, _1, _2)); } } #endif #ifdef TORRENT_DEBUG m_started = true; #endif m_bind_port = ep.port(); }
void observer::set_target(udp::endpoint const& ep) { m_sent = clock_type::now(); m_port = ep.port(); #if TORRENT_USE_IPV6 if (ep.address().is_v6()) { flags |= flag_ipv6_address; m_addr.v6 = ep.address().to_v6().to_bytes(); } else #endif { flags &= ~flag_ipv6_address; m_addr.v4 = ep.address().to_v4().to_bytes(); } }
impl(udp::endpoint endpoint, Concurrency::ISource<core::monitor::message>& source) : endpoint_(endpoint) , socket_(service_, endpoint_.protocol()) , thread_(std::bind(&boost::asio::io_service::run, &service_)) , on_next_([this](const core::monitor::message& msg){ on_next(msg); }) { source.link_target(&on_next_); }
void dht_tracker::direct_request(udp::endpoint const& ep, entry& e , std::function<void(msg const&)> f) { #if TORRENT_USE_IPV6 if (ep.protocol() == udp::v6()) m_dht6.direct_request(ep, e, f); else #endif m_dht.direct_request(ep, e, f); }
broadcast_socket::broadcast_socket(io_service& ios , udp::endpoint const& multicast_endpoint , receive_handler_t const& handler , bool loopback) : m_multicast_endpoint(multicast_endpoint) , m_on_receive(handler) , m_ip_broadcast(false) { TORRENT_ASSERT(is_multicast(m_multicast_endpoint.address())); using namespace asio::ip::multicast; error_code ec; std::vector<ip_interface> interfaces = enum_net_interfaces(ios, ec); #if TORRENT_USE_IPV6 if (multicast_endpoint.address().is_v6()) open_multicast_socket(ios, address_v6::any(), loopback, ec); else #endif open_multicast_socket(ios, address_v4::any(), loopback, ec); for (std::vector<ip_interface>::const_iterator i = interfaces.begin() , end(interfaces.end()); i != end; ++i) { // only multicast on compatible networks if (i->interface_address.is_v4() != multicast_endpoint.address().is_v4()) continue; // ignore any loopback interface if (!loopback && is_loopback(i->interface_address)) continue; ec = error_code(); open_multicast_socket(ios, i->interface_address, loopback, ec); #ifndef NDEBUG // fprintf(stderr, "broadcast socket [ if: %s group: %s ] %s\n" // , i->interface_address.to_string().c_str() // , print_address(multicast_endpoint.address()).c_str() // , ec.message().c_str()); #endif open_unicast_socket(ios, i->interface_address , i->netmask.is_v4() ? i->netmask.to_v4() : address_v4()); } }
bool CUDPSocket::SendData(udp::endpoint& ep, char* msg, int size, string& errInfo, unsigned long iProxyIp /*= 0*/, unsigned short iProxyPort /*= 0*/) { if(ep.address().to_v4().to_string().empty()) return false; if(ep.address().to_v4().to_string()=="255.255.255.255") return false; if(ep.port() <=0 || ep.port() >65535) return false; if(msg == NULL) return true; try { int ret = this->m_mySocket.send_to(boost::asio::buffer((const void*)msg, size), ep); if (ret < size) { return false; } } catch (const boost::system::error_code& err) { ostringstream oss; oss << "严重错误 CUDPSocket error_code2 " << err.value(); make_log_func_(oss.str()); return false; } catch (...) { ostringstream oss; oss << "严重错误..."; make_log_func_(oss.str()); return false; } return true; }
void observer::set_target(udp::endpoint const& ep) { #ifdef TORRENT_DHT_VERBOSE_LOGGING // use high resolution timers for logging m_sent = time_now_hires(); #else m_sent = time_now(); #endif m_port = ep.port(); #if TORRENT_USE_IPV6 if (ep.address().is_v6()) { flags |= flag_ipv6_address; m_addr.v6 = ep.address().to_v6().to_bytes(); } else #endif { flags &= ~flag_ipv6_address; m_addr.v4 = ep.address().to_v4().to_bytes(); } }
void udp_socket::send(udp::endpoint const& ep, char const* p, int len, error_code& ec) { if (ec == asio::error::operation_aborted) return; if (m_tunnel_packets) { // send udp packets through SOCKS5 server wrap(ep, p, len, ec); return; } if (ep.address().is_v4() && m_ipv4_sock.is_open()) m_ipv4_sock.send_to(asio::buffer(p, len), ep, 0, ec); else m_ipv6_sock.send_to(asio::buffer(p, len), ep, 0, ec); }
//============================================================================== // Handle Connection (uglysolution.com) // - Checks if the connection already exists. If it exists, restart timeout timer. // Else, add new connection. //============================================================================== boost::shared_ptr<Connection> ConnectionHandler::handleConnection( udp::endpoint& _endpoint ) { unsigned int connection_size = m_connections.size(); // Check if the connection already exists for( unsigned int i = 0; i < connection_size; i++ ) { if( m_connections[i]->endpoint.address().to_string().compare(_endpoint.address().to_string()) == 0 && m_connections[i]->endpoint.port() == _endpoint.port() ) { boost::shared_ptr<Connection> connection = m_connections[i]; connection->timout_timer.expires_from_now( boost::posix_time::seconds(TIMEOUT) ); connection->timout_timer.async_wait( boost::bind(&ConnectionHandler::timeout, this, connection, boost::asio::placeholders::error) ); return m_connections[i]; } } // Check if connection size is greater than the allowed amount of connections if( connection_size >= MAX_CONNECTIONS ) return boost::shared_ptr<Connection>(); // Find an connection ID m_id_counter++; for( unsigned int i = 0; i < m_connections.size(); i++ ) { if( m_connections[i]->connection_id == m_id_counter ) { m_id_counter++; i = 0; } } // Add the connection and start the timers boost::shared_ptr<Connection> new_connection( new Connection(m_id_counter, _endpoint, (*m_io_service)) ); new_connection->ack_timer.async_wait( boost::bind(&ConnectionHandler::requestAck, this, new_connection, boost::asio::placeholders::error) ); new_connection->timout_timer.async_wait( boost::bind(&ConnectionHandler::timeout, this, new_connection, boost::asio::placeholders::error) ); m_connections.push_back( new_connection ); // temp solution if( m_network_handler->isServer() ) new_connection->sync_timer.async_wait( boost::bind(&ConnectionHandler::syncClock, this, new_connection, boost::asio::placeholders::error) ); return m_connections.back(); }
static bool resolve_address_udp(io_service &io, int chan, std::string host, unsigned short port, udp::endpoint &ep) { bool result = false; udp::resolver resolver(io); error_code ec; udp::resolver::query query(host, ""); std::for_each(resolver.resolve(query, ec), udp::resolver::iterator(), [&](const udp::endpoint &q_ep) { ep = q_ep; ep.port(port); result = true; logDebug(PFXd "host %s resolved as %s", chan, host.c_str(), to_string_ss(ep).c_str()); }); if (ec) { logWarn(PFXd "resolve error: %s", chan, ec.message().c_str()); result = false; } return result; }
bool dht_tracker::send_packet(entry& e, udp::endpoint const& addr) { static char const version_str[] = {'L', 'T' , LIBTORRENT_VERSION_MAJOR, LIBTORRENT_VERSION_MINOR }; e["v"] = std::string(version_str, version_str + 4); m_send_buf.clear(); bencode(std::back_inserter(m_send_buf), e); // update the quota. We won't prevent the packet to be sent if we exceed // the quota, we'll just (potentially) block the next incoming request. m_send_quota -= int(m_send_buf.size()); error_code ec; m_send_fun(addr, m_send_buf, ec, 0); if (ec) { m_counters.inc_stats_counter(counters::dht_messages_out_dropped); #ifndef TORRENT_DISABLE_LOGGING m_log->log_packet(dht_logger::outgoing_message, m_send_buf, addr); #endif return false; } m_counters.inc_stats_counter(counters::dht_bytes_out, m_send_buf.size()); // account for IP and UDP overhead m_counters.inc_stats_counter(counters::sent_ip_overhead_bytes , addr.address().is_v6() ? 48 : 28); m_counters.inc_stats_counter(counters::dht_messages_out); #ifndef TORRENT_DISABLE_LOGGING m_log->log_packet(dht_logger::outgoing_message, m_send_buf, addr); #endif return true; }
tuple endpoint_to_tuple(udp::endpoint const& ep) { return boost::python::make_tuple(ep.address().to_string(), ep.port()); }
void udp_socket::send(udp::endpoint const& ep, char const* p, int len , error_code& ec, int flags) { CHECK_MAGIC; TORRENT_ASSERT(is_single_thread()); // if the sockets are closed, the udp_socket is closing too if (!is_open()) { ec = error_code(boost::system::errc::bad_file_descriptor, boost::system::generic_category()); return; } if (!(flags & peer_connection) || m_proxy_settings.proxy_peer_connections) { if (m_tunnel_packets) { // send udp packets through SOCKS5 server wrap(ep, p, len, ec); return; } if (m_queue_packets) { if (m_queue.size() > 1000) return; m_queue.push_back(queued_packet()); queued_packet& qp = m_queue.back(); qp.ep = ep; qp.hostname = 0; qp.flags = flags; qp.buf.insert(qp.buf.begin(), p, p + len); return; } } if (m_force_proxy) return; #if TORRENT_USE_IPV6 if (ep.address().is_v6() && m_ipv6_sock.is_open()) m_ipv6_sock.send_to(asio::buffer(p, len), ep, 0, ec); else #endif m_ipv4_sock.send_to(asio::buffer(p, len), ep, 0, ec); if (ec == error::would_block || ec == error::try_again) { #if TORRENT_USE_IPV6 if (ep.address().is_v6() && m_ipv6_sock.is_open()) { if (!m_v6_write_subscribed) { m_ipv6_sock.async_send(asio::null_buffers() , boost::bind(&udp_socket::on_writable, this, _1, &m_ipv6_sock)); m_v6_write_subscribed = true; } } else #endif { if (!m_v4_write_subscribed) { m_ipv4_sock.async_send(asio::null_buffers() , boost::bind(&udp_socket::on_writable, this, _1, &m_ipv4_sock)); m_v4_write_subscribed = true; } } } }
uint64_t endpoint_to_i(const udp::endpoint& ep) { uint64_t addr_i = ep.address().to_v4().to_ulong(); uint32_t port = ep.port(); return (addr_i << 32) + port; }
void upnp::on_reply(udp::endpoint const& from, char* buffer , std::size_t bytes_transferred) { mutex_t::scoped_lock l(m_mutex); using namespace libtorrent::detail; // parse out the url for the device /* the response looks like this: HTTP/1.1 200 OK ST:upnp:rootdevice USN:uuid:000f-66d6-7296000099dc::upnp:rootdevice Location: http://192.168.1.1:5431/dyndev/uuid:000f-66d6-7296000099dc Server: Custom/1.0 UPnP/1.0 Proc/Ver EXT: Cache-Control:max-age=180 DATE: Fri, 02 Jan 1970 08:10:38 GMT a notification looks like this: NOTIFY * HTTP/1.1 Host:239.255.255.250:1900 NT:urn:schemas-upnp-org:device:MediaServer:1 NTS:ssdp:alive Location:http://10.0.3.169:2869/upnphost/udhisapi.dll?content=uuid:c17f0c32-d19b-4938-ae94-65f945c3a26e USN:uuid:c17f0c32-d19b-4938-ae94-65f945c3a26e::urn:schemas-upnp-org:device:MediaServer:1 Cache-Control:max-age=900 Server:Microsoft-Windows-NT/5.1 UPnP/1.0 UPnP-Device-Host/1.0 */ error_code ec; if (!in_local_network(m_io_service, from.address(), ec)) { if (ec) { char msg[200]; snprintf(msg, sizeof(msg), "when receiving response from: %s: %s" , print_endpoint(from).c_str(), ec.message().c_str()); log(msg); } else { char msg[200]; int num_chars = snprintf(msg, sizeof(msg) , "ignoring response from: %s. IP is not on local network. " , print_endpoint(from).c_str()); log(msg); std::vector<ip_interface> net = enum_net_interfaces(m_io_service, ec); for (std::vector<ip_interface>::const_iterator i = net.begin() , end(net.end()); i != end; ++i) { num_chars += snprintf(msg + num_chars, sizeof(msg) - num_chars, "(%s,%s) " , print_address(i->interface_address).c_str(), print_address(i->netmask).c_str()); } log(msg); } return; } if (m_ignore_non_routers) { std::vector<ip_route> routes = enum_routes(m_io_service, ec); if (std::find_if(routes.begin(), routes.end() , bind(&ip_route::gateway, _1) == from.address()) == routes.end()) { // this upnp device is filtered because it's not in the // list of configured routers if (ec) { char msg[200]; snprintf(msg, sizeof(msg), "when receiving response from: %s: %s" , print_endpoint(from).c_str(), ec.message().c_str()); log(msg); } else { char msg[200]; int num_chars = snprintf(msg, sizeof(msg), "ignoring response from: %s: IP is not a router. " , print_endpoint(from).c_str()); for (std::vector<ip_route>::const_iterator i = routes.begin() , end(routes.end()); i != end; ++i) { num_chars += snprintf(msg + num_chars, sizeof(msg) - num_chars, "(%s,%s) " , print_address(i->gateway).c_str(), print_address(i->netmask).c_str()); } log(msg); } return; } } http_parser p; bool error = false; p.incoming(buffer::const_interval(buffer , buffer + bytes_transferred), error); if (error) { char msg[200]; snprintf(msg, sizeof(msg), "received malformed HTTP from: %s" , print_endpoint(from).c_str()); log(msg); return; } if (p.status_code() != 200 && p.method() != "notify") { if (p.method().empty()) { char msg[200]; snprintf(msg, sizeof(msg), "HTTP status %u from %s" , p.status_code(), print_endpoint(from).c_str()); log(msg); } else { char msg[200]; snprintf(msg, sizeof(msg), "HTTP method %s from %s" , p.method().c_str(), print_endpoint(from).c_str()); log(msg); } return; } if (!p.header_finished()) { char msg[200]; snprintf(msg, sizeof(msg), "incomplete HTTP packet from %s" , print_endpoint(from).c_str()); log(msg); return; } std::string url = p.header("location"); if (url.empty()) { char msg[200]; snprintf(msg, sizeof(msg), "missing location header from %s" , print_endpoint(from).c_str()); log(msg); return; } rootdevice d; d.url = url; std::set<rootdevice>::iterator i = m_devices.find(d); if (i == m_devices.end()) { std::string protocol; std::string auth; char const* error; // we don't have this device in our list. Add it boost::tie(protocol, auth, d.hostname, d.port, d.path, error) = parse_url_components(d.url); if (error) { char msg[200]; snprintf(msg, sizeof(msg), "invalid URL %s from %s: %s" , d.url.c_str(), print_endpoint(from).c_str(), error); log(msg); return; } // ignore the auth here. It will be re-parsed // by the http connection later if (protocol != "http") { char msg[200]; snprintf(msg, sizeof(msg), "unsupported protocol %s from %s" , protocol.c_str(), print_endpoint(from).c_str()); log(msg); return; } if (d.port == 0) { char msg[200]; snprintf(msg, sizeof(msg), "URL with port 0 from %s" , print_endpoint(from).c_str()); log(msg); return; } char msg[200]; snprintf(msg, sizeof(msg), "found rootdevice: %s (%d)" , d.url.c_str(), int(m_devices.size())); log(msg); if (m_devices.size() >= 50) { char msg[200]; snprintf(msg, sizeof(msg), "too many rootdevices: (%d). Ignoring %s" , int(m_devices.size()), d.url.c_str()); log(msg); return; } TORRENT_ASSERT(d.mapping.empty()); for (std::vector<global_mapping_t>::iterator j = m_mappings.begin() , end(m_mappings.end()); j != end; ++j) { mapping_t m; m.action = mapping_t::action_add; m.local_port = j->local_port; m.external_port = j->external_port; m.protocol = j->protocol; d.mapping.push_back(m); } boost::tie(i, boost::tuples::ignore) = m_devices.insert(d); } if (!m_devices.empty()) { for (std::set<rootdevice>::iterator i = m_devices.begin() , end(m_devices.end()); i != end; ++i) { if (i->control_url.empty() && !i->upnp_connection && !i->disabled) { // we don't have a WANIP or WANPPP url for this device, // ask for it rootdevice& d = const_cast<rootdevice&>(*i); TORRENT_ASSERT(d.magic == 1337); #ifndef BOOST_NO_EXCEPTIONS try { #endif char msg[200]; snprintf(msg, sizeof(msg), "connecting to: %s" , d.url.c_str()); log(msg); if (d.upnp_connection) d.upnp_connection->close(); d.upnp_connection.reset(new http_connection(m_io_service , m_cc, bind(&upnp::on_upnp_xml, self(), _1, _2 , boost::ref(d), _5))); d.upnp_connection->get(d.url, seconds(30), 1); #ifndef BOOST_NO_EXCEPTIONS } catch (std::exception& e) { (void)e; char msg[200]; snprintf(msg, sizeof(msg), "connection failed to: %s %s" , d.url.c_str(), e.what()); log(msg); d.disabled = true; } #endif } } } }
bool utp_socket_manager::incoming_packet(std::weak_ptr<utp_socket_interface> socket , udp::endpoint const& ep, span<char const> p) { // UTP_LOGV("incoming packet size:%d\n", size); if (p.size() < sizeof(utp_header)) return false; utp_header const* ph = reinterpret_cast<utp_header const*>(p.data()); // UTP_LOGV("incoming packet version:%d\n", int(ph->get_version())); if (ph->get_version() != 1) return false; const time_point receive_time = clock_type::now(); // parse out connection ID and look for existing // connections. If found, forward to the utp_stream. std::uint16_t id = ph->connection_id; // first test to see if it's the same socket as last time // in most cases it is if (m_last_socket && utp_match(m_last_socket, ep, id)) { return utp_incoming_packet(m_last_socket, p, ep, receive_time); } std::pair<socket_map_t::iterator, socket_map_t::iterator> r = m_utp_sockets.equal_range(id); for (; r.first != r.second; ++r.first) { if (!utp_match(r.first->second, ep, id)) continue; bool ret = utp_incoming_packet(r.first->second, p, ep, receive_time); if (ret) m_last_socket = r.first->second; return ret; } // UTP_LOGV("incoming packet id:%d source:%s\n", id, print_endpoint(ep).c_str()); if (!m_sett.get_bool(settings_pack::enable_incoming_utp)) return false; // if not found, see if it's a SYN packet, if it is, // create a new utp_stream if (ph->get_type() == ST_SYN) { // possible SYN flood. Just ignore if (int(m_utp_sockets.size()) > m_sett.get_int(settings_pack::connections_limit) * 2) return false; // UTP_LOGV("not found, new connection id:%d\n", m_new_connection); std::shared_ptr<socket_type> c(new (std::nothrow) socket_type(m_ios)); if (!c) return false; TORRENT_ASSERT(m_new_connection == -1); // create the new socket with this ID m_new_connection = id; instantiate_connection(m_ios, aux::proxy_settings(), *c , m_ssl_context, this, true, false); utp_stream* str = nullptr; #ifdef TORRENT_USE_OPENSSL if (is_ssl(*c)) str = &c->get<ssl_stream<utp_stream>>()->next_layer(); else #endif str = c->get<utp_stream>(); TORRENT_ASSERT(str); int link_mtu, utp_mtu; mtu_for_dest(ep.address(), link_mtu, utp_mtu); utp_init_mtu(str->get_impl(), link_mtu, utp_mtu); utp_init_socket(str->get_impl(), socket); bool ret = utp_incoming_packet(str->get_impl(), p, ep, receive_time); if (!ret) return false; m_cb(c); // the connection most likely changed its connection ID here // we need to move it to the correct ID return true; } if (ph->get_type() == ST_RESET) return false; // #error send reset return false; }
void lsd::on_announce(udp::endpoint const& from, char* buffer , std::size_t bytes_transferred) { using namespace libtorrent::detail; http_parser p; bool error = false; p.incoming(buffer::const_interval(buffer, buffer + bytes_transferred) , error); if (!p.header_finished() || error) { #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING) if (m_log) fprintf(m_log, "%s <== announce: incomplete HTTP message\n", time_now_string()); #endif return; } if (p.method() != "bt-search") { #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING) if (m_log) fprintf(m_log, "%s <== announce: invalid HTTP method: %s\n" , time_now_string(), p.method().c_str()); #endif return; } std::string const& port_str = p.header("port"); if (port_str.empty()) { #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING) if (m_log) fprintf(m_log, "%s <== announce: invalid BT-SEARCH, missing port\n" , time_now_string()); #endif return; } int port = std::atoi(port_str.c_str()); typedef std::multimap<std::string, std::string> headers_t; headers_t const& headers = p.headers(); headers_t::const_iterator cookie_iter = headers.find("cookie"); if (cookie_iter != headers.end()) { // we expect it to be hexadecimal // if it isn't, it's not our cookie anyway boost::int32_t cookie = strtol(cookie_iter->second.c_str(), NULL, 16); if (cookie == m_cookie) { #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING) if (m_log) fprintf(m_log, "%s <== announce: ignoring packet (cookie matched our own): %x == %x\n" , time_now_string(), cookie, m_cookie); #endif return; } } std::pair<headers_t::const_iterator, headers_t::const_iterator> ihs = headers.equal_range("infohash"); for (headers_t::const_iterator i = ihs.first; i != ihs.second; ++i) { std::string const& ih_str = i->second; if (ih_str.size() != 40) { #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING) if (m_log) fprintf(m_log, "%s <== announce: invalid BT-SEARCH, invalid infohash: %s\n" , time_now_string(), ih_str.c_str()); #endif continue; } sha1_hash ih(0); from_hex(ih_str.c_str(), 40, (char*)&ih[0]); if (!ih.is_all_zeros() && port != 0) { #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING) if (m_log) fprintf(m_log, "%s *** incoming local announce %s:%d ih: %s\n" , time_now_string(), print_address(from.address()).c_str() , port, ih_str.c_str()); #endif // we got an announce, pass it on through the callback TORRENT_TRY { m_callback(tcp::endpoint(from.address(), port), ih); } TORRENT_CATCH(std::exception&) {} } } }
inline std::string print_endpoint(udp::endpoint const& ep) { return print_endpoint(tcp::endpoint(ep.address(), ep.port())); }