Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(51)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/common/extensions/api/sockets/sockets_manifest_permission.cc

Issue 217263002: Move sockets manifest types to //extensions. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « chrome/common/extensions/api/sockets/sockets_manifest_permission.h ('k') | chrome/common/extensions/api/sockets/sockets_manifest_permission_unittest.cc » ('j') | extensions/common/api/manifest_types.json » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2013 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 "chrome/common/extensions/api/sockets/sockets_manifest_permission.h"
6
7 #include "base/memory/scoped_ptr.h"
8 #include "base/stl_util.h"
9 #include "base/strings/utf_string_conversions.h"
10 #include "base/values.h"
11 #include "chrome/common/extensions/api/manifest_types.h"
12 #include "chrome/common/extensions/api/sockets/sockets_manifest_data.h"
13 #include "extensions/common/error_utils.h"
14 #include "extensions/common/extension_messages.h"
15 #include "extensions/common/manifest_constants.h"
16 #include "grit/generated_resources.h"
17 #include "ipc/ipc_message.h"
18 #include "ui/base/l10n/l10n_util.h"
19
20 namespace extensions {
21
22 namespace sockets_errors {
23 const char kErrorInvalidHostPattern[] = "Invalid host:port pattern '*'";
24 }
25
26 namespace errors = sockets_errors;
27 using api::manifest_types::Sockets;
28 using api::manifest_types::SocketHostPatterns;
29 using content::SocketPermissionRequest;
30
31 namespace {
32
33 static bool ParseHostPattern(
34 SocketsManifestPermission* permission,
35 content::SocketPermissionRequest::OperationType operation_type,
36 const std::string& host_pattern,
37 base::string16* error) {
38 SocketPermissionEntry entry;
39 if (!SocketPermissionEntry::ParseHostPattern(
40 operation_type, host_pattern, &entry)) {
41 *error = ErrorUtils::FormatErrorMessageUTF16(
42 errors::kErrorInvalidHostPattern, host_pattern);
43 return false;
44 }
45 permission->AddPermission(entry);
46 return true;
47 }
48
49 static bool ParseHostPatterns(
50 SocketsManifestPermission* permission,
51 content::SocketPermissionRequest::OperationType operation_type,
52 const scoped_ptr<SocketHostPatterns>& host_patterns,
53 base::string16* error) {
54 if (!host_patterns)
55 return true;
56
57 if (host_patterns->as_string) {
58 return ParseHostPattern(permission, operation_type,
59 *host_patterns->as_string, error);
60 }
61
62 CHECK(host_patterns->as_strings);
63 for (std::vector<std::string>::const_iterator it =
64 host_patterns->as_strings->begin();
65 it != host_patterns->as_strings->end(); ++it) {
66 if (!ParseHostPattern(permission, operation_type, *it, error)) {
67 return false;
68 }
69 }
70 return true;
71 }
72
73 static void SetHostPatterns(
74 scoped_ptr<SocketHostPatterns>& host_patterns,
75 const SocketsManifestPermission* permission,
76 content::SocketPermissionRequest::OperationType operation_type) {
77 host_patterns.reset(new SocketHostPatterns());
78 host_patterns->as_strings.reset(new std::vector<std::string>());
79 for (SocketsManifestPermission::SocketPermissionEntrySet::const_iterator it =
80 permission->entries().begin(); it != permission->entries().end() ; ++it) {
81 if (it->pattern().type == operation_type) {
82 host_patterns->as_strings->push_back(it->GetHostPatternAsString());
83 }
84 }
85 }
86
87 } // namespace
88
89 SocketsManifestPermission::SocketsManifestPermission() {}
90
91 SocketsManifestPermission::~SocketsManifestPermission() {}
92
93 // static
94 scoped_ptr<SocketsManifestPermission> SocketsManifestPermission::FromValue(
95 const base::Value& value,
96 base::string16* error) {
97 scoped_ptr<Sockets> sockets = Sockets::FromValue(value, error);
98 if (!sockets)
99 return scoped_ptr<SocketsManifestPermission>();
100
101 scoped_ptr<SocketsManifestPermission> result(new SocketsManifestPermission());
102 if (sockets->udp) {
103 if (!ParseHostPatterns(result.get(),
104 SocketPermissionRequest::UDP_BIND,
105 sockets->udp->bind,
106 error)) {
107 return scoped_ptr<SocketsManifestPermission>();
108 }
109 if (!ParseHostPatterns(result.get(),
110 SocketPermissionRequest::UDP_SEND_TO,
111 sockets->udp->send,
112 error)) {
113 return scoped_ptr<SocketsManifestPermission>();
114 }
115 if (!ParseHostPatterns(result.get(),
116 SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
117 sockets->udp->multicast_membership,
118 error)) {
119 return scoped_ptr<SocketsManifestPermission>();
120 }
121 }
122 if (sockets->tcp) {
123 if (!ParseHostPatterns(result.get(),
124 SocketPermissionRequest::TCP_CONNECT,
125 sockets->tcp->connect,
126 error)) {
127 return scoped_ptr<SocketsManifestPermission>();
128 }
129 }
130 if (sockets->tcp_server) {
131 if (!ParseHostPatterns(result.get(),
132 SocketPermissionRequest::TCP_LISTEN,
133 sockets->tcp_server->listen,
134 error)) {
135 return scoped_ptr<SocketsManifestPermission>();
136 }
137 }
138 return result.Pass();
139 }
140
141 bool SocketsManifestPermission::CheckRequest(
142 const Extension* extension,
143 const SocketPermissionRequest& request) const {
144 for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
145 it != permissions_.end(); ++it) {
146 if (it->Check(request))
147 return true;
148 }
149 return false;
150 }
151
152 std::string SocketsManifestPermission::name() const {
153 return manifest_keys::kSockets;
154 }
155
156 std::string SocketsManifestPermission::id() const {
157 return name();
158 }
159
160 bool SocketsManifestPermission::HasMessages() const {
161 bool is_empty = permissions_.empty();
162 return !is_empty;
163 }
164
165 PermissionMessages SocketsManifestPermission::GetMessages() const {
166 // TODO(rpaquay): This function and callees is (almost) a copy/paste
167 // from extensions::SocketPermissiona.
168 PermissionMessages result;
169 if (!AddAnyHostMessage(result)) {
170 AddSpecificHostMessage(result);
171 AddSubdomainHostMessage(result);
172 }
173 AddNetworkListMessage(result);
174 return result;
175 }
176
177 bool SocketsManifestPermission::FromValue(const base::Value* value) {
178 if (!value)
179 return false;
180 base::string16 error;
181 scoped_ptr<SocketsManifestPermission> manifest_permission(
182 SocketsManifestPermission::FromValue(*value, &error));
183
184 if (!manifest_permission)
185 return false;
186
187 permissions_ = manifest_permission->permissions_;
188 return true;
189 }
190
191 scoped_ptr<base::Value> SocketsManifestPermission::ToValue() const {
192 Sockets sockets;
193
194 sockets.udp.reset(new Sockets::Udp());
195 SetHostPatterns(sockets.udp->bind, this,
196 SocketPermissionRequest::UDP_BIND);
197 SetHostPatterns(sockets.udp->send, this,
198 SocketPermissionRequest::UDP_SEND_TO);
199 SetHostPatterns(sockets.udp->multicast_membership, this,
200 SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP);
201 if (sockets.udp->bind->as_strings->size() == 0 &&
202 sockets.udp->send->as_strings->size() == 0 &&
203 sockets.udp->multicast_membership->as_strings->size() == 0) {
204 sockets.udp.reset(NULL);
205 }
206
207 sockets.tcp.reset(new Sockets::Tcp());
208 SetHostPatterns(sockets.tcp->connect, this,
209 SocketPermissionRequest::TCP_CONNECT);
210 if (sockets.tcp->connect->as_strings->size() == 0) {
211 sockets.tcp.reset(NULL);
212 }
213
214 sockets.tcp_server.reset(new Sockets::TcpServer());
215 SetHostPatterns(sockets.tcp_server->listen, this,
216 SocketPermissionRequest::TCP_LISTEN);
217 if (sockets.tcp_server->listen->as_strings->size() == 0) {
218 sockets.tcp_server.reset(NULL);
219 }
220
221 return scoped_ptr<base::Value>(sockets.ToValue().release()).Pass();
222 }
223
224 ManifestPermission* SocketsManifestPermission::Clone() const {
225 scoped_ptr<SocketsManifestPermission> result(new SocketsManifestPermission());
226 result->permissions_ = permissions_;
227 return result.release();
228 }
229
230 ManifestPermission* SocketsManifestPermission::Diff(
231 const ManifestPermission* rhs) const {
232 const SocketsManifestPermission* other =
233 static_cast<const SocketsManifestPermission*>(rhs);
234
235 scoped_ptr<SocketsManifestPermission> result(new SocketsManifestPermission());
236 result->permissions_ = base::STLSetDifference<SocketPermissionEntrySet>(
237 permissions_, other->permissions_);
238 return result.release();
239 }
240
241 ManifestPermission* SocketsManifestPermission::Union(
242 const ManifestPermission* rhs) const {
243 const SocketsManifestPermission* other =
244 static_cast<const SocketsManifestPermission*>(rhs);
245
246 scoped_ptr<SocketsManifestPermission> result(new SocketsManifestPermission());
247 result->permissions_ = base::STLSetUnion<SocketPermissionEntrySet>(
248 permissions_, other->permissions_);
249 return result.release();
250 }
251
252 ManifestPermission* SocketsManifestPermission::Intersect(
253 const ManifestPermission* rhs) const {
254 const SocketsManifestPermission* other =
255 static_cast<const SocketsManifestPermission*>(rhs);
256
257 scoped_ptr<SocketsManifestPermission> result(new SocketsManifestPermission());
258 result->permissions_ = base::STLSetIntersection<SocketPermissionEntrySet>(
259 permissions_, other->permissions_);
260 return result.release();
261 }
262
263 bool SocketsManifestPermission::Contains(const ManifestPermission* rhs) const {
264 const SocketsManifestPermission* other =
265 static_cast<const SocketsManifestPermission*>(rhs);
266
267 return base::STLIncludes<SocketPermissionEntrySet>(permissions_,
268 other->permissions_);
269 }
270
271 bool SocketsManifestPermission::Equal(const ManifestPermission* rhs) const {
272 const SocketsManifestPermission* other =
273 static_cast<const SocketsManifestPermission*>(rhs);
274
275 return (permissions_ == other->permissions_);
276 }
277
278 void SocketsManifestPermission::Write(IPC::Message* m) const {
279 IPC::WriteParam(m, permissions_);
280 }
281
282 bool SocketsManifestPermission::Read(const IPC::Message* m,
283 PickleIterator* iter) {
284 return IPC::ReadParam(m, iter, &permissions_);
285 }
286
287 void SocketsManifestPermission::Log(std::string* log) const {
288 IPC::LogParam(permissions_, log);
289 }
290
291 void SocketsManifestPermission::AddPermission(
292 const SocketPermissionEntry& entry) {
293 permissions_.insert(entry);
294 }
295
296 bool SocketsManifestPermission::AddAnyHostMessage(
297 PermissionMessages& messages) const {
298 for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
299 it != permissions_.end(); ++it) {
300 if (it->IsAddressBoundType() &&
301 it->GetHostType() == SocketPermissionEntry::ANY_HOST) {
302 messages.push_back(PermissionMessage(
303 PermissionMessage::kSocketAnyHost,
304 l10n_util::GetStringUTF16(
305 IDS_EXTENSION_PROMPT_WARNING_SOCKET_ANY_HOST)));
306 return true;
307 }
308 }
309 return false;
310 }
311
312 void SocketsManifestPermission::AddSubdomainHostMessage(
313 PermissionMessages& messages) const {
314 std::set<base::string16> domains;
315 for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
316 it != permissions_.end(); ++it) {
317 if (it->GetHostType() == SocketPermissionEntry::HOSTS_IN_DOMAINS)
318 domains.insert(base::UTF8ToUTF16(it->pattern().host));
319 }
320 if (!domains.empty()) {
321 int id = (domains.size() == 1) ?
322 IDS_EXTENSION_PROMPT_WARNING_SOCKET_HOSTS_IN_DOMAIN :
323 IDS_EXTENSION_PROMPT_WARNING_SOCKET_HOSTS_IN_DOMAINS;
324 messages.push_back(PermissionMessage(
325 PermissionMessage::kSocketDomainHosts,
326 l10n_util::GetStringFUTF16(
327 id,
328 JoinString(
329 std::vector<base::string16>(
330 domains.begin(), domains.end()), ' '))));
331 }
332 }
333
334 void SocketsManifestPermission::AddSpecificHostMessage(
335 PermissionMessages& messages) const {
336 std::set<base::string16> hostnames;
337 for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
338 it != permissions_.end(); ++it) {
339 if (it->GetHostType() == SocketPermissionEntry::SPECIFIC_HOSTS)
340 hostnames.insert(base::UTF8ToUTF16(it->pattern().host));
341 }
342 if (!hostnames.empty()) {
343 int id = (hostnames.size() == 1) ?
344 IDS_EXTENSION_PROMPT_WARNING_SOCKET_SPECIFIC_HOST :
345 IDS_EXTENSION_PROMPT_WARNING_SOCKET_SPECIFIC_HOSTS;
346 messages.push_back(PermissionMessage(
347 PermissionMessage::kSocketSpecificHosts,
348 l10n_util::GetStringFUTF16(
349 id,
350 JoinString(
351 std::vector<base::string16>(
352 hostnames.begin(), hostnames.end()), ' '))));
353 }
354 }
355
356 void SocketsManifestPermission::AddNetworkListMessage(
357 PermissionMessages& messages) const {
358 for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
359 it != permissions_.end(); ++it) {
360 if (it->pattern().type == SocketPermissionRequest::NETWORK_STATE) {
361 messages.push_back(PermissionMessage(
362 PermissionMessage::kNetworkState,
363 l10n_util::GetStringUTF16(
364 IDS_EXTENSION_PROMPT_WARNING_NETWORK_STATE)));
365 }
366 }
367 }
368
369 } // namespace extensions
OLDNEW
« no previous file with comments | « chrome/common/extensions/api/sockets/sockets_manifest_permission.h ('k') | chrome/common/extensions/api/sockets/sockets_manifest_permission_unittest.cc » ('j') | extensions/common/api/manifest_types.json » ('J')

Powered by Google App Engine
This is Rietveld 408576698