[thirdparty/pdns.git] / pdns / lua-base4.cc

#include <fstream>
#include <unordered_set>
#include <unordered_map>
#include <typeinfo>
#include "logger.hh"
#include "iputils.hh"
#include "dnsname.hh"
#include "dnsparser.hh"
#include "dnspacket.hh"
#include "namespaces.hh"
#include "ednssubnet.hh"
#include "lua-base4.hh"
#include "ext/luawrapper/include/LuaContext.hpp"
#include "dns_random.hh"

BaseLua4::BaseLua4() {
}

void BaseLua4::loadFile(const std::string &fname) {
  std::ifstream ifs(fname);
  if(!ifs) {
    g_log<<Logger::Error<<"Unable to read configuration file from '"<<fname<<"': "<<stringerror()<<endl;
    return;
  }
  loadStream(ifs);
};

void BaseLua4::loadString(const std::string &script) {
  std::istringstream iss(script);
  loadStream(iss);
};

//  By default no features
void BaseLua4::getFeatures(Features &) { }

void BaseLua4::prepareContext() {
  d_lw = std::unique_ptr<LuaContext>(new LuaContext);

  // lua features available
  Features features;
  getFeatures(features);
  d_lw->writeVariable("pdns_features", features);
  
  // dnsheader
  d_lw->registerFunction<int(dnsheader::*)()>("getID", [](dnsheader& dh) { return ntohs(dh.id); });
  d_lw->registerFunction<bool(dnsheader::*)()>("getCD", [](dnsheader& dh) { return dh.cd; });
  d_lw->registerFunction<bool(dnsheader::*)()>("getTC", [](dnsheader& dh) { return dh.tc; });
  d_lw->registerFunction<bool(dnsheader::*)()>("getRA", [](dnsheader& dh) { return dh.ra; });
  d_lw->registerFunction<bool(dnsheader::*)()>("getAD", [](dnsheader& dh) { return dh.ad; });
  d_lw->registerFunction<bool(dnsheader::*)()>("getAA", [](dnsheader& dh) { return dh.aa; });
  d_lw->registerFunction<bool(dnsheader::*)()>("getRD", [](dnsheader& dh) { return dh.rd; });
  d_lw->registerFunction<int(dnsheader::*)()>("getRCODE", [](dnsheader& dh) { return dh.rcode; });
  d_lw->registerFunction<int(dnsheader::*)()>("getOPCODE", [](dnsheader& dh) { return dh.opcode; });
  d_lw->registerFunction<int(dnsheader::*)()>("getQDCOUNT", [](dnsheader& dh) { return ntohs(dh.qdcount); });
  d_lw->registerFunction<int(dnsheader::*)()>("getANCOUNT", [](dnsheader& dh) { return ntohs(dh.ancount); });
  d_lw->registerFunction<int(dnsheader::*)()>("getNSCOUNT", [](dnsheader& dh) { return ntohs(dh.nscount); });
  d_lw->registerFunction<int(dnsheader::*)()>("getARCOUNT", [](dnsheader& dh) { return ntohs(dh.arcount); });

  // DNSName
  d_lw->writeFunction("newDN", [](const std::string& dom){ return DNSName(dom); });
  d_lw->registerFunction("__lt", &DNSName::operator<);
  d_lw->registerFunction("canonCompare", &DNSName::canonCompare);
  d_lw->registerFunction("makeRelative", &DNSName::makeRelative);
  d_lw->registerFunction("isPartOf", &DNSName::isPartOf);
  d_lw->registerFunction("getRawLabels", &DNSName::getRawLabels);
  d_lw->registerFunction<unsigned int(DNSName::*)()>("countLabels", [](const DNSName& name) { return name.countLabels(); });
  d_lw->registerFunction<size_t(DNSName::*)()>("wireLength", [](const DNSName& name) { return name.wirelength(); });
  d_lw->registerFunction<size_t(DNSName::*)()>("wirelength", [](const DNSName& name) { return name.wirelength(); });
  d_lw->registerFunction<bool(DNSName::*)(const std::string&)>("equal", [](const DNSName& lhs, const std::string& rhs) { return lhs==DNSName(rhs); });
  d_lw->registerEqFunction(&DNSName::operator==);
  d_lw->registerToStringFunction<string(DNSName::*)()>([](const DNSName&dn ) { return dn.toString(); });
  d_lw->registerFunction<string(DNSName::*)()>("toString", [](const DNSName&dn ) { return dn.toString(); });
  d_lw->registerFunction<string(DNSName::*)()>("toStringNoDot", [](const DNSName&dn ) { return dn.toStringNoDot(); });
  d_lw->registerFunction<bool(DNSName::*)()>("chopOff", [](DNSName&dn ) { return dn.chopOff(); });

  // DNSResourceRecord
  d_lw->writeFunction("newDRR", [](const DNSName& qname, const string& qtype, const unsigned int ttl, const string& content, boost::optional<int> domain_id, boost::optional<int> auth){
    auto drr = DNSResourceRecord();
    drr.qname = qname;
    drr.qtype = qtype;
    drr.ttl = ttl;
    drr.setContent(content);
    if (domain_id)
      drr.domain_id = *domain_id;
    if (auth)
      drr.auth = *auth;
     return drr;
  });
  d_lw->registerEqFunction(&DNSResourceRecord::operator==);
  d_lw->registerFunction("__lt", &DNSResourceRecord::operator<);
  d_lw->registerToStringFunction<string(DNSResourceRecord::*)()>([](const DNSResourceRecord& rec) { return rec.getZoneRepresentation(); });
  d_lw->registerFunction<string(DNSResourceRecord::*)()>("toString", [](const DNSResourceRecord& rec) { return rec.getZoneRepresentation();} );
  d_lw->registerFunction<DNSName(DNSResourceRecord::*)()>("qname", [](DNSResourceRecord& rec) { return rec.qname; });
  d_lw->registerFunction<DNSName(DNSResourceRecord::*)()>("wildcardName", [](DNSResourceRecord& rec) { return rec.wildcardname; });
  d_lw->registerFunction<string(DNSResourceRecord::*)()>("content", [](DNSResourceRecord& rec) { return rec.content; });
  d_lw->registerFunction<time_t(DNSResourceRecord::*)()>("lastModified", [](DNSResourceRecord& rec) { return rec.last_modified; });
  d_lw->registerFunction<uint32_t(DNSResourceRecord::*)()>("ttl", [](DNSResourceRecord& rec) { return rec.ttl; });
  d_lw->registerFunction<uint32_t(DNSResourceRecord::*)()>("signttl", [](DNSResourceRecord& rec) { return rec.signttl; });
  d_lw->registerFunction<int(DNSResourceRecord::*)()>("domainId", [](DNSResourceRecord& rec) { return rec.domain_id; });
  d_lw->registerFunction<uint16_t(DNSResourceRecord::*)()>("qtype", [](DNSResourceRecord& rec) { return rec.qtype.getCode(); });
  d_lw->registerFunction<uint16_t(DNSResourceRecord::*)()>("qclass", [](DNSResourceRecord& rec) { return rec.qclass; });
  d_lw->registerFunction<uint8_t(DNSResourceRecord::*)()>("scopeMask", [](DNSResourceRecord& rec) { return rec.scopeMask; });
  d_lw->registerFunction<bool(DNSResourceRecord::*)()>("auth", [](DNSResourceRecord& rec) { return rec.auth; });
  d_lw->registerFunction<bool(DNSResourceRecord::*)()>("disabled", [](DNSResourceRecord& rec) { return rec.disabled; });

  // ComboAddress
  d_lw->registerFunction<bool(ComboAddress::*)()>("isIPv4", [](const ComboAddress& ca) { return ca.sin4.sin_family == AF_INET; });
  d_lw->registerFunction<bool(ComboAddress::*)()>("isIPv6", [](const ComboAddress& ca) { return ca.sin4.sin_family == AF_INET6; });
  d_lw->registerFunction<uint16_t(ComboAddress::*)()>("getPort", [](const ComboAddress& ca) { return ntohs(ca.sin4.sin_port); } );
  d_lw->registerFunction<bool(ComboAddress::*)()>("isMappedIPv4", [](const ComboAddress& ca) { return ca.isMappedIPv4(); });
  d_lw->registerFunction<ComboAddress(ComboAddress::*)()>("mapToIPv4", [](const ComboAddress& ca) { return ca.mapToIPv4(); });
  d_lw->registerFunction<void(ComboAddress::*)(unsigned int)>("truncate", [](ComboAddress& ca, unsigned int bits) { ca.truncate(bits); });
  d_lw->registerFunction<string(ComboAddress::*)()>("toString", [](const ComboAddress& ca) { return ca.toString(); });
  d_lw->registerToStringFunction<string(ComboAddress::*)()>([](const ComboAddress& ca) { return ca.toString(); });
  d_lw->registerFunction<string(ComboAddress::*)()>("toStringWithPort", [](const ComboAddress& ca) { return ca.toStringWithPort(); });
  d_lw->registerFunction<string(ComboAddress::*)()>("getRaw", [](const ComboAddress& ca) {
      if(ca.sin4.sin_family == AF_INET) {
        auto t=ca.sin4.sin_addr.s_addr; return string((const char*)&t, 4);
      }
      else
        return string((const char*)&ca.sin6.sin6_addr.s6_addr, 16);
    } );

  d_lw->writeFunction("newCA", [](const std::string& a) { return ComboAddress(a); });
  typedef std::unordered_set<ComboAddress,ComboAddress::addressOnlyHash,ComboAddress::addressOnlyEqual> cas_t;
  d_lw->registerFunction<bool(ComboAddress::*)(const ComboAddress&)>("equal", [](const ComboAddress& lhs, const ComboAddress& rhs) { return ComboAddress::addressOnlyEqual()(lhs, rhs); });

  // cas_t
  d_lw->writeFunction("newCAS", []{ return cas_t(); });
  d_lw->registerFunction<void(cas_t::*)(boost::variant<string,ComboAddress, vector<pair<unsigned int,string> > >)>("add",
    [](cas_t& cas, const boost::variant<string,ComboAddress,vector<pair<unsigned int,string> > >& in)
    {
      try {
      if(auto s = boost::get<string>(&in)) {
        cas.insert(ComboAddress(*s));
      }
      else if(auto v = boost::get<vector<pair<unsigned int, string> > >(&in)) {
        for(const auto& str : *v)
          cas.insert(ComboAddress(str.second));
      }
      else
        cas.insert(boost::get<ComboAddress>(in));
      }
      catch(std::exception& e) { g_log <<Logger::Error<<e.what()<<endl; }
    });
  d_lw->registerFunction<bool(cas_t::*)(const ComboAddress&)>("check",[](const cas_t& cas, const ComboAddress&ca) { return cas.count(ca)>0; });

  // QType
  d_lw->writeFunction("newQType", [](const string& s) { QType q; q = s; return q; });
  d_lw->registerFunction("getCode", &QType::getCode);
  d_lw->registerFunction("getName", &QType::getName);
  d_lw->registerEqFunction<bool(QType::*)(const QType&)>([](const QType& a, const QType& b){ return a == b;}); // operator overloading confuses LuaContext
  d_lw->registerToStringFunction(&QType::getName);

  // Netmask
  d_lw->writeFunction("newNetmask", [](const string& s) { return Netmask(s); });
  d_lw->registerFunction<ComboAddress(Netmask::*)()>("getNetwork", [](const Netmask& nm) { return nm.getNetwork(); } ); // const reference makes this necessary
  d_lw->registerFunction<ComboAddress(Netmask::*)()>("getMaskedNetwork", [](const Netmask& nm) { return nm.getMaskedNetwork(); } );
  d_lw->registerFunction("isIpv4", &Netmask::isIPv4);
  d_lw->registerFunction("isIPv4", &Netmask::isIPv4);
  d_lw->registerFunction("isIpv6", &Netmask::isIPv6);
  d_lw->registerFunction("isIPv6", &Netmask::isIPv6);
  d_lw->registerFunction("getBits", &Netmask::getBits);
  d_lw->registerFunction("toString", &Netmask::toString);
  d_lw->registerFunction("empty", &Netmask::empty);
  d_lw->registerFunction("match", (bool (Netmask::*)(const string&) const)&Netmask::match);
  d_lw->registerEqFunction(&Netmask::operator==);
  d_lw->registerToStringFunction(&Netmask::toString);

  // NetmaskGroup
  d_lw->writeFunction("newNMG", []() { return NetmaskGroup(); });
  d_lw->registerFunction<void(NetmaskGroup::*)(const std::string&mask)>("addMask", [](NetmaskGroup&nmg, const std::string& mask) { nmg.addMask(mask); });
  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); } });
  d_lw->registerFunction("match", (bool (NetmaskGroup::*)(const ComboAddress&) const)&NetmaskGroup::match);

  // DNSRecord
  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; });
  d_lw->registerMember("name", &DNSRecord::d_name);
  d_lw->registerMember("type", &DNSRecord::d_type);
  d_lw->registerMember("ttl", &DNSRecord::d_ttl);
  d_lw->registerMember("place", &DNSRecord::d_place);
  d_lw->registerFunction<string(DNSRecord::*)()>("getContent", [](const DNSRecord& dr) { return dr.d_content->getZoneRepresentation(); });
  d_lw->registerFunction<boost::optional<ComboAddress>(DNSRecord::*)()>("getCA", [](const DNSRecord& dr) {
      boost::optional<ComboAddress> ret;

      if(auto arec = std::dynamic_pointer_cast<ARecordContent>(dr.d_content))
        ret=arec->getCA(53);
      else if(auto aaaarec = std::dynamic_pointer_cast<AAAARecordContent>(dr.d_content))
        ret=aaaarec->getCA(53);
      return ret;
    });
  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)); });

  // pdnsload
  d_lw->writeFunction("pdnslog", [](const std::string& msg, boost::optional<int> loglevel) { g_log << (Logger::Urgency)loglevel.get_value_or(Logger::Warning) << msg<<endl; });
  d_lw->writeFunction("pdnsrandom", [](boost::optional<uint32_t> maximum) { return dns_random(maximum.get_value_or(0xffffffff)); });

  // certain constants
  d_pd.push_back({"PASS", (int)PolicyDecision::PASS});
  d_pd.push_back({"DROP", (int)PolicyDecision::DROP});
  d_pd.push_back({"TRUNCATE", (int)PolicyDecision::TRUNCATE});

  vector<pair<string, int> > rcodes = {{"NOERROR",  RCode::NoError  },
                                       {"FORMERR",  RCode::FormErr  },
                                       {"SERVFAIL", RCode::ServFail },
                                       {"NXDOMAIN", RCode::NXDomain },
                                       {"NOTIMP",   RCode::NotImp   },
                                       {"REFUSED",  RCode::Refused  },
                                       {"YXDOMAIN", RCode::YXDomain },
                                       {"YXRRSET",  RCode::YXRRSet  },
                                       {"NXRRSET",  RCode::NXRRSet  },
                                       {"NOTAUTH",  RCode::NotAuth  },
                                       {"NOTZONE",  RCode::NotZone  }};
  for(const auto& rcode : rcodes)
    d_pd.push_back({rcode.first, rcode.second});

  d_pd.push_back({"place", in_t{
    {"QUESTION", 0},
    {"ANSWER", 1},
    {"AUTHORITY", 2},
    {"ADDITIONAL", 3}
  }});

  d_pd.push_back({"loglevels", in_t{
        {"Alert", LOG_ALERT},
        {"Critical", LOG_CRIT},
        {"Debug", LOG_DEBUG},
        {"Emergency", LOG_EMERG},
        {"Info", LOG_INFO},
        {"Notice", LOG_NOTICE},
        {"Warning", LOG_WARNING},
        {"Error", LOG_ERR}
          }});

  for(const auto& n : QType::names)
    d_pd.push_back({n.first, n.second});

  d_lw->registerMember("tv_sec", &timeval::tv_sec);
  d_lw->registerMember("tv_usec", &timeval::tv_usec);

  postPrepareContext();

  // so we can let postprepare do changes to this
  d_lw->writeVariable("pdns", d_pd);
}

void BaseLua4::loadStream(std::istream &is) {
  d_lw->executeCode(is);

  postLoad();
}

BaseLua4::~BaseLua4() { }
Commit	Line	Data
f03de9dc AT	1	#include <fstream>
	2	#include <unordered_set>
	3	#include <unordered_map>
	4	#include <typeinfo>
	5	#include "logger.hh"
	6	#include "iputils.hh"
	7	#include "dnsname.hh"
	8	#include "dnsparser.hh"
	9	#include "dnspacket.hh"
	10	#include "namespaces.hh"
	11	#include "ednssubnet.hh"
	12	#include "lua-base4.hh"
0c606b24	13	#include "ext/luawrapper/include/LuaContext.hpp"
2c419831	14	#include "dns_random.hh"
f03de9dc	15
9694e14f AT	16	BaseLua4::BaseLua4() {
	17	}
	18
	19	void BaseLua4::loadFile(const std::string &fname) {
	20	std::ifstream ifs(fname);
	21	if(!ifs) {
04360367	22	g_log<<Logger::Error<<"Unable to read configuration file from '"<<fname<<"': "<<stringerror()<<endl;
9694e14f AT	23	return;
	24	}
	25	loadStream(ifs);
	26	};
	27
	28	void BaseLua4::loadString(const std::string &script) {
	29	std::istringstream iss(script);
	30	loadStream(iss);
	31	};
	32
c4e71b7c OM	33	// By default no features
	34	void BaseLua4::getFeatures(Features &) { }
	35
f03de9dc AT	36	void BaseLua4::prepareContext() {
	37	d_lw = std::unique_ptr<LuaContext>(new LuaContext);
	38
1b2c38ad	39	// lua features available
c4e71b7c OM	40	Features features;
	41	getFeatures(features);
	42	d_lw->writeVariable("pdns_features", features);
1b2c38ad	43
f03de9dc	44	// dnsheader
7a95b864	45	d_lw->registerFunction<int(dnsheader::*)()>("getID", [](dnsheader& dh) { return ntohs(dh.id); });
f03de9dc AT	46	d_lw->registerFunction<bool(dnsheader::*)()>("getCD", [](dnsheader& dh) { return dh.cd; });
	47	d_lw->registerFunction<bool(dnsheader::*)()>("getTC", [](dnsheader& dh) { return dh.tc; });
	48	d_lw->registerFunction<bool(dnsheader::*)()>("getRA", [](dnsheader& dh) { return dh.ra; });
	49	d_lw->registerFunction<bool(dnsheader::*)()>("getAD", [](dnsheader& dh) { return dh.ad; });
	50	d_lw->registerFunction<bool(dnsheader::*)()>("getAA", [](dnsheader& dh) { return dh.aa; });
	51	d_lw->registerFunction<bool(dnsheader::*)()>("getRD", [](dnsheader& dh) { return dh.rd; });
	52	d_lw->registerFunction<int(dnsheader::*)()>("getRCODE", [](dnsheader& dh) { return dh.rcode; });
	53	d_lw->registerFunction<int(dnsheader::*)()>("getOPCODE", [](dnsheader& dh) { return dh.opcode; });
	54	d_lw->registerFunction<int(dnsheader::*)()>("getQDCOUNT", [](dnsheader& dh) { return ntohs(dh.qdcount); });
	55	d_lw->registerFunction<int(dnsheader::*)()>("getANCOUNT", [](dnsheader& dh) { return ntohs(dh.ancount); });
	56	d_lw->registerFunction<int(dnsheader::*)()>("getNSCOUNT", [](dnsheader& dh) { return ntohs(dh.nscount); });
	57	d_lw->registerFunction<int(dnsheader::*)()>("getARCOUNT", [](dnsheader& dh) { return ntohs(dh.arcount); });
	58
	59	// DNSName
	60	d_lw->writeFunction("newDN", [](const std::string& dom){ return DNSName(dom); });
d45048a5 AT	61	d_lw->registerFunction("__lt", &DNSName::operator<);
	62	d_lw->registerFunction("canonCompare", &DNSName::canonCompare);
	63	d_lw->registerFunction("makeRelative", &DNSName::makeRelative);
f03de9dc	64	d_lw->registerFunction("isPartOf", &DNSName::isPartOf);
0be34c86	65	d_lw->registerFunction("getRawLabels", &DNSName::getRawLabels);
f03de9dc	66	d_lw->registerFunction<unsigned int(DNSName::*)()>("countLabels", [](const DNSName& name) { return name.countLabels(); });
c052aac7	67	d_lw->registerFunction<size_t(DNSName::*)()>("wireLength", [](const DNSName& name) { return name.wirelength(); });
8c5a204f	68	d_lw->registerFunction<size_t(DNSName::*)()>("wirelength", [](const DNSName& name) { return name.wirelength(); });
f03de9dc AT	69	d_lw->registerFunction<bool(DNSName::*)(const std::string&)>("equal", [](const DNSName& lhs, const std::string& rhs) { return lhs==DNSName(rhs); });
f03de9dc AT	70	d_lw->registerEqFunction(&DNSName::operator==);
f03de9dc AT	71	d_lw->registerToStringFunction<string(DNSName::*)()>([](const DNSName&dn ) { return dn.toString(); });
	72	d_lw->registerFunction<string(DNSName::*)()>("toString", [](const DNSName&dn ) { return dn.toString(); });
	73	d_lw->registerFunction<string(DNSName::*)()>("toStringNoDot", [](const DNSName&dn ) { return dn.toStringNoDot(); });
	74	d_lw->registerFunction<bool(DNSName::*)()>("chopOff", [](DNSName&dn ) { return dn.chopOff(); });
	75
	76	// DNSResourceRecord
27c44631 AT	77	d_lw->writeFunction("newDRR", [](const DNSName& qname, const string& qtype, const unsigned int ttl, const string& content, boost::optional<int> domain_id, boost::optional<int> auth){
	78	auto drr = DNSResourceRecord();
	79	drr.qname = qname;
	80	drr.qtype = qtype;
	81	drr.ttl = ttl;
	82	drr.setContent(content);
	83	if (domain_id)
	84	drr.domain_id = *domain_id;
	85	if (auth)
	86	drr.auth = *auth;
	87	return drr;
	88	});
f03de9dc AT	89	d_lw->registerEqFunction(&DNSResourceRecord::operator==);
f03de9dc AT	90	d_lw->registerFunction("__lt", &DNSResourceRecord::operator<);
c052aac7	91	d_lw->registerToStringFunction<string(DNSResourceRecord::*)()>([](const DNSResourceRecord& rec) { return rec.getZoneRepresentation(); });
f03de9dc AT	92	d_lw->registerFunction<string(DNSResourceRecord::*)()>("toString", [](const DNSResourceRecord& rec) { return rec.getZoneRepresentation();} );
f03de9dc AT	93	d_lw->registerFunction<DNSName(DNSResourceRecord::*)()>("qname", [](DNSResourceRecord& rec) { return rec.qname; });
c052aac7	94	d_lw->registerFunction<DNSName(DNSResourceRecord::*)()>("wildcardName", [](DNSResourceRecord& rec) { return rec.wildcardname; });
f03de9dc	95	d_lw->registerFunction<string(DNSResourceRecord::*)()>("content", [](DNSResourceRecord& rec) { return rec.content; });
c052aac7	96	d_lw->registerFunction<time_t(DNSResourceRecord::*)()>("lastModified", [](DNSResourceRecord& rec) { return rec.last_modified; });
f03de9dc AT	97	d_lw->registerFunction<uint32_t(DNSResourceRecord::*)()>("ttl", [](DNSResourceRecord& rec) { return rec.ttl; });
f03de9dc AT	98	d_lw->registerFunction<uint32_t(DNSResourceRecord::*)()>("signttl", [](DNSResourceRecord& rec) { return rec.signttl; });
c052aac7	99	d_lw->registerFunction<int(DNSResourceRecord::*)()>("domainId", [](DNSResourceRecord& rec) { return rec.domain_id; });
f03de9dc AT	100	d_lw->registerFunction<uint16_t(DNSResourceRecord::*)()>("qtype", [](DNSResourceRecord& rec) { return rec.qtype.getCode(); });
	101	d_lw->registerFunction<uint16_t(DNSResourceRecord::*)()>("qclass", [](DNSResourceRecord& rec) { return rec.qclass; });
	102	d_lw->registerFunction<uint8_t(DNSResourceRecord::*)()>("scopeMask", [](DNSResourceRecord& rec) { return rec.scopeMask; });
	103	d_lw->registerFunction<bool(DNSResourceRecord::*)()>("auth", [](DNSResourceRecord& rec) { return rec.auth; });
	104	d_lw->registerFunction<bool(DNSResourceRecord::*)()>("disabled", [](DNSResourceRecord& rec) { return rec.disabled; });
	105
	106	// ComboAddress
	107	d_lw->registerFunction<bool(ComboAddress::*)()>("isIPv4", [](const ComboAddress& ca) { return ca.sin4.sin_family == AF_INET; });
	108	d_lw->registerFunction<bool(ComboAddress::*)()>("isIPv6", [](const ComboAddress& ca) { return ca.sin4.sin_family == AF_INET6; });
c052aac7	109	d_lw->registerFunction<uint16_t(ComboAddress::*)()>("getPort", [](const ComboAddress& ca) { return ntohs(ca.sin4.sin_port); } );
f03de9dc AT	110	d_lw->registerFunction<bool(ComboAddress::*)()>("isMappedIPv4", [](const ComboAddress& ca) { return ca.isMappedIPv4(); });
	111	d_lw->registerFunction<ComboAddress(ComboAddress::*)()>("mapToIPv4", [](const ComboAddress& ca) { return ca.mapToIPv4(); });
	112	d_lw->registerFunction<void(ComboAddress::*)(unsigned int)>("truncate", [](ComboAddress& ca, unsigned int bits) { ca.truncate(bits); });
	113	d_lw->registerFunction<string(ComboAddress::*)()>("toString", [](const ComboAddress& ca) { return ca.toString(); });
	114	d_lw->registerToStringFunction<string(ComboAddress::*)()>([](const ComboAddress& ca) { return ca.toString(); });
	115	d_lw->registerFunction<string(ComboAddress::*)()>("toStringWithPort", [](const ComboAddress& ca) { return ca.toStringWithPort(); });
f03de9dc AT	116	d_lw->registerFunction<string(ComboAddress::*)()>("getRaw", [](const ComboAddress& ca) {
	117	if(ca.sin4.sin_family == AF_INET) {
	118	auto t=ca.sin4.sin_addr.s_addr; return string((const char*)&t, 4);
	119	}
	120	else
	121	return string((const char*)&ca.sin6.sin6_addr.s6_addr, 16);
	122	} );
	123
	124	d_lw->writeFunction("newCA", [](const std::string& a) { return ComboAddress(a); });
	125	typedef std::unordered_set<ComboAddress,ComboAddress::addressOnlyHash,ComboAddress::addressOnlyEqual> cas_t;
c052aac7	126	d_lw->registerFunction<bool(ComboAddress::*)(const ComboAddress&)>("equal", [](const ComboAddress& lhs, const ComboAddress& rhs) { return ComboAddress::addressOnlyEqual()(lhs, rhs); });
f03de9dc AT	127
f03de9dc AT	128	// cas_t
c052aac7	129	d_lw->writeFunction("newCAS", []{ return cas_t(); });
70c21c40 AT	130	d_lw->registerFunction<void(cas_t::*)(boost::variant<string,ComboAddress, vector<pair<unsigned int,string> > >)>("add",
70c21c40 AT	131	[](cas_t& cas, const boost::variant<string,ComboAddress,vector<pair<unsigned int,string> > >& in)
f03de9dc AT	132	{
f03de9dc AT	133	try {
70c21c40 AT	134	if(auto s = boost::get<string>(&in)) {
	135	cas.insert(ComboAddress(*s));
	136	}
	137	else if(auto v = boost::get<vector<pair<unsigned int, string> > >(&in)) {
	138	for(const auto& str : *v)
	139	cas.insert(ComboAddress(str.second));
	140	}
	141	else
	142	cas.insert(boost::get<ComboAddress>(in));
	143	}
e6a9dde5	144	catch(std::exception& e) { g_log <<Logger::Error<<e.what()<<endl; }
f03de9dc AT	145	});
f03de9dc AT	146	d_lw->registerFunction<bool(cas_t::*)(const ComboAddress&)>("check",[](const cas_t& cas, const ComboAddress&ca) { return cas.count(ca)>0; });
f03de9dc	147
49f44df3 AT	148	// QType
	149	d_lw->writeFunction("newQType", [](const string& s) { QType q; q = s; return q; });
	150	d_lw->registerFunction("getCode", &QType::getCode);
	151	d_lw->registerFunction("getName", &QType::getName);
	152	d_lw->registerEqFunction<bool(QType::*)(const QType&)>([](const QType& a, const QType& b){ return a == b;}); // operator overloading confuses LuaContext
	153	d_lw->registerToStringFunction(&QType::getName);
	154
f03de9dc AT	155	// Netmask
	156	d_lw->writeFunction("newNetmask", [](const string& s) { return Netmask(s); });
	157	d_lw->registerFunction<ComboAddress(Netmask::*)()>("getNetwork", [](const Netmask& nm) { return nm.getNetwork(); } ); // const reference makes this necessary
	158	d_lw->registerFunction<ComboAddress(Netmask::*)()>("getMaskedNetwork", [](const Netmask& nm) { return nm.getMaskedNetwork(); } );
d14121a8 AT	159	d_lw->registerFunction("isIpv4", &Netmask::isIPv4);
d14121a8 AT	160	d_lw->registerFunction("isIPv4", &Netmask::isIPv4);
37e35fbc AT	161	d_lw->registerFunction("isIpv6", &Netmask::isIPv6);
37e35fbc AT	162	d_lw->registerFunction("isIPv6", &Netmask::isIPv6);
f03de9dc AT	163	d_lw->registerFunction("getBits", &Netmask::getBits);
	164	d_lw->registerFunction("toString", &Netmask::toString);
	165	d_lw->registerFunction("empty", &Netmask::empty);
	166	d_lw->registerFunction("match", (bool (Netmask::*)(const string&) const)&Netmask::match);
	167	d_lw->registerEqFunction(&Netmask::operator==);
70c21c40	168	d_lw->registerToStringFunction(&Netmask::toString);
f03de9dc AT	169
	170	// NetmaskGroup
	171	d_lw->writeFunction("newNMG", []() { return NetmaskGroup(); });
	172	d_lw->registerFunction<void(NetmaskGroup::*)(const std::string&mask)>("addMask", [](NetmaskGroup&nmg, const std::string& mask) { nmg.addMask(mask); });
	173	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); } });
	174	d_lw->registerFunction("match", (bool (NetmaskGroup::*)(const ComboAddress&) const)&NetmaskGroup::match);
	175
	176	// DNSRecord
	177	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; });
	178	d_lw->registerMember("name", &DNSRecord::d_name);
	179	d_lw->registerMember("type", &DNSRecord::d_type);
	180	d_lw->registerMember("ttl", &DNSRecord::d_ttl);
	181	d_lw->registerMember("place", &DNSRecord::d_place);
	182	d_lw->registerFunction<string(DNSRecord::*)()>("getContent", [](const DNSRecord& dr) { return dr.d_content->getZoneRepresentation(); });
	183	d_lw->registerFunction<boost::optional<ComboAddress>(DNSRecord::*)()>("getCA", [](const DNSRecord& dr) {
	184	boost::optional<ComboAddress> ret;
	185
dc058f65 RG	186	if(auto arec = std::dynamic_pointer_cast<ARecordContent>(dr.d_content))
	187	ret=arec->getCA(53);
	188	else if(auto aaaarec = std::dynamic_pointer_cast<AAAARecordContent>(dr.d_content))
	189	ret=aaaarec->getCA(53);
f03de9dc AT	190	return ret;
	191	});
	192	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)); });
	193
	194	// pdnsload
e6a9dde5	195	d_lw->writeFunction("pdnslog", [](const std::string& msg, boost::optional<int> loglevel) { g_log << (Logger::Urgency)loglevel.get_value_or(Logger::Warning) << msg<<endl; });
2c419831	196	d_lw->writeFunction("pdnsrandom", [](boost::optional<uint32_t> maximum) { return dns_random(maximum.get_value_or(0xffffffff)); });
f03de9dc AT	197
	198	// certain constants
	199	d_pd.push_back({"PASS", (int)PolicyDecision::PASS});
	200	d_pd.push_back({"DROP", (int)PolicyDecision::DROP});
	201	d_pd.push_back({"TRUNCATE", (int)PolicyDecision::TRUNCATE});
	202
	203	vector<pair<string, int> > rcodes = {{"NOERROR", RCode::NoError },
	204	{"FORMERR", RCode::FormErr },
	205	{"SERVFAIL", RCode::ServFail },
	206	{"NXDOMAIN", RCode::NXDomain },
	207	{"NOTIMP", RCode::NotImp },
	208	{"REFUSED", RCode::Refused },
	209	{"YXDOMAIN", RCode::YXDomain },
	210	{"YXRRSET", RCode::YXRRSet },
	211	{"NXRRSET", RCode::NXRRSet },
	212	{"NOTAUTH", RCode::NotAuth },
	213	{"NOTZONE", RCode::NotZone }};
	214	for(const auto& rcode : rcodes)
	215	d_pd.push_back({rcode.first, rcode.second});
	216
	217	d_pd.push_back({"place", in_t{
	218	{"QUESTION", 0},
	219	{"ANSWER", 1},
	220	{"AUTHORITY", 2},
	221	{"ADDITIONAL", 3}
	222	}});
	223
	224	d_pd.push_back({"loglevels", in_t{
	225	{"Alert", LOG_ALERT},
	226	{"Critical", LOG_CRIT},
	227	{"Debug", LOG_DEBUG},
	228	{"Emergency", LOG_EMERG},
	229	{"Info", LOG_INFO},
	230	{"Notice", LOG_NOTICE},
	231	{"Warning", LOG_WARNING},
	232	{"Error", LOG_ERR}
	233	}});
	234
	235	for(const auto& n : QType::names)
	236	d_pd.push_back({n.first, n.second});
	237
	238	d_lw->registerMember("tv_sec", &timeval::tv_sec);
	239	d_lw->registerMember("tv_usec", &timeval::tv_usec);
	240
	241	postPrepareContext();
	242
	243	// so we can let postprepare do changes to this
	244	d_lw->writeVariable("pdns", d_pd);
	245	}
	246
9694e14f AT	247	void BaseLua4::loadStream(std::istream &is) {
	248	d_lw->executeCode(is);
	249
	250	postLoad();
	251	}
	252
f03de9dc	253	BaseLua4::~BaseLua4() { }