Define mDNS RecordType and ResponseType.
Change-Id: I8516855ac9c9c28ad41aad464a6417b0ba6f138b
Reviewed-on: https://chromium-review.googlesource.com/c/openscreen/+/1761018
Commit-Queue: Max Yakimakha <yakimakha@chromium.org>
Reviewed-by: Peter Thatcher <pthatcher@google.com>
diff --git a/cast/common/mdns/mdns_constants.h b/cast/common/mdns/mdns_constants.h
index 053f70a..192dbf1 100644
--- a/cast/common/mdns/mdns_constants.h
+++ b/cast/common/mdns/mdns_constants.h
@@ -285,44 +285,58 @@
kANY = 255, // Only allowed for QTYPE
};
-// DNS CLASS masks and values.
-constexpr uint16_t kClassMask = 0x7FFF;
-
-// In mDNS the most significant bit of the RRCLASS for response records is
-// designated as the "cache-flush bit", as described in
-// https://tools.ietf.org/html/rfc6762#section-10.2
-constexpr uint16_t kCacheFlushBit = 0x8000;
-// In mDNS the most significant bit of the RRCLASS for query records is
-// designated as the "unicast-response bit", as described in
-// https://tools.ietf.org/html/rfc6762#section-5.4
-constexpr uint16_t kUnicastResponseBit = 0x8000;
-
enum class DnsClass : uint16_t {
kIN = 1,
kANY = 255, // Only allowed for QCLASS
};
+// Unique and shared records are described in
+// https://tools.ietf.org/html/rfc6762#section-2 and
+// https://tools.ietf.org/html/rfc6762#section-10.2
+enum class RecordType {
+ kShared = 0,
+ kUnique = 1,
+};
+
+// Unicast and multicast preferred response types are described in
+// https://tools.ietf.org/html/rfc6762#section-5.4
+enum class ResponseType {
+ kMulticast = 0,
+ kUnicast = 1,
+};
+
+// DNS CLASS masks and values.
+// In mDNS the most significant bit of the RRCLASS for response records is
+// designated as the "cache-flush bit", as described in
+// https://tools.ietf.org/html/rfc6762#section-10.2
+// In mDNS the most significant bit of the RRCLASS for query records is
+// designated as the "unicast-response bit", as described in
+// https://tools.ietf.org/html/rfc6762#section-5.4
+constexpr uint16_t kClassMask = 0x7FFF;
+constexpr uint16_t kClassMsbMask = 0x8000;
+constexpr uint16_t kClassMsbShift = 0xF;
+
constexpr DnsClass GetDnsClass(uint16_t rrclass) {
return static_cast<DnsClass>(rrclass & kClassMask);
}
-constexpr bool GetCacheFlush(uint16_t rrclass) {
- return rrclass & kCacheFlushBit;
+constexpr RecordType GetRecordType(uint16_t rrclass) {
+ return static_cast<RecordType>((rrclass & kClassMsbMask) >> kClassMsbShift);
}
-constexpr bool GetUnicastResponse(uint16_t rrclass) {
- return rrclass & kUnicastResponseBit;
+constexpr ResponseType GetResponseType(uint16_t rrclass) {
+ return static_cast<ResponseType>((rrclass & kClassMsbMask) >> kClassMsbShift);
}
-constexpr uint16_t MakeRecordClass(DnsClass dns_class, bool cache_flush) {
+constexpr uint16_t MakeRecordClass(DnsClass dns_class, RecordType record_type) {
return static_cast<uint16_t>(dns_class) |
- (static_cast<uint16_t>(cache_flush) << 15);
+ (static_cast<uint16_t>(record_type) << kClassMsbShift);
}
constexpr uint16_t MakeQuestionClass(DnsClass dns_class,
- bool unicast_response) {
+ ResponseType response_type) {
return static_cast<uint16_t>(dns_class) |
- (static_cast<uint16_t>(unicast_response) << 15);
+ (static_cast<uint16_t>(response_type) << kClassMsbShift);
}
// See RFC 6762, section 11: https://tools.ietf.org/html/rfc6762#section-11
diff --git a/cast/common/mdns/mdns_reader.cc b/cast/common/mdns/mdns_reader.cc
index 36bc3ed..c91983b 100644
--- a/cast/common/mdns/mdns_reader.cc
+++ b/cast/common/mdns/mdns_reader.cc
@@ -202,7 +202,7 @@
if (Read(&name) && Read(&type) && Read(&rrclass) && Read(&ttl) &&
Read(static_cast<DnsType>(type), &rdata)) {
*out = MdnsRecord(std::move(name), static_cast<DnsType>(type),
- GetDnsClass(rrclass), GetCacheFlush(rrclass), ttl,
+ GetDnsClass(rrclass), GetRecordType(rrclass), ttl,
std::move(rdata));
cursor.Commit();
return true;
@@ -218,7 +218,7 @@
uint16_t rrclass;
if (Read(&name) && Read(&type) && Read(&rrclass)) {
*out = MdnsQuestion(std::move(name), static_cast<DnsType>(type),
- GetDnsClass(rrclass), GetUnicastResponse(rrclass));
+ GetDnsClass(rrclass), GetResponseType(rrclass));
cursor.Commit();
return true;
}
diff --git a/cast/common/mdns/mdns_reader_unittest.cc b/cast/common/mdns/mdns_reader_unittest.cc
index 5fdf4d4..426d75e 100644
--- a/cast/common/mdns/mdns_reader_unittest.cc
+++ b/cast/common/mdns/mdns_reader_unittest.cc
@@ -375,10 +375,10 @@
0x08, 0x08, 0x08, 0x08, // RDATA = 8.8.8.8
};
// clang-format on
- TestReadEntrySucceeds(
- kTestRecord, sizeof(kTestRecord),
- MdnsRecord(DomainName{"testing", "local"}, DnsType::kA, DnsClass::kIN,
- true, 120, ARecordRdata(IPAddress{8, 8, 8, 8})));
+ TestReadEntrySucceeds(kTestRecord, sizeof(kTestRecord),
+ MdnsRecord(DomainName{"testing", "local"}, DnsType::kA,
+ DnsClass::kIN, RecordType::kUnique, 120,
+ ARecordRdata(IPAddress{8, 8, 8, 8})));
}
TEST(MdnsReaderTest, ReadMdnsRecord_UnknownRecordType) {
@@ -400,8 +400,9 @@
TestReadEntrySucceeds(
kTestRecord, sizeof(kTestRecord),
MdnsRecord(DomainName{"testing", "local"},
- static_cast<DnsType>(5) /*CNAME class*/, DnsClass::kIN, true,
- 120, RawRecordRdata(kCnameRdata, sizeof(kCnameRdata))));
+ static_cast<DnsType>(5) /*CNAME class*/, DnsClass::kIN,
+ RecordType::kUnique, 120,
+ RawRecordRdata(kCnameRdata, sizeof(kCnameRdata))));
}
TEST(MdnsReaderTest, ReadMdnsRecord_CompressedNames) {
@@ -434,12 +435,12 @@
EXPECT_TRUE(reader.Read(&record));
EXPECT_EQ(record,
MdnsRecord(DomainName{"testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, false, 120,
+ DnsClass::kIN, RecordType::kShared, 120,
PtrRecordRdata(DomainName{"ptr", "testing", "local"})));
EXPECT_TRUE(reader.Read(&record));
EXPECT_EQ(record, MdnsRecord(DomainName{"one", "two", "testing", "local"},
- DnsType::kA, DnsClass::kIN, true, 120,
- ARecordRdata(IPAddress{8, 8, 8, 8})));
+ DnsType::kA, DnsClass::kIN, RecordType::kUnique,
+ 120, ARecordRdata(IPAddress{8, 8, 8, 8})));
}
TEST(MdnsReaderTest, ReadMdnsRecord_MissingRdata) {
@@ -483,9 +484,10 @@
0x80, 0x01, // CLASS = IN (1) | UNICAST_BIT
};
// clang-format on
- TestReadEntrySucceeds(kTestQuestion, sizeof(kTestQuestion),
- MdnsQuestion(DomainName{"testing", "local"},
- DnsType::kA, DnsClass::kIN, true));
+ TestReadEntrySucceeds(
+ kTestQuestion, sizeof(kTestQuestion),
+ MdnsQuestion(DomainName{"testing", "local"}, DnsType::kA, DnsClass::kIN,
+ ResponseType::kUnicast));
}
TEST(MdnsReaderTest, ReadMdnsQuestion_CompressedNames) {
@@ -508,10 +510,10 @@
MdnsQuestion question;
EXPECT_TRUE(reader.Read(&question));
EXPECT_EQ(question, MdnsQuestion(DomainName{"first", "local"}, DnsType::kA,
- DnsClass::kIN, true));
+ DnsClass::kIN, ResponseType::kUnicast));
EXPECT_TRUE(reader.Read(&question));
EXPECT_EQ(question, MdnsQuestion(DomainName{"second", "local"}, DnsType::kPTR,
- DnsClass::kIN, false));
+ DnsClass::kIN, ResponseType::kMulticast));
EXPECT_EQ(reader.remaining(), UINT64_C(0));
}
@@ -559,10 +561,12 @@
};
// clang-format on
- MdnsRecord record1(DomainName{"record1"}, DnsType::kPTR, DnsClass::kIN, false,
- 120, PtrRecordRdata(DomainName{"testing", "local"}));
- MdnsRecord record2(DomainName{"record2"}, DnsType::kA, DnsClass::kIN, false,
- 120, ARecordRdata(IPAddress{172, 0, 0, 1}));
+ MdnsRecord record1(DomainName{"record1"}, DnsType::kPTR, DnsClass::kIN,
+ RecordType::kShared, 120,
+ PtrRecordRdata(DomainName{"testing", "local"}));
+ MdnsRecord record2(DomainName{"record2"}, DnsType::kA, DnsClass::kIN,
+ RecordType::kShared, 120,
+ ARecordRdata(IPAddress{172, 0, 0, 1}));
MdnsMessage message(1, MessageType::Response, std::vector<MdnsQuestion>{},
std::vector<MdnsRecord>{record1},
std::vector<MdnsRecord>{},
diff --git a/cast/common/mdns/mdns_receiver_unittest.cc b/cast/common/mdns/mdns_receiver_unittest.cc
index 025d70b..ce796dd 100644
--- a/cast/common/mdns/mdns_receiver_unittest.cc
+++ b/cast/common/mdns/mdns_receiver_unittest.cc
@@ -63,7 +63,7 @@
receiver.Start();
MdnsQuestion question(DomainName{"testing", "local"}, DnsType::kA,
- DnsClass::kIN, false);
+ DnsClass::kIN, ResponseType::kMulticast);
MdnsMessage message(1, MessageType::Query);
message.AddQuestion(question);
@@ -121,7 +121,8 @@
receiver.Start();
MdnsRecord record(DomainName{"testing", "local"}, DnsType::kA, DnsClass::kIN,
- false, 120, ARecordRdata(IPAddress{172, 0, 0, 1}));
+ RecordType::kShared, 120,
+ ARecordRdata(IPAddress{172, 0, 0, 1}));
MdnsMessage message(1, MessageType::Response);
message.AddAnswer(record);
diff --git a/cast/common/mdns/mdns_records.cc b/cast/common/mdns/mdns_records.cc
index df85a3a..cb0dfb5 100644
--- a/cast/common/mdns/mdns_records.cc
+++ b/cast/common/mdns/mdns_records.cc
@@ -159,34 +159,34 @@
}
MdnsRecord::MdnsRecord(DomainName name,
- DnsType type,
+ DnsType dns_type,
DnsClass record_class,
- bool cache_flush,
+ RecordType record_type,
uint32_t ttl,
Rdata rdata)
: name_(std::move(name)),
- type_(type),
+ dns_type_(dns_type),
record_class_(record_class),
- cache_flush_(cache_flush),
+ record_type_(record_type),
ttl_(ttl),
rdata_(std::move(rdata)) {
OSP_DCHECK(!name_.empty());
- OSP_DCHECK(
- (type == DnsType::kSRV &&
- absl::holds_alternative<SrvRecordRdata>(rdata_)) ||
- (type == DnsType::kA && absl::holds_alternative<ARecordRdata>(rdata_)) ||
- (type == DnsType::kAAAA &&
- absl::holds_alternative<AAAARecordRdata>(rdata_)) ||
- (type == DnsType::kPTR &&
- absl::holds_alternative<PtrRecordRdata>(rdata_)) ||
- (type == DnsType::kTXT &&
- absl::holds_alternative<TxtRecordRdata>(rdata_)) ||
- absl::holds_alternative<RawRecordRdata>(rdata_));
+ OSP_DCHECK((dns_type == DnsType::kSRV &&
+ absl::holds_alternative<SrvRecordRdata>(rdata_)) ||
+ (dns_type == DnsType::kA &&
+ absl::holds_alternative<ARecordRdata>(rdata_)) ||
+ (dns_type == DnsType::kAAAA &&
+ absl::holds_alternative<AAAARecordRdata>(rdata_)) ||
+ (dns_type == DnsType::kPTR &&
+ absl::holds_alternative<PtrRecordRdata>(rdata_)) ||
+ (dns_type == DnsType::kTXT &&
+ absl::holds_alternative<TxtRecordRdata>(rdata_)) ||
+ absl::holds_alternative<RawRecordRdata>(rdata_));
}
bool MdnsRecord::operator==(const MdnsRecord& rhs) const {
- return type_ == rhs.type_ && record_class_ == rhs.record_class_ &&
- cache_flush_ == rhs.cache_flush_ && ttl_ == rhs.ttl_ &&
+ return dns_type_ == rhs.dns_type_ && record_class_ == rhs.record_class_ &&
+ record_type_ == rhs.record_type_ && ttl_ == rhs.ttl_ &&
name_ == rhs.name_ && rdata_ == rhs.rdata_;
}
@@ -196,24 +196,24 @@
size_t MdnsRecord::MaxWireSize() const {
auto wire_size_visitor = [](auto&& arg) { return arg.MaxWireSize(); };
- return name_.MaxWireSize() + sizeof(type_) + sizeof(record_class_) +
+ return name_.MaxWireSize() + sizeof(dns_type_) + sizeof(record_class_) +
sizeof(ttl_) + absl::visit(wire_size_visitor, rdata_);
}
MdnsQuestion::MdnsQuestion(DomainName name,
- DnsType type,
+ DnsType dns_type,
DnsClass record_class,
- bool unicast_response)
+ ResponseType response_type)
: name_(std::move(name)),
- type_(type),
+ dns_type_(dns_type),
record_class_(record_class),
- unicast_response_(unicast_response) {
+ response_type_(response_type) {
OSP_CHECK(!name_.empty());
}
bool MdnsQuestion::operator==(const MdnsQuestion& rhs) const {
- return type_ == rhs.type_ && record_class_ == rhs.record_class_ &&
- unicast_response_ == rhs.unicast_response_ && name_ == rhs.name_;
+ return dns_type_ == rhs.dns_type_ && record_class_ == rhs.record_class_ &&
+ response_type_ == rhs.response_type_ && name_ == rhs.name_;
}
bool MdnsQuestion::operator!=(const MdnsQuestion& rhs) const {
@@ -221,7 +221,7 @@
}
size_t MdnsQuestion::MaxWireSize() const {
- return name_.MaxWireSize() + sizeof(type_) + sizeof(record_class_);
+ return name_.MaxWireSize() + sizeof(dns_type_) + sizeof(record_class_);
}
MdnsMessage::MdnsMessage(uint16_t id, MessageType type)
diff --git a/cast/common/mdns/mdns_records.h b/cast/common/mdns/mdns_records.h
index 1c8a1a9..f5d4568 100644
--- a/cast/common/mdns/mdns_records.h
+++ b/cast/common/mdns/mdns_records.h
@@ -299,9 +299,9 @@
public:
MdnsRecord() = default;
MdnsRecord(DomainName name,
- DnsType type,
+ DnsType dns_type,
DnsClass record_class,
- bool cache_flush,
+ RecordType record_type,
uint32_t ttl,
Rdata rdata);
MdnsRecord(const MdnsRecord& other) = default;
@@ -316,24 +316,24 @@
size_t MaxWireSize() const;
const DomainName& name() const { return name_; }
- DnsType type() const { return type_; }
+ DnsType dns_type() const { return dns_type_; }
DnsClass record_class() const { return record_class_; }
- bool cache_flush() const { return cache_flush_; }
+ RecordType record_type() const { return record_type_; }
uint32_t ttl() const { return ttl_; }
const Rdata& rdata() const { return rdata_; }
template <typename H>
friend H AbslHashValue(H h, const MdnsRecord& record) {
- return H::combine(std::move(h), record.name_, record.type_,
- record.record_class_, record.cache_flush_, record.ttl_,
+ return H::combine(std::move(h), record.name_, record.dns_type_,
+ record.record_class_, record.record_type_, record.ttl_,
record.rdata_);
}
private:
DomainName name_;
- DnsType type_ = static_cast<DnsType>(0);
+ DnsType dns_type_ = static_cast<DnsType>(0);
DnsClass record_class_ = static_cast<DnsClass>(0);
- bool cache_flush_ = false;
+ RecordType record_type_ = RecordType::kShared;
uint32_t ttl_ = kDefaultRecordTTL;
// Default-constructed Rdata contains default-constructed RawRecordRdata
// as it is the first alternative type and it is default-constructible.
@@ -348,9 +348,9 @@
public:
MdnsQuestion() = default;
MdnsQuestion(DomainName name,
- DnsType type,
+ DnsType dns_type,
DnsClass record_class,
- bool unicast_response);
+ ResponseType response_type);
MdnsQuestion(const MdnsQuestion& other) = default;
MdnsQuestion(MdnsQuestion&& other) noexcept = default;
~MdnsQuestion() = default;
@@ -363,23 +363,23 @@
size_t MaxWireSize() const;
const DomainName& name() const { return name_; }
- DnsType type() const { return type_; }
+ DnsType dns_type() const { return dns_type_; }
DnsClass record_class() const { return record_class_; }
- bool unicast_response() const { return unicast_response_; }
+ ResponseType response_type() const { return response_type_; }
template <typename H>
friend H AbslHashValue(H h, const MdnsQuestion& record) {
- return H::combine(std::move(h), record.name_, record.type_,
- record.record_class_, record.unicast_response_);
+ return H::combine(std::move(h), record.name_, record.dns_type_,
+ record.record_class_, record.response_type_);
}
private:
void CopyFrom(const MdnsQuestion& other);
DomainName name_;
- DnsType type_ = static_cast<DnsType>(0);
+ DnsType dns_type_ = static_cast<DnsType>(0);
DnsClass record_class_ = static_cast<DnsClass>(0);
- bool unicast_response_ = false;
+ ResponseType response_type_ = ResponseType::kMulticast;
};
// Message top level format (http://www.ietf.org/rfc/rfc1035.txt):
diff --git a/cast/common/mdns/mdns_records_unittest.cc b/cast/common/mdns/mdns_records_unittest.cc
index a5cef3b..cd4f25d 100644
--- a/cast/common/mdns/mdns_records_unittest.cc
+++ b/cast/common/mdns/mdns_records_unittest.cc
@@ -285,20 +285,20 @@
MdnsRecord record1;
EXPECT_EQ(record1.MaxWireSize(), UINT64_C(11));
EXPECT_EQ(record1.name(), DomainName());
- EXPECT_EQ(record1.type(), static_cast<DnsType>(0));
+ EXPECT_EQ(record1.dns_type(), static_cast<DnsType>(0));
EXPECT_EQ(record1.record_class(), static_cast<DnsClass>(0));
- EXPECT_EQ(record1.cache_flush(), false);
+ EXPECT_EQ(record1.record_type(), RecordType::kShared);
EXPECT_EQ(record1.ttl(), UINT32_C(255)); // 255 is kDefaultRecordTTL
EXPECT_EQ(record1.rdata(), Rdata(RawRecordRdata()));
MdnsRecord record2(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, true, 120,
+ DnsClass::kIN, RecordType::kUnique, 120,
PtrRecordRdata(DomainName{"testing", "local"}));
EXPECT_EQ(record2.MaxWireSize(), UINT64_C(41));
EXPECT_EQ(record2.name(), (DomainName{"hostname", "local"}));
- EXPECT_EQ(record2.type(), DnsType::kPTR);
+ EXPECT_EQ(record2.dns_type(), DnsType::kPTR);
EXPECT_EQ(record2.record_class(), DnsClass::kIN);
- EXPECT_EQ(record2.cache_flush(), true);
+ EXPECT_EQ(record2.record_type(), RecordType::kUnique);
EXPECT_EQ(record2.ttl(), UINT32_C(120));
EXPECT_EQ(record2.rdata(),
Rdata(PtrRecordRdata(DomainName{"testing", "local"})));
@@ -306,25 +306,25 @@
TEST(MdnsRecordTest, Compare) {
MdnsRecord record1(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, false, 120,
+ DnsClass::kIN, RecordType::kShared, 120,
PtrRecordRdata(DomainName{"testing", "local"}));
MdnsRecord record2(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, false, 120,
+ DnsClass::kIN, RecordType::kShared, 120,
PtrRecordRdata(DomainName{"testing", "local"}));
MdnsRecord record3(DomainName{"othername", "local"}, DnsType::kPTR,
- DnsClass::kIN, false, 120,
+ DnsClass::kIN, RecordType::kShared, 120,
PtrRecordRdata(DomainName{"testing", "local"}));
MdnsRecord record4(DomainName{"hostname", "local"}, DnsType::kA,
- DnsClass::kIN, false, 120,
+ DnsClass::kIN, RecordType::kShared, 120,
ARecordRdata(IPAddress{8, 8, 8, 8}));
MdnsRecord record5(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, true, 120,
+ DnsClass::kIN, RecordType::kUnique, 120,
PtrRecordRdata(DomainName{"testing", "local"}));
MdnsRecord record6(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, false, 200,
+ DnsClass::kIN, RecordType::kShared, 200,
PtrRecordRdata(DomainName{"testing", "local"}));
MdnsRecord record7(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, false, 120,
+ DnsClass::kIN, RecordType::kShared, 120,
PtrRecordRdata(DomainName{"device", "local"}));
EXPECT_EQ(record1, record2);
@@ -337,7 +337,7 @@
TEST(MdnsRecordTest, CopyAndMove) {
MdnsRecord record(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, true, 120,
+ DnsClass::kIN, RecordType::kUnique, 120,
PtrRecordRdata(DomainName{"testing", "local"}));
TestCopyAndMove(record);
}
@@ -346,30 +346,30 @@
MdnsQuestion question1;
EXPECT_EQ(question1.MaxWireSize(), UINT64_C(5));
EXPECT_EQ(question1.name(), DomainName());
- EXPECT_EQ(question1.type(), static_cast<DnsType>(0));
+ EXPECT_EQ(question1.dns_type(), static_cast<DnsType>(0));
EXPECT_EQ(question1.record_class(), static_cast<DnsClass>(0));
- EXPECT_EQ(question1.unicast_response(), false);
+ EXPECT_EQ(question1.response_type(), ResponseType::kMulticast);
MdnsQuestion question2(DomainName{"testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, true);
+ DnsClass::kIN, ResponseType::kUnicast);
EXPECT_EQ(question2.MaxWireSize(), UINT64_C(19));
EXPECT_EQ(question2.name(), (DomainName{"testing", "local"}));
- EXPECT_EQ(question2.type(), DnsType::kPTR);
+ EXPECT_EQ(question2.dns_type(), DnsType::kPTR);
EXPECT_EQ(question2.record_class(), DnsClass::kIN);
- EXPECT_EQ(question2.unicast_response(), true);
+ EXPECT_EQ(question2.response_type(), ResponseType::kUnicast);
}
TEST(MdnsQuestionTest, Compare) {
MdnsQuestion question1(DomainName{"testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, false);
+ DnsClass::kIN, ResponseType::kMulticast);
MdnsQuestion question2(DomainName{"testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, false);
+ DnsClass::kIN, ResponseType::kMulticast);
MdnsQuestion question3(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, false);
+ DnsClass::kIN, ResponseType::kMulticast);
MdnsQuestion question4(DomainName{"testing", "local"}, DnsType::kA,
- DnsClass::kIN, false);
+ DnsClass::kIN, ResponseType::kMulticast);
MdnsQuestion question5(DomainName{"hostname", "local"}, DnsType::kPTR,
- DnsClass::kIN, true);
+ DnsClass::kIN, ResponseType::kUnicast);
EXPECT_EQ(question1, question2);
EXPECT_NE(question1, question3);
@@ -379,7 +379,7 @@
TEST(MdnsQuestionTest, CopyAndMove) {
MdnsQuestion question(DomainName{"testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, true);
+ DnsClass::kIN, ResponseType::kUnicast);
TestCopyAndMove(question);
}
@@ -394,13 +394,16 @@
EXPECT_EQ(message1.additional_records().size(), UINT64_C(0));
MdnsQuestion question(DomainName{"testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, true);
- MdnsRecord record1(DomainName{"record1"}, DnsType::kA, DnsClass::kIN, false,
- 120, ARecordRdata(IPAddress{172, 0, 0, 1}));
- MdnsRecord record2(DomainName{"record2"}, DnsType::kTXT, DnsClass::kIN, false,
- 120, TxtRecordRdata{"foo=1", "bar=2"});
- MdnsRecord record3(DomainName{"record3"}, DnsType::kPTR, DnsClass::kIN, false,
- 120, PtrRecordRdata(DomainName{"device", "local"}));
+ DnsClass::kIN, ResponseType::kUnicast);
+ MdnsRecord record1(DomainName{"record1"}, DnsType::kA, DnsClass::kIN,
+ RecordType::kShared, 120,
+ ARecordRdata(IPAddress{172, 0, 0, 1}));
+ MdnsRecord record2(DomainName{"record2"}, DnsType::kTXT, DnsClass::kIN,
+ RecordType::kShared, 120,
+ TxtRecordRdata{"foo=1", "bar=2"});
+ MdnsRecord record3(DomainName{"record3"}, DnsType::kPTR, DnsClass::kIN,
+ RecordType::kShared, 120,
+ PtrRecordRdata(DomainName{"device", "local"}));
MdnsMessage message2(123, MessageType::Response);
EXPECT_EQ(message2.MaxWireSize(), UINT64_C(12));
@@ -446,13 +449,16 @@
TEST(MdnsMessageTest, Compare) {
MdnsQuestion question(DomainName{"testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, true);
- MdnsRecord record1(DomainName{"record1"}, DnsType::kA, DnsClass::kIN, false,
- 120, ARecordRdata(IPAddress{172, 0, 0, 1}));
- MdnsRecord record2(DomainName{"record2"}, DnsType::kTXT, DnsClass::kIN, false,
- 120, TxtRecordRdata{"foo=1", "bar=2"});
- MdnsRecord record3(DomainName{"record3"}, DnsType::kPTR, DnsClass::kIN, false,
- 120, PtrRecordRdata(DomainName{"device", "local"}));
+ DnsClass::kIN, ResponseType::kUnicast);
+ MdnsRecord record1(DomainName{"record1"}, DnsType::kA, DnsClass::kIN,
+ RecordType::kShared, 120,
+ ARecordRdata(IPAddress{172, 0, 0, 1}));
+ MdnsRecord record2(DomainName{"record2"}, DnsType::kTXT, DnsClass::kIN,
+ RecordType::kShared, 120,
+ TxtRecordRdata{"foo=1", "bar=2"});
+ MdnsRecord record3(DomainName{"record3"}, DnsType::kPTR, DnsClass::kIN,
+ RecordType::kShared, 120,
+ PtrRecordRdata(DomainName{"device", "local"}));
MdnsMessage message1(
123, MessageType::Response, std::vector<MdnsQuestion>{question},
@@ -498,13 +504,16 @@
TEST(MdnsMessageTest, CopyAndMove) {
MdnsQuestion question(DomainName{"testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, true);
- MdnsRecord record1(DomainName{"record1"}, DnsType::kA, DnsClass::kIN, false,
- 120, ARecordRdata(IPAddress{172, 0, 0, 1}));
- MdnsRecord record2(DomainName{"record2"}, DnsType::kTXT, DnsClass::kIN, false,
- 120, TxtRecordRdata{"foo=1", "bar=2"});
- MdnsRecord record3(DomainName{"record3"}, DnsType::kPTR, DnsClass::kIN, false,
- 120, PtrRecordRdata(DomainName{"device", "local"}));
+ DnsClass::kIN, ResponseType::kUnicast);
+ MdnsRecord record1(DomainName{"record1"}, DnsType::kA, DnsClass::kIN,
+ RecordType::kShared, 120,
+ ARecordRdata(IPAddress{172, 0, 0, 1}));
+ MdnsRecord record2(DomainName{"record2"}, DnsType::kTXT, DnsClass::kIN,
+ RecordType::kShared, 120,
+ TxtRecordRdata{"foo=1", "bar=2"});
+ MdnsRecord record3(DomainName{"record3"}, DnsType::kPTR, DnsClass::kIN,
+ RecordType::kShared, 120,
+ PtrRecordRdata(DomainName{"device", "local"}));
MdnsMessage message(
123, MessageType::Response, std::vector<MdnsQuestion>{question},
std::vector<MdnsRecord>{record1}, std::vector<MdnsRecord>{record2},
diff --git a/cast/common/mdns/mdns_sender_unittest.cc b/cast/common/mdns/mdns_sender_unittest.cc
index 294afd4..821ac1f 100644
--- a/cast/common/mdns/mdns_sender_unittest.cc
+++ b/cast/common/mdns/mdns_sender_unittest.cc
@@ -39,11 +39,11 @@
: a_question_(DomainName{"testing", "local"},
DnsType::kA,
DnsClass::kIN,
- false),
+ ResponseType::kMulticast),
a_record_(DomainName{"testing", "local"},
DnsType::kA,
DnsClass::kIN,
- false,
+ RecordType::kShared,
120,
ARecordRdata(IPAddress{172, 0, 0, 1})),
query_message_(1, MessageType::Query),
diff --git a/cast/common/mdns/mdns_writer.cc b/cast/common/mdns/mdns_writer.cc
index 2912ba7..94a190b 100644
--- a/cast/common/mdns/mdns_writer.cc
+++ b/cast/common/mdns/mdns_writer.cc
@@ -204,8 +204,8 @@
bool MdnsWriter::Write(const MdnsRecord& record) {
Cursor cursor(this);
- if (Write(record.name()) && Write(static_cast<uint16_t>(record.type())) &&
- Write(MakeRecordClass(record.record_class(), record.cache_flush())) &&
+ if (Write(record.name()) && Write(static_cast<uint16_t>(record.dns_type())) &&
+ Write(MakeRecordClass(record.record_class(), record.record_type())) &&
Write(record.ttl()) && Write(record.rdata())) {
cursor.Commit();
return true;
@@ -215,9 +215,10 @@
bool MdnsWriter::Write(const MdnsQuestion& question) {
Cursor cursor(this);
- if (Write(question.name()) && Write(static_cast<uint16_t>(question.type())) &&
+ if (Write(question.name()) &&
+ Write(static_cast<uint16_t>(question.dns_type())) &&
Write(MakeQuestionClass(question.record_class(),
- question.unicast_response()))) {
+ question.response_type()))) {
cursor.Commit();
return true;
}
diff --git a/cast/common/mdns/mdns_writer_unittest.cc b/cast/common/mdns/mdns_writer_unittest.cc
index a7bf676..c1f12b4 100644
--- a/cast/common/mdns/mdns_writer_unittest.cc
+++ b/cast/common/mdns/mdns_writer_unittest.cc
@@ -306,10 +306,10 @@
0xac, 0x00, 0x00, 0x01, // 172.0.0.1
};
// clang-format on
- TestWriteEntrySucceeds(
- MdnsRecord(DomainName{"testing", "local"}, DnsType::kA, DnsClass::kIN,
- true, 120, ARecordRdata(IPAddress{172, 0, 0, 1})),
- kExpectedResult, sizeof(kExpectedResult));
+ TestWriteEntrySucceeds(MdnsRecord(DomainName{"testing", "local"}, DnsType::kA,
+ DnsClass::kIN, RecordType::kUnique, 120,
+ ARecordRdata(IPAddress{172, 0, 0, 1})),
+ kExpectedResult, sizeof(kExpectedResult));
}
TEST(MdnsWriterTest, WriteMdnsRecord_PtrRecordRdata) {
@@ -328,15 +328,15 @@
// clang-format on
TestWriteEntrySucceeds(
MdnsRecord(DomainName{"_service", "testing", "local"}, DnsType::kPTR,
- DnsClass::kIN, false, 120,
+ DnsClass::kIN, RecordType::kShared, 120,
PtrRecordRdata(DomainName{"testing", "local"})),
kExpectedResult, sizeof(kExpectedResult));
}
TEST(MdnsWriterTest, WriteMdnsRecord_InsufficientBuffer) {
- TestWriteEntryInsufficientBuffer(
- MdnsRecord(DomainName{"testing", "local"}, DnsType::kA, DnsClass::kIN,
- true, 120, ARecordRdata(IPAddress{172, 0, 0, 1})));
+ TestWriteEntryInsufficientBuffer(MdnsRecord(
+ DomainName{"testing", "local"}, DnsType::kA, DnsClass::kIN,
+ RecordType::kUnique, 120, ARecordRdata(IPAddress{172, 0, 0, 1})));
}
TEST(MdnsWriterTest, WriteMdnsQuestion) {
@@ -350,15 +350,16 @@
0x80, 0x01, // CLASS = IN (1) | UNICAST_BIT
};
// clang-format on
- TestWriteEntrySucceeds(MdnsQuestion(DomainName{"wire", "format", "local"},
- DnsType::kPTR, DnsClass::kIN, true),
- kExpectedResult, sizeof(kExpectedResult));
+ TestWriteEntrySucceeds(
+ MdnsQuestion(DomainName{"wire", "format", "local"}, DnsType::kPTR,
+ DnsClass::kIN, ResponseType::kUnicast),
+ kExpectedResult, sizeof(kExpectedResult));
}
TEST(MdnsWriterTest, WriteMdnsQuestion_InsufficientBuffer) {
TestWriteEntryInsufficientBuffer(
MdnsQuestion(DomainName{"wire", "format", "local"}, DnsType::kPTR,
- DnsClass::kIN, true));
+ DnsClass::kIN, ResponseType::kUnicast));
}
TEST(MdnsWriterTest, WriteMdnsMessage) {
@@ -387,10 +388,11 @@
};
// clang-format on
MdnsQuestion question(DomainName{"question"}, DnsType::kPTR, DnsClass::kIN,
- false);
+ ResponseType::kMulticast);
MdnsRecord auth_record(DomainName{"auth"}, DnsType::kTXT, DnsClass::kIN,
- false, 120, TxtRecordRdata{"foo=1", "bar=2"});
+ RecordType::kShared, 120,
+ TxtRecordRdata{"foo=1", "bar=2"});
MdnsMessage message(1, MessageType::Query);
message.AddQuestion(question);
@@ -405,10 +407,11 @@
TEST(MdnsWriterTest, WriteMdnsMessage_InsufficientBuffer) {
MdnsQuestion question(DomainName{"question"}, DnsType::kPTR, DnsClass::kIN,
- false);
+ ResponseType::kMulticast);
- MdnsRecord auth_record(DomainName{"auth"}, DnsType::kTXT, DnsClass::kIN, 120,
- false, TxtRecordRdata{"foo=1", "bar=2"});
+ MdnsRecord auth_record(DomainName{"auth"}, DnsType::kTXT, DnsClass::kIN,
+ RecordType::kShared, 120,
+ TxtRecordRdata{"foo=1", "bar=2"});
MdnsMessage message(1, MessageType::Query);
message.AddQuestion(question);
