| 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_handler.h" | |
| 6 | |
| 7 #include "base/memory/scoped_ptr.h" | |
| 8 #include "base/strings/utf_string_conversions.h" | |
| 9 #include "base/values.h" | |
| 10 #include "chrome/common/extensions/api/manifest_types.h" | |
| 11 #include "chrome/common/extensions/extension.h" | |
| 12 #include "chrome/common/extensions/permissions/permissions_data.h" | |
| 13 #include "chrome/common/extensions/permissions/socket_permission_data.h" | |
| 14 #include "extensions/common/error_utils.h" | |
| 15 #include "extensions/common/manifest_constants.h" | |
| 16 #include "extensions/common/permissions/api_permission_set.h" | |
| 17 | |
| 18 namespace extensions { | |
| 19 | |
| 20 namespace sockets_errors { | |
| 21 const char kErrorInvalidHostPattern[] = "Invalid host:port pattern '*'"; | |
| 22 } | |
| 23 | |
| 24 namespace keys = extensions::manifest_keys; | |
| 25 namespace errors = sockets_errors; | |
| 26 using api::manifest_types::Sockets; | |
| 27 | |
| 28 SocketsHandler::SocketsHandler() {} | |
| 29 | |
| 30 SocketsHandler::~SocketsHandler() {} | |
| 31 | |
| 32 bool SocketsHandler::Parse(Extension* extension, string16* error) { | |
| 33 const base::Value* sockets = NULL; | |
| 34 CHECK(extension->manifest()->Get(keys::kSockets, &sockets)); | |
| 35 std::vector<InstallWarning> install_warnings; | |
| 36 scoped_ptr<SocketsManifestData> data = | |
| 37 SocketsManifestData::FromValue(*sockets, | |
| 38 &install_warnings, | |
| 39 error); | |
| 40 if (!data) | |
| 41 return false; | |
| 42 | |
| 43 extension->AddInstallWarnings(install_warnings); | |
| 44 extension->SetManifestData(keys::kSockets, data.release()); | |
| 45 return true; | |
| 46 } | |
| 47 | |
| 48 const std::vector<std::string> SocketsHandler::Keys() const { | |
| 49 return SingleKey(manifest_keys::kSockets); | |
| 50 } | |
| 51 | |
| 52 SocketsManifestData::SocketsManifestData() {} | |
| 53 SocketsManifestData::~SocketsManifestData() {} | |
| 54 | |
| 55 // static | |
| 56 SocketsManifestData* SocketsManifestData::Get(const Extension* extension) { | |
| 57 return static_cast<SocketsManifestData*>( | |
| 58 extension->GetManifestData(keys::kSockets)); | |
| 59 } | |
| 60 | |
| 61 // static | |
| 62 bool SocketsManifestData::CheckRequest( | |
| 63 const Extension* extension, | |
| 64 const content::SocketPermissionRequest& request) { | |
| 65 SocketsManifestData* data = SocketsManifestData::Get(extension); | |
| 66 if (data == NULL) | |
| 67 return false; | |
| 68 | |
| 69 return data->CheckRequestImpl(extension, request); | |
| 70 } | |
| 71 | |
| 72 // static | |
| 73 scoped_ptr<SocketsManifestData> SocketsManifestData::FromValue( | |
| 74 const base::Value& value, | |
| 75 std::vector<InstallWarning>* install_warnings, | |
| 76 string16* error) { | |
| 77 scoped_ptr<Sockets> sockets = Sockets::FromValue(value, error); | |
| 78 if (!sockets) | |
| 79 return scoped_ptr<SocketsManifestData>(); | |
| 80 | |
| 81 scoped_ptr<SocketsManifestData> result(new SocketsManifestData()); | |
| 82 if (sockets->udp) { | |
| 83 if (!ParseHostPattern(result.get(), | |
| 84 content::SocketPermissionRequest::UDP_BIND, | |
| 85 sockets->udp->bind, | |
| 86 error)) { | |
| 87 return scoped_ptr<SocketsManifestData>(); | |
| 88 } | |
| 89 if (!ParseHostPattern(result.get(), | |
| 90 content::SocketPermissionRequest::UDP_SEND_TO, | |
| 91 sockets->udp->send, | |
| 92 error)) { | |
| 93 return scoped_ptr<SocketsManifestData>(); | |
| 94 } | |
| 95 if (!ParseHostPattern(result.get(), | |
| 96 content::SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, | |
| 97 sockets->udp->multicast_membership, | |
| 98 error)) { | |
| 99 return scoped_ptr<SocketsManifestData>(); | |
| 100 } | |
| 101 } | |
| 102 if (sockets->tcp) { | |
| 103 if (!ParseHostPattern(result.get(), | |
| 104 content::SocketPermissionRequest::TCP_CONNECT, | |
| 105 sockets->tcp->connect, | |
| 106 error)) { | |
| 107 return scoped_ptr<SocketsManifestData>(); | |
| 108 } | |
| 109 } | |
| 110 if (sockets->tcp_server) { | |
| 111 if (!ParseHostPattern(result.get(), | |
| 112 content::SocketPermissionRequest::TCP_LISTEN, | |
| 113 sockets->tcp_server->listen, | |
| 114 error)) { | |
| 115 return scoped_ptr<SocketsManifestData>(); | |
| 116 } | |
| 117 } | |
| 118 return result.Pass(); | |
| 119 } | |
| 120 | |
| 121 // static | |
| 122 bool SocketsManifestData::ParseHostPattern( | |
| 123 SocketsManifestData* manifest_data, | |
| 124 content::SocketPermissionRequest::OperationType operation_type, | |
| 125 const scoped_ptr<std::string>& value, | |
| 126 string16* error) { | |
| 127 if (value) { | |
| 128 SocketPermissionEntry entry; | |
| 129 if (!SocketPermissionEntry::ParseHostPattern( | |
| 130 operation_type, *value, &entry)) { | |
| 131 *error = ErrorUtils::FormatErrorMessageUTF16( | |
| 132 errors::kErrorInvalidHostPattern, *value); | |
| 133 return false; | |
| 134 } | |
| 135 manifest_data->AddPermission(entry); | |
| 136 } | |
| 137 return true; | |
| 138 } | |
| 139 | |
| 140 void SocketsManifestData::AddPermission(const SocketPermissionEntry& entry) { | |
| 141 permissions_.insert(entry); | |
| 142 } | |
| 143 | |
| 144 bool SocketsManifestData::CheckRequestImpl( | |
| 145 const Extension* extension, | |
| 146 const content::SocketPermissionRequest& request) { | |
| 147 for (PermissionSet::const_iterator it = permissions_.begin(); | |
| 148 it != permissions_.end(); ++it) { | |
| 149 if (it->Check(request)) | |
| 150 return true; | |
| 151 } | |
| 152 return false; | |
| 153 } | |
| 154 | |
| 155 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 51433002:
Enable permission warnings from ManifestHandlers. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master