util.h

#include <inttypes.h>
#include <stdio.h>
#include <math.h>

#define BIN_ARRAY_LEN 1000
#define FILE_SYSTEM_STRING_MAX_SIZE 11
#define DRIVE_SIZE_STRING_MAX_SIZE 21

struct DRIVE
{
    char letter;
    char fileSystem[FILE_SYSTEM_STRING_MAX_SIZE];
    double sizeGB;
    uint8_t number;
};

uint64_t littleEndianToDecimal(uint8_t *bytes, uint8_t length)
{
    uint64_t result = 0;
    int i;
    for (i = length - 1; i >= 0; i--)
    {
        result = (result << 8) | bytes[i];
    }
    return result;
}

uint8_t maxNumberInArray(uint8_t *array, uint8_t length)
{
    uint8_t biggestNumber = 0;
    uint8_t currentNumber;
    int i;

    for (i = 0; i < length; i++)
    {
        currentNumber = array[i];
        if (currentNumber > biggestNumber)
        {
            biggestNumber = currentNumber;
        }
    }

    return biggestNumber;
}

void decimalToBinary(uint64_t decNum, uint8_t *array, uint64_t size)
{
    uint8_t binaryNum[BIN_ARRAY_LEN];
    int16_t x;

    uint16_t i = 0;
    while (decNum > 0)
    {
        binaryNum[i] = decNum % 2;
        decNum = decNum / 2;
        i++;
    }

    uint16_t y = 0;
    for (x = i - 1; x > 0; x--)
    {
        array[y] = binaryNum[x];
        y++;
    }
}

uint8_t binaryToDecimal(uint8_t *binary, uint64_t size)
{
    uint8_t dec = 0;
    uint8_t base = 1;

    int8_t i;
    for (i = size - 1; i >= 0; i--)
    {
        if (binary[i] == 1)
        {
            dec += base;
        }
        base = base * 2;
    }

    return dec;
}

uint64_t nearestNextInteger(double number)
{
    return ceil(number);
}

void elaborateTimestampBits(uint8_t *timestamp, uint8_t size)
{
    const uint16_t startYear = 1980;
    uint8_t secondsBin[5] = {0};
    uint8_t minutesBin[6] = {0};
    uint8_t hoursBin[5] = {0};
    uint8_t dayBin[5] = {0};
    uint8_t monthBin[4] = {0};
    uint8_t yearOffsetBin[6] = {0};

    memcpy(secondsBin, &timestamp[26], sizeof(secondsBin));
    memcpy(minutesBin, &timestamp[20], sizeof(minutesBin));
    memcpy(hoursBin, &timestamp[15], sizeof(hoursBin));
    memcpy(dayBin, &timestamp[10], sizeof(dayBin));
    memcpy(monthBin, &timestamp[6], sizeof(monthBin));
    memcpy(yearOffsetBin, timestamp, sizeof(yearOffsetBin));
    uint8_t secondsDec = binaryToDecimal(secondsBin, sizeof(secondsBin));
    uint8_t minutesDec = binaryToDecimal(minutesBin, sizeof(minutesBin));
    uint8_t hoursDec = binaryToDecimal(hoursBin, sizeof(hoursBin));
    uint8_t dayDec = binaryToDecimal(dayBin, sizeof(dayBin));
    uint8_t monthDec = binaryToDecimal(monthBin, sizeof(monthBin));
    uint8_t yearOffsetDec = binaryToDecimal(yearOffsetBin, sizeof(yearOffsetBin));

    printf("%d/%d/%d %d:%d:%d\n", dayDec, monthDec, (startYear + yearOffsetDec), hoursDec, minutesDec, (secondsDec * 2));
}

uint64_t clusterToSector(uint64_t clusterHeapOffset, uint64_t cluster, uint64_t sectorsPerCluster)
{
    return clusterHeapOffset + (cluster - 2) * sectorsPerCluster;
}

char *createPath(char path[], uint8_t pathLength, char folderName[], uint8_t folderNameLength, char fileName[], uint8_t fileNameLength)
{
    uint8_t pathSeparator = pathLength ? 1 : 0;
    uint8_t folderSeparator = folderNameLength ? 1 : 0;
    size_t size = pathLength + pathSeparator + folderNameLength + folderSeparator + fileNameLength + 1;

    char *res = (char *)malloc(sizeof(char) * size);
    memset(res, 0, size);

    if (size > MAX_PATH)
    {
        res[0] = 'E';
        return res;
    }

    size_t offset = 0;

    if (pathLength)
    {
        memcpy(res, path, pathLength);
        offset += pathLength;
        res[offset] = '\\';
        offset++;
    }

    if (folderNameLength)
    {
        memcpy(&res[offset], folderName, folderNameLength);
        offset += folderNameLength;
        res[offset] = '\\';
        offset++;
    }

    if (fileNameLength)
    {
        memcpy(&res[offset], fileName, fileNameLength);
        offset += fileNameLength;
    }

    res[offset] = '\0';

    return res;
}

void printSector(BYTE *buffer, uint64_t bytesPerSector)
{
    int16_t i;
    for (i = 0; i < bytesPerSector; i++)
    {
        printf("%02X ", buffer[i]);
        if ((i + 1) % 16 == 0)
            printf("\n");
    }
}

void rev(char arr[], uint8_t n)
{
    char l = 0, r = n - 1;
    while (l < r)
    {
        char temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;
        l++;
        r--;
    }
}

double U64ToDoubleConverter(uint64_t val)
{
    double convertedValue = 0.0;
    memcpy(&convertedValue, &val, sizeof(convertedValue));
    return convertedValue;
}

void trimEndPath(char *str)
{
    int len = strlen(str);
    while (len > 0 && (str[len - 1] == '\\' || str[len - 1] == ' ' || str[len - 1] == '\n'))
    {
        str[len - 1] = '\0';
        len--;
    }
}