343 lines
9.8 KiB
C
343 lines
9.8 KiB
C
#include <dirent.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#include <miniz.h>
|
|
|
|
#include "pxl8_cart.h"
|
|
#include "pxl8_macros.h"
|
|
|
|
struct pxl8_cart {
|
|
void* archive_data;
|
|
size_t archive_size;
|
|
char* base_path;
|
|
bool is_folder;
|
|
bool is_mounted;
|
|
char* name;
|
|
};
|
|
|
|
static pxl8_cart* __pxl8_current_cart = NULL;
|
|
static char* __pxl8_original_cwd = NULL;
|
|
|
|
static void pxl8_add_file_recursive(mz_zip_archive* zip, const char* dir_path, const char* prefix) {
|
|
DIR* dir = opendir(dir_path);
|
|
if (!dir) return;
|
|
|
|
struct dirent* entry;
|
|
while ((entry = readdir(dir)) != NULL) {
|
|
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue;
|
|
|
|
char full_path[1024];
|
|
char zip_path[1024];
|
|
snprintf(full_path, sizeof(full_path), "%s/%s", dir_path, entry->d_name);
|
|
snprintf(zip_path, sizeof(zip_path), "%s%s", prefix, entry->d_name);
|
|
|
|
struct stat st;
|
|
if (stat(full_path, &st) == 0) {
|
|
if (S_ISDIR(st.st_mode)) {
|
|
char new_prefix[1025];
|
|
snprintf(new_prefix, sizeof(new_prefix), "%s/", zip_path);
|
|
pxl8_add_file_recursive(zip, full_path, new_prefix);
|
|
} else {
|
|
pxl8_info("Adding: %s", zip_path);
|
|
if (!mz_zip_writer_add_file(zip, zip_path, full_path, NULL, 0, MZ_BEST_COMPRESSION)) {
|
|
pxl8_warn("Failed to add file: %s", zip_path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
closedir(dir);
|
|
}
|
|
|
|
static char* get_cart_name(const char* path) {
|
|
char* name = strdup(path);
|
|
size_t len = strlen(name);
|
|
|
|
if (len > 4 && strcmp(name + len - 4, ".pxc") == 0) {
|
|
name[len - 4] = '\0';
|
|
}
|
|
|
|
char* last_slash = strrchr(name, '/');
|
|
if (last_slash) {
|
|
char* result = strdup(last_slash + 1);
|
|
free(name);
|
|
return result;
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
static bool is_directory(const char* path) {
|
|
struct stat st;
|
|
return stat(path, &st) == 0 && S_ISDIR(st.st_mode);
|
|
}
|
|
|
|
static bool is_pxc_file(const char* path) {
|
|
size_t len = strlen(path);
|
|
return len > 4 && strcmp(path + len - 4, ".pxc") == 0;
|
|
}
|
|
|
|
pxl8_cart* pxl8_cart_create(void) {
|
|
pxl8_cart* cart = calloc(1, sizeof(pxl8_cart));
|
|
return cart;
|
|
}
|
|
|
|
pxl8_cart* pxl8_cart_current(void) {
|
|
return __pxl8_current_cart;
|
|
}
|
|
|
|
void pxl8_cart_destroy(pxl8_cart* cart) {
|
|
if (!cart) return;
|
|
pxl8_cart_unload(cart);
|
|
free(cart);
|
|
}
|
|
|
|
const char* pxl8_cart_get_base_path(const pxl8_cart* cart) {
|
|
return cart ? cart->base_path : NULL;
|
|
}
|
|
|
|
const char* pxl8_cart_get_name(const pxl8_cart* cart) {
|
|
return cart ? cart->name : NULL;
|
|
}
|
|
|
|
pxl8_result pxl8_cart_load(pxl8_cart* cart, const char* path) {
|
|
if (!cart || !path) return PXL8_ERROR_NULL_POINTER;
|
|
|
|
pxl8_cart_unload(cart);
|
|
|
|
cart->name = get_cart_name(path);
|
|
|
|
if (is_directory(path)) {
|
|
cart->base_path = realpath(path, NULL);
|
|
if (!cart->base_path) {
|
|
pxl8_error("Failed to resolve cart path: %s", path);
|
|
return PXL8_ERROR_FILE_NOT_FOUND;
|
|
}
|
|
cart->is_folder = true;
|
|
|
|
char main_path[512];
|
|
snprintf(main_path, sizeof(main_path), "%s/main.fnl", cart->base_path);
|
|
if (access(main_path, F_OK) != 0) {
|
|
snprintf(main_path, sizeof(main_path), "%s/main.lua", cart->base_path);
|
|
if (access(main_path, F_OK) != 0) {
|
|
pxl8_error("No main.fnl or main.lua found in cart: %s", path);
|
|
return PXL8_ERROR_FILE_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
pxl8_info("Loaded cart folder: %s", cart->name);
|
|
return PXL8_OK;
|
|
}
|
|
|
|
if (is_pxc_file(path)) {
|
|
FILE* file = fopen(path, "rb");
|
|
if (!file) {
|
|
pxl8_error("Failed to open cart archive: %s", path);
|
|
return PXL8_ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
cart->archive_size = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
cart->archive_data = malloc(cart->archive_size);
|
|
if (!cart->archive_data) {
|
|
fclose(file);
|
|
return PXL8_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
if (fread(cart->archive_data, 1, cart->archive_size, file) != cart->archive_size) {
|
|
free(cart->archive_data);
|
|
cart->archive_data = NULL;
|
|
fclose(file);
|
|
return PXL8_ERROR_SYSTEM_FAILURE;
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
char temp_dir[256];
|
|
snprintf(temp_dir, sizeof(temp_dir), "/tmp/pxl8_%s_%d", cart->name, getpid());
|
|
|
|
if (mkdir(temp_dir, 0755) != 0) {
|
|
pxl8_error("Failed to create temp directory: %s", temp_dir);
|
|
return PXL8_ERROR_SYSTEM_FAILURE;
|
|
}
|
|
|
|
mz_zip_archive zip = {0};
|
|
if (!mz_zip_reader_init_mem(&zip, cart->archive_data, cart->archive_size, 0)) {
|
|
pxl8_error("Failed to open cart archive as zip");
|
|
return PXL8_ERROR_INVALID_FORMAT;
|
|
}
|
|
|
|
i32 num_files = mz_zip_reader_get_num_files(&zip);
|
|
for (i32 i = 0; i < num_files; i++) {
|
|
mz_zip_archive_file_stat file_stat;
|
|
if (!mz_zip_reader_file_stat(&zip, i, &file_stat)) continue;
|
|
|
|
char extract_path[1024];
|
|
snprintf(extract_path, sizeof(extract_path), "%s/%s", temp_dir, file_stat.m_filename);
|
|
|
|
if (file_stat.m_is_directory) {
|
|
mkdir(extract_path, 0755);
|
|
} else {
|
|
char* last_slash = strrchr(extract_path, '/');
|
|
if (last_slash) {
|
|
*last_slash = '\0';
|
|
mkdir(extract_path, 0755);
|
|
*last_slash = '/';
|
|
}
|
|
|
|
if (!mz_zip_reader_extract_to_file(&zip, i, extract_path, 0)) {
|
|
pxl8_warn("Failed to extract: %s", file_stat.m_filename);
|
|
}
|
|
}
|
|
}
|
|
|
|
mz_zip_reader_end(&zip);
|
|
|
|
cart->base_path = strdup(temp_dir);
|
|
cart->is_folder = false;
|
|
|
|
pxl8_info("Loaded cart archive: %s", cart->name);
|
|
return PXL8_OK;
|
|
}
|
|
|
|
pxl8_error("Unknown cart format: %s", path);
|
|
return PXL8_ERROR_INVALID_FORMAT;
|
|
}
|
|
|
|
void pxl8_cart_unload(pxl8_cart* cart) {
|
|
if (!cart) return;
|
|
|
|
pxl8_cart_unmount(cart);
|
|
|
|
if (!cart->is_folder && cart->base_path) {
|
|
char cmd[512];
|
|
snprintf(cmd, sizeof(cmd), "rm -rf %s", cart->base_path);
|
|
system(cmd);
|
|
}
|
|
|
|
char* cart_name = cart->name ? strdup(cart->name) : NULL;
|
|
|
|
if (cart->base_path) {
|
|
free(cart->base_path);
|
|
cart->base_path = NULL;
|
|
}
|
|
|
|
if (cart->name) {
|
|
free(cart->name);
|
|
cart->name = NULL;
|
|
}
|
|
|
|
if (cart->archive_data) {
|
|
free(cart->archive_data);
|
|
cart->archive_data = NULL;
|
|
}
|
|
|
|
cart->archive_size = 0;
|
|
cart->is_folder = false;
|
|
cart->is_mounted = false;
|
|
|
|
if (cart_name) {
|
|
pxl8_info("Unloaded cart: %s", cart_name);
|
|
free(cart_name);
|
|
}
|
|
}
|
|
|
|
pxl8_result pxl8_cart_mount(pxl8_cart* cart) {
|
|
if (!cart || !cart->base_path) return PXL8_ERROR_NULL_POINTER;
|
|
if (cart->is_mounted) return PXL8_OK;
|
|
|
|
if (__pxl8_current_cart) {
|
|
pxl8_cart_unmount(__pxl8_current_cart);
|
|
}
|
|
|
|
__pxl8_original_cwd = getcwd(NULL, 0);
|
|
if (chdir(cart->base_path) != 0) {
|
|
pxl8_error("Failed to change to cart directory: %s", cart->base_path);
|
|
free(__pxl8_original_cwd);
|
|
__pxl8_original_cwd = NULL;
|
|
return PXL8_ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
cart->is_mounted = true;
|
|
__pxl8_current_cart = cart;
|
|
|
|
pxl8_info("Mounted cart: %s", cart->name);
|
|
return PXL8_OK;
|
|
}
|
|
|
|
void pxl8_cart_unmount(pxl8_cart* cart) {
|
|
if (!cart || !cart->is_mounted) return;
|
|
|
|
if (__pxl8_original_cwd) {
|
|
chdir(__pxl8_original_cwd);
|
|
free(__pxl8_original_cwd);
|
|
__pxl8_original_cwd = NULL;
|
|
}
|
|
|
|
cart->is_mounted = false;
|
|
if (__pxl8_current_cart == cart) {
|
|
__pxl8_current_cart = NULL;
|
|
}
|
|
|
|
pxl8_info("Unmounted cart: %s", cart->name);
|
|
}
|
|
|
|
bool pxl8_cart_resolve_path(const pxl8_cart* cart, const char* relative_path, char* out_path, size_t out_size) {
|
|
if (!cart || !cart->base_path || !relative_path || !out_path || out_size == 0) return false;
|
|
|
|
i32 written = snprintf(out_path, out_size, "%s/%s", cart->base_path, relative_path);
|
|
return written >= 0 && (size_t)written < out_size;
|
|
}
|
|
|
|
bool pxl8_cart_file_exists(const pxl8_cart* cart, const char* path) {
|
|
if (!cart || !cart->base_path || !path) return false;
|
|
|
|
char full_path[512];
|
|
if (!pxl8_cart_resolve_path(cart, path, full_path, sizeof(full_path))) return false;
|
|
|
|
return access(full_path, F_OK) == 0;
|
|
}
|
|
|
|
pxl8_result pxl8_cart_pack(const char* folder_path, const char* output_path) {
|
|
if (!folder_path || !output_path) return PXL8_ERROR_NULL_POINTER;
|
|
|
|
if (!is_directory(folder_path)) {
|
|
pxl8_error("Cart folder not found: %s", folder_path);
|
|
return PXL8_ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
char main_path[512];
|
|
snprintf(main_path, sizeof(main_path), "%s/main.fnl", folder_path);
|
|
if (access(main_path, F_OK) != 0) {
|
|
snprintf(main_path, sizeof(main_path), "%s/main.lua", folder_path);
|
|
if (access(main_path, F_OK) != 0) {
|
|
pxl8_error("No main.fnl or main.lua found in cart: %s", folder_path);
|
|
return PXL8_ERROR_FILE_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
mz_zip_archive zip = {0};
|
|
if (!mz_zip_writer_init_file(&zip, output_path, 0)) {
|
|
pxl8_error("Failed to create archive: %s", output_path);
|
|
return PXL8_ERROR_SYSTEM_FAILURE;
|
|
}
|
|
|
|
pxl8_info("Packing cart: %s -> %s", folder_path, output_path);
|
|
pxl8_add_file_recursive(&zip, folder_path, "");
|
|
|
|
if (!mz_zip_writer_finalize_archive(&zip)) {
|
|
pxl8_error("Failed to finalize archive");
|
|
mz_zip_writer_end(&zip);
|
|
return PXL8_ERROR_SYSTEM_FAILURE;
|
|
}
|
|
|
|
mz_zip_writer_end(&zip);
|
|
pxl8_info("Cart packed successfully!");
|
|
return PXL8_OK;
|
|
}
|