// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif
#include "chrome/installer/mini_installer/decompress.h"
#include <windows.h>
#include <fcntl.h> // for _O_* constants
#include <fdi.h>
#include <stddef.h>
#include <stdlib.h>
#include "chrome/installer/mini_installer/mini_file.h"
namespace {
// A simple struct to hold data passed to and from FDICopy via its |pvUser|
// argument.
struct ExpandContext {
// The path to the single destination file.
const wchar_t* const dest_path;
// The destination file; valid once the destination is created.
mini_installer::MiniFile dest_file;
// Set to true if the file was extracted to |dest_path|. Note that |dest_file|
// may be valid even in case of failure.
bool succeeded;
};
FNALLOC(Alloc) {
return ::HeapAlloc(::GetProcessHeap(), 0, cb);
}
FNFREE(Free) {
::HeapFree(::GetProcessHeap(), 0, pv);
}
// Converts a wide string to utf8. Set |len| to -1 if |str| is zero terminated
// and you want to convert the entire string.
// The returned string will have been allocated with Alloc(), so free it
// with a call to Free().
char* WideToUtf8(const wchar_t* str, int len) {
char* ret = nullptr;
int size =
WideCharToMultiByte(CP_UTF8, 0, str, len, nullptr, 0, nullptr, nullptr);
if (size) {
if (len != -1)
++size; // include space for the terminator.
ret = reinterpret_cast<char*>(Alloc(size * sizeof(ret[0])));
if (ret) {
WideCharToMultiByte(CP_UTF8, 0, str, len, ret, size, nullptr, nullptr);
if (len != -1)
ret[size - 1] = '\0'; // terminate the string
}
}
return ret;
}
wchar_t* Utf8ToWide(const char* str) {
wchar_t* ret = nullptr;
int size = MultiByteToWideChar(CP_UTF8, 0, str, -1, nullptr, 0);
if (size) {
ret = reinterpret_cast<wchar_t*>(Alloc(size * sizeof(ret[0])));
if (ret)
MultiByteToWideChar(CP_UTF8, 0, str, -1, ret, size);
}
return ret;
}
template <typename T>
class scoped_ptr {
public:
explicit scoped_ptr(T* a) : a_(a) {}
~scoped_ptr() {
if (a_)
Free(a_);
}
operator T*() { return a_; }
private:
T* a_;
};
FNOPEN(Open) {
DWORD access = 0;
DWORD disposition = 0;
if (oflag & _O_RDWR) {
access = GENERIC_READ | GENERIC_WRITE;
} else if (oflag & _O_WRONLY) {
access = GENERIC_WRITE;
} else {
access = GENERIC_READ;
}
if (oflag & _O_CREAT) {
disposition = CREATE_ALWAYS;
} else {
disposition = OPEN_EXISTING;
}
scoped_ptr<wchar_t> path(Utf8ToWide(pszFile));
HANDLE file =
CreateFileW(path, access, FILE_SHARE_DELETE | FILE_SHARE_READ, nullptr,
disposition, FILE_ATTRIBUTE_NORMAL, nullptr);
return reinterpret_cast<INT_PTR>(file);
}
FNREAD(Read) {
DWORD read = 0;
if (!::ReadFile(reinterpret_cast<HANDLE>(hf), pv, cb, &read, nullptr))
read = static_cast<DWORD>(-1L);
return read;
}
FNWRITE(Write) {
DWORD written = 0;
if (!::WriteFile(reinterpret_cast<HANDLE>(hf), pv, cb, &written, nullptr))
written = static_cast<DWORD>(-1L);
return written;
}
FNCLOSE(Close) {
return ::CloseHandle(reinterpret_cast<HANDLE>(hf)) ? 0 : -1;
}
FNSEEK(Seek) {
return ::SetFilePointer(reinterpret_cast<HANDLE>(hf), dist, nullptr,
seektype);
}
FNFDINOTIFY(Notify) {
// Since we will only ever be decompressing a single file at a time
// we take a shortcut and provide a pointer to the wide destination file
// of the file we want to write. This way we don't have to bother with
// utf8/wide conversion and concatenation of directory and file name.
ExpandContext& context = *reinterpret_cast<ExpandContext*>(pfdin->pv);
switch (fdint) {
case fdintCOPY_FILE:
context.dest_file.Create(context.dest_path);
// By sheer coincidence, CreateFileW's success/failure results match that
// of fdintCOPY_FILE. The handle given out here is closed either by
// FDICopy (in case of error) or below when handling fdintCLOSE_FILE_INFO
// (in case of success).
return reinterpret_cast<INT_PTR>(context.dest_file.DuplicateHandle());
case fdintCLOSE_FILE_INFO: {
// Set the file's creation time and file attributes.
FILE_BASIC_INFO info = {};
FILETIME file_time;
FILETIME local;
if (DosDateTimeToFileTime(pfdin->date, pfdin->time, &file_time) &&
LocalFileTimeToFileTime(&file_time, &local)) {
info.CreationTime.u.LowPart = local.dwLowDateTime;
info.CreationTime.u.HighPart = local.dwHighDateTime;
}
info.FileAttributes =
pfdin->attribs & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE);
::SetFileInformationByHandle(reinterpret_cast<HANDLE>(pfdin->hf),
FileBasicInfo, &info, sizeof(info));
// Close the handle given out above in fdintCOPY_FILE.
::CloseHandle(reinterpret_cast<HANDLE>(pfdin->hf));
context.succeeded = true;
return -1; // Break: the one file was extracted.
}
case fdintCABINET_INFO:
case fdintENUMERATE:
return 0; // Continue: success.
case fdintPARTIAL_FILE:
case fdintNEXT_CABINET:
default:
return -1; // Break: error.
}
}
// Module handle of cabinet.dll
HMODULE g_fdi = nullptr;
// API prototypes.
typedef HFDI(DIAMONDAPI* FDICreateFn)(PFNALLOC alloc,
PFNFREE free,
PFNOPEN open,
PFNREAD read,
PFNWRITE write,
PFNCLOSE close,
PFNSEEK seek,
int cpu_type,
PERF perf);
typedef BOOL(DIAMONDAPI* FDIDestroyFn)(HFDI fdi);
typedef BOOL(DIAMONDAPI* FDICopyFn)(HFDI fdi,
char* cab,
char* cab_path,
int flags,
PFNFDINOTIFY notify,
PFNFDIDECRYPT decrypt,
void* context);
FDICreateFn g_FDICreate = nullptr;
FDIDestroyFn g_FDIDestroy = nullptr;
FDICopyFn g_FDICopy = nullptr;
bool InitializeFdi() {
if (!g_fdi) {
// It has been observed that some users do not have the expected
// environment variables set, so we try a couple that *should* always be
// present and fallback to the default Windows install path if all else
// fails.
// The cabinet.dll should be available on all supported versions of Windows.
static const wchar_t* const candidate_paths[] = {
L"%WINDIR%\\system32\\cabinet.dll",
L"%SYSTEMROOT%\\system32\\cabinet.dll",
L"C:\\Windows\\system32\\cabinet.dll",
};
wchar_t path[MAX_PATH] = {0};
for (size_t i = 0; i < _countof(candidate_paths); ++i) {
path[0] = L'\0';
DWORD result =
::ExpandEnvironmentStringsW(candidate_paths[i], path, _countof(path));
if (result > 0 && result <= _countof(path))
g_fdi = ::LoadLibraryExW(path, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
if (g_fdi)
break;
}
}
if (g_fdi) {
g_FDICreate =
reinterpret_cast<FDICreateFn>(::GetProcAddress(g_fdi, "FDICreate"));
g_FDIDestroy =
reinterpret_cast<FDIDestroyFn>(::GetProcAddress(g_fdi, "FDIDestroy"));
g_FDICopy = reinterpret_cast<FDICopyFn>(::GetProcAddress(g_fdi, "FDICopy"));
}
return g_FDICreate && g_FDIDestroy && g_FDICopy;
}
} // namespace
namespace mini_installer {
bool Expand(const wchar_t* source, const wchar_t* destination) {
if (!InitializeFdi())
return false;
// Start by splitting up the source path and convert to utf8 since the
// cabinet API doesn't support wide strings.
const wchar_t* source_name = source + lstrlenW(source);
while (source_name > source && *source_name != L'\\')
--source_name;
if (source_name == source)
return false;
// Convert the name to utf8.
source_name++;
scoped_ptr<char> source_name_utf8(WideToUtf8(source_name, -1));
// The directory part is assumed to have a trailing backslash.
scoped_ptr<char> source_path_utf8(WideToUtf8(source, source_name - source));
if (!source_name_utf8 || !source_path_utf8)
return false;
ERF erf = {0};
HFDI fdi = g_FDICreate(&Alloc, &Free, &Open, &Read, &Write, &Close, &Seek,
cpuUNKNOWN, &erf);
if (!fdi)
return false;
ExpandContext context = {destination, {}, /*succeeded=*/false};
g_FDICopy(fdi, source_name_utf8, source_path_utf8, 0, &Notify, nullptr,
&context);
g_FDIDestroy(fdi);
if (context.succeeded) {
// https://crbug.com/1443320: We see crashes on Windows 10 when running
// setup.exe in which it appears that an entire hunk of the file is zeros or
// random memory. There is nothing out of the ordinary in the way that this
// file is written (0x8000 byte chunks via normal WriteFile calls). As an
// experiment, flush the file before closing it.
::FlushFileBuffers(context.dest_file.GetHandleUnsafe());
return true;
}
// Delete the output file if it was created.
if (context.dest_file.IsValid())
context.dest_file.DeleteOnClose();
return false;
}
} // namespace mini_installer
Codebase Browser
chromium