]>
Commit | Line | Data |
---|---|---|
d9d3f9c1 RG |
1 | |
2 | #include "config.h" | |
3 | #include "rec-protobuf.hh" | |
4 | ||
5 | void RecProtoBufMessage::addRR(const DNSRecord& record) | |
6 | { | |
7 | #ifdef HAVE_PROTOBUF | |
8 | PBDNSMessage_DNSResponse* response = d_message.mutable_response(); | |
9 | if (!response) { | |
10 | return; | |
11 | } | |
12 | ||
13 | if (record.d_place != DNSResourceRecord::ANSWER || | |
14 | record.d_class != QClass::IN || | |
15 | (record.d_type != QType::A && | |
16 | record.d_type != QType::AAAA && | |
17 | record.d_type != QType::CNAME)) { | |
18 | return; | |
19 | } | |
20 | ||
21 | PBDNSMessage_DNSResponse_DNSRR* pbRR = response->add_rrs(); | |
22 | if (!pbRR) { | |
23 | return; | |
24 | } | |
25 | ||
26 | pbRR->set_name(record.d_name.toString()); | |
27 | pbRR->set_type(record.d_type); | |
28 | pbRR->set_class_(record.d_class); | |
29 | pbRR->set_ttl(record.d_ttl); | |
30 | if (record.d_type == QType::A) { | |
31 | const ARecordContent& arc = dynamic_cast<const ARecordContent&>(*(record.d_content)); | |
32 | ComboAddress data = arc.getCA(); | |
33 | pbRR->set_rdata(&data.sin4.sin_addr.s_addr, sizeof(data.sin4.sin_addr.s_addr)); | |
34 | } | |
35 | else if (record.d_type == QType::AAAA) { | |
36 | const AAAARecordContent& arc = dynamic_cast<const AAAARecordContent&>(*(record.d_content)); | |
37 | ComboAddress data = arc.getCA(); | |
38 | pbRR->set_rdata(&data.sin6.sin6_addr.s6_addr, sizeof(data.sin6.sin6_addr.s6_addr)); | |
39 | } else if (record.d_type == QType::CNAME) { | |
40 | const CNAMERecordContent& crc = dynamic_cast<const CNAMERecordContent&>(*(record.d_content)); | |
41 | DNSName data = crc.getTarget(); | |
42 | pbRR->set_rdata(data.toString()); | |
43 | } | |
44 | #endif /* HAVE_PROTOBUF */ | |
45 | } | |
46 | ||
47 | void RecProtoBufMessage::addRRs(const std::vector<DNSRecord>& records) | |
48 | { | |
49 | for (const auto& record : records) { | |
50 | addRR(record); | |
51 | } | |
52 | } | |
53 | ||
54 | void RecProtoBufMessage::setAppliedPolicy(const std::string& policy) | |
55 | { | |
56 | #ifdef HAVE_PROTOBUF | |
57 | PBDNSMessage_DNSResponse* response = d_message.mutable_response(); | |
58 | if (response && !policy.empty()) { | |
59 | response->set_appliedpolicy(policy); | |
60 | } | |
61 | #endif /* HAVE_PROTOBUF */ | |
62 | } | |
63 | ||
f3da83fe RG |
64 | void RecProtoBufMessage::setAppliedPolicyType(const DNSFilterEngine::PolicyType& type) |
65 | { | |
66 | #ifdef HAVE_PROTOBUF | |
67 | PBDNSMessage_DNSResponse* response = d_message.mutable_response(); | |
68 | if (response) { | |
69 | switch(type) { | |
70 | case DNSFilterEngine::PolicyType::None: | |
71 | response->set_appliedpolicytype(PBDNSMessage_PolicyType_UNKNOWN); | |
72 | break; | |
73 | case DNSFilterEngine::PolicyType::QName: | |
74 | response->set_appliedpolicytype(PBDNSMessage_PolicyType_QNAME); | |
75 | break; | |
76 | case DNSFilterEngine::PolicyType::ClientIP: | |
77 | response->set_appliedpolicytype(PBDNSMessage_PolicyType_CLIENTIP); | |
78 | break; | |
79 | case DNSFilterEngine::PolicyType::ResponseIP: | |
80 | response->set_appliedpolicytype(PBDNSMessage_PolicyType_RESPONSEIP); | |
81 | break; | |
82 | case DNSFilterEngine::PolicyType::NSDName: | |
83 | response->set_appliedpolicytype(PBDNSMessage_PolicyType_NSDNAME); | |
84 | break; | |
85 | case DNSFilterEngine::PolicyType::NSIP: | |
86 | response->set_appliedpolicytype(PBDNSMessage_PolicyType_NSIP); | |
87 | break; | |
88 | default: | |
89 | throw std::runtime_error("Unsupported protobuf policy type"); | |
90 | } | |
91 | } | |
92 | #endif /* HAVE_PROTOBUF */ | |
93 | } | |
94 | ||
d9d3f9c1 RG |
95 | void RecProtoBufMessage::setPolicyTags(const std::vector<std::string>& policyTags) |
96 | { | |
97 | #ifdef HAVE_PROTOBUF | |
98 | PBDNSMessage_DNSResponse* response = d_message.mutable_response(); | |
99 | if (response) { | |
100 | for (const auto& tag : policyTags) { | |
101 | response->add_tags(tag); | |
102 | } | |
103 | } | |
104 | #endif /* HAVE_PROTOBUF */ | |
105 | } | |
b790ef3d RG |
106 | |
107 | std::string RecProtoBufMessage::getAppliedPolicy() const | |
108 | { | |
109 | std::string result; | |
110 | #ifdef HAVE_PROTOBUF | |
111 | const PBDNSMessage_DNSResponse& response = d_message.response(); | |
112 | result = response.appliedpolicy(); | |
113 | #endif /* HAVE_PROTOBUF */ | |
114 | return result; | |
115 | } | |
116 | ||
117 | std::vector<std::string> RecProtoBufMessage::getPolicyTags() const | |
118 | { | |
119 | std::vector<std::string> result; | |
120 | #ifdef HAVE_PROTOBUF | |
121 | const PBDNSMessage_DNSResponse& response = d_message.response(); | |
122 | const int count = response.tags_size(); | |
123 | for (int idx = 0; idx < count; idx++) { | |
124 | result.push_back(response.tags(idx)); | |
125 | } | |
126 | #endif /* HAVE_PROTOBUF */ | |
127 | return result; | |
128 | } |