Refactor the example a little

main.c

 
 #define TCP_PORT 4242
 #define DEBUG_printf printf
-#define BUF_SIZE 2048
 #define POLL_TIME_S 5
 
-typedef struct TCP_SERVER_T_ {
-	struct tcp_pcb *server_pcb;
-	struct tcp_pcb *client_pcb;
-	bool complete;
-	uint8_t buffer_recv[BUF_SIZE];
-	int sent_len;
-} TCP_SERVER_T;
-
-static TCP_SERVER_T* tcp_server_init(void) {
-	TCP_SERVER_T *state = calloc(1, sizeof(TCP_SERVER_T));
-	if (!state) {
-		DEBUG_printf("failed to allocate state\n");
-		return NULL;
-	}
-	return state;
+#define MAX_LEN 2048
+
+enum conn_state {
+	CONN_STATE_WAIT_FOR_SYNC,
+	CONN_STATE_READ_OPCODE,
+	CONN_STATE_READ_ARGS,
+	CONN_STATE_READ_DATA,
+	CONN_STATE_HANDLE,
+	CONN_STATE_WRITE_RESP,
+	CONN_STATE_ERROR,
+	CONN_STATE_CLOSED,
+};
+
+struct tcp_ctx {
+	struct tcp_pcb *serv_pcb;
+	volatile bool serv_done;
+
+	struct tcp_pcb *conn_pcb;
+	uint8_t buf[MAX_LEN];
+	size_t bytes_remaining;
+	enum conn_state conn_state;
+};
+
+static err_t tcp_conn_close(struct tcp_ctx *ctx)
+{
+	err_t err = ERR_OK;
+
+	cyw43_arch_gpio_put (0, false);
+	ctx->conn_state = CONN_STATE_CLOSED;
+
+	if (!ctx->conn_pcb) {
+		return err;
+	}
+
+	tcp_arg(ctx->conn_pcb, NULL);
+	tcp_poll(ctx->conn_pcb, NULL, 0);
+	tcp_sent(ctx->conn_pcb, NULL);
+	tcp_recv(ctx->conn_pcb, NULL);
+	tcp_err(ctx->conn_pcb, NULL);
+	err = tcp_close(ctx->conn_pcb);
+	if (err != ERR_OK) {
+		DEBUG_printf("close failed %d, calling abort\n", err);
+		tcp_abort(ctx->conn_pcb);
+		err = ERR_ABRT;
+	}
+
+	ctx->conn_pcb = NULL;
+
+	return err;
 }
 
-static err_t tcp_server_close(void *arg) {
-	TCP_SERVER_T *state = (TCP_SERVER_T*)arg;
+static err_t tcp_server_close(void *arg)
+{
+	struct tcp_ctx *ctx = (struct tcp_ctx *)arg;
 	err_t err = ERR_OK;
-	if (state->client_pcb != NULL) {
-		tcp_arg(state->client_pcb, NULL);
-		tcp_poll(state->client_pcb, NULL, 0);
-		tcp_sent(state->client_pcb, NULL);
-		tcp_recv(state->client_pcb, NULL);
-		tcp_err(state->client_pcb, NULL);
-		err = tcp_close(state->client_pcb);
-		if (err != ERR_OK) {
-			DEBUG_printf("close failed %d, calling abort\n", err);
-			tcp_abort(state->client_pcb);
-			err = ERR_ABRT;
-		}
-		state->client_pcb = NULL;
+
+	err = tcp_conn_close(ctx);
+	if ((err != ERR_OK) && ctx->serv_pcb) {
+		tcp_arg(ctx->serv_pcb, NULL);
+		tcp_abort(ctx->serv_pcb);
+		ctx->serv_pcb = NULL;
+		return ERR_ABRT;
 	}
-	if (state->server_pcb) {
-		tcp_arg(state->server_pcb, NULL);
-		tcp_close(state->server_pcb);
-		state->server_pcb = NULL;
+
+	if (!ctx->serv_pcb) {
+		return err;
 	}
+
+	tcp_arg(ctx->serv_pcb, NULL);
+	err = tcp_close(ctx->serv_pcb);
+	if (err != ERR_OK) {
+		tcp_abort(ctx->serv_pcb);
+		err = ERR_ABRT;
+	}
+	ctx->serv_pcb = NULL;
+
 	return err;
 }
 
-static err_t tcp_server_result(void *arg, int status) {
-	TCP_SERVER_T *state = (TCP_SERVER_T*)arg;
+static void tcp_server_complete(void *arg, int status)
+{
+	struct tcp_ctx *ctx = (struct tcp_ctx *)arg;
 	if (status == 0) {
-		DEBUG_printf("completed normally\n");
+		DEBUG_printf("server completed normally\n");
 	} else {
-		DEBUG_printf("error %d\n", status);
+		DEBUG_printf("server error %d\n", status);
 	}
-	state->complete = true;
-	return tcp_server_close(arg);
-}
 
-static err_t tcp_server_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) {
-	TCP_SERVER_T *state = (TCP_SERVER_T*)arg;
-	DEBUG_printf("tcp_server_sent %u\n", len);
-	state->sent_len += len;
+	tcp_server_close(ctx);
+	ctx->serv_done = true;
+}
 
-	if (state->sent_len >= strlen("hello\n")) {
-		DEBUG_printf("Sending done\n");
+static err_t tcp_conn_complete(void *arg, int status)
+{
+	struct tcp_ctx *ctx = (struct tcp_ctx *)arg;
+	if (status == 0) {
+		DEBUG_printf("conn completed normally\n");
+	} else {
+		DEBUG_printf("conn error %d\n", status);
 	}
-
-	return ERR_OK;
+	return tcp_conn_close(ctx);
 }
 
-err_t tcp_server_send_data(void *arg, struct tcp_pcb *tpcb)
+static err_t tcp_conn_sent(void *arg, struct tcp_pcb *tpcb, u16_t len)
 {
-	TCP_SERVER_T *state = (TCP_SERVER_T*)arg;
+	struct tcp_ctx *ctx = (struct tcp_ctx *)arg;
+	DEBUG_printf("tcp_server_sent %u\n", len);
 
-	state->sent_len = 0;
-	DEBUG_printf("Writing to client\n");
-	// this method is callback from lwIP, so cyw43_arch_lwip_begin is not required, however you
-	// can use this method to cause an assertion in debug mode, if this method is called when
-	// cyw43_arch_lwip_begin IS needed
-	cyw43_arch_lwip_check();
-	err_t err = tcp_write(tpcb, "hello\n", strlen("hello\n"), TCP_WRITE_FLAG_COPY);
-	if (err != ERR_OK) {
-		DEBUG_printf("Failed to write data %d\n", err);
-		return tcp_server_result(arg, -1);
-	}
 	return ERR_OK;
 }
 
-err_t tcp_server_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
-	TCP_SERVER_T *state = (TCP_SERVER_T*)arg;
+static err_t tcp_conn_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
+{
+	struct tcp_ctx *ctx = (struct tcp_ctx *)arg;
 	if (!p) {
-		return tcp_server_result(arg, 0);
+		return tcp_conn_complete(ctx, 0);
 	}
+
 	// this method is callback from lwIP, so cyw43_arch_lwip_begin is not required, however you
 	// can use this method to cause an assertion in debug mode, if this method is called when
 	// cyw43_arch_lwip_begin IS needed
 		DEBUG_printf("tcp_server_recv %d err %d\n", p->tot_len, err);
 
 		// Receive the buffer
-		pbuf_copy_partial(p, state->buffer_recv, p->tot_len, 0);
+		pbuf_copy_partial(p, ctx->buf, p->tot_len, 0);
 
-		state->buffer_recv[p->tot_len] = '\0';
-		printf("%s\n", state->buffer_recv);
+		ctx->buf[p->tot_len] = '\0';
+		printf("%s\n", ctx->buf);
 		tcp_recved(tpcb, p->tot_len);
 	}
 	pbuf_free(p);
 	return ERR_OK;
 }
 
-static err_t tcp_server_poll(void *arg, struct tcp_pcb *tpcb) {
+static err_t tcp_conn_poll(void *arg, struct tcp_pcb *tpcb)
+{
 	DEBUG_printf("tcp_server_poll_fn\n");
 	return ERR_OK;
 }
 
-static void tcp_server_err(void *arg, err_t err) {
-	if (err != ERR_ABRT) {
-		DEBUG_printf("tcp_client_err_fn %d\n", err);
-		tcp_server_result(arg, err);
-	} else {
-		DEBUG_printf("tcp_client_err_fn abort %d\n", err);
-		tcp_server_result(arg, err);
-	}
+static void tcp_conn_err(void *arg, err_t err)
+{
+	struct tcp_ctx *ctx = (struct tcp_ctx *)arg;
+
+	DEBUG_printf("tcp_conn_err %d\n", err);
+
+	ctx->conn_pcb = NULL;
+	ctx->conn_state = CONN_STATE_CLOSED;
+	ctx->bytes_remaining = 0;
+	cyw43_arch_gpio_put (0, false);
+}
+
+static void tcp_conn_wait_for_sync(struct tcp_ctx *ctx)
+{
+	ctx->conn_state = CONN_STATE_WAIT_FOR_SYNC;
+	ctx->bytes_remaining = 4;
+}
+
+static void tcp_conn_init(struct tcp_ctx *ctx, struct tcp_pcb *pcb)
+{
+	ctx->conn_pcb = pcb;
+	tcp_arg(pcb, ctx);
+	tcp_sent(pcb, tcp_conn_sent);
+	tcp_recv(pcb, tcp_conn_recv);
+	tcp_poll(pcb, tcp_conn_poll, POLL_TIME_S * 2);
+	tcp_err(pcb, tcp_conn_err);
+
+	cyw43_arch_gpio_put (0, true);
+
+	tcp_conn_wait_for_sync(ctx);
 }
 
-static err_t tcp_server_accept(void *arg, struct tcp_pcb *client_pcb, err_t err) {
-	TCP_SERVER_T *state = (TCP_SERVER_T*)arg;
+static err_t tcp_server_accept(void *arg, struct tcp_pcb *client_pcb, err_t err)
+{
+	struct tcp_ctx *ctx = (struct tcp_ctx *)arg;
+
 	if (err != ERR_OK || client_pcb == NULL) {
 		DEBUG_printf("Failure in accept\n");
-		tcp_server_result(arg, err);
+		tcp_server_complete(ctx, err);
 		return ERR_VAL;
 	}
-	DEBUG_printf("Client connected\n");
+	DEBUG_printf("Connection opened\n");
 
-	state->client_pcb = client_pcb;
-	tcp_arg(client_pcb, state);
-	tcp_sent(client_pcb, tcp_server_sent);
-	tcp_recv(client_pcb, tcp_server_recv);
-	tcp_poll(client_pcb, tcp_server_poll, POLL_TIME_S * 2);
-	tcp_err(client_pcb, tcp_server_err);
+	if (ctx->conn_pcb) {
+		DEBUG_printf("Already have a connection\n");
+		tcp_abort(client_pcb);
+		return ERR_ABRT;
+	}
 
-	return tcp_server_send_data(arg, state->client_pcb);
+	tcp_conn_init(ctx, client_pcb);
+
+	return ERR_OK;
 }
 
-static bool tcp_server_open(void *arg) {
-	TCP_SERVER_T *state = (TCP_SERVER_T*)arg;
+static err_t tcp_server_listen(struct tcp_ctx *ctx)
+{
 	DEBUG_printf("Starting server at %s on port %u\n", ip4addr_ntoa(netif_ip4_addr(netif_list)), TCP_PORT);
 
+	ctx->serv_done = false;
+
 	struct tcp_pcb *pcb = tcp_new_ip_type(IPADDR_TYPE_ANY);
 	if (!pcb) {
 		DEBUG_printf("failed to create pcb\n");
-		return false;
+		return ERR_MEM;
 	}
 
 	err_t err = tcp_bind(pcb, NULL, TCP_PORT);
 	if (err) {
-		DEBUG_printf("failed to bind to port %d\n");
-		return false;
+		DEBUG_printf("failed to bind to port %d\n", TCP_PORT);
+		tcp_abort(pcb);
+		return err;
 	}
 
-	state->server_pcb = tcp_listen_with_backlog(pcb, 1);
-	if (!state->server_pcb) {
-		DEBUG_printf("failed to listen\n");
-		if (pcb) {
-			tcp_close(pcb);
-		}
-		return false;
+	ctx->serv_pcb = tcp_listen_with_backlog_and_err(pcb, 1, &err);
+	if (!ctx->serv_pcb) {
+		DEBUG_printf("failed to listen: %d\n", err);
+		return err;
 	}
 
-	tcp_arg(state->server_pcb, state);
-	tcp_accept(state->server_pcb, tcp_server_accept);
+	tcp_arg(ctx->serv_pcb, ctx);
+	tcp_accept(ctx->serv_pcb, tcp_server_accept);
 
-	return true;
-}
-
-void run_tcp_server(void) {
-	TCP_SERVER_T *state = tcp_server_init();
-	if (!state) {
-		return;
-	}
-
-	if (!tcp_server_open(state)) {
-		tcp_server_result(state, -1);
-		return;
-	}
-
-	// Block until the connection is closed
-	while(!state->complete) {
-		// the following #ifdef is only here so this same example can be used in multiple modes;
-		// you do not need it in your code
-#if PICO_CYW43_ARCH_POLL
-		// if you are using pico_cyw43_arch_poll, then you must poll periodically from your
-		// main loop (not from a timer) to check for WiFi driver or lwIP work that needs to be done.
-		cyw43_arch_poll();
-		sleep_ms(1);
-#else
-		// if you are not using pico_cyw43_arch_poll, then WiFI driver and lwIP work
-		// is done via interrupt in the background. This sleep is just an example of some (blocking)
-		// work you might be doing.
-		sleep_ms(1000);
-#endif
-	}
-	free(state);
+	return ERR_OK;
 }
 
-int main() {
+int main()
+{
 	stdio_init_all();
 
 	sleep_ms(1000);
 		printf("Connected.\n");
 	}
 
+	struct tcp_ctx tcp = { 0 };
+
 	for ( ; ; ) {
-		run_tcp_server();
+		err_t err = tcp_server_listen(&tcp);
+		if (err != ERR_OK) {
+			printf("Failed to start server: %d\n", err);
+			sleep_ms(1000);
+			continue;
+		}
+
+		while (!tcp.serv_done) {
+			sleep_ms(1000);
+		}
 	}
 
 	cyw43_arch_deinit();