tor-browser

vrpathregistry_public.cpp (12070B)

---

//========= Copyright Valve Corporation ============//

#include "vrpathregistry_public.h"
#include "json/json.h"
#include "pathtools_public.h"
#include "envvartools_public.h"
#include "strtools_public.h"
#include "dirtools_public.h"

#if defined( WIN32 )
#include <windows.h>
#include <shlobj.h>

#undef GetEnvironmentVariable
#elif defined OSX
#include <Foundation/Foundation.h>
#include <AppKit/AppKit.h>
#elif defined(LINUX)
#include <dlfcn.h>
#include <stdio.h>
#endif

#include <algorithm>

#ifndef VRLog
#if defined( __MINGW32__ )
	#define VRLog(args...)		fprintf(stderr, args)
#elif defined( WIN32 )
	#define VRLog(fmt, ...)		fprintf(stderr, fmt, __VA_ARGS__)
#else
	#define VRLog(args...)		fprintf(stderr, args)
#endif
#endif

/** Returns the root of the directory the system wants us to store user config data in */
static std::string GetAppSettingsPath()
{
#if defined( WIN32 )
WCHAR rwchPath[MAX_PATH];

if( !SUCCEEDED( SHGetFolderPathW( NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, rwchPath ) ) )
{
	return "";
}

// Convert the path to UTF-8 and store in the output
std::string sUserPath = UTF16to8( rwchPath );

return sUserPath;
#elif defined( OSX )
std::string sSettingsDir;
@autoreleasepool {
	// Search for the path
	NSArray *paths = NSSearchPathForDirectoriesInDomains( NSApplicationSupportDirectory, NSUserDomainMask, YES );
	if ( [paths count] == 0 )
	{
		return "";
	}
	
	NSString *resolvedPath = [paths objectAtIndex:0];
	resolvedPath = [resolvedPath stringByAppendingPathComponent: @"OpenVR"];
	
	if ( ![[NSFileManager defaultManager] createDirectoryAtPath: resolvedPath withIntermediateDirectories:YES attributes:nil error:nil] )
	{
		return "";
	}
	
	sSettingsDir.assign( [resolvedPath UTF8String] );
}
return sSettingsDir;
#elif defined( LINUX )

// As defined by XDG Base Directory Specification 
// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html

const char *pchHome = getenv("XDG_CONFIG_HOME");
if ( ( pchHome != NULL) && ( pchHome[0] != '\0' ) )
{
	return pchHome;
}

//
// XDG_CONFIG_HOME is not defined, use ~/.config instead
// 
pchHome = getenv( "HOME" );
if ( pchHome == NULL )
{
	return "";
}

std::string sUserPath( pchHome );
sUserPath = Path_Join( sUserPath, ".config" );
return sUserPath;
#else
#warning "Unsupported platform"
#endif
}


// ---------------------------------------------------------------------------
// Purpose: Constructor
// ---------------------------------------------------------------------------
CVRPathRegistry_Public::CVRPathRegistry_Public()
{

}

// ---------------------------------------------------------------------------
// Purpose: Computes the registry filename
// ---------------------------------------------------------------------------
std::string CVRPathRegistry_Public::GetOpenVRConfigPath()
{
std::string sConfigPath = GetAppSettingsPath();
if( sConfigPath.empty() )
	return "";

#if defined( _WIN32 ) || defined( LINUX )
sConfigPath = Path_Join( sConfigPath, "openvr" );
#elif defined ( OSX ) 
sConfigPath = Path_Join( sConfigPath, ".openvr" );
#else
#warning "Unsupported platform"
#endif
sConfigPath = Path_FixSlashes( sConfigPath );
return sConfigPath;
}



//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
std::string CVRPathRegistry_Public::GetVRPathRegistryFilename()
{
std::string sOverridePath = GetEnvironmentVariable( "VR_PATHREG_OVERRIDE" );
if ( !sOverridePath.empty() )
	return sOverridePath;

std::string sPath = GetOpenVRConfigPath();
if ( sPath.empty() )
	return "";

#if defined( _WIN32 )
sPath = Path_Join( sPath, "openvrpaths.vrpath" );
#elif defined ( POSIX ) 
sPath = Path_Join( sPath, "openvrpaths.vrpath" );
#else
#error "Unsupported platform"
#endif
sPath = Path_FixSlashes( sPath );
return sPath;
}


// ---------------------------------------------------------------------------
// Purpose: Converts JSON to a history array
// ---------------------------------------------------------------------------
static void ParseStringListFromJson( std::vector< std::string > *pvecHistory, const Json::Value & root, const char *pchArrayName )
{
if( !root.isMember( pchArrayName ) )
	return;

const Json::Value & arrayNode = root[ pchArrayName ];
if( !arrayNode )
{
	VRLog( "VR Path Registry node %s is not an array\n", pchArrayName );
	return;
}

pvecHistory->clear();
pvecHistory->reserve( arrayNode.size() );
for( uint32_t unIndex = 0; unIndex < arrayNode.size(); unIndex++ )
{
	std::string sPath( arrayNode[ unIndex ].asString() );
	pvecHistory->push_back( sPath );
}
}


// ---------------------------------------------------------------------------
// Purpose: Converts a history array to JSON
// ---------------------------------------------------------------------------
static void StringListToJson( const std::vector< std::string > & vecHistory, Json::Value & root, const char *pchArrayName )
{
Json::Value & arrayNode = root[ pchArrayName ];
for( auto i = vecHistory.begin(); i != vecHistory.end(); i++ )
{
	arrayNode.append( *i );
}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CVRPathRegistry_Public::ToJsonString( std::string &sJsonString )
{
std::string sRegPath = GetVRPathRegistryFilename();
if( sRegPath.empty() )
	return false;

std::string sRegistryContents = Path_ReadTextFile( sRegPath );
if( sRegistryContents.empty() )
	return false;

sJsonString = sRegistryContents;

return true;
}

// Mozilla: see mozilla.patch for more details
// ---------------------------------------------------------------------------
// Purpose: Loads the config file from its well known location
// ---------------------------------------------------------------------------
bool CVRPathRegistry_Public::BLoadFromFile( std::string *psLoadError )
{
std::string sRegPath = GetVRPathRegistryFilename();
if( sRegPath.empty() )
{
	if ( psLoadError )
	{
		*psLoadError = "Unable to determine VR Path Registry filename";
	}
	return false;
}

std::string sRegistryContents = Path_ReadTextFile( sRegPath );
if( sRegistryContents.empty() )
{
	if ( psLoadError )
	{
		*psLoadError = "Unable to read VR Path Registry from " + sRegPath;
	}
	return false;
}

Json::Value root;
Json::CharReaderBuilder builder;
std::istringstream istream( sRegistryContents );
std::string sErrors;

// try
{
	if ( !parseFromStream( builder, istream, &root, &sErrors ) )
	{
		if ( psLoadError )
		{
			*psLoadError = "Unable to parse " + sRegPath + ": " + sErrors;
		}
		return false;
	}

	ParseStringListFromJson( &m_vecRuntimePath, root, "runtime" );
	ParseStringListFromJson( &m_vecConfigPath, root, "config" );
	ParseStringListFromJson( &m_vecLogPath, root, "log" );
	if ( root.isMember( "external_drivers" ) && root["external_drivers"].isArray() )
	{
		ParseStringListFromJson( &m_vecExternalDrivers, root, "external_drivers" );
	}
}
// catch ( ... )
// {
// 	if ( psLoadError )
// 	{
// 		*psLoadError = "Unable to parse " + sRegPath + ": exception thrown in JSON library";
// 	}
// 	return false;
// }

return true;
}


// ---------------------------------------------------------------------------
// Purpose: Saves the config file to its well known location
// ---------------------------------------------------------------------------
bool CVRPathRegistry_Public::BSaveToFile() const
{
std::string sRegPath = GetVRPathRegistryFilename();
if( sRegPath.empty() )
	return false;

Json::Value root;

root[ "version" ] = 1;
root[ "jsonid" ] = "vrpathreg";

StringListToJson( m_vecRuntimePath, root, "runtime" );
StringListToJson( m_vecConfigPath, root, "config" );
StringListToJson( m_vecLogPath, root, "log" );
StringListToJson( m_vecExternalDrivers, root, "external_drivers" );

Json::StreamWriterBuilder builder;
std::string sRegistryContents = Json::writeString( builder, root );

// make sure the directory we're writing into actually exists
std::string sRegDirectory = Path_StripFilename( sRegPath );
if( !BCreateDirectoryRecursive( sRegDirectory.c_str() ) )
{
	VRLog( "Unable to create path registry directory %s\n", sRegDirectory.c_str() );
	return false;
}

if( !Path_WriteStringToTextFile( sRegPath, sRegistryContents.c_str() ) )
{
	VRLog( "Unable to write VR path registry to %s\n", sRegPath.c_str() );
	return false;
}

return true;
}


// ---------------------------------------------------------------------------
// Purpose: Returns the current runtime path or NULL if no path is configured.
// ---------------------------------------------------------------------------
std::string CVRPathRegistry_Public::GetRuntimePath() const
{
if( m_vecRuntimePath.empty() )
	return "";
else
	return m_vecRuntimePath.front().c_str();
}


// ---------------------------------------------------------------------------
// Purpose: Returns the current config path or NULL if no path is configured.
// ---------------------------------------------------------------------------
std::string CVRPathRegistry_Public::GetConfigPath() const
{
if( m_vecConfigPath.empty() )
	return "";
else
	return m_vecConfigPath.front().c_str();
}


// ---------------------------------------------------------------------------
// Purpose: Returns the current log path or NULL if no path is configured.
// ---------------------------------------------------------------------------
std::string CVRPathRegistry_Public::GetLogPath() const
{
if( m_vecLogPath.empty() )
	return "";
else
	return m_vecLogPath.front().c_str();
}



// ---------------------------------------------------------------------------
// Purpose: Returns paths using the path registry and the provided override 
//			values. Pass NULL for any paths you don't care about.
// ---------------------------------------------------------------------------
bool CVRPathRegistry_Public::GetPaths( std::string *psRuntimePath, std::string *psConfigPath, std::string *psLogPath, const char *pchConfigPathOverride, const char *pchLogPathOverride, std::vector<std::string> *pvecExternalDrivers )
{
std::string sLoadError;
CVRPathRegistry_Public pathReg;
bool bLoadedRegistry = pathReg.BLoadFromFile( &sLoadError );
int nCountEnvironmentVariables = 0;
int nRequestedPaths = 0;

if( psRuntimePath )
{
	nRequestedPaths++;
	if ( GetEnvironmentVariable( k_pchRuntimeOverrideVar ).length() != 0 )
	{
		*psRuntimePath = GetEnvironmentVariable( k_pchRuntimeOverrideVar );
		nCountEnvironmentVariables++;
	}
	else if( !pathReg.GetRuntimePath().empty() )
	{
		*psRuntimePath = pathReg.GetRuntimePath();
	}
	else
	{
		*psRuntimePath = "";
	}
}

if( psConfigPath )
{
	nRequestedPaths++;
	if ( GetEnvironmentVariable( k_pchConfigOverrideVar ).length() != 0 )
	{
		*psConfigPath = GetEnvironmentVariable( k_pchConfigOverrideVar );
		nCountEnvironmentVariables++;
	}
	else if( pchConfigPathOverride )
	{
		*psConfigPath = pchConfigPathOverride;
	}
	else if( !pathReg.GetConfigPath().empty() )
	{
		*psConfigPath = pathReg.GetConfigPath();
	}
	else
	{
		*psConfigPath = "";
	}
}

if( psLogPath )
{
	nRequestedPaths++;
	if ( GetEnvironmentVariable( k_pchLogOverrideVar ).length() != 0 )
	{
		*psLogPath = GetEnvironmentVariable( k_pchLogOverrideVar );
		nCountEnvironmentVariables++;
	}
	else if( pchLogPathOverride )
	{
		*psLogPath = pchLogPathOverride;
	}
	else if( !pathReg.GetLogPath().empty() )
	{
		*psLogPath = pathReg.GetLogPath();
	}
	else
	{
		*psLogPath = "";
	}
}

if ( pvecExternalDrivers )
{
	*pvecExternalDrivers = pathReg.m_vecExternalDrivers;
}

if ( nCountEnvironmentVariables == nRequestedPaths )
{
	// all three environment variables were set, so we don't need the physical file
	return true;
}
else if( !bLoadedRegistry )
{
	VRLog( "%s\n", sLoadError.c_str() );
}

return bLoadedRegistry;
}