AuroraRuntime/Source/IO/FS/Resources.cpp
Reece cf70f0d45c [*/+/-] MEGA COMMIT. ~2 weeks compressed.
The intention is to quickly improve and add util apis, enhance functionality given current demands, go back to the build pipeline, finish that, publish runtime tests, and then use what we have to go back to to linux support with a more stable api.

[+] AuMakeSharedArray
[+] Technet ArgvQuote
[+] Grug subsystem (UNIX signal thread async safe ipc + telemetry flusher + log flusher.)
[+] auEndianness -> Endian swap utils
[+] AuGet<N>(...)
[*] AUE_DEFINE conversion for
        ECompresionType, EAnsiColor, EHashType, EStreamError, EHexDump
[+] ConsoleMessage ByteBuffer serialization
[+] CmdLine subsystem for parsing command line arguments and simple switch/flag checks
[*] Split logger from console subsystem
[+] StartupParameters -> A part of a clean up effort under Process
[*] Refactor SysErrors header + get caller hack
[+] Atomic APIs
[+] popcnt
[+] Ring Buffer sink
[+] Added more standard errors
        Catch,
        Submission,
        LockError,
        NoAccess,
        ResourceMissing,
        ResourceLocked,
        MalformedData,
        InSandboxContext,
        ParseError

[+] Added ErrorCategorySet, ErrorCategoryClear, GetStackTrace
[+] IExitSubscriber, ETriggerLevel
[*] Write bias the high performance RWLockImpl read-lock operation operation
[+] ExitHandlerAdd/ExitHandlerRemove (exit subsystem)
[*] Updated API style
        Digests
[+] CpuId::CpuBitCount
[+] GetUserProgramsFolder
[+] GetPackagePath
[*] Split IStreamReader with an inl file
[*] BlobWriter/BlobReader/BlobArbitraryReader can now take shared pointers to bytebuffers. default constructor allocates a new scalable bytebuffer
[+] ICharacterProvider
[+] ICharacterProviderEx
[+] IBufferedCharacterConsumer
[+] ProviderFromSharedString
[+] ProviderFromString
[+] BufferConsumerFromProvider
[*] Parse Subsystem uses character io bufferer
[*] Rewritten NT's high perf semaphore to use userland SRW/ConVars [like mutex, based on generic semaphore]
[+] ByteBuffer::ResetReadPointer
[*] Bug fix bytebuffer base not reset on free and some scaling issues
[+] ProcessMap -> Added kSectionNameStack, kSectionNameFile, kSectionNameHeap for Section
[*] ProcessMap -> Refactor Segment to Section. I was stupid for keeping a type conflict hack API facing
[+] Added 64 *byte* fast RNG seeds
[+] File Advisorys/File Lock Awareness
[+] Added extended IAuroraThread from OS identifier caches for debug purposes
[*] Tweaked how memory is reported on Windows. Better consistency of what values mean across functions.
[*] Broke AuroraUtils/Typedefs out into a separate library
[*] Update build script
[+] Put some more effort into adding detail to the readme before rewriting it, plus, added some media
[*] Improved public API documentation
[*] Bug fix `SetConsoleCtrlHandler`
[+] Locale TimeDateToFileNameISO8601
[+] Console config stdOutShortTime
[*] Begin using internal UTF8/16 decoders when platform support isnt available (instead of stl)
[*] Bug fixes in decoders
[*] Major bug fix, AuMax
[+] RateLimiter
[+] Binary file sink
[+] Log directory sink
[*] Data header usability (more operators)
[+] AuRemoveRange
[+] AuRemove
[+] AuTryRemove
[+] AuTryRemoveRange
[+] auCastUtils
[+] Finish NewLSWin32Source
[+] AuTryFindByTupleN, AuTryRemoveByTupleN
[+] Separated AuRead/Write types, now in auTypeUtils
[+] Added GetPosition/SetPosition to FileWriter
[*] Fix stupid AuMin in place of AuMax in SpawnThread.Unix.Cpp
[*] Refactored Arbitrary readers to SeekingReaders (as in, they could be atomic and/or parallelized, and accept an arbitrary position as a work parameter -> not Seekable, as in, you can simply set the position)
[*] Hack back in the sched deinit
[+] File AIO loop source interop
[+] Begin to prototype a LoopQueue object I had in mind for NT, untested btw
[+] Stub code for networking
[+] Compression BaseStream/IngestableStreamBase
[*] Major: read/write locks now support write-entrant read routines.
[*] Compression subsystem now uses the MemoryView concept
[*] Rewrite the base stream compressions, made them less broken
[*] Update hashing api
[*] WriterTryGoForward and ReaderTryGoForward now revert to the previous relative index instead of panicing
[+] Added new AuByteBuffer apis
    Trim, Pad, WriteFrom, WriteString, [TODO: ReadString]
[+] Added ByteBufferPushReadState
[+] Added ByteBufferPushWriteState
[*] Move from USC-16 to full UTF-16. Win32 can handle full UTF-16.
[*] ELogLevel is now an Aurora enum
[+] Raised arbitrary limit in header to 255, the max filter buffer
[+] Explicit GZip support
[+] Explicit Zip support
[+] Added [some] compressors

et al
2022-02-17 00:11:40 +00:00

452 lines
14 KiB
C++

/***
Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.
File: Resources.cpp
Date: 2021-6-16
Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include "FS.hpp"
#include "Resources.hpp"
#if defined(AURORA_PLATFORM_LINUX)
#include <sys/types.h>
#include <pwd.h>
#include <unistd.h>
#elif defined(AURORA_PLATFORM_WIN32)
#include <ShlObj_core.h>
#include <accctrl.h>
#include <aclapi.h>
#endif
namespace Aurora::IO::FS
{
#if defined(AURORA_PLATFORM_WIN32)
static void Win32FixGlobalAppDataAcl(const AuString &path);
#endif
static AuString gHomeDirectory;
static AuString gUserHomeDirectory;
static AuString gUserWritableAppData;
static AuString gGlobalWritableAppDirectory;
static AuString gAdminWritableAppDirectory;
static AuString gProgramsFolder;
static AuString gApplicationData;
static AuOptional<AuString> gSystemLibPath;
static AuOptional<AuString> gSystemLibPath2;
static AuOptional<AuString> gUserLibPath;
static AuOptional<AuString> gUserLibPath2;
// Should the following be /opt? Probably, if it were a direct replacement for Windows' appdata on Linux for global software packages outside of our ecosystem, sure; however, this is strictly a fallback for when there is no home
// We don't support initially-undefined global application configurations across users on Unix targets. We can therefore conclue the application running is a service whose user is without a home, and should be subject to the same rules as an application deployed by a real package manager
// For internal packages, in our own ecosystem of tools, I think this follows the UNIX spec, not that I care what arcahic C-with-vendor-packages-as-an-OS specification says.
// The only way you can break this assumption is if you argue for users who will be outside of our deployment pipeline, wanting global configs, and don't have write permission on a relevant global directory.
// They can shove it. Superuser should install software for all users.
// XDG (falling back to home) for non-root installs; for root installs, installing a service package, use /var; for root installs of an application whose system configs should be shared amongst all users, unsupported, idc, it's sandboxed per user
static const AuString kUnixAppData {"/var"};
AUKN_SYM bool GetSystemDomain(AuString &path)
{
path = gApplicationData;
return true;
}
AUKN_SYM bool GetProfileDomain(AuString &path)
{
path = gHomeDirectory;
return true;
}
AUKN_SYM bool GetSystemResourcePath(const AuString &fileName, AuString &path)
{
path.clear();
if (fileName.find("..") != AuString::npos)
{
AuLogWarn("Exploit Attempt? A system resource path may not contain relative directory move tokens: {}", fileName);
return false;
}
{
AuString tempPath;
if (Process::GetWorkingDirectory(tempPath))
{
tempPath += "/" + fileName;
if (FileExists(tempPath))
{
path = tempPath;
return true;
}
}
}
{
AuString tempPath;
if (Process::GetProcDirectory(tempPath))
{
tempPath += "/" + fileName;
if (FileExists(tempPath))
{
path = tempPath;
return true;
}
}
}
{
auto systemPath = gHomeDirectory + fileName;
if (FileExists(systemPath))
{
path = systemPath;
return true;
}
}
{
auto systemPath = gApplicationData + fileName;
if (FileExists(systemPath))
{
path = systemPath;
return true;
}
}
return false;
}
#if defined(AURORA_PLATFORM_WIN32)
static AuString GetSpecialDir(REFKNOWNFOLDERID rfid)
{
PWSTR directory;
if (SHGetKnownFolderPath(rfid, KF_FLAG_DEFAULT, NULL, &directory) != S_OK)
{
SysPanic("Couldn't get known special directory path of [MS:{}-{}-{}-{}{}{}{}{}{}{}{}] with a NULL access token",
rfid.Data1, rfid.Data2, rfid.Data3, rfid.Data4[0], rfid.Data4[1], rfid.Data4[2], rfid.Data4[3], rfid.Data4[4], rfid.Data4[5], rfid.Data4[6], rfid.Data4[7]);
}
return Locale::ConvertFromWChar(directory);
}
static void SetNamespaceDirectories()
{
gHomeDirectory = GetSpecialDir(FOLDERID_RoamingAppData);
gApplicationData = GetSpecialDir(FOLDERID_ProgramData);
gSystemLibPath = GetSpecialDir(FOLDERID_System);
gUserHomeDirectory = GetSpecialDir(FOLDERID_Profile);
gAdminWritableAppDirectory = gApplicationData;
gUserWritableAppData = gHomeDirectory;
gProgramsFolder = GetSpecialDir(FOLDERID_UserProgramFiles);
}
#elif defined(AURORA_PLATFORM_LINUX) || defined(AURORA_PLATFORM_BSD)
static void SetUnixPaths(AuOptional<AuString> &primary, AuOptional<AuString> &secondary, const AuString &base)
{
primary = base;
if (Aurora::Build::IsPlatformX32())
{
secondary = base + "32";
}
else
{
secondary = base + "64";
}
if (DirExists(*secondary))
{
std::swap(secondary, primary);
}
else
{
secondary.reset();
}
if (!DirExists(*primary))
{
primary.reset();
}
}
static void SetXdg(AuString &out, const char *envvar, const char *home, const char *defaultHomeExt, const char *fallback)
{
auto value = getenv(envvar);
if (value)
{
out = value;
}
else if (home)
{
out = AuString(home) + defaultHomeExt;
}
else
{
out = fallback;
}
}
static void SetNamespaceDirectories()
{
const char *homedir;
homedir = getenv("HOME");
if (!homedir)
{
homedir = getpwuid(getuid())->pw_dir;
}
gUserHomeDirectory = homedir;
// XDG Base Directory Specification
// $XDG_CONFIG_HOME defines the base directory relative to which user-specific configuration files should be stored. If $XDG_CONFIG_HOME is either not set or empty, a default equal to $HOME/.config should be used.
// $XDG_DATA_HOME defines the base directory relative to which user-specific data files should be stored
SetXdg(gApplicationData, "XDG_CONFIG_HOME", homedir, "/.config", kUnixAppData);
SetXdg(gHomeDirectory, "XDG_DATA_HOME", homedir, "/.local/share", ".");
// https://www.freedesktop.org/wiki/Software/systemd/TheCaseForTheUsrMerge/
// Arch 2012: https://archlinux.org/news/the-lib-directory-becomes-a-symlink/
// Ubuntu 2018 (mandatory 2021+): https://lists.ubuntu.com/archives/ubuntu-devel-announce/2018-November/001253.html https://wiki.debian.org/UsrMerge
// Fedora (2011?): https://fedoraproject.org/wiki/Features/UsrMove
SetUnixPaths(gUserLibPath, gUserLibPath2, "/usr/local/lib");
SetUnixPaths(gSystemLibPath, gSystemLibPath2, "/usr/lib");
gProgramsFolder = "/opt";
gGlobalWritableAppDirectory = "/opt";
gAdminWritableAppDirectory = kUnixAppData;
gUserWritableAppData = gApplicationData;
}
#else
static void SetNamespaceDirectories()
{
gHomeDirectory = ".";
gApplicationData = ".";
}
#endif
AuOptional<AuString> GetSystemLibPath()
{
return gSystemLibPath;
}
AuOptional<AuString> GetUserLibPath()
{
return gUserLibPath;
}
AuOptional<AuString> GetSystemLibPath2()
{
return gSystemLibPath2;
}
AuOptional<AuString> GetUserLibPath2()
{
return gUserLibPath2;
}
static void ChangeDir()
{
#if !defined(AU_NO_AU_HOME_BRANDING)
if (gRuntimeConfig.fio.defaultBrand.size())
{
gApplicationData += "/" + gRuntimeConfig.fio.defaultBrand;
gHomeDirectory += "/" + gRuntimeConfig.fio.defaultBrand;
gProgramsFolder += "/" + gRuntimeConfig.fio.defaultBrand;
}
#endif
#if defined(AURORA_PLATFORM_WIN32)
if (gRuntimeConfig.fio.defaultBrand.empty())
{
gApplicationData += "/AllUsers";
}
if (!FS::DirExists(gApplicationData))
{
if (FS::DirMk(gApplicationData))
{
Win32FixGlobalAppDataAcl(gApplicationData);
}
}
#endif
NormalizePath(gApplicationData);
NormalizePath(gProgramsFolder);
NormalizePath(gHomeDirectory);
if ((gApplicationData == gHomeDirectory) || (gApplicationData == gProgramsFolder))
{
gApplicationData += kPathSplitter;
gHomeDirectory += kPathSplitter;
gApplicationData += "System";
gHomeDirectory += "Profile";
}
// Noting we append a path splitter to prevent hair pulling over missing path delimiters
// Eg: GetHome() + "myAwesomeApp/Config" = %HOME%/Aurora/ProfilemyAwsomeApp/Config
gApplicationData += kPathSplitter;
gHomeDirectory += kPathSplitter;
gProgramsFolder += kPathSplitter;
}
void InitResources()
{
SetNamespaceDirectories();
ChangeDir();
}
AUKN_SYM bool GetAppData(AuString &path)
{
path.clear();
if (gUserWritableAppData.empty())
{
return false;
}
path = gUserWritableAppData;
return true;
}
AUKN_SYM bool GetUserHome(AuString &path)
{
path.clear();
if (gUserHomeDirectory.empty())
{
return false;
}
path = gUserHomeDirectory;
return true;
}
AUKN_SYM bool GetPackagePath(AuString &path)
{
// TODO: iOS/mac OS -> CFBundleCopyResourcesDirectoryURL
return Process::GetProcDirectory(path);
}
AUKN_SYM bool GetWritableAppdata(AuString &path)
{
path.clear();
if (gGlobalWritableAppDirectory.empty())
{
return false;
}
path = gGlobalWritableAppDirectory;
return true;
}
AUKN_SYM bool GetRootAppdata(AuString &path)
{
path.clear();
if (gAdminWritableAppDirectory.empty())
{
return false;
}
path = gAdminWritableAppDirectory;
return true;
}
AUKN_SYM bool GetUserProgramsFolder(AuString &path)
{
path.clear();
if (gProgramsFolder.empty())
{
return false;
}
path = gProgramsFolder;
return true;
}
#if defined(AURORA_PLATFORM_WIN32)
static void Win32FixGlobalAppDataAcl(const AuString &path)
{
BOOL bRetval = FALSE;
HANDLE hToken = NULL;
PSID pSIDEveryone = NULL;
PACL pACL = NULL;
SID_IDENTIFIER_AUTHORITY SIDAuthWorld =
SECURITY_WORLD_SID_AUTHORITY;
const int NUM_ACES = 1;
EXPLICIT_ACCESS ea[NUM_ACES];
DWORD dwRes;
// Specify the DACL to use.
// Create a SID for the Everyone group.
if (!AllocateAndInitializeSid(&SIDAuthWorld, 1,
SECURITY_WORLD_RID,
0,
0, 0, 0, 0, 0, 0,
&pSIDEveryone))
{
SysPushErrorFIO("AllocateAndInitializeSid (Everyone) error");
goto Cleanup;
}
ZeroMemory(&ea, NUM_ACES * sizeof(EXPLICIT_ACCESS));
// Set read access for Everyone.
ea[0].grfAccessPermissions = GENERIC_ALL;
ea[0].grfAccessMode = SET_ACCESS;
ea[0].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
ea[0].Trustee.TrusteeForm = TRUSTEE_IS_SID;
ea[0].Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
ea[0].Trustee.ptstrName = (LPTSTR) pSIDEveryone;
if (ERROR_SUCCESS != SetEntriesInAcl(NUM_ACES,
ea,
NULL,
&pACL))
{
SysPushErrorFIO("Failed SetEntriesInAcl");
goto Cleanup;
}
// Try to modify the object's DACL.
dwRes = SetNamedSecurityInfoW(
Locale::ConvertFromUTF8(FS::NormalizePathRet(path)).data(), // name of the object
SE_FILE_OBJECT, // type of object
DACL_SECURITY_INFORMATION, // change only the object's DACL
NULL, NULL, // do not change owner or group
pACL, // DACL specified
NULL); // do not change SACL
if (ERROR_SUCCESS == dwRes)
{
bRetval = TRUE;
// No more processing needed.
goto Cleanup;
}
if (dwRes != ERROR_ACCESS_DENIED)
{
SysPushErrorFIO("First SetNamedSecurityInfo call failed: {}", dwRes);
goto Cleanup;
}
Cleanup:
if (pSIDEveryone)
{
FreeSid(pSIDEveryone);
}
if (pACL)
{
LocalFree(pACL);
}
if (hToken)
{
CloseHandle(hToken);
}
if (!bRetval)
{
AuLogError("Couldn't grant ownership to EVERYONE; System wide configuration directory {} will be inaccessible to other users", path);
}
}
#endif
}