diff options
Diffstat (limited to 'chromium/net/base/ip_pattern.cc')
| -rw-r--r-- | chromium/net/base/ip_pattern.cc | 188 |
1 files changed, 188 insertions, 0 deletions
diff --git a/chromium/net/base/ip_pattern.cc b/chromium/net/base/ip_pattern.cc new file mode 100644 index 00000000000..f67d3a0ba64 --- /dev/null +++ b/chromium/net/base/ip_pattern.cc @@ -0,0 +1,188 @@ +// Copyright 2014 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "net/base/ip_pattern.h" + +#include <string> + +#include "base/logging.h" +#include "base/memory/scoped_ptr.h" +#include "base/stl_util.h" +#include "base/strings/string_number_conversions.h" +#include "base/strings/string_split.h" +#include "base/strings/string_tokenizer.h" + +namespace net { + +class IPPattern::ComponentPattern { + public: + ComponentPattern(); + void AppendRange(uint32 min, uint32 max); + bool Match(uint32 value) const; + + private: + struct Range { + public: + Range(uint32 min, uint32 max) : minimum(min), maximum(max) {} + uint32 minimum; + uint32 maximum; + }; + typedef std::vector<Range> RangeVector; + + RangeVector ranges_; + + DISALLOW_COPY_AND_ASSIGN(ComponentPattern); +}; + +IPPattern::ComponentPattern::ComponentPattern() {} + +void IPPattern::ComponentPattern::AppendRange(uint32 min, uint32 max) { + ranges_.push_back(Range(min, max)); +} + +bool IPPattern::ComponentPattern::Match(uint32 value) const { + // Simple linear search should be fine, as we usually only have very few + // distinct ranges to test. + for (RangeVector::const_iterator range_it = ranges_.begin(); + range_it != ranges_.end(); ++range_it) { + if (range_it->maximum >= value && range_it->minimum <= value) + return true; + } + return false; +} + +IPPattern::IPPattern() : is_ipv4_(true) {} + +IPPattern::~IPPattern() { + STLDeleteElements(&component_patterns_); +} + +bool IPPattern::Match(const IPAddressNumber& address) const { + if (ip_mask_.empty()) + return false; + bool address_is_ipv4 = address.size() == kIPv4AddressSize; + if (address_is_ipv4 != is_ipv4_) + return false; + + ComponentPatternList::const_iterator pattern_it(component_patterns_.begin()); + int fixed_value_index = 0; + // IPv6 |address| vectors have 16 pieces, while our |ip_mask_| has only + // 8, so it is easier to count separately. + int address_index = 0; + for (size_t i = 0; i < ip_mask_.size(); ++i) { + uint32 value_to_test = address[address_index++]; + if (!is_ipv4_) { + value_to_test = (value_to_test << 8) + address[address_index++]; + } + if (ip_mask_[i]) { + if (component_values_[fixed_value_index++] != value_to_test) + return false; + continue; + } + if (!(*pattern_it)->Match(value_to_test)) + return false; + ++pattern_it; + } + return true; +} + +bool IPPattern::ParsePattern(const std::string& ip_pattern) { + DCHECK(ip_mask_.empty()); + if (ip_pattern.find(':') != std::string::npos) { + is_ipv4_ = false; + } + Strings components; + base::SplitString(ip_pattern, is_ipv4_ ? '.' : ':', &components); + if (components.size() != (is_ipv4_ ? 4u : 8u)) { + DVLOG(1) << "Invalid component count: " << ip_pattern; + return false; + } + for (Strings::iterator component_it = components.begin(); + component_it != components.end(); ++component_it) { + if (component_it->empty()) { + DVLOG(1) << "Empty component: " << ip_pattern; + return false; + } + if (*component_it == "*") { + // Let standard code handle this below. + *component_it = is_ipv4_ ? "[0-255]" : "[0-FFFF]"; + } else if ((*component_it)[0] != '[') { + // This value will just have a specific integer to match. + uint32 value; + if (!ValueTextToInt(*component_it, &value)) + return false; + ip_mask_.push_back(true); + component_values_.push_back(value); + continue; + } + if ((*component_it)[component_it->size() - 1] != ']') { + DVLOG(1) << "Missing close bracket: " << ip_pattern; + return false; + } + // Now we know the size() is at least 2. + if (component_it->size() == 2) { + DVLOG(1) << "Empty bracket: " << ip_pattern; + return false; + } + // We'll need a pattern to match this bracketed component. + scoped_ptr<ComponentPattern> component_pattern(new ComponentPattern); + // Trim leading and trailing bracket before calling for parsing. + if (!ParseComponentPattern(base::StringPiece(component_it->data() + 1, + component_it->size() - 2), component_pattern.get())) { + return false; + } + ip_mask_.push_back(false); + component_patterns_.push_back(component_pattern.release()); + } + return true; +} + +bool IPPattern::ParseComponentPattern(const base::StringPiece& text, + ComponentPattern* pattern) const { + // We're given a comma separated set of ranges, some of which may be simple + // constants. + Strings ranges; + base::SplitString(text.as_string(), ',', &ranges); + for (Strings::iterator range_it = ranges.begin(); + range_it != ranges.end(); ++range_it) { + base::StringTokenizer range_pair(*range_it, "-"); + uint32 min = 0; + range_pair.GetNext(); + if (!ValueTextToInt(range_pair.token(), &min)) + return false; + uint32 max = min; // Sometimes we have no distinct max. + if (range_pair.GetNext()) { + if (!ValueTextToInt(range_pair.token(), &max)) + return false; + } + if (range_pair.GetNext()) { + // Too many "-" in this range specifier. + DVLOG(1) << "Too many hyphens in range: "; + return false; + } + pattern->AppendRange(min, max); + } + return true; +} + +bool IPPattern::ValueTextToInt(const base::StringPiece& input, + uint32* output) const { + bool ok = is_ipv4_ ? base::StringToUint(input, output) : + base::HexStringToUInt(input, output); + if (!ok) { + DVLOG(1) << "Could not convert value to number: " << input; + return false; + } + if (is_ipv4_ && *output > 255u) { + DVLOG(1) << "IPv4 component greater than 255"; + return false; + } + if (!is_ipv4_ && *output > 0xFFFFu) { + DVLOG(1) << "IPv6 component greater than 0xFFFF"; + return false; + } + return ok; +} + +} // namespace net |