Packet.cpp 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Sergey Bugaev <bugaevc@serenityos.org>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include "Packet.h"
  8. #include "Name.h"
  9. #include "PacketHeader.h"
  10. #include <AK/Debug.h>
  11. #include <AK/MemoryStream.h>
  12. #include <AK/StringBuilder.h>
  13. #include <arpa/inet.h>
  14. namespace DNS {
  15. void Packet::add_question(Question const& question)
  16. {
  17. m_questions.empend(question);
  18. VERIFY(m_questions.size() <= UINT16_MAX);
  19. }
  20. void Packet::add_answer(Answer const& answer)
  21. {
  22. m_answers.empend(answer);
  23. VERIFY(m_answers.size() <= UINT16_MAX);
  24. }
  25. ErrorOr<ByteBuffer> Packet::to_byte_buffer() const
  26. {
  27. PacketHeader header;
  28. header.set_id(m_id);
  29. if (is_query())
  30. header.set_is_query();
  31. else
  32. header.set_is_response();
  33. header.set_authoritative_answer(m_authoritative_answer);
  34. // FIXME: What should this be?
  35. header.set_opcode(0);
  36. header.set_response_code(m_code);
  37. header.set_truncated(false); // hopefully...
  38. header.set_recursion_desired(m_recursion_desired);
  39. // FIXME: what should the be for requests?
  40. header.set_recursion_available(m_recursion_available);
  41. header.set_question_count(m_questions.size());
  42. header.set_answer_count(m_answers.size());
  43. AllocatingMemoryStream stream;
  44. TRY(stream.write_value(header));
  45. for (auto& question : m_questions) {
  46. TRY(stream.write_value(question.name()));
  47. TRY(stream.write_value(htons((u16)question.record_type())));
  48. TRY(stream.write_value(htons(question.raw_class_code())));
  49. }
  50. for (auto& answer : m_answers) {
  51. TRY(stream.write_value(answer.name()));
  52. TRY(stream.write_value(htons((u16)answer.type())));
  53. TRY(stream.write_value(htons(answer.raw_class_code())));
  54. TRY(stream.write_value(htonl(answer.ttl())));
  55. if (answer.type() == RecordType::PTR) {
  56. Name name { answer.record_data() };
  57. TRY(stream.write_value(htons(name.serialized_size())));
  58. TRY(stream.write_value(name));
  59. } else {
  60. TRY(stream.write_value(htons(answer.record_data().length())));
  61. TRY(stream.write_until_depleted(answer.record_data().bytes()));
  62. }
  63. }
  64. auto buffer = TRY(ByteBuffer::create_uninitialized(stream.used_buffer_size()));
  65. TRY(stream.read_until_filled(buffer));
  66. return buffer;
  67. }
  68. class [[gnu::packed]] DNSRecordWithoutName {
  69. public:
  70. DNSRecordWithoutName() = default;
  71. u16 type() const { return m_type; }
  72. u16 record_class() const { return m_class; }
  73. u32 ttl() const { return m_ttl; }
  74. u16 data_length() const { return m_data_length; }
  75. void* data() { return this + 1; }
  76. void const* data() const { return this + 1; }
  77. private:
  78. NetworkOrdered<u16> m_type;
  79. NetworkOrdered<u16> m_class;
  80. NetworkOrdered<u32> m_ttl;
  81. NetworkOrdered<u16> m_data_length;
  82. };
  83. static_assert(sizeof(DNSRecordWithoutName) == 10);
  84. Optional<Packet> Packet::from_raw_packet(u8 const* raw_data, size_t raw_size)
  85. {
  86. if (raw_size < sizeof(PacketHeader)) {
  87. dbgln("DNS response not large enough ({} out of {}) to be a DNS packet.", raw_size, sizeof(PacketHeader));
  88. return {};
  89. }
  90. auto& header = *(PacketHeader const*)(raw_data);
  91. dbgln_if(LOOKUPSERVER_DEBUG, "Got packet (ID: {})", header.id());
  92. dbgln_if(LOOKUPSERVER_DEBUG, " Question count: {}", header.question_count());
  93. dbgln_if(LOOKUPSERVER_DEBUG, " Answer count: {}", header.answer_count());
  94. dbgln_if(LOOKUPSERVER_DEBUG, " Authority count: {}", header.authority_count());
  95. dbgln_if(LOOKUPSERVER_DEBUG, "Additional count: {}", header.additional_count());
  96. Packet packet;
  97. packet.m_id = header.id();
  98. packet.m_query_or_response = header.is_response();
  99. packet.m_code = header.response_code();
  100. // FIXME: Should we parse further in this case?
  101. if (packet.code() != Code::NOERROR)
  102. return packet;
  103. size_t offset = sizeof(PacketHeader);
  104. for (u16 i = 0; i < header.question_count(); i++) {
  105. auto name = Name::parse(raw_data, offset, raw_size);
  106. struct RawDNSAnswerQuestion {
  107. NetworkOrdered<u16> record_type;
  108. NetworkOrdered<u16> class_code;
  109. };
  110. auto& record_and_class = *(RawDNSAnswerQuestion const*)&raw_data[offset];
  111. u16 class_code = record_and_class.class_code & ~MDNS_WANTS_UNICAST_RESPONSE;
  112. bool mdns_wants_unicast_response = record_and_class.class_code & MDNS_WANTS_UNICAST_RESPONSE;
  113. packet.m_questions.empend(name, (RecordType)(u16)record_and_class.record_type, (RecordClass)class_code, mdns_wants_unicast_response);
  114. offset += 4;
  115. auto& question = packet.m_questions.last();
  116. dbgln_if(LOOKUPSERVER_DEBUG, "Question #{}: name=_{}_, type={}, class={}", i, question.name(), question.record_type(), question.class_code());
  117. }
  118. for (u16 i = 0; i < header.answer_count(); ++i) {
  119. auto name = Name::parse(raw_data, offset, raw_size);
  120. auto& record = *(DNSRecordWithoutName const*)(&raw_data[offset]);
  121. DeprecatedString data;
  122. offset += sizeof(DNSRecordWithoutName);
  123. switch ((RecordType)record.type()) {
  124. case RecordType::PTR: {
  125. size_t dummy_offset = offset;
  126. data = Name::parse(raw_data, dummy_offset, raw_size).as_string();
  127. break;
  128. }
  129. case RecordType::CNAME:
  130. // Fall through
  131. case RecordType::A:
  132. // Fall through
  133. case RecordType::TXT:
  134. // Fall through
  135. case RecordType::AAAA:
  136. // Fall through
  137. case RecordType::SRV:
  138. data = ReadonlyBytes { record.data(), record.data_length() };
  139. break;
  140. default:
  141. // FIXME: Parse some other record types perhaps?
  142. dbgln("data=(unimplemented record type {})", (u16)record.type());
  143. }
  144. dbgln_if(LOOKUPSERVER_DEBUG, "Answer #{}: name=_{}_, type={}, ttl={}, length={}, data=_{}_", i, name, record.type(), record.ttl(), record.data_length(), data);
  145. u16 class_code = record.record_class() & ~MDNS_CACHE_FLUSH;
  146. bool mdns_cache_flush = record.record_class() & MDNS_CACHE_FLUSH;
  147. packet.m_answers.empend(name, (RecordType)record.type(), (RecordClass)class_code, record.ttl(), data, mdns_cache_flush);
  148. offset += record.data_length();
  149. }
  150. return packet;
  151. }
  152. }