Module server 

Server module

Handles network servers, connection management, and protocol implementations

Re-exports

pub use tcp::actions::TcpProtocol;

pub use tcp::TcpServer;

pub use socket_file::actions::SocketFileProtocol;

pub use socket_file::SocketFileServer;

pub use named_pipe::actions::NamedPipeProtocol;

pub use named_pipe::NamedPipeServer;

pub use pty::actions::PtyProtocol;

pub use pty::PtyServer;

pub use stdio::actions::StdioProtocol;

pub use stdio::StdioServer;

pub use http::actions::HttpProtocol;

pub use http::HttpServer;

pub use http2::actions::Http2Protocol;

pub use http2::H2Server;

pub use pypi::actions::PypiProtocol;

pub use pypi::PypiServer;

pub use maven::actions::MavenProtocol;

pub use maven::MavenServer;

pub use datalink::actions::DataLinkProtocol;

pub use datalink::DataLinkServer;

pub use arp::actions::ArpProtocol;

pub use arp::ArpServer;

pub use icmp::actions::IcmpProtocol;

pub use icmp::IcmpServer;

pub use dc::actions::DcProtocol;

pub use dc::DcServer;

pub use udp::actions::UdpProtocol;

pub use udp::SharedUdpSocket;

pub use udp::UdpPeerMap;

pub use udp::UdpServer;

pub use dns::actions::DnsProtocol;

pub use dns::DnsServer;

pub use dot::actions::DotProtocol;

pub use dot::DotServer;

pub use doh::actions::DohProtocol;

pub use doh::DohServer;

pub use dhcp::actions::DhcpProtocol;

pub use dhcp::DhcpServer;

pub use bootp::actions::BootpProtocol;

pub use bootp::BootpServer;

pub use ntp::actions::NtpProtocol;

pub use ntp::NtpServer;

pub use tftp::actions::TftpProtocol;

pub use tftp::TftpServer;

pub use whois::actions::WhoisProtocol;

pub use whois::WhoisServer;

pub use ndp::actions::NdpProtocol;

pub use ndp::NdpServer;

pub use dhcpv6::actions::Dhcpv6Protocol;

pub use dhcpv6::Dhcpv6Server;

pub use tuntap::actions::TunTapProtocol;

pub use tuntap::TunTapServer;

pub use rawip::actions::RawIpProtocol;

pub use rawip::RawIpServer;

pub use gtp::actions::GtpProtocol;

pub use gtp::GtpServer;

pub use m3ua::actions::M3uaProtocol;

pub use m3ua::M3uaServer;

pub use can::actions::CanProtocol;

pub use can::CanServer;

pub use lldp::actions::LldpProtocol;

pub use lldp::LldpServer;

pub use cdp::actions::CdpProtocol;

pub use cdp::CdpServer;

pub use stp::actions::StpProtocol;

pub use stp::StpServer;

pub use vrrp::actions::VrrpProtocol;

pub use vrrp::VrrpServer;

pub use hsrp::actions::HsrpProtocol;

pub use hsrp::HsrpServer;

pub use eapol::actions::EapolProtocol;

pub use eapol::EapolServer;

pub use wol::actions::WolProtocol;

pub use wol::WolServer;

pub use nats::actions::NatsProtocol;

pub use nats::NatsServer;

pub use stomp::actions::StompProtocol;

pub use stomp::StompServer;

pub use ident::actions::IdentProtocol;

pub use ident::IdentServer;

pub use gemini::actions::GeminiProtocol;

pub use gemini::GeminiServer;

pub use dict::actions::DictProtocol;

pub use dict::DictServer;

pub use beanstalkd::actions::BeanstalkdProtocol;

pub use beanstalkd::BeanstalkdServer;

pub use zabbix::actions::ZabbixProtocol;

pub use zabbix::ZabbixServer;

pub use gearman::actions::GearmanProtocol;

pub use gearman::GearmanServer;

pub use nsq::actions::NsqProtocol;

pub use nsq::NsqServer;

pub use gopher::actions::GopherProtocol;

pub use gopher::GopherServer;

pub use finger::actions::FingerProtocol;

pub use finger::FingerServer;

pub use ssdp::actions::SsdpProtocol;

pub use ssdp::SsdpServer;

pub use llmnr::actions::LlmnrProtocol;

pub use llmnr::LlmnrServer;

pub use netbios_ns::actions::NetbiosNsProtocol;

pub use netbios_ns::NetbiosNsServer;

pub use snmp::actions::SnmpProtocol;

pub use snmp::SnmpServer;

pub use igmp::actions::IgmpProtocol;

pub use igmp::IgmpServer;

pub use syslog::actions::SyslogProtocol;

pub use syslog::SyslogServer;

pub use ssh::actions::SshProtocol;

pub use ssh::sftp_handler::LlmSftpHandler;

pub use ssh::SshServer;

pub use ssh_agent::actions::SshAgentProtocol;

pub use ssh_agent::SshAgentServer;

pub use svn::actions::SvnProtocol;

pub use svn::SvnServer;

pub use irc::actions::IrcProtocol;

pub use irc::IrcServer;

pub use xmpp::actions::XmppProtocol;

pub use xmpp::XmppServer;

pub use telnet::actions::TelnetProtocol;

pub use telnet::TelnetServer;

pub use smtp::actions::SmtpProtocol;

pub use smtp::SmtpServer;

pub use ftp::actions::FtpProtocol;

pub use ftp::FtpServer;

pub use mdns::actions::MdnsProtocol;

pub use mdns::MdnsServer;

pub use mysql::actions::MysqlProtocol;

pub use mysql::MysqlServer;

pub use snowflake::actions::SnowflakeProtocol;

pub use snowflake::SnowflakeServer;

pub use db2::actions::Db2Protocol;

pub use db2::Db2Server;

pub use mongodb::actions::MongodbProtocol;

pub use mongodb::MongodbServer;

pub use mssql::actions::MssqlProtocol;

pub use mssql::MssqlServer;

pub use ipp::actions::IppProtocol;

pub use ipp::IppServer;

pub use postgresql::actions::PostgresqlProtocol;

pub use postgresql::PostgresqlServer;

pub use memcached::actions::MemcachedProtocol;

pub use memcached::MemcachedServer;

pub use radius::actions::RadiusProtocol;

pub use radius::RadiusServer;

pub use redis::actions::RedisProtocol;

pub use redis::RedisServer;

pub use rss::actions::RssProtocol;

pub use rss::RssServer;

pub use cassandra::actions::CassandraProtocol;

pub use cassandra::CassandraServer;

pub use proxy::actions::ProxyProtocol;

pub use proxy::filter::CertificateMode;

pub use proxy::filter::FilterMode;

pub use proxy::filter::FullRequestInfo;

pub use proxy::filter::FullResponseInfo;

pub use proxy::filter::HttpsConnectionAction;

pub use proxy::filter::HttpsConnectionInfo;

pub use proxy::filter::ProxyFilterConfig;

pub use proxy::filter::RequestAction;

pub use proxy::filter::RequestFilter;

pub use proxy::filter::ResponseAction;

pub use proxy::filter::ResponseFilter;

pub use proxy::ProxyServer;

pub use socks5::actions::Socks5Protocol;

pub use socks5::filter::FilterMode as Socks5FilterMode;

pub use socks5::filter::Socks5FilterConfig;

pub use socks5::Socks5Server;

pub use webdav::actions::WebDavProtocol;

pub use webdav::WebDavServer;

pub use nfs::actions::NfsProtocol;

pub use nfs::NfsServer;

pub use nfc::actions::NfcServerProtocol;

pub use nfc::NfcServer;

pub use smb::actions::SmbProtocol;

pub use smb::SmbServer;

pub use stun::actions::StunProtocol;

pub use stun::StunServer;

pub use turn::actions::TurnProtocol;

pub use turn::TurnServer;

pub use webrtc::actions::WebRtcProtocol;

pub use webrtc::WebRtcServer;

pub use webrtc::WebRtcServerData;

pub use websocket::actions::WebSocketProtocol;

pub use websocket::WebSocketServer;

pub use webrtc_signaling::actions::WebRtcSignalingProtocol;

pub use webrtc_signaling::WebRtcSignalingServer;

pub use webrtc_signaling::WebRtcSignalingServerData;

pub use sip::actions::SipProtocol;

pub use sip::SipServer;

pub use rtp::actions::RtpProtocol;

pub use rtp::RtpServer;

pub use rtsp::actions::RtspProtocol;

pub use rtsp::RtspServer;

pub use hls::actions::HlsProtocol;

pub use hls::HlsServer;

pub use ldap::actions::LdapProtocol;

pub use ldap::LdapServer;

pub use imap::actions::ImapProtocol;

pub use imap::ImapServer;

pub use pop3::actions::Pop3Protocol;

pub use pop3::Pop3Server;

pub use nntp::actions::NntpProtocol;

pub use nntp::NntpServer;

pub use mqtt::actions::MqttProtocol;

pub use mqtt::MqttServer;

pub use modbus::actions::ModbusProtocol;

pub use modbus::ModbusServer;

pub use coap::actions::CoapProtocol;

pub use coap::CoapServer;

pub use amqp::actions::AmqpProtocol;

pub use amqp::AmqpServer;

pub use elasticsearch::actions::ElasticsearchProtocol;

pub use elasticsearch::ElasticsearchServer;

pub use couchdb::actions::CouchDbProtocol;

pub use couchdb::CouchDbServer;

pub use yarn::actions::YarnProtocol;

pub use yarn::YarnServer;

pub use spark::actions::SparkProtocol;

pub use spark::SparkServer;

pub use dynamo::actions::DynamoProtocol;

pub use dynamo::DynamoServer;

pub use s3::actions::S3Protocol;

pub use s3::S3Server;

pub use sqs::actions::SqsProtocol;

pub use sqs::SqsServer;

pub use npm::actions::NpmProtocol;

pub use npm::NpmServer;

pub use oci_registry::actions::OciRegistryProtocol;

pub use oci_registry::OciRegistryServer;

pub use kubernetes::actions::KubernetesProtocol;

pub use kubernetes::KubernetesServer;

pub use prometheus::actions::PrometheusProtocol;

pub use prometheus::PrometheusServer;

pub use otlp::actions::OtlpProtocol;

pub use otlp::OtlpServer;

pub use docker::actions::DockerProtocol;

pub use docker::DockerServer;

pub use vault::actions::VaultProtocol;

pub use vault::VaultServer;

pub use bolt::actions::BoltProtocol;

pub use bolt::BoltServer;

pub use openai::actions::OpenAiProtocol;

pub use openai::OpenAiServer;

pub use ollama::actions::OllamaProtocol;

pub use ollama::OllamaServer;

pub use oauth2::actions::OAuth2Protocol;

pub use oauth2::OAuth2Server;

pub use jsonrpc::actions::JsonRpcProtocol;

pub use jsonrpc::JsonRpcServer;

pub use wireguard::actions::WireguardProtocol;

pub use wireguard::WireguardServer;

pub use openvpn::actions::OpenvpnProtocol;

pub use openvpn::OpenvpnServer;

pub use ipsec::actions::IpsecProtocol;

pub use ipsec::IpsecServer;

pub use bgp::actions::BgpProtocol;

pub use bgp::BgpServer;

pub use ospf::actions::OspfProtocol;

pub use ospf::OspfServer;

pub use isis::actions::IsisProtocol;

pub use isis::IsisServer;

pub use rip::actions::RipProtocol;

pub use rip::RipServer;

pub use bitcoin::actions::BitcoinProtocol;

pub use bitcoin::BitcoinServer;

pub use nostr::actions::NostrProtocol;

pub use nostr::NostrServer;

pub use mcp::actions::McpProtocol;

pub use mcp::McpServer;

pub use grpc::actions::GrpcProtocol;

pub use grpc::GrpcServer;

pub use etcd::actions::EtcdProtocol;

pub use etcd::EtcdServer;

pub use xmlrpc::actions::XmlRpcProtocol;

pub use xmlrpc::XmlRpcServer;

pub use zookeeper::actions::ZookeeperProtocol;

pub use zookeeper::ZookeeperServer;

pub use tor_relay::actions::TorRelayProtocol;

pub use tor_relay::TorRelayServer;

pub use vnc::actions::VncProtocol;

pub use vnc::VncServer;

pub use reverse_shell::actions::ReverseShellProtocol;

pub use reverse_shell::ReverseShellServer;

pub use rdp::actions::RdpProtocol;

pub use rdp::RdpServer;

pub use openapi::actions::OpenApiProtocol;

pub use openapi::OpenApiServer;

pub use openid::actions::OpenIdProtocol;

pub use openid::OpenIdServer;

pub use git::actions::GitProtocol;

pub use git::GitServer;

pub use mercurial::actions::MercurialProtocol;

pub use mercurial::MercurialServer;

pub use kafka::actions::KafkaProtocol;

pub use kafka::KafkaServer;

pub use quic::actions::QuicProtocol;

pub use quic::QuicServer;

pub use torrent_tracker::actions::TorrentTrackerProtocol;

pub use torrent_tracker::TorrentTrackerServer;

pub use torrent_dht::actions::TorrentDhtProtocol;

pub use torrent_dht::TorrentDhtServer;

pub use torrent_peer::actions::TorrentPeerProtocol;

pub use torrent_peer::TorrentPeerServer;

pub use tls::actions::TlsProtocol;

pub use tls::TlsServer;

pub use saml_idp::actions::SamlIdpProtocol;

pub use saml_idp::SamlIdpServer;

pub use saml_sp::actions::SamlSpProtocol;

pub use saml_sp::SamlSpServer;

pub use usb::keyboard::UsbKeyboardServer;

pub use usb::UsbKeyboardProtocol;

pub use usb::mouse::UsbMouseServer;

pub use usb::UsbMouseProtocol;

pub use usb::serial::UsbSerialServer;

pub use usb::UsbSerialProtocol;

pub use usb::msc::UsbMscServer;

pub use usb::UsbMscProtocol;

pub use usb::fido2::UsbFido2Server;

pub use usb::UsbFido2Protocol;

pub use usb::smartcard::UsbSmartCardServer;

pub use usb::UsbSmartCardProtocol;

pub use bluetooth_ble::actions::BluetoothBleProtocol;

pub use bluetooth_ble::BluetoothBle;

pub use bluetooth_ble_keyboard::actions::BluetoothBleKeyboardProtocol;

pub use bluetooth_ble_keyboard::BluetoothBleKeyboard;

pub use bluetooth_ble_mouse::actions::BluetoothBleMouseProtocol;

pub use bluetooth_ble_mouse::BluetoothBleMouse;

pub use bluetooth_ble_beacon::actions::BluetoothBleBeaconProtocol;

pub use bluetooth_ble_beacon::BluetoothBleBeacon;

pub use bluetooth_ble_remote::actions::BluetoothBleRemoteProtocol;

pub use bluetooth_ble_remote::BluetoothBleRemote;

pub use bluetooth_ble_battery::actions::BluetoothBleBatteryProtocol;

pub use bluetooth_ble_battery::BluetoothBleBattery;

pub use bluetooth_ble_heart_rate::actions::BluetoothBleHeartRateProtocol;

pub use bluetooth_ble_heart_rate::BluetoothBleHeartRate;

pub use bluetooth_ble_thermometer::actions::BluetoothBleThermometerProtocol;

pub use bluetooth_ble_thermometer::BluetoothBleThermometer;

pub use bluetooth_ble_environmental::actions::BluetoothBleEnvironmentalProtocol;

pub use bluetooth_ble_environmental::BluetoothBleEnvironmental;

pub use bluetooth_ble_proximity::actions::BluetoothBleProximityProtocol;

pub use bluetooth_ble_proximity::BluetoothBleProximity;

pub use bluetooth_ble_gamepad::actions::BluetoothBleGamepadProtocol;

pub use bluetooth_ble_gamepad::BluetoothBleGamepad;

pub use bluetooth_ble_presenter::actions::BluetoothBlePresenterProtocol;

pub use bluetooth_ble_presenter::BluetoothBlePresenter;

pub use bluetooth_ble_file_transfer::actions::BluetoothBleFileTransferProtocol;

pub use bluetooth_ble_file_transfer::BluetoothBleFileTransfer;

pub use bluetooth_ble_data_stream::actions::BluetoothBleDataStreamProtocol;

pub use bluetooth_ble_data_stream::BluetoothBleDataStream;

pub use bluetooth_ble_cycling::actions::BluetoothBleCyclingProtocol;

pub use bluetooth_ble_cycling::BluetoothBleCycling;

pub use bluetooth_ble_running::actions::BluetoothBleRunningProtocol;

pub use bluetooth_ble_running::BluetoothBleRunning;

pub use bluetooth_ble_weight_scale::actions::BluetoothBleWeightScaleProtocol;

pub use bluetooth_ble_weight_scale::BluetoothBleWeightScale;

pub use connection::Connection;

pub use connection::ConnectionId;

pub use http3::actions::Http3Protocol;

Modules

a2a

A2A 1.0 agent over HTTP/1.1: agent card, JSON-RPC dispatch, SSE streaming. Rust owns the envelope, ids and version rules; the handler owns every reply.

a2s

Steam/Source server query (A2S) over UDP. Rust owns the challenge exchange, encoding and splitting; handlers decide what the server reports.

accept_bounded

A connection cap for accept loops, and the refusal that says why.

acme

ACME (RFC 8555) certificate authority over HTTP/1.1, optionally over TLS. Rust owns the directory, nonces, JWS verification, the account / order / authorization / challenge state machine, http-01 fetching, CSR checks and issuance; the handler approves or refuses each account, order, validation, issuance and revocation.

activitypub

ActivityPub instance (server role). HTTP is served by http.rs over instance.rs; every activity that arrives at an inbox with a valid signature is queued and answered by the model one at a time, in order.

adc

adc_peer

amqp

AMQP 0-9-1 broker with LLM-controlled responses.

amqp1

AMQP 1.0 container. Rust owns the protocol headers, SASL, the connection / session / link state machines, link credit, transfers (multi-frame both ways), settlement and the relay of accepted messages to receivers of the same address; the handler admits connections and links, settles each message and produces messages for receivers.

anthropic

Anthropic Messages API. Rust owns HTTP, validation and Anthropic’s error envelope, the optional API key check, ids, usage estimates, the event stream, count_tokens and the models list; the handler writes every assistant message.

arp

ARP (Address Resolution Protocol) server implementation

bacnet

beanstalkd

Beanstalkd work-queue server — the model is the queue.

bfd

BFD speaker (RFC 5880 Asynchronous mode over UDP: RFC 5881 single-hop, RFC 5883 multihop), in the passive role: a peer that starts sending is a session request for the model; an accepted session is run in Rust (runner.rs) and every state change is the model’s to react to. Deliberately silent: BFD has no refusal, so a peer that is not accepted — or a backend failure — is never answered and its session stays Down.

bgp

BGP-4 server (RFC 4271).

bitcoin

Bitcoin P2P protocol server implementation

bluetooth_ble

Bluetooth Low Energy (BLE) GATT server implementation

bluetooth_ble_battery

Bluetooth Low Energy (BLE) Battery Service implementation

bluetooth_ble_beacon

BLE beacon server (iBeacon / Eddystone).

bluetooth_ble_cycling

BLE Cycling Speed and Cadence Service (0x1816)

bluetooth_ble_data_stream

BLE Data Stream Service (custom GATT for real-time streaming)

bluetooth_ble_environmental

BLE Environmental Service

bluetooth_ble_file_transfer

BLE File Transfer Service

bluetooth_ble_gamepad

BLE Gamepad Service

bluetooth_ble_heart_rate

BLE Heart Rate Service (0x180D)

bluetooth_ble_keyboard

Bluetooth Low Energy (BLE) HID Keyboard implementation

bluetooth_ble_mouse

Bluetooth Low Energy (BLE) HID Mouse implementation

bluetooth_ble_presenter

BLE Presenter Service — a presentation clicker over HID-over-GATT.

bluetooth_ble_proximity

BLE Proximity Service

bluetooth_ble_remote

Bluetooth Low Energy (BLE) Remote Control implementation

bluetooth_ble_running

BLE Running Speed and Cadence Service (0x1814)

bluetooth_ble_thermometer

BLE Health Thermometer Service (0x1809)

bluetooth_ble_weight_scale

BLE Weight Scale Service (0x181D)

bmp

BGP Monitoring Protocol collector (RFC 7854). Rust owns framing, the per-peer header, TLVs and the embedded BGP PDUs; the handler sees each message as JSON and decides whether to keep monitoring the router. A collector never writes to the router.

bolt

Neo4j’s Bolt protocol — the model is the graph database.

bootp

BOOTP server implementation

caldav

CalDAV server: the shared DAV engine in dav_common with CalDAV’s flavor.

can

CAN bus (SocketCAN) server — NetGet as an ECU on somebody’s vehicle bus.

capnp_rpc

Cap’n Proto RPC server. Rust owns the encoding, the RPC tables and every bound; one capability (the bootstrap, typed by the startup schema’s interface) is exported, and the handler answers each call on it with results or an exception.

carddav

CardDAV server: the shared DAV engine in dav_common with CardDAV’s flavor.

cassandra

Cassandra/CQL server implementation using cassandra-protocol

cdp

CDP (Cisco Discovery Protocol) server — NetGet impersonating a Cisco device to its neighbours.

clickhouse

ClickHouse native TCP server. Rust owns the handshake, revision negotiation, packet and block encoding, compression, the INSERT exchange and every bound; the handler answers each query and decides each INSERT’s rows.

coap

CoAP (RFC 7252) server over UDP.

connect_rpc

Native binary protobuf Connect over owned HTTP/1.1 connections.

connection

Connection management

consul

Consul agent HTTP API. Rust owns HTTP, Consul’s JSON shapes, base64 values, the index header and the agent’s own description; the handler answers every KV, catalog and registration request. NetGet stores nothing.

couchdb

CouchDB server implementation

datalink

Data Link layer (Layer 2) server implementation using pcap

dav_common

WebDAV machinery CalDAV and CardDAV share: object parsing (object), XML (xml), the server engine (server), the client engine (client) and the per-protocol actions.

db2

IBM Db2 server implementation (DRDA wire protocol).

dbus

D-Bus server: NetGet as a small message bus that every call terminates at. A client authenticates (SASL EXTERNAL on the Unix socket, checked against the peer’s uid; ANONYMOUS where allowed), may say Hello and request names, and every method call that is not the bus’s own goes to the model, which answers with a return value or an error.

dc

DC (Direct Connect) server implementation

dc_peer

devp2p

Ethereum devp2p node: RLPx over TCP, the base protocol, and eth/68 / eth/69.

dhcp

DHCP server implementation

dhcpv6

DHCPv6 (RFC 8415) server.

diameter

dicom

DICOM DIMSE service provider. Rust owns the upper layer (association negotiation, PDU and PDV framing, release, abort), the DIMSE command sets, the dataset codec, C-ECHO and C-FIND matching; the handler decides associations, stored instances and query records.

dict

DICT (RFC 2229) server — the model is the dictionary.

dnp3

dns

DNS server: UDP and TCP on one port, EDNS0, zone transfers and DNSSEC for one zone.

docker

Docker Engine API server: the read-only core a real docker -H tcp://… CLI needs.

doh

DNS-over-HTTPS (DoH) server implementation

doq

DNS over QUIC. All connection and stream futures are owned by the registered accept task; aborting it drops them and closes the endpoint, with no detached I/O.

dot

DNS-over-TLS (DoT) server implementation

dynamo

DynamoDB-compatible server implementation

eapol

EAPOL / 802.1X authenticator — the switch-port role.

elasticsearch

Elasticsearch/OpenSearch server implementation

epp

EPP registry server (RFC 5730, RFC 5734). Rust owns TLS, framing, the greeting, hello, login/logout and session state; the handler answers every domain, host and contact command.

etcd

etcd v3 server implementation with gRPC KV service

ethernet_ip

fastcgi

FastCGI 1.0 application in the Responder role. Rust owns records, request ids, streams, management records and bounds; the handler owns every response.

finger

Finger (RFC 1288) server.

fix

FIX acceptor. Rust owns framing, the Logon handshake rules, the session layer and its timers; the handler admits each counterparty and answers each application message.

fluent_forward

One-way Fluent Forward collector with bounded stream parsing and owned tasks.

ftp

FTP server implementation

gearman

Gearman job server — the model is the worker for every function.

gelf

One-way GELF collector with bounded stream parsing and owned tasks.

gemini

Gemini server (gemini://, TLS, port 1965) — the model writes the capsule.

git

Git Smart HTTP server implementation

gnmi

Typed, bounded OpenConfig gNMI protocol boundary.

gnutella

gopher

Gopher (RFC 1436) server.

graphite

One-way Carbon plaintext collector with bounded stream parsing and owned tasks.

graphql

GraphQL over HTTP (GraphQL-over-HTTP draft) on hyper. Rust owns request parsing, media-type negotiation, validation against the schema, introspection and execution; the handler owns the data behind every query and mutation.

grpc

gRPC server implementation with dynamic schema support

grpc_web

Separate binary protobuf HTTP/1.1 binding; the HTTP connection owns every RPC worker.

gtp

GTP-C / GTP-U server — a mobile-core node driven by the model.

guacamole

Guacamole protocol server in guacd’s place. Rust runs the handshake, frames every instruction, answers sync and keeps the connection alive; the model accepts or refuses each connection and draws the display it shows, hearing typed lines, special keys, clicks and the client’s clipboard.

h323

H.323: a gatekeeper (H323-Gatekeeper, H.225.0 RAS over UDP 1719) and a called endpoint (H323, H.225.0 call signalling — Q.931 over TPKT — on TCP 1720), plus the codecs the H.323 client (src/client/h323) shares.

hl7

HL7 v2 over MLLP. Rust frames, parses and builds the acknowledgment envelope; the handler decides what each message is acknowledged with.

hls

HLS server (HTTP Live Streaming, RFC 8216).

hsrp

HSRP (Hot Standby Router Protocol) speaker — RFC 2281 for v1, Cisco’s TLV format for v2.

http

HTTP server implementation using hyper

http2

HTTP/2 server implementation built directly on the h2 crate.

http3

Real HTTP/3. The registered endpoint task owns every session and request future.

http_common

Shared HTTP/HTTP2 implementation components

icap

ICAP (RFC 3507) server. Rust owns framing, OPTIONS, preview continuation and response assembly; the handler decides each REQMOD/RESPMOD.

icmp

ICMP (Internet Control Message Protocol) server implementation

ics_support

Shared task ownership and bounded I/O for request/reply device simulators. Wire formats and decisions remain in each protocol’s session implementation.

ident

Ident (RFC 1413) server.

iec104

igmp

IGMP server implementation using raw IP sockets

imap

IMAP server implementation

inetd

The classic inetd services (RFC 862-868) over TCP and UDP, sharing one engine. Rust owns the framing, the clock arithmetic, the chargen pattern and every bound; handlers decide what each request receives. No handler failure ever produces fabricated output.

influxdb

One-request-per-connection HTTP/1.1 InfluxDB endpoint with owned tasks: v2 writes, Flux queries at /api/v2/query, InfluxQL at the v1-compatible /query, and /ping.

ipfix

Receive/parse ownership stays independent of parked common handlers.

ipp

IPP (Internet Printing Protocol) server implementation.

ipsec

IPSec/IKEv2 parse-and-log honeypot

irc

IRC server implementation

isis

IS-IS (Intermediate System to Intermediate System) routing protocol server

jmap

JMAP (RFC 8620, RFC 8621) server. Rust owns the session resource, authentication, request validation and limits, capabilities, accounts, Core/echo, result references and creation ids; the handler is the store and answers every other method call.

jsonrpc

JSON-RPC 2.0 server implementation

kafka

Kafka broker — Rust owns the wire format, the LLM owns the content.

kerberos

Kerberos V5 KDC (RFC 4120): AS and TGS exchanges over UDP and TCP on one port.

knx

KNXnet/IP tunnelling gateway. Rust owns the frames, the tunnels (channels, sequence numbers, heartbeats), acknowledgements, confirmations and the routing of group telegrams between tunnels; the handler is every device on the bus, answering reads and reacting to writes.

kubernetes

Kubernetes API server implementation.

ldap

LDAPv3 server with hand-written ASN.1 BER coding.

libp2p

libp2p host (server role): accepts TCP connections, upgrades them to Noise and yamux, answers identify and ping in Rust, and hands every message on the application protocols’ streams to the model, one connection’s events at a time.

lldp

LLDP (IEEE 802.1AB) server — NetGet as a switch on somebody else’s link.

llmnr

LLMNR (RFC 4795) responder.

lmtp

LMTP (RFC 2033) delivery server. Rust owns the SMTP-style state machine, framing, bounds and the one-reply-per-recipient rule after DATA; handlers decide which recipients exist and what happened to each delivery. Nothing is stored here.

loki

One-request-per-connection HTTP/1.1 push collector with owned tasks.

lpd

LPD (RFC 1179) print server. Rust owns the one-command-per-connection framing, the receive-job subcommands and their acknowledgements, and every bound; handlers decide whether each complete job is queued, what lpq is told and what lprm removed. No spool: nothing received is kept after the handler has seen it.

lwm2m

LwM2M 1.1 server over CoAP/UDP. Rust owns the registration interface (register, update, deregister, lifetime expiry) and turns the handler’s operations into CoAP requests to the device; responses and notifications come back as events.

m3ua

M3UA / SIGTRAN server (RFC 4666) — an SGP that an ASP connects to.

managesieve

ManageSieve (RFC 5804) server. Rust owns the line and literal grammar, capabilities, SASL PLAIN and name checks; the handler decides logins and answers every script command.

matrix

Matrix homeserver, client-server API v3. Rust owns HTTP, the API’s JSON shapes, access tokens, room membership and per-user /sync delivery (hub.rs); the handler decides logins (unless user_passwords is given), room creation, joins and every message, and speaks in rooms as its own user.

maven

Maven repository server implementation using hyper

mcp

MCP (Model Context Protocol) server implementation

mdns

mDNS/DNS-SD server implementation

memcached

Memcached server (text protocol) — the model is the cache.

mercurial

Mercurial HTTP server implementation

milter

Milter (mail filter) server. Rust owns the packets, option negotiation, macros and the collection of headers and body; the handler decides at each SMTP stage and may modify the message at its end.

minecraft

Minecraft Java Edition server: the server-list ping (modern and legacy) and the front of login. Rust owns framing, the handshake, ping/pong and every bound; the handler decides the server-list entry and the reason a joining player is disconnected. No game is run.

modbus

Modbus TCP server.

mongodb

MongoDB server implementation with manual OP_MSG parsing

mqtt

MQTT 3.1.1 and 5.0 broker with LLM-controlled responses

mqtt_sn

MQTT-SN 1.2 gateway over UDP. One task owns every session: datagrams, handler answers, injected commands and a timer arrive on it in turn, so no state is shared. Handler calls run as their own tasks and report back; a client’s later datagrams wait while its call is out.

msgpack_rpc

MessagePack-RPC server. Rust owns the MessagePack codec, the envelope, message ids and every bound; the handler answers each request and may send notifications back.

mssql

MSSQL server implementation using manual TDS protocol

mysql

MySQL server implementation using opensrv-mysql

named_pipe

Named pipe (POSIX FIFO) server implementation.

nats

NATS server implementation.

nbd

Network Block Device server. Rust owns the fixed newstyle handshake, option haggling and transmission; the handler describes each export once per connection and Rust serves every read from that description. Exports are read-only.

ndp

IPv6 Neighbour Discovery (RFC 4861) server — NetGet as a router, or as a neighbour, on somebody else’s link.

netbios_ns

NetBIOS Name Service server (RFC 1001 / RFC 1002).

netconf

NETCONF over SSH (RFC 6241, RFC 6242): russh carries the transport, NetGet owns the netconf subsystem — hello exchange, framing, envelopes, message identity and the capability rules — and a handler decides every RPC’s data and outcome.

netflow_v9

Receive/parse ownership stays independent of parked common handlers.

nfc

NFC (Near Field Communication) virtual tag server.

nfs

NFSv3 server built on nfsserve, with the filesystem supplied entirely by the LLM.

ngap

NGAP (3GPP TS 38.413) — NetGet as an AMF on the 5G N2 interface, which a gNB connects to.

ninep

9P2000 file server. Rust owns the message codec, version negotiation, the fid table, walks (including partial walks and “..”), open modes, directory paging, offsets and every bound; the handler decides what exists, what each directory lists, each file’s content, and whether each change is accepted. Nothing is stored.

nntp

NNTP server implementation

nostr

Nostr relay (NIP-01 over WebSocket, NIP-11 on plain HTTP) — the model is the relay’s policy and its archive.

npm

NPM registry server implementation

nsq

NSQ broker (nsqd’s TCP protocol, V2) — the model decides what is accepted and delivered.

ntp

NTP server implementation

nut

Programmable NUT attachment daemon; application data belongs to event handlers.

oauth2

OAuth2 authorization server implementation

oci_registry

OCI Distribution Specification v1.1 registry server (pull path).

ocpp

OCPP-J central system (CSMS). Rust negotiates the subprotocol, frames every RPC message, correlates ids and enforces one outstanding CALL per direction; the handler decides each answer and any CSMS-initiated call.

ollama

Ollama-compatible API server implementation

onvif

ONVIF device (server role): the Device and Media services over SOAP 1.2 on HTTP/1.1.

opcua

openai

OpenAI-compatible API server implementation

openapi

OpenAPI 3.1 spec-driven HTTP server implementation

openid

OpenID Connect server implementation

openvpn

OpenVPN control-channel server.

ospf

OSPF protocol simulator - LLM-controlled OSPF responses

otlp

OpenTelemetry HTTP/gRPC receiver — the model decides which exports are accepted.

p2p_support

Owned, bounded TCP/TLS sessions for hub and peer simulators. Wire formats and decisions remain in each protocol’s session implementation.

peer_support

Generic adoption helpers for messaging ONE connection of a server.

pfcp

PFCP user plane function (UDP 8805). Rust owns the framing, the association and session tables, heartbeats, the refusals that need no judgement (no association, unknown session, missing F-SEID) and retransmissions; the model decides associations and sessions.

pop3

POP3 server implementation

postgresql

PostgreSQL server implementation using pgwire

prometheus

Prometheus exporter: an HTTP /metrics endpoint whose metrics the model invents.

prometheus_remote_write

Published Remote Write 1.0 float-sample HTTP collector with owned tasks.

proxy

HTTP/HTTPS Proxy server implementation using MITM with LLM control

pty

Pseudo-terminal (PTY) server implementation.

pulsar

Apache Pulsar broker (server role). Rust owns the connection handshake, lookups, producers, subscriptions, flow control, delivery and acknowledgement (broker.rs); the model decides which producers and subscriptions to allow and whether each message is accepted.

pypi

PyPI (Python Package Index) server implementation

quic

QUIC server implementation using Quinn

radius

RADIUS server (RFC 2865 authentication/authorization, RFC 2866 accounting).

radsec

RadSec server (RFC 6614): RADIUS over TLS. TLS and framing live here; every request goes through the RADIUS server’s own decision path, fail-closed rule included.

rawip

Generic raw IP protocol-N server.

rcon

Source RCON server (the same framing Minecraft’s RCON uses). Rust owns framing, ids, splitting, the password check when one is configured, and every bound; handlers answer commands, and logins when no password is configured.

rdap

RDAP over HTTP/1.1: Rust parses and normalizes every RFC 9082 query and enforces the RFC 9083 envelope on every answer; the handler supplies the registration data.

rdp

RDP server — the TPKT + X.224 connection-negotiation slice of [MS-RDPBCGR].

redfish

DMTF Redfish service over HTTP/1.1. Rust serves the service root, the OData documents, the SessionService and the TaskService and owns every envelope rule; the handler owns logins and every other resource.

redis

Redis server implementation with RESP protocol

restconf

RESTCONF (RFC 8040) server. Rust owns discovery, the API root, the YANG library from the declared modules, data-resource paths, query parameters, media types and the error document; the handler is the datastore and answers every data request and operation.

reverse_shell

Reverse-shell listener server.

rip

RIP (Routing Information Protocol) server implementation

rpki_rtr

RPKI-to-Router cache (RFC 8210 version 1, RFC 6810 version 0). Rust owns framing, the session id, timers and version negotiation; the handler owns the VRP data.

rss

RSS (Really Simple Syndication) Feed Server

rsync

rsync daemon (rsync://, TCP 873) at protocol 29. Rust owns the handshake, the file-list encoding and order, the transfer tokens, the checksums and the end-of-run dance; the model says which modules exist, what each requested path holds, and which uploaded files to take (their contents are handed to it, never written to disk).

rtmp

RTMP live server. Rust owns the handshake, chunking, AMF0 commands, the NetConnection and NetStream flow and the live relay from each publisher to its players (sequence headers and metadata cached, players joining at a keyframe, timestamps rebased per player); the handler admits connections, publishers and players and can push AMF0 data messages into a stream.

rtp

RTP server (RFC 3550).

rtsp

RTSP server (RFC 2326).

s3

S3-compatible object storage server implementation

s7comm

saml_idp

SAML Identity Provider (IDP) server implementation

saml_sp

SAML Service Provider (SP) server implementation

scim

SCIM 2.0 service (RFC 7643/7644) over HTTP/1.1. Rust owns discovery, request parsing, filters, PATCH paths, sorting, paging, projection and meta; the handler owns the data.

server_trait

Common trait and utilities for network servers

sflow

Receive/parse ownership stays independent of parked common handlers.

sip

SIP server implementation

smb

SMB/CIFS server implementation

smpp

SMPP 3.4 SMSC. Rust owns PDU framing, the bind state machine, sequence numbers, response status codes, message ids, enquire_link, unbind, delivery receipts and every bound; the handler decides binds (unless credentials are configured) and the fate of each message.

smtp

SMTP server implementation

snmp

SNMP agent implementation using rasn-snmp library

snowflake

Snowflake server implementation

socket_file

Unix domain socket server implementation

socket_helpers

Socket helper utilities for creating sockets with proper options

socketio

Socket.IO v5 over Engine.IO v4. Rust owns sessions, transports (long-polling, WebSocket, upgrade), heartbeats, packet framing, namespaces, acknowledgement ids and rooms; the handler decides connections and what to emit.

socks5

SOCKS5 proxy server implementation with LLM control

soulseek

soulseek_peer

spark

Apache Spark monitoring REST API server.

spice

SPICE server — the remote display protocol of QEMU/KVM, spoken by hand over TCP.

sqs

AWS SQS (Simple Queue Service) compatible server implementation

srt

SRT listener over srt-tokio (ARQ, TSBPD, optional AES). Rust owns the handshake, stream-ID parsing, one publisher per resource and the relay to every reader of it; the handler admits each caller and can push text messages to a reader.

ssdp

SSDP / UPnP discovery server (UPnP Device Architecture 1.1, §1).

sse

Server-sent events server. Each connection carries one HTTP/1.1 request; the model answers it with a stream (kept open, with keep-alive comments) or an ordinary response. Open streams are registered per server for sse_broadcast and as peers for injected events.

ssh

SSH server implementation using russh

ssh_agent

SSH Agent server implementation

statsd

StatsD collector with bounded, sequential batch handling and no reply traffic.

stdio

Standard I/O (stdin/stdout/stderr) server implementation.

stomp

STOMP 1.2 server implementation.

stp

STP / RSTP (IEEE 802.1D-2004 / 802.1w) bridge server.

stratum

Stratum V1 pool (server role). Rust owns each session — subscription, extranonce1, jobs, the share arithmetic and every refusal the arithmetic decides — and asks the model only who may mine and whether a share proven valid is credited.

stratum_v2

Stratum V2 pool (server role). Rust owns each connection — the Noise NX handshake and the certificate it presents, every frame’s encryption and encoding, channels, extranonce prefixes, jobs, the share arithmetic and every refusal that arithmetic decides — and asks the model only whether a device may connect, whether a channel opens and at what difficulty, and whether a share already proven to meet its target is credited.

stun

STUN server implementation

sunrpc

ONC RPC portmapper / rpcbind server on TCP and UDP (the same port). Rust decodes every call and answers the RPC-level errors, NULL and GETTIME; the model answers lookups and dumps with mappings and decides registrations.

svn

SVN (Subversion) server implementation

syslog

Syslog server implementation using syslog_loose library

tacacs

tcp

TCP server implementation

telnet

Telnet server implementation

tftp

TFTP server implementation

thrift

Apache Thrift RPC server for a service declared in IDL. Rust owns the transport (framed or unframed, detected per connection), the protocol (binary or compact, detected per message), method lookup, argument decoding and result encoding by IDL type; the handler answers calls.

tls

TLS server implementation

tls_cert_manager

TLS certificate management for DoT and DoH servers

tor_relay

Tor Relay (OR protocol) server - partial, not interoperable with real Tor.

torrent_dht

BitTorrent DHT server implementation

torrent_peer

BitTorrent Peer Wire Protocol server implementation

torrent_tracker

BitTorrent Tracker server implementation

tr069

TR-069 ACS (server role). A CWMP session is a run of HTTP POSTs from the device bound by a cookie: Inform, then empty posts and RPC responses, each answered with the next queued RPC or with 204 to end it. Rust owns sessions and envelopes; the model fills the queue.

tuntap

TUN/TAP interface endpoint.

turn

TURN relay server (RFC 8656)

udp

UDP server implementation for raw UDP stack

usb

USB protocol implementations

vault

HashiCorp Vault server, KV version 2: what vault status and vault kv get/put/list/ metadata get need.

vnc

VNC (Virtual Network Computing) server — RFB 3.8 (RFC 6143) over TCP.

vrrp

VRRP (v2/v3) and CARP server — IP protocol 112, multicast 224.0.0.18.

vxlan

VXLAN / Geneve / GRE (gretap, in UDP) tunnel endpoint: decapsulates what other tunnel endpoints send, and the model plays the hosts on the overlay — ARP, ping and UDP — with replies built in Rust and sent back through the tunnel. Deliberately silent: an overlay IP with no host never answers, and a backend failure reads the same way.

wamp

WAMP v2 router, basic profile, JSON over WebSocket. Rust owns the transport, message validation, realms, sessions, subscriptions, registrations and every routed call and event; the handler admits sessions and answers calls to procedures no session has registered.

webdav

WebDAV server (RFC 4918) with an LLM-supplied virtual filesystem.

webrtc

WebRTC server: real peer connections carrying data channels only (no media).

webrtc_signaling

WebRTC Signaling Server - WebSocket-based SDP relay for WebRTC connections

websocket

WebSocket (RFC 6455) server with LLM-controlled frames.

webtransport

WebTransport over HTTP/3 on the vendored wtransport. The registered endpoint task owns every session; each session asks the handler whether to admit it, then runs session::Session.

whois

WHOIS (RFC 3912) server.

wireguard

WireGuard VPN server implementation with LLM control

wol

Wake-on-LAN magic packet listener.

wsdiscovery

WS-Discovery target service: answers Probe and Resolve on UDP 3702, multicast and directed. The model decides which of its services match; matches go back unicast to the asker, and Hello/Bye announcements go to the group. Deliberately silent: WS-Discovery has no negative reply, so a probe the model does not answer — or a backend failure — sends nothing, and the log says which it was.

xmlrpc

XML-RPC server implementation

xmpp

XMPP server implementation

yarn

Hadoop YARN ResourceManager REST API server.

zabbix

Zabbix trapper — the protocol zabbix_sender speaks to a Zabbix server on port 10051.

zenoh

Zenoh router or peer over the zenoh runtime. Rust declares the subscribers and queryables from the startup parameters, hands each sample and query to the handler and runs its actions on the session; the link list becomes the connection list.

zeromq

ZeroMQ server socket (REP, ROUTER or PULL) speaking ZMTP 3.1 with the NULL mechanism. Rust owns the greeting, READY, the compatibility check, framing, envelopes, heartbeats and every bound; the handler writes the reply to each message.

zipkin

Zipkin collector and read API over HTTP/1.1. Rust owns HTTP, gzip, span validation and every bound; the handler decides whether a report is accepted and answers every query. NetGet stores no spans.

zookeeper

ZooKeeper server implementation.