tcp tidyups, crash fixes on ethernet stack init

Author: braindigitalis

include/tcp.h

@@ -99,6 +99,18 @@ typedef struct tcp_ordered_list_t {
 	struct tcp_ordered_list_t* next;
 } tcp_ordered_list_t;
 
+typedef struct tcp_conn_t tcp_conn_t;
+
+typedef struct pending_node {
+	tcp_conn_t *conn;
+	struct pending_node *next;
+} pending_node_t;
+
+typedef struct {
+	pending_node_t *head;
+	pending_node_t *tail;
+} queue_t;
+
 typedef struct tcp_conn_t
 {
 	tcp_state_t state;
@@ -141,6 +153,10 @@ typedef struct tcp_conn_t
 	uint32_t msl_time;	// Maximum socket lifetime timeout or 0
 
 	tcp_ordered_list_t* segment_list;
+
+	int backlog;
+
+	queue_t* pending;
 } tcp_conn_t;
 
 /**
@@ -166,6 +182,8 @@ typedef enum tcp_error_code_t {
 	TCP_ERROR_INVALID_SOCKET = -9,
 	TCP_ERROR_CONNECTION_FAILED = -10,
 	TCP_LAST_ERROR = -11,
+	TCP_ERROR_NOT_LISTENING = -12,
+	TCP_ERROR_WOULD_BLOCK = -13,
 } tcp_error_code_t;
 
 /**
@@ -246,4 +264,110 @@ const char* socket_error(int error_code);
 /**
  * @brief Idle loop ran from timer ISR
  */
-void tcp_idle();
+void tcp_idle();
+
+/**
+ * @brief Allocate a new empty queue
+ *
+ * @return queue_t* newly allocated queue, or NULL on failure
+ */
+queue_t* queue_new(void);
+
+/**
+ * @brief Push a tcp_conn_t into the queue
+ *
+ * @param q queue
+ * @param conn TCP connection to enqueue
+ */
+void queue_push(queue_t *q, tcp_conn_t *conn);
+
+/**
+ * @brief Pop the oldest tcp_conn_t from the queue
+ *
+ * @param q queue
+ * @return tcp_conn_t* dequeued connection, or NULL if empty
+ */
+tcp_conn_t* queue_pop(queue_t *q);
+
+/**
+ * @brief Return true if queue is empty
+ *
+ * @param q queue
+ * @return true if empty, false otherwise
+ */
+bool queue_empty(queue_t *q);
+
+/**
+ * @brief Free all nodes in the queue and the queue itself
+ *
+ * @param q queue
+ */
+void queue_free(queue_t *q);
+
+/**
+ * @brief Allocate a new file descriptor for a TCP connection.
+ * @note O(n) time
+ *
+ * @param conn Pointer to the TCP connection.
+ * @return File descriptor number on success, or -1 on failure.
+ */
+int tcp_allocate_fd(tcp_conn_t* conn);
+
+/**
+ * @brief Free a previously allocated TCP file descriptor.
+ * @note O(1) time
+ *
+ * @param x File descriptor number to free.
+ */
+void tcp_free_fd(int x);
+
+/**
+ * @brief Find a TCP connection by its file descriptor.
+ * @note O(1) time
+ *
+ * @param x File descriptor number.
+ * @return Pointer to the TCP connection if found, or NULL if not found.
+ */
+tcp_conn_t* tcp_find_by_fd(int x);
+
+/**
+ * @brief Dump debug info for a TCP segment
+ *
+ * @param encap_packet encapsulating IP packet
+ * @param segment TCP segment
+ * @param options TCP options
+ * @param len TCP length
+ * @param our_checksum calculated checksum
+ */
+void tcp_dump_segment(bool in, tcp_conn_t* conn, const ip_packet_t* encap_packet, const tcp_segment_t* segment, const tcp_options_t* options, size_t len, uint16_t our_checksum);
+
+/**
+ * @brief Create a listening TCP socket.
+ *
+ * Binds a TCP connection control block (TCB) to the given local address
+ * and port, and transitions it into the LISTEN state. A pending connection
+ * queue is created to hold half‑open connections until they are accepted.
+ *
+ * @param addr    Local IPv4 address to bind to (network byte order).
+ * @param port    Local TCP port to listen on (host byte order).
+ * @param backlog Maximum number of pending connections that may be queued.
+ *
+ * @return File descriptor for the listening socket on success, or a
+ *         negative TCP_ERROR code on failure.
+ */
+int tcp_listen(uint32_t addr, uint16_t port, int backlog);
+
+/**
+ * @brief Accept an incoming connection on a listening socket.
+ *
+ * Removes one pending connection from the listening socket’s queue and
+ * allocates a new file descriptor for it. The connection will be in the
+ * ESTABLISHED state upon return.
+ *
+ * @param socket File descriptor of a socket previously placed in the
+ *               LISTEN state using tcp_listen().
+ *
+ * @return File descriptor for the accepted connection on success, or a
+ *         negative TCP_ERROR code on failure.
+ */
+int tcp_accept(int socket);

src/ethernet.c

@@ -54,6 +54,7 @@ bool ethernet_register_iee802_number(uint16_t protocol_number, ethernet_protocol
 		if (!protocol_handlers) {
 			return false;
 		}
+		memset(protocol_handlers, 0, sizeof(void*) * UINT16_MAX);
 	}
 	if (protocol_handlers[protocol_number] == NULL) {
 		protocol_handlers[protocol_number] = handler;

src/iso9660.c

@@ -251,7 +251,7 @@ void *iso_get_directory(void *t) {
 		dprintf("iso_get_directory size: %d %d %d\n", treeitem->size, info->rootextent_len, treeitem->size ? treeitem->size : info->rootextent_len);
 		return (void *) parse_directory(treeitem, (iso9660 *) treeitem->opaque,
 						treeitem->lbapos ? treeitem->lbapos : info->rootextent_lba,
-						treeitem->size ? treeitem->size : info->rootextent_len * 2048);
+						treeitem->size ? treeitem->size : (info->rootextent_len == 1 ? 2048 : info->rootextent_len));
 	} else {
 		kprintf("*** BUG *** iso_get_directory: null fs_tree_t*!\n");
 		return NULL;

src/arp.c src/net/arp.csrc/arp.c renamed to src/net/arp.c

@@ -0,0 +1,41 @@
+#include <kernel.h>
+
+void tcp_dump_segment(bool in, tcp_conn_t* conn, const ip_packet_t* encap_packet, const tcp_segment_t* segment, const tcp_options_t* options, size_t len, uint16_t our_checksum)
+{
+#if (TCP_TRACE != 1)
+	return;
+#endif
+	const char *states[] = { "LISTEN","SYN-SENT","SYN-RECEIVED","ESTABLISHED","FIN-WAIT-1","FIN-WAIT-2","CLOSE-WAIT","CLOSING","LAST-ACK","TIME-WAIT" };
+	char source_ip[15] = { 0 }, dest_ip[15] = { 0 };
+	get_ip_str(source_ip, encap_packet->src_ip);
+	get_ip_str(dest_ip, encap_packet->dst_ip);
+	dprintf(
+		"TCP %s: %s %s:%d->%s:%d len=%ld seq=%d ack=%d off=%d flags[%c%c%c%c%c%c%c%c] win=%d, sum=%04x/%04x, urg=%d",
+		in ? "IN" : "OUT",
+		conn ? states[conn->state] : "CLOSED",
+		source_ip,
+		segment->src_port,
+		dest_ip,
+		segment->dst_port,
+		len,
+		segment->seq,
+		segment->ack,
+		segment->flags.off,
+		segment->flags.fin ? 'F' : '-',
+		segment->flags.syn ? 'S' : '-',
+		segment->flags.rst ? 'R' : '-',
+		segment->flags.psh ? 'P' : '-',
+		segment->flags.ack ? 'A' : '-',
+		segment->flags.urg ? 'U' : '-',
+		segment->flags.ece ? 'E' : '-',
+		segment->flags.cwr ? 'C' : '-',
+		segment->window_size,
+		segment->checksum,
+		our_checksum,
+		segment->urgent
+	);
+	if (options && options->mss) {
+		dprintf(" [opt.mss=%d]", options->mss);
+	}
+	dprintf("\n");
+}

src/net/debug.c

@@ -0,0 +1,30 @@
+#include <kernel.h>
+
+static tcp_conn_t* fd[FD_MAX] = { 0 };
+
+int tcp_allocate_fd(tcp_conn_t* conn)
+{
+	for (size_t x = 0; x < FD_MAX; ++x) {
+		if (fd[x] == NULL) {
+			fd[x] = conn;
+			return x;
+		}
+	}
+	return -1;
+}
+
+void tcp_free_fd(int x)
+{
+	if (x >= 0 && x < FD_MAX) {
+		fd[x] = NULL;
+	}
+}
+
+tcp_conn_t* tcp_find_by_fd(int x)
+{
+	if (x >= 0 && x < FD_MAX) {
+		return fd[x];
+	}
+	return NULL;
+}
+

src/net/descriptor.c

@@ -116,7 +116,10 @@ void ip_idle()
 		time_t current_time = time(NULL);
 		packet_queue_item_t* cur = packet_queue;
 		packet_queue_item_t* last = NULL;
-		for (; cur; cur = cur->next) {
+
+		for (; cur; ) {
+			/* Save next pointer early, because cur may be freed */
+			packet_queue_item_t* next = cur->next;
 
 			/* Here we determine if the packet is destined for the local net or the
 			 * internet at large. The calculation is actually very easy, we just AND
@@ -129,7 +132,7 @@ void ip_idle()
 			 * is the IP address of the target machine otherwise is the IP of the
 			 * router. This is then used in arp_lookup() to decide which mac address
 			 * we send the packet to.
-			 * 
+			 *
 			 * Note that if we have no gateway address everything is considered local.
 			 *
 			 * These addresses are all in network byte order - it doesn't matter, so
@@ -148,19 +151,25 @@ void ip_idle()
 				/* The ARP for this MAC has come back now, we can send the packet! */
 				ethernet_send_packet(dst_hardware_addr, (uint8_t*)cur->packet, htons(cur->packet->length), ETHERNET_TYPE_IP);
 				dequeue_packet(cur, last);
+				/* do not advance last, because cur was freed */
 			} else if (is_local && cur->arp_tries < 2 && current_time - cur->last_arp > 0) {
 				/* After one second, ARP didn't come back, try it again up to 3 times */
 				cur->arp_tries++;
 				cur->last_arp = current_time;
 				arp_send_packet(zero_hardware_addr, arp_dest);
+				last = cur; /* safe to advance last, we kept cur */
 			} else if (cur->arp_tries == 3 && current_time - cur->last_arp >= 10) {
 				/* 3 ARPs have been tried over 3 seconds, and then we waited another ten.
 				 * Packet still didn't get an ARP reply. Dequeue it as a lost packet.
 				 */
 				dprintf("Failed ARP resolution after 3 tries to %08x at %d\n", arp_dest, current_time);
 				dequeue_packet(cur, last);
+				/* again, don't advance last */
+			} else {
+				last = cur; /* still alive, advance last */
 			}
-			last = cur;
+
+			cur = next; /* always advance from saved next pointer */
 		}
 	}
 }