Beispiel #1
0
static int UpgradeNSIS(void)
{
	std::string installPath = GetNSISInstallPath();

	if (installPath.empty())
		return 0;

	std::string uninstallerPath = installPath + "\\uninstall.exe";

	if (!PathExists(uninstallerPath))
		return 0;

	std::string dataPath = GetIcingaDataPath();

	if (dataPath.empty())
		return 1;

	bool moveUserData = !PathExists(dataPath);

	/* perform open heart surgery on the user's data dirs - yay */
	if (moveUserData) {
		MkDir(dataPath.c_str());

		std::string oldNameEtc = installPath + "\\etc";
		std::string newNameEtc = dataPath + "\\etc";
		if (!CopyDirectory(oldNameEtc, newNameEtc))
			return 1;

		std::string oldNameVar = installPath + "\\var";
		std::string newNameVar = dataPath + "\\var";
		if (!CopyDirectory(oldNameVar, newNameVar))
			return 1;
	}

	ExecuteCommand(uninstallerPath, "/S _?=" + installPath);

	_unlink(uninstallerPath.c_str());

	if (moveUserData) {
		std::string oldNameEtc = installPath + "\\etc";
		if (!DeleteDirectory(oldNameEtc))
			return 1;

		std::string oldNameVar = installPath + "\\var";
		if (!DeleteDirectory(oldNameVar))
			return 1;

		_rmdir(installPath.c_str());
	}	

	return 0;
}
Beispiel #2
0
bool CopyDirectory( const wxString& from, const wxString& to ) {
	wxDir src( from );
	if ( !src.IsOpened() ) {
		return false;
	}

	wxMkdir( to );
	wxDir dst( to );
	if ( !dst.IsOpened() ) {
		return false;
	}

	wxString filename;

	// copy directories
	if ( src.GetFirst( &filename, wxEmptyString, wxDIR_DIRS | wxDIR_HIDDEN ) ) {
		do {
			if ( !CopyDirectory( wxFileName( from, filename ).GetFullPath(), wxFileName( to, filename ).GetFullPath() ) ) {
				return false;
			}
		} while ( src.GetNext( &filename ) );
	}

	// copy files
	if ( src.GetFirst( &filename, wxEmptyString, wxDIR_FILES | wxDIR_HIDDEN ) ) {
		do {
			if ( !wxCopyFile( wxFileName( from, filename ).GetFullPath(), wxFileName( to, filename ).GetFullPath() ) ) {
				return false;
			}
		} while ( src.GetNext( &filename ) );
	}

	return true;
}
Beispiel #3
0
BOOL WINAPI
CopyProfileDirectoryW(LPCWSTR lpSourcePath,
		      LPCWSTR lpDestinationPath,
		      DWORD dwFlags)
{
  /* FIXME: dwFlags are ignored! */
  return CopyDirectory(lpDestinationPath, lpSourcePath);
}
//---------------------------------------------------------------------
// CopyObjectToFileSystem():
//---------------------------------------------------------------------
BOOL WPDIRECTORY::CopyObjectToFileSystem(char *pszDestPath)
{
   char  szDestPath[_MAX_PATH+1];

   // Create destination directory name fully qualified.
   sprintf(szDestPath,"%s\\%s",pszDestPath,MakeFATName((char *)GetTitleNoCRLF()));
   // Copy directory recursively.
   return (CopyDirectory(GetPath(),szDestPath));
}
void GenesisCopyWindow::Copy(const char *filename, const char *destination, const char *destfilename)
////////////////////////////////////////////////////////////////////////
{
	BEntry sourcefile(filename);
	BString text;
	
	if (sourcefile.InitCheck()==B_OK)
	{
/*
		BString text;
		
		text.SetTo("");
		text << filename << "\n" << destination;

		BAlert *myAlert = new BAlert("Copy debug",text.String(),"OK", NULL, NULL, B_WIDTH_AS_USUAL, B_OFFSET_SPACING, B_WARNING_ALERT);
		myAlert->Go();
*/

		if (sourcefile.IsDirectory())
		{
			if (IsRecursiveCopy(filename, destination))
			{
				BString text;
				text << "Recursive copy not allowed.\nPlease check the destination folder.";
			
				BAlert *myAlert = new BAlert("Copy",text.String(),"OK", NULL, NULL, B_WIDTH_AS_USUAL, B_OFFSET_SPACING, B_WARNING_ALERT);
				myAlert->Go();
				Close();
				kill_thread(m_CopyThread);
			}

			CopyDirectory(filename, destination, destfilename);
		}
		else if (sourcefile.IsSymLink())
			CopyLink(filename,destination, destfilename);
		else
			CopyFile(filename, destination, destfilename);
	}
	else if (!m_SkipAllCopyError)
	{
		text << "Error while initializing file:\n\n" << filename;
		
		BAlert *myAlert = new BAlert("Copy",text.String(),"Abort","Skip all","Skip",B_WIDTH_AS_USUAL,B_OFFSET_SPACING,B_WARNING_ALERT);
		myAlert->SetShortcut(0, B_ESCAPE);
		switch (myAlert->Go())
		{
			case 0:
				Close();
				kill_thread(m_CopyThread);
				break;
			case 1:
				m_SkipAllCopyError = true;
				break;
		}	
	}
}
Beispiel #6
0
        /**
         * @brief 拷贝目录
         * @param[in] szSrcDir   源目录
         * @param[in] szDstDir   目标目录
         * @param[in] bCoverFile 是否覆盖已存在的文件
         * @return 返回拷贝文件的数目
         * @see 
         */
        static int CopyDirectory(LPCTSTR lpSrcDir, LPCTSTR lpDstDir, BOOL bCoverFile = TRUE)
        {
            if (!lpSrcDir || !lpDstDir)
                return 0;

            int nReturn = 0;
            CString strFind;
            CString strSubFile;
            CString strSubDstFile;
            CString strSrcDir(lpSrcDir);
            CString strDstDir(lpDstDir);
            WIN32_FIND_DATA FindFileData;
            HANDLE hFind = INVALID_HANDLE_VALUE;
            ZLPath::PathAddBackslash(strSrcDir);
            ZLPath::PathAddBackslash(strDstDir);
            CreateDeepDirectory(strDstDir);
            strFind.Format(_T("%s*.*"), strSrcDir);
            hFind = ::FindFirstFile(strFind, &FindFileData);
            if (hFind == INVALID_HANDLE_VALUE)
                goto Exit0;
            do 
            {
                if (_tcscmp(FindFileData.cFileName, _T(".")) == 0
                    || _tcscmp(FindFileData.cFileName, _T("..")) == 0)
                    continue;

                if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                {
                    strSubFile.Format(_T("%s%s\\"), strSrcDir, FindFileData.cFileName);
                    strSubDstFile.Format(_T("%s%s\\"), strDstDir, FindFileData.cFileName);

                    CreateDeepDirectory(strSubDstFile);
                    nReturn += CopyDirectory(strSubFile, strSubDstFile, !bCoverFile);
                }
                else
                {
                    strSubFile.Format(_T("%s%s"), strSrcDir, FindFileData.cFileName);
                    strSubDstFile.Format(_T("%s%s"), strDstDir, FindFileData.cFileName);

                    if (!::CopyFile(strSubFile, strSubDstFile, !bCoverFile))
                        nReturn++;
                }
            } while (::FindNextFile(hFind, &FindFileData) != 0);
Exit0:
            if (hFind != INVALID_HANDLE_VALUE)
                ::FindClose(hFind);
            return nReturn;
        }
//*****************************************************************************
// You can use this function to create backups in the way that you copy all 
// files recursive into a folder under the installation folder. So the whole tree
// of the previous installation in lDir can be copied into lSubdir.
//*****************************************************************************
long WINAPI	RecursiveCopyIntoSubdir(long lDir,long lSubdir)
{
	TCHAR DirToCopy[MAX_PATH+1];
	TCHAR SubDir[MAX_PATH+1];
	TCHAR SupressSubDir[MAX_PATH+1];

	// Verzeichnis ist notwendig!
	if(lDir==0) return 1;

	memset(DirToCopy,0,sizeof(DirToCopy));
	memset(SubDir,0,sizeof(SubDir));
	memset(SupressSubDir,0,sizeof(SupressSubDir));

	_tcsncpy(DirToCopy,(TCHAR*)lDir,MAX_PATH);
	if(DirToCopy[_tcslen(DirToCopy)-1] != '\\')
		_tcsncat(DirToCopy,"\\",MAX_PATH);

	// Übertragen in Unterverzeichnis
	SubDir[0] = '\0';
	_tcsncat(SubDir,DirToCopy,MAX_PATH);
	if(lSubdir==0)
		_tcsncat(SubDir,"bak",MAX_PATH);
	else 
		_tcsncat(SubDir,(TCHAR*)lSubdir,MAX_PATH);

	if(SubDir[_tcslen(SubDir)-1] != '\\')
		_tcsncat(SubDir,"\\",MAX_PATH);

	// Erzeugen des Unterverzeichnisses
	CreateDirectory(SubDir,NULL);

	// Übertragen in Supress-Verzeichnis
	_tcscpy(SupressSubDir,SubDir);

	return CopyDirectory(DirToCopy,SubDir,SupressSubDir);
	
	return 0;
	
};
Beispiel #8
0
bool GalleryUtil::Copy(const QFileInfo &src, QFileInfo &dst)
{
    if (src.isDir())
        return CopyDirectory(src, dst);

    dst = MakeUnique(dst);

    if (!FileCopy(src, dst))
        return false;

    MSqlQuery query(MSqlQuery::InitCon());
    query.prepare("INSERT INTO gallerymetadata (image, angle) "
                  "SELECT :IMAGENEW , angle "
                  "FROM gallerymetadata "
                  "WHERE image = :IMAGEOLD");
    query.bindValue(":IMAGENEW", dst.absoluteFilePath());
    query.bindValue(":IMAGEOLD", src.absoluteFilePath());
    if (query.exec())
        return true;

    // try to undo copy on DB failure
    FileDelete(dst);
    return false;
}
Beispiel #9
0
int CopyDirectory(const char *src_path, const char *dest_path, int verbose) {
	
	file_t fd = fs_open(src_path, O_RDONLY | O_DIR);

	if(fd != FILEHND_INVALID) {
		
		char Path[MAX_FN_LEN], *EndPtr = Path;
		char PathDest[MAX_FN_LEN], *EndDestPtr = PathDest;
		dirent_t *e;
		
		strcpy(Path, src_path);
		Path[strlen(src_path)] = '/';
		EndPtr += (strlen(src_path)+1);
		
		strcpy(PathDest, dest_path);
		
		if(!DirExists(PathDest)) {
			
			if(verbose) {
				ds_printf("DS_PROCESS: Making directory: %s\n", PathDest);
			}
			
			if(fs_mkdir(PathDest)) {
				ds_printf("DS_ERROR: Can't make directory %s\n", PathDest);
				fs_close(fd);
				return 0;
			}
		}
		
		PathDest[strlen(dest_path)] = '/';
		EndDestPtr += (strlen(dest_path)+1);

		while((e = fs_readdir(fd)) != NULL) {

			strcpy(EndPtr, e->name);
			strcpy(EndDestPtr, e->name);
			
			if(e->attr == O_DIR) {
				
				if(verbose) {
					ds_printf("DS_PROCESS: Making directory: %s\n", PathDest);
				}
				
				if(!fs_mkdir(PathDest)) {
					CopyDirectory(Path, PathDest, verbose);
				} else {
					ds_printf("DS_ERROR: Can't make directory %s\n", PathDest);
					fs_close(fd);
					return 0;
				}
			} else {
				if(!CopyFile(Path, PathDest, verbose)) {
					fs_close(fd);
					return 0;
				}
			}
		}
		
		fs_close(fd);
		return 1;
	}
	
	return 0;
}
   bool 
   FileUtilities::CopyDirectory(String sFrom, String sTo, String &errorMessage)
   {
      if (!FileUtilities::Exists(sTo))
      {
         if( !CreateDirectory(sTo))
         {
            errorMessage = Formatter::Format(_T("CreateDirectory {0} failed. See previous error."), sTo);

            ErrorManager::Instance()->ReportError(ErrorManager::Medium, 4234, "File::CopyDirectory", errorMessage);
            return false;
         }
      }

      if (sFrom.Right(1) != _T("\\"))
         sFrom += "\\";
      if (sTo.Right(1) != _T("\\"))
         sTo += "\\";

      String sWildCard = sFrom + "*.*";

      // Locate first match
      WIN32_FIND_DATA ffData;
      HANDLE hFileFound = FindFirstFile(sWildCard, &ffData);

      if (hFileFound == INVALID_HANDLE_VALUE)
      {
         errorMessage.Format(_T("Find first file with wildcard %s failed. Error: %d."), sWildCard, GetLastError());
         ErrorManager::Instance()->ReportError(ErrorManager::Medium, 4233, "File::CopyDirectory", errorMessage);
         return false;
      }

      while (hFileFound && FindNextFile(hFileFound, &ffData))
      {
         String sOldFullPath = sFrom + ffData.cFileName;
         String sNewFullPath = sTo + ffData.cFileName;

         if (ffData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) 
         {
            if( (_tcscmp(ffData.cFileName, _T(".")) != 0) &&
               (_tcscmp(ffData.cFileName, _T("..")) != 0) ) 
            {
               if( !CopyDirectory(sOldFullPath, sNewFullPath, errorMessage) )
                  return false;
            }

         }
         else
         { 
            if (FileUtilities::Exists(sNewFullPath))
            {
               // File already exists
               continue;
            }

            if (CopyFile(sOldFullPath, sNewFullPath, TRUE))
            {
               // We have copied the file successfully
               continue;
            }

            // We failed to copy the file. Check if the file no 
            // longer exists
            if (!FileUtilities::Exists(sOldFullPath))
               continue;

            // The file exists , but we were not able to copy it.
            errorMessage.Format(_T("Copy of file from %s to %s failed. Error: %d"), sOldFullPath, sNewFullPath, GetLastError());
            ErrorManager::Instance()->ReportError(ErrorManager::Medium, 4232, "File::CopyDirectory", errorMessage);
            return false;
         }
      }

      FindClose(hFileFound);

      return true;
   }
Beispiel #11
0
BOOL
CopyDirectory (LPCWSTR lpDestinationPath,
	       LPCWSTR lpSourcePath)
{
  WCHAR szFileName[MAX_PATH];
  WCHAR szFullSrcName[MAX_PATH];
  WCHAR szFullDstName[MAX_PATH];
  WIN32_FIND_DATAW FindFileData;
  LPWSTR lpSrcPtr;
  LPWSTR lpDstPtr;
  HANDLE hFind;

  DPRINT ("CopyDirectory (%S, %S) called\n",
	  lpDestinationPath, lpSourcePath);

  wcscpy (szFileName, lpSourcePath);
  wcscat (szFileName, L"\\*.*");

  hFind = FindFirstFileW (szFileName,
			  &FindFileData);
  if (hFind == INVALID_HANDLE_VALUE)
    {
      DPRINT1 ("Error: %lu\n", GetLastError());
      return FALSE;
    }

  wcscpy (szFullSrcName, lpSourcePath);
  lpSrcPtr = AppendBackslash (szFullSrcName);

  wcscpy (szFullDstName, lpDestinationPath);
  lpDstPtr = AppendBackslash (szFullDstName);

  for (;;)
    {
      if (wcscmp (FindFileData.cFileName, L".") &&
	  wcscmp (FindFileData.cFileName, L".."))
	{
	  wcscpy (lpSrcPtr, FindFileData.cFileName);
	  wcscpy (lpDstPtr, FindFileData.cFileName);

	  if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
	    {
	      DPRINT ("Create directory: %S\n", szFullDstName);
	      if (!CreateDirectoryExW (szFullSrcName, szFullDstName, NULL))
		{
		  if (GetLastError () != ERROR_ALREADY_EXISTS)
		    {
		      DPRINT1 ("Error: %lu\n", GetLastError());

		      FindClose (hFind);
		      return FALSE;
		    }
		}

	      if (!CopyDirectory (szFullDstName, szFullSrcName))
		{
		  DPRINT1 ("Error: %lu\n", GetLastError());

		  FindClose (hFind);
		  return FALSE;
		}
	    }
	  else
	    {
	      DPRINT ("Copy file: %S -> %S\n", szFullSrcName, szFullDstName);
	      if (!CopyFileW (szFullSrcName, szFullDstName, FALSE))
		{
		  DPRINT1 ("Error: %lu\n", GetLastError());

		  FindClose (hFind);
		  return FALSE;
		}
	    }
	}

      if (!FindNextFileW (hFind, &FindFileData))
	{
	  if (GetLastError () != ERROR_NO_MORE_FILES)
	    {
	      DPRINT1 ("Error: %lu\n", GetLastError());
	    }

	  break;
	}
    }

  FindClose (hFind);

  DPRINT ("CopyDirectory() done\n");

  return TRUE;
}
DWORD CopyDirectory(TCHAR* sourcepath, TCHAR* destpath, TCHAR* supresspath)
{
	WIN32_FIND_DATA		FindData;
	TCHAR				SearchName[MAX_PATH+1];
	HANDLE				SearchHandle = INVALID_HANDLE_VALUE;


	typedef queue<FILENAME_PAIR*> FILENAME_QUEUE;

	FILENAME_QUEUE		CopyfileQueue;

	memset(&FindData,0,sizeof(FindData));
	memset(SearchName,0,sizeof(SearchName));

	// Testen: ist das Verzeichnis identisch oder "länger" als supresspath?
	// Wenn ja kann an dieser Stelle aufgegeben werden.
	if((supresspath)&&(_tcsnicmp(sourcepath,supresspath,_tcslen(supresspath))==0))
		return 0;

	_tcsncat(SearchName,sourcepath,MAX_PATH);
	_tcsncat(SearchName,"*.*",MAX_PATH);

	SearchHandle = FindFirstFile(SearchName,&FindData);
	// Nicht erfolgreich?
	if(SearchHandle==INVALID_HANDLE_VALUE) return 0;
	BOOLEAN bFileFound = TRUE;
	while(bFileFound)
	{
		// Stelle fest: Ist es eine Datei oder ein Verzeichnis?
		if(FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
		{
			// Ausfiltern von "." und ".." Verzeichnissen
			if(!((_tcsicmp(FindData.cFileName,".")==0)||(_tcsicmp(FindData.cFileName,"..")==0)))
			{	
				// Es ist ein Verzeichnis. Dieses muß rekursiv bearbeitet werden. 
				TCHAR SubdirSourceName[MAX_PATH+1];
				TCHAR SubdirDestName[MAX_PATH+1];
				_snprintf(SubdirSourceName,MAX_PATH,"%s%s\\",sourcepath,FindData.cFileName);
				_snprintf(SubdirDestName,MAX_PATH,"%s%s\\",destpath,FindData.cFileName);
				// Erzeugen des Unterverzeichnisses
				CreateDirectory(SubdirDestName,NULL);
				CopyDirectory(SubdirSourceName,SubdirDestName,supresspath);
			};
		}
		else
		{
			// Kopieren der Datei
//			TCHAR SourceFileName[MAX_PATH+1];
//			TCHAR DestFileName[MAX_PATH+1];
//			_snprintf(SourceFileName,MAX_PATH,"%s%s",sourcepath,FindData.cFileName);
//			_snprintf(DestFileName,MAX_PATH,"%s%s",destpath,FindData.cFileName);
			FILENAME_PAIR* fp = new FILENAME_PAIR;
			_snprintf(fp->Source,MAX_PATH,"%s%s",sourcepath,FindData.cFileName);
			_snprintf(fp->Dest,MAX_PATH,"%s%s",destpath,FindData.cFileName);
			CopyfileQueue.push(fp);
//			DWORD dwErg = CopyFile(SourceFileName,DestFileName,FALSE);
//			if(dwErg==0)
//				DWORD dwError = GetLastError();
		};
		
		// Nächste Datei suchen
		bFileFound = FindNextFile(SearchHandle,&FindData);
	};




	// Aufräumen
	if(SearchHandle!=INVALID_HANDLE_VALUE) FindClose(SearchHandle);

	while(!CopyfileQueue.empty())
	{
		FILENAME_PAIR* fp = CopyfileQueue.front();
		CopyfileQueue.pop();
		if(fp) 
		{
			DWORD dwErg = CopyFile(fp->Source,fp->Dest,FALSE);
			if(dwErg==0)
				DWORD dwError = GetLastError();
			delete fp;
		};
	};


	return 0;
};
Beispiel #13
0
bool ProjectGenerator::Make()
{
  NGL_OUT(_T("nui project generator\n"));
  

  // create target directory
  nglPath targetpath = nglPath(mProjectTargetPath);
  if (!targetpath.Create())
  {
    nglString msg;
    msg.Format(_T("creating target directory '%ls'"), targetpath.GetChars());
    return MsgError(msg);
  }

  NGL_OUT(_T("nui project generator : target directory created '%ls'\n"), targetpath.GetChars());

    
  //copy the src folder 
  if (!CopyDirectory(targetpath + nglPath(_T("src")), mNuiTemplatePath + nglPath(_T("src"))))
    return false;
  

  //copy the resources folders
  if (!CopyDirectory(targetpath + nglPath(_T("resources")), mNuiTemplatePath + nglPath(_T("resources"))))
    return false;
  if (!CopyDirectory(targetpath + nglPath(_T("resources/css")), mNuiTemplatePath + nglPath(_T("resources/css"))))
    return false;
  if (!CopyDirectory(targetpath + nglPath(_T("resources/decorations")), mNuiTemplatePath + nglPath(_T("resources/decorations"))))
    return false;

  
  nglPath projpath;
  nglPath projectfile;
  nglString filename;
  
  // create xcodeproj folder
  if (mpCheckXcode->IsPressed())
  {
    projpath = targetpath;
    nglString projfolder = mProjectName + nglString(_T(".xcodeproj"));
    projpath += nglPath(projfolder);
    if (!projpath.Create())
    {
      nglString msg;
      msg.Format(_T("creating xcodeproj folder '%ls'"), projpath.GetChars());
      return MsgError(msg);
    }
      
    NGL_OUT(_T("nui project generator : project folder created '%ls'\n"), projpath.GetChars());

  
    // generate xcode project file
    projectfile = targetpath;
    projectfile += nglPath(projfolder);
    projectfile += nglPath(_T("project.pbxproj"));
    if (!GenerateFile(mNuiTemplatePath + nglPath(_T("TemplateApp.xcodeproj/project.pbxproj")), projectfile))
      return false;
    
  }

  
  // generate visual studio 2008 project file
  if (mpCheckVisualStudio2008->IsPressed())
  {
    filename = mProjectName + nglString(_T(".2008.vcproj"));
    projectfile = targetpath;
    projectfile += nglPath(filename);
    if (!GenerateFile(mNuiTemplatePath + nglPath(_T("TemplateApp.2008.vcproj")), projectfile))
      return false;
  }
  
  // generate visual studio 2008 solution file
  if (mpCheckVisualStudio2008->IsPressed())
  {
    filename = mProjectName + nglString(_T(".2008.sln"));
    projectfile = targetpath;
    projectfile += nglPath(filename);
    if (!GenerateFile(mNuiTemplatePath + nglPath(_T("TemplateApp.2008.sln")), projectfile))
      return false;
  }
  
  
  
  // generate Info.plist
  if (mpCheckXcode->IsPressed())
  {
    filename = mProjectName + nglString(_T(".plist"));
    projectfile = targetpath;
    projectfile += nglPath(filename);
    if (!GenerateFile(mNuiTemplatePath + nglPath(_T("TemplateApp.plist")), projectfile))
      return false;
  }

  // generate iPhone Info.plist
  if (mpCheckXcode->IsPressed())
  {
    filename = mProjectName + nglString(_T("-iPhone.plist"));
    projectfile = targetpath;
    projectfile += nglPath(filename);
    if (!GenerateFile(mNuiTemplatePath + nglPath(_T("TemplateApp-iPhone.plist")), projectfile))
      return false;
  }
  
  
  
  // generate resource.rc
  filename = _T("resource.rc");
  projectfile = targetpath;
  projectfile += nglPath(filename);
  if (!GenerateFile(mNuiTemplatePath + nglPath(_T("resource.rc")), projectfile))
    return false;
   

  nglString msg;
  msg.Format(_T("nui project '%ls' successfully generated!"), mProjectName.GetChars());
  nuiMessageBox* pMessageBox = new nuiMessageBox(GetMainWindow(), nglString(_T("Project Creator")), msg, eMB_OK);
  pMessageBox->QueryUser();      
  
  return true;
  
  
}
int WiiSave::Download(std::string ID)
{
	if(ID.empty())
		return -1;
	
	//! Check Network
	if (!IsNetworkInit())
	{
		ManageProgressStop();
		
		ManageButtons * connect = new ManageButtons(tr("No network connection"),
													tr("Do you want to connect?"),
													tr("Yes"),
													tr("Cancel"));
		
		connect->SetAlignment(ALIGN_CENTRE, ALIGN_MIDDLE);
		connect->SetPosition(-6, 75);
		connect->SetEffect(EFFECT_FADE, 20);
		mainWindow->Append(connect);
		ResumeGui();
		
		while (connect->GetEffect()) usleep(50);
		
		while(!connect->GetChoice()) usleep(50);
		
		connect->SetEffect(EFFECT_FADE, -20);
		
		while (connect->GetEffect()) usleep(50);
		
		HaltGui();
		
		mainWindow->Remove(connect);
		
		ResumeGui();
		
		if(connect->GetChoice() == 1)
		{
			StartManageProgress(tr("Initializing Network"));
			
			Initialize_Network();
			
			ManageProgressStop();
		}
		
		delete connect;
		
		if (!IsNetworkInit())
			return -2;
		
		StartManageProgress(tr("Downloading saveslist:"), "www.wiisave.com");
	}

	//! Generate gameUrl
	std:: string WiiSaveListURL("http://wiisave.com/savegamecode_xml.php?gamecode=");
	WiiSaveListURL += ID.substr(0, 3);
	
	//! Check Connection
	if(!CheckConnection(WiiSaveListURL.c_str()))
	{
		ManageProgressStop();
		return -3;
	}
	
	//! Check Region
	std::string Region;
	switch (ID[3])
	{
		case 'E':
			Region = "E - USA / Canada";
			break;
		case 'J':
			Region = "J - Japanese";
			break;
		case 'W':
			Region = "J - Japanese";//Region = "NTSC T";
			break;
		case 'K':
			Region = "J - Japanese";//Region = "NTSC K";
			break;
		default:
		case 'P':
		case 'D':
		case 'F':
		case 'I':
		case 'S':
		case 'H':
		case 'U':
		case 'X':
		case 'Y':
		case 'Z':
			Region = "P - European / Other / PAL";
			break;
	}
	
	//! Get list
	WiiSave_List * SaveList = new WiiSave_List(WiiSaveListURL.c_str());

	ManageProgressStop();
	
	if (!SaveList->GetCount())
	{
		delete SaveList;
		return -4;
	}
	
	if (!SaveList->FilterList(Region))
	{
		delete SaveList;
		return -5;
	}
	
	//! open browser & select save
	WiiSaveBrowser * SaveBrowser = new WiiSaveBrowser(SaveList);
	mainWindow->Append(SaveBrowser);
	
	SaveBrowser->Show();
	
	int selected = SaveBrowser->GetSelectedSave();
	delete SaveBrowser;
	
	if (selected < 0)
	{
		delete SaveList;
		return -10;
	}
	
	//! select download destination
	ManageButtons * path = new ManageButtons(tr("Select a target path."),
											 tr("Be carrefull, present files can be overwritten"),
											 tr("OK"));
	
	path->SetAlignment(ALIGN_CENTRE, ALIGN_MIDDLE);
	path->SetPosition(-6, 75);
	path->SetEffect(EFFECT_FADE, 20);
	mainWindow->Append(path);
	ResumeGui();
	while (path->GetEffect()) usleep(50);
	
	while(!path->GetChoice()) usleep(50);
	
	path->SetEffect(EFFECT_FADE, -20);
	
	while (path->GetEffect()) usleep(50);
	
	HaltGui();
	
	mainWindow->Remove(path);
	delete path;
	
	ResumeGui();
	
	if( selectBrowser(Settings.BrowserPath.c_str(), PATH) != 2 )
	{
		delete SaveList;
		return -10;
	}
	
	//! download file
	std::string filepath = Settings.TmpPath;
	filepath += "/";
	filepath += SaveList->GetFilteredFilename(selected);
	
	if( WiiSave::InternalDownload(SaveList->GetFilteredDownloadLink(selected), filepath) < 0)
	{
		delete SaveList;
		return -6;
	}
	
	delete SaveList;
	
	//! check file type
	char destID[5];
	std::string srcfilepath;
	bool isSgmgxSave = false;
	bool isDataBin = false;
	
	std::string tmpDest = filepath.substr(0, filepath.rfind("/")+1);
	tmpDest += "tmpExtract";
	
	std::string fileext = filepath.substr(filepath.rfind("."));
	if( !Settings.FileExtensions.CompareArchive(fileext.c_str()) ) //! Archive
	{
		StartManageProgress(tr("Extracting files..."));
		
		//! extract files
		ArchiveHandle * Archive = new ArchiveHandle(filepath.c_str());
		
		Archive->ExtractAll(tmpDest.c_str());
		
		delete Archive;
		RemoveFile(filepath.c_str());
		
		//! check save type
		DirList * dirList = new DirList(tmpDest.c_str(), ".bin" , DirList::Files | DirList::Dirs | DirList::CheckSubfolders);
		
		for(int i = 0; i < dirList->GetFilecount(); i++)
		{
			if(!strcmp(dirList->GetFilename(i), "banner.bin"))
			{
				isSgmgxSave = true;
				srcfilepath = dirList->GetFilepath(i);
				break;
			}
			
			std::string name(dirList->GetFilename(i));
			fileext = name.substr(name.rfind("."));
			if( !Settings.FileExtensions.CompareBinaryFiles(fileext.c_str()) )
			{
				SaveInfos * infos = GetSaveInfos(dirList->GetFilepath(i));
				if(infos)
				{
					isDataBin = true;
					srcfilepath = dirList->GetFilepath(i);
					memcpy(destID, infos->ID, 5);
					delete infos;
					break;
				}
			}
		}
		
		delete dirList;
		
		ManageProgressStop();
	}
	else //! check for data.bin file
	{
		StartManageProgress(tr("Verifying file..."));
		
		SaveInfos * infos = GetSaveInfos(filepath);
		if(infos)
		{
			isDataBin = true;
			srcfilepath = filepath;
			memcpy(destID, infos->ID, 5);
			delete infos;
		}
		
		ManageProgressStop();
	}
	
	if(!isDataBin && !isSgmgxSave) //! supported files not found
	{
		RemoveFile(filepath.c_str());
		RemoveDirectory(tmpDest.c_str());
		return -7;
	}
	
	//! write files
	StartManageProgress(tr("Writing files..."));
	if(isSgmgxSave)
	{
		std::string srcfolder = srcfilepath.substr(0, srcfilepath.rfind("/"));
		
		DirList * dirList = new DirList(srcfolder.c_str(), NULL , DirList::Files | DirList::Dirs);
		
		srcfolder = srcfolder.substr(srcfolder.rfind("/"));
		std::string finaldest = Settings.TmpPath;
		finaldest += srcfolder;
		
		CreateSubfolder(finaldest.c_str());
		
		for(int i = 0; i < dirList->GetFilecount(); i++)
		{
			if(IsDir(i))
				CopyDirectory(dirList->GetFilepath(i), finaldest.c_str());
			else
				CopyFile(dirList->GetFilepath(i),  fmt("%s/%s", finaldest.c_str(), dirList->GetFilename(i)));
		}
		
		delete dirList;
	}
	else if(isDataBin)
	{
		std::string finaldest = Settings.TmpPath;
		finaldest += "/";
		finaldest += destID;
		
		CreateSubfolder(finaldest.c_str());
		
		finaldest += "/data.bin";
		CopyFile(srcfilepath.c_str(), finaldest.c_str());
	}
	
	RemoveFile(filepath.c_str());
	RemoveDirectory(tmpDest.c_str());
	ManageProgressStop();
	
	return 1;
}
Beispiel #15
0
BOOL
WINAPI
CreateUserProfileW(PSID Sid,
                   LPCWSTR lpUserName)
{
    WCHAR szRawProfilesPath[MAX_PATH];
    WCHAR szProfilesPath[MAX_PATH];
    WCHAR szUserProfilePath[MAX_PATH];
    WCHAR szDefaultUserPath[MAX_PATH];
    WCHAR szUserProfileName[MAX_PATH];
    WCHAR szBuffer[MAX_PATH];
    LPWSTR SidString;
    DWORD dwLength;
    DWORD dwDisposition;
    UINT i;
    HKEY hKey;
    BOOL bRet = TRUE;
    LONG Error;

    DPRINT("CreateUserProfileW() called\n");

    Error = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                          L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList",
                          0,
                          KEY_QUERY_VALUE,
                          &hKey);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        SetLastError((DWORD)Error);
        return FALSE;
    }

    /* Get profiles path */
    dwLength = MAX_PATH * sizeof(WCHAR);
    Error = RegQueryValueExW(hKey,
                             L"ProfilesDirectory",
                             NULL,
                             NULL,
                             (LPBYTE)szRawProfilesPath,
                             &dwLength);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        RegCloseKey(hKey);
        SetLastError((DWORD)Error);
        return FALSE;
    }

    /* Expand it */
    if (!ExpandEnvironmentStringsW(szRawProfilesPath,
                                   szProfilesPath,
                                   MAX_PATH))
    {
        DPRINT1("Error: %lu\n", GetLastError());
        RegCloseKey(hKey);
        return FALSE;
    }

    /* create the profiles directory if it does not yet exist */
    if (!CreateDirectoryW(szProfilesPath, NULL))
    {
        if (GetLastError() != ERROR_ALREADY_EXISTS)
        {
            DPRINT1("Error: %lu\n", GetLastError());
            return FALSE;
        }
    }

    /* Get default user path */
    dwLength = MAX_PATH * sizeof(WCHAR);
    Error = RegQueryValueExW(hKey,
                             L"DefaultUserProfile",
                             NULL,
                             NULL,
                             (LPBYTE)szBuffer,
                             &dwLength);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        RegCloseKey(hKey);
        SetLastError((DWORD)Error);
        return FALSE;
    }

    RegCloseKey (hKey);

    wcscpy(szUserProfileName, lpUserName);

    wcscpy(szUserProfilePath, szProfilesPath);
    wcscat(szUserProfilePath, L"\\");
    wcscat(szUserProfilePath, szUserProfileName);

    wcscpy(szDefaultUserPath, szProfilesPath);
    wcscat(szDefaultUserPath, L"\\");
    wcscat(szDefaultUserPath, szBuffer);

    /* Create user profile directory */
    if (!CreateDirectoryW(szUserProfilePath, NULL))
    {
        if (GetLastError() != ERROR_ALREADY_EXISTS)
        {
            DPRINT1("Error: %lu\n", GetLastError());
            return FALSE;
        }

        for (i = 0; i < 1000; i++)
        {
            swprintf(szUserProfileName, L"%s.%03u", lpUserName, i);

            wcscpy(szUserProfilePath, szProfilesPath);
            wcscat(szUserProfilePath, L"\\");
            wcscat(szUserProfilePath, szUserProfileName);

            if (CreateDirectoryW(szUserProfilePath, NULL))
                break;

            if (GetLastError() != ERROR_ALREADY_EXISTS)
            {
                DPRINT1("Error: %lu\n", GetLastError());
                return FALSE;
            }
        }
    }

    /* Copy default user directory */
    if (!CopyDirectory(szUserProfilePath, szDefaultUserPath))
    {
        DPRINT1("Error: %lu\n", GetLastError());
        return FALSE;
    }

    /* Add profile to profile list */
    if (!ConvertSidToStringSidW(Sid,
                                &SidString))
    {
        DPRINT1("Error: %lu\n", GetLastError());
        return FALSE;
    }

    wcscpy(szBuffer,
           L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\");
    wcscat(szBuffer, SidString);

    /* Create user profile key */
    Error = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
                            szBuffer,
                            0,
                            NULL,
                            REG_OPTION_NON_VOLATILE,
                            KEY_ALL_ACCESS,
                            NULL,
                            &hKey,
                            &dwDisposition);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        bRet = FALSE;
        goto Done;
    }

    /* Create non-expanded user profile path */
    wcscpy(szBuffer, szRawProfilesPath);
    wcscat(szBuffer, L"\\");
    wcscat(szBuffer, szUserProfileName);

    /* Set 'ProfileImagePath' value (non-expanded) */
    Error = RegSetValueExW(hKey,
                           L"ProfileImagePath",
                           0,
                           REG_EXPAND_SZ,
                           (LPBYTE)szBuffer,
                           (wcslen (szBuffer) + 1) * sizeof(WCHAR));
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        RegCloseKey(hKey);
        bRet = FALSE;
        goto Done;
    }

    /* Set 'Sid' value */
    Error = RegSetValueExW(hKey,
                           L"Sid",
                           0,
                           REG_BINARY,
                           Sid,
                           GetLengthSid(Sid));
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        RegCloseKey(hKey);
        bRet = FALSE;
        goto Done;
    }

    RegCloseKey(hKey);

    /* Create user hive name */
    wcscpy(szBuffer, szUserProfilePath);
    wcscat(szBuffer, L"\\ntuser.dat");

    /* Acquire restore privilege */
    if (!AcquireRemoveRestorePrivilege(TRUE))
    {
        Error = GetLastError();
        DPRINT1("Error: %lu\n", Error);
        bRet = FALSE;
        goto Done;
    }

    /* Create new user hive */
    Error = RegLoadKeyW(HKEY_USERS,
                        SidString,
                        szBuffer);
    AcquireRemoveRestorePrivilege(FALSE);
    if (Error != ERROR_SUCCESS)
    {
        DPRINT1("Error: %lu\n", Error);
        bRet = FALSE;
        goto Done;
    }

    /* Initialize user hive */
    if (!CreateUserHive(SidString, szUserProfilePath))
    {
        Error = GetLastError();
        DPRINT1("Error: %lu\n", Error);
        bRet = FALSE;
    }

    /* Unload the hive */
    AcquireRemoveRestorePrivilege(TRUE);
    RegUnLoadKeyW(HKEY_USERS, SidString);
    AcquireRemoveRestorePrivilege(FALSE);

Done:
    LocalFree((HLOCAL)SidString);
    SetLastError((DWORD)Error);

    DPRINT("CreateUserProfileW() done\n");

    return bRet;
}
//  27-Aug-2004 SFK		Created
void CopyLogsMenuOption()
{                                 

    static char szDfltRootPath[PATH_LEN+1] = "";
    static char szDfltCurrentDbPath[PATH_LEN+1] = "";                   
    static BOOL bFirst = TRUE;
    
	char szCurrentDbPath[PATH_LEN+1] = "";    
	char szMainCurrentDbPath[PATH_LEN+1] = "";    
    char szRootBackupPath[PATH_LEN+1] = "";
	char szMainBackupPath[PATH_LEN+1] = "";
    unsigned long ulDirSize, ulDiskSize, ulDiskAvailable;
    BOOL bRoom;     
    int status;
    char *pStr;

    
    GUI_ACTION DlgReturn;         
    CGFmtStr msg;

	SetCurrentDrive();    
    GetDbName(szCurrentDbPath);
    
   /* ------------------------------------------------------------------
    *	First time or when change databases, get the default values
    *	from the .ini file else use the last successful values.
    * ------------------------------------------------------------------*/
    if ((bFirst == TRUE) || (!SameDb(szDfltCurrentDbPath))) {
    	pStr = pRAD_Init->Get_LogCopy_To_Path(); 
		MyStrnCpy(szDfltRootPath, pStr, PATH_LEN); 
   		bFirst = FALSE;
    	strcpy(szDfltCurrentDbPath, szCurrentDbPath);
	}
	
	strcpy(szRootBackupPath, szDfltRootPath);

   /* ------------------------------------------------------------------
    *	Define the buttons and actions in the dialog box
    * ----------------------------------------------------------------*/
    CGUI_Dlg BackupDbDlg(IDD_FILE_COPY_LOGS, NULL, DLG_POSN_NO_SAVE);
    if (BackupDbDlg.IsValid()) {
		BackupDbDlg.DefinePushBtn(IDCANCEL, GUI_CANCEL);
		BackupDbDlg.DefinePushBtn(IDOK, GUI_OK);
		BackupDbDlg.DefinePushBtn(IDUPDATE, GUI_NONE, UpdateINI_Parms);              
			                                               
		BackupDbDlg.DefineFldTxt(IDC_CLOG_EDIT_NEW_PATH, szRootBackupPath, PATH_LEN);
			
		BackupDbDlg.SetFocus(IDOK);
		
	    DlgReturn = BackupDbDlg.Go();
		    
	    if (DlgReturn == GUI_OK) {  
		    	
	    	BackupDbDlg.RetrieveAllControlValues();

		   /* ------------------------------------------------------------------
		    *	Remove spaces, check length
		    * ----------------------------------------------------------------*/
	    	if (PathCopy(szMainBackupPath, szRootBackupPath) != TRUE) return;
	    	strcat(szMainBackupPath, "logs\\rad\\");

	    	if (PathCopy(szMainCurrentDbPath, szCurrentDbPath) != TRUE) return;
	    	strcat(szMainCurrentDbPath, "logs\\rad\\");

		   /* ------------------------------------------------------------------
		    *	See if the new path exists, if not make it.  If can't make it give
		    *	reason why.
		    * ----------------------------------------------------------------*/
		    status = PathExists(szMainBackupPath); // returns TRUE, uiPATH_TOO_LONG_ERR, uiDRIVE_DOES_NOT_EXIST_ERR oruiPATH_DOES_NOT_EXIST_ERR
		    if ( status == uiPATH_DOES_NOT_EXIST_ERR) {
		    	status = AskAndMakePath(szMainBackupPath);
		    	if (status != TRUE) return;
		    }	
		    if ( status != TRUE) {
		    	RadReviewMsg(status, (const char *)szMainBackupPath);
				return;
			}	

		   /* ------------------------------------------------------------------
		    *	See if a log file exists at the location specified.  If yes,
		    *	see if they want to overwrite it.
		    * ----------------------------------------------------------------*/
		    if (FileExists(szMainBackupPath, "RadReviewLog.txt") == TRUE) {
		    	status = AskOverwriteQuestion(szMainBackupPath);
		    	if (status == FALSE) return;
		    }	
		    
		   /* ------------------------------------------------------------------
		    *	Figure out how many bytes will need to be copied and if there
		    *	is room on the destination drive.  (Destination drive must have
		    *	directory size + 10000 to allow for directory entries, etc.)
		    * ----------------------------------------------------------------*/
		    if (GetDirSize(szMainCurrentDbPath, "*.*", &ulDirSize) != TRUE) return;	/* check number of bytes filled in szCurrentDbPath */
			
			// Customize for COMs, if don't write to this log directory

		    if (GetDriveSize(szMainBackupPath, &ulDiskSize, &ulDiskAvailable) != TRUE) return;	/* check number of bytes available on drive */
			
			bRoom = TRUE;
			if ((ulDirSize + 10000) > ulDiskAvailable) bRoom = FALSE;	    
		    	    
		    if (bRoom == FALSE) {
		    	if (AskNotEnoughRoomQuestion(ulDirSize, ulDiskAvailable, szMainBackupPath) == FALSE) return;
		    }
		    
		   /* ------------------------------------------------------------------
		    *	Close the current database in case are trying to copy it.
		    *	Copy the data and show progress. Inform of the results of the copy.	
		    * ----------------------------------------------------------------*/
		    GetDbName(szCurrentDbPath);
			_flushall();
			    
		    status = CopyDirectory(szMainCurrentDbPath, szMainBackupPath);

			// Customize for COMs, if don't write to this log directory

		    if (status != TRUE) { 
		    	RadReviewMsg(uiCOPY_DB_ERR, (const char *)szCurrentDbPath, (const char *)szRootBackupPath);
		    }
		    else {	
		    	MyStrnCpy(szDfltRootPath,szRootBackupPath, PATH_LEN);	// remember the default for next time
				msg.Printf("Logs copied to %s.", szRootBackupPath);	
			    GUI_MsgBox(msg, GUI_ICON_INFO);
		    }	

	    }	
	}    
}   		                                 
void GenesisCopyWindow::CopyDirectory(const char *dirname, const char *destination, const char *destdirname)
////////////////////////////////////////////////////////////////////////
{
	BEntry srcentry(dirname);
	BEntry dstentry;
	char name[B_FILE_NAME_LENGTH];
	BString fulldestdir;
	
	if (srcentry.InitCheck()!=B_OK)
		return;
		
	if (!srcentry.Exists())
		return;
		
	srcentry.GetName(name);	
	
	fulldestdir.SetTo(destination);
	if (destdirname)
		fulldestdir << "/" << destdirname;
	else
		fulldestdir << "/" << name;

	dstentry.SetTo(fulldestdir.String());
	
	if (dstentry.InitCheck()!=B_OK)
		return;
		
	if (!dstentry.Exists())
	{
		if (create_directory(fulldestdir.String(), 0777)!=B_OK)		// TODO: jo a 0777?
			return;
	}

	BDirectory dir;
	
	dir.SetTo(dirname);
	if (dir.InitCheck()==B_OK)
	{
		BEntry entry;
		
		if (dir.GetEntry(&entry)==B_OK)
		{	
			while (dir.GetNextEntry(&entry)==B_OK)			
			{
				entry.GetName(name);
								
				if (entry.IsDirectory())
				{
					BString fullname;
					
					fullname.SetTo(dirname);
					fullname << "/" << name;
					CopyDirectory(fullname.String(), fulldestdir.String());
				}
				else if (entry.IsSymLink())
				{
					BString fullname;
					
					fullname.SetTo(dirname);
					fullname << "/" << name;
					CopyLink(fullname.String(), fulldestdir.String());
				}
				else 
				{
					BString fullname;
					
					fullname.SetTo(dirname);
					fullname << "/" << name;
					CopyFile(fullname.String(), fulldestdir.String());
				}
			}
		}
	}

	// Copy attributes...
	CopyAttr(dirname, fulldestdir.String());
}