docs: Add documentation.

src/cluster.c

···
 	
 
 int consume(void*args) {
-
+	// Turns the strange looking thing thrd_current() into a smaller number.
 	size_t tid = ((thrd_current() & 0xFFFF) >> 12) % 12;
 
 	log(INFO, "Consumer %zu started.\n", tid);
···
 	size_t total_time = 0;
 	Proc proc = {0};
 	while (true) {
-
+		// Enter crit region
 		mtx_lock(&pq_mtx); // down
 		if (pq_empty(pq)) {
 			mtx_unlock(&pq_mtx); // up
···
 			pq_delete(&pq);
 			mtx_unlock(&pq_mtx); // up
 		}
+		// Left crit region
 
+		// Let the client know what just happened.
 		log(INFO, "Consumer %zu:\n\tProcessing: %s for %d seconds.\n", tid, (const char*)proc.program.buf, proc.time);
 		zumba(cliente, proc.program);
 
+		// Perform work.
 		sleep(proc.time);
 		total_time += proc.time;
+		// Free the buffer.
 		free(proc.program.buf);
 	}
 
+	// Report back to the user.
 	log(INFO, "Consumer %zu consumed %zu seconds of CPU time.\n", tid, total_time);
 
 	return thrd_success;
···
 	};
 
 	while (true) {
+		// Get the message.
 		size_t msg_len = recibe(cliente, out_buf);
 
+		// The client closed the connection.
 		if (msg_len == 0) break;
 
+		// Deserialize the message
 		Procs procs = deserialize(out_buf, msg_len);
 		for (size_t i = 0; i < procs.len; ++i) {
 			Proc proc = procs.procs[i];
+
+			// Put the proc in the queue (Enter crit region)
 			mtx_lock(&pq_mtx); // down
 			pq_insert(&pq, proc);
 			mtx_unlock(&pq_mtx); // up
+			// Leave crit region
 		}
 
 		memset(out_buf.buf, 0, out_buf.len);
 	}
+	// Let the rest of the threads know that the client is closed.
 	client_closed = true;
 
 
···
 int main(int argc, const char** argv) {
 	assert(argc == 3 && "You must provide three arguments.");
 
+	// Get a new enchufe.
 	IPv4 ip = parse_address(argv[1]);
 	Port port = (Port)atoi(argv[2]);
 	Enchufe enchufe = enchufa(ip, port);
 	amarra(enchufe);
 
+	// Listen to incoming clients.
 	escucha(enchufe, 1);
 	log(INFO, "Listening to: %d.%d.%d.%d on port: %d\n", ip.bytes[0], ip.bytes[1], ip.bytes[2], ip.bytes[3], port);
 
+	// Accept connection from client.
 	Enchufe cliente = acepta(enchufe);
 	log(INFO, "Accepted a connection.\n");
 
+	// Initialize data for program.
 	mtx_init(&pq_mtx, mtx_plain);
 	mtx_init(&so_mtx, mtx_plain);
 	pq = pq_init();
 
+	// Start producer.
 	thrd_t producer = {0};
 	thrd_create(&producer, produce, (void*)&cliente);
 
 	log(INFO, "Producer started.\n");
 
+	// Start consumers.
 	thrd_t consumers[THREAD_COUNT] = {0};
 	for (size_t i = 0; i < THREAD_COUNT; ++i) {
 		thrd_create(&consumers[i], consume, (void*)&cliente);
 	}
 	log(INFO, "Consumers started.\n");
 	
+	// Join the producer.
 	thrd_join(producer, NULL);
+
+	// Join the consumers.
 	for (size_t i = 0; i < THREAD_COUNT; ++i) {
 		thrd_join(consumers[i], NULL);
 	}
 
 	log(INFO, "Done.\n");
 
+	// Deinitialize all the program's data.
 	pq_deinit(&pq);
 	mtx_destroy(&pq_mtx);
 	mtx_destroy(&so_mtx);

src/lib/enchufe.c

···
 #include <netinet/in.h> // sockaddr_in
 #include <arpa/inet.h> // inet_pton
 
+// Esta funcion llama a tres otras funciones inline.
 Enchufe enchufa(IPv4 ip, Port port) {
 	return aplasta(nuevo(), receptaculo(ip, port));
 }
 
+// Wrapper para connect.
 void conecta(Enchufe enchufe) {
 	try (connect(enchufe.fd, (const struct sockaddr*)&enchufe.addr, enchufe.addrlen));
 }
 
+// Wrapper para bind.
 void amarra(Enchufe enchufe) {
 	try (bind(enchufe.fd, (struct sockaddr*)&enchufe.addr, enchufe.addrlen));
 }
 
+// Wrapper para liste.
 void escucha(Enchufe enchufe, size_t len) {
 	listen(enchufe.fd, (int)len);
 }
 
+// Wrapper para acepta.
 Enchufe acepta(Enchufe enchufe) {
 	FD fd = accept(enchufe.fd, (struct sockaddr*)&enchufe.addr, &enchufe.addrlen);
 	try (fd);
···
 	};
 }
 
+// Wrapper para zumba.
 void zumba(Enchufe enchufe, Buffer buf) {
 	try (write(enchufe.fd, buf.buf, buf.len));
 }
 
+// Wrapper para recibe.
 size_t recibe(Enchufe enchufe, Buffer buf) {
 	int64_t bytes_read = read(enchufe.fd, buf.buf, buf.len);
 	try (bytes_read);
 	return (size_t)bytes_read;
 }
 
+// Wrapper para close.
 void desenchufa(Enchufe enchufe) {
 	close(enchufe.fd);
 }
 
+// Esta funcion convierte un string a un buffer.
 Buffer atob(const char* str) {
 	return (Buffer){
 		.buf = (Byte*)str,

src/lib/enchufe.h

···
 #include <string.h>
 #include <sys/socket.h>
 
+// Macro para probar si un numero es negativo. En general, esta libreria
+// prefiere crashear el programa que dejar que el usuario arregle un error.
 #define try(a) do { \
 		if ((a) < 0) { \
 			fprintf(stderr, "[ERROR]: %s:%d %s\n", __FILE__, __LINE__, strerror(errno)); \
···
 typedef uint16_t Port;
 typedef uint8_t Byte;
 
+// Buffer de bytes, lo puedes usar para lo que sea.
 typedef struct {
 	size_t len;
 	Byte* buf;
 } Buffer;
 
+// Convierte un string de C a un buffer de bytes.
 Buffer atob(const char* str);
 
+
+// Tipo para un IPv4. Ademas te ayuda convertir entre little endian y big
+// endian. La data de bytes aparece como bytes[3]bytes[2]bytes[1]bytes[0] en
+// memoria.
 typedef union {
 	Byte bytes[4];
 	uint32_t ip;
 } IPv4;
 
+// Enchufe.
 typedef struct {
 	FD fd;
 	struct sockaddr_in addr;
 	socklen_t addrlen;
 } Enchufe;
 
+// Receptaculo.
 typedef struct {
 	struct sockaddr_in addr;
 	socklen_t addrlen;
 } Receptaculo;
 
+// Crea un file descriptor nuevo para un enchufe.
 inline FD nuevo() {
 	FD fd = socket(PF_INET, SOCK_STREAM, 0);
 	try (fd);
 	return fd;
 }
 
+// Crea un receptaculo.
 inline Receptaculo receptaculo(IPv4 ip, Port port) {
 	struct sockaddr_in name = {
 		.sin_family = AF_INET,
···
 	};
 }
 
+// Coge un file descriptor y un receptaculo y los junta. En otras palabras, los
+// aplasta. Un enchufe es basicamente, un file descriptor con un IP.
 inline Enchufe aplasta(FD fd, Receptaculo rec) {
 	return (Enchufe){
 		.fd = fd,
···
 	};
 }
 
+// Esta funcion te crea un enchufe.
 Enchufe enchufa(IPv4 ip, Port port);
+
+// Esta funcion crea la conexion desde tu computadora hasta donde sea que este
+// el enchufe.
 void conecta(Enchufe enchufe);
+
+// Esta funcion amarra la direccion de IP que se le dio al enchufe, al file
+// descriptor. Hay casos donde no vas a querer que esten amarrados, como cuando
+// no te importa la direccion que tendra un cliente conectandose a un servidor,
+// por eso el default es que la funcion enchufa(ip, port) no amarre el file
+// descriptor al puerto.
 void amarra(Enchufe enchufe);
+
+// Le deja saber al enchufe cuantas conexiones se pueden hacer. El default es
+// que no se puedan hacer conexiones. Asi que si estas codificando un servidor,
+// tienes que llamar esta funcion.
 void escucha(Enchufe enchufe, size_t len);
+
+// Esta funcion bloquea el thread hasta que un cliente se conecte. Devuelve el
+// enchufe del cliente para poder comunicarse con el cliente. Tienes que
+// desenchufarlo cuando termines la direccion.
 Enchufe acepta(Enchufe enchufe);
+
+// Envia un buffer de bytes a un cliente.
 void zumba(Enchufe enchufe, Buffer in_buf);
+
+// Recibe un buffer de bytes de un cliente. Devuelve la cantidad de bytes que se
+// leyeron. Si devuelve 0, entonces el cliente cerro la conexion.
 size_t recibe(Enchufe enchufe, Buffer out_buf);
+
+// Esta funcion se encarga de liberar los recursos que ocupan los echufes.
 void desenchufa(Enchufe enchufe);
 
 #endif // ENCHUFE_H_ header

src/lib/lib.c

···
 	if (str.len != calculated_len) {
 		log(ERROR, "%s:%d String's length (%zu) is not equal to given length (%zu).", __FILE__, __LINE__, calculated_len, str.len);
 
-		printf("\n");
+		printf("\nBuffer contains: ");
 		for (size_t i = 0; i < max_len; ++i) printf("[%d] ", str.buf[i]);
 		printf("\n");
 
···
 	if (str.len > max_len) {
 		log(ERROR, "%s:%d String's length (%zu) is larger than the buffer that contains it (%zu).\n", str.len, calculated_len);
 
-		printf("\n");
+		printf("\nBuffer contains: ");
 		for (size_t i = 0; i < max_len; ++i) printf("[%d] ", str.buf[i]);
 		printf("\n");
 
···
 	return str;
 }
 
-// Convertr the buffer received from a socket into an array of processes. The
+// Converts the buffer received from a socket into an array of processes. The
 // user must free this memory.
 Procs deserialize(Buffer out_buf, size_t msg_len) {
 	Procs procs = {
···
 	};
 	exists(procs.procs);
 
+	// This loop will continue until all Proc's have been deserialized.
 	size_t buf_idx = 0;
 	for (size_t j = 0; buf_idx < msg_len; ++j) {
 		// Reallocate new Proc if more than one proc was received.
···
 		size_t len = *(size_t*)(curr + sizeof(Time));
 		Byte* str_buf = curr + sizeof(Time) + sizeof(size_t);
 
+		// Validate the string in the buffer.
 		Buffer program = validate_str((Buffer){.len = len, .buf = str_buf}, msg_len - buf_idx);
 
+		// Insert everything into the proc list.
 		procs.procs[j] = (Proc){
 			.time = time,
 			.program = bufcpy(program),
···
 	return procs;
 }
 
+// This function turns a proc into a buffer. In order to do that, this function
+// reinterprets everything on the proc as a sequence of bytes.
 Buffer serialize(Proc proc) {
+	// First, determine how long the buffer has to be.
 	size_t len = sizeof(Time) + sizeof(size_t) + proc.program.len + 1;
+
+	// Allocate the bytes in the buffer.
 	Buffer buf = {
 		.len = len,
 		.buf = (Byte*)calloc(len, sizeof(Byte)),
 	};
 	exists(buf.buf);
 
+	// Copy everything in the buffer.
 	memcpy((void*)buf.buf, (void*)&proc.time, sizeof(Time));
 	memcpy((void*)(buf.buf + sizeof(Time)), (void*)&proc.program.len, sizeof(size_t));
 	memcpy((void*)(buf.buf + sizeof(Time) + sizeof(size_t)), (void*)proc.program.buf, proc.program.len);
 	return buf;
 }
 
+// This function takes a string representing an IPv4 address and converts it
+// into an IPv4 type.
 IPv4 parse_address(const char* str) {
-	size_t len = strlen(str);
-
-	assert(len <= 15 && "What you have entered cannot possibly be an IP address.");
+	size_t len = safe_strlen(str, 15);
 
 	IPv4 ip = {0};
 	size_t curr_byte = 0;
···
 	return ip;
 }
 
+// uses memchr to calculate strlen.
 size_t safe_strlen(const char* str, size_t max_len) {
 	return (size_t)memchr(str, '\0', max_len) - (size_t)str;
 }

src/lib/lib.h

···
 #include "enchufe.h"
 #include <assert.h>
 
+// Macro para detectar si un pointer es NULL. Usa esta funcion si prefieres
+// crashear el programa cuando encuetras un puntero NULL.
 #define exists(a) do { \
 		if ((a) == NULL) { \
 			fprintf(stderr, "[ERROR]: %s:%d Null pointer encountered, %s\n", __FILE__, __LINE__, strerror(errno)); \
···
 		} \
 	} while(0)
 
+// Esto es necesario por si prefieres que Proc aguante una unidad de tiempo
+// distinta.
 typedef Byte Time;
 
+// Esto sera lo que se envia y recibe por el socket.
 typedef struct {
 	Time time;
 	Buffer program;
 } Proc;
 
+// Esto es para crear una lista dinamica de Procs.
 typedef struct {
 	Proc* procs;
 	size_t len;
 } Procs;
 
-typedef Buffer SafeStr;
+// Esta funcion convierte un buffer en una lista de Proc's.
+Procs deserialize(Buffer out_buf, size_t msg_len);
 
-Procs deserialize(Buffer out_buf, size_t msg_len);
+// Esta funcion convierte un Proc en un buffer.
 Buffer  serialize(Proc);
+
+// Esta funcion convierte un string que representa un IPv4 en un IPv4.
 IPv4 parse_address(const char* str);
+
+// Esta funcion verifica que el string enviado por el socket sea valido.
 Buffer validate_str(Buffer str, size_t max_len);
+
+// Esta funcion crea una copia de un buffer en memoria y lo devuelve.
 Buffer bufcpy(Buffer in);
+
+// Esta funcion es mejor que strlen.
 size_t safe_strlen(const char* str, size_t max_len);
 
 #endif // LIB_H_

src/lib/log.c

···
 #include <stdarg.h>
 #include "log.h"
 
+// LOGGGG
 void log(LogLevel level, const char* format, ...) {
 	FILE* out = stdout;
 

src/lib/log.h

···
 #ifndef LOG_H_
 #define LOG_H_
 
+// ¿Cuál log prefieres hacer?
 typedef enum {
 	INFO,
 	WARN,
 	ERROR,
 } LogLevel;
 
-void log(LogLevel level, const char* format, ...);
+// logggg
+void log(LogLevel level, const char* format, ...);;;;
 
 #endif // LOG_H_ header

src/lib/pq.c

···
 #include "pq.h"
 #include "log.h"
 
-#include <string.h>
+// Just sets the head to NULL.
 PQ pq_init() {
 	return (PQ){.head = NULL};
 }
 
+// Goes node by node freeing all the memory.
 void pq_deinit(PQ* pq) {
 	exists(pq);
 	struct Node* curr = pq->head;
···
 	}
 }
 
+
+// I spent way too long trying to implement this in C. . . So I tried it in
+// Haskell. The Haskell implementation looks like this:
+// 	insert :: a -> [a] -> [a]
+// 	insert p [] = [p]
+// 	insert p (x:xs) = if x > p then p:x:xs else x:insert p xs
+// The C implementation looks like this:
 Node* n_insert(Proc proc, Node* node) {
 	if (node == NULL) {
 		Node* n = malloc(sizeof(Node));
···
 	}
 }
 
+// This function just calls n_insert.
 void pq_insert(PQ* pq, Proc proc) {
 	exists(pq);
 
 	pq->head = n_insert(proc, pq->head);
 }
 
+// Free node and buffer.
 void pq_delete(PQ* pq) {
 	exists(pq);
 	if (pq->head != NULL) {
···
 	}
 }
 
+// This function creates a copy of the Proc.
 Proc pq_access(PQ pq) {
 	exists(pq.head);
 	Proc proc = pq.head->proc;
···
 	};
 }
 
+// This function.
 void pq_print(PQ pq) {
 	struct Node* curr = pq.head;
 	printf("\n");
···
 	printf("\n");
 }
 
+// When the head is NULL the list is empty.
 bool pq_empty(PQ pq) {
 	return pq.head == NULL;
 }

src/lib/pq.h

···
 #include "lib.h"
 #include <stdbool.h>
 
+// Nodo que aguanta cada proceso.
 struct Node {
 	Proc proc;
 	struct Node* next;
 };
+// Para crear un struct recursivo no se puede hacer un typedef. Aqui esta el
+// typedef.
 typedef struct Node Node;
 
+// Funcion helper para insertar un proceso en la lista y respetar el orden de
+// tiempo de procesos.
 Node* n_insert(Proc proc, Node* node);
 
+// La estructura para priority queue.
 typedef struct {
 	Node* head;
 } PQ;
 
+// Inicializar el prio queue.
 PQ pq_init();
+
+// La funcion para borrar el prio queue.
 void pq_deinit(PQ* pq);
+
+// La funcion para insertar en el prio queue.
 void pq_insert(PQ* pq, Proc proc);
+
+// la funcion para borrar el primer elemento del prio queue.
 void pq_delete(PQ* pq);
+
+// La funcion para accesar el tope del prio queue.
 Proc pq_access(PQ pq);
+
+// La funcion para imprimir el prio queue.
 void pq_print(PQ pq);
+
+// La funcion para verificar si el prio queue esta vacio.
 bool pq_empty(PQ pq);
 
 #endif // PQ_H_