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/dns/mapped_host_resolver.h" 6 7#include "net/base/address_list.h" 8#include "net/base/net_errors.h" 9#include "net/base/net_log.h" 10#include "net/base/net_util.h" 11#include "net/base/test_completion_callback.h" 12#include "net/dns/mock_host_resolver.h" 13#include "testing/gtest/include/gtest/gtest.h" 14 15namespace net { 16 17namespace { 18 19std::string FirstAddress(const AddressList& address_list) { 20 if (address_list.empty()) 21 return std::string(); 22 return address_list.front().ToString(); 23} 24 25TEST(MappedHostResolverTest, Inclusion) { 26 // Create a mock host resolver, with specific hostname to IP mappings. 27 scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); 28 resolver_impl->rules()->AddSimulatedFailure("*google.com"); 29 resolver_impl->rules()->AddRule("baz.com", "192.168.1.5"); 30 resolver_impl->rules()->AddRule("foo.com", "192.168.1.8"); 31 resolver_impl->rules()->AddRule("proxy", "192.168.1.11"); 32 33 // Create a remapped resolver that uses |resolver_impl|. 34 scoped_ptr<MappedHostResolver> resolver( 35 new MappedHostResolver(resolver_impl.PassAs<HostResolver>())); 36 37 int rv; 38 AddressList address_list; 39 40 // Try resolving "www.google.com:80". There are no mappings yet, so this 41 // hits |resolver_impl| and fails. 42 TestCompletionCallback callback; 43 rv = resolver->Resolve(HostResolver::RequestInfo( 44 HostPortPair("www.google.com", 80)), 45 &address_list, callback.callback(), NULL, 46 BoundNetLog()); 47 EXPECT_EQ(ERR_IO_PENDING, rv); 48 rv = callback.WaitForResult(); 49 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); 50 51 // Remap *.google.com to baz.com. 52 EXPECT_TRUE(resolver->AddRuleFromString("map *.google.com baz.com")); 53 54 // Try resolving "www.google.com:80". Should be remapped to "baz.com:80". 55 rv = resolver->Resolve(HostResolver::RequestInfo( 56 HostPortPair("www.google.com", 80)), 57 &address_list, callback.callback(), NULL, 58 BoundNetLog()); 59 EXPECT_EQ(ERR_IO_PENDING, rv); 60 rv = callback.WaitForResult(); 61 EXPECT_EQ(OK, rv); 62 EXPECT_EQ("192.168.1.5:80", FirstAddress(address_list)); 63 64 // Try resolving "foo.com:77". This will NOT be remapped, so result 65 // is "foo.com:77". 66 rv = resolver->Resolve(HostResolver::RequestInfo(HostPortPair("foo.com", 77)), 67 &address_list, callback.callback(), NULL, 68 BoundNetLog()); 69 EXPECT_EQ(ERR_IO_PENDING, rv); 70 rv = callback.WaitForResult(); 71 EXPECT_EQ(OK, rv); 72 EXPECT_EQ("192.168.1.8:77", FirstAddress(address_list)); 73 74 // Remap "*.org" to "proxy:99". 75 EXPECT_TRUE(resolver->AddRuleFromString("Map *.org proxy:99")); 76 77 // Try resolving "chromium.org:61". Should be remapped to "proxy:99". 78 rv = resolver->Resolve(HostResolver::RequestInfo 79 (HostPortPair("chromium.org", 61)), 80 &address_list, callback.callback(), NULL, 81 BoundNetLog()); 82 EXPECT_EQ(ERR_IO_PENDING, rv); 83 rv = callback.WaitForResult(); 84 EXPECT_EQ(OK, rv); 85 EXPECT_EQ("192.168.1.11:99", FirstAddress(address_list)); 86} 87 88// Tests that exclusions are respected. 89TEST(MappedHostResolverTest, Exclusion) { 90 // Create a mock host resolver, with specific hostname to IP mappings. 91 scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); 92 resolver_impl->rules()->AddRule("baz", "192.168.1.5"); 93 resolver_impl->rules()->AddRule("www.google.com", "192.168.1.3"); 94 95 // Create a remapped resolver that uses |resolver_impl|. 96 scoped_ptr<MappedHostResolver> resolver( 97 new MappedHostResolver(resolver_impl.PassAs<HostResolver>())); 98 99 int rv; 100 AddressList address_list; 101 TestCompletionCallback callback; 102 103 // Remap "*.com" to "baz". 104 EXPECT_TRUE(resolver->AddRuleFromString("map *.com baz")); 105 106 // Add an exclusion for "*.google.com". 107 EXPECT_TRUE(resolver->AddRuleFromString("EXCLUDE *.google.com")); 108 109 // Try resolving "www.google.com". Should not be remapped due to exclusion). 110 rv = resolver->Resolve(HostResolver::RequestInfo( 111 HostPortPair("www.google.com", 80)), 112 &address_list, callback.callback(), NULL, 113 BoundNetLog()); 114 EXPECT_EQ(ERR_IO_PENDING, rv); 115 rv = callback.WaitForResult(); 116 EXPECT_EQ(OK, rv); 117 EXPECT_EQ("192.168.1.3:80", FirstAddress(address_list)); 118 119 // Try resolving "chrome.com:80". Should be remapped to "baz:80". 120 rv = resolver->Resolve(HostResolver::RequestInfo( 121 HostPortPair("chrome.com", 80)), 122 &address_list, callback.callback(), NULL, 123 BoundNetLog()); 124 EXPECT_EQ(ERR_IO_PENDING, rv); 125 rv = callback.WaitForResult(); 126 EXPECT_EQ(OK, rv); 127 EXPECT_EQ("192.168.1.5:80", FirstAddress(address_list)); 128} 129 130TEST(MappedHostResolverTest, SetRulesFromString) { 131 // Create a mock host resolver, with specific hostname to IP mappings. 132 scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); 133 resolver_impl->rules()->AddRule("baz", "192.168.1.7"); 134 resolver_impl->rules()->AddRule("bar", "192.168.1.9"); 135 136 // Create a remapped resolver that uses |resolver_impl|. 137 scoped_ptr<MappedHostResolver> resolver( 138 new MappedHostResolver(resolver_impl.PassAs<HostResolver>())); 139 140 int rv; 141 AddressList address_list; 142 TestCompletionCallback callback; 143 144 // Remap "*.com" to "baz", and *.net to "bar:60". 145 resolver->SetRulesFromString("map *.com baz , map *.net bar:60"); 146 147 // Try resolving "www.google.com". Should be remapped to "baz". 148 rv = resolver->Resolve(HostResolver::RequestInfo( 149 HostPortPair("www.google.com", 80)), 150 &address_list, callback.callback(), NULL, 151 BoundNetLog()); 152 EXPECT_EQ(ERR_IO_PENDING, rv); 153 rv = callback.WaitForResult(); 154 EXPECT_EQ(OK, rv); 155 EXPECT_EQ("192.168.1.7:80", FirstAddress(address_list)); 156 157 // Try resolving "chrome.net:80". Should be remapped to "bar:60". 158 rv = resolver->Resolve(HostResolver::RequestInfo( 159 HostPortPair("chrome.net", 80)), 160 &address_list, callback.callback(), NULL, 161 BoundNetLog()); 162 EXPECT_EQ(ERR_IO_PENDING, rv); 163 rv = callback.WaitForResult(); 164 EXPECT_EQ(OK, rv); 165 EXPECT_EQ("192.168.1.9:60", FirstAddress(address_list)); 166} 167 168// Parsing bad rules should silently discard the rule (and never crash). 169TEST(MappedHostResolverTest, ParseInvalidRules) { 170 scoped_ptr<MappedHostResolver> resolver( 171 new MappedHostResolver(scoped_ptr<HostResolver>())); 172 173 EXPECT_FALSE(resolver->AddRuleFromString("xyz")); 174 EXPECT_FALSE(resolver->AddRuleFromString(std::string())); 175 EXPECT_FALSE(resolver->AddRuleFromString(" ")); 176 EXPECT_FALSE(resolver->AddRuleFromString("EXCLUDE")); 177 EXPECT_FALSE(resolver->AddRuleFromString("EXCLUDE foo bar")); 178 EXPECT_FALSE(resolver->AddRuleFromString("INCLUDE")); 179 EXPECT_FALSE(resolver->AddRuleFromString("INCLUDE x")); 180 EXPECT_FALSE(resolver->AddRuleFromString("INCLUDE x :10")); 181} 182 183// Test mapping hostnames to resolving failures. 184TEST(MappedHostResolverTest, MapToError) { 185 scoped_ptr<MockHostResolver> resolver_impl(new MockHostResolver()); 186 resolver_impl->rules()->AddRule("*", "192.168.1.5"); 187 188 scoped_ptr<MappedHostResolver> resolver( 189 new MappedHostResolver(resolver_impl.PassAs<HostResolver>())); 190 191 int rv; 192 AddressList address_list; 193 194 // Remap *.google.com to resolving failures. 195 EXPECT_TRUE(resolver->AddRuleFromString("MAP *.google.com ~NOTFOUND")); 196 197 // Try resolving www.google.com --> Should give an error. 198 TestCompletionCallback callback1; 199 rv = resolver->Resolve(HostResolver::RequestInfo( 200 HostPortPair("www.google.com", 80)), 201 &address_list, callback1.callback(), NULL, 202 BoundNetLog()); 203 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv); 204 205 // Try resolving www.foo.com --> Should succeed. 206 TestCompletionCallback callback2; 207 rv = resolver->Resolve(HostResolver::RequestInfo( 208 HostPortPair("www.foo.com", 80)), 209 &address_list, callback2.callback(), NULL, 210 BoundNetLog()); 211 EXPECT_EQ(ERR_IO_PENDING, rv); 212 rv = callback2.WaitForResult(); 213 EXPECT_EQ(OK, rv); 214 EXPECT_EQ("192.168.1.5:80", FirstAddress(address_list)); 215} 216 217} // namespace 218 219} // namespace net 220