bool AudioSourceOJM::Open(std::filesystem::path f)
{
char sig[4];
ifile = std::make_shared<std::ifstream>(f.string(), std::ios::binary);
if (!ifile->is_open())
{
Log::Printf("AudioSourceOJM: unable to load %s.\n", f.c_str());
return false;
}
ifile->read(sig, 4);
switch (GetContainerKind(sig))
{
case M30:
parseM30();
break;
case OMC:
parseOMC();
break;
default:
return false;
}
ifile->close();
return true;
}
fs::path
HOSTFXR_UTILITY::GetAbsolutePathToHostFxr(
const fs::path & dotnetPath
)
{
std::vector<std::wstring> versionFolders;
const auto hostFxrBase = dotnetPath.parent_path() / "host" / "fxr";
LOG_INFOF(L"Resolving absolute path to hostfxr.dll from '%ls'", dotnetPath.c_str());
if (!is_directory(hostFxrBase))
{
throw InvalidOperationException(format(L"Unable to find hostfxr directory at %s", hostFxrBase.c_str()));
}
FindDotNetFolders(hostFxrBase, versionFolders);
if (versionFolders.empty())
{
throw InvalidOperationException(format(L"Hostfxr directory '%s' doesn't contain any version subdirectories", hostFxrBase.c_str()));
}
const auto highestVersion = FindHighestDotNetVersion(versionFolders);
const auto hostFxrPath = hostFxrBase / highestVersion / "hostfxr.dll";
if (!is_regular_file(hostFxrPath))
{
throw InvalidOperationException(format(L"hostfxr.dll not found at '%s'", hostFxrPath.c_str()));
}
LOG_INFOF(L"hostfxr.dll located at '%ls'", hostFxrPath.c_str());
return hostFxrPath;
}
std::system_error run_process(const std::filesystem::path &filename, const std::vector<std::string> &argv,
const std::vector<std::string> &envp)
{
cpid = fork();
if (cpid == -1)
{
return std::system_error(std::make_error_code(std::errc(std::errno)));
}
if (cpid == 0)
{
std::vector<char *> arg;
arg.push_back(filename.c_str());
for (const auto &v : argv)
{
arg.push_back(v.c_str());
}
arg.push_back(nullptr);
std::vector<char *> env;
for (auto &e : envp)
{
env.push_back(e.c_str());
}
env.push_back(nullptr);
auto exec_error = execve(filename.c_str(), arg.data(), env.data());
perror("execve");
exit(EXIT_FAILURE);
}
else
{
attached = true;
}
return std::system_error(std::make_error_code(std::errc(0)));
}
void decrypt_file(
fs::path const & sourcefile,
fs::path const & destfile,
std::string_view password)
{
CryptoPP::FileSource source(
sourcefile.c_str(),
true,
new CryptoPP::DefaultDecryptorWithMAC(
(CryptoPP::byte*)password.data(), password.size(),
new CryptoPP::FileSink(
destfile.c_str())
)
);
}
bool open(const std::filesystem::path& jpeg_file) override
{
auto fp = ::fopen(to_osmbstr(to_utf8(jpeg_file.native())).c_str(), "rb");
if(nullptr == fp) return false;
bool is_opened = false;
struct ::jpeg_decompress_struct jdstru;
error_mgr jerr;
jdstru.err = ::jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = _m_error_handler;
if (!setjmp(jerr.setjmp_buf))
{
::jpeg_create_decompress(&jdstru);
::jpeg_stdio_src(&jdstru, fp);
_m_read_jpg(jdstru);
jpeg_finish_decompress(&jdstru);
is_opened = true;
}
::jpeg_destroy_decompress(&jdstru);
::fclose(fp);
return is_opened;
}
//------------------------------------------------------------
bool ofOpenALSoundPlayer::mpg123ReadFile(const std::filesystem::path& path,vector<short> & buffer,vector<float> & fftAuxBuffer){
int err = MPG123_OK;
mpg123_handle * f = mpg123_new(nullptr,&err);
if(mpg123_open(f,path.c_str())!=MPG123_OK){
ofLogError("ofOpenALSoundPlayer") << "mpg123ReadFile(): couldn't read \"" << path << "\"";
return false;
}
mpg123_enc_enum encoding;
long int rate;
mpg123_getformat(f,&rate,&channels,(int*)&encoding);
if(encoding!=MPG123_ENC_SIGNED_16){
ofLogError("ofOpenALSoundPlayer") << "mpg123ReadFile(): " << getMpg123EncodingString(encoding)
<< " encoding for \"" << path << "\"" << " unsupported, expecting MPG123_ENC_SIGNED_16";
return false;
}
samplerate = rate;
size_t done=0;
size_t buffer_size = mpg123_outblock( f );
buffer.resize(buffer_size/2);
while(mpg123_read(f,(unsigned char*)&buffer[buffer.size()-buffer_size/2],buffer_size,&done)!=MPG123_DONE){
buffer.resize(buffer.size()+buffer_size/2);
};
buffer.resize(buffer.size()-(buffer_size/2-done/2));
mpg123_close(f);
mpg123_delete(f);
fftAuxBuffer.resize(buffer.size());
for(int i=0;i<(int)buffer.size();i++){
fftAuxBuffer[i] = float(buffer[i])/32565.f;
}
duration = float(buffer.size()/channels) / float(samplerate);
return true;
}
//------------------------------------------------------------
bool ofOpenALSoundPlayer::sfStream(const std::filesystem::path& path,vector<short> & buffer,vector<float> & fftAuxBuffer){
if(!streamf){
SF_INFO sfInfo;
streamf = sf_open(path.c_str(),SFM_READ,&sfInfo);
if(!streamf){
ofLogError("ofOpenALSoundPlayer") << "sfStream(): couldn't read \"" << path << "\"";
return false;
}
stream_subformat = sfInfo.format & SF_FORMAT_SUBMASK ;
if (stream_subformat == SF_FORMAT_FLOAT || stream_subformat == SF_FORMAT_DOUBLE){
sf_command (streamf, SFC_CALC_SIGNAL_MAX, &stream_scale, sizeof (stream_scale)) ;
if (stream_scale < 1e-10)
stream_scale = 1.0 ;
else
stream_scale = 32700.0 / stream_scale ;
}
channels = sfInfo.channels;
duration = float(sfInfo.frames) / float(sfInfo.samplerate);
samplerate = sfInfo.samplerate;
stream_samples_read = 0;
}
int curr_buffer_size = BUFFER_STREAM_SIZE*channels;
if(speed>1) curr_buffer_size *= (int)round(speed);
buffer.resize(curr_buffer_size);
fftAuxBuffer.resize(buffer.size());
if (stream_subformat == SF_FORMAT_FLOAT || stream_subformat == SF_FORMAT_DOUBLE){
sf_count_t samples_read = sf_read_float (streamf, &fftAuxBuffer[0], fftAuxBuffer.size());
stream_samples_read += samples_read;
if(samples_read<(int)fftAuxBuffer.size()){
fftAuxBuffer.resize(samples_read);
buffer.resize(samples_read);
setPosition(0);
if(!bLoop) stopThread();
stream_samples_read = 0;
stream_end = true;
}
for (int i = 0 ; i < int(fftAuxBuffer.size()) ; i++){
fftAuxBuffer[i] *= stream_scale ;
buffer[i] = 32565.0 * fftAuxBuffer[i];
}
}else{
sf_count_t frames_read = sf_readf_short(streamf,&buffer[0],curr_buffer_size/channels);
stream_samples_read += frames_read*channels;
if(frames_read<curr_buffer_size/channels){
fftAuxBuffer.resize(frames_read*channels);
buffer.resize(frames_read*channels);
setPosition(0);
if(!bLoop) stopThread();
stream_samples_read = 0;
stream_end = true;
}
for(int i=0;i<(int)buffer.size();i++){
fftAuxBuffer[i]=float(buffer[i])/32565.0f;
}
}
return true;
}
std::shared_ptr<VSRG::Song> LoadSong7KFromFilename(std::filesystem::path Filename, std::filesystem::path Prefix, VSRG::Song *Sng)
{
auto prefix = Prefix.string();
bool AllocSong = false;
if (!Sng)
{
AllocSong = true;
Sng = new VSRG::Song();
}
std::wstring Ext = Utility::Widen(Filename.extension().string());
// no extension
if (!Filename.has_extension() || !VSRGValidExtension(Ext))
{
if (AllocSong) delete Sng;
return nullptr;
}
Sng->SongDirectory = Prefix.string();
auto fn = Prefix / Filename;
auto fnu8 = Utility::Narrow(fn.wstring());
for (int i = 0; i < sizeof(LoadersVSRG) / sizeof(loaderVSRGEntry_t); i++)
{
if (Ext == LoadersVSRG[i].Ext)
{
Log::LogPrintf("Load %s from disk...", fnu8.c_str());
try
{
LoadersVSRG[i].LoadFunc(fn, Sng);
Log::LogPrintf(" ok\n");
}
catch (std::exception &e)
{
Log::LogPrintf("Failure loading: %s\n", e.what());
}
break;
}
}
if (AllocSong)
return std::shared_ptr<VSRG::Song>(Sng);
return nullptr;
}
void decrypt_file(
fs::path const & filepath,
std::string_view password)
{
auto temppath = fs::temp_directory_path() / filepath.filename();
decrypt_file(filepath, temppath, password);
fs::remove(filepath);
fs::rename(temppath, filepath);
}
FileWatchWin::FileWatchWin(const std::filesystem::path& path, const FileMonitor::t_callbackFunc& callback, DWORD dwNotifyFilter, HANDLE hDirectory) :
FileWatch(path),
m_callback(callback),
m_dwNotifyFilter(dwNotifyFilter),
m_hDirectory(hDirectory)
{
std::string filename = path.filename().string();
m_filename.assign(filename.begin(), filename.end());
memset(m_pOverlapped.get(), 0, sizeof(*m_pOverlapped));
m_pOverlapped->hEvent = CreateEvent(nullptr, true, false, nullptr);
}
static std::filesystem::path find_last_file_matching_pattern(const std::filesystem::path& pattern) {
std::filesystem::path last_match;
for(const auto& entry : std::filesystem::directory_iterator(u"", pattern.c_str())) {
if( std::filesystem::is_regular_file(entry.status()) ) {
const auto match = entry.path();
if( match > last_match ) {
last_match = match;
}
}
}
return last_match;
}
// ----------------------------------------------------------------------------
bool ofOpenALSoundPlayer::sfReadFile(const std::filesystem::path& path, vector<short> & buffer, vector<float> & fftAuxBuffer){
SF_INFO sfInfo;
SNDFILE* f = sf_open(path.c_str(),SFM_READ,&sfInfo);
if(!f){
ofLogError("ofOpenALSoundPlayer") << "sfReadFile(): couldn't read \"" << path << "\"";
return false;
}
buffer.resize(sfInfo.frames*sfInfo.channels);
fftAuxBuffer.resize(sfInfo.frames*sfInfo.channels);
int subformat = sfInfo.format & SF_FORMAT_SUBMASK ;
if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE){
double scale ;
sf_command (f, SFC_CALC_SIGNAL_MAX, &scale, sizeof (scale)) ;
if (scale < 1e-10)
scale = 1.0 ;
else
scale = 32700.0 / scale ;
sf_count_t samples_read = sf_read_float (f, &fftAuxBuffer[0], fftAuxBuffer.size());
if(samples_read<(int)fftAuxBuffer.size()){
ofLogWarning("ofOpenALSoundPlayer") << "sfReadFile(): read " << samples_read << " float samples, expected "
<< fftAuxBuffer.size() << " for \"" << path << "\"";
}
for (int i = 0 ; i < int(fftAuxBuffer.size()) ; i++){
fftAuxBuffer[i] *= scale ;
buffer[i] = 32565.0 * fftAuxBuffer[i];
}
}else{
sf_count_t frames_read = sf_readf_short(f,&buffer[0],sfInfo.frames);
if(frames_read<sfInfo.frames){
ofLogError("ofOpenALSoundPlayer") << "sfReadFile(): read " << frames_read << " frames from buffer, expected "
<< sfInfo.frames << " for \"" << path << "\"";
return false;
}
sf_seek(f,0,SEEK_SET);
frames_read = sf_readf_float(f,&fftAuxBuffer[0],sfInfo.frames);
if(frames_read<sfInfo.frames){
ofLogError("ofOpenALSoundPlayer") << "sfReadFile(): read " << frames_read << " frames from fft buffer, expected "
<< sfInfo.frames << " for \"" << path << "\"";
return false;
}
}
sf_close(f);
channels = sfInfo.channels;
duration = float(sfInfo.frames) / float(sfInfo.samplerate);
samplerate = sfInfo.samplerate;
return true;
}
std::shared_ptr<VSRG::Song> LoadSong7KFromFilename(const std::filesystem::path& filename, VSRG::Song *Sng)
{
if (!filename.has_extension())
{
return nullptr;
}
bool AllocSong = false;
if (!Sng)
{
AllocSong = true;
Sng = new VSRG::Song();
}
Sng->SongDirectory = filename.parent_path();
for (int i = 0; i < sizeof(LoadersVSRG) / sizeof(loaderVSRGEntry_t); i++)
{
if (filename.extension() == LoadersVSRG[i].Ext)
{
Log::LogPrintf("Load %s from disk...", filename.string().c_str());
try
{
LoadersVSRG[i].LoadFunc(filename, Sng);
Log::LogPrintf(" ok\n");
}
catch (std::exception &e)
{
Log::LogPrintf("Failure loading %s: %s\n", filename.string().c_str(), e.what());
}
break;
}
}
if (AllocSong)
return std::shared_ptr<VSRG::Song>(Sng);
return nullptr;
}
//-----------------------------------------------------------
static bool loadFontFace(const std::filesystem::path& _fontname, FT_Face & face, std::filesystem::path & filename){
std::filesystem::path fontname = _fontname;
filename = ofToDataPath(_fontname,true);
ofFile fontFile(filename,ofFile::Reference);
int fontID = 0;
if(!fontFile.exists()){
#ifdef TARGET_LINUX
filename = linuxFontPathByName(fontname.string());
#elif defined(TARGET_OSX)
if(fontname==OF_TTF_SANS){
fontname = "Helvetica Neue";
#if MAC_OS_X_VERSION_10_13 && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_13
fontID = 0;
#else
fontID = 4;
#endif
}else if(fontname==OF_TTF_SERIF){
fontname = "Times New Roman";
}else if(fontname==OF_TTF_MONO){
fontname = "Menlo Regular";
}
filename = osxFontPathByName(fontname.string());
#elif defined(TARGET_WIN32)
if(fontname==OF_TTF_SANS){
fontname = "Arial";
}else if(fontname==OF_TTF_SERIF){
fontname = "Times New Roman";
}else if(fontname==OF_TTF_MONO){
fontname = "Courier New";
}
filename = winFontPathByName(fontname.string());
#endif
if(filename == "" ){
ofLogError("ofTrueTypeFont") << "loadFontFace(): couldn't find font \"" << fontname << "\"";
return false;
}
ofLogVerbose("ofTrueTypeFont") << "loadFontFace(): \"" << fontname << "\" not a file in data loading system font from \"" << filename << "\"";
}
FT_Error err;
err = FT_New_Face( library, filename.string().c_str(), fontID, &face );
if (err) {
// simple error table in lieu of full table (see fterrors.h)
string errorString = "unknown freetype";
if(err == 1) errorString = "INVALID FILENAME";
ofLogError("ofTrueTypeFont") << "loadFontFace(): couldn't create new face for \"" << fontname << "\": FT_Error " << err << " " << errorString;
return false;
}
return true;
}
void print_pdf(
fs::path const & pdfpath,
fs::path const & dirpath)
{
const int height = 842;
const int width = 595;
const int margin = 20;
auto image_paths = get_images(dirpath);
PDFWriter pdf;
pdf.StartPDF(pdfpath.string(), ePDFVersion13);
PDFPage* page = nullptr;
PageContentContext* context = nullptr;
auto top = height - margin;
for (size_t i = 0; i < image_paths.size(); ++i)
{
auto dims = pdf.GetImageDimensions(image_paths[i]);
if (i == 0 || top - dims.second < margin)
{
if (page != nullptr)
{
pdf.EndPageContentContext(context);
pdf.WritePageAndRelease(page);
}
page = new PDFPage();
page->SetMediaBox(PDFRectangle(0, 0, width, height));
context = pdf.StartPageContentContext(page);
top = height - margin;
}
context->DrawImage(margin, top - dims.second, image_paths[i]);
top -= dims.second + margin;
}
if (page != nullptr)
{
pdf.EndPageContentContext(context);
pdf.WritePageAndRelease(page);
}
pdf.EndPDF();
}
//------------------------------------------------------------
bool ofOpenALSoundPlayer::mpg123Stream(const std::filesystem::path& path,vector<short> & buffer,vector<float> & fftAuxBuffer){
if(!mp3streamf){
int err = MPG123_OK;
mp3streamf = mpg123_new(nullptr,&err);
if(mpg123_open(mp3streamf,path.c_str())!=MPG123_OK){
mpg123_close(mp3streamf);
mpg123_delete(mp3streamf);
ofLogError("ofOpenALSoundPlayer") << "mpg123Stream(): couldn't read \"" << path << "\"";
return false;
}
long int rate;
mpg123_getformat(mp3streamf,&rate,&channels,(int*)&stream_encoding);
if(stream_encoding!=MPG123_ENC_SIGNED_16){
ofLogError("ofOpenALSoundPlayer") << "mpg123Stream(): " << getMpg123EncodingString(stream_encoding)
<< " encoding for \"" << path << "\"" << " unsupported, expecting MPG123_ENC_SIGNED_16";
return false;
}
samplerate = rate;
mp3_buffer_size = mpg123_outblock( mp3streamf );
mpg123_seek(mp3streamf,0,SEEK_END);
off_t samples = mpg123_tell(mp3streamf);
duration = float(samples/channels) / float(samplerate);
mpg123_seek(mp3streamf,0,SEEK_SET);
}
int curr_buffer_size = mp3_buffer_size;
if(speed>1) curr_buffer_size *= (int)round(speed);
buffer.resize(curr_buffer_size);
fftAuxBuffer.resize(buffer.size());
size_t done=0;
if(mpg123_read(mp3streamf,(unsigned char*)&buffer[0],curr_buffer_size*2,&done)==MPG123_DONE){
setPosition(0);
buffer.resize(done/2);
fftAuxBuffer.resize(done/2);
if(!bLoop) stopThread();
stream_end = true;
}
for(int i=0;i<(int)buffer.size();i++){
fftAuxBuffer[i] = float(buffer[i])/32565.f;
}
return true;
}
Optional<File::Error> File::open_fatfs(const std::filesystem::path& filename, BYTE mode) {
auto result = f_open(&f, reinterpret_cast<const TCHAR*>(filename.c_str()), mode);
if( result == FR_OK ) {
if( mode & FA_OPEN_ALWAYS ) {
const auto result = f_lseek(&f, f_size(&f));
if( result != FR_OK ) {
f_close(&f);
}
}
}
if( result == FR_OK ) {
return { };
} else {
return { result };
}
}
void ConvertToSMTiming(VSRG::Song *Sng, std::filesystem::path PathOut)
{
TimingData BPS, VSpeeds, Warps;
VSRG::Difficulty* Diff = Sng->Difficulties[0].get();
Diff->GetPlayableData(nullptr, BPS, VSpeeds, Warps);
std::ofstream out(PathOut.string());
// Technically, stepmania's #OFFSET is actually #GAP, not #OFFSET.
out << "#OFFSET:" << -Diff->Offset << ";\n";
out << "#BPMS:";
for (auto i = Diff->Timing.begin();
i != Diff->Timing.end();
++i)
{
double Time = 0;
double Value = 0;
switch (Diff->BPMType)
{
case VSRG::Difficulty::BT_BEAT:
Time = i->Time;
Value = i->Value;
break;
case VSRG::Difficulty::BT_BEATSPACE:
Time = i->Time;
Value = 60000 / i->Value;
break;
case VSRG::Difficulty::BT_MS:
Time = i->Time / 1000.0;
Value = i->Value;
break;
}
double Beat = QuantizeBeat(IntegrateToTime(BPS, Time + Diff->Offset, 0));
out << Beat << "=" << Value;
if ((i + 1) != Diff->Timing.end()) // Only output comma if there's still stuff to output.
out << "\n,";
}
out << ";";
}
void FileBasedBenchmarkItemRunner::_parse_query_file(
const std::filesystem::path& query_file_path, const std::optional<std::unordered_set<std::string>>& query_subset) {
std::ifstream file(query_file_path);
// The names of queries from, e.g., "queries/TPCH-7.sql" will be prefixed with "TPCH-7."
const auto item_name_prefix = query_file_path.stem().string();
std::string content{std::istreambuf_iterator<char>(file), {}};
/**
* A file can contain multiple SQL statements, and each statement may cover one or more lines.
* We use the SQLParser to split up the content of the file into the individual SQL statements.
*/
hsql::SQLParserResult parse_result;
hsql::SQLParser::parse(content, &parse_result);
Assert(parse_result.isValid(), create_sql_parser_error_message(content, parse_result));
std::vector<Query> queries_in_file{parse_result.size()};
size_t sql_string_offset{0u};
for (auto statement_idx = size_t{0}; statement_idx < parse_result.size(); ++statement_idx) {
const auto item_name = item_name_prefix + '.' + std::to_string(statement_idx);
const auto statement_string_length = parse_result.getStatement(statement_idx)->stringLength;
const auto statement_string = boost::trim_copy(content.substr(sql_string_offset, statement_string_length));
sql_string_offset += statement_string_length;
queries_in_file[statement_idx] = {item_name, statement_string};
}
// Remove ".0" from the end of the query name if there is only one file
if (queries_in_file.size() == 1) {
queries_in_file.front().name.erase(queries_in_file.front().name.end() - 2, queries_in_file.front().name.end());
}
/**
* Add queries to _queries and _item_names, if query_subset allows it
*/
for (const auto& query : queries_in_file) {
if (!query_subset || query_subset->count(query.name)) {
_queries.emplace_back(query);
}
}
}
std::string GetSha256ForFile(std::filesystem::path Filename)
{
SHA256 SHA;
std::ifstream InStream(Filename.string());
unsigned char tmpbuf[256];
if (!InStream.is_open())
return "";
while (!InStream.eof())
{
InStream.read((char*)tmpbuf, 256);
size_t cnt = InStream.gcount();
SHA.add(tmpbuf, cnt);
}
return std::string(SHA.getHash());
}
bool TTFCache::SaveCache(std::filesystem::path cachepath)
{
std::ofstream out(cachepath.string(), std::ios::binary);
if (!out.is_open()) return false;
auto size = mCharBuffer.size();
BinWrite(out, size);
for (const auto &it : mCharBuffer) {
BinWrite(out, it.first);
auto csize = it.second.size();
BinWrite(out, csize);
out.write((char*)it.second.data(), it.second.size());
}
return true;
}
//------------------------------------------------------------
bool ofFmodSoundPlayer::load(std::filesystem::path fileName, bool stream){
fileName = ofToDataPath(fileName);
// fmod uses IO posix internally, might have trouble
// with unicode paths...
// says this code:
// http://66.102.9.104/search?q=cache:LM47mq8hytwJ:www.cleeker.com/doxygen/audioengine__fmod_8cpp-source.html+FSOUND_Sample_Load+cpp&hl=en&ct=clnk&cd=18&client=firefox-a
// for now we use FMODs way, but we could switch if
// there are problems:
bMultiPlay = false;
// [1] init fmod, if necessary
initializeFmod();
// [2] try to unload any previously loaded sounds
// & prevent user-created memory leaks
// if they call "loadSound" repeatedly, for example
unload();
// [3] load sound
//choose if we want streaming
int fmodFlags = FMOD_SOFTWARE;
if(stream)fmodFlags = FMOD_SOFTWARE | FMOD_CREATESTREAM;
result = FMOD_System_CreateSound(sys, fileName.string().c_str(), fmodFlags, nullptr, &sound);
if (result != FMOD_OK){
bLoadedOk = false;
ofLogError("ofFmodSoundPlayer") << "loadSound(): could not load \"" << fileName << "\"";
} else {
bLoadedOk = true;
FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_PCM);
isStreaming = stream;
}
return bLoadedOk;
}
bool writePipe(const std::filesystem::path &pipe, const std::wstring &data, bool wait)
{
HANDLE hPipe = CreateFile(pipe.wstring().c_str(), GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0,
nullptr);
if (hPipe != INVALID_HANDLE_VALUE) {
DWORD written;
const DWORD toWrite = static_cast<DWORD>(data.size() * sizeof(wchar_t));
WriteFile(hPipe, data.c_str(), toWrite, &written, nullptr);
const bool success = written == toWrite;
tLog << (success ? L"Wrote: " : L"Failed to write: ") << data << " to " << pipe;
WriteFile(hPipe, nullptr, sizeof(wchar_t), &written, nullptr);
CloseHandle(hPipe);
return success;
} else if (wait) {
// wait and retry
Sleep(20000);
return writePipe(pipe, data);
}
tLog << L"Failed to open pipe: " << pipe << L" data: " << data;
return false;
}
std::system_error run_process(const std::filesystem::path& filename, const std::vector<std::string>& argv,
const std::vector<std::string>& envp)
{
std::memset(&si, 0, sizeof(si));
std::memset(&pi, 0, sizeof(pi));
command_line = filename.string();
for (const auto& s : argv)
{
command_line += " " + quote_this(s);
}
std::vector<char> env_block;
env_block.reserve(env.size() * 128);
for (const auto& keys : envp)
{
env_block.insert(env_block.end(), keys.begin(), keys.end());
env_block.push_back('\0');
}
env_block.push_back('\0');
#ifdef _DEBUG
std::cout << command_line << std::endl;
#endif
char* env_block_data = nullptr;
if(envp.size())
env_block_data = env_block.data();
auto result = ::CreateProcessA(NULL, command_line.data(), NULL, NULL,
TRUE, NULL, env_block_data, running_dir.data(), &si, &pi);
if (result > 0)
{
attached = true;
}
else
{
return std::system_error(std::error_code(GetLastError(), std::system_category()));
}
return std::system_error(std::make_error_code(std::errc(0)));
}
bool startProcess(const std::filesystem::path &app)
{
STARTUPINFO info = {};
info.cb = sizeof(info);
PROCESS_INFORMATION pInfo = {};
const auto application = app.wstring();
if (!CreateProcess(const_cast<wchar_t *>(application.c_str()),
const_cast<wchar_t *>(application.c_str()), nullptr, nullptr, false,
DETACHED_PROCESS | INHERIT_PARENT_AFFINITY | CREATE_NO_WINDOW, nullptr,
nullptr, &info, &pInfo)) {
tLog << L"Failed to start: " << app;
return false;
}
WaitForInputIdle(pInfo.hProcess, INFINITE);
DWORD status;
GetExitCodeProcess(pInfo.hProcess, &status);
CloseHandle(pInfo.hProcess);
CloseHandle(pInfo.hThread);
tLog << L"Started: " << app << L" Status: "
<< (status == STILL_ACTIVE ? L"STILL_ACTIVE" : std::to_wstring(status));
return status == STILL_ACTIVE;
}
bool TTFCache::LoadCache(std::filesystem::path cachepath)
{
std::ifstream in(cachepath.string(), std::ios::binary);
if (!in.is_open()) return false;
mCharBuffer.clear();
int size;
BinRead(in, size);
while (!in.eof() && size > 0) {
size_t chsize;
int id;
BinRead(in, id);
BinRead(in, chsize);
std::vector<uint8_t> buf(chsize);
in.read((char*)buf.data(), chsize);
mCharBuffer[id] = std::move(buf);
size--;
}
return true;
}
static std::filesystem::path remove_filename_extension(const std::filesystem::path& filename) {
const auto extension_index = filename.find_last_of('.');
return filename.substr(0, extension_index);
}
ofHttpResponse ofURLFileLoaderImpl::saveTo(const string& url, const std::filesystem::path& path){
ofHttpRequest request(url,path.string(),true);
return handleRequest(request);
}
int ofURLFileLoaderImpl::saveAsync(const string& url, const std::filesystem::path& path){
ofHttpRequest request(url,path.string(),true);
requests.send(request);
start();
return request.getId();
}
// The processPath ends with dotnet.exe or dotnet
// like: C:\Program Files\dotnet\dotnet.exe, C:\Program Files\dotnet\dotnet, dotnet.exe, or dotnet.
// Get the absolute path to dotnet. If the path is already an absolute path, it will return that path
fs::path
HOSTFXR_UTILITY::GetAbsolutePathToDotnet(
const fs::path & applicationPath,
const fs::path & requestedPath
)
{
LOG_INFOF(L"Resolving absolute path to dotnet.exe from '%ls'", requestedPath.c_str());
auto processPath = requestedPath;
if (processPath.is_relative())
{
processPath = applicationPath / processPath;
}
//
// If we are given an absolute path to dotnet.exe, we are done
//
if (is_regular_file(processPath))
{
LOG_INFOF(L"Found dotnet.exe at '%ls'", processPath.c_str());
return processPath;
}
// At this point, we are calling where.exe to find dotnet.
// If we encounter any failures, try getting dotnet.exe from the
// backup location.
// Only do it if no path is specified
if (requestedPath.has_parent_path())
{
LOG_INFOF(L"Absolute path to dotnet.exe was not found at '%ls'", requestedPath.c_str());
throw InvalidOperationException(format(L"Could not find dotnet.exe at '%s'", processPath.c_str()));
}
const auto dotnetViaWhere = InvokeWhereToFindDotnet();
if (dotnetViaWhere.has_value())
{
LOG_INFOF(L"Found dotnet.exe via where.exe invocation at '%ls'", dotnetViaWhere.value().c_str());
return dotnetViaWhere.value();
}
const auto programFilesLocation = GetAbsolutePathToDotnetFromProgramFiles();
if (programFilesLocation.has_value())
{
LOG_INFOF(L"Found dotnet.exe in Program Files at '%ls'", programFilesLocation.value().c_str());
return programFilesLocation.value();
}
LOG_INFOF(L"dotnet.exe not found");
throw InvalidOperationException(format(
L"Could not find dotnet.exe at '%s' or using the system PATH environment variable."
" Check that a valid path to dotnet is on the PATH and the bitness of dotnet matches the bitness of the IIS worker process.",
processPath.c_str()));
}