blob: f3f49ea5a3f45d347da87797e68228b75b17349f (
plain)
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
125
126
127
128
129
130
|
// Copyright (c) 2009 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.
#ifndef CHROME_BROWSER_PRIVACY_BLACKLIST_BLACKLIST_H_
#define CHROME_BROWSER_PRIVACY_BLACKLIST_BLACKLIST_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/scoped_ptr.h"
#include "googleurl/src/gurl.h"
#include "net/url_request/url_request.h"
class FilePath;
////////////////////////////////////////////////////////////////////////////////
//
// Blacklist Class
//
// Represents a blacklist used to protect user from privacy and annoyances.
// A blacklist is essentially a map from resource-match patterns to filter-
// attributes. Each time a resources matches a pattern the filter-attributes
// are used to determine how the browser handles the matching resource.
//
// TODO(idanan): Implement this efficiently.
// To get things started, the initial implementation is as simple as
// it gets and cannot scale to large blacklists but it should be enough
// for testing on the order of a hundred or so entries.
//
////////////////////////////////////////////////////////////////////////////////
class Blacklist {
public:
// Filter attributes (more to come):
static const unsigned int kBlockAll = 1;
static const unsigned int kDontSendCookies = 1 << 1;
static const unsigned int kDontStoreCookies = 1 << 2;
static const unsigned int kDontPersistCookies = 1 << 3;
static const unsigned int kDontSendReferrer = 1 << 4;
static const unsigned int kDontSendUserAgent = 1 << 5;
static const unsigned int kBlockByType = 1 << 6;
static const unsigned int kBlockUnsecure = 1 << 7;
// Aggregate filter types:
static const unsigned int kBlockRequest = kBlockAll | kBlockUnsecure;
static const unsigned int kBlockResponse = kBlockByType;
static const unsigned int kModifySentHeaders =
kDontSendCookies | kDontSendUserAgent | kDontSendReferrer;
static const unsigned int kModifyReceivedHeaders =
kDontPersistCookies | kDontStoreCookies;
static const unsigned int kFilterByHeaders = kModifyReceivedHeaders |
kBlockByType;
// Key used to access data attached to URLRequest objects.
static const void* const kRequestDataKey;
// A single blacklist entry which is returned when a URL matches one of
// the patterns. Entry objects are owned by the Blacklist that stores them.
class Entry {
public:
// Returns the pattern which this entry matches.
const std::string& pattern() const { return pattern_; }
// Bitfield of filter-attributes matching the pattern.
unsigned int attributes() const { return attributes_; }
// Returns true if the given type matches one of the types for which
// the filter-attributes of this pattern apply. This needs only to be
// checked for content-type specific rules, as determined by calling
// attributes().
bool MatchType(const std::string&) const;
// Returns true of the given URL is blocked, assumes it matches the
// pattern of this entry.
bool IsBlocked(const GURL&) const;
private:
Entry(const std::string& pattern, unsigned int attributes);
void AddType(const std::string& type);
std::string pattern_;
unsigned int attributes_;
scoped_ptr< std::vector<std::string> > types_;
friend class Blacklist; // Only Blacklist can create an entry.
};
// When a request matches a Blacklist rule but the rule must be applied
// after the request has started, we tag it with this user data to
// avoid doing lookups more than once per request. The Entry is owned
// be the blacklist, so this indirection makes sure that it does not
// get destroyed by the Blacklist.
class RequestData : public URLRequest::UserData {
public:
explicit RequestData(const Entry* entry) : entry_(entry) {}
const Entry* entry() const { return entry_; }
private:
const Entry* const entry_;
};
// Constructs a Blacklist given the filename of the persistent version.
//
// For startup efficiency, and because the blacklist must be available
// before any http request is made (including the homepage, if one is
// set to be loaded at startup), it is important to load the blacklist
// from a local source as efficiently as possible. For this reason, the
// combined rules from all active blacklists are stored in one local file.
explicit Blacklist(const FilePath& path);
// Destructor.
~Blacklist();
// Returns a pointer to the Blacklist-owned entry which matches the given
// URL. If no matching Entry is found, returns null.
const Entry* findMatch(const GURL&) const;
// Helper to remove cookies from a header.
static std::string StripCookies(const std::string&);
// Helper to remove cookie expiration from a header.
static std::string StripCookieExpiry(const std::string&);
private:
std::vector<Entry*> blacklist_;
DISALLOW_COPY_AND_ASSIGN(Blacklist);
};
#endif
|
