Lib.rs

rusoto_core

AWS SDK for Rust - Core

actix-rt

Actix runtime

trust-dns-resolver

Trust-DNS is a safe and secure DNS library. This Resolver library uses the Client library to perform all DNS queries. The Resolver is intended to be a high-level library for any DNS…

tonic

A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility

zmq

High-level bindings to the zeromq library

httparse

A tiny, safe, speedy, zero-copy HTTP/1.x parser

ipnet

Provides types and useful methods for working with IPv4 and IPv6 network addresses, commonly called IP prefixes. The new IpNet, Ipv4Net, and Ipv6Net types build on the existing IpAddr…

nats

A Rust NATS client

tarpc

An RPC framework for Rust with a focus on ease of use

pnet

Cross-platform, low level networking using the Rust programming language

pulsar

Rust client for Apache Pulsar

rust-s3

Tiny Rust library for working with Amazon S3 and compatible object storage APIs

mles

Mles - a distributed publish/subscribe data server

grpcio-compiler

gRPC compiler for grpcio

rusoto_s3

AWS SDK for Rust - Amazon Simple Storage Service @ 2006-03-01

backoff

Retry operations with exponential backoff policy

etherparse

A library for parsing & writing a bunch of packet based protocols (EthernetII, IPv4, IPv6, UDP, TCP …)

irc

the irc crate – usable, async IRC for Rust

capnp-rpc

implementation of the Cap’n Proto remote procedure call protocol

dns-lookup

A simple dns resolving api, much like rust’s unstable api. Also includes getaddrinfo and getnameinfo wrappers for libc variants.

pnet_base

Fundamental base types and code used by pnet

libp2p

Peer-to-peer networking library

yamux

Multiplexer over reliable, ordered connections

ipnetwork

A library to work with IP CIDRs in Rust

quinn

QUIC transport protocol implementation for Tokio

doh-proxy

A DNS-over-HTTPS (DoH) proxy

findomain

The fastest and cross-platform subdomain enumerator, do not waste your time

async-trait

Type erasure for async trait methods

quiche

🥧 Savoury implementation of the QUIC transport protocol and HTTP/3

raptorq

RaptorQ (RFC6330)

eui48

A library to generate and parse IEEE EUI-48 and EUI-64, also known as MAC-48 media access control addresses. The IEEE claims trademarks on the names EUI-48 and EUI-64, in which EUI is an…

webrtc-sdp

This create parses strings in the format of the Session Description Protocol according to RFC4566. It specifically supports the subset of features required to support WebRTC according to the JSEP draft.

shadowsocks-rust

shadowsocks is a fast tunnel proxy that helps you bypass firewalls

tentacle

Minimal implementation for a multiplexed p2p network framework

actix-connect

TCP connector service for Actix ecosystem

schannel

Schannel bindings for rust, allowing SSL/TLS (e.g. https) without openssl

smoltcp

A TCP/IP stack designed for bare-metal, real-time systems without a heap

prometheus_wireguard_exporter

Prometheus WireGuard Exporter

ether-dream

A full implementation of the Ether Dream Laster DAC protocol

zenoh-protocol

Zenoh: Zero Overhead Pub/sub, Store/Query and Compute

quic-p2p

Peer-to-peer networking library using QUIC

google-dns1

A complete library to interact with dns (protocol v1)

ipconfig

Get network adapters information and network configuration for windows

twitchchat

interface to the irc-side of twitch’s chat system

protocol

Easy protocol definitions

tonic-build

Codegen module of tonic gRPC implementation

tun

TUN device creation and handling

libunftp

Safe, fast and extensible FTP(S) server library for Rust

protobuf

Rust implementation of Google protocol buffers

openldap

Straightforward Rust bindings to the C openldap library. This is a fork of cldap that has been methodically fixed, extended, and made to be more compliant with openldap. It should be…

azure_sdk_storage_blob

Rust wrappers around Microsoft Azure REST APIs - Blob storage crate

nanomsg

A high-level, Rust idiomatic wrapper around nanomsg

netstat2

Cross-platform library to retrieve network sockets information

amq-protocol-types

AMQP specifications - types

mdns

A multicast DNS client library. Supports discovery of any mDNS device on a LAN

grpcio

The rust language implementation of gRPC, base on the gRPC c core library

actix-router

Resource path matching library

tower-limit

Limit maximum request rate to a Service

rusp

The Rust USP toolkit

async-net

Async networking primitives for TCP/UDP/Unix communication

cidr

IP network and IP host within network types

imap-proto

IMAP protocol parser and data structures

sentry-actix

Sentry client extension for actix-web 0.7

oxygengine-network

Network module for Oxygen Engine

nng

A safe wrapper for NNG (Nanomsg v2)

rpki

A library for validating and creating RPKI data

trust-dns-proto

Trust-DNS is a safe and secure DNS library. This is the foundational DNS protocol library for all Trust-DNS projects.

varlink

Client and server support for the varlink protocol

igd

Internet Gateway Protocol client

quinn-proto

State machine for the QUIC transport protocol

tls-api

TLS API without implementation

rusoto_logs

AWS SDK for Rust - Amazon CloudWatch Logs @ 2014-03-28

google-youtube3-cli

A complete library to interact with YouTube (protocol v3)

iovec

Portable buffer type for scatter/gather I/O operations

state

A library for safe and effortless global and thread-local state management

runng-sys

Bindings to NNG (Nanomsg-Next-Generation) aka Nanomsg2

bgp-rs

A library for parsing Border Gateway Protocol (BGP) formatted streams

netaddr2

A Rust network address parsing and arithmetic library

nordselect

Select the ideal NordVPN server

new-tokio-smtp

extendible smtp implementation for tokio

paho-mqtt

The Official Eclipse Paho MQTT Rust Client Library. This is a wrapper around the Paho C library

solicit

A library implementation of HTTP/2

mbus-api

A RESTful HTTP API exposing (wired) M-Bus functionality

pcarp

A pure-Rust library for reading pcap-ng files

rustls-native-certs

rustls-native-certs allows rustls to use the platform native certificate store

qlog

qlog data model for QUIC and HTTP/3

beanstalkc

Yet another simple Beanstalkd client for Rust

encrypted-dns

A modern encrypted DNS server (DNSCrypt v2, Anonymized DNSCrypt, DoH)

async_ftp

FTP client for Rust

iprange

A library to manage IP ranges

fibers_rpc

RPC library built on top of fibers crate

remote-trait-object

A remote method invocation library based on trait objects

openssh-keys

read and write OpenSSH public keys

queen

message queue

hap

Rust implementation of the Apple HomeKit Accessory Protocol (HAP)

aster-proxy

A light, fast and powerful cache proxy written in Rust

tokio-socks

Asynchronous SOCKS proxy support for Rust

webdriver

Library implementing the wire protocol for the W3C WebDriver specification

packet_crafter

Simple tools for creating / parsing / manipulating data packets. Calculates checsums and length fields where possible.

zipkin

A library for collecting timing information about distributed computations

bitstream-io

Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats

libp2p-swarm

The libp2p swarm

actyxos_sdk

Tools for interacting with the services of an ActyxOS node

grpcio-proto

Public proto files for grpcio

nano-get

A very tiny implementation of HTTP(s) GET, using minimal dependencies

librsync

Bindings to librsync for calculating and applying network deltas exposed as Reader/Writer streams

alexa_sdk

Implements Request/Response for Amazon Alexa skills

rsntp

An RFC 4330 compliant Simple Network Time Protocol (SNTP) client library for Rust

telegram-bot-raw

Telegram Bot API types

ttrpc

A Rust version of ttrpc

prost-build

A Protocol Buffers implementation for the Rust Language

osshkeys

A library to read and write OpenSSH public and private keys

mqttrs

Mqtt protocol encoding and decoding

coap

A CoAP library

url-bot-rs

Minimal IRC URL bot in Rust

multibase

multibase in rust

ssh2

Bindings to libssh2 for interacting with SSH servers and executing remote commands, forwarding local ports, etc

ftp

FTP client for Rust

natsclient

NATS client designed for both an ergonomic API and performance

ldap3

Pure-Rust LDAPv3 Client

gpsd_proto

The gpsd_proto module contains types and functions to connect to gpsd to get GPS coordinates and satellite information

lambda_runtime

Rust runtime for AWS Lambda

io-uring

The io_uring library for Rust

poldercast

Peer to Peer topology management

libsip

SIP protocol Implementation, with a focus towords softphone clients

async-listen

Various helpers for writing production-ready servers in rust using async-std

oping

Rust bindings for liboping, a simple ICMP ping library

pnet_macros_support

Support library for libpnet_macros

c-ares

A Rust wrapper for the c-ares library, for asynchronous DNS requests

networking

secure RSA + AES network implementations in a peer to peer enabled manner

ipp

Asynchronous IPP print protocol implementation

astro-dnssd

Simple & safe DNS-SD wrapper

input_buffer

A peekable FIFO-like buffer for receiving network data efficiently

zenoh-router

Zenoh: Zero Overhead Pub/sub, Store/Query and Compute

get-port

Get an available port

abci-rs

A Rust crate for creating ABCI applications

secded

Single Error Correction, Double Error Detection Codes for Everyone

faktory

API bindings for the language-agnostic Faktory work server

rdkafka-sys

Native bindings to the librdkafka library

wifiscanner

List WiFi hotspots in your area

tcp-stream

mio’s TcpStream on steroids

agate

Very simple server for the Gemini hypertext protocol

actix-threadpool

Actix thread pool for sync code

bolt-proto

Bolt protocol primitives: values, messages, and serialization / deserialization

ip_network

IPv4 and IPv6 network structs

rcon

An rcon protocol implementation

protobuf-codegen

Code generator for rust-protobuf. Includes a library and protoc-gen-rust binary. See protoc-rust and protobuf-codegen-pure crates

kf-protocol

Native Rust implementation of kafka protocol

mles-client

Mles-client, a distributed data protocol example (chat) client/ws-proxy

irc-proto

The IRC protocol distilled

lib3h

The lib3h p2p communication rust library

ssdp-client

An asynchronous library for discovering, notifying and subscribing to devices and services on a network

aquatic

Blazingly fast, multi-threaded BitTorrent tracker (UDP, HTTP, WebTorrent)

packet-builder

High-level library for interacting with low-level network data

openssh

SSH through OpenSSH

libstrophe

Rust ergonomic wrapper for libstrophe

dachshund

Dachshund is a graph mining library written in Rust. It provides high performance data structures for multiple kinds of graphs, from simple undirected graphs to typed hypergraphs. Dachshund…

ieee802154

Partial implementation of the IEEE 802.15.4 standard for low-rate wireless personal area networks

fast-socks5

Fast SOCKS5 client/server implementation written in Rust async/.await (with async-std)

geoip-rs

geoip-rs provides geographical information about the calling or the specified IP address

sntp_request

Tiny Rust library to request timestamp from NTP servers trough SNTP protocol

i3_ipc

For communicating with i3 over it’s IPC interface synchronously

mac_address

Cross-platform retrieval of a network interface MAC address

ellidri

Your kawaii IRC server

ccsds_primary_header

Implementation of the CCSDS Primary Header for space applications

pdu

Small, fast, and correct L2/L3/L4 packet parser

shorty

shorty is a library for assigning short IDs to long URL, and store them on redis

knx_examples_rs

Examples for KNX Library

wmata

wmata is a high level Rust interface to the Washington Metropolitan Area Transit Authority (WMATA) API

no-std-net

Rust’s std::net… without the ‘std’.

kipa

Distributed Key to IP Address (KIPA) query network

phroxy

phroxy proxies gopher through HTTP

google-androidenterprise1-cli

A complete library to interact with Android Enterprise (protocol v1)

enocean

EnOcean serial protocol implementation

domain

A DNS library for Rust

packet

Network packet handling

ece

Encrypted Content-Encoding for HTTP Rust implementation

zmq-sys

Low-level bindings to the zeromq library

port_check

Get a free local port or check if a port somewhere is reachable

pcap

A packet capture API around pcap/wpcap

telnet

A simple implementation of telnet protocol

sc-network-gossip

Gossiping for the Substrate network protocol

what

Display current network utilization by process, connection and remote IP/hostname

telebot

A wrapper around the telegram bot api, powered by futures

rpcx

A rpc/microservice framework

oxygengine-network-backend-desktop

Network Desktop backend module for Oxygen Engine

beanstalkd

Easy-to-use beanstalkd client for Rust (IronMQ compatible)

keyphrase

KeyPhrase generation for the EARTH Network

secreteriat

A Discord bot for managing the Langford Discord guild

nng-sys

Bindings to NNG (Nanomsg-Next-Generation) aka Nanomsg2

tiny

An IRC client

jid

A crate which provides a Jid struct for Jabber IDs

memcached-rs

A MemCached Library in Rust

fiscalidade

Biblioteca Rust para geração, validação, assinatura de XMLs de Documentos Fiscais e transmissão com webservices da SEFAZ

tarpc-plugins

Proc macros for tarpc

ncgopher

An ncurses gopher and gemini client for the modern internet

savon

SOAP async HTTP client generator

rabbit_borough

Create a RabbitMQ consumer project with minimal effort, by bypassing templating, configuration and complicated resiliency logic

vpncloud

Peer-to-peer VPN

capsule

A framework for network function development. Written in Rust, inspired by NetBricks and built on Intel’s Data Plane Development Kit.

resolv

DNS resolution via glibc

nfq

Rust library for dealing with NetFilter queue

libtor-sys

Rust crate that internally compiles Tor and its dependencies

poston

Yet another Fluentd logger for Rust

aws-build

Build Rust crates for deployment to AWS EC2 or AWS Lambda

async-tftp

Executor agnostic async TFTP implementation

zenscan

This program is port scanner to target server

opcua-certificate-creator

OPC UA certificate creator

aws-sdk-rust

Important Enhancements: Supports V2 and V4 API Signatures for third party S3 compliant products like Ceph Works from behind proxies Returned data can be in Rust structs, JSON or XML…

autodiscover-rs

autodiscover-rs implements a simple algorithm to detect peers on an IP network, connects to them, and calls back with the connected stream. The algorthm supports both UDP broadcast and multicasting.

ion-binary-rs

Pure Rust binary parser for Amazon’s Ion. It helps to communicate with products like QLDB.

rusoto_sts

AWS SDK for Rust - AWS Security Token Service @ 2011-06-15

ethox

A standalone network stack for user-space networking and unikernels

nb-connect

Non-blocking TCP or Unix connect

lrpc

local rpc

netidx

Cross platform secure messaging framework, “like DNS for values”

suricata-ipc

Library for sending packets to suricata and receiving output

rodbus

A high-performance implementation of the Modbus protocol using Tokio and async/await

nbd

Rust library for NBD (network block device) servers and clients

bevy_prototype_networking_laminar

This is a prototype of a networking crate for bevy. This create provides a low-level networking plugin built on top of laminar.

rustcord

A safe wrapper around the Discord Rich Presence API

utp

A µTP (Micro/uTorrent Transport Library) library implemented in Rust

treebitmap

Fast IPv4/IPv6 lookup trie

xmpp-parsers

Collection of parsers and serialisers for XMPP extensions

koibumi

An experimental Bitmessage client

udp_netmsg

A low cost abstraction for sending and receiving udp datagrams. Gives ability to send and receive datagrams defined by custom structs in a simple way

fractal-matrix-api

Library to communicate with a Matrix.org server

amq-protocol

AMQP specifications

libipld-core

Base traits and definitions used by ipld codecs

dockworker

Docker daemon API client. (a fork of Faraday’s boondock)

nearby

Scans all nearby wifi networks and the devices connected to each network

enet

High-level, rust-y bindings to the ENet library

xmlrpc

An XML-RPC implementation for Rust

hdlc

Rust implementation of HDLC with support of the IEEE standard

twilio-async

An async and ergonomic wrapper around Twilio API & TwiML

jsonrpc

Rust support for the JSON-RPC 2.0 protocol

prost-types

A Protocol Buffers implementation for the Rust Language

oci-distribution

An OCI implementation in Rust

libtelnet-rs

libtelnet-inspired telnet parser for rust

buffering

A library primarily designed for network packet buffer operations

actori-router

Path router

unimap

Scan only once by IP address and reduce scan times with Nmap for large amounts of data

matrix_bot_api

API for writing a bot for the Matrix messaging protocol

rqpush

A library to assist with pushing notifications to RQueue

brokaw

📰 An NNTP client liberary. More at 11! 📰

pnet_transport

Cross-platform, transport layer networking

svc-agent

An agent library

service_world

Discover services from Hasicorp’s consul

golem-rpc-api

Typesafe binding for Brass Golem RPC services

oui

Lookup MAC OUI vendor information from the Wireshark manufacturer database

dlt_parse

A library for parsing the “Diagnostic Log and Trace” network protocol (currently without payload interpretation)

amiquip

Pure Rust RabbitMQ client

natpmp

NAT-PMP client library

srvrls

A lightweight, opinionated serverless framework reducing boilerplate

prosafe_exporter

Prometheus exporter for NETGEAR switches supported by ProSAFE Plus utility

figma-asset-downloader

Small utility to help you download Figma assets directly to your computer

trust-dns-client

Trust-DNS is a safe and secure DNS library. This is the Client library with DNSec support. DNSSec with NSEC validation for negative records, is complete. The client supports dynamic…

rust-doh-proxy

Rust DNS over HTTPS proxy application

av-stream-info-rust

Analyze a http/https internet address and display information if an audio or video stream has been found. All information is extracted from metainformation.

async-dnssd

Asynchronous wrapper for DNS-SD C libraries

multicast-socket

Single-socket multi-interface multicast socket

safe-nd

Safe Network Data Types

psocket

the socket for Rust

ssb-packetstream

Secure Scuttlebutt packet stream protocol

gatekeeper

A SOCKS proxy implementation

lavish-compiler

Compiler for the Lavish IDL

cannyls_rpc

RPC library for operating cannyls’s devices from remote nodes

no_proto

Faster than JSON with Schemas and Native Types. Like Mutable Protocol Buffers with Compile Free Schemas.

async-port-scanner

Simple, yet fast, async port scanner library for Rust

winping

An easy-to-use ICMP Echo API for Windows programs without requiring elevated rights

ds

A library for controlling FIRST Robotics Competition robots

smolapps

A collection of application-layer protocols built on top of smoltcp

net-parser-rs

Basic network parser leveraging Rust and nom for safe and efficient packet parsing. Design influenced by pktparse-rs.

wifi-rs

Interface with and manage Wireless Network (WiFi)

bincode-no-std

A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!

evm-network-classic

Ethereum Classic patches for SputnikVM. Deprecated and will be dropped in future releases: use evm-network instead

nannou_osc

The OSC API for Nannou, the creative coding framework

artillery-core

Fire-forged cluster management & Distributed data protocol

postgres-inet

CIDR/INET support for rust-postgres

manuf

Ethernet vendor codes, and well-known MAC addresses

bytefmt

an utility to parse byte string into bytes count and vice versa

tcp-warp-cli

A userspace tunnel between two hosts mapping ports on client machine to addresses reachable from server machine

readwrite

Combine Read and Write into a single Read+Write object

dtn7-plus

Additional helpers for rust dtn daemon

bytebuffer-rs

A bytebuffer for networking and binary protocols

mpd_protocol

Implementation of MPD client protocol

coldsnap

A library and command-line interface for uploading and downloading Amazon EBS snapshots

temp_utp

A µTP (Micro/uTorrent Transport Library) library implemented in Rust

upnp-daemon

A daemon for continuously opening ports via UPnP

bip_peer

Communication with bittorrent peers via peer wire protocol

runng

High-level wrapper around nng (Nanomsg-Next-Generation) aka Nanomsg2

brpc-protoc-plugin

Protobuf-compiler plugin for brpc-rs

tls-api-stub

TLS API implementation that returns error on any operation

joyent-tokio-zookeeper

Asynchronous client library for interacting with Apache ZooKeeper

onc-rpc

Open Network Computing / Sun RPC types and fast serialisation

httpbis

Rust implementation of HTTP/2 protocol

wayk_proto

WaykNow packet encoder-decoder and sequencing utilities

libp2p-core

Core traits and structs of libp2p

multicast_dns

Simple Rust wrapper around Avahi Daemon

td_proto_rust

bin protocol for Rust

ftp-client

A FTP client library

hassium-network-backend-web

Network Web backend module for Hassium home automation engine

erpc-rs

eRPC library for Rust

aurpc

Asynchronous UDP RPCs

potatonet

PotatoNet is a lightweight microservices framework

adventure

Helps your great adventure for the various type of requests

blip

A crate for writing fast and highly resilient in-process gRPC service meshes

bmp-client

Tokio-based BMP client

pcap_on_demand

A packet capture API around pcap/wpcap that loads pcap/wpcap on demand

nearprotocol/near-network

Reference client for NEAR Protocol

bolt-proto-derive

Procedural macros for bolt-proto

joystream/joystream-node-runtime

Joystream monorepo

proxy_cfg

A library to get proxy configuration from the OS

rtable

Generic Routing Table Library with Radix Tree

middleman

A wrapper for a mio::TcpStream to send and receive serializable Structs (blocking or non blocking) of arbitrary size

timeout_io

This library provides a simple timeout-based API for IO-operations

bee-signing

IOTA signing primitives

rmonitor

A simple, Tokio-compatible protocol decoder for RMonitor, a line based timing protocol supported by different vendors of sport timing software

amqp

AMQP/RabbitMQ protocol client

rumq-core

Serializes and deserializes mqtt byte stream

saltyrtc-client

Asynchronous SaltyRTC client implementation for Rust 1.26+

protoc-rust

protoc –rust_out=… available as API. protoc needs to be in $PATH, protoc-gen-run does not.

lambda_runtime_client

Client SDK for AWS Lambda’s runtime APIs

blather

Helper objects for a talkative line-based protocol

pubnub-hyper

PubNub async crate based on Tokio and Hyper

third-wheel

third-wheel is a TLS man-in-the-middle proxy written in rust, with the aim of being lightweight and fast. It is currently in pre-alpha stage.

mbus

An HTTP microservice exposing M-Bus Functionality

aws-region

Tiny Rust library for working with Amazon AWS regions, supports s3 crate

naia-server

A server that uses either UDP or WebRTC communication to send/receive events to/from connected clients, and syncs registered entities to clients to whom those entities are in-scope

lib3h_protocol

Protocol definition for interacting with Lib3h

tower-util

Utilities for working with Service

sdp-types

SDP (RFC 4566) types, parser and serializer

quick_crawler

QuickCrawler is a Rust crate that provides a completely async, declarative web crawler with domain-specific request rate-limiting built-in

pad-motion

Implementation of Cemuhook gamepad motion protocol. Includes client and server implementations.

requiem-router

Path router

azure_sdk_for_rust

Rust wrappers around Microsoft Azure REST APIs

fibers_transport

Transport layer abstraction built on top of [fibers] crate

async-mpd

Async Mpd client library

grpcio-sys

FFI bindings to gRPC c core library

google-admin1_directory-cli

A complete library to interact with directory (protocol directory_v1)

amy

Polling and Registration abstractions around kqueue and epoll for multithreaded async network programming

zenoh-util

Zenoh: Zero Overhead Pub/sub, Store/Query and Compute

dementia

A small client library for the Matrix protocol

varlink_generator

Rust code generator for the varlink protocol

paho-mqtt-sys

Rust wrapper for the Paho MQTT C Client Library. This is part of the official Eclipse Paho Rust Client Library

amp-async

Implementation of the AMP remoting protocol

network

did_doc

Library for loading/saving DID documents

bacnet_parse

no_std BACnet parser

installer

this crate serves as the installer for the artifice network, however it can also be used as a simple task scheduler

rupnp

An asynchronous library for finding UPnP control points, performing actions on them and reading their service descriptions

tftp_server

A TFTP server implementation in Rust using mio

cueball-dns-resolver

This is a rust implementation of Joyent’s node-cueball DNS resolver

afxdp

AF XDP for Rust

ax25

Utilities for Packet Radio in Rust. AX.25 encoding/decoding and radio interfacing.

iptools

Python iptools port for Rust

sacn

Rust sACN implementation

s3-ext

Simple Storage Service Extensions for Rust

ironrdp

A Rust implementation of the Microsoft Remote Desktop Protocol

lib3h_p2p_protocol

Lib3h Protocol definition for inter-node p2p communication

subspace

A convenience crate for IPC, using TcpStreams

kf-protocol-transport

Transport frame encoder and decoder for Kakfa protocol

simple-message-channels

Simple binary protocol with a channel, type, message scheme

transmission-rpc

Transmission JRPC client

milstian-internet-framework

My first experiment with a lightweight and dynamic internet application framework in Rust

srtp2-sys

Binding for libsrtp

simpletcp

Crate for simple and secure tcp communication

bubblebabble

The Bubble Babble Binary Data Encoding

rust_ofp

Rust OpenFlow 0x01 Protocol and Controller Framework

libslirp-sys

FFI bindings for libslirp

ifinfo

Simple ifconfig placed on Rust

cord-client

The client-side user interfaces for the Cord Platform that publish and subscribe messages to the Broker

uniui_core

Basic structures like Signal and Slot for uniui_* crates familiy

sozu-command-lib

configuration library to command a sozu instance

ezmsg

Simple buffer with a topic and parameters

azure-sdk-keyvault

Rust wrapper around Microsoft Azure REST APIs for Azure Key Vault

secretbox

Rust implementation of the secretbox encryption algorithm

minion

Crate for managing cancellable services

async-fsw

Cross-platform asynchronous filesystem notification library for Rust

snmp_mp

SNMPv3 Message Processing

prost-amino-derive

A Protocol Buffers implementation for the Rust Language modified to enable amino (de)serialization

homie-device

A library for creating devices implementing the Homie convention for MQTT

multisock

Unified types for TCP & Unix sockets

tun-tap

TUN/TAP interface wrapper

rustls-connector

Connector similar to openssl or native-tls for rustls

ssdp

An asynchronous abstraction for discovering devices and services on a network

rpc-perf

RPC Performance Testing

file_transfer

Enum to transfer files

tentacle-ping

ping protocol implementation for tentacle

acute_core

core sub-crate of acute

http_header

A simple, dependency-less HTTP-header builder and parser

hwaddr

MAC address handling

mesalock-linux/mesalink

MesaLink is a memory-safe and OpenSSL-compatible TLS library based on Rustls and Ring

i2cbus-api

HTTP RESTful API and skeleton server/client implement for I2C bus control

catalyst-protocol-sdk-rust

Protocol Specification for Catalyst Network

stripe-rust

API bindings for the Stripe HTTP API

async-ssh2

Async wrapper over ssh2

message_protocol

A protocol for seperating binary messages over TCP, similar to WebSockets but more minimal

rusty_tarantool

Tarantul async client based on tokio framework

sntp

A Simple Network Time Protocol (SNTP) client implementation using smoltcp

rtorrent_xml_rpc

A crate to send XML RPC to rtorrent

datachannel-sys

Native bindings to libdatachannel

oxygengine-network-backend-web

Network Web backend module for Oxygen Engine

splits-io-api

Bindings to the Splits.io API for Rust

anysocket

Socket types that can be either Tcp or Unix Domain

actori-server

Actori server - General purpose tcp server

actix-lua

A safe scripting environment for actix with the Lua Programming Language

tockloader-proto

A #[no_std] implementation of the protocol used by tockloader and the TockOS bootloader

net-utils

Network utility library which provides client connection pool for TCP/SSL connctions

libstrophe-sys-bindgen

Rust bindings for libstrophe, generated using bindgen

minirpc

A minimalist RPC framework

tari_comms_dht

Tari comms DHT module

condure

HTTP/WebSocket connection manager

rust-thrift-tls

Client and Server TLS support for Apache Thrift

my_internet_ip

Retrieve the public IP of the machine your app runs on

librsyncr

librsyncr is a Rust library to calculate and apply deltas between two files without having access to both files on the same system

netinfo-ffi

C FFI for netinfo, which groups network usage by process

telnetify

A tool for local development of TELNET applications

drogue-esp8266

Networking stack for ESP8266 Wifi offload board

nt-network

Networking types and codecs for nt-rs

capsule-macros

Capsule procedural macros

parsec

Implementation of Protocol for Asynchronous, Reliable, Secure and Efficient Consensus

dnscat-client

Standalone DNSCAT2 client

rdp-rs

A Pure RUST imlementation of Remote Desktop Protocol

streams-rs

OCaml like streams for Russt

amq-protocol-codegen

AMQP specifications - codegen

opcua-core

Core components for OPC UA used by client and server

tile_net

Continuous tile-based collision detection and resolution

greetd_ipc

An implementation of the greetd IPC protocol

nispor

Unified interface for Linux network state querying

robust-arduino-serial

Simple and robust serial communication protocol

kinetic-rust

A Kinetic protocol library written in Rust

woopsa

A pure Rust library for Woopsa

mobc-lapin

RabbitMQ support for the async mobc connection pool

ntpd

Simple NTP server and client

ipv6_rs

网上分享的 ipv6 地址库解析

easyfibers

easyfibers is a closure-less couroutine library for executing asynchronous tasks as painlessly as possible

discord-rpc-client

A Rust client for Discord RPC

rusty-p4

A (WIP) library for writing P4 controller in Rust

discv5

Implementation of the p2p discv5 discovery protocol

sandstorm

Sandstorm Cap’n Proto interfaces

netflow_v9

Library for parsing Netflow-v9 packets

ntp

Library for parsing and communicating over Network Time Protocol

thrussh

A client and server SSH library

pf

transfer file command line tool

stegos_consensus

Stegos - Consensus Implementation

tailscale

A set of application-level primitives for Tailscale

tap-windows

tap-windows driver interface

aquatic_http_protocol

HTTP BitTorrent tracker protocol

lrpc-macros

lrpc’s proc macros

fhttp-core

core library for the fhttp tool

tls-client_hello-parser

TLS ClientHello parser

xmpp-addr

An implementation of the XMPP Address format (Jabber ID) defined in RFC 7622

actix_web_metrics_mw

Actix middleware library for metrics