util.c

/*
  Common code for Gust (Koei/Tecmo) PC games tools
  Copyright © 2019-2021 VitaSmith

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include "utf8.h"
#include "util.h"

// Flags to indicate the endianness of the data being processed as well as the platform
endianness data_endianness = little_endian;
const endianness platform_endianness = little_endian;

bool create_path(char* path)
{
    bool result = true;
    struct stat64_t st;
#if defined(_WIN32)
    // Ignore Windows drive names
    if ((strlen(path) == 2) && (path[1] == ':'))
        return true;
#endif
    if (stat64_utf8(path, &st) != 0) {
        // Directory doesn't exist, create it
        size_t pos = 0;
        for (size_t n = strlen(path); n > 0; n--) {
            if (path[n] == PATH_SEP) {
                while ((n > 0) && (path[--n] == PATH_SEP));
                pos = n + 1;
                break;
            }
        }
        if (pos > 0) {
            // Create parent dirs
            path[pos] = 0;
            char* new_path = malloc(strlen(path) + 1);
            if (new_path == NULL) {
                fprintf(stderr, "ERROR: Can't allocate path\n");
                return false;
            }
            strcpy(new_path, path);
            result = create_path(new_path);
            free(new_path);
            path[pos] = PATH_SEP;
        }
        // Create node
        if (result)
            result = CREATE_DIR(path);
    } else if (!S_ISDIR(st.st_mode)) {
        fprintf(stderr, "ERROR: '%s' exists but isn't a directory\n", path);
        return false;
    }

    return result;
}

// dirname/basename, that *PRESERVE* the string parameter.
// Note that these calls are not concurrent, meaning that you MUST be done
// using the returned string from a previous call before invoking again.
#if defined(_WIN32)
char* _basename_win32(const char* path, bool remove_extension)
{
    static char basename[128];
    static char ext[64];
    ext[0] = 0;
    _splitpath_s(path, NULL, 0, NULL, 0, basename, sizeof(basename), ext, sizeof(ext));
    if ((ext[0] != 0) && !remove_extension)
        strncat(basename, ext, sizeof(basename) - strlen(basename));
    return basename;
}

// This call should behave pretty similar to UNIX' dirname
char* _dirname_win32(const char* path)
{
    static char dir[PATH_MAX];
    static char drive[4];
    int found_sep = 0;
    memset(drive, 0, sizeof(drive));
    _splitpath_s(path, drive, sizeof(drive), dir, sizeof(dir) - 3, NULL, 0, NULL, 0);
    // Only deal with drives that are one letter
    drive[2] = 0;
    drive[3] = 0;
    if (drive[1] != ':')
        drive[0] = 0;
    // Removing trailing path separators
    for (int32_t n = (int32_t)strlen(dir) - 1; (n > 0) && ((dir[n] == '/') || (dir[n] == '\\')); n--) {
        dir[n] = 0;
        found_sep++;
    }
    if (dir[0] == 0) {
        if (drive[0] == 0)
            return found_sep ? "\\" : ".";
        drive[2] = '\\';
        return drive;
    }
    if (drive[0] != 0) {
        // Add the drive
        memmove(&dir[2], dir, strlen(dir) + 1);
        memcpy(dir, drive, strlen(drive));
        dir[2] = '\\';
    }
    return dir;
}
#else
char* _basename_unix(const char* path)
{
    static char path_copy[PATH_MAX];
    strncpy(path_copy, path, sizeof(path_copy));
    path_copy[PATH_MAX - 1] = 0;
    return basename(path_copy);
}

char* _dirname_unix(const char* path)
{
    static char path_copy[PATH_MAX];
    strncpy(path_copy, path, sizeof(path_copy));
    path_copy[PATH_MAX - 1] = 0;
    return dirname(path_copy);
}
#endif

bool is_file(const char* path)
{
    struct stat64_t st;
    return (stat64_utf8(path, &st) == 0) && S_ISREG(st.st_mode);
}

bool is_directory(const char* path)
{
    struct stat64_t st;
    return (stat64_utf8(path, &st) == 0) && S_ISDIR(st.st_mode);
}

char* change_extension(const char* path, const char* extension)
{
    static char new_path[PATH_MAX];
    strncpy(new_path, _basename((char*)path), sizeof(new_path) - 1);
    for (size_t i = 0; i < sizeof(new_path); i++) {
        if (new_path[i] == '.')
            new_path[i] = 0;
    }
    strncat(new_path, extension, sizeof(new_path) - strlen(new_path) - 1);
    return new_path;
}

size_t get_trailing_slash(const char* path)
{
    size_t i;
    if ((path == NULL) || (path[0] == 0))
        return 0;
    for (i = strlen(path) - 1; (i > 0) && ((path[i] != '/') && (path[i] != '\\')); i--);
    return (i == 0) ? 0: i + 1;
}

uint32_t read_file_max(const char* path, uint8_t** buf, uint32_t max_size)
{
    FILE* file = fopen_utf8(path, "rb");
    if (file == NULL) {
        fprintf(stderr, "ERROR: Can't open '%s'\n", path);
        return UINT32_MAX;
    }

    fseek(file, 0L, SEEK_END);
    uint32_t size = (uint32_t)ftell(file);
    fseek(file, 0L, SEEK_SET);
    if (max_size != 0)
        size = min(size, max_size);

    *buf = calloc(size, 1);
    if (*buf == NULL) {
        size = UINT32_MAX;
        goto out;
    }
    if (fread(*buf, 1, size, file) != size) {
        fprintf(stderr, "ERROR: Can't read '%s'\n", path);
        size = UINT32_MAX;
    }
out:
    fclose(file);
    if (size == UINT32_MAX) {
        free(*buf);
        *buf = NULL;
    }
    return size;
}

uint64_t get_file_size(const char* path)
{
    FILE* file = fopen_utf8(path, "rb");
    if (file == NULL) {
        fprintf(stderr, "ERROR: Can't open '%s'\n", path);
        return UINT32_MAX;
    }

    fseek(file, 0L, SEEK_END);
    uint64_t size = ftell64(file);
    fclose(file);
    return size;
}

void create_backup(const char* path)
{
    struct stat64_t st;
    if (stat64_utf8(path, &st) == 0) {
        char* backup_path = malloc(strlen(path) + 5);
        if (backup_path == NULL)
            return;
        strcpy(backup_path, path);
        strcat(backup_path, ".bak");
        if (stat64_utf8(backup_path, &st) != 0) {
            if (rename_utf8(path, backup_path) == 0)
                printf("Saved backup as '%s'\n", backup_path);
            else
                fprintf(stderr, "WARNING: Could not create backup file '%s\n", backup_path);
        }
        free(backup_path);
    }
}

bool write_file(const uint8_t* buf, const uint32_t size, const char* path, const bool backup)
{
    if (backup)
        create_backup(path);
    FILE* file = fopen_utf8(path, "wb");
    if (file == NULL) {
        fprintf(stderr, "ERROR: Can't create file '%s'\n", path);
        return false;
    }
    bool r = (fwrite(buf, 1, size, file) == size);
    fclose(file);
    if (!r)
        fprintf(stderr, "ERROR: Can't write file '%s'\n", path);
    return r;
}