//++ ------------------------------------------------------------------------------------
// Details: Retrieve the frame information from LLDB frame object.
// Type:    Method.
// Args:    vrFrame         - (R) LLDB thread object.
//          vPc             - (W) Address number.
//          vFnName         - (W) Function name.
//          vFileName       - (W) File name text.
//          vPath           - (W) Full file name and path text.
//          vnLine          - (W) File line number.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::GetFrameInfo(const lldb::SBFrame &vrFrame, lldb::addr_t &vwPc, CMIUtilString &vwFnName,
                                         CMIUtilString &vwFileName, CMIUtilString &vwPath, MIuint &vwnLine)
{
    lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);

    static char pBuffer[MAX_PATH];
    const MIuint nBytes = rFrame.GetLineEntry().GetFileSpec().GetPath(&pBuffer[0], sizeof(pBuffer));
    MIunused(nBytes);
    CMIUtilString strResolvedPath(&pBuffer[0]);
    const char *pUnkwn = "??";
    if (!ResolvePath(pUnkwn, strResolvedPath))
        return MIstatus::failure;
    vwPath = strResolvedPath;

    vwPc = rFrame.GetPC();

    const char *pFnName = rFrame.GetFunctionName();
    vwFnName = (pFnName != nullptr) ? pFnName : pUnkwn;

    const char *pFileName = rFrame.GetLineEntry().GetFileSpec().GetFilename();
    vwFileName = (pFileName != nullptr) ? pFileName : pUnkwn;

    vwnLine = rFrame.GetLineEntry().GetLine();

    return MIstatus::success;
}
示例#2
0
  TransactionResult::Enum MarkAsProcessed(const std::string &Path)
  {
    std::string Absolute;
    if (!ResolvePath(Path.c_str(), Absolute)) {
      DB->ErrorMessage = "could not find file on disk: ";
      DB->ErrorMessage += Path;
      return TransactionResult::ERROR;
    }

    Statement SQL;
    TransactionResult::Enum tret =
      SQL.TxnPrepare(*DB, "SELECT id FROM files "
		     "WHERE path = ? ORDER BY id DESC LIMIT 1");
    if (tret != TransactionResult::COMMIT) {
      return tret;
    }
    sqlite3_bind_text(SQL.Ptr, 1, Absolute.data(), Absolute.size(),
		      SQLITE_TRANSIENT);
    int ret = sqlite3_step(SQL.Ptr);
    if (ret == SQLITE_DONE) {
      // File is not in the database.  No need to mask older errors.
      return TransactionResult::COMMIT;
    }
    if (ret != SQLITE_ROW) {
      return DB->SetTransactionError(sqlite3_sql(SQL.Ptr));
    }
    // Add an entry for the file, hiding the previous reports.
    // TODO: Only hide changed files? What about plugin changes?
    if (Resolve(Path) == NULL) {
      return TransactionResult::ERROR;
    }
    return TransactionResult::COMMIT;
  }
示例#3
0
CFile::ERRCODE CWinFileSystem::GetCurrentDirectory(CStrAny &sDir)
{
  char *pPath = _getcwd(0, 0);
  if (!pPath) {
    sDir.Clear();
    return (CFile::ERRCODE) errno;
  }
  sDir = ResolvePath(CStrAny(ST_WHOLE, pPath));
  free(pPath);
  return 0;
}
示例#4
0
initrd_inode_t* ResolvePath(int fd, initrd_superblock_t* sb,
                            initrd_inode_t* inode, const char* path)
{
	if ( !path[0] ) { return CloneInode(inode); }
	if ( path[0] == '/' )
	{
		if ( !INITRD_S_ISDIR(inode->mode) ) { errno = ENOTDIR; return NULL; }
		return ResolvePath(fd, sb, inode, path+1);
	}
	size_t elemlen = strcspn(path, "/");
	char* elem = Substring(path, 0, elemlen);
	uint32_t ino = Traverse(fd, sb, inode, elem);
	free(elem);
	if ( !ino ) { return NULL; }
	initrd_inode_t* child = GetInode(fd, sb, ino);
	if ( !child ) { return NULL; }
	if ( !path[elemlen] ) { return child; }
	initrd_inode_t* result = ResolvePath(fd, sb, child, path + elemlen);
	free(child);
	return result;
}
示例#5
0
bool JPSPlusPathFinder::Run(const Cell& startCell, const Cell& goalCell, List<const Cell*>* outPath)
{
	if (startCell.Capability()!=0 || goalCell.Capability()!=0)
		return false;

	mOpenList.Clear();
	mPathNodes.Clear();

	PathNode& pathNode = mPathNodes[startCell.Id()];
	pathNode.CurrentToGoalCost = HDistance(startCell, goalCell);
	mOpenList.Push(pathNode.CurrentToGoalCost, &startCell);

	while (!mOpenList.IsEmpty())
	{
		const Cell* currentCell = mOpenList.Top().Value;
		if (currentCell == &goalCell)
			break;
		mOpenList.Pop();

		mPathNodes[currentCell->Id()].IsClosed = 1;

		if (TraversalNeighbours(currentCell, &goalCell))
		{
			if (outPath!=nullptr)
			{
				return ResolvePath(&startCell, &goalCell,*outPath) > 0;
			}
			return true;
		}
	}

	if (outPath != nullptr)
	{
		ResolvePath(&startCell, &goalCell, *outPath);
	}

	return true;
}
示例#6
0
FileIdentification::FileIdentification(const char *path)
  : Mtime(0), Size(0)
{
  if (ResolvePath(path, Path)) {
    struct stat st;
    int ret = lstat(Path.c_str(), &st);
    if (ret == 0) {
      Mtime = st.st_mtime;
      Size = st.st_size;
    } else {
      Path.clear();
    }
  }
}
示例#7
0
//++ ------------------------------------------------------------------------------------
// Details:	Return the resolved file's path for the given file.
// Type:	Method.
// Args:	vCmdData		- (R) A command's information.
//			vPath			- (R) Original path.
//			vwrResolvedPath	- (W) Resolved path.
// Return:	MIstatus::success - Functional succeeded.
//			MIstatus::failure - Functional failed.
// Throws:	None.
//--
bool CMICmnLLDBDebugSessionInfo::ResolvePath( const SMICmdData & vCmdData, const CMIUtilString & vPath, CMIUtilString & vwrResolvedPath )
{
	// ToDo: Verify this code as it does not work as vPath is always empty

	CMIUtilString strResolvedPath;
	if( !SharedDataRetrieve( "Working Directory", strResolvedPath ) )
	{
		vwrResolvedPath = "";
		SetErrorDescription( CMIUtilString::Format( MIRSRC( IDS_CMD_ERR_SHARED_DATA_NOT_FOUND ), vCmdData.strMiCmd.c_str(), "Working Directory" ) );
		return MIstatus::failure;
	}

	vwrResolvedPath = vPath;

	return ResolvePath( strResolvedPath, vwrResolvedPath );
}
示例#8
0
const TreeNode *TreeNode::Child(const std::string& s) const {
	std::string name;
	const TreeNode *parent = ResolvePath(s, name);

	Children::const_iterator it(mChildren.begin()), itEnd(mChildren.end());

	for(; it!=itEnd; ++it) {
		TreeNode *child = *it;
		if (!child->mbIsText) {
			if (child->mName == "lina:data") {
				const TreeNode *t = child->Child(name);
				if (t)
					return t;
			}
			if (child->mName == name)
				return *it;
		}
	}
	return NULL;
}
示例#9
0
void scandir(const std::string& path,
             const std::string& extension,
             std::vector<std::string>* files) {
  files->clear();

  std::string search_path = path.empty() ? "." : path;
  DIR* dir = opendir(ResolvePath(search_path).c_str());
  if (!dir) return;

  struct dirent entry;
  struct dirent* result;

  while (readdir_r(dir, &entry, &result) == 0) {
    if (result == NULL) break;
    if (mats::ends_with(entry.d_name, extension)) {
      files->emplace_back(entry.d_name);
    }
  }

  closedir(dir);
}
示例#10
0
/* Resolves actor paths a la LoadActor("..."), with autowildcarding and .redir
 * files.  Returns a path *within* the Rage filesystem, unlike the FILEMAN
 * function of the same name. */
bool ActorUtil::ResolvePath( RString &sPath, const RString &sName, bool optional )
{
	CollapsePath( sPath );

	// If we know this is an exact match, don't bother with the GetDirListing,
	// so "foo" doesn't partial match "foobar" if "foo" exists.
	RageFileManager::FileType ft = FILEMAN->GetFileType( sPath );
	if( ft != RageFileManager::TYPE_FILE && ft != RageFileManager::TYPE_DIR )
	{
		vector<RString> asPaths;
		GetDirListing( sPath + "*", asPaths, false, true );	// return path too

		if( asPaths.empty() )
		{
			if(optional)
			{
				return false;
			}
			RString sError = ssprintf( "%s: references a file \"%s\" which doesn't exist", sName.c_str(), sPath.c_str() );
			switch(LuaHelpers::ReportScriptError(sError, "BROKEN_FILE_REFERENCE", true))
			{
			case Dialog::abort:
				RageException::Throw( "%s", sError.c_str() ); 
				break;
			case Dialog::retry:
				FILEMAN->FlushDirCache();
				return ResolvePath( sPath, sName );
			case Dialog::ignore:
				return false;
			default:
				FAIL_M("Invalid response to Abort/Retry/Ignore dialog");
			}
		}

		THEME->FilterFileLanguages( asPaths );

		if( asPaths.size() > 1 )
		{
			RString sError = ssprintf( "%s: references a file \"%s\" which has multiple matches", sName.c_str(), sPath.c_str() );
			sError += "\n" + join( "\n", asPaths );
			switch(LuaHelpers::ReportScriptError(sError, "BROKEN_FILE_REFERENCE", true))
			{
			case Dialog::abort:
				RageException::Throw( "%s", sError.c_str() ); 
				break;
			case Dialog::retry:
				FILEMAN->FlushDirCache();
				return ResolvePath( sPath, sName );
			case Dialog::ignore:
				asPaths.erase( asPaths.begin()+1, asPaths.end() );
				break;
			default:
				FAIL_M("Invalid response to Abort/Retry/Ignore dialog");
			}
		}

		sPath = asPaths[0];
	}

	if( ft == RageFileManager::TYPE_DIR )
	{
		RString sLuaPath = sPath + "/default.lua";
		if( DoesFileExist(sLuaPath) )
		{
			sPath = sLuaPath;
			return true;
		}
	}

	sPath = DerefRedir( sPath );
	return true;
}
示例#11
0
Actor *ActorUtil::LoadFromNode( const XNode* _pNode, Actor *pParentActor )
{
	ASSERT( _pNode != NULL );

	XNode node = *_pNode;

	// Remove this in favor of using conditionals in Lua. -Chris
	// There are a number of themes out there that depend on this (including
	// sm-ssc default). Probably for the best to leave this in. -aj
	{
		bool bCond;
		if( node.GetAttrValue("Condition", bCond) && !bCond )
			return NULL;
	}

	RString sClass;
	bool bHasClass = node.GetAttrValue( "Class", sClass );
	if( !bHasClass )
		bHasClass = node.GetAttrValue( "Type", sClass );

	bool bLegacy = (node.GetAttr( "_LegacyXml" ) != NULL);
	if( !bHasClass && bLegacy )
		sClass = GetLegacyActorClass( &node );

	map<RString,CreateActorFn>::iterator iter = g_pmapRegistrees->find( sClass );
	if( iter == g_pmapRegistrees->end() )
	{
		RString sFile;
		if (bLegacy && node.GetAttrValue("File", sFile) && sFile != "")
		{
			RString sPath;
			// Handle absolute paths correctly
			if (sFile.Left(1) == "/")
				sPath = sFile;
			else
				sPath = Dirname(GetSourcePath(&node)) + sFile;
			if (ResolvePath(sPath, GetWhere(&node)))
			{
				Actor *pNewActor = MakeActor(sPath, pParentActor);
				if (pNewActor == NULL)
					return NULL;
				if (pParentActor)
					pNewActor->SetParent(pParentActor);
				pNewActor->LoadFromNode(&node);
				return pNewActor;
			}
		}

		// sClass is invalid
		RString sError = ssprintf( "%s: invalid Class \"%s\"",
			ActorUtil::GetWhere(&node).c_str(), sClass.c_str() );
		LuaHelpers::ReportScriptError(sError);
		return new Actor;	// Return a dummy object so that we don't crash in AutoActor later.
	}

	const CreateActorFn &pfn = iter->second;
	Actor *pRet = pfn();

	if( pParentActor )
		pRet->SetParent( pParentActor );

	pRet->LoadFromNode( &node );
	return pRet;
}
void CommandPromptProcess(ScriptValue &s, ScriptValue* args) {
if (0)
{
  char buf[1024];           //i/o buffer

  STARTUPINFOA si;
  SECURITY_ATTRIBUTES sa;
  PROCESS_INFORMATION pi;
  HANDLE newstdin,newstdout,read_stdout,write_stdin;  //pipe handles

  sa.lpSecurityDescriptor = NULL;
  sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  sa.bInheritHandle = true;         //allow inheritable handles

  if (!CreatePipe(&newstdin,&write_stdin,&sa,0))   //create stdin pipe
  {
    return;
  }
  if (!CreatePipe(&read_stdout,&newstdout,&sa,0))  //create stdout pipe
  {
    CloseHandle(newstdin);
    CloseHandle(write_stdin);
    return;
  }

  GetStartupInfoA(&si);      //set startupinfo for the spawned process
  /*
  The dwFlags member tells CreateProcess how to make the process.
  STARTF_USESTDHANDLES validates the hStd* members. STARTF_USESHOWWINDOW
  validates the wShowWindow member.
  */
  si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
  si.wShowWindow = SW_HIDE;
  si.hStdOutput = newstdout;
  si.hStdError = newstdout;     //set the new handles for the child process
  si.hStdInput = newstdin;
  char app_spawn[] = "C:\\windows\\system32\\ping.exe"; //sample, modify for your
                                                     //system

  //spawn the child process
  if (!CreateProcessA(app_spawn,NULL,NULL,NULL,TRUE,CREATE_NEW_CONSOLE,
                     NULL,NULL,&si,&pi))
  {
    CloseHandle(newstdin);
    CloseHandle(newstdout);
    CloseHandle(read_stdout);
    CloseHandle(write_stdin);
    return;
  }

  unsigned long exit=0;  //process exit code
  unsigned long bread;   //bytes read
  unsigned long avail;   //bytes available

  for(;;)      //main program loop
  {
    PeekNamedPipe(read_stdout,buf,1023,&bread,&avail,NULL);
    //check to see if there is any data to read from stdout
    if (bread != 0)
    {
      if (avail > 1023)
      {
        while (bread >= 1023)
        {
          ReadFile(read_stdout,buf,1023,&bread,NULL);  //read the stdout pipe
          printf("%s",buf);
        }
      }
      else {
        ReadFile(read_stdout,buf,1023,&bread,NULL);
        printf("%s",buf);
      }
    }
    GetExitCodeProcess(pi.hProcess,&exit);      //while the process is running
    if (exit != STILL_ACTIVE)
      break;
	/*
    if (kbhit())      //check for user input.
    {
      bzero(buf);
      *buf = (char)getche();
      //printf("%c",*buf);
      WriteFile(write_stdin,buf,1,&bread,NULL); //send it to stdin
      if (*buf == '\r') {
        *buf = '\n';
        printf("%c",*buf);
        WriteFile(write_stdin,buf,1,&bread,NULL); //send an extra newline char,
                                                  //if necessary
      }
    }
	//*/
  }
  CloseHandle(pi.hThread);
  CloseHandle(pi.hProcess);
  CloseHandle(newstdin);            //clean stuff up
  CloseHandle(newstdout);
  CloseHandle(read_stdout);
  CloseHandle(write_stdin);
}

	wchar_t *path = ResolvePath(args[0].stringVal->value);
	wchar_t *dir = 0;
	if (path && (!args[2].stringVal->len || (dir = ResolvePath(args[2].stringVal->value)))) {
		STARTUPINFO si;
		PROCESS_INFORMATION pi;
		memset(&si, 0, sizeof(si));
		si.cb = sizeof(si);
		wchar_t *params = UTF8toUTF16Alloc(args[1].stringVal->value);
		ConnectedProcess *cp = 0;
		cp = (ConnectedProcess*)calloc(1,sizeof(ConnectedProcess));
		if (cp) {
			SECURITY_ATTRIBUTES saAttr; 
			saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
			saAttr.bInheritHandle = TRUE;
			saAttr.lpSecurityDescriptor = NULL; 
			static __int64 namedPipes = 0;
			char pipeNames[3][100];
			sprintf(pipeNames[0], "\\\\.\\pipe\\LCD Miscellany error pipe %I64i", namedPipes);
			sprintf(pipeNames[1], "\\\\.\\pipe\\LCD Miscellany out pipe %I64i", namedPipes);
			sprintf(pipeNames[2], "\\\\.\\pipe\\LCD Miscellany in pipe %I64i", namedPipes);
			namedPipes++;
			//*
			cp->error[0] = CreateNamedPipeA(pipeNames[0], PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE | PIPE_WAIT, 1, 1024, 1024, 5000, 0);
			cp->error[1] = CreateFileA(pipeNames[0], GENERIC_WRITE, 0, &saAttr, OPEN_EXISTING, 0, 0);
			cp->out[0] = CreateNamedPipeA(pipeNames[1], PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE | PIPE_WAIT, 1, 1024, 1024, 5000, 0);
			cp->out[1] = CreateFileA(pipeNames[1], GENERIC_WRITE, 0, &saAttr, OPEN_EXISTING, 0, 0);
			cp->in[0] = CreateNamedPipeA(pipeNames[2], PIPE_ACCESS_OUTBOUND, PIPE_TYPE_BYTE | PIPE_WAIT, 1, 1024, 1024, 5000, 0);
			cp->in[1] = CreateFileA(pipeNames[2], GENERIC_READ, 0, &saAttr, OPEN_EXISTING, 0, 0);
			//*/
			//CreatePipe(&cp->error[0], &cp->error[1], &saAttr, 0);
			//CreatePipe(&cp->out[0], &cp->out[1], &saAttr, 0);
			//CreatePipe(&cp->in[1], &cp->in[0], &saAttr, 0);
			int happy = 1;
			for (int i=0; i<3; i++) {
				if (cp->handles[2*i] == INVALID_HANDLE_VALUE ||
					cp->handles[2*i+1] == INVALID_HANDLE_VALUE) {
					happy = 0;
				}
			}
			if (happy) {
				si.hStdError = cp->out[1];
				si.hStdInput = cp->in[1];
				si.hStdOutput = cp->out[1];
				si.dwFlags = STARTF_USESTDHANDLES;
				if (!CreateProcessW(L"c:\\Windows\\System32\\PING.EXE", 0, 0, 0, 1, CREATE_NEW_CONSOLE, 0, dir, &si, &pi)/* && CreateListValue(s, 4)//*/) {
					happy = 0;
				}
				else {
					CreateIntValue(s, pi.dwProcessId);
					if (si.dwFlags) {
						char temp[1000];
						{
							DWORD bread, avail;
							//PeekNamedPipe(read_stdout,temp,1000,&bread,&avail,NULL);
							PeekNamedPipe(cp->out[0],temp,1000,&bread,&avail,NULL);
							PeekNamedPipe(cp->in[0],temp,1000,&bread,&avail,NULL);
							bread = bread;
						}
						DWORD read = 0;
						ReadFile(cp->out[0], temp, 1, &read, 0);
						ReadFile(cp->error[0], temp, 1, &read, 0);
						ReadFile(cp->in[0], temp, 1000, &read, 0);
						read = read;
					}
				}
			}
			if (!happy) {
				if (cp) {
					for (int i=0; i<6; i++) {
						if (cp->handles[i] != INVALID_HANDLE_VALUE) {
							CloseHandle(cp->handles[i]);
						}
					}
					free(cp);
				}
			}
		}
		free(params);
	}
	free(path);
	free(dir);
}
示例#13
0
Stroka ResolvePath(const char* path, bool isDir) {
    char buf[PATH_MAX];
    if (ResolvePath(path, NULL, buf, isDir))
        ythrow yexception() << "cannot resolve path: \"" <<  path << "\"";
    return buf;
}
示例#14
0
std::string GlobalConfigData::ResolveTmpDataPath() {
	return ResolvePath(TmpDataPath);
}
示例#15
0
std::string GlobalConfigData::ResolveHTTPCARPath() {
	return ResolvePath(HTTPCARFolder);
}
void DirectFilenameDB::PopulateFileSet( FileSet &fs, const RString &path )
{
	RString sPath = path;

#if defined(XBOX)
	/* Xbox doesn't handle path names which end with ".", which are used when using an
	 * alternative song directory */
	if( sPath.size() > 0 && sPath.Right(1) == "." )
		sPath.erase( sPath.size() - 1 );
#endif

	/* Resolve path cases (path/Path -> PATH/path). */
	ResolvePath( sPath );

	fs.age.GetDeltaTime(); /* reset */
	fs.files.clear();

#if defined(WIN32)
	WIN32_FIND_DATA fd;

	if ( sPath.size() > 0  && sPath.Right(1) == "/" )
		sPath.erase( sPath.size() - 1 );

	HANDLE hFind = DoFindFirstFile( root+sPath+"/*", &fd );
	CHECKPOINT_M( root+sPath+"/*" );

	if( hFind == INVALID_HANDLE_VALUE )
		return;

	do {
		if( !strcmp(fd.cFileName, ".") || !strcmp(fd.cFileName, "..") )
			continue;

		File f;
		f.SetName( fd.cFileName );
		f.dir = !!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
		f.size = fd.nFileSizeLow;
		f.hash = fd.ftLastWriteTime.dwLowDateTime;

		fs.files.insert( f );
	} while( FindNextFile( hFind, &fd ) );
	FindClose( hFind );
#else
	/* Ugly: POSIX threads are not guaranteed to have per-thread cwds, and only
	 * a few systems have openat() or equivalent; one or the other is needed
	 * to do efficient, thread-safe directory traversal.  Instead, we have to
	 * use absolute paths, which forces the system to re-parse the directory
	 * for each file.  This isn't a major issue, since most large directory
	 * scans are I/O-bound. */
	 
	DIR *pDir = opendir(root+sPath);
	if( pDir == NULL )
		return;

	while( struct dirent *pEnt = readdir(pDir) )
	{
		if( !strcmp(pEnt->d_name, ".") )
			continue;
		if( !strcmp(pEnt->d_name, "..") )
			continue;
		
		File f( pEnt->d_name );
		
		struct stat st;
		if( DoStat(root+sPath + "/" + pEnt->d_name, &st) == -1 )
		{
			int iError = errno;
			/* If it's a broken symlink, ignore it.  Otherwise, warn. */
			if( lstat(root+sPath + "/" + pEnt->d_name, &st) == 0 )
				continue;
			
			/* Huh? */
			WARN( ssprintf("Got file '%s' in '%s' from list, but can't stat? (%s)",
					pEnt->d_name, sPath.c_str(), strerror(iError)) );
			continue;
		}
		else
		{
			f.dir = (st.st_mode & S_IFDIR);
			f.size = (int)st.st_size;
			f.hash = st.st_mtime;
		}

		fs.files.insert(f);
	}
	       
	closedir( pDir );
#endif

	/*
	 * Check for any ".ignore" markers.  If a marker exists, hide the marker and its 
	 * corresponding file.
	 * For example, if "file.xml.ignore" exists, hide both it and "file.xml" by 
	 * removing them from the file set.
	 * Ignore markers are used for convenience during build staging and are not used in 
	 * performance-critical situations.  To avoid incurring some of the overheard 
	 * due to ignore markers, delete the file instead instead of using an ignore marker.
	 */
	static const RString IGNORE_MARKER_BEGINNING = "ignore-";

	vector<RString> vsFilesToRemove;
	for( set<File>::iterator iter = fs.files.lower_bound(IGNORE_MARKER_BEGINNING); 
		 iter != fs.files.end(); 
		 ++iter )
	{
		if( !BeginsWith( iter->lname, IGNORE_MARKER_BEGINNING ) )
			break;
		RString sFileLNameToIgnore = iter->lname.Right( iter->lname.length() - IGNORE_MARKER_BEGINNING.length() );
		vsFilesToRemove.push_back( iter->name );
		vsFilesToRemove.push_back( sFileLNameToIgnore );
	}
	
	FOREACH_CONST( RString, vsFilesToRemove, iter )
	{
		// Erase the file corresponding to the ignore marker
		File fileToDelete;
		fileToDelete.SetName( *iter );
		set<File>::iterator iter2 = fs.files.find( fileToDelete );
		if( iter2 != fs.files.end() )
			fs.files.erase( iter2 );
	}
示例#17
0
int main(int argc, char* argv[])
{
	bool all = false;
	const char* argv0 = argv[0];
	for ( int i = 1; i < argc; i++ )
	{
		const char* arg = argv[i];
		if ( arg[0] != '-' || !arg[1] )
			continue;
		argv[i] = NULL;
		if ( !strcmp(arg, "--") )
			break;
		if ( arg[1] != '-' )
		{
			char c;
			while ( (c = *++arg) ) switch ( c )
			{
			default:
				fprintf(stderr, "%s: unknown option -- '%c'\n", argv0, c);
				help(stderr, argv0);
				exit(1);
			}
		}
		else if ( !strcmp(arg, "--help") )
			help(stdout, argv0), exit(0);
		else if ( !strcmp(arg, "--version") )
			version(stdout, argv0), exit(0);
		else if ( !strcmp(arg, "-a") )
			all = true;
		else
		{
			fprintf(stderr, "%s: unknown option: %s\n", argv0, arg);
			help(stderr, argv0);
			exit(1);
		}
	}

	compact_arguments(&argc, &argv);

	if ( argc == 1 )
		error(1, 0, "No initrd specified");
	const char* initrd = argv[1];
	if ( argc == 2 )
		error(1, 0, "No command specified");
	const char* cmd = argv[2];
	if ( argc == 3 )
		error(1, 0, "No path specified");
	const char* path = argv[3];

	int fd = open(initrd, O_RDONLY);
	if ( fd < 0 ) { error(1, errno, "open: %s", initrd); }

	initrd_superblock_t* sb = GetSuperBlock(fd);
	if ( !sb ) { error(1, errno, "read: %s", initrd); }

	if ( path[0] != '/' ) { error(1, ENOENT, "%s", path); }

	initrd_inode_t* root = GetInode(fd, sb, sb->root);
	if ( !root ) { error(1, errno, "read: %s", initrd); }

	initrd_inode_t* inode = ResolvePath(fd, sb, root, path+1);
	if ( !inode ) { error(1, errno, "%s", path); }

	free(root);

	if ( !strcmp(cmd, "cat") )
	{
		if ( !PrintFile(fd, sb, inode) ) { error(1, errno, "%s", path); }
	}
	else if ( !strcmp(cmd, "ls") )
	{
		initrd_inode_t* dir = inode;
		if ( !ListDirectory(fd, sb, dir, all) ) { error(1, errno, "%s", path); }
	}
	else
	{
		fprintf(stderr, "%s: unrecognized command: %s", argv0, cmd);
		exit(1);
	}

	free(inode);
	free(sb);
	close(fd);

	return 0;
}
示例#18
0
CFile::ERRCODE CWinFileSystem::DeleteFile(CStrAny const &sFile)
{
  CStrAny sPath = ResolvePath(sFile);
  int iRes = _unlink(sPath.m_pBuf);
  return (iRes < 0) ? (CFile::ERRCODE) errno : 0;
}
示例#19
0
CFile::ERRCODE CWinFileSystem::DeleteDirectory(CStrAny const &sDir)
{
  CStrAny sPath = ResolvePath(sDir);
  int iRes = _rmdir(sPath.m_pBuf);
  return (iRes < 0) ? (CFile::ERRCODE) errno : 0;
}
示例#20
0
std::string GlobalConfigData::ResolveStaticDataPath() {
	return ResolvePath(StaticDataPath);
}
示例#21
0
 /// \brief
 ///   Resolves all possible ".." in the path. Accepts \ and /
 ///   
 /// \param szPath
 ///   The actual path to resolve
 ///   
 /// \return
 ///   A VString containing the resolved path (no more '..' inside the path)
 ///   
 /// \note
 ///   Internally creates a temp buffer on the stack. Do not use it extensively for time critical processes.  
 VBASE_IMPEXP static VString ResolvePath(const char* szPath)
 {
   char szBuffer[FS_MAX_PATH];
   ResolvePath(szBuffer, szPath);
   return VString(szBuffer);
 }
示例#22
0
std::string GlobalConfigData::ResolveVariableDataPath() {
	return ResolvePath(VariableDataPath);
}
示例#23
0
int MakeTempDir(char path[/*FILENAME_MAX*/], const char* prefix) {
    int ret;

    Stroka sysTmp;

#ifdef _win32_
    if (!prefix || *prefix == '/') {
#else
    if (!prefix) {
#endif
        sysTmp = GetSystemTempDir();
        prefix = ~sysTmp;
    }

    if ((ret = ResolvePath(prefix, NULL, path, 1)) != 0)
        return ret;
    if ((ret = isdir(path)) != 0)
        return ret;
    if ((strlcat(path, "tmpXXXXXX", FILENAME_MAX) > FILENAME_MAX - 100))
        return EINVAL;
    if (!(mkdtemp(path)))
        return errno ? errno : EINVAL;
    strcat(path, LOCSLASH_S);
    return 0;
}

int RemoveTempDir(const char* dirName) {
    DIR *dir;
#ifndef DT_DIR
    struct stat sbp;
#endif
    if ((dir = opendir(dirName)) == 0)
        return errno ? errno : ENOENT;

    int ret;
    dirent ent, *pent;
    char path[FILENAME_MAX], *ptr;
    size_t len = strlcpy(path, dirName, FILENAME_MAX);

    if (path[len-1] != LOCSLASH_C) {
        path[len] = LOCSLASH_C;
        path[++len] = 0;
    }
    ptr = path + len;
    while ((ret = readdir_r(dir, &ent, &pent)) == 0 && pent == &ent) {
        if (!strcmp(ent.d_name, ".") || !strcmp(ent.d_name, ".."))
            continue;
#ifdef DT_DIR
        if (ent.d_type == DT_DIR)
#else
        lstat(ent.d_name, &sbp);
        if (S_ISREG(sbp.st_mode))
#endif
        {
            ret = ENOTEMPTY;
            break;
        }
        strcpy(ptr, ent.d_name);
        if (unlink(path)) {
            ret = errno ? errno : ENOENT;
            break;
        }
    }
    closedir(dir);
    if (ret)
        return ret;
    *ptr = 0;
    if (rmdir(path))
        return errno ? errno : ENOTEMPTY;
    return 0;
}
示例#24
0
std::string GlobalConfigData::ResolveLogPath() {
	return ResolvePath(LogPath);
}
示例#25
0
Stroka ResolveDir(const char* path) {
    return ResolvePath(path, true);
}