Use ki_* socket methods in socket_test to fix linux trusted mode.

native_client_sdk/src/tests/nacl_io_socket_test/socket_test.cc

 // Copyright 2013 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 <errno.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <pthread.h>
 #include <sys/types.h>
@@ skipping 252 matching lines @@
   // at the time of the first send.
   EXPECT_EQ(0, Bind(sock2_, LOCAL_HOST, PORT2));
 
   sockaddr_in addr;
   sockaddr_in addr2;
   socklen_t addrlen = sizeof(addr2);
   IP4ToSockAddr(LOCAL_HOST, PORT2, &addr2);
 
   // The first send hasn't occurred, so the socket is not yet bound.
   socklen_t out_addrlen = sizeof(addr);
-  ASSERT_EQ(0, getsockname(sock1_, (sockaddr*)&addr, &out_addrlen));
+  ASSERT_EQ(0, ki_getsockname(sock1_, (sockaddr*)&addr, &out_addrlen));
   EXPECT_EQ(addrlen, out_addrlen);
   EXPECT_EQ(0, htonl(addr.sin_addr.s_addr));
   EXPECT_EQ(0, htons(addr.sin_port));
 
   int len1 =
-     sendto(sock1_, outbuf, sizeof(outbuf), 0, (sockaddr*) &addr2, addrlen);
+     ki_sendto(sock1_, outbuf, sizeof(outbuf), 0, (sockaddr*) &addr2, addrlen);
   EXPECT_EQ(sizeof(outbuf), len1);
 
   // After the first send, the socket should be bound; the port is set, but
   // the address is still 0.
-  ASSERT_EQ(0, getsockname(sock1_, (sockaddr*)&addr, &out_addrlen));
+  ASSERT_EQ(0, ki_getsockname(sock1_, (sockaddr*)&addr, &out_addrlen));
   EXPECT_EQ(addrlen, out_addrlen);
   EXPECT_EQ(0, htonl(addr.sin_addr.s_addr));
   EXPECT_NE(0, htons(addr.sin_port));
 
   // Ensure the buffers are different
   EXPECT_NE(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 
   // Try to receive the previously sent packet
   int len2 =
-    recvfrom(sock2_, inbuf, sizeof(inbuf), 0, (sockaddr*) &addr, &addrlen);
+    ki_recvfrom(sock2_, inbuf, sizeof(inbuf), 0, (sockaddr*) &addr, &addrlen);
   EXPECT_EQ(sizeof(outbuf), len2);
   EXPECT_EQ(sizeof(sockaddr_in), addrlen);
   EXPECT_EQ(LOCAL_HOST, htonl(addr.sin_addr.s_addr));
   EXPECT_NE(0, htons(addr.sin_port));
 
   // Now they should be the same
   EXPECT_EQ(0, memcmp(outbuf, inbuf, sizeof(outbuf)));
 }
 
 const size_t kQueueSize = 65536 * 8;
@@ skipping 114 matching lines @@
   socklen_t len = sizeof(socket_error);
   ASSERT_EQ(-1, ki_setsockopt(sock1_, SOL_SOCKET, SO_ERROR,
                               &socket_error, len));
   ASSERT_EQ(ENOPROTOOPT, errno);
 }
 
 TEST_F(SocketTest, Sockopt_TCP_NODELAY) {
   int option = 0;
   socklen_t len = sizeof(option);
   // Getting and setting TCP_NODELAY on UDP socket should fail
-  sock1_ = socket(AF_INET, SOCK_DGRAM, 0);
+  sock1_ = ki_socket(AF_INET, SOCK_DGRAM, 0);
   ASSERT_EQ(-1, ki_setsockopt(sock1_, IPPROTO_TCP, TCP_NODELAY, &option, len));
   ASSERT_EQ(ENOPROTOOPT, errno);
   ASSERT_EQ(-1, ki_getsockopt(sock1_, IPPROTO_TCP, TCP_NODELAY, &option, &len));
   ASSERT_EQ(ENOPROTOOPT, errno);
 
   // Getting and setting TCP_NODELAY on TCP socket should preserve value
-  sock2_ = socket(AF_INET, SOCK_STREAM, 0);
+  sock2_ = ki_socket(AF_INET, SOCK_STREAM, 0);
   ASSERT_EQ(0, ki_getsockopt(sock2_, IPPROTO_TCP, TCP_NODELAY, &option, &len));
   ASSERT_EQ(0, option);
   ASSERT_EQ(sizeof(option), len);
 
   option = 1;
   len = sizeof(option);
   ASSERT_EQ(0, ki_setsockopt(sock2_, IPPROTO_TCP, TCP_NODELAY, &option, len))
       << "Failed with " << errno << ": " << strerror(errno);
   ASSERT_EQ(1, option);
 }
@@ skipping 141 matching lines @@
   sockaddr_in addr;
   socklen_t addrlen = sizeof(addr);
   const char* client_greeting = "hello";
   const char* server_reply = "reply";
   const int greeting_len = strlen(client_greeting);
   const int reply_len = strlen(server_reply);
 
   int server_sock = sock1_;
 
   // Accept before listen should fail
-  ASSERT_EQ(-1, accept(server_sock, (sockaddr*)&addr, &addrlen));
+  ASSERT_EQ(-1, ki_accept(server_sock, (sockaddr*)&addr, &addrlen));
 
   // Listen should fail on unbound socket
   ASSERT_EQ(-1,  ki_listen(server_sock, 10));
 
   // Bind and Listen
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0,  ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // Connect to listening socket, and send greeting
   int client_sock = sock2_;
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   addrlen = sizeof(addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
     << "Failed with " << errno << ": " << strerror(errno);
 
   ASSERT_EQ(greeting_len, ki_send(client_sock, client_greeting,
                                   greeting_len, 0));
 
   // Pass in addrlen that is larger than our actual address to make
   // sure that it is correctly set back to sizeof(sockaddr_in)
   addrlen = sizeof(addr) + 10;
-  int new_socket = accept(server_sock, (sockaddr*)&addr, &addrlen);
+  int new_socket = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_GT(new_socket, -1)
     << "accept failed with " << errno << ": " << strerror(errno);
 
   // Verify addr and addrlen were set correctly
   ASSERT_EQ(addrlen, sizeof(sockaddr_in));
   sockaddr_in client_addr;
   ASSERT_EQ(0, ki_getsockname(client_sock, (sockaddr*)&client_addr, &addrlen));
   ASSERT_EQ(client_addr.sin_family, addr.sin_family);
   ASSERT_EQ(client_addr.sin_port, addr.sin_port);
   ASSERT_EQ(client_addr.sin_addr.s_addr, addr.sin_addr.s_addr);
@@ skipping 21 matching lines @@
 
   // bind and listen
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0, ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // Accept should fail with EAGAIN since there is no incomming
   // connection.
   sockaddr_in addr;
   socklen_t addrlen = sizeof(addr);
-  ASSERT_EQ(-1, accept(server_sock, (sockaddr*)&addr, &addrlen));
+  ASSERT_EQ(-1, ki_accept(server_sock, (sockaddr*)&addr, &addrlen));
   ASSERT_EQ(EAGAIN, errno);
 
   // If we poll the listening socket it should also return
   // not readable to indicate that no connections are available
   // to accept.
   struct pollfd pollfd = { server_sock, POLLIN|POLLOUT, 0 };
   ASSERT_EQ(0, ki_poll(&pollfd, 1, 0));
 
   // Connect to listening socket
   int client_sock = sock2_;
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   addrlen = sizeof(addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
     << "Failed with " << errno << ": " << strerror(errno);
 
   // Not poll again but with an infintie timeout.
   pollfd.fd = server_sock;
   pollfd.events = POLLIN | POLLOUT;
   ASSERT_EQ(1, ki_poll(&pollfd, 1, -1));
 
   // Now non-blocking accept should return the new socket
-  int new_socket = accept(server_sock, (sockaddr*)&addr, &addrlen);
+  int new_socket = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_NE(-1, new_socket)
     << "accept failed with: " << strerror(errno);
   ASSERT_EQ(0, ki_close(new_socket));
 
   // Accept calls should once again fail with EAGAIN
-  ASSERT_EQ(-1, accept(server_sock, (sockaddr*)&addr, &addrlen));
+  ASSERT_EQ(-1, ki_accept(server_sock, (sockaddr*)&addr, &addrlen));
   ASSERT_EQ(EAGAIN, errno);
 
   // As should polling the listening socket
   pollfd.fd = server_sock;
   pollfd.events = POLLIN | POLLOUT;
   ASSERT_EQ(0, ki_poll(&pollfd, 1, 0));
 }
 
 TEST_F(SocketTestTCP, SendRecvAfterRemoteShutdown) {
   sockaddr_in addr;
   socklen_t addrlen = sizeof(addr);
 
   int server_sock = sock1_;
   int client_sock = sock2_;
 
   // bind and listen
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0, ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // connect to listening socket
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
     << "Failed with " << errno << ": " << strerror(errno);
 
   addrlen = sizeof(addr);
-  int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
+  int new_sock = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_NE(-1, new_sock);
 
   const char* send_buf = "hello world";
   ASSERT_EQ(strlen(send_buf), ki_send(new_sock, send_buf, strlen(send_buf), 0));
 
   // Recv first 10 bytes
   char buf[256];
   ASSERT_EQ(10, ki_recv(client_sock, buf, 10, 0));
 
   // Close the new socket
@@ skipping 21 matching lines @@
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0, ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // connect to listening socket
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
     << "Failed with " << errno << ": " << strerror(errno);
 
   addrlen = sizeof(addr);
-  int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
+  int new_sock = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_NE(-1, new_sock);
 
   // Close the new socket
   ASSERT_EQ(0, ki_shutdown(client_sock, SHUT_RDWR));
 
   // Attempt to read/write after shutdown
   char buffer[10];
   ASSERT_EQ(0, ki_recv(client_sock, buffer, sizeof(buffer), 0));
   ASSERT_EQ(-1, ki_send(client_sock, buffer, sizeof(buffer), 0));
   ASSERT_EQ(errno, EPIPE);
@@ skipping 11 matching lines @@
   ASSERT_EQ(0, Bind(server_sock, LOCAL_HOST, PORT1));
   ASSERT_EQ(0, ki_listen(server_sock, 10))
     << "listen failed with: " << strerror(errno);
 
   // connect to listening socket
   IP4ToSockAddr(LOCAL_HOST, PORT1, &addr);
   ASSERT_EQ(0, ki_connect(client_sock, (sockaddr*)&addr, addrlen))
     << "Failed with " << errno << ": " << strerror(errno);
 
   addrlen = sizeof(addr);
-  int new_sock = accept(server_sock, (sockaddr*)&addr, &addrlen);
+  int new_sock = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
   ASSERT_NE(-1, new_sock);
 
   // send a fairly large amount of data and immediately close
   // the socket.
   void* buffer = alloca(SEND_BYTES);
   ASSERT_EQ(SEND_BYTES, ki_send(client_sock, buffer, SEND_BYTES, 0));
   ASSERT_EQ(0, ki_close(client_sock));
 
   // avoid double close of sock2_
   sock2_ = -1;
 
   // Attempt to recv() all the sent data.  None should be lost.
   int remainder = SEND_BYTES;
   while (remainder > 0) {
     int rtn = ki_recv(new_sock, buffer, remainder, 0);
     ASSERT_GT(rtn, 0);
     remainder -= rtn;
   }
 
   ASSERT_EQ(0, ki_close(new_sock));
 }
 
 #endif  // PROVIDES_SOCKET_API