blob: 400f45b563e84a4b5b76408e6e7c87ae3d1db8be [file] [log] [blame]
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <arpa/inet.h>
#include <fcntl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include "absl/base/optimization.h"
#include "quiche/quic/core/io/socket.h"
#include "quiche/quic/core/quic_udp_socket.h"
#include "quiche/quic/platform/api/quic_bug_tracker.h"
#include "quiche/quic/platform/api/quic_ip_address_family.h"
#include "quiche/quic/platform/api/quic_udp_socket_platform_api.h"
#if defined(__APPLE__) && !defined(__APPLE_USE_RFC_3542)
#error "__APPLE_USE_RFC_3542 needs to be defined."
#endif
#if defined(__linux__)
#include <alloca.h>
// For SO_TIMESTAMPING.
#include <linux/net_tstamp.h>
#endif
#if defined(__linux__) && !defined(__ANDROID__)
#define QUIC_UDP_SOCKET_SUPPORT_TTL 1
#endif
namespace quic {
namespace {
#if defined(__linux__) && (!defined(__ANDROID_API__) || __ANDROID_API__ >= 21)
#define QUIC_UDP_SOCKET_SUPPORT_LINUX_TIMESTAMPING 1
// This is the structure that SO_TIMESTAMPING fills into the cmsg header.
// It is well-defined, but does not have a definition in a public header.
// See https://www.kernel.org/doc/Documentation/networking/timestamping.txt
// for more information.
struct LinuxSoTimestamping {
// The converted system time of the timestamp.
struct timespec systime;
// Deprecated; serves only as padding.
struct timespec hwtimetrans;
// The raw hardware timestamp.
struct timespec hwtimeraw;
};
const size_t kCmsgSpaceForRecvTimestamp =
CMSG_SPACE(sizeof(LinuxSoTimestamping));
#else
const size_t kCmsgSpaceForRecvTimestamp = 0;
#endif
const size_t kMinCmsgSpaceForRead =
CMSG_SPACE(sizeof(uint32_t)) // Dropped packet count
+ CMSG_SPACE(sizeof(in_pktinfo)) // V4 Self IP
+ CMSG_SPACE(sizeof(in6_pktinfo)) // V6 Self IP
+ kCmsgSpaceForRecvTimestamp + CMSG_SPACE(sizeof(int)) // TTL
+ kCmsgSpaceForGooglePacketHeader;
void SetV4SelfIpInControlMessage(const QuicIpAddress& self_address,
cmsghdr* cmsg) {
QUICHE_DCHECK(self_address.IsIPv4());
in_pktinfo* pktinfo = reinterpret_cast<in_pktinfo*>(CMSG_DATA(cmsg));
memset(pktinfo, 0, sizeof(in_pktinfo));
pktinfo->ipi_ifindex = 0;
std::string address_string = self_address.ToPackedString();
memcpy(&pktinfo->ipi_spec_dst, address_string.c_str(),
address_string.length());
}
void SetV6SelfIpInControlMessage(const QuicIpAddress& self_address,
cmsghdr* cmsg) {
QUICHE_DCHECK(self_address.IsIPv6());
in6_pktinfo* pktinfo = reinterpret_cast<in6_pktinfo*>(CMSG_DATA(cmsg));
memset(pktinfo, 0, sizeof(in6_pktinfo));
std::string address_string = self_address.ToPackedString();
memcpy(&pktinfo->ipi6_addr, address_string.c_str(), address_string.length());
}
void PopulatePacketInfoFromControlMessage(struct cmsghdr* cmsg,
QuicUdpPacketInfo* packet_info,
BitMask64 packet_info_interested) {
#ifdef SOL_UDP
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::IS_GRO) &&
cmsg->cmsg_level == SOL_UDP && cmsg->cmsg_type == UDP_GRO) {
packet_info->set_gso_size(*reinterpret_cast<uint16_t*>(CMSG_DATA(cmsg)));
}
#endif
#if defined(__linux__) && defined(SO_RXQ_OVFL)
if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_RXQ_OVFL) {
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::DROPPED_PACKETS)) {
packet_info->SetDroppedPackets(
*(reinterpret_cast<uint32_t*> CMSG_DATA(cmsg)));
}
return;
}
#endif
#if defined(QUIC_UDP_SOCKET_SUPPORT_LINUX_TIMESTAMPING)
if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_TIMESTAMPING) {
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::RECV_TIMESTAMP)) {
LinuxSoTimestamping* linux_ts =
reinterpret_cast<LinuxSoTimestamping*>(CMSG_DATA(cmsg));
timespec* ts = &linux_ts->systime;
int64_t usec = (static_cast<int64_t>(ts->tv_sec) * 1000 * 1000) +
(static_cast<int64_t>(ts->tv_nsec) / 1000);
packet_info->SetReceiveTimestamp(
QuicWallTime::FromUNIXMicroseconds(usec));
}
return;
}
#endif
if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO) {
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V6_SELF_IP)) {
const in6_pktinfo* info = reinterpret_cast<in6_pktinfo*>(CMSG_DATA(cmsg));
const char* addr_data = reinterpret_cast<const char*>(&info->ipi6_addr);
int addr_len = sizeof(in6_addr);
QuicIpAddress self_v6_ip;
if (self_v6_ip.FromPackedString(addr_data, addr_len)) {
packet_info->SetSelfV6Ip(self_v6_ip);
} else {
QUIC_BUG(quic_bug_10751_1) << "QuicIpAddress::FromPackedString failed";
}
}
return;
}
if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO) {
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V4_SELF_IP)) {
const in_pktinfo* info = reinterpret_cast<in_pktinfo*>(CMSG_DATA(cmsg));
const char* addr_data = reinterpret_cast<const char*>(&info->ipi_addr);
int addr_len = sizeof(in_addr);
QuicIpAddress self_v4_ip;
if (self_v4_ip.FromPackedString(addr_data, addr_len)) {
packet_info->SetSelfV4Ip(self_v4_ip);
} else {
QUIC_BUG(quic_bug_10751_2) << "QuicIpAddress::FromPackedString failed";
}
}
return;
}
if ((cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_TTL) ||
(cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_HOPLIMIT)) {
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::TTL)) {
packet_info->SetTtl(*(reinterpret_cast<int*>(CMSG_DATA(cmsg))));
}
return;
}
if (packet_info_interested.IsSet(
QuicUdpPacketInfoBit::GOOGLE_PACKET_HEADER)) {
BufferSpan google_packet_headers;
if (GetGooglePacketHeadersFromControlMessage(
cmsg, &google_packet_headers.buffer,
&google_packet_headers.buffer_len)) {
packet_info->SetGooglePacketHeaders(google_packet_headers);
}
}
}
bool NextCmsg(msghdr* hdr, char* control_buffer, size_t control_buffer_len,
int cmsg_level, int cmsg_type, size_t data_size,
cmsghdr** cmsg /*in, out*/) {
// msg_controllen needs to be increased first, otherwise CMSG_NXTHDR will
// return nullptr.
hdr->msg_controllen += CMSG_SPACE(data_size);
if (hdr->msg_controllen > control_buffer_len) {
return false;
}
if ((*cmsg) == nullptr) {
QUICHE_DCHECK_EQ(nullptr, hdr->msg_control);
memset(control_buffer, 0, control_buffer_len);
hdr->msg_control = control_buffer;
(*cmsg) = CMSG_FIRSTHDR(hdr);
} else {
QUICHE_DCHECK_NE(nullptr, hdr->msg_control);
(*cmsg) = CMSG_NXTHDR(hdr, (*cmsg));
}
if (nullptr == (*cmsg)) {
return false;
}
(*cmsg)->cmsg_len = CMSG_LEN(data_size);
(*cmsg)->cmsg_level = cmsg_level;
(*cmsg)->cmsg_type = cmsg_type;
return true;
}
} // namespace
QuicUdpSocketFd QuicUdpSocketApi::Create(int address_family,
int receive_buffer_size,
int send_buffer_size, bool ipv6_only) {
// QUICHE_DCHECK here so the program exits early(before reading packets) in
// debug mode. This should have been a static_assert, however it can't be done
// on ios/osx because CMSG_SPACE isn't a constant expression there.
QUICHE_DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead);
absl::StatusOr<SocketFd> socket =
socket_api::CreateSocket(FromPlatformAddressFamily(address_family),
socket_api::SocketProtocol::kUdp,
/*blocking=*/false);
if (!socket.ok()) {
QUIC_LOG_FIRST_N(ERROR, 100)
<< "UDP non-blocking socket creation for address_family="
<< address_family << " failed: " << socket.status();
return kQuicInvalidSocketFd;
}
SetGoogleSocketOptions(socket.value());
if (!SetupSocket(socket.value(), address_family, receive_buffer_size,
send_buffer_size, ipv6_only)) {
Destroy(socket.value());
return kQuicInvalidSocketFd;
}
return socket.value();
}
bool QuicUdpSocketApi::SetupSocket(QuicUdpSocketFd fd, int address_family,
int receive_buffer_size,
int send_buffer_size, bool ipv6_only) {
// Receive buffer size.
if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &receive_buffer_size,
sizeof(receive_buffer_size)) != 0) {
QUIC_LOG_FIRST_N(ERROR, 100) << "Failed to set socket recv size";
return false;
}
// Send buffer size.
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &send_buffer_size,
sizeof(send_buffer_size)) != 0) {
QUIC_LOG_FIRST_N(ERROR, 100) << "Failed to set socket send size";
return false;
}
if (!(address_family == AF_INET6 && ipv6_only)) {
if (!EnableReceiveSelfIpAddressForV4(fd)) {
QUIC_LOG_FIRST_N(ERROR, 100)
<< "Failed to enable receiving of self v4 ip";
return false;
}
}
if (address_family == AF_INET6) {
if (!EnableReceiveSelfIpAddressForV6(fd)) {
QUIC_LOG_FIRST_N(ERROR, 100)
<< "Failed to enable receiving of self v6 ip";
return false;
}
}
return true;
}
void QuicUdpSocketApi::Destroy(QuicUdpSocketFd fd) {
if (fd != kQuicInvalidSocketFd) {
absl::Status result = socket_api::Close(fd);
if (!result.ok()) {
QUIC_LOG_FIRST_N(WARNING, 100)
<< "Failed to close UDP socket with error " << result;
}
}
}
bool QuicUdpSocketApi::Bind(QuicUdpSocketFd fd, QuicSocketAddress address) {
sockaddr_storage addr = address.generic_address();
int addr_len =
address.host().IsIPv4() ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
return 0 == bind(fd, reinterpret_cast<sockaddr*>(&addr), addr_len);
}
bool QuicUdpSocketApi::BindInterface(QuicUdpSocketFd fd,
const std::string& interface_name) {
#if defined(__linux__) && !defined(__ANDROID_API__)
if (interface_name.empty() || interface_name.size() >= IFNAMSIZ) {
QUIC_BUG(udp_bad_interface_name)
<< "interface_name must be nonempty and shorter than " << IFNAMSIZ;
return false;
}
return 0 == setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
interface_name.c_str(), interface_name.length());
#else
(void)fd;
(void)interface_name;
QUIC_BUG(interface_bind_not_implemented)
<< "Interface binding is not implemented on this platform";
return false;
#endif
}
bool QuicUdpSocketApi::EnableDroppedPacketCount(QuicUdpSocketFd fd) {
#if defined(__linux__) && defined(SO_RXQ_OVFL)
int get_overflow = 1;
return 0 == setsockopt(fd, SOL_SOCKET, SO_RXQ_OVFL, &get_overflow,
sizeof(get_overflow));
#else
(void)fd;
return false;
#endif
}
bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV4(QuicUdpSocketFd fd) {
int get_self_ip = 1;
return 0 == setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &get_self_ip,
sizeof(get_self_ip));
}
bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV6(QuicUdpSocketFd fd) {
int get_self_ip = 1;
return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &get_self_ip,
sizeof(get_self_ip));
}
bool QuicUdpSocketApi::EnableReceiveTimestamp(QuicUdpSocketFd fd) {
#if defined(__linux__) && (!defined(__ANDROID_API__) || __ANDROID_API__ >= 21)
int timestamping = SOF_TIMESTAMPING_RX_SOFTWARE | SOF_TIMESTAMPING_SOFTWARE;
return 0 == setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING, &timestamping,
sizeof(timestamping));
#else
(void)fd;
return false;
#endif
}
bool QuicUdpSocketApi::EnableReceiveTtlForV4(QuicUdpSocketFd fd) {
#if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
int get_ttl = 1;
return 0 == setsockopt(fd, IPPROTO_IP, IP_RECVTTL, &get_ttl, sizeof(get_ttl));
#else
(void)fd;
return false;
#endif
}
bool QuicUdpSocketApi::EnableReceiveTtlForV6(QuicUdpSocketFd fd) {
#if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
int get_ttl = 1;
return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &get_ttl,
sizeof(get_ttl));
#else
(void)fd;
return false;
#endif
}
bool QuicUdpSocketApi::WaitUntilReadable(QuicUdpSocketFd fd,
QuicTime::Delta timeout) {
fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(fd, &read_fds);
timeval select_timeout;
select_timeout.tv_sec = timeout.ToSeconds();
select_timeout.tv_usec = timeout.ToMicroseconds() % 1000000;
return 1 == select(1 + fd, &read_fds, nullptr, nullptr, &select_timeout);
}
void QuicUdpSocketApi::ReadPacket(QuicUdpSocketFd fd,
BitMask64 packet_info_interested,
ReadPacketResult* result) {
result->ok = false;
BufferSpan& packet_buffer = result->packet_buffer;
BufferSpan& control_buffer = result->control_buffer;
QuicUdpPacketInfo* packet_info = &result->packet_info;
QUICHE_DCHECK_GE(control_buffer.buffer_len, kMinCmsgSpaceForRead);
struct iovec iov = {packet_buffer.buffer, packet_buffer.buffer_len};
struct sockaddr_storage raw_peer_address;
if (control_buffer.buffer_len > 0) {
reinterpret_cast<struct cmsghdr*>(control_buffer.buffer)->cmsg_len =
control_buffer.buffer_len;
}
msghdr hdr;
hdr.msg_name = &raw_peer_address;
hdr.msg_namelen = sizeof(raw_peer_address);
hdr.msg_iov = &iov;
hdr.msg_iovlen = 1;
hdr.msg_flags = 0;
hdr.msg_control = control_buffer.buffer;
hdr.msg_controllen = control_buffer.buffer_len;
#if defined(__linux__)
// If MSG_TRUNC is set on Linux, recvmsg will return the real packet size even
// if |packet_buffer| is too small to receive it.
int flags = MSG_TRUNC;
#else
int flags = 0;
#endif
int bytes_read = recvmsg(fd, &hdr, flags);
if (bytes_read < 0) {
const int error_num = errno;
if (error_num != EAGAIN) {
QUIC_LOG_FIRST_N(ERROR, 100)
<< "Error reading packet: " << strerror(error_num);
}
return;
}
if (ABSL_PREDICT_FALSE(hdr.msg_flags & MSG_CTRUNC)) {
QUIC_BUG(quic_bug_10751_3)
<< "Control buffer too small. size:" << control_buffer.buffer_len;
return;
}
if (ABSL_PREDICT_FALSE(hdr.msg_flags & MSG_TRUNC) ||
// Normally "bytes_read > packet_buffer.buffer_len" implies the MSG_TRUNC
// bit is set, but it is not the case if tested with config=android_arm64.
static_cast<size_t>(bytes_read) > packet_buffer.buffer_len) {
QUIC_LOG_FIRST_N(WARNING, 100)
<< "Received truncated QUIC packet: buffer size:"
<< packet_buffer.buffer_len << " packet size:" << bytes_read;
return;
}
packet_buffer.buffer_len = bytes_read;
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
packet_info->SetPeerAddress(QuicSocketAddress(raw_peer_address));
}
if (hdr.msg_controllen > 0) {
for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr;
cmsg = CMSG_NXTHDR(&hdr, cmsg)) {
BitMask64 prior_bitmask = packet_info->bitmask();
PopulatePacketInfoFromControlMessage(cmsg, packet_info,
packet_info_interested);
if (packet_info->bitmask() == prior_bitmask) {
QUIC_DLOG(INFO) << "Ignored cmsg_level:" << cmsg->cmsg_level
<< ", cmsg_type:" << cmsg->cmsg_type;
}
}
}
result->ok = true;
}
size_t QuicUdpSocketApi::ReadMultiplePackets(QuicUdpSocketFd fd,
BitMask64 packet_info_interested,
ReadPacketResults* results) {
#if defined(__linux__) && !defined(__ANDROID__)
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::IS_GRO)) {
size_t num_packets = 0;
for (ReadPacketResult& result : *results) {
result.ok = false;
}
for (ReadPacketResult& result : *results) {
ReadPacket(fd, packet_info_interested, &result);
if (!result.ok) {
break;
}
++num_packets;
}
return num_packets;
} else {
// Use recvmmsg.
size_t hdrs_size = sizeof(mmsghdr) * results->size();
mmsghdr* hdrs = static_cast<mmsghdr*>(alloca(hdrs_size));
memset(hdrs, 0, hdrs_size);
struct TempPerPacketData {
iovec iov;
sockaddr_storage raw_peer_address;
};
TempPerPacketData* packet_data_array = static_cast<TempPerPacketData*>(
alloca(sizeof(TempPerPacketData) * results->size()));
for (size_t i = 0; i < results->size(); ++i) {
(*results)[i].ok = false;
msghdr* hdr = &hdrs[i].msg_hdr;
TempPerPacketData* packet_data = &packet_data_array[i];
packet_data->iov.iov_base = (*results)[i].packet_buffer.buffer;
packet_data->iov.iov_len = (*results)[i].packet_buffer.buffer_len;
hdr->msg_name = &packet_data->raw_peer_address;
hdr->msg_namelen = sizeof(sockaddr_storage);
hdr->msg_iov = &packet_data->iov;
hdr->msg_iovlen = 1;
hdr->msg_flags = 0;
hdr->msg_control = (*results)[i].control_buffer.buffer;
hdr->msg_controllen = (*results)[i].control_buffer.buffer_len;
QUICHE_DCHECK_GE(hdr->msg_controllen, kMinCmsgSpaceForRead);
}
// If MSG_TRUNC is set on Linux, recvmmsg will return the real packet size
// in |hdrs[i].msg_len| even if packet buffer is too small to receive it.
int packets_read = recvmmsg(fd, hdrs, results->size(), MSG_TRUNC, nullptr);
if (packets_read <= 0) {
const int error_num = errno;
if (error_num != EAGAIN) {
QUIC_LOG_FIRST_N(ERROR, 100)
<< "Error reading packets: " << strerror(error_num);
}
return 0;
}
for (int i = 0; i < packets_read; ++i) {
if (hdrs[i].msg_len == 0) {
continue;
}
msghdr& hdr = hdrs[i].msg_hdr;
if (ABSL_PREDICT_FALSE(hdr.msg_flags & MSG_CTRUNC)) {
QUIC_BUG(quic_bug_10751_4) << "Control buffer too small. size:"
<< (*results)[i].control_buffer.buffer_len
<< ", need:" << hdr.msg_controllen;
continue;
}
if (ABSL_PREDICT_FALSE(hdr.msg_flags & MSG_TRUNC)) {
QUIC_LOG_FIRST_N(WARNING, 100)
<< "Received truncated QUIC packet: buffer size:"
<< (*results)[i].packet_buffer.buffer_len
<< " packet size:" << hdrs[i].msg_len;
continue;
}
(*results)[i].ok = true;
(*results)[i].packet_buffer.buffer_len = hdrs[i].msg_len;
QuicUdpPacketInfo* packet_info = &(*results)[i].packet_info;
if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
packet_info->SetPeerAddress(
QuicSocketAddress(packet_data_array[i].raw_peer_address));
}
if (hdr.msg_controllen > 0) {
for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr;
cmsg = CMSG_NXTHDR(&hdr, cmsg)) {
PopulatePacketInfoFromControlMessage(cmsg, packet_info,
packet_info_interested);
}
}
}
return packets_read;
}
#else
size_t num_packets = 0;
for (ReadPacketResult& result : *results) {
result.ok = false;
}
for (ReadPacketResult& result : *results) {
errno = 0;
ReadPacket(fd, packet_info_interested, &result);
if (!result.ok && errno == EAGAIN) {
break;
}
++num_packets;
}
return num_packets;
#endif
}
WriteResult QuicUdpSocketApi::WritePacket(
QuicUdpSocketFd fd, const char* packet_buffer, size_t packet_buffer_len,
const QuicUdpPacketInfo& packet_info) {
if (!packet_info.HasValue(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
return WriteResult(WRITE_STATUS_ERROR, EINVAL);
}
char control_buffer[512];
sockaddr_storage raw_peer_address =
packet_info.peer_address().generic_address();
iovec iov = {const_cast<char*>(packet_buffer), packet_buffer_len};
msghdr hdr;
hdr.msg_name = &raw_peer_address;
hdr.msg_namelen = packet_info.peer_address().host().IsIPv4()
? sizeof(sockaddr_in)
: sizeof(sockaddr_in6);
hdr.msg_iov = &iov;
hdr.msg_iovlen = 1;
hdr.msg_flags = 0;
hdr.msg_control = nullptr;
hdr.msg_controllen = 0;
cmsghdr* cmsg = nullptr;
// Set self IP.
if (packet_info.HasValue(QuicUdpPacketInfoBit::V4_SELF_IP) &&
packet_info.self_v4_ip().IsInitialized()) {
if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), IPPROTO_IP,
IP_PKTINFO, sizeof(in_pktinfo), &cmsg)) {
QUIC_LOG_FIRST_N(ERROR, 100)
<< "Not enough buffer to set self v4 ip address.";
return WriteResult(WRITE_STATUS_ERROR, EINVAL);
}
SetV4SelfIpInControlMessage(packet_info.self_v4_ip(), cmsg);
} else if (packet_info.HasValue(QuicUdpPacketInfoBit::V6_SELF_IP) &&
packet_info.self_v6_ip().IsInitialized()) {
if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), IPPROTO_IPV6,
IPV6_PKTINFO, sizeof(in6_pktinfo), &cmsg)) {
QUIC_LOG_FIRST_N(ERROR, 100)
<< "Not enough buffer to set self v6 ip address.";
return WriteResult(WRITE_STATUS_ERROR, EINVAL);
}
SetV6SelfIpInControlMessage(packet_info.self_v6_ip(), cmsg);
}
#if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
// Set ttl.
if (packet_info.HasValue(QuicUdpPacketInfoBit::TTL)) {
int cmsg_level =
packet_info.peer_address().host().IsIPv4() ? IPPROTO_IP : IPPROTO_IPV6;
int cmsg_type =
packet_info.peer_address().host().IsIPv4() ? IP_TTL : IPV6_HOPLIMIT;
if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), cmsg_level,
cmsg_type, sizeof(int), &cmsg)) {
QUIC_LOG_FIRST_N(ERROR, 100) << "Not enough buffer to set ttl.";
return WriteResult(WRITE_STATUS_ERROR, EINVAL);
}
*reinterpret_cast<int*>(CMSG_DATA(cmsg)) = packet_info.ttl();
}
#endif
int rc;
do {
rc = sendmsg(fd, &hdr, 0);
} while (rc < 0 && errno == EINTR);
if (rc >= 0) {
return WriteResult(WRITE_STATUS_OK, rc);
}
return WriteResult((errno == EAGAIN || errno == EWOULDBLOCK)
? WRITE_STATUS_BLOCKED
: WRITE_STATUS_ERROR,
errno);
}
} // namespace quic