diff --git a/libraries/AP_Networking/AP_Networking.h b/libraries/AP_Networking/AP_Networking.h
index c931fc26982461..911b2fa6af4a8a 100644
--- a/libraries/AP_Networking/AP_Networking.h
+++ b/libraries/AP_Networking/AP_Networking.h
@@ -184,6 +184,9 @@ class AP_Networking
     enum class NetworkPortType {
         NONE = 0,
         UDP_CLIENT = 1,
+        UDP_SERVER = 2,
+        TCP_CLIENT = 3,
+        TCP_SERVER = 4,
     };
 
     // class for NET_Pn_* parameters
@@ -199,6 +202,7 @@ class AP_Networking
         AP_Networking_IPV4 ip {"0.0.0.0"};
         AP_Int32 port;
         SocketAPM *sock;
+        SocketAPM *listen_sock;
 
         bool is_initialized() override {
             return true;
@@ -207,8 +211,18 @@ class AP_Networking
             return false;
         }
 
+        void wait_startup();
         void udp_client_init(const uint32_t size_rx, const uint32_t size_tx);
+        void udp_server_init(const uint32_t size_rx, const uint32_t size_tx);
+        void tcp_server_init(const uint32_t size_rx, const uint32_t size_tx);
+        void tcp_client_init(const uint32_t size_rx, const uint32_t size_tx);
+
         void udp_client_loop(void);
+        void udp_server_loop(void);
+        void tcp_client_loop(void);
+        void tcp_server_loop(void);
+
+        bool send_receive(void);
 
     private:
         bool init_buffers(const uint32_t size_rx, const uint32_t size_tx);
@@ -222,10 +236,21 @@ class AP_Networking
         void _flush() override {}
         bool _discard_input() override;
 
+        enum flow_control get_flow_control(void) override;
+
+        uint32_t bw_in_bytes_per_second() const override {
+            return 1000000UL;
+        }
+
         ByteBuffer *readbuffer;
         ByteBuffer *writebuffer;
         uint32_t last_size_tx;
         uint32_t last_size_rx;
+        bool packetise;
+        bool connected;
+        bool have_received;
+        bool close_on_recv_error;
+
         HAL_Semaphore sem;
     };
 
diff --git a/libraries/AP_Networking/AP_Networking_address.cpp b/libraries/AP_Networking/AP_Networking_address.cpp
index 5cadbbe6f7a144..19dc446b09501d 100644
--- a/libraries/AP_Networking/AP_Networking_address.cpp
+++ b/libraries/AP_Networking/AP_Networking_address.cpp
@@ -3,6 +3,7 @@
  */
 
 #include "AP_Networking_Config.h"
+#include <arpa/inet.h>
 
 #if AP_NETWORKING_ENABLED
 
@@ -68,9 +69,11 @@ void AP_Networking_IPV4::set_default_uint32(uint32_t v)
     }
 }
 
-const char* AP_Networking_IPV4::get_str() const
+const char* AP_Networking_IPV4::get_str()
 {
-    return AP_Networking::convert_ip_to_str(get_uint32());
+    const auto ip = ntohl(get_uint32());
+    inet_ntop(AF_INET, &ip, strbuf, sizeof(strbuf));
+    return strbuf;
 }
 
 #endif // AP_NETWORKING_ENABLED
diff --git a/libraries/AP_Networking/AP_Networking_address.h b/libraries/AP_Networking/AP_Networking_address.h
index a4a3b6f8b29a8f..f9852948676ec8 100644
--- a/libraries/AP_Networking/AP_Networking_address.h
+++ b/libraries/AP_Networking/AP_Networking_address.h
@@ -18,12 +18,15 @@ class AP_Networking_IPV4
     void set_uint32(uint32_t addr);
 
     // return address as a null-terminated string
-    const char* get_str() const;
+    const char* get_str();
 
     // set default address from a uint32
     void set_default_uint32(uint32_t addr);
 
     static const struct AP_Param::GroupInfo var_info[];
+
+private:
+    char strbuf[16];
 };
 
 /*
diff --git a/libraries/AP_Networking/AP_Networking_port.cpp b/libraries/AP_Networking/AP_Networking_port.cpp
index e70224cf4b4b7b..83a8074f6943d9 100644
--- a/libraries/AP_Networking/AP_Networking_port.cpp
+++ b/libraries/AP_Networking/AP_Networking_port.cpp
@@ -11,6 +11,8 @@
 #include <GCS_MAVLink/GCS.h>
 #include <AP_BoardConfig/AP_BoardConfig.h>
 #include <AP_Math/AP_Math.h>
+#include <AP_SerialManager/AP_SerialManager.h>
+#include <AP_HAL/utility/packetise.h>
 
 extern const AP_HAL::HAL& hal;
 
@@ -68,8 +70,17 @@ void AP_Networking::ports_init(void)
         case NetworkPortType::UDP_CLIENT:
             p.udp_client_init(AP_NETWORKING_PORT_MIN_RXSIZE, AP_NETWORKING_PORT_MIN_TXSIZE);
             break;
+        case NetworkPortType::UDP_SERVER:
+            p.udp_server_init(AP_NETWORKING_PORT_MIN_RXSIZE, AP_NETWORKING_PORT_MIN_TXSIZE);
+            break;
+        case NetworkPortType::TCP_SERVER:
+            p.tcp_server_init(AP_NETWORKING_PORT_MIN_RXSIZE, AP_NETWORKING_PORT_MIN_TXSIZE);
+            break;
+        case NetworkPortType::TCP_CLIENT:
+            p.tcp_client_init(AP_NETWORKING_PORT_MIN_RXSIZE, AP_NETWORKING_PORT_MIN_TXSIZE);
+            break;
         }
-        if (p.sock != nullptr) {
+        if (p.sock != nullptr || p.listen_sock != nullptr) {
             AP::serialmanager().register_port(&p);
         }
     }
@@ -84,27 +95,102 @@ void AP_Networking::Port::udp_client_init(const uint32_t size_rx, const uint32_t
     if (!init_buffers(size_rx, size_tx)) {
         return;
     }
-    if (sock != nullptr) {
-        return;
-    }
     sock = new SocketAPM(true);
     if (sock == nullptr) {
         return;
     }
+    sock->set_blocking(false);
+
+    // setup for packet boundaries if this is mavlink
+    packetise = (state.protocol == AP_SerialManager::SerialProtocol_MAVLink ||
+                 state.protocol == AP_SerialManager::SerialProtocol_MAVLink2);
+
     if (!hal.scheduler->thread_create(FUNCTOR_BIND_MEMBER(&AP_Networking::Port::udp_client_loop, void), "NET", 2048, AP_HAL::Scheduler::PRIORITY_UART, 0)) {
         AP_BoardConfig::allocation_error("Failed to allocate UDP client thread");
     }
 }
 
 /*
-  update a UDP client
+  initialise a UDP server
  */
-void AP_Networking::Port::udp_client_loop(void)
+void AP_Networking::Port::udp_server_init(const uint32_t size_rx, const uint32_t size_tx)
+{
+    WITH_SEMAPHORE(sem);
+    if (!init_buffers(size_rx, size_tx)) {
+        return;
+    }
+    sock = new SocketAPM(true);
+    if (sock == nullptr) {
+        return;
+    }
+    sock->set_blocking(false);
+
+    // setup for packet boundaries if this is mavlink
+    packetise = (state.protocol == AP_SerialManager::SerialProtocol_MAVLink ||
+                 state.protocol == AP_SerialManager::SerialProtocol_MAVLink2);
+
+    if (!hal.scheduler->thread_create(FUNCTOR_BIND_MEMBER(&AP_Networking::Port::udp_server_loop, void), "NET", 2048, AP_HAL::Scheduler::PRIORITY_UART, 0)) {
+        AP_BoardConfig::allocation_error("Failed to allocate UDP server thread");
+    }
+}
+
+/*
+  initialise a TCP server
+ */
+void AP_Networking::Port::tcp_server_init(const uint32_t size_rx, const uint32_t size_tx)
+{
+    WITH_SEMAPHORE(sem);
+    if (!init_buffers(size_rx, size_tx)) {
+        return;
+    }
+    listen_sock = new SocketAPM(false);
+    if (listen_sock == nullptr) {
+        return;
+    }
+    listen_sock->reuseaddress();
+
+    if (!hal.scheduler->thread_create(FUNCTOR_BIND_MEMBER(&AP_Networking::Port::tcp_server_loop, void), "NET", 2048, AP_HAL::Scheduler::PRIORITY_UART, 0)) {
+        AP_BoardConfig::allocation_error("Failed to allocate TCP server thread");
+    }
+}
+
+/*
+  initialise a TCP client
+ */
+void AP_Networking::Port::tcp_client_init(const uint32_t size_rx, const uint32_t size_tx)
+{
+    WITH_SEMAPHORE(sem);
+    if (!init_buffers(size_rx, size_tx)) {
+        return;
+    }
+    sock = new SocketAPM(false);
+    if (sock == nullptr) {
+        return;
+    }
+    sock->set_blocking(false);
+
+    if (!hal.scheduler->thread_create(FUNCTOR_BIND_MEMBER(&AP_Networking::Port::tcp_client_loop, void), "NET", 2048, AP_HAL::Scheduler::PRIORITY_UART, 0)) {
+        AP_BoardConfig::allocation_error("Failed to allocate TCP client thread");
+    }
+}
+
+/*
+  wait for networking stack to be up
+ */
+void AP_Networking::Port::wait_startup(void)
 {
     while (!hal.scheduler->is_system_initialized()) {
         hal.scheduler->delay(100);
     }
     hal.scheduler->delay(1000);
+}
+
+/*
+  update a UDP client
+ */
+void AP_Networking::Port::udp_client_loop(void)
+{
+    wait_startup();
 
     const char *dest = ip.get_str();
     if (!sock->connect(dest, port.get())) {
@@ -116,31 +202,187 @@ void AP_Networking::Port::udp_client_loop(void)
 
     GCS_SEND_TEXT(MAV_SEVERITY_INFO, "UDP[%u]: connected to %s:%u", (unsigned)state.idx, dest, unsigned(port.get()));
 
+    connected = true;
+
+    bool active = false;
     while (true) {
-        hal.scheduler->delay_microseconds(500);
-        WITH_SEMAPHORE(sem);
+        if (!active) {
+            hal.scheduler->delay_microseconds(100);
+        }
+        active = send_receive();
+    }
+}
 
-        // handle outgoing packets
-        uint32_t available;
-        const auto *ptr = writebuffer->readptr(available);
-        if (ptr != nullptr) {
-            const auto ret = sock->send(ptr, available);
-            if (ret > 0) {
-                writebuffer->advance(ret);
+/*
+  update a UDP server
+ */
+void AP_Networking::Port::udp_server_loop(void)
+{
+    wait_startup();
+
+    const char *addr = ip.get_str();
+    if (!sock->bind(addr, port.get())) {
+        GCS_SEND_TEXT(MAV_SEVERITY_ERROR, "UDP[%u]: Failed to bind to %s:%u", (unsigned)state.idx, addr, unsigned(port.get()));
+        delete sock;
+        sock = nullptr;
+        return;
+    }
+    sock->reuseaddress();
+
+    GCS_SEND_TEXT(MAV_SEVERITY_INFO, "UDP[%u]: bound to %s:%u", (unsigned)state.idx, addr, unsigned(port.get()));
+
+    bool active = false;
+    while (true) {
+        if (!active) {
+            hal.scheduler->delay_microseconds(100);
+        }
+        active = send_receive();
+    }
+}
+
+/*
+  update a TCP server
+ */
+void AP_Networking::Port::tcp_server_loop(void)
+{
+    wait_startup();
+
+    const char *addr = ip.get_str();
+    if (!listen_sock->bind(addr, port.get()) || !listen_sock->listen(1)) {
+        GCS_SEND_TEXT(MAV_SEVERITY_ERROR, "TCP[%u]: Failed to bind to %s:%u", (unsigned)state.idx, addr, unsigned(port.get()));
+        delete listen_sock;
+        listen_sock = nullptr;
+        return;
+    }
+
+    GCS_SEND_TEXT(MAV_SEVERITY_INFO, "TCP[%u]: bound to %s:%u", (unsigned)state.idx, addr, unsigned(port.get()));
+
+    close_on_recv_error = true;
+
+    bool active = false;
+    while (true) {
+        if (!active) {
+            hal.scheduler->delay_microseconds(100);
+        }
+        if (sock == nullptr) {
+            sock = listen_sock->accept(100);
+            if (sock != nullptr) {
+                sock->set_blocking(false);
+                char buf[16];
+                uint16_t last_port;
+                const char *last_addr = listen_sock->last_recv_address(buf, sizeof(buf), last_port);
+                if (last_addr != nullptr) {
+                    GCS_SEND_TEXT(MAV_SEVERITY_INFO, "TCP[%u]: connection from %s:%u", (unsigned)state.idx, last_addr, unsigned(last_port));
+                }
+                connected = true;
+                sock->reuseaddress();
             }
         }
+        if (sock != nullptr) {
+            active = send_receive();
+        }
+    }
+}
+
+/*
+  update a TCP client
+ */
+void AP_Networking::Port::tcp_client_loop(void)
+{
+    wait_startup();
+
+    close_on_recv_error = true;
 
-        // handle incoming packets
-        const auto space = readbuffer->space();
-        if (space > 0) {
-            const uint32_t n = MIN(350U, space);
-            uint8_t buf[n];
-            const auto ret = sock->recv(buf, n, 0);
-            if (ret > 0) {
-                readbuffer->write(buf, ret);
+    bool active = false;
+    while (true) {
+        if (!active) {
+            hal.scheduler->delay_microseconds(100);
+        }
+        if (sock == nullptr) {
+            sock = new SocketAPM(false);
+            if (sock == nullptr) {
+                continue;
+            }
+            connected = false;
+        }
+        if (!connected) {
+            const char *dest = ip.get_str();
+            connected = sock->connect(dest, port.get());
+            if (connected) {
+                GCS_SEND_TEXT(MAV_SEVERITY_INFO, "TCP[%u]: connected to %s:%u", unsigned(state.idx), dest, unsigned(port.get()));
+                sock->set_blocking(false);
+            } else {
+                delete sock;
+                sock = nullptr;
+                // don't try and connect too fast
+                hal.scheduler->delay(100);
+            }
+        }
+        if (sock != nullptr && connected) {
+            active = send_receive();
+        }
+    }
+}
+
+/*
+  run one send/receive loop
+ */
+bool AP_Networking::Port::send_receive(void)
+{
+
+    bool active = false;
+    WITH_SEMAPHORE(sem);
+
+    // handle incoming packets
+    const auto space = readbuffer->space();
+    if (space > 0) {
+        const uint32_t n = MIN(300U, space);
+        uint8_t buf[n];
+        const auto ret = sock->recv(buf, n, 0);
+        if (close_on_recv_error && ret == 0) {
+            GCS_SEND_TEXT(MAV_SEVERITY_INFO, "TCP[%u]: closed connection", unsigned(state.idx));
+            delete sock;
+            sock = nullptr;
+            return false;
+        }
+        if (ret > 0) {
+            readbuffer->write(buf, ret);
+            active = true;
+            have_received = true;
+        }
+    }
+
+    if (connected) {
+        // handle outgoing packets
+        uint32_t available = writebuffer->available();
+        available = MIN(300U, available);
+        if (packetise) {
+            available = mavlink_packetise(*writebuffer, available);
+        }
+        if (available > 0) {
+            uint8_t buf[available];
+            auto n = writebuffer->peekbytes(buf, available);
+            if (n > 0) {
+                const auto ret = sock->send(buf, n);
+                if (ret > 0) {
+                    writebuffer->advance(ret);
+                    active = true;
+                }
+            }
+        }
+    } else {
+        if (type == NetworkPortType::UDP_SERVER && have_received) {
+            // connect the socket to the last receive address if we have one
+            char buf[16];
+            uint16_t last_port;
+            const char *last_addr = sock->last_recv_address(buf, sizeof(buf), last_port);
+            if (last_addr != nullptr && port != 0) {
+                connected = sock->connect(last_addr, last_port);
             }
         }
     }
+
+    return active;
 }
 
 /*
@@ -210,4 +452,22 @@ bool AP_Networking::Port::init_buffers(const uint32_t size_rx, const uint32_t si
     return readbuffer != nullptr && writebuffer != nullptr;
 }
 
+/*
+  return flow control state
+ */
+enum AP_HAL::UARTDriver::flow_control AP_Networking::Port::get_flow_control(void)
+{
+    const NetworkPortType ptype = (NetworkPortType)type;
+    switch (ptype) {
+    case NetworkPortType::TCP_CLIENT:
+    case NetworkPortType::TCP_SERVER:
+        return AP_HAL::UARTDriver::FLOW_CONTROL_ENABLE;
+    case NetworkPortType::UDP_CLIENT:
+    case NetworkPortType::UDP_SERVER:
+    case NetworkPortType::NONE:
+        break;
+    }
+    return AP_HAL::UARTDriver::FLOW_CONTROL_DISABLE;
+}
+
 #endif // AP_NETWORKING_ENABLED