void adns__querysend_tcp(adns_query qu, struct timeval now) {
  ...
  if (!(errno == EAGAIN || EWOULDBLOCK || 
        errno == EINTR || errno == ENOSPC ||
        errno == ENOBUFS || errno == ENOMEM)) {
  ...
}

if (!(   errno == EAGAIN
      || EWOULDBLOCK
      || errno == EINTR
      || errno == ENOSPC
      || errno == ENOBUFS
      || errno == ENOMEM)) {

if (!(errno is in (
                       EAGAIN,
                       EWOULDBLOCK,
                       EINTR,
                       ENOSPC,
                       ENOBUFS,
                       ENOMEM
                   ))
{
...
}

A>if (!(   errno == EAGAIN
A>      || EWOULDBLOCK
A>      || errno == EINTR
A>      || errno == ENOSPC
A>      || errno == ENOBUFS
A>      || errno == ENOMEM)) {
A>

A>if (!(errno is in (
A>                       EAGAIN,
A>                       EWOULDBLOCK,
A>                       EINTR,
A>                       ENOSPC,
A>                       ENOBUFS,
A>                       ENOMEM
A>                   ))
A>{
A>...
A>}
A>

#include <errno.h>

template <auto... set>
bool isin(auto val)
{
    return (false || ... || (set == val));
}

int main() 
{
    // 
    if(isin<EAGAIN,
            EWOULDBLOCK,
            EINTR,
            ENOSPC,
            ENOBUFS,
            ENOMEM>(errno))
    {
        return 0;
    }

    return 1;
}

return ( ... || (set == val));

A>>void adns__querysend_tcp(adns_query qu, struct timeval now) {
A>>  ...
A>>  if (!(errno == EAGAIN || EWOULDBLOCK || 
A>>        errno == EINTR || errno == ENOSPC ||
A>>        errno == ENOBUFS || errno == ENOMEM)) {
A>>  ...
A>>}
A>>

void adns__querysend_tcp(adns_query qu, struct timeval now) {
  auto is_err = false;
  switch(errno) {
    case EAGAIN:
    case EWOULDBLOCK:
    case EINTR:
    case ENOSPC:
    case ENOBUFS:
    case ENOMEM:
      is_err =  true;
  }
  if (!is_err) {

switch(errno)
    case EAGAIN:
    case EWOULDBLOCK:
    case EINTR:
    case ENOSPC:
    case ENOBUFS:
    case ENOMEM:
    {...}

У нас чего только может не быть. У нас всего может не быть. У нас чего только не захочешь, того может и не быть.

template<class T>
class The
{
    public:
        constexpr explicit The(const T& x) noexcept
          : _x(x)
        {
        }

        template <class... TArgs>
        bool one_of(TArgs&&... args) const
        {
            return ((_x == args) || ...);
        }

        template <auto... VArgs>
        bool one_of() const
        {
            return ((_x == VArgs) || ...);
        }

    public:
        const T& _x;
};

int main() 
{
    // 
    if ( The(errno).one_of<
                           EAGAIN,
                           EWOULDBLOCK,
                           EINTR,
                           ENOSPC,
                           ENOBUFS,
                           ENOMEM
                         >()
       )
    {
        return 0;
    }

    return 1;
}