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/files/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
18namespace content {
19namespace {
20
21// The maximum number of plugins allowed to be registered from command line.
22const size_t kMaxPluginsToRegisterFromCommandLine = 64;
23
24// Appends any plugins from the command line to the given vector.
25void 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 (base::CommandLine::ForCurrentProcess()->HasSwitch(
40          switches::kPpapiInProcess))
41    out_of_process = false;
42
43  const std::string value =
44      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
45          switches::kRegisterPepperPlugins);
46  if (value.empty())
47    return;
48
49  // FORMAT:
50  // command-line = <plugin-entry> + *( LWS + "," + LWS + <plugin-entry> )
51  // plugin-entry =
52  //    <file-path> +
53  //    ["#" + <name> + ["#" + <description> + ["#" + <version>]]] +
54  //    *1( LWS + ";" + LWS + <mime-type> )
55  std::vector<std::string> modules;
56  base::SplitString(value, ',', &modules);
57
58  size_t plugins_to_register = modules.size();
59  if (plugins_to_register > kMaxPluginsToRegisterFromCommandLine) {
60    VLOG(1) << plugins_to_register << " pepper plugins registered from"
61        << " command line which exceeds the limit (maximum "
62        << kMaxPluginsToRegisterFromCommandLine << " plugins allowed)";
63    plugins_to_register = kMaxPluginsToRegisterFromCommandLine;
64  }
65
66  for (size_t i = 0; i < plugins_to_register; ++i) {
67    std::vector<std::string> parts;
68    base::SplitString(modules[i], ';', &parts);
69    if (parts.size() < 2) {
70      VLOG(1) << "Required mime-type not found";
71      continue;
72    }
73
74    std::vector<std::string> name_parts;
75    base::SplitString(parts[0], '#', &name_parts);
76
77    PepperPluginInfo plugin;
78    plugin.is_out_of_process = out_of_process;
79#if defined(OS_WIN)
80    // This means we can't provide plugins from non-ASCII paths, but
81    // since this switch is only for development I don't think that's
82    // too awful.
83    plugin.path = base::FilePath(base::ASCIIToUTF16(name_parts[0]));
84#else
85    plugin.path = base::FilePath(name_parts[0]);
86#endif
87
88    uint64 index_mask = 1ULL << i;
89    if (!(skip_file_check_flags & index_mask)) {
90      if (base::PathExists(plugin.path)) {
91        skip_file_check_flags |= index_mask;
92      } else {
93        VLOG(1) << "Plugin doesn't exist: " << plugin.path.MaybeAsASCII();
94        continue;
95      }
96    }
97
98    if (name_parts.size() > 1)
99      plugin.name = name_parts[1];
100    if (name_parts.size() > 2)
101      plugin.description = name_parts[2];
102    if (name_parts.size() > 3)
103      plugin.version = name_parts[3];
104    for (size_t j = 1; j < parts.size(); ++j) {
105      WebPluginMimeType mime_type(parts[j],
106                                  std::string(),
107                                  plugin.description);
108      plugin.mime_types.push_back(mime_type);
109    }
110
111    // If the plugin name is empty, use the filename.
112    if (plugin.name.empty()) {
113      plugin.name =
114          base::UTF16ToUTF8(plugin.path.BaseName().LossyDisplayName());
115    }
116
117    // Command-line plugins get full permissions.
118    plugin.permissions = ppapi::PERMISSION_ALL_BITS;
119
120    plugins->push_back(plugin);
121  }
122}
123
124}  // namespace
125
126bool MakePepperPluginInfo(const WebPluginInfo& webplugin_info,
127                          PepperPluginInfo* pepper_info) {
128  if (!webplugin_info.is_pepper_plugin())
129    return false;
130
131  pepper_info->is_out_of_process =
132      webplugin_info.type == WebPluginInfo::PLUGIN_TYPE_PEPPER_OUT_OF_PROCESS ||
133      webplugin_info.type == WebPluginInfo::PLUGIN_TYPE_PEPPER_UNSANDBOXED;
134  pepper_info->is_sandboxed = webplugin_info.type !=
135      WebPluginInfo::PLUGIN_TYPE_PEPPER_UNSANDBOXED;
136
137  pepper_info->path = base::FilePath(webplugin_info.path);
138  pepper_info->name = base::UTF16ToASCII(webplugin_info.name);
139  pepper_info->description = base::UTF16ToASCII(webplugin_info.desc);
140  pepper_info->version = base::UTF16ToASCII(webplugin_info.version);
141  pepper_info->mime_types = webplugin_info.mime_types;
142  pepper_info->permissions = webplugin_info.pepper_permissions;
143
144  return true;
145}
146
147void ComputePepperPluginList(std::vector<PepperPluginInfo>* plugins) {
148  GetContentClient()->AddPepperPlugins(plugins);
149  ComputePluginsFromCommandLine(plugins);
150}
151
152}  // namespace content
153