]>
git.ipfire.org Git - thirdparty/pdns.git/blob - pdns/lua-base4.cc
2 #include <unordered_set>
3 #include <unordered_map>
8 #include "dnsparser.hh"
9 #include "dnspacket.hh"
10 #include "namespaces.hh"
11 #include "ednssubnet.hh"
12 #include "lua-base4.hh"
14 BaseLua4::BaseLua4() {
17 void BaseLua4::loadFile(const std::string
&fname
) {
18 std::ifstream
ifs(fname
);
20 theL()<<Logger::Error
<<"Unable to read configuration file from '"<<fname
<<"': "<<strerror(errno
)<<endl
;
26 void BaseLua4::loadString(const std::string
&script
) {
27 std::istringstream
iss(script
);
31 #if !defined(HAVE_LUA)
33 void BaseLua4::prepareContext() { return; }
34 void BaseLua4::loadStream(std::istream
&is
) { return; }
35 BaseLua4::~BaseLua4() { }
40 #include "ext/luawrapper/include/LuaContext.hpp"
42 void BaseLua4::prepareContext() {
43 d_lw
= std::unique_ptr
<LuaContext
>(new LuaContext
);
46 d_lw
->registerFunction
<int(dnsheader::*)()>("getID", [](dnsheader
& dh
) { return dh
.id
; });
47 d_lw
->registerFunction
<bool(dnsheader::*)()>("getCD", [](dnsheader
& dh
) { return dh
.cd
; });
48 d_lw
->registerFunction
<bool(dnsheader::*)()>("getTC", [](dnsheader
& dh
) { return dh
.tc
; });
49 d_lw
->registerFunction
<bool(dnsheader::*)()>("getRA", [](dnsheader
& dh
) { return dh
.ra
; });
50 d_lw
->registerFunction
<bool(dnsheader::*)()>("getAD", [](dnsheader
& dh
) { return dh
.ad
; });
51 d_lw
->registerFunction
<bool(dnsheader::*)()>("getAA", [](dnsheader
& dh
) { return dh
.aa
; });
52 d_lw
->registerFunction
<bool(dnsheader::*)()>("getRD", [](dnsheader
& dh
) { return dh
.rd
; });
53 d_lw
->registerFunction
<int(dnsheader::*)()>("getRCODE", [](dnsheader
& dh
) { return dh
.rcode
; });
54 d_lw
->registerFunction
<int(dnsheader::*)()>("getOPCODE", [](dnsheader
& dh
) { return dh
.opcode
; });
55 d_lw
->registerFunction
<int(dnsheader::*)()>("getQDCOUNT", [](dnsheader
& dh
) { return ntohs(dh
.qdcount
); });
56 d_lw
->registerFunction
<int(dnsheader::*)()>("getANCOUNT", [](dnsheader
& dh
) { return ntohs(dh
.ancount
); });
57 d_lw
->registerFunction
<int(dnsheader::*)()>("getNSCOUNT", [](dnsheader
& dh
) { return ntohs(dh
.nscount
); });
58 d_lw
->registerFunction
<int(dnsheader::*)()>("getARCOUNT", [](dnsheader
& dh
) { return ntohs(dh
.arcount
); });
61 d_lw
->writeFunction("newDN", [](const std::string
& dom
){ return DNSName(dom
); });
62 d_lw
->registerFunction("isPartOf", &DNSName::isPartOf
);
63 d_lw
->registerFunction
<unsigned int(DNSName::*)()>("countLabels", [](const DNSName
& name
) { return name
.countLabels(); });
64 d_lw
->registerFunction
<size_t(DNSName::*)()>("wirelength", [](const DNSName
& name
) { return name
.wirelength(); });
65 d_lw
->registerFunction
<bool(DNSName::*)(const std::string
&)>("equal", [](const DNSName
& lhs
, const std::string
& rhs
) { return lhs
==DNSName(rhs
); });
66 d_lw
->registerEqFunction(&DNSName::operator==);
68 d_lw
->registerToStringFunction
<string(DNSName::*)()>([](const DNSName
&dn
) { return dn
.toString(); });
69 d_lw
->registerFunction
<string(DNSName::*)()>("toString", [](const DNSName
&dn
) { return dn
.toString(); });
70 d_lw
->registerFunction
<string(DNSName::*)()>("toStringNoDot", [](const DNSName
&dn
) { return dn
.toStringNoDot(); });
71 d_lw
->registerFunction
<bool(DNSName::*)()>("chopOff", [](DNSName
&dn
) { return dn
.chopOff(); });
74 d_lw
->registerEqFunction(&DNSResourceRecord::operator==);
75 d_lw
->registerFunction("__lt", &DNSResourceRecord::operator<);
76 d_lw
->registerFunction
<string(DNSResourceRecord::*)()>("toString", [](const DNSResourceRecord
& rec
) { return rec
.getZoneRepresentation();} );
77 d_lw
->registerFunction
<DNSName(DNSResourceRecord::*)()>("qname", [](DNSResourceRecord
& rec
) { return rec
.qname
; });
78 d_lw
->registerFunction
<DNSName(DNSResourceRecord::*)()>("wildcardname", [](DNSResourceRecord
& rec
) { return rec
.wildcardname
; });
79 d_lw
->registerFunction
<string(DNSResourceRecord::*)()>("content", [](DNSResourceRecord
& rec
) { return rec
.content
; });
80 d_lw
->registerFunction
<time_t(DNSResourceRecord::*)()>("last_modified", [](DNSResourceRecord
& rec
) { return rec
.last_modified
; });
81 d_lw
->registerFunction
<uint32_t(DNSResourceRecord::*)()>("ttl", [](DNSResourceRecord
& rec
) { return rec
.ttl
; });
82 d_lw
->registerFunction
<uint32_t(DNSResourceRecord::*)()>("signttl", [](DNSResourceRecord
& rec
) { return rec
.signttl
; });
83 d_lw
->registerFunction
<int(DNSResourceRecord::*)()>("domain_id", [](DNSResourceRecord
& rec
) { return rec
.domain_id
; });
84 d_lw
->registerFunction
<uint16_t(DNSResourceRecord::*)()>("qtype", [](DNSResourceRecord
& rec
) { return rec
.qtype
.getCode(); });
85 d_lw
->registerFunction
<uint16_t(DNSResourceRecord::*)()>("qclass", [](DNSResourceRecord
& rec
) { return rec
.qclass
; });
86 d_lw
->registerFunction
<uint8_t(DNSResourceRecord::*)()>("scopeMask", [](DNSResourceRecord
& rec
) { return rec
.scopeMask
; });
87 d_lw
->registerFunction
<bool(DNSResourceRecord::*)()>("auth", [](DNSResourceRecord
& rec
) { return rec
.auth
; });
88 d_lw
->registerFunction
<bool(DNSResourceRecord::*)()>("disabled", [](DNSResourceRecord
& rec
) { return rec
.disabled
; });
91 d_lw
->registerFunction
<bool(ComboAddress::*)()>("isIPv4", [](const ComboAddress
& ca
) { return ca
.sin4
.sin_family
== AF_INET
; });
92 d_lw
->registerFunction
<bool(ComboAddress::*)()>("isIPv6", [](const ComboAddress
& ca
) { return ca
.sin4
.sin_family
== AF_INET6
; });
93 d_lw
->registerFunction
<bool(ComboAddress::*)()>("isMappedIPv4", [](const ComboAddress
& ca
) { return ca
.isMappedIPv4(); });
94 d_lw
->registerFunction
<ComboAddress(ComboAddress::*)()>("mapToIPv4", [](const ComboAddress
& ca
) { return ca
.mapToIPv4(); });
95 d_lw
->registerFunction
<void(ComboAddress::*)(unsigned int)>("truncate", [](ComboAddress
& ca
, unsigned int bits
) { ca
.truncate(bits
); });
96 d_lw
->registerFunction
<string(ComboAddress::*)()>("toString", [](const ComboAddress
& ca
) { return ca
.toString(); });
97 d_lw
->registerToStringFunction
<string(ComboAddress::*)()>([](const ComboAddress
& ca
) { return ca
.toString(); });
98 d_lw
->registerFunction
<string(ComboAddress::*)()>("toStringWithPort", [](const ComboAddress
& ca
) { return ca
.toStringWithPort(); });
99 d_lw
->registerFunction
<uint16_t(ComboAddress::*)()>("getPort", [](const ComboAddress
& ca
) { return ntohs(ca
.sin4
.sin_port
); } );
100 d_lw
->registerFunction
<string(ComboAddress::*)()>("getRaw", [](const ComboAddress
& ca
) {
101 if(ca
.sin4
.sin_family
== AF_INET
) {
102 auto t
=ca
.sin4
.sin_addr
.s_addr
; return string((const char*)&t
, 4);
105 return string((const char*)&ca
.sin6
.sin6_addr
.s6_addr
, 16);
108 d_lw
->writeFunction("newCA", [](const std::string
& a
) { return ComboAddress(a
); });
109 typedef std::unordered_set
<ComboAddress
,ComboAddress::addressOnlyHash
,ComboAddress::addressOnlyEqual
> cas_t
;
110 d_lw
->writeFunction("newCAS", []{ return cas_t(); });
113 d_lw
->registerFunction
<void(cas_t::*)(boost::variant
<string
,ComboAddress
, vector
<pair
<unsigned int,string
> > >)>("add",
114 [](cas_t
& cas
, const boost::variant
<string
,ComboAddress
,vector
<pair
<unsigned int,string
> > >& in
)
117 if(auto s
= boost::get
<string
>(&in
)) {
118 cas
.insert(ComboAddress(*s
));
120 else if(auto v
= boost::get
<vector
<pair
<unsigned int, string
> > >(&in
)) {
121 for(const auto& str
: *v
)
122 cas
.insert(ComboAddress(str
.second
));
125 cas
.insert(boost::get
<ComboAddress
>(in
));
127 catch(std::exception
& e
) { theL() <<Logger::Error
<<e
.what()<<endl
; }
129 d_lw
->registerFunction
<bool(cas_t::*)(const ComboAddress
&)>("check",[](const cas_t
& cas
, const ComboAddress
&ca
) { return cas
.count(ca
)>0; });
130 d_lw
->registerFunction
<bool(ComboAddress::*)(const ComboAddress
&)>("equal", [](const ComboAddress
& lhs
, const ComboAddress
& rhs
) { return ComboAddress::addressOnlyEqual()(lhs
, rhs
); });
133 d_lw
->writeFunction("newNetmask", [](const string
& s
) { return Netmask(s
); });
134 d_lw
->registerFunction
<ComboAddress(Netmask::*)()>("getNetwork", [](const Netmask
& nm
) { return nm
.getNetwork(); } ); // const reference makes this necessary
135 d_lw
->registerFunction
<ComboAddress(Netmask::*)()>("getMaskedNetwork", [](const Netmask
& nm
) { return nm
.getMaskedNetwork(); } );
136 d_lw
->registerFunction("isIpv4", &Netmask::isIpv4
);
137 d_lw
->registerFunction("isIpv6", &Netmask::isIpv6
);
138 d_lw
->registerFunction("getBits", &Netmask::getBits
);
139 d_lw
->registerFunction("toString", &Netmask::toString
);
140 d_lw
->registerFunction("empty", &Netmask::empty
);
141 d_lw
->registerFunction("match", (bool (Netmask::*)(const string
&) const)&Netmask::match
);
142 d_lw
->registerEqFunction(&Netmask::operator==);
143 d_lw
->registerToStringFunction(&Netmask::toString
);
146 d_lw
->writeFunction("newNMG", []() { return NetmaskGroup(); });
147 d_lw
->registerFunction
<void(NetmaskGroup::*)(const std::string
&mask
)>("addMask", [](NetmaskGroup
&nmg
, const std::string
& mask
) { nmg
.addMask(mask
); });
148 d_lw
->registerFunction
<void(NetmaskGroup::*)(const vector
<pair
<unsigned int, std::string
>>&)>("addMasks", [](NetmaskGroup
&nmg
, const vector
<pair
<unsigned int, std::string
>>& masks
) { for(const auto& mask
: masks
) { nmg
.addMask(mask
.second
); } });
149 d_lw
->registerFunction("match", (bool (NetmaskGroup::*)(const ComboAddress
&) const)&NetmaskGroup::match
);
152 d_lw
->writeFunction("newDR", [](const DNSName
&name
, const std::string
&type
, unsigned int ttl
, const std::string
&content
, int place
){ QType qtype
; qtype
= type
; auto dr
= DNSRecord(); dr
.d_name
= name
; dr
.d_type
= qtype
.getCode(); dr
.d_ttl
= ttl
; dr
.d_content
= shared_ptr
<DNSRecordContent
>(DNSRecordContent::mastermake(dr
.d_type
, 1, content
)); dr
.d_place
= static_cast<DNSResourceRecord::Place
>(place
); return dr
; });
153 d_lw
->registerMember("name", &DNSRecord::d_name
);
154 d_lw
->registerMember("type", &DNSRecord::d_type
);
155 d_lw
->registerMember("ttl", &DNSRecord::d_ttl
);
156 d_lw
->registerMember("place", &DNSRecord::d_place
);
157 d_lw
->registerFunction
<string(DNSRecord::*)()>("getContent", [](const DNSRecord
& dr
) { return dr
.d_content
->getZoneRepresentation(); });
158 d_lw
->registerFunction
<boost::optional
<ComboAddress
>(DNSRecord::*)()>("getCA", [](const DNSRecord
& dr
) {
159 boost::optional
<ComboAddress
> ret
;
161 if(auto rec
= std::dynamic_pointer_cast
<ARecordContent
>(dr
.d_content
))
163 else if(auto rec
= std::dynamic_pointer_cast
<AAAARecordContent
>(dr
.d_content
))
167 d_lw
->registerFunction
<void(DNSRecord::*)(const std::string
&)>("changeContent", [](DNSRecord
& dr
, const std::string
& newContent
) { dr
.d_content
= shared_ptr
<DNSRecordContent
>(DNSRecordContent::mastermake(dr
.d_type
, 1, newContent
)); });
170 d_lw
->writeFunction("pdnslog", [](const std::string
& msg
, boost::optional
<int> loglevel
) { theL() << (Logger::Urgency
)loglevel
.get_value_or(Logger::Warning
) << msg
<<endl
; });
173 d_pd
.push_back({"PASS", (int)PolicyDecision::PASS
});
174 d_pd
.push_back({"DROP", (int)PolicyDecision::DROP
});
175 d_pd
.push_back({"TRUNCATE", (int)PolicyDecision::TRUNCATE
});
177 vector
<pair
<string
, int> > rcodes
= {{"NOERROR", RCode::NoError
},
178 {"FORMERR", RCode::FormErr
},
179 {"SERVFAIL", RCode::ServFail
},
180 {"NXDOMAIN", RCode::NXDomain
},
181 {"NOTIMP", RCode::NotImp
},
182 {"REFUSED", RCode::Refused
},
183 {"YXDOMAIN", RCode::YXDomain
},
184 {"YXRRSET", RCode::YXRRSet
},
185 {"NXRRSET", RCode::NXRRSet
},
186 {"NOTAUTH", RCode::NotAuth
},
187 {"NOTZONE", RCode::NotZone
}};
188 for(const auto& rcode
: rcodes
)
189 d_pd
.push_back({rcode
.first
, rcode
.second
});
191 d_pd
.push_back({"place", in_t
{
198 d_pd
.push_back({"loglevels", in_t
{
199 {"Alert", LOG_ALERT
},
200 {"Critical", LOG_CRIT
},
201 {"Debug", LOG_DEBUG
},
202 {"Emergency", LOG_EMERG
},
204 {"Notice", LOG_NOTICE
},
205 {"Warning", LOG_WARNING
},
209 for(const auto& n
: QType::names
)
210 d_pd
.push_back({n
.first
, n
.second
});
212 d_lw
->registerMember("tv_sec", &timeval::tv_sec
);
213 d_lw
->registerMember("tv_usec", &timeval::tv_usec
);
215 postPrepareContext();
217 // so we can let postprepare do changes to this
218 d_lw
->writeVariable("pdns", d_pd
);
221 void BaseLua4::loadStream(std::istream
&is
) {
222 d_lw
->executeCode(is
);
227 BaseLua4::~BaseLua4() { }