7120819346

Committed 06 Dec 2023 10:17AM UTC coverage: 57.643% (+0.03%) from 57.616%

Build # 7120819346

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13521 from omoerbeek/coverity20231120

rec: set of coverity fixes 20231120

Run Details

31769 of 86280 branches covered (0.0%)

Branch coverage included in aggregate %.

24 of 66 new or added lines in 20 files covered. (36.36%)

35 existing lines in 10 files now uncovered.

106779 of 154076 relevant lines covered (69.3%)

4525556.53 hits per line

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

82.61

/pdns/pollmplexer.cc

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "mplexer.hh"
#include "sstuff.hh"
#include <iostream>
#include <poll.h>
#include <unordered_map>
#include "misc.hh"
#include "namespaces.hh"

FDMultiplexer* FDMultiplexer::getMultiplexerSilent(unsigned int maxEventsHint)
{
  FDMultiplexer* ret = nullptr;
  for (const auto& i : FDMultiplexer::getMultiplexerMap()) {
    try {
      ret = i.second(std::min(maxEventsHint, FDMultiplexer::s_maxevents));
      return ret;
    }
    catch (const FDMultiplexerException& fe) {
    }
    catch (...) {
    }
  }
  return ret;
}

class PollFDMultiplexer : public FDMultiplexer
{
public:
  PollFDMultiplexer(unsigned int /* maxEventsHint */)
  {}
  ~PollFDMultiplexer()
  {
  }

  int run(struct timeval* tv, int timeout = 500) override;
  void getAvailableFDs(std::vector<int>& fds, int timeout) override;

  void addFD(int fd, FDMultiplexer::EventKind) override;
  void removeFD(int fd, FDMultiplexer::EventKind) override;

  string getName() const override
  {
    return "poll";
  }

private:
  std::unordered_map<int, struct pollfd> d_pollfds;
  vector<struct pollfd> preparePollFD() const;
};

static FDMultiplexer* make(unsigned int maxEventsHint)
{
  return new PollFDMultiplexer(maxEventsHint);
}

static struct RegisterOurselves
{
  RegisterOurselves()
  {
    FDMultiplexer::getMultiplexerMap().emplace(2, &make);
  }
} doIt;

static int convertEventKind(FDMultiplexer::EventKind kind)
{
  switch (kind) {
  case FDMultiplexer::EventKind::Read:
    return POLLIN;
  case FDMultiplexer::EventKind::Write:
    return POLLOUT;
  case FDMultiplexer::EventKind::Both:
    return POLLIN | POLLOUT;
  }
  throw std::runtime_error("Unhandled event kind in the ports multiplexer");
}

void PollFDMultiplexer::addFD(int fd, FDMultiplexer::EventKind kind)
{
  if (d_pollfds.count(fd) == 0) {
    auto& pollfd = d_pollfds[fd];
    pollfd.fd = fd;
    pollfd.events = 0;
  }
  auto& pollfd = d_pollfds.at(fd);
  pollfd.events |= convertEventKind(kind);
}

void PollFDMultiplexer::removeFD(int fd, FDMultiplexer::EventKind)
{
  d_pollfds.erase(fd);
}

vector<struct pollfd> PollFDMultiplexer::preparePollFD() const
{
  std::vector<struct pollfd> result;
  result.reserve(d_pollfds.size());
  for (const auto& entry : d_pollfds) {
    result.push_back(entry.second);
  }

  return result;
}

void PollFDMultiplexer::getAvailableFDs(std::vector<int>& fds, int timeout)
{
  auto pollfds = preparePollFD();
  if (pollfds.empty()) {
    return;
  }

  int ret = poll(&pollfds[0], pollfds.size(), timeout);

  if (ret < 0 && errno != EINTR) {
    throw FDMultiplexerException("poll returned error: " + stringerror());
  }

  for (const auto& pollfd : pollfds) {
    if (pollfd.revents & POLLIN || pollfd.revents & POLLOUT || pollfd.revents & POLLERR || pollfd.revents & POLLHUP) {
      fds.push_back(pollfd.fd);
    }
  }
}

int PollFDMultiplexer::run(struct timeval* now, int timeout)
{
  if (d_inrun) {
    throw FDMultiplexerException("FDMultiplexer::run() is not reentrant!\n");
  }

  auto pollfds = preparePollFD();
  if (pollfds.empty()) {
    gettimeofday(now, nullptr); // MANDATORY!
    return 0;
  }

  int ret = poll(&pollfds[0], pollfds.size(), timeout);
  gettimeofday(now, nullptr); // MANDATORY!

  if (ret < 0 && errno != EINTR) {
    throw FDMultiplexerException("poll returned error: " + stringerror());
  }

  d_inrun = true;
  int count = 0;
  for (const auto& pollfd : pollfds) {
    if (pollfd.revents & POLLIN || pollfd.revents & POLLERR || pollfd.revents & POLLHUP) {
      const auto& iter = d_readCallbacks.find(pollfd.fd);
      if (iter != d_readCallbacks.end()) {
        iter->d_callback(iter->d_fd, iter->d_parameter);
        count++;
      }
    }

    if (pollfd.revents & POLLOUT || pollfd.revents & POLLERR) {
      const auto& iter = d_writeCallbacks.find(pollfd.fd);
      if (iter != d_writeCallbacks.end()) {
        iter->d_callback(iter->d_fd, iter->d_parameter);
        count++;
      }
    }
  }

  d_inrun = false;
  return count;
}

#if 0

void acceptData(int fd, boost::any& parameter)
{
  cout<<"Have data on fd "<<fd<<endl;
  Socket* sock=boost::any_cast<Socket*>(parameter);
  string packet;
  IPEndpoint rem;
  sock->recvFrom(packet, rem);
  cout<<"Received "<<packet.size()<<" bytes!\n";
}


int main()
{
  Socket s(AF_INET, SOCK_DGRAM);

  IPEndpoint loc("0.0.0.0", 2000);
  s.bind(loc);

  PollFDMultiplexer sfm;

  sfm.addReadFD(s.getHandle(), &acceptData, &s);

  for(int n=0; n < 100 ; ++n) {
    sfm.run();
  }
  sfm.removeReadFD(s.getHandle());
  sfm.removeReadFD(s.getHandle());
}
#endif

1	#ifdef HAVE_CONFIG_H
2	#include "config.h"
3	#endif
4	#include "mplexer.hh"
5	#include "sstuff.hh"
6	#include <iostream>
7	#include <poll.h>
8	#include <unordered_map>
9	#include "misc.hh"
10	#include "namespaces.hh"
11
12	FDMultiplexer* FDMultiplexer::getMultiplexerSilent(unsigned int maxEventsHint)
13	{	4,444✔
14	FDMultiplexer* ret = nullptr;	4,444✔
15	for (const auto& i : FDMultiplexer::getMultiplexerMap()) {	4,449!
16	try {	4,449✔
17	ret = i.second(std::min(maxEventsHint, FDMultiplexer::s_maxevents));	4,449✔
18	return ret;	4,449✔
19	}	4,449✔
20	catch (const FDMultiplexerException& fe) {	4,449✔
21	}	5✔
22	catch (...) {	4,449✔
23	}	×
24	}	4,449✔
UNCOV 25	return ret;	×
26	}	4,444✔
27
28	class PollFDMultiplexer : public FDMultiplexer
29	{
30	public:
31	PollFDMultiplexer(unsigned int /* maxEventsHint */)
32	{}	13✔
33	~PollFDMultiplexer()
34	{	13✔
35	}	13✔
36
37	int run(struct timeval* tv, int timeout = 500) override;
38	void getAvailableFDs(std::vector<int>& fds, int timeout) override;
39
40	void addFD(int fd, FDMultiplexer::EventKind) override;
41	void removeFD(int fd, FDMultiplexer::EventKind) override;
42
43	string getName() const override
44	{	×
45	return "poll";	×
46	}	×
47
48	private:
49	std::unordered_map<int, struct pollfd> d_pollfds;
50	vector<struct pollfd> preparePollFD() const;
51	};
52
53	static FDMultiplexer* make(unsigned int maxEventsHint)
54	{	13✔
55	return new PollFDMultiplexer(maxEventsHint);	13✔
56	}	13✔
57
58	static struct RegisterOurselves
59	{
60	RegisterOurselves()
61	{	596✔
62	FDMultiplexer::getMultiplexerMap().emplace(2, &make);	596✔
63	}	596✔
64	} doIt;
65
66	static int convertEventKind(FDMultiplexer::EventKind kind)
67	{	28✔
68	switch (kind) {	28!
69	case FDMultiplexer::EventKind::Read:	8✔
70	return POLLIN;	8✔
71	case FDMultiplexer::EventKind::Write:	16✔
72	return POLLOUT;	16✔
73	case FDMultiplexer::EventKind::Both:	4✔
74	return POLLIN \| POLLOUT;	4✔
75	}	28✔
76	throw std::runtime_error("Unhandled event kind in the ports multiplexer");	×
77	}	28✔
78
79	void PollFDMultiplexer::addFD(int fd, FDMultiplexer::EventKind kind)
80	{	28✔
81	if (d_pollfds.count(fd) == 0) {	28✔
82	auto& pollfd = d_pollfds[fd];	24✔
83	pollfd.fd = fd;	24✔
84	pollfd.events = 0;	24✔
85	}	24✔
86	auto& pollfd = d_pollfds.at(fd);	28✔
87	pollfd.events \|= convertEventKind(kind);	28✔
88	}	28✔
89
90	void PollFDMultiplexer::removeFD(int fd, FDMultiplexer::EventKind)
91	{	24✔
92	d_pollfds.erase(fd);	24✔
93	}	24✔
94
95	vector<struct pollfd> PollFDMultiplexer::preparePollFD() const
96	{	68✔
97	std::vector<struct pollfd> result;	68✔
98	result.reserve(d_pollfds.size());	68✔
99	for (const auto& entry : d_pollfds) {	68✔
100	result.push_back(entry.second);	60✔
101	}	60✔
102
103	return result;	68✔
104	}	68✔
105
106	void PollFDMultiplexer::getAvailableFDs(std::vector<int>& fds, int timeout)
107	{	36✔
108	auto pollfds = preparePollFD();	36✔
109	if (pollfds.empty()) {	36✔
110	return;	8✔
111	}	8✔
112
113	int ret = poll(&pollfds[0], pollfds.size(), timeout);	28✔
114
115	if (ret < 0 && errno != EINTR) {	28!
116	throw FDMultiplexerException("poll returned error: " + stringerror());	×
117	}	×
118
119	for (const auto& pollfd : pollfds) {	32✔
120	if (pollfd.revents & POLLIN \|\| pollfd.revents & POLLOUT \|\| pollfd.revents & POLLERR \|\| pollfd.revents & POLLHUP) {	32!
121	fds.push_back(pollfd.fd);	28✔
122	}	28✔
123	}	32✔
124	}	28✔
125
126	int PollFDMultiplexer::run(struct timeval* now, int timeout)
127	{	32✔
128	if (d_inrun) {	32!
129	throw FDMultiplexerException("FDMultiplexer::run() is not reentrant!\n");	×
130	}	×
131
132	auto pollfds = preparePollFD();	32✔
133	if (pollfds.empty()) {	32✔
134	gettimeofday(now, nullptr); // MANDATORY!	8✔
135	return 0;	8✔
136	}	8✔
137
138	int ret = poll(&pollfds[0], pollfds.size(), timeout);	24✔
139	gettimeofday(now, nullptr); // MANDATORY!	24✔
140
141	if (ret < 0 && errno != EINTR) {	24!
142	throw FDMultiplexerException("poll returned error: " + stringerror());	×
143	}	×
144
145	d_inrun = true;	24✔
146	int count = 0;	24✔
147	for (const auto& pollfd : pollfds) {	28✔
148	if (pollfd.revents & POLLIN \|\| pollfd.revents & POLLERR \|\| pollfd.revents & POLLHUP) {	28!
149	const auto& iter = d_readCallbacks.find(pollfd.fd);	12✔
150	if (iter != d_readCallbacks.end()) {	12!
151	iter->d_callback(iter->d_fd, iter->d_parameter);	12✔
152	count++;	12✔
153	}	12✔
154	}	12✔
155
156	if (pollfd.revents & POLLOUT \|\| pollfd.revents & POLLERR) {	28!
157	const auto& iter = d_writeCallbacks.find(pollfd.fd);	16✔
158	if (iter != d_writeCallbacks.end()) {	16!
159	iter->d_callback(iter->d_fd, iter->d_parameter);	16✔
160	count++;	16✔
161	}	16✔
162	}	16✔
163	}	28✔
164
165	d_inrun = false;	24✔
166	return count;	24✔
167	}	24✔
168
169	#if 0
170
171	void acceptData(int fd, boost::any& parameter)
172	{
173	cout<<"Have data on fd "<<fd<<endl;
174	Socket* sock=boost::any_cast<Socket*>(parameter);
175	string packet;
176	IPEndpoint rem;
177	sock->recvFrom(packet, rem);
178	cout<<"Received "<<packet.size()<<" bytes!\n";
179	}
180
181
182	int main()
183	{
184	Socket s(AF_INET, SOCK_DGRAM);
185
186	IPEndpoint loc("0.0.0.0", 2000);
187	s.bind(loc);
188
189	PollFDMultiplexer sfm;
190
191	sfm.addReadFD(s.getHandle(), &acceptData, &s);
192
193	for(int n=0; n < 100 ; ++n) {
194	sfm.run();
195	}
196	sfm.removeReadFD(s.getHandle());
197	sfm.removeReadFD(s.getHandle());
198	}
199	#endif

PowerDNS / pdns / 7120819346

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