Home | History | Annotate | Download | only in udp 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/udp/udp_client_socket.h"
      6 #include "net/udp/udp_server_socket.h"
      7 
      8 #include "base/basictypes.h"
      9 #include "base/bind.h"
     10 #include "base/metrics/histogram.h"
     11 #include "base/stl_util.h"
     12 #include "net/base/io_buffer.h"
     13 #include "net/base/ip_endpoint.h"
     14 #include "net/base/net_errors.h"
     15 #include "net/base/net_log_unittest.h"
     16 #include "net/base/net_util.h"
     17 #include "net/base/test_completion_callback.h"
     18 #include "net/test/net_test_suite.h"
     19 #include "testing/gtest/include/gtest/gtest.h"
     20 #include "testing/platform_test.h"
     21 
     22 namespace net {
     23 
     24 namespace {
     25 
     26 class UDPSocketTest : public PlatformTest {
     27  public:
     28   UDPSocketTest()
     29       : buffer_(new IOBufferWithSize(kMaxRead)) {
     30   }
     31 
     32   // Blocks until data is read from the socket.
     33   std::string RecvFromSocket(UDPServerSocket* socket) {
     34     TestCompletionCallback callback;
     35 
     36     int rv = socket->RecvFrom(
     37         buffer_.get(), kMaxRead, &recv_from_address_, callback.callback());
     38     if (rv == ERR_IO_PENDING)
     39       rv = callback.WaitForResult();
     40     if (rv < 0)
     41       return std::string();  // error!
     42     return std::string(buffer_->data(), rv);
     43   }
     44 
     45   // Loop until |msg| has been written to the socket or until an
     46   // error occurs.
     47   // If |address| is specified, then it is used for the destination
     48   // to send to. Otherwise, will send to the last socket this server
     49   // received from.
     50   int SendToSocket(UDPServerSocket* socket, std::string msg) {
     51     return SendToSocket(socket, msg, recv_from_address_);
     52   }
     53 
     54   int SendToSocket(UDPServerSocket* socket,
     55                    std::string msg,
     56                    const IPEndPoint& address) {
     57     TestCompletionCallback callback;
     58 
     59     int length = msg.length();
     60     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     61     scoped_refptr<DrainableIOBuffer> buffer(
     62         new DrainableIOBuffer(io_buffer.get(), length));
     63 
     64     int bytes_sent = 0;
     65     while (buffer->BytesRemaining()) {
     66       int rv = socket->SendTo(
     67           buffer.get(), buffer->BytesRemaining(), address, callback.callback());
     68       if (rv == ERR_IO_PENDING)
     69         rv = callback.WaitForResult();
     70       if (rv <= 0)
     71         return bytes_sent > 0 ? bytes_sent : rv;
     72       bytes_sent += rv;
     73       buffer->DidConsume(rv);
     74     }
     75     return bytes_sent;
     76   }
     77 
     78   std::string ReadSocket(UDPClientSocket* socket) {
     79     TestCompletionCallback callback;
     80 
     81     int rv = socket->Read(buffer_.get(), kMaxRead, callback.callback());
     82     if (rv == ERR_IO_PENDING)
     83       rv = callback.WaitForResult();
     84     if (rv < 0)
     85       return std::string();  // error!
     86     return std::string(buffer_->data(), rv);
     87   }
     88 
     89   // Loop until |msg| has been written to the socket or until an
     90   // error occurs.
     91   int WriteSocket(UDPClientSocket* socket, std::string msg) {
     92     TestCompletionCallback callback;
     93 
     94     int length = msg.length();
     95     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     96     scoped_refptr<DrainableIOBuffer> buffer(
     97         new DrainableIOBuffer(io_buffer.get(), length));
     98 
     99     int bytes_sent = 0;
    100     while (buffer->BytesRemaining()) {
    101       int rv = socket->Write(
    102           buffer.get(), buffer->BytesRemaining(), callback.callback());
    103       if (rv == ERR_IO_PENDING)
    104         rv = callback.WaitForResult();
    105       if (rv <= 0)
    106         return bytes_sent > 0 ? bytes_sent : rv;
    107       bytes_sent += rv;
    108       buffer->DidConsume(rv);
    109     }
    110     return bytes_sent;
    111   }
    112 
    113  protected:
    114   static const int kMaxRead = 1024;
    115   scoped_refptr<IOBufferWithSize> buffer_;
    116   IPEndPoint recv_from_address_;
    117 };
    118 
    119 // Creates and address from an ip/port and returns it in |address|.
    120 void CreateUDPAddress(std::string ip_str, int port, IPEndPoint* address) {
    121   IPAddressNumber ip_number;
    122   bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
    123   if (!rv)
    124     return;
    125   *address = IPEndPoint(ip_number, port);
    126 }
    127 
    128 TEST_F(UDPSocketTest, Connect) {
    129   const int kPort = 9999;
    130   std::string simple_message("hello world!");
    131 
    132   // Setup the server to listen.
    133   IPEndPoint bind_address;
    134   CreateUDPAddress("127.0.0.1", kPort, &bind_address);
    135   CapturingNetLog server_log;
    136   scoped_ptr<UDPServerSocket> server(
    137       new UDPServerSocket(&server_log, NetLog::Source()));
    138   server->AllowAddressReuse();
    139   int rv = server->Listen(bind_address);
    140   ASSERT_EQ(OK, rv);
    141 
    142   // Setup the client.
    143   IPEndPoint server_address;
    144   CreateUDPAddress("127.0.0.1", kPort, &server_address);
    145   CapturingNetLog client_log;
    146   scoped_ptr<UDPClientSocket> client(
    147       new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
    148                           RandIntCallback(),
    149                           &client_log,
    150                           NetLog::Source()));
    151   rv = client->Connect(server_address);
    152   EXPECT_EQ(OK, rv);
    153 
    154   // Client sends to the server.
    155   rv = WriteSocket(client.get(), simple_message);
    156   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
    157 
    158   // Server waits for message.
    159   std::string str = RecvFromSocket(server.get());
    160   DCHECK(simple_message == str);
    161 
    162   // Server echoes reply.
    163   rv = SendToSocket(server.get(), simple_message);
    164   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
    165 
    166   // Client waits for response.
    167   str = ReadSocket(client.get());
    168   DCHECK(simple_message == str);
    169 
    170   // Delete sockets so they log their final events.
    171   server.reset();
    172   client.reset();
    173 
    174   // Check the server's log.
    175   CapturingNetLog::CapturedEntryList server_entries;
    176   server_log.GetEntries(&server_entries);
    177   EXPECT_EQ(4u, server_entries.size());
    178   EXPECT_TRUE(LogContainsBeginEvent(
    179       server_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
    180   EXPECT_TRUE(LogContainsEvent(
    181       server_entries, 1, NetLog::TYPE_UDP_BYTES_RECEIVED, NetLog::PHASE_NONE));
    182   EXPECT_TRUE(LogContainsEvent(
    183       server_entries, 2, NetLog::TYPE_UDP_BYTES_SENT, NetLog::PHASE_NONE));
    184   EXPECT_TRUE(LogContainsEndEvent(
    185       server_entries, 3, NetLog::TYPE_SOCKET_ALIVE));
    186 
    187   // Check the client's log.
    188   CapturingNetLog::CapturedEntryList client_entries;
    189   client_log.GetEntries(&client_entries);
    190   EXPECT_EQ(6u, client_entries.size());
    191   EXPECT_TRUE(LogContainsBeginEvent(
    192       client_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
    193   EXPECT_TRUE(LogContainsBeginEvent(
    194       client_entries, 1, NetLog::TYPE_UDP_CONNECT));
    195   EXPECT_TRUE(LogContainsEndEvent(
    196       client_entries, 2, NetLog::TYPE_UDP_CONNECT));
    197   EXPECT_TRUE(LogContainsEvent(
    198       client_entries, 3, NetLog::TYPE_UDP_BYTES_SENT, NetLog::PHASE_NONE));
    199   EXPECT_TRUE(LogContainsEvent(
    200       client_entries, 4, NetLog::TYPE_UDP_BYTES_RECEIVED, NetLog::PHASE_NONE));
    201   EXPECT_TRUE(LogContainsEndEvent(
    202       client_entries, 5, NetLog::TYPE_SOCKET_ALIVE));
    203 }
    204 
    205 #if defined(OS_MACOSX)
    206 // UDPSocketPrivate_Broadcast is disabled for OSX because it requires
    207 // root permissions on OSX 10.7+.
    208 TEST_F(UDPSocketTest, DISABLED_Broadcast) {
    209 #elif defined(OS_ANDROID)
    210 // It is also disabled for Android because it is extremely flaky.
    211 // The first call to SendToSocket returns -109 (Address not reachable)
    212 // in some unpredictable cases. crbug.com/139144.
    213 TEST_F(UDPSocketTest, DISABLED_Broadcast) {
    214 #else
    215 TEST_F(UDPSocketTest, Broadcast) {
    216 #endif
    217   const int kPort = 9999;
    218   std::string first_message("first message"), second_message("second message");
    219 
    220   IPEndPoint broadcast_address;
    221   CreateUDPAddress("255.255.255.255", kPort, &broadcast_address);
    222   IPEndPoint listen_address;
    223   CreateUDPAddress("0.0.0.0", kPort, &listen_address);
    224 
    225   CapturingNetLog server1_log, server2_log;
    226   scoped_ptr<UDPServerSocket> server1(
    227       new UDPServerSocket(&server1_log, NetLog::Source()));
    228   scoped_ptr<UDPServerSocket> server2(
    229       new UDPServerSocket(&server2_log, NetLog::Source()));
    230   server1->AllowAddressReuse();
    231   server1->AllowBroadcast();
    232   server2->AllowAddressReuse();
    233   server2->AllowBroadcast();
    234 
    235   int rv = server1->Listen(listen_address);
    236   EXPECT_EQ(OK, rv);
    237   rv = server2->Listen(listen_address);
    238   EXPECT_EQ(OK, rv);
    239 
    240   rv = SendToSocket(server1.get(), first_message, broadcast_address);
    241   ASSERT_EQ(static_cast<int>(first_message.size()), rv);
    242   std::string str = RecvFromSocket(server1.get());
    243   ASSERT_EQ(first_message, str);
    244   str = RecvFromSocket(server2.get());
    245   ASSERT_EQ(first_message, str);
    246 
    247   rv = SendToSocket(server2.get(), second_message, broadcast_address);
    248   ASSERT_EQ(static_cast<int>(second_message.size()), rv);
    249   str = RecvFromSocket(server1.get());
    250   ASSERT_EQ(second_message, str);
    251   str = RecvFromSocket(server2.get());
    252   ASSERT_EQ(second_message, str);
    253 }
    254 
    255 // In this test, we verify that random binding logic works, which attempts
    256 // to bind to a random port and returns if succeeds, otherwise retries for
    257 // |kBindRetries| number of times.
    258 
    259 // To generate the scenario, we first create |kBindRetries| number of
    260 // UDPClientSockets with default binding policy and connect to the same
    261 // peer and save the used port numbers.  Then we get rid of the last
    262 // socket, making sure that the local port it was bound to is available.
    263 // Finally, we create a socket with random binding policy, passing it a
    264 // test PRNG that would serve used port numbers in the array, one after
    265 // another.  At the end, we make sure that the test socket was bound to the
    266 // port that became available after deleting the last socket with default
    267 // binding policy.
    268 
    269 // We do not test the randomness of bound ports, but that we are using
    270 // passed in PRNG correctly, thus, it's the duty of PRNG to produce strong
    271 // random numbers.
    272 static const int kBindRetries = 10;
    273 
    274 class TestPrng {
    275  public:
    276   explicit TestPrng(const std::deque<int>& numbers) : numbers_(numbers) {}
    277   int GetNext(int /* min */, int /* max */) {
    278     DCHECK(!numbers_.empty());
    279     int rv = numbers_.front();
    280     numbers_.pop_front();
    281     return rv;
    282   }
    283  private:
    284   std::deque<int> numbers_;
    285 
    286   DISALLOW_COPY_AND_ASSIGN(TestPrng);
    287 };
    288 
    289 #if defined(OS_ANDROID)
    290 // Disabled on Android for lack of 192.168.1.13. crbug.com/161245
    291 TEST_F(UDPSocketTest, DISABLED_ConnectRandomBind) {
    292 #else
    293 TEST_F(UDPSocketTest, ConnectRandomBind) {
    294 #endif
    295   std::vector<UDPClientSocket*> sockets;
    296   IPEndPoint peer_address;
    297   CreateUDPAddress("192.168.1.13", 53, &peer_address);
    298 
    299   // Create and connect sockets and save port numbers.
    300   std::deque<int> used_ports;
    301   for (int i = 0; i < kBindRetries; ++i) {
    302     UDPClientSocket* socket =
    303         new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
    304                             RandIntCallback(),
    305                             NULL,
    306                             NetLog::Source());
    307     sockets.push_back(socket);
    308     EXPECT_EQ(OK, socket->Connect(peer_address));
    309 
    310     IPEndPoint client_address;
    311     EXPECT_EQ(OK, socket->GetLocalAddress(&client_address));
    312     used_ports.push_back(client_address.port());
    313   }
    314 
    315   // Free the last socket, its local port is still in |used_ports|.
    316   delete sockets.back();
    317   sockets.pop_back();
    318 
    319   TestPrng test_prng(used_ports);
    320   RandIntCallback rand_int_cb =
    321       base::Bind(&TestPrng::GetNext, base::Unretained(&test_prng));
    322 
    323   // Create a socket with random binding policy and connect.
    324   scoped_ptr<UDPClientSocket> test_socket(
    325       new UDPClientSocket(DatagramSocket::RANDOM_BIND,
    326                           rand_int_cb,
    327                           NULL,
    328                           NetLog::Source()));
    329   EXPECT_EQ(OK, test_socket->Connect(peer_address));
    330 
    331   // Make sure that the last port number in the |used_ports| was used.
    332   IPEndPoint client_address;
    333   EXPECT_EQ(OK, test_socket->GetLocalAddress(&client_address));
    334   EXPECT_EQ(used_ports.back(), client_address.port());
    335 
    336   STLDeleteElements(&sockets);
    337 }
    338 
    339 // Return a privileged port (under 1024) so binding will fail.
    340 int PrivilegedRand(int min, int max) {
    341   // Chosen by fair dice roll.  Guaranteed to be random.
    342   return 4;
    343 }
    344 
    345 TEST_F(UDPSocketTest, ConnectFail) {
    346   IPEndPoint peer_address;
    347   CreateUDPAddress("0.0.0.0", 53, &peer_address);
    348 
    349   scoped_ptr<UDPSocket> socket(
    350       new UDPSocket(DatagramSocket::RANDOM_BIND,
    351                     base::Bind(&PrivilegedRand),
    352                     NULL,
    353                     NetLog::Source()));
    354   int rv = socket->Connect(peer_address);
    355   // Connect should have failed since we couldn't bind to that port,
    356   EXPECT_NE(OK, rv);
    357   // Make sure that UDPSocket actually closed the socket.
    358   EXPECT_FALSE(socket->is_connected());
    359 }
    360 
    361 // In this test, we verify that connect() on a socket will have the effect
    362 // of filtering reads on this socket only to data read from the destination
    363 // we connected to.
    364 //
    365 // The purpose of this test is that some documentation indicates that connect
    366 // binds the client's sends to send to a particular server endpoint, but does
    367 // not bind the client's reads to only be from that endpoint, and that we need
    368 // to always use recvfrom() to disambiguate.
    369 TEST_F(UDPSocketTest, VerifyConnectBindsAddr) {
    370   const int kPort1 = 9999;
    371   const int kPort2 = 10000;
    372   std::string simple_message("hello world!");
    373   std::string foreign_message("BAD MESSAGE TO GET!!");
    374 
    375   // Setup the first server to listen.
    376   IPEndPoint bind_address;
    377   CreateUDPAddress("127.0.0.1", kPort1, &bind_address);
    378   UDPServerSocket server1(NULL, NetLog::Source());
    379   server1.AllowAddressReuse();
    380   int rv = server1.Listen(bind_address);
    381   ASSERT_EQ(OK, rv);
    382 
    383   // Setup the second server to listen.
    384   CreateUDPAddress("127.0.0.1", kPort2, &bind_address);
    385   UDPServerSocket server2(NULL, NetLog::Source());
    386   server2.AllowAddressReuse();
    387   rv = server2.Listen(bind_address);
    388   ASSERT_EQ(OK, rv);
    389 
    390   // Setup the client, connected to server 1.
    391   IPEndPoint server_address;
    392   CreateUDPAddress("127.0.0.1", kPort1, &server_address);
    393   UDPClientSocket client(DatagramSocket::DEFAULT_BIND,
    394                          RandIntCallback(),
    395                          NULL,
    396                          NetLog::Source());
    397   rv = client.Connect(server_address);
    398   EXPECT_EQ(OK, rv);
    399 
    400   // Client sends to server1.
    401   rv = WriteSocket(&client, simple_message);
    402   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
    403 
    404   // Server1 waits for message.
    405   std::string str = RecvFromSocket(&server1);
    406   DCHECK(simple_message == str);
    407 
    408   // Get the client's address.
    409   IPEndPoint client_address;
    410   rv = client.GetLocalAddress(&client_address);
    411   EXPECT_EQ(OK, rv);
    412 
    413   // Server2 sends reply.
    414   rv = SendToSocket(&server2, foreign_message,
    415                     client_address);
    416   EXPECT_EQ(foreign_message.length(), static_cast<size_t>(rv));
    417 
    418   // Server1 sends reply.
    419   rv = SendToSocket(&server1, simple_message,
    420                     client_address);
    421   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
    422 
    423   // Client waits for response.
    424   str = ReadSocket(&client);
    425   DCHECK(simple_message == str);
    426 }
    427 
    428 TEST_F(UDPSocketTest, ClientGetLocalPeerAddresses) {
    429   struct TestData {
    430     std::string remote_address;
    431     std::string local_address;
    432     bool may_fail;
    433   } tests[] = {
    434     { "127.0.00.1", "127.0.0.1", false },
    435     { "::1", "::1", true },
    436 #if !defined(OS_ANDROID)
    437     // Addresses below are disabled on Android. See crbug.com/161248
    438     { "192.168.1.1", "127.0.0.1", false },
    439     { "2001:db8:0::42", "::1", true },
    440 #endif
    441   };
    442   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
    443     SCOPED_TRACE(std::string("Connecting from ") +  tests[i].local_address +
    444                  std::string(" to ") + tests[i].remote_address);
    445 
    446     IPAddressNumber ip_number;
    447     ParseIPLiteralToNumber(tests[i].remote_address, &ip_number);
    448     IPEndPoint remote_address(ip_number, 80);
    449     ParseIPLiteralToNumber(tests[i].local_address, &ip_number);
    450     IPEndPoint local_address(ip_number, 80);
    451 
    452     UDPClientSocket client(DatagramSocket::DEFAULT_BIND,
    453                            RandIntCallback(),
    454                            NULL,
    455                            NetLog::Source());
    456     int rv = client.Connect(remote_address);
    457     if (tests[i].may_fail && rv == ERR_ADDRESS_UNREACHABLE) {
    458       // Connect() may return ERR_ADDRESS_UNREACHABLE for IPv6
    459       // addresses if IPv6 is not configured.
    460       continue;
    461     }
    462 
    463     EXPECT_LE(ERR_IO_PENDING, rv);
    464 
    465     IPEndPoint fetched_local_address;
    466     rv = client.GetLocalAddress(&fetched_local_address);
    467     EXPECT_EQ(OK, rv);
    468 
    469     // TODO(mbelshe): figure out how to verify the IP and port.
    470     //                The port is dynamically generated by the udp stack.
    471     //                The IP is the real IP of the client, not necessarily
    472     //                loopback.
    473     //EXPECT_EQ(local_address.address(), fetched_local_address.address());
    474 
    475     IPEndPoint fetched_remote_address;
    476     rv = client.GetPeerAddress(&fetched_remote_address);
    477     EXPECT_EQ(OK, rv);
    478 
    479     EXPECT_EQ(remote_address, fetched_remote_address);
    480   }
    481 }
    482 
    483 TEST_F(UDPSocketTest, ServerGetLocalAddress) {
    484   IPEndPoint bind_address;
    485   CreateUDPAddress("127.0.0.1", 0, &bind_address);
    486   UDPServerSocket server(NULL, NetLog::Source());
    487   int rv = server.Listen(bind_address);
    488   EXPECT_EQ(OK, rv);
    489 
    490   IPEndPoint local_address;
    491   rv = server.GetLocalAddress(&local_address);
    492   EXPECT_EQ(rv, 0);
    493 
    494   // Verify that port was allocated.
    495   EXPECT_GT(local_address.port(), 0);
    496   EXPECT_EQ(local_address.address(), bind_address.address());
    497 }
    498 
    499 TEST_F(UDPSocketTest, ServerGetPeerAddress) {
    500   IPEndPoint bind_address;
    501   CreateUDPAddress("127.0.0.1", 0, &bind_address);
    502   UDPServerSocket server(NULL, NetLog::Source());
    503   int rv = server.Listen(bind_address);
    504   EXPECT_EQ(OK, rv);
    505 
    506   IPEndPoint peer_address;
    507   rv = server.GetPeerAddress(&peer_address);
    508   EXPECT_EQ(rv, ERR_SOCKET_NOT_CONNECTED);
    509 }
    510 
    511 // Close the socket while read is pending.
    512 TEST_F(UDPSocketTest, CloseWithPendingRead) {
    513   IPEndPoint bind_address;
    514   CreateUDPAddress("127.0.0.1", 0, &bind_address);
    515   UDPServerSocket server(NULL, NetLog::Source());
    516   int rv = server.Listen(bind_address);
    517   EXPECT_EQ(OK, rv);
    518 
    519   TestCompletionCallback callback;
    520   IPEndPoint from;
    521   rv = server.RecvFrom(buffer_.get(), kMaxRead, &from, callback.callback());
    522   EXPECT_EQ(rv, ERR_IO_PENDING);
    523 
    524   server.Close();
    525 
    526   EXPECT_FALSE(callback.have_result());
    527 }
    528 
    529 #if defined(OS_ANDROID)
    530 // Some Android devices do not support multicast socket.
    531 // The ones supporting multicast need WifiManager.MulitcastLock to enable it.
    532 // http://goo.gl/jjAk9
    533 #define MAYBE_JoinMulticastGroup DISABLED_JoinMulticastGroup
    534 #else
    535 #define MAYBE_JoinMulticastGroup JoinMulticastGroup
    536 #endif  // defined(OS_ANDROID)
    537 
    538 TEST_F(UDPSocketTest, MAYBE_JoinMulticastGroup) {
    539   const int kPort = 9999;
    540   const char* const kGroup = "237.132.100.17";
    541 
    542   IPEndPoint bind_address;
    543   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
    544   IPAddressNumber group_ip;
    545   EXPECT_TRUE(ParseIPLiteralToNumber(kGroup, &group_ip));
    546 
    547   UDPSocket socket(DatagramSocket::DEFAULT_BIND,
    548                    RandIntCallback(),
    549                    NULL,
    550                    NetLog::Source());
    551   EXPECT_EQ(OK, socket.Bind(bind_address));
    552   EXPECT_EQ(OK, socket.JoinGroup(group_ip));
    553   // Joining group multiple times.
    554   EXPECT_NE(OK, socket.JoinGroup(group_ip));
    555   EXPECT_EQ(OK, socket.LeaveGroup(group_ip));
    556   // Leaving group multiple times.
    557   EXPECT_NE(OK, socket.LeaveGroup(group_ip));
    558 
    559   socket.Close();
    560 }
    561 
    562 TEST_F(UDPSocketTest, MulticastOptions) {
    563   const int kPort = 9999;
    564   IPEndPoint bind_address;
    565   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
    566 
    567   UDPSocket socket(DatagramSocket::DEFAULT_BIND,
    568                    RandIntCallback(),
    569                    NULL,
    570                    NetLog::Source());
    571   // Before binding.
    572   EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(false));
    573   EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(true));
    574   EXPECT_EQ(OK, socket.SetMulticastTimeToLive(0));
    575   EXPECT_EQ(OK, socket.SetMulticastTimeToLive(3));
    576   EXPECT_NE(OK, socket.SetMulticastTimeToLive(-1));
    577 
    578   EXPECT_EQ(OK, socket.Bind(bind_address));
    579 
    580   socket.Close();
    581 }
    582 
    583 }  // namespace
    584 
    585 }  // namespace net
    586