mini/jfile.cpp

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include "jfile.h"
#include <sys/stat.h>
#include <unistd.h>
#include <string>
#include <vector>

#ifndef _WIN32
#include <pwd.h>
#endif

#define DEFAULT_FILENAME    "data.jrf"
#define DEFAULT_FOLDER      "data/"
#define CONFIG_FILENAME      "config.txt"

#pragma pack(push,1)
struct DATA_Header {
	char magic[4];
	uint32_t num_files;
	uint32_t index_offset;
};

struct DATA_Info {
	uint32_t	offset;
	uint32_t	length;
	char	name[13];
};

struct DATA_Index {
	DATA_Info*	file_info;
};

struct DATA_File {
	DATA_Header	header;
	DATA_Index	index;
};

#pragma pack(pop)

/* El std::map me fa coses rares, vaig a usar un good old std::vector amb una estructura key,value propia i au, que sempre funciona */
struct keyvalue_t {
	std::string key, value;
};

char *resource_filename = NULL;
char *resource_folder = NULL;
DATA_File *data_file = NULL;
int file_source = SOURCE_FILE;
char scratch[255];
std::string config_folder = NULL;
std::vector<keyvalue_t> config;

void file_setresourcefilename(const char *str) {
    if (resource_filename != NULL) free(resource_filename);
    resource_filename = (char*)malloc(strlen(str)+1);
    strcpy(resource_filename, str);
}

void file_setresourcefolder(const char *str) {
    if (resource_folder != NULL) free(resource_folder);
    resource_folder = (char*)malloc(strlen(str)+1);
    strcpy(resource_folder, str);
}

void file_setsource(const int src) {
    file_source = src%2; // mod 2 so it always is a valid value, 0 (file) or 1 (folder)
	if (src==SOURCE_FOLDER && resource_folder==NULL) file_setresourcefolder(DEFAULT_FOLDER);
}

bool file_getdictionary() {
    if (resource_filename == NULL) file_setresourcefilename(DEFAULT_FILENAME);
    FILE* f = fopen(resource_filename, "rb");
	if (f) {
	    data_file = (DATA_File*)malloc(sizeof(DATA_File));
        fread((char*)&data_file->header, sizeof(DATA_Header), 1, f);
        fseek(f, data_file->header.index_offset, SEEK_SET);
    	data_file->index.file_info = (DATA_Info*)malloc(data_file->header.num_files * sizeof(DATA_Info));
        fread((char*)data_file->index.file_info, data_file->header.num_files * sizeof(DATA_Info), 1, f);
    	fclose(f);
        return true;
    } else {
        return false;
    }
}

char *file_getfilenamewithfolder(const char* filename) {
	strcpy(scratch, resource_folder);
	strcat(scratch, filename);
	return scratch;
}

FILE *file_getfilepointer(const char *resourcename, int& filesize, const bool binary) {

    if (file_source==SOURCE_FILE and not data_file) {
        if (not file_getdictionary()) file_setsource(SOURCE_FOLDER);
    }

    FILE *f;

    if (file_source==SOURCE_FILE) {
	    bool found = false;
	    uint32_t count = 0;
	    while( !found && count < data_file->header.num_files ) {
		    found = ( strcmp( resourcename, data_file->index.file_info[count].name ) == 0 );
		    if( !found ) count++;
	    }

	    if( !found ) {
		    perror("El recurs no s'ha trobat en l'arxiu de recursos");
		    exit(1);
	    }

	    filesize = data_file->index.file_info[count].length;

        f = fopen(resource_filename, binary?"rb":"r");
	    if (not f) {
		    perror("No s'ha pogut obrir l'arxiu de recursos");
		    exit(1);
	    }
        fseek(f, data_file->index.file_info[count].offset, SEEK_SET);
	} else {
		f = fopen(file_getfilenamewithfolder(resourcename), binary?"rb":"r");
		fseek(f, 0, SEEK_END);
		filesize = ftell(f);
        fseek(f, 0, SEEK_SET);
	}
	return f;
}

char *file_getfilebuffer(const char *resourcename, int& filesize) {
	FILE *f = file_getfilepointer(resourcename, filesize, true);
	char* buffer = (char*)malloc(filesize);
	fread(buffer, filesize, 1, f);
	fclose(f);
	return buffer;
}

// Crea la carpeta del sistema donde guardar datos
void createSystemFolder(const char *foldername)
{
#ifdef _WIN32
	config_folder = std::string(getenv("APPDATA")) + "/" + foldername;
#elif __APPLE__
	struct passwd *pw = getpwuid(getuid());
	const char *homedir = pw->pw_dir;
	config_folder = std::string(homedir) + "/Library/Application Support/" + foldername;
#elif __linux__
	struct passwd *pw = getpwuid(getuid());
	const char *homedir = pw->pw_dir;
	config_folder = std::string(homedir) + "/." + foldername;
#endif

	struct stat st = {0};
	if (stat(config_folder.c_str(), &st) == -1)
	{
		errno = 0;
#ifdef _WIN32
		int ret = mkdir(config_folder.c_str());
#else
		int ret = mkdir(config_folder.c_str(), S_IRWXU);
#endif

		if (ret == -1)
		{
			switch (errno)
			{
			case EACCES:
				printf("the parent directory does not allow write");
				exit(EXIT_FAILURE);

			case EEXIST:
				printf("pathname already exists");
				exit(EXIT_FAILURE);

			case ENAMETOOLONG:
				printf("pathname is too long");
				exit(EXIT_FAILURE);

			default:
				perror("mkdir");
				exit(EXIT_FAILURE);
			}
		}
	}
}

void file_loadconfigvalues() {
	config.clear();
	std::string config_file = config_folder + "/config.txt";
	FILE *f = fopen(config_file.c_str(), "r");
	if (f) {
		while (!feof(f)) {
			char key[100], value[100];
			fscanf(f, "%s = %S", key, value);
			config.push_back({key, value});
		}
		fclose(f);
	}
}

void file_saveconfigvalues() {
	std::string config_file = config_folder + "/config.txt";
	FILE *f = fopen(config_file.c_str(), "w");
	if (f) {
		for (auto pair : config) {
			fprintf(f, "%s = %s\n", pair.key.c_str(), pair.value.c_str());
		}
		fclose(f);
	}
}

const char* file_getconfigvalue(const char *key) {
	if (config.empty()) file_loadconfigvalues();
	for (auto pair : config) {
		if (pair.key == std::string(key)) {
			strcpy(scratch, pair.value.c_str());
			return scratch;
		}
	}
	return NULL;
}

void file_setconfigvalue(const char* key, const char* value) {
	if (config.empty()) file_loadconfigvalues();
	for (auto pair : config) {
		if (pair.key == std::string(key)) {
			pair.value = value;
			file_saveconfigvalues();
			return;
		}
	}
	config.push_back({key, value});
	file_saveconfigvalues();
	return;
}