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 "base/memory/scoped_ptr.h"
6#include "net/base/address_tracker_linux.h"
7
8#include <linux/if.h>
9
10#include <vector>
11
12#include "base/bind.h"
13#include "testing/gtest/include/gtest/gtest.h"
14
15#ifndef IFA_F_HOMEADDRESS
16#define IFA_F_HOMEADDRESS 0x10
17#endif
18
19namespace net {
20namespace internal {
21namespace {
22
23const int kTestInterfaceTun = 123;
24
25const char* TestGetInterfaceName(int interface_index) {
26  if (interface_index == kTestInterfaceTun)
27    return "tun0";
28  return "eth0";
29}
30
31}  // namespace
32
33typedef std::vector<char> Buffer;
34
35class AddressTrackerLinuxTest : public testing::Test {
36 protected:
37  AddressTrackerLinuxTest() {}
38
39  void InitializeAddressTracker(bool tracking) {
40    if (tracking) {
41      tracker_.reset(new AddressTrackerLinux(base::Bind(&base::DoNothing),
42                                             base::Bind(&base::DoNothing),
43                                             base::Bind(&base::DoNothing)));
44    } else {
45      tracker_.reset(new AddressTrackerLinux());
46    }
47    original_get_interface_name_ = tracker_->get_interface_name_;
48    tracker_->get_interface_name_ = TestGetInterfaceName;
49  }
50
51  bool HandleAddressMessage(const Buffer& buf) {
52    Buffer writable_buf = buf;
53    bool address_changed = false;
54    bool link_changed = false;
55    bool tunnel_changed = false;
56    tracker_->HandleMessage(&writable_buf[0], buf.size(),
57                           &address_changed, &link_changed, &tunnel_changed);
58    EXPECT_FALSE(link_changed);
59    return address_changed;
60  }
61
62  bool HandleLinkMessage(const Buffer& buf) {
63    Buffer writable_buf = buf;
64    bool address_changed = false;
65    bool link_changed = false;
66    bool tunnel_changed = false;
67    tracker_->HandleMessage(&writable_buf[0], buf.size(),
68                           &address_changed, &link_changed, &tunnel_changed);
69    EXPECT_FALSE(address_changed);
70    return link_changed;
71  }
72
73  bool HandleTunnelMessage(const Buffer& buf) {
74    Buffer writable_buf = buf;
75    bool address_changed = false;
76    bool link_changed = false;
77    bool tunnel_changed = false;
78    tracker_->HandleMessage(&writable_buf[0], buf.size(),
79                           &address_changed, &link_changed, &tunnel_changed);
80    EXPECT_FALSE(address_changed);
81    return tunnel_changed;
82  }
83
84  AddressTrackerLinux::AddressMap GetAddressMap() {
85    return tracker_->GetAddressMap();
86  }
87
88  const base::hash_set<int> GetOnlineLinks() const {
89    return tracker_->GetOnlineLinks();
90  }
91
92  scoped_ptr<AddressTrackerLinux> tracker_;
93  AddressTrackerLinux::GetInterfaceNameFunction original_get_interface_name_;
94};
95
96namespace {
97
98class NetlinkMessage {
99 public:
100  explicit NetlinkMessage(uint16 type) : buffer_(NLMSG_HDRLEN) {
101    header()->nlmsg_type = type;
102    Align();
103  }
104
105  void AddPayload(const void* data, size_t length) {
106    CHECK_EQ(static_cast<size_t>(NLMSG_HDRLEN),
107             buffer_.size()) << "Payload must be added first";
108    Append(data, length);
109    Align();
110  }
111
112  void AddAttribute(uint16 type, const void* data, size_t length) {
113    struct nlattr attr;
114    attr.nla_len = NLA_HDRLEN + length;
115    attr.nla_type = type;
116    Append(&attr, sizeof(attr));
117    Align();
118    Append(data, length);
119    Align();
120  }
121
122  void AppendTo(Buffer* output) const {
123    CHECK_EQ(NLMSG_ALIGN(output->size()), output->size());
124    output->reserve(output->size() + NLMSG_LENGTH(buffer_.size()));
125    output->insert(output->end(), buffer_.begin(), buffer_.end());
126  }
127
128 private:
129  void Append(const void* data, size_t length) {
130    const char* chardata = reinterpret_cast<const char*>(data);
131    buffer_.insert(buffer_.end(), chardata, chardata + length);
132  }
133
134  void Align() {
135    header()->nlmsg_len = buffer_.size();
136    buffer_.insert(buffer_.end(), NLMSG_ALIGN(buffer_.size()) - buffer_.size(),
137                   0);
138    CHECK(NLMSG_OK(header(), buffer_.size()));
139  }
140
141  struct nlmsghdr* header() {
142    return reinterpret_cast<struct nlmsghdr*>(&buffer_[0]);
143  }
144
145  Buffer buffer_;
146};
147
148#define INFINITY_LIFE_TIME 0xFFFFFFFF
149
150void MakeAddrMessageWithCacheInfo(uint16 type,
151                                  uint8 flags,
152                                  uint8 family,
153                                  const IPAddressNumber& address,
154                                  const IPAddressNumber& local,
155                                  uint32 preferred_lifetime,
156                                  Buffer* output) {
157  NetlinkMessage nlmsg(type);
158  struct ifaddrmsg msg = {};
159  msg.ifa_family = family;
160  msg.ifa_flags = flags;
161  nlmsg.AddPayload(&msg, sizeof(msg));
162  if (address.size())
163    nlmsg.AddAttribute(IFA_ADDRESS, &address[0], address.size());
164  if (local.size())
165    nlmsg.AddAttribute(IFA_LOCAL, &local[0], local.size());
166  struct ifa_cacheinfo cache_info = {};
167  cache_info.ifa_prefered = preferred_lifetime;
168  cache_info.ifa_valid = INFINITY_LIFE_TIME;
169  nlmsg.AddAttribute(IFA_CACHEINFO, &cache_info, sizeof(cache_info));
170  nlmsg.AppendTo(output);
171}
172
173void MakeAddrMessage(uint16 type,
174                     uint8 flags,
175                     uint8 family,
176                     const IPAddressNumber& address,
177                     const IPAddressNumber& local,
178                     Buffer* output) {
179  MakeAddrMessageWithCacheInfo(type, flags, family, address, local,
180                               INFINITY_LIFE_TIME, output);
181}
182
183void MakeLinkMessage(uint16 type, uint32 flags, uint32 index, Buffer* output) {
184  NetlinkMessage nlmsg(type);
185  struct ifinfomsg msg = {};
186  msg.ifi_index = index;
187  msg.ifi_flags = flags;
188  nlmsg.AddPayload(&msg, sizeof(msg));
189  output->clear();
190  nlmsg.AppendTo(output);
191}
192
193const unsigned char kAddress0[] = { 127, 0, 0, 1 };
194const unsigned char kAddress1[] = { 10, 0, 0, 1 };
195const unsigned char kAddress2[] = { 192, 168, 0, 1 };
196const unsigned char kAddress3[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
197                                    0, 0, 0, 1 };
198
199TEST_F(AddressTrackerLinuxTest, NewAddress) {
200  InitializeAddressTracker(true);
201
202  const IPAddressNumber kEmpty;
203  const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
204  const IPAddressNumber kAddr1(kAddress1, kAddress1 + arraysize(kAddress1));
205  const IPAddressNumber kAddr2(kAddress2, kAddress2 + arraysize(kAddress2));
206  const IPAddressNumber kAddr3(kAddress3, kAddress3 + arraysize(kAddress3));
207
208  Buffer buffer;
209  MakeAddrMessage(RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty,
210                  &buffer);
211  EXPECT_TRUE(HandleAddressMessage(buffer));
212  AddressTrackerLinux::AddressMap map = GetAddressMap();
213  EXPECT_EQ(1u, map.size());
214  EXPECT_EQ(1u, map.count(kAddr0));
215  EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
216
217  buffer.clear();
218  MakeAddrMessage(RTM_NEWADDR, IFA_F_HOMEADDRESS, AF_INET, kAddr1, kAddr2,
219                  &buffer);
220  EXPECT_TRUE(HandleAddressMessage(buffer));
221  map = GetAddressMap();
222  EXPECT_EQ(2u, map.size());
223  EXPECT_EQ(1u, map.count(kAddr0));
224  EXPECT_EQ(1u, map.count(kAddr2));
225  EXPECT_EQ(IFA_F_HOMEADDRESS, map[kAddr2].ifa_flags);
226
227  buffer.clear();
228  MakeAddrMessage(RTM_NEWADDR, 0, AF_INET6, kEmpty, kAddr3, &buffer);
229  EXPECT_TRUE(HandleAddressMessage(buffer));
230  map = GetAddressMap();
231  EXPECT_EQ(3u, map.size());
232  EXPECT_EQ(1u, map.count(kAddr3));
233}
234
235TEST_F(AddressTrackerLinuxTest, NewAddressChange) {
236  InitializeAddressTracker(true);
237
238  const IPAddressNumber kEmpty;
239  const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
240
241  Buffer buffer;
242  MakeAddrMessage(RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty,
243                  &buffer);
244  EXPECT_TRUE(HandleAddressMessage(buffer));
245  AddressTrackerLinux::AddressMap map = GetAddressMap();
246  EXPECT_EQ(1u, map.size());
247  EXPECT_EQ(1u, map.count(kAddr0));
248  EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
249
250  buffer.clear();
251  MakeAddrMessage(RTM_NEWADDR, IFA_F_HOMEADDRESS, AF_INET, kAddr0, kEmpty,
252                  &buffer);
253  EXPECT_TRUE(HandleAddressMessage(buffer));
254  map = GetAddressMap();
255  EXPECT_EQ(1u, map.size());
256  EXPECT_EQ(1u, map.count(kAddr0));
257  EXPECT_EQ(IFA_F_HOMEADDRESS, map[kAddr0].ifa_flags);
258
259  // Both messages in one buffer.
260  buffer.clear();
261  MakeAddrMessage(RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty,
262                  &buffer);
263  MakeAddrMessage(RTM_NEWADDR, IFA_F_HOMEADDRESS, AF_INET, kAddr0, kEmpty,
264                  &buffer);
265  EXPECT_TRUE(HandleAddressMessage(buffer));
266  map = GetAddressMap();
267  EXPECT_EQ(1u, map.size());
268  EXPECT_EQ(IFA_F_HOMEADDRESS, map[kAddr0].ifa_flags);
269}
270
271TEST_F(AddressTrackerLinuxTest, NewAddressDuplicate) {
272  InitializeAddressTracker(true);
273
274  const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
275
276  Buffer buffer;
277  MakeAddrMessage(RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kAddr0,
278                  &buffer);
279  EXPECT_TRUE(HandleAddressMessage(buffer));
280  AddressTrackerLinux::AddressMap map = GetAddressMap();
281  EXPECT_EQ(1u, map.size());
282  EXPECT_EQ(1u, map.count(kAddr0));
283  EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
284
285  EXPECT_FALSE(HandleAddressMessage(buffer));
286  map = GetAddressMap();
287  EXPECT_EQ(1u, map.size());
288  EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
289}
290
291TEST_F(AddressTrackerLinuxTest, DeleteAddress) {
292  InitializeAddressTracker(true);
293
294  const IPAddressNumber kEmpty;
295  const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
296  const IPAddressNumber kAddr1(kAddress1, kAddress1 + arraysize(kAddress1));
297  const IPAddressNumber kAddr2(kAddress2, kAddress2 + arraysize(kAddress2));
298
299  Buffer buffer;
300  MakeAddrMessage(RTM_NEWADDR, 0, AF_INET, kAddr0, kEmpty, &buffer);
301  MakeAddrMessage(RTM_NEWADDR, 0, AF_INET, kAddr1, kAddr2, &buffer);
302  EXPECT_TRUE(HandleAddressMessage(buffer));
303  AddressTrackerLinux::AddressMap map = GetAddressMap();
304  EXPECT_EQ(2u, map.size());
305
306  buffer.clear();
307  MakeAddrMessage(RTM_DELADDR, 0, AF_INET, kEmpty, kAddr0, &buffer);
308  EXPECT_TRUE(HandleAddressMessage(buffer));
309  map = GetAddressMap();
310  EXPECT_EQ(1u, map.size());
311  EXPECT_EQ(0u, map.count(kAddr0));
312  EXPECT_EQ(1u, map.count(kAddr2));
313
314  buffer.clear();
315  MakeAddrMessage(RTM_DELADDR, 0, AF_INET, kAddr2, kAddr1, &buffer);
316  // kAddr1 does not exist in the map.
317  EXPECT_FALSE(HandleAddressMessage(buffer));
318  map = GetAddressMap();
319  EXPECT_EQ(1u, map.size());
320
321  buffer.clear();
322  MakeAddrMessage(RTM_DELADDR, 0, AF_INET, kAddr2, kEmpty, &buffer);
323  EXPECT_TRUE(HandleAddressMessage(buffer));
324  map = GetAddressMap();
325  EXPECT_EQ(0u, map.size());
326}
327
328TEST_F(AddressTrackerLinuxTest, DeprecatedLifetime) {
329  InitializeAddressTracker(true);
330
331  const IPAddressNumber kEmpty;
332  const IPAddressNumber kAddr3(kAddress3, kAddress3 + arraysize(kAddress3));
333
334  Buffer buffer;
335  MakeAddrMessage(RTM_NEWADDR, 0, AF_INET6, kEmpty, kAddr3, &buffer);
336  EXPECT_TRUE(HandleAddressMessage(buffer));
337  AddressTrackerLinux::AddressMap map = GetAddressMap();
338  EXPECT_EQ(1u, map.size());
339  EXPECT_EQ(1u, map.count(kAddr3));
340  EXPECT_EQ(0, map[kAddr3].ifa_flags);
341
342  // Verify 0 preferred lifetime implies deprecated.
343  buffer.clear();
344  MakeAddrMessageWithCacheInfo(RTM_NEWADDR, 0, AF_INET6, kEmpty, kAddr3, 0,
345                               &buffer);
346  EXPECT_TRUE(HandleAddressMessage(buffer));
347  map = GetAddressMap();
348  EXPECT_EQ(1u, map.size());
349  EXPECT_EQ(IFA_F_DEPRECATED, map[kAddr3].ifa_flags);
350
351  // Verify properly flagged message doesn't imply change.
352  buffer.clear();
353  MakeAddrMessageWithCacheInfo(RTM_NEWADDR, IFA_F_DEPRECATED, AF_INET6, kEmpty,
354                               kAddr3, 0, &buffer);
355  EXPECT_FALSE(HandleAddressMessage(buffer));
356  map = GetAddressMap();
357  EXPECT_EQ(1u, map.size());
358  EXPECT_EQ(IFA_F_DEPRECATED, map[kAddr3].ifa_flags);
359
360  // Verify implied deprecated doesn't imply change.
361  buffer.clear();
362  MakeAddrMessageWithCacheInfo(RTM_NEWADDR, 0, AF_INET6, kEmpty, kAddr3, 0,
363                               &buffer);
364  EXPECT_FALSE(HandleAddressMessage(buffer));
365  map = GetAddressMap();
366  EXPECT_EQ(1u, map.size());
367  EXPECT_EQ(IFA_F_DEPRECATED, map[kAddr3].ifa_flags);
368}
369
370TEST_F(AddressTrackerLinuxTest, IgnoredMessage) {
371  InitializeAddressTracker(true);
372
373  const IPAddressNumber kEmpty;
374  const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
375  const IPAddressNumber kAddr3(kAddress3, kAddress3 + arraysize(kAddress3));
376
377  Buffer buffer;
378  // Ignored family.
379  MakeAddrMessage(RTM_NEWADDR, 0, AF_UNSPEC, kAddr3, kAddr0, &buffer);
380  // No address.
381  MakeAddrMessage(RTM_NEWADDR, 0, AF_INET, kEmpty, kEmpty, &buffer);
382  // Ignored type.
383  MakeAddrMessage(RTM_DELROUTE, 0, AF_INET6, kAddr3, kEmpty, &buffer);
384  EXPECT_FALSE(HandleAddressMessage(buffer));
385  EXPECT_TRUE(GetAddressMap().empty());
386
387  // Valid message after ignored messages.
388  NetlinkMessage nlmsg(RTM_NEWADDR);
389  struct ifaddrmsg msg = {};
390  msg.ifa_family = AF_INET;
391  nlmsg.AddPayload(&msg, sizeof(msg));
392  // Ignored attribute.
393  struct ifa_cacheinfo cache_info = {};
394  nlmsg.AddAttribute(IFA_CACHEINFO, &cache_info, sizeof(cache_info));
395  nlmsg.AddAttribute(IFA_ADDRESS, &kAddr0[0], kAddr0.size());
396  nlmsg.AppendTo(&buffer);
397
398  EXPECT_TRUE(HandleAddressMessage(buffer));
399  EXPECT_EQ(1u, GetAddressMap().size());
400}
401
402TEST_F(AddressTrackerLinuxTest, AddInterface) {
403  InitializeAddressTracker(true);
404
405  Buffer buffer;
406
407  // Ignores loopback.
408  MakeLinkMessage(RTM_NEWLINK,
409                  IFF_LOOPBACK | IFF_UP | IFF_LOWER_UP | IFF_RUNNING,
410                  0, &buffer);
411  EXPECT_FALSE(HandleLinkMessage(buffer));
412  EXPECT_TRUE(GetOnlineLinks().empty());
413
414  // Ignores not IFF_LOWER_UP.
415  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
416  EXPECT_FALSE(HandleLinkMessage(buffer));
417  EXPECT_TRUE(GetOnlineLinks().empty());
418
419  // Ignores deletion.
420  MakeLinkMessage(RTM_DELLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
421  EXPECT_FALSE(HandleLinkMessage(buffer));
422  EXPECT_TRUE(GetOnlineLinks().empty());
423
424  // Verify success.
425  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
426  EXPECT_TRUE(HandleLinkMessage(buffer));
427  EXPECT_EQ(1u, GetOnlineLinks().count(0));
428  EXPECT_EQ(1u, GetOnlineLinks().size());
429
430  // Ignores redundant enables.
431  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
432  EXPECT_FALSE(HandleLinkMessage(buffer));
433  EXPECT_EQ(1u, GetOnlineLinks().count(0));
434  EXPECT_EQ(1u, GetOnlineLinks().size());
435
436  // Verify adding another online device (e.g. VPN) is considered a change.
437  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 1, &buffer);
438  EXPECT_TRUE(HandleLinkMessage(buffer));
439  EXPECT_EQ(1u, GetOnlineLinks().count(0));
440  EXPECT_EQ(1u, GetOnlineLinks().count(1));
441  EXPECT_EQ(2u, GetOnlineLinks().size());
442}
443
444TEST_F(AddressTrackerLinuxTest, RemoveInterface) {
445  InitializeAddressTracker(true);
446
447  Buffer buffer;
448
449  // Should disappear when not IFF_LOWER_UP.
450  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
451  EXPECT_TRUE(HandleLinkMessage(buffer));
452  EXPECT_FALSE(GetOnlineLinks().empty());
453  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
454  EXPECT_TRUE(HandleLinkMessage(buffer));
455  EXPECT_TRUE(GetOnlineLinks().empty());
456
457  // Ignores redundant disables.
458  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
459  EXPECT_FALSE(HandleLinkMessage(buffer));
460  EXPECT_TRUE(GetOnlineLinks().empty());
461
462  // Ignores deleting down interfaces.
463  MakeLinkMessage(RTM_DELLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
464  EXPECT_FALSE(HandleLinkMessage(buffer));
465  EXPECT_TRUE(GetOnlineLinks().empty());
466
467  // Should disappear when deleted.
468  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
469  EXPECT_TRUE(HandleLinkMessage(buffer));
470  EXPECT_FALSE(GetOnlineLinks().empty());
471  MakeLinkMessage(RTM_DELLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
472  EXPECT_TRUE(HandleLinkMessage(buffer));
473  EXPECT_TRUE(GetOnlineLinks().empty());
474}
475
476TEST_F(AddressTrackerLinuxTest, TunnelInterface) {
477  InitializeAddressTracker(true);
478
479  Buffer buffer;
480
481  // Ignores without "tun" prefixed name.
482  MakeLinkMessage(RTM_NEWLINK,
483                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
484                  0, &buffer);
485  EXPECT_FALSE(HandleTunnelMessage(buffer));
486
487  // Verify success.
488  MakeLinkMessage(RTM_NEWLINK,
489                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
490                  kTestInterfaceTun, &buffer);
491  EXPECT_TRUE(HandleTunnelMessage(buffer));
492
493  // Ignores redundant enables.
494  MakeLinkMessage(RTM_NEWLINK,
495                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
496                  kTestInterfaceTun, &buffer);
497  EXPECT_FALSE(HandleTunnelMessage(buffer));
498
499  // Ignores deleting without "tun" prefixed name.
500  MakeLinkMessage(RTM_DELLINK,
501                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
502                  0, &buffer);
503  EXPECT_FALSE(HandleTunnelMessage(buffer));
504
505  // Verify successful deletion
506  MakeLinkMessage(RTM_DELLINK,
507                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
508                  kTestInterfaceTun, &buffer);
509  EXPECT_TRUE(HandleTunnelMessage(buffer));
510
511  // Ignores redundant deletions.
512  MakeLinkMessage(RTM_DELLINK,
513                  IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
514                  kTestInterfaceTun, &buffer);
515  EXPECT_FALSE(HandleTunnelMessage(buffer));
516}
517
518// Check AddressTrackerLinux::get_interface_name_ original implementation
519// doesn't crash or return NULL.
520TEST_F(AddressTrackerLinuxTest, GetInterfaceName) {
521  InitializeAddressTracker(true);
522
523  for (int i = 0; i < 10; i++)
524    EXPECT_NE((const char*)NULL, original_get_interface_name_(i));
525}
526
527TEST_F(AddressTrackerLinuxTest, NonTrackingMode) {
528  InitializeAddressTracker(false);
529
530  const IPAddressNumber kEmpty;
531  const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
532
533  Buffer buffer;
534  MakeAddrMessage(
535      RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty, &buffer);
536  EXPECT_TRUE(HandleAddressMessage(buffer));
537  AddressTrackerLinux::AddressMap map = GetAddressMap();
538  EXPECT_EQ(1u, map.size());
539  EXPECT_EQ(1u, map.count(kAddr0));
540  EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
541
542  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
543  EXPECT_TRUE(HandleLinkMessage(buffer));
544  EXPECT_EQ(1u, GetOnlineLinks().count(0));
545  EXPECT_EQ(1u, GetOnlineLinks().size());
546}
547
548TEST_F(AddressTrackerLinuxTest, NonTrackingModeInit) {
549  AddressTrackerLinux tracker;
550  tracker.Init();
551}
552
553}  // namespace
554
555}  // namespace internal
556}  // namespace net
557