diff --git a/CMakeLists.txt b/CMakeLists.txt index 6c4d169..dcd6dd4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,20 +1,34 @@ cmake_minimum_required(VERSION 3.10) +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +if(CMAKE_BUILD_TYPE MATCHES DEBUG) + add_link_options(-fsanitize=address) +endif() + +set(CMAKE_C_FLAGS "-Wall -Wextra -pedantic -Wcast-qual -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wmaybe-uninitialized") +set(CMAKE_C_FLAGS_DEBUG "-g -fsanitize=address -Werror -O0") +set(CMAKE_C_FLAGS_RELEASE "-g") # generate the compile_commands for vscode / clang set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE INTERNAL "") # set the project name -project(ModManager) +project(mod-manager) set(SOURCES src/steam.c + src/loadOrder.c src/install.c src/overlayfs.c + src/getDataPath.c src/getHome.c src/file.c src/order.c + src/archives.c src/fomod.c src/fomod/group.c src/fomod/xmlUtil.c @@ -23,9 +37,7 @@ set(SOURCES ) # add the executable -add_executable(ModManager src/main.c ${SOURCES}) - -add_compile_options(-Wall -Wextra -pedantic -Werror) +add_executable(mod-manager src/main.c ${SOURCES}) find_package(PkgConfig REQUIRED) pkg_search_module(GLIB REQUIRED glib-2.0) @@ -33,17 +45,17 @@ pkg_search_module(AUDIT REQUIRED audit) pkg_search_module(LIBXML REQUIRED libxml-2.0) pkg_search_module(GTK REQUIRED gtk4) -target_include_directories(ModManager PRIVATE ${GLIB_INCLUDE_DIRS}) -target_include_directories(ModManager PRIVATE ${LIBXML_INCLUDE_DIRS}) -target_include_directories(ModManager PRIVATE ${AUDIT_INCLUDE_DIRS}) -target_include_directories(ModManager PRIVATE ${GTK_INCLUDE_DIRS}) +target_include_directories(mod-manager PRIVATE ${GLIB_INCLUDE_DIRS}) +target_include_directories(mod-manager PRIVATE ${LIBXML_INCLUDE_DIRS}) +target_include_directories(mod-manager PRIVATE ${AUDIT_INCLUDE_DIRS}) +target_include_directories(mod-manager PRIVATE ${GTK_INCLUDE_DIRS}) -add_compile_options(-fsanitize=address) -add_link_options(-fsanitize=address) -target_link_libraries(ModManager ${GLIB_LDFLAGS}) -target_link_libraries(ModManager ${LIBXML_LIBRARIES}) -target_link_libraries(ModManager ${AUDIT_LIBRARIES}) -target_link_libraries(ModManager ${GTK_LIBRARIES}) +target_link_libraries(mod-manager ${GLIB_LDFLAGS}) +target_link_libraries(mod-manager ${LIBXML_LIBRARIES}) +target_link_libraries(mod-manager ${AUDIT_LIBRARIES}) +target_link_libraries(mod-manager ${GTK_LIBRARIES}) -install(TARGETS ModManager DESTINATION bin) +install(TARGETS mod-manager DESTINATION bin) + +set_property(TARGET mod-manager PROPERTY C_STANDARD 23) diff --git a/PKGBUILD b/PKGBUILD new file mode 100644 index 0000000..71491fd --- /dev/null +++ b/PKGBUILD @@ -0,0 +1,26 @@ +# Maintainer: Marc barbier +pkgname=modmanager +pkgver=0.1 +pkgrel=1 +pkgdesc="a Mod manager for bethesda games" +arch=('x86_64') # might work on other archs but i can not try +url='https://gitlab.marcbarbier.fr/Marc/modmanager' +license=('GPL2') +source=( 'git+https://gitlab.marcbarbier.fr/Marc/modmanager.git' ) +md5sums=( 'SKIP' ) + +optdepends=('fuse-overlayfs: special filesystem support' ) + +depends=( 'glib2' 'unrar' 'p7zip' 'unzip' ) + +build() { + cmake -B build -S "${pkgname}" \ + -DCMAKE_BUILD_TYPE='None' \ + -DCMAKE_INSTALL_PREFIX='/usr' \ + -Wno-dev + cmake --build build +} + +package() { + DESTDIR="$pkgdir" cmake --install build +} diff --git a/naming_conventions.md b/naming_conventions.md new file mode 100644 index 0000000..2b090e1 --- /dev/null +++ b/naming_conventions.md @@ -0,0 +1,19 @@ +# Current naming conventions (subject to debate) + +## Function names + +### shared functions + +function should start by the name of their module in camelCase followed by an underscore and the name of the function in camelCase + +example: + steam_searchGames() + + +### static functions + +there is no rule for now + +## Struct names + +function should start by the name of their module in camelCase followed by an underscore and the name of the struct in PascalCase diff --git a/src/archives.c b/src/archives.c new file mode 100644 index 0000000..b774baf --- /dev/null +++ b/src/archives.c @@ -0,0 +1,96 @@ +#include "archives.h" +#include "file.h" + +#include +#include +#include +#include +#include +#include + +int archive_unzip(char * path, char * outdir) { + char * const args[] = { + "unzip", + "-LL", // to lowercase + "-q", + path, + "-d", + outdir, + NULL + }; + + pid_t pid = fork(); + + if(pid == 0) { + execv("/usr/bin/unzip", args); + return EXIT_FAILURE; + } else { + int returnValue; + waitpid(pid, &returnValue, 0); + + if(returnValue != 0) { + fprintf(stderr, "\nFailed to decompress archive\n"); + } + return returnValue; + } +} + +int archive_unrar(char * path, char * outdir) { + char * const args[] = { + "unrar", + "x", + "-y", //assume yes + "-cl", // to lowercase + path, + outdir, + NULL + }; + + pid_t pid = fork(); + + if(pid == 0) { + execv("/usr/bin/unrar", args); + return EXIT_FAILURE; + } else { + int returnValue; + waitpid(pid, &returnValue, 0); + + if(returnValue != 0) { + fprintf(stderr, "\nFailed to decompress archive\n"); + } + return returnValue; + } +} + + +int archive_un7z(char * path, const char * outdir) { + gchar * outParameter = g_strjoin("", "-o", outdir, NULL); + + char * const args[] = { + "7z", + "-y", //assume yes + "x", + path, + outParameter, + NULL + }; + + pid_t pid = fork(); + + if(pid == 0) { + execv("/usr/bin/7z", args); + return EXIT_FAILURE; + } else { + g_free(outParameter); + int returnValue; + waitpid(pid, &returnValue, 0); + + if(returnValue != 0) { + fprintf(stderr, "\nFailed to decompress archive\n"); + return returnValue; + } + //make everything lowercase since 7z don't have an argument for that. + file_casefold(outdir); + return returnValue; + } +} diff --git a/src/archives.h b/src/archives.h new file mode 100644 index 0000000..d1be6d1 --- /dev/null +++ b/src/archives.h @@ -0,0 +1,30 @@ +#ifndef __ARCHIVES_H__ +#define __ARCHIVES_H__ + +//all of these function will make every file into lowercase + +/** + * @brief Execute the unzip command + * @param path path to archive + * @param outdir output director + * @return int return code + */ +int archive_unzip(char * path, char * outdir); + +/** + * @brief Execute the unrar command + * @param path path to archive + * @param outdir output director + * @return int return code + */ +int archive_unrar(char * path, char * outdir); + +/** + * @brief Execute the 7z command + * @param path path to archive + * @param outdir output director + * @return int return code + */ +int archive_un7z(char * path, const char * outdir); + +#endif diff --git a/src/file.c b/src/file.c index b4439a7..30d7ca6 100644 --- a/src/file.c +++ b/src/file.c @@ -8,39 +8,41 @@ #include #include "file.h" -u_int32_t countSetBits(u_int32_t n) { - // base case - if (n == 0) - return 0; - else - // if last bit set add 1 else add 0 - return (n & 1) + countSetBits(n >> 1); +static u_int32_t countSetBits(u_int32_t n) { + // base case + if (n == 0) + return 0; + else + // if last bit set add 1 else add 0 + return (n & 1) + countSetBits(n >> 1); } //TODO: add interruption support //simplest way to copy a file in c(linux) -int copy(const char * path, const char * dest, u_int32_t flags) { +int file_copy(const char * path, const char * dest, u_int32_t flags) { int flagCount = countSetBits(flags); if(flagCount > 3) { - printf("Invalid flags for cp command\n"); + fprintf(stderr, "Invalid flags for cp command\n"); return -1; } //flags + cp + path + dest - const char * args[flagCount + 4]; + char * args[flagCount + 4]; args[0] = "/bin/cp"; - args[1] = path; - args[2] = dest; + args[1] = alloca((strlen(path) + 1) * sizeof(char)); + strcpy(args[1], path); + args[2] = alloca((strlen(dest) + 1) * sizeof(char)); + strcpy(args[2], dest); int argIndex = 3; - if(flags & CP_LINK) { + if(flags & FILE_CP_LINK) { args[argIndex] = "--link"; argIndex += 1; } - if(flags & CP_RECURSIVE) { + if(flags & FILE_CP_RECURSIVE) { args[argIndex] = "-r"; argIndex += 1; } - if(flags & CP_NO_TARGET_DIR) { + if(flags & FILE_CP_NO_TARGET_DIR) { args[argIndex] = "-T"; argIndex += 1; } @@ -50,7 +52,7 @@ int copy(const char * path, const char * dest, u_int32_t flags) { int pid = fork(); if(pid == 0) { //discard the const. since we are in a fork we don't care. - execv("/bin/cp", (char **)args); + execv("/bin/cp", args); return 0; } else { int returnValue; @@ -59,7 +61,7 @@ int copy(const char * path, const char * dest, u_int32_t flags) { } } -int delete(const char * path, bool recursive) { +int file_delete(const char * path, bool recursive) { int pid = fork(); if(pid == 0) { if(recursive) { @@ -75,7 +77,7 @@ int delete(const char * path, bool recursive) { } } -int move(const char * source, const char * destination) { +int file_move(const char * source, const char * destination) { int pid = fork(); if(pid == 0) { execl("/bin/mv", "/bin/mv", source, destination, NULL); @@ -90,7 +92,7 @@ int move(const char * source, const char * destination) { //rename a folder and all subfolder and files to lowercase //TODO: error handling -void casefold(const char * folder) { +void file_casefold(const char * folder) { DIR * d = opendir(folder); struct dirent *dir; if (d) { @@ -98,24 +100,53 @@ void casefold(const char * folder) { //removes .. & . from the list if(strcmp(dir->d_name, "..") != 0 && strcmp(dir->d_name, ".") != 0) { //only look at ascii and hope for the best. - gchar * file = g_build_path("/", folder, dir->d_name, NULL); + gchar * file = g_build_filename(folder, dir->d_name, NULL); gchar * destinationName = g_ascii_strdown(dir->d_name, -1); gchar * destination = g_build_path("/", folder,destinationName, NULL); - int result = move(file, destination); - if(result != EXIT_SUCCESS) { - printf("Move failed: %s => %s \n", dir->d_name, destinationName); - } - g_free(destinationName); - g_free(destination); - if(dir->d_type == DT_DIR) { - casefold(file); + if(strcmp(destinationName, dir->d_name) != 0) { + + int result = file_move(file, destination); + if(result != EXIT_SUCCESS) { + fprintf(stderr, "Move failed: %s => %s \n", dir->d_name, destinationName); + } + + } g_free(file); + g_free(destinationName); + + if(dir->d_type == DT_DIR) { + file_casefold(destination); + } + + g_free(destination); } } closedir(d); } } + +const char * file_extractLastPart(const char * filePath, const char delimeter) { + const int length = strlen(filePath); + long index = -1; + for(long i= length - 1; i >= 0; i--) { + if(filePath[i] == delimeter) { + index = i + 1; + break; + } + } + + if(index <= 0 || index == length) return NULL; + return &filePath[index]; +} + +const char * file_extractExtension(const char * filePath) { + return file_extractLastPart(filePath, '.'); +} + +const char * file_extractFileName(const char * filePath) { + return file_extractLastPart(filePath, '/'); +} diff --git a/src/file.h b/src/file.h index 3c1be0c..57d5618 100644 --- a/src/file.h +++ b/src/file.h @@ -1,33 +1,34 @@ -#include -#include - #ifndef __FILE_H__ #define __FILE_H__ +#include +#include +#include "main.h" + //valid copy flags -#define cp_DEFAULT 0 -#define CP_LINK 1 -#define CP_RECURSIVE 2 -#define CP_NO_TARGET_DIR 4 +#define FILE_CP_DEFAULT 0 +#define FILE_CP_LINK 1 +#define FILE_CP_RECURSIVE 2 +#define FILE_CP_NO_TARGET_DIR 4 /** * @brief execute the cp command from the source to the dest * @param source path to the source files * @param dest path to the destination folder * @param flags refer to the "valid copy flags" use them like this CP_LINK | CP_RECURSIVE - * @return status code + * @return cp return value */ -int copy(const char * source, const char * dest, u_int32_t flags); +int file_copy(const char * source, const char * dest, u_int32_t flags); /** * @brief execute the cp command from the source to the dest * @param source path to the source files * @param dest path to the destination folder * @param bool enable recursive rm -r - * @return status code + * @return rm return value */ -int delete(const char * path, bool recursive); +int file_delete(const char * path, bool recursive); /** * @brief Run the mv command @@ -35,13 +36,30 @@ int delete(const char * path, bool recursive); * @param destination * @return mv's exit value */ -int move(const char * source, const char * destination); +int file_move(const char * source, const char * destination); /** * @brief Recursively rename all file and folder to lowercase. * * @param folder */ -void casefold(const char * folder); +void file_casefold(const char * folder); + + +const char * file_extractLastPart(const char * filePath, const char delimeter); + +/** + * @brief Return the extension of a file by looking for the character '.' + * @param filePath + * @return return a pointer to the address after the '.' or null if it was not found; + */ +const char * file_extractExtension(const char * filePath); + +/** + * @brief Return the file name by looking for the last character '/' + * @param filePath + * @return return a pointer to the address after the last '/' or null if it was not found (the path might not be a path in this case) + */ +const char * file_extractFileName(const char * filePath); #endif diff --git a/src/fomod.c b/src/fomod.c index 3d5c2e8..11375f7 100644 --- a/src/fomod.c +++ b/src/fomod.c @@ -12,16 +12,19 @@ #include "fomod.h" #include "file.h" +#include "fomod/fomodTypes.h" +#include "fomod/group.h" #include "libxml/globals.h" +#include "main.h" -int getInputCount(const char * input) { +static int getInputCount(const char * input) { char buff[2]; buff[1] = '\0'; int elementCount = 0; bool prevWasValue = false; - for(int i = 0; input + i != NULL && input[i] != '\0' && input[i] != '\n'; i++) { + for(int i = 0; input[i] != '\0' && input[i] != '\n'; i++) { buff[0] = input[i]; //if the character is a valid character @@ -40,21 +43,21 @@ int getInputCount(const char * input) { return elementCount; } -gint priorityCmp(gconstpointer a, gconstpointer b) { - const FOModFile_t * fileA = (const FOModFile_t *)a; - const FOModFile_t * fileB = (const FOModFile_t *)b; +static gint priorityCmp(gconstpointer a, gconstpointer b) { + const fomod_File_t * fileA = (const fomod_File_t *)a; + const fomod_File_t * fileB = (const fomod_File_t *)b; - return fileA->priority - fileB->priority; + return fileB->priority - fileA->priority; } -void printfOptionsInOrder(FOModGroup_t group) { +static void fomod_printOptionsInOrder(fomod_Group_t group) { for(int i = 0; i < group.pluginCount; i++) { printf("%d, %s\n", i, group.plugins[i].name); printf("%s\n", group.plugins[i].description); } } -gint flagEqual(const FOModFlag_t * a, const FOModFlag_t * b) { +static gint fomod_flagEqual(const fomod_Flag_t * a, const fomod_Flag_t * b) { int nameCmp = strcmp(a->name, b->name); if(nameCmp == 0) { if(strcmp(a->value, b->value) == 0) @@ -66,20 +69,20 @@ gint flagEqual(const FOModFlag_t * a, const FOModFlag_t * b) { return nameCmp; } -int stepCmpAsc(const void * stepA, const void * stepB) { +static int stepCmpAsc(const void * stepA, const void * stepB) { const FOModStep_t * step1 = (const FOModStep_t *)stepA; const FOModStep_t * step2 = (const FOModStep_t *)stepB; return strcmp(step1->name, step2->name); } -int stepCmpDesc(const void * stepA, const void * stepB) { +static int stepCmpDesc(const void * stepA, const void * stepB) { const FOModStep_t * step1 = (const FOModStep_t *)stepA; const FOModStep_t * step2 = (const FOModStep_t *)stepB; return 1 - strcmp(step1->name, step2->name); } -void sortSteps(FOMod_t * fomod) { +static void fomod_sortSteps(FOMod_t * fomod) { switch(fomod->stepOrder) { case ASC: qsort(fomod->steps, fomod->stepCount, sizeof(*fomod->steps), stepCmpAsc); @@ -93,25 +96,25 @@ void sortSteps(FOMod_t * fomod) { } } -int groupCmpAsc(const void * stepA, const void * stepB) { - const FOModGroup_t * step1 = (const FOModGroup_t *)stepA; - const FOModGroup_t * step2 = (const FOModGroup_t *)stepB; +static int fomod_groupCmpAsc(const void * stepA, const void * stepB) { + const fomod_Group_t * step1 = (const fomod_Group_t *)stepA; + const fomod_Group_t * step2 = (const fomod_Group_t *)stepB; return strcmp(step1->name, step2->name); } -int groupCmpDesc(const void * stepA, const void * stepB) { - const FOModGroup_t * step1 = (const FOModGroup_t *)stepA; - const FOModGroup_t * step2 = (const FOModGroup_t *)stepB; +static int fomod_groupCmpDesc(const void * stepA, const void * stepB) { + const fomod_Group_t * step1 = (const fomod_Group_t *)stepA; + const fomod_Group_t * step2 = (const fomod_Group_t *)stepB; return 1 - strcmp(step1->name, step2->name); } -void sortGroup(FOModGroup_t * group) { +static void fomod_sortGroup(fomod_Group_t * group) { switch(group->order) { case ASC: - qsort(group->plugins, group->pluginCount, sizeof(*group->plugins), groupCmpAsc); + qsort(group->plugins, group->pluginCount, sizeof(*group->plugins), fomod_groupCmpAsc); break; case DESC: - qsort(group->plugins, group->pluginCount, sizeof(*group->plugins), groupCmpDesc); + qsort(group->plugins, group->pluginCount, sizeof(*group->plugins), fomod_groupCmpDesc); break; case ORD: //ord mean that we keep the curent order, so no need to sort anything. @@ -120,45 +123,45 @@ void sortGroup(FOModGroup_t * group) { } //TODO: handle error -int processFileOperations(GList * pendingFileOperations, const char * modFolder, const char * destination) { - pendingFileOperations = g_list_sort(pendingFileOperations, priorityCmp); - GList * currentFileOperation = pendingFileOperations; +error_t fomod_processFileOperations(GList ** pendingFileOperations, const char * modFolder, const char * destination) { + //priority higher a less important and should be processed first. + *pendingFileOperations = g_list_sort(*pendingFileOperations, priorityCmp); + GList * currentFileOperation = *pendingFileOperations; while(currentFileOperation != NULL) { //TODO: support destination //no using link since priority is made to override files and link is annoying to deal with when overriding files. - const FOModFile_t * file = (const FOModFile_t *)currentFileOperation->data; + const fomod_File_t * file = (const fomod_File_t *)currentFileOperation->data; char * source = g_build_path("/", modFolder, file->source, NULL); //fix the / and \ windows - unix paths - fixPath(source); + xml_fixPath(source); int copyResult; if(file->isFolder) { - copyResult = copy(source, destination, CP_NO_TARGET_DIR | CP_RECURSIVE); + copyResult = file_copy(source, destination, FILE_CP_NO_TARGET_DIR | FILE_CP_RECURSIVE); } else { - copyResult = copy(source, destination, 0); + copyResult = file_copy(source, destination, 0); } if(copyResult != EXIT_SUCCESS) { fprintf(stderr, "Copy failed, some file might be corrupted\n"); } - printf("source: %s, destination: %s\n", source, destination); g_free(source); currentFileOperation = g_list_next(currentFileOperation); } - return EXIT_SUCCESS; + return ERR_SUCCESS; } -GList * processCondFiles(const FOMod_t * fomod, GList * flagList, GList * pendingFileOperations) { +GList * fomod_processCondFiles(const FOMod_t * fomod, GList * flagList, GList * pendingFileOperations) { for(int condId = 0; condId < fomod->condFilesCount; condId++) { - const FOModCondFile_t *condFile = &fomod->condFiles[condId]; + const fomod_CondFile_t *condFile = &fomod->condFiles[condId]; bool areAllFlagsValid = true; //checking if all flags are valid - for(int flagId = 0; flagId < condFile->flagCount; flagId++) { - const GList * link = g_list_find_custom(flagList, &(condFile->requiredFlags[flagId]), (GCompareFunc)flagEqual); + for(long flagId = 0; flagId < condFile->flagCount; flagId++) { + const GList * link = g_list_find_custom(flagList, &(condFile->requiredFlags[flagId]), (GCompareFunc)fomod_flagEqual); if(link == NULL) { areAllFlagsValid = false; break; @@ -166,12 +169,19 @@ GList * processCondFiles(const FOMod_t * fomod, GList * flagList, GList * pendin } if(areAllFlagsValid) { - for(int fileId = 0; fileId < condFile->flagCount; fileId++) { - const FOModFile_t * file = &(condFile->files[fileId]); + for(long fileId = 0; fileId < condFile->flagCount; fileId++) { + const fomod_File_t * file = &(condFile->files[fileId]); - FOModFile_t * fileCopy = malloc(sizeof(*file)); + fomod_File_t * fileCopy = malloc(sizeof(*file)); *fileCopy = *file; + //changing pathes to lowercase since we used casefold and the pathes in the xml might not like it + char * destination = g_ascii_strdown(file->destination, -1); + fileCopy->destination = destination; + + char * source = g_ascii_strdown(file->source, -1); + fileCopy->source = source; + pendingFileOperations = g_list_append(pendingFileOperations, fileCopy); } } @@ -179,7 +189,19 @@ GList * processCondFiles(const FOMod_t * fomod, GList * flagList, GList * pendin return pendingFileOperations; } -int installFOMod(const char * modFolder, const char * destination) { +void fomod_freeFileOperations(GList * fileOperations) { + GList * fileOperationsStart = fileOperations; + while(fileOperations != NULL) { + fomod_File_t * file = (fomod_File_t *)fileOperations->data; + if(file->destination != NULL)free(file->destination); + if(file->source != NULL)free(file->source); + fileOperations = g_list_next(fileOperations); + } + + g_list_free_full(fileOperationsStart, free); +} + +error_t fomod_installFOMod(const char * modFolder, const char * destination) { //everything should be lowercase since we use casefold() before calling any install function char * fomodFolder = g_build_path("/", modFolder, "fomod", NULL); char * fomodFile = g_build_filename(fomodFolder, "moduleconfig.xml", NULL); @@ -188,27 +210,27 @@ int installFOMod(const char * modFolder, const char * destination) { fprintf(stderr, "FOMod file not found, are you sure this is a fomod mod ?\n"); g_free(fomodFolder); g_free(fomodFile); - return EXIT_FAILURE; + return ERR_FAILURE; } FOMod_t fomod; - int returnValue = parseFOMod(fomodFile, &fomod); - if(returnValue != EXIT_SUCCESS) { - return returnValue; - } + int returnValue = parser_parseFOMod(fomodFile, &fomod); + if(returnValue == ERR_FAILURE) + return ERR_FAILURE; + g_free(fomodFile); GList * flagList = NULL; GList * pendingFileOperations = NULL; - sortSteps(&fomod); + fomod_sortSteps(&fomod); for(int i = 0; i < fomod.stepCount; i++) { const FOModStep_t * step = &fomod.steps[i]; bool validFlags = true; for(int flagId = 0; flagId < step->flagCount; flagId++) { - const GList * flagLink = g_list_find_custom(flagList, &step->requiredFlags[flagId], (GCompareFunc)flagEqual); + const GList * flagLink = g_list_find_custom(flagList, &step->requiredFlags[flagId], (GCompareFunc)fomod_flagEqual); if(flagLink == NULL) { validFlags = false; break; @@ -218,9 +240,9 @@ int installFOMod(const char * modFolder, const char * destination) { if(!validFlags) continue; for(int groupId = 0; groupId < step->groupCount; groupId++ ) { - FOModGroup_t group = step->groups[groupId]; + fomod_Group_t group = step->groups[groupId]; - sortGroup(&group); + fomod_sortGroup(&group); u_int8_t min; u_int8_t max; @@ -229,7 +251,7 @@ int installFOMod(const char * modFolder, const char * destination) { size_t bufferSize = 0; while(true) { - printfOptionsInOrder(group); + fomod_printOptionsInOrder(group); switch(group.type) { case ONE_ONLY: printf("Select one :\n"); @@ -260,6 +282,10 @@ int installFOMod(const char * modFolder, const char * destination) { min = 0; max = 0; break; + default: + //never happen; + fprintf(stderr, "unexpected type please report this issue %d, %d", group.type, __LINE__); + return ERR_FAILURE; } @@ -278,24 +304,36 @@ int installFOMod(const char * modFolder, const char * destination) { } } + //processing user input + GRegex* regex = g_regex_new("\\s*", 0, 0, NULL); char ** choices = g_regex_split(regex, inputBuffer, 0); g_regex_unref(regex); for(int choiceId = 0; choices[choiceId] != NULL; choiceId++) { + //TODO: safer user input int choice = atoi(choices[choiceId]); - FOModPlugin_t plugin = group.plugins[choice]; + fomod_Plugin_t plugin = group.plugins[choice]; for(int flagId = 0; flagId < plugin.flagCount; flagId++) { flagList = g_list_append(flagList, &plugin.flags[flagId]); } //do the install for(int pluginId = 0; pluginId < plugin.fileCount; pluginId++) { - const FOModFile_t * file = &plugin.files[pluginId]; + const fomod_File_t * file = &plugin.files[pluginId]; - FOModFile_t * fileCopy = malloc(sizeof(*file)); + fomod_File_t * fileCopy = malloc(sizeof(fomod_File_t)); *fileCopy = *file; + //changing pathes to lowercase since we used casefold and the pathes in the xml might not like it + char * destination = g_ascii_strdown(file->destination, -1); + fileCopy->destination = strdup(destination); + g_free(destination); + + char * source = g_ascii_strdown(file->source, -1); + fileCopy->source = strdup(source); + g_free(source); + pendingFileOperations = g_list_append(pendingFileOperations, fileCopy); } } @@ -305,15 +343,63 @@ int installFOMod(const char * modFolder, const char * destination) { } } + //TODO: manage multiple files with the same name - - pendingFileOperations = processCondFiles(&fomod, flagList, pendingFileOperations); - processFileOperations(pendingFileOperations, modFolder, destination); + pendingFileOperations = fomod_processCondFiles(&fomod, flagList, pendingFileOperations); + fomod_processFileOperations(&pendingFileOperations, modFolder, destination); printf("FOMod successfully installed!\n"); g_list_free(flagList); - g_list_free_full(pendingFileOperations, free); - freeFOMod(&fomod); + fomod_freeFileOperations(pendingFileOperations); + fomod_freeFOMod(&fomod); g_free(fomodFolder); - return EXIT_SUCCESS; + return ERR_SUCCESS; +} + + +void fomod_freeFOMod(FOMod_t * fomod) { + for(int i = 0; i < fomod->condFilesCount; i++) { + fomod_CondFile_t * condFile = &(fomod->condFiles[i]); + for(long fileId = 0; fileId < condFile->fileCount; fileId++) { + free(condFile->files[fileId].destination); + free(condFile->files[fileId].source); + } + + for(long flagId = 0; flagId < condFile->flagCount; flagId++) { + fomod_Flag_t * flag = &(condFile->requiredFlags[flagId]); + free(flag->name); + free(flag->value); + } + free(condFile->files); + free(condFile->requiredFlags); + } + free(fomod->condFiles); + free(fomod->moduleImage); + free(fomod->moduleName); + + int size = fomod_countUntilNull(fomod->requiredInstallFiles, sizeof(char **)); + for(int i = 0; i < size; i++) { + free(fomod->requiredInstallFiles[i]); + } + free(fomod->requiredInstallFiles); + + for(int i = 0; i < fomod->stepCount; i++) { + FOModStep_t * step = &fomod->steps[i]; + for(int groupId = 0; groupId < step->groupCount; groupId++) { + fomod_Group_t * group = &step->groups[groupId]; + grp_freeGroup(group); + } + for(int flagId = 0; flagId < step->flagCount; flagId++) { + fomod_Flag_t * flag = &(step->requiredFlags[flagId]); + free(flag->name); + free(flag->value); + } + free(step->groups); + free(step->requiredFlags); + free(step->name); + } + free(fomod->steps); + + //set every counter to zero and every pointer to null + memset(fomod, 0, sizeof(FOMod_t)); } diff --git a/src/fomod.h b/src/fomod.h index 368af57..abd70bd 100644 --- a/src/fomod.h +++ b/src/fomod.h @@ -3,8 +3,9 @@ #include #include -#include "fomod/parser.h" +#include "main.h" +#include "fomod/parser.h" #include "fomod/group.h" #include "fomod/xmlUtil.h" @@ -15,7 +16,7 @@ * @param destination folder of the new mod that contains the result of the fomod process. * @return int */ -int installFOMod(const char * modFolder, const char * destination); +error_t fomod_installFOMod(const char * modFolder, const char * destination); /** * @brief In fomod there is file operations which depends on multiple flags this function find the ones that mach our current flags and append them to a list. @@ -25,7 +26,7 @@ int installFOMod(const char * modFolder, const char * destination); * @param pendingFileOperations a list of pending FOModFile_t operation to which add the new ones. (can be null) * @return a list of pendingFileOperations(FOModFile_t) */ -GList * processCondFiles(const FOMod_t * fomod, GList * flagList, GList * pendingFileOperations) __attribute__((warn_unused_result)); +GList * fomod_processCondFiles(const FOMod_t * fomod, GList * flagList, GList * pendingFileOperations) __attribute__((warn_unused_result)); /** * @brief FOModFile_t have a priority option and this function execute the file operation while taking this into account. @@ -35,8 +36,20 @@ GList * processCondFiles(const FOMod_t * fomod, GList * flagList, GList * pendin * @param destination folder of the new mod that contains the result of the process. * @return error code */ -int processFileOperations(GList * pendingFileOperations, const char * modFolder, const char * destination); +error_t fomod_processFileOperations(GList ** pendingFileOperations, const char * modFolder, const char * destination); + +/** + * @brief + * + * @param fileOperations + */ +void fomod_freeFileOperations(GList * fileOperations); +/** + * @brief Free content of a fomod file. + * @param fomod + */ +void fomod_freeFOMod(FOMod_t * fomod); #endif diff --git a/src/fomod/fomodTypes.h b/src/fomod/fomodTypes.h index 616f4a8..aa20d41 100644 --- a/src/fomod/fomodTypes.h +++ b/src/fomod/fomodTypes.h @@ -4,25 +4,25 @@ #include "stdbool.h" #include "xmlUtil.h" -typedef struct FOModFlag { +typedef struct fomod_Flag { char * name; char * value; -} FOModFlag_t; +} fomod_Flag_t; -typedef struct FOModFile { +typedef struct fomod_File { char * source; char * destination; int priority; bool isFolder; -} FOModFile_t; +} fomod_File_t; -typedef struct FOModCondFile { - FOModFlag_t * requiredFlags; +typedef struct fomod_CondFile { + fomod_Flag_t * requiredFlags; unsigned int flagCount; - FOModFile_t * files; + fomod_File_t * files; unsigned int fileCount; -} FOModCondFile_t; +} fomod_CondFile_t; #endif diff --git a/src/fomod/group.c b/src/fomod/group.c index 470153a..3b6b7f9 100644 --- a/src/fomod/group.c +++ b/src/fomod/group.c @@ -1,9 +1,10 @@ #include "group.h" +#include "fomodTypes.h" #include "xmlUtil.h" #include "string.h" #include -GroupType_t getGroupType(const char * type) { +static GroupType_t getGroupType(const char * type) { if(strcmp(type, "SelectAtLeastOne") == 0) { return AT_LEAST_ONE; } else if(strcmp(type, "SelectAtMostOne") == 0) { @@ -19,7 +20,7 @@ GroupType_t getGroupType(const char * type) { } } -TypeDescriptor_t getDescriptor(const char * descriptor) { +static TypeDescriptor_t getDescriptor(const char * descriptor) { if(strcmp(descriptor, "Optional") == 0) { return OPTIONAL; } else if(strcmp(descriptor, "Required") == 0) { @@ -35,10 +36,11 @@ TypeDescriptor_t getDescriptor(const char * descriptor) { } } -void freeGroup(FOModGroup_t * group) { +void grp_freeGroup(fomod_Group_t * group){ + free(group->name); if(group->pluginCount == 0) return; for(int pluginId = 0; pluginId < group->pluginCount; pluginId++) { - FOModPlugin_t * plugin = &group->plugins[pluginId]; + fomod_Plugin_t * plugin = &group->plugins[pluginId]; if(plugin->fileCount > 0) { for(int i = 0; i < plugin->fileCount; i++) { free(plugin->files[i].destination); @@ -64,10 +66,10 @@ void freeGroup(FOModGroup_t * group) { group->pluginCount = 0; } -int parseConditionFlags(FOModPlugin_t * plugin, xmlNodePtr nodeElement) { +static int parseConditionFlags(fomod_Plugin_t * plugin, xmlNodePtr nodeElement) { xmlNodePtr flagNode = nodeElement->children; while(flagNode != NULL) { - if(!validateNode(&flagNode, true, "flag", NULL)) { + if(!xml_validateNode(&flagNode, true, "flag", NULL)) { if(plugin->flagCount > 0) { free(plugin->flags); } @@ -76,12 +78,12 @@ int parseConditionFlags(FOModPlugin_t * plugin, xmlNodePtr nodeElement) { if(flagNode == NULL)continue; plugin->flagCount += 1; - plugin->flags = realloc(plugin->flags, plugin->flagCount * sizeof(FOModFlag_t)); + plugin->flags = realloc(plugin->flags, plugin->flagCount * sizeof(fomod_Flag_t)); - FOModFlag_t * flag = &plugin->flags[plugin->flagCount - 1]; + fomod_Flag_t * flag = &plugin->flags[plugin->flagCount - 1]; - flag->name = freeAndDup(xmlGetProp(flagNode, (const xmlChar *) "name")); - flag->value = freeAndDup(xmlNodeGetContent(flagNode)); + flag->name = xml_freeAndDup(xmlGetProp(flagNode, (const xmlChar *) "name")); + flag->value = xml_freeAndDup(xmlNodeGetContent(flagNode)); flagNode = flagNode->next; } @@ -89,11 +91,10 @@ int parseConditionFlags(FOModPlugin_t * plugin, xmlNodePtr nodeElement) { return EXIT_SUCCESS; } -int parseGroupFiles(FOModPlugin_t * plugin, xmlNodePtr nodeElement) { - FOModFile_t * files = NULL; +static int parseGroupFiles(fomod_Plugin_t * plugin, xmlNodePtr nodeElement) { xmlNodePtr fileNode = nodeElement->children; while(fileNode != NULL) { - if(!validateNode(&fileNode, true, "folder", "file", NULL)) { + if(!xml_validateNode(&fileNode, true, "folder", "file", NULL)) { fprintf(stderr, "Unexpected node in files"); //TODO: free return EXIT_FAILURE; @@ -103,11 +104,11 @@ int parseGroupFiles(FOModPlugin_t * plugin, xmlNodePtr nodeElement) { plugin->fileCount += 1; - plugin->files = realloc(plugin->files, (plugin->fileCount + 1) * sizeof(FOModFile_t)); - FOModFile_t * file = &plugin->files[plugin->fileCount - 1]; + plugin->files = realloc(plugin->files, (plugin->fileCount + 1) * sizeof(fomod_File_t)); + fomod_File_t * file = &plugin->files[plugin->fileCount - 1]; - file->destination = freeAndDup(xmlGetProp(fileNode, (const xmlChar *) "destination")); - file->source = freeAndDup(xmlGetProp(fileNode, (const xmlChar *) "source")); + file->destination = xml_freeAndDup(xmlGetProp(fileNode, (const xmlChar *) "destination")); + file->source = xml_freeAndDup(xmlGetProp(fileNode, (const xmlChar *) "source")); //TODO: test if it's a number xmlChar * priority = xmlGetProp(fileNode, (const xmlChar *) "priority"); @@ -123,18 +124,18 @@ int parseGroupFiles(FOModPlugin_t * plugin, xmlNodePtr nodeElement) { return EXIT_SUCCESS; } -int parseNodeElement(FOModPlugin_t * plugin, xmlNodePtr nodeElement) { +static int parseNodeElement(fomod_Plugin_t * plugin, xmlNodePtr nodeElement) { if(xmlStrcmp(nodeElement->name, (const xmlChar *) "description") == 0) { - plugin->description = freeAndDup(xmlNodeGetContent(nodeElement)); + plugin->description = xml_freeAndDup(xmlNodeGetContent(nodeElement)); } else if(xmlStrcmp(nodeElement->name, (const xmlChar *) "image") == 0) { - plugin->image = freeAndDup(xmlGetProp(nodeElement, (const xmlChar *) "path")); + plugin->image = xml_freeAndDup(xmlGetProp(nodeElement, (const xmlChar *) "path")); } else if(xmlStrcmp(nodeElement->name, (const xmlChar *) "conditionFlags") == 0) { return parseConditionFlags(plugin, nodeElement); } else if(xmlStrcmp(nodeElement->name, (const xmlChar *) "files") == 0) { return parseGroupFiles(plugin, nodeElement); } else if(xmlStrcmp(nodeElement->name, (const xmlChar *) "typeDescriptor") == 0) { xmlNodePtr typeNode = nodeElement->children; - if(!validateNode(&typeNode, true, "type", NULL)) { + if(!xml_validateNode(&typeNode, true, "type", NULL)) { fprintf(stderr, "Unexpected node in typeDescriptor"); return EXIT_FAILURE; } @@ -145,29 +146,29 @@ int parseNodeElement(FOModPlugin_t * plugin, xmlNodePtr nodeElement) { return EXIT_SUCCESS; } -int parseGroup(xmlNodePtr groupNode, FOModGroup_t* group) { +int grp_parseGroup(xmlNodePtr groupNode, fomod_Group_t* group) { xmlNodePtr pluginsNode = groupNode->children; - if(!validateNode(&pluginsNode, true, "plugins", NULL)) { + if(!xml_validateNode(&pluginsNode, true, "plugins", NULL)) { return EXIT_FAILURE; } - group->name = freeAndDup(xmlGetProp( groupNode, (const xmlChar *) "name")); + group->name = xml_freeAndDup(xmlGetProp( groupNode, (const xmlChar *) "name")); xmlChar * type = xmlGetProp(groupNode, (const xmlChar *) "type"); group->type = getGroupType((const char *)type); xmlFree(type); char * order = (char *) xmlGetProp(pluginsNode, (const xmlChar *) "order"); - group->order = getFOModOrder(order); + group->order = fomod_getOrder(order); xmlFree(order); - FOModPlugin_t * plugins = NULL; + fomod_Plugin_t * plugins = NULL; int pluginCount = 0; xmlNodePtr currentPlugin = pluginsNode->children; while(currentPlugin != NULL) { - if(!validateNode(¤tPlugin, true, "plugin", NULL)) { + if(!xml_validateNode(¤tPlugin, true, "plugin", NULL)) { //TODO handle error; printf("%d\n", __LINE__); exit(EXIT_FAILURE); @@ -177,12 +178,12 @@ int parseGroup(xmlNodePtr groupNode, FOModGroup_t* group) { pluginCount += 1; - plugins = realloc(plugins, pluginCount * sizeof(FOModPlugin_t)); - FOModPlugin_t * plugin = &plugins[pluginCount - 1]; + plugins = realloc(plugins, pluginCount * sizeof(fomod_Plugin_t)); + fomod_Plugin_t * plugin = &plugins[pluginCount - 1]; //initialise everything to 0 and null pointers - memset(plugin, 0, sizeof(FOModPlugin_t)); + memset(plugin, 0, sizeof(fomod_Plugin_t)); - plugin->name = freeAndDup(xmlGetProp(currentPlugin, (const xmlChar *) "name")); + plugin->name = xml_freeAndDup(xmlGetProp(currentPlugin, (const xmlChar *) "name")); xmlNodePtr nodeElement = currentPlugin->children; while(nodeElement != NULL) { @@ -203,6 +204,6 @@ failure: //we need to free all of our allocations since we can't expect ou parent function to know what we allocated and what we haven't. group->plugins = plugins; group->pluginCount = pluginCount; - freeGroup(group); + grp_freeGroup(group); return EXIT_FAILURE; } diff --git a/src/fomod/group.h b/src/fomod/group.h index 27c0538..6583186 100644 --- a/src/fomod/group.h +++ b/src/fomod/group.h @@ -3,32 +3,33 @@ #include #include "fomodTypes.h" +#include "xmlUtil.h" typedef enum GroupType_t { ONE_ONLY, ANY, AT_LEAST_ONE, AT_MOST_ONE, ALL } GroupType_t; typedef enum TypeDescriptor { OPTIONAL, MAYBE_USABLE, NOT_USABLE, REQUIRED, RECOMMENDED } TypeDescriptor_t; -typedef struct FOModPlugin { +typedef struct fomod_Plugin { char * description; char * image; - FOModFlag_t * flags; + fomod_Flag_t * flags; int flagCount; - FOModFile_t * files; + fomod_File_t * files; int fileCount; TypeDescriptor_t type; char * name; -} FOModPlugin_t; +} fomod_Plugin_t; //combine group and "plugins" -typedef struct FOModGroup { - FOModPlugin_t * plugins; +typedef struct fomod_Group { + fomod_Plugin_t * plugins; int pluginCount; GroupType_t type; char * name; - FOModOrder_t order; -} FOModGroup_t; + fomod_Order_t order; +} fomod_Group_t; -int parseGroup(xmlNodePtr groupNode, FOModGroup_t* group); -void freeGroup(FOModGroup_t * group); +int grp_parseGroup(xmlNodePtr groupNode, fomod_Group_t* group); +void grp_freeGroup(fomod_Group_t * group); #endif diff --git a/src/fomod/parser.c b/src/fomod/parser.c index fe8c437..0d71a7d 100644 --- a/src/fomod/parser.c +++ b/src/fomod/parser.c @@ -1,62 +1,17 @@ #include "parser.h" +#include "fomodTypes.h" +#include "group.h" #include "libxml/tree.h" #include "xmlUtil.h" #include #include -//Maybe integrate this into the rest of the code instead of freeing after the fact -void freeFOMod(FOMod_t * fomod) { - for(int i = 0; i < fomod->condFilesCount; i++) { - FOModCondFile_t * condFile = &(fomod->condFiles[i]); - for(int fileId = 0; fileId < condFile->fileCount; fileId++) { - free(condFile->files[fileId].destination); - free(condFile->files[fileId].source); - } - - for(int flagId = 0; flagId < condFile->flagCount; flagId++) { - FOModFlag_t * flag = &(condFile->requiredFlags[flagId]); - free(flag->name); - free(flag->value); - } - free(condFile->files); - free(condFile->requiredFlags); - } - free(fomod->condFiles); - free(fomod->moduleImage); - free(fomod->moduleName); - - int size = countUntilNull(fomod->requiredInstallFiles, sizeof(char **)); - for(int i = 0; i < size; i++) { - free(fomod->requiredInstallFiles[i]); - } - free(fomod->requiredInstallFiles); - - for(int i = 0; i < fomod->stepCount; i++) { - FOModStep_t * step = &fomod->steps[i]; - for(int groupId = 0; groupId < step->groupCount; groupId++) { - FOModGroup_t * group = &step->groups[groupId]; - freeGroup(group); - free(step->groups[groupId].plugins); - } - for(int flagId = 0; flagId < step->flagCount; flagId++) { - FOModFlag_t * flag = &(step->requiredFlags[flagId]); - free(flag->name); - free(flag->value); - } - free(step->requiredFlags); - free(step->name); - } - - //set every counter to zero and every pointer to null - memset(fomod, 0, sizeof(FOMod_t)); -} - -int parseVisibleNode(xmlNodePtr node, FOModStep_t * step) { +static int parseVisibleNode(xmlNodePtr node, FOModStep_t * step) { xmlNodePtr requiredFlagsNode = node->children; while (requiredFlagsNode != NULL) { - if(!validateNode(&requiredFlagsNode, true, "flagDependency", NULL)) { + if(!xml_validateNode(&requiredFlagsNode, true, "flagDependency", NULL)) { //TODO: handle error printf("%d\n", __LINE__); return EXIT_FAILURE; @@ -65,10 +20,10 @@ int parseVisibleNode(xmlNodePtr node, FOModStep_t * step) { if(requiredFlagsNode == NULL)break; step->flagCount += 1; - step->requiredFlags = realloc(step->requiredFlags, step->flagCount * sizeof(FOModFlag_t)); - FOModFlag_t * flag = &(step->requiredFlags[step->flagCount - 1]); - flag->name = freeAndDup(xmlGetProp(requiredFlagsNode, (const xmlChar *) "flag")); - flag->value = freeAndDup(xmlGetProp(requiredFlagsNode, (const xmlChar *) "value")); + step->requiredFlags = realloc(step->requiredFlags, step->flagCount * sizeof(fomod_Flag_t)); + fomod_Flag_t * flag = &(step->requiredFlags[step->flagCount - 1]); + flag->name = xml_freeAndDup(xmlGetProp(requiredFlagsNode, (const xmlChar *) "flag")); + flag->value = xml_freeAndDup(xmlGetProp(requiredFlagsNode, (const xmlChar *) "value")); requiredFlagsNode = requiredFlagsNode->next; } @@ -76,13 +31,13 @@ int parseVisibleNode(xmlNodePtr node, FOModStep_t * step) { return EXIT_SUCCESS; } -int parseOptionalFileGroup(xmlNodePtr node, FOModStep_t * step) { +static int parseOptionalFileGroup(xmlNodePtr node, FOModStep_t * step) { xmlChar * optionOrder = xmlGetProp(node, (const xmlChar *)"order"); - step->optionOrder = getFOModOrder((char *)optionOrder); + step->optionOrder = fomod_getOrder((char *)optionOrder); xmlFree(optionOrder); xmlNodePtr group = node->children; while(group != NULL) { - if(!validateNode(&group, true, "group", NULL)) { + if(!xml_validateNode(&group, true, "group", NULL)) { //TODO: handle error printf("%d\n", __LINE__); return EXIT_FAILURE; @@ -91,8 +46,8 @@ int parseOptionalFileGroup(xmlNodePtr node, FOModStep_t * step) { if(group == NULL)break; step->groupCount += 1; - step->groups = realloc(step->groups, step->groupCount * sizeof(FOModGroup_t)); - int status = parseGroup(group, &step->groups[step->groupCount - 1]); + step->groups = realloc(step->groups, step->groupCount * sizeof(fomod_Group_t)); + int status = grp_parseGroup(group, &step->groups[step->groupCount - 1]); if(status != EXIT_SUCCESS) { //TODO: handle error @@ -105,14 +60,14 @@ int parseOptionalFileGroup(xmlNodePtr node, FOModStep_t * step) { return EXIT_SUCCESS; } -FOModStep_t * parseInstallSteps(xmlNodePtr installStepsNode, int * stepCount) { +static FOModStep_t * parseInstallSteps(xmlNodePtr installStepsNode, int * stepCount) { FOModStep_t * steps = NULL; *stepCount = 0; xmlNodePtr stepNode = installStepsNode->children; while(stepNode != NULL) { //skipping the text node - if(!validateNode(&stepNode, true, "installStep", NULL)) { + if(!xml_validateNode(&stepNode, true, "installStep", NULL)) { //TODO: handle error printf("%d\n", __LINE__); exit(EXIT_FAILURE); @@ -124,7 +79,7 @@ FOModStep_t * parseInstallSteps(xmlNodePtr installStepsNode, int * stepCount) { steps = realloc(steps, *stepCount * sizeof(FOModStep_t)); FOModStep_t * step = &steps[*stepCount - 1]; - step->name = freeAndDup(xmlGetProp(stepNode, (const xmlChar *)"name")); + step->name = xml_freeAndDup(xmlGetProp(stepNode, (const xmlChar *)"name")); step->requiredFlags = NULL; step->flagCount = 0; step->groupCount = 0; @@ -146,10 +101,10 @@ FOModStep_t * parseInstallSteps(xmlNodePtr installStepsNode, int * stepCount) { return steps; } -int parseDependencies(xmlNodePtr node, FOModCondFile_t * condFile) { +static int parseDependencies(xmlNodePtr node, fomod_CondFile_t * condFile) { xmlNodePtr flagNode = node->children; - if(!validateNode(&flagNode, true, "flagDependency", NULL)) { + if(!xml_validateNode(&flagNode, true, "flagDependency", NULL)) { //TODO: handle error printf("%d\n", __LINE__); return EXIT_FAILURE; @@ -157,32 +112,32 @@ int parseDependencies(xmlNodePtr node, FOModCondFile_t * condFile) { while(flagNode != NULL) { condFile->flagCount += 1; - condFile->requiredFlags = realloc(condFile->requiredFlags, condFile->flagCount * sizeof(FOModFlag_t)); - FOModFlag_t * flag = &(condFile->requiredFlags[condFile->flagCount - 1]); - flag->name = freeAndDup(xmlGetProp(flagNode, (const xmlChar *) "flag")); - flag->value = freeAndDup(xmlGetProp(flagNode, (const xmlChar *) "value")); + condFile->requiredFlags = realloc(condFile->requiredFlags, condFile->flagCount * sizeof(fomod_Flag_t)); + fomod_Flag_t * flag = &(condFile->requiredFlags[condFile->flagCount - 1]); + flag->name = xml_freeAndDup(xmlGetProp(flagNode, (const xmlChar *) "flag")); + flag->value = xml_freeAndDup(xmlGetProp(flagNode, (const xmlChar *) "value")); flagNode = flagNode->next; } return EXIT_SUCCESS; } -int parseFiles(xmlNodePtr node, FOModCondFile_t * condFile) { +static int parseFiles(xmlNodePtr node, fomod_CondFile_t * condFile) { xmlNodePtr filesNode = node->children; while(filesNode != NULL) { - if(!validateNode(&filesNode, true, "folder", "file", NULL)) { + if(!xml_validateNode(&filesNode, true, "folder", "file", NULL)) { //TODO: handle error printf("%d\n", __LINE__); return EXIT_FAILURE; } condFile->fileCount += 1; - condFile->files = realloc(condFile->files, condFile->fileCount * sizeof(FOModFile_t)); - FOModFile_t * flag = &(condFile->files[condFile->fileCount - 1]); - flag->source = freeAndDup(xmlGetProp(filesNode, (const xmlChar *) "source")); - flag->destination = freeAndDup(xmlGetProp(filesNode, (const xmlChar *) "destination")); + condFile->files = realloc(condFile->files, condFile->fileCount * sizeof(fomod_File_t)); + fomod_File_t * flag = &(condFile->files[condFile->fileCount - 1]); + flag->source = xml_freeAndDup(xmlGetProp(filesNode, (const xmlChar *) "source")); + flag->destination = xml_freeAndDup(xmlGetProp(filesNode, (const xmlChar *) "destination")); flag->priority = 0; flag->isFolder = xmlStrcmp(filesNode->name, (xmlChar *) "folder") == 0; @@ -192,10 +147,10 @@ int parseFiles(xmlNodePtr node, FOModCondFile_t * condFile) { return EXIT_SUCCESS; } -int parseConditionalInstalls(xmlNodePtr node, FOMod_t * fomod) { +static int parseConditionalInstalls(xmlNodePtr node, FOMod_t * fomod) { xmlNodePtr patterns = node->children; if(patterns != NULL) { - if(!validateNode(&patterns, true, "patterns", NULL)) { + if(!xml_validateNode(&patterns, true, "patterns", NULL)) { //TODO: handle error printf("%d\n", __LINE__); return EXIT_FAILURE; @@ -204,7 +159,7 @@ int parseConditionalInstalls(xmlNodePtr node, FOMod_t * fomod) { while(currentPattern != NULL) { xmlNodePtr patternChild = currentPattern->children; - if(!validateNode(&patternChild, true, "pattern", NULL)) { + if(!xml_validateNode(&patternChild, true, "pattern", NULL)) { //TODO: handle error printf("%d\n", __LINE__); return EXIT_FAILURE; @@ -212,8 +167,8 @@ int parseConditionalInstalls(xmlNodePtr node, FOMod_t * fomod) { while(patternChild != NULL) { fomod->condFilesCount += 1; - fomod->condFiles = realloc(fomod->condFiles, fomod->condFilesCount * sizeof(FOModCondFile_t)); - FOModCondFile_t * condFile = &(fomod->condFiles[fomod->condFilesCount - 1]); + fomod->condFiles = realloc(fomod->condFiles, fomod->condFilesCount * sizeof(fomod_CondFile_t)); + fomod_CondFile_t * condFile = &(fomod->condFiles[fomod->condFilesCount - 1]); condFile->fileCount = 0; condFile->files = NULL; @@ -238,7 +193,7 @@ int parseConditionalInstalls(xmlNodePtr node, FOMod_t * fomod) { return EXIT_SUCCESS; } -int parseFOMod(const char * fomodFile, FOMod_t* fomod) { +error_t parser_parseFOMod(const char * fomodFile, FOMod_t* fomod) { xmlDocPtr doc; xmlNodePtr cur; @@ -255,7 +210,7 @@ int parseFOMod(const char * fomodFile, FOMod_t* fomod) { if(doc == NULL) { fprintf(stderr, "Document is not a valid xml file\n"); - return EXIT_FAILURE; + return ERR_FAILURE; } @@ -263,12 +218,13 @@ int parseFOMod(const char * fomodFile, FOMod_t* fomod) { if(cur == NULL) { fprintf(stderr, "emptyDocument"); xmlFreeDoc(doc); - return EXIT_FAILURE; + return ERR_FAILURE; } if(xmlStrcmp(cur->name, (const xmlChar *) "config") != 0) { fprintf(stderr, "document of the wrong type, root node is '%s' instead of config\n", cur->name); - return EXIT_FAILURE; + xmlFreeDoc(doc); + return ERR_FAILURE; } cur = cur->children; @@ -277,22 +233,22 @@ int parseFOMod(const char * fomodFile, FOMod_t* fomod) { //might cause some issues. when will c finally support utf-8 fomod->moduleName = (char *)cur->content; } else if(xmlStrcmp(cur->name, (const xmlChar *) "moduleImage") == 0) { - fomod->moduleImage = freeAndDup(xmlGetProp(cur, (const xmlChar *)"path")); + fomod->moduleImage = xml_freeAndDup(xmlGetProp(cur, (const xmlChar *)"path")); } else if(xmlStrcmp(cur->name, (const xmlChar *)"requiredInstallFiles") == 0) { //TODO: support non empty destination. xmlNodePtr requiredInstallFile = cur->children; while(requiredInstallFile != NULL) { - if(validateNode(&requiredInstallFile, true, "folder", "file", NULL)) { + if(xml_validateNode(&requiredInstallFile, true, "folder", "file", NULL)) { //TODO: handle error printf("%d\n", __LINE__); - exit(EXIT_FAILURE); + exit(ERR_FAILURE); } - int size = countUntilNull(fomod->requiredInstallFiles, sizeof(char **)) + 2; + int size = fomod_countUntilNull(fomod->requiredInstallFiles, sizeof(char **)) + 2; fomod->requiredInstallFiles = realloc(fomod->requiredInstallFiles, sizeof(char *) * size); //ensure it is null terminated fomod->requiredInstallFiles[size - 1] = NULL; - fomod->requiredInstallFiles[size - 2] = freeAndDup(xmlGetProp(requiredInstallFile, (const xmlChar *)"source")); + fomod->requiredInstallFiles[size - 2] = xml_freeAndDup(xmlGetProp(requiredInstallFile, (const xmlChar *)"source")); requiredInstallFile = cur->children; } @@ -300,11 +256,11 @@ int parseFOMod(const char * fomodFile, FOMod_t* fomod) { if(fomod->steps != NULL) { fprintf(stderr, "Multiple 'installSteps' tags"); //TODO: handle error - return EXIT_FAILURE; + return ERR_FAILURE; } xmlChar * stepOrder = xmlGetProp(cur, (xmlChar *)"order"); - fomod->stepOrder = getFOModOrder((char *)stepOrder); + fomod->stepOrder = fomod_getOrder((char *)stepOrder); xmlFree(stepOrder); int stepCount = 0; @@ -314,7 +270,7 @@ int parseFOMod(const char * fomodFile, FOMod_t* fomod) { fprintf(stderr, "Failed to parse the install steps\n"); //TODO: manage the error properly - return EXIT_FAILURE; + return ERR_FAILURE; } fomod->steps = steps; @@ -326,5 +282,5 @@ int parseFOMod(const char * fomodFile, FOMod_t* fomod) { } xmlFreeDoc(doc); - return EXIT_SUCCESS; + return ERR_SUCCESS; } diff --git a/src/fomod/parser.h b/src/fomod/parser.h index 6f08a5c..37ebce8 100644 --- a/src/fomod/parser.h +++ b/src/fomod/parser.h @@ -2,15 +2,17 @@ #define __FOMOD_PARSER_H__ +#include "fomodTypes.h" #include "group.h" +#include "../main.h" //combine installStep and optionalFileGroups typedef struct FOModStep { - FOModOrder_t optionOrder; - FOModGroup_t * groups; + fomod_Order_t optionOrder; + fomod_Group_t * groups; int groupCount; char * name; - FOModFlag_t * requiredFlags; + fomod_Flag_t * requiredFlags; int flagCount; } FOModStep_t; @@ -18,10 +20,10 @@ typedef struct FOMod { char * moduleName; char * moduleImage; char ** requiredInstallFiles; - FOModOrder_t stepOrder; + fomod_Order_t stepOrder; FOModStep_t * steps; int stepCount; - FOModCondFile_t * condFiles; + fomod_CondFile_t * condFiles; int condFilesCount; } FOMod_t; @@ -30,14 +32,7 @@ typedef struct FOMod { * * @param fomodFile path to the moduleconfig.xml * @param fomod pointer to a new FOMod_t - * @return error code. */ -int parseFOMod(const char * fomodFile, FOMod_t* fomod); - -/** - * @brief Free content of a fomod file. - * @param fomod - */ -void freeFOMod(FOMod_t * fomod); +error_t parser_parseFOMod(const char * fomodFile, FOMod_t* fomod); #endif diff --git a/src/fomod/xmlUtil.c b/src/fomod/xmlUtil.c index b7c0d3d..e2ac79a 100644 --- a/src/fomod/xmlUtil.c +++ b/src/fomod/xmlUtil.c @@ -1,14 +1,15 @@ #include "xmlUtil.h" #include +#include -char * freeAndDup(xmlChar * line) { +char * xml_freeAndDup(xmlChar * line) { char * free = strdup((const char *) line); xmlFree(line); return free; } -FOModOrder_t getFOModOrder(const char * order) { +fomod_Order_t fomod_getOrder(const char * order) { if(order == NULL || strcmp(order, "Ascending") == 0) { return ASC; } else if(strcmp(order, "Explicit") == 0) { @@ -20,17 +21,18 @@ FOModOrder_t getFOModOrder(const char * order) { } //replace \ in the path by / -void fixPath(char * path) { +void xml_fixPath(char * path) { while(*path != '\0') { if(*path == '\\')*path = '/'; path++; } } -int countUntilNull(void * pointers, size_t typeSize) { +int fomod_countUntilNull(void * pointers, size_t typeSize) { int i = 0; - while(pointers != NULL) { - pointers += typeSize; + char * arithmetic = (char *)pointers; + while(arithmetic != NULL) { + arithmetic += typeSize; i++; } return i; @@ -38,7 +40,7 @@ int countUntilNull(void * pointers, size_t typeSize) { //names cannot contain false //need to be null terminated -bool validateNode(xmlNodePtr * node, bool skipText, const char * names, ...) { +bool xml_validateNode(xmlNodePtr * node, bool skipText, const char * names, ...) { va_list namesPtr; while(*node != NULL && xmlStrcmp((*node)->name, (const xmlChar *)"text") == 0) { diff --git a/src/fomod/xmlUtil.h b/src/fomod/xmlUtil.h index e09e236..42af76f 100644 --- a/src/fomod/xmlUtil.h +++ b/src/fomod/xmlUtil.h @@ -5,19 +5,31 @@ #include -typedef enum FOModOrder { ASC, DESC, ORD } FOModOrder_t; +typedef enum FOModOrder { ASC, DESC, ORD } fomod_Order_t; + +/** + * @brief + * + * @param node a pointer to the current node pointer (xmlNode **) + * @param skipText if a text element is found skip it. + * @param names variadic of the valid names. + * @return return true if it found a valid node + */ +bool xml_validateNode(xmlNodePtr * node, bool skipText, const char * names, ...); -bool validateNode(xmlNodePtr * node, bool skipText, const char * names, ...); /** * @brief Free memory of and xmlChar and return a strdup version. just to make sure there is nothing remaining in libxml */ -char * freeAndDup(xmlChar * line); -FOModOrder_t getFOModOrder(const char * order); +char * xml_freeAndDup(xmlChar * line); + + +fomod_Order_t fomod_getOrder(const char * order); + /** * @brief replace / by \ * @param path */ -void fixPath(char * path); +void xml_fixPath(char * path); /** * @brief Count the number of step before null @@ -26,6 +38,6 @@ void fixPath(char * path); * @param typeSize size of each element of the list * @return size */ -int countUntilNull(void * pointers, size_t typeSize); +int fomod_countUntilNull(void * pointers, size_t typeSize); #endif diff --git a/src/getDataPath.c b/src/getDataPath.c new file mode 100644 index 0000000..4ea3b56 --- /dev/null +++ b/src/getDataPath.c @@ -0,0 +1,51 @@ + +#include "getDataPath.h" +#include "main.h" +#include "steam.h" + +#include +#include +#include +#include + +error_t getDataPath(int appid, char ** destination) { + GHashTable * gamePaths; + error_t status = steam_searchGames(&gamePaths); + if(status == ERR_FAILURE) { + return ERR_FAILURE; + } + + int gameId = steam_gameIdFromAppId(appid); + if(gameId < 0 ) { + fprintf(stderr, "invalid appid"); + return ERR_FAILURE; + } + + const char * path = g_hash_table_lookup(gamePaths, &gameId); + + if(path == NULL) { + fprintf(stderr, "game not found\n"); + return ERR_FAILURE; + } + + char * gameFolder = g_build_filename(path, "steamapps/common", GAMES_NAMES[gameId], NULL); + //the folder names for older an newer titles + char * dataFolderOld = g_build_filename(gameFolder, "Data Files", NULL); + char * dataFolderNew = g_build_filename(gameFolder, "Data", NULL); + + g_free(gameFolder); + + *destination = NULL; + //struct stat sb; + if(access(dataFolderOld, F_OK) == 0) { + *destination = strdup(dataFolderOld); + } else if(access(dataFolderNew, F_OK) == 0) { + *destination = strdup(dataFolderNew); + } + + g_free(dataFolderNew); + g_free(dataFolderOld); + + if(*destination == NULL) return ERR_FAILURE; + else return ERR_SUCCESS; +} diff --git a/src/getDataPath.h b/src/getDataPath.h new file mode 100644 index 0000000..b0dcca7 --- /dev/null +++ b/src/getDataPath.h @@ -0,0 +1,15 @@ +#ifndef __DATA_PATH_H__ +#define __DATA_PATH_H__ + +#include "main.h" + +/** + * @brief Get the path to the data folder + * @param appid appid of the game + * @param destination pointer to a null char * variable. it's value will be allocated with malloc + * @return error_t + */ +error_t getDataPath(int appid, char ** destination); + + +#endif diff --git a/src/getHome.c b/src/getHome.c index e294d51..3025efe 100644 --- a/src/getHome.c +++ b/src/getHome.c @@ -1,8 +1,9 @@ #include #include #include +#include "getHome.h" -char * getHome() { +char * getHome(void) { //not getting home from the env enable us to use sudo struct passwd *pw = getpwuid(audit_getloginuid()); return strdup(pw->pw_dir); diff --git a/src/getHome.h b/src/getHome.h index 141b34c..9ce8b04 100644 --- a/src/getHome.h +++ b/src/getHome.h @@ -5,4 +5,4 @@ * * @return char* path to the home dir */ -char * getHome(); +char * getHome(void); diff --git a/src/install.c b/src/install.c index f212610..bbbddf8 100644 --- a/src/install.c +++ b/src/install.c @@ -1,144 +1,31 @@ #include -#include #include -#include #include #include + #include "install.h" #include "main.h" +#include "archives.h" #include "file.h" -int unzip(char * path, char * outdir) { - char * const args[] = { - "unzip", - "-LL", // to lowercase - "-q", - path, - "-d", - outdir, - NULL - }; - - pid_t pid = fork(); - - if(pid == 0) { - execv("/usr/bin/unzip", args); - return EXIT_FAILURE; - } else { - int returnValue; - waitpid(pid, &returnValue, 0); - - if(returnValue != 0) { - printf("\nFailed to decompress archive\n"); - returnValue = EXIT_FAILURE; - } - return EXIT_SUCCESS; - } -} - -int unrar(char * path, char * outdir) { - char * const args[] = { - "unrar", - "x", - "-y", //assume yes - "-cl", // to lowercase - path, - outdir, - NULL - }; - - pid_t pid = fork(); - - if(pid == 0) { - execv("/usr/bin/unrar", args); - return EXIT_FAILURE; - } else { - int returnValue; - waitpid(pid, &returnValue, 0); - - if(returnValue != 0) { - printf("\nFailed to decompress archive\n"); - returnValue = EXIT_FAILURE; - } - return EXIT_SUCCESS; - } -} - - -int un7z(char * path, const char * outdir) { - gchar * outParameter = g_strjoin("", "-o", outdir, NULL); - - char * const args[] = { - "7z", - "-y", //assume yes - "x", - path, - outParameter, - NULL - }; - - pid_t pid = fork(); - - if(pid == 0) { - execv("/usr/bin/7z", args); - return EXIT_FAILURE; - } else { - g_free(outParameter); - int returnValue; - waitpid(pid, &returnValue, 0); - - if(returnValue != 0) { - printf("\nFailed to decompress archive\n"); - returnValue = EXIT_FAILURE; - } - //make everything lowercase since 7z don't have an argument for that. - casefold(outdir); - return EXIT_SUCCESS; - } -} - -const char * extractLastPart(const char * filePath, const char delimeter) { - const unsigned long length = strlen(filePath); - long index = -1; - for(long i= length - 1; i >= 0; i--) { - if(filePath[i] == delimeter) { - index = i + 1; - break; - } - } - - if(index <= 0 || index == length) return NULL; - return &filePath[index]; -} - -const char * extractExtension(const char * filePath) { - return extractLastPart(filePath, '.'); -} - -const char * extractFileName(const char * filePath) { - return extractLastPart(filePath, '/'); -} - - -int addMod(char * filePath, int appId) { - int returnValue = EXIT_SUCCESS; - +error_t install_addMod(char * filePath, int appId) { + error_t resultError = ERR_SUCCESS; if (access(filePath, F_OK) != 0) { - printf("File not found\n"); - returnValue = EXIT_FAILURE; + fprintf(stderr, "File not found\n"); + resultError = ERR_FAILURE; goto exit; } char * configFolder = g_build_filename(getenv("HOME"), MANAGER_FILES, NULL); if(g_mkdir_with_parents(configFolder, 0755) < 0) { - printf("Could not create mod folder"); - returnValue = EXIT_FAILURE; + fprintf(stderr, "Could not create mod folder"); + resultError = ERR_FAILURE; goto exit2; } - const char * filename = extractFileName(filePath); - const char * extension = extractExtension(filename); + const char * filename = file_extractFileName(filePath); + const char * extension = file_extractExtension(filename); char * lowercaseExtension = g_ascii_strdown(extension, -1); char appIdStr[20]; @@ -146,18 +33,23 @@ int addMod(char * filePath, int appId) { char * outdir = g_build_filename(configFolder, MOD_FOLDER_NAME, appIdStr, filename, NULL); g_mkdir_with_parents(outdir, 0755); + + int returnValue = EXIT_SUCCESS; printf("Adding mod, this process can be slow depending on your hardware\n"); if(strcmp(lowercaseExtension, "rar") == 0) { - returnValue = unrar(filePath, outdir); + returnValue = archive_unrar(filePath, outdir); } else if (strcmp(lowercaseExtension, "zip") == 0) { - returnValue = unzip(filePath, outdir); + returnValue = archive_unzip(filePath, outdir); } else if (strcmp(lowercaseExtension, "7z") == 0) { - returnValue = un7z(filePath, outdir); + returnValue = archive_un7z(filePath, outdir); } else { - printf("Unsupported format only zip/7z/rar are supported\n"); + fprintf(stderr, "Unsupported format only zip/7z/rar are supported\n"); returnValue = EXIT_FAILURE; } + if(returnValue == EXIT_FAILURE) + resultError = ERR_FAILURE; + printf("Done\n"); free(lowercaseExtension); @@ -165,5 +57,5 @@ int addMod(char * filePath, int appId) { exit2: free(configFolder); exit: - return returnValue; + return resultError; } diff --git a/src/install.h b/src/install.h index 5a89ca6..ba11f6d 100644 --- a/src/install.h +++ b/src/install.h @@ -1,6 +1,7 @@ #ifndef __INSTALL_H__ #define __INSTALL_H__ #include +#include "main.h" #define INSTALLED_FLAG_FILE "__DO_NOT_REMOVE__" /** @@ -8,8 +9,7 @@ * * @param filePath path to the mod file * @param appId game for which the mod is destined to be used with. - * @return EXIT_SUCCESS or EXIT_FAILURE */ -int addMod(char * filePath, int appId); +error_t install_addMod(char * filePath, int appId); #endif diff --git a/src/loadOrder.c b/src/loadOrder.c new file mode 100644 index 0000000..d3533b9 --- /dev/null +++ b/src/loadOrder.c @@ -0,0 +1,216 @@ +#include "loadOrder.h" +#include "main.h" +#include "steam.h" +#include "file.h" + +#include +#include +#include +#include + +#include "getDataPath.h" + +//TODO: detect if the game is running +//TODO: deploy the game + +error_t order_listPlugins(int appid, GList ** plugins) { + //save appid parsing + //TODO: apply a similar mechanism everywhere + size_t appidStrLen = snprintf(NULL, 0, "%d", appid) + 1; + char appidStr[appidStrLen]; + sprintf(appidStr, "%d", appid); + + char * dataFolder = NULL; + error_t error = getDataPath(appid, &dataFolder); + if(error != ERR_SUCCESS) { + return ERR_FAILURE; + } + + //esp && esm files are loadable + DIR * d = opendir(dataFolder); + struct dirent *dir; + if (d != NULL) { + while ((dir = readdir(d)) != NULL) { + const char * extension = file_extractExtension(dir->d_name); + //folder don't have file extensions + if(extension == NULL) + continue; + + if(strcmp(extension, "esp") == 0 || strcmp(extension, "esm") == 0) { + *plugins = g_list_append(*plugins, strdup(dir->d_name)); + } + } + closedir(d); + } + + free(dataFolder); + return ERR_SUCCESS; +} + +static void removeCRLF_CR_LF(char * string) { + int size = strlen(string); + if(string[size - 1] == '\r') size--; + if(string[size - 1] == '\n') size--; + if(string[size - 1] == '\r') size--; + string[size] = '\0'; +} + +error_t order_getLoadOrder(int appid, GList ** order) { + + GHashTable * gamePaths; + error_t status = steam_searchGames(&gamePaths); + if(status == ERR_FAILURE) { + return ERR_FAILURE; + } + + GList * l_plugins = NULL; + error_t error = order_listPlugins(appid, &l_plugins); + if(error == ERR_FAILURE) + return ERR_FAILURE; + + + int gameId = steam_gameIdFromAppId(appid); + if(gameId < 0 ) { + return ERR_FAILURE; + } + + size_t appidStrLen = snprintf(NULL, 0, "%d", appid) + 1; + char appidStr[appidStrLen]; + sprintf(appidStr, "%d", appid); + + const char * path = g_hash_table_lookup(gamePaths, &gameId); + + + //this is the path i would use in windows but it seems it is not avaliable in all wine versions. + //char * loadOrderPath = g_build_filename(path, "steamapps/compatdata", appidStr, "pfx/drive_c/users/steamuser/AppData/Local/", GAMES_NAMES[gameId], "loadorder.txt", NULL); + char * loadOrderPath = g_build_filename(path, "steamapps/compatdata", appidStr, "pfx/drive_c/users/steamuser/Local Settings/Application Data/", GAMES_NAMES[gameId], "loadorder.txt", NULL); + + GList * l_currentLoadOrder = NULL; + if(access(loadOrderPath, R_OK) == 0) { + FILE * f_loadOrder = fopen(loadOrderPath, "r"); + + size_t length = 0; + char * line = NULL; + + while(getline(&line, &length, f_loadOrder) > 0) { + if(line[0] == '#' || line[0] == '\n') + continue; + + removeCRLF_CR_LF(line); + + l_currentLoadOrder = g_list_append(l_currentLoadOrder, strdup(line)); + } + if(line != NULL)free(line); + } + + + GList * l_currentLoadOrderCursor = l_currentLoadOrder; + GList * l_completeLoadOrder = NULL; + + while(l_currentLoadOrderCursor != NULL) { + char * modName = l_currentLoadOrderCursor->data; + //TODO: finir sa + GList * mod = g_list_find_custom(l_plugins, modName, (GCompareFunc)strcmp); + if(mod == NULL) { + //The plugin is no longer installed + continue; + } else { + l_completeLoadOrder = g_list_append(l_completeLoadOrder, strdup(modName)); + } + l_currentLoadOrderCursor = g_list_next(l_currentLoadOrderCursor); + } + + *order = l_completeLoadOrder; + + g_list_free_full(l_plugins, free); + g_list_free_full(l_currentLoadOrder, free); + g_free(loadOrderPath); + return ERR_SUCCESS; +} + +error_t order_setLoadOrder(int appid, GList * loadOrder) { + GHashTable * gamePaths; + error_t status = steam_searchGames(&gamePaths); + if(status == ERR_FAILURE) { + return ERR_FAILURE; + } + + int gameId = steam_gameIdFromAppId(appid); + if(gameId < 0 ) { + return ERR_FAILURE; + } + + size_t appidStrLen = snprintf(NULL, 0, "%d", appid) + 1; + char appidStr[appidStrLen]; + sprintf(appidStr, "%d", appid); + + const char * path = g_hash_table_lookup(gamePaths, &gameId); + char * loadOrderPath = g_build_filename(path, "steamapps/compatdata", appidStr, "pfx/drive_c/users/steamuser/AppData/Local/", GAMES_NAMES[gameId], "loadorder.txt", NULL); + + FILE * f_loadOrder = fopen(loadOrderPath, "w"); + while(loadOrder != NULL) { + fwrite(loadOrder->data, sizeof(char), strlen(loadOrder->data), f_loadOrder); + loadOrder = g_list_next(loadOrder); + } + fclose(f_loadOrder); + + return ERR_SUCCESS; +} + +//TODO: support compression since it can change how we read the file +//https://en.uesp.net/wiki/Skyrim_Mod:Mod_File_Format#Records +//https://www.mwmythicmods.com/argent/tech/es_format.html +error_t order_getModDependencies(const char * esmPath, GList ** dependencies) { + FILE * file = fopen(esmPath, "r"); + + char sectionName[5]; + sectionName[4] = '\0'; + fread(sectionName, sizeof(char), 4, file); + + size_t sizeFieldSize = 0; + u_int8_t recordHeaderToIgnore = 0; + + //the field "length" in the sub-record change between games. + //TES4 => Fallout4 Oblivion Skyrim(+SE) + //TES3 => Morrowind + if(strcmp(sectionName, "TES3") == 0) { + printf("Using tes3 file format\n"); + recordHeaderToIgnore = 8; + sizeFieldSize = 4; + } else if(strcmp(sectionName, "TES4") == 0) { + printf("Using tes4 file format\n"); + recordHeaderToIgnore = 16; + sizeFieldSize = 2; + } else { + fprintf(stderr, "Unrecognized file format %s\n", sectionName); + fclose(file); + return ERR_FAILURE; + } + + + u_int32_t lengthVal = 0; + fread(&lengthVal, 4, 1, file); + //ignore the rest of the data + fseek(file, recordHeaderToIgnore, SEEK_CUR); + + int64_t length = lengthVal; + while(length > 0) { + char sectionName[5]; + sectionName[4] = '\0'; + fread(sectionName, sizeof(char), 4, file); + unsigned long subsectionLength = 0; + fread(&subsectionLength, sizeFieldSize, 1, file); + + length -= 8 + subsectionLength; + if(strcmp(sectionName, "MAST") == 0) { + char * dependency = malloc(subsectionLength + 1); + dependency[subsectionLength] = '\0'; + fread(dependency, sizeof(char), subsectionLength, file); + *dependencies = g_list_append(*dependencies, dependency); + } else { + fseek(file, subsectionLength, SEEK_CUR); + } + } + fclose(file); + return ERR_SUCCESS; +} diff --git a/src/loadOrder.h b/src/loadOrder.h new file mode 100644 index 0000000..2f8f67e --- /dev/null +++ b/src/loadOrder.h @@ -0,0 +1,36 @@ +#ifndef __LOAD_ORDER_H__ +#define __LOAD_ORDER_H__ + +#include +#include "main.h" + +/** + * @brief find all plugins in the data folder of the game + * @param appid the appid of the game + * @param order a pointer to a null Glist *. in which there will be the list of esm files. + */ +error_t order_listPlugins(int appid, GList ** list) __attribute__((warn_unused_result)); + +/** + * @brief fetch the load order of the game it might be null if setLoadOrder was never called. + * @param appid the appid of the game + * @param order a pointer to a null Glist *. in which there will be the list of esm files. + */ +error_t order_getLoadOrder(int appid, GList ** order) __attribute__((warn_unused_result)); + +/** + * @brief change the plugin load order of the game + * @param appid the appid of the game + * @param loadOrder the load order + */ +error_t order_setLoadOrder(int appid, GList * loadOrder) __attribute__((warn_unused_result)); + +/** + * @brief List all dependencies for a esm mod. + * @param esmPath path to the esm file + * @param dependencies a pointer to a null Glist *. in which there will be the list of esm files. + * free it using g_list_free_full(dependencies, free); + */ +error_t order_getModDependencies(const char * esmPath, GList ** dependencies) __attribute__((warn_unused_result)); + +#endif diff --git a/src/main.c b/src/main.c index 0d1f95d..b4d6d53 100644 --- a/src/main.c +++ b/src/main.c @@ -1,6 +1,5 @@ #include #include -#include #include #include #include @@ -9,6 +8,8 @@ #include #include +#include "getDataPath.h" +#include "loadOrder.h" #include "overlayfs.h" #include "install.h" #include "getHome.h" @@ -21,12 +22,14 @@ #include "gui/guiMain.h" GHashTable * gamePaths; +#define ENABLED_COLOR "\033[0;32m" +#define DISABLED_COLOR "\033[0;31m" -bool isRoot() { +static bool isRoot() { return getuid() == 0; } -GList * listFilesInFolder(const char * path) { +static GList * listFilesInFolder(const char * path) { GList * list = NULL; DIR *d; struct dirent *dir; @@ -44,45 +47,52 @@ GList * listFilesInFolder(const char * path) { return list; } -int noRoot() { - printf("Don't run this argument as root\n"); - return EXIT_FAILURE; -} - -int needRoot() { - printf("Root is needed to bind with the game files\n"); - return EXIT_FAILURE; -} - -int usage() { +static int usage() { printf("Use --list-games or -l to list compatible games\n"); + + printf("Use --bind or -d to deploy the mods for the game\n"); + printf("Use --unbind to rollback a deployment\n"); + printf("Use --add or -a to add a mod to a game\n"); + printf("Use --remove or -r to remove a mod\n"); + printf("Use --fomod to create a new mod using the result from the FOMod\n"); + printf("Use --list-mods or -m to list all mods for a game\n"); printf("Use --install or -i to add a mod to a game\n"); printf("Use --uninstall or -u to uninstall a mod from a game\n"); - printf("Use --remove or -r to remove a mod\n"); - printf("Use --deploy or -d to deploy the mods for the game\n"); - printf("Use --unbind to rollback a deployment\n"); - printf("Use --fomod to create a new mod using the result from the FOMod\n"); + + printf("Use --swap MODID B> to swap two mod in the loading order\n"); + + printf("Use --version or -v to get the version number\n"); + + printf("Use --show-load-order \n"); + printf("Use --list-plugins \n"); return EXIT_FAILURE; } -int validateAppId(const char * appIdStr) { +static error_t validateAppId(const char * appIdStr) { + GHashTable * gamePaths; + error_t status = steam_searchGames(&gamePaths); + if(status == ERR_FAILURE) { + return ERR_FAILURE; + } + + char * strtoulSentinel; //strtoul set EINVAL(after C99) if the string is invalid - unsigned long appid = strtoul(appIdStr, NULL, 10); - if(errno == EINVAL) { - printf("Appid has to be a valid number\n"); + unsigned long appid = strtoul(appIdStr, &strtoulSentinel, 10); + if(errno == EINVAL || strtoulSentinel == appIdStr) { + fprintf(stderr, "Appid has to be a valid number\n"); return -1; } - int gameId = getGameIdFromAppId(appid); + int gameId = steam_gameIdFromAppId((int)appid); if(gameId < 0) { - printf("Game is not compatible\n"); + fprintf(stderr, "Game is not compatible\n"); return -1; } if(!g_hash_table_contains(gamePaths, &gameId)) { - printf("Game not found\n"); + fprintf(stderr, "Game not found\n"); return -1; } @@ -90,8 +100,15 @@ int validateAppId(const char * appIdStr) { return (int)appid; } -int listGames(int argc, char ** argv) { +static int listGames(int argc, char **) { if(argc != 2) return usage(); + + GHashTable * gamePaths; + error_t status = steam_searchGames(&gamePaths); + if(status == ERR_FAILURE) { + return EXIT_FAILURE; + } + GList * gamesIds = g_hash_table_get_keys(gamePaths); GList * gamesIdsFirstPointer = gamesIds; if(g_list_length(gamesIds) == 0) { @@ -104,10 +121,10 @@ int listGames(int argc, char ** argv) { } } g_list_free(gamesIdsFirstPointer); - return EXIT_SUCCESS; + return EXIT_FAILURE; } -int add(int argc, char ** argv) { +static int add(int argc, char ** argv) { if(argc != 4) return usage(); const char * appIdStr = argv[2]; @@ -116,11 +133,11 @@ int add(int argc, char ** argv) { return EXIT_FAILURE; } - addMod(argv[3], appid); + install_addMod(argv[3], appid); return EXIT_SUCCESS; } -int listAllMods(int argc, char ** argv) { +static int listAllMods(int argc, char ** argv) { if(argc != 3) return usage(); char * appIdStr = argv[2]; int appid = validateAppId(appIdStr); @@ -133,7 +150,8 @@ int listAllMods(int argc, char ** argv) { char * modFolder = g_build_filename(home, MANAGER_FILES, MOD_FOLDER_NAME, appIdStr, NULL); free(home); - GList * mods = listMods(appid); + GList * mods = order_listMods(appid); + GList * p_mods = mods; unsigned short index = 0; printf("Id | Installed | Name\n"); @@ -142,18 +160,20 @@ int listAllMods(int argc, char ** argv) { char * modPath = g_build_filename(modFolder, modName, INSTALLED_FLAG_FILE, NULL); if(access(modPath, F_OK) == 0) { - printf("\033[0;32m %d | ✓ | %s\n", index, modName); + printf(ENABLED_COLOR " %d | ✓ | %s\n", index, modName); } else { - printf("\033[0;31m %d | ✕ | %s\n", index, modName); + printf(DISABLED_COLOR " %d | ✕ | %s\n", index, modName); } + g_free(modPath); + index++; mods = g_list_next(mods); } free(modFolder); - free(mods); + g_list_free_full(p_mods, free); return EXIT_SUCCESS; } @@ -163,7 +183,7 @@ int listAllMods(int argc, char ** argv) { * this will just flag the mod as needed to be deployed * it's the deploying process that handle the rest */ -int installAndUninstallMod(int argc, char ** argv, bool install) { +static int installAndUninstallMod(int argc, char ** argv, bool install) { if(argc != 4) return usage(); char * appIdStr = argv[2]; int appid = validateAppId(appIdStr); @@ -176,7 +196,7 @@ int installAndUninstallMod(int argc, char ** argv, bool install) { //strtoul set EINVAL if the string is invalid unsigned long modId = strtoul(argv[3], NULL, 10); if(errno == EINVAL) { - printf("ModId has to be a valid number\n"); + fprintf(stderr, "ModId has to be a valid number\n"); return -1; } @@ -187,12 +207,12 @@ int installAndUninstallMod(int argc, char ** argv, bool install) { GList * mods = listFilesInFolder(modFolder); GList * modsFirstPointer = mods; - for(int i = 0; i < modId; i++) { + for(unsigned long i = 0; i < modId; i++) { mods = g_list_next(mods); } if(mods == NULL) { - printf("Mod not found\n"); + fprintf(stderr, "Mod not found\n"); return EXIT_FAILURE; } @@ -201,7 +221,7 @@ int installAndUninstallMod(int argc, char ** argv, bool install) { if(install) { if(access(modFlag, F_OK) == 0) { - printf("The mod is already activated \n"); + fprintf(stderr, "The mod is already activated \n"); returnValue = EXIT_SUCCESS; goto exit; } @@ -223,8 +243,8 @@ int installAndUninstallMod(int argc, char ** argv, bool install) { } if(unlink(modFlag) != 0) { - printf("Error could not disable the mod.\n"); - printf("please remove this file '%s' as root\n", modFlag); + fprintf(stderr, "Error could not disable the mod.\n"); + fprintf(stderr, "please remove this file '%s'\n", modFlag); returnValue = EXIT_FAILURE; goto exit; } @@ -238,7 +258,7 @@ exit: return returnValue; } -int deploy(int argc, char ** argv) { +static int deploy(int argc, char ** argv) { if(argc != 3) return usage(); char * appIdStr = argv[2]; @@ -251,7 +271,10 @@ int deploy(int argc, char ** argv) { char * gameFolder = g_build_filename(home, MANAGER_FILES, GAME_FOLDER_NAME, appIdStr, NULL); if(access(gameFolder, F_OK) != 0) { + free(home); + g_free(gameFolder); printf("Please run '%s --setup %d' first", APP_NAME, appid); + return EXIT_FAILURE; } //unmount everything beforhand @@ -297,9 +320,13 @@ int deploy(int argc, char ** argv) { modsToInstall[modCount] = gameFolder; modsToInstall[modCount + 1] = NULL; printf("Mounting the overlay\n"); - int gameId = getGameIdFromAppId(appid); - const char * path = g_hash_table_lookup(gamePaths, &gameId); - char * steamGameFolder = g_build_path("/", path, "steamapps/common", GAMES_NAMES[gameId], "Data", NULL); + + char * dataFolder = NULL; + error_t error = getDataPath(appid, &dataFolder); + if(error != ERR_SUCCESS) { + free(home); + return ERR_FAILURE; + } char * gameUpperDir = g_build_filename(home, MANAGER_FILES, GAME_UPPER_DIR_NAME, appIdStr, NULL); char * gameWorkDir = g_build_filename(home, MANAGER_FILES, GAME_WORK_DIR_NAME, appIdStr, NULL); @@ -309,36 +336,35 @@ int deploy(int argc, char ** argv) { //DETACH + FORCE allow us to be sure it will be unload. //it might crash / corrupt game file if the user do it while the game is running //but it's still very unlikely - while(umount2(steamGameFolder, MNT_FORCE | MNT_DETACH) == 0); - int status = overlayMount(modsToInstall, steamGameFolder, gameUpperDir, gameWorkDir); - if(status == 0) { + while(umount2(dataFolder, MNT_FORCE | MNT_DETACH) == 0); + overlay_errors_t status = overlay_mount(modsToInstall, dataFolder, gameUpperDir, gameWorkDir); + if(status == SUCESS) { printf("Everything is ready, just launch the game\n"); - } else if(status == -1) { - printf("Could not mount the mods overlay, try to install fuse-overlay\n"); + } else if(status == FAILURE) { + fprintf(stderr, "Could not mount the mods overlay\n"); return EXIT_FAILURE; - } else if(status == -2) { - printf("Could not mount the mods overlay\n"); + } else if(status == NOT_INSTALLED) { + fprintf(stderr, "Please install fuse-overlayfs\n"); return EXIT_FAILURE; } else { - printf("%d take a screenshot and go insult the dev that let this passthrough\n", __LINE__); + fprintf(stderr, "%d bug detected, please report this.\n", __LINE__); return EXIT_FAILURE; } - g_free(steamGameFolder); + g_free(dataFolder); g_free(gameUpperDir); g_free(gameWorkDir); return EXIT_SUCCESS; } -int setup(int argc, char ** argv) { +static int setup(int argc, char ** argv) { if(argc != 3 ) return usage(); const char * appIdStr = argv[2]; int appid = validateAppId(appIdStr); if(appid < 0) { return EXIT_FAILURE; } - int gameId = getGameIdFromAppId(appid); char * home = getHome(); char * gameUpperDir = g_build_filename(home, MANAGER_FILES, GAME_UPPER_DIR_NAME, appIdStr, NULL); @@ -348,69 +374,75 @@ int setup(int argc, char ** argv) { free(gameUpperDir); free(gameWorkDir); - const char * path = g_hash_table_lookup(gamePaths, &gameId); - char * steamGameFolder = g_build_path("/", path, "steamapps/common", GAMES_NAMES[gameId], "Data", NULL); + char * dataFolder = NULL; + error_t error = getDataPath(appid, &dataFolder); + if(error != ERR_SUCCESS) { + return ERR_FAILURE; + } char * gameFolder = g_build_filename(home, MANAGER_FILES, GAME_FOLDER_NAME, appIdStr, NULL); if(access(gameFolder, F_OK) == 0) { //if the game folder alredy exists just delete it //this will allow the removal of dlcs and language change - delete(gameFolder, true); + file_delete(gameFolder, true); } g_mkdir_with_parents(gameFolder, 0755); //links don't conflict with overlayfs and avoid coping 17Gb of files. //but links require the files to be on the same filesystem - int returnValue = copy(steamGameFolder, gameFolder, CP_RECURSIVE | CP_NO_TARGET_DIR | CP_LINK); + int returnValue = file_copy(dataFolder, gameFolder, FILE_CP_RECURSIVE | FILE_CP_NO_TARGET_DIR | FILE_CP_LINK); if(returnValue < 0) { printf("Coping game files. HINT: having the game on the same partition as you home director will make this operation use zero extra space"); - returnValue = copy(steamGameFolder, gameFolder, CP_RECURSIVE | CP_NO_TARGET_DIR); + returnValue = file_copy(dataFolder, gameFolder, FILE_CP_RECURSIVE | FILE_CP_NO_TARGET_DIR); if(returnValue < 0) { fprintf(stderr, "Copy failed make sure you have enough space on your device."); - free(steamGameFolder); + free(dataFolder); free(gameFolder); return EXIT_FAILURE; } } - casefold(gameFolder); + file_casefold(gameFolder); - free(steamGameFolder); + free(dataFolder); free(gameFolder); printf("Done\n"); return EXIT_SUCCESS; } -int unbind(int argc, char ** argv) { +static int unbind(int argc, char ** argv) { if(argc != 3 ) return usage(); const char * appIdStr = argv[2]; int appid = validateAppId(appIdStr); if(appid < 0) { return EXIT_FAILURE; } - int gameId = getGameIdFromAppId(appid); - const char * path = g_hash_table_lookup(gamePaths, &gameId); - char * steamGameFolder = g_build_path("/", path, "steamapps/common", GAMES_NAMES[gameId], "Data", NULL); - while(umount2(steamGameFolder, MNT_FORCE | MNT_DETACH) == 0); + char * dataFolder = NULL; + error_t error = getDataPath(appid, &dataFolder); + if(error != ERR_SUCCESS) { + return ERR_FAILURE; + } - free(steamGameFolder); + while(umount2(dataFolder, MNT_FORCE | MNT_DETACH) == 0); + + free(dataFolder); return EXIT_SUCCESS; } -int removeMod(int argc, char ** argv) { +static int removeMod(int argc, char ** argv) { if(argc != 4) return usage(); const char * appIdStr = argv[2]; int appid = validateAppId(appIdStr); if(appid < 0) { - printf("Invalid appid"); + fprintf(stderr, "Invalid appid"); return EXIT_FAILURE; } //strtoul set EINVAL if the string is invalid unsigned long modId = strtoul(argv[3], NULL, 10); if(errno == EINVAL) { - printf("Modid has to be a valid number\n"); + fprintf(stderr, "Modid has to be a valid number\n"); return EXIT_FAILURE; } @@ -421,18 +453,18 @@ int removeMod(int argc, char ** argv) { GList * mods = listFilesInFolder(modFolder); GList * modsFirstPointer = mods; - for(int i = 0; i < modId; i++) { + for(unsigned long i = 0; i < modId; i++) { mods = g_list_next(mods); } if(mods == NULL) { - printf("Mod not found\n"); + fprintf(stderr, "Mod not found\n"); return EXIT_FAILURE; } gchar * filename = g_build_filename(modFolder, mods->data, NULL); - delete(filename, true); + file_delete(filename, true); g_free(filename); g_free(modFolder); @@ -440,19 +472,19 @@ int removeMod(int argc, char ** argv) { return EXIT_SUCCESS; } -int fomod(int argc, char ** argv) { +static int fomod(int argc, char ** argv) { if(argc != 4) return usage(); char * appIdStr = argv[2]; int appid = validateAppId(appIdStr); if(appid < 0) { - printf("Invalid appid"); + fprintf(stderr, "Invalid appid"); return EXIT_FAILURE; } //strtoul set EINVAL if the string is invalid unsigned long modId = strtoul(argv[3], NULL, 10); if(errno == EINVAL) { - printf("Modid has to be a valid number\n"); + fprintf(stderr, "Modid has to be a valid number\n"); return -1; } @@ -463,25 +495,25 @@ int fomod(int argc, char ** argv) { GList * mods = listFilesInFolder(modFolder); GList * modsFirstPointer = mods; - for(int i = 0; i < modId; i++) { + for(unsigned long i = 0; i < modId; i++) { mods = g_list_next(mods); } if(mods == NULL) { - printf("Mod not found\n"); + fprintf(stderr, "Mod not found\n"); return EXIT_FAILURE; } char * destination = g_strconcat(mods->data, "__FOMOD", NULL); if(access(destination, F_OK) == 0) { - delete(destination, true); + file_delete(destination, true); } char * modDestination = g_build_filename(modFolder, destination, NULL); char * modPath = g_build_filename(modFolder, mods->data, NULL); //TODO: add error handling - int returnValue = installFOMod(modPath, modDestination); + int returnValue = fomod_installFOMod(modPath, modDestination); free(destination); g_list_free_full(modsFirstPointer, free); @@ -491,24 +523,98 @@ int fomod(int argc, char ** argv) { return returnValue; } -int main(int argc, char ** argv) { - if(argc < 2 ) return usage(); - - if(audit_getloginuid() == 0) { - printf("Root user should not be using this\n"); +static int swapMod(int argc, char ** argv) { + if(argc != 5) return usage(); + char * appIdStr = argv[2]; + int appid = validateAppId(appIdStr); + if(appid < 0) { + fprintf(stderr, "Invalid appid"); return EXIT_FAILURE; } - int searchStatus; - gamePaths = search_games(&searchStatus); - int returnValue = EXIT_SUCCESS; - if(searchStatus == EXIT_FAILURE) { - returnValue = EXIT_FAILURE; - printf("Error while looking up libraries, do you have steam installed ?"); - goto exit; + char * sentinel; + //no mod will go over the MAX_INT value + int modIdA = (int)strtoul(argv[3], &sentinel, 10); + if(errno == EINVAL || sentinel == argv[3]) { + fprintf(stderr, "Modid A has to be a valid number\n"); + return -1; + } + int modIdB = (int)strtoul(argv[4], &sentinel, 10); + if(errno == EINVAL || sentinel == argv[4]) { + fprintf(stderr, "Modid B has to be a valid number\n"); + return -1; } + printf("%d, %d\n", modIdA, modIdB); + return order_swapPlace(appid, modIdA, modIdB); +} + +static int printLoadOrder(int argc, char ** argv) { + if(argc != 3) return usage(); + + char * appIdStr = argv[2]; + int appid = validateAppId(appIdStr); + if(appid < 0) { + fprintf(stderr, "Invalid appid"); + return EXIT_FAILURE; + } + + GList * order = NULL; + error_t status = order_getLoadOrder(appid, &order); + if(status != ERR_SUCCESS) { + fprintf(stderr, "Could not fetch the load order\n"); + return EXIT_FAILURE; + } + + printf("If the load order is empty that mean it wasn't set\n"); + + GList * cur_order = order; + while (cur_order != NULL) { + printf("%s\n", (char *)cur_order->data); + cur_order = g_list_next(cur_order); + } + + g_list_free_full(order, free); + return EXIT_SUCCESS; +} + +static int printPlugins(int argc, char ** argv) { + if(argc != 3) return usage(); + + char * appIdStr = argv[2]; + int appid = validateAppId(appIdStr); + if(appid < 0) { + fprintf(stderr, "Invalid appid"); + return EXIT_FAILURE; + } + + GList * mods = NULL; + error_t status = order_listPlugins(appid, &mods); + if(status != ERR_SUCCESS) { + fprintf(stderr, "Could not list plugins\n"); + return EXIT_FAILURE; + } + + GList * cur_mods = mods; + while (cur_mods != NULL) { + printf("%s\n", (char *)cur_mods->data); + cur_mods = g_list_next(cur_mods); + } + + g_list_free_full(mods, free); + return EXIT_SUCCESS; +} + +int main(int argc, char ** argv) { + if(argc < 2 ) return usage(); + + if(audit_getloginuid() == 0 || isRoot()) { + fprintf(stderr, "Please don't run this software as root\n"); + return EXIT_FAILURE; + } + + int returnValue = EXIT_SUCCESS; char * home = getHome(); char * configFolder = g_build_filename(home, MANAGER_FILES, NULL); free(home); @@ -519,92 +625,76 @@ int main(int argc, char ** argv) { //such as problem with access rights and taking the risk of //running system as root (which is a big security issue) if(getuid() == 0) { - printf("For the first please run without sudo\n"); + fprintf(stderr, "For the first run please avoid sudo\n"); returnValue = EXIT_FAILURE; - goto exit2; + goto exit; } else { //leading 0 == octal int i = g_mkdir_with_parents(configFolder, 0755); if(i < 0) { - printf("Could not create configs, check access rights for this path: %s", configFolder); + fprintf(stderr, "Could not create configs, check access rights for this path: %s", configFolder); + goto exit; } } } + if(strcmp(argv[1], "--list-games") == 0 || strcmp(argv[1], "-l") == 0) + returnValue = listGames(argc, argv); - if(strcmp(argv[1], "--list-games") == 0 || strcmp(argv[1], "-l") == 0) { - if(isRoot()) - returnValue = noRoot(); - else - returnValue = listGames(argc, argv); + else if(strcmp(argv[1], "--add") == 0 || strcmp(argv[1], "-a") == 0) + returnValue = add(argc, argv); - } else if(strcmp(argv[1], "--add") == 0 || strcmp(argv[1], "-a") == 0) { - if(isRoot()) - returnValue = noRoot(); - else - returnValue = add(argc, argv); + else if(strcmp(argv[1], "--list-mods") == 0 || strcmp(argv[1], "-m") == 0) + returnValue = listAllMods(argc, argv); - } else if(strcmp(argv[1], "--list-mods") == 0 || strcmp(argv[1], "-m") == 0) { - if(isRoot()) - returnValue = noRoot(); - else - returnValue = listAllMods(argc, argv); + else if(strcmp(argv[1], "--install") == 0 || strcmp(argv[1], "-i") == 0) + returnValue = installAndUninstallMod(argc, argv, true); - } else if(strcmp(argv[1], "--install") == 0 || strcmp(argv[1], "-i") == 0) { - if(isRoot()) - returnValue = noRoot(); - else - returnValue = installAndUninstallMod(argc, argv, true); + else if(strcmp(argv[1], "--uninstall") == 0 || strcmp(argv[1], "-u") == 0) + returnValue = installAndUninstallMod(argc, argv, false); - } else if(strcmp(argv[1], "--uninstall") == 0 || strcmp(argv[1], "-u") == 0) { - if(isRoot()) - returnValue = noRoot(); - else - returnValue = installAndUninstallMod(argc, argv, false); + else if(strcmp(argv[1], "--bind") == 0 || strcmp(argv[1], "-d") == 0) + returnValue = deploy(argc, argv); - } else if(strcmp(argv[1], "--deploy") == 0 || strcmp(argv[1], "-d") == 0) { - if(!isRoot()) - returnValue = needRoot(); - else - returnValue = deploy(argc, argv); + else if(strcmp(argv[1], "--unbind") == 0) + returnValue = unbind(argc, argv); - } else if(strcmp(argv[1], "--unbind") == 0){ - if(!isRoot()) - returnValue = needRoot(); - else - returnValue = unbind(argc, argv); + else if(strcmp(argv[1], "--setup") == 0) + returnValue = setup(argc, argv); - } else if(strcmp(argv[1], "--setup") == 0) { - if(isRoot()) - returnValue = noRoot(); - else - returnValue = setup(argc, argv); - } else if(strcmp(argv[1], "--fomod") == 0){ - if(isRoot()) - returnValue = noRoot(); - else - returnValue = fomod(argc, argv); + else if(strcmp(argv[1], "--fomod") == 0) + returnValue = fomod(argc, argv); - } else if(strcmp(argv[1], "--remove") == 0 || strcmp(argv[1], "-r") == 0) { - if(isRoot()) - returnValue = noRoot(); - else - returnValue = removeMod(argc, argv); + else if(strcmp(argv[1], "--remove") == 0 || strcmp(argv[1], "-r") == 0) + returnValue = removeMod(argc, argv); - } else if(strcmp(argv[1], "--gui") == 0) { - if(isRoot()) - returnValue = noRoot(); - else - returnValue = guiMain(argc, argv); + else if(strcmp(argv[1], "--gui") == 0) + returnValue = guiMain(argc, argv); + else if(strcmp(argv[1], "--swap") == 0 || strcmp(argv[1], "-s") == 0) + returnValue = swapMod(argc, argv); + + else if(strcmp(argv[1], "--list-plugins") == 0) + returnValue = printPlugins(argc, argv); + + else if(strcmp(argv[1], "--show-load-order") == 0) + returnValue = printLoadOrder(argc, argv); + + else if(strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-v") == 0) { + #ifdef __clang__ + printf("%s: Clang: %d.%d.%d\n", VERSION, __clang_major__, __clang_minor__, __clang_patchlevel__); + #elifdef __GNUC__ + printf("%s: GCC: %d.%d.%d\n", VERSION, __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__); + #else + printf("%s: unknown compiler\n", VERSION); + #endif } else { usage(); returnValue = EXIT_FAILURE; } -exit2: - g_free(configFolder); - g_hash_table_destroy(gamePaths); exit: + g_free(configFolder); + steam_freeGameTable(); return returnValue; } diff --git a/src/main.h b/src/main.h index e63cd96..a563bd6 100644 --- a/src/main.h +++ b/src/main.h @@ -1,6 +1,11 @@ -//no function should ever be put here, only keep important macros here +#ifndef __MAIN_H__ +#define __MAIN_H__ -#define APP_NAME "modmanager" +#include + +//no function should ever be put here, only keep important macros and globals here + +#define APP_NAME "mod-manager" //relative to home the url is not preprocessed so ../ might create some issues // in c "A" "B" is the same as "AB" #define MANAGER_FILES ".local/share/" APP_NAME @@ -11,3 +16,9 @@ #define GAME_UPPER_DIR_NAME "UPPER_DIRS" //overlayfs temporary dir. #define GAME_WORK_DIR_NAME "WORK_DIRS" + +#define VERSION "0.1" + +typedef enum { ERR_SUCCESS, ERR_FAILURE } error_t; + +#endif diff --git a/src/order.c b/src/order.c index 0354585..03d935a 100644 --- a/src/order.c +++ b/src/order.c @@ -1,4 +1,5 @@ #include +#include #include "order.h" //no function are declared in main it's just macros @@ -11,7 +12,7 @@ typedef struct Mod { char * name; } Mod_t; -gint compareOrder(const void * a, const void * b) { +static gint compareOrder(const void * a, const void * b) { const Mod_t * ModA = a; const Mod_t * ModB = b; @@ -21,7 +22,7 @@ gint compareOrder(const void * a, const void * b) { return ModA->modId - ModB->modId; } -GList * listMods(int appid) { +GList * order_listMods(int appid) { char appidStr[10]; sprintf(appidStr, "%d", appid); @@ -50,6 +51,7 @@ GList * listMods(int appid) { Mod_t * mod = alloca(sizeof(Mod_t)); mod->modId = modId; + //we are going to return this value so no alloca here mod->name = strdup(dir->d_name); //strdup but on the stack //add one for the \0 @@ -92,9 +94,52 @@ GList * listMods(int appid) { } -void swapPlace(int appid, int modId, int modId2) { - GList * list = listMods(appid); +error_t order_swapPlace(int appid, int modIdA, int modIdB) { + char appidStr[10]; + sprintf(appidStr, "%d", appid); + char * home = getHome(); + char * modFolder = g_build_filename(home, MANAGER_FILES, MOD_FOLDER_NAME, appidStr, NULL); + free(home); - g_list_free(list); + GList * list = order_listMods(appid); + GList * listA = list; + GList * listB = list; + + for(int i = 0; i < modIdA; i++) { + listA = g_list_next(listA); + } + + for(int i = 0; i < modIdB; i++) { + listB = g_list_next(listB); + } + + if(listA == NULL || listB == NULL) { + fprintf(stderr, "Invalid modId\n"); + return ERR_FAILURE; + } + + char * modAFolder = g_build_filename(modFolder, listA->data, ORDER_FILE, NULL); + char * modBFolder = g_build_filename(modFolder, listB->data, ORDER_FILE, NULL); + g_free(modFolder); + + FILE * fileA = fopen(modAFolder, "w"); + FILE * fileB = fopen(modBFolder, "w"); + + g_free(modAFolder); + g_free(modBFolder); + + if(fileA == NULL || fileB == NULL) { + fprintf(stderr, "Error could not open order file\n"); + return ERR_FAILURE; + } + + fprintf(fileA, "%d", modIdB); + fprintf(fileB, "%d", modIdA); + + fclose(fileA); + fclose(fileB); + + g_list_free_full(list, free); + return ERR_SUCCESS; } diff --git a/src/order.h b/src/order.h index 020b04d..33f1812 100644 --- a/src/order.h +++ b/src/order.h @@ -2,6 +2,7 @@ #define __ORDER_H__ #include +#include "main.h" #define ORDER_FILE "__ORDER__" @@ -14,7 +15,7 @@ * * @return GList of char containing the name of the mod folder in order */ -GList * listMods(int appid); +GList * order_listMods(int appid); /** * @brief Change the mod order by swaping two mod @@ -24,6 +25,6 @@ GList * listMods(int appid); * @param modId * @param modId2 */ -void swapPlace(int appid, int modId, int modId2); +error_t order_swapPlace(int appid, int modId, int modId2); #endif diff --git a/src/overlayfs.c b/src/overlayfs.c index 43a6b49..8ba7c2a 100644 --- a/src/overlayfs.c +++ b/src/overlayfs.c @@ -6,39 +6,29 @@ #include "overlayfs.h" #include -int overlayMount(char ** sources, const char * dest, const char * upperdir, const char * workdir) { +overlay_errors_t overlay_mount(char ** sources, const char * dest, const char * upperdir, const char * workdir) { char * lowerdir = g_strjoinv(":", sources); char * mountData = g_strjoin("", "lowerdir=", lowerdir, ",workdir=", workdir, ",upperdir=", upperdir, NULL); - int result = mount("overlay", "none", "overlay", MS_RDONLY, mountData); - if(result < 0) { - //this is very important for a lot of filesystems - //even ext4 can be incompatible with the kernel's implementation - //with some flags such as casefold - if(access("/usr/bin/fuse-overlayfs", F_OK) == 0) { - int pid = fork(); - if(pid == 0) { - //exit is used to get the return value when using waitpid - exit(execl("/usr/bin/fuse-overlayfs", "/usr/bin/fuse-overlayfs", "-r", "-o", mountData, dest, NULL)); - } else { - - int returnValue = 0; - waitpid(pid, &returnValue, 0); - free(lowerdir); - free(mountData); - if(returnValue != 0) { - return -2; - } - return 0; - } + overlay_errors_t result = SUCESS; + if(access("/usr/bin/fuse-overlayfs", F_OK) == 0) { + int pid = fork(); + if(pid == 0) { + //exit is used to get the return value when using waitpid + exit(execl("/usr/bin/fuse-overlayfs", "/usr/bin/fuse-overlayfs", "-r", "-o", mountData, dest, NULL)); } else { - free(lowerdir); - free(mountData); - return -1; + + int returnValue = 0; + waitpid(pid, &returnValue, 0); + if(returnValue != 0) { + result = FAILURE; + } } + } else { + result = NOT_INSTALLED; } free(lowerdir); free(mountData); - return 0; + return result; } diff --git a/src/overlayfs.h b/src/overlayfs.h index f9eb612..7bd95e1 100644 --- a/src/overlayfs.h +++ b/src/overlayfs.h @@ -1,6 +1,9 @@ #ifndef __OVERLAY_H__ #define __OVERLAY_H__ +typedef enum overlay_errors { SUCESS, NOT_INSTALLED, FAILURE } overlay_errors_t; + + /** * @brief Overlayfs is what make it possible to deploy to the game files without altering anything. * it allows us to overlay multiple folder over the game files. like appling filters to an image. @@ -10,6 +13,6 @@ * @param workdir a directory that will contains only temporary files. * @return int error code */ -int overlayMount(char ** sources, const char * dest, const char * upperdir, const char * workdir); +overlay_errors_t overlay_mount(char ** sources, const char * dest, const char * upperdir, const char * workdir); #endif diff --git a/src/steam.c b/src/steam.c index ee77166..f43e1fb 100644 --- a/src/steam.c +++ b/src/steam.c @@ -1,6 +1,7 @@ #include "steam.h" #include "macro.h" #include "getHome.h" +#include "main.h" #include #include #include @@ -12,7 +13,16 @@ enum FieldIds { FIELD_PATH, FIELD_LABEL, FIELD_CONTENT_ID, FIELD_TOTAL_SIZE, FIELD_CLEAN_BYTES, FIELD_CORRUPTION, FIELD_APPS }; -int getFiledId(const char * field) { +// relative to the home directory +static const char * steamLibraries[] = { + "/.steam/root/", + "/.steam/steam/", + "/.local/share/steam", + //flatpack steam. + "/.var/app/com.valvesoftware.Steam/.local/share/Steam" +}; + +static int getFiledId(const char * field) { //replace with a hash + switch if(strcmp(field, "path") == 0) { return FIELD_PATH; @@ -29,22 +39,21 @@ int getFiledId(const char * field) { } else if(strcmp(field, "apps") == 0) { return FIELD_APPS; } else { - printf("unknown field"); + fprintf(stderr, "unknown field"); return -1; } } -ValveLibraries_t * parseVDF(const char * path, size_t * size, int * status) { +static steam_Libraries_t * parseVDF(const char * path, size_t * size, int * status) { FILE * fd = fopen(path, "r"); char * line = NULL; size_t len = 0; - ssize_t read; *status = EXIT_SUCCESS; bool inQuotes = false; - ValveLibraries_t * libraries = NULL; + steam_Libraries_t * libraries = NULL; *size = 0; //skip the "libraryfolders" label & the first opening brace @@ -81,7 +90,7 @@ ValveLibraries_t * parseVDF(const char * path, size_t * size, int * status) { } else { char * value = strndup(buffer, bufferIndex); - ValveLibraries_t * library = &libraries[*size - 1]; + steam_Libraries_t * library = &libraries[*size - 1]; switch (nextFieldToFill) { case FIELD_PATH: library->path = value; @@ -111,14 +120,17 @@ ValveLibraries_t * parseVDF(const char * path, size_t * size, int * status) { case FIELD_APPS: if(isAppId) { library->appsCount++; - library->apps = realloc(library->apps, library->appsCount * sizeof(ValveApp_t)); + library->apps = realloc(library->apps, library->appsCount * sizeof(steam_App_t)); unsigned int appid = strtoul(value, NULL, 10); library->apps[library->appsCount - 1].appid = appid; } else { library->apps[library->appsCount - 1].update = strtoul(value, NULL, 10); } + free(value); isAppId = !isAppId; break; + default: + free(value); } //field apps is using braces so the syntax is different if(nextFieldToFill != FIELD_APPS)nextFieldToFill = -1; @@ -134,13 +146,14 @@ ValveLibraries_t * parseVDF(const char * path, size_t * size, int * status) { braceDepth++; if(braceDepth == 1) { *size += 1; - libraries = realloc(libraries, sizeof(ValveLibraries_t) * (*size)); - memset(&libraries[*size - 1], 0, sizeof(ValveLibraries_t)); + libraries = realloc(libraries, sizeof(steam_Libraries_t) * (*size)); + memset(&libraries[*size - 1], 0, sizeof(steam_Libraries_t)); } break; case '}': if(inQuotes) { - printf("Syntax error in VDF\n"); + fprintf(stderr, "Syntax error in VDF\n"); + //TODO: fix this leak free(libraries); libraries = NULL; *status = EXIT_FAILURE; @@ -166,7 +179,7 @@ exit: return libraries; } -void freeLibraries(ValveLibraries_t * libraries, int size) { +static void freeLibraries(steam_Libraries_t * libraries, int size) { for(int i = 0; i < size; i++) { free(libraries[i].path); free(libraries[i].label); @@ -178,13 +191,23 @@ void freeLibraries(ValveLibraries_t * libraries, int size) { free(libraries); } -GHashTable* search_games(int * status) { - ValveLibraries_t * libraries = NULL; +static GHashTable* gameTableSingleton = NULL; + +void steam_freeGameTable() { + if(gameTableSingleton != NULL)g_hash_table_destroy(gameTableSingleton); +} + +error_t steam_searchGames(GHashTable ** p_hashTable) { + if(gameTableSingleton != NULL) { + *p_hashTable = gameTableSingleton; + return ERR_SUCCESS; + } + + steam_Libraries_t * libraries = NULL; size_t size = 0; char * home = getHome(); - *status = EXIT_SUCCESS; - for(int i = 0; i < LEN(steamLibraries); i++) { + for(unsigned long i = 0; i < LEN(steamLibraries); i++) { char * path = g_build_filename(home, steamLibraries[i], "steamapps/libraryfolders.vdf", NULL); if (access(path, F_OK) == 0) { int parserStatus; @@ -200,16 +223,15 @@ GHashTable* search_games(int * status) { free(home); if(libraries == NULL) { - *status = EXIT_FAILURE; - return NULL; + return ERR_FAILURE; } GHashTable* table = g_hash_table_new_full(g_int_hash, g_int_equal, free, free); //fill the table - for(int i = 0; i < size; i++) { - for(int j = 0; j < libraries[i].appsCount; j++) { - int gameId = getGameIdFromAppId(libraries[i].apps[j].appid); + for(unsigned long i = 0; i < size; i++) { + for(unsigned long j = 0; j < libraries[i].appsCount; j++) { + int gameId = steam_gameIdFromAppId(libraries[i].apps[j].appid); if(gameId >= 0) { int * key = malloc(sizeof(int)); *key = gameId; @@ -219,12 +241,14 @@ GHashTable* search_games(int * status) { } freeLibraries(libraries, size); - return table; + *p_hashTable = table; + gameTableSingleton = table; + return ERR_SUCCESS; } -int getGameIdFromAppId(u_int32_t appid) { - for(int k = 0; k < LEN(GAMES_APPIDS); k++) { +int steam_gameIdFromAppId(u_int32_t appid) { + for(unsigned long k = 0; k < LEN(GAMES_APPIDS); k++) { if(appid == GAMES_APPIDS[k]) { return k; } diff --git a/src/steam.h b/src/steam.h index d849104..b0ec69c 100644 --- a/src/steam.h +++ b/src/steam.h @@ -1,62 +1,62 @@ #ifndef __STEAM_H__ #define __STEAM_H__ +#include "macro.h" +#include "main.h" + #include #include #include #include #include -typedef struct ValveApp { +typedef struct steam_App { unsigned int appid; unsigned int update; -} ValveApp_t; +} steam_App_t; -typedef struct ValveLibraries { +typedef struct steam_Libraries { char * path; char * label; char * contentId; unsigned long totalSize; char * update_clean_bytes_tally; char * time_last_update_corruption; - ValveApp_t * apps; + steam_App_t * apps; size_t appsCount; -} ValveLibraries_t; - -// relative to the home directory -const static char * steamLibraries[] = { - "/.steam/root/", - "/.steam/steam/", - "/.local/share/steam", - //flatpack steam. - "/.var/app/com.valvesoftware.Steam/.local/share/Steam" -}; +} steam_Libraries_t; //todo add the older games // order has to be the same as in GAMES_NAMES -const static u_int32_t GAMES_APPIDS[] = { +static const u_int32_t GAMES_APPIDS[] = { 489830, 22330, 377160, 72850, + 22320 }; //the name of the game in the steamapps/common folder -const static char * GAMES_NAMES[] = { +static const char * GAMES_NAMES[] = { "Skyrim Special Edition", "Oblivion", "Fallout 4", "Skyrim", + "Morrowind" }; +_Static_assert(LEN(GAMES_APPIDS) == LEN(GAMES_NAMES), "Game APPIDS and Game Names doesn't match"); + /** * @brief list all installed games and the paths to the game's files + * This method has a singleton so after the first execution it will no rescan for new games. * * @param status pointer to a status variable that will be modified to EXIT_SUCCESS or EXIT_FAILURE - * @return GHashTable* a map appid(int) => path(char *) + * @return GHashTable* a map gameId(int) => path(char *) to the corresponding steam library */ - //TODO: flip the return value and parameter -GHashTable* search_games(int * status); +error_t steam_searchGames(GHashTable** tablePointer); + +void steam_freeGameTable(void); /** * @brief search the index of the game inside GAMES_NAMES or GAMES_APPIDS @@ -64,6 +64,6 @@ GHashTable* search_games(int * status); * @param appid * @return -1 in case of failure or the index of the game. */ -int getGameIdFromAppId(u_int32_t appid); +int steam_gameIdFromAppId(u_int32_t appid); #endif