[thirdparty/pdns.git] / pdns / iputils.cc

/*
 * 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.
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "iputils.hh"
#include <sys/socket.h> 

/** these functions provide a very lightweight wrapper to the Berkeley sockets API. Errors -> exceptions! */

static void RuntimeError(const boost::format& fmt)
{
  throw runtime_error(fmt.str());
}

static void NetworkErr(const boost::format& fmt)
{
  throw NetworkError(fmt.str());
}

int SSocket(int family, int type, int flags)
{
  int ret = socket(family, type, flags);
  if(ret < 0)
    RuntimeError(boost::format("creating socket of type %d: %s") % family % strerror(errno));
  return ret;
}

int SConnect(int sockfd, const ComboAddress& remote)
{
  int ret = connect(sockfd, reinterpret_cast<const struct sockaddr*>(&remote), remote.getSocklen());
  if(ret < 0) {
    int savederrno = errno;
    RuntimeError(boost::format("connecting socket to %s: %s") % remote.toStringWithPort() % strerror(savederrno));
  }
  return ret;
}

int SConnectWithTimeout(int sockfd, const ComboAddress& remote, int timeout)
{
  int ret = connect(sockfd, reinterpret_cast<const struct sockaddr*>(&remote), remote.getSocklen());
  if(ret < 0) {
    int savederrno = errno;
    if (savederrno == EINPROGRESS) {
      if (timeout <= 0) {
        return savederrno;
      }

      /* we wait until the connection has been established */
      bool error = false;
      bool disconnected = false;
      int res = waitForRWData(sockfd, false, timeout, 0, &error, &disconnected);
      if (res == 1) {
        if (error) {
          savederrno = 0;
          socklen_t errlen = sizeof(savederrno);
          if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&savederrno, &errlen) == 0) {
            NetworkErr(boost::format("connecting to %s failed: %s") % remote.toStringWithPort() % string(strerror(savederrno)));
          }
          else {
            NetworkErr(boost::format("connecting to %s failed") % remote.toStringWithPort());
          }
        }
        if (disconnected) {
          NetworkErr(boost::format("%s closed the connection") % remote.toStringWithPort());
        }
        return 0;
      }
      else if (res == 0) {
        NetworkErr(boost::format("timeout while connecting to %s") % remote.toStringWithPort());
      } else if (res < 0) {
        savederrno = errno;
        NetworkErr(boost::format("waiting to connect to %s: %s") % remote.toStringWithPort() % string(strerror(savederrno)));
      }
    }
    else {
      NetworkErr(boost::format("connecting to %s: %s") % remote.toStringWithPort() % string(strerror(savederrno)));
    }
  }

  return 0;
}

int SBind(int sockfd, const ComboAddress& local)
{
  int ret = bind(sockfd, (struct sockaddr*)&local, local.getSocklen());
  if(ret < 0) {
    int savederrno = errno;
    RuntimeError(boost::format("binding socket to %s: %s") % local.toStringWithPort() % strerror(savederrno));
  }
  return ret;
}

int SAccept(int sockfd, ComboAddress& remote)
{
  socklen_t remlen = remote.getSocklen();

  int ret = accept(sockfd, (struct sockaddr*)&remote, &remlen);
  if(ret < 0)
    RuntimeError(boost::format("accepting new connection on socket: %s") % strerror(errno));
  return ret;
}

int SListen(int sockfd, int limit)
{
  int ret = listen(sockfd, limit);
  if(ret < 0)
    RuntimeError(boost::format("setting socket to listen: %s") % strerror(errno));
  return ret;
}

int SSetsockopt(int sockfd, int level, int opname, int value)
{
  int ret = setsockopt(sockfd, level, opname, &value, sizeof(value));
  if(ret < 0)
    RuntimeError(boost::format("setsockopt for level %d and opname %d to %d failed: %s") % level % opname % value % strerror(errno));
  return ret;
}


bool HarvestTimestamp(struct msghdr* msgh, struct timeval* tv) 
{
#ifdef SO_TIMESTAMP
  struct cmsghdr *cmsg;
  for (cmsg = CMSG_FIRSTHDR(msgh); cmsg != NULL; cmsg = CMSG_NXTHDR(msgh,cmsg)) {
    if ((cmsg->cmsg_level == SOL_SOCKET) && (cmsg->cmsg_type == SO_TIMESTAMP || cmsg->cmsg_type == SCM_TIMESTAMP) && 
	CMSG_LEN(sizeof(*tv)) == cmsg->cmsg_len) {
      memcpy(tv, CMSG_DATA(cmsg), sizeof(*tv));
      return true;
    }
  }
#endif
  return false;
}
bool HarvestDestinationAddress(const struct msghdr* msgh, ComboAddress* destination)
{
  destination->reset();
#ifdef __NetBSD__
  struct cmsghdr* cmsg;
#else
  const struct cmsghdr* cmsg;
#endif
  for (cmsg = CMSG_FIRSTHDR(msgh); cmsg != NULL; cmsg = CMSG_NXTHDR(const_cast<struct msghdr*>(msgh), const_cast<struct cmsghdr*>(cmsg))) {
#if defined(IP_PKTINFO)
     if ((cmsg->cmsg_level == IPPROTO_IP) && (cmsg->cmsg_type == IP_PKTINFO)) {
        struct in_pktinfo *i = (struct in_pktinfo *) CMSG_DATA(cmsg);
        destination->sin4.sin_addr = i->ipi_addr;
        destination->sin4.sin_family = AF_INET;
        return true;
    }
#elif defined(IP_RECVDSTADDR)
    if ((cmsg->cmsg_level == IPPROTO_IP) && (cmsg->cmsg_type == IP_RECVDSTADDR)) {
      struct in_addr *i = (struct in_addr *) CMSG_DATA(cmsg);
      destination->sin4.sin_addr = *i;
      destination->sin4.sin_family = AF_INET;      
      return true;
    }
#endif

    if ((cmsg->cmsg_level == IPPROTO_IPV6) && (cmsg->cmsg_type == IPV6_PKTINFO)) {
        struct in6_pktinfo *i = (struct in6_pktinfo *) CMSG_DATA(cmsg);
        destination->sin6.sin6_addr = i->ipi6_addr;
        destination->sin4.sin_family = AF_INET6;
        return true;
    }
  }
  return false;
}

bool IsAnyAddress(const ComboAddress& addr)
{
  if(addr.sin4.sin_family == AF_INET)
    return addr.sin4.sin_addr.s_addr == 0;
  else if(addr.sin4.sin_family == AF_INET6)
    return !memcmp(&addr.sin6.sin6_addr, &in6addr_any, sizeof(addr.sin6.sin6_addr));
  
  return false;
}

ssize_t sendfromto(int sock, const char* data, size_t len, int flags, const ComboAddress& from, const ComboAddress& to)
{
  struct msghdr msgh;
  struct iovec iov;
  char cbuf[256];

  /* Set up iov and msgh structures. */
  memset(&msgh, 0, sizeof(struct msghdr));
  iov.iov_base = (void*)data;
  iov.iov_len = len;
  msgh.msg_iov = &iov;
  msgh.msg_iovlen = 1;
  msgh.msg_name = (struct sockaddr*)&to;
  msgh.msg_namelen = to.getSocklen();

  if(from.sin4.sin_family) {
    addCMsgSrcAddr(&msgh, cbuf, &from, 0);
  }
  else {
    msgh.msg_control=NULL;
  }
  return sendmsg(sock, &msgh, flags);
}

// be careful: when using this for receive purposes, make sure addr->sin4.sin_family is set appropriately so getSocklen works!
// be careful: when using this function for *send* purposes, be sure to set cbufsize to 0!
// be careful: if you don't call addCMsgSrcAddr after fillMSGHdr, make sure to set msg_control to NULL
void fillMSGHdr(struct msghdr* msgh, struct iovec* iov, char* cbuf, size_t cbufsize, char* data, size_t datalen, ComboAddress* addr)
{
  iov->iov_base = data;
  iov->iov_len  = datalen;

  memset(msgh, 0, sizeof(struct msghdr));
  
  msgh->msg_control = cbuf;
  msgh->msg_controllen = cbufsize;
  msgh->msg_name = addr;
  msgh->msg_namelen = addr->getSocklen();
  msgh->msg_iov  = iov;
  msgh->msg_iovlen = 1;
  msgh->msg_flags = 0;
}

// warning: various parts of PowerDNS assume 'truncate' will never throw
void ComboAddress::truncate(unsigned int bits) noexcept
{
  uint8_t* start;
  int len=4;
  if(sin4.sin_family==AF_INET) {
    if(bits >= 32)
      return;
    start = (uint8_t*)&sin4.sin_addr.s_addr;
    len=4;
  }
  else {
    if(bits >= 128)
      return;
    start = (uint8_t*)&sin6.sin6_addr.s6_addr;
    len=16;
  }

  auto tozero= len*8 - bits; // if set to 22, this will clear 1 byte, as it should

  memset(start + len - tozero/8, 0, tozero/8); // blot out the whole bytes on the right
  
  auto bitsleft=tozero % 8; // 2 bits left to clear

  // a b c d, to truncate to 22 bits, we just zeroed 'd' and need to zero 2 bits from c
  // so and by '11111100', which is ~((1<<2)-1)  = ~3
  uint8_t* place = start + len - 1 - tozero/8; 
  *place &= (~((1<<bitsleft)-1));
}

size_t sendMsgWithTimeout(int fd, const char* buffer, size_t len, int idleTimeout, const ComboAddress* dest, const ComboAddress* local, unsigned int localItf, int totalTimeout, int flags)
{
  int remainingTime = totalTimeout;
  time_t start = 0;
  if (totalTimeout) {
    start = time(nullptr);
  }

  struct msghdr msgh;
  struct iovec iov;
  char cbuf[256];

  /* Set up iov and msgh structures. */
  memset(&msgh, 0, sizeof(struct msghdr));
  msgh.msg_control = nullptr;
  msgh.msg_controllen = 0;
  if (dest) {
    msgh.msg_name = reinterpret_cast<void*>(const_cast<ComboAddress*>(dest));
    msgh.msg_namelen = dest->getSocklen();
  }
  else {
    msgh.msg_name = nullptr;
    msgh.msg_namelen = 0;
  }

  msgh.msg_flags = 0;

  if (localItf != 0 && local) {
    addCMsgSrcAddr(&msgh, cbuf, local, localItf);
  }

  iov.iov_base = reinterpret_cast<void*>(const_cast<char*>(buffer));
  iov.iov_len = len;
  msgh.msg_iov = &iov;
  msgh.msg_iovlen = 1;
  msgh.msg_flags = 0;

  size_t sent = 0;
  bool firstTry = true;

  do {

#ifdef MSG_FASTOPEN
    if (flags & MSG_FASTOPEN && firstTry == false) {
      flags &= ~MSG_FASTOPEN;
    }
#endif /* MSG_FASTOPEN */

    ssize_t res = sendmsg(fd, &msgh, flags);

    if (res > 0) {
      size_t written = static_cast<size_t>(res);
      sent += written;

      if (sent == len) {
        return sent;
      }

      /* partial write */
      iov.iov_len -= written;
      iov.iov_base = reinterpret_cast<void*>(reinterpret_cast<char*>(iov.iov_base) + written);
      written = 0;
    }
    else if (res == -1) {
      if (errno == EINTR) {
        continue;
      }
      else if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS || errno == ENOTCONN) {
        /* EINPROGRESS might happen with non blocking socket,
           especially with TCP Fast Open */
        if (totalTimeout <= 0 && idleTimeout <= 0) {
          return sent;
        }

        if (firstTry) {
          int res = waitForRWData(fd, false, (totalTimeout == 0 || idleTimeout <= remainingTime) ? idleTimeout : remainingTime, 0);
          if (res > 0) {
            /* there is room available */
            firstTry = false;
          }
          else if (res == 0) {
            throw runtime_error("Timeout while waiting to write data");
          } else {
            throw runtime_error("Error while waiting for room to write data");
          }
        }
        else {
          throw runtime_error("Timeout while waiting to write data");
        }
      }
      else {
        unixDie("failed in sendMsgWithTimeout");
      }
    }
    if (totalTimeout) {
      time_t now = time(nullptr);
      int elapsed = now - start;
      if (elapsed >= remainingTime) {
        throw runtime_error("Timeout while sending data");
      }
      start = now;
      remainingTime -= elapsed;
    }
  }
  while (firstTry);

  return 0;
}

template class NetmaskTree<bool>;

bool sendSizeAndMsgWithTimeout(int sock, uint16_t bufferLen, const char* buffer, int idleTimeout, const ComboAddress* dest, const ComboAddress* local, unsigned int localItf, int totalTimeout, int flags)
{
  uint16_t size = htons(bufferLen);
  char cbuf[256];
  struct msghdr msgh;
  struct iovec iov[2];
  int remainingTime = totalTimeout;
  time_t start = 0;
  if (totalTimeout) {
    start = time(NULL);
  }

  /* Set up iov and msgh structures. */
  memset(&msgh, 0, sizeof(struct msghdr));
  msgh.msg_control = nullptr;
  msgh.msg_controllen = 0;
  if (dest) {
    msgh.msg_name = reinterpret_cast<void*>(const_cast<ComboAddress*>(dest));
    msgh.msg_namelen = dest->getSocklen();
  }
  else {
    msgh.msg_name = nullptr;
    msgh.msg_namelen = 0;
  }

  msgh.msg_flags = 0;

  if (localItf != 0 && local) {
    addCMsgSrcAddr(&msgh, cbuf, local, localItf);
  }

  iov[0].iov_base = &size;
  iov[0].iov_len = sizeof(size);
  iov[1].iov_base = reinterpret_cast<void*>(const_cast<char*>(buffer));
  iov[1].iov_len = bufferLen;

  size_t pos = 0;
  size_t sent = 0;
  size_t nbElements = sizeof(iov)/sizeof(*iov);
  while (true) {
    msgh.msg_iov = &iov[pos];
    msgh.msg_iovlen = nbElements - pos;

    ssize_t res = sendmsg(sock, &msgh, flags);
    if (res > 0) {
      size_t written = static_cast<size_t>(res);
      sent += written;

      if (sent == (sizeof(size) + bufferLen)) {
        return true;
      }
      /* partial write, we need to keep only the (parts of) elements
         that have not been written.
      */
      do {
        if (written < iov[pos].iov_len) {
          iov[pos].iov_len -= written;
          iov[pos].iov_base = reinterpret_cast<void*>(reinterpret_cast<char*>(iov[pos].iov_base) + written);
          written = 0;
        }
        else {
          written -= iov[pos].iov_len;
          iov[pos].iov_len = 0;
          pos++;
        }
      }
      while (written > 0 && pos < nbElements);
    }
    else if (res == -1) {
      if (errno == EINTR) {
        continue;
      }
      else if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS) {
        /* EINPROGRESS might happen with non blocking socket,
           especially with TCP Fast Open */
        int ret = waitForRWData(sock, false, (totalTimeout == 0 || idleTimeout <= remainingTime) ? idleTimeout : remainingTime, 0);
        if (ret > 0) {
          /* there is room available */
        }
        else if (ret == 0) {
          throw runtime_error("Timeout while waiting to send data");
        } else {
          throw runtime_error("Error while waiting for room to send data");
        }
      }
      else {
        unixDie("failed in sendSizeAndMsgWithTimeout");
      }
    }
    if (totalTimeout) {
      time_t now = time(NULL);
      int elapsed = now - start;
      if (elapsed >= remainingTime) {
        throw runtime_error("Timeout while sending data");
      }
      start = now;
      remainingTime -= elapsed;
    }
  }

  return false;
}

/* requires a non-blocking socket.
   On Linux, we could use MSG_DONTWAIT on a blocking socket
   but this is not portable.
*/
bool isTCPSocketUsable(int sock)
{
  int err = 0;
  char buf = '\0';
  size_t buf_size = sizeof(buf);

  do {
    ssize_t got = recv(sock, &buf, buf_size, MSG_PEEK);

    if (got > 0) {
      /* socket is usable, some data is even waiting to be read */
      return true;
    }
    else if (got == 0) {
      /* other end has closed the socket */
      return false;
    }
    else {
      err = errno;

      if (err == EAGAIN || err == EWOULDBLOCK) {
        /* socket is usable, no data waiting */
        return true;
      }
      else {
        if (err != EINTR) {
          /* something is wrong, could be ECONNRESET,
             ENOTCONN, EPIPE, but anyway this socket is
             not usable. */
          return false;
        }
      }
    }
  } while (err == EINTR);

  return false;
}
Commit	Line	Data
12471842 PL	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	*/
870a0fe4 AT	22	#ifdef HAVE_CONFIG_H
	23	#include "config.h"
	24	#endif
002c970a	25	#include "iputils.hh"
22cf1fda	26	#include <sys/socket.h>
22cf1fda	27
002c970a	28	/** these functions provide a very lightweight wrapper to the Berkeley sockets API. Errors -> exceptions! */
	29
	30	static void RuntimeError(const boost::format& fmt)
	31	{
	32	throw runtime_error(fmt.str());
	33	}
	34
73ba5999 CHB	35	static void NetworkErr(const boost::format& fmt)
	36	{
	37	throw NetworkError(fmt.str());
	38	}
002c970a	39
	40	int SSocket(int family, int type, int flags)
	41	{
	42	int ret = socket(family, type, flags);
	43	if(ret < 0)
	44	RuntimeError(boost::format("creating socket of type %d: %s") % family % strerror(errno));
	45	return ret;
	46	}
	47
	48	int SConnect(int sockfd, const ComboAddress& remote)
	49	{
bdf8277d	50	int ret = connect(sockfd, reinterpret_cast<const struct sockaddr*>(&remote), remote.getSocklen());
ccb4b5e2 PD	51	if(ret < 0) {
	52	int savederrno = errno;
	53	RuntimeError(boost::format("connecting socket to %s: %s") % remote.toStringWithPort() % strerror(savederrno));
	54	}
002c970a	55	return ret;
	56	}
	57
51959320 RG	58	int SConnectWithTimeout(int sockfd, const ComboAddress& remote, int timeout)
51959320 RG	59	{
bdf8277d	60	int ret = connect(sockfd, reinterpret_cast<const struct sockaddr*>(&remote), remote.getSocklen());
51959320 RG	61	if(ret < 0) {
	62	int savederrno = errno;
	63	if (savederrno == EINPROGRESS) {
399fd947	64	if (timeout <= 0) {
bdf8277d	65	return savederrno;
399fd947 RG	66	}
399fd947 RG	67
51959320 RG	68	/* we wait until the connection has been established */
	69	bool error = false;
	70	bool disconnected = false;
	71	int res = waitForRWData(sockfd, false, timeout, 0, &error, &disconnected);
	72	if (res == 1) {
	73	if (error) {
	74	savederrno = 0;
	75	socklen_t errlen = sizeof(savederrno);
	76	if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&savederrno, &errlen) == 0) {
73ba5999	77	NetworkErr(boost::format("connecting to %s failed: %s") % remote.toStringWithPort() % string(strerror(savederrno)));
51959320 RG	78	}
51959320 RG	79	else {
73ba5999	80	NetworkErr(boost::format("connecting to %s failed") % remote.toStringWithPort());
51959320 RG	81	}
	82	}
	83	if (disconnected) {
73ba5999	84	NetworkErr(boost::format("%s closed the connection") % remote.toStringWithPort());
51959320 RG	85	}
	86	return 0;
	87	}
	88	else if (res == 0) {
73ba5999	89	NetworkErr(boost::format("timeout while connecting to %s") % remote.toStringWithPort());
51959320 RG	90	} else if (res < 0) {
51959320 RG	91	savederrno = errno;
73ba5999	92	NetworkErr(boost::format("waiting to connect to %s: %s") % remote.toStringWithPort() % string(strerror(savederrno)));
51959320 RG	93	}
	94	}
	95	else {
73ba5999	96	NetworkErr(boost::format("connecting to %s: %s") % remote.toStringWithPort() % string(strerror(savederrno)));
51959320 RG	97	}
	98	}
	99
bdf8277d	100	return 0;
51959320 RG	101	}
51959320 RG	102
002c970a	103	int SBind(int sockfd, const ComboAddress& local)
	104	{
	105	int ret = bind(sockfd, (struct sockaddr*)&local, local.getSocklen());
ccb4b5e2 PD	106	if(ret < 0) {
	107	int savederrno = errno;
	108	RuntimeError(boost::format("binding socket to %s: %s") % local.toStringWithPort() % strerror(savederrno));
	109	}
002c970a	110	return ret;
	111	}
	112
	113	int SAccept(int sockfd, ComboAddress& remote)
	114	{
	115	socklen_t remlen = remote.getSocklen();
	116
	117	int ret = accept(sockfd, (struct sockaddr*)&remote, &remlen);
	118	if(ret < 0)
	119	RuntimeError(boost::format("accepting new connection on socket: %s") % strerror(errno));
	120	return ret;
	121	}
	122
	123	int SListen(int sockfd, int limit)
	124	{
	125	int ret = listen(sockfd, limit);
	126	if(ret < 0)
	127	RuntimeError(boost::format("setting socket to listen: %s") % strerror(errno));
	128	return ret;
	129	}
	130
	131	int SSetsockopt(int sockfd, int level, int opname, int value)
	132	{
	133	int ret = setsockopt(sockfd, level, opname, &value, sizeof(value));
	134	if(ret < 0)
	135	RuntimeError(boost::format("setsockopt for level %d and opname %d to %d failed: %s") % level % opname % value % strerror(errno));
	136	return ret;
	137	}
	138
	139
3e3f0358	140	bool HarvestTimestamp(struct msghdr* msgh, struct timeval* tv)
	141	{
	142	#ifdef SO_TIMESTAMP
	143	struct cmsghdr *cmsg;
	144	for (cmsg = CMSG_FIRSTHDR(msgh); cmsg != NULL; cmsg = CMSG_NXTHDR(msgh,cmsg)) {
22cf1fda	145	if ((cmsg->cmsg_level == SOL_SOCKET) && (cmsg->cmsg_type == SO_TIMESTAMP \|\| cmsg->cmsg_type == SCM_TIMESTAMP) &&
3e3f0358	146	CMSG_LEN(sizeof(*tv)) == cmsg->cmsg_len) {
	147	memcpy(tv, CMSG_DATA(cmsg), sizeof(*tv));
	148	return true;
	149	}
	150	}
	151	#endif
	152	return false;
	153	}
2b3eefc3	154	bool HarvestDestinationAddress(const struct msghdr* msgh, ComboAddress* destination)
3e3f0358	155	{
d38e2ba9	156	destination->reset();
4d39d7f3 TIH	157	#ifdef __NetBSD__
	158	struct cmsghdr* cmsg;
	159	#else
2b3eefc3	160	const struct cmsghdr* cmsg;
4d39d7f3	161	#endif
2b3eefc3	162	for (cmsg = CMSG_FIRSTHDR(msgh); cmsg != NULL; cmsg = CMSG_NXTHDR(const_cast<struct msghdr>(msgh), const_cast<struct cmsghdr>(cmsg))) {
3e3f0358	163	#if defined(IP_PKTINFO)
	164	if ((cmsg->cmsg_level == IPPROTO_IP) && (cmsg->cmsg_type == IP_PKTINFO)) {
	165	struct in_pktinfo i = (struct in_pktinfo ) CMSG_DATA(cmsg);
	166	destination->sin4.sin_addr = i->ipi_addr;
	167	destination->sin4.sin_family = AF_INET;
	168	return true;
	169	}
	170	#elif defined(IP_RECVDSTADDR)
	171	if ((cmsg->cmsg_level == IPPROTO_IP) && (cmsg->cmsg_type == IP_RECVDSTADDR)) {
	172	struct in_addr i = (struct in_addr ) CMSG_DATA(cmsg);
	173	destination->sin4.sin_addr = *i;
	174	destination->sin4.sin_family = AF_INET;
	175	return true;
	176	}
	177	#endif
	178
	179	if ((cmsg->cmsg_level == IPPROTO_IPV6) && (cmsg->cmsg_type == IPV6_PKTINFO)) {
	180	struct in6_pktinfo i = (struct in6_pktinfo ) CMSG_DATA(cmsg);
	181	destination->sin6.sin6_addr = i->ipi6_addr;
	182	destination->sin4.sin_family = AF_INET6;
	183	return true;
	184	}
	185	}
	186	return false;
	187	}
	188
	189	bool IsAnyAddress(const ComboAddress& addr)
	190	{
	191	if(addr.sin4.sin_family == AF_INET)
	192	return addr.sin4.sin_addr.s_addr == 0;
	193	else if(addr.sin4.sin_family == AF_INET6)
	194	return !memcmp(&addr.sin6.sin6_addr, &in6addr_any, sizeof(addr.sin6.sin6_addr));
	195
	196	return false;
	197	}
	198
a683e8bd	199	ssize_t sendfromto(int sock, const char* data, size_t len, int flags, const ComboAddress& from, const ComboAddress& to)
3e3f0358	200	{
	201	struct msghdr msgh;
	202	struct iovec iov;
	203	char cbuf[256];
	204
	205	/* Set up iov and msgh structures. */
	206	memset(&msgh, 0, sizeof(struct msghdr));
	207	iov.iov_base = (void*)data;
	208	iov.iov_len = len;
	209	msgh.msg_iov = &iov;
	210	msgh.msg_iovlen = 1;
	211	msgh.msg_name = (struct sockaddr*)&to;
	212	msgh.msg_namelen = to.getSocklen();
	213
	214	if(from.sin4.sin_family) {
fbe2a2e0	215	addCMsgSrcAddr(&msgh, cbuf, &from, 0);
3e3f0358	216	}
579cae19 PD	217	else {
	218	msgh.msg_control=NULL;
	219	}
3e3f0358	220	return sendmsg(sock, &msgh, flags);
3e3f0358	221	}
b71b60ee	222
	223	// be careful: when using this for receive purposes, make sure addr->sin4.sin_family is set appropriately so getSocklen works!
	224	// be careful: when using this function for send purposes, be sure to set cbufsize to 0!
579cae19	225	// be careful: if you don't call addCMsgSrcAddr after fillMSGHdr, make sure to set msg_control to NULL
b71b60ee	226	void fillMSGHdr(struct msghdr* msgh, struct iovec* iov, char* cbuf, size_t cbufsize, char* data, size_t datalen, ComboAddress* addr)
	227	{
	228	iov->iov_base = data;
	229	iov->iov_len = datalen;
	230
	231	memset(msgh, 0, sizeof(struct msghdr));
	232
	233	msgh->msg_control = cbuf;
	234	msgh->msg_controllen = cbufsize;
	235	msgh->msg_name = addr;
	236	msgh->msg_namelen = addr->getSocklen();
	237	msgh->msg_iov = iov;
	238	msgh->msg_iovlen = 1;
	239	msgh->msg_flags = 0;
	240	}
22779196	241
5b6099b2	242	// warning: various parts of PowerDNS assume 'truncate' will never throw
5b6099b2	243	void ComboAddress::truncate(unsigned int bits) noexcept
22779196	244	{
	245	uint8_t* start;
	246	int len=4;
	247	if(sin4.sin_family==AF_INET) {
ecd43f08	248	if(bits >= 32)
22779196	249	return;
	250	start = (uint8_t*)&sin4.sin_addr.s_addr;
	251	len=4;
	252	}
	253	else {
ecd43f08	254	if(bits >= 128)
22779196	255	return;
	256	start = (uint8_t*)&sin6.sin6_addr.s6_addr;
	257	len=16;
	258	}
	259
22779196	260	auto tozero= len*8 - bits; // if set to 22, this will clear 1 byte, as it should
	261
	262	memset(start + len - tozero/8, 0, tozero/8); // blot out the whole bytes on the right
	263
	264	auto bitsleft=tozero % 8; // 2 bits left to clear
	265
	266	// a b c d, to truncate to 22 bits, we just zeroed 'd' and need to zero 2 bits from c
	267	// so and by '11111100', which is ~((1<<2)-1) = ~3
	268	uint8_t* place = start + len - 1 - tozero/8;
22779196	269	*place &= (~((1<<bitsleft)-1));
22779196	270	}
f9f9592e	271
d0ae6360	272	size_t sendMsgWithTimeout(int fd, const char* buffer, size_t len, int idleTimeout, const ComboAddress* dest, const ComboAddress* local, unsigned int localItf, int totalTimeout, int flags)
fbe2a2e0	273	{
d0ae6360 RG	274	int remainingTime = totalTimeout;
	275	time_t start = 0;
	276	if (totalTimeout) {
	277	start = time(nullptr);
	278	}
	279
fbe2a2e0 RG	280	struct msghdr msgh;
	281	struct iovec iov;
	282	char cbuf[256];
d0ae6360 RG	283
	284	/* Set up iov and msgh structures. */
	285	memset(&msgh, 0, sizeof(struct msghdr));
	286	msgh.msg_control = nullptr;
	287	msgh.msg_controllen = 0;
	288	if (dest) {
	289	msgh.msg_name = reinterpret_cast<void>(const_cast<ComboAddress>(dest));
	290	msgh.msg_namelen = dest->getSocklen();
	291	}
	292	else {
	293	msgh.msg_name = nullptr;
	294	msgh.msg_namelen = 0;
	295	}
	296
	297	msgh.msg_flags = 0;
	298
	299	if (localItf != 0 && local) {
	300	addCMsgSrcAddr(&msgh, cbuf, local, localItf);
	301	}
	302
d0ae6360 RG	303	iov.iov_base = reinterpret_cast<void>(const_cast<char>(buffer));
	304	iov.iov_len = len;
	305	msgh.msg_iov = &iov;
	306	msgh.msg_iovlen = 1;
	307	msgh.msg_flags = 0;
	308
	309	size_t sent = 0;
fbe2a2e0	310	bool firstTry = true;
fbe2a2e0 RG	311
fbe2a2e0 RG	312	do {
fbe2a2e0	313
d0ae6360 RG	314	#ifdef MSG_FASTOPEN
	315	if (flags & MSG_FASTOPEN && firstTry == false) {
	316	flags &= ~MSG_FASTOPEN;
	317	}
	318	#endif /* MSG_FASTOPEN */
	319
	320	ssize_t res = sendmsg(fd, &msgh, flags);
fbe2a2e0	321
d0ae6360 RG	322	if (res > 0) {
	323	size_t written = static_cast<size_t>(res);
	324	sent += written;
	325
	326	if (sent == len) {
	327	return sent;
	328	}
	329
	330	/* partial write */
	331	iov.iov_len -= written;
	332	iov.iov_base = reinterpret_cast<void>(reinterpret_cast<char>(iov.iov_base) + written);
	333	written = 0;
	334	}
	335	else if (res == -1) {
	336	if (errno == EINTR) {
	337	continue;
	338	}
2bd6a088	339	else if (errno == EAGAIN \|\| errno == EWOULDBLOCK \|\| errno == EINPROGRESS \|\| errno == ENOTCONN) {
d0ae6360 RG	340	/* EINPROGRESS might happen with non blocking socket,
	341	especially with TCP Fast Open */
	342	if (totalTimeout <= 0 && idleTimeout <= 0) {
	343	return sent;
fbe2a2e0	344	}
d0ae6360 RG	345
	346	if (firstTry) {
	347	int res = waitForRWData(fd, false, (totalTimeout == 0 \|\| idleTimeout <= remainingTime) ? idleTimeout : remainingTime, 0);
	348	if (res > 0) {
	349	/* there is room available */
	350	firstTry = false;
	351	}
	352	else if (res == 0) {
	353	throw runtime_error("Timeout while waiting to write data");
	354	} else {
	355	throw runtime_error("Error while waiting for room to write data");
	356	}
	357	}
	358	else {
fbe2a2e0	359	throw runtime_error("Timeout while waiting to write data");
fbe2a2e0 RG	360	}
	361	}
	362	else {
d0ae6360	363	unixDie("failed in sendMsgWithTimeout");
fbe2a2e0 RG	364	}
fbe2a2e0 RG	365	}
d0ae6360 RG	366	if (totalTimeout) {
	367	time_t now = time(nullptr);
	368	int elapsed = now - start;
	369	if (elapsed >= remainingTime) {
	370	throw runtime_error("Timeout while sending data");
	371	}
	372	start = now;
	373	remainingTime -= elapsed;
fbe2a2e0 RG	374	}
	375	}
	376	while (firstTry);
	377
	378	return 0;
	379	}
	380
f9f9592e	381	template class NetmaskTree<bool>;
fbe2a2e0	382
17bca36a RG	383	bool sendSizeAndMsgWithTimeout(int sock, uint16_t bufferLen, const char* buffer, int idleTimeout, const ComboAddress* dest, const ComboAddress* local, unsigned int localItf, int totalTimeout, int flags)
	384	{
	385	uint16_t size = htons(bufferLen);
	386	char cbuf[256];
	387	struct msghdr msgh;
	388	struct iovec iov[2];
	389	int remainingTime = totalTimeout;
	390	time_t start = 0;
	391	if (totalTimeout) {
	392	start = time(NULL);
	393	}
	394
	395	/* Set up iov and msgh structures. */
	396	memset(&msgh, 0, sizeof(struct msghdr));
	397	msgh.msg_control = nullptr;
	398	msgh.msg_controllen = 0;
	399	if (dest) {
	400	msgh.msg_name = reinterpret_cast<void>(const_cast<ComboAddress>(dest));
	401	msgh.msg_namelen = dest->getSocklen();
	402	}
	403	else {
	404	msgh.msg_name = nullptr;
	405	msgh.msg_namelen = 0;
	406	}
	407
	408	msgh.msg_flags = 0;
	409
	410	if (localItf != 0 && local) {
	411	addCMsgSrcAddr(&msgh, cbuf, local, localItf);
	412	}
	413
	414	iov[0].iov_base = &size;
	415	iov[0].iov_len = sizeof(size);
	416	iov[1].iov_base = reinterpret_cast<void>(const_cast<char>(buffer));
	417	iov[1].iov_len = bufferLen;
	418
	419	size_t pos = 0;
	420	size_t sent = 0;
	421	size_t nbElements = sizeof(iov)/sizeof(*iov);
	422	while (true) {
	423	msgh.msg_iov = &iov[pos];
	424	msgh.msg_iovlen = nbElements - pos;
	425
	426	ssize_t res = sendmsg(sock, &msgh, flags);
	427	if (res > 0) {
	428	size_t written = static_cast<size_t>(res);
	429	sent += written;
	430
	431	if (sent == (sizeof(size) + bufferLen)) {
	432	return true;
	433	}
	434	/* partial write, we need to keep only the (parts of) elements
	435	that have not been written.
	436	*/
	437	do {
	438	if (written < iov[pos].iov_len) {
	439	iov[pos].iov_len -= written;
d9442969	440	iov[pos].iov_base = reinterpret_cast<void>(reinterpret_cast<char>(iov[pos].iov_base) + written);
17bca36a RG	441	written = 0;
	442	}
	443	else {
	444	written -= iov[pos].iov_len;
	445	iov[pos].iov_len = 0;
	446	pos++;
	447	}
	448	}
	449	while (written > 0 && pos < nbElements);
	450	}
	451	else if (res == -1) {
	452	if (errno == EINTR) {
	453	continue;
	454	}
	455	else if (errno == EAGAIN \|\| errno == EWOULDBLOCK \|\| errno == EINPROGRESS) {
	456	/* EINPROGRESS might happen with non blocking socket,
	457	especially with TCP Fast Open */
	458	int ret = waitForRWData(sock, false, (totalTimeout == 0 \|\| idleTimeout <= remainingTime) ? idleTimeout : remainingTime, 0);
	459	if (ret > 0) {
	460	/* there is room available */
	461	}
	462	else if (ret == 0) {
	463	throw runtime_error("Timeout while waiting to send data");
	464	} else {
	465	throw runtime_error("Error while waiting for room to send data");
	466	}
	467	}
	468	else {
	469	unixDie("failed in sendSizeAndMsgWithTimeout");
	470	}
	471	}
	472	if (totalTimeout) {
	473	time_t now = time(NULL);
	474	int elapsed = now - start;
	475	if (elapsed >= remainingTime) {
	476	throw runtime_error("Timeout while sending data");
	477	}
	478	start = now;
	479	remainingTime -= elapsed;
	480	}
	481	}
	482
	483	return false;
	484	}
840ed663 RG	485
	486	/* requires a non-blocking socket.
	487	On Linux, we could use MSG_DONTWAIT on a blocking socket
	488	but this is not portable.
	489	*/
	490	bool isTCPSocketUsable(int sock)
	491	{
	492	int err = 0;
	493	char buf = '\0';
	494	size_t buf_size = sizeof(buf);
	495
	496	do {
	497	ssize_t got = recv(sock, &buf, buf_size, MSG_PEEK);
	498
	499	if (got > 0) {
	500	/* socket is usable, some data is even waiting to be read */
	501	return true;
	502	}
	503	else if (got == 0) {
	504	/* other end has closed the socket */
	505	return false;
	506	}
	507	else {
88479ac5	508	err = errno;
840ed663 RG	509
	510	if (err == EAGAIN \|\| err == EWOULDBLOCK) {
	511	/* socket is usable, no data waiting */
	512	return true;
	513	}
	514	else {
	515	if (err != EINTR) {
	516	/* something is wrong, could be ECONNRESET,
	517	ENOTCONN, EPIPE, but anyway this socket is
	518	not usable. */
	519	return false;
	520	}
	521	}
	522	}
	523	} while (err == EINTR);
	524
	525	return false;
	526	}