usbloadergx/source/FileOperations/fileops.cpp
cyan06 83e3aa545c * Fixed custom banner download issue introduced in r1259.
* Fixed spelling mistake in image download function.
* Reverted HTTP to non SSL revision (r1252).
* Removed Nintendont internal update feature (requires SSL).
* Added batch wad (un)install from a folder.
* Changed the wad install menu interface.
* Added an option to the wad class to display or hide errors on wad install.
* Fixed RemoveDirectory return value.
* Added game type and console name in exported game list. (requested)

* Updated French language
2016-01-02 16:23:01 +00:00

604 lines
13 KiB
C++

/***************************************************************************
* Copyright (C) 2009
* by Dimok
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any
* damages arising from the use of this software.
*
* Permission is granted to anyone to use this software for any
* purpose, including commercial applications, and to alter it and
* redistribute it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you
* must not claim that you wrote the original software. If you use
* this software in a product, an acknowledgment in the product
* documentation would be appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and
* must not be misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*
* fileops.cpp
* File operations for the WiiXplorer
* Handling all the needed file operations
***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <gccore.h>
#include <sys/dir.h>
#include <dirent.h>
#include <unistd.h>
#include <vector>
#include "prompts/ProgressWindow.h"
#include "language/gettext.h"
#include "DirList.h"
#include "fileops.h"
#include "gecko.h"
#define BLOCKSIZE 70*1024 //70KB
#define VectorResize(List) if(List.capacity()-List.size() == 0) List.reserve(List.size()+100)
static bool actioncanceled = false;
/****************************************************************************
* CheckFile
*
* Check if file is existing
***************************************************************************/
extern "C" bool CheckFile(const char * filepath)
{
if(!filepath)
return false;
struct stat filestat;
char dirnoslash[strlen(filepath)+2];
snprintf(dirnoslash, sizeof(dirnoslash), "%s", filepath);
while(dirnoslash[strlen(dirnoslash)-1] == '/')
dirnoslash[strlen(dirnoslash)-1] = '\0';
char * notRoot = strrchr(dirnoslash, '/');
if(!notRoot)
{
strcat(dirnoslash, "/");
}
if (stat(dirnoslash, &filestat) == 0)
return true;
return false;
}
/****************************************************************************
* FileSize
*
* Get filesize in bytes. u64 for files bigger than 4GB
***************************************************************************/
extern "C" u64 FileSize(const char * filepath)
{
struct stat filestat;
if (stat(filepath, &filestat) != 0)
return 0;
return filestat.st_size;
}
/****************************************************************************
* LoadFileToMem
*
* Load up the file into a block of memory
***************************************************************************/
extern "C" int LoadFileToMem(const char *filepath, u8 **inbuffer, u32 *size)
{
int ret = -1;
u64 filesize = FileSize(filepath);
char * filename = strrchr(filepath, '/');
if(filename)
filename++;
*inbuffer = NULL;
*size = 0;
FILE *file = fopen(filepath, "rb");
if (file == NULL)
return -1;
u8 *buffer = (u8 *) malloc(filesize);
if (buffer == NULL)
{
fclose(file);
return -2;
}
u64 done = 0;
u32 blocksize = BLOCKSIZE;
do
{
if(actioncanceled)
{
free(buffer);
fclose(file);
return PROGRESS_CANCELED;
}
if(blocksize > filesize-done)
blocksize = filesize-done;
ret = fread(buffer+done, 1, blocksize, file);
if(ret < 0)
{
free(buffer);
fclose(file);
return -3;
}
else if(ret == 0)
{
//we are done
break;
}
done += ret;
}
while(done < filesize);
fclose(file);
if (done != filesize)
{
free(buffer);
return -3;
}
*inbuffer = buffer;
*size = filesize;
return 1;
}
/****************************************************************************
* LoadFileToMemWithProgress
*
* Load up the file into a block of memory, while showing a progress dialog
***************************************************************************/
extern "C" int LoadFileToMemWithProgress(const char *progressText, const char *filepath, u8 **inbuffer, u32 *size)
{
int ret = LoadFileToMem(filepath, inbuffer, size);
return ret;
}
/****************************************************************************
* CreateSubfolder
*
* Create recursive all subfolders to the given path
***************************************************************************/
extern "C" bool CreateSubfolder(const char * fullpath)
{
if(!fullpath)
return false;
bool result = false;
char dirnoslash[strlen(fullpath)+1];
strcpy(dirnoslash, fullpath);
int pos = strlen(dirnoslash)-1;
while(dirnoslash[pos] == '/')
{
dirnoslash[pos] = '\0';
pos--;
}
if(CheckFile(dirnoslash))
{
return true;
}
else
{
char parentpath[strlen(dirnoslash)+2];
strcpy(parentpath, dirnoslash);
char * ptr = strrchr(parentpath, '/');
if(!ptr)
{
//!Device root directory (must be with '/')
strcat(parentpath, "/");
struct stat filestat;
if (stat(parentpath, &filestat) == 0)
return true;
return false;
}
ptr++;
ptr[0] = '\0';
result = CreateSubfolder(parentpath);
}
if(!result)
return false;
if (mkdir(dirnoslash, 0777) == -1)
{
return false;
}
return true;
}
/****************************************************************************
* CompareDevices
*
* Compare if its the devices are equal
***************************************************************************/
static bool CompareDevices(const char *src, const char *dest)
{
if(!src || !dest)
return false;
char *device1 = strchr(src, ':');
char *device2 = strchr(dest, ':');
if(!device1 || !device2)
return false;
int position1 = device1-src+1;
int position2 = device2-dest+1;
char temp1[50];
char temp2[50];
snprintf(temp1, position1, "%s", src);
snprintf(temp2, position2, "%s", dest);
if(strcasecmp(temp1, temp2) == 0)
return true;
return false;
}
/****************************************************************************
* CopyFile
*
* Copy the file from source filepath to destination filepath
***************************************************************************/
extern "C" int CopyFile(const char * src, const char * dest)
{
int read = 1;
int wrote = 1;
char * filename = strrchr(src, '/');
if(filename)
filename++;
else
return -1;
u64 sizesrc = FileSize(src);
FILE * source = fopen(src, "rb");
if(!source)
return -2;
u32 blksize = BLOCKSIZE;
u8 * buffer = (u8 *) malloc(blksize);
if(buffer == NULL){
//no memory
fclose(source);
return -1;
}
FILE * destination = fopen(dest, "wb");
if(destination == NULL)
{
free(buffer);
fclose(source);
return -3;
}
u64 done = 0;
do
{
if(ProgressCanceled())
{
fclose(source);
fclose(destination);
free(buffer);
RemoveFile((char *) dest);
return PROGRESS_CANCELED;
}
ShowProgress(done, sizesrc);
if(blksize > sizesrc - done)
blksize = sizesrc - done;
//Display progress
read = fread(buffer, 1, blksize, source);
if(read < 0)
{
fclose(source);
fclose(destination);
free(buffer);
RemoveFile((char *) dest);
return -3;
}
wrote = fwrite(buffer, 1, read, destination);
if(wrote < 0)
{
fclose(source);
fclose(destination);
free(buffer);
RemoveFile((char *) dest);
return -3;
}
done += wrote;
}
while (read > 0);
ProgressStop();
free(buffer);
fclose(source);
fclose(destination);
if(sizesrc != done)
return -4;
return 1;
}
/****************************************************************************
* MoveFile
*
* Move a file from srcpath to destdir
***************************************************************************/
extern "C" int MoveFile(const char *srcpath, char *destdir)
{
if(CompareDevices(srcpath, destdir))
{
if(RenameFile(srcpath, destdir))
return 1;
else
return -1;
}
int res = CopyFile(srcpath, destdir);
if(res < 0)
return -1;
if(RemoveFile(srcpath))
return 1;
return -1;
}
/****************************************************************************
* RemoveFile
*
* Delete the file from a given filepath
***************************************************************************/
extern "C" bool RemoveFile(const char * filepath)
{
return (remove(filepath) == 0);
}
/****************************************************************************
* RenameFile
*
* Rename the file from a given srcpath to a given destpath
***************************************************************************/
extern "C" bool RenameFile(const char * srcpath, const char * destpath)
{
return (rename(srcpath, destpath) == 0);
}
/****************************************************************************
* RemoveDirectory
***************************************************************************/
extern "C" bool RemoveDirectory(const char *path)
{
std::string folderpath = path;
while(folderpath[folderpath.size()-1] == '/')
folderpath.erase(folderpath.size()-1);
bool isRoot = (folderpath.find('/') == std::string::npos);
if(isRoot)
folderpath += '/';
ProgressCancelEnable(true);
StartProgress(tr("Getting file list..."), tr("Please wait"), 0, false, false);
ShowProgress(0, 1);
//! load list not sorted, to remove in correct order
DirList dir;
dir.LoadPath(folderpath.c_str(), 0, DirList::Dirs | DirList::Files | DirList::CheckSubfolders);
int done = 0;
int fileCount = dir.GetFilecount();
//! remove files first
for(int i = 0; i < fileCount; i++)
{
if(!dir.IsDir(i))
{
ShowProgress(tr("Deleting files..."), dir.GetFilename(i), 0, done, fileCount, false, false);
RemoveFile(dir.GetFilepath(i));
done++;
}
}
//! now remove all folders
for(int i = 0; i < fileCount; i++)
{
if(dir.IsDir(i))
{
ShowProgress(tr("Deleting directories..."), dir.GetFilename(i), 0, done, fileCount, false, false);
RemoveFile(dir.GetFilepath(i));
done++;
gprintf("%s\n", dir.GetFilepath(i));
}
}
ProgressStop();
ProgressCancelEnable(false);
return (remove(folderpath.c_str()) == 0);
}
/****************************************************************************
* RemoveDirectory
***************************************************************************/
extern "C" int CopyDirectory(const char *path, const char *dst)
{
if(!path || !dst)
return -1;
ProgressCancelEnable(true);
StartProgress(tr("Getting file list..."), tr("Please wait"), 0, true, true);
ShowProgress(0, 1);
//! load list not sorted as there is no need to
DirList dir;
dir.LoadPath(path, 0, DirList::Dirs | DirList::Files | DirList::CheckSubfolders);
int result = 0;
int fileCount = dir.GetFilecount();
int pathlen = strlen(path);
// we are done
if(fileCount == 0) {
ProgressStop();
ProgressCancelEnable(false);
return 0;
}
u64 totalDone = 0;
u64 totalSize = 0;
for(int i = 0; i < fileCount; i++)
totalSize += dir.GetFilesize(i);
char filepath[1024];
u32 blksize = BLOCKSIZE;
u8 * buffer = (u8 *) malloc(blksize);
if(buffer == NULL){
ProgressStop();
ProgressCancelEnable(false);
return -2;
}
for(int i = 0; i < fileCount; i++)
{
const char *srcPath = dir.GetFilepath(i);
if(!srcPath)
continue;
const char *filename = dir.GetFilename(i);
snprintf(filepath, sizeof(filepath), "%s/%s", dst, srcPath+pathlen);
char *ptr = strrchr(filepath, '/');
if(ptr) *ptr = 0;
//! create path for the file
CreateSubfolder(filepath);
snprintf(filepath, sizeof(filepath), "%s/%s", dst, srcPath+pathlen);
// Start copying file
FILE * source = fopen(srcPath, "rb");
if(!source)
continue;
FILE * destination = fopen(filepath, "wb");
if(destination == NULL)
{
fclose(source);
continue;
}
ShowProgress(tr("Copying files..."), filename, 0, totalDone, totalSize, true, true);
blksize = BLOCKSIZE;
u64 done = 0;
u64 filesize = dir.GetFilesize(i);
while(done < filesize)
{
if(ProgressCanceled())
{
fclose(source);
fclose(destination);
free(buffer);
ProgressStop();
ProgressCancelEnable(false);
return PROGRESS_CANCELED;
}
//Display progress
ShowProgress(totalDone, totalSize);
if(blksize > filesize - done)
blksize = filesize - done;
if(fread(buffer, 1, blksize, source) != blksize)
{
result = -5;
break;
}
if(fwrite(buffer, 1, blksize, destination) != blksize)
{
result = -5;
break;
}
done += blksize;
totalDone += blksize;
}
fclose(source);
fclose(destination);
}
free(buffer);
ProgressStop();
ProgressCancelEnable(false);
return result;
}
u64 GetDirectorySize(const char *path)
{
DirList dir(path, 0, DirList::Files | DirList::CheckSubfolders);
int fileCount = dir.GetFilecount();
u64 totalSize = 0;
for(int i = 0; i < fileCount; i++)
totalSize += dir.GetFilesize(i);
return totalSize;
}