Collaboration diagram for Slic3r::Bonjour::priv:

Public Member Functions
	priv (std::string &&service)
void	lookup_perform ()
void	resolve_perform ()

Public Attributes
const std::string	service
std::string	protocol
std::string	service_dn
TxtKeys	txt_keys
unsigned	timeout
unsigned	retries
std::string	hostname
std::vector< char >	buffer
std::thread	io_thread
Bonjour::ReplyFn	replyfn
Bonjour::CompleteFn	completefn
Bonjour::ResolveFn	resolvefn

Detailed Description

Constructor & Destructor Documentation

◆ priv()

Slic3r::Bonjour::priv::priv ( std::string && service )

  : service(std::move(service))
  , protocol("tcp")
  , timeout(10)
  , retries(1)
{
  buffer.resize(DnsMessage::MAX_SIZE);
}

References buffer, Slic3r::DnsMessage::MAX_SIZE, protocol, retries, service, and timeout.

Member Function Documentation

◆ lookup_perform()

void Slic3r::Bonjour::priv::lookup_perform ( )

{
  service_dn = (boost::format("_%1%._%2%.local") % service % protocol).str();
 
  std::shared_ptr< boost::asio::io_context > io_service(new boost::asio::io_context);
 
  std::vector<LookupSocket*> sockets;
 
  // resolve interfaces - from PR#6646
  std::vector<boost::asio::ip::address> interfaces;
  asio::ip::udp::resolver resolver(*io_service);
  boost::system::error_code ec;
  // ipv4 interfaces
  auto results = resolver.resolve(udp::v4(), asio::ip::host_name(), "", ec);
  if (!ec) {  
    for (const auto & r : results) {
      const auto addr = r.endpoint().address();
      if (addr.is_loopback()) continue;
      interfaces.emplace_back(std::move(addr));
    }
    // create ipv4 socket for each interface
    // each will send to querry to for both ipv4 and ipv6
    for (const auto& intrfc : interfaces)     
      sockets.emplace_back(new LookupSocket(txt_keys, service, service_dn, protocol, replyfn, BonjourRequest::MCAST_IP4, intrfc, io_service));
  } else {
    BOOST_LOG_TRIVIAL(info) << "Failed to resolve ipv4 interfaces: " << ec.message();
  }
  if (sockets.empty())
    sockets.emplace_back(new LookupSocket(txt_keys, service, service_dn, protocol, replyfn, BonjourRequest::MCAST_IP4, io_service));
  // ipv6 interfaces
  interfaces.clear();
  //udp::resolver::query query(host, PORT, boost::asio::ip::resolver_query_base::numeric_service);
  results = resolver.resolve(udp::v6(), asio::ip::host_name(), "", ec);
  if (!ec)
  {
    for (const auto& r : results) {
      const auto addr = r.endpoint().address();
      if (addr.is_loopback()) continue;
      interfaces.emplace_back(std::move(addr));
    }
    // create ipv6 socket for each interface
    // each will send to querry to for both ipv4 and ipv6
    for (const auto& intrfc : interfaces)
      sockets.emplace_back(new LookupSocket(txt_keys, service, service_dn, protocol, replyfn, BonjourRequest::MCAST_IP6, intrfc, io_service));
    if (interfaces.empty())
      sockets.emplace_back(new LookupSocket(txt_keys, service, service_dn, protocol, replyfn, BonjourRequest::MCAST_IP6, io_service));
  } else {
    BOOST_LOG_TRIVIAL(info)<< "Failed to resolve ipv6 interfaces: " << ec.message();
  }
  
  try {
    // send first queries
    for (auto * socket : sockets)
      socket->send();
 
    // timer settings
    asio::steady_timer timer(*io_service);
    retries--;
    std::function<void(const error_code&)> timer_handler = [&](const error_code& error) {
      // end 
      if (retries == 0 || error) {
        // is this correct ending?
        io_service->stop();
        if (completefn) {
          completefn();
        }
      // restart timer
      } else {
        retries--;
        timer.expires_after(std::chrono::seconds(timeout));
        timer.async_wait(timer_handler);
        // trigger another round of queries
        for (auto * socket : sockets)
          socket->send();
      }
    };
    // start timer
    timer.expires_after(std::chrono::seconds(timeout));
    timer.async_wait(timer_handler);
    // start io_service, it will run until it has something to do - so in this case until stop is called in timer
    io_service->run();
  }
  catch (std::exception& e) {
    BOOST_LOG_TRIVIAL(error) << e.what();
  }
}

References completefn, Slic3r::BonjourRequest::MCAST_IP4, Slic3r::BonjourRequest::MCAST_IP6, protocol, replyfn, retries, service, service_dn, timeout, and txt_keys.

◆ resolve_perform()

void Slic3r::Bonjour::priv::resolve_perform ( )

{
  // reply callback is shared to every UDPSession which is called on same thread as io_service->run();
  // thus no need to mutex replies in reply_callback, same should go with the timer
  std::vector<BonjourReply> replies;
  // examples would store [self] to the lambda (and the timer one), is it ok not to do it? (Should be c++03)
  const auto reply_callback = [&rpls = replies](BonjourReply&& reply)
  {
    if (std::find(rpls.begin(), rpls.end(), reply) == rpls.end())
      rpls.push_back(reply);
  };
 
  std::shared_ptr< boost::asio::io_context > io_service(new boost::asio::io_context);
  std::vector<ResolveSocket*> sockets;
 
  // resolve interfaces - from PR#6646
  std::vector<boost::asio::ip::address> interfaces;
  asio::ip::udp::resolver resolver(*io_service);
  boost::system::error_code ec;
  // ipv4 interfaces
  auto results = resolver.resolve(udp::v4(), asio::ip::host_name(), "", ec);
  if (!ec) {
    for (auto const& r : results) {
      auto const addr = r.endpoint().address();
      if (addr.is_loopback()) continue;
      interfaces.emplace_back(addr);
    }
    // create ipv4 socket for each interface
    // each will send to querry to for both ipv4 and ipv6
    for (const auto& intrfc : interfaces)
      sockets.emplace_back(new ResolveSocket(hostname, reply_callback, BonjourRequest::MCAST_IP4, intrfc, io_service));
  } else {
    BOOST_LOG_TRIVIAL(info) << "Failed to resolve ipv4 interfaces: " << ec.message();
  }
  if (sockets.empty())
    sockets.emplace_back(new ResolveSocket(hostname, reply_callback, BonjourRequest::MCAST_IP4, io_service));
 
  // ipv6 interfaces
  interfaces.clear();
  results = resolver.resolve(udp::v6(), asio::ip::host_name(), "", ec);
  if (!ec) {
    for (auto const& r : results) {
      auto const addr = r.endpoint().address();
      if (addr.is_loopback()) continue;
      interfaces.emplace_back(addr);
    }
    // create ipv6 socket for each interface
    // each will send to querry to for both ipv4 and ipv6
    for (const auto& intrfc : interfaces) 
      sockets.emplace_back(new ResolveSocket(hostname, reply_callback, BonjourRequest::MCAST_IP6, intrfc, io_service));
    if (interfaces.empty())
      sockets.emplace_back(new ResolveSocket(hostname, reply_callback, BonjourRequest::MCAST_IP6, io_service));
  } else {
    BOOST_LOG_TRIVIAL(info) << "Failed to resolve ipv6 interfaces: " << ec.message();
  }
 
  try {
    // send first queries
    for (auto * socket : sockets)
      socket->send();
 
    // timer settings
    asio::steady_timer timer(*io_service);
    retries--;
    std::function<void(const error_code&)> timer_handler = [&](const error_code& error) {
      int replies_count = replies.size();
      // end 
      if (retries == 0 || error || replies_count > 0) {
        // is this correct ending?
        io_service->stop();
        if (replies_count > 0 && resolvefn) {
          resolvefn(replies);
        }
      // restart timer
      } else {
        retries--;
        timer.expires_after(std::chrono::seconds(timeout));
        timer.async_wait(timer_handler);
        // trigger another round of queries
        for (auto * socket : sockets)
          socket->send();
      }
    };
    // start timer
    timer.expires_after(std::chrono::seconds(timeout));
    timer.async_wait(timer_handler);
    // start io_service, it will run until it has something to do - so in this case until stop is called in timer
    io_service->run();
  }
  catch (std::exception& e) {
    BOOST_LOG_TRIVIAL(error) << e.what();
  }
}