net/base/host_mapping_rules.cc

   1 // Copyright (c) 2010 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/base/host_mapping_rules.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/pattern.h"
   9 #include "base/strings/string_split.h"
  10 #include "base/strings/string_tokenizer.h"
  11 #include "base/strings/string_util.h"
  12 #include "net/base/host_port_pair.h"
  13 #include "net/base/net_util.h"
  14
  15 namespace net {
  16
  17 struct HostMappingRules::MapRule {
  18   MapRule() : replacement_port(-1) {}
  19
  20   std::string hostname_pattern;
  21   std::string replacement_hostname;
  22   int replacement_port;
  23 };
  24
  25 struct HostMappingRules::ExclusionRule {
  26   std::string hostname_pattern;
  27 };
  28
  29 HostMappingRules::HostMappingRules() {}
  30
  31 HostMappingRules::~HostMappingRules() {}
  32
  33 bool HostMappingRules::RewriteHost(HostPortPair* host_port) const {
  34   // Check if the hostname was excluded.
  35   for (ExclusionRuleList::const_iterator it = exclusion_rules_.begin();
  36        it != exclusion_rules_.end(); ++it) {
  37     const ExclusionRule& rule = *it;
  38     if (base::MatchPattern(host_port->host(), rule.hostname_pattern))
  39       return false;
  40   }
  41
  42   // Check if the hostname was remapped.
  43   for (MapRuleList::const_iterator it = map_rules_.begin();
  44        it != map_rules_.end(); ++it) {
  45     const MapRule& rule = *it;
  46
  47     // The rule's hostname_pattern will be something like:
  48     //     www.foo.com
  49     //     *.foo.com
  50     //     www.foo.com:1234
  51     //     *.foo.com:1234
  52     // First, we'll check for a match just on hostname.
  53     // If that fails, we'll check for a match with both hostname and port.
  54     if (!base::MatchPattern(host_port->host(), rule.hostname_pattern)) {
  55       std::string host_port_string = host_port->ToString();
  56       if (!base::MatchPattern(host_port_string, rule.hostname_pattern))
  57         continue;  // This rule doesn't apply.
  58     }
  59
  60     host_port->set_host(rule.replacement_hostname);
  61     if (rule.replacement_port != -1)
  62       host_port->set_port(static_cast<uint16_t>(rule.replacement_port));
  63     return true;
  64   }
  65
  66   return false;
  67 }
  68
  69 bool HostMappingRules::AddRuleFromString(const std::string& rule_string) {
  70   std::vector<std::string> parts =
  71       base::SplitString(base::TrimWhitespaceASCII(rule_string, base::TRIM_ALL),
  72                         " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
  73
  74   // Test for EXCLUSION rule.
  75   if (parts.size() == 2 && base::LowerCaseEqualsASCII(parts[0], "exclude")) {
  76     ExclusionRule rule;
  77     rule.hostname_pattern = base::ToLowerASCII(parts[1]);
  78     exclusion_rules_.push_back(rule);
  79     return true;
  80   }
  81
  82   // Test for MAP rule.
  83   if (parts.size() == 3 && base::LowerCaseEqualsASCII(parts[0], "map")) {
  84     MapRule rule;
  85     rule.hostname_pattern = base::ToLowerASCII(parts[1]);
  86
  87     if (!ParseHostAndPort(parts[2], &rule.replacement_hostname,
  88                           &rule.replacement_port)) {
  89       return false;  // Failed parsing the hostname/port.
  90     }
  91
  92     map_rules_.push_back(rule);
  93     return true;
  94   }
  95
  96   return false;
  97 }
  98
  99 void HostMappingRules::SetRulesFromString(const std::string& rules_string) {
 100   exclusion_rules_.clear();
 101   map_rules_.clear();
 102
 103   base::StringTokenizer rules(rules_string, ",");
 104   while (rules.GetNext()) {
 105     bool ok = AddRuleFromString(rules.token());
 106     LOG_IF(ERROR, !ok) << "Failed parsing rule: " << rules.token();
 107   }
 108 }
 109
 110 }  // namespace net