folly::netops Namespace Reference

Namespaces
	detail

Classes
struct	PollDescriptor

Functions
	TEST (SocketFileDescriptorMap, fd_to_socket_consistent)
	TEST (SocketFileDescriptorMap, no_socket_reuse)
	TEST (SocketFileDescriptorMap, close_non_mapped_native_socket)
NetworkSocket	accept (NetworkSocket s, sockaddr *addr, socklen_t *addrlen)
int	bind (NetworkSocket s, const sockaddr *name, socklen_t namelen)
int	close (NetworkSocket s)
int	connect (NetworkSocket s, const sockaddr *name, socklen_t namelen)
int	getpeername (NetworkSocket s, sockaddr *name, socklen_t *namelen)
int	getsockname (NetworkSocket s, sockaddr *name, socklen_t *namelen)
int	getsockopt (NetworkSocket s, int level, int optname, void *optval, socklen_t *optlen)
int	inet_aton (const char *cp, in_addr *inp)
int	listen (NetworkSocket s, int backlog)
int	poll (PollDescriptor fds[], nfds_t nfds, int timeout)
ssize_t	recv (NetworkSocket s, void *buf, size_t len, int flags)
ssize_t	recvfrom (NetworkSocket s, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen)
ssize_t	recvmsg (NetworkSocket s, msghdr *message, int flags)
ssize_t	send (NetworkSocket s, const void *buf, size_t len, int flags)
ssize_t	sendmsg (NetworkSocket socket, const msghdr *message, int flags)
ssize_t	sendto (NetworkSocket s, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen)
int	setsockopt (NetworkSocket s, int level, int optname, const void *optval, socklen_t optlen)
int	shutdown (NetworkSocket s, int how)
NetworkSocket	socket (int af, int type, int protocol)
int	socketpair (int domain, int type, int protocol, NetworkSocket sv[2])
int	set_socket_non_blocking (NetworkSocket s)
int	set_socket_close_on_exec (NetworkSocket s)

Function Documentation

NetworkSocket folly::netops::accept	(	NetworkSocket	s,
		sockaddr *	addr,
		socklen_t *	addrlen
	)

Definition at line 71 of file NetOps.cpp.

Referenced by TestServer::acceptFD(), fizz::server::test::AsyncFizzServerTest::completeHandshake(), proxygen::HTTP1xCodec::generateWebsocketAccept(), fizz::server::detail::handleInvalidEvent(), folly::AsyncServerSocket::handlerReady(), proxygen::HTTP1xCodec::onHeadersComplete(), fizz::server::ServerStateMachine::processAccept(), folly::test::Server::Server(), proxygen::TEST_F(), fizz::server::test::TEST_F(), TEST_F(), testSetFromSocket(), and TestServer::verifyConnection().

                                                                          {
  return NetworkSocket(wrapSocketFunction<NetworkSocket::native_handle_type>(
      ::accept, s, addr, addrlen));
}

int folly::netops::bind	(	NetworkSocket	s,
		const sockaddr *	name,
		socklen_t	namelen
	)

Definition at line 76 of file NetOps.cpp.

References folly::kIsWindows, name, and s.

Referenced by folly::ThreadPoolExecutor::addThreads(), BENCHMARK(), folly::AsyncUDPSocket::bind(), folly::AsyncServerSocket::bind(), wangle::ServerBootstrap< DefaultPipeline >::bindImpl(), folly::AsyncServerSocket::bindSocket(), folly::AsyncSocket::connect(), wangle::SSLContextManager::ctxSetupByOpensslFeature(), proxygen::QueueTest::dump(), proxygen::QueueTest::dumpBFS(), wangle::FilePoller::fileTouchedWithinCond(), TestAsyncTransport::fireNextReadEvent(), folly::TestSSLAsyncCacheServer::getSessionCallback(), proxygen::FakeHTTPCodecCallback::getStopFn(), wangle::LocalSSLSessionCache::LocalSSLSessionCache(), StaticService::StaticHandler::onEgressResumed(), StaticService::StaticHandler::onRequest(), run_basic_tests(), run_mt_sequencer_test(), runNeverFailTest(), runTryEnqDeqTest(), folly::runWritesNeverFail(), scheduleEvents(), folly::test::Server::Server(), folly::SNIServer::SNIServer(), TEST(), TEST_F(), testConnectOptWrite(), TestServer::TestServer(), testSetFromSocket(), ThreadExecutor::ThreadExecutor(), and tmpDisableReads().

                                                                   {
  if (kIsWindows && name->sa_family == AF_UNIX) {
    // Windows added support for AF_UNIX sockets, but didn't add
    // support for autobind sockets, so detect requests for autobind
    // sockets and treat them as invalid. (otherwise they don't trigger
    // an error, but also don't actually work)
    if (name->sa_data[0] == '\0') {
      errno = EINVAL;
      return -1;
    }
  }
  return wrapSocketFunction<int>(::bind, s, name, namelen);
}

int folly::netops::close

(

NetworkSocket

s

)

Definition at line 90 of file NetOps.cpp.

References folly::netops::detail::SocketFileDescriptorMap::close(), and folly::NetworkSocket::data.

Referenced by BENCHMARK(), folly::AsyncUDPSocket::bind(), folly::test::CaptureFD::CaptureFD(), folly::netops::detail::SocketFileDescriptorMap::close(), BonkMultiplexClientDispatcher::close(), folly::AsyncUDPSocket::close(), testing::internal::posix::Close(), folly::SocketPair::closeFD0(), folly::SocketPair::closeFD1(), wangle::BroadcastHandler< T, R >::closeIfIdle(), folly::closeNoInt(), folly::SSLServerAcceptCallbackBase::connectionAccepted(), wangle::Acceptor::connectionAccepted(), wangle::Pipeline< int >::create(), proxygen::HTTPDirectResponseHandler::forceConnectionClose(), folly::getSchedTimeWaiting(), fizz::client::test::MockAsyncFizzClient::MockAsyncFizzClient(), folly::NotificationQueue< folly::AsyncServerSocket::QueueMessage >::NotificationQueue(), testing::internal::PortableLocaltime(), folly::Subprocess::prepareChild(), TelnetHandler::read(), FileServerHandler::read(), folly::WriteErrorCallback::readDataAvailable(), TelnetHandler::readEOF(), EchoHandler::readEOF(), ProxyFrontendHandler::readEOF(), TelnetHandler::readException(), EchoHandler::readException(), FileServerHandler::readException(), ProxyFrontendHandler::readException(), folly::test::CaptureFD::release(), folly::symbolizer::ElfFile::reset(), folly::test::runCloseTest(), folly::test::runKillTest(), folly::Subprocess::spawn(), folly::Subprocess::spawnInternal(), EventHandlerTest::TearDown(), TEST(), TEST(), TEST_F(), fizz::test::TEST_F(), testing::internal::TestResultAccessor::test_part_results(), testConnectOptWrite(), testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(), testSetFromSocket(), testTemporaryDirectory(), ThreadPrintingHandler::transportActive(), ProxyFrontendHandler::transportActive(), folly::writeFileAtomicNoThrow(), folly::AsyncIO::~AsyncIO(), testing::internal::GTestLog::~GTestLog(), folly::NotificationQueue< folly::AsyncServerSocket::QueueMessage >::~NotificationQueue(), and TestServer::~TestServer().

                           {
  return netops::detail::SocketFileDescriptorMap::close(s.data);
}

int folly::netops::connect	(	NetworkSocket	s,
		const sockaddr *	name,
		socklen_t	namelen
	)

Definition at line 94 of file NetOps.cpp.

References name, and s.

Referenced by fizz::client::test::AsyncFizzClientTest::completeEarlyHandshake(), fizz::client::test::AsyncFizzClientTest::completeHandshake(), fizz::client::FizzClient< ActionMoveVisitor, SM >::connect(), folly::AsyncUDPSocket::connect(), folly::test::createConnectedSocket(), fizz::sm::getEarlyDataParams(), wangle::BaseClientBootstrap< DefaultPipeline >::getPipeline(), fizz::client::test::MockAsyncFizzClient::MockAsyncFizzClient(), testing::internal::PortableLocaltime(), fizz::client::ClientStateMachine::processConnect(), folly::SSLClient::readDataAvailable(), folly::AsyncSocket::socketConnect(), UDPClient::start(), folly::TEST(), TEST(), TEST_F(), fizz::client::test::TEST_F(), testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(), testSetFromSocket(), and ConnectedWriteUDPClient::writePing().

                                                                      {
  auto r = wrapSocketFunction<int>(::connect, s, name, namelen);
#if _WIN32
  if (r == -1 && WSAGetLastError() == WSAEWOULDBLOCK) {
    errno = EINPROGRESS;
  }
#endif
  return r;
}

int folly::netops::getpeername	(	NetworkSocket	s,
		sockaddr *	name,
		socklen_t *	namelen
	)

Definition at line 104 of file NetOps.cpp.

References name, and s.

Referenced by folly::ssl::OpenSSLUtils::getPeerAddressFromX509StoreCtx(), and folly::SocketAddress::setFromPeerAddress().

                                                                     {
  return wrapSocketFunction<int>(::getpeername, s, name, namelen);
}

int folly::netops::getsockname	(	NetworkSocket	s,
		sockaddr *	name,
		socklen_t *	namelen
	)

Definition at line 108 of file NetOps.cpp.

References name, and s.

Referenced by folly::test::Server::Server(), folly::SocketAddress::setFromLocalAddress(), and TEST_F().

                                                                     {
  return wrapSocketFunction<int>(::getsockname, s, name, namelen);
}

int folly::netops::getsockopt	(	NetworkSocket	s,
		int	level,
		int	optname,
		void *	optval,
		socklen_t *	optlen
	)

Definition at line 112 of file NetOps.cpp.

References s, and uint8_t.

Referenced by folly::SSLServerAcceptCallbackDelay::connAccepted(), folly::AsyncUDPSocket::getGSO(), folly::AsyncSocket::getSockOpt(), folly::AsyncSocket::getSockOptVirtual(), folly::AsyncSocket::handleConnect(), folly::AsyncServerSocket::handlerReady(), wangle::TransportInfo::readRTT(), folly::AsyncSocket::setZeroCopy(), folly::TEST(), and TEST().

                       {
  auto ret = wrapSocketFunction<int>(
      ::getsockopt, s, level, optname, (char*)optval, optlen);
#if _WIN32
  if (optname == TCP_NODELAY && *optlen == 1) {
    // Windows is weird about this value, and documents it as a
    // BOOL (ie. int) but expects the variable to be bool (1-byte),
    // so we get to adapt the interface to work that way.
    *(int*)optval = *(uint8_t*)optval;
    *optlen = sizeof(int);
  }
#endif
  return ret;
}

int folly::netops::inet_aton	(	const char *	cp,
		in_addr *	inp
	)

Definition at line 132 of file NetOps.cpp.

                                            {
  inp->s_addr = inet_addr(cp);
  return inp->s_addr == INADDR_NONE ? 0 : 1;
}

int folly::netops::listen	(	NetworkSocket	s,
		int	backlog
	)

Definition at line 137 of file NetOps.cpp.

References s.

Referenced by folly::AsyncServerSocket::listen(), folly::test::Server::Server(), TEST(), TEST_F(), TestServer::TestServer(), and testSetFromSocket().

                                         {
  return wrapSocketFunction<int>(::listen, s, backlog);
}

int folly::netops::poll	(	PollDescriptor	fds[],
		nfds_t	nfds,
		int	timeout
	)

Definition at line 141 of file NetOps.cpp.

Referenced by TestServer::acceptFD(), folly::Subprocess::communicate(), folly::Future< folly::folly::Unit >::Future(), folly::AsyncSocket::hangup(), folly::Subprocess::pollChecked(), folly::AsyncSocket::readable(), folly::Subprocess::returnCode(), folly::SemiFuture< T >::SemiFuture(), TEST(), folly::futures::detail::FutureBase< T >::valid(), and folly::AsyncSocket::writable().

                                                         {
  // Make sure that PollDescriptor is byte-for-byte identical to pollfd,
  // so we don't need extra allocations just for the safety of this shim.
  static_assert(
      alignof(PollDescriptor) == alignof(pollfd),
      "PollDescriptor is misaligned");
  static_assert(
      sizeof(PollDescriptor) == sizeof(pollfd),
      "PollDescriptor is the wrong size");
  static_assert(
      offsetof(PollDescriptor, fd) == offsetof(pollfd, fd),
      "PollDescriptor.fd is at the wrong place");
  static_assert(
      sizeof(decltype(PollDescriptor().fd)) == sizeof(decltype(pollfd().fd)),
      "PollDescriptor.fd is the wrong size");
  static_assert(
      offsetof(PollDescriptor, events) == offsetof(pollfd, events),
      "PollDescriptor.events is at the wrong place");
  static_assert(
      sizeof(decltype(PollDescriptor().events)) ==
          sizeof(decltype(pollfd().events)),
      "PollDescriptor.events is the wrong size");
  static_assert(
      offsetof(PollDescriptor, revents) == offsetof(pollfd, revents),
      "PollDescriptor.revents is at the wrong place");
  static_assert(
      sizeof(decltype(PollDescriptor().revents)) ==
          sizeof(decltype(pollfd().revents)),
      "PollDescriptor.revents is the wrong size");

  // Pun it through
  pollfd* files = reinterpret_cast<pollfd*>(reinterpret_cast<void*>(fds));
#if _WIN32
  return ::WSAPoll(files, (ULONG)nfds, timeout);
#else
  return ::poll(files, nfds, timeout);
#endif
}

ssize_t folly::netops::recv	(	NetworkSocket	s,
		void *	buf,
		size_t	len,
		int	flags
	)

Definition at line 180 of file NetOps.cpp.

References folly::NetworkSocket::data, s, and folly::detail::timeout.

Referenced by folly::AsyncSSLSocket::bioRead(), folly::AsyncSocket::performRead(), folly::TEST(), and TEST_F().

                                                                {
#if _WIN32
  if ((flags & MSG_DONTWAIT) == MSG_DONTWAIT) {
    flags &= ~MSG_DONTWAIT;

    u_long pendingRead = 0;
    if (ioctlsocket(s.data, FIONREAD, &pendingRead)) {
      errno = translate_wsa_error(WSAGetLastError());
      return -1;
    }

    fd_set readSet;
    FD_ZERO(&readSet);
    FD_SET(s.data, &readSet);
    timeval timeout{0, 0};
    auto ret = select(1, &readSet, nullptr, nullptr, &timeout);
    if (ret == 0) {
      errno = EWOULDBLOCK;
      return -1;
    }
  }
  return wrapSocketFunction<ssize_t>(::recv, s, (char*)buf, (int)len, flags);
#else
  return wrapSocketFunction<ssize_t>(::recv, s, buf, len, flags);
#endif
}

ssize_t folly::netops::recvfrom	(	NetworkSocket	s,
		void *	buf,
		size_t	len,
		int	flags,
		sockaddr *	from,
		socklen_t *	fromlen
	)

Definition at line 207 of file NetOps.cpp.

References folly::NetworkSocket::data, folly::pushmi::operators::from, h, and s.

Referenced by folly::AsyncUDPSocket::handleRead().

                        {
#if _WIN32
  if ((flags & MSG_TRUNC) == MSG_TRUNC) {
    SOCKET h = s.data;

    WSABUF wBuf{};
    wBuf.buf = (CHAR*)buf;
    wBuf.len = (ULONG)len;
    WSAMSG wMsg{};
    wMsg.dwBufferCount = 1;
    wMsg.lpBuffers = &wBuf;
    wMsg.name = from;
    if (fromlen != nullptr) {
      wMsg.namelen = *fromlen;
    }

    // WSARecvMsg is an extension, so we don't get
    // the convenience of being able to call it directly, even though
    // WSASendMsg is part of the normal API -_-...
    LPFN_WSARECVMSG WSARecvMsg;
    GUID WSARecgMsg_GUID = WSAID_WSARECVMSG;
    DWORD recMsgBytes;
    WSAIoctl(
        h,
        SIO_GET_EXTENSION_FUNCTION_POINTER,
        &WSARecgMsg_GUID,
        sizeof(WSARecgMsg_GUID),
        &WSARecvMsg,
        sizeof(WSARecvMsg),
        &recMsgBytes,
        nullptr,
        nullptr);

    DWORD bytesReceived;
    int res = WSARecvMsg(h, &wMsg, &bytesReceived, nullptr, nullptr);
    errno = translate_wsa_error(WSAGetLastError());
    if (res == 0) {
      return bytesReceived;
    }
    if (fromlen != nullptr) {
      *fromlen = wMsg.namelen;
    }
    if ((wMsg.dwFlags & MSG_TRUNC) == MSG_TRUNC) {
      return wBuf.len + 1;
    }
    return -1;
  }
  return wrapSocketFunction<ssize_t>(
      ::recvfrom, s, (char*)buf, (int)len, flags, from, fromlen);
#else
  return wrapSocketFunction<ssize_t>(
      ::recvfrom, s, buf, len, flags, from, fromlen);
#endif
}

ssize_t folly::netops::recvmsg	(	NetworkSocket	s,
		msghdr *	message,
		int	flags
	)

Definition at line 268 of file NetOps.cpp.

References folly::NetworkSocket::data, h, i, message, s, and SCOPE_EXIT.

Referenced by folly::AsyncUDPSocket::handleErrMessages(), folly::AsyncSocket::handleErrMessages(), TEST(), and folly::ExpectWriteErrorCallback::~ExpectWriteErrorCallback().

                                                             {
#if _WIN32
  (void)flags;
  SOCKET h = s.data;

  // Don't currently support the name translation.
  if (message->msg_name != nullptr || message->msg_namelen != 0) {
    return (ssize_t)-1;
  }
  WSAMSG msg;
  msg.name = nullptr;
  msg.namelen = 0;
  msg.Control.buf = (CHAR*)message->msg_control;
  msg.Control.len = (ULONG)message->msg_controllen;
  msg.dwFlags = 0;
  msg.dwBufferCount = (DWORD)message->msg_iovlen;
  msg.lpBuffers = new WSABUF[message->msg_iovlen];
  SCOPE_EXIT {
    delete[] msg.lpBuffers;
  };
  for (size_t i = 0; i < message->msg_iovlen; i++) {
    msg.lpBuffers[i].buf = (CHAR*)message->msg_iov[i].iov_base;
    msg.lpBuffers[i].len = (ULONG)message->msg_iov[i].iov_len;
  }

  // WSARecvMsg is an extension, so we don't get
  // the convenience of being able to call it directly, even though
  // WSASendMsg is part of the normal API -_-...
  LPFN_WSARECVMSG WSARecvMsg;
  GUID WSARecgMsg_GUID = WSAID_WSARECVMSG;
  DWORD recMsgBytes;
  WSAIoctl(
      h,
      SIO_GET_EXTENSION_FUNCTION_POINTER,
      &WSARecgMsg_GUID,
      sizeof(WSARecgMsg_GUID),
      &WSARecvMsg,
      sizeof(WSARecvMsg),
      &recMsgBytes,
      nullptr,
      nullptr);

  DWORD bytesReceived;
  int res = WSARecvMsg(h, &msg, &bytesReceived, nullptr, nullptr);
  errno = translate_wsa_error(WSAGetLastError());
  return res == 0 ? (ssize_t)bytesReceived : -1;
#else
  return wrapSocketFunction<ssize_t>(::recvmsg, s, message, flags);
#endif
}

ssize_t folly::netops::send	(	NetworkSocket	s,
		const void *	buf,
		size_t	len,
		int	flags
	)

Definition at line 319 of file NetOps.cpp.

References s.

Referenced by ZlibServerFilterTest::exercise_compression(), PushService::PushRequestHandler::onRequest(), sendmsg(), and TEST_F().

                                                                      {
#if _WIN32
  return wrapSocketFunction<ssize_t>(
      ::send, s, (const char*)buf, (int)len, flags);
#else
  return wrapSocketFunction<ssize_t>(::send, s, buf, len, flags);
#endif
}

ssize_t folly::netops::sendmsg	(	NetworkSocket	socket,
		const msghdr *	message,
		int	flags
	)

Definition at line 328 of file NetOps.cpp.

References folly::NetworkSocket::data, h, i, message, send(), sendto(), and socket().

Referenced by folly::AsyncUDPSocket::sendmsg(), folly::AsyncSocket::sendSocketMessage(), TestAsyncUDPSocket::TestAsyncUDPSocket(), and ConnectedWriteUDPClient::writePing().

                                                                        {
#if _WIN32
  (void)flags;
  SOCKET h = socket.data;

  // Unfortunately, WSASendMsg requires the socket to have been opened
  // as either SOCK_DGRAM or SOCK_RAW, but sendmsg has no such requirement,
  // so we have to implement it based on send instead :(
  ssize_t bytesSent = 0;
  for (size_t i = 0; i < message->msg_iovlen; i++) {
    int r = -1;
    if (message->msg_name != nullptr) {
      r = ::sendto(
          h,
          (const char*)message->msg_iov[i].iov_base,
          (int)message->msg_iov[i].iov_len,
          message->msg_flags,
          (const sockaddr*)message->msg_name,
          (int)message->msg_namelen);
    } else {
      r = ::send(
          h,
          (const char*)message->msg_iov[i].iov_base,
          (int)message->msg_iov[i].iov_len,
          message->msg_flags);
    }
    if (r == -1 || size_t(r) != message->msg_iov[i].iov_len) {
      errno = translate_wsa_error(WSAGetLastError());
      if (WSAGetLastError() == WSAEWOULDBLOCK && bytesSent > 0) {
        return bytesSent;
      }
      return -1;
    }
    bytesSent += r;
  }
  return bytesSent;
#else
  return wrapSocketFunction<ssize_t>(::sendmsg, socket, message, flags);
#endif
}

ssize_t folly::netops::sendto	(	NetworkSocket	s,
		const void *	buf,
		size_t	len,
		int	flags,
		const sockaddr *	to,
		socklen_t	tolen
	)

Definition at line 369 of file NetOps.cpp.

References s, and folly::to().

Referenced by sendmsg().

                     {
#if _WIN32
  return wrapSocketFunction<ssize_t>(
      ::sendto, s, (const char*)buf, (int)len, flags, to, (int)tolen);
#else
  return wrapSocketFunction<ssize_t>(::sendto, s, buf, len, flags, to, tolen);
#endif
}

int folly::netops::set_socket_close_on_exec

(

NetworkSocket

s

)

Definition at line 454 of file NetOps.cpp.

References folly::NetworkSocket::data.

                                              {
#if _WIN32
  if (SetHandleInformation((HANDLE)s.data, HANDLE_FLAG_INHERIT, 0)) {
    return 0;
  }
  return -1;
#else
  return fcntl(s.data, F_SETFD, FD_CLOEXEC);
#endif
}

int folly::netops::set_socket_non_blocking

(

NetworkSocket

s

)

Definition at line 441 of file NetOps.cpp.

References folly::NetworkSocket::data.

Referenced by folly::AsyncUDPSocket::bind().

                                             {
#if _WIN32
  u_long nonBlockingEnabled = 1;
  return ioctlsocket(s.data, FIONBIO, &nonBlockingEnabled);
#else
  int flags = fcntl(s.data, F_GETFL, 0);
  if (flags == -1) {
    return -1;
  }
  return fcntl(s.data, F_SETFL, flags | O_NONBLOCK);
#endif
}

int folly::netops::setsockopt	(	NetworkSocket	s,
		int	level,
		int	optname,
		const void *	optval,
		socklen_t	optlen
	)

Definition at line 384 of file NetOps.cpp.

References s, and SO_REUSEPORT.

Referenced by folly::AsyncSocket::OptionKey::apply(), folly::AsyncUDPSocket::bind(), folly::AsyncServerSocket::bind(), folly::AsyncServerSocket::bindSocket(), folly::test::Server::closeClients(), folly::SSLServerAcceptCallbackDelay::connAccepted(), folly::AsyncSocket::connect(), wangle::Acceptor::connectionAccepted(), folly::AsyncUDPSocket::dontFragment(), folly::ShutdownSocketSet::doShutdown(), folly::AsyncSocket::SendMsgParamsCallback::getDefaultFlags(), folly::AsyncServerSocket::handlerReady(), folly::AsyncSocket::setCongestionFlavor(), folly::AsyncUDPSocket::setErrMessageCallback(), folly::AsyncUDPSocket::setGSO(), folly::AsyncServerSocket::setKeepAliveEnabled(), folly::AsyncSocket::setNoDelay(), folly::AsyncSocket::setQuickAck(), folly::AsyncSocket::setRecvBufSize(), folly::AsyncServerSocket::setReusePortEnabled(), folly::AsyncSocket::setSendBufSize(), folly::AsyncSocket::setSockOpt(), folly::AsyncSocket::setSockOptVirtual(), folly::AsyncSocket::setTCPProfile(), folly::AsyncServerSocket::setTosReflect(), folly::AsyncServerSocket::setupSocket(), folly::AsyncServerSocket::setZeroCopy(), folly::AsyncSocket::setZeroCopy(), TestServer::TestServer(), and folly::AsyncServerSocket::useExistingSockets().

                      {
#if _WIN32
  if (optname == SO_REUSEADDR) {
    // We don't have an equivelent to the Linux & OSX meaning of this
    // on Windows, so ignore it.
    return 0;
  } else if (optname == SO_REUSEPORT) {
    // Windows's SO_REUSEADDR option is closer to SO_REUSEPORT than
    // it is to the Linux & OSX meaning of SO_REUSEADDR.
    return -1;
  }
  return wrapSocketFunction<int>(
      ::setsockopt, s, level, optname, (char*)optval, optlen);
#else
  return wrapSocketFunction<int>(
      ::setsockopt, s, level, optname, optval, optlen);
#endif
}

int folly::netops::shutdown	(	NetworkSocket	s,
		int	how
	)

Definition at line 408 of file NetOps.cpp.

References s.

Referenced by folly::shutdownNoInt().

                                       {
  return wrapSocketFunction<int>(::shutdown, s, how);
}

NetworkSocket folly::netops::socket	(	int	af,
		int	type,
		int	protocol
	)

Definition at line 412 of file NetOps.cpp.

Referenced by wangle::AsyncServerSocketFactory::addAcceptCB(), wangle::AsyncUDPServerSocketFactory::addAcceptCB(), folly::AsyncUDPSocket::bind(), wangle::ServerBootstrap< DefaultPipeline >::bind(), folly::AsyncServerSocket::bind(), wangle::ServerBootstrap< DefaultPipeline >::bindImpl(), wangle::ClientBootstrap< DefaultPipeline >::connect(), folly::AsyncSocket::connect(), folly::test::createConnectedSocket(), folly::AsyncServerSocket::createSocket(), folly::AsyncServerSocket::dispatchSocket(), folly::AsyncServerSocket::getAddresses(), main(), folly::SocketAddress::makeFromPath(), wangle::AsyncServerSocketFactory::newSocket(), wangle::AsyncUDPServerSocketFactory::newSocket(), UDPAcceptor::onDataAvailable(), folly::AsyncUDPServerSocket::onDataAvailable(), wangle::ServerAcceptor< Pipeline >::onDataAvailable(), folly::AsyncUDPServerSocket::Callback::onListenResumed(), wangle::AcceptRoutingHandler< Pipeline, R >::onRoutingData(), wangle::AsyncUDPServerSocketFactory::ThreadSafeDestructor::operator()(), testing::internal::PortableLocaltime(), wangle::AcceptRoutingHandler< Pipeline, R >::read(), wangle::AsyncServerSocketFactory::removeAcceptCB(), sendmsg(), UDPAcceptor::sendPong(), folly::test::Server::Server(), serverSocketSanityTest(), folly::ssl::OpenSSLUtils::setBioFd(), folly::SendMsgParamsCallbackBase::setSocket(), folly::WriteCallbackBase::setSocket(), folly::ReadCallbackBase::setSocket(), folly::HandshakeCallback::setSocket(), folly::TEST(), TEST(), TEST(), TEST_F(), TEST_P(), testConnectOptWrite(), testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(), TestServer::TestServer(), testSetFromSocket(), wangle::ServerWorkerPool::threadStarted(), wangle::ServerWorkerPool::threadStopped(), proxygen::HTTPServerOptions::useExistingSockets(), folly::ExpectWriteErrorCallback::~ExpectWriteErrorCallback(), and wangle::RoutingDataPipelineFactory< ObservingPipeline< T >, R >::~RoutingDataPipelineFactory().

                                                     {
  return NetworkSocket(::socket(af, type, protocol));
}

int folly::netops::socketpair	(	int	domain,
		int	type,
		int	protocol,
		NetworkSocket	sv[2]
	)

Definition at line 416 of file NetOps.cpp.

Referenced by folly::getfds(), folly::SocketPair::SocketPair(), and TEST().

                                                                        {
#if _WIN32
  if (domain != PF_UNIX || type != SOCK_STREAM || protocol != 0) {
    return -1;
  }
  intptr_t pair[2];
  auto r = evutil_socketpair(AF_INET, type, protocol, pair);
  if (r == -1) {
    return r;
  }
  sv[0] = NetworkSocket(static_cast<SOCKET>(pair[0]));
  sv[1] = NetworkSocket(static_cast<SOCKET>(pair[1]));
  return r;
#else
  int pair[2];
  auto r = ::socketpair(domain, type, protocol, pair);
  if (r == -1) {
    return r;
  }
  sv[0] = NetworkSocket(pair[0]);
  sv[1] = NetworkSocket(pair[1]);
  return r;
#endif
}

folly::netops::TEST	(	SocketFileDescriptorMap	,
		fd_to_socket_consistent
	)

Definition at line 31 of file SocketFileDescriptorMapTest.cpp.

References folly::netops::detail::SocketFileDescriptorMap::close(), EXPECT_EQ, folly::netops::detail::SocketFileDescriptorMap::fdToSocket(), socket(), and folly::netops::detail::SocketFileDescriptorMap::socketToFd().

                                                       {
  auto fd = fsp::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  auto sockA = SocketFileDescriptorMap::fdToSocket(fd);
  auto sockB = SocketFileDescriptorMap::fdToSocket(fd);
  EXPECT_EQ(sockA, sockB);

  int fd2 = SocketFileDescriptorMap::socketToFd(sockA);
  EXPECT_EQ(fd, fd2);

  SocketFileDescriptorMap::close(fd);
}

folly::netops::TEST	(	SocketFileDescriptorMap	,
		no_socket_reuse
	)

Definition at line 43 of file SocketFileDescriptorMapTest.cpp.

References folly::netops::detail::SocketFileDescriptorMap::close(), close(), EXPECT_EQ, EXPECT_NE, folly::netops::detail::SocketFileDescriptorMap::fdToSocket(), folly::kIsWindows, socket(), and folly::netops::detail::SocketFileDescriptorMap::socketToFd().

                                               {
  auto sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  int fdA = SocketFileDescriptorMap::socketToFd(sock);
  int fdB = SocketFileDescriptorMap::socketToFd(sock);
  EXPECT_EQ(fdA, fdB);

  auto sock2 = SocketFileDescriptorMap::fdToSocket(fdA);
  EXPECT_EQ(sock, sock2);

  SocketFileDescriptorMap::close(sock);

  // We're on Windows, so let's do some additional testing to ensure
  // that we aren't using stale entries in the map.
  // This is guarded to only on Windows because we need to assert on
  // the specifics of how file descriptors & sockets are allocated,
  // which varies between platforms.
  if (kIsWindows) {
    auto sock3 = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    // Nothing else is running in this context, so we should,
    // in theory, have re-allocated the same socket/file descriptor.
    EXPECT_EQ(sock, sock3);

    // Now we mess up the order by creating a new FD.
    int devNull = ::open("/dev/null", O_RDONLY);
    EXPECT_EQ(devNull, fdA);

    int fdC = SocketFileDescriptorMap::socketToFd(sock);
    EXPECT_NE(fdA, fdC);

    SocketFileDescriptorMap::close(sock3);
    ::close(devNull);
  }
}

folly::netops::TEST	(	SocketFileDescriptorMap	,
		close_non_mapped_native_socket
	)

Definition at line 77 of file SocketFileDescriptorMapTest.cpp.

References folly::netops::detail::SocketFileDescriptorMap::close(), and socket().

                                                              {
  auto sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  SocketFileDescriptorMap::close(sock);
}