The-Homebrew-Cloud/wiiload_plugin
2
0
Fork 0
mirror of https://github.com/wiiu-env/wiiload_plugin.git synced 2024-11-22 02:29:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

Formatting

Browse Source
This commit is contained in:
Maschell 2020-06-03 19:45:51 +02:00
parent 0d33e1a9b6
commit 80586bb5de
20 changed files with 545 additions and 485 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
src/fs/CFile.cpp
View File

@ -11,12 +11,12 @@ CFile::CFile() {
pos = 0;
}
CFile::CFile(const std::string & filepath, eOpenTypes mode) {
CFile::CFile(const std::string &filepath, eOpenTypes mode) {
iFd = -1;
this->open(filepath, mode);
}
CFile::CFile(const uint8_t * mem, int32_t size) {
CFile::CFile(const uint8_t *mem, int32_t size) {
iFd = -1;
this->open(mem, size);
}
@ -25,7 +25,7 @@ CFile::~CFile() {
this->close();
}
int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
int32_t CFile::open(const std::string &filepath, eOpenTypes mode) {
this->close();
int32_t openMode = 0;
@ -33,20 +33,20 @@ int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
// This depend on the devoptab implementation.
// see https://github.com/devkitPro/wut/blob/master/libraries/wutdevoptab/devoptab_fs_open.c#L21 fpr reference
switch(mode) {
default:
case ReadOnly: // file must exist
openMode = O_RDONLY;
break;
case WriteOnly: // file will be created / zerod
openMode = O_TRUNC | O_CREAT | O_WRONLY;
break;
case ReadWrite: // file must exist
openMode = O_RDWR;
break;
case Append: // append to file, file will be created if missing. write only
openMode = O_CREAT | O_APPEND | O_WRONLY;
break;
switch (mode) {
default:
case ReadOnly: // file must exist
openMode = O_RDONLY;
break;
case WriteOnly: // file will be created / zerod
openMode = O_TRUNC | O_CREAT | O_WRONLY;
break;
case ReadWrite: // file must exist
openMode = O_RDWR;
break;
case Append: // append to file, file will be created if missing. write only
openMode = O_CREAT | O_APPEND | O_WRONLY;
break;
}
//! Using fopen works only on the first launch as expected
@ -54,7 +54,7 @@ int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
//! the .data sections which is needed for a normal application to re-init
//! this will be added with launching as RPX
iFd = ::open(filepath.c_str(), openMode);
if(iFd < 0)
if (iFd < 0)
return iFd;
@ -64,7 +64,7 @@ int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
return 0;
}
int32_t CFile::open(const uint8_t * mem, int32_t size) {
int32_t CFile::open(const uint8_t *mem, int32_t size) {
this->close();
mem_file = mem;
@ -74,7 +74,7 @@ int32_t CFile::open(const uint8_t * mem, int32_t size) {
}
void CFile::close() {
if(iFd >= 0)
if (iFd >= 0)
::close(iFd);
iFd = -1;
@ -83,24 +83,24 @@ void CFile::close() {
pos = 0;
}
int32_t CFile::read(uint8_t * ptr, size_t size) {
if(iFd >= 0) {
int32_t ret = ::read(iFd, ptr,size);
if(ret > 0)
int32_t CFile::read(uint8_t *ptr, size_t size) {
if (iFd >= 0) {
int32_t ret = ::read(iFd, ptr, size);
if (ret > 0)
pos += ret;
return ret;
}
int32_t readsize = size;
if(readsize > (int64_t) (filesize-pos))
readsize = filesize-pos;
if (readsize > (int64_t) (filesize - pos))
readsize = filesize - pos;
if(readsize <= 0)
if (readsize <= 0)
return readsize;
if(mem_file != NULL) {
memcpy(ptr, mem_file+pos, readsize);
if (mem_file != NULL) {
memcpy(ptr, mem_file + pos, readsize);
pos += readsize;
return readsize;
}
@ -108,12 +108,12 @@ int32_t CFile::read(uint8_t * ptr, size_t size) {
return -1;
}
int32_t CFile::write(const uint8_t * ptr, size_t size) {
if(iFd >= 0) {
int32_t CFile::write(const uint8_t *ptr, size_t size) {
if (iFd >= 0) {
size_t done = 0;
while(done < size) {
while (done < size) {
int32_t ret = ::write(iFd, ptr, size - done);
if(ret <= 0)
if (ret <= 0)
return ret;
ptr += ret;
@ -130,25 +130,25 @@ int32_t CFile::seek(long int offset, int32_t origin) {
int32_t ret = 0;
int64_t newPos = pos;
if(origin == SEEK_SET) {
if (origin == SEEK_SET) {
newPos = offset;
} else if(origin == SEEK_CUR) {
} else if (origin == SEEK_CUR) {
newPos += offset;
} else if(origin == SEEK_END) {
newPos = filesize+offset;
} else if (origin == SEEK_END) {
newPos = filesize + offset;
}
if(newPos < 0) {
if (newPos < 0) {
pos = 0;
} else {
pos = newPos;
}
if(iFd >= 0)
if (iFd >= 0)
ret = ::lseek(iFd, pos, SEEK_SET);
if(mem_file != NULL) {
if(pos > filesize) {
if (mem_file != NULL) {
if (pos > filesize) {
pos = filesize;
}
}
@ -163,8 +163,8 @@ int32_t CFile::fwrite(const char *format, ...) {
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
result = this->write((uint8_t *)tmp, strlen(tmp));
if ((vsprintf(tmp, format, va) >= 0)) {
result = this->write((uint8_t *) tmp, strlen(tmp));
}
va_end(va);

28
src/fs/CFile.hpp
View File

@ -18,18 +18,22 @@ public:
};
CFile();
CFile(const std::string & filepath, eOpenTypes mode);
CFile(const uint8_t * memory, int32_t memsize);
CFile(const std::string &filepath, eOpenTypes mode);
CFile(const uint8_t *memory, int32_t memsize);
virtual ~CFile();
int32_t open(const std::string & filepath, eOpenTypes mode);
int32_t open(const uint8_t * memory, int32_t memsize);
int32_t open(const std::string &filepath, eOpenTypes mode);
int32_t open(const uint8_t *memory, int32_t memsize);
BOOL isOpen() const {
if(iFd >= 0)
if (iFd >= 0)
return true;
if(mem_file)
if (mem_file)
return true;
return false;
@ -37,23 +41,29 @@ public:
void close();
int32_t read(uint8_t * ptr, size_t size);
int32_t write(const uint8_t * ptr, size_t size);
int32_t read(uint8_t *ptr, size_t size);
int32_t write(const uint8_t *ptr, size_t size);
int32_t fwrite(const char *format, ...);
int32_t seek(long int offset, int32_t origin);
uint64_t tell() {
return pos;
};
uint64_t size() {
return filesize;
};
void rewind() {
this->seek(0, SEEK_SET);
};
protected:
int32_t iFd;
const uint8_t * mem_file;
const uint8_t *mem_file;
uint64_t filesize;
uint64_t pos;
};

70
src/fs/DirList.cpp
View File

@ -42,7 +42,7 @@ DirList::DirList() {
Depth = 0;
}
DirList::DirList(const std::string & path, const char *filter, uint32_t flags, uint32_t maxDepth) {
DirList::DirList(const std::string &path, const char *filter, uint32_t flags, uint32_t maxDepth) {
this->LoadPath(path, filter, flags, maxDepth);
this->SortList();
}
@ -51,8 +51,8 @@ DirList::~DirList() {
ClearList();
}
BOOL DirList::LoadPath(const std::string & folder, const char *filter, uint32_t flags, uint32_t maxDepth) {
if(folder.empty()) return false;
BOOL DirList::LoadPath(const std::string &folder, const char *filter, uint32_t flags, uint32_t maxDepth) {
if (folder.empty()) return false;
Flags = flags;
Filter = filter;
@ -65,11 +65,11 @@ BOOL DirList::LoadPath(const std::string & folder, const char *filter, uint32_t
StringTools::RemoveDoubleSlashs(folderpath);
//! remove last slash if exists
if(length > 0 && folderpath[length-1] == '/')
folderpath.erase(length-1);
if (length > 0 && folderpath[length - 1] == '/')
folderpath.erase(length - 1);
//! add root slash if missing
if(folderpath.find('/') == std::string::npos) {
if (folderpath.find('/') == std::string::npos) {
folderpath += '/';
}
@ -77,7 +77,7 @@ BOOL DirList::LoadPath(const std::string & folder, const char *filter, uint32_t
}
BOOL DirList::InternalLoadPath(std::string &folderpath) {
if(folderpath.size() < 3)
if (folderpath.size() < 3)
return false;
struct dirent *dirent = NULL;
@ -91,13 +91,13 @@ BOOL DirList::InternalLoadPath(std::string &folderpath) {
BOOL isDir = dirent->d_type & DT_DIR;
const char *filename = dirent->d_name;
if(isDir) {
if(strcmp(filename,".") == 0 || strcmp(filename,"..") == 0)
if (isDir) {
if (strcmp(filename, ".") == 0 || strcmp(filename, "..") == 0)
continue;
if((Flags & CheckSubfolders) && (Depth > 0)) {
if ((Flags & CheckSubfolders) && (Depth > 0)) {
int32_t length = folderpath.size();
if(length > 2 && folderpath[length-1] != '/') {
if (length > 2 && folderpath[length - 1] != '/') {
folderpath += '/';
}
folderpath += filename;
@ -108,18 +108,18 @@ BOOL DirList::InternalLoadPath(std::string &folderpath) {
Depth++;
}
if(!(Flags & Dirs))
if (!(Flags & Dirs))
continue;
} else if(!(Flags & Files)) {
} else if (!(Flags & Files)) {
continue;
}
if(Filter) {
char * fileext = strrchr(filename, '.');
if(!fileext)
if (Filter) {
char *fileext = strrchr(filename, '.');
if (!fileext)
continue;
if(StringTools::strtokcmp(fileext, Filter, ",") == 0)
if (StringTools::strtokcmp(fileext, Filter, ",") == 0)
AddEntrie(folderpath, filename, isDir);
} else {
AddEntrie(folderpath, filename, isDir);
@ -130,16 +130,16 @@ BOOL DirList::InternalLoadPath(std::string &folderpath) {
return true;
}
void DirList::AddEntrie(const std::string &filepath, const char * filename, BOOL isDir) {
if(!filename)
void DirList::AddEntrie(const std::string &filepath, const char *filename, BOOL isDir) {
if (!filename)
return;
int32_t pos = FileInfo.size();
FileInfo.resize(pos+1);
FileInfo.resize(pos + 1);
FileInfo[pos].FilePath = (char *) malloc(filepath.size()+strlen(filename)+2);
if(!FileInfo[pos].FilePath) {
FileInfo[pos].FilePath = (char *) malloc(filepath.size() + strlen(filename) + 2);
if (!FileInfo[pos].FilePath) {
FileInfo.resize(pos);
return;
}
@ -149,8 +149,8 @@ void DirList::AddEntrie(const std::string &filepath, const char * filename, BOOL
}
void DirList::ClearList() {
for(uint32_t i = 0; i < FileInfo.size(); ++i) {
if(FileInfo[i].FilePath) {
for (uint32_t i = 0; i < FileInfo.size(); ++i) {
if (FileInfo[i].FilePath) {
free(FileInfo[i].FilePath);
FileInfo[i].FilePath = NULL;
}
@ -160,33 +160,33 @@ void DirList::ClearList() {
std::vector<DirEntry>().swap(FileInfo);
}
const char * DirList::GetFilename(int32_t ind) const {
const char *DirList::GetFilename(int32_t ind) const {
if (!valid(ind))
return "";
return StringTools::FullpathToFilename(FileInfo[ind].FilePath);
}
static BOOL SortCallback(const DirEntry & f1, const DirEntry & f2) {
if(f1.isDir && !(f2.isDir)) return true;
if(!(f1.isDir) && f2.isDir) return false;
static BOOL SortCallback(const DirEntry &f1, const DirEntry &f2) {
if (f1.isDir && !(f2.isDir)) return true;
if (!(f1.isDir) && f2.isDir) return false;
if(f1.FilePath && !f2.FilePath) return true;
if(!f1.FilePath) return false;
if (f1.FilePath && !f2.FilePath) return true;
if (!f1.FilePath) return false;
if(strcasecmp(f1.FilePath, f2.FilePath) > 0)
if (strcasecmp(f1.FilePath, f2.FilePath) > 0)
return false;
return true;
}
void DirList::SortList() {
if(FileInfo.size() > 1)
if (FileInfo.size() > 1)
std::sort(FileInfo.begin(), FileInfo.end(), SortCallback);
}
void DirList::SortList(BOOL (*SortFunc)(const DirEntry &a, const DirEntry &b)) {
if(FileInfo.size() > 1)
if (FileInfo.size() > 1)
std::sort(FileInfo.begin(), FileInfo.end(), SortFunc);
}
@ -194,14 +194,14 @@ uint64_t DirList::GetFilesize(int32_t index) const {
struct stat st;
const char *path = GetFilepath(index);
if(!path || stat(path, &st) != 0)
if (!path || stat(path, &st) != 0)
return 0;
return st.st_size;
}
int32_t DirList::GetFileIndex(const char *filename) const {
if(!filename)
if (!filename)
return -1;
for (uint32_t i = 0; i < FileInfo.size(); ++i) {

27
src/fs/DirList.h
View File

@ -32,7 +32,7 @@
#include <wut_types.h>
typedef struct {
char * FilePath;
char *FilePath;
BOOL isDir;
} DirEntry;
@ -40,42 +40,54 @@ class DirList {
public:
//!Constructor
DirList(void);
//!\param path Path from where to load the filelist of all files
//!\param filter A fileext that needs to be filtered
//!\param flags search/filter flags from the enum
DirList(const std::string & path, const char *filter = NULL, uint32_t flags = Files | Dirs, uint32_t maxDepth = 0xffffffff);
DirList(const std::string &path, const char *filter = NULL, uint32_t flags = Files | Dirs, uint32_t maxDepth = 0xffffffff);
//!Destructor
virtual ~DirList();
//! Load all the files from a directory
BOOL LoadPath(const std::string & path, const char *filter = NULL, uint32_t flags = Files | Dirs, uint32_t maxDepth = 0xffffffff);
BOOL LoadPath(const std::string &path, const char *filter = NULL, uint32_t flags = Files | Dirs, uint32_t maxDepth = 0xffffffff);
//! Get a filename of the list
//!\param list index
const char * GetFilename(int32_t index) const;
const char *GetFilename(int32_t index) const;
//! Get the a filepath of the list
//!\param list index
const char *GetFilepath(int32_t index) const {
if (!valid(index)) return "";
else return FileInfo[index].FilePath;
}
//! Get the a filesize of the list
//!\param list index
uint64_t GetFilesize(int32_t index) const;
//! Is index a dir or a file
//!\param list index
BOOL IsDir(int32_t index) const {
if(!valid(index)) return false;
if (!valid(index)) return false;
return FileInfo[index].isDir;
};
//! Get the filecount of the whole list
int32_t GetFilecount() const {
return FileInfo.size();
};
//! Sort list by filepath
void SortList();
//! Custom sort command for custom sort functions definitions
void SortList(BOOL (*SortFunc)(const DirEntry &a, const DirEntry &b));
//! Get the index of the specified filename
int32_t GetFileIndex(const char *filename) const;
//! Enum for search/filter flags
enum {
Files = 0x01,
@ -85,10 +97,13 @@ public:
protected:
// Internal parser
BOOL InternalLoadPath(std::string &path);
//!Add a list entrie
void AddEntrie(const std::string &filepath, const char * filename, BOOL isDir);
void AddEntrie(const std::string &filepath, const char *filename, BOOL isDir);
//! Clear the list
void ClearList();
//! Check if valid pos is requested
inline BOOL valid(uint32_t pos) const {
return (pos < FileInfo.size());

50
src/fs/FSUtils.cpp
View File

@ -10,7 +10,7 @@
int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size) {
//! always initialze input
*inbuffer = NULL;
if(size)
if (size)
*size = 0;
int32_t iFd = open(filepath, O_RDONLY);
@ -30,12 +30,12 @@ int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_
uint32_t done = 0;
int32_t readBytes = 0;
while(done < filesize) {
if(done + blocksize > filesize) {
while (done < filesize) {
if (done + blocksize > filesize) {
blocksize = filesize - done;
}
readBytes = read(iFd, buffer + done, blocksize);
if(readBytes <= 0)
if (readBytes <= 0)
break;
done += readBytes;
}
@ -51,27 +51,27 @@ int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_
*inbuffer = buffer;
//! sign is optional input
if(size) {
if (size) {
*size = filesize;
}
return filesize;
}
int32_t FSUtils::CheckFile(const char * filepath) {
if(!filepath)
int32_t FSUtils::CheckFile(const char *filepath) {
if (!filepath)
return 0;
struct stat filestat;
char dirnoslash[strlen(filepath)+2];
char dirnoslash[strlen(filepath) + 2];
snprintf(dirnoslash, sizeof(dirnoslash), "%s", filepath);
while(dirnoslash[strlen(dirnoslash)-1] == '/')
dirnoslash[strlen(dirnoslash)-1] = '\0';
while (dirnoslash[strlen(dirnoslash) - 1] == '/')
dirnoslash[strlen(dirnoslash) - 1] = '\0';
char * notRoot = strrchr(dirnoslash, '/');
if(!notRoot) {
char *notRoot = strrchr(dirnoslash, '/');
if (!notRoot) {
strcat(dirnoslash, "/");
}
@ -81,29 +81,29 @@ int32_t FSUtils::CheckFile(const char * filepath) {
return 0;
}
int32_t FSUtils::CreateSubfolder(const char * fullpath) {
if(!fullpath)
int32_t FSUtils::CreateSubfolder(const char *fullpath) {
if (!fullpath)
return 0;
int32_t result = 0;
char dirnoslash[strlen(fullpath)+1];
char dirnoslash[strlen(fullpath) + 1];
strcpy(dirnoslash, fullpath);
int32_t pos = strlen(dirnoslash)-1;
while(dirnoslash[pos] == '/') {
int32_t pos = strlen(dirnoslash) - 1;
while (dirnoslash[pos] == '/') {
dirnoslash[pos] = '\0';
pos--;
}
if(CheckFile(dirnoslash)) {
if (CheckFile(dirnoslash)) {
return 1;
} else {
char parentpath[strlen(dirnoslash)+2];
char parentpath[strlen(dirnoslash) + 2];
strcpy(parentpath, dirnoslash);
char * ptr = strrchr(parentpath, '/');
char *ptr = strrchr(parentpath, '/');
if(!ptr) {
if (!ptr) {
//!Device root directory (must be with '/')
strcat(parentpath, "/");
struct stat filestat;
@ -119,7 +119,7 @@ int32_t FSUtils::CreateSubfolder(const char * fullpath) {
result = CreateSubfolder(parentpath);
}
if(!result)
if (!result)
return 0;
if (mkdir(dirnoslash, 0777) == -1) {
@ -129,13 +129,13 @@ int32_t FSUtils::CreateSubfolder(const char * fullpath) {
return 1;
}
BOOL FSUtils::saveBufferToFile(const char * path, void * buffer, uint32_t size) {
BOOL FSUtils::saveBufferToFile(const char *path, void *buffer, uint32_t size) {
CFile file(path, CFile::WriteOnly);
if (!file.isOpen()) {
DEBUG_FUNCTION_LINE("Failed to open %s\n",path);
DEBUG_FUNCTION_LINE("Failed to open %s\n", path);
return false;
}
file.write((const uint8_t*) buffer,size);
file.write((const uint8_t *) buffer, size);
file.close();
return true;
}

8
src/fs/FSUtils.h
View File

@ -8,9 +8,11 @@ public:
static int32_t LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size);
//! todo: C++ class
static int32_t CreateSubfolder(const char * fullpath);
static int32_t CheckFile(const char * filepath);
static BOOL saveBufferToFile(const char * path, void * buffer, uint32_t size);
static int32_t CreateSubfolder(const char *fullpath);
static int32_t CheckFile(const char *filepath);
static BOOL saveBufferToFile(const char *path, void *buffer, uint32_t size);
};
#endif // __FS_UTILS_H_

11
src/main.cpp
View File

@ -10,8 +10,7 @@ WUPS_PLUGIN_LICENSE("GPL");
WUPS_USE_WUT_CRT()
TcpReceiver * thread = NULL;
TcpReceiver *thread = NULL;
/* Entry point */
ON_APPLICATION_START(args) {
@ -19,18 +18,18 @@ ON_APPLICATION_START(args) {
log_init();
DEBUG_FUNCTION_LINE("Started wiiload thread\n");
thread = new TcpReceiver(4299);
thread = new TcpReceiver(4299);
}
void stopThread(){
if(thread != NULL){
void stopThread() {
if (thread != NULL) {
delete thread;
thread = NULL;
}
}
ON_APPLICATION_END(){
ON_APPLICATION_END() {
DEBUG_FUNCTION_LINE("Kill thread\n");
stopThread();

51
src/utils/CThread.h
View File

@ -25,23 +25,20 @@
class CThread {
public:
typedef void (* Callback)(CThread *thread, void *arg);
typedef void (*Callback)(CThread *thread, void *arg);
//! constructor
CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL)
: pThread(NULL)
, pThreadStack(NULL)
, pCallback(callback)
, pCallbackArg(callbackArg) {
: pThread(NULL), pThreadStack(NULL), pCallback(callback), pCallbackArg(callbackArg) {
//! save attribute assignment
iAttributes = iAttr;
//! allocate the thread
pThread = (OSThread*)memalign(8, sizeof(OSThread));
pThread = (OSThread *) memalign(8, sizeof(OSThread));
//! allocate the stack
pThreadStack = (uint8_t *) memalign(0x20, iStackSize);
//! create the thread
if(pThread && pThreadStack)
OSCreateThread(pThread, &CThread::threadCallback, 1, (char*)this, pThreadStack+iStackSize, iStackSize, iPriority, iAttributes);
if (pThread && pThreadStack)
OSCreateThread(pThread, &CThread::threadCallback, 1, (char *) this, pThreadStack + iStackSize, iStackSize, iPriority, iAttributes);
}
//! destructor
@ -51,64 +48,73 @@ public:
}
static CThread *create(CThread::Callback callback, void *callbackArg, int32_t iAttr = eAttributeNone, int32_t iPriority = 16, int32_t iStackSize = 0x8000) {
return ( new CThread(iAttr, iPriority, iStackSize, callback, callbackArg) );
return (new CThread(iAttr, iPriority, iStackSize, callback, callbackArg));
}
//! Get thread ID
virtual void* getThread() const {
virtual void *getThread() const {
return pThread;
}
//! Thread entry function
virtual void executeThread(void) {
if(pCallback)
if (pCallback)
pCallback(this, pCallbackArg);
}
//! Suspend thread
virtual void suspendThread(void) {
if(isThreadSuspended()) return;
if(pThread) OSSuspendThread(pThread);
if (isThreadSuspended()) return;
if (pThread) OSSuspendThread(pThread);
}
//! Resume thread
virtual void resumeThread(void) {
if(!isThreadSuspended()) return;
if(pThread) OSResumeThread(pThread);
if (!isThreadSuspended()) return;
if (pThread) OSResumeThread(pThread);
}
//! Set thread priority
virtual void setThreadPriority(int prio) {
if(pThread) OSSetThreadPriority(pThread, prio);
if (pThread) OSSetThreadPriority(pThread, prio);
}
//! Check if thread is suspended
virtual BOOL isThreadSuspended(void) const {
if(pThread) return OSIsThreadSuspended(pThread);
if (pThread) return OSIsThreadSuspended(pThread);
return false;
}
//! Check if thread is terminated
virtual BOOL isThreadTerminated(void) const {
if(pThread) return OSIsThreadTerminated(pThread);
if (pThread) return OSIsThreadTerminated(pThread);
return false;
}
//! Check if thread is running
virtual BOOL isThreadRunning(void) const {
return !isThreadSuspended() && !isThreadRunning();
}
//! Shutdown thread
virtual void shutdownThread(void) {
//! wait for thread to finish
if(pThread && !(iAttributes & eAttributeDetach)) {
if(isThreadSuspended())
if (pThread && !(iAttributes & eAttributeDetach)) {
if (isThreadSuspended())
resumeThread();
OSJoinThread(pThread, NULL);
}
//! free the thread stack buffer
if(pThreadStack)
if (pThreadStack)
free(pThreadStack);
if(pThread)
if (pThread)
free(pThread);
pThread = NULL;
pThreadStack = NULL;
}
//! Thread attributes
enum eCThreadAttributes {
eAttributeNone = 0x07,
@ -124,6 +130,7 @@ private:
((CThread *) argv)->executeThread();
return 0;
}
int iAttributes;
OSThread *pThread;
uint8_t *pThreadStack;

60
src/utils/StringTools.cpp
View File

@ -36,12 +36,12 @@
#include <utils/StringTools.h>
BOOL StringTools::EndsWith(const std::string& a, const std::string& b) {
BOOL StringTools::EndsWith(const std::string &a, const std::string &b) {
if (b.size() > a.size()) return false;
return std::equal(a.begin() + a.size() - b.size(), a.end(), b.begin());
}
const char * StringTools::byte_to_binary(int32_t x) {
const char *StringTools::byte_to_binary(int32_t x) {
static char b[9];
b[0] = '\0';
@ -53,25 +53,25 @@ const char * StringTools::byte_to_binary(int32_t x) {
return b;
}
std::string StringTools::removeCharFromString(std::string& input,char toBeRemoved) {
std::string StringTools::removeCharFromString(std::string &input, char toBeRemoved) {
std::string output = input;
size_t position;
while(1) {
while (1) {
position = output.find(toBeRemoved);
if(position == std::string::npos)
if (position == std::string::npos)
break;
output.erase(position, 1);
}
return output;
}
const char * StringTools::fmt(const char * format, ...) {
const char *StringTools::fmt(const char *format, ...) {
static char strChar[512];
strChar[0] = 0;
va_list va;
va_start(va, format);
if((vsprintf(strChar, format, va) >= 0)) {
if ((vsprintf(strChar, format, va) >= 0)) {
va_end(va);
return (const char *) strChar;
}
@ -80,26 +80,26 @@ const char * StringTools::fmt(const char * format, ...) {
return NULL;
}
const wchar_t * StringTools::wfmt(const char * format, ...) {
const wchar_t *StringTools::wfmt(const char *format, ...) {
static char tmp[512];
static wchar_t strWChar[512];
strWChar[0] = 0;
tmp[0] = 0;
if(!format)
if (!format)
return (const wchar_t *) strWChar;
if(strcmp(format, "") == 0)
if (strcmp(format, "") == 0)
return (const wchar_t *) strWChar;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
int bt;
if ((vsprintf(tmp, format, va) >= 0)) {
int bt;
int32_t strlength = strlen(tmp);
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512 );
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512);
if(bt > 0) {
if (bt > 0) {
strWChar[bt] = 0;
return (const wchar_t *) strWChar;
}
@ -109,14 +109,14 @@ const wchar_t * StringTools::wfmt(const char * format, ...) {
return NULL;
}
int32_t StringTools::strprintf(std::string &str, const char * format, ...) {
int32_t StringTools::strprintf(std::string &str, const char *format, ...) {
static char tmp[512];
tmp[0] = 0;
int32_t result = 0;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
if ((vsprintf(tmp, format, va) >= 0)) {
str = tmp;
result = str.size();
}
@ -125,14 +125,14 @@ int32_t StringTools::strprintf(std::string &str, const char * format, ...) {
return result;
}
std::string StringTools::strfmt(const char * format, ...) {
std::string StringTools::strfmt(const char *format, ...) {
std::string str;
static char tmp[512];
tmp[0] = 0;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
if ((vsprintf(tmp, format, va) >= 0)) {
str = tmp;
}
va_end(va);
@ -140,11 +140,11 @@ std::string StringTools::strfmt(const char * format, ...) {
return str;
}
BOOL StringTools::char2wchar_t(const char * strChar, wchar_t * dest) {
if(!strChar || !dest)
BOOL StringTools::char2wchar_t(const char *strChar, wchar_t *dest) {
if (!strChar || !dest)
return false;
int bt;
int bt;
bt = mbstowcs(dest, strChar, strlen(strChar));
if (bt > 0) {
dest[bt] = 0;
@ -154,39 +154,39 @@ BOOL StringTools::char2wchar_t(const char * strChar, wchar_t * dest) {
return false;
}
int32_t StringTools::strtokcmp(const char * string, const char * compare, const char * separator) {
if(!string || !compare)
int32_t StringTools::strtokcmp(const char *string, const char *compare, const char *separator) {
if (!string || !compare)
return -1;
char TokCopy[512];
strncpy(TokCopy, compare, sizeof(TokCopy));
TokCopy[511] = '\0';
char * strTok = strtok(TokCopy, separator);
char *strTok = strtok(TokCopy, separator);
while (strTok != NULL) {
if (strcasecmp(string, strTok) == 0) {
return 0;
}
strTok = strtok(NULL,separator);
strTok = strtok(NULL, separator);
}
return -1;
}
int32_t StringTools::strextcmp(const char * string, const char * extension, char seperator) {
if(!string || !extension)
int32_t StringTools::strextcmp(const char *string, const char *extension, char seperator) {
if (!string || !extension)
return -1;
char *ptr = strrchr(string, seperator);
if(!ptr)
if (!ptr)
return -1;
return strcasecmp(ptr + 1, extension);
}
std::vector<std::string> StringTools::stringSplit(const std::string & inValue, const std::string & splitter) {
std::vector<std::string> StringTools::stringSplit(const std::string &inValue, const std::string &splitter) {
std::string value = inValue;
std::vector<std::string> result;
while (true) {
@ -201,7 +201,7 @@ std::vector<std::string> StringTools::stringSplit(const std::string & inValue, c
result.push_back("");
break;
}
if(index + splitter.size() > value.length()) {
if (index + splitter.size() > value.length()) {
break;
}
value = value.substr(index + splitter.size(), value.length());

76
src/utils/StringTools.h
View File

@ -30,52 +30,58 @@
#include <string>
#include <wut_types.h>
class StringTools{
public:
static BOOL EndsWith(const std::string& a, const std::string& b);
static const char * byte_to_binary(int32_t x);
static std::string removeCharFromString(std::string& input,char toBeRemoved);
static const char * fmt(const char * format, ...);
static const wchar_t * wfmt(const char * format, ...);
static int32_t strprintf(std::string &str, const char * format, ...);
static std::string strfmt(const char * format, ...);
static BOOL char2wchar_t(const char * src, wchar_t * dest);
static int32_t strtokcmp(const char * string, const char * compare, const char * separator);
static int32_t strextcmp(const char * string, const char * extension, char seperator);
class StringTools {
public:
static BOOL EndsWith(const std::string &a, const std::string &b);
static const char * FullpathToFilename(const char *path){
if(!path) return path;
static const char *byte_to_binary(int32_t x);
const char * ptr = path;
const char * Filename = ptr;
static std::string removeCharFromString(std::string &input, char toBeRemoved);
while(*ptr != '\0')
{
if(ptr[0] == '/' && ptr[1] != '\0')
Filename = ptr+1;
static const char *fmt(const char *format, ...);
++ptr;
}
static const wchar_t *wfmt(const char *format, ...);
return Filename;
static int32_t strprintf(std::string &str, const char *format, ...);
static std::string strfmt(const char *format, ...);
static BOOL char2wchar_t(const char *src, wchar_t *dest);
static int32_t strtokcmp(const char *string, const char *compare, const char *separator);
static int32_t strextcmp(const char *string, const char *extension, char seperator);
static const char *FullpathToFilename(const char *path) {
if (!path) return path;
const char *ptr = path;
const char *Filename = ptr;
while (*ptr != '\0') {
if (ptr[0] == '/' && ptr[1] != '\0')
Filename = ptr + 1;
++ptr;
}
static void RemoveDoubleSlashs(std::string &str){
uint32_t length = str.size();
return Filename;
}
//! clear path of double slashes
for(uint32_t i = 1; i < length; ++i)
{
if(str[i-1] == '/' && str[i] == '/')
{
str.erase(i, 1);
i--;
length--;
}
static void RemoveDoubleSlashs(std::string &str) {
uint32_t length = str.size();
//! clear path of double slashes
for (uint32_t i = 1; i < length; ++i) {
if (str[i - 1] == '/' && str[i] == '/') {
str.erase(i, 1);
i--;
length--;
}
}
}
static std::vector<std::string> stringSplit(const std::string & value, const std::string & splitter);
static std::vector<std::string> stringSplit(const std::string &value, const std::string &splitter);
};
#endif /* __STRING_TOOLS_H */

98
src/utils/TcpReceiver.cpp
View File

@ -19,15 +19,13 @@
#define RPX_TEMP_FILE "fs:/vol/external01/wiiu/apps/temp.rpx"
#define RPX_TEMP_FILE_EX "wiiu/apps/temp.rpx"
extern "C"{
uint64_t _SYSGetSystemApplicationTitleId(int32_t);
void _SYSLaunchTitleWithStdArgsInNoSplash(uint64_t, uint32_t);
extern "C" {
uint64_t _SYSGetSystemApplicationTitleId(int32_t);
void _SYSLaunchTitleWithStdArgsInNoSplash(uint64_t, uint32_t);
}
TcpReceiver::TcpReceiver(int32_t port)
: CThread(CThread::eAttributeAffCore0)
, exitRequested(false)
, serverPort(port)
, serverSocket(-1) {
: CThread(CThread::eAttributeAffCore0), exitRequested(false), serverPort(port), serverSocket(-1) {
resumeThread();
}
@ -35,7 +33,7 @@ TcpReceiver::TcpReceiver(int32_t port)
TcpReceiver::~TcpReceiver() {
exitRequested = true;
if(serverSocket >= 0) {
if (serverSocket >= 0) {
shutdown(serverSocket, SHUT_RDWR);
}
}
@ -62,7 +60,7 @@ void TcpReceiver::executeThread() {
socklen_t len;
int32_t ret;
if ((ret = bind(serverSocket, (struct sockaddr *)&bindAddress, 16)) < 0) {
if ((ret = bind(serverSocket, (struct sockaddr *) &bindAddress, 16)) < 0) {
socketclose(serverSocket);
return;
}
@ -80,12 +78,12 @@ void TcpReceiver::executeThread() {
memset(&clientAddr, 0, sizeof(clientAddr));
int32_t addrlen = sizeof(struct sockaddr);
while(!exitRequested) {
while (!exitRequested) {
DEBUG_FUNCTION_LINE("\n");
len = 16;
int32_t clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &len);
if(clientSocket >= 0) {
int32_t clientSocket = accept(serverSocket, (struct sockaddr *) &clientAddr, &len);
if (clientSocket >= 0) {
DEBUG_FUNCTION_LINE("\n");
uint32_t ipAddress = clientAddr.sin_addr.s_addr;
@ -94,10 +92,10 @@ void TcpReceiver::executeThread() {
//serverReceiveFinished(this, ipAddress, result);
socketclose(clientSocket);
if(result > 0)
if (result > 0)
break;
} else {
DEBUG_FUNCTION_LINE("Server socket accept failed %i %d\n", clientSocket,wiiu_geterrno());
DEBUG_FUNCTION_LINE("Server socket accept failed %i %d\n", clientSocket, wiiu_geterrno());
OSSleepTicks(OSMicrosecondsToTicks(100000));
}
}
@ -111,7 +109,7 @@ typedef struct __attribute((packed)) {
uint32_t filesize;
uint32_t fileoffset;
char path[256];
}LOAD_REQUEST;
} LOAD_REQUEST;
int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
DEBUG_FUNCTION_LINE("Loading file from ip %08X\n", ipAddress);
@ -122,10 +120,10 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
memset(haxx, 0, sizeof(haxx));
//skip haxx
recvwait(clientSocket, haxx, sizeof(haxx));
recvwait(clientSocket, (unsigned char*)&fileSize, sizeof(fileSize));
recvwait(clientSocket, (unsigned char *) &fileSize, sizeof(fileSize));
if (haxx[4] > 0 || haxx[5] > 4) {
recvwait(clientSocket, (unsigned char*)&fileSizeUnc, sizeof(fileSizeUnc)); // Compressed protocol, read another 4 bytes
recvwait(clientSocket, (unsigned char *) &fileSizeUnc, sizeof(fileSizeUnc)); // Compressed protocol, read another 4 bytes
}
struct in_addr in;
@ -134,21 +132,21 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
DEBUG_FUNCTION_LINE("transfer start\n");
unsigned char* loadAddress = (unsigned char*)memalign(0x40, fileSize);
if(!loadAddress) {
unsigned char *loadAddress = (unsigned char *) memalign(0x40, fileSize);
if (!loadAddress) {
OSSleepTicks(OSSecondsToTicks(1));
return NOT_ENOUGH_MEMORY;
}
// Copy rpl in memory
while(bytesRead < fileSize) {
while (bytesRead < fileSize) {
uint32_t blockSize = 0x1000;
if(blockSize > (fileSize - bytesRead))
if (blockSize > (fileSize - bytesRead))
blockSize = fileSize - bytesRead;
int32_t ret = recv(clientSocket, loadAddress + bytesRead, blockSize, 0);
if(ret <= 0) {
if (ret <= 0) {
DEBUG_FUNCTION_LINE("Failure on reading file\n");
break;
}
@ -156,7 +154,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
bytesRead += ret;
}
if(bytesRead != fileSize) {
if (bytesRead != fileSize) {
free(loadAddress);
DEBUG_FUNCTION_LINE("File loading not finished, %i of %i bytes received\n", bytesRead, fileSize);
return FILE_READ_ERROR;
@ -167,7 +165,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
// Do we need to unzip this thing?
if (haxx[4] > 0 || haxx[5] > 4) {
unsigned char* inflatedData = NULL;
unsigned char *inflatedData = NULL;
// We need to unzip...
if (loadAddress[0] == 'P' && loadAddress[1] == 'K' && loadAddress[2] == 0x03 && loadAddress[3] == 0x04) {
@ -175,8 +173,8 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
//! mhmm this is incorrect, it has to parse the zip
// Section is compressed, inflate
inflatedData = (unsigned char*)malloc(fileSizeUnc);
if(!inflatedData) {
inflatedData = (unsigned char *) malloc(fileSizeUnc);
if (!inflatedData) {
free(loadAddress);
return NOT_ENOUGH_MEMORY;
@ -199,10 +197,10 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
}
s.avail_in = fileSize;
s.next_in = (Bytef *)(&loadAddress[0]);
s.next_in = (Bytef *) (&loadAddress[0]);
s.avail_out = fileSizeUnc;
s.next_out = (Bytef *)&inflatedData[0];
s.next_out = (Bytef *) &inflatedData[0];
ret = inflate(&s, Z_FINISH);
if (ret != Z_OK && ret != Z_STREAM_END) {
@ -216,16 +214,16 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
fileSize = fileSizeUnc;
} else {
// Section is compressed, inflate
inflatedData = (unsigned char*)malloc(fileSizeUnc);
if(!inflatedData) {
inflatedData = (unsigned char *) malloc(fileSizeUnc);
if (!inflatedData) {
free(loadAddress);
return NOT_ENOUGH_MEMORY;
}
uLongf f = fileSizeUnc;
int32_t result = uncompress((Bytef*)&inflatedData[0], &f, (Bytef*)loadAddress, fileSize);
if(result != Z_OK) {
int32_t result = uncompress((Bytef *) &inflatedData[0], &f, (Bytef *) loadAddress, fileSize);
if (result != Z_OK) {
DEBUG_FUNCTION_LINE("uncompress failed %i\n", result);
return FILE_READ_ERROR;
@ -235,16 +233,16 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
fileSize = fileSizeUnc;
}
if(inflatedData[0x7] == 0xCA && inflatedData[0x8] == 0xFE && inflatedData[0x9] != 0xDE && inflatedData[0xA] != 0xAD){
if (inflatedData[0x7] == 0xCA && inflatedData[0x8] == 0xFE && inflatedData[0x9] != 0xDE && inflatedData[0xA] != 0xAD) {
DEBUG_FUNCTION_LINE("Try to load a rpx\n");
FSUtils::CreateSubfolder(RPX_TEMP_PATH);
res = FSUtils::saveBufferToFile(RPX_TEMP_FILE,inflatedData, fileSize);
res = FSUtils::saveBufferToFile(RPX_TEMP_FILE, inflatedData, fileSize);
free(inflatedData);
loadedRPX = true;
}else if(inflatedData[0x7] == 0xCA && inflatedData[0x8] == 0xFE && inflatedData[0x9] == 0xDE && inflatedData[0xA] == 0xAD){
} else if (inflatedData[0x7] == 0xCA && inflatedData[0x8] == 0xFE && inflatedData[0x9] == 0xDE && inflatedData[0xA] == 0xAD) {
auto newContainer = PluginUtils::getPluginForBuffer((char*)inflatedData, fileSize);
if(newContainer){
auto newContainer = PluginUtils::getPluginForBuffer((char *) inflatedData, fileSize);
if (newContainer) {
auto oldPlugins = PluginUtils::getLoadedPlugins(8);
std::vector<PluginContainer> finalList;
@ -256,7 +254,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
DEBUG_FUNCTION_LINE("Skipping duplicate");
PluginUtils::destroyPluginContainer(plugin);
continue;
}else{
} else {
finalList.push_back(plugin);
}
}
@ -271,39 +269,39 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
if (PluginUtils::LoadAndLinkOnRestart(finalList) != 0) {
DEBUG_FUNCTION_LINE("Failed to load& link\n");
PluginUtils::destroyPluginContainer(finalList);
}else{
} else {
PluginUtils::destroyPluginContainer(finalList);
SYSRelaunchTitle(NULL,NULL);
SYSRelaunchTitle(NULL, NULL);
}
free(inflatedData);
free(loadAddress);
return fileSize;
}else{
} else {
DEBUG_FUNCTION_LINE("Failed to parse plugin\n");
}
free(inflatedData);
}
} else {
if(loadAddress[0x7] == 0xCA && loadAddress[0x8] == 0xFE){
if (loadAddress[0x7] == 0xCA && loadAddress[0x8] == 0xFE) {
DEBUG_FUNCTION_LINE("Try to load a rpx\n");
FSUtils::CreateSubfolder(RPX_TEMP_PATH);
res = FSUtils::saveBufferToFile(RPX_TEMP_FILE,loadAddress, fileSize);
res = FSUtils::saveBufferToFile(RPX_TEMP_FILE, loadAddress, fileSize);
free(loadAddress);
loadedRPX = true;
}else if(loadAddress[0x7] == 0xCA && loadAddress[0x8] == 0xFE && loadAddress[0x9] == 0xDE){
} else if (loadAddress[0x7] == 0xCA && loadAddress[0x8] == 0xFE && loadAddress[0x9] == 0xDE) {
OSFatal("Not implemented yet");
free(loadAddress);
}
}
if(!res) {
if (!res) {
return NOT_ENOUGH_MEMORY;
}
if(loadedRPX){
if (loadedRPX) {
LOAD_REQUEST request;
memset(&request, 0, sizeof(request));
@ -315,12 +313,12 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
strncpy(request.path, RPX_TEMP_FILE_EX, 255);
int mcpFd = IOS_Open("/dev/mcp", (IOSOpenMode)0);
if(mcpFd >= 0) {
int mcpFd = IOS_Open("/dev/mcp", (IOSOpenMode) 0);
if (mcpFd >= 0) {
int out = 0;
IOS_Ioctl(mcpFd, 100, &request, sizeof(request), &out, sizeof(out));
IOS_Close(mcpFd);
if(out == 2) {
if (out == 2) {
}
}
@ -330,7 +328,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
return fileSize;
}
SYSRelaunchTitle(NULL,NULL);
SYSRelaunchTitle(NULL, NULL);
return fileSize;
}

5
src/utils/TcpReceiver.h
View File

@ -18,6 +18,7 @@ public:
};
TcpReceiver(int32_t port);
~TcpReceiver();
//sigslot::signal2<GuiElement *, uint32_t> serverReceiveStart;
@ -26,8 +27,10 @@ public:
private:
void executeThread();
int32_t loadToMemory(int32_t clientSocket, uint32_t ipAddress);
bool saveFileToSDCard(const char * path, void * buffer,uint32_t size);
bool saveFileToSDCard(const char *path, void *buffer, uint32_t size);
bool exitRequested;
int32_t serverPort;

16
src/utils/logger.c
View File

@ -10,7 +10,7 @@
#include <coreinit/systeminfo.h>
#include <coreinit/thread.h>
static int log_socket __attribute__((section(".data")))= -1;
static int log_socket __attribute__((section(".data"))) = -1;
static struct sockaddr_in connect_addr __attribute__((section(".data")));
static volatile int log_lock __attribute__((section(".data"))) = 0;
@ -30,11 +30,11 @@ void log_init_() {
void log_print_(const char *str) {
// socket is always 0 initially as it is in the BSS
if(log_socket < 0) {
if (log_socket < 0) {
return;
}
while(log_lock)
while (log_lock)
OSSleepTicks(OSMicrosecondsToTicks(1000));
log_lock = 1;
@ -42,8 +42,8 @@ void log_print_(const char *str) {
int ret;
while (len > 0) {
int block = len < 1400 ? len : 1400; // take max 1400 bytes per UDP packet
ret = sendto(log_socket, str, block, 0, (struct sockaddr *)&connect_addr, sizeof(struct sockaddr_in));
if(ret < 0)
ret = sendto(log_socket, str, block, 0, (struct sockaddr *) &connect_addr, sizeof(struct sockaddr_in));
if (ret < 0)
break;
len -= ret;
@ -58,14 +58,14 @@ void OSFatal_printf(const char *format, ...) {
tmp[0] = 0;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
if ((vsprintf(tmp, format, va) >= 0)) {
OSFatal(tmp);
}
va_end(va);
}
void log_printf_(const char *format, ...) {
if(log_socket < 0) {
if (log_socket < 0) {
return;
}
@ -74,7 +74,7 @@ void log_printf_(const char *format, ...) {
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
if ((vsprintf(tmp, format, va) >= 0)) {
log_print_(tmp);
}
va_end(va);

4
src/utils/logger.h
View File

@ -8,9 +8,12 @@ extern "C" {
#include <string.h>
void log_init_();
//void log_deinit_(void);
void log_print_(const char *str);
void log_printf_(const char *format, ...);
void OSFatal_printf(const char *format, ...);
#define __FILENAME_X__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)
@ -21,7 +24,6 @@ void OSFatal_printf(const char *format, ...);
} while (0)
#define log_init() log_init_()
//#define log_deinit() log_deinit_()
#define log_print(str) log_print_(str)

14
src/utils/net.c
View File

@ -4,18 +4,18 @@
static volatile int socket_lock __attribute__((section(".data"))) = 0;
int32_t recvwait(int32_t sock, void *buffer, int32_t len) {
while(socket_lock) {
while (socket_lock) {
usleep(1000);
}
int32_t ret;
while (len > 0) {
ret = recv(sock, buffer, len, 0);
if(ret < 0) {
if (ret < 0) {
socket_lock = 0;
return ret;
}
len -= ret;
buffer = (void *)(((char *) buffer) + ret);
buffer = (void *) (((char *) buffer) + ret);
}
socket_lock = 0;
return 0;
@ -42,7 +42,7 @@ uint32_t recvword(int32_t sock) {
}
int32_t checkbyte(int32_t sock) {
while(socket_lock) {
while (socket_lock) {
usleep(1000);
}
unsigned char buffer[1];
@ -58,7 +58,7 @@ int32_t checkbyte(int32_t sock) {
}
int32_t sendwait(int32_t sock, const void *buffer, int32_t len) {
while(socket_lock) {
while (socket_lock) {
usleep(1000);
}
int32_t ret;
@ -66,12 +66,12 @@ int32_t sendwait(int32_t sock, const void *buffer, int32_t len) {
// For some reason the send blocks/crashes if the buffer is too big..
int cur_length = len <= 0x30 ? len : 0x30;
ret = send(sock, buffer, cur_length, 0);
if(ret < 0) {
if (ret < 0) {
socket_lock = 0;
return ret;
}
len -= ret;
buffer = (void *)(((char *) buffer) + ret);
buffer = (void *) (((char *) buffer) + ret);
}
socket_lock = 0;
return 0;

7
src/utils/net.h
View File

@ -1,16 +1,23 @@
#ifndef _UTILS_NET_H_
#define _UTILS_NET_H_
#include <stdint.h>
#include <nsysnet/socket.h>
#ifdef __cplusplus
extern "C" {
#endif
int32_t recvwait(int32_t sock, void *buffer, int32_t len);
uint8_t recvbyte(int32_t sock);
uint32_t recvword(int32_t sock);
int32_t checkbyte(int32_t sock);
int32_t sendwait(int32_t sock, const void *buffer, int32_t len);
int32_t sendbyte(int32_t sock, unsigned char byte);
#ifdef __cplusplus

375
src/utils/romfs_dev.c
View File

@ -16,29 +16,29 @@ typedef enum {
} RomfsSource;
typedef struct romfs_mount {
devoptab_t device;
bool setup;
RomfsSource fd_type;
int32_t id;
int32_t fd;
time_t mtime;
uint64_t offset;
romfs_header header;
romfs_dir *cwd;
uint32_t *dirHashTable, *fileHashTable;
void *dirTable, *fileTable;
char name[32];
devoptab_t device;
bool setup;
RomfsSource fd_type;
int32_t id;
int32_t fd;
time_t mtime;
uint64_t offset;
romfs_header header;
romfs_dir *cwd;
uint32_t *dirHashTable, *fileHashTable;
void *dirTable, *fileTable;
char name[32];
} romfs_mount;
extern int __system_argc;
extern char** __system_argv;
extern char **__system_argv;
//static char __thread __component[PATH_MAX+1];
static char __component[PATH_MAX+1];
static char __component[PATH_MAX + 1];
#define romFS_root(m) ((romfs_dir*)(m)->dirTable)
#define romFS_dir(m,x) ((romfs_dir*) ((uint8_t*)(m)->dirTable + (x)))
#define romFS_file(m,x) ((romfs_file*)((uint8_t*)(m)->fileTable + (x)))
#define romFS_dir(m, x) ((romfs_dir*) ((uint8_t*)(m)->dirTable + (x)))
#define romFS_file(m, x) ((romfs_file*)((uint8_t*)(m)->fileTable + (x)))
#define romFS_none ((uint32_t)~0)
#define romFS_dir_mode (S_IFDIR | S_IRUSR | S_IRGRP | S_IROTH)
#define romFS_file_mode (S_IFREG | S_IRUSR | S_IRGRP | S_IROTH)
@ -47,7 +47,7 @@ uint64_t swapLong(uint64_t X) {
uint64_t x = (uint64_t) X;
x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32;
x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16;
x = (x & 0x00FF00FF00FF00FF) << 8 | (x & 0xFF00FF00FF00FF00) >> 8;
x = (x & 0x00FF00FF00FF00FF) << 8 | (x & 0xFF00FF00FF00FF00) >> 8;
return x;
}
@ -58,12 +58,12 @@ uint64_t swapLong(uint64_t X) {
((n & 0xFF0000) >> 8) | \
((n & 0xFF000000) >> 24)))
static ssize_t _romfs_read(romfs_mount *mount, uint64_t offset, void* buffer, uint64_t size) {
static ssize_t _romfs_read(romfs_mount *mount, uint64_t offset, void *buffer, uint64_t size) {
uint64_t pos = mount->offset + offset;
size_t _read = 0;
if(mount->fd_type == RomfsSource_FileDescriptor) {
if (mount->fd_type == RomfsSource_FileDescriptor) {
off_t seek_offset = lseek(mount->fd, pos, SEEK_SET);
if(pos != seek_offset) {
if (pos != seek_offset) {
return -1;
}
_read = read(mount->fd, buffer, size);
@ -71,52 +71,62 @@ static ssize_t _romfs_read(romfs_mount *mount, uint64_t offset, void* buffer, ui
return _read;
}
static bool _romfs_read_chk(romfs_mount *mount, uint64_t offset, void* buffer, uint64_t size) {
static bool _romfs_read_chk(romfs_mount *mount, uint64_t offset, void *buffer, uint64_t size) {
return _romfs_read(mount, offset, buffer, size) == size;
}
//-----------------------------------------------------------------------------
static int romfs_open(struct _reent *r, void *fileStruct, const char *path, int flags, int mode);
static int romfs_close(struct _reent *r, void *fd);
static ssize_t romfs_read(struct _reent *r, void *fd, char *ptr, size_t len);
static off_t romfs_seek(struct _reent *r, void *fd, off_t pos, int dir);
static int romfs_fstat(struct _reent *r, void *fd, struct stat *st);
static int romfs_stat(struct _reent *r, const char *path, struct stat *st);
static int romfs_chdir(struct _reent *r, const char *path);
static DIR_ITER* romfs_diropen(struct _reent *r, DIR_ITER *dirState, const char *path);
static int romfs_dirreset(struct _reent *r, DIR_ITER *dirState);
static int romfs_dirnext(struct _reent *r, DIR_ITER *dirState, char *filename, struct stat *filestat);
static int romfs_dirclose(struct _reent *r, DIR_ITER *dirState);
static int romfs_open(struct _reent *r, void *fileStruct, const char *path, int flags, int mode);
static int romfs_close(struct _reent *r, void *fd);
static ssize_t romfs_read(struct _reent *r, void *fd, char *ptr, size_t len);
static off_t romfs_seek(struct _reent *r, void *fd, off_t pos, int dir);
static int romfs_fstat(struct _reent *r, void *fd, struct stat *st);
static int romfs_stat(struct _reent *r, const char *path, struct stat *st);
static int romfs_chdir(struct _reent *r, const char *path);
static DIR_ITER *romfs_diropen(struct _reent *r, DIR_ITER *dirState, const char *path);
static int romfs_dirreset(struct _reent *r, DIR_ITER *dirState);
static int romfs_dirnext(struct _reent *r, DIR_ITER *dirState, char *filename, struct stat *filestat);
static int romfs_dirclose(struct _reent *r, DIR_ITER *dirState);
typedef struct {
romfs_mount *mount;
romfs_file *file;
uint64_t offset, pos;
romfs_file *file;
uint64_t offset, pos;
} romfs_fileobj;
typedef struct {
romfs_mount *mount;
romfs_dir* dir;
uint32_t state;
uint32_t childDir;
uint32_t childFile;
romfs_dir *dir;
uint32_t state;
uint32_t childDir;
uint32_t childFile;
} romfs_diriter;
static devoptab_t romFS_devoptab = {
.structSize = sizeof(romfs_fileobj),
.open_r = romfs_open,
.close_r = romfs_close,
.read_r = romfs_read,
.seek_r = romfs_seek,
.fstat_r = romfs_fstat,
.stat_r = romfs_stat,
.chdir_r = romfs_chdir,
.dirStateSize = sizeof(romfs_diriter),
.diropen_r = romfs_diropen,
.dirreset_r = romfs_dirreset,
.dirnext_r = romfs_dirnext,
.dirclose_r = romfs_dirclose,
.structSize = sizeof(romfs_fileobj),
.open_r = romfs_open,
.close_r = romfs_close,
.read_r = romfs_read,
.seek_r = romfs_seek,
.fstat_r = romfs_fstat,
.stat_r = romfs_stat,
.chdir_r = romfs_chdir,
.dirStateSize = sizeof(romfs_diriter),
.diropen_r = romfs_diropen,
.dirreset_r = romfs_dirreset,
.dirnext_r = romfs_dirnext,
.dirclose_r = romfs_dirclose,
};
static bool romfs_initialised = false;
@ -125,6 +135,7 @@ static romfs_mount romfs_mounts[32];
//-----------------------------------------------------------------------------
static int32_t romfsMountCommon(const char *name, romfs_mount *mount);
static void romfsInitMtime(romfs_mount *mount);
static void _romfsResetMount(romfs_mount *mount, int32_t id) {
@ -139,8 +150,8 @@ static void _romfsInit(void) {
uint32_t i;
uint32_t total = sizeof(romfs_mounts) / sizeof(romfs_mount);
if(!romfs_initialised) {
for(i = 0; i < total; i++) {
if (!romfs_initialised) {
for (i = 0; i < total; i++) {
_romfsResetMount(&romfs_mounts[i], i);
}
@ -155,14 +166,14 @@ static romfs_mount *romfsFindMount(const char *name) {
_romfsInit();
for(i=0; i<total; i++) {
for (i = 0; i < total; i++) {
mount = &romfs_mounts[i];
if(name==NULL) { //Find an unused mount entry.
if(!mount->setup)
if (name == NULL) { //Find an unused mount entry.
if (!mount->setup)
return mount;
} else if(mount->setup) { //Find the mount with the input name.
if(strncmp(mount->name, name, sizeof(mount->name))==0)
} else if (mount->setup) { //Find the mount with the input name.
if (strncmp(mount->name, name, sizeof(mount->name)) == 0)
return mount;
}
}
@ -170,9 +181,9 @@ static romfs_mount *romfsFindMount(const char *name) {
return NULL;
}
__attribute__((weak)) const char* __romfs_path = NULL;
__attribute__((weak)) const char *__romfs_path = NULL;
static romfs_mount* romfs_alloc(void) {
static romfs_mount *romfs_alloc(void) {
return romfsFindMount(NULL);
}
@ -185,15 +196,15 @@ static void romfs_free(romfs_mount *mount) {
}
static void romfs_mountclose(romfs_mount *mount) {
if(mount->fd_type == RomfsSource_FileDescriptor) {
if (mount->fd_type == RomfsSource_FileDescriptor) {
close(mount->fd);
}
romfs_free(mount);
}
int32_t romfsMount(const char *name, const char * filepath) {
int32_t romfsMount(const char *name, const char *filepath) {
romfs_mount *mount = romfs_alloc();
if(mount == NULL)
if (mount == NULL)
return 99;
// Regular RomFS
@ -208,19 +219,19 @@ int32_t romfsMount(const char *name, const char * filepath) {
romfsInitMtime(mount);
return romfsMountCommon(name, mount);
_fail0:
_fail0:
romfs_mountclose(mount);
return 10;
}
int32_t romfsMountCommon(const char *name, romfs_mount *mount) {
memset(mount->name, 0, sizeof(mount->name));
strncpy(mount->name, name, sizeof(mount->name)-1);
strncpy(mount->name, name, sizeof(mount->name) - 1);
if (_romfs_read(mount, 0, &mount->header, sizeof(mount->header)) != sizeof(mount->header))
goto fail;
mount->dirHashTable = (uint32_t*)malloc(swapLong(mount->header.dirHashTableSize));
mount->dirHashTable = (uint32_t *) malloc(swapLong(mount->header.dirHashTableSize));
if (!mount->dirHashTable)
goto fail;
if (!_romfs_read_chk(mount, swapLong(mount->header.dirHashTableOff), mount->dirHashTable, swapLong(mount->header.dirHashTableSize)))
@ -231,7 +242,7 @@ int32_t romfsMountCommon(const char *name, romfs_mount *mount) {
goto fail;
if (!_romfs_read_chk(mount, swapLong(mount->header.dirTableOff), mount->dirTable, swapLong(mount->header.dirTableSize)))
goto fail;
mount->fileHashTable = (uint32_t*)malloc(swapLong(mount->header.fileHashTableSize));
mount->fileHashTable = (uint32_t *) malloc(swapLong(mount->header.fileHashTableSize));
if (!mount->fileHashTable)
goto fail;
if (!_romfs_read_chk(mount, swapLong(mount->header.fileHashTableOff), mount->fileHashTable, swapLong(mount->header.fileHashTableSize)))
@ -245,12 +256,12 @@ int32_t romfsMountCommon(const char *name, romfs_mount *mount) {
mount->cwd = romFS_root(mount);
// add device if this is the first one
if(AddDevice(&mount->device) < 0)
if (AddDevice(&mount->device) < 0)
goto fail;
mount->setup = true;
return 0;
fail:
fail:
romfs_mountclose(mount);
return 10;
}
@ -269,8 +280,8 @@ int32_t romfsUnmount(const char *name) {
// Remove device
memset(tmpname, 0, sizeof(tmpname));
strncpy(tmpname, mount->name, sizeof(tmpname)-2);
strncat(tmpname, ":", sizeof(tmpname)-strlen(tmpname)-1);
strncpy(tmpname, mount->name, sizeof(tmpname) - 2);
strncat(tmpname, ":", sizeof(tmpname) - strlen(tmpname) - 1);
RemoveDevice(tmpname);
@ -281,20 +292,20 @@ int32_t romfsUnmount(const char *name) {
//-----------------------------------------------------------------------------
static uint32_t calcHash(uint32_t parent, const uint8_t* name, uint32_t namelen, uint32_t total) {
uint32_t hash = parent ^ 123456789;
static uint32_t calcHash(uint32_t parent, const uint8_t *name, uint32_t namelen, uint32_t total) {
uint32_t hash = parent ^123456789;
uint32_t i;
for (i = 0; i < namelen; i ++) {
for (i = 0; i < namelen; i++) {
hash = (hash >> 5) | (hash << 27);
hash ^= name[i];
}
return hash % total;
}
static romfs_dir* searchForDir(romfs_mount *mount, romfs_dir* parent, const uint8_t* name, uint32_t namelen) {
uint64_t parentOff = (uintptr_t)parent - (uintptr_t)mount->dirTable;
uint32_t hash = calcHash(parentOff, name, namelen, swapLong(mount->header.dirHashTableSize)/4);
romfs_dir* curDir = NULL;
static romfs_dir *searchForDir(romfs_mount *mount, romfs_dir *parent, const uint8_t *name, uint32_t namelen) {
uint64_t parentOff = (uintptr_t) parent - (uintptr_t) mount->dirTable;
uint32_t hash = calcHash(parentOff, name, namelen, swapLong(mount->header.dirHashTableSize) / 4);
romfs_dir *curDir = NULL;
uint32_t curOff;
for (curOff = REVERSE_INT(mount->dirHashTable[hash]); curOff != romFS_none; curOff = REVERSE_INT(curDir->nextHash)) {
curDir = romFS_dir(mount, curOff);
@ -309,10 +320,10 @@ static romfs_dir* searchForDir(romfs_mount *mount, romfs_dir* parent, const uint
return NULL;
}
static romfs_file* searchForFile(romfs_mount *mount, romfs_dir* parent, const uint8_t* name, uint32_t namelen) {
uint64_t parentOff = (uintptr_t)parent - (uintptr_t)mount->dirTable;
uint32_t hash = calcHash(parentOff, name, namelen, swapLong(mount->header.fileHashTableSize)/4);
romfs_file* curFile = NULL;
static romfs_file *searchForFile(romfs_mount *mount, romfs_dir *parent, const uint8_t *name, uint32_t namelen) {
uint64_t parentOff = (uintptr_t) parent - (uintptr_t) mount->dirTable;
uint32_t hash = calcHash(parentOff, name, namelen, swapLong(mount->header.fileHashTableSize) / 4);
romfs_file *curFile = NULL;
uint32_t curOff;
for (curOff = REVERSE_INT(mount->fileHashTable[hash]); curOff != romFS_none; curOff = REVERSE_INT(curFile->nextHash)) {
curFile = romFS_file(mount, curOff);
@ -327,10 +338,10 @@ static romfs_file* searchForFile(romfs_mount *mount, romfs_dir* parent, const ui
return NULL;
}
static int navigateToDir(romfs_mount *mount, romfs_dir** ppDir, const char** pPath, bool isDir) {
char* colonPos = strchr(*pPath, ':');
static int navigateToDir(romfs_mount *mount, romfs_dir **ppDir, const char **pPath, bool isDir) {
char *colonPos = strchr(*pPath, ':');
if (colonPos)
*pPath = colonPos+1;
*pPath = colonPos + 1;
if (!**pPath)
return EILSEQ;
@ -341,8 +352,8 @@ static int navigateToDir(romfs_mount *mount, romfs_dir** ppDir, const char** pPa
}
while (**pPath) {
char* slashPos = strchr(*pPath, '/');
char* component = __component;
char *slashPos = strchr(*pPath, '/');
char *component = __component;
if (slashPos) {
uint32_t len = slashPos - *pPath;
@ -353,23 +364,23 @@ static int navigateToDir(romfs_mount *mount, romfs_dir** ppDir, const char** pPa
memcpy(component, *pPath, len);
component[len] = 0;
*pPath = slashPos+1;
*pPath = slashPos + 1;
} else if (isDir) {
component = (char*)*pPath;
component = (char *) *pPath;
*pPath += strlen(component);
} else
return 0;
if (component[0]=='.') {
if (component[0] == '.') {
if (!component[1])
continue;
if (component[1]=='.' && !component[2]) {
if (component[1] == '.' && !component[2]) {
*ppDir = romFS_dir(mount, REVERSE_INT((*ppDir)->parent));
continue;
}
}
*ppDir = searchForDir(mount, *ppDir, (uint8_t*)component, strlen(component));
*ppDir = searchForDir(mount, *ppDir, (uint8_t *) component, strlen(component));
if (!*ppDir)
return EEXIST;
}
@ -381,25 +392,25 @@ static int navigateToDir(romfs_mount *mount, romfs_dir** ppDir, const char** pPa
}
static ino_t dir_inode(romfs_mount *mount, romfs_dir *dir) {
return (uint32_t*)dir - (uint32_t*)mount->dirTable;
return (uint32_t *) dir - (uint32_t *) mount->dirTable;
}
static off_t dir_size(romfs_dir *dir) {
return sizeof(romfs_dir) + (REVERSE_INT(dir->nameLen)+3)/4;
return sizeof(romfs_dir) + (REVERSE_INT(dir->nameLen) + 3) / 4;
}
static nlink_t dir_nlink(romfs_mount *mount, romfs_dir *dir) {
nlink_t count = 2; // one for self, one for parent
uint32_t offset = REVERSE_INT(dir->childDir);
uint32_t offset = REVERSE_INT(dir->childDir);
while(offset != romFS_none) {
while (offset != romFS_none) {
romfs_dir *tmp = romFS_dir(mount, offset);
++count;
offset = REVERSE_INT(tmp->sibling);
}
offset = REVERSE_INT(dir->childFile);
while(offset != romFS_none) {
while (offset != romFS_none) {
romfs_file *tmp = romFS_file(mount, offset);
++count;
offset = REVERSE_INT(tmp->sibling);
@ -409,24 +420,24 @@ static nlink_t dir_nlink(romfs_mount *mount, romfs_dir *dir) {
}
static ino_t file_inode(romfs_mount *mount, romfs_file *file) {
return ((uint32_t*)file - (uint32_t*)mount->fileTable) + swapLong(mount->header.dirTableSize)/4;
return ((uint32_t *) file - (uint32_t *) mount->fileTable) + swapLong(mount->header.dirTableSize) / 4;
}
int romfs_GetFileInfoPerPath(const char* romfs, const char *path, romfs_fileInfo* out) {
if(out == NULL){
int romfs_GetFileInfoPerPath(const char *romfs, const char *path, romfs_fileInfo *out) {
if (out == NULL) {
return -1;
}
romfs_mount* mount = (romfs_mount*)romfsFindMount(romfs);
if(mount == NULL){
romfs_mount *mount = (romfs_mount *) romfsFindMount(romfs);
if (mount == NULL) {
return -2;
}
romfs_dir* curDir = NULL;
romfs_dir *curDir = NULL;
int errno2 = navigateToDir(mount, &curDir, &path, false);
if (errno2 != 0){
if (errno2 != 0) {
return -3;
}
romfs_file* file = searchForFile(mount, curDir, (uint8_t*)path, strlen(path));
romfs_file *file = searchForFile(mount, curDir, (uint8_t *) path, strlen(path));
if (!file) {
return -4;
}
@ -441,35 +452,35 @@ int romfs_GetFileInfoPerPath(const char* romfs, const char *path, romfs_fileInfo
//-----------------------------------------------------------------------------
int romfs_open(struct _reent *r, void *fileStruct, const char *path, int flags, int mode) {
romfs_fileobj* fileobj = (romfs_fileobj*)fileStruct;
romfs_fileobj *fileobj = (romfs_fileobj *) fileStruct;
fileobj->mount = (romfs_mount*)r->deviceData;
fileobj->mount = (romfs_mount *) r->deviceData;
if ((flags & O_ACCMODE) != O_RDONLY) {
r->_errno = EROFS;
return -1;
}
romfs_dir* curDir = NULL;
romfs_dir *curDir = NULL;
r->_errno = navigateToDir(fileobj->mount, &curDir, &path, false);
if (r->_errno != 0)
return -1;
romfs_file* file = searchForFile(fileobj->mount, curDir, (uint8_t*)path, strlen(path));
romfs_file *file = searchForFile(fileobj->mount, curDir, (uint8_t *) path, strlen(path));
if (!file) {
if(flags & O_CREAT)
if (flags & O_CREAT)
r->_errno = EROFS;
else
r->_errno = ENOENT;
return -1;
} else if((flags & O_CREAT) && (flags & O_EXCL)) {
} else if ((flags & O_CREAT) && (flags & O_EXCL)) {
r->_errno = EEXIST;
return -1;
}
fileobj->file = file;
fileobj->file = file;
fileobj->offset = swapLong(fileobj->mount->header.fileDataOff) + swapLong(file->dataOff);
fileobj->pos = 0;
fileobj->pos = 0;
return 0;
}
@ -479,20 +490,20 @@ int romfs_close(struct _reent *r, void *fd) {
}
ssize_t romfs_read(struct _reent *r, void *fd, char *ptr, size_t len) {
romfs_fileobj* file = (romfs_fileobj*)fd;
romfs_fileobj *file = (romfs_fileobj *) fd;
uint64_t endPos = file->pos + len;
/* check if past end-of-file */
if(file->pos >= swapLong(file->file->dataSize))
if (file->pos >= swapLong(file->file->dataSize))
return 0;
/* truncate the read to end-of-file */
if(endPos > swapLong(file->file->dataSize))
if (endPos > swapLong(file->file->dataSize))
endPos = swapLong(file->file->dataSize);
len = endPos - file->pos;
ssize_t adv = _romfs_read(file->mount, file->offset + file->pos, ptr, len);
if(adv >= 0) {
if (adv >= 0) {
file->pos += adv;
return adv;
}
@ -502,35 +513,35 @@ ssize_t romfs_read(struct _reent *r, void *fd, char *ptr, size_t len) {
}
off_t romfs_seek(struct _reent *r, void *fd, off_t pos, int dir) {
romfs_fileobj* file = (romfs_fileobj*)fd;
off_t start;
romfs_fileobj *file = (romfs_fileobj *) fd;
off_t start;
switch (dir) {
case SEEK_SET:
start = 0;
break;
case SEEK_SET:
start = 0;
break;
case SEEK_CUR:
start = file->pos;
break;
case SEEK_CUR:
start = file->pos;
break;
case SEEK_END:
start = swapLong(file->file->dataSize);
break;
case SEEK_END:
start = swapLong(file->file->dataSize);
break;
default:
r->_errno = EINVAL;
return -1;
default:
r->_errno = EINVAL;
return -1;
}
/* don't allow negative position */
if(pos < 0) {
if(start + pos < 0) {
if (pos < 0) {
if (start + pos < 0) {
r->_errno = EINVAL;
return -1;
}
}
/* check for overflow */
else if(INT64_MAX - pos < start) {
/* check for overflow */
else if (INT64_MAX - pos < start) {
r->_errno = EOVERFLOW;
return -1;
}
@ -540,49 +551,49 @@ off_t romfs_seek(struct _reent *r, void *fd, off_t pos, int dir) {
}
int romfs_fstat(struct _reent *r, void *fd, struct stat *st) {
romfs_fileobj* file = (romfs_fileobj*)fd;
romfs_fileobj *file = (romfs_fileobj *) fd;
memset(st, 0, sizeof(struct stat));
st->st_ino = file_inode(file->mount, file->file);
st->st_mode = romFS_file_mode;
st->st_ino = file_inode(file->mount, file->file);
st->st_mode = romFS_file_mode;
st->st_nlink = 1;
st->st_size = (off_t)swapLong(file->file->dataSize);
st->st_size = (off_t) swapLong(file->file->dataSize);
st->st_blksize = 512;
st->st_blocks = (st->st_blksize + 511) / 512;
st->st_blocks = (st->st_blksize + 511) / 512;
st->st_atime = st->st_mtime = st->st_ctime = file->mount->mtime;
return 0;
}
int romfs_stat(struct _reent *r, const char *path, struct stat *st) {
romfs_mount* mount = (romfs_mount*)r->deviceData;
romfs_dir* curDir = NULL;
romfs_mount *mount = (romfs_mount *) r->deviceData;
romfs_dir *curDir = NULL;
r->_errno = navigateToDir(mount, &curDir, &path, false);
if(r->_errno != 0)
if (r->_errno != 0)
return -1;
romfs_dir* dir = searchForDir(mount, curDir, (uint8_t*)path, strlen(path));
if(dir) {
romfs_dir *dir = searchForDir(mount, curDir, (uint8_t *) path, strlen(path));
if (dir) {
memset(st, 0, sizeof(*st));
st->st_ino = dir_inode(mount, dir);
st->st_mode = romFS_dir_mode;
st->st_nlink = dir_nlink(mount, dir);
st->st_size = dir_size(dir);
st->st_ino = dir_inode(mount, dir);
st->st_mode = romFS_dir_mode;
st->st_nlink = dir_nlink(mount, dir);
st->st_size = dir_size(dir);
st->st_blksize = 512;
st->st_blocks = (st->st_blksize + 511) / 512;
st->st_blocks = (st->st_blksize + 511) / 512;
st->st_atime = st->st_mtime = st->st_ctime = mount->mtime;
return 0;
}
romfs_file* file = searchForFile(mount, curDir, (uint8_t*)path, strlen(path));
if(file) {
romfs_file *file = searchForFile(mount, curDir, (uint8_t *) path, strlen(path));
if (file) {
memset(st, 0, sizeof(*st));
st->st_ino = file_inode(mount, file);
st->st_mode = romFS_file_mode;
st->st_ino = file_inode(mount, file);
st->st_mode = romFS_file_mode;
st->st_nlink = 1;
st->st_size = swapLong(file->dataSize);
st->st_size = swapLong(file->dataSize);
st->st_blksize = 512;
st->st_blocks = (st->st_blksize + 511) / 512;
st->st_blocks = (st->st_blksize + 511) / 512;
st->st_atime = st->st_mtime = st->st_ctime = mount->mtime;
return 0;
@ -593,8 +604,8 @@ int romfs_stat(struct _reent *r, const char *path, struct stat *st) {
}
int romfs_chdir(struct _reent *r, const char *path) {
romfs_mount* mount = (romfs_mount*)r->deviceData;
romfs_dir* curDir = NULL;
romfs_mount *mount = (romfs_mount *) r->deviceData;
romfs_dir *curDir = NULL;
r->_errno = navigateToDir(mount, &curDir, &path, false);
if (r->_errno != 0)
return -1;
@ -603,48 +614,48 @@ int romfs_chdir(struct _reent *r, const char *path) {
return 0;
}
DIR_ITER* romfs_diropen(struct _reent *r, DIR_ITER *dirState, const char *path) {
romfs_diriter* iter = (romfs_diriter*)(dirState->dirStruct);
romfs_dir* curDir = NULL;
iter->mount = (romfs_mount*)r->deviceData;
DIR_ITER *romfs_diropen(struct _reent *r, DIR_ITER *dirState, const char *path) {
romfs_diriter *iter = (romfs_diriter *) (dirState->dirStruct);
romfs_dir *curDir = NULL;
iter->mount = (romfs_mount *) r->deviceData;
r->_errno = navigateToDir(iter->mount, &curDir, &path, true);
if(r->_errno != 0)
if (r->_errno != 0)
return NULL;
iter->dir = curDir;
iter->state = 0;
iter->childDir = REVERSE_INT(curDir->childDir);
iter->dir = curDir;
iter->state = 0;
iter->childDir = REVERSE_INT(curDir->childDir);
iter->childFile = REVERSE_INT(curDir->childFile);
return dirState;
}
int romfs_dirreset(struct _reent *r, DIR_ITER *dirState) {
romfs_diriter* iter = (romfs_diriter*)(dirState->dirStruct);
romfs_diriter *iter = (romfs_diriter *) (dirState->dirStruct);
iter->state = 0;
iter->childDir = REVERSE_INT(iter->dir->childDir);
iter->state = 0;
iter->childDir = REVERSE_INT(iter->dir->childDir);
iter->childFile = REVERSE_INT(iter->dir->childFile);
return 0;
}
int romfs_dirnext(struct _reent *r, DIR_ITER *dirState, char *filename, struct stat *filestat) {
romfs_diriter* iter = (romfs_diriter*)(dirState->dirStruct);
romfs_diriter *iter = (romfs_diriter *) (dirState->dirStruct);
if(iter->state == 0) {
if (iter->state == 0) {
/* '.' entry */
memset(filestat, 0, sizeof(*filestat));
filestat->st_ino = dir_inode(iter->mount, iter->dir);
filestat->st_ino = dir_inode(iter->mount, iter->dir);
filestat->st_mode = romFS_dir_mode;
strcpy(filename, ".");
iter->state = 1;
return 0;
} else if(iter->state == 1) {
} else if (iter->state == 1) {
/* '..' entry */
romfs_dir* dir = romFS_dir(iter->mount, REVERSE_INT(iter->dir->parent));
romfs_dir *dir = romFS_dir(iter->mount, REVERSE_INT(iter->dir->parent));
memset(filestat, 0, sizeof(*filestat));
filestat->st_ino = dir_inode(iter->mount, dir);
@ -655,8 +666,8 @@ int romfs_dirnext(struct _reent *r, DIR_ITER *dirState, char *filename, struct s
return 0;
}
if(iter->childDir != romFS_none) {
romfs_dir* dir = romFS_dir(iter->mount, iter->childDir);
if (iter->childDir != romFS_none) {
romfs_dir *dir = romFS_dir(iter->mount, iter->childDir);
iter->childDir = REVERSE_INT(dir->sibling);
memset(filestat, 0, sizeof(*filestat));
@ -665,16 +676,16 @@ int romfs_dirnext(struct _reent *r, DIR_ITER *dirState, char *filename, struct s
memset(filename, 0, NAME_MAX);
if(REVERSE_INT(dir->nameLen) >= NAME_MAX) {
if (REVERSE_INT(dir->nameLen) >= NAME_MAX) {
r->_errno = ENAMETOOLONG;
return -1;
}
strncpy(filename, (char*)dir->name, REVERSE_INT(dir->nameLen));
strncpy(filename, (char *) dir->name, REVERSE_INT(dir->nameLen));
return 0;
} else if(iter->childFile != romFS_none) {
romfs_file* file = romFS_file(iter->mount, iter->childFile);
} else if (iter->childFile != romFS_none) {
romfs_file *file = romFS_file(iter->mount, iter->childFile);
iter->childFile = REVERSE_INT(file->sibling);
memset(filestat, 0, sizeof(*filestat));
@ -683,12 +694,12 @@ int romfs_dirnext(struct _reent *r, DIR_ITER *dirState, char *filename, struct s
memset(filename, 0, NAME_MAX);
if(REVERSE_INT(file->nameLen) >= NAME_MAX) {
if (REVERSE_INT(file->nameLen) >= NAME_MAX) {
r->_errno = ENAMETOOLONG;
return -1;
}
strncpy(filename, (char*)file->name, REVERSE_INT(file->nameLen));
strncpy(filename, (char *) file->name, REVERSE_INT(file->nameLen));
return 0;
}

4
src/utils/romfs_dev.h
View File

@ -54,7 +54,7 @@ extern "C" {
* @brief Mounts the Application's RomFS.
* @param name Device mount name.
*/
int32_t romfsMount(const char *name, const char * path);
int32_t romfsMount(const char *name, const char *path);
/**
@ -82,7 +82,7 @@ typedef struct {
uint64_t offset; ///< Length of the file's data.
} romfs_fileInfo;
int romfs_GetFileInfoPerPath(const char* romfs, const char *path, romfs_fileInfo* out);
int romfs_GetFileInfoPerPath(const char *romfs, const char *path, romfs_fileInfo *out);
#ifdef __cplusplus
}

26
src/utils/utils.c
View File

@ -7,31 +7,31 @@
#include <utils/logger.h>
// https://gist.github.com/ccbrown/9722406
void dumpHex(const void* data, size_t size) {
void dumpHex(const void *data, size_t size) {
char ascii[17];
size_t i, j;
ascii[16] = '\0';
DEBUG_FUNCTION_LINE("0x%08X (0x0000): ", data);
for (i = 0; i < size; ++i) {
log_printf("%02X ", ((unsigned char*)data)[i]);
if (((unsigned char*)data)[i] >= ' ' && ((unsigned char*)data)[i] <= '~') {
ascii[i % 16] = ((unsigned char*)data)[i];
log_printf("%02X ", ((unsigned char *) data)[i]);
if (((unsigned char *) data)[i] >= ' ' && ((unsigned char *) data)[i] <= '~') {
ascii[i % 16] = ((unsigned char *) data)[i];
} else {
ascii[i % 16] = '.';
}
if ((i+1) % 8 == 0 || i+1 == size) {
if ((i + 1) % 8 == 0 || i + 1 == size) {
log_printf(" ");
if ((i+1) % 16 == 0) {
if ((i + 1) % 16 == 0) {
log_printf("| %s \n", ascii);
if(i + 1 < size) {
DEBUG_FUNCTION_LINE("0x%08X (0x%04X); ", data + i + 1,i+1);
if (i + 1 < size) {
DEBUG_FUNCTION_LINE("0x%08X (0x%04X); ", data + i + 1, i + 1);
}
} else if (i+1 == size) {
ascii[(i+1) % 16] = '\0';
if ((i+1) % 16 <= 8) {
} else if (i + 1 == size) {
ascii[(i + 1) % 16] = '\0';
if ((i + 1) % 16 <= 8) {
log_printf(" ");
}
for (j = (i+1) % 16; j < 16; ++j) {
for (j = (i + 1) % 16; j < 16; ++j) {
log_printf(" ");
}
log_printf("| %s \n", ascii);
@ -66,7 +66,7 @@ char *str_replace(char *orig, char *rep, char *with) {
ins = tmp + len_rep;
}
tmp = result = (char*)malloc(strlen(orig) + (len_with - len_rep) * count + 1);
tmp = result = (char *) malloc(strlen(orig) + (len_with - len_rep) * count + 1);
if (!result)
return NULL;

14
src/utils/utils.h
View File

@ -7,12 +7,12 @@
extern "C" {
#endif
#define LIMIT(x, min, max) \
({ \
typeof( x ) _x = x; \
typeof( min ) _min = min; \
typeof( max ) _max = max; \
( ( ( _x ) < ( _min ) ) ? ( _min ) : ( ( _x ) > ( _max ) ) ? ( _max) : ( _x ) ); \
#define LIMIT(x, min, max) \
({ \
typeof( x ) _x = x; \
typeof( min ) _min = min; \
typeof( max ) _max = max; \
( ( ( _x ) < ( _min ) ) ? ( _min ) : ( ( _x ) > ( _max ) ) ? ( _max) : ( _x ) ); \
})
#define DegToRad(a) ( (a) * 0.01745329252f )
@ -29,7 +29,7 @@ extern "C" {
#define le64(i) ((((uint64_t)le32((i) & 0xFFFFFFFFLL)) << 32) | ((uint64_t)le32(((i) & 0xFFFFFFFF00000000LL) >> 32)))
//Needs to have log_init() called beforehand.
void dumpHex(const void* data, size_t size);
void dumpHex(const void *data, size_t size);
char *str_replace(char *orig, char *rep, char *with);
#ifdef __cplusplus