| OLD | NEW |
|---|
| (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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 217263002:
Move sockets manifest types to //extensions. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src