Fix socket calls in glibc by using new errno return macros.

Also update tests to match.

BUG=None
TEST=trybots
R=binji@chromium.org

Review URL: https://codereview.chromium.org/286303002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@271241 0039d316-1c4b-4281-b951-d872f2087c98

native_client_sdk/src/libraries/nacl_io/kernel_wrap_glibc.cc

@@ -325,72 +325,76 @@ int WRAP(write)(int fd, const void* buf, size_t count, size_t* nwrote) {
 
 int WRAP(accept)(int sockfd, struct sockaddr* addr,
                  socklen_t* addrlen, int *sd) {
-  int result = ki_accept(sockfd, addr, addrlen);
-  if (result < 0) {
-    *sd = -1;
-    return errno;
-  } else {
-    *sd = result;
-    return 0;
-  }
+  *sd = ki_accept(sockfd, addr, addrlen);
+  RTN_ERRNO_IF(*sd < 0);
+  return 0;
 }
 
 int WRAP(bind)(int sockfd, const struct sockaddr* addr, socklen_t addrlen) {
-  return (ki_bind(sockfd, addr, addrlen) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_bind(sockfd, addr, addrlen) < 0);
+  return 0;
 }
 
 int WRAP(connect)(int sockfd, const struct sockaddr* addr, socklen_t addrlen) {
-  return (ki_connect(sockfd, addr, addrlen) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_connect(sockfd, addr, addrlen) < 0);
+  return 0;
 }
 
 int WRAP(getpeername)(int sockfd, struct sockaddr* addr, socklen_t* addrlen) {
-  return (ki_getpeername(sockfd, addr, addrlen) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_getpeername(sockfd, addr, addrlen) < 0);
+  return 0;
 }
 
 int WRAP(getsockname)(int sockfd, struct sockaddr* addr, socklen_t* addrlen) {
-  return (ki_getsockname(sockfd, addr, addrlen) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_getsockname(sockfd, addr, addrlen) < 0);
+  return 0;
 }
 
 int WRAP(getsockopt)(int sockfd, int level, int optname, void* optval,
                      socklen_t* optlen) {
-  return (ki_getsockopt(
-      sockfd, level, optname, optval, optlen) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_getsockopt(sockfd, level, optname, optval, optlen) < 0);
+  return 0;
 }
 
 int WRAP(setsockopt)(int sockfd, int level, int optname, const void* optval,
                      socklen_t optlen) {
-  return (ki_setsockopt(
-      sockfd, level, optname, optval, optlen) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_setsockopt(sockfd, level, optname, optval, optlen) < 0);
+  return 0;
 }
 
 int WRAP(listen)(int sockfd, int backlog) {
-  return (ki_listen(sockfd, backlog) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_listen(sockfd, backlog) < 0);
+  return 0;
 }
 
 int WRAP(recv)(int sockfd, void* buf, size_t len, int flags, int* count) {
   ssize_t signed_nread = ki_recv(sockfd, buf, len, flags);
   *count = static_cast<int>(signed_nread);
-  return (signed_nread < 0) ? errno : 0;
+  RTN_ERRNO_IF(signed_nread < 0);
+  return 0;
 }
 
 int WRAP(recvfrom)(int sockfd, void* buf, size_t len, int flags,
                    struct sockaddr* addr, socklen_t* addrlen, int* count) {
   ssize_t signed_nread = ki_recvfrom(sockfd, buf, len, flags, addr, addrlen);
   *count = static_cast<int>(signed_nread);
-  return (signed_nread < 0) ? errno : 0;
+  RTN_ERRNO_IF(signed_nread < 0);
+  return 0;
 }
 
 int WRAP(recvmsg)(int sockfd, struct msghdr* msg, int flags, int *count) {
   ssize_t signed_nread = ki_recvmsg(sockfd, msg, flags);
   *count = static_cast<int>(signed_nread);
-  return (signed_nread < 0) ? errno : 0;
+  RTN_ERRNO_IF(signed_nread < 0);
+  return 0;
 }
 
 ssize_t WRAP(send)(int sockfd, const void* buf, size_t len, int flags,
                    int* count) {
   ssize_t signed_nread = ki_send(sockfd, buf, len, flags);
   *count = static_cast<int>(signed_nread);
-  return (signed_nread < 0) ? errno : 0;
+  RTN_ERRNO_IF(signed_nread < 0);
+  return 0;
 }
 
 ssize_t WRAP(sendto)(int sockfd, const void* buf, size_t len, int flags,
@@ -398,33 +402,32 @@ ssize_t WRAP(sendto)(int sockfd, const void* buf, size_t len, int flags,
                      int* count) {
   ssize_t signed_nread = ki_sendto(sockfd, buf, len, flags, addr, addrlen);
   *count = static_cast<int>(signed_nread);
-  return (signed_nread < 0) ? errno : 0;
+  RTN_ERRNO_IF(signed_nread < 0);
+  return 0;
 }
 
 ssize_t WRAP(sendmsg)(int sockfd, const struct msghdr* msg, int flags,
                       int* count) {
   ssize_t signed_nread = ki_sendmsg(sockfd, msg, flags);
   *count = static_cast<int>(signed_nread);
-  return (signed_nread < 0) ? errno : 0;
+  RTN_ERRNO_IF(signed_nread < 0);
+  return 0;
 }
 
 int WRAP(shutdown)(int sockfd, int how) {
-  return (ki_shutdown(sockfd, how) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_shutdown(sockfd, how) < 0);
+  return 0;
 }
 
 int WRAP(socket)(int domain, int type, int protocol, int* sd) {
-  int result = ki_socket(domain, type, protocol);
-  if (result < 0) {
-    *sd = -1;
-    return errno;
-  } else {
-    *sd = result;
-    return 0;
-  }
+  *sd = ki_socket(domain, type, protocol);
+  RTN_ERRNO_IF(*sd < 0);
+  return 0;
 }
 
 int WRAP(socketpair)(int domain, int type, int protocol, int* sv) {
-  return (ki_socketpair(domain, type, protocol, sv) < 0) ? errno : 0;
+  RTN_ERRNO_IF(ki_socketpair(domain, type, protocol, sv) < 0);
+  return 0;
 }
 
 static void assign_real_pointers() {

native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc

@@ -655,9 +655,10 @@ TEST_F(KernelWrapTest, bind) {
   struct sockaddr addr;
   EXPECT_CALL(mock, bind(kDummyInt, &addr, kDummyInt2))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(0, bind(kDummyInt, &addr, kDummyInt2));
   EXPECT_EQ(-1, bind(kDummyInt, &addr, kDummyInt2));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, connect) {
@@ -666,9 +667,10 @@ TEST_F(KernelWrapTest, connect) {
   struct sockaddr addr;
   EXPECT_CALL(mock, connect(kDummyInt, &addr, kDummyInt2))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(0, connect(kDummyInt, &addr, kDummyInt2));
   EXPECT_EQ(-1, connect(kDummyInt, &addr, kDummyInt2));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, gethostbyname) {
@@ -684,9 +686,10 @@ TEST_F(KernelWrapTest, getpeername) {
   socklen_t len;
   EXPECT_CALL(mock, getpeername(kDummyInt, &addr, &len))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(0, getpeername(kDummyInt, &addr, &len));
   EXPECT_EQ(-1, getpeername(kDummyInt, &addr, &len));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, getsockname) {
@@ -694,11 +697,13 @@ TEST_F(KernelWrapTest, getsockname) {
   // so we test 0 and -1.
   struct sockaddr addr;
   socklen_t len;
+
   EXPECT_CALL(mock, getsockname(kDummyInt, &addr, &len))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(0, getsockname(kDummyInt, &addr, &len));
   EXPECT_EQ(-1, getsockname(kDummyInt, &addr, &len));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, getsockopt) {
@@ -710,13 +715,14 @@ TEST_F(KernelWrapTest, getsockopt) {
   EXPECT_CALL(
       mock, getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(
       0,
       getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len));
   EXPECT_EQ(
       -1,
       getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, listen) {
@@ -724,9 +730,10 @@ TEST_F(KernelWrapTest, listen) {
   // test 0 and -1.
   EXPECT_CALL(mock, listen(kDummyInt, kDummyInt2))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(0, listen(kDummyInt, kDummyInt2));
   EXPECT_EQ(-1, listen(kDummyInt, kDummyInt2));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, recv) {
@@ -803,7 +810,7 @@ TEST_F(KernelWrapTest, setsockopt) {
       setsockopt(
           kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(
       0,
       setsockopt(
@@ -812,6 +819,7 @@ TEST_F(KernelWrapTest, setsockopt) {
       -1,
       setsockopt(
           kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, shutdown) {
@@ -819,9 +827,10 @@ TEST_F(KernelWrapTest, shutdown) {
   // test 0 and -1.
   EXPECT_CALL(mock, shutdown(kDummyInt, kDummyInt2))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(0, shutdown(kDummyInt, kDummyInt2));
   EXPECT_EQ(-1, shutdown(kDummyInt, kDummyInt2));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, socket) {
@@ -836,11 +845,10 @@ TEST_F(KernelWrapTest, socketpair) {
   int dummy_val;
   EXPECT_CALL(mock, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val))
       .WillOnce(Return(0))
-      .WillOnce(Return(-1));
-  EXPECT_EQ(0,
-            socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
-  EXPECT_EQ(-1,
-            socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(0, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
+  EXPECT_EQ(-1, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
+  EXPECT_EQ(kDummyErrno, errno);
 }
 
 #endif  // PROVIDES_SOCKET_API