gists/c-programming/experiments/reverse-ramdisk.c

/*
 * reverse-ramdisk.c
 *
 * C programming idea: Handling temporary files like memory allocations
 * (allocating -> creating empty file, using -> locking for R/W,
 * freeing -> deleting).
 *
 * 20% AI, 80% human (the code is tested and reviewed)
 *
 * XXX: The current result is quick and dirty. Not for educational or
 * production purposes.
 *
 * Compile with set macro TEST (using -DTEST) to set macro TEST as defined,
 * and/or with set macro DEBUG (using -DDEBUG) to enable debug mode
 *
 * TODO:XXX: `tf_free`: Do not shift the array, only empty entry
 * TODO:XXX: Implement function `tf_finish` to free the array of TempFiles
 * structs
 * TODO:XXX: `tf_free`, `tf_write`, `tf_read`: Do not use `ID` as `index`, but
 * look for it in TempFile structs
 * TODO:XXX: Set freed memory pointers to NULL
 * TODO:XXX: Add more error handling
 * TODO: Test: Automate the test verification
 *
 * Author: Intel A80486DX2-66
 * License: Unlicense
 */

#include <errno.h>
#include <inttypes.h>
#include <math.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if _POSIX_VERSION >= 200112L
# include <fcntl.h>
# include <unistd.h>
# define IS_POSIX 1
#else
# define IS_POSIX 0
#endif

#ifdef DEBUG
# define LINE_FAIL(x) printf("failed on line %d\n", __LINE__ + x)
#else
# define LINE_FAIL(x)
#endif

#if defined(DEBUG) || defined(TEST)
# define DBG_PRINT(...) do {                                                  \
    printf(__VA_ARGS__);                                                      \
    fflush(stdout);                                                           \
} while (0)
#else
# define DBG_PRINT(...)
#endif

#define RETREAT(s) do {                                                       \
    perror(s);                                                                \
    exit(EXIT_FAILURE);                                                       \
} while (0)

typedef struct {
	bool locked;
	int ID;
	char* file_path;
#if IS_POSIX
	int
#else
	FILE*
#endif
		file;
} TempFile;

TempFile* temp_files = NULL;
size_t num_temp_files = 0;

int tf_alloc(size_t n, size_t type_size);
int tf_free(int ID);
int tf_write(int ID, size_t offset, void* src, size_t data_size);
int tf_read(int ID, size_t offset, void* dest, size_t data_size);

int tf_alloc(size_t n, size_t type_size) {
	DBG_PRINT("tf_alloc(%zu, %zu)\n", n, type_size);

	// Create an empty file
	size_t len_digit =
		num_temp_files == 0 ?
			1
		:
			(size_t) floor(log10((double) num_temp_files)) + 1,
	       file_path_len = len_digit + strlen("tf_.tmp");
	char* file_path = malloc((file_path_len + 1) * sizeof(char));
	if (file_path == NULL) {
		LINE_FAIL(-2);
		return -1;
	}
	int res = snprintf(file_path, file_path_len + 1, "tf_%" PRIuMAX ".tmp",
		(uintmax_t) num_temp_files);
	if ((size_t) res != file_path_len) {
		LINE_FAIL(-2);
		return -1;
	}

#if IS_POSIX
	int file = open(file_path, O_RDWR | O_CREAT);
	if (file == -1) {
#else
	FILE* file = fopen(file_path, "w+b");
	if (file == NULL) {
#endif
		LINE_FAIL(-2);
		return -1;
	}

	// Allocate/reallocate memory for all TempFiles
	temp_files = temp_files == NULL ?
		malloc(sizeof(TempFile))
	:
		realloc(temp_files, (num_temp_files + 1) * sizeof(TempFile));
	if (temp_files == NULL) {
		LINE_FAIL(-2);
		return -1;
	}

	// Allocate memory for this TempFile
	TempFile* temp_file = malloc(sizeof(TempFile));
	if (temp_file == NULL) {
		LINE_FAIL(-2);
		return -1;
	}

	// Assign the ID, file path, file handler
	temp_file->locked = false;
	temp_file->ID = num_temp_files;
	temp_file->file_path = strdup(file_path);
	temp_file->file = file;

	// Add the temp file to the array
	temp_files[num_temp_files++] = *temp_file;

	return temp_file->ID;
}

int tf_free(int ID) {
	DBG_PRINT("tf_free(%d)\n", ID);

	size_t index = (size_t) ID;

	if (temp_files[index].locked) {
		errno = EBUSY;
		return -1;
	}
	temp_files[index].locked = true;

#if IS_POSIX
	close
#else
	fclose
#endif
		(temp_files[index].file);

	// Delete the file
	if (remove(temp_files[index].file_path) != 0) {
		LINE_FAIL(-1);
		return -1;
	}

	free(temp_files[index].file_path);

	// Shift the remaining temp files in the array
	for (size_t i = index; i < num_temp_files - 1; i++)
		temp_files[i] = temp_files[i + 1];

	// Reallocate memory for the temp_files array
	if (--num_temp_files > 0) {
		DBG_PRINT("num_temp_files = %zu\n", num_temp_files);
		TempFile* new_temp_files_ptr = realloc(temp_files, num_temp_files *
			sizeof(TempFile));
		if (new_temp_files_ptr == NULL) {
			LINE_FAIL(-3);
			return -1;
		}
		temp_files = new_temp_files_ptr;
	}

	temp_files[index].locked = false;

	return 0;
}

int tf_write(int ID, size_t offset, void* src, size_t data_size) {
	DBG_PRINT("tf_write(%d, %zu, %p, %zu)\n", ID, offset, src, data_size);

	size_t index = (size_t) ID;

	if (temp_files[index].locked) {
		errno = EBUSY;
		return -1;
	}
	temp_files[index].locked = true;

#if IS_POSIX
	// Check file handler for -1
	int file = temp_files[index].file;
	if (file == -1)
#else
	// Check file handler for NULL
	FILE* file = temp_files[index].file;
	if (file == NULL)
#endif
		return -1;

	// Set the position
	if (
#if IS_POSIX
		lseek
#else
		fseek
#endif
			(file, offset, SEEK_SET) == -1) {
		LINE_FAIL(-1);
		return -1;
	}

	// Write the data to the file
#if IS_POSIX
	ssize_t
#else
	size_t
#endif
		bytes_written =
#if IS_POSIX
			write(file, src, data_size);
#else
			fwrite(src, 1, data_size, file);
#endif

	if (
#if IS_POSIX
		(size_t)
#endif
		bytes_written != data_size) {
		errno = EIO;
		return -1;
	}

#if IS_POSIX
	if (fsync(file) == -1) {
		LINE_FAIL(-1);
		return -1;
	}
#else
	fflush(file);
#endif

	temp_files[index].locked = false;

	return 0;
}

int tf_read(int ID, size_t offset, void* dest, size_t data_size) {
	DBG_PRINT("tf_read(%d, %zu, %p, %zu)\n", ID, offset, dest, data_size);

	size_t index = (size_t) ID;

	if (temp_files[index].locked) {
		errno = EBUSY;
		return -1;
	}
	temp_files[index].locked = true;

#if IS_POSIX
	int
#else
	FILE*
#endif
		file = temp_files[index].file;
	if (file ==
#if IS_POSIX
		-1
#else
		NULL
#endif
	   )
		return -1;

	// Read the data from the file
	void* src = malloc(data_size);
	if (src == NULL) {
#if IS_POSIX
		close
#else
		fclose
#endif
			(file);
		LINE_FAIL(-8);
		return -1;
	}

	memset(src, 0, data_size); // clear destination
	// Set the position
	if (
#if IS_POSIX
		lseek
#else
		fseek
#endif
		(file, offset, SEEK_SET) == -1) {
		LINE_FAIL(-1);
		return -1;
	}

	// read bytes
#if IS_POSIX
	ssize_t bytes_read = read(file, src, data_size);
#else
	size_t bytes_read = fread(src, 1, data_size, file);
#endif
	memcpy(dest, src, data_size);

	free(src); // Free the allocated memory

	if (
#if IS_POSIX
		(size_t)
#endif
		bytes_read != data_size) {
		errno = EIO;
		return -1;
	}

#ifdef DEBUG
	printf("Read: ID = %d, src = %p, size = %zu -> '",
		ID, dest, data_size);
	for (size_t i = 0; i < data_size; i++)
		printf("0x%02" PRIX8 "%c", *((uint8_t*)((uint8_t*)dest + i)),
			i == (data_size - 1) ? '\'' : ' ');
	printf("\n");
	fflush(stdout);
#endif

	temp_files[index].locked = false;

	return 0;
}

#ifdef TEST
int main(void) {
	DBG_PRINT("started\n");

#define ARRAY_1_LEN 4
#define ARRAY_2_LEN 16

	int ID_1 = tf_alloc(ARRAY_1_LEN, sizeof(int));
	int ID_2 = tf_alloc(ARRAY_2_LEN, sizeof(uint16_t));
	if (ID_1 == -1 || ID_2 == -1)
		RETREAT("tf_alloc");
	DBG_PRINT("allocated memory\n");

	int test_data_1[ARRAY_1_LEN] = {123, 456, 789, -123};
	DBG_PRINT("initialized array 1\n");

	uint16_t test_data_2[ARRAY_2_LEN];
	for (size_t i = 0; i < ARRAY_2_LEN; i++)
		test_data_2[i] = 1 << i;
	DBG_PRINT("initialized array 2\n");

	for (size_t i = 0; i < ARRAY_1_LEN; i++)
		if (tf_write(ID_1, i * sizeof(int), &test_data_1[i], sizeof(int)) == -1)
			RETREAT("tf_write");
	DBG_PRINT("wrote array 1\n");

	for (size_t i = 0; i < ARRAY_2_LEN; i++)
		if (tf_write(ID_2, i * sizeof(uint16_t), &test_data_2[i],
			sizeof(uint16_t)) == -1)
			RETREAT("tf_write");
	DBG_PRINT("wrote array 2\n");

	// round-trip
	test_data_1[0] = 111;
	test_data_1[1] = 222;
	test_data_1[2] = 333;
	test_data_1[3] = 444;
	DBG_PRINT("filled array 1 with garbage\n");

	for (size_t i = 0; i < 16; i++)
		test_data_2[i] ^= 1;
	DBG_PRINT("filled array 2 with garbage\n");

	for (size_t i = 0; i < ARRAY_1_LEN; i++)
		if (tf_read(ID_1, i * sizeof(int), &test_data_1[i], sizeof(int)) == -1)
			RETREAT("tf_read");
	DBG_PRINT("restored array 1\n");

	for (size_t i = 0; i < ARRAY_2_LEN; i++)
		if (tf_read(ID_2, i * sizeof(uint16_t), &test_data_2[i],
			sizeof(uint16_t)) == -1)
			RETREAT("tf_read");
	DBG_PRINT("restored array 2\n");

	DBG_PRINT("Values (1): ");
	for (size_t i = 0; i < ARRAY_1_LEN; i++)
		DBG_PRINT("%d%c", test_data_1[i], i == (ARRAY_1_LEN - 1) ? '\n' : ' ');
	DBG_PRINT("Values (2): ");
	for (size_t i = 0; i < ARRAY_2_LEN; i++)
		DBG_PRINT("%d%c", test_data_2[i], i == (ARRAY_2_LEN - 1) ? '\n' : ' ');

	tf_free(ID_1);
	tf_free(ID_2);
	DBG_PRINT("freed both files\n");

	return 0;
}
#endif