• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

PowerDNS / pdns / 26832729776

02 Jun 2026 04:14PM UTC coverage: 67.035% (-4.0%) from 71.048%
26832729776

push

github

web-flow
Merge pull request #16961 from pieterlexis/dnsdist-lua-opentelemetry

dnsdist: Add feature to create Telemetry Spans from LuaAction

43130 of 81538 branches covered (52.9%)

Branch coverage included in aggregate %.

217 of 232 new or added lines in 13 files covered. (93.53%)

6992 existing lines in 78 files now uncovered.

125855 of 170548 relevant lines covered (73.79%)

7163549.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

49.54
/pdns/lua-base4.cc
1
#include "config.h"
2
#include <cassert>
3
#include <fstream>
4
#include <unordered_set>
5
#include <unordered_map>
6
#include <typeinfo>
7
#include <sys/stat.h>
8
#include "logger.hh"
9
#include "logging.hh"
10
#include "iputils.hh"
11
#include "dnsname.hh"
12
#include "dnsparser.hh"
13
#include "dnspacket.hh"
14
#include "namespaces.hh"
15
#include "ednssubnet.hh"
16
#include "lua-base4.hh"
17
#include "ext/luawrapper/include/LuaContext.hpp"
18
#include "dns_random.hh"
19

20
void BaseLua4::loadFile(const std::string& fname, bool doPostLoad)
21
{
450✔
22
  std::ifstream ifs(fname);
450✔
23
  if (!ifs) {
450!
24
    auto ret = errno;
×
25
    auto msg = stringerror(ret);
×
26
    SLOG(g_log << Logger::Error << "Unable to read configuration file from '" << fname << "': " << msg << endl,
×
27
         g_slog->withName("lua")->error(Logr::Error, msg, "Unable to read configuration file", "file", Logging::Loggable(fname)));
×
28
    throw std::runtime_error(msg);
×
29
  }
×
30
  loadStream(ifs, doPostLoad);
450✔
31
};
450✔
32

33
void BaseLua4::loadString(const std::string &script) {
2✔
34
  std::istringstream iss(script);
2✔
35
  loadStream(iss, true);
2✔
36
};
2✔
37

38
void BaseLua4::includePath(const std::string& directory) {
×
39
  std::vector<std::string> vec;
×
40
  const std::string& suffix = "lua";
×
41
  auto directoryError = pdns::visit_directory(directory, [this, &directory, &suffix, &vec]([[maybe_unused]] ino_t inodeNumber, const std::string_view& name) {
×
42
    (void)this;
×
43
    if (boost::starts_with(name, ".")) {
×
44
      return true; // skip any dots
×
45
    }
×
46
    if (boost::ends_with(name, suffix)) {
×
47
      // build name
48
      string fullName = directory + "/" + std::string(name);
×
49
      // ensure it's readable file
50
      struct stat statInfo
×
51
      {
×
52
      };
×
53
      if (stat(fullName.c_str(), &statInfo) != 0 || !S_ISREG(statInfo.st_mode)) {
×
54
        string msg = fullName + " is not a regular file";
×
55
        SLOG(g_log << Logger::Error << msg << std::endl,
×
56
             g_slog->withName("lua")->info(Logr::Error, "include file is not a regular file", "file", Logging::Loggable(fullName)));
×
57
        throw PDNSException(std::move(msg));
×
58
      }
×
59
      vec.emplace_back(fullName);
×
60
    }
×
61
    return true;
×
62
  });
×
63

64
  if (directoryError) {
×
65
    int err = errno;
×
66
    string msg = directory + " is not accessible: " + stringerror(err);
×
67
    SLOG(g_log << Logger::Error << msg << std::endl,
×
68
         g_slog->withName("lua")->error(Logr::Error, err, "Error trying to walk directory", "directory", Logging::Loggable(directory)));
×
69
    throw PDNSException(std::move(msg));
×
70
  }
×
71

72
  std::sort(vec.begin(), vec.end(), CIStringComparePOSIX());
×
73

74
  for(const auto& file: vec) {
×
75
    loadFile(file, false);
×
76
  }
×
77
};
×
78

79
//  By default no features
80
void BaseLua4::getFeatures(Features &) { }
472✔
81

82
void BaseLua4::prepareContext() {
472✔
83
  d_lw = std::make_unique<LuaContext>();
472✔
84

85
  // lua features available
86
  Features features;
472✔
87
  getFeatures(features);
472✔
88
  d_lw->writeVariable("pdns_features", features);
472✔
89

90
  // dnsheader
91
  d_lw->registerFunction<int(dnsheader::*)()>("getID", [](dnsheader& dh) { return ntohs(dh.id); });
472✔
92
  d_lw->registerFunction<bool(dnsheader::*)()>("getCD", [](dnsheader& dh) { return dh.cd; });
472✔
93
  d_lw->registerFunction<bool(dnsheader::*)()>("getTC", [](dnsheader& dh) { return dh.tc; });
472✔
94
  d_lw->registerFunction<bool(dnsheader::*)()>("getRA", [](dnsheader& dh) { return dh.ra; });
472✔
95
  d_lw->registerFunction<bool(dnsheader::*)()>("getAD", [](dnsheader& dh) { return dh.ad; });
472✔
96
  d_lw->registerFunction<bool(dnsheader::*)()>("getAA", [](dnsheader& dh) { return dh.aa; });
472✔
97
  d_lw->registerFunction<bool(dnsheader::*)()>("getRD", [](dnsheader& dh) { return dh.rd; });
472✔
98
  d_lw->registerFunction<int(dnsheader::*)()>("getRCODE", [](dnsheader& dh) { return dh.rcode; });
472✔
99
  d_lw->registerFunction<int(dnsheader::*)()>("getOPCODE", [](dnsheader& dh) { return dh.opcode; });
472✔
100
  d_lw->registerFunction<int(dnsheader::*)()>("getQDCOUNT", [](dnsheader& dh) { return ntohs(dh.qdcount); });
472✔
101
  d_lw->registerFunction<int(dnsheader::*)()>("getANCOUNT", [](dnsheader& dh) { return ntohs(dh.ancount); });
472✔
102
  d_lw->registerFunction<int(dnsheader::*)()>("getNSCOUNT", [](dnsheader& dh) { return ntohs(dh.nscount); });
472✔
103
  d_lw->registerFunction<int(dnsheader::*)()>("getARCOUNT", [](dnsheader& dh) { return ntohs(dh.arcount); });
472✔
104

105
  // DNSName
106
  d_lw->writeFunction("newDN", [](const std::string& dom){ return DNSName(dom); });
98,500✔
107
  d_lw->registerFunction("__lt", &DNSName::operator<);
472✔
108
  d_lw->registerFunction<bool(DNSName::*)(const DNSName&)>("canonCompare", [](const DNSName& name, const DNSName& rhs) { return name.canonCompare(rhs); });
700✔
109
  d_lw->registerFunction<DNSName(DNSName::*)(const DNSName&)>("makeRelative", [](const DNSName& name, const DNSName& zone) { return name.makeRelative(zone); });
504✔
110
  d_lw->registerFunction<bool(DNSName::*)(const DNSName&)>("isPartOf", [](const DNSName& name, const DNSName& rhs) { return name.isPartOf(rhs); });
565✔
111
  d_lw->registerFunction("getRawLabels", &DNSName::getRawLabels);
472✔
112
  d_lw->registerFunction<unsigned int(DNSName::*)()>("countLabels", [](const DNSName& name) { return name.countLabels(); });
472✔
113
  d_lw->registerFunction<size_t(DNSName::*)()>("wireLength", [](const DNSName& name) { return name.wirelength(); });
472✔
114
  d_lw->registerFunction<size_t(DNSName::*)()>("wirelength", [](const DNSName& name) { return name.wirelength(); });
472✔
115
  d_lw->registerFunction<bool(DNSName::*)(const std::string&)>("equal", [](const DNSName& lhs, const std::string& rhs) { return lhs==DNSName(rhs); });
472✔
116
  d_lw->registerEqFunction(&DNSName::operator==);
472✔
117
  d_lw->registerToStringFunction<string(DNSName::*)()>([](const DNSName&dn ) { return dn.toString(); });
472✔
118
  d_lw->registerFunction<string(DNSName::*)()>("toString", [](const DNSName&dn ) { return dn.toString(); });
472✔
119
  d_lw->registerFunction<string(DNSName::*)()>("toStringNoDot", [](const DNSName&dn ) { return dn.toStringNoDot(); });
472✔
120
  d_lw->registerFunction<bool(DNSName::*)()>("chopOff", [](DNSName&dn ) { return dn.chopOff(); });
472✔
121

122
  // DNSResourceRecord
123
  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){
472✔
124
    auto drr = DNSResourceRecord();
×
125
    drr.qname = qname;
×
126
    drr.qtype = qtype;
×
127
    drr.ttl = ttl;
×
128
    drr.setContent(content);
×
129
    if (domain_id)
×
130
      drr.domain_id = *domain_id;
×
131
    if (auth)
×
132
      drr.auth = *auth;
×
133
     return drr;
×
134
  });
×
135
  d_lw->registerEqFunction(&DNSResourceRecord::operator==);
472✔
136
  d_lw->registerFunction("__lt", &DNSResourceRecord::operator<);
472✔
137
  d_lw->registerToStringFunction<string(DNSResourceRecord::*)()>([](const DNSResourceRecord& rec) { return rec.getZoneRepresentation(); });
472✔
138
  d_lw->registerFunction<string(DNSResourceRecord::*)()>("toString", [](const DNSResourceRecord& rec) { return rec.getZoneRepresentation();} );
472✔
139
  d_lw->registerFunction<DNSName(DNSResourceRecord::*)()>("qname", [](DNSResourceRecord& rec) { return rec.qname; });
472✔
140
  d_lw->registerFunction<DNSName(DNSResourceRecord::*)()>("wildcardName", [](DNSResourceRecord& rec) { return rec.wildcardname; });
472✔
141
  d_lw->registerFunction<string(DNSResourceRecord::*)()>("content", [](DNSResourceRecord& rec) { return rec.content; });
472✔
142
  d_lw->registerFunction<time_t(DNSResourceRecord::*)()>("lastModified", [](DNSResourceRecord& rec) { return rec.last_modified; });
472✔
143
  d_lw->registerFunction<uint32_t(DNSResourceRecord::*)()>("ttl", [](DNSResourceRecord& rec) { return rec.ttl; });
472✔
144
  d_lw->registerFunction<uint32_t(DNSResourceRecord::*)()>("signttl", [](DNSResourceRecord& rec) { return rec.signttl; });
472✔
145
  d_lw->registerFunction<int(DNSResourceRecord::*)()>("domainId", [](DNSResourceRecord& rec) { return rec.domain_id; });
472✔
146
  d_lw->registerFunction<uint16_t(DNSResourceRecord::*)()>("qtype", [](DNSResourceRecord& rec) { return rec.qtype.getCode(); });
472✔
147
  d_lw->registerFunction<uint16_t(DNSResourceRecord::*)()>("qclass", [](DNSResourceRecord& rec) { return rec.qclass; });
472✔
148
  d_lw->registerFunction<uint8_t(DNSResourceRecord::*)()>("scopeMask", [](DNSResourceRecord& rec) { return rec.scopeMask; });
472✔
149
  d_lw->registerFunction<bool(DNSResourceRecord::*)()>("auth", [](DNSResourceRecord& rec) { return rec.auth; });
472✔
150
  d_lw->registerFunction<bool(DNSResourceRecord::*)()>("disabled", [](DNSResourceRecord& rec) { return rec.disabled; });
472✔
151

152
  // ComboAddress
153
  d_lw->registerFunction<bool(ComboAddress::*)()>("isIPv4", [](const ComboAddress& addr) { return addr.sin4.sin_family == AF_INET; });
472✔
154
  d_lw->registerFunction<bool(ComboAddress::*)()>("isIPv6", [](const ComboAddress& addr) { return addr.sin4.sin_family == AF_INET6; });
472✔
155
  d_lw->registerFunction<uint16_t(ComboAddress::*)()>("getPort", [](const ComboAddress& addr) { return ntohs(addr.sin4.sin_port); } );
472✔
156
  d_lw->registerFunction<bool(ComboAddress::*)()>("isMappedIPv4", [](const ComboAddress& addr) { return addr.isMappedIPv4(); });
472✔
157
  d_lw->registerFunction<ComboAddress(ComboAddress::*)()>("mapToIPv4", [](const ComboAddress& addr) { return addr.mapToIPv4(); });
472✔
158
  d_lw->registerFunction<void(ComboAddress::*)(unsigned int)>("truncate", [](ComboAddress& addr, unsigned int bits) { addr.truncate(bits); });
472✔
159
  d_lw->registerFunction<string(ComboAddress::*)()>("toString", [](const ComboAddress& addr) { return addr.toString(); });
472✔
160
  d_lw->registerToStringFunction<string(ComboAddress::*)()>([](const ComboAddress& addr) { return addr.toString(); });
98,250✔
161
  d_lw->registerFunction<string(ComboAddress::*)()>("toStringWithPort", [](const ComboAddress& addr) { return addr.toStringWithPort(); });
472✔
162
  d_lw->registerFunction<string(ComboAddress::*)()>("getRaw", [](const ComboAddress& addr) { return addr.toByteString(); });
472✔
163

164
  d_lw->writeFunction("newCA", [](const std::string& a) { return ComboAddress(a); });
472✔
165
  d_lw->writeFunction("newCAFromRaw", [](const std::string& raw, boost::optional<uint16_t> port) {
472✔
166
                                        if (raw.size() == 4) {
×
167
                                          struct sockaddr_in sin4;
×
168
                                          memset(&sin4, 0, sizeof(sin4));
×
169
                                          sin4.sin_family = AF_INET;
×
170
                                          memcpy(&sin4.sin_addr.s_addr, raw.c_str(), raw.size());
×
171
                                          if (port) {
×
172
                                            sin4.sin_port = htons(*port);
×
173
                                          }
×
174
                                          return ComboAddress(&sin4);
×
175
                                        }
×
176
                                        else if (raw.size() == 16) {
×
177
                                          struct sockaddr_in6 sin6;
×
178
                                          memset(&sin6, 0, sizeof(sin6));
×
179
                                          sin6.sin6_family = AF_INET6;
×
180
                                          memcpy(&sin6.sin6_addr.s6_addr, raw.c_str(), raw.size());
×
181
                                          if (port) {
×
182
                                            sin6.sin6_port = htons(*port);
×
183
                                          }
×
184
                                          return ComboAddress(&sin6);
×
185
                                        }
×
186
                                        return ComboAddress();
×
187
                                      });
×
188
  typedef std::unordered_set<ComboAddress,ComboAddress::addressOnlyHash,ComboAddress::addressOnlyEqual> cas_t;
472✔
189
  d_lw->registerFunction<bool(ComboAddress::*)(const ComboAddress&)>("equal", [](const ComboAddress& lhs, const ComboAddress& rhs) { return ComboAddress::addressOnlyEqual()(lhs, rhs); });
472✔
190

191
  // cas_t
192
  d_lw->writeFunction("newCAS", []{ return cas_t(); });
472✔
193
  d_lw->registerFunction<void(cas_t::*)(boost::variant<string,ComboAddress, vector<pair<unsigned int,string> > >)>("add",
472✔
194
    [](cas_t& cas, const boost::variant<string,ComboAddress,vector<pair<unsigned int,string> > >& in)
472✔
195
    {
472✔
196
      try {
×
197
      if(auto s = boost::get<string>(&in)) {
×
198
        cas.insert(ComboAddress(*s));
×
199
      }
×
200
      else if(auto v = boost::get<vector<pair<unsigned int, string> > >(&in)) {
×
201
        for(const auto& str : *v)
×
202
          cas.insert(ComboAddress(str.second));
×
203
      }
×
204
      else
×
205
        cas.insert(boost::get<ComboAddress>(in));
×
206
      }
×
207
      catch(std::exception& e) {
×
208
        SLOG(g_log <<Logger::Error<<e.what()<<endl,
×
209
             g_slog->withName("lua")->error(Logr::Error, e.what(), "Exception in newCAS", "exception", Logging::Loggable("std::exception")));
×
210
      }
×
211
    });
×
212
  d_lw->registerFunction<bool(cas_t::*)(const ComboAddress&)>("check",[](const cas_t& cas, const ComboAddress&ca) { return cas.count(ca)>0; });
472✔
213

214
  // QType
215
  d_lw->writeFunction("newQType", [](const string& s) { QType q; q = s; return q; });
520✔
216
  d_lw->registerFunction("getCode", &QType::getCode);
472✔
217
  d_lw->registerFunction("getName", &QType::toString);
472✔
218
  d_lw->registerEqFunction<bool(QType::*)(const QType&)>([](const QType& a, const QType& b){ return a == b;}); // operator overloading confuses LuaContext
472✔
219
  d_lw->registerToStringFunction(&QType::toString);
472✔
220

221
  // Netmask
222
  d_lw->writeFunction("newNetmask", [](const string& s) { return Netmask(s); });
472✔
223
  d_lw->registerFunction<ComboAddress(Netmask::*)()>("getNetwork", [](const Netmask& nm) { return nm.getNetwork(); } ); // const reference makes this necessary
472✔
224
  d_lw->registerFunction<ComboAddress(Netmask::*)()>("getMaskedNetwork", [](const Netmask& nm) { return nm.getMaskedNetwork(); } );
472✔
225
  d_lw->registerFunction("isIpv4", &Netmask::isIPv4);
472✔
226
  d_lw->registerFunction("isIPv4", &Netmask::isIPv4);
472✔
227
  d_lw->registerFunction("isIpv6", &Netmask::isIPv6);
472✔
228
  d_lw->registerFunction("isIPv6", &Netmask::isIPv6);
472✔
229
  d_lw->registerFunction("getBits", &Netmask::getBits);
472✔
230
  d_lw->registerFunction("toString", &Netmask::toString);
472✔
231
  d_lw->registerFunction("empty", &Netmask::empty);
472✔
232
  d_lw->registerFunction("match", (bool (Netmask::*)(const string&) const)&Netmask::match);
472✔
233
  d_lw->registerEqFunction(&Netmask::operator==);
472✔
234
  d_lw->registerToStringFunction(&Netmask::toString);
472✔
235

236
  // NetmaskGroup
237
  d_lw->writeFunction("newNMG", [](boost::optional<vector<pair<unsigned int, std::string>>> masks) {
472✔
UNCOV
238
    auto nmg = NetmaskGroup();
×
239

UNCOV
240
    if (masks) {
×
241
      for(const auto& mask: *masks) {
×
242
        nmg.addMask(mask.second);
×
243
      }
×
244
    }
×
245

UNCOV
246
    return nmg;
×
UNCOV
247
  });
×
248
  // d_lw->writeFunction("newNMG", []() { return NetmaskGroup(); });
249
  d_lw->registerFunction<void(NetmaskGroup::*)(const std::string&mask)>("addMask", [](NetmaskGroup&nmg, const std::string& mask) { nmg.addMask(mask); });
472✔
250
  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); } });
472!
251
  d_lw->registerFunction("match", (bool (NetmaskGroup::*)(const ComboAddress&) const)&NetmaskGroup::match);
472✔
252

253
  // DNSRecord
254
  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.setContent(shared_ptr<DNSRecordContent>(DNSRecordContent::make(dr.d_type, QClass::IN, content))); dr.d_place = static_cast<DNSResourceRecord::Place>(place); return dr; });
472✔
255
  d_lw->registerMember("name", &DNSRecord::d_name);
472✔
256
  d_lw->registerMember("type", &DNSRecord::d_type);
472✔
257
  d_lw->registerMember("ttl", &DNSRecord::d_ttl);
472✔
258
  d_lw->registerMember("place", &DNSRecord::d_place);
472✔
259
  d_lw->registerFunction<string(DNSRecord::*)()>("getContent", [](const DNSRecord& dr) { return dr.getContent()->getZoneRepresentation(); });
472✔
260
  d_lw->registerFunction<boost::optional<ComboAddress>(DNSRecord::*)()>("getCA", [](const DNSRecord& dr) {
472✔
261
      boost::optional<ComboAddress> ret;
×
262

263
      if(auto arec = getRR<ARecordContent>(dr))
×
264
        ret=arec->getCA(53);
×
265
      else if(auto aaaarec = getRR<AAAARecordContent>(dr))
×
266
        ret=aaaarec->getCA(53);
×
267
      return ret;
×
268
    });
×
269
  d_lw->registerFunction<void (DNSRecord::*)(const std::string&)>("changeContent", [](DNSRecord& dr, const std::string& newContent) { dr.setContent(shared_ptr<DNSRecordContent>(DNSRecordContent::make(dr.d_type, 1, newContent))); });
472✔
270

271
  // pdnslog
272
#if defined(PDNS_AUTH)
472✔
273
  d_lw->writeFunction("pdnslog", [](const std::string& msg, boost::optional<int> loglevel) {
472✔
274
    if (g_slogStructured) {
×
275
      auto log = g_slog->withName("lua");
276
      log->info(static_cast<Logr::Priority>(loglevel.get_value_or(Logr::Warning)), msg);
277
    }
278
    else {
279
      g_log << (Logger::Urgency)loglevel.get_value_or(Logger::Warning)<<msg<<endl;
280
    }
281
  });
282
#elif defined(RECURSOR)
283
  d_lw->writeFunction("pdnslog", [](const std::string& msg, boost::optional<int> loglevel, boost::optional<std::map<std::string, std::string>> values) {
284
    auto log = g_slog->withName("lua");
285
    if (values) {
×
286
      for (const auto& [key, value] : *values) {
×
287
        log = log->withValues(key, Logging::Loggable(value));
288
      }
289
    }
290
    log->info(static_cast<Logr::Priority>(loglevel.get_value_or(Logr::Warning)), msg);
291
  });
292
#else /* DNSDIST */
293
  d_lw->writeFunction("pdnslog", [](const std::string& msg, boost::optional<int> loglevel) {
294
    g_log << (Logger::Urgency)loglevel.get_value_or(Logger::Warning)<<msg<<endl;
295
  });
296
#endif
297

298
  d_lw->writeFunction("pdnsrandom", [](boost::optional<uint32_t> maximum) {
472✔
UNCOV
299
    return maximum ? dns_random(*maximum) : dns_random_uint32();
×
UNCOV
300
  });
×
301

302
  // certain constants
303

304
  vector<pair<string, int> > rcodes = {{"NOERROR",  RCode::NoError  },
472✔
305
                                       {"FORMERR",  RCode::FormErr  },
472✔
306
                                       {"SERVFAIL", RCode::ServFail },
472✔
307
                                       {"NXDOMAIN", RCode::NXDomain },
472✔
308
                                       {"NOTIMP",   RCode::NotImp   },
472✔
309
                                       {"REFUSED",  RCode::Refused  },
472✔
310
                                       {"YXDOMAIN", RCode::YXDomain },
472✔
311
                                       {"YXRRSET",  RCode::YXRRSet  },
472✔
312
                                       {"NXRRSET",  RCode::NXRRSet  },
472✔
313
                                       {"NOTAUTH",  RCode::NotAuth  },
472✔
314
                                       {"NOTZONE",  RCode::NotZone  },
472✔
315
                                       {"DROP",    -2               }}; // To give backport-incompatibility warning
472✔
316
  for(const auto& rcode : rcodes)
472✔
317
    d_pd.push_back({rcode.first, rcode.second});
5,658✔
318

319
  d_pd.push_back({"place", in_t{
472✔
320
    {"QUESTION", 0},
472✔
321
    {"ANSWER", 1},
472✔
322
    {"AUTHORITY", 2},
472✔
323
    {"ADDITIONAL", 3}
472✔
324
  }});
472✔
325

326
  d_pd.push_back({"loglevels", in_t{
472✔
327
        {"Alert", LOG_ALERT},
472✔
328
        {"Critical", LOG_CRIT},
472✔
329
        {"Debug", LOG_DEBUG},
472✔
330
        {"Emergency", LOG_EMERG},
472✔
331
        {"Info", LOG_INFO},
472✔
332
        {"Notice", LOG_NOTICE},
472✔
333
        {"Warning", LOG_WARNING},
472✔
334
        {"Error", LOG_ERR}
472✔
335
          }});
472✔
336

337
  for(const auto& n : QType::names)
472✔
338
    d_pd.push_back({n.first, n.second});
32,532✔
339

340
  d_lw->registerMember("tv_sec", &timeval::tv_sec);
472✔
341
  d_lw->registerMember("tv_usec", &timeval::tv_usec);
472✔
342

343
  postPrepareContext();
472✔
344

345
  // so we can let postprepare do changes to this
346
  d_lw->writeVariable("pdns", d_pd);
472✔
347
}
472✔
348

349
void BaseLua4::loadStream(std::istream &stream, bool doPostLoad) {
452✔
350
  d_lw->executeCode(stream);
452✔
351

352
  if (doPostLoad) {
452!
353
    postLoad();
452✔
354
  }
452✔
355
}
452✔
356

357
BaseLua4::~BaseLua4() = default;
18✔
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc