VitaShell/archiveRAR.c

#include "archiveRAR.h"
#include "main.h"

static ArchiveFileNode* root = NULL;
static int32_t filePathLength = -1;


int archiveRAROpen(const char *file) {
	root = openRARFile(file);
	if(!root) {
		return -1;
	}
	filePathLength = strlen(file);
	return 1;
}

int fileListGetRARArchiveEntries(FileList *list, const char *path, int sort) {
	if(!root)
		return -1;

	FileListEntry *entry = malloc(sizeof(FileListEntry));
	strcpy(entry->name, DIR_UP);
	entry->name_length = strlen(DIR_UP);
	entry->is_folder = 1;
	entry->type = FILE_TYPE_UNKNOWN;
	fileListAddEntry(list, entry, sort);

	ArchiveFileNode* node = NULL;
	if(strlen(path) == (filePathLength + sizeof(char)))
		node = root;
	else
		node = getFloderNodeFromPath(root,path + filePathLength + sizeof(char));

	uint32_t i = 0;
	for(; i < node->childCount; i++) {
		ArchiveFileNode* _t = (ArchiveFileNode*)(node->childPt[i]);
		FileListEntry * childentry = malloc(sizeof(FileListEntry));

		strcpy(childentry->name,_t->nodeName);
		childentry->name_length = strlen(childentry->name);
		childentry->size = _t->data.UnpSize;
		childentry->size2 = _t->data.PackSize;

		sceRtcSetDosTime(&childentry->atime,_t->data.FileTime);
		sceRtcSetDosTime(&childentry->ctime,_t->data.FileTime);
		sceRtcSetDosTime(&childentry->mtime,_t->data.FileTime);

		if(_t->data.Flags == 0x20) {
			addEndSlash(childentry->name);
			childentry->is_folder = 1;
			list->folders++;
		} else {
			childentry->type = getFileType(childentry->name);
			childentry->is_folder = 0;
			list->files++;
		}
		fileListAddEntry(list, childentry, sort);
	}
	return 1;
}

int ReadArchiveRARFile(const char *file, void *buf, int size) {
	if(filePathLength < 0)
		return -1;

	char filepath[filePathLength + sizeof(char)];
	strncpy(filepath,file,filePathLength);
	filepath[filePathLength] = '\0';
struct ExtractHeader header = {memPtr:buf,offset:0,bufferSize:size,file:0,param:NULL};
	if(extractRAR(filepath,file + (filePathLength + sizeof(char)),&header) > 0)
		return header.offset;
	else
		return -1;
}

int archiveRARFileGetstat(const char *file, SceIoStat *stat) {
	if(!root)
		return -1;

	const char* p = file + (filePathLength + sizeof(char));
	uint32_t p_length = strlen(p);

	if(p[p_length-1] == '/')
		return -1;

	ArchiveFileNode* filenode = getFileNodeFromFilePath(root,p);
	if(!filenode)
		return -1;

	if(stat) {
		stat->st_size = filenode->data.UnpSize;
		sceRtcSetDosTime(&stat->st_atime,filenode->data.FileTime);
		sceRtcSetDosTime(&stat->st_ctime,filenode->data.FileTime);
		sceRtcSetDosTime(&stat->st_mtime,filenode->data.FileTime);
	}

	return 1;
}

int getRARArchivePathInfo(const char *path, uint64_t *size, uint32_t *folders, uint32_t *files) {
	if(!root)
		return -1;

	SceIoStat stat;
	memset(&stat, 0, sizeof(SceIoStat));
	if (archiveRARFileGetstat(path, &stat) < 0) {
		FileList list;
		memset(&list, 0, sizeof(FileList));
		fileListGetRARArchiveEntries(&list, path, SORT_NONE);

		FileListEntry *entry = list.head->next; // Ignore ..

		int i;
		for (i = 0; i < list.length-1; i++) {
			char *new_path = malloc(strlen(path) + strlen(entry->name) + 2);
			snprintf(new_path, MAX_PATH_LENGTH, "%s%s", path, entry->name);

			getRARArchivePathInfo(new_path, size, folders, files);

			free(new_path);

			entry = entry->next;
		}

		if (folders)
			(*folders)++;

		fileListEmpty(&list);
	} else {
		if (size)
			(*size) += stat.st_size;

		if (files)
			(*files)++;
	}

	return 0;
}

int extractRARArchivePath(const char *src, const char *dst, FileProcessParam *param) {
	if(!root)
		return -1;

	SceIoStat stat;
	memset(&stat, 0, sizeof(SceIoStat));
	if (archiveRARFileGetstat(src, &stat) < 0) {
		FileList list;
		memset(&list, 0, sizeof(FileList));
		fileListGetRARArchiveEntries(&list, src, SORT_NONE);

		int ret = sceIoMkdir(dst, 0777);
		if (ret < 0 && ret != SCE_ERROR_ERRNO_EEXIST) {
			fileListEmpty(&list);
			return ret;
		}

		if (param) {
			if (param->value)
				(*param->value) += DIRECTORY_SIZE;

			if (param->SetProgress)
				param->SetProgress(param->value ? *param->value : 0, param->max);

			if (param->cancelHandler && param->cancelHandler()) {
				fileListEmpty(&list);
				return 0;
			}
		}

		FileListEntry *entry = list.head->next; // Ignore ..

		int i;
		for (i = 0; i < list.length-1; i++) {
			char *src_path = malloc(strlen(src) + strlen(entry->name) + 2);
			snprintf(src_path, MAX_PATH_LENGTH, "%s%s", src, entry->name);

			char *dst_path = malloc(strlen(dst) + strlen(entry->name) + 2);
			snprintf(dst_path, MAX_PATH_LENGTH, "%s%s", dst, entry->name);

			int ret = extractRARArchivePath(src_path, dst_path, param);

			free(dst_path);
			free(src_path);

			if (ret <= 0) {
				fileListEmpty(&list);
				return ret;
			}

			entry = entry->next;
		}

		fileListEmpty(&list);
	} else {
		char filepath[filePathLength + sizeof(char)];
		strncpy(filepath,src,filePathLength);
		filepath[filePathLength] = '\0';

		SceUID fddst = sceIoOpen(dst, SCE_O_WRONLY | SCE_O_CREAT | SCE_O_TRUNC, 0777);

		struct ExtractHeader header = {file:fddst,offset:0,memPtr:NULL,bufferSize:0,param:param};

		int result = extractRAR(filepath, (const char *)(src + (filePathLength + sizeof(char))), &header);
		sceIoClose(fddst);

		return result;
	}

	return 1;
}

int archiveRARClose() {
	filePathLength = -1;
	if (!root) {
		closeRARFile(root);
		root = NULL;
	}
	return 1;
}