bool remove(const path & p) { int ret = ::remove(p.string().c_str()); return !ret || ret == ENOENT || ret == ENOTDIR; }
bool operator<(const path& lhs, const path& rhs) noexcept { return lhs.compare(rhs) < 0; }
long ExtractCurrentFile ( path parent, unzFile uf ) { long error = UNZ_OK; char filename_inzip[PATH_MAX]; unz_file_info64 file_info; error = unzGetCurrentFileInfo64 ( uf, &file_info, filename_inzip, sizeof ( filename_inzip ), NULL, 0, NULL, 0 ); path file = filename_inzip; file.make_preferred(); parent.make_preferred(); if ( error == UNZ_OK ) { std::string macos = "__MACOSX"; if ( file.string().compare ( 0, macos.length(), macos ) == 0 ) { return kNoError; } path to_write = parent / file; create_directories ( to_write.parent_path() ); if ( file.filename().string() == "." ) { create_directory ( to_write ); } else { error = unzOpenCurrentFilePassword ( uf, NULL ); if ( error == UNZ_OK ) { char * buffer = new char [ WRITEBUFFERSIZE ]; boost::filesystem::ofstream output_file ( to_write, std::ios_base::binary ); output_file.exceptions ( boost::filesystem::ofstream::badbit | boost::filesystem::ofstream::failbit ); long bytes_read = 0; do { bytes_read = unzReadCurrentFile ( uf, (void *)buffer, WRITEBUFFERSIZE ); if ( bytes_read > 0 ) { output_file.write ( buffer, bytes_read ); } else if ( bytes_read < 0 ) { error = bytes_read; } } while ( bytes_read > 0 ); output_file.close(); ChangeFileDate ( to_write, file_info.tmu_date ); delete [] buffer; } // don't lose the error int close_error = unzCloseCurrentFile ( uf ); if ( error == UNZ_OK ) { error = close_error; } } } return error; } // ExtractCurrentFile
void pushFlowThrowPath(const path& p, const F& pFlow) { for (typename path::const_iterator v = p.begin(); v != p.end() - 1; ++v) { flows.at(*v).at(*(v + 1)) += pFlow; flows.at(*(v + 1)).at(*v) -= pFlow; } }
void swap(path& lhs, path& rhs) noexcept { lhs.swap(rhs); }
boost::intmax_t getFileSize(path &myPath){ if ( !exists(myPath) ) throw std::string("file "+myPath.string()+" doesn't exist"); return file_size(myPath); }
/*************************** Find liblightsparkBACKENDplugin libraries ****************************/ void PluginManager::findPlugins() { //Search for all files under the plugins directory //Verify if they are audio plugins //If true, add to list of audio plugins #ifdef _WIN32 const path plugins_folder = getExectuablePath(); #else const path plugins_folder = string(PRIVATELIBDIR) + "/plugins/"; #endif const string pattern ( "liblightspark+[A-Za-z]+plugin.*" ); //Stuff used by/for pcre const char* patternError; int patternErrorOffset; pcre* file_pattern = pcre_compile ( pattern.c_str(), 0, &patternError, &patternErrorOffset, NULL ); if(patternError) throw RunTimeException("PluginManager::findPlugins(): can't compile file_pattern"); //We don't expect any captured substrings, so 3 ints should be enough #if defined DEBUG LOG(LOG_INFO, "Looking for plugins under " << plugins_folder << " for pattern " << pattern); #endif if ( !is_directory ( plugins_folder ) ) { LOG ( LOG_ERROR, _ ( ( ( string ) ( "The plugins folder doesn't exists under " + plugins_folder.string() ) ).c_str() ) ); } else { for ( directory_iterator itr ( plugins_folder ), end_itr; itr != end_itr; ++itr ) { if ( is_regular_file ( *itr ) ) //Is it a real file? This will remove symlink { #if BOOST_VERSION >= 104600 string leaf_name = itr->path().filename().string(); #else string leaf_name = itr->path().filename(); #endif int patternOvector[3]; int rc=pcre_exec(file_pattern, NULL, leaf_name.c_str(), leaf_name.length(), 0, 0, patternOvector, 3); if ( rc > 0 ) // Does it answer to the desired pattern? { #if BOOST_VERSION >= 104600 path fullpath = plugins_folder.string(); #else path fullpath = plugins_folder.directory_string(); #endif fullpath /= leaf_name; //Try to load the file and see if it's an audio plugin if ( GModule* h_plugin = g_module_open( fullpath.string().c_str(), G_MODULE_BIND_LAZY) ) { PLUGIN_FACTORY p_factory_function; PLUGIN_CLEANUP p_cleanup_function; if ( g_module_symbol(h_plugin, "create", (void**)&p_factory_function) && g_module_symbol(h_plugin, "release", (void**)&p_cleanup_function) ) { //Does it contain the LS IPlugin? IPlugin *p_plugin = p_factory_function (); //Instanciate the plugin LOG ( LOG_INFO, _ ( "A plugin was found. Adding it to the list." ) ); addPluginToList ( p_plugin, fullpath.string() ); //Add the plugin info to the audio plugins list p_cleanup_function ( p_plugin ); g_module_close ( h_plugin ); } else //If doesn't implement our IPlugin interface entry points, close it { g_module_close( h_plugin ); } } } } } } pcre_free(file_pattern); }
size_type filesys::file_size(const path & p) { struct stat stats; if (stat(p.c_str(), &stats) != 0) return 0; return stats.st_size; }
/// \brief Attempt to parse the specified options /// /// \pre All previously added options_blocks must still exist /// /// \pre The two parameters must be in the standard argc/argv configuration /// /// Note that the two input parameters are taken const /// (including the argv being (a pointer to) an array of const pointers *to const*) /// so they will remain untouched. /// /// \post The options will be parsed and ready for querying void executable_options::parse_options(const int &argc, ///< The argc from command line parameters const char * const argv[] ///< The argv from command line parameters ) { // Check the options haven't already been processed if (processed_options) { BOOST_THROW_EXCEPTION(invalid_argument_exception("Cannot process options once they have already been processed")); } // Create two options_description, one complete and another containing all visible options options_description full_po_desc ( DEFAULT_PROG_OPS_LINE_LENGTH ); options_description visible_po_desc( DEFAULT_PROG_OPS_LINE_LENGTH ); // Frustratingly, Boost 1.41 (as used by orengobuild64) won't accept a const argv, so // it's necessary to construct a fake argc/argv here argc_argv_faker fake_argc_argv(argc, argv); int new_argc = fake_argc_argv.get_argc(); char * * new_argv = fake_argc_argv.get_argv(); // Add each of the options_blocks to po_desc for (options_block * const options_block_ptr : all_options_blocks) { const options_description hidden_opts = options_block_ptr->get_hidden_options_description( DEFAULT_PROG_OPS_LINE_LENGTH ); const options_description visible_opts = options_block_ptr->get_visible_options_description( DEFAULT_PROG_OPS_LINE_LENGTH ); full_po_desc.add( hidden_opts ); full_po_desc.add( visible_opts ); visible_po_desc.add( visible_opts ); } // Attempt the parses and catch any exceptions // // The parses are performed in decreasing order of precedence // (ie options specified via the command line should take precedence over those // specified via environment variables so it comes first) // // \todo If this gets any more complicated then consider putting each of these // different parses into different objects (presumably of classes deriving from // a single ABC). string parsing_approach = ""; try { // Parse options from the command line parsing_approach = "from the command line"; const positional_options_description positionals = get_positional_options(); processed_options = true; store( command_line_parser( new_argc, new_argv ).options( full_po_desc ).positional( positionals ).run(), vm ); // Parse any environment variables prefixed with "CATH_TOOLS_" // and just silently ignore any unknown options parsing_approach = "from global environment variables with prefix " + CATH_TOOLS_ENVIRONMENT_VARIABLE_PREFIX; //! [Using env_var_option_name_handler] store( parse_environment( full_po_desc, env_var_option_name_handler( CATH_TOOLS_ENVIRONMENT_VARIABLE_PREFIX, true, full_po_desc ) ), vm ); //! [Using env_var_option_name_handler] // Parse any configuration file called cath_tools.conf const path located_cath_tools_conf_file = find_file(CATH_TOOLS_CONF_FILE_SEARCH_PATH, CATH_TOOLS_CONF_FILE.string()); if (!located_cath_tools_conf_file.empty()) { // cerr << "Parsing configuration from file " << CATH_TOOLS_CONF_FILE << endl; parsing_approach = "from the global configuration file " + located_cath_tools_conf_file.string(); ifstream config_file_stream; open_ifstream(config_file_stream, CATH_TOOLS_CONF_FILE); store(parse_config_file(config_file_stream, full_po_desc, true), vm); config_file_stream.close(); } // All parsing is complete so call notify, which will trigger any // post-parsing hooks to get called notify(vm); } catch (std::exception &e) { error_or_help_string = get_program_name() + ": Error in parsing program options (" + parsing_approach + "): " + e.what(); } catch (...) { error_or_help_string = get_program_name() + ": Caught an unrecognised exception whilst parsing program options (" + parsing_approach + ").\n"; } // If no error has yet been encountered // and if any of the blocks return non-empty invalid_string() results, // then set error_or_help_string to the first if (error_or_help_string.empty()) { for (options_block * const options_block_ptr : all_options_blocks) { const opt_str block_invalid_string = options_block_ptr->invalid_string(); if ( block_invalid_string ) { error_or_help_string = *block_invalid_string; break; } } } // If an error string has already arisen from the parsing or from an options block being invalid... if (!error_or_help_string.empty()) { // ...and if doesn't already end with the standard usage error string // (eg "Try 'cath-ssap --help' for usage information.") // then append it now. if (!ends_with(error_or_help_string, get_standard_usage_error_string())) { error_or_help_string += ("\n" + get_standard_usage_error_string()); } } // Else there is no error string yet, so now let the derived class consider then // set it to whatever the derived class decides else { error_or_help_string = do_update_error_or_help_string( visible_po_desc ); } }
// ---------------------------------------------------------------------------- Track::Track(path file) { m_valid = true; FILE* pFile; pFile = fopen(file.c_str(), "rb"); if (!pFile) { m_valid = false; stringw emsg = _("Editor failed to open file:\n \""); emsg += file; emsg += "\""; MsgWndw::get()->showMsg(emsg); return; } // SIGN u64 sign; fread(&sign, sizeof(u64), 1, pFile); if (sign != TOP_SECRET_SIGNATURE_NUMBER) { MsgWndw::get()->showMsg(_("File can not be opened: signature failed.")); m_valid = false; fclose(pFile); return; } // TRACK NAME u8 size; wchar_t* c; fread(&size, sizeof(u8), 1, pFile); if (!Editor::isValidSize(size)) { fclose(pFile); m_valid = false; MsgWndw::get()->showMsg(_("File loading failed!")); return; } c = new wchar_t[size]; fread(c, sizeof(wchar_t), size, pFile); m_track_name = c; delete[] c; // DESIGNER NAME fread(&size, sizeof(u8), 1, pFile); if (!Editor::isValidSize(size)) { fclose(pFile); m_valid = false; MsgWndw::get()->showMsg(_("File loading failed!")); return; } c = new wchar_t[size]; fread(c, sizeof(wchar_t), size, pFile); m_designer = c; delete[] c; // FILE NAME c8* cc; fread(&size, sizeof(u8), 1, pFile); if (!Editor::isValidSize(size)) { fclose(pFile); m_valid = false; MsgWndw::get()->showMsg(_("File loading failed!")); return; } cc = new c8[size]; fread(cc, sizeof(c8), size, pFile); m_file_name = cc; delete[] cc; // MUSIC fread(&size, sizeof(u8), 1, pFile); if (!Editor::isValidSize(size)) { fclose(pFile); m_valid = false; MsgWndw::get()->showMsg(_("File loading failed!")); return; } cc = new c8[size]; fread(cc, sizeof(c8), size, pFile); m_music = cc; delete[] cc; // TERRAIN ISceneManager* sm = Editor::getEditor()->getSceneManager(); m_terrain = new Terrain(sm->getRootSceneNode(), sm, 1, pFile); if (!m_terrain->isValid()) { fclose(pFile); MsgWndw::get()->showMsg(_("Loading failed :invalid terrain!")); m_valid = false; return; } // SKY Sky* s = Viewport::get()->getSky(); delete s; s = new Sky(pFile); Viewport::get()->setSky(s); // GRAVITY ROAD FLAG fread(&m_gravity_road, sizeof(bool), 1, pFile); // ROADS fread(&size, sizeof(u8), 1, pFile); if (size < 0 || size > MAX_ROAD_NUM) { MsgWndw::get()->showMsg(_("Loading failed: invalid terrain!")); } else { if (size > 0) { m_driveline = new DriveLine(sm->getRootSceneNode(), sm, 0, pFile); if (!m_driveline->isValid()) { std::cerr << _("Warning: invalid driveline!\n"); ISpline* spline = new TCR(sm->getRootSceneNode(), sm, 0); m_driveline = new DriveLine(sm->getRootSceneNode(), sm, 0, spline, L"DriveLine"); } m_roads.push_back(m_driveline); m_driveline->refresh(); } // driveline for (u8 i = 1; i < size; i++) { std::unique_ptr<IRoad> r(new Road(sm->getRootSceneNode(), sm, 0, pFile)); if (r->isValid()) { m_roads.push_back(r.get()); r->refresh(); r->setWireFrame(false); Viewport::get()->setSplineMode(false); // Explicitly release r to prevent it from being deleted. r.release(); } else std::cerr << "Warning: invalid road - skipped :(\n"; } // roads } // valid roadnum // CHECKLINES Viewport::get()->loadCheckLines(pFile); // OBJECTS u32 num; fread(&num, sizeof(u32), 1, pFile); Viewport::setLastEntityID(num + MAGIC_NUMBER); for (u32 i = 0; i < num; i++) { ISceneNode* node = 0; vector3df pos, rot, sca; fread(&pos, sizeof(vector3df), 1, pFile); fread(&rot, sizeof(vector3df), 1, pFile); fread(&sca, sizeof(vector3df), 1, pFile); u8 size; fread(&size, sizeof(u8), 1, pFile); if (!Editor::isValidSize(size)) { m_valid = false; MsgWndw::get()->showMsg(_("Loading failed!")); fclose(pFile); return; } c8 *name = new c8[size]; fread(name, sizeof(c8), size, pFile); path p = name; if (p == path("banana") || p == path("item") || p == path("small-nitro") || p == path("big-nitro")) { node = loadItem(name); } // item else { node = sm->addAnimatedMeshSceneNode(sm->getMesh(p)); node->setName(name); } // object if (node) { node->setPosition(pos); node->setRotation(rot); node->setScale(sca); node->setID(MAGIC_NUMBER + i + 1); } // valid node else { std::cerr << "Warning: couldn't load object < " << name << " >!\n"; num -= 1; i -= 1; } // invalid node delete[] name; } fclose(pFile); } // Track - from file
/*************************** Find liblightsparkBACKENDplugin libraries ****************************/ void PluginManager::findPlugins() { //Search for all files under ${PRIVATELIBDIR}/plugins //Verify if they are audio plugins //If true, add to list of audio plugins string froot ( PRIVATELIBDIR ), fplugins ( "/plugins/" ); //LS should always look in the plugins folder, nowhere else const path plugins_folder = froot + fplugins; const string pattern ( "liblightspark+[A-Za-z]+plugin.so" ); //Stuff used by/for pcre const char* patternError; int patternErrorOffset; pcre* file_pattern = pcre_compile ( pattern.c_str(), 0, &patternError, &patternErrorOffset, NULL ); if(patternError) throw RunTimeException("PluginManager::findPlugins(): can't compile file_pattern"); //We don't expect any captured substrings, so 3 ints should be enough int patternOvector[3]; #if defined DEBUG cout << "Looking for plugins under " << plugins_folder << " for pattern " << pattern << endl; #endif if ( !is_directory ( plugins_folder ) ) { LOG ( LOG_ERROR, _ ( ( ( string ) ( "The plugins folder doesn't exists under " + plugins_folder.string() ) ).c_str() ) ); } else { for ( recursive_directory_iterator itr ( plugins_folder ), end_itr; itr != end_itr; ++itr ) { if ( is_regular_file ( itr.status() ) ) //Is it a real file? This will remove symlink { string leaf_name = itr->path().filename(); int rc=pcre_exec(file_pattern, NULL, leaf_name.c_str(), leaf_name.length(), 0, 0, patternOvector, 3); if ( rc > 0 ) // Does it answer to the desired pattern? { string fullpath = plugins_folder.directory_string() + leaf_name; //Try to load the file and see if it's an audio plugin if ( HMODULE h_plugin = LoadLib ( fullpath ) ) { PLUGIN_FACTORY p_factory_function = ( PLUGIN_FACTORY ) ExtractLibContent ( h_plugin, "create" ); PLUGIN_CLEANUP p_cleanup_function = ( PLUGIN_CLEANUP ) ExtractLibContent ( h_plugin, "release" ); if ( p_factory_function != NULL && p_cleanup_function != NULL ) //Does it contain the LS IPlugin? { IPlugin *p_plugin = ( *p_factory_function ) (); //Instanciate the plugin LOG ( LOG_NO_INFO, _ ( "A plugin was found. Adding it to the list." ) ); addPluginToList ( p_plugin, fullpath ); //Add the plugin info to the audio plugins list ( *p_cleanup_function ) ( p_plugin ); CloseLib ( h_plugin ); } else //If doesn't implement our IPlugin interface entry points, close it { CloseLib ( h_plugin ); } } } } } } pcre_free(file_pattern); }
void encrypt(path &filesPlace, path &keysPlace) { if (!groupes.size()) { std::cout << "Files are not grouped" << std::endl; return; } for (auto it : groupes) { std::ostringstream dataToEncode; auto group = it.second; for (auto currentFile : group) { std::ifstream input(filesPlace.string() + currentFile, std::ios::binary); if (!input.is_open()) { std::cout << "Wrong directory: " << filesPlace.string(); exit(0); } //Obtaining file data std::string buffer(( std::istreambuf_iterator<char >(input)), (std::istreambuf_iterator<char >())); //Encode to hex if file is an image if (it.first.second == IMAGE) { std::string encoded_image; bn::encode_b16(buffer.begin(), buffer.end(), std::back_inserter(encoded_image)); dataToEncode << currentFile << std::endl << encoded_image.size() << std::endl << encoded_image; } else { dataToEncode << currentFile << std::endl << buffer.size() << std::endl << buffer; } input.close(); } //Size of files to decode int size = dataToEncode.tellp(); DES_cblock key; DES_random_key(&key); DES_key_schedule key_schedule; DES_set_key_checked(&key, &key_schedule); //ncbc block magic size_t len = (size + 7) / 8 * 8; char *output = new char[len + 1]; DES_cblock ivec; memset((char*)&ivec, 0, sizeof(ivec)); DES_ncbc_encrypt((unsigned char *)&dataToEncode.str()[0], (unsigned char *)output, size, &key_schedule, &ivec, DES_ENCRYPT); std::string Day = std::to_string(it.first.first); std::string Type = it.first.second == TEXT ? "txt" : "image"; std::string encodedFileName = Type + "_" + Day; std::ofstream outputFile(filesPlace.string() + encodedFileName, std::ofstream::in | std::ofstream::trunc | std::ofstream::binary); std::ofstream outputKey(keysPlace.string() + encodedFileName + "_key", std::ofstream::in | std::ofstream::trunc | std::ofstream::binary); if (!outputFile.is_open()) { std::cout << "Cannot create output file: " << encodedFileName; exit(0); } outputFile.write(output, len); if (!outputKey.is_open()) { std::cout << "Cannot create output key for file: " << encodedFileName; exit(0); } outputKey.write((char *)key, sizeof(key)); outputFile.close(); outputKey.close(); } }
void decrypt(path &filePlace, path &keyPlace) { std::ifstream fileToDecode(filePlace.string(), std::ios::binary); std::ifstream fileWithKey(keyPlace.string(), std::ios::binary); if (!fileToDecode.is_open()) { std::cout << "Cannot open file to decode: " << filePlace.filename().string(); exit(0); } if (!fileWithKey.is_open()) { std::cout << "Cannot open file with key: " << keyPlace.filename().string(); exit(0); } DES_cblock key; fileWithKey.read((char *)key, file_size(keyPlace)); DES_key_schedule key_schedule; DES_set_key_checked(&key, &key_schedule); DES_cblock ivec; memset((char*)&ivec, 0, sizeof(ivec)); char *inputData = new char[file_size(filePlace)]; char *outputData = new char[file_size(filePlace)]; memset(inputData, 0, file_size(filePlace)); memset(outputData, 0, file_size(filePlace)); fileToDecode.read(inputData, file_size(filePlace)); DES_ncbc_encrypt((unsigned char *)inputData, (unsigned char *)outputData, file_size(filePlace), &key_schedule, &ivec, DES_DECRYPT); std::stringstream outputDataStream(outputData); std::string newFileName; std::string size; //Loop for file data while (std::getline(outputDataStream, newFileName)) { std::getline(outputDataStream, size); int fileSize = std::stoi(size); std::string newData; newData.resize(fileSize + 1); outputDataStream.read(&newData[0], fileSize); std::ofstream outputFile; //if on Linux if (filePlace.parent_path().string()[0] == '/') { outputFile.open(filePlace.parent_path().string() + "/" + newFileName, std::ofstream::out | std::ofstream::trunc | std::ofstream::binary); } else { outputFile.open(filePlace.parent_path().string() + "\\" + newFileName, std::ofstream::out | std::ofstream::trunc | std::ofstream::binary); } if (!outputFile.is_open()) { std::cout << "Cannot create new file: " << newFileName; exit(0); } //If it`s an image then decode back path p(newFileName); if (p.extension() != ".txt") { char *decoded_image = new char[fileSize + 1]; bn::decode_b16(newData.begin(), newData.end(), decoded_image); outputFile.write(decoded_image, fileSize); } else { outputFile.write(&newData[0], fileSize); } outputFile.close(); } fileToDecode.close(); fileWithKey.close(); delete[] inputData; delete[] outputData; }
//! Like IGPUProgrammingServices::addShaderMaterial() (look there for a detailed description), //! but tries to load the programs from files. s32 CNullDriver::addHighLevelShaderMaterialFromFiles( const path& vertexShaderProgramFileName, const c8* vertexShaderEntryPointName, E_VERTEX_SHADER_TYPE vsCompileTarget, const path& pixelShaderProgramFileName, const c8* pixelShaderEntryPointName, E_PIXEL_SHADER_TYPE psCompileTarget, const path& geometryShaderProgramFileName, const c8* geometryShaderEntryPointName, E_GEOMETRY_SHADER_TYPE gsCompileTarget, E_PRIMITIVE_TYPE inType, E_PRIMITIVE_TYPE outType, u32 verticesOut, IShaderConstantSetCallBack* callback, E_MATERIAL_TYPE baseMaterial, s32 userData, E_GPU_SHADING_LANGUAGE shadingLang) { IReadFile* vsfile = 0; IReadFile* psfile = 0; IReadFile* gsfile = 0; if (vertexShaderProgramFileName.size() ) { vsfile = FileSystem->createAndOpenFile(vertexShaderProgramFileName); if (!vsfile) { Printer::log("Could not open vertex shader program file", vertexShaderProgramFileName, ELL_WARNING); } } if (pixelShaderProgramFileName.size() ) { psfile = FileSystem->createAndOpenFile(pixelShaderProgramFileName); if (!psfile) { Printer::log("Could not open pixel shader program file", pixelShaderProgramFileName, ELL_WARNING); } } if (geometryShaderProgramFileName.size() ) { gsfile = FileSystem->createAndOpenFile(geometryShaderProgramFileName); if (!gsfile) { Printer::log("Could not open geometry shader program file", geometryShaderProgramFileName, ELL_WARNING); } } s32 result = addHighLevelShaderMaterialFromFiles( vsfile, vertexShaderEntryPointName, vsCompileTarget, psfile, pixelShaderEntryPointName, psCompileTarget, gsfile, geometryShaderEntryPointName, gsCompileTarget, inType, outType, verticesOut, callback, baseMaterial, userData, shadingLang); if (psfile) psfile->releaseRef(); if (vsfile) vsfile->releaseRef(); if (gsfile) gsfile->releaseRef(); return result; }
void __rename(const path& from, const path& to, std::error_code *ec) { if (::rename(from.c_str(), to.c_str()) == -1) set_or_throw(ec, "rename", from, to); else if (ec) ec->clear(); }
void file_name_check::inspect( const string & library_name, const path & full_path ) { string::size_type pos; // called for each file and directory, so only the leaf need be tested string const leaf( full_path.leaf().string() ); // includes only allowable characters if ( (pos = leaf.find_first_not_of( allowable )) != string::npos ) { ++m_name_errors; error( library_name, full_path, loclink(full_path, string(name())) + " file or directory name contains unacceptable character '" + leaf[pos] + "'" ); } // allowable initial character if ( std::strchr( initial_char, leaf[0] ) == nullptr ) { ++m_name_errors; error( library_name, full_path, loclink(full_path, string(name())) + " file or directory name begins with an unacceptable character" ); } // rules for dot characters differ slightly for directories and files if ( filesystem::is_directory( full_path ) ) { if ( std::strchr( leaf.c_str(), '.' ) ) { ++m_name_errors; error( library_name, full_path, loclink(full_path, string(name())) + " directory name contains a dot character ('.')" ); } } //else // not a directory //{ // // includes at most one dot character // const char * first_dot = std::strchr( leaf.c_str(), '.' ); // if ( first_dot && std::strchr( first_dot+1, '.' ) ) // { // ++m_name_errors; // error( library_name, full_path, string(name()) // + " file name with more than one dot character ('.')" ); // } //} // the path, including a presumed root, does not exceed the maximum size path const relative_path( relative_to( full_path, search_root_path() ) ); const unsigned max_relative_path = 207; // ISO 9660:1999 sets this limit const string generic_root( "boost_X_XX_X/" ); if ( relative_path.string().size() > ( max_relative_path - generic_root.size() ) ) { ++m_name_errors; error( library_name, full_path, loclink(full_path, string(name())) + " path will exceed " + boost::lexical_cast<string>(max_relative_path) + " characters in a directory tree with a root in the form " + generic_root + ", and this exceeds ISO 9660:1999 limit of 207" ) ; } }
void __resize_file(const path& p, std::uintmax_t size, std::error_code *ec) { if (::truncate(p.c_str(), static_cast<long>(size)) == -1) set_or_throw(ec, "resize_file", p); else if (ec) ec->clear(); }
void open( const path & file_ph, std::ios_base::openmode mode = std::ios_base::out ) { std::basic_ofstream<charT,traits>::open( file_ph.native_file_string().c_str(), mode ); }
void get_files_in_dir(const std::string &dir, std::vector<std::string>* files, std::vector<std::string>* dirs, file_name_option mode, file_filter_option filter, file_reorder_option reorder, file_tree_checksum* checksum) { if(path(dir).is_relative() && !game_config::path.empty()) { path absolute_dir(game_config::path); absolute_dir /= dir; if(is_directory_internal(absolute_dir)) { get_files_in_dir(absolute_dir.string(), files, dirs, mode, filter, reorder, checksum); return; } } const path dirpath(dir); if (reorder == DO_REORDER) { LOG_FS << "searching for _main.cfg in directory " << dir << '\n'; const path maincfg = dirpath / maincfg_filename; if (file_exists(maincfg)) { LOG_FS << "_main.cfg found : " << maincfg << '\n'; push_if_exists(files, maincfg, mode == ENTIRE_FILE_PATH); return; } } error_code ec; bfs::directory_iterator di(dirpath, ec); bfs::directory_iterator end; if (ec) { // Probably not a directory, let the caller deal with it. return; } for(; di != end; ++di) { bfs::file_status st = di->status(ec); if (ec) { LOG_FS << "Failed to get file status of " << di->path().string() << ": " << ec.message() << '\n'; continue; } if (st.type() == bfs::regular_file) { { std::string basename = di->path().filename().string(); if (filter == SKIP_PBL_FILES && looks_like_pbl(basename)) continue; if(!basename.empty() && basename[0] == '.' ) continue; } push_if_exists(files, di->path(), mode == ENTIRE_FILE_PATH); if (checksum != NULL) { std::time_t mtime = bfs::last_write_time(di->path(), ec); if (ec) { LOG_FS << "Failed to read modification time of " << di->path().string() << ": " << ec.message() << '\n'; } else if (mtime > checksum->modified) { checksum->modified = mtime; } uintmax_t size = bfs::file_size(di->path(), ec); if (ec) { LOG_FS << "Failed to read filesize of " << di->path().string() << ": " << ec.message() << '\n'; } else { checksum->sum_size += size; } checksum->nfiles++; } } else if (st.type() == bfs::directory_file) { std::string basename = di->path().filename().string(); if(!basename.empty() && basename[0] == '.' ) continue; if (filter == SKIP_MEDIA_DIR && (basename == "images" || basename == "sounds")) continue; const path inner_main(di->path() / maincfg_filename); bfs::file_status main_st = bfs::status(inner_main, ec); if (error_except_not_found(ec)) { LOG_FS << "Failed to get file status of " << inner_main.string() << ": " << ec.message() << '\n'; } else if (reorder == DO_REORDER && main_st.type() == bfs::regular_file) { LOG_FS << "_main.cfg found : " << (mode == ENTIRE_FILE_PATH ? inner_main.string() : inner_main.filename().string()) << '\n'; push_if_exists(files, inner_main, mode == ENTIRE_FILE_PATH); } else { push_if_exists(dirs, di->path(), mode == ENTIRE_FILE_PATH); } } } if (files != NULL) std::sort(files->begin(),files->end()); if (dirs != NULL) std::sort(dirs->begin(),dirs->end()); if (files != NULL && reorder == DO_REORDER) { // move finalcfg_filename, if present, to the end of the vector for (unsigned int i = 0; i < files->size(); i++) { if (ends_with((*files)[i], "/" + finalcfg_filename)) { files->push_back((*files)[i]); files->erase(files->begin()+i); break; } } // move initialcfg_filename, if present, to the beginning of the vector int foundit = -1; for (unsigned int i = 0; i < files->size(); i++) if (ends_with((*files)[i], "/" + initialcfg_filename)) { foundit = i; break; } if (foundit > 0) { std::string initialcfg = (*files)[foundit]; for (unsigned int i = foundit; i > 0; i--) (*files)[i] = (*files)[i-1]; (*files)[0] = initialcfg; } } }
explicit basic_fstream( const path & file_ph, std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out ) : std::basic_fstream<charT,traits>( file_ph.native_file_string().c_str(), mode ) {}
/** path to UTF-8 encoding. */ std::string toString(const path& p) { return p.generic_string(); }
path path::combine(const path &p) const { TCHAR combined[MAX_PATH]; PathCombine(combined, p_.c_str(), p.to_string().c_str()); return path(combined); }
int path::compare(const path& p) const noexcept { return native() < p.native(); }
void __copy(const path& from, const path& to, copy_options options, std::error_code *ec) { const bool sym_status = bool(options & (copy_options::create_symlinks | copy_options::skip_symlinks)); const bool sym_status2 = bool(options & copy_options::copy_symlinks); std::error_code m_ec; struct ::stat f_st = {}; const file_status f = sym_status || sym_status2 ? detail::posix_lstat(from, f_st, &m_ec) : detail::posix_stat(from, f_st, &m_ec); if (m_ec) return set_or_throw(m_ec, ec, "copy", from, to); struct ::stat t_st = {}; const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec) : detail::posix_stat(to, t_st, &m_ec); if (not status_known(t)) return set_or_throw(m_ec, ec, "copy", from, to); if (!exists(f) || is_other(f) || is_other(t) || (is_directory(f) && is_regular_file(t)) || detail::stat_equivalent(f_st, t_st)) { return set_or_throw(make_error_code(errc::function_not_supported), ec, "copy", from, to); } if (ec) ec->clear(); if (is_symlink(f)) { if (bool(copy_options::skip_symlinks & options)) { // do nothing } else if (not exists(t)) { __copy_symlink(from, to, ec); } else { set_or_throw(make_error_code(errc::file_exists), ec, "copy", from, to); } return; } else if (is_regular_file(f)) { if (bool(copy_options::directories_only & options)) { // do nothing } else if (bool(copy_options::create_symlinks & options)) { __create_symlink(from, to, ec); } else if (bool(copy_options::create_hard_links & options)) { __create_hard_link(from, to, ec); } else if (is_directory(t)) { __copy_file(from, to / from.filename(), options, ec); } else { __copy_file(from, to, options, ec); } return; } else if (is_directory(f)) { if (not bool(copy_options::recursive & options) && bool(copy_options::__in_recursive_copy & options)) { return; } if (!exists(t)) { // create directory to with attributes from 'from'. __create_directory(to, from, ec); if (ec && *ec) { return; } } directory_iterator it = ec ? directory_iterator(from, *ec) : directory_iterator(from); if (ec && *ec) { return; } std::error_code m_ec; for (; it != directory_iterator(); it.increment(m_ec)) { if (m_ec) return set_or_throw(m_ec, ec, "copy", from, to); __copy(it->path(), to / it->path().filename(), options | copy_options::__in_recursive_copy, ec); if (ec && *ec) { return; } } } }
size_t hash_value(const path& p) noexcept { return std::hash<path::string_type>()(p.generic_string()); }
void __create_hard_link(const path& from, const path& to, std::error_code *ec){ if (::link(from.c_str(), to.c_str()) == -1) set_or_throw(ec, "create_hard_link", from, to); else if (ec) ec->clear(); }
string replace_ending(path file, string new_ending){ string filename=file.string(); filename.erase(filename.rfind(".")+1); return filename+new_ending; }
void __current_path(const path& p, std::error_code *ec) { if (::chdir(p.c_str()) == -1) set_or_throw(ec, "current_path", p); else if (ec) ec->clear(); }
path canonical_parent(const path& pth, const path& base) { return canonical(pth.parent_path(), base) / pth.filename(); }
u64 file_size(const path & p) { struct stat buf; return stat(p.string().c_str(), &buf) ? (u64)-1 : (u64)buf.st_size; }