1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_PROXY_RESOLUTION_PROXY_HOST_MATCHING_RULES_H_
#define NET_PROXY_RESOLUTION_PROXY_HOST_MATCHING_RULES_H_
#include <memory>
#include <string>
#include <string_view>
#include <vector>
#include "net/base/net_export.h"
#include "net/base/scheme_host_port_matcher.h"
#include "net/base/scheme_host_port_matcher_rule.h"
#include "url/gurl.h"
namespace net {
// ProxyHostMatchingRules describes a set of rules to match against URLs for
// general purposes, for example to determine if such URLs should bypass the use
// of a proxy.
//
// The rules are expressed as an ordered list of rules, which can be thought of
// as being evaluated left-to-right. Order only matters when mixing "negative
// rules" with "positive rules". For more details see the comments in
// ProxyHostMatchingRules::Matches().
//
// This rule list is serializable to a string (either comma or semi-colon
// separated), which has similar semantics across platforms.
//
// When evaluating ProxyHostMatchingRules there are some implicitly applied
// rules when the URL does not match any of the explicit rules. See
// MatchesImplicitRules() for details.
class NET_EXPORT ProxyHostMatchingRules {
public:
// Note: This class supports copy constructor and assignment.
ProxyHostMatchingRules();
ProxyHostMatchingRules(const ProxyHostMatchingRules& rhs);
ProxyHostMatchingRules(ProxyHostMatchingRules&& rhs);
~ProxyHostMatchingRules();
ProxyHostMatchingRules& operator=(const ProxyHostMatchingRules& rhs);
ProxyHostMatchingRules& operator=(ProxyHostMatchingRules&& rhs);
// Returns the current list of rules. The rules list contains pointers
// which are owned by this class, callers should NOT keep references
// or delete them.
const SchemeHostPortMatcher::RuleList& rules() const {
return matcher_.rules();
}
// Replace rule on |index| in the internal RuleList.
void ReplaceRule(size_t index,
std::unique_ptr<SchemeHostPortMatcherRule> rule);
// Returns true if the bypass rules indicate that |url| should bypass the
// proxy. Matching is done using both the explicit rules, as well as a
// set of global implicit rules.
//
// If |reverse| is set to true then the bypass
// rule list is inverted (this is almost equivalent to negating the result of
// Matches(), except for implicit matches).
bool Matches(const GURL& url, bool reverse = false) const;
// Returns true if |*this| has the same serialized list of rules as |other|.
bool operator==(const ProxyHostMatchingRules& other) const;
// Initializes the list of rules by parsing the string |raw|. |raw| is a
// comma separated or semi-colon separated list of rules. See
// AddRuleFromString() to see the specific rule grammar.
void ParseFromString(const std::string& raw);
// Adds a rule to the front of thelist that bypasses hostnames without a dot
// in them (and is not an IP literal), which can be indicative of intranet
// websites.
//
// On Windows this corresponds to the "Bypass proxy server for local
// addresses" settings checkbox, and on macOS the "Exclude simple hostnames"
// checkbox.
void PrependRuleToBypassSimpleHostnames();
// Adds a rule given by the string |raw|. The format of |raw| can be any of
// the following:
//
// Returns true if the rule was successfully added.
//
// For the supported format of bypass rules see //net/docs/proxy.md.
bool AddRuleFromString(std::string_view raw);
// Appends rules that "cancels out" the implicit bypass rules. See
// GetRulesToSubtractImplicit() for details.
void AddRulesToSubtractImplicit();
// Returns a list of bypass rules that "cancels out" the implicit bypass
// rules.
//
// The current set of implicit bypass rules are localhost and link-local
// addresses, and are subtracted using <-loopback> (an idiom from Windows),
// however this could change.
//
// If using this for tests, see https://crbug.com/901896.
static std::string GetRulesToSubtractImplicit();
// Converts the rules to a string representation (ParseFormat::kDefault).
std::string ToString() const;
// Removes all the rules.
void Clear();
// Returns true if |url| matches one of the implicit proxy bypass rules
// (localhost or link local).
static bool MatchesImplicitRules(const GURL& url);
// The delimiter used by |ToString()| for the string representation of the
// proxy bypass rules.
constexpr static char kBypassListDelimeter[] = ";";
private:
SchemeHostPortMatcher matcher_;
};
} // namespace net
#endif // NET_PROXY_RESOLUTION_PROXY_HOST_MATCHING_RULES_H_
|
