129 lines
4.8 KiB
C++
129 lines
4.8 KiB
C++
/***
|
|
Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.
|
|
|
|
File: Open.Win32.cpp
|
|
Date: 2021-6-12
|
|
Author: Reece
|
|
***/
|
|
#include <Source/RuntimeInternal.hpp>
|
|
#include "Processes.hpp"
|
|
#include "Open.Win32.hpp"
|
|
|
|
#include <shellapi.h>
|
|
#include <tlhelp32.h>
|
|
|
|
#include <Source/IO/FS/FS.hpp>
|
|
#include "Objbase.h"
|
|
#include "shellapi.h"
|
|
|
|
namespace Aurora::Processes
|
|
{
|
|
static AuList<AuString> gOpenItems;
|
|
static AuThreadPrimitives::ConditionMutexUnique_t gCondMutex;
|
|
static AuThreadPrimitives::ConditionVariableUnique_t gCondVariable;
|
|
static AuThreads::ThreadUnique_t gOpenerThread;
|
|
|
|
static void RunTasks()
|
|
{
|
|
AU_LOCK_GUARD(gCondMutex);
|
|
|
|
while (AuIsThreadRunning())
|
|
{
|
|
try
|
|
{
|
|
for (const auto &open : gOpenItems)
|
|
{
|
|
if (open.empty()) continue; // [*1]
|
|
|
|
ShellExecuteW(nullptr,
|
|
AuIOFS::DirExists(open) ? L"explore" : L"open",
|
|
Locale::ConvertFromUTF8(open).c_str(),
|
|
nullptr,
|
|
nullptr,
|
|
SW_SHOWNORMAL);
|
|
}
|
|
gOpenItems.clear();
|
|
gCondVariable->WaitForSignal();
|
|
}
|
|
catch (...)
|
|
{
|
|
Debug::PrintError();
|
|
AuLogWarn("An error occurred while dispatching a ShellExecute runner frame");
|
|
}
|
|
}
|
|
}
|
|
|
|
static void OpenerThread()
|
|
{
|
|
CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
|
|
RunTasks();
|
|
CoUninitialize();
|
|
}
|
|
|
|
void InitWin32Opener()
|
|
{
|
|
gCondMutex = AuThreadPrimitives::ConditionMutexUnique();
|
|
SysAssert(gCondMutex);
|
|
|
|
gCondVariable = AuThreadPrimitives::ConditionVariableUnique(AuUnsafeRaiiToShared(gCondMutex));
|
|
SysAssert(gCondVariable);
|
|
|
|
gOpenerThread = AuThreads::ThreadUnique(AuThreads::ThreadInfo(
|
|
AuMakeShared<AuThreads::IThreadVectorsFunctional>(AuThreads::IThreadVectorsFunctional::OnEntry_t(std::bind(OpenerThread)),
|
|
AuThreads::IThreadVectorsFunctional::OnExit_t{}),
|
|
"COM ShellExecute Runner"
|
|
));
|
|
SysAssert(gOpenerThread);
|
|
|
|
gOpenerThread->Run();
|
|
}
|
|
|
|
void DeinitWin32Opener()
|
|
{
|
|
gOpenerThread->SendExitSignal();
|
|
gCondVariable->Broadcast();
|
|
gOpenerThread.reset();
|
|
gCondVariable.reset();
|
|
gCondMutex.reset();
|
|
}
|
|
|
|
AUKN_SYM void OpenUri(const AuString &uri)
|
|
{
|
|
AU_LOCK_GUARD(gCondMutex);
|
|
AuTryInsert(gOpenItems, uri);
|
|
gCondVariable->Broadcast();
|
|
}
|
|
|
|
AUKN_SYM void OpenFile(const AuString &file)
|
|
{
|
|
OpenUri(AuIOFS::NormalizePathRet(file));
|
|
}
|
|
}
|
|
|
|
|
|
// TODO: Consider creating blocking apis whose return value is an IProcess (construct from ShellExecuteExW -> in.hProcess, or ("xdg-start", ...))
|
|
// For the most part, blocking for a specific application in the context of a protocol or file open request is a dated computing construct.
|
|
// Nowdays, opening an editor, mail client, or such like means poking a single executable that'll spawn a fuck ton of background workers, io threads,
|
|
// and other resources, to manage multiple instances of whatever the application deals with (think: editor tabs; browser windows; sendto: isnt a modal)
|
|
|
|
// [*1] :
|
|
// We probably ran out of memory.
|
|
// AuProcess/Open can safely drop as we expect shells to be kinda fucky and async
|
|
//
|
|
// Case in point: Minecraft on Linux (would?) blocks when you click a link in chat
|
|
//
|
|
// Fuck tons of applications support clicking of links, in the case of TS and others, allowing for RCE.
|
|
// In the case of MC and others, they don't even know if the operation blocks until the process closes.
|
|
// Assuming non-blocking, the API returns false on failure; but if it's blocking, who knows what that
|
|
// means... Nonzero exit code? Not enough resources? No error?
|
|
//
|
|
// Websites, programs, and scripts wouldn't know how to process "missing protocol handler,"
|
|
// "not enough resources," "process crashed before pump," "shell busy." For the most part, we don't
|
|
// expect expect the developer to be aware of what happens after a request to open a resource is
|
|
// requested. It's a lot of engineering effort for what should be fork, exec("start", ...)
|
|
//
|
|
// Dropping invalid paths, out of memory during UTF8 conversion, and other IO issues is probably fine.
|
|
// Use an actual IProcess object, if you care about spawning and monitoring executables.
|
|
|
|
|
|
// TODO: Move the above comments into something less gross
|