1 // Copyright (c) 2012 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 "content/common/pepper_plugin_list.h" 6 7 #include "base/basictypes.h" 8 #include "base/command_line.h" 9 #include "base/file_util.h" 10 #include "base/strings/string_split.h" 11 #include "base/strings/string_util.h" 12 #include "base/strings/utf_string_conversions.h" 13 #include "content/public/common/content_client.h" 14 #include "content/public/common/content_switches.h" 15 #include "content/public/common/pepper_plugin_info.h" 16 #include "ppapi/shared_impl/ppapi_permissions.h" 17 18 namespace content { 19 namespace { 20 21 // The maximum number of plugins allowed to be registered from command line. 22 const size_t kMaxPluginsToRegisterFromCommandLine = 64; 23 24 // Appends any plugins from the command line to the given vector. 25 void ComputePluginsFromCommandLine(std::vector<PepperPluginInfo>* plugins) { 26 // On Linux, once we're sandboxed, we can't know if a plugin is available or 27 // not. But (on Linux) this function is always called once before we're 28 // sandboxed. So when this function is called for the first time we set a 29 // flag if the plugin file is available. Then we can skip the check on file 30 // existence in subsequent calls if the flag is set. 31 // NOTE: In theory we could have unlimited number of plugins registered in 32 // command line. But in practice, 64 plugins should be more than enough. 33 static uint64 skip_file_check_flags = 0; 34 COMPILE_ASSERT( 35 kMaxPluginsToRegisterFromCommandLine <= sizeof(skip_file_check_flags) * 8, 36 max_plugins_to_register_from_command_line_exceeds_limit); 37 38 bool out_of_process = true; 39 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kPpapiInProcess)) 40 out_of_process = false; 41 42 const std::string value = 43 CommandLine::ForCurrentProcess()->GetSwitchValueASCII( 44 switches::kRegisterPepperPlugins); 45 if (value.empty()) 46 return; 47 48 // FORMAT: 49 // command-line = <plugin-entry> + *( LWS + "," + LWS + <plugin-entry> ) 50 // plugin-entry = 51 // <file-path> + 52 // ["#" + <name> + ["#" + <description> + ["#" + <version>]]] + 53 // *1( LWS + ";" + LWS + <mime-type> ) 54 std::vector<std::string> modules; 55 base::SplitString(value, ',', &modules); 56 57 size_t plugins_to_register = modules.size(); 58 if (plugins_to_register > kMaxPluginsToRegisterFromCommandLine) { 59 VLOG(1) << plugins_to_register << " pepper plugins registered from" 60 << " command line which exceeds the limit (maximum " 61 << kMaxPluginsToRegisterFromCommandLine << " plugins allowed)"; 62 plugins_to_register = kMaxPluginsToRegisterFromCommandLine; 63 } 64 65 for (size_t i = 0; i < plugins_to_register; ++i) { 66 std::vector<std::string> parts; 67 base::SplitString(modules[i], ';', &parts); 68 if (parts.size() < 2) { 69 VLOG(1) << "Required mime-type not found"; 70 continue; 71 } 72 73 std::vector<std::string> name_parts; 74 base::SplitString(parts[0], '#', &name_parts); 75 76 PepperPluginInfo plugin; 77 plugin.is_out_of_process = out_of_process; 78 #if defined(OS_WIN) 79 // This means we can't provide plugins from non-ASCII paths, but 80 // since this switch is only for development I don't think that's 81 // too awful. 82 plugin.path = base::FilePath(base::ASCIIToUTF16(name_parts[0])); 83 #else 84 plugin.path = base::FilePath(name_parts[0]); 85 #endif 86 87 uint64 index_mask = 1ULL << i; 88 if (!(skip_file_check_flags & index_mask)) { 89 if (base::PathExists(plugin.path)) { 90 skip_file_check_flags |= index_mask; 91 } else { 92 VLOG(1) << "Plugin doesn't exist: " << plugin.path.MaybeAsASCII(); 93 continue; 94 } 95 } 96 97 if (name_parts.size() > 1) 98 plugin.name = name_parts[1]; 99 if (name_parts.size() > 2) 100 plugin.description = name_parts[2]; 101 if (name_parts.size() > 3) 102 plugin.version = name_parts[3]; 103 for (size_t j = 1; j < parts.size(); ++j) { 104 WebPluginMimeType mime_type(parts[j], 105 std::string(), 106 plugin.description); 107 plugin.mime_types.push_back(mime_type); 108 } 109 110 // If the plugin name is empty, use the filename. 111 if (plugin.name.empty()) { 112 plugin.name = 113 base::UTF16ToUTF8(plugin.path.BaseName().LossyDisplayName()); 114 } 115 116 // Command-line plugins get full permissions. 117 plugin.permissions = ppapi::PERMISSION_ALL_BITS; 118 119 plugins->push_back(plugin); 120 } 121 } 122 123 } // namespace 124 125 bool MakePepperPluginInfo(const WebPluginInfo& webplugin_info, 126 PepperPluginInfo* pepper_info) { 127 if (!webplugin_info.is_pepper_plugin()) 128 return false; 129 130 pepper_info->is_out_of_process = 131 webplugin_info.type == WebPluginInfo::PLUGIN_TYPE_PEPPER_OUT_OF_PROCESS || 132 webplugin_info.type == WebPluginInfo::PLUGIN_TYPE_PEPPER_UNSANDBOXED; 133 pepper_info->is_sandboxed = webplugin_info.type != 134 WebPluginInfo::PLUGIN_TYPE_PEPPER_UNSANDBOXED; 135 136 pepper_info->path = base::FilePath(webplugin_info.path); 137 pepper_info->name = base::UTF16ToASCII(webplugin_info.name); 138 pepper_info->description = base::UTF16ToASCII(webplugin_info.desc); 139 pepper_info->version = base::UTF16ToASCII(webplugin_info.version); 140 pepper_info->mime_types = webplugin_info.mime_types; 141 pepper_info->permissions = webplugin_info.pepper_permissions; 142 143 return true; 144 } 145 146 void ComputePepperPluginList(std::vector<PepperPluginInfo>* plugins) { 147 GetContentClient()->AddPepperPlugins(plugins); 148 ComputePluginsFromCommandLine(plugins); 149 } 150 151 } // namespace content 152