6545214347

Committed 17 Oct 2023 09:25AM UTC coverage: 57.644% (+0.3%) from 57.388%

Build # 6545214347

Build Type

Pull #13381

github

Committed by

web-flow

Commit Message

Merge 9085eae25 into 477220170

Pull Request Pull Request #13381: dnsdist: Fix the case where nghttp2 is available but DoH is disabled

Run Details

31288 of 84870 branches covered (0.0%)

Branch coverage included in aggregate %.

27 of 38 new or added lines in 7 files covered. (71.05%)

209 existing lines in 8 files now uncovered.

105646 of 152680 relevant lines covered (69.19%)

2635021.3 hits per line

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

55.97

/pdns/channel.hh

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#pragma once
#include <memory>
#include <optional>

#include "misc.hh"

/* g++ defines __SANITIZE_THREAD__
   clang++ supports the nice __has_feature(thread_sanitizer),
   let's merge them */
#if defined(__has_feature)
#if __has_feature(thread_sanitizer)
#define __SANITIZE_THREAD__ 1
#endif
#endif

#if __SANITIZE_THREAD__
#if defined __has_include
#if __has_include(<sanitizer/tsan_interface.h>)
#include <sanitizer/tsan_interface.h>
#else /* __has_include(<sanitizer/tsan_interface.h>) */
extern "C" void __tsan_acquire(void* addr);
extern "C" void __tsan_release(void* addr);
#endif /* __has_include(<sanitizer/tsan_interface.h>) */
#else /* defined __has_include */
extern "C" void __tsan_acquire(void* addr);
extern "C" void __tsan_release(void* addr);
#endif /* defined __has_include */
#endif /* __SANITIZE_THREAD__ */

namespace pdns
{
namespace channel
{
  enum class SenderBlockingMode
  {
    SenderNonBlocking,
    SenderBlocking
  };
  enum class ReceiverBlockingMode
  {
    ReceiverNonBlocking,
    ReceiverBlocking
  };

  /**
   * The sender's end of a channel used to pass objects between threads.
   *
   * A sender can be used by several threads in a safe way.
   */
  template <typename T, typename D = std::default_delete<T>>
  class Sender
  {
  public:
    Sender() = default;
    Sender(FDWrapper&& descriptor) :
      d_fd(std::move(descriptor))
    {
    }
    Sender(const Sender&) = delete;
    Sender& operator=(const Sender&) = delete;
    Sender(Sender&&) = default;
    Sender& operator=(Sender&&) = default;
    ~Sender() = default;
    /**
     * \brief Try to send the supplied object to the other end of that channel. Might block if the channel was created in blocking mode.
     *
     * \return True if the object was properly sent, False if the channel is full.
     *
     * \throw runtime_error if the channel is broken, for example if the other end has been closed.
     */
    bool send(std::unique_ptr<T, D>&&) const;
    void close();

  private:
    FDWrapper d_fd;
  };

  /**
   * The receiver's end of a channel used to pass objects between threads.
   *
   * A receiver can be used by several threads in a safe way, but in that case spurious wake up might happen.
   */
  template <typename T, typename D = std::default_delete<T>>
  class Receiver
  {
  public:
    Receiver() = default;
    Receiver(FDWrapper&& descriptor, bool throwOnEOF = true) :
      d_fd(std::move(descriptor)), d_throwOnEOF(throwOnEOF)
    {
    }
    Receiver(const Receiver&) = delete;
    Receiver& operator=(const Receiver&) = delete;
    Receiver(Receiver&&) = default;
    Receiver& operator=(Receiver&&) = default;
    ~Receiver() = default;
    /**
     * \brief Try to read an object sent by the other end of that channel. Might block if the channel was created in blocking mode.
     *
     * \return An object if one was available, and std::nullopt otherwise.
     *
     * \throw runtime_error if the channel is broken, for example if the other end has been closed.
     */
    std::optional<std::unique_ptr<T, D>> receive();
    std::optional<std::unique_ptr<T, D>> receive(D deleter);

    /**
     * \brief Get a descriptor that can be used with an I/O multiplexer to wait for an object to become available.
     *
     * \return A valid descriptor or -1 if the Receiver was not properly initialized.
     */
    int getDescriptor() const
    {
      return d_fd.getHandle();
    }
    /**
     * \brief Whether the remote end has closed the channel.
     */
    bool isClosed() const
    {
      return d_closed;
    }

  private:
    FDWrapper d_fd;
    bool d_closed{false};
    bool d_throwOnEOF{true};
  };

  /**
   * \brief Create a channel to pass objects between threads, accepting multiple senders and receivers.
   *
   * \return A pair of Sender and Receiver objects.
   *
   * \throw runtime_error if the channel creation failed.
   */
  template <typename T, typename D = std::default_delete<T>>
  std::pair<Sender<T, D>, Receiver<T, D>> createObjectQueue(SenderBlockingMode senderBlockingMode = SenderBlockingMode::SenderNonBlocking, ReceiverBlockingMode receiverBlockingMode = ReceiverBlockingMode::ReceiverNonBlocking, size_t pipeBufferSize = 0, bool throwOnEOF = true);

  /**
   * The notifier's end of a channel used to communicate between threads.
   *
   * A notifier can be used by several threads in a safe way.
   */
  class Notifier
  {
  public:
    Notifier() = default;
    Notifier(FDWrapper&&);
    Notifier(const Notifier&) = delete;
    Notifier& operator=(const Notifier&) = delete;
    Notifier(Notifier&&) = default;
    Notifier& operator=(Notifier&&) = default;
    ~Notifier() = default;

    /**
     * \brief Queue a notification to wake up the other end of the channel.
     *
     * \return True if the notification was properly sent, False if the channel is full.
     *
     * \throw runtime_error if the channel is broken, for example if the other end has been closed.
     */
    bool notify() const;

  private:
    FDWrapper d_fd;
  };

  /**
   * The waiter's end of a channel used to communicate between threads.
   *
   * A waiter can be used by several threads in a safe way, but in that case spurious wake up might happen.
   */
  class Waiter
  {
  public:
    Waiter() = default;
    Waiter(FDWrapper&&, bool throwOnEOF = true);
    Waiter(const Waiter&) = delete;
    Waiter& operator=(const Waiter&) = delete;
    Waiter(Waiter&&) = default;
    Waiter& operator=(Waiter&&) = default;
    ~Waiter() = default;

    /**
     * \brief Clear all notifications queued on that channel, if any.
     */
    void clear();
    /**
     * \brief Get a descriptor that can be used with an I/O multiplexer to wait for a notification to arrive.
     *
     * \return A valid descriptor or -1 if the Waiter was not properly initialized.
     */
    int getDescriptor() const;
    /**
     * \brief Whether the remote end has closed the channel.
     */
    bool isClosed() const
    {
      return d_closed;
    }

  private:
    FDWrapper d_fd;
    bool d_closed{false};
    bool d_throwOnEOF{true};
  };

  /**
   * \brief Create a channel to notify one thread from another one, accepting multiple senders and receivers.
   *
   * \return A pair of Notifier and Sender objects.
   *
   * \throw runtime_error if the channel creation failed.
   */
  std::pair<Notifier, Waiter> createNotificationQueue(bool nonBlocking = true, size_t pipeBufferSize = 0, bool throwOnEOF = true);

  template <typename T, typename D>
  bool Sender<T, D>::send(std::unique_ptr<T, D>&& object) const
  {
    /* we cannot touch the initial unique pointer after writing to the pipe,
       not even to release it, so let's transfer it to a local object */
    auto localObj = std::move(object);
    auto ptr = localObj.get();
    static_assert(sizeof(ptr) <= PIPE_BUF, "Writes up to PIPE_BUF are guaranted not to interleaved and to either fully succeed or fail");
    while (true) {
#if __SANITIZE_THREAD__
      __tsan_release(ptr);
#endif /* __SANITIZE_THREAD__ */
      ssize_t sent = write(d_fd.getHandle(), &ptr, sizeof(ptr));

      if (sent == sizeof(ptr)) {
        // coverity[leaked_storage]
        localObj.release();
        return true;
      }
      else if (sent == 0) {
#if __SANITIZE_THREAD__
        __tsan_acquire(ptr);
#endif /* __SANITIZE_THREAD__ */
        throw std::runtime_error("Unable to write to channel: remote end has been closed");
      }
      else {
#if __SANITIZE_THREAD__
        __tsan_acquire(ptr);
#endif /* __SANITIZE_THREAD__ */
        if (errno == EINTR) {
          continue;
        }
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
          object = std::move(localObj);
          return false;
        }
        else {
          throw std::runtime_error("Unable to write to channel:" + stringerror());
        }
      }
    }
  }

  template <typename T, typename D>
  void Sender<T, D>::close()
  {
    d_fd.reset();
  }

  template <typename T, typename D>
  std::optional<std::unique_ptr<T, D>> Receiver<T, D>::receive()
  {
    return receive(D());
  }

  template <typename T, typename D>
  std::optional<std::unique_ptr<T, D>> Receiver<T, D>::receive(D deleter)
  {
    while (true) {
      std::optional<std::unique_ptr<T, D>> result;
      T* objPtr{nullptr};
      ssize_t got = read(d_fd.getHandle(), &objPtr, sizeof(objPtr));
      if (got == sizeof(objPtr)) {
#if __SANITIZE_THREAD__
        __tsan_acquire(objPtr);
#endif /* __SANITIZE_THREAD__ */
        return std::unique_ptr<T, D>(objPtr, deleter);
      }
      else if (got == 0) {
        d_closed = true;
        if (!d_throwOnEOF) {
          return result;
        }
        throw std::runtime_error("EOF while reading from Channel receiver");
      }
      else if (got == -1) {
        if (errno == EINTR) {
          continue;
        }
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
          return result;
        }
        throw std::runtime_error("Error while reading from Channel receiver: " + stringerror());
      }
      else {
        throw std::runtime_error("Partial read from Channel receiver");
      }
    }
  }

  template <typename T, typename D>
  std::pair<Sender<T, D>, Receiver<T, D>> createObjectQueue(SenderBlockingMode senderBlockingMode, ReceiverBlockingMode receiverBlockingMode, size_t pipeBufferSize, bool throwOnEOF)
  {
    int fds[2] = {-1, -1};
    if (pipe(fds) < 0) {
      throw std::runtime_error("Error creating channel pipe: " + stringerror());
    }

    FDWrapper sender(fds[1]);
    FDWrapper receiver(fds[0]);
    if (receiverBlockingMode == ReceiverBlockingMode::ReceiverNonBlocking && !setNonBlocking(receiver.getHandle())) {
      int err = errno;
      throw std::runtime_error("Error making channel pipe non-blocking: " + stringerror(err));
    }

    if (senderBlockingMode == SenderBlockingMode::SenderNonBlocking && !setNonBlocking(sender.getHandle())) {
      int err = errno;
      throw std::runtime_error("Error making channel pipe non-blocking: " + stringerror(err));
    }

    if (pipeBufferSize > 0 && getPipeBufferSize(receiver.getHandle()) < pipeBufferSize) {
      setPipeBufferSize(receiver.getHandle(), pipeBufferSize);
    }

    return {Sender<T, D>(std::move(sender)), Receiver<T, D>(std::move(receiver), throwOnEOF)};
  }
}
}

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#pragma once
23	#include <memory>
24	#include <optional>
25
26	#include "misc.hh"
27
28	/* g++ defines __SANITIZE_THREAD__
29	clang++ supports the nice __has_feature(thread_sanitizer),
30	let's merge them */
31	#if defined(__has_feature)
32	#if __has_feature(thread_sanitizer)
33	#define __SANITIZE_THREAD__ 1
34	#endif
35	#endif
36
37	#if __SANITIZE_THREAD__
38	#if defined __has_include
39	#if __has_include(<sanitizer/tsan_interface.h>)
40	#include <sanitizer/tsan_interface.h>
41	#else /* __has_include(<sanitizer/tsan_interface.h>) */
42	extern "C" void __tsan_acquire(void* addr);
43	extern "C" void __tsan_release(void* addr);
44	#endif /* __has_include(<sanitizer/tsan_interface.h>) */
45	#else /* defined __has_include */
46	extern "C" void __tsan_acquire(void* addr);
47	extern "C" void __tsan_release(void* addr);
48	#endif /* defined __has_include */
49	#endif /* __SANITIZE_THREAD__ */
50
51	namespace pdns
52	{
53	namespace channel
54	{
55	enum class SenderBlockingMode
56	{
57	SenderNonBlocking,
58	SenderBlocking
59	};
60	enum class ReceiverBlockingMode
61	{
62	ReceiverNonBlocking,
63	ReceiverBlocking
64	};
65
66	/**
67	* The sender's end of a channel used to pass objects between threads.
68	*
69	* A sender can be used by several threads in a safe way.
70	*/
71	template <typename T, typename D = std::default_delete<T>>
72	class Sender
73	{
74	public:
75	Sender() = default;	11,436✔
76	Sender(FDWrapper&& descriptor) :
77	d_fd(std::move(descriptor))
78	{	11,671✔
79	}	11,671✔
80	Sender(const Sender&) = delete;
81	Sender& operator=(const Sender&) = delete;
82	Sender(Sender&&) = default;	23,252✔
83	Sender& operator=(Sender&&) = default;	11,405✔
84	~Sender() = default;	48,685✔
85	/**
86	* \brief Try to send the supplied object to the other end of that channel. Might block if the channel was created in blocking mode.
87	*
88	* \return True if the object was properly sent, False if the channel is full.
89	*
90	* \throw runtime_error if the channel is broken, for example if the other end has been closed.
91	*/
92	bool send(std::unique_ptr<T, D>&&) const;
93	void close();
94
95	private:
96	FDWrapper d_fd;
97	};
98
99	/**
100	* The receiver's end of a channel used to pass objects between threads.
101	*
102	* A receiver can be used by several threads in a safe way, but in that case spurious wake up might happen.
103	*/
104	template <typename T, typename D = std::default_delete<T>>
105	class Receiver
106	{
107	public:
108	Receiver() = default;	8,312✔
109	Receiver(FDWrapper&& descriptor, bool throwOnEOF = true) :
110	d_fd(std::move(descriptor)), d_throwOnEOF(throwOnEOF)
111	{	11,671✔
112	}	11,671✔
113	Receiver(const Receiver&) = delete;
114	Receiver& operator=(const Receiver&) = delete;
115	Receiver(Receiver&&) = default;	23,832✔
116	Receiver& operator=(Receiver&&) = default;	8,219✔
117	~Receiver() = default;	23,707✔
118	/**
119	* \brief Try to read an object sent by the other end of that channel. Might block if the channel was created in blocking mode.
120	*
121	* \return An object if one was available, and std::nullopt otherwise.
122	*
123	* \throw runtime_error if the channel is broken, for example if the other end has been closed.
124	*/
125	std::optional<std::unique_ptr<T, D>> receive();
126	std::optional<std::unique_ptr<T, D>> receive(D deleter);
127
128	/**
129	* \brief Get a descriptor that can be used with an I/O multiplexer to wait for an object to become available.
130	*
131	* \return A valid descriptor or -1 if the Receiver was not properly initialized.
132	*/
133	int getDescriptor() const
134	{	2,059,218✔
135	return d_fd.getHandle();	2,059,218✔
136	}	2,059,218✔
137	/**
138	* \brief Whether the remote end has closed the channel.
139	*/
140	bool isClosed() const
141	{	15✔
142	return d_closed;	15✔
143	}	15✔
144
145	private:
146	FDWrapper d_fd;
147	bool d_closed{false};
148	bool d_throwOnEOF{true};
149	};
150
151	/**
152	* \brief Create a channel to pass objects between threads, accepting multiple senders and receivers.
153	*
154	* \return A pair of Sender and Receiver objects.
155	*
156	* \throw runtime_error if the channel creation failed.
157	*/
158	template <typename T, typename D = std::default_delete<T>>
159	std::pair<Sender<T, D>, Receiver<T, D>> createObjectQueue(SenderBlockingMode senderBlockingMode = SenderBlockingMode::SenderNonBlocking, ReceiverBlockingMode receiverBlockingMode = ReceiverBlockingMode::ReceiverNonBlocking, size_t pipeBufferSize = 0, bool throwOnEOF = true);
160
161	/**
162	* The notifier's end of a channel used to communicate between threads.
163	*
164	* A notifier can be used by several threads in a safe way.
165	*/
166	class Notifier
167	{
168	public:
169	Notifier() = default;	301✔
170	Notifier(FDWrapper&&);
171	Notifier(const Notifier&) = delete;
172	Notifier& operator=(const Notifier&) = delete;
173	Notifier(Notifier&&) = default;	294✔
174	Notifier& operator=(Notifier&&) = default;	301✔
175	~Notifier() = default;	1,226✔
176
177	/**
178	* \brief Queue a notification to wake up the other end of the channel.
179	*
180	* \return True if the notification was properly sent, False if the channel is full.
181	*
182	* \throw runtime_error if the channel is broken, for example if the other end has been closed.
183	*/
184	bool notify() const;
185
186	private:
187	FDWrapper d_fd;
188	};
189
190	/**
191	* The waiter's end of a channel used to communicate between threads.
192	*
193	* A waiter can be used by several threads in a safe way, but in that case spurious wake up might happen.
194	*/
195	class Waiter
196	{
197	public:
198	Waiter() = default;	285✔
199	Waiter(FDWrapper&&, bool throwOnEOF = true);
200	Waiter(const Waiter&) = delete;
201	Waiter& operator=(const Waiter&) = delete;
202	Waiter(Waiter&&) = default;	294✔
203	Waiter& operator=(Waiter&&) = default;	285✔
204	~Waiter() = default;	1,212✔
205
206	/**
207	* \brief Clear all notifications queued on that channel, if any.
208	*/
209	void clear();
210	/**
211	* \brief Get a descriptor that can be used with an I/O multiplexer to wait for a notification to arrive.
212	*
213	* \return A valid descriptor or -1 if the Waiter was not properly initialized.
214	*/
215	int getDescriptor() const;
216	/**
217	* \brief Whether the remote end has closed the channel.
218	*/
219	bool isClosed() const
220	{	12✔
221	return d_closed;	12✔
222	}	12✔
223
224	private:
225	FDWrapper d_fd;
226	bool d_closed{false};
227	bool d_throwOnEOF{true};
228	};
229
230	/**
231	* \brief Create a channel to notify one thread from another one, accepting multiple senders and receivers.
232	*
233	* \return A pair of Notifier and Sender objects.
234	*
235	* \throw runtime_error if the channel creation failed.
236	*/
237	std::pair<Notifier, Waiter> createNotificationQueue(bool nonBlocking = true, size_t pipeBufferSize = 0, bool throwOnEOF = true);
238
239	template <typename T, typename D>
240	bool Sender<T, D>::send(std::unique_ptr<T, D>&& object) const
241	{	2,109,080✔
242	/* we cannot touch the initial unique pointer after writing to the pipe,
243	not even to release it, so let's transfer it to a local object */
244	auto localObj = std::move(object);	2,109,080✔
245	auto ptr = localObj.get();	2,109,080✔
246	static_assert(sizeof(ptr) <= PIPE_BUF, "Writes up to PIPE_BUF are guaranted not to interleaved and to either fully succeed or fail");	2,109,080✔
247	while (true) {	2,109,080✔
248	#if __SANITIZE_THREAD__
249	__tsan_release(ptr);
250	#endif /* __SANITIZE_THREAD__ */
251	ssize_t sent = write(d_fd.getHandle(), &ptr, sizeof(ptr));	2,109,080✔
252
253	if (sent == sizeof(ptr)) {	2,109,080!
254	// coverity[leaked_storage]
255	localObj.release();	2,109,077✔
256	return true;	2,109,077✔
257	}	2,109,077✔
258	else if (sent == 0) {	3!
259	#if __SANITIZE_THREAD__
260	__tsan_acquire(ptr);
261	#endif /* __SANITIZE_THREAD__ */
262	throw std::runtime_error("Unable to write to channel: remote end has been closed");	×
263	}	×
264	else {	3✔
265	#if __SANITIZE_THREAD__
266	__tsan_acquire(ptr);
267	#endif /* __SANITIZE_THREAD__ */
268	if (errno == EINTR) {	3!
269	continue;	×
270	}	×
271	if (errno == EAGAIN \|\| errno == EWOULDBLOCK) {	3!
272	object = std::move(localObj);	3✔
273	return false;	3✔
274	}	3✔
UNCOV 275	else {	×
UNCOV 276	throw std::runtime_error("Unable to write to channel:" + stringerror());	×
UNCOV 277	}	×
278	}	3✔
279	}	2,109,080✔
280	}	2,109,080✔
281
282	template <typename T, typename D>
283	void Sender<T, D>::close()
284	{	12✔
285	d_fd.reset();	12✔
286	}	12✔
287
288	template <typename T, typename D>
289	std::optional<std::unique_ptr<T, D>> Receiver<T, D>::receive()
290	{	2,108,980✔
291	return receive(D());	2,108,980✔
292	}	2,108,980✔
293
294	template <typename T, typename D>
295	std::optional<std::unique_ptr<T, D>> Receiver<T, D>::receive(D deleter)
296	{	2,108,979✔
297	while (true) {	2,108,979✔
298	std::optional<std::unique_ptr<T, D>> result;	2,108,978✔
299	T* objPtr{nullptr};	2,108,978✔
300	ssize_t got = read(d_fd.getHandle(), &objPtr, sizeof(objPtr));	2,108,978✔
301	if (got == sizeof(objPtr)) {	2,108,978!
302	#if __SANITIZE_THREAD__
303	__tsan_acquire(objPtr);
304	#endif /* __SANITIZE_THREAD__ */
305	return std::unique_ptr<T, D>(objPtr, deleter);	2,108,557✔
306	}	2,108,557✔
307	else if (got == 0) {	421!
308	d_closed = true;	12✔
309	if (!d_throwOnEOF) {	12!
310	return result;	9✔
311	}	9✔
312	throw std::runtime_error("EOF while reading from Channel receiver");	3✔
313	}	12✔
314	else if (got == -1) {	409!
315	if (errno == EINTR) {	141!
316	continue;	×
317	}	×
318	if (errno == EAGAIN \|\| errno == EWOULDBLOCK) {	141!
319	return result;	141✔
320	}	141✔
321	throw std::runtime_error("Error while reading from Channel receiver: " + stringerror());	×
322	}	141✔
323	else {	268✔
324	throw std::runtime_error("Partial read from Channel receiver");	268✔
325	}	268✔
326	}	2,108,978✔
327	}	2,108,979✔
328
329	template <typename T, typename D>
330	std::pair<Sender<T, D>, Receiver<T, D>> createObjectQueue(SenderBlockingMode senderBlockingMode, ReceiverBlockingMode receiverBlockingMode, size_t pipeBufferSize, bool throwOnEOF)
331	{	11,671✔
332	int fds[2] = {-1, -1};	11,671✔
333	if (pipe(fds) < 0) {	11,671!
334	throw std::runtime_error("Error creating channel pipe: " + stringerror());	×
335	}	×
336
337	FDWrapper sender(fds[1]);	11,671✔
338	FDWrapper receiver(fds[0]);	11,671✔
339	if (receiverBlockingMode == ReceiverBlockingMode::ReceiverNonBlocking && !setNonBlocking(receiver.getHandle())) {	11,671!
340	int err = errno;	×
341	throw std::runtime_error("Error making channel pipe non-blocking: " + stringerror(err));	×
342	}	×
343
344	if (senderBlockingMode == SenderBlockingMode::SenderNonBlocking && !setNonBlocking(sender.getHandle())) {	11,671!
345	int err = errno;	×
346	throw std::runtime_error("Error making channel pipe non-blocking: " + stringerror(err));	×
347	}	×
348
349	if (pipeBufferSize > 0 && getPipeBufferSize(receiver.getHandle()) < pipeBufferSize) {	11,671!
350	setPipeBufferSize(receiver.getHandle(), pipeBufferSize);	11,119✔
351	}	11,119✔
352
353	return {Sender<T, D>(std::move(sender)), Receiver<T, D>(std::move(receiver), throwOnEOF)};	11,671✔
354	}	11,671✔
355	}
356	}

PowerDNS / pdns / 6545214347

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