11389386292

Committed 17 Oct 2024 04:47PM UTC coverage: 60.82% (-3.8%) from 64.658%

Build # 11389386292

Build Type

Pull #14782

github

Committed by

web-flow

Commit Message

Merge a15771b94 into 271961a52

Pull Request Pull Request #14782: Rework MDBIn/OutVal

Run Details

22556 of 54234 branches covered (41.59%)

Branch coverage included in aggregate %.

62 of 85 new or added lines in 2 files covered. (72.94%)

7695 existing lines in 105 files now uncovered.

78839 of 112478 relevant lines covered (70.09%)

5029772.14 hits per line

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

0.0

/pdns/snmp-agent.cc

#include "snmp-agent.hh"
#include "misc.hh"
#include "threadname.hh"
#ifdef RECURSOR
#include "logger.hh"
#else
#include "dolog.hh"
#endif

#ifdef HAVE_NET_SNMP

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/definitions.h>
#include <net-snmp/types.h>
#include <net-snmp/utilities.h>
#include <net-snmp/config_api.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#undef INET6 /* SRSLY? */

#ifndef HAVE_SNMP_SELECT_INFO2
/* that's terrible, because it means we are going to have trouble with large
   FD numbers at some point.. */
# define netsnmp_large_fd_set fd_set
# define snmp_read2 snmp_read
# define snmp_select_info2 snmp_select_info
# define netsnmp_large_fd_set_init(...)
# define netsnmp_large_fd_set_cleanup(...)
# define NETSNMP_LARGE_FD_SET FD_SET
# define NETSNMP_LARGE_FD_CLR FD_CLR
# define NETSNMP_LARGE_FD_ZERO FD_ZERO
# define NETSNMP_LARGE_FD_ISSET FD_ISSET
#else
# include <net-snmp/library/large_fd_set.h>
#endif

static const std::array<oid, 11> s_snmpTrapOID = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };

int SNMPAgent::setCounter64Value(netsnmp_request_info* request,
                                 uint64_t value)
{
  struct counter64 val64;
  val64.high = value >> 32;
  val64.low = value & 0xffffffff;
  snmp_set_var_typed_value(request->requestvb,
                           ASN_COUNTER64,
                           &val64,
                           sizeof(val64));
  return SNMP_ERR_NOERROR;
}

void SNMPAgent::addSNMPTrapOID(netsnmp_variable_list** varList, const void* value, size_t len)
{
  snmp_varlist_add_variable(varList,
                            s_snmpTrapOID.data(),
                            s_snmpTrapOID.size(),
                            ASN_OBJECT_ID,
                            value,
                            len);
}

bool SNMPAgent::sendTrap(pdns::channel::Sender<netsnmp_variable_list, void(*)(netsnmp_variable_list*)>& sender,
                         netsnmp_variable_list* varList)
{
  try  {
    auto obj = std::unique_ptr<netsnmp_variable_list, void(*)(netsnmp_variable_list*)>(varList, snmp_free_varbind);
    return sender.send(std::move(obj));
  }
  catch (...) {
    return false;
  }
}

void SNMPAgent::handleTrapsEvent()
{
  try {
    while (true) {
      auto obj = d_receiver.receive(snmp_free_varbind);
      if (!obj) {
        break;
      }
      send_v2trap(obj->get());
    }
  }
  catch (const std::exception& e) {
  }
}

void SNMPAgent::handleSNMPQueryEvent(int fd)
{
  netsnmp_large_fd_set fdset;
  netsnmp_large_fd_set_init(&fdset, FD_SETSIZE);
  NETSNMP_LARGE_FD_ZERO(&fdset);
  NETSNMP_LARGE_FD_SET(fd, &fdset);
  snmp_read2(&fdset);
}

void SNMPAgent::handleTrapsCB(int /* fd */, FDMultiplexer::funcparam_t& var)
{
  SNMPAgent** agent = boost::any_cast<SNMPAgent*>(&var);
  if (!agent || !*agent)
    throw std::runtime_error("Invalid value received in SNMP trap callback");

  (*agent)->handleTrapsEvent();
}

void SNMPAgent::handleSNMPQueryCB(int fd, FDMultiplexer::funcparam_t& var)
{
  SNMPAgent** agent = boost::any_cast<SNMPAgent*>(&var);
  if (!agent || !*agent)
    throw std::runtime_error("Invalid value received in SNMP trap callback");

  (*agent)->handleSNMPQueryEvent(fd);
}

#endif /* HAVE_NET_SNMP */

void SNMPAgent::worker()
{
#ifdef HAVE_NET_SNMP
  FDMultiplexer* mplexer = FDMultiplexer::getMultiplexerSilent();
  if (mplexer == nullptr) {
    throw std::runtime_error("No FD multiplexer found for the SNMP agent!");
  }

#ifdef RECURSOR
  string threadName = "rec/snmp";
#else
  string threadName = "dnsdist/SNMP";
#endif
  setThreadName(threadName);

  int maxfd = 0;
  int block = 1;
  netsnmp_large_fd_set fdset;
  struct timeval timeout = { 0, 0 };
  struct timeval now;

  /* we want to be notified if a trap is waiting
   to be sent */
  mplexer->addReadFD(d_receiver.getDescriptor(), &handleTrapsCB, this);

  while(true) {
    netsnmp_large_fd_set_init(&fdset, FD_SETSIZE);
    NETSNMP_LARGE_FD_ZERO(&fdset);

    block = 1;
    timeout = { 0, 0 };
    snmp_select_info2(&maxfd, &fdset, &timeout, &block);

    for (int fd = 0; fd < maxfd; fd++) {
      if (NETSNMP_LARGE_FD_ISSET(fd, &fdset)) {
        mplexer->addReadFD(fd, &handleSNMPQueryCB, this);
      }
    }

    /* run updates now */
    int res = mplexer->run(&now, (timeout.tv_sec * 1000) + (timeout.tv_usec / 1000));

    /* we handle timeouts here, the rest has already been handled by callbacks */
    if (res == 0) {
      snmp_timeout();
      run_alarms();
    }

    for (int fd = 0; fd < maxfd; fd++) {
      if (NETSNMP_LARGE_FD_ISSET(fd, &fdset)) {
        try {
          mplexer->removeReadFD(fd);
        }
        catch(const FDMultiplexerException& e) {
          /* we might get an exception when removing a closed file descriptor,
             just ignore it */
        }
      }
    }
  }
#endif /* HAVE_NET_SNMP */
}

SNMPAgent::SNMPAgent([[maybe_unused]] const std::string& name, [[maybe_unused]] const std::string& daemonSocket)
{
#ifdef HAVE_NET_SNMP
  netsnmp_enable_subagent();
  snmp_disable_log();
  if (!daemonSocket.empty()) {
    netsnmp_ds_set_string(NETSNMP_DS_APPLICATION_ID,
                          NETSNMP_DS_AGENT_X_SOCKET,
                          daemonSocket.c_str());
  }
  /* no need to load any MIBS,
     and it causes import errors if some modules are not present */
  setenv("MIBS", "", 1);

  init_agent(name.c_str());

  /* we use select() so don't use SIGALARM to handle alarms.
     Note that we need to handle alarms for automatic reconnection
     to the daemon to work.
  */
  netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,
                         NETSNMP_DS_LIB_ALARM_DONT_USE_SIG,
                         1);

  init_snmp(name.c_str());

  auto [sender, receiver] = pdns::channel::createObjectQueue<netsnmp_variable_list, void(*)(netsnmp_variable_list*)>();
  d_sender = std::move(sender);
  d_receiver = std::move(receiver);
#endif /* HAVE_NET_SNMP */
}

1	#include "snmp-agent.hh"
2	#include "misc.hh"
3	#include "threadname.hh"
4	#ifdef RECURSOR
5	#include "logger.hh"
6	#else
7	#include "dolog.hh"
8	#endif
9
10	#ifdef HAVE_NET_SNMP
11
12	#include <net-snmp/net-snmp-config.h>
13	#include <net-snmp/definitions.h>
14	#include <net-snmp/types.h>
15	#include <net-snmp/utilities.h>
16	#include <net-snmp/config_api.h>
17	#include <net-snmp/agent/net-snmp-agent-includes.h>
18	#undef INET6 /* SRSLY? */
19
20	#ifndef HAVE_SNMP_SELECT_INFO2
21	/* that's terrible, because it means we are going to have trouble with large
22	FD numbers at some point.. */
23	# define netsnmp_large_fd_set fd_set
24	# define snmp_read2 snmp_read
25	# define snmp_select_info2 snmp_select_info
26	# define netsnmp_large_fd_set_init(...)
27	# define netsnmp_large_fd_set_cleanup(...)
28	# define NETSNMP_LARGE_FD_SET FD_SET
29	# define NETSNMP_LARGE_FD_CLR FD_CLR
30	# define NETSNMP_LARGE_FD_ZERO FD_ZERO
31	# define NETSNMP_LARGE_FD_ISSET FD_ISSET
32	#else
33	# include <net-snmp/library/large_fd_set.h>
34	#endif
35
36	static const std::array<oid, 11> s_snmpTrapOID = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };
37
38	int SNMPAgent::setCounter64Value(netsnmp_request_info* request,
39	uint64_t value)
UNCOV 40	{	×
UNCOV 41	struct counter64 val64;	×
UNCOV 42	val64.high = value >> 32;	×
UNCOV 43	val64.low = value & 0xffffffff;	×
UNCOV 44	snmp_set_var_typed_value(request->requestvb,	×
UNCOV 45	ASN_COUNTER64,	×
UNCOV 46	&val64,	×
UNCOV 47	sizeof(val64));	×
UNCOV 48	return SNMP_ERR_NOERROR;	×
UNCOV 49	}	×
50
51	void SNMPAgent::addSNMPTrapOID(netsnmp_variable_list** varList, const void* value, size_t len)
52	{	×
53	snmp_varlist_add_variable(varList,	×
54	s_snmpTrapOID.data(),	×
55	s_snmpTrapOID.size(),	×
56	ASN_OBJECT_ID,	×
57	value,	×
58	len);	×
59	}	×
60
61	bool SNMPAgent::sendTrap(pdns::channel::Sender<netsnmp_variable_list, void()(netsnmp_variable_list)>& sender,
62	netsnmp_variable_list* varList)
63	{	×
64	try {	×
65	auto obj = std::unique_ptr<netsnmp_variable_list, void()(netsnmp_variable_list)>(varList, snmp_free_varbind);	×
66	return sender.send(std::move(obj));	×
67	}	×
68	catch (...) {	×
69	return false;	×
70	}	×
71	}	×
72
73	void SNMPAgent::handleTrapsEvent()
74	{	×
75	try {	×
76	while (true) {	×
77	auto obj = d_receiver.receive(snmp_free_varbind);	×
78	if (!obj) {	×
79	break;	×
80	}	×
81	send_v2trap(obj->get());	×
82	}	×
83	}	×
84	catch (const std::exception& e) {	×
85	}	×
86	}	×
87
88	void SNMPAgent::handleSNMPQueryEvent(int fd)
UNCOV 89	{	×
UNCOV 90	netsnmp_large_fd_set fdset;	×
UNCOV 91	netsnmp_large_fd_set_init(&fdset, FD_SETSIZE);	×
UNCOV 92	NETSNMP_LARGE_FD_ZERO(&fdset);	×
UNCOV 93	NETSNMP_LARGE_FD_SET(fd, &fdset);	×
UNCOV 94	snmp_read2(&fdset);	×
UNCOV 95	}	×
96
97	void SNMPAgent::handleTrapsCB(int /* fd */, FDMultiplexer::funcparam_t& var)
98	{	×
99	SNMPAgent** agent = boost::any_cast<SNMPAgent*>(&var);	×
100	if (!agent \|\| !*agent)	×
101	throw std::runtime_error("Invalid value received in SNMP trap callback");	×
102
103	(*agent)->handleTrapsEvent();	×
104	}	×
105
106	void SNMPAgent::handleSNMPQueryCB(int fd, FDMultiplexer::funcparam_t& var)
UNCOV 107	{	×
UNCOV 108	SNMPAgent** agent = boost::any_cast<SNMPAgent*>(&var);	×
UNCOV 109	if (!agent \|\| !*agent)	×
110	throw std::runtime_error("Invalid value received in SNMP trap callback");	×
111
UNCOV 112	(*agent)->handleSNMPQueryEvent(fd);	×
UNCOV 113	}	×
114
115	#endif /* HAVE_NET_SNMP */
116
117	void SNMPAgent::worker()
UNCOV 118	{	×
UNCOV 119	#ifdef HAVE_NET_SNMP	×
UNCOV 120	FDMultiplexer* mplexer = FDMultiplexer::getMultiplexerSilent();	×
UNCOV 121	if (mplexer == nullptr) {	×
122	throw std::runtime_error("No FD multiplexer found for the SNMP agent!");	×
123	}	×
124
UNCOV 125	#ifdef RECURSOR	×
UNCOV 126	string threadName = "rec/snmp";	×
127	#else
128	string threadName = "dnsdist/SNMP";
129	#endif
UNCOV 130	setThreadName(threadName);	×
131
UNCOV 132	int maxfd = 0;	×
UNCOV 133	int block = 1;	×
UNCOV 134	netsnmp_large_fd_set fdset;	×
UNCOV 135	struct timeval timeout = { 0, 0 };	×
UNCOV 136	struct timeval now;	×
137
138	/* we want to be notified if a trap is waiting
139	to be sent */
UNCOV 140	mplexer->addReadFD(d_receiver.getDescriptor(), &handleTrapsCB, this);	×
141
UNCOV 142	while(true) {	×
UNCOV 143	netsnmp_large_fd_set_init(&fdset, FD_SETSIZE);	×
UNCOV 144	NETSNMP_LARGE_FD_ZERO(&fdset);	×
145
UNCOV 146	block = 1;	×
UNCOV 147	timeout = { 0, 0 };	×
UNCOV 148	snmp_select_info2(&maxfd, &fdset, &timeout, &block);	×
149
UNCOV 150	for (int fd = 0; fd < maxfd; fd++) {	×
UNCOV 151	if (NETSNMP_LARGE_FD_ISSET(fd, &fdset)) {	×
UNCOV 152	mplexer->addReadFD(fd, &handleSNMPQueryCB, this);	×
UNCOV 153	}	×
UNCOV 154	}	×
155
156	/* run updates now */
UNCOV 157	int res = mplexer->run(&now, (timeout.tv_sec * 1000) + (timeout.tv_usec / 1000));	×
158
159	/* we handle timeouts here, the rest has already been handled by callbacks */
UNCOV 160	if (res == 0) {	×
161	snmp_timeout();	×
162	run_alarms();	×
163	}	×
164
UNCOV 165	for (int fd = 0; fd < maxfd; fd++) {	×
UNCOV 166	if (NETSNMP_LARGE_FD_ISSET(fd, &fdset)) {	×
UNCOV 167	try {	×
UNCOV 168	mplexer->removeReadFD(fd);	×
UNCOV 169	}	×
UNCOV 170	catch(const FDMultiplexerException& e) {	×
171	/* we might get an exception when removing a closed file descriptor,
172	just ignore it */
173	}	×
UNCOV 174	}	×
UNCOV 175	}	×
UNCOV 176	}	×
UNCOV 177	#endif /* HAVE_NET_SNMP */	×
UNCOV 178	}	×
179
180	SNMPAgent::SNMPAgent([[maybe_unused]] const std::string& name, [[maybe_unused]] const std::string& daemonSocket)
UNCOV 181	{	×
UNCOV 182	#ifdef HAVE_NET_SNMP	×
UNCOV 183	netsnmp_enable_subagent();	×
UNCOV 184	snmp_disable_log();	×
UNCOV 185	if (!daemonSocket.empty()) {	×
186	netsnmp_ds_set_string(NETSNMP_DS_APPLICATION_ID,	×
187	NETSNMP_DS_AGENT_X_SOCKET,	×
188	daemonSocket.c_str());	×
189	}	×
190	/* no need to load any MIBS,
191	and it causes import errors if some modules are not present */
UNCOV 192	setenv("MIBS", "", 1);	×
193
UNCOV 194	init_agent(name.c_str());	×
195
196	/* we use select() so don't use SIGALARM to handle alarms.
197	Note that we need to handle alarms for automatic reconnection
198	to the daemon to work.
199	*/
UNCOV 200	netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID,	×
UNCOV 201	NETSNMP_DS_LIB_ALARM_DONT_USE_SIG,	×
UNCOV 202	1);	×
203
UNCOV 204	init_snmp(name.c_str());	×
205
UNCOV 206	auto [sender, receiver] = pdns::channel::createObjectQueue<netsnmp_variable_list, void()(netsnmp_variable_list)>();	×
UNCOV 207	d_sender = std::move(sender);	×
UNCOV 208	d_receiver = std::move(receiver);	×
UNCOV 209	#endif /* HAVE_NET_SNMP */	×
UNCOV 210	}	×

PowerDNS / pdns / 11389386292

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

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