feat!: Finish copy to server implementation

src/copy.c

···
 	conecta(enchufe);
 
 	if (from_server) {
+		Command get = (Command){
+			.tag = GET,
+			.as.get.fname = atoss(source),
+		};
+		Buffer get_buf = Command_serialize(get);
+		printf("INFO: Sending GET Command to metadata server.\n");
+		zumba(enchufe, get_buf);
+		free(get_buf.buf);
+		Byte buf[BUF_LEN] = {0};
+		Buffer outside_buf = (Buffer){
+			.buf = buf,
+			.len = BUF_LEN,
+		};
+		size_t len = recibe(enchufe, outside_buf);
+		outside_buf.len = len;
+		ListDNodeInfo dinfo = ListDNodeInfo_deserialize(outside_buf);
+
+
 	} else {
 		LazyBuffer b = open(source);
 		exists(b.fptr);
···
 		size_t chunks_per_dnode = 1 + (chunk_count - 1) / dnode_count;
 
 		ListDNodeInfo dinfo = NULL;
+		size_t seq = 1;
 		for (ListDNode dptr = dnodes; dptr != NULL; dptr = dptr ->rest) {
 			DNode d = dptr->head;
 			printf("INFO: Creating socket for DNode\n");
···
 			len = recibe(d_enc, cid_buf);
 			UUID cid = UUID_deserialize(cid_buf);
 
-			while (true) {
+			for (size_t sent_chunks = 0; sent_chunks < chunks_per_dnode; sent_chunks++) {
 				b = next_chunk(b);
 				if (b.len == 0) break;
 
 				printf("INFO: Sending %zu bytes to data node.\n", b.size);
 				zumba(d_enc, (Buffer){ .buf = b.buf, .len = b.len });
-				dinfo = ListDNodeInfo_cons((DNodeInfo){
+			}
+			printf("INFO: Sequence number is: %zu\n", seq);
+			dinfo = ListDNodeInfo_cons((DNodeInfo){
+						.dnode = {
 							.address = d.address,
-							.cid = cid,
 							.port = d.port,
-						}, dinfo);
-			}
+							.nid = (UUID){0},
+						},
+						.cid = cid,
+						.seq = seq,
+					}, dinfo);
+			seq += 1;
 			printf("INFO: Disconnecting from data node.\n");
 			desenchufa(d_enc);
 		}

src/lib/block.c

···
 	Buffer fid_buf = UUID_serialize(block.fid);
 	Buffer nid_buf = UUID_serialize(block.nid);
 	Buffer cid_buf = UUID_serialize(block.cid);
+	Buffer seq_buf = size_t_serialize(block.seq);
 
-	return concat(bid_buf, concat(fid_buf, concat(nid_buf, cid_buf)));
+	return concat(bid_buf,
+		concat(fid_buf,
+		concat(nid_buf,
+		concat(cid_buf, seq_buf))));
 }
 
 Block Block_deserialize(Buffer buf) {
···
 	};
 	UUID cid = UUID_deserialize(cid_buf);
 
+	Buffer seq_buf = {
+		.len = sizeof(size_t),
+		.buf = buf.buf + sizeof(UUID) * 4,
+	};
+	size_t seq = size_t_deserialize(seq_buf);
+
 	return (Block){
 		.bid = bid,
 		.fid = fid,
 		.nid = nid,
 		.cid = cid,
+		.seq = seq,
 	};
 }
 
···
 	return ListBlock_reverse(out);
 }
 
-void insert_into_block(UUID* fid, UUID* nid, UUID* cid) {
+void insert_into_block(UUID* fid, UUID* nid, UUID* cid, size_t* seq) {
 	Block block = {
 		.bid = new_uuid(),
 		.fid = fid != NULL ? *fid : (UUID){0},
 		.nid = nid != NULL ? *nid : (UUID){0},
 		.cid = cid != NULL ? *cid : (UUID){0},
+		.seq = seq != NULL ? *seq : 0,
 	};
 
 	ListBlock blocks = Block_get_db();
-	ListBlock old_blocks = blocks;
+	
 	bool unique = true;
-	while (blocks != NULL) {
-		Block current = blocks->head;
-		blocks = blocks->rest;
-		if (UUID_eq(current.nid, block.nid) && UUID_eq(current.cid, block.cid))
+	for (ListBlock bptr = blocks; bptr != NULL; bptr = bptr->rest) {
+		Block b = bptr->head;
+		if (UUID_eq(b.nid, block.nid) && UUID_eq(b.cid, block.cid))
 			unique = false;
 	}
-	blocks = old_blocks;
 
 	if (unique) {
 		printf("LOGBLOCK: Inserted tuple: ");
···
 	ListBlock_deinit(blocks);
 }
 
-ListBlock select_from_block(UUID* bid, UUID* fid, UUID* nid, UUID* cid) {
+ListBlock select_from_block(UUID* bid, UUID* fid, UUID* nid, UUID* cid, size_t* seq) {
 	ListBlock out = NULL;
 	ListBlock blocks = Block_get_db();
 	for (ListBlock bptr = blocks; bptr != NULL; bptr = bptr->rest) {
···
 		if ((bid != NULL ? UUID_eq(*bid, b.bid) : true)
 				&& (fid != NULL ? UUID_eq(*fid, b.fid) : true)
 				&& (nid != NULL ? UUID_eq(*nid, b.nid) : true)
-				&& (cid != NULL ? UUID_eq(*cid, b.cid) : true)) {
+				&& (cid != NULL ? UUID_eq(*cid, b.cid) : true)
+				&& (seq != NULL ? *seq == b.seq : true)) {
 			out = ListBlock_cons(b, out);
 		}
 	}
···
 	print_uuid(block.nid);
 	printf(", cid: ");
 	print_uuid(block.nid);
-	printf("\n)");
+	printf(", seq: %zu\n", block.seq);
 }

src/lib/block.h

···
 	UUID fid;	///< File ID (foreign from INode) default 0
 	UUID nid;	///< Node ID (foreign from DNode) default 0
 	UUID cid;	///< Chunk ID default ""
+	size_t seq;	///< The order of this chunk
 } Block;
 
 DefList(Block)
···
 /// @param fid UUID of file's INode or NULL
 /// @param nid UUID of DNode or NULL
 /// @param cid string representing Block's chunk ID or NULL
-void insert_into_block(UUID* fid, UUID* nid, UUID* cid);
+void insert_into_block(UUID* fid, UUID* nid, UUID* cid, size_t* seq);
 
 /// SELECT from the Block table.
 ///
···
 /// @param nid the Block's DNode's UUID or NULL
 /// @param cid the Block's chunk ID or NULL
 /// @return a ListBlock of the possible matches
-ListBlock select_from_block(UUID* bid, UUID* fid, UUID* nid, UUID* cid);
+ListBlock select_from_block(UUID* bid, UUID* fid, UUID* nid, UUID* cid, size_t* seq);
 
 /// Get the Block table from the database.
 ///

src/lib/dnode.c

···
 ImplList(DNodeInfo)
 
 Buffer DNodeInfo_serialize(DNodeInfo dinfo) {
-	return concat(IPv4_serialize(dinfo.address), concat(UUID_serialize(dinfo.cid), Port_serialize(dinfo.port)));
+	return concat(DNode_serialize(dinfo.dnode), concat(UUID_serialize(dinfo.cid), size_t_serialize(dinfo.seq)));
 }
 
 DNodeInfo DNodeInfo_deserialize(Buffer buf) {
-	IPv4 address = IPv4_deserialize((Buffer){ .buf = buf.buf, .len = sizeof(IPv4) });
-	UUID cid = UUID_deserialize((Buffer){ .buf = buf.buf + sizeof(IPv4), .len = sizeof(UUID) });
-	Port port = Port_deserialize((Buffer){ .buf = buf.buf + sizeof(IPv4) + sizeof(UUID), .len = sizeof(Port)});
+	DNode dnode = DNode_deserialize((Buffer){ .buf = buf.buf, .len = sizeof(UUID) + sizeof(IPv4) + sizeof(Port) });
+	UUID cid = UUID_deserialize((Buffer){ .buf = buf.buf + sizeof(UUID) + sizeof(IPv4) + sizeof(Port), .len = sizeof(UUID) });
+	size_t seq = size_t_deserialize((Buffer){ .buf = buf.buf + sizeof(UUID) + sizeof(IPv4) + sizeof(Port) + sizeof(UUID), .len = sizeof(size_t)});
 
 	return (DNodeInfo){
-		.address = address,
+		.dnode = dnode,
 		.cid = cid,
-		.port = port
+		.seq = seq,
 	};
 }
 
···
 
 ListDNodeInfo ListDNodeInfo_deserialize(Buffer buf) {
 	ListDNodeInfo out = NULL;
-	for (size_t len = 0; len < buf.len; len += sizeof(IPv4) + sizeof(UUID) + sizeof(Port)) {
+	for (size_t len = 0; len < buf.len; len += sizeof(UUID) + sizeof(IPv4) + sizeof(Port) + sizeof(UUID) + sizeof(size_t)) {
 		out = ListDNodeInfo_cons(DNodeInfo_deserialize((Buffer){
 				.len = 0, // INFO: this does not have to be set.
 				.buf = buf.buf + len,

src/lib/dnode.h

···
 	Port port;		///< Port of where the connection came from
 } DNode;
 
-DefList(DNode)
 
+/// This carries all the necessary information that a chunk should have.
 typedef struct {
-	IPv4 address;
-	Port port;
-	UUID cid;
+	DNode dnode;	///< the DNode of the chunk
+	UUID cid;		///< The UUID of the chunk
+	size_t seq;		///< The place in the sequence of chunks where this chunk should be
 } DNodeInfo;
 
+DefList(DNodeInfo)
+
+DefList(DNode)
+
 Buffer DNodeInfo_serialize(DNodeInfo dinfo);
 
 DNodeInfo DNodeInfo_deserialize(Buffer buf);
 
-DefList(DNodeInfo)
-
 Buffer ListDNodeInfo_serialize(ListDNodeInfo list);
 
 ListDNodeInfo ListDNodeInfo_deserialize(Buffer buf);
-
 
 /// Serialize a DNode into a Buffer.
 /// Caller must free memory in Buffer.buf.

src/lib/enchufe.c

···
 			return concat(Tag_serialize(command.tag), concat(size_t_serialize(command.as.put.fsize), SafeStr_serialize(command.as.put.fname)));
 		case WRITE:
 			return concat(Tag_serialize(command.tag), size_t_serialize(command.as.write.nbytes));
+		case READ:
+			return concat(Tag_serialize(command.tag), UUID_serialize(command.as.read.cid));
 		default:
 			fprintf(stderr, "ERROR: Tried to serialize a command in a wrong way.\n");
 			exit(1);
···
 					.fname = SafeStr_deserialize((Buffer){ .buf = buf.buf + sizeof(enum Tag) + sizeof(size_t), .len = 0 }),
 				}
 			};
-		case WRITE: {
+		case WRITE:
 			return (Command){
 				.tag = tag,
 				.as.write.nbytes = size_t_deserialize((Buffer){ .buf = buf.buf + sizeof(enum Tag), .len = sizeof(size_t)}),
 			};
-		} break; 
+		case READ: {
+			// INFO: This is necessary to avoid the padding that the C compiler
+			// introduces. This padding shows up in sizeof() but not in the
+			// Buffer itself.
+			Buffer tmp = UUID_serialize((UUID){0});
+			free(tmp.buf);
+			return (Command){
+				.tag = tag,
+				.as.read.cid = UUID_deserialize((Buffer){ .buf = buf.buf + sizeof(enum Tag), .len = tmp.len }),
+			};
+		} break;
 		default:
 			fprintf(stderr, "ERROR: Tried to serialize a command in a wrong way.\n");
 			exit(1);

src/lib/enchufe.h

···
 #include <string.h>
 #include <sys/socket.h>
 #include "lib.h"
+#include "uuid.h"
 
 /* ----- Types ----- */
 
···
 		GET,
 		PUT,
 		WRITE,
+		READ,
 	} tag ;
 	union {
 		struct {
···
 		struct {
 			size_t nbytes;
 		} write;
+		struct {
+			UUID cid;
+		} read;
 	} as ;
 } Command;
 

src/meta-data.c

···
 	ListINode_deinit(inodes);
 	free((void*)cmd.as.put.fname.str);
 
-	printf("INFO: Waiting for copy client to respond with data node UUID's.\n");
 
 	Byte buf[BUF_LEN] = {0};
 	Buffer outside_buf = { .buf = buf, .len = BUF_LEN };
+	printf("INFO: Waiting for copy client to respond with data node UUID's.\n");
 	size_t len = recibe(cliente, outside_buf);
 	outside_buf.len = len;
 	ListDNodeInfo dinfo = ListDNodeInfo_deserialize(outside_buf);
 	exists(dinfo);
 	for (ListDNodeInfo lptr = dinfo; lptr != NULL; lptr = lptr->rest) {
 		DNodeInfo d = lptr->head;
-		ListDNode dptr = select_from_dnode(NULL, &d.address, &d.port);
+		ListDNode dptr = select_from_dnode(NULL, &d.dnode.address, &d.dnode.port);
 		exists(dptr);
 		UUID nid = dptr->head.nid;
-		insert_into_block(&fid, &nid, &d.cid);
+		insert_into_block(&fid, &nid, &d.cid, &d.seq);
 	}
 }
 

src/testdb.c

···
 			DNode* dnode = check_node(p.address, p.port);
 			if (dnode != NULL) {
 				// insert into block (nid, fid, cid) values (nid, fid, chunkid)
-				insert_into_block(&fid, &dnode->nid, &p.chunkid);
+				insert_into_block(&fid, &dnode->nid, &p.chunkid, NULL);
 				free(dnode);
 				return add_block_to_inode(fname, params->rest);
 			} else {
···
 
 	ListBlockLocation out = NULL;
 	if (inode != NULL) {
-		ListBlock block_matches = select_from_block(NULL, &inode->fid, NULL, NULL);
+		ListBlock block_matches = select_from_block(NULL, &inode->fid, NULL, NULL, NULL);
 
 		assert(block_matches != NULL);
 		for (ListBlock bptr = block_matches; bptr != NULL; bptr = bptr->rest) {