netbird/gvisor
0
0
Fork 0
mirror of https://github.com/netbirdio/gvisor.git synced 2026-05-22 17:12:49 -07:00
Code Issues Packages Projects Releases Wiki Activity

Make AsSockAddr() to replace reinterpret_cast<sockaddr*>

Browse Source 
It's a common pattern in test code to reinterpret_cast<sockaddr*> from
sockaddr_* structs. Make AsSockAddr() for them so code looks better.

Note: Why not a wrapper type for `sockaddr_storage` and etc?
It's also a common need to have a local in-out variable of socklen_t.
Creating a wrapper type may however lead to this wrong code:
  Wrapper addr;
  socklen_t addrlen = sizeof(addr);
where sizeof(Wrapper) may not equal to sizeof(sockaddr_storage).
PiperOrigin-RevId: 368126229
This commit is contained in:
Ting-Yu Wang
2021-04-12 18:35:09 -07:00
committed by gVisor bot
parent 90900e4f8f
commit e5f58e89bb
19 changed files with 973 additions and 1365 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/syscalls/linux/accept_bind.cc
+14 -20
View File
@@ -321,8 +321,7 @@ TEST_P(AllSocketPairTest, AcceptValidAddrLen) {
struct sockaddr_un addr = {};
socklen_t addr_len = sizeof(addr);
ASSERT_THAT(
accepted = accept(sockets->first_fd(),
reinterpret_cast<struct sockaddr*>(&addr), &addr_len),
accepted = accept(sockets->first_fd(), AsSockAddr(&addr), &addr_len),
SyscallSucceeds());
ASSERT_THAT(close(accepted), SyscallSucceeds());
}
@@ -343,8 +342,7 @@ TEST_P(AllSocketPairTest, AcceptNegativeAddrLen) {
// With a negative addr_len, accept returns EINVAL,
struct sockaddr_un addr = {};
socklen_t addr_len = -1;
ASSERT_THAT(accept(sockets->first_fd(),
reinterpret_cast<struct sockaddr*>(&addr), &addr_len),
ASSERT_THAT(accept(sockets->first_fd(), AsSockAddr(&addr), &addr_len),
SyscallFailsWithErrno(EINVAL));
}
@@ -535,10 +533,9 @@ TEST_P(AllSocketPairTest, UnboundSenderAddr) {
struct sockaddr_storage addr;
socklen_t addr_len = sizeof(addr);
ASSERT_THAT(
RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
reinterpret_cast<sockaddr*>(&addr), &addr_len),
SyscallSucceedsWithValue(sizeof(i)));
ASSERT_THAT(RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
AsSockAddr(&addr), &addr_len),
SyscallSucceedsWithValue(sizeof(i)));
EXPECT_EQ(addr_len, 0);
}
@@ -570,10 +567,9 @@ TEST_P(AllSocketPairTest, BoundSenderAddr) {
struct sockaddr_storage addr;
socklen_t addr_len = sizeof(addr);
ASSERT_THAT(
RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
reinterpret_cast<sockaddr*>(&addr), &addr_len),
SyscallSucceedsWithValue(sizeof(i)));
ASSERT_THAT(RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
AsSockAddr(&addr), &addr_len),
SyscallSucceedsWithValue(sizeof(i)));
EXPECT_EQ(addr_len, sockets->second_addr_len());
EXPECT_EQ(
memcmp(&addr, sockets->second_addr(),
@@ -609,10 +605,9 @@ TEST_P(AllSocketPairTest, BindAfterConnectSenderAddr) {
struct sockaddr_storage addr;
socklen_t addr_len = sizeof(addr);
ASSERT_THAT(
RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
reinterpret_cast<sockaddr*>(&addr), &addr_len),
SyscallSucceedsWithValue(sizeof(i)));
ASSERT_THAT(RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
AsSockAddr(&addr), &addr_len),
SyscallSucceedsWithValue(sizeof(i)));
EXPECT_EQ(addr_len, sockets->second_addr_len());
EXPECT_EQ(
memcmp(&addr, sockets->second_addr(),
@@ -648,10 +643,9 @@ TEST_P(AllSocketPairTest, BindAfterAcceptSenderAddr) {
struct sockaddr_storage addr;
socklen_t addr_len = sizeof(addr);
ASSERT_THAT(
RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
reinterpret_cast<sockaddr*>(&addr), &addr_len),
SyscallSucceedsWithValue(sizeof(i)));
ASSERT_THAT(RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
AsSockAddr(&addr), &addr_len),
SyscallSucceedsWithValue(sizeof(i)));
EXPECT_EQ(addr_len, sockets->second_addr_len());
EXPECT_EQ(
memcmp(&addr, sockets->second_addr(),
test/syscalls/linux/proc_net.cc
+4 -6
View File
@@ -263,9 +263,8 @@ TEST(ProcNetSnmp, TcpEstab_NoRandomSave) {
// Get the port bound by the listening socket.
socklen_t addrlen = sizeof(sin);
ASSERT_THAT(
getsockname(s_listen.get(), reinterpret_cast<sockaddr*>(&sin), &addrlen),
SyscallSucceeds());
ASSERT_THAT(getsockname(s_listen.get(), AsSockAddr(&sin), &addrlen),
SyscallSucceeds());
FileDescriptor s_connect =
ASSERT_NO_ERRNO_AND_VALUE(Socket(AF_INET, SOCK_STREAM, 0));
@@ -384,9 +383,8 @@ TEST(ProcNetSnmp, UdpIn_NoRandomSave) {
SyscallSucceeds());
// Get the port bound by the server socket.
socklen_t addrlen = sizeof(sin);
ASSERT_THAT(
getsockname(server.get(), reinterpret_cast<sockaddr*>(&sin), &addrlen),
SyscallSucceeds());
ASSERT_THAT(getsockname(server.get(), AsSockAddr(&sin), &addrlen),
SyscallSucceeds());
FileDescriptor client =
ASSERT_NO_ERRNO_AND_VALUE(Socket(AF_INET, SOCK_DGRAM, 0));
test/syscalls/linux/socket_bind_to_device_distribution.cc
+17 -23
View File
@@ -141,9 +141,8 @@ TEST_P(BindToDeviceDistributionTest, Tcp) {
endpoint.bind_to_device.c_str(),
endpoint.bind_to_device.size() + 1),
SyscallSucceeds());
ASSERT_THAT(
bind(fd, reinterpret_cast<sockaddr*>(&listen_addr), listener.addr_len),
SyscallSucceeds());
ASSERT_THAT(bind(fd, AsSockAddr(&listen_addr), listener.addr_len),
SyscallSucceeds());
ASSERT_THAT(listen(fd, 40), SyscallSucceeds());
// On the first bind we need to determine which port was bound.
@@ -154,8 +153,7 @@ TEST_P(BindToDeviceDistributionTest, Tcp) {
// Get the port bound by the listening socket.
socklen_t addrlen = listener.addr_len;
ASSERT_THAT(
getsockname(listener_fds[0].get(),
reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
getsockname(listener_fds[0].get(), AsSockAddr(&listen_addr), &addrlen),
SyscallSucceeds());
uint16_t const port =
ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -207,10 +205,9 @@ TEST_P(BindToDeviceDistributionTest, Tcp) {
for (int32_t i = 0; i < kConnectAttempts; i++) {
const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(
Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
ASSERT_THAT(
RetryEINTR(connect)(fd.get(), reinterpret_cast<sockaddr*>(&conn_addr),
connector.addr_len),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(fd.get(), AsSockAddr(&conn_addr),
connector.addr_len),
SyscallSucceeds());
EXPECT_THAT(RetryEINTR(send)(fd.get(), &i, sizeof(i), 0),
SyscallSucceedsWithValue(sizeof(i)));
@@ -267,9 +264,8 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
endpoint.bind_to_device.c_str(),
endpoint.bind_to_device.size() + 1),
SyscallSucceeds());
ASSERT_THAT(
bind(fd, reinterpret_cast<sockaddr*>(&listen_addr), listener.addr_len),
SyscallSucceeds());
ASSERT_THAT(bind(fd, AsSockAddr(&listen_addr), listener.addr_len),
SyscallSucceeds());
// On the first bind we need to determine which port was bound.
if (listener_fds.size() > 1) {
@@ -279,8 +275,7 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
// Get the port bound by the listening socket.
socklen_t addrlen = listener.addr_len;
ASSERT_THAT(
getsockname(listener_fds[0].get(),
reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
getsockname(listener_fds[0].get(), AsSockAddr(&listen_addr), &addrlen),
SyscallSucceeds());
uint16_t const port =
ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -302,9 +297,9 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
socklen_t addrlen = sizeof(addr);
int data;
auto ret = RetryEINTR(recvfrom)(
listener_fds[i].get(), &data, sizeof(data), 0,
reinterpret_cast<struct sockaddr*>(&addr), &addrlen);
auto ret =
RetryEINTR(recvfrom)(listener_fds[i].get(), &data, sizeof(data),
0, AsSockAddr(&addr), &addrlen);
if (packets_received < kConnectAttempts) {
ASSERT_THAT(ret, SyscallSucceedsWithValue(sizeof(data)));
@@ -322,10 +317,10 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
// A response is required to synchronize with the main thread,
// otherwise the main thread can send more than can fit into receive
// queues.
EXPECT_THAT(RetryEINTR(sendto)(
listener_fds[i].get(), &data, sizeof(data), 0,
reinterpret_cast<sockaddr*>(&addr), addrlen),
SyscallSucceedsWithValue(sizeof(data)));
EXPECT_THAT(
RetryEINTR(sendto)(listener_fds[i].get(), &data, sizeof(data),
0, AsSockAddr(&addr), addrlen),
SyscallSucceedsWithValue(sizeof(data)));
} while (packets_received < kConnectAttempts);
// Shutdown all sockets to wake up other threads.
@@ -339,8 +334,7 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
FileDescriptor const fd =
ASSERT_NO_ERRNO_AND_VALUE(Socket(connector.family(), SOCK_DGRAM, 0));
EXPECT_THAT(RetryEINTR(sendto)(fd.get(), &i, sizeof(i), 0,
reinterpret_cast<sockaddr*>(&conn_addr),
connector.addr_len),
AsSockAddr(&conn_addr), connector.addr_len),
SyscallSucceedsWithValue(sizeof(i)));
int data;
EXPECT_THAT(RetryEINTR(recv)(fd.get(), &data, sizeof(data), 0),
test/syscalls/linux/socket_inet_loopback.cc
+266 -384
View File
File diff suppressed because it is too large Load Diff
test/syscalls/linux/socket_inet_loopback_nogotsan.cc
+7 -11
View File
@@ -98,15 +98,14 @@ TEST_P(SocketInetLoopbackTest, DISABLED_TestTCPPortExhaustion_NoRandomSave) {
auto listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
sockaddr_storage listen_addr = listener.addr;
ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
listener.addr_len),
SyscallSucceeds());
ASSERT_THAT(
bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
SyscallSucceeds());
ASSERT_THAT(listen(listen_fd.get(), kBacklog), SyscallSucceeds());
// Get the port bound by the listening socket.
socklen_t addrlen = listener.addr_len;
ASSERT_THAT(getsockname(listen_fd.get(),
reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
SyscallSucceeds());
uint16_t const port =
ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -124,8 +123,7 @@ TEST_P(SocketInetLoopbackTest, DISABLED_TestTCPPortExhaustion_NoRandomSave) {
for (int i = 0; i < kClients; i++) {
FileDescriptor client = ASSERT_NO_ERRNO_AND_VALUE(
Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
int ret = connect(client.get(), reinterpret_cast<sockaddr*>(&conn_addr),
connector.addr_len);
int ret = connect(client.get(), AsSockAddr(&conn_addr), connector.addr_len);
if (ret == 0) {
clients.push_back(std::move(client));
FileDescriptor server =
@@ -205,8 +203,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
&kSockOptOn, sizeof(kSockOptOn)),
SyscallSucceeds());
int ret = bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
test_addr.addr_len);
int ret = bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len);
if (ret != 0) {
ASSERT_EQ(errno, EADDRINUSE);
break;
@@ -214,8 +211,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
// Get the port that we bound.
socklen_t bound_addr_len = test_addr.addr_len;
ASSERT_THAT(
getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
&bound_addr_len),
getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
SyscallSucceeds());
uint16_t port = reinterpret_cast<sockaddr_in*>(&bound_addr)->sin_port;
test/syscalls/linux/socket_ip_unbound_netlink.cc
+2 -4
View File
@@ -57,8 +57,7 @@ TEST_P(IPv6UnboundSocketTest, ConnectToBadLocalAddress_NoRandomSave) {
TestAddress addr = V6Loopback();
reinterpret_cast<sockaddr_in6*>(&addr.addr)->sin6_port = 65535;
auto sock = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
EXPECT_THAT(connect(sock->get(), reinterpret_cast<sockaddr*>(&addr.addr),
addr.addr_len),
EXPECT_THAT(connect(sock->get(), AsSockAddr(&addr.addr), addr.addr_len),
SyscallFailsWithErrno(EADDRNOTAVAIL));
}
@@ -90,8 +89,7 @@ TEST_P(IPv4UnboundSocketTest, ConnectToBadLocalAddress_NoRandomSave) {
TestAddress addr = V4Loopback();
reinterpret_cast<sockaddr_in*>(&addr.addr)->sin_port = 65535;
auto sock = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
EXPECT_THAT(connect(sock->get(), reinterpret_cast<sockaddr*>(&addr.addr),
addr.addr_len),
EXPECT_THAT(connect(sock->get(), AsSockAddr(&addr.addr), addr.addr_len),
SyscallFailsWithErrno(ENETUNREACH));
}
test/syscalls/linux/socket_ipv4_udp_unbound.cc
+248 -360
View File
File diff suppressed because it is too large Load Diff
test/syscalls/linux/socket_ipv4_udp_unbound_external_networking.cc
+144 -180
View File
File diff suppressed because it is too large Load Diff
test/syscalls/linux/socket_ipv4_udp_unbound_loopback_nogotsan.cc
+4 -8
View File
@@ -35,12 +35,10 @@ TEST_P(IPv4UDPUnboundSocketNogotsanTest,
constexpr int kClients = 65536;
// Bind the first socket to the loopback and take note of the selected port.
auto addr = V4Loopback();
ASSERT_THAT(bind(receiver1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
addr.addr_len),
ASSERT_THAT(bind(receiver1->get(), AsSockAddr(&addr.addr), addr.addr_len),
SyscallSucceeds());
socklen_t addr_len = addr.addr_len;
ASSERT_THAT(getsockname(receiver1->get(),
reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
ASSERT_THAT(getsockname(receiver1->get(), AsSockAddr(&addr.addr), &addr_len),
SyscallSucceeds());
EXPECT_EQ(addr_len, addr.addr_len);
@@ -50,8 +48,7 @@ TEST_P(IPv4UDPUnboundSocketNogotsanTest,
for (int i = 0; i < kClients; i++) {
auto s = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
int ret = connect(s->get(), reinterpret_cast<sockaddr*>(&addr.addr),
addr.addr_len);
int ret = connect(s->get(), AsSockAddr(&addr.addr), addr.addr_len);
if (ret == 0) {
sockets.push_back(std::move(s));
continue;
@@ -73,8 +70,7 @@ TEST_P(IPv4UDPUnboundSocketNogotsanTest, UDPBindPortExhaustion_NoRandomSave) {
for (int i = 0; i < kClients; i++) {
auto s = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
int ret =
bind(s->get(), reinterpret_cast<sockaddr*>(&addr.addr), addr.addr_len);
int ret = bind(s->get(), AsSockAddr(&addr.addr), addr.addr_len);
if (ret == 0) {
sockets.push_back(std::move(s));
continue;
test/syscalls/linux/socket_ipv4_udp_unbound_netlink.cc
+19 -26
View File
@@ -56,10 +56,9 @@ TEST_P(IPv4UDPUnboundSocketNetlinkTest, JoinSubnet) {
ASSERT_EQ(1, inet_pton(AF_INET, "192.0.2.2",
&(reinterpret_cast<sockaddr_in*>(&sender_addr.addr)
->sin_addr.s_addr)));
ASSERT_THAT(
bind(snd_sock->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
sender_addr.addr_len),
SyscallSucceeds());
ASSERT_THAT(bind(snd_sock->get(), AsSockAddr(&sender_addr.addr),
sender_addr.addr_len),
SyscallSucceeds());
// Send the packet to an unassigned address but an address that is in the
// subnet associated with the loopback interface.
@@ -69,23 +68,20 @@ TEST_P(IPv4UDPUnboundSocketNetlinkTest, JoinSubnet) {
ASSERT_EQ(1, inet_pton(AF_INET, "192.0.2.254",
&(reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)
->sin_addr.s_addr)));
ASSERT_THAT(
bind(rcv_sock->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceeds());
ASSERT_THAT(bind(rcv_sock->get(), AsSockAddr(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceeds());
socklen_t receiver_addr_len = receiver_addr.addr_len;
ASSERT_THAT(getsockname(rcv_sock->get(),
reinterpret_cast<sockaddr*>(&receiver_addr.addr),
ASSERT_THAT(getsockname(rcv_sock->get(), AsSockAddr(&receiver_addr.addr),
&receiver_addr_len),
SyscallSucceeds());
ASSERT_EQ(receiver_addr_len, receiver_addr.addr_len);
char send_buf[kSendBufSize];
RandomizeBuffer(send_buf, kSendBufSize);
ASSERT_THAT(
RetryEINTR(sendto)(snd_sock->get(), send_buf, kSendBufSize, 0,
reinterpret_cast<sockaddr*>(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceedsWithValue(kSendBufSize));
ASSERT_THAT(RetryEINTR(sendto)(snd_sock->get(), send_buf, kSendBufSize, 0,
AsSockAddr(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceedsWithValue(kSendBufSize));
// Check that we received the packet.
char recv_buf[kSendBufSize] = {};
@@ -155,14 +151,12 @@ TEST_P(IPv4UDPUnboundSocketNetlinkTest, ReuseAddrSubnetDirectedBroadcast) {
<< "socks[" << idx << "]";
if (bind_wildcard) {
ASSERT_THAT(
bind(sock->get(), reinterpret_cast<sockaddr*>(&any_address.addr),
any_address.addr_len),
SyscallSucceeds())
ASSERT_THAT(bind(sock->get(), AsSockAddr(&any_address.addr),
any_address.addr_len),
SyscallSucceeds())
<< "socks[" << idx << "]";
} else {
ASSERT_THAT(bind(sock->get(),
reinterpret_cast<sockaddr*>(&broadcast_address.addr),
ASSERT_THAT(bind(sock->get(), AsSockAddr(&broadcast_address.addr),
broadcast_address.addr_len),
SyscallSucceeds())
<< "socks[" << idx << "]";
@@ -179,11 +173,10 @@ TEST_P(IPv4UDPUnboundSocketNetlinkTest, ReuseAddrSubnetDirectedBroadcast) {
// the sending socket).
for (long unsigned int w = 0; w < socks.size(); w++) {
auto& w_sock = socks[w];
ASSERT_THAT(
RetryEINTR(sendto)(w_sock->get(), send_buf, kSendBufSize, 0,
reinterpret_cast<sockaddr*>(&broadcast_address.addr),
broadcast_address.addr_len),
SyscallSucceedsWithValue(kSendBufSize))
ASSERT_THAT(RetryEINTR(sendto)(w_sock->get(), send_buf, kSendBufSize, 0,
AsSockAddr(&broadcast_address.addr),
broadcast_address.addr_len),
SyscallSucceedsWithValue(kSendBufSize))
<< "write socks[" << w << "]";
// Check that we received the packet on all sockets.
test/syscalls/linux/socket_ipv6_udp_unbound.cc
+8 -12
View File
@@ -47,29 +47,25 @@ TEST_P(IPv6UDPUnboundSocketTest, SetAndReceiveIPReceiveOrigDstAddr) {
int level = SOL_IPV6;
int type = IPV6_RECVORIGDSTADDR;
ASSERT_THAT(
bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceeds());
ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceeds());
// Retrieve the port bound by the receiver.
socklen_t receiver_addr_len = receiver_addr.addr_len;
ASSERT_THAT(getsockname(receiver->get(),
reinterpret_cast<sockaddr*>(&receiver_addr.addr),
ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
&receiver_addr_len),
SyscallSucceeds());
EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
ASSERT_THAT(
connect(sender->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceeds());
ASSERT_THAT(connect(sender->get(), AsSockAddr(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceeds());
// Get address and port bound by the sender.
sockaddr_storage sender_addr_storage;
socklen_t sender_addr_len = sizeof(sender_addr_storage);
ASSERT_THAT(getsockname(sender->get(),
reinterpret_cast<sockaddr*>(&sender_addr_storage),
ASSERT_THAT(getsockname(sender->get(), AsSockAddr(&sender_addr_storage),
&sender_addr_len),
SyscallSucceeds());
ASSERT_EQ(sender_addr_len, sizeof(struct sockaddr_in6));
test/syscalls/linux/socket_ipv6_udp_unbound_external_networking.cc
+13 -16
View File
@@ -24,13 +24,11 @@ TEST_P(IPv6UDPUnboundExternalNetworkingSocketTest, TestJoinLeaveMulticast) {
auto receiver = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
auto receiver_addr = V6Any();
ASSERT_THAT(
bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceeds());
ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
receiver_addr.addr_len),
SyscallSucceeds());
socklen_t receiver_addr_len = receiver_addr.addr_len;
ASSERT_THAT(getsockname(receiver->get(),
reinterpret_cast<sockaddr*>(&receiver_addr.addr),
ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
&receiver_addr_len),
SyscallSucceeds());
EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -50,8 +48,7 @@ TEST_P(IPv6UDPUnboundExternalNetworkingSocketTest, TestJoinLeaveMulticast) {
// Set the sender to the loopback interface.
auto sender_addr = V6Loopback();
ASSERT_THAT(
bind(sender->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
sender_addr.addr_len),
bind(sender->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
SyscallSucceeds());
// Send a multicast packet.
@@ -60,10 +57,10 @@ TEST_P(IPv6UDPUnboundExternalNetworkingSocketTest, TestJoinLeaveMulticast) {
reinterpret_cast<sockaddr_in6*>(&receiver_addr.addr)->sin6_port;
char send_buf[200];
RandomizeBuffer(send_buf, sizeof(send_buf));
ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
reinterpret_cast<sockaddr*>(&send_addr.addr),
send_addr.addr_len),
SyscallSucceedsWithValue(sizeof(send_buf)));
ASSERT_THAT(
RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
AsSockAddr(&send_addr.addr), send_addr.addr_len),
SyscallSucceedsWithValue(sizeof(send_buf)));
// Check that we received the multicast packet.
char recv_buf[sizeof(send_buf)] = {};
@@ -77,10 +74,10 @@ TEST_P(IPv6UDPUnboundExternalNetworkingSocketTest, TestJoinLeaveMulticast) {
&group_req, sizeof(group_req)),
SyscallSucceeds());
RandomizeBuffer(send_buf, sizeof(send_buf));
ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
reinterpret_cast<sockaddr*>(&send_addr.addr),
send_addr.addr_len),
SyscallSucceedsWithValue(sizeof(send_buf)));
ASSERT_THAT(
RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
AsSockAddr(&send_addr.addr), send_addr.addr_len),
SyscallSucceedsWithValue(sizeof(send_buf)));
ASSERT_THAT(RetryEINTR(recv)(receiver->get(), recv_buf, sizeof(recv_buf),
MSG_DONTWAIT),
SyscallFailsWithErrno(EAGAIN));
test/syscalls/linux/socket_ipv6_udp_unbound_netlink.cc
+3 -3
View File
@@ -44,9 +44,9 @@ TEST_P(IPv6UDPUnboundSocketNetlinkTest, JoinSubnet) {
reinterpret_cast<sockaddr_in6*>(&sender_addr.addr)
->sin6_addr.s6_addr));
auto sock = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
EXPECT_THAT(bind(sock->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
sender_addr.addr_len),
SyscallFailsWithErrno(EADDRNOTAVAIL));
EXPECT_THAT(
bind(sock->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
SyscallFailsWithErrno(EADDRNOTAVAIL));
}
} // namespace testing
test/syscalls/linux/socket_test_util.cc
+20 -26
View File
@@ -82,8 +82,7 @@ Creator<SocketPair> AcceptBindSocketPairCreator(bool abstract, int domain,
RETURN_ERROR_IF_SYSCALL_FAIL(bound = socket(domain, type, protocol));
MaybeSave(); // Successful socket creation.
RETURN_ERROR_IF_SYSCALL_FAIL(
bind(bound, reinterpret_cast<struct sockaddr*>(&bind_addr),
sizeof(bind_addr)));
bind(bound, AsSockAddr(&bind_addr), sizeof(bind_addr)));
MaybeSave(); // Successful bind.
RETURN_ERROR_IF_SYSCALL_FAIL(listen(bound, /* backlog = */ 5));
MaybeSave(); // Successful listen.
@@ -92,8 +91,7 @@ Creator<SocketPair> AcceptBindSocketPairCreator(bool abstract, int domain,
RETURN_ERROR_IF_SYSCALL_FAIL(connected = socket(domain, type, protocol));
MaybeSave(); // Successful socket creation.
RETURN_ERROR_IF_SYSCALL_FAIL(
connect(connected, reinterpret_cast<struct sockaddr*>(&bind_addr),
sizeof(bind_addr)));
connect(connected, AsSockAddr(&bind_addr), sizeof(bind_addr)));
MaybeSave(); // Successful connect.
int accepted;
@@ -145,22 +143,22 @@ Creator<SocketPair> BidirectionalBindSocketPairCreator(bool abstract,
RETURN_ERROR_IF_SYSCALL_FAIL(sock1 = socket(domain, type, protocol));
MaybeSave(); // Successful socket creation.
RETURN_ERROR_IF_SYSCALL_FAIL(
bind(sock1, reinterpret_cast<struct sockaddr*>(&addr1), sizeof(addr1)));
bind(sock1, AsSockAddr(&addr1), sizeof(addr1)));
MaybeSave(); // Successful bind.
int sock2;
RETURN_ERROR_IF_SYSCALL_FAIL(sock2 = socket(domain, type, protocol));
MaybeSave(); // Successful socket creation.
RETURN_ERROR_IF_SYSCALL_FAIL(
bind(sock2, reinterpret_cast<struct sockaddr*>(&addr2), sizeof(addr2)));
bind(sock2, AsSockAddr(&addr2), sizeof(addr2)));
MaybeSave(); // Successful bind.
RETURN_ERROR_IF_SYSCALL_FAIL(connect(
sock1, reinterpret_cast<struct sockaddr*>(&addr2), sizeof(addr2)));
RETURN_ERROR_IF_SYSCALL_FAIL(
connect(sock1, AsSockAddr(&addr2), sizeof(addr2)));
MaybeSave(); // Successful connect.
RETURN_ERROR_IF_SYSCALL_FAIL(connect(
sock2, reinterpret_cast<struct sockaddr*>(&addr1), sizeof(addr1)));
RETURN_ERROR_IF_SYSCALL_FAIL(
connect(sock2, AsSockAddr(&addr1), sizeof(addr1)));
MaybeSave(); // Successful connect.
// Cleanup no longer needed resources.
@@ -206,15 +204,15 @@ Creator<SocketPair> SocketpairGoferSocketPairCreator(int domain, int type,
int sock1;
RETURN_ERROR_IF_SYSCALL_FAIL(sock1 = socket(domain, type, protocol));
MaybeSave(); // Successful socket creation.
RETURN_ERROR_IF_SYSCALL_FAIL(connect(
sock1, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)));
RETURN_ERROR_IF_SYSCALL_FAIL(
connect(sock1, AsSockAddr(&addr), sizeof(addr)));
MaybeSave(); // Successful connect.
int sock2;
RETURN_ERROR_IF_SYSCALL_FAIL(sock2 = socket(domain, type, protocol));
MaybeSave(); // Successful socket creation.
RETURN_ERROR_IF_SYSCALL_FAIL(connect(
sock2, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)));
RETURN_ERROR_IF_SYSCALL_FAIL(
connect(sock2, AsSockAddr(&addr), sizeof(addr)));
MaybeSave(); // Successful connect.
// Make and close another socketpair to ensure that the duped ends of the
@@ -228,8 +226,8 @@ Creator<SocketPair> SocketpairGoferSocketPairCreator(int domain, int type,
for (int i = 0; i < 2; i++) {
int sock;
RETURN_ERROR_IF_SYSCALL_FAIL(sock = socket(domain, type, protocol));
RETURN_ERROR_IF_SYSCALL_FAIL(connect(
sock, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)));
RETURN_ERROR_IF_SYSCALL_FAIL(
connect(sock, AsSockAddr(&addr), sizeof(addr)));
RETURN_ERROR_IF_SYSCALL_FAIL(close(sock));
}
@@ -308,11 +306,9 @@ template <typename T>
PosixErrorOr<T> BindIP(int fd, bool dual_stack) {
T addr = {};
LocalhostAddr(&addr, dual_stack);
RETURN_ERROR_IF_SYSCALL_FAIL(
bind(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)));
RETURN_ERROR_IF_SYSCALL_FAIL(bind(fd, AsSockAddr(&addr), sizeof(addr)));
socklen_t addrlen = sizeof(addr);
RETURN_ERROR_IF_SYSCALL_FAIL(
getsockname(fd, reinterpret_cast<struct sockaddr*>(&addr), &addrlen));
RETURN_ERROR_IF_SYSCALL_FAIL(getsockname(fd, AsSockAddr(&addr), &addrlen));
return addr;
}
@@ -329,9 +325,8 @@ CreateTCPConnectAcceptSocketPair(int bound, int connected, int type,
bool dual_stack, T bind_addr) {
int connect_result = 0;
RETURN_ERROR_IF_SYSCALL_FAIL(
(connect_result = RetryEINTR(connect)(
connected, reinterpret_cast<struct sockaddr*>(&bind_addr),
sizeof(bind_addr))) == -1 &&
(connect_result = RetryEINTR(connect)(connected, AsSockAddr(&bind_addr),
sizeof(bind_addr))) == -1 &&
errno == EINPROGRESS
? 0
: connect_result);
@@ -703,7 +698,7 @@ PosixErrorOr<int> TryPortAvailable(int port, AddressFamily family,
}
RETURN_ERROR_IF_SYSCALL_FAIL(
bind(fd.get(), reinterpret_cast<sockaddr*>(&storage), storage_size));
bind(fd.get(), AsSockAddr(&storage), storage_size));
// If the user specified 0 as the port, we will return the port that the
// kernel gave us, otherwise we will validate that this socket bound to the
@@ -711,8 +706,7 @@ PosixErrorOr<int> TryPortAvailable(int port, AddressFamily family,
sockaddr_storage bound_storage = {};
socklen_t bound_storage_size = sizeof(bound_storage);
RETURN_ERROR_IF_SYSCALL_FAIL(
getsockname(fd.get(), reinterpret_cast<sockaddr*>(&bound_storage),
&bound_storage_size));
getsockname(fd.get(), AsSockAddr(&bound_storage), &bound_storage_size));
int available_port = -1;
if (bound_storage.ss_family == AF_INET) {
test/syscalls/linux/socket_test_util.h
+14
View File
@@ -520,6 +520,20 @@ uint16_t UDPChecksum(struct iphdr iphdr, struct udphdr udphdr,
uint16_t ICMPChecksum(struct icmphdr icmphdr, const char* payload,
ssize_t payload_len);
// Convenient functions for reinterpreting common types to sockaddr pointer.
inline sockaddr* AsSockAddr(sockaddr_storage* s) {
return reinterpret_cast<sockaddr*>(s);
}
inline sockaddr* AsSockAddr(sockaddr_in* s) {
return reinterpret_cast<sockaddr*>(s);
}
inline sockaddr* AsSockAddr(sockaddr_in6* s) {
return reinterpret_cast<sockaddr*>(s);
}
inline sockaddr* AsSockAddr(sockaddr_un* s) {
return reinterpret_cast<sockaddr*>(s);
}
namespace internal {
PosixErrorOr<int> TryPortAvailable(int port, AddressFamily family,
SocketType type, bool reuse_addr);
test/syscalls/linux/tcp_socket.cc
+67 -117
View File
@@ -139,20 +139,16 @@ void TcpSocketTest::SetUp() {
socklen_t addrlen = sizeof(addr);
// Bind to some port then start listening.
ASSERT_THAT(
bind(listener_, reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(bind(listener_, AsSockAddr(&addr), addrlen), SyscallSucceeds());
ASSERT_THAT(listen(listener_, SOMAXCONN), SyscallSucceeds());
// Get the address we're listening on, then connect to it. We need to do this
// because we're allowing the stack to pick a port for us.
ASSERT_THAT(getsockname(listener_, reinterpret_cast<struct sockaddr*>(&addr),
&addrlen),
ASSERT_THAT(getsockname(listener_, AsSockAddr(&addr), &addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(
first_fd, reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(first_fd, AsSockAddr(&addr), addrlen),
SyscallSucceeds());
// Get the initial send buffer size.
@@ -229,10 +225,9 @@ TEST_P(TcpSocketTest, SenderAddressIgnored) {
socklen_t addrlen = sizeof(addr);
memset(&addr, 0, sizeof(addr));
ASSERT_THAT(
RetryEINTR(recvfrom)(second_fd, buf, sizeof(buf), 0,
reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
SyscallSucceedsWithValue(3));
ASSERT_THAT(RetryEINTR(recvfrom)(second_fd, buf, sizeof(buf), 0,
AsSockAddr(&addr), &addrlen),
SyscallSucceedsWithValue(3));
// Check that addr remains zeroed-out.
const char* ptr = reinterpret_cast<char*>(&addr);
@@ -250,10 +245,9 @@ TEST_P(TcpSocketTest, SenderAddressIgnoredOnPeek) {
socklen_t addrlen = sizeof(addr);
memset(&addr, 0, sizeof(addr));
ASSERT_THAT(
RetryEINTR(recvfrom)(second_fd, buf, sizeof(buf), MSG_PEEK,
reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
SyscallSucceedsWithValue(3));
ASSERT_THAT(RetryEINTR(recvfrom)(second_fd, buf, sizeof(buf), MSG_PEEK,
AsSockAddr(&addr), &addrlen),
SyscallSucceedsWithValue(3));
// Check that addr remains zeroed-out.
const char* ptr = reinterpret_cast<char*>(&addr);
@@ -268,10 +262,9 @@ TEST_P(TcpSocketTest, SendtoAddressIgnored) {
addr.ss_family = GetParam(); // FIXME(b/63803955)
char data = '\0';
EXPECT_THAT(
RetryEINTR(sendto)(first_fd, &data, sizeof(data), 0,
reinterpret_cast<sockaddr*>(&addr), sizeof(addr)),
SyscallSucceedsWithValue(1));
EXPECT_THAT(RetryEINTR(sendto)(first_fd, &data, sizeof(data), 0,
AsSockAddr(&addr), sizeof(addr)),
SyscallSucceedsWithValue(1));
}
TEST_P(TcpSocketTest, WritevZeroIovec) {
@@ -869,10 +862,9 @@ TEST_P(SimpleTcpSocketTest, SendtoWithAddressUnconnected) {
sockaddr_storage addr =
ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
char data = '\0';
EXPECT_THAT(
RetryEINTR(sendto)(fd, &data, sizeof(data), 0,
reinterpret_cast<sockaddr*>(&addr), sizeof(addr)),
SyscallFailsWithErrno(EPIPE));
EXPECT_THAT(RetryEINTR(sendto)(fd, &data, sizeof(data), 0, AsSockAddr(&addr),
sizeof(addr)),
SyscallFailsWithErrno(EPIPE));
}
TEST_P(SimpleTcpSocketTest, GetPeerNameUnconnected) {
@@ -883,7 +875,7 @@ TEST_P(SimpleTcpSocketTest, GetPeerNameUnconnected) {
sockaddr_storage addr;
socklen_t addrlen = sizeof(addr);
EXPECT_THAT(getpeername(fd, reinterpret_cast<sockaddr*>(&addr), &addrlen),
EXPECT_THAT(getpeername(fd, AsSockAddr(&addr), &addrlen),
SyscallFailsWithErrno(ENOTCONN));
}
@@ -974,24 +966,20 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRetry) {
socklen_t addrlen = sizeof(addr);
// Bind to some port but don't listen yet.
ASSERT_THAT(
bind(listener.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(bind(listener.get(), AsSockAddr(&addr), addrlen),
SyscallSucceeds());
// Get the address we're bound to, then connect to it. We need to do this
// because we're allowing the stack to pick a port for us.
ASSERT_THAT(getsockname(listener.get(),
reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
ASSERT_THAT(getsockname(listener.get(), AsSockAddr(&addr), &addrlen),
SyscallSucceeds());
FileDescriptor connector =
ASSERT_NO_ERRNO_AND_VALUE(Socket(GetParam(), SOCK_STREAM, IPPROTO_TCP));
// Verify that connect fails.
ASSERT_THAT(
RetryEINTR(connect)(connector.get(),
reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallFailsWithErrno(ECONNREFUSED));
ASSERT_THAT(RetryEINTR(connect)(connector.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(ECONNREFUSED));
// Now start listening
ASSERT_THAT(listen(listener.get(), SOMAXCONN), SyscallSucceeds());
@@ -1000,17 +988,14 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRetry) {
// failed first connect should succeed.
if (IsRunningOnGvisor()) {
ASSERT_THAT(
RetryEINTR(connect)(connector.get(),
reinterpret_cast<struct sockaddr*>(&addr), addrlen),
RetryEINTR(connect)(connector.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(ECONNABORTED));
return;
}
// Verify that connect now succeeds.
ASSERT_THAT(
RetryEINTR(connect)(connector.get(),
reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(connector.get(), AsSockAddr(&addr), addrlen),
SyscallSucceeds());
// Accept the connection.
const FileDescriptor accepted =
@@ -1030,13 +1015,11 @@ PosixErrorOr<FileDescriptor> nonBlockingConnectNoListener(const int family,
int b_sock;
RETURN_ERROR_IF_SYSCALL_FAIL(b_sock = socket(family, sock_type, IPPROTO_TCP));
FileDescriptor b(b_sock);
EXPECT_THAT(bind(b.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
EXPECT_THAT(bind(b.get(), AsSockAddr(&addr), addrlen), SyscallSucceeds());
// Get the address bound by the listening socket.
EXPECT_THAT(
getsockname(b.get(), reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
SyscallSucceeds());
EXPECT_THAT(getsockname(b.get(), AsSockAddr(&addr), &addrlen),
SyscallSucceeds());
// Now create another socket and issue a connect on this one. This connect
// should fail as there is no listener.
@@ -1046,8 +1029,7 @@ PosixErrorOr<FileDescriptor> nonBlockingConnectNoListener(const int family,
// Now connect to the bound address and this should fail as nothing
// is listening on the bound address.
EXPECT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
EXPECT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(EINPROGRESS));
// Wait for the connect to fail.
@@ -1078,8 +1060,7 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectNoListener) {
opts &= ~O_NONBLOCK;
EXPECT_THAT(fcntl(s.get(), F_SETFL, opts), SyscallSucceeds());
// Try connecting again.
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(ECONNABORTED));
}
@@ -1094,8 +1075,7 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectNoListenerRead) {
unsigned char c;
ASSERT_THAT(read(s.get(), &c, 1), SyscallFailsWithErrno(ECONNREFUSED));
ASSERT_THAT(read(s.get(), &c, 1), SyscallSucceedsWithValue(0));
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(ECONNABORTED));
}
@@ -1111,8 +1091,7 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectNoListenerPeek) {
ASSERT_THAT(recv(s.get(), &c, 1, MSG_PEEK),
SyscallFailsWithErrno(ECONNREFUSED));
ASSERT_THAT(recv(s.get(), &c, 1, MSG_PEEK), SyscallSucceedsWithValue(0));
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(ECONNABORTED));
}
@@ -1125,15 +1104,11 @@ TEST_P(SimpleTcpSocketTest, SelfConnectSendRecv_NoRandomSave) {
const FileDescriptor s =
ASSERT_NO_ERRNO_AND_VALUE(Socket(GetParam(), SOCK_STREAM, IPPROTO_TCP));
ASSERT_THAT(
(bind)(s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT((bind)(s.get(), AsSockAddr(&addr), addrlen), SyscallSucceeds());
// Get the bound port.
ASSERT_THAT(
getsockname(s.get(), reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(getsockname(s.get(), AsSockAddr(&addr), &addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallSucceeds());
constexpr int kBufSz = 1 << 20; // 1 MiB
@@ -1182,14 +1157,11 @@ TEST_P(SimpleTcpSocketTest, SelfConnectSend_NoRandomSave) {
setsockopt(s.get(), SOL_TCP, TCP_MAXSEG, &max_seg, sizeof(max_seg)),
SyscallSucceeds());
ASSERT_THAT(bind(s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(bind(s.get(), AsSockAddr(&addr), addrlen), SyscallSucceeds());
// Get the bound port.
ASSERT_THAT(
getsockname(s.get(), reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(getsockname(s.get(), AsSockAddr(&addr), &addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallSucceeds());
std::vector<char> writebuf(512 << 10); // 512 KiB.
@@ -1213,9 +1185,8 @@ void NonBlockingConnect(int family, int16_t pollMask) {
socklen_t addrlen = sizeof(addr);
// Bind to some port then start listening.
ASSERT_THAT(
bind(listener.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(bind(listener.get(), AsSockAddr(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(listen(listener.get(), SOMAXCONN), SyscallSucceeds());
@@ -1228,12 +1199,10 @@ void NonBlockingConnect(int family, int16_t pollMask) {
opts |= O_NONBLOCK;
ASSERT_THAT(fcntl(s.get(), F_SETFL, opts), SyscallSucceeds());
ASSERT_THAT(getsockname(listener.get(),
reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
ASSERT_THAT(getsockname(listener.get(), AsSockAddr(&addr), &addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(EINPROGRESS));
int t;
@@ -1276,21 +1245,18 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRemoteClose) {
socklen_t addrlen = sizeof(addr);
// Bind to some port then start listening.
ASSERT_THAT(
bind(listener.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(bind(listener.get(), AsSockAddr(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(listen(listener.get(), SOMAXCONN), SyscallSucceeds());
FileDescriptor s = ASSERT_NO_ERRNO_AND_VALUE(
Socket(GetParam(), SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP));
ASSERT_THAT(getsockname(listener.get(),
reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
ASSERT_THAT(getsockname(listener.get(), AsSockAddr(&addr), &addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(EINPROGRESS));
int t;
@@ -1305,12 +1271,10 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRemoteClose) {
EXPECT_THAT(RetryEINTR(poll)(&poll_fd, 1, 10000),
SyscallSucceedsWithValue(1));
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(EISCONN));
}
@@ -1325,8 +1289,7 @@ TEST_P(SimpleTcpSocketTest, BlockingConnectRefused) {
ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
socklen_t addrlen = sizeof(addr);
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(ECONNREFUSED));
// Avoiding triggering save in destructor of s.
@@ -1346,17 +1309,14 @@ TEST_P(SimpleTcpSocketTest, CleanupOnConnectionRefused) {
ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
socklen_t bound_addrlen = sizeof(bound_addr);
ASSERT_THAT(
bind(bound_s.get(), reinterpret_cast<struct sockaddr*>(&bound_addr),
bound_addrlen),
SyscallSucceeds());
ASSERT_THAT(bind(bound_s.get(), AsSockAddr(&bound_addr), bound_addrlen),
SyscallSucceeds());
// Get the addresses the socket is bound to because the port is chosen by the
// stack.
ASSERT_THAT(getsockname(bound_s.get(),
reinterpret_cast<struct sockaddr*>(&bound_addr),
&bound_addrlen),
SyscallSucceeds());
ASSERT_THAT(
getsockname(bound_s.get(), AsSockAddr(&bound_addr), &bound_addrlen),
SyscallSucceeds());
// Create, initialize, and bind the socket that is used to test connecting to
// the non-listening port.
@@ -1367,16 +1327,13 @@ TEST_P(SimpleTcpSocketTest, CleanupOnConnectionRefused) {
ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
socklen_t client_addrlen = sizeof(client_addr);
ASSERT_THAT(
bind(client_s.get(), reinterpret_cast<struct sockaddr*>(&client_addr),
client_addrlen),
SyscallSucceeds());
ASSERT_THAT(getsockname(client_s.get(),
reinterpret_cast<struct sockaddr*>(&client_addr),
&client_addrlen),
ASSERT_THAT(bind(client_s.get(), AsSockAddr(&client_addr), client_addrlen),
SyscallSucceeds());
ASSERT_THAT(
getsockname(client_s.get(), AsSockAddr(&client_addr), &client_addrlen),
SyscallSucceeds());
// Now the test: connect to the bound but not listening socket with the
// client socket. The bound socket should return a RST and cause the client
// socket to return an error and clean itself up immediately.
@@ -1392,10 +1349,8 @@ TEST_P(SimpleTcpSocketTest, CleanupOnConnectionRefused) {
// Test binding to the address from the client socket. This should be okay
// if it was dropped correctly.
ASSERT_THAT(
bind(new_s.get(), reinterpret_cast<struct sockaddr*>(&client_addr),
client_addrlen),
SyscallSucceeds());
ASSERT_THAT(bind(new_s.get(), AsSockAddr(&client_addr), client_addrlen),
SyscallSucceeds());
// Attempt #2, with the new socket and reused addr our connect should fail in
// the same way as before, not with an EADDRINUSE.
@@ -1428,8 +1383,7 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRefused) {
ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
socklen_t addrlen = sizeof(addr);
ASSERT_THAT(RetryEINTR(connect)(
s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(EINPROGRESS));
// We don't need to specify any events to get POLLHUP or POLLERR as these
@@ -1720,8 +1674,7 @@ TEST_P(SimpleTcpSocketTest, TCPConnectSoRcvBufRace) {
ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
socklen_t addrlen = sizeof(addr);
RetryEINTR(connect)(s.get(), reinterpret_cast<struct sockaddr*>(&addr),
addrlen);
RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen);
int buf_sz = 1 << 18;
EXPECT_THAT(
setsockopt(s.get(), SOL_SOCKET, SO_RCVBUF, &buf_sz, sizeof(buf_sz)),
@@ -2034,8 +1987,7 @@ TEST_P(SimpleTcpSocketTest, GetSocketAcceptConnWithShutdown) {
socklen_t addrlen = sizeof(addr);
// Bind to some port then start listening.
ASSERT_THAT(bind(s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
SyscallSucceeds());
ASSERT_THAT(bind(s.get(), AsSockAddr(&addr), addrlen), SyscallSucceeds());
ASSERT_THAT(listen(s.get(), SOMAXCONN), SyscallSucceeds());
@@ -2062,10 +2014,8 @@ TEST_P(SimpleTcpSocketTest, ConnectUnspecifiedAddress) {
auto do_connect = [&addr, addrlen]() {
FileDescriptor s = ASSERT_NO_ERRNO_AND_VALUE(
Socket(addr.ss_family, SOCK_STREAM, IPPROTO_TCP));
ASSERT_THAT(
RetryEINTR(connect)(s.get(), reinterpret_cast<struct sockaddr*>(&addr),
addrlen),
SyscallFailsWithErrno(ECONNREFUSED));
ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
SyscallFailsWithErrno(ECONNREFUSED));
};
do_connect();
// Test the v4 mapped address as well.
test/syscalls/linux/tuntap.cc
+2 -3
View File
@@ -397,8 +397,7 @@ TEST_F(TuntapTest, SendUdpTriggersArpResolution) {
.sin_port = htons(42),
.sin_addr = {.s_addr = kTapPeerIPAddr},
};
ASSERT_THAT(sendto(sock, "hello", 5, 0, reinterpret_cast<sockaddr*>(&remote),
sizeof(remote)),
ASSERT_THAT(sendto(sock, "hello", 5, 0, AsSockAddr(&remote), sizeof(remote)),
SyscallSucceeds());
struct inpkt {
@@ -498,7 +497,7 @@ TEST_F(TuntapTest, WriteHangBug155928773) {
.sin_addr = {.s_addr = kTapIPAddr},
};
// Return values do not matter in this test.
connect(sock, reinterpret_cast<struct sockaddr*>(&remote), sizeof(remote));
connect(sock, AsSockAddr(&remote), sizeof(remote));
write(sock, "hello", 5);
}
test/syscalls/linux/udp_bind.cc
+19 -24
View File
@@ -83,27 +83,24 @@ TEST_P(SendtoTest, Sendto) {
ASSERT_NO_ERRNO_AND_VALUE(Socket(param.recv_domain, SOCK_DGRAM, 0));
if (param.send_addr_len > 0) {
ASSERT_THAT(bind(s1.get(), reinterpret_cast<sockaddr*>(&param.send_addr),
param.send_addr_len),
SyscallSucceeds());
}
if (param.connect_addr_len > 0) {
ASSERT_THAT(
connect(s1.get(), reinterpret_cast<sockaddr*>(&param.connect_addr),
param.connect_addr_len),
bind(s1.get(), AsSockAddr(&param.send_addr), param.send_addr_len),
SyscallSucceeds());
}
ASSERT_THAT(bind(s2.get(), reinterpret_cast<sockaddr*>(&param.recv_addr),
param.recv_addr_len),
if (param.connect_addr_len > 0) {
ASSERT_THAT(connect(s1.get(), AsSockAddr(&param.connect_addr),
param.connect_addr_len),
SyscallSucceeds());
}
ASSERT_THAT(bind(s2.get(), AsSockAddr(&param.recv_addr), param.recv_addr_len),
SyscallSucceeds());
struct sockaddr_storage real_recv_addr = {};
socklen_t real_recv_addr_len = param.recv_addr_len;
ASSERT_THAT(
getsockname(s2.get(), reinterpret_cast<sockaddr*>(&real_recv_addr),
&real_recv_addr_len),
getsockname(s2.get(), AsSockAddr(&real_recv_addr), &real_recv_addr_len),
SyscallSucceeds());
ASSERT_EQ(real_recv_addr_len, param.recv_addr_len);
@@ -116,23 +113,22 @@ TEST_P(SendtoTest, Sendto) {
char buf[20] = {};
if (!param.sendto_errnos.empty()) {
ASSERT_THAT(RetryEINTR(sendto)(s1.get(), buf, sizeof(buf), 0,
reinterpret_cast<sockaddr*>(&sendto_addr),
param.sendto_addr_len),
SyscallFailsWithErrno(ElementOf(param.sendto_errnos)));
ASSERT_THAT(
RetryEINTR(sendto)(s1.get(), buf, sizeof(buf), 0,
AsSockAddr(&sendto_addr), param.sendto_addr_len),
SyscallFailsWithErrno(ElementOf(param.sendto_errnos)));
return;
}
ASSERT_THAT(RetryEINTR(sendto)(s1.get(), buf, sizeof(buf), 0,
reinterpret_cast<sockaddr*>(&sendto_addr),
param.sendto_addr_len),
SyscallSucceedsWithValue(sizeof(buf)));
ASSERT_THAT(
RetryEINTR(sendto)(s1.get(), buf, sizeof(buf), 0,
AsSockAddr(&sendto_addr), param.sendto_addr_len),
SyscallSucceedsWithValue(sizeof(buf)));
struct sockaddr_storage got_addr = {};
socklen_t got_addr_len = sizeof(sockaddr_storage);
ASSERT_THAT(RetryEINTR(recvfrom)(s2.get(), buf, sizeof(buf), 0,
reinterpret_cast<sockaddr*>(&got_addr),
&got_addr_len),
AsSockAddr(&got_addr), &got_addr_len),
SyscallSucceedsWithValue(sizeof(buf)));
ASSERT_GT(got_addr_len, sizeof(sockaddr_in_common));
@@ -140,8 +136,7 @@ TEST_P(SendtoTest, Sendto) {
struct sockaddr_storage sender_addr = {};
socklen_t sender_addr_len = sizeof(sockaddr_storage);
ASSERT_THAT(getsockname(s1.get(), reinterpret_cast<sockaddr*>(&sender_addr),
&sender_addr_len),
ASSERT_THAT(getsockname(s1.get(), AsSockAddr(&sender_addr), &sender_addr_len),
SyscallSucceeds());
ASSERT_GT(sender_addr_len, sizeof(sockaddr_in_common));
test/syscalls/linux/udp_socket.cc
+102 -142
View File
File diff suppressed because it is too large Load Diff