fix: Fix important bugs highlighted by compiler warnings.

src/createdb.c

···
 bool touch(const char* fname) {
 	FILE* f = fopen(fname, "w");
 	if (f == NULL) {
-		fclose(f);
 		return false;
 	}
 	fclose(f);

src/lib/block.c

···
 #include "block.h"
 #include <stdbool.h>
-ImplList(Block);
+ImplList(Block)
 
 Buffer Block_serialize(Block block) {
 	Buffer bid_buf = UUID_serialize(block.bid);

src/lib/block.h

···
 	Str cid;
 } Block;
 
-DefList(Block);
+DefList(Block)
 
 Buffer Block_serialize(Block block);
 

src/lib/dnode.c

···
 #include "dnode.h"
-ImplList(DNode);
+ImplList(DNode)
 
 Buffer DNode_serialize(DNode dnode) {
 	Buffer uuid_buf = UUID_serialize(dnode.nid);
···
 			.buf = buf.buf + len,
 		};
 		current = DNode_deserialize(tmp);
+		exists(current.address);
 		out = ListDNode_cons(current, out);
 	}
 	return ListDNode_reverse(out);

src/lib/dnode.h

···
 	Port port;
 } DNode;
 
-DefList(DNode);
+DefList(DNode)
 
 Buffer DNode_serialize(DNode dnode);
 

src/lib/inode.c

···
 #include "inode.h"
 #include "list.h"
 
-ImplList(INode);
+ImplList(INode)
 
 Buffer ListINode_serialize(ListINode list) {
 	if (list != NULL) return concat(INode_serialize(list->head), ListINode_serialize(list->rest));

src/lib/inode.h

···
 	size_t size;
 } INode;
 
-DefList(INode);
+DefList(INode)
 
 Buffer INode_serialize(INode in);
 

src/lib/lib.c

···
 Buffer Buffer_read(FILE* f) {
 	exists(f);
 	fseek(f, 0, SEEK_END);
-	size_t len = ftell(f);
+	size_t len = (size_t)ftell(f);
 	fseek(f, 0, SEEK_SET);
 	Buffer buf = {
 		.buf = calloc(len, sizeof(Byte)),
···
 	return buf;
 }
 
-void* copy(void* src, size_t nbytes) {
+Byte* copy(Byte* src, size_t nbytes) {
 	exists(src);
-	void* out = calloc(nbytes, sizeof(void));
+	Byte* out = (Byte*)malloc(nbytes * sizeof(Byte));
 	exists(out);
 	memcpy(out, src, nbytes);
 	return out;

src/lib/lib.h

···
 } SafeStr;
 
 
-void* copy(void* src, size_t nbytes);
+Byte* copy(Byte* src, size_t nbytes);
 
 // Buffer de bytes, lo puedes usar para lo que sea.
 typedef struct {

src/lib/list_str.c

···
 #include "list_str.h"
 #include "list.h"
-ImplList(Str);
+ImplList(Str)
 
 ListStr split(Str str, char sep) {
 	ListStr out = NULL;
 	char current[BUF_LEN] = {0};
+	size_t cap = strlen(str);
 	size_t len = 0;
-	for (size_t i = 0; i < strlen(str); ++i) {
+	for (size_t i = 0; i < cap; ++i) {
 		if (str[i] == sep) {
-			out = ListStr_cons(copy(current, len), out);
+			char* buf = calloc(len + 1, sizeof(char));
+			memcpy(buf, current, len);
+			out = ListStr_cons(buf, out);
 			memset(current, 0, len);
 			len = 0;
 		} else {
+			if (len + 1 >= BUF_LEN) {
+				fprintf(stderr, "ERROR: string too long: %s\n", str);
+				exit(1);
+			}
 			current[len++] = str[i];
 		}
 	}
-	out = ListStr_cons(copy(current, len), out);
+	char* buf = calloc(len + 1, sizeof(char));
+	memcpy(buf, current, len);
+	out = ListStr_cons(buf,  out);
 
 	return ListStr_reverse(out);
 }

src/lib/list_str.h

···
 #include "list.h"
 #define BUF_LEN 0x100
 
-DefList(Str);
+DefList(Str)
 
 ListStr split(Str str, char sep);
 

src/lib/uuid.c

···
 #include "uuid.h"
 #include <stdbool.h>
 
-ImplList(HexByte);
+ImplList(HexByte)
 
 bool UUID_eq(UUID l, UUID r) {
 	return l.id1 == r.id1
···
 
 uint64_t from_hex(Str str, size_t len) {
 	uint64_t acc = 0;
-	for (unsigned int i = 0; i < len; ++i) {
+	for (size_t i = 0; i < len; ++i) {
 		char c = str[i];
 		if ((c <= '9' && c >= '0')) {
-			acc = acc * 16 + (c - '0');
+			acc = acc * 16 + (uint64_t)(c - '0');
 		} else if ((c <= 'F' && c >= 'A')) {
-			acc = acc * 16 + (c - 'A') + 10;
+			acc = acc * 16 + (uint64_t)(c - 'A') + 10;
 		} else if ((c <= 'f' && c >= 'a')) {
-			acc = acc * 16 + (c - 'a') + 10;
+			acc = acc * 16 + (uint64_t)(c - 'a') + 10;
 		} else {
 			fprintf(stderr, "ERROR: incorrect hex conversion: %s\n", str);
 			exit(1);
···
 		fprintf(stderr, "ERROR: sizes are: id1 = %zu, id2 = %zu, id3 = %zu, id4 = %zu, id5 = %zu.\n", strlen(id1), strlen(id2), strlen(id3), strlen(id4), strlen(id5));
 		exit(1);
 	}
-	uint32_t id1i = from_hex(id1, strlen(id1));
-	uint16_t id2i = from_hex(id2, strlen(id2));
-	uint16_t id3i = from_hex(id3, strlen(id3));
-	uint16_t id4i = from_hex(id4, strlen(id4));
+	uint32_t id1i = (uint32_t)from_hex(id1, strlen(id1));
+	uint16_t id2i = (uint16_t)from_hex(id2, strlen(id2));
+	uint16_t id3i = (uint16_t)from_hex(id3, strlen(id3));
+	uint16_t id4i = (uint16_t)from_hex(id4, strlen(id4));
 	uint64_t id5i = from_hex(id5, strlen(id5));
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
 	return (UUID) {
 		.id1 = id1i,
 		.id2 = id2i,
···
 		.id4 = id4i,
 		.id5 = id5i,
 	};
+#pragma GCC diagnostic pop
 }
 
 HexByte to_hex1(unsigned char c) {

src/lib/uuid.h

···
 	char r;
 } HexByte;
 
-DefList(HexByte);
+DefList(HexByte)
 
 Buffer UUID_serialize(UUID in);
 

src/testdb.c

···
 	Port port;
 	Str chunkid;
 } BlockAssoc;
-DefList(BlockAssoc);
-ImplList(BlockAssoc);
+DefList(BlockAssoc)
+ImplList(BlockAssoc)
 bool add_block_to_inode(Str fname, ListBlockAssoc params) {
 	if (params != NULL) {
 		BlockAssoc p = params->head;
···
 	Port port;
 	Block block;
 } BlockLocation;
-DefList(BlockLocation);
-ImplList(BlockLocation);
+DefList(BlockLocation)
+ImplList(BlockLocation)
 
 typedef struct {
 	size_t fsize;