PowerToys/src/runner/settings_window.cpp

#include "pch.h"
#include <WinSafer.h>
#include <Sddl.h>
#include <sstream>
#include <accctrl.h>
#include <aclapi.h>

#include "powertoy_module.h"
#include <common/two_way_pipe_message_ipc.h>
#include "tray_icon.h"
#include "general_settings.h"
#include "common/windows_colors.h"

#include <common/json.h>

#define BUFSIZE 1024

TwoWayPipeMessageIPC* current_settings_ipc = NULL;

json::JsonObject get_power_toys_settings()
{
    json::JsonObject result;
    for (const auto& [name, powertoy] : modules())
    {
        try
        {
            result.SetNamedValue(name, powertoy.json_config());
        }
        catch (...)
        {
            // TODO: handle malformed JSON.
        }
    }
    return result;
}

json::JsonObject get_all_settings()
{
    json::JsonObject result;

    result.SetNamedValue(L"general", get_general_settings());
    result.SetNamedValue(L"powertoys", get_power_toys_settings());
    return result;
}

void dispatch_json_action_to_module(const json::JsonObject& powertoys_configs)
{
    for (const auto& powertoy_element : powertoys_configs)
    {
        const std::wstring name{ powertoy_element.Key().c_str() };
        if (modules().find(name) != modules().end())
        {
            const auto element = powertoy_element.Value().Stringify();
            modules().at(name).call_custom_action(element.c_str());
        }
    }
}

void send_json_config_to_module(const std::wstring& module_key, const std::wstring& settings)
{
    if (modules().find(module_key) != modules().end())
    {
        modules().at(module_key).set_config(settings.c_str());
    }
}

void dispatch_json_config_to_modules(const json::JsonObject& powertoys_configs)
{
    for (const auto& powertoy_element : powertoys_configs)
    {
        const auto element = powertoy_element.Value().Stringify();
        send_json_config_to_module(powertoy_element.Key().c_str(), element.c_str());
    }
};

void dispatch_received_json(const std::wstring& json_to_parse)
{
    const json::JsonObject j = json::JsonObject::Parse(json_to_parse);
    for (const auto& base_element : j)
    {
        const auto name = base_element.Key();
        const auto value = base_element.Value();

        if (name == L"general")
        {
            apply_general_settings(value.GetObjectW());
            if (current_settings_ipc != nullptr)
            {
                const std::wstring settings_string{ get_all_settings().Stringify().c_str() };
                current_settings_ipc->send(settings_string);
            }
        }
        else if (name == L"powertoys")
        {
            dispatch_json_config_to_modules(value.GetObjectW());
            if (current_settings_ipc != nullptr)
            {
                const std::wstring settings_string{ get_all_settings().Stringify().c_str() };
                current_settings_ipc->send(settings_string);
            }
        }
        else if (name == L"refresh")
        {
            if (current_settings_ipc != nullptr)
            {
                const std::wstring settings_string{ get_all_settings().Stringify().c_str() };
                current_settings_ipc->send(settings_string);
            }
        }
        else if (name == L"action")
        {
            dispatch_json_action_to_module(value.GetObjectW());
        }
    }
    return;
}

void dispatch_received_json_callback(PVOID data)
{
    std::wstring* msg = (std::wstring*)data;
    dispatch_received_json(*msg);
    delete msg;
}

void receive_json_send_to_main_thread(const std::wstring& msg)
{
    std::wstring* copy = new std::wstring(msg);
    dispatch_run_on_main_ui_thread(dispatch_received_json_callback, copy);
}

DWORD g_settings_process_id = 0;

void run_settings_window()
{
    STARTUPINFO startup_info = { sizeof(startup_info) };
    PROCESS_INFORMATION process_info = { 0 };
    HANDLE process = NULL;
    HANDLE hToken = NULL;
    STARTUPINFOEX siex = { 0 };
    PPROC_THREAD_ATTRIBUTE_LIST pptal = NULL;
    WCHAR executable_path[MAX_PATH];
    GetModuleFileName(NULL, executable_path, MAX_PATH);
    PathRemoveFileSpec(executable_path);
    wcscat_s(executable_path, L"\\PowerToysSettings.exe");
    WCHAR executable_args[MAX_PATH * 3];

    const std::wstring settings_theme_setting{ get_general_settings().GetNamedString(L"theme").c_str() };
    std::wstring settings_theme;
    if (settings_theme_setting == L"dark" || (settings_theme_setting == L"system" && WindowsColors::is_dark_mode()))
    {
        settings_theme = L" dark"; // Include arg separating space
    }
    // Generate unique names for the pipes, if getting a UUID is possible
    std::wstring powertoys_pipe_name(L"\\\\.\\pipe\\powertoys_runner_");
    std::wstring settings_pipe_name(L"\\\\.\\pipe\\powertoys_settings_");
    SIZE_T size = 0;
    UUID temp_uuid;
    UuidCreate(&temp_uuid);
    wchar_t* uuid_chars;
    UuidToString(&temp_uuid, (RPC_WSTR*)&uuid_chars);
    if (uuid_chars != NULL)
    {
        powertoys_pipe_name += std::wstring(uuid_chars);
        settings_pipe_name += std::wstring(uuid_chars);
        RpcStringFree((RPC_WSTR*)&uuid_chars);
        uuid_chars = NULL;
    }
    DWORD powertoys_pid = GetCurrentProcessId();
    // Arguments for calling the settings executable:
    // C:\powertoys_path\PowerToysSettings.exe powertoys_pipe settings_pipe powertoys_pid
    // powertoys_pipe - PowerToys pipe server.
    // settings_pipe - Settings pipe server.
    // powertoys_pid - PowerToys process pid.
    // settings_theme - pass "dark" to start the settings window in dark mode
    wcscpy_s(executable_args, L"\"");
    wcscat_s(executable_args, executable_path);
    wcscat_s(executable_args, L"\"");
    wcscat_s(executable_args, L" ");
    wcscat_s(executable_args, powertoys_pipe_name.c_str());
    wcscat_s(executable_args, L" ");
    wcscat_s(executable_args, settings_pipe_name.c_str());
    wcscat_s(executable_args, L" ");
    wcscat_s(executable_args, std::to_wstring(powertoys_pid).c_str());
    wcscat_s(executable_args, settings_theme.c_str());

    // Run the Settings process with non-elevated privileges

    HWND hwnd = GetShellWindow();
    if (!hwnd)
    {
        goto LExit;
    }
    DWORD pid;
    GetWindowThreadProcessId(hwnd, &pid);

    process = OpenProcess(PROCESS_CREATE_PROCESS, FALSE, pid);
    if (!process)
    {
        goto LExit;
    }

    InitializeProcThreadAttributeList(nullptr, 1, 0, &size);
    pptal = (PPROC_THREAD_ATTRIBUTE_LIST) new char[size];
    if (!pptal)
    {
        goto LExit;
    }

    if (!InitializeProcThreadAttributeList(pptal, 1, 0, &size))
    {
        goto LExit;
    }

    if (!UpdateProcThreadAttribute(pptal,
                                   0,
                                   PROC_THREAD_ATTRIBUTE_PARENT_PROCESS,
                                   &process,
                                   sizeof(process),
                                   nullptr,
                                   nullptr))
    {
        goto LExit;
    }

    siex.lpAttributeList = pptal;
    siex.StartupInfo.cb = sizeof(siex);

    if (!CreateProcessW(executable_path,
                        executable_args,
                        nullptr,
                        nullptr,
                        FALSE,
                        EXTENDED_STARTUPINFO_PRESENT,
                        nullptr,
                        nullptr,
                        &siex.StartupInfo,
                        &process_info))
    {
        goto LExit;
    }

    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
    {
        goto LExit;
    }
    current_settings_ipc = new TwoWayPipeMessageIPC(powertoys_pipe_name, settings_pipe_name, receive_json_send_to_main_thread);
    current_settings_ipc->start(hToken);
    g_settings_process_id = process_info.dwProcessId;

    WaitForSingleObject(process_info.hProcess, INFINITE);
    if (WaitForSingleObject(process_info.hProcess, INFINITE) != WAIT_OBJECT_0)
    {
        show_last_error_message(L"Couldn't wait on the Settings Window to close.", GetLastError());
    }

LExit:

    if (process_info.hProcess)
    {
        CloseHandle(process_info.hProcess);
    }

    if (process_info.hThread)
    {
        CloseHandle(process_info.hThread);
    }

    if (pptal)
    {
        delete[](char*) pptal;
    }

    if (process)
    {
        CloseHandle(process);
    }

    if (current_settings_ipc)
    {
        current_settings_ipc->end();
        delete current_settings_ipc;
        current_settings_ipc = NULL;
    }

    if (hToken)
    {
        CloseHandle(hToken);
    }

    g_settings_process_id = 0;
}

void bring_settings_to_front()
{
    auto callback = [](HWND hwnd, LPARAM data) -> BOOL {
        DWORD processId;
        if (GetWindowThreadProcessId(hwnd, &processId) && processId == g_settings_process_id)
        {
            ShowWindow(hwnd, SW_NORMAL);
            SetForegroundWindow(hwnd);
            return FALSE;
        }

        return TRUE;
    };

    EnumWindows(callback, 0);
}

void open_settings_window()
{
    if (g_settings_process_id != 0)
    {
        bring_settings_to_front();
    }
    else
    {
        std::thread(run_settings_window).detach();
    }
}