net/dns/mdns_client_unittest.cc

   1 // Copyright 2013 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 <queue>
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "net/base/rand_callback.h"
  10 #include "net/base/test_completion_callback.h"
  11 #include "net/dns/mdns_client_impl.h"
  12 #include "net/dns/mock_mdns_socket_factory.h"
  13 #include "net/dns/record_rdata.h"
  14 #include "net/udp/udp_client_socket.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using ::testing::Invoke;
  19 using ::testing::InvokeWithoutArgs;
  20 using ::testing::StrictMock;
  21 using ::testing::NiceMock;
  22 using ::testing::Exactly;
  23 using ::testing::Return;
  24 using ::testing::SaveArg;
  25 using ::testing::_;
  26
  27 namespace net {
  28
  29 namespace {
  30
  31 const uint8 kSamplePacket1[] = {
  32   // Header
  33   0x00, 0x00,               // ID is zeroed out
  34   0x81, 0x80,               // Standard query response, RA, no error
  35   0x00, 0x00,               // No questions (for simplicity)
  36   0x00, 0x02,               // 2 RRs (answers)
  37   0x00, 0x00,               // 0 authority RRs
  38   0x00, 0x00,               // 0 additional RRs
  39
  40   // Answer 1
  41   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
  42   0x04, '_', 't', 'c', 'p',
  43   0x05, 'l', 'o', 'c', 'a', 'l',
  44   0x00,
  45   0x00, 0x0c,        // TYPE is PTR.
  46   0x00, 0x01,        // CLASS is IN.
  47   0x00, 0x00,        // TTL (4 bytes) is 1 second;
  48   0x00, 0x01,
  49   0x00, 0x08,        // RDLENGTH is 8 bytes.
  50   0x05, 'h', 'e', 'l', 'l', 'o',
  51   0xc0, 0x0c,
  52
  53   // Answer 2
  54   0x08, '_', 'p', 'r', 'i', 'n', 't', 'e', 'r',
  55   0xc0, 0x14,         // Pointer to "._tcp.local"
  56   0x00, 0x0c,        // TYPE is PTR.
  57   0x00, 0x01,        // CLASS is IN.
  58   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 49 seconds.
  59   0x24, 0x75,
  60   0x00, 0x08,        // RDLENGTH is 8 bytes.
  61   0x05, 'h', 'e', 'l', 'l', 'o',
  62   0xc0, 0x32
  63 };
  64
  65 const uint8 kCorruptedPacketBadQuestion[] = {
  66   // Header
  67   0x00, 0x00,               // ID is zeroed out
  68   0x81, 0x80,               // Standard query response, RA, no error
  69   0x00, 0x01,               // One question
  70   0x00, 0x02,               // 2 RRs (answers)
  71   0x00, 0x00,               // 0 authority RRs
  72   0x00, 0x00,               // 0 additional RRs
  73
  74   // Question is corrupted and cannot be read.
  75   0x99, 'h', 'e', 'l', 'l', 'o',
  76   0x00,
  77   0x00, 0x00,
  78   0x00, 0x00,
  79
  80   // Answer 1
  81   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
  82   0x04, '_', 't', 'c', 'p',
  83   0x05, 'l', 'o', 'c', 'a', 'l',
  84   0x00,
  85   0x00, 0x0c,        // TYPE is PTR.
  86   0x00, 0x01,        // CLASS is IN.
  87   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
  88   0x24, 0x74,
  89   0x00, 0x99,        // RDLENGTH is impossible
  90   0x05, 'h', 'e', 'l', 'l', 'o',
  91   0xc0, 0x0c,
  92
  93   // Answer 2
  94   0x08, '_', 'p', 'r',  // Useless trailing data.
  95 };
  96
  97 const uint8 kCorruptedPacketUnsalvagable[] = {
  98   // Header
  99   0x00, 0x00,               // ID is zeroed out
 100   0x81, 0x80,               // Standard query response, RA, no error
 101   0x00, 0x00,               // No questions (for simplicity)
 102   0x00, 0x02,               // 2 RRs (answers)
 103   0x00, 0x00,               // 0 authority RRs
 104   0x00, 0x00,               // 0 additional RRs
 105
 106   // Answer 1
 107   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 108   0x04, '_', 't', 'c', 'p',
 109   0x05, 'l', 'o', 'c', 'a', 'l',
 110   0x00,
 111   0x00, 0x0c,        // TYPE is PTR.
 112   0x00, 0x01,        // CLASS is IN.
 113   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
 114   0x24, 0x74,
 115   0x00, 0x99,        // RDLENGTH is impossible
 116   0x05, 'h', 'e', 'l', 'l', 'o',
 117   0xc0, 0x0c,
 118
 119   // Answer 2
 120   0x08, '_', 'p', 'r',  // Useless trailing data.
 121 };
 122
 123 const uint8 kCorruptedPacketDoubleRecord[] = {
 124   // Header
 125   0x00, 0x00,               // ID is zeroed out
 126   0x81, 0x80,               // Standard query response, RA, no error
 127   0x00, 0x00,               // No questions (for simplicity)
 128   0x00, 0x02,               // 2 RRs (answers)
 129   0x00, 0x00,               // 0 authority RRs
 130   0x00, 0x00,               // 0 additional RRs
 131
 132   // Answer 1
 133   0x06, 'p', 'r', 'i', 'v', 'e', 't',
 134   0x05, 'l', 'o', 'c', 'a', 'l',
 135   0x00,
 136   0x00, 0x01,        // TYPE is A.
 137   0x00, 0x01,        // CLASS is IN.
 138   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
 139   0x24, 0x74,
 140   0x00, 0x04,        // RDLENGTH is 4
 141   0x05, 0x03,
 142   0xc0, 0x0c,
 143
 144   // Answer 2 -- Same key
 145   0x06, 'p', 'r', 'i', 'v', 'e', 't',
 146   0x05, 'l', 'o', 'c', 'a', 'l',
 147   0x00,
 148   0x00, 0x01,        // TYPE is A.
 149   0x00, 0x01,        // CLASS is IN.
 150   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
 151   0x24, 0x74,
 152   0x00, 0x04,        // RDLENGTH is 4
 153   0x02, 0x03,
 154   0x04, 0x05,
 155 };
 156
 157 const uint8 kCorruptedPacketSalvagable[] = {
 158   // Header
 159   0x00, 0x00,               // ID is zeroed out
 160   0x81, 0x80,               // Standard query response, RA, no error
 161   0x00, 0x00,               // No questions (for simplicity)
 162   0x00, 0x02,               // 2 RRs (answers)
 163   0x00, 0x00,               // 0 authority RRs
 164   0x00, 0x00,               // 0 additional RRs
 165
 166   // Answer 1
 167   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 168   0x04, '_', 't', 'c', 'p',
 169   0x05, 'l', 'o', 'c', 'a', 'l',
 170   0x00,
 171   0x00, 0x0c,        // TYPE is PTR.
 172   0x00, 0x01,        // CLASS is IN.
 173   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
 174   0x24, 0x74,
 175   0x00, 0x08,        // RDLENGTH is 8 bytes.
 176   0x99, 'h', 'e', 'l', 'l', 'o',   // Bad RDATA format.
 177   0xc0, 0x0c,
 178
 179   // Answer 2
 180   0x08, '_', 'p', 'r', 'i', 'n', 't', 'e', 'r',
 181   0xc0, 0x14,         // Pointer to "._tcp.local"
 182   0x00, 0x0c,        // TYPE is PTR.
 183   0x00, 0x01,        // CLASS is IN.
 184   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 49 seconds.
 185   0x24, 0x75,
 186   0x00, 0x08,        // RDLENGTH is 8 bytes.
 187   0x05, 'h', 'e', 'l', 'l', 'o',
 188   0xc0, 0x32
 189 };
 190
 191 const uint8 kSamplePacket2[] = {
 192   // Header
 193   0x00, 0x00,               // ID is zeroed out
 194   0x81, 0x80,               // Standard query response, RA, no error
 195   0x00, 0x00,               // No questions (for simplicity)
 196   0x00, 0x02,               // 2 RRs (answers)
 197   0x00, 0x00,               // 0 authority RRs
 198   0x00, 0x00,               // 0 additional RRs
 199
 200   // Answer 1
 201   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 202   0x04, '_', 't', 'c', 'p',
 203   0x05, 'l', 'o', 'c', 'a', 'l',
 204   0x00,
 205   0x00, 0x0c,        // TYPE is PTR.
 206   0x00, 0x01,        // CLASS is IN.
 207   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
 208   0x24, 0x74,
 209   0x00, 0x08,        // RDLENGTH is 8 bytes.
 210   0x05, 'z', 'z', 'z', 'z', 'z',
 211   0xc0, 0x0c,
 212
 213   // Answer 2
 214   0x08, '_', 'p', 'r', 'i', 'n', 't', 'e', 'r',
 215   0xc0, 0x14,         // Pointer to "._tcp.local"
 216   0x00, 0x0c,        // TYPE is PTR.
 217   0x00, 0x01,        // CLASS is IN.
 218   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
 219   0x24, 0x74,
 220   0x00, 0x08,        // RDLENGTH is 8 bytes.
 221   0x05, 'z', 'z', 'z', 'z', 'z',
 222   0xc0, 0x32
 223 };
 224
 225 const uint8 kQueryPacketPrivet[] = {
 226   // Header
 227   0x00, 0x00,               // ID is zeroed out
 228   0x00, 0x00,               // No flags.
 229   0x00, 0x01,               // One question.
 230   0x00, 0x00,               // 0 RRs (answers)
 231   0x00, 0x00,               // 0 authority RRs
 232   0x00, 0x00,               // 0 additional RRs
 233
 234   // Question
 235   // This part is echoed back from the respective query.
 236   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 237   0x04, '_', 't', 'c', 'p',
 238   0x05, 'l', 'o', 'c', 'a', 'l',
 239   0x00,
 240   0x00, 0x0c,        // TYPE is PTR.
 241   0x00, 0x01,        // CLASS is IN.
 242 };
 243
 244 const uint8 kQueryPacketPrivetA[] = {
 245   // Header
 246   0x00, 0x00,               // ID is zeroed out
 247   0x00, 0x00,               // No flags.
 248   0x00, 0x01,               // One question.
 249   0x00, 0x00,               // 0 RRs (answers)
 250   0x00, 0x00,               // 0 authority RRs
 251   0x00, 0x00,               // 0 additional RRs
 252
 253   // Question
 254   // This part is echoed back from the respective query.
 255   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 256   0x04, '_', 't', 'c', 'p',
 257   0x05, 'l', 'o', 'c', 'a', 'l',
 258   0x00,
 259   0x00, 0x01,        // TYPE is A.
 260   0x00, 0x01,        // CLASS is IN.
 261 };
 262
 263 const uint8 kSamplePacketAdditionalOnly[] = {
 264   // Header
 265   0x00, 0x00,               // ID is zeroed out
 266   0x81, 0x80,               // Standard query response, RA, no error
 267   0x00, 0x00,               // No questions (for simplicity)
 268   0x00, 0x00,               // 2 RRs (answers)
 269   0x00, 0x00,               // 0 authority RRs
 270   0x00, 0x01,               // 0 additional RRs
 271
 272   // Answer 1
 273   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 274   0x04, '_', 't', 'c', 'p',
 275   0x05, 'l', 'o', 'c', 'a', 'l',
 276   0x00,
 277   0x00, 0x0c,        // TYPE is PTR.
 278   0x00, 0x01,        // CLASS is IN.
 279   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
 280   0x24, 0x74,
 281   0x00, 0x08,        // RDLENGTH is 8 bytes.
 282   0x05, 'h', 'e', 'l', 'l', 'o',
 283   0xc0, 0x0c,
 284 };
 285
 286 const uint8 kSamplePacketNsec[] = {
 287   // Header
 288   0x00, 0x00,               // ID is zeroed out
 289   0x81, 0x80,               // Standard query response, RA, no error
 290   0x00, 0x00,               // No questions (for simplicity)
 291   0x00, 0x01,               // 1 RR (answers)
 292   0x00, 0x00,               // 0 authority RRs
 293   0x00, 0x00,               // 0 additional RRs
 294
 295   // Answer 1
 296   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 297   0x04, '_', 't', 'c', 'p',
 298   0x05, 'l', 'o', 'c', 'a', 'l',
 299   0x00,
 300   0x00, 0x2f,        // TYPE is NSEC.
 301   0x00, 0x01,        // CLASS is IN.
 302   0x00, 0x01,        // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
 303   0x24, 0x74,
 304   0x00, 0x06,        // RDLENGTH is 6 bytes.
 305   0xc0, 0x0c,
 306   0x00, 0x02, 0x00, 0x08  // Only A record present
 307 };
 308
 309 const uint8 kSamplePacketAPrivet[] = {
 310   // Header
 311   0x00, 0x00,               // ID is zeroed out
 312   0x81, 0x80,               // Standard query response, RA, no error
 313   0x00, 0x00,               // No questions (for simplicity)
 314   0x00, 0x01,               // 1 RR (answers)
 315   0x00, 0x00,               // 0 authority RRs
 316   0x00, 0x00,               // 0 additional RRs
 317
 318   // Answer 1
 319   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 320   0x04, '_', 't', 'c', 'p',
 321   0x05, 'l', 'o', 'c', 'a', 'l',
 322   0x00,
 323   0x00, 0x01,        // TYPE is A.
 324   0x00, 0x01,        // CLASS is IN.
 325   0x00, 0x00,        // TTL (4 bytes) is 5 seconds
 326   0x00, 0x05,
 327   0x00, 0x04,        // RDLENGTH is 4 bytes.
 328   0xc0, 0x0c,
 329   0x00, 0x02,
 330 };
 331
 332 const uint8 kSamplePacketGoodbye[] = {
 333   // Header
 334   0x00, 0x00,               // ID is zeroed out
 335   0x81, 0x80,               // Standard query response, RA, no error
 336   0x00, 0x00,               // No questions (for simplicity)
 337   0x00, 0x01,               // 2 RRs (answers)
 338   0x00, 0x00,               // 0 authority RRs
 339   0x00, 0x00,               // 0 additional RRs
 340
 341   // Answer 1
 342   0x07, '_', 'p', 'r', 'i', 'v', 'e', 't',
 343   0x04, '_', 't', 'c', 'p',
 344   0x05, 'l', 'o', 'c', 'a', 'l',
 345   0x00,
 346   0x00, 0x0c,        // TYPE is PTR.
 347   0x00, 0x01,        // CLASS is IN.
 348   0x00, 0x00,        // TTL (4 bytes) is zero;
 349   0x00, 0x00,
 350   0x00, 0x08,        // RDLENGTH is 8 bytes.
 351   0x05, 'z', 'z', 'z', 'z', 'z',
 352   0xc0, 0x0c,
 353 };
 354
 355 std::string MakeString(const uint8* data, unsigned size) {
 356   return std::string(reinterpret_cast<const char*>(data), size);
 357 }
 358
 359 class PtrRecordCopyContainer {
 360  public:
 361   PtrRecordCopyContainer() {}
 362   ~PtrRecordCopyContainer() {}
 363
 364   bool is_set() const { return set_; }
 365
 366   void SaveWithDummyArg(int unused, const RecordParsed* value) {
 367     Save(value);
 368   }
 369
 370   void Save(const RecordParsed* value) {
 371     set_ = true;
 372     name_ = value->name();
 373     ptrdomain_ = value->rdata<PtrRecordRdata>()->ptrdomain();
 374     ttl_ = value->ttl();
 375   }
 376
 377   bool IsRecordWith(std::string name, std::string ptrdomain) {
 378     return set_ && name_ == name && ptrdomain_ == ptrdomain;
 379   }
 380
 381   const std::string& name() { return name_; }
 382   const std::string& ptrdomain() { return ptrdomain_; }
 383   int ttl() { return ttl_; }
 384
 385  private:
 386   bool set_;
 387   std::string name_;
 388   std::string ptrdomain_;
 389   int ttl_;
 390 };
 391
 392 class MDnsTest : public ::testing::Test {
 393  public:
 394   virtual void SetUp() OVERRIDE;
 395   void DeleteTransaction();
 396   void DeleteBothListeners();
 397   void RunFor(base::TimeDelta time_period);
 398   void Stop();
 399
 400   MOCK_METHOD2(MockableRecordCallback, void(MDnsTransaction::Result result,
 401                                             const RecordParsed* record));
 402
 403   MOCK_METHOD2(MockableRecordCallback2, void(MDnsTransaction::Result result,
 404                                              const RecordParsed* record));
 405
 406
 407  protected:
 408   void ExpectPacket(const uint8* packet, unsigned size);
 409   void SimulatePacketReceive(const uint8* packet, unsigned size);
 410
 411   MDnsClientImpl test_client_;
 412   IPEndPoint mdns_ipv4_endpoint_;
 413   StrictMock<MockMDnsSocketFactory> socket_factory_;
 414
 415   // Transactions and listeners that can be deleted by class methods for
 416   // reentrancy tests.
 417   scoped_ptr<MDnsTransaction> transaction_;
 418   scoped_ptr<MDnsListener> listener1_;
 419   scoped_ptr<MDnsListener> listener2_;
 420 };
 421
 422 class MockListenerDelegate : public MDnsListener::Delegate {
 423  public:
 424   MOCK_METHOD2(OnRecordUpdate,
 425                void(MDnsListener::UpdateType update,
 426                     const RecordParsed* records));
 427   MOCK_METHOD2(OnNsecRecord, void(const std::string&, unsigned));
 428   MOCK_METHOD0(OnCachePurged, void());
 429 };
 430
 431 void MDnsTest::SetUp() {
 432   test_client_.StartListening(&socket_factory_);
 433 }
 434
 435 void MDnsTest::SimulatePacketReceive(const uint8* packet, unsigned size) {
 436   socket_factory_.SimulateReceive(packet, size);
 437 }
 438
 439 void MDnsTest::ExpectPacket(const uint8* packet, unsigned size) {
 440   EXPECT_CALL(socket_factory_, OnSendTo(MakeString(packet, size)))
 441       .Times(2);
 442 }
 443
 444 void MDnsTest::DeleteTransaction() {
 445   transaction_.reset();
 446 }
 447
 448 void MDnsTest::DeleteBothListeners() {
 449   listener1_.reset();
 450   listener2_.reset();
 451 }
 452
 453 void MDnsTest::RunFor(base::TimeDelta time_period) {
 454   base::CancelableCallback<void()> callback(base::Bind(&MDnsTest::Stop,
 455                                                        base::Unretained(this)));
 456   base::MessageLoop::current()->PostDelayedTask(
 457       FROM_HERE, callback.callback(), time_period);
 458
 459   base::MessageLoop::current()->Run();
 460   callback.Cancel();
 461 }
 462
 463 void MDnsTest::Stop() {
 464   base::MessageLoop::current()->Quit();
 465 }
 466
 467 TEST_F(MDnsTest, PassiveListeners) {
 468   StrictMock<MockListenerDelegate> delegate_privet;
 469   StrictMock<MockListenerDelegate> delegate_printer;
 470
 471   PtrRecordCopyContainer record_privet;
 472   PtrRecordCopyContainer record_printer;
 473
 474   scoped_ptr<MDnsListener> listener_privet =
 475       test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
 476                                   &delegate_privet);
 477   scoped_ptr<MDnsListener> listener_printer =
 478       test_client_.CreateListener(dns_protocol::kTypePTR, "_printer._tcp.local",
 479                                   &delegate_printer);
 480
 481   ASSERT_TRUE(listener_privet->Start());
 482   ASSERT_TRUE(listener_printer->Start());
 483
 484   // Send the same packet twice to ensure no records are double-counted.
 485
 486   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
 487       .Times(Exactly(1))
 488       .WillOnce(Invoke(
 489           &record_privet,
 490           &PtrRecordCopyContainer::SaveWithDummyArg));
 491
 492   EXPECT_CALL(delegate_printer, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
 493       .Times(Exactly(1))
 494       .WillOnce(Invoke(
 495           &record_printer,
 496           &PtrRecordCopyContainer::SaveWithDummyArg));
 497
 498
 499   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 500   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 501
 502   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
 503                                          "hello._privet._tcp.local"));
 504
 505   EXPECT_TRUE(record_printer.IsRecordWith("_printer._tcp.local",
 506                                           "hello._printer._tcp.local"));
 507
 508   listener_privet.reset();
 509   listener_printer.reset();
 510 }
 511
 512 TEST_F(MDnsTest, PassiveListenersCacheCleanup) {
 513   StrictMock<MockListenerDelegate> delegate_privet;
 514
 515   PtrRecordCopyContainer record_privet;
 516   PtrRecordCopyContainer record_privet2;
 517
 518   scoped_ptr<MDnsListener> listener_privet =
 519       test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
 520                                   &delegate_privet);
 521
 522   ASSERT_TRUE(listener_privet->Start());
 523
 524   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
 525       .Times(Exactly(1))
 526       .WillOnce(Invoke(
 527           &record_privet,
 528           &PtrRecordCopyContainer::SaveWithDummyArg));
 529
 530   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 531
 532   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
 533                                          "hello._privet._tcp.local"));
 534
 535   // Expect record is removed when its TTL expires.
 536   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_REMOVED, _))
 537       .Times(Exactly(1))
 538       .WillOnce(DoAll(InvokeWithoutArgs(this, &MDnsTest::Stop),
 539                       Invoke(&record_privet2,
 540                              &PtrRecordCopyContainer::SaveWithDummyArg)));
 541
 542   RunFor(base::TimeDelta::FromSeconds(record_privet.ttl() + 1));
 543
 544   EXPECT_TRUE(record_privet2.IsRecordWith("_privet._tcp.local",
 545                                           "hello._privet._tcp.local"));
 546 }
 547
 548 TEST_F(MDnsTest, MalformedPacket) {
 549   StrictMock<MockListenerDelegate> delegate_printer;
 550
 551   PtrRecordCopyContainer record_printer;
 552
 553   scoped_ptr<MDnsListener> listener_printer =
 554       test_client_.CreateListener(dns_protocol::kTypePTR, "_printer._tcp.local",
 555                                   &delegate_printer);
 556
 557   ASSERT_TRUE(listener_printer->Start());
 558
 559   EXPECT_CALL(delegate_printer, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
 560       .Times(Exactly(1))
 561       .WillOnce(Invoke(
 562           &record_printer,
 563           &PtrRecordCopyContainer::SaveWithDummyArg));
 564
 565   // First, send unsalvagable packet to ensure we can deal with it.
 566   SimulatePacketReceive(kCorruptedPacketUnsalvagable,
 567                         sizeof(kCorruptedPacketUnsalvagable));
 568
 569   // Regression test: send a packet where the question cannot be read.
 570   SimulatePacketReceive(kCorruptedPacketBadQuestion,
 571                         sizeof(kCorruptedPacketBadQuestion));
 572
 573   // Then send salvagable packet to ensure we can extract useful records.
 574   SimulatePacketReceive(kCorruptedPacketSalvagable,
 575                         sizeof(kCorruptedPacketSalvagable));
 576
 577   EXPECT_TRUE(record_printer.IsRecordWith("_printer._tcp.local",
 578                                           "hello._printer._tcp.local"));
 579 }
 580
 581 TEST_F(MDnsTest, TransactionWithEmptyCache) {
 582   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 583
 584   scoped_ptr<MDnsTransaction> transaction_privet =
 585       test_client_.CreateTransaction(
 586           dns_protocol::kTypePTR, "_privet._tcp.local",
 587           MDnsTransaction::QUERY_NETWORK |
 588           MDnsTransaction::QUERY_CACHE |
 589           MDnsTransaction::SINGLE_RESULT,
 590           base::Bind(&MDnsTest::MockableRecordCallback,
 591                      base::Unretained(this)));
 592
 593   ASSERT_TRUE(transaction_privet->Start());
 594
 595   PtrRecordCopyContainer record_privet;
 596
 597   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
 598       .Times(Exactly(1))
 599       .WillOnce(Invoke(&record_privet,
 600                        &PtrRecordCopyContainer::SaveWithDummyArg));
 601
 602   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 603
 604   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
 605                                          "hello._privet._tcp.local"));
 606 }
 607
 608 TEST_F(MDnsTest, TransactionCacheOnlyNoResult) {
 609   scoped_ptr<MDnsTransaction> transaction_privet =
 610       test_client_.CreateTransaction(
 611           dns_protocol::kTypePTR, "_privet._tcp.local",
 612           MDnsTransaction::QUERY_CACHE |
 613           MDnsTransaction::SINGLE_RESULT,
 614           base::Bind(&MDnsTest::MockableRecordCallback,
 615                      base::Unretained(this)));
 616
 617   EXPECT_CALL(*this,
 618               MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS, _))
 619       .Times(Exactly(1));
 620
 621   ASSERT_TRUE(transaction_privet->Start());
 622 }
 623
 624 TEST_F(MDnsTest, TransactionWithCache) {
 625   // Listener to force the client to listen
 626   StrictMock<MockListenerDelegate> delegate_irrelevant;
 627   scoped_ptr<MDnsListener> listener_irrelevant =
 628       test_client_.CreateListener(dns_protocol::kTypeA,
 629                                   "codereview.chromium.local",
 630                                   &delegate_irrelevant);
 631
 632   ASSERT_TRUE(listener_irrelevant->Start());
 633
 634   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 635
 636
 637   PtrRecordCopyContainer record_privet;
 638
 639   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
 640       .WillOnce(Invoke(&record_privet,
 641                        &PtrRecordCopyContainer::SaveWithDummyArg));
 642
 643   scoped_ptr<MDnsTransaction> transaction_privet =
 644       test_client_.CreateTransaction(
 645           dns_protocol::kTypePTR, "_privet._tcp.local",
 646           MDnsTransaction::QUERY_NETWORK |
 647           MDnsTransaction::QUERY_CACHE |
 648           MDnsTransaction::SINGLE_RESULT,
 649           base::Bind(&MDnsTest::MockableRecordCallback,
 650                      base::Unretained(this)));
 651
 652   ASSERT_TRUE(transaction_privet->Start());
 653
 654   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
 655                                          "hello._privet._tcp.local"));
 656 }
 657
 658 TEST_F(MDnsTest, AdditionalRecords) {
 659   StrictMock<MockListenerDelegate> delegate_privet;
 660
 661   PtrRecordCopyContainer record_privet;
 662
 663   scoped_ptr<MDnsListener> listener_privet =
 664       test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
 665                                   &delegate_privet);
 666
 667   ASSERT_TRUE(listener_privet->Start());
 668
 669   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
 670       .Times(Exactly(1))
 671       .WillOnce(Invoke(
 672           &record_privet,
 673           &PtrRecordCopyContainer::SaveWithDummyArg));
 674
 675   SimulatePacketReceive(kSamplePacketAdditionalOnly,
 676                         sizeof(kSamplePacketAdditionalOnly));
 677
 678   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
 679                                          "hello._privet._tcp.local"));
 680 }
 681
 682 TEST_F(MDnsTest, TransactionTimeout) {
 683   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 684
 685   scoped_ptr<MDnsTransaction> transaction_privet =
 686       test_client_.CreateTransaction(
 687           dns_protocol::kTypePTR, "_privet._tcp.local",
 688           MDnsTransaction::QUERY_NETWORK |
 689           MDnsTransaction::QUERY_CACHE |
 690           MDnsTransaction::SINGLE_RESULT,
 691           base::Bind(&MDnsTest::MockableRecordCallback,
 692                      base::Unretained(this)));
 693
 694   ASSERT_TRUE(transaction_privet->Start());
 695
 696   EXPECT_CALL(*this,
 697               MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS, NULL))
 698       .Times(Exactly(1))
 699       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::Stop));
 700
 701   RunFor(base::TimeDelta::FromSeconds(4));
 702 }
 703
 704 TEST_F(MDnsTest, TransactionMultipleRecords) {
 705   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 706
 707   scoped_ptr<MDnsTransaction> transaction_privet =
 708       test_client_.CreateTransaction(
 709           dns_protocol::kTypePTR, "_privet._tcp.local",
 710           MDnsTransaction::QUERY_NETWORK |
 711           MDnsTransaction::QUERY_CACHE ,
 712           base::Bind(&MDnsTest::MockableRecordCallback,
 713                      base::Unretained(this)));
 714
 715   ASSERT_TRUE(transaction_privet->Start());
 716
 717   PtrRecordCopyContainer record_privet;
 718   PtrRecordCopyContainer record_privet2;
 719
 720   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
 721       .Times(Exactly(2))
 722       .WillOnce(Invoke(&record_privet,
 723                        &PtrRecordCopyContainer::SaveWithDummyArg))
 724       .WillOnce(Invoke(&record_privet2,
 725                        &PtrRecordCopyContainer::SaveWithDummyArg));
 726
 727   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 728   SimulatePacketReceive(kSamplePacket2, sizeof(kSamplePacket2));
 729
 730   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
 731                                          "hello._privet._tcp.local"));
 732
 733   EXPECT_TRUE(record_privet2.IsRecordWith("_privet._tcp.local",
 734                                           "zzzzz._privet._tcp.local"));
 735
 736   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_DONE, NULL))
 737       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::Stop));
 738
 739   RunFor(base::TimeDelta::FromSeconds(4));
 740 }
 741
 742 TEST_F(MDnsTest, TransactionReentrantDelete) {
 743   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 744
 745   transaction_ = test_client_.CreateTransaction(
 746       dns_protocol::kTypePTR, "_privet._tcp.local",
 747       MDnsTransaction::QUERY_NETWORK |
 748       MDnsTransaction::QUERY_CACHE |
 749       MDnsTransaction::SINGLE_RESULT,
 750       base::Bind(&MDnsTest::MockableRecordCallback,
 751                  base::Unretained(this)));
 752
 753   ASSERT_TRUE(transaction_->Start());
 754
 755   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS,
 756                                             NULL))
 757       .Times(Exactly(1))
 758       .WillOnce(DoAll(InvokeWithoutArgs(this, &MDnsTest::DeleteTransaction),
 759                       InvokeWithoutArgs(this, &MDnsTest::Stop)));
 760
 761   RunFor(base::TimeDelta::FromSeconds(4));
 762
 763   EXPECT_EQ(NULL, transaction_.get());
 764 }
 765
 766 TEST_F(MDnsTest, TransactionReentrantDeleteFromCache) {
 767   StrictMock<MockListenerDelegate> delegate_irrelevant;
 768   scoped_ptr<MDnsListener> listener_irrelevant = test_client_.CreateListener(
 769       dns_protocol::kTypeA, "codereview.chromium.local",
 770       &delegate_irrelevant);
 771   ASSERT_TRUE(listener_irrelevant->Start());
 772
 773   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 774
 775   transaction_ = test_client_.CreateTransaction(
 776       dns_protocol::kTypePTR, "_privet._tcp.local",
 777       MDnsTransaction::QUERY_NETWORK |
 778       MDnsTransaction::QUERY_CACHE,
 779       base::Bind(&MDnsTest::MockableRecordCallback,
 780                  base::Unretained(this)));
 781
 782   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
 783       .Times(Exactly(1))
 784       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::DeleteTransaction));
 785
 786   ASSERT_TRUE(transaction_->Start());
 787
 788   EXPECT_EQ(NULL, transaction_.get());
 789 }
 790
 791 TEST_F(MDnsTest, TransactionReentrantCacheLookupStart) {
 792   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 793
 794   scoped_ptr<MDnsTransaction> transaction1 =
 795       test_client_.CreateTransaction(
 796           dns_protocol::kTypePTR, "_privet._tcp.local",
 797           MDnsTransaction::QUERY_NETWORK |
 798           MDnsTransaction::QUERY_CACHE |
 799           MDnsTransaction::SINGLE_RESULT,
 800           base::Bind(&MDnsTest::MockableRecordCallback,
 801                      base::Unretained(this)));
 802
 803   scoped_ptr<MDnsTransaction> transaction2 =
 804       test_client_.CreateTransaction(
 805           dns_protocol::kTypePTR, "_printer._tcp.local",
 806           MDnsTransaction::QUERY_CACHE |
 807           MDnsTransaction::SINGLE_RESULT,
 808           base::Bind(&MDnsTest::MockableRecordCallback2,
 809                      base::Unretained(this)));
 810
 811   EXPECT_CALL(*this, MockableRecordCallback2(MDnsTransaction::RESULT_RECORD,
 812                                              _))
 813       .Times(Exactly(1));
 814
 815   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD,
 816                                             _))
 817       .Times(Exactly(1))
 818       .WillOnce(IgnoreResult(InvokeWithoutArgs(transaction2.get(),
 819                                                &MDnsTransaction::Start)));
 820
 821   ASSERT_TRUE(transaction1->Start());
 822
 823   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 824 }
 825
 826 TEST_F(MDnsTest, GoodbyePacketNotification) {
 827   StrictMock<MockListenerDelegate> delegate_privet;
 828
 829   scoped_ptr<MDnsListener> listener_privet = test_client_.CreateListener(
 830       dns_protocol::kTypePTR, "_privet._tcp.local", &delegate_privet);
 831   ASSERT_TRUE(listener_privet->Start());
 832
 833   SimulatePacketReceive(kSamplePacketGoodbye, sizeof(kSamplePacketGoodbye));
 834
 835   RunFor(base::TimeDelta::FromSeconds(2));
 836 }
 837
 838 TEST_F(MDnsTest, GoodbyePacketRemoval) {
 839   StrictMock<MockListenerDelegate> delegate_privet;
 840
 841   scoped_ptr<MDnsListener> listener_privet =
 842       test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
 843                                   &delegate_privet);
 844   ASSERT_TRUE(listener_privet->Start());
 845
 846   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
 847       .Times(Exactly(1));
 848
 849   SimulatePacketReceive(kSamplePacket2, sizeof(kSamplePacket2));
 850
 851   SimulatePacketReceive(kSamplePacketGoodbye, sizeof(kSamplePacketGoodbye));
 852
 853   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_REMOVED, _))
 854       .Times(Exactly(1));
 855
 856   RunFor(base::TimeDelta::FromSeconds(2));
 857 }
 858
 859 // In order to reliably test reentrant listener deletes, we create two listeners
 860 // and have each of them delete both, so we're guaranteed to try and deliver a
 861 // callback to at least one deleted listener.
 862
 863 TEST_F(MDnsTest, ListenerReentrantDelete) {
 864   StrictMock<MockListenerDelegate> delegate_privet;
 865
 866   listener1_ = test_client_.CreateListener(dns_protocol::kTypePTR,
 867                                            "_privet._tcp.local",
 868                                            &delegate_privet);
 869
 870   listener2_ = test_client_.CreateListener(dns_protocol::kTypePTR,
 871                                            "_privet._tcp.local",
 872                                            &delegate_privet);
 873
 874   ASSERT_TRUE(listener1_->Start());
 875
 876   ASSERT_TRUE(listener2_->Start());
 877
 878   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
 879       .Times(Exactly(1))
 880       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::DeleteBothListeners));
 881
 882   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 883
 884   EXPECT_EQ(NULL, listener1_.get());
 885   EXPECT_EQ(NULL, listener2_.get());
 886 }
 887
 888 ACTION_P(SaveIPAddress, ip_container) {
 889   ::testing::StaticAssertTypeEq<const RecordParsed*, arg1_type>();
 890   ::testing::StaticAssertTypeEq<IPAddressNumber*, ip_container_type>();
 891
 892   *ip_container = arg1->template rdata<ARecordRdata>()->address();
 893 }
 894
 895 TEST_F(MDnsTest, DoubleRecordDisagreeing) {
 896   IPAddressNumber address;
 897   StrictMock<MockListenerDelegate> delegate_privet;
 898
 899   scoped_ptr<MDnsListener> listener_privet =
 900       test_client_.CreateListener(dns_protocol::kTypeA, "privet.local",
 901                                   &delegate_privet);
 902
 903   ASSERT_TRUE(listener_privet->Start());
 904
 905   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
 906       .Times(Exactly(1))
 907       .WillOnce(SaveIPAddress(&address));
 908
 909   SimulatePacketReceive(kCorruptedPacketDoubleRecord,
 910                         sizeof(kCorruptedPacketDoubleRecord));
 911
 912   EXPECT_EQ("2.3.4.5", IPAddressToString(address));
 913 }
 914
 915 TEST_F(MDnsTest, NsecWithListener) {
 916   StrictMock<MockListenerDelegate> delegate_privet;
 917   scoped_ptr<MDnsListener> listener_privet =
 918       test_client_.CreateListener(dns_protocol::kTypeA, "_privet._tcp.local",
 919                                   &delegate_privet);
 920
 921   // Test to make sure nsec callback is NOT called for PTR
 922   // (which is marked as existing).
 923   StrictMock<MockListenerDelegate> delegate_privet2;
 924   scoped_ptr<MDnsListener> listener_privet2 =
 925       test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
 926                                   &delegate_privet2);
 927
 928   ASSERT_TRUE(listener_privet->Start());
 929
 930   EXPECT_CALL(delegate_privet,
 931               OnNsecRecord("_privet._tcp.local", dns_protocol::kTypeA));
 932
 933   SimulatePacketReceive(kSamplePacketNsec,
 934                         sizeof(kSamplePacketNsec));
 935 }
 936
 937 TEST_F(MDnsTest, NsecWithTransactionFromNetwork) {
 938   scoped_ptr<MDnsTransaction> transaction_privet =
 939       test_client_.CreateTransaction(
 940           dns_protocol::kTypeA, "_privet._tcp.local",
 941           MDnsTransaction::QUERY_NETWORK |
 942           MDnsTransaction::QUERY_CACHE |
 943           MDnsTransaction::SINGLE_RESULT,
 944           base::Bind(&MDnsTest::MockableRecordCallback,
 945                      base::Unretained(this)));
 946
 947   EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(2);
 948
 949   ASSERT_TRUE(transaction_privet->Start());
 950
 951   EXPECT_CALL(*this,
 952               MockableRecordCallback(MDnsTransaction::RESULT_NSEC, NULL));
 953
 954   SimulatePacketReceive(kSamplePacketNsec,
 955                         sizeof(kSamplePacketNsec));
 956 }
 957
 958 TEST_F(MDnsTest, NsecWithTransactionFromCache) {
 959   // Force mDNS to listen.
 960   StrictMock<MockListenerDelegate> delegate_irrelevant;
 961   scoped_ptr<MDnsListener> listener_irrelevant =
 962       test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
 963                                   &delegate_irrelevant);
 964   listener_irrelevant->Start();
 965
 966   SimulatePacketReceive(kSamplePacketNsec,
 967                         sizeof(kSamplePacketNsec));
 968
 969   EXPECT_CALL(*this,
 970               MockableRecordCallback(MDnsTransaction::RESULT_NSEC, NULL));
 971
 972   scoped_ptr<MDnsTransaction> transaction_privet_a =
 973       test_client_.CreateTransaction(
 974           dns_protocol::kTypeA, "_privet._tcp.local",
 975           MDnsTransaction::QUERY_NETWORK |
 976           MDnsTransaction::QUERY_CACHE |
 977           MDnsTransaction::SINGLE_RESULT,
 978           base::Bind(&MDnsTest::MockableRecordCallback,
 979                      base::Unretained(this)));
 980
 981   ASSERT_TRUE(transaction_privet_a->Start());
 982
 983   // Test that a PTR transaction does NOT consider the same NSEC record to be a
 984   // valid answer to the query
 985
 986   scoped_ptr<MDnsTransaction> transaction_privet_ptr =
 987       test_client_.CreateTransaction(
 988           dns_protocol::kTypePTR, "_privet._tcp.local",
 989           MDnsTransaction::QUERY_NETWORK |
 990           MDnsTransaction::QUERY_CACHE |
 991           MDnsTransaction::SINGLE_RESULT,
 992           base::Bind(&MDnsTest::MockableRecordCallback,
 993                      base::Unretained(this)));
 994
 995   EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(2);
 996
 997   ASSERT_TRUE(transaction_privet_ptr->Start());
 998 }
 999
1000 TEST_F(MDnsTest, NsecConflictRemoval) {
1001   StrictMock<MockListenerDelegate> delegate_privet;
1002   scoped_ptr<MDnsListener> listener_privet =
1003       test_client_.CreateListener(dns_protocol::kTypeA, "_privet._tcp.local",
1004                                   &delegate_privet);
1005
1006   ASSERT_TRUE(listener_privet->Start());
1007
1008   const RecordParsed* record1;
1009   const RecordParsed* record2;
1010
1011   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
1012       .WillOnce(SaveArg<1>(&record1));
1013
1014   SimulatePacketReceive(kSamplePacketAPrivet,
1015                         sizeof(kSamplePacketAPrivet));
1016
1017   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_REMOVED, _))
1018       .WillOnce(SaveArg<1>(&record2));
1019
1020   EXPECT_CALL(delegate_privet,
1021               OnNsecRecord("_privet._tcp.local", dns_protocol::kTypeA));
1022
1023   SimulatePacketReceive(kSamplePacketNsec,
1024                         sizeof(kSamplePacketNsec));
1025
1026   EXPECT_EQ(record1, record2);
1027 }
1028
1029
1030 TEST_F(MDnsTest, RefreshQuery) {
1031   StrictMock<MockListenerDelegate> delegate_privet;
1032   scoped_ptr<MDnsListener> listener_privet =
1033       test_client_.CreateListener(dns_protocol::kTypeA, "_privet._tcp.local",
1034                                   &delegate_privet);
1035
1036   listener_privet->SetActiveRefresh(true);
1037   ASSERT_TRUE(listener_privet->Start());
1038
1039   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _));
1040
1041   SimulatePacketReceive(kSamplePacketAPrivet,
1042                         sizeof(kSamplePacketAPrivet));
1043
1044   // Expecting 2 calls (one for ipv4 and one for ipv6) for each of the 2
1045   // scheduled refresh queries.
1046   EXPECT_CALL(socket_factory_, OnSendTo(
1047       MakeString(kQueryPacketPrivetA, sizeof(kQueryPacketPrivetA))))
1048       .Times(4);
1049
1050   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_REMOVED, _));
1051
1052   RunFor(base::TimeDelta::FromSeconds(6));
1053 }
1054
1055 // Note: These tests assume that the ipv4 socket will always be created first.
1056 // This is a simplifying assumption based on the way the code works now.
1057 class SimpleMockSocketFactory : public MDnsSocketFactory {
1058  public:
1059   virtual void CreateSockets(
1060       ScopedVector<DatagramServerSocket>* sockets) OVERRIDE {
1061     sockets->clear();
1062     sockets->swap(sockets_);
1063   }
1064
1065   void PushSocket(DatagramServerSocket* socket) {
1066     sockets_.push_back(socket);
1067   }
1068
1069  private:
1070   ScopedVector<DatagramServerSocket> sockets_;
1071 };
1072
1073 class MockMDnsConnectionDelegate : public MDnsConnection::Delegate {
1074  public:
1075   virtual void HandlePacket(DnsResponse* response, int size) {
1076     HandlePacketInternal(std::string(response->io_buffer()->data(), size));
1077   }
1078
1079   MOCK_METHOD1(HandlePacketInternal, void(std::string packet));
1080
1081   MOCK_METHOD1(OnConnectionError, void(int error));
1082 };
1083
1084 class MDnsConnectionTest : public ::testing::Test {
1085  public:
1086   MDnsConnectionTest() : connection_(&delegate_) {
1087   }
1088
1089  protected:
1090   // Follow successful connection initialization.
1091   virtual void SetUp() OVERRIDE {
1092     socket_ipv4_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV4);
1093     socket_ipv6_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV6);
1094     factory_.PushSocket(socket_ipv6_);
1095     factory_.PushSocket(socket_ipv4_);
1096     sample_packet_ = MakeString(kSamplePacket1, sizeof(kSamplePacket1));
1097     sample_buffer_ = new StringIOBuffer(sample_packet_);
1098   }
1099
1100   bool InitConnection() {
1101     return connection_.Init(&factory_);
1102   }
1103
1104   StrictMock<MockMDnsConnectionDelegate> delegate_;
1105
1106   MockMDnsDatagramServerSocket* socket_ipv4_;
1107   MockMDnsDatagramServerSocket* socket_ipv6_;
1108   SimpleMockSocketFactory factory_;
1109   MDnsConnection connection_;
1110   TestCompletionCallback callback_;
1111   std::string sample_packet_;
1112   scoped_refptr<IOBuffer> sample_buffer_;
1113 };
1114
1115 TEST_F(MDnsConnectionTest, ReceiveSynchronous) {
1116   socket_ipv6_->SetResponsePacket(sample_packet_);
1117   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
1118       .WillOnce(Return(ERR_IO_PENDING));
1119   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
1120       .WillOnce(
1121           Invoke(socket_ipv6_, &MockMDnsDatagramServerSocket::HandleRecvNow))
1122       .WillOnce(Return(ERR_IO_PENDING));
1123
1124   EXPECT_CALL(delegate_, HandlePacketInternal(sample_packet_));
1125   ASSERT_TRUE(InitConnection());
1126 }
1127
1128 TEST_F(MDnsConnectionTest, ReceiveAsynchronous) {
1129   socket_ipv6_->SetResponsePacket(sample_packet_);
1130
1131   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
1132       .WillOnce(Return(ERR_IO_PENDING));
1133   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
1134       .Times(2)
1135       .WillOnce(
1136            Invoke(socket_ipv6_, &MockMDnsDatagramServerSocket::HandleRecvLater))
1137       .WillOnce(Return(ERR_IO_PENDING));
1138
1139   ASSERT_TRUE(InitConnection());
1140
1141   EXPECT_CALL(delegate_, HandlePacketInternal(sample_packet_));
1142
1143   base::MessageLoop::current()->RunUntilIdle();
1144 }
1145
1146 TEST_F(MDnsConnectionTest, Error) {
1147   CompletionCallback callback;
1148
1149   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
1150       .WillOnce(Return(ERR_IO_PENDING));
1151   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
1152       .WillOnce(DoAll(SaveArg<3>(&callback), Return(ERR_IO_PENDING)));
1153
1154   ASSERT_TRUE(InitConnection());
1155
1156   EXPECT_CALL(delegate_, OnConnectionError(ERR_SOCKET_NOT_CONNECTED));
1157   callback.Run(ERR_SOCKET_NOT_CONNECTED);
1158   base::MessageLoop::current()->RunUntilIdle();
1159 }
1160
1161 class MDnsConnectionSendTest : public MDnsConnectionTest {
1162  protected:
1163   virtual void SetUp() OVERRIDE {
1164     MDnsConnectionTest::SetUp();
1165     EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
1166         .WillOnce(Return(ERR_IO_PENDING));
1167     EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
1168         .WillOnce(Return(ERR_IO_PENDING));
1169     EXPECT_TRUE(InitConnection());
1170   }
1171 };
1172
1173 TEST_F(MDnsConnectionSendTest, Send) {
1174   EXPECT_CALL(*socket_ipv4_,
1175               SendToInternal(sample_packet_, "224.0.0.251:5353", _));
1176   EXPECT_CALL(*socket_ipv6_,
1177               SendToInternal(sample_packet_, "[ff02::fb]:5353", _));
1178
1179   connection_.Send(sample_buffer_, sample_packet_.size());
1180 }
1181
1182 TEST_F(MDnsConnectionSendTest, SendError) {
1183   CompletionCallback callback;
1184
1185   EXPECT_CALL(*socket_ipv4_,
1186               SendToInternal(sample_packet_, "224.0.0.251:5353", _));
1187   EXPECT_CALL(*socket_ipv6_,
1188               SendToInternal(sample_packet_, "[ff02::fb]:5353", _))
1189       .WillOnce(DoAll(SaveArg<2>(&callback), Return(ERR_SOCKET_NOT_CONNECTED)));
1190
1191   connection_.Send(sample_buffer_, sample_packet_.size());
1192   EXPECT_CALL(delegate_, OnConnectionError(ERR_SOCKET_NOT_CONNECTED));
1193   base::MessageLoop::current()->RunUntilIdle();
1194 }
1195
1196 TEST_F(MDnsConnectionSendTest, SendQueued) {
1197   // Send data immediately.
1198   EXPECT_CALL(*socket_ipv4_,
1199               SendToInternal(sample_packet_, "224.0.0.251:5353", _))
1200       .Times(2)
1201       .WillRepeatedly(Return(OK));
1202
1203   CompletionCallback callback;
1204   // Delay sending data. Only the first call should be made.
1205   EXPECT_CALL(*socket_ipv6_,
1206               SendToInternal(sample_packet_, "[ff02::fb]:5353", _))
1207       .WillOnce(DoAll(SaveArg<2>(&callback), Return(ERR_IO_PENDING)));
1208
1209   connection_.Send(sample_buffer_, sample_packet_.size());
1210   connection_.Send(sample_buffer_, sample_packet_.size());
1211
1212   // The second IPv6 packed is not sent yet.
1213   EXPECT_CALL(*socket_ipv4_,
1214               SendToInternal(sample_packet_, "224.0.0.251:5353", _))
1215       .Times(0);
1216   // Expect call for the second IPv6 packed.
1217   EXPECT_CALL(*socket_ipv6_,
1218               SendToInternal(sample_packet_, "[ff02::fb]:5353", _))
1219       .WillOnce(Return(OK));
1220   callback.Run(OK);
1221 }
1222
1223 }  // namespace
1224
1225 }  // namespace net