Slic3r::DnsMessage Struct Reference

Collaboration diagram for Slic3r::DnsMessage:

Public Types
enum	{ MAX_SIZE = 4096 , MAX_ANS = 30 }

Static Public Member Functions
static optional< DnsMessage >	decode (const std::vector< char > &buffer, const Bonjour::TxtKeys &txt_keys)

Public Attributes
DnsHeader	header
optional< DnsQuestion >	question
optional< DnsRR_A >	rr_a
optional< DnsRR_AAAA >	rr_aaaa
std::vector< DnsRR_SRV >	rr_srv
DnsSDMap	sdmap

Private Member Functions
void	parse_rr (const std::vector< char > &buffer, DnsResource &&rr, size_t dataoffset, const Bonjour::TxtKeys &txt_keys)

Detailed Description

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
MAX_SIZE
MAX_ANS

  {
    MAX_SIZE = 4096,
    MAX_ANS = 30,
  };

Member Function Documentation

decode()

static optional< DnsMessage > Slic3r::DnsMessage::decode ( const std::vector< char > &  buffer, const Bonjour::TxtKeys &  txt_keys  )

inlinestatic

  {
    const auto size = buffer.size();
    if (size < DnsHeader::SIZE + DnsQuestion::MIN_SIZE || size > MAX_SIZE) {
      return boost::none;
    }
 
    DnsMessage res;
    res.header = DnsHeader::decode(buffer);
 
    if (res.header.qdcount > 1 || res.header.ancount > MAX_ANS) {
      return boost::none;
    }
 
    size_t offset = DnsHeader::SIZE;
    if (res.header.qdcount == 1) {
      res.question = DnsQuestion::decode(buffer, offset);
    }
 
    for (unsigned i = 0; i < res.header.rrcount(); i++) {
      size_t dataoffset = 0;
      auto rr = DnsResource::decode(buffer, offset, dataoffset);
      if (!rr) {
        return boost::none;
      }
      else {
        res.parse_rr(buffer, std::move(*rr), dataoffset, txt_keys);
      }
    }
 
    return std::move(res);
  }

References Slic3r::DnsHeader::ancount, Slic3r::DnsHeader::decode(), Slic3r::DnsQuestion::decode(), Slic3r::DnsResource::decode(), header, MAX_ANS, MAX_SIZE, Slic3r::offset(), parse_rr(), Slic3r::DnsHeader::qdcount, question, Slic3r::DnsHeader::rrcount(), and Slic3r::DnsHeader::SIZE.

Referenced by Slic3r::LookupSession::handle_receive(), and Slic3r::ResolveSession::handle_receive().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_rr()

void Slic3r::DnsMessage::parse_rr ( const std::vector< char > &  buffer, DnsResource &&  rr, size_t  dataoffset, const Bonjour::TxtKeys &  txt_keys  )

inlineprivate

  {
    switch (rr.type) {
    case DnsRR_A::TAG:
      DnsRR_A::decode(this->rr_a, rr);
      this->rr_a->name = rr.name;
      break;
    case DnsRR_AAAA::TAG:
      DnsRR_AAAA::decode(this->rr_aaaa, rr);
      this->rr_aaaa->name = rr.name;
      break;
    case DnsRR_SRV::TAG: {
      auto srv = DnsRR_SRV::decode(buffer, rr, dataoffset);
      if (srv) { this->sdmap.insert_srv(std::move(rr.name), std::move(*srv)); }
      break;
    }
    case DnsRR_TXT::TAG: {
      auto txt = DnsRR_TXT::decode(rr, txt_keys);
      if (txt) { this->sdmap.insert_txt(std::move(rr.name), std::move(*txt)); }
      break;
    }
    }
  }

References Slic3r::DnsRR_TXT::decode(), Slic3r::DnsRR_SRV::decode(), Slic3r::DnsRR_A::decode(), Slic3r::DnsRR_AAAA::decode(), Slic3r::DnsSDMap::insert_srv(), Slic3r::DnsSDMap::insert_txt(), Slic3r::DnsRR_A::TAG, Slic3r::DnsRR_AAAA::TAG, Slic3r::DnsRR_SRV::TAG, and Slic3r::DnsRR_TXT::TAG.

Referenced by decode().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

header

DnsHeader Slic3r::DnsMessage::header

Referenced by decode(), and Slic3r::operator<<().

question

optional<DnsQuestion> Slic3r::DnsMessage::question

Referenced by decode(), and Slic3r::operator<<().

rr_a

optional<DnsRR_A> Slic3r::DnsMessage::rr_a

Referenced by Slic3r::operator<<().

rr_aaaa

optional<DnsRR_AAAA> Slic3r::DnsMessage::rr_aaaa

Referenced by Slic3r::operator<<().

rr_srv

std::vector<DnsRR_SRV> Slic3r::DnsMessage::rr_srv

sdmap

DnsSDMap Slic3r::DnsMessage::sdmap

Referenced by Slic3r::operator<<().

---

The documentation for this struct was generated from the following file:

• src/slic3r/Utils/Bonjour.cpp