コード例 #1
0
ファイル: path.cpp プロジェクト: darkphase/LXiMedia
std::string home_dir()
{
    const char *home = getenv("HOME");
    if (home)
        return clean_path(home);

    struct passwd *pw = getpwuid(getuid());
    if (pw && pw->pw_dir)
        return clean_path(pw->pw_dir);

    return std::string();
}
コード例 #2
0
ファイル: lustre_cfg.c プロジェクト: hocks/lustre-release
int jt_lcfg_listparam(int argc, char **argv)
{
        int rc = 0, i;
        struct param_opts popt;
        char pattern[PATH_MAX];
        char *path;

        rc = listparam_cmdline(argc, argv, &popt);
        if (rc == argc && popt.po_recursive) {
                rc--;           /* we know at least "-R" is a parameter */
                argv[rc] = "*";
        } else if (rc < 0 || rc >= argc) {
                return CMD_HELP;
        }

        for (i = rc; i < argc; i++) {
                path = argv[i];

                clean_path(path);

                lprocfs_param_pattern(argv[0], path, pattern, sizeof(pattern));

                rc = listparam_display(&popt, pattern);
                if (rc < 0)
                        return rc;
        }

        return 0;
}
コード例 #3
0
ファイル: fe_image.cpp プロジェクト: mbarnes/attract
FeTextureContainer::FeTextureContainer(
	bool is_artwork,
	const std::string &art_name )
	: m_index_offset( 0 ),
	m_filter_offset( 0 ),
	m_current_rom_index( -1 ),
	m_current_filter_index( -1 ),
	m_art_update_trigger( ToNewSelection ),
	m_movie( NULL ),
	m_swf( NULL ),
	m_movie_status( -1 ),
	m_video_flags( VF_Normal )
{
	if ( is_artwork )
	{
		m_type = IsArtwork;
		m_art_name = art_name.empty() ? FE_DEFAULT_ARTWORK : art_name;
	}
	else if ( art_name.find_first_of( "[" ) != std::string::npos )
	{
		m_type = IsDynamic;
		m_art_name = clean_path( art_name );
	}
	else
		m_type = IsStatic;
}
コード例 #4
0
ファイル: lustre_cfg.c プロジェクト: hocks/lustre-release
int jt_lcfg_getparam(int argc, char **argv)
{
        int rc = 0, i;
        struct param_opts popt;
        char pattern[PATH_MAX];
        char *path;

        rc = getparam_cmdline(argc, argv, &popt);
        if (rc < 0 || rc >= argc)
                return CMD_HELP;

	for (i = rc, rc = 0; i < argc; i++) {
		int rc2;

		path = argv[i];

		clean_path(path);

		lprocfs_param_pattern(argv[0], path, pattern, sizeof(pattern));

		if (popt.po_only_path)
			rc2 = listparam_display(&popt, pattern);
		else
			rc2 = getparam_display(&popt, pattern);
		if (rc2 < 0 && rc == 0)
			rc = rc2;
	}

	return rc;
}
コード例 #5
0
ファイル: path.cpp プロジェクト: darkphase/LXiMedia
std::vector<std::string> list_files(
        const std::string &path,
        file_filter filter,
        size_t max_count)
{
    const std::wstring wpath = clean_path(platform::to_windows_path(::to_lower(path))) + L'\\';

    auto &hidden_dirs = platform::hidden_dirs();
    for (auto &i : hidden_dirs)
        if (starts_with(wpath, i + L'\\'))
            return std::vector<std::string>();

    std::vector<std::string> result;

    WIN32_FIND_DATA find_data;
    HANDLE handle = FindFirstFile((wpath + L'*').c_str(), &find_data);
    if (handle != INVALID_HANDLE_VALUE)
    {
        auto &hidden_names = platform::hidden_names();
        auto &hidden_suffixes = platform::hidden_suffixes();

        do
        {
            if ((find_data.cFileName[0] != L'.') &&
                ((find_data.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) == 0) &&
                ((find_data.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) == 0))
            {
                std::wstring name = find_data.cFileName, lname = to_lower(name);
                if ((find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
                    (hidden_names.find(lname) == hidden_names.end()) &&
                    (hidden_dirs.find(wpath + lname) == hidden_dirs.end()))
                {
                    result.emplace_back(from_utf16(name) + '/');
                }
                else if (filter == file_filter::all)
                {
                    result.emplace_back(from_utf16(name));
                }
                else if ((filter == file_filter::large_files) &&
                         (hidden_suffixes.find(suffix_of(lname)) ==
                          hidden_suffixes.end()))
                {
                    struct __stat64 stat;
                    if ((::_wstat64(
                                (wpath + find_data.cFileName).c_str(),
                                &stat) == 0) &&
                        (size_t(stat.st_size) >= min_file_size))
                    {
                        result.emplace_back(from_utf16(name));
                    }
                }
            }
        } while((result.size() < max_count) && (FindNextFile(handle, &find_data) != 0));

        FindClose(handle);
    }

    return result;
}
コード例 #6
0
ファイル: VisualNovel.cpp プロジェクト: rmxhaha/phantasia
		// clean messy text coming from the writers
		void clean()
		{
			if( !cleaned ) {
				clean_name();
				clean_log_text();
				clean_path();
				
				cleaned = true;
			}
		}
コード例 #7
0
ファイル: parserslow.c プロジェクト: tommie/xppaut
int add_file_table(int index, char *file) {
  char file2[XPP_MAX_NAME];
  clean_path(file2, sizeof(file2), file);
  if (load_table(file2, index) == 0) {
    plintf("Problem with creating table !!\n");
    return (1);
  }

  return (0);
}
コード例 #8
0
ファイル: lustre_cfg.c プロジェクト: hocks/lustre-release
int jt_lcfg_setparam(int argc, char **argv)
{
        int rc = 0, i;
        struct param_opts popt;
        char pattern[PATH_MAX];
        char *path = NULL, *value = NULL;

        rc = setparam_cmdline(argc, argv, &popt);
        if (rc < 0 || rc >= argc)
                return CMD_HELP;

	if (popt.po_params2)
		/* We can't delete parameters that were
		 * set with old conf_param interface */
		return jt_lcfg_mgsparam2(argc, argv, &popt);

	for (i = rc, rc = 0; i < argc; i++) {
		int rc2;

                if ((value = strchr(argv[i], '=')) != NULL) {
                        /* format: set_param a=b */
                        *value = '\0';
                        value ++;
                        path = argv[i];
			if (*value == '\0')
				break;
                } else {
                        /* format: set_param a b */
                        if (path == NULL) {
                                path = argv[i];
                                continue;
                        } else {
                                value = argv[i];
                        }
                }

                clean_path(path);

                lprocfs_param_pattern(argv[0], path, pattern, sizeof(pattern));

                rc2 = setparam_display(&popt, pattern, value);
                path = NULL;
                value = NULL;
		if (rc2 < 0 && rc == 0)
			rc = rc2;
	}
	if (path != NULL && (value == NULL || *value == '\0'))
		fprintf(stderr, "error: %s: setting %s=: %s\n",
			jt_cmdname(argv[0]), path, strerror(rc = EINVAL));

	return rc;
}
コード例 #9
0
ファイル: fe_image.cpp プロジェクト: mbarnes/attract
void FeTextureContainer::load_from_archive( const char *a, const char *n )
{
	std::string path, filename = clean_path( n );

	if ( filename.empty() )
	{
		clear();
		notify_texture_change();
		return;
	}

	if ( a && ( strlen( a ) > 0 ))
		path = clean_path( a );

	// If it is a relative path we assume it is in the
	// layout/screensaver/intro directory
	//
	else if ( is_relative_path( filename ) )
		path = FePresent::script_get_base_path();

	bool is_image=false;

	int i=0;
	while ( FE_ART_EXTENSIONS[i] )
	{
		if ( tail_compare( filename, FE_ART_EXTENSIONS[i] ) )
		{
			is_image=true;
			break;
		}
		i++;
	}

	try_to_load( path, filename, is_image );
	notify_texture_change();
}
コード例 #10
0
ファイル: main.cpp プロジェクト: avakar/gh
static bool open_wd(gitdb & db, git_wd & wd, string_view path)
{
	std::string apath = absolute_path(clean_path(path));
	path = apath;

	while (!path.empty())
	{
		std::string nonbare_path = join_paths(path, ".git");
		if (file::is_directory(nonbare_path))
		{
			db.open(nonbare_path);
			wd.open(db, path);
			return true;
		}

		path = path_head(path);
	}
	return false;
}
コード例 #11
0
ファイル: example_test.cpp プロジェクト: jiapei100/opennurbs
  const ON_wString Internal_CleanPath(const wchar_t* dirty_path) const
  {
    const wchar_t* volume = 0;
    const wchar_t* path = 0;

    // Use local path in case drive, dir, file_name_stem or ext are being reused.
    on_wsplitpath(dirty_path, &volume, &path, nullptr, nullptr);
    ON_wString clean_path(path);
    if (clean_path.IsEmpty())
      return ON_wString(dirty_path);
    clean_path.Replace(ON_wString::Backslash, ON_wString::Slash);
    
    if (nullptr != volume && volume < path)
    {
      ON_wString clean_volume(volume, (int)(path - volume));
      return (clean_volume + clean_path);
    }

    return clean_path;
  }
コード例 #12
0
ファイル: lustre_cfg.c プロジェクト: KnightKu/lustre-stable
int jt_lcfg_listparam(int argc, char **argv)
{
	int rc = 0, index, i;
	struct param_opts popt;
	char *path;

	memset(&popt, 0, sizeof(popt));
	index = listparam_cmdline(argc, argv, &popt);
	if (index < 0 || index >= argc)
		return CMD_HELP;

	for (i = index; i < argc; i++) {
		int rc2;

		path = argv[i];

		rc2 = clean_path(&popt, path);
		if (rc2 < 0) {
			fprintf(stderr, "error: %s: cleaning '%s': %s\n",
				jt_cmdname(argv[0]), path, strerror(-rc2));
			if (rc == 0)
				rc = rc2;
			continue;
		}

		rc2 = param_display(&popt, path, NULL, LIST_PARAM);
		if (rc2 < 0) {
			fprintf(stderr, "error: %s: listing '%s': %s\n",
				jt_cmdname(argv[0]), path, strerror(-rc2));
			if (rc == 0)
				rc = rc2;
			continue;
		}
	}

	return rc;
}
コード例 #13
0
ファイル: clidfs.c プロジェクト: kleopatra999/finx
BOOL cli_resolve_path( const char *mountpt,
			struct cli_state *rootcli,
			const char *path,
			struct cli_state **targetcli,
			pstring targetpath)
{
	CLIENT_DFS_REFERRAL *refs = NULL;
	size_t num_refs;
	uint16 consumed;
	struct cli_state *cli_ipc;
	pstring dfs_path, cleanpath, extrapath;
	int pathlen;
	fstring server, share;
	struct cli_state *newcli;
	pstring newpath;
	pstring newmount;
	char *ppath, *temppath = NULL;
	
	SMB_STRUCT_STAT sbuf;
	uint32 attributes;
	
	if ( !rootcli || !path || !targetcli ) {
		return False;
	}
		
	/* Don't do anything if this is not a DFS root. */

	if ( !rootcli->dfsroot) {
		*targetcli = rootcli;
		pstrcpy( targetpath, path );
		return True;
	}

	*targetcli = NULL;

	/* Send a trans2_query_path_info to check for a referral. */

	clean_path(path, cleanpath);
	cli_dfs_make_full_path(rootcli, cleanpath, dfs_path );

	if (cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes ) ) {
		/* This is an ordinary path, just return it. */
		*targetcli = rootcli;
		pstrcpy( targetpath, path );
		goto done;
	}

	/* Special case where client asked for a path that does not exist */

	if ( cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND) ) {
		*targetcli = rootcli;
		pstrcpy( targetpath, path );
		goto done;
	}

	/* We got an error, check for DFS referral. */

	if ( !cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED))  {
		return False;
	}

	/* Check for the referral. */

	if ( !(cli_ipc = cli_cm_open( rootcli->desthost, "IPC$", False )) ) {
		return False;
	}
	
	if ( !cli_dfs_get_referral(cli_ipc, dfs_path, &refs, &num_refs, &consumed) 
			|| !num_refs ) {
		return False;
	}
	
	/* Just store the first referral for now. */

	split_dfs_path( refs[0].dfspath, server, share, extrapath );
	SAFE_FREE(refs);

	/* Make sure to recreate the original string including any wildcards. */
	
	cli_dfs_make_full_path( rootcli, path, dfs_path);
	pathlen = strlen( dfs_path )*2;
	consumed = MIN(pathlen, consumed );
	pstrcpy( targetpath, &dfs_path[consumed/2] );
	dfs_path[consumed/2] = '\0';

	/*
 	 * targetpath is now the unconsumed part of the path.
 	 * dfs_path is now the consumed part of the path (in \server\share\path format).
 	 */

	/* Open the connection to the target server & share */
	
	if ( (*targetcli = cli_cm_open(server, share, False)) == NULL ) {
		d_printf("Unable to follow dfs referral [\\%s\\%s]\n",
			server, share );
		return False;
	}
	
	if (strlen(extrapath) > 0) {
		string_append(&temppath, extrapath);
		string_append(&temppath, targetpath);
		pstrcpy( targetpath, temppath );
	}
	
	/* parse out the consumed mount path */
	/* trim off the \server\share\ */

	ppath = dfs_path;

	if (*ppath != '\\') {
		d_printf("cli_resolve_path: dfs_path (%s) not in correct format.\n",
			dfs_path );
		return False;
	}

	ppath++; /* Now pointing at start of server name. */
	
	if ((ppath = strchr_m( dfs_path, '\\' )) == NULL) {
		return False;
	}

	ppath++; /* Now pointing at start of share name. */

	if ((ppath = strchr_m( ppath+1, '\\' )) == NULL) {
		return False;
	}

	ppath++; /* Now pointing at path component. */

	pstr_sprintf( newmount, "%s\\%s", mountpt, ppath );

	cli_cm_set_mntpoint( *targetcli, newmount );

	/* Check for another dfs referral, note that we are not 
	   checking for loops here. */

	if ( !strequal( targetpath, "\\" ) &&  !strequal( targetpath, "/")) {
		if ( cli_resolve_path( newmount, *targetcli, targetpath, &newcli, newpath ) ) {
			/*
			 * When cli_resolve_path returns true here it's always
 			 * returning the complete path in newpath, so we're done
 			 * here.
 			 */
			*targetcli = newcli;
			pstrcpy( targetpath, newpath );
			return True;
		}
	}

  done:

	/* If returning True ensure we return a dfs root full path. */
	if ( (*targetcli)->dfsroot ) {
		pstrcpy(dfs_path, targetpath );
		cli_dfs_make_full_path( *targetcli, dfs_path, targetpath); 
	}

	return True;
}
コード例 #14
0
ファイル: VN_1.0.cpp プロジェクト: rmxhaha/phantasia
	void _Log::clean_sound_path(){
		clean_path( sound_path );
	}
コード例 #15
0
ファイル: VN_1.0.cpp プロジェクト: rmxhaha/phantasia
	void _Log::clean_image_path(){
		clean_path( image_path );
	}
コード例 #16
0
ファイル: EasySFML.cpp プロジェクト: smagras/SFMLEasy
void EasySFML::config(){

        string typeCompiler;
        string compiler;
        string cmake;
        bool ok = true;

        // Type de compiler
        SetColor(DARKGREEN);

        cout << "# Enter the number in the list to define your compiler." << endl;
        cout << "# ex: 1" << endl;

        XMLNode xMainNode=XMLNode::openFileHelper("conf/compiler.xml","PMML");
        XMLNode xcompilers=xMainNode.getChildNode("compilers");
        int n=xcompilers.nChildNode("compiler");
        for (int i = 0; i < n;i++ ){
        XMLNode xcompiler =xcompilers.getChildNode("compiler",i);
        cout << i << " : " << xcompiler.getChildNode("name").getText() << endl;
        }

        SetColor(WHITE);
        cout << "Compiler >> " ;
        getline(cin, compiler);
        cout << endl;

        int i = atoi(compiler.c_str());
        if (!(i >= 0 && i < n) || compiler == ""){
            ok = false;
            SetColor(RED);
            cout << "ERROR: Impossible to choose compiler '" << compiler << "' ."<< endl << endl;
            SetColor(WHITE);
        }
        else{
            _compilertype = compiler;
        }

        // Compiler
        if(ok){
            XMLNode xcompiler =xcompilers.getChildNode("compiler",i);

            SetColor(DARKGREEN);
            cout << "# Enter your compiler path:" << endl;
            cout << "# ex: " << xcompiler.getChildNode("example").getText() << endl;
            SetColor(WHITE);
            cout << "Compiler path >> " ;
            getline(cin, compiler);
            cout << endl;



            string compExe = compiler+xcompiler.getChildNode("bin").getText();
            if (!fileExist(compExe)){
                ok = false;
                SetColor(RED);
                cout << "ERROR: Impossible to find '"<< compExe <<"' ." << endl << endl;
                SetColor(WHITE);
            }else{

                _compilerpath = compiler;
            }
        }

        _compilerpath = clean_path(_compilerpath);

        // Cmake
        if(ok){
            SetColor(DARKGREEN);
            cout << "# Enter your cmake path or ENTER for automatic download:" << endl;
            cout << "# ex: C:\\Cmake" << endl;
            SetColor(WHITE);
            cout << "Cmake path >> " ;
            getline(cin, cmake);
            cout << endl;

            if (cmake == ""){

                XMLNode confxml = XMLNode::openFileHelper("conf/cmake.xml","PMML");
                XMLNode xcmake = confxml.getChildNode("cmake");

                if (!fileExist(xcmake.getChildNode("zip").getText())){
                    cout << "Download: "<< xcmake.getChildNode("url").getText() << "..." << endl;
                    get_http_data(xcmake.getChildNode("url").getText(),xcmake.getChildNode("zip").getText());
                }

                if (!fileExist(xcmake.getChildNode("src").getText())){
                    cout << "Unzip: "<< xcmake.getChildNode("zip").getText() << "..." << endl;
                    extract_zip("download/cmake",xcmake.getChildNode("zip").getText());
                    cmake = xcmake.getChildNode("path").getText();
                }


                cmake = xcmake.getChildNode("path").getText();
                cmake = GetPath()+"\\"+cmake+"\\";
// C:/Users/STEVE/Desktop/Projet/C++/download/cmake/cmake-2.8.12.2-win32-x86/bin/cmake.exe

            }

            cmake = clean_path(cmake);

            string cmakeExe = cmake+"bin/cmake.exe";
            if (!fileExist(cmakeExe)){
                ok = false;
                SetColor(RED);
                cout << "ERROR: Impossible to find '"<< cmakeExe <<"' ." << endl << endl;
                SetColor(WHITE);
            }
            else{
                _cmakepath = cmake;

            }
        }

        // End
        if (ok){
            SetColor(DARKGREEN);
            save();
            cout << "Configuration is succesfully done." << endl;
            SetColor(WHITE);
        }


}
コード例 #17
0
ファイル: EasySFML.cpp プロジェクト: smagras/SFMLEasy
void EasySFML::install(){

    if (checkConfig()){

        SetColor(DARKGREEN);

        string version;
        bool ok=true;
        string finalpath;
        string command = "";

        // Final Path
        if(ok){

            SetColor(DARKGREEN);
            cout << "# Enter where you want to install sfml:" << endl;
            cout << "# ex: C:/" << endl;
            SetColor(WHITE);
            cout << "SFML path >> " ;
            getline(cin, finalpath);
            cout << endl;

            if (finalpath != ""){
                finalpath = clean_path(finalpath);
                if (!dirExist(finalpath)){
                    SetColor(RED);
                    cout << "ERROR: Impossible to find folder '" << finalpath << "' ."<< endl << endl;
                    SetColor(WHITE);
                    ok = false;
                }
            }
            else{
                SetColor(RED);
                cout << "ERROR: Impossible to find folder '" << finalpath << "' ."<< endl << endl;
                SetColor(WHITE);
                ok = false;
            }
        }

        if (ok){
            SetColor(DARKGREEN);
            cout << "# Enter the sfml version to install." << endl;
            cout << "# ex: 1" << endl;

            XMLNode xMainNode=XMLNode::openFileHelper("conf/version.xml","PMML");
            XMLNode xversions=xMainNode.getChildNode("versions");
            int n=xversions.nChildNode("version");
            for (int i = 0; i < n;i++ ){
                XMLNode xversion =xversions.getChildNode("version",i);
                cout << i << " : " << xversion.getChildNode("name").getText() << endl;
            }

            SetColor(WHITE);
            cout << "Version >> " ;
            getline(cin, version);
            cout << endl;

            int i = atoi(version.c_str());
            if (!(i >= 0 && i < n) || version == ""){
                ok = false;
                SetColor(RED);
                cout << "ERROR: Impossible to choose version '" << version << "' ."<< endl << endl;
                SetColor(WHITE);
            }
            else{
               // _compilertype = version;
               int i = atoi(version.c_str());
                XMLNode xversion =xversions.getChildNode("version",i);
                string sfmlPath = xversion.getChildNode("path").getText();
                if (!dirExist(sfmlPath)){
                    cout << "Create new dir: '"<< sfmlPath <<"'" << endl;
                    if (!dirExist("download/versions/")) mkdir("download/versions/");
                    mkdir(sfmlPath.c_str());

                }

                if (!fileExist(xversion.getChildNode("zip").getText())){
                    cout << "Download: "<< xversion.getChildNode("url").getText() << "..." << endl;
                    get_http_data(xversion.getChildNode("url").getText(),xversion.getChildNode("zip").getText());
                }



                cout << "Delete: "<< xversion.getChildNode("src").getText() << "..." << endl;
                command = xversion.getChildNode("src").getText();
                command = "rd /s /q \""+command+"\"";
                system( command.c_str() );
                cout << "Unzip: "<< xversion.getChildNode("zip").getText() << "..." << endl;
                extract_zip(xversion.getChildNode("path").getText(),xversion.getChildNode("zip").getText());

                // Compilation
                string mainpath = GetPath();
                string compiler = getCompiler();
                string src_sfml = xversion.getChildNode("src").getText();

                command = "";
                command += "cd " + src_sfml + " && ";
                command += "set PATH=\""+_compilerpath +"bin/\";%PATH%" + " && ";
                command += "set PATH=\""+_cmakepath +"bin/\";%PATH%" + " && ";
                command += "cmake -G \""+compiler+"\" -D CMAKE_BUILD_TYPE=Release -D BUILD_SHARED_LIBS=TRUE \"" + mainpath+"/"+src_sfml + "\" && ";
                command += "mingw32-make &&";
                command += "cmake -G \""+compiler+"\" -D CMAKE_BUILD_TYPE=Debug -D BUILD_SHARED_LIBS=TRUE \"" + mainpath+"/"+src_sfml + "\" && ";
                command += "mingw32-make && ";
                command += "cmake -G \""+compiler+"\" -D CMAKE_BUILD_TYPE=Release -D BUILD_SHARED_LIBS=FALSE \"" + mainpath+"/"+src_sfml + "\" && ";
                command += "mingw32-make && ";
                command += "cmake -G \""+compiler+"\" -D CMAKE_BUILD_TYPE=Debug -D BUILD_SHARED_LIBS=FALSE \"" + mainpath+"/"+src_sfml + "\" && ";
                command += "mingw32-make";
                //cout << command << endl;
                int resCMD = system(command.c_str());

                if (resCMD == 0 && errno == 0)
                {
                    cout << "Finalize installation..." << endl;
                    command = xversion.getChildNode("name").getText();
                    command = "xcopy  \""+ mainpath+"/"+src_sfml +"\" \""+finalpath+"/"+command+"\" /s /e /y /i";
                    cout << command << endl;
                    system(command.c_str());

                    cout << endl << "Installation complete." << endl;
                }
                else{
                    SetColor(RED);
                    cout << "ERROR: Impossible to cmake or compile." << endl;
                    SetColor(WHITE);
                }



            }
        }

    }



}
コード例 #18
0
ファイル: clidfs.c プロジェクト: hajuuk/R7000
BOOL cli_resolve_path( const char *mountpt, struct cli_state *rootcli, const char *path,
                       struct cli_state **targetcli, pstring targetpath )
{
	CLIENT_DFS_REFERRAL *refs = NULL;
	size_t num_refs;
	uint16 consumed;
	struct cli_state *cli_ipc;
	pstring fullpath, cleanpath;
	int pathlen;
	fstring server, share;
	struct cli_state *newcli;
	pstring newpath;
	pstring newmount;
	char *ppath;
	
	SMB_STRUCT_STAT sbuf;
	uint32 attributes;
	
	*targetcli = NULL;
	
	if ( !rootcli || !path || !targetcli )
		return False;
		
	/* send a trans2_query_path_info to check for a referral */
	
	clean_path( cleanpath, 	path );
	make_full_path( fullpath, rootcli->desthost, rootcli->share, cleanpath );

	/* don't bother continuing if this is not a dfs root */
	
	if ( !rootcli->dfsroot || cli_qpathinfo_basic( rootcli, cleanpath, &sbuf, &attributes ) ) {
		*targetcli = rootcli;
		pstrcpy( targetpath, path );
		return True;
	}

	/* we got an error, check for DFS referral */
			
	if ( !cli_dfs_check_error(rootcli) ) 
		return False;

	/* check for the referral */

	if ( !(cli_ipc = cli_cm_open( rootcli->desthost, "IPC$", False )) )
		return False;
	
	if ( !cli_dfs_get_referral(cli_ipc, fullpath, &refs, &num_refs, &consumed) 
		|| !num_refs )
	{
		return False;
	}
	
	/* just store the first referral for now
	   Make sure to recreate the original string including any wildcards */
	
	make_full_path( fullpath, rootcli->desthost, rootcli->share, path );
	pathlen = strlen( fullpath )*2;
	consumed = MIN(pathlen, consumed );
	pstrcpy( targetpath, &fullpath[consumed/2] );

	split_dfs_path( refs[0].dfspath, server, share );
	SAFE_FREE( refs );
	
	/* open the connection to the target path */
	
	if ( (*targetcli = cli_cm_open(server, share, False)) == NULL ) {
		d_printf("Unable to follow dfs referral [//%s/%s]\n",
			server, share );
			
		return False;
	}
	
	/* parse out the consumed mount path */
	/* trim off the \server\share\ */

	fullpath[consumed/2] = '\0';
	dos_clean_name( fullpath );
	ppath = strchr_m( fullpath, '\\' );
	ppath = strchr_m( ppath+1, '\\' );
	ppath = strchr_m( ppath+1, '\\' );
	ppath++;
	
	pstr_sprintf( newmount, "%s\\%s", mountpt, ppath );
	cli_cm_set_mntpoint( *targetcli, newmount );

	/* check for another dfs referral, note that we are not 
	   checking for loops here */

	if ( !strequal( targetpath, "\\" ) ) {
		if ( cli_resolve_path( newmount, *targetcli, targetpath, &newcli, newpath ) ) {
			*targetcli = newcli;
			pstrcpy( targetpath, newpath );
		}
	}

	return True;
}
コード例 #19
0
ファイル: fe_build.cpp プロジェクト: omegaman1/attract
void FeSettings::apply_xml_import( FeImporterContext &c )
{
	std::string source = c.emulator.get_info(
				FeEmulatorInfo::Info_source );

	if ( source.empty() )
		return;

	std::string base_command = clean_path( c.emulator.get_info(
				FeEmulatorInfo::Executable ) );

	if ( source.compare( "mame" ) == 0 )
	{
		std::cout << " - Obtaining -listxml info...";
		FeMameXMLParser mamep( c );
		if ( !mamep.parse( base_command ) )
			std::cout << "No XML output found, command: " << base_command << " -listxml" << std::endl;
	}
	else if ( source.compare( "mess" ) == 0 )
	{
		const std::vector < std::string > &system_names = c.emulator.get_systems();
		if ( system_names.empty() )
		{
			std::cout << "Note: No system configured for emulator: "
				<< c.emulator.get_info( FeEmulatorInfo::Name )
				<< ", unable to obtain -listsoftware info."
				<< std::endl;
			return;
		}

		FeMessXMLParser messp( c );
		messp.parse( base_command, system_names );
	}
	else if ( source.compare( "steam" ) == 0 )
	{
		const std::vector<std::string> &paths = c.emulator.get_paths();
		const std::vector<std::string> &exts = c.emulator.get_extensions();
		if ( paths.empty() || exts.empty() )
			return;

		std::string path = clean_path( paths.front(), true );
		const std::string &extension = exts.front();

		// A bit mislabelled: the steam import isn't really xml.
		for ( FeRomInfoListType::iterator itr = c.romlist.begin(); itr != c.romlist.end(); ++itr )
		{
			// We expect appmanifest_* entries in the romname field.  Open each of these files and
			// extract the data we can use in our list
			const std::string &n = (*itr).get_info( FeRomInfo::Romname );
			std::string fname = path + n + extension;

			//
			// First, Fix the Romname entry in case we don't find it in the manifest
			//
			size_t start_pos = n.find_last_of( "_" );
			if ( start_pos != std::string::npos )
				(*itr).set_info( FeRomInfo::Romname,
						n.substr( start_pos + 1 ) );

			std::ifstream myfile( fname.c_str() );

			int fields_left( 3 );

			if ( myfile.is_open() )
			{
				while ( myfile.good() && ( fields_left > 0 ) )
				{
					std::string line, val;
					size_t pos( 0 );

					getline( myfile, line );

					token_helper( line, pos, val, FE_WHITESPACE );

					if ( icompare( val, "appid" ) == 0 )
					{
						std::string id;
						token_helper( line, pos, id, FE_WHITESPACE );
						(*itr).set_info( FeRomInfo::Romname, id );
						fields_left--;
					}
					else if ( icompare( val, "name" ) == 0 )
					{
						std::string name;
						token_helper( line, pos, name, FE_WHITESPACE );
						(*itr).set_info( FeRomInfo::Title, name );
						fields_left--;
					}
					else if ( icompare( val, "installdir" ) == 0 )
					{
						std::string altname;
						token_helper( line, pos, altname, FE_WHITESPACE );
						(*itr).set_info( FeRomInfo::AltRomname, altname );
						fields_left--;
					}
				}

				ASSERT( !fields_left );
			}
			else
				std::cerr << "Error opening file: " << fname << std::endl;
		}
	}
	else if ( source.compare( "thegamesdb.net" ) == 0 )
		thegamesdb_scraper( c );
	else
	{
		std::cout << "Unrecognized import_source setting: " << source
					<< std::endl;
	}
}
コード例 #20
0
ファイル: lustre_cfg.c プロジェクト: KnightKu/lustre-stable
/**
 * Perform a read, write or just a listing of a parameter
 *
 * \param[in] popt		list,set,get parameter options
 * \param[in] pattern		search filter for the path of the parameter
 * \param[in] value		value to set the parameter if write operation
 * \param[in] mode		what operation to perform with the parameter
 *
 * \retval number of bytes written on success.
 * \retval -errno on error and prints error message.
 */
static int
param_display(struct param_opts *popt, char *pattern, char *value,
	      enum parameter_operation mode)
{
	int dir_count = 0;
	char **dir_cache;
	glob_t paths;
	char *opname = parameter_opname[mode];
	int rc, i;

	rc = cfs_get_param_paths(&paths, "%s", pattern);
	if (rc != 0) {
		rc = -errno;
		if (!popt->po_recursive) {
			fprintf(stderr, "error: %s: param_path '%s': %s\n",
				opname, pattern, strerror(errno));
		}
		return rc;
	}

	dir_cache = calloc(paths.gl_pathc, sizeof(char *));
	if (dir_cache == NULL) {
		rc = -ENOMEM;
		fprintf(stderr,
			"error: %s: allocating '%s' dir_cache[%zd]: %s\n",
			opname, pattern, paths.gl_pathc, strerror(-rc));
		goto out_param;
	}

	for (i = 0; i < paths.gl_pathc; i++) {
		char *param_name = NULL, *tmp;
		char pathname[PATH_MAX];
		struct stat st;
		int rc2;

		if (stat(paths.gl_pathv[i], &st) == -1) {
			fprintf(stderr, "error: %s: stat '%s': %s\n",
				opname, paths.gl_pathv[i], strerror(errno));
			if (rc == 0)
				rc = -errno;
			continue;
		}

		if (popt->po_only_dir && !S_ISDIR(st.st_mode))
			continue;

		param_name = display_name(paths.gl_pathv[i], &st, popt);
		if (param_name == NULL) {
			fprintf(stderr,
				"error: %s: generating name for '%s': %s\n",
				opname, paths.gl_pathv[i], strerror(ENOMEM));
			if (rc == 0)
				rc = -ENOMEM;
			continue;
		}

		/**
		 * For the upstream client the parameter files locations
		 * are split between under both /sys/kernel/debug/lustre
		 * and /sys/fs/lustre. The parameter files containing
		 * small amounts of data, less than a page in size, are
		 * located under /sys/fs/lustre and in the case of large
		 * parameter data files, think stats for example, are
		 * located in the debugfs tree. Since the files are split
		 * across two trees the directories are often duplicated
		 * which means these directories are listed twice which
		 * leads to duplicate output to the user. To avoid scanning
		 * a directory twice we have to cache any directory and
		 * check if a search has been requested twice.
		 */
		if (S_ISDIR(st.st_mode)) {
			int j;

			for (j = 0; j < dir_count; j++) {
				if (!strcmp(dir_cache[j], param_name))
					break;
			}
			if (j != dir_count) {
				free(param_name);
				param_name = NULL;
				continue;
			}
			dir_cache[dir_count++] = strdup(param_name);
		}

		switch (mode) {
		case GET_PARAM:
			/* Read the contents of file to stdout */
			if (S_ISREG(st.st_mode))
				read_param(paths.gl_pathv[i], param_name, popt);
			break;
		case SET_PARAM:
			if (S_ISREG(st.st_mode)) {
				rc2 = write_param(paths.gl_pathv[i],
						  param_name, popt, value);
				if (rc2 < 0 && rc == 0)
					rc = rc2;
			}
			break;
		case LIST_PARAM:
			if (popt->po_show_path)
				printf("%s\n", param_name);
			break;
		}

		/* Only directories are searched recursively if
		 * requested by the user */
		if (!S_ISDIR(st.st_mode) || !popt->po_recursive) {
			free(param_name);
			param_name = NULL;
			continue;
		}

		/* Turn param_name into file path format */
		rc2 = clean_path(popt, param_name);
		if (rc2 < 0) {
			fprintf(stderr, "error: %s: cleaning '%s': %s\n",
				opname, param_name, strerror(-rc2));
			free(param_name);
			param_name = NULL;
			if (rc == 0)
				rc = rc2;
			continue;
		}

		/* Use param_name to grab subdirectory tree from full path */
		tmp = strstr(paths.gl_pathv[i], param_name);

		/* cleanup paramname now that we are done with it */
		free(param_name);
		param_name = NULL;

		/* Shouldn't happen but just in case */
		if (tmp == NULL) {
			if (rc == 0)
				rc = -EINVAL;
			continue;
		}

		rc2 = snprintf(pathname, sizeof(pathname), "%s/*", tmp);
		if (rc2 < 0) {
			/* snprintf() should never an error, and if it does
			 * there isn't much point trying to use fprintf() */
			continue;
		}
		if (rc2 >= sizeof(pathname)) {
			fprintf(stderr, "error: %s: overflow processing '%s'\n",
				opname, pathname);
			if (rc == 0)
				rc = -EINVAL;
			continue;
		}

		rc2 = param_display(popt, pathname, value, mode);
		if (rc2 != 0 && rc2 != -ENOENT) {
			/* errors will be printed by param_display() */
			if (rc == 0)
				rc = rc2;
			continue;
		}
	}

	for (i = 0; i < dir_count; i++)
		free(dir_cache[i]);
	free(dir_cache);
out_param:
	cfs_free_param_data(&paths);
	return rc;
}
コード例 #21
0
ファイル: filewatch_win32.c プロジェクト: jtsiomb/libresman
int resman_start_watch(struct resman *rman, struct resource *res)
{
    char *path = 0, *last_slash;
    struct watch_dir *wdir = 0;
    struct watch_item *witem = 0;

    /* construct an absolute path for the directory containing this file (must free it afterwards) */
    if(!(path = abs_path(res->name))) {
        return -1;
    }
    clean_path(path);

    /* we need the directory path, so let's find the last slash and cut it there */
    if(!(last_slash = strrchr(path, '\\'))) {
        goto err;
    }
    *last_slash = 0;

    /* check to see if we already have a watch handle for this directory */
    if((wdir = rb_find(rman->watchdirs, path))) {
        wdir->nref++;	/* ... if so, increase the refcount */
    } else {
        /* otherwise start a new watch */
        if(!(wdir = malloc(sizeof *wdir))) {
            perror("failed to allocate watchdir");
            goto err;
        }
        memset(wdir, 0, sizeof *wdir);
        wdir->nref = 1;

        /* open the directory we need to watch */
        wdir->handle = CreateFile(path, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                                  0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, 0);
        if(wdir->handle == INVALID_HANDLE_VALUE) {
            fprintf(stderr, "failed to watch %s: failed to open directory: %s\n", res->name, path);
            goto err;
        }

        if(!(wdir->buf_unaligned = malloc(RES_BUF_SIZE + 3))) {
            fprintf(stderr, "failed to allocate watch result buffer (%d bytes)\n", RES_BUF_SIZE);
            goto err;
        }
        wdir->buf = (char*)(((intptr_t)wdir->buf_unaligned + 3) & ~(intptr_t)0x3);

        memset(&wdir->over, 0, sizeof wdir->over);
        wdir->over.hEvent = CreateEvent(0, TRUE, FALSE, 0);

        if(!ReadDirectoryChangesW(wdir->handle, wdir->buf, RES_BUF_SIZE, 0, FILE_NOTIFY_CHANGE_LAST_WRITE, 0, &wdir->over, 0)) {
            fprintf(stderr, "failed to start async dirchange monitoring\n");
            goto err;
        }

        wdir->watch_path = path;

        rb_insert(rman->watchdirs, path, wdir);
        rb_insert(rman->wdirbyev, wdir->over.hEvent, wdir);
        rman->watch_handles = dynarr_push(rman->watch_handles, &wdir->over.hEvent);
    }

    /* add a new watch item to this watch dir */
    if(!(witem = malloc(sizeof *witem))) {
        perror("failed to allocate watch item");
        goto err;
    }
    witem->next = wdir->items;
    wdir->items = witem;
    witem->res = res;

    res->watch_path = path;
    return 0;
err:
    free(path);
    if(wdir) {
        if(wdir->handle && wdir->handle != INVALID_HANDLE_VALUE) {
            CloseHandle(wdir->handle);
        }
        free(wdir->buf_unaligned);
        if(wdir->over.hEvent && wdir->over.hEvent != INVALID_HANDLE_VALUE) {
            CloseHandle(wdir->over.hEvent);
        }
    }
    return -1;
}
コード例 #22
0
ファイル: lustre_cfg.c プロジェクト: KnightKu/lustre-stable
int jt_lcfg_setparam(int argc, char **argv)
{
	int rc = 0, index, i;
	struct param_opts popt;
	char *path = NULL, *value = NULL;

	memset(&popt, 0, sizeof(popt));
	index = setparam_cmdline(argc, argv, &popt);
	if (index < 0 || index >= argc)
		return CMD_HELP;

	if (popt.po_params2)
		/* We can't delete parameters that were
		 * set with old conf_param interface */
		return jt_lcfg_mgsparam2(argc, argv, &popt);

	for (i = index; i < argc; i++) {
		int rc2;
		path = NULL;

		value = strchr(argv[i], '=');
		if (value != NULL) {
			/* format: set_param a=b */
			*value = '\0';
			value++;
			path = argv[i];
			if (*value == '\0') {
				fprintf(stderr,
					"error: %s: setting %s: no value\n",
					jt_cmdname(argv[0]), path);
				if (rc == 0)
					rc = -EINVAL;
				continue;
			}
		} else {
			/* format: set_param a b */
			path = argv[i];
			i++;
			if (i >= argc) {
				fprintf(stderr,
					"error: %s: setting %s: no value\n",
					jt_cmdname(argv[0]), path);
				if (rc == 0)
					rc = -EINVAL;
				break;
			} else {
				value = argv[i];
			}
		}

		rc2 = clean_path(&popt, path);
		if (rc2 < 0) {
			fprintf(stderr, "error: %s: cleaning %s: %s\n",
				jt_cmdname(argv[0]), path, strerror(-rc2));
			if (rc == 0)
				rc = rc2;
			continue;
		}

		/* A value containing '=' is indicative of user error, e.g.:
		 *     lctl set_param param1 param2=value2
		 *     lctl set_param param1=param2=value2
		 */
		if (strchr(value, '=') != NULL)
			fprintf(stderr,
				"warning: %s: value '%s' contains '='\n",
				jt_cmdname(argv[0]), value);

		rc2 = param_display(&popt, path, value, SET_PARAM);
		if (rc == 0)
			rc = rc2;
	}

	return rc;
}
コード例 #23
0
ファイル: clidfs.c プロジェクト: ekohl/samba
NTSTATUS cli_resolve_path(TALLOC_CTX *ctx,
			  const char *mountpt,
			  const struct user_auth_info *dfs_auth_info,
			  struct cli_state *rootcli,
			  const char *path,
			  struct cli_state **targetcli,
			  char **pp_targetpath)
{
	struct client_dfs_referral *refs = NULL;
	size_t num_refs = 0;
	size_t consumed = 0;
	struct cli_state *cli_ipc = NULL;
	char *dfs_path = NULL;
	char *cleanpath = NULL;
	char *extrapath = NULL;
	int pathlen;
	char *server = NULL;
	char *share = NULL;
	struct cli_state *newcli = NULL;
	char *newpath = NULL;
	char *newmount = NULL;
	char *ppath = NULL;
	SMB_STRUCT_STAT sbuf;
	uint32 attributes;
	NTSTATUS status;

	if ( !rootcli || !path || !targetcli ) {
		return NT_STATUS_INVALID_PARAMETER;
	}

	/* Don't do anything if this is not a DFS root. */

	if ( !rootcli->dfsroot) {
		*targetcli = rootcli;
		*pp_targetpath = talloc_strdup(ctx, path);
		if (!*pp_targetpath) {
			return NT_STATUS_NO_MEMORY;
		}
		return NT_STATUS_OK;
	}

	*targetcli = NULL;

	/* Send a trans2_query_path_info to check for a referral. */

	cleanpath = clean_path(ctx, path);
	if (!cleanpath) {
		return NT_STATUS_NO_MEMORY;
	}

	dfs_path = cli_dfs_make_full_path(ctx, rootcli, cleanpath);
	if (!dfs_path) {
		return NT_STATUS_NO_MEMORY;
	}

	status = cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes);
	if (NT_STATUS_IS_OK(status)) {
		/* This is an ordinary path, just return it. */
		*targetcli = rootcli;
		*pp_targetpath = talloc_strdup(ctx, path);
		if (!*pp_targetpath) {
			return NT_STATUS_NO_MEMORY;
		}
		goto done;
	}

	/* Special case where client asked for a path that does not exist */

	if (cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND,
				status)) {
		*targetcli = rootcli;
		*pp_targetpath = talloc_strdup(ctx, path);
		if (!*pp_targetpath) {
			return NT_STATUS_NO_MEMORY;
		}
		goto done;
	}

	/* We got an error, check for DFS referral. */

	if (!cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED,
				 status)) {
		return status;
	}

	/* Check for the referral. */

	status = cli_cm_open(ctx,
			     rootcli,
			     cli_state_remote_name(rootcli),
			     "IPC$",
			     dfs_auth_info,
			     false,
			     cli_state_encryption_on(rootcli),
			     cli_state_protocol(rootcli),
			     0,
			     0x20,
			     &cli_ipc);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	status = cli_dfs_get_referral(ctx, cli_ipc, dfs_path, &refs,
				      &num_refs, &consumed);
	if (!NT_STATUS_IS_OK(status) || !num_refs) {
		return status;
	}

	/* Just store the first referral for now. */

	if (!refs[0].dfspath) {
		return NT_STATUS_NOT_FOUND;
	}
	if (!split_dfs_path(ctx, refs[0].dfspath, &server, &share,
			    &extrapath)) {
		return NT_STATUS_NOT_FOUND;
	}

	/* Make sure to recreate the original string including any wildcards. */

	dfs_path = cli_dfs_make_full_path(ctx, rootcli, path);
	if (!dfs_path) {
		return NT_STATUS_NO_MEMORY;
	}
	pathlen = strlen(dfs_path);
	consumed = MIN(pathlen, consumed);
	*pp_targetpath = talloc_strdup(ctx, &dfs_path[consumed]);
	if (!*pp_targetpath) {
		return NT_STATUS_NO_MEMORY;
	}
	dfs_path[consumed] = '\0';

	/*
 	 * *pp_targetpath is now the unconsumed part of the path.
 	 * dfs_path is now the consumed part of the path
	 * (in \server\share\path format).
 	 */

	/* Open the connection to the target server & share */
	status = cli_cm_open(ctx, rootcli,
			     server,
			     share,
			     dfs_auth_info,
			     false,
			     cli_state_encryption_on(rootcli),
			     cli_state_protocol(rootcli),
			     0,
			     0x20,
			     targetcli);
	if (!NT_STATUS_IS_OK(status)) {
		d_printf("Unable to follow dfs referral [\\%s\\%s]\n",
			server, share );
		return status;
	}

	if (extrapath && strlen(extrapath) > 0) {
		/* EMC Celerra NAS version 5.6.50 (at least) doesn't appear to */
		/* put the trailing \ on the path, so to be save we put one in if needed */
		if (extrapath[strlen(extrapath)-1] != '\\' && **pp_targetpath != '\\') {
			*pp_targetpath = talloc_asprintf(ctx,
						  "%s\\%s",
						  extrapath,
						  *pp_targetpath);
		} else {
			*pp_targetpath = talloc_asprintf(ctx,
						  "%s%s",
						  extrapath,
						  *pp_targetpath);
		}
		if (!*pp_targetpath) {
			return NT_STATUS_NO_MEMORY;
		}
	}

	/* parse out the consumed mount path */
	/* trim off the \server\share\ */

	ppath = dfs_path;

	if (*ppath != '\\') {
		d_printf("cli_resolve_path: "
			"dfs_path (%s) not in correct format.\n",
			dfs_path );
		return NT_STATUS_NOT_FOUND;
	}

	ppath++; /* Now pointing at start of server name. */

	if ((ppath = strchr_m( dfs_path, '\\' )) == NULL) {
		return NT_STATUS_NOT_FOUND;
	}

	ppath++; /* Now pointing at start of share name. */

	if ((ppath = strchr_m( ppath+1, '\\' )) == NULL) {
		return NT_STATUS_NOT_FOUND;
	}

	ppath++; /* Now pointing at path component. */

	newmount = talloc_asprintf(ctx, "%s\\%s", mountpt, ppath );
	if (!newmount) {
		return NT_STATUS_NOT_FOUND;
	}

	cli_set_mntpoint(*targetcli, newmount);

	/* Check for another dfs referral, note that we are not
	   checking for loops here. */

	if (!strequal(*pp_targetpath, "\\") && !strequal(*pp_targetpath, "/")) {
		status = cli_resolve_path(ctx,
					  newmount,
					  dfs_auth_info,
					  *targetcli,
					  *pp_targetpath,
					  &newcli,
					  &newpath);
		if (NT_STATUS_IS_OK(status)) {
			/*
			 * When cli_resolve_path returns true here it's always
 			 * returning the complete path in newpath, so we're done
 			 * here.
 			 */
			*targetcli = newcli;
			*pp_targetpath = newpath;
			return status;
		}
	}

  done:

	/* If returning true ensure we return a dfs root full path. */
	if ((*targetcli)->dfsroot) {
		dfs_path = talloc_strdup(ctx, *pp_targetpath);
		if (!dfs_path) {
			return NT_STATUS_NO_MEMORY;
		}
		*pp_targetpath = cli_dfs_make_full_path(ctx, *targetcli, dfs_path);
		if (*pp_targetpath == NULL) {
			return NT_STATUS_NO_MEMORY;
		}
	}

	return NT_STATUS_OK;
}
コード例 #24
0
ファイル: path.cpp プロジェクト: darkphase/LXiMedia
static const std::unordered_set<std::wstring> & hidden_dirs()
{
    static std::unordered_set<std::wstring> hidden_dirs;
    static std::once_flag flag;
    std::call_once(flag, []
    {
        const wchar_t *dir = _wgetenv(L"SystemDrive");
        if (dir == nullptr) dir = L"c:";
        hidden_dirs.insert(to_lower(clean_path(dir) + L"\\program files"));
        hidden_dirs.insert(to_lower(clean_path(dir) + L"\\program files (x86)"));
        hidden_dirs.insert(to_lower(clean_path(dir) + L"\\windows"));
        hidden_dirs.insert(to_lower(clean_path(dir) + L"\\temp"));
        hidden_dirs.insert(to_lower(clean_path(dir) + L"\\recycler"));

        dir = _wgetenv(L"ProgramFiles");
        if (dir) hidden_dirs.insert(to_lower(clean_path(dir)));
        dir = _wgetenv(L"ProgramFiles(x86)");
        if (dir) hidden_dirs.insert(to_lower(clean_path(dir)));
        dir = _wgetenv(L"SystemRoot");
        if (dir) hidden_dirs.insert(to_lower(clean_path(dir)));
        dir = _wgetenv(L"TEMP");
        if (dir) hidden_dirs.insert(to_lower(clean_path(dir)));
        dir = _wgetenv(L"TMP");
        if (dir) hidden_dirs.insert(to_lower(clean_path(dir)));
        dir = _wgetenv(L"windir");
        if (dir) hidden_dirs.insert(to_lower(clean_path(dir)));

        wchar_t temp_path[MAX_PATH];
        if (GetTempPath(sizeof(temp_path) / sizeof(*temp_path), temp_path) > 0)
            hidden_dirs.insert(to_lower(clean_path(temp_path)));
    });

    return hidden_dirs;
}
コード例 #25
0
ファイル: fe_config.cpp プロジェクト: Cucurbitace/attract
bool FeEmulatorEditMenu::on_option_select(
		FeConfigContext &ctx, FeBaseConfigMenu *& submenu )
{
	FeMenuOpt &o = ctx.curr_opt();

	if ( !m_emulator )
		return true;

	switch ( o.opaque )
	{
	case 1: //	 Edit artwork
		m_art_menu.set_art( m_emulator, o.setting );
		submenu = &m_art_menu;
		break;

	case 2: //	 Add new artwork
		m_art_menu.set_art( m_emulator, "" );
		submenu = &m_art_menu;
		break;

	case 3: // Generate Romlist
		{
			// Make sure m_emulator is set with all the configured info
			//
			for ( int i=0; i < FeEmulatorInfo::LAST_INDEX; i++ )
				m_emulator->set_info( (FeEmulatorInfo::Index)i,
					ctx.opt_list[i].get_value() );

			// Do some checks and confirmation before launching the Generator
			//
			std::vector<std::string> paths = m_emulator->get_paths();

			for ( std::vector<std::string>::const_iterator itr = paths.begin();
					itr != paths.end(); ++itr )
			{
				std::string rom_path = clean_path( *itr );
				if ( !directory_exists( rom_path ) )
				{
					if ( ctx.confirm_dialog( "Rom path '$1' not found, proceed anyways?",
										rom_path ) == false )
						return false;
					else
						break; // only bug the user once if there are multiple paths configured
				}
			}

			std::string emu_name = m_emulator->get_info( FeEmulatorInfo::Name );

			if ( m_romlist_exists )
			{
				if ( ctx.confirm_dialog( "Overwrite existing '$1' list?",
									emu_name ) == false )
					return false;
			}

			FePresent *fep = FePresent::script_get_fep();
			if ( fep )
				fep->set_video_play_state( false );

			ctx.fe_settings.build_romlist( emu_name, gen_ui_update, &ctx,
								ctx.help_msg );

			if ( fep )
				fep->set_video_play_state(
					fep->get_video_toggle() );

			//
			// If we don't have a display configured for this romlist,
			// configure one now
			//
			if ( !ctx.fe_settings.check_romlist_configured( emu_name ) )
			{
				FeDisplayInfo *new_disp = ctx.fe_settings.create_display( emu_name );
				new_disp->set_info( FeDisplayInfo::Romlist, emu_name );
			}

			ctx.save_req = true;
			m_parent_save = true;
		}
		break;
	case 4: // Scrape Artwork
		{
			FePresent *fep = FePresent::script_get_fep();
			if ( fep )
				fep->set_video_play_state( false );

			std::string emu_name = m_emulator->get_info( FeEmulatorInfo::Name );
			ctx.fe_settings.scrape_artwork( emu_name, scrape_ui_update, &ctx, ctx.help_msg );

			if ( fep )
				fep->set_video_play_state(
					fep->get_video_toggle() );
		}
		break;
	case 5: // Delete this Emulator
		{
			std::string name = m_emulator->get_info(FeEmulatorInfo::Name);

			if ( ctx.confirm_dialog( "Delete emulator '$1'?", name ) == false )
				return false;

			ctx.fe_settings.delete_emulator(
					m_emulator->get_info(FeEmulatorInfo::Name) );
		}
		break;

	case 100: // Hotkey input
		{
			std::string res;
			FeInputMap::Command conflict( FeInputMap::LAST_COMMAND );
			ctx.input_map_dialog( "Press Exit Hotkey", res, conflict );

			bool save=false;
			if ( o.get_value().compare( res ) != 0 )
				save = true;
			else
			{
				if ( ctx.confirm_dialog( "Clear Exit Hotkey?", res ))
				{
					res.clear();
					save = true;
				}
			}

			if ( save )
			{
				o.set_value( res );
				ctx.save_req = true;
			}
		}
		break;

	default:
		break;
	}

	return true;
}
コード例 #26
0
ファイル: fe_present.cpp プロジェクト: philenotfound/attract
FeShader *FePresent::add_shader( FeShader::Type type, const char *shader1, const char *shader2 )
{
    std::string path;
    m_feSettings->get_path( FeSettings::Current, path );

    std::string s1 = clean_path( shader1 );

    m_scriptShaders.push_back( new FeShader() );
    FeShader *sh = m_scriptShaders.back();

    if ( !is_relative_path( s1 ) )
        path.clear();

    switch ( type )
    {
    case FeShader::VertexAndFragment:
        if ( is_supported_archive( path ) )
        {
            //
            // Known Issue: We don't properly handle the
            // situation where one shader is specified as a
            // relative path and is in a zip, while the other
            // is specified as an absolute path.  If the first
            // is in a zip, the second is assumed to be in the
            // same zip as well.
            //
            FeZipStream zs1( path );
            zs1.open( shader1 );

            FeZipStream zs2( path );
            zs2.open( shader2 );

            sh->load( zs1, zs2 );
        }
        else
        {
            std::string path2 = path;
            std::string s2 = clean_path( shader2 );
            if ( !is_relative_path( s2 ) )
                path2.clear();

            sh->load( path + s1, path2 + s2 );
        }
        break;

    case FeShader::Vertex:
    case FeShader::Fragment:
        if ( is_supported_archive( path ) )
        {
            FeZipStream zs( path );
            zs.open( shader1 );

            sh->load( zs, type );
        }
        else
        {
            sh->load( path + s1, type );
        }
        break;

    case FeShader::Empty:
    default:
        break;
    }

    return sh;
}
コード例 #27
0
void AppDelegate::preload_sounds()
{

#ifdef _WIN32
    CCLOG("on windows, skipping audio preload");
#else
    CocosDenshion::SimpleAudioEngine* cache = CocosDenshion::SimpleAudioEngine::getInstance();
    CCLOG("start loading audio");
    cache->preloadEffect(clean_path("sounds\\old\\Swoosh.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\barrel.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\beep.mp3").c_str());
    // cache->preloadEffect(clean_path("sounds\\old\\block.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\brick_hit.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\brick_scrape.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\cheering.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\coin.mp3").c_str());
    //cache->preloadEffect(clean_path("sounds\\old\\ding.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\doom_rocket.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\dsnoway.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\glassbreak.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\ice_freeze.mp3").c_str());
    //cache->preloadEffect(clean_path("sounds\\old\\lighter.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\radio_wave.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\real_punch.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\shield_die.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\shield_disable.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\shield_hit.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\shotgun.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\shotgun_reload.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\suicide_bomber.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\wall_destroy.mp3").c_str());

    cache->preloadEffect(clean_path("sounds\\new\\barrel\\C_barrel_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\block\\C_block+1.mp3").c_str());
    // cache->preloadEffect(clean_path("sounds\\new\\block\\C_block+2.mp3").c_str());
    // cache->preloadEffect(clean_path("sounds\\new\\block\\C_block_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\charged\\C_charged_1.mp3").c_str());
    //cache->preloadEffect(clean_path("sounds\\new\\cheering\\C_cheering_11.mp3").c_str()); //TODO Find a use for this
    //cache->preloadEffect(clean_path("sounds\\new\\cheering\\C_cheering_12.mp3").c_str()); //TODO Find a use for this
    cache->preloadEffect(clean_path("sounds\\new\\cheering\\C_cheering_13.mp3").c_str());
    //cache->preloadEffect(clean_path("sounds\\new\\coin\\C_coin_1.mp3").c_str());
    //cache->preloadEffect(clean_path("sounds\\new\\coin\\C_coin_2.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\doom_rocket\\C_grenade_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\doom_rocket\\C_rocket_big_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\doom_rocket\\C_rocket_small_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Grunt_11.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Grunt_12.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Grunt_13.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Grunt_14.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Grunt_15.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Grunt_16.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Grunt_17.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Grunt_18.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Hit_11.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Hit_12.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Hit_13.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Hit_14.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Hit_15.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Hit_16.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Hit_17.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\dsnoway\\C_Hit_18.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\extra\\C_explosion_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\glassbreak\\C_glassbreak_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\ice_freeze\\C_ice_freeze+.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\ice_freeze\\C_ice_freeze_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\lighter\\C_lighter_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\radio_wave\\C_radio_wave_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\radio_wave\\C_radio_wave_2.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\radio_wave\\C_radio_wave_3.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_combo_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch+1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch+2.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch+3.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_11.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_21.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_22.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_23.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_24.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_25.mp3").c_str());
    // cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_26.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_27.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_28.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\real_punch\\C_punch_31.mp3").c_str());

    cache->preloadEffect(clean_path("sounds\\new\\shotgun\\C_shotgun_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\shotgun_reload\\C_shotgun_reload_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\suicide_bomber\\C_rocket_big+1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\suicide_bomber\\C_rocket_small+2.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_1.wav").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_11.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_12.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_13.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_14.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_15.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_21.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_22.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_23.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_24.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_25.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_26.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\Swoosh\\C_Swoosh_27.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\new\\woop\\C_woop_1.mp3").c_str());
    cache->preloadEffect(clean_path("sounds\\old\\woop.mp3").c_str());
    CCLOG("done loading audio");
#endif

};