folly::AsyncUDPSocket Class Reference

#include <AsyncUDPSocket.h>

Inheritance diagram for folly::AsyncUDPSocket:

Classes
class	ErrMessageCallback
class	ReadCallback

Public Types
enum	FDOwnership { FDOwnership::OWNS, FDOwnership::SHARED }
Public Types inherited from folly::EventHandler
enum	EventFlags {   NONE = 0, READ = EV_READ, WRITE = EV_WRITE, READ_WRITE = (READ | WRITE),   PERSIST = EV_PERSIST }

Public Member Functions
	AsyncUDPSocket (EventBase *evb)
	~AsyncUDPSocket () override
virtual const folly::SocketAddress &	address () const
virtual void	bind (const folly::SocketAddress &address)
void	setFD (int fd, FDOwnership ownership)
virtual void	setFD (NetworkSocket fd, FDOwnership ownership)
virtual ssize_t	write (const folly::SocketAddress &address, const std::unique_ptr< folly::IOBuf > &buf)
virtual ssize_t	writeGSO (const folly::SocketAddress &address, const std::unique_ptr< folly::IOBuf > &buf, int gso)
virtual ssize_t	writev (const folly::SocketAddress &address, const struct iovec *vec, size_t veclen, int gso)
virtual ssize_t	writev (const folly::SocketAddress &address, const struct iovec *vec, size_t veclen)
virtual void	resumeRead (ReadCallback *cob)
virtual void	pauseRead ()
virtual void	close ()
virtual int	getFD () const
virtual void	setReusePort (bool reusePort)
virtual void	setReuseAddr (bool reuseAddr)
virtual void	setRcvBuf (int rcvBuf)
virtual void	setSndBuf (int sndBuf)
virtual void	setBusyPoll (int busyPollUs)
EventBase *	getEventBase () const
virtual void	dontFragment (bool df)
virtual void	setErrMessageCallback (ErrMessageCallback *errMessageCallback)
virtual int	connect (const folly::SocketAddress &address)
virtual bool	isBound () const
virtual void	detachEventBase ()
virtual void	attachEventBase (folly::EventBase *evb)
int	getGSO ()
bool	setGSO (int val)
Public Member Functions inherited from folly::EventHandler
	EventHandler (EventBase *eventBase, int fd)
	EventHandler (EventBase *eventBase=nullptr, NetworkSocket fd=NetworkSocket())
virtual	~EventHandler ()
bool	registerHandler (uint16_t events)
void	unregisterHandler ()
bool	isHandlerRegistered () const
void	attachEventBase (EventBase *eventBase)
void	detachEventBase ()
void	changeHandlerFD (int fd)
void	changeHandlerFD (NetworkSocket fd)
void	initHandler (EventBase *eventBase, int fd)
void	initHandler (EventBase *eventBase, NetworkSocket fd)
uint16_t	getRegisteredEvents () const
bool	registerInternalHandler (uint16_t events)
bool	isPending () const

Protected Member Functions
virtual ssize_t	sendmsg (NetworkSocket socket, const struct msghdr *message, int flags)
size_t	handleErrMessages () noexcept
void	failErrMessageRead (const AsyncSocketException &ex)

Protected Attributes
ReadCallback *	readCallback_

Private Member Functions
	AsyncUDPSocket (const AsyncUDPSocket &)=delete
AsyncUDPSocket &	operator= (const AsyncUDPSocket &)=delete
void	handlerReady (uint16_t events) noexceptoverride
void	handleRead () noexcept
bool	updateRegistration () noexcept

Private Attributes
EventBase *	eventBase_
folly::SocketAddress	localAddress_
NetworkSocket	fd_
FDOwnership	ownership_
folly::SocketAddress	clientAddress_
bool	reuseAddr_ {true}
bool	reusePort_ {false}
int	rcvBuf_ {0}
int	sndBuf_ {0}
int	busyPollUs_ {0}
folly::Optional< int >	gso_
ErrMessageCallback *	errMessageCallback_ {nullptr}

Detailed Description

UDP socket

Definition at line 36 of file AsyncUDPSocket.h.

Member Enumeration Documentation

enum folly::AsyncUDPSocket::FDOwnership

strong

Enumerator
OWNS
SHARED

Definition at line 38 of file AsyncUDPSocket.h.

{ OWNS, SHARED };

Constructor & Destructor Documentation

folly::AsyncUDPSocket::AsyncUDPSocket ( EventBase *  evb )

explicit

Create a new UDP socket that will run in the given eventbase

Definition at line 37 of file AsyncUDPSocket.cpp.

References folly::EventBase::dcheckIsInEventBaseThread().

    : EventHandler(CHECK_NOTNULL(evb)),
      readCallback_(nullptr),
      eventBase_(evb),
      fd_() {
  evb->dcheckIsInEventBaseThread();
}

folly::AsyncUDPSocket::~AsyncUDPSocket ( )

override

Definition at line 45 of file AsyncUDPSocket.cpp.

References close(), and fd_.

                                {
  if (fd_ != NetworkSocket()) {
    close();
  }
}

folly::AsyncUDPSocket::AsyncUDPSocket ( const AsyncUDPSocket &  )

privatedelete

Member Function Documentation

virtual const folly::SocketAddress& folly::AsyncUDPSocket::address ( ) const

inlinevirtual

Returns the address server is listening on

Definition at line 112 of file AsyncUDPSocket.h.

References bind(), fd_, and localAddress_.

Referenced by bind(), dontFragment(), setErrMessageCallback(), TEST(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                                    {
    CHECK_NE(NetworkSocket(), fd_) << "Server not yet bound to an address";
    return localAddress_;
  }

void folly::AsyncUDPSocket::attachEventBase ( folly::EventBase *  evb )

virtual

Definition at line 546 of file AsyncUDPSocket.cpp.

References folly::EventHandler::attachEventBase(), eventBase_, folly::EventBase::isInEventBaseThread(), and updateRegistration().

Referenced by isBound().

                                                        {
  DCHECK(!eventBase_);
  DCHECK(evb && evb->isInEventBaseThread());
  eventBase_ = evb;
  EventHandler::attachEventBase(evb);
  updateRegistration();
}

void folly::AsyncUDPSocket::bind ( const folly::SocketAddress &  address )

virtual

Bind the socket to the following address. If port is not set in the address an ephemeral port is chosen and you can use address() method above to get it after this method successfully returns.

Definition at line 51 of file AsyncUDPSocket.cpp.

References address(), folly::netops::bind(), busyPollUs_, folly::EventHandler::changeHandlerFD(), folly::netops::close(), folly::SocketAddress::describe(), fd_, flag, g(), folly::SocketAddress::getActualSize(), folly::SocketAddress::getAddress(), folly::SocketAddress::getFamily(), folly::SocketAddress::getPort(), localAddress_, folly::makeGuard(), folly::AsyncSocketException::NOT_OPEN, ownership_, OWNS, rcvBuf_, reuseAddr_, reusePort_, folly::netops::set_socket_non_blocking(), folly::SocketAddress::setFromLocalAddress(), folly::netops::setsockopt(), sndBuf_, SO_REUSEPORT, folly::netops::socket(), and folly::value().

Referenced by address(), TEST(), TEST_F(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                                           {
  NetworkSocket socket =
      netops::socket(address.getFamily(), SOCK_DGRAM, IPPROTO_UDP);
  if (socket == NetworkSocket()) {
    throw AsyncSocketException(
        AsyncSocketException::NOT_OPEN,
        "error creating async udp socket",
        errno);
  }

  auto g = folly::makeGuard([&] { netops::close(socket); });

  // put the socket in non-blocking mode
  int ret = netops::set_socket_non_blocking(socket);
  if (ret != 0) {
    throw AsyncSocketException(
        AsyncSocketException::NOT_OPEN,
        "failed to put socket in non-blocking mode",
        errno);
  }

  if (reuseAddr_) {
    // put the socket in reuse mode
    int value = 1;
    if (netops::setsockopt(
            socket, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value)) != 0) {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN,
          "failed to put socket in reuse mode",
          errno);
    }
  }

  if (reusePort_) {
    // put the socket in port reuse mode
    int value = 1;
    if (netops::setsockopt(
            socket, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)) != 0) {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN,
          "failed to put socket in reuse_port mode",
          errno);
    }
  }

  if (busyPollUs_ > 0) {
#ifdef SO_BUSY_POLL
    // Set busy_poll time in microseconds on the socket.
    // It sets how long socket will be in busy_poll mode when no event occurs.
    int value = busyPollUs_;
    if (netops::setsockopt(
            socket, SOL_SOCKET, SO_BUSY_POLL, &value, sizeof(value)) != 0) {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN,
          "failed to set SO_BUSY_POLL on the socket",
          errno);
    }
#else /* SO_BUSY_POLL is not supported*/
    throw AsyncSocketException(
        AsyncSocketException::NOT_OPEN, "SO_BUSY_POLL is not supported", errno);
#endif
  }

  if (rcvBuf_ > 0) {
    // Set the size of the buffer for the received messages in rx_queues.
    int value = rcvBuf_;
    if (netops::setsockopt(
            socket, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) != 0) {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN,
          "failed to set SO_RCVBUF on the socket",
          errno);
    }
  }

  if (sndBuf_ > 0) {
    // Set the size of the buffer for the sent messages in tx_queues.
    int value = rcvBuf_;
    if (netops::setsockopt(
            socket, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) != 0) {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN,
          "failed to set SO_SNDBUF on the socket",
          errno);
    }
  }

  // If we're using IPv6, make sure we don't accept V4-mapped connections
  if (address.getFamily() == AF_INET6) {
    int flag = 1;
    if (netops::setsockopt(
            socket, IPPROTO_IPV6, IPV6_V6ONLY, &flag, sizeof(flag))) {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN, "Failed to set IPV6_V6ONLY", errno);
    }
  }

  // bind to the address
  sockaddr_storage addrStorage;
  address.getAddress(&addrStorage);
  auto& saddr = reinterpret_cast<sockaddr&>(addrStorage);
  if (netops::bind(socket, &saddr, address.getActualSize()) != 0) {
    throw AsyncSocketException(
        AsyncSocketException::NOT_OPEN,
        "failed to bind the async udp socket for:" + address.describe(),
        errno);
  }

  // success
  g.dismiss();
  fd_ = socket;
  ownership_ = FDOwnership::OWNS;

  // attach to EventHandler
  EventHandler::changeHandlerFD(fd_);

  if (address.getPort() != 0) {
    localAddress_ = address;
  } else {
    localAddress_.setFromLocalAddress(fd_);
  }
}

void folly::AsyncUDPSocket::close ( )

virtual

Stop listening on the socket.

Definition at line 329 of file AsyncUDPSocket.cpp.

References folly::netops::close(), folly::EventBase::dcheckIsInEventBaseThread(), eventBase_, fd_, folly::AsyncUDPSocket::ReadCallback::onReadClosed(), ownership_, OWNS, readCallback_, and folly::EventHandler::unregisterHandler().

Referenced by setFD(), ~AsyncUDPSocket(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                           {
  eventBase_->dcheckIsInEventBaseThread();

  if (readCallback_) {
    auto cob = readCallback_;
    readCallback_ = nullptr;

    cob->onReadClosed();
  }

  // Unregister any events we are registered for
  unregisterHandler();

  if (fd_ != NetworkSocket() && ownership_ == FDOwnership::OWNS) {
    netops::close(fd_);
  }

  fd_ = NetworkSocket();
}

int folly::AsyncUDPSocket::connect ( const folly::SocketAddress &  address )

virtual

Connects the UDP socket to a remote destination address provided in address. This can speed up UDP writes on linux because it will cache flow state on connects. Using connect has many quirks, and you should be aware of them before using this API:

1. This must only be called after binding the socket.
2. Normally UDP can use the 2 tuple (src ip, src port) to steer packets sent by the peer to the socket, however after connecting the socket, only packets destined to the destination address specified in connect() will be forwarded and others will be dropped. If the server can send a packet from a different destination port / IP then you probably do not want to use this API.
3. It can be called repeatedly on either the client or server however it's normally only useful on the client and not server.

Returns the result of calling the connect syscall.

Definition at line 421 of file AsyncUDPSocket.cpp.

References folly::netops::connect(), fd_, folly::SocketAddress::getActualSize(), and folly::SocketAddress::getAddress().

Referenced by getEventBase(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                                             {
  CHECK_NE(NetworkSocket(), fd_) << "Socket not yet bound";
  sockaddr_storage addrStorage;
  address.getAddress(&addrStorage);
  return netops::connect(
      fd_, reinterpret_cast<sockaddr*>(&addrStorage), address.getActualSize());
}

void folly::AsyncUDPSocket::detachEventBase ( )

virtual

Definition at line 539 of file AsyncUDPSocket.cpp.

References folly::EventHandler::detachEventBase(), eventBase_, folly::EventBase::isInEventBaseThread(), folly::EventHandler::NONE, folly::EventHandler::registerHandler(), and uint16_t.

Referenced by isBound().

                                     {
  DCHECK(eventBase_ && eventBase_->isInEventBaseThread());
  registerHandler(uint16_t(NONE));
  eventBase_ = nullptr;
  EventHandler::detachEventBase();
}

void folly::AsyncUDPSocket::dontFragment ( bool  df )

virtual

Enable or disable fragmentation on the socket.

On Linux, this sets IP(V6)_MTU_DISCOVER to IP(V6)_PMTUDISC_DO when enabled, and to IP(V6)_PMTUDISC_WANT when disabled. IP(V6)_PMTUDISC_WANT will use per-route setting to set DF bit. It may be more desirable to use IP(V6)_PMTUDISC_PROBE as opposed to IP(V6)_PMTUDISC_DO for apps that has its own PMTU Discovery mechanism. Note this doesn't work on Apple.

Definition at line 174 of file AsyncUDPSocket.cpp.

References address(), fd_, folly::SocketAddress::getFamily(), folly::AsyncSocketException::NOT_OPEN, and folly::netops::setsockopt().

Referenced by getEventBase(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                         {
  (void)df; // to avoid potential unused variable warning
#if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) && \
    defined(IP_PMTUDISC_WANT)
  if (address().getFamily() == AF_INET) {
    int v4 = df ? IP_PMTUDISC_DO : IP_PMTUDISC_WANT;
    if (netops::setsockopt(fd_, IPPROTO_IP, IP_MTU_DISCOVER, &v4, sizeof(v4))) {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN,
          "Failed to set DF with IP_MTU_DISCOVER",
          errno);
    }
  }
#endif
#if defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) && \
    defined(IPV6_PMTUDISC_WANT)
  if (address().getFamily() == AF_INET6) {
    int v6 = df ? IPV6_PMTUDISC_DO : IPV6_PMTUDISC_WANT;
    if (netops::setsockopt(
            fd_, IPPROTO_IPV6, IPV6_MTU_DISCOVER, &v6, sizeof(v6))) {
      throw AsyncSocketException(
          AsyncSocketException::NOT_OPEN,
          "Failed to set DF with IPV6_MTU_DISCOVER",
          errno);
    }
  }
#endif
}

void folly::AsyncUDPSocket::failErrMessageRead ( const AsyncSocketException &  ex )

protected

Definition at line 413 of file AsyncUDPSocket.cpp.

References errMessageCallback_, and folly::AsyncUDPSocket::ErrMessageCallback::errMessageError().

Referenced by handleErrMessages(), and sendmsg().

                                                                      {
  if (errMessageCallback_ != nullptr) {
    ErrMessageCallback* callback = errMessageCallback_;
    errMessageCallback_ = nullptr;
    callback->errMessageError(ex);
  }
}

EventBase* folly::AsyncUDPSocket::getEventBase ( ) const

inline

Definition at line 231 of file AsyncUDPSocket.h.

References connect(), dontFragment(), eventBase_, and setErrMessageCallback().

                                  {
    return eventBase_;
  }

virtual int folly::AsyncUDPSocket::getFD ( ) const

inlinevirtual

Get internal FD used by this socket

Definition at line 190 of file AsyncUDPSocket.h.

References fd_, and folly::NetworkSocket::toFd().

Referenced by folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                            {
    CHECK_NE(NetworkSocket(), fd_) << "Need to bind before getting FD out";
    return fd_.toFd();
  }

int folly::AsyncUDPSocket::getGSO

(

)

Definition at line 520 of file AsyncUDPSocket.cpp.

References fd_, FOLLY_UNLIKELY, folly::netops::getsockopt(), gso_, folly::Optional< Value >::hasValue(), SOL_UDP, UDP_SEGMENT, and folly::Optional< Value >::value().

Referenced by isBound(), TEST(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                           {
  // check if we can return the cached value
  if (FOLLY_UNLIKELY(!gso_.hasValue())) {
#ifdef FOLLY_HAVE_MSG_ERRQUEUE
    int gso = -1;
    socklen_t optlen = sizeof(gso);
    if (!netops::getsockopt(fd_, SOL_UDP, UDP_SEGMENT, &gso, &optlen)) {
      gso_ = gso;
    } else {
      gso_ = -1;
    }
#else
    gso_ = -1;
#endif
  }

  return gso_.value();
}

size_t folly::AsyncUDPSocket::handleErrMessages ( )

protectednoexcept

Definition at line 356 of file AsyncUDPSocket.cpp.

References folly::data(), folly::AsyncUDPSocket::ErrMessageCallback::errMessage(), errMessageCallback_, failErrMessageRead(), fd_, folly::AsyncSocketException::INTERNAL_ERROR, folly::netops::recvmsg(), and uint8_t.

Referenced by handleRead(), and sendmsg().

                                                  {
#ifdef FOLLY_HAVE_MSG_ERRQUEUE
  if (errMessageCallback_ == nullptr) {
    return 0;
  }
  uint8_t ctrl[1024];
  unsigned char data;
  struct msghdr msg;
  iovec entry;

  entry.iov_base = &data;
  entry.iov_len = sizeof(data);
  msg.msg_iov = &entry;
  msg.msg_iovlen = 1;
  msg.msg_name = nullptr;
  msg.msg_namelen = 0;
  msg.msg_control = ctrl;
  msg.msg_controllen = sizeof(ctrl);
  msg.msg_flags = 0;

  int ret;
  size_t num = 0;
  while (fd_ != NetworkSocket()) {
    ret = netops::recvmsg(fd_, &msg, MSG_ERRQUEUE);
    VLOG(5) << "AsyncSocket::handleErrMessages(): recvmsg returned " << ret;

    if (ret < 0) {
      if (errno != EAGAIN) {
        auto errnoCopy = errno;
        LOG(ERROR) << "::recvmsg exited with code " << ret
                   << ", errno: " << errnoCopy;
        AsyncSocketException ex(
            AsyncSocketException::INTERNAL_ERROR,
            "recvmsg() failed",
            errnoCopy);
        failErrMessageRead(ex);
      }
      return num;
    }

    for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
         cmsg != nullptr && cmsg->cmsg_len != 0;
         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
      ++num;
      errMessageCallback_->errMessage(*cmsg);
      if (fd_ == NetworkSocket()) {
        // once the socket is closed there is no use for more read errors.
        return num;
      }
    }
  }
  return num;
#else
  return 0;
#endif
}

void folly::AsyncUDPSocket::handleRead ( )

privatenoexcept

Definition at line 429 of file AsyncUDPSocket.cpp.

References folly::AsyncSocketException::BAD_ARGS, clientAddress_, fd_, folly::SocketAddress::getFamily(), folly::AsyncUDPSocket::ReadCallback::getReadBuffer(), handleErrMessages(), folly::AsyncSocketException::INTERNAL_ERROR, localAddress_, folly::AsyncUDPSocket::ReadCallback::onDataAvailable(), folly::AsyncUDPSocket::ReadCallback::onReadError(), readCallback_, folly::netops::recvfrom(), folly::SocketAddress::setFromSockaddr(), and updateRegistration().

Referenced by handlerReady().

                                         {
  void* buf{nullptr};
  size_t len{0};

  if (handleErrMessages()) {
    return;
  }

  if (fd_ == NetworkSocket()) {
    // The socket may have been closed by the error callbacks.
    return;
  }

  readCallback_->getReadBuffer(&buf, &len);
  if (buf == nullptr || len == 0) {
    AsyncSocketException ex(
        AsyncSocketException::BAD_ARGS,
        "AsyncUDPSocket::getReadBuffer() returned empty buffer");

    auto cob = readCallback_;
    readCallback_ = nullptr;

    cob->onReadError(ex);
    updateRegistration();
    return;
  }

  struct sockaddr_storage addrStorage;
  socklen_t addrLen = sizeof(addrStorage);
  memset(&addrStorage, 0, size_t(addrLen));
  struct sockaddr* rawAddr = reinterpret_cast<sockaddr*>(&addrStorage);
  rawAddr->sa_family = localAddress_.getFamily();

  ssize_t bytesRead =
      netops::recvfrom(fd_, buf, len, MSG_TRUNC, rawAddr, &addrLen);
  if (bytesRead >= 0) {
    clientAddress_.setFromSockaddr(rawAddr, addrLen);

    if (bytesRead > 0) {
      bool truncated = false;
      if ((size_t)bytesRead > len) {
        truncated = true;
        bytesRead = ssize_t(len);
      }

      readCallback_->onDataAvailable(
          clientAddress_, size_t(bytesRead), truncated);
    }
  } else {
    if (errno == EAGAIN || errno == EWOULDBLOCK) {
      // No data could be read without blocking the socket
      return;
    }

    AsyncSocketException ex(
        AsyncSocketException::INTERNAL_ERROR, "::recvfrom() failed", errno);

    // In case of UDP we can continue reading from the socket
    // even if the current request fails. We notify the user
    // so that he can do some logging/stats collection if he wants.
    auto cob = readCallback_;
    readCallback_ = nullptr;

    cob->onReadError(ex);
    updateRegistration();
  }
}

void folly::AsyncUDPSocket::handlerReady ( uint16_t  events )

overrideprivatevirtualnoexcept

handlerReady() is invoked when the handler is ready.

Parameters

events

A bitset indicating the events that are ready.

Implements folly::EventHandler.

Definition at line 349 of file AsyncUDPSocket.cpp.

References handleRead(), folly::EventHandler::READ, and readCallback_.

                                                          {
  if (events & EventHandler::READ) {
    DCHECK(readCallback_);
    handleRead();
  }
}

virtual bool folly::AsyncUDPSocket::isBound ( ) const

inlinevirtual

Definition at line 272 of file AsyncUDPSocket.h.

References attachEventBase(), detachEventBase(), fd_, getGSO(), setGSO(), and val.

Referenced by TEST_F(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                               {
    return fd_ != NetworkSocket();
  }

AsyncUDPSocket& folly::AsyncUDPSocket::operator= ( const AsyncUDPSocket &  )

privatedelete

void folly::AsyncUDPSocket::pauseRead ( )

virtual

Pause reading datagrams

Definition at line 323 of file AsyncUDPSocket.cpp.

References readCallback_, and updateRegistration().

Referenced by setFD(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                               {
  // It is ok to pause an already paused socket
  readCallback_ = nullptr;
  updateRegistration();
}

void folly::AsyncUDPSocket::resumeRead ( ReadCallback *  cob )

virtual

Start reading datagrams

Definition at line 307 of file AsyncUDPSocket.cpp.

References fd_, folly::AsyncSocketException::NOT_OPEN, folly::AsyncUDPSocket::ReadCallback::onReadError(), readCallback_, and updateRegistration().

Referenced by setFD(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                                 {
  CHECK(!readCallback_) << "Another read callback already installed";
  CHECK_NE(NetworkSocket(), fd_)
      << "UDP server socket not yet bind to an address";

  readCallback_ = CHECK_NOTNULL(cob);
  if (!updateRegistration()) {
    AsyncSocketException ex(
        AsyncSocketException::NOT_OPEN, "failed to register for accept events");

    readCallback_ = nullptr;
    cob->onReadError(ex);
    return;
  }
}

virtual ssize_t folly::AsyncUDPSocket::sendmsg ( NetworkSocket  socket, const struct msghdr *  message, int  flags  )

inlineprotectedvirtual

Definition at line 288 of file AsyncUDPSocket.h.

References failErrMessageRead(), handleErrMessages(), folly::pushmi::__adl::noexcept(), and folly::netops::sendmsg().

Referenced by writev().

                                                                         {
    return netops::sendmsg(socket, message, flags);
  }

virtual void folly::AsyncUDPSocket::setBusyPoll ( int  busyPollUs )

inlinevirtual

Set SO_BUSY_POLL option on the socket, if not zero. Default is zero. Caution! The feature is not available on Apple's systems.

Definition at line 227 of file AsyncUDPSocket.h.

References busyPollUs_.

                                           {
    busyPollUs_ = busyPollUs;
  }

void folly::AsyncUDPSocket::setErrMessageCallback ( ErrMessageCallback *  errMessageCallback )

virtual

Callback for receiving errors on the UDP sockets

Definition at line 203 of file AsyncUDPSocket.cpp.

References address(), errMessageCallback_, fd_, folly::SocketAddress::getFamily(), folly::AsyncSocketException::NOT_OPEN, and folly::netops::setsockopt().

Referenced by getEventBase(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                            {
  errMessageCallback_ = errMessageCallback;
  int err = (errMessageCallback_ != nullptr);
#if defined(IP_RECVERR)
  if (address().getFamily() == AF_INET &&
      netops::setsockopt(fd_, IPPROTO_IP, IP_RECVERR, &err, sizeof(err))) {
    throw AsyncSocketException(
        AsyncSocketException::NOT_OPEN, "Failed to set IP_RECVERR", errno);
  }
#endif
#if defined(IPV6_RECVERR)
  if (address().getFamily() == AF_INET6 &&
      netops::setsockopt(fd_, IPPROTO_IPV6, IPV6_RECVERR, &err, sizeof(err))) {
    throw AsyncSocketException(
        AsyncSocketException::NOT_OPEN, "Failed to set IPV6_RECVERR", errno);
  }
#endif
  (void)err;
}

void folly::AsyncUDPSocket::setFD ( int  fd, FDOwnership  ownership  )

inline

Use an already bound file descriptor. You can either transfer ownership of this FD by using ownership = FDOwnership::OWNS or share it using FDOwnership::SHARED. In case FD is shared, it will not be closed in destructor.

Definition at line 131 of file AsyncUDPSocket.h.

References close(), folly::NetworkSocket::fromFd(), pauseRead(), resumeRead(), write(), writeGSO(), and writev().

Referenced by folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                            {
    setFD(NetworkSocket::fromFd(fd), ownership);
  }

void folly::AsyncUDPSocket::setFD ( NetworkSocket  fd, FDOwnership  ownership  )

virtual

Definition at line 224 of file AsyncUDPSocket.cpp.

References folly::EventHandler::changeHandlerFD(), fd_, localAddress_, ownership_, and folly::SocketAddress::setFromLocalAddress().

                                                                  {
  CHECK_EQ(NetworkSocket(), fd_) << "Already bound to another FD";

  fd_ = fd;
  ownership_ = ownership;

  EventHandler::changeHandlerFD(fd_);
  localAddress_.setFromLocalAddress(fd_);
}

bool folly::AsyncUDPSocket::setGSO

(

int

val

)

Definition at line 507 of file AsyncUDPSocket.cpp.

References fd_, gso_, folly::netops::setsockopt(), SOL_UDP, UDP_SEGMENT, and val.

Referenced by isBound(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                   {
#ifdef FOLLY_HAVE_MSG_ERRQUEUE
  int ret = netops::setsockopt(fd_, SOL_UDP, UDP_SEGMENT, &val, sizeof(val));

  gso_ = ret ? -1 : val;

  return !ret;
#else
  (void)val;
  return false;
#endif
}

virtual void folly::AsyncUDPSocket::setRcvBuf ( int  rcvBuf )

inlinevirtual

Set SO_RCVBUF option on the socket, if not zero. Default is zero.

Definition at line 212 of file AsyncUDPSocket.h.

References rcvBuf_.

                                     {
    rcvBuf_ = rcvBuf;
  }

virtual void folly::AsyncUDPSocket::setReuseAddr ( bool  reuseAddr )

inlinevirtual

Set SO_REUSEADDR flag on the socket. Default is ON.

Definition at line 205 of file AsyncUDPSocket.h.

References reuseAddr_.

Referenced by folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                            {
    reuseAddr_ = reuseAddr;
  }

virtual void folly::AsyncUDPSocket::setReusePort ( bool  reusePort )

inlinevirtual

Set reuse port mode to call bind() on the same address multiple times

Definition at line 198 of file AsyncUDPSocket.h.

References reusePort_.

Referenced by folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                            {
    reusePort_ = reusePort;
  }

virtual void folly::AsyncUDPSocket::setSndBuf ( int  sndBuf )

inlinevirtual

Set SO_SNDBUG option on the socket, if not zero. Default is zero.

Definition at line 219 of file AsyncUDPSocket.h.

References sndBuf_.

                                     {
    sndBuf_ = sndBuf;
  }

bool folly::AsyncUDPSocket::updateRegistration ( )

privatenoexcept

Definition at line 497 of file AsyncUDPSocket.cpp.

References folly::EventHandler::NONE, folly::EventHandler::PERSIST, folly::EventHandler::READ, readCallback_, folly::EventHandler::registerHandler(), and uint16_t.

Referenced by attachEventBase(), handleRead(), pauseRead(), and resumeRead().

                                                 {
  uint16_t flags = NONE;

  if (readCallback_) {
    flags |= READ;
  }

  return registerHandler(uint16_t(flags | PERSIST));
}

ssize_t folly::AsyncUDPSocket::write ( const folly::SocketAddress &  address, const std::unique_ptr< folly::IOBuf > &  buf  )

virtual

Send the data in buffer to destination. Returns the return code from ::sendmsg.

Definition at line 254 of file AsyncUDPSocket.cpp.

References writeGSO().

Referenced by setFD(), TEST(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

                                          {
  return writeGSO(address, buf, 0);
}

ssize_t folly::AsyncUDPSocket::writeGSO ( const folly::SocketAddress &  address, const std::unique_ptr< folly::IOBuf > &  buf, int  gso  )

virtual

Send the data in buffer to destination. Returns the return code from ::sendmsg. gso is the generic segmentation offload value writeGSO will return -1 if buf->computeChainDataLength() <= gso Before calling writeGSO with a positive value verify GSO is supported on this platform by calling getGSO

Definition at line 234 of file AsyncUDPSocket.cpp.

References folly::IOBuf::coalesce(), folly::IOBuf::data(), folly::IOBuf::fillIov(), folly::IOBuf::length(), uint8_t, UNLIKELY, and writev().

Referenced by GSOSendTest::GSOSendTest(), setFD(), write(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

             {
  // UDP's typical MTU size is 1500, so high number of buffers
  //   really do not make sense. Optimize for buffer chains with
  //   buffers less than 16, which is the highest I can think of
  //   for a real use case.
  iovec vec[16];
  size_t iovec_len = buf->fillIov(vec, sizeof(vec) / sizeof(vec[0]));
  if (UNLIKELY(iovec_len == 0)) {
    buf->coalesce();
    vec[0].iov_base = const_cast<uint8_t*>(buf->data());
    vec[0].iov_len = buf->length();
    iovec_len = 1;
  }

  return writev(address, vec, iovec_len, gso);
}

ssize_t folly::AsyncUDPSocket::writev ( const folly::SocketAddress &  address, const struct iovec *  vec, size_t  veclen, int  gso  )

virtual

Send data in iovec to destination. Returns the return code from sendmsg.

Definition at line 260 of file AsyncUDPSocket.cpp.

References fd_, folly::SocketAddress::getActualSize(), folly::SocketAddress::getAddress(), sendmsg(), SOL_UDP, UDP_SEGMENT, and uint16_t.

Referenced by setFD(), writeGSO(), writev(), and folly::test::MockAsyncUDPSocket::~MockAsyncUDPSocket().

             {
  CHECK_NE(NetworkSocket(), fd_) << "Socket not yet bound";

  sockaddr_storage addrStorage;
  address.getAddress(&addrStorage);

  struct msghdr msg;
  msg.msg_name = reinterpret_cast<void*>(&addrStorage);
  msg.msg_namelen = address.getActualSize();
  msg.msg_iov = const_cast<struct iovec*>(vec);
  msg.msg_iovlen = iovec_len;
  msg.msg_control = nullptr;
  msg.msg_controllen = 0;
  msg.msg_flags = 0;

#ifdef FOLLY_HAVE_MSG_ERRQUEUE
  if (gso > 0) {
    char control[CMSG_SPACE(sizeof(uint16_t))];
    msg.msg_control = control;
    msg.msg_controllen = sizeof(control);

    struct cmsghdr* cm = CMSG_FIRSTHDR(&msg);
    cm->cmsg_level = SOL_UDP;
    cm->cmsg_type = UDP_SEGMENT;
    cm->cmsg_len = CMSG_LEN(sizeof(uint16_t));
    uint16_t gso_len = static_cast<uint16_t>(gso);
    memcpy(CMSG_DATA(cm), &gso_len, sizeof(gso_len));

    return sendmsg(fd_, &msg, 0);
  }
#else
  CHECK_LT(gso, 1) << "GSO not supported";
#endif

  return sendmsg(fd_, &msg, 0);
}

ssize_t folly::AsyncUDPSocket::writev ( const folly::SocketAddress &  address, const struct iovec *  vec, size_t  veclen  )

virtual

Definition at line 301 of file AsyncUDPSocket.cpp.

References writev().

                      {
  return writev(address, vec, iovec_len, 0);
}

Member Data Documentation

int folly::AsyncUDPSocket::busyPollUs_ {0}

private

Definition at line 322 of file AsyncUDPSocket.h.

Referenced by bind(), and setBusyPoll().

folly::SocketAddress folly::AsyncUDPSocket::clientAddress_

private

Definition at line 316 of file AsyncUDPSocket.h.

Referenced by handleRead().

ErrMessageCallback* folly::AsyncUDPSocket::errMessageCallback_ {nullptr}

private

Definition at line 328 of file AsyncUDPSocket.h.

Referenced by failErrMessageRead(), handleErrMessages(), and setErrMessageCallback().

EventBase* folly::AsyncUDPSocket::eventBase_

private

Definition at line 309 of file AsyncUDPSocket.h.

Referenced by attachEventBase(), close(), detachEventBase(), and getEventBase().

NetworkSocket folly::AsyncUDPSocket::fd_

private

Definition at line 312 of file AsyncUDPSocket.h.

Referenced by address(), bind(), close(), connect(), dontFragment(), getFD(), getGSO(), handleErrMessages(), handleRead(), isBound(), resumeRead(), setErrMessageCallback(), setFD(), setGSO(), writev(), and ~AsyncUDPSocket().

folly::Optional<int> folly::AsyncUDPSocket::gso_

private

Definition at line 326 of file AsyncUDPSocket.h.

Referenced by getGSO(), and setGSO().

folly::SocketAddress folly::AsyncUDPSocket::localAddress_

private

Definition at line 310 of file AsyncUDPSocket.h.

Referenced by address(), bind(), handleRead(), and setFD().

FDOwnership folly::AsyncUDPSocket::ownership_

private

Definition at line 313 of file AsyncUDPSocket.h.

Referenced by bind(), close(), and setFD().

int folly::AsyncUDPSocket::rcvBuf_ {0}

private

Definition at line 320 of file AsyncUDPSocket.h.

Referenced by bind(), and setRcvBuf().

ReadCallback* folly::AsyncUDPSocket::readCallback_

protected

Definition at line 297 of file AsyncUDPSocket.h.

Referenced by close(), handleRead(), handlerReady(), pauseRead(), resumeRead(), and updateRegistration().

bool folly::AsyncUDPSocket::reuseAddr_ {true}

private

Definition at line 318 of file AsyncUDPSocket.h.

Referenced by bind(), and setReuseAddr().

bool folly::AsyncUDPSocket::reusePort_ {false}

private

Definition at line 319 of file AsyncUDPSocket.h.

Referenced by bind(), and setReusePort().

int folly::AsyncUDPSocket::sndBuf_ {0}

private

Definition at line 321 of file AsyncUDPSocket.h.

Referenced by bind(), and setSndBuf().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/io/async/AsyncUDPSocket.h
• proxygen/folly/folly/io/async/AsyncUDPSocket.cpp