зеркало из https://github.com/mozilla/gecko-dev.git
292 строки
8.8 KiB
C++
292 строки
8.8 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "ChromiumCDMAdapter.h"
|
|
#include "content_decryption_module.h"
|
|
#include "content_decryption_module_ext.h"
|
|
#include "VideoUtils.h"
|
|
#include "gmp-api/gmp-entrypoints.h"
|
|
#include "gmp-api/gmp-video-codec.h"
|
|
#include "WidevineUtils.h"
|
|
#include "GMPLog.h"
|
|
#include "mozilla/Move.h"
|
|
|
|
#ifdef XP_WIN
|
|
#include "WinUtils.h"
|
|
#include "nsWindowsDllInterceptor.h"
|
|
#include <windows.h>
|
|
#include <strsafe.h>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
#else
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#endif
|
|
|
|
const GMPPlatformAPI* sPlatform = nullptr;
|
|
|
|
namespace mozilla {
|
|
|
|
#ifdef XP_WIN
|
|
static void InitializeHooks();
|
|
#endif
|
|
|
|
ChromiumCDMAdapter::ChromiumCDMAdapter(
|
|
nsTArray<Pair<nsCString, nsCString>>&& aHostPathPairs) {
|
|
#ifdef XP_WIN
|
|
InitializeHooks();
|
|
#endif
|
|
PopulateHostFiles(std::move(aHostPathPairs));
|
|
}
|
|
|
|
void ChromiumCDMAdapter::SetAdaptee(PRLibrary* aLib) { mLib = aLib; }
|
|
|
|
void* ChromiumCdmHost(int aHostInterfaceVersion, void* aUserData) {
|
|
GMP_LOG("ChromiumCdmHostFunc(%d, %p)", aHostInterfaceVersion, aUserData);
|
|
if (aHostInterfaceVersion != cdm::Host_9::kVersion &&
|
|
aHostInterfaceVersion != cdm::Host_10::kVersion) {
|
|
return nullptr;
|
|
}
|
|
return aUserData;
|
|
}
|
|
|
|
#define STRINGIFY(s) _STRINGIFY(s)
|
|
#define _STRINGIFY(s) #s
|
|
|
|
#ifdef MOZILLA_OFFICIAL
|
|
static cdm::HostFile TakeToCDMHostFile(HostFileData& aHostFileData) {
|
|
return cdm::HostFile(aHostFileData.mBinary.Path().get(),
|
|
aHostFileData.mBinary.TakePlatformFile(),
|
|
aHostFileData.mSig.TakePlatformFile());
|
|
}
|
|
#endif
|
|
|
|
GMPErr ChromiumCDMAdapter::GMPInit(const GMPPlatformAPI* aPlatformAPI) {
|
|
GMP_LOG("ChromiumCDMAdapter::GMPInit");
|
|
sPlatform = aPlatformAPI;
|
|
if (!mLib) {
|
|
return GMPGenericErr;
|
|
}
|
|
|
|
#ifdef MOZILLA_OFFICIAL
|
|
// Note: we must call the VerifyCdmHost_0 function if it's present before
|
|
// we call the initialize function.
|
|
auto verify = reinterpret_cast<decltype(::VerifyCdmHost_0)*>(
|
|
PR_FindFunctionSymbol(mLib, STRINGIFY(VerifyCdmHost_0)));
|
|
if (verify) {
|
|
nsTArray<cdm::HostFile> files;
|
|
for (HostFileData& hostFile : mHostFiles) {
|
|
files.AppendElement(TakeToCDMHostFile(hostFile));
|
|
}
|
|
bool result = verify(files.Elements(), files.Length());
|
|
GMP_LOG("%s VerifyCdmHost_0 returned %d", __func__, result);
|
|
}
|
|
#endif
|
|
|
|
auto init = reinterpret_cast<decltype(::INITIALIZE_CDM_MODULE)*>(
|
|
PR_FindFunctionSymbol(mLib, STRINGIFY(INITIALIZE_CDM_MODULE)));
|
|
if (!init) {
|
|
return GMPGenericErr;
|
|
}
|
|
|
|
GMP_LOG(STRINGIFY(INITIALIZE_CDM_MODULE) "()");
|
|
init();
|
|
|
|
return GMPNoErr;
|
|
}
|
|
|
|
GMPErr ChromiumCDMAdapter::GMPGetAPI(const char* aAPIName, void* aHostAPI,
|
|
void** aPluginAPI, uint32_t aDecryptorId) {
|
|
GMP_LOG("ChromiumCDMAdapter::GMPGetAPI(%s, 0x%p, 0x%p, %u) this=0x%p",
|
|
aAPIName, aHostAPI, aPluginAPI, aDecryptorId, this);
|
|
bool isCDM10 = !strcmp(aAPIName, CHROMIUM_CDM_API);
|
|
bool isCDM9 = !strcmp(aAPIName, CHROMIUM_CDM_API_BACKWARD_COMPAT);
|
|
if (isCDM9 || isCDM10) {
|
|
auto create = reinterpret_cast<decltype(::CreateCdmInstance)*>(
|
|
PR_FindFunctionSymbol(mLib, "CreateCdmInstance"));
|
|
if (!create) {
|
|
GMP_LOG(
|
|
"ChromiumCDMAdapter::GMPGetAPI(%s, 0x%p, 0x%p, %u) this=0x%p "
|
|
"FAILED to find CreateCdmInstance",
|
|
aAPIName, aHostAPI, aPluginAPI, aDecryptorId, this);
|
|
return GMPGenericErr;
|
|
}
|
|
|
|
int version = isCDM9 ? cdm::ContentDecryptionModule_9::kVersion
|
|
: cdm::ContentDecryptionModule_10::kVersion;
|
|
void* cdm =
|
|
create(version, kEMEKeySystemWidevine.get(),
|
|
kEMEKeySystemWidevine.Length(), &ChromiumCdmHost, aHostAPI);
|
|
if (!cdm) {
|
|
GMP_LOG(
|
|
"ChromiumCDMAdapter::GMPGetAPI(%s, 0x%p, 0x%p, %u) this=0x%p "
|
|
"FAILED to create cdm version %d",
|
|
aAPIName, aHostAPI, aPluginAPI, aDecryptorId, this, version);
|
|
return GMPGenericErr;
|
|
}
|
|
GMP_LOG("cdm: 0x%p, version: %d", cdm, version);
|
|
*aPluginAPI = cdm;
|
|
}
|
|
return *aPluginAPI ? GMPNoErr : GMPNotImplementedErr;
|
|
}
|
|
|
|
void ChromiumCDMAdapter::GMPShutdown() {
|
|
GMP_LOG("ChromiumCDMAdapter::GMPShutdown()");
|
|
|
|
decltype(::DeinitializeCdmModule)* deinit;
|
|
deinit =
|
|
(decltype(deinit))(PR_FindFunctionSymbol(mLib, "DeinitializeCdmModule"));
|
|
if (deinit) {
|
|
GMP_LOG("DeinitializeCdmModule()");
|
|
deinit();
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
bool ChromiumCDMAdapter::Supports(int32_t aModuleVersion,
|
|
int32_t aInterfaceVersion,
|
|
int32_t aHostVersion) {
|
|
return aModuleVersion == CDM_MODULE_VERSION &&
|
|
(aInterfaceVersion == cdm::ContentDecryptionModule_9::kVersion ||
|
|
aInterfaceVersion == cdm::ContentDecryptionModule_10::kVersion) &&
|
|
(aHostVersion == cdm::Host_9::kVersion ||
|
|
aHostVersion == cdm::Host_10::kVersion);
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
|
|
static WindowsDllInterceptor sKernel32Intercept;
|
|
|
|
typedef DWORD(WINAPI* QueryDosDeviceWFnPtr)(_In_opt_ LPCWSTR lpDeviceName,
|
|
_Out_ LPWSTR lpTargetPath,
|
|
_In_ DWORD ucchMax);
|
|
|
|
static WindowsDllInterceptor::FuncHookType<QueryDosDeviceWFnPtr>
|
|
sOriginalQueryDosDeviceWFnPtr;
|
|
|
|
static std::unordered_map<std::wstring, std::wstring>* sDeviceNames = nullptr;
|
|
|
|
DWORD WINAPI QueryDosDeviceWHook(LPCWSTR lpDeviceName, LPWSTR lpTargetPath,
|
|
DWORD ucchMax) {
|
|
if (!sDeviceNames) {
|
|
return 0;
|
|
}
|
|
std::wstring name = std::wstring(lpDeviceName);
|
|
auto iter = sDeviceNames->find(name);
|
|
if (iter == sDeviceNames->end()) {
|
|
return 0;
|
|
}
|
|
const std::wstring& device = iter->second;
|
|
if (device.size() + 1 > ucchMax) {
|
|
return 0;
|
|
}
|
|
PodCopy(lpTargetPath, device.c_str(), device.size());
|
|
lpTargetPath[device.size()] = 0;
|
|
GMP_LOG("QueryDosDeviceWHook %S -> %S", lpDeviceName, lpTargetPath);
|
|
return name.size();
|
|
}
|
|
|
|
static std::vector<std::wstring> GetDosDeviceNames() {
|
|
std::vector<std::wstring> v;
|
|
std::vector<wchar_t> buf;
|
|
buf.resize(1024);
|
|
DWORD rv = GetLogicalDriveStringsW(buf.size(), buf.data());
|
|
if (rv == 0 || rv > buf.size()) {
|
|
return v;
|
|
}
|
|
|
|
// buf will be a list of null terminated strings, with the last string
|
|
// being 0 length.
|
|
const wchar_t* p = buf.data();
|
|
const wchar_t* end = &buf.back();
|
|
size_t l;
|
|
while (p < end && (l = wcsnlen_s(p, end - p)) > 0) {
|
|
// The string is of the form "C:\". We need to strip off the trailing
|
|
// backslash.
|
|
std::wstring drive = std::wstring(p, p + l);
|
|
if (drive.back() == '\\') {
|
|
drive.erase(drive.end() - 1);
|
|
}
|
|
v.push_back(move(drive));
|
|
p += l + 1;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
static std::wstring GetDeviceMapping(const std::wstring& aDosDeviceName) {
|
|
wchar_t buf[MAX_PATH] = {0};
|
|
DWORD rv = QueryDosDeviceW(aDosDeviceName.c_str(), buf, MAX_PATH);
|
|
if (rv == 0) {
|
|
return std::wstring(L"");
|
|
}
|
|
return std::wstring(buf, buf + rv);
|
|
}
|
|
|
|
static void InitializeHooks() {
|
|
static bool initialized = false;
|
|
if (initialized) {
|
|
return;
|
|
}
|
|
initialized = true;
|
|
sDeviceNames = new std::unordered_map<std::wstring, std::wstring>();
|
|
for (const std::wstring& name : GetDosDeviceNames()) {
|
|
sDeviceNames->emplace(name, GetDeviceMapping(name));
|
|
}
|
|
|
|
sKernel32Intercept.Init("kernelbase.dll");
|
|
sOriginalQueryDosDeviceWFnPtr.Set(sKernel32Intercept, "QueryDosDeviceW",
|
|
&QueryDosDeviceWHook);
|
|
}
|
|
#endif
|
|
|
|
HostFile::HostFile(HostFile&& aOther)
|
|
: mPath(aOther.mPath), mFile(aOther.TakePlatformFile()) {}
|
|
|
|
HostFile::~HostFile() {
|
|
if (mFile != cdm::kInvalidPlatformFile) {
|
|
#ifdef XP_WIN
|
|
CloseHandle(mFile);
|
|
#else
|
|
close(mFile);
|
|
#endif
|
|
mFile = cdm::kInvalidPlatformFile;
|
|
}
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
HostFile::HostFile(const nsCString& aPath)
|
|
: mPath(NS_ConvertUTF8toUTF16(aPath)) {
|
|
HANDLE handle =
|
|
CreateFileW(mPath.get(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, 0, NULL);
|
|
mFile = (handle == INVALID_HANDLE_VALUE) ? cdm::kInvalidPlatformFile : handle;
|
|
}
|
|
#endif
|
|
|
|
#ifndef XP_WIN
|
|
HostFile::HostFile(const nsCString& aPath) : mPath(aPath) {
|
|
// Note: open() returns -1 on failure; i.e. kInvalidPlatformFile.
|
|
mFile = open(aPath.get(), O_RDONLY);
|
|
}
|
|
#endif
|
|
|
|
cdm::PlatformFile HostFile::TakePlatformFile() {
|
|
cdm::PlatformFile f = mFile;
|
|
mFile = cdm::kInvalidPlatformFile;
|
|
return f;
|
|
}
|
|
|
|
void ChromiumCDMAdapter::PopulateHostFiles(
|
|
nsTArray<Pair<nsCString, nsCString>>&& aHostPathPairs) {
|
|
for (const auto& pair : aHostPathPairs) {
|
|
mHostFiles.AppendElement(HostFileData(mozilla::HostFile(pair.first()),
|
|
mozilla::HostFile(pair.second())));
|
|
}
|
|
}
|
|
|
|
} // namespace mozilla
|