nacl_io: only copy up to the size of the sockaddr_in*, not the given len.

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 599 matching lines @@
   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 = ki_accept(server_sock, (sockaddr*)&addr, &addrlen);
+  sockaddr_in client_addr[2];
+  sockaddr_in cmp_addr;
+  memset(&client_addr[0], 0, sizeof(client_addr[0]));
+  memset(&client_addr[1], 0xab, sizeof(client_addr[1]));
+  memset(&cmp_addr, 0xab, sizeof(cmp_addr));
+  addrlen = sizeof(client_addr[0]) + 10;
+  int new_socket = ki_accept(server_sock, (sockaddr*)&client_addr[0],
+                             &addrlen);
   ASSERT_GT(new_socket, -1)
     << "accept failed with " << errno << ": " << strerror(errno);
+  ASSERT_EQ(addrlen, sizeof(sockaddr_in));
+  // Check that client_addr[1] and cmp_addr are the same (not overwritten).
+  ASSERT_EQ(0, memcmp(&client_addr[1], &cmp_addr, sizeof(cmp_addr)));
+  ASSERT_EQ(0xabab, client_addr[1].sin_port);
 
   // 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);
+  ASSERT_EQ(0, ki_getsockname(client_sock, (sockaddr*)&client_addr[1],
+                              &addrlen));
+  ASSERT_EQ(client_addr[1].sin_family, client_addr[0].sin_family);
+  ASSERT_EQ(client_addr[1].sin_port, client_addr[0].sin_port);
+  ASSERT_EQ(client_addr[1].sin_addr.s_addr, client_addr[0].sin_addr.s_addr);
+
+  // Try a call where the supplied len is smaller than the expected length.
+  // The API should only write up to that amount, but should return the
+  // expected length.
+  sockaddr_in client_addr2;
+  memset(&client_addr2, 0, sizeof(client_addr2));
+  socklen_t truncated_len = sizeof(client_addr2.sin_family);
+  ASSERT_GT(sizeof(sockaddr_in), truncated_len);
+  ASSERT_EQ(0, ki_getsockname(client_sock, (sockaddr*)&client_addr2,
+                              &truncated_len));
+  ASSERT_EQ(sizeof(sockaddr_in), truncated_len);
+  ASSERT_EQ(client_addr2.sin_family, client_addr[0].sin_family);
+  ASSERT_EQ(client_addr2.sin_port, 0);
+  ASSERT_EQ(client_addr2.sin_addr.s_addr, 0);

[Sam Clegg, 2014/06/04 00:45:28]

This seems like it should be its own test really...  I can move it out in
another CL if the CQ is gonna land this version.

 
   // Recv greeting from client and send reply
   char inbuf[512];
   ASSERT_EQ(greeting_len, ki_recv(new_socket, inbuf, sizeof(inbuf), 0));
   inbuf[greeting_len] = 0;
   ASSERT_STREQ(inbuf, client_greeting);
   ASSERT_EQ(reply_len, ki_send(new_socket, server_reply, reply_len, 0));
 
   // Recv reply on client socket
   ASSERT_EQ(reply_len, ki_recv(client_sock, inbuf, sizeof(inbuf), 0));
@@ skipping 164 matching lines @@
   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