SYMBOL INDEX (302 symbols across 20 files)

FILE: build.rs
  function main (line 4) | fn main() -> Result<()> {

FILE: src/cli.rs
  type KeypairType (line 5) | pub enum KeypairType {
  type Cli (line 47) | pub struct Cli {

FILE: src/client.rs
  function run_client (line 34) | pub async fn run_client(
  type ServiceDigest (line 80) | type ServiceDigest = protocol::Digest;
  type Nonce (line 81) | type Nonce = protocol::Digest;
  type Client (line 84) | struct Client<T: Transport> {
  function from (line 92) | async fn from(config: ClientConfig) -> Result<Client<T>> {
  function run (line 103) | async fn run(
  function handle_hot_reload (line 147) | async fn handle_hot_reload(&mut self, e: ConfigChange) {
  type RunDataChannelArgs (line 169) | struct RunDataChannelArgs<T: Transport> {
  function do_data_channel_handshake (line 177) | async fn do_data_channel_handshake<T: Transport>(
  function run_data_channel (line 214) | async fn run_data_channel<T: Transport>(args: Arc<RunDataChannelArgs<T>>...
  function run_data_channel_for_tcp (line 238) | async fn run_data_channel_for_tcp<T: Transport>(
  type UdpPortMap (line 255) | type UdpPortMap = Arc<RwLock<HashMap<SocketAddr, mpsc::Sender<Bytes>>>>;
  function run_data_channel_for_udp (line 258) | async fn run_data_channel_for_udp<T: Transport>(conn: T::Stream, local_a...
  function run_udp_forwarder (line 336) | async fn run_udp_forwarder(
  type ControlChannel (line 388) | struct ControlChannel<T: Transport> {
  type ControlChannelHandle (line 399) | struct ControlChannelHandle {
    method new (line 499) | fn new<T: 'static + Transport>(
    method shutdown (line 556) | fn shutdown(self) {
  function run (line 405) | async fn run(&mut self) -> Result<()> {

FILE: src/config.rs
  constant DEFAULT_HEARTBEAT_INTERVAL_SECS (line 13) | const DEFAULT_HEARTBEAT_INTERVAL_SECS: u64 = 30;
  constant DEFAULT_HEARTBEAT_TIMEOUT_SECS (line 14) | const DEFAULT_HEARTBEAT_TIMEOUT_SECS: u64 = 40;
  constant DEFAULT_CLIENT_RETRY_INTERVAL_SECS (line 17) | const DEFAULT_CLIENT_RETRY_INTERVAL_SECS: u64 = 1;
  type MaskedString (line 22) | pub struct MaskedString(String);
    method from (line 38) | fn from(s: &str) -> MaskedString {
  method fmt (line 25) | fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt...
  type Target (line 31) | type Target = str;
  method deref (line 32) | fn deref(&self) -> &Self::Target {
  type TransportType (line 44) | pub enum TransportType {
  type ClientServiceConfig (line 60) | pub struct ClientServiceConfig {
    method with_name (line 74) | pub fn with_name(name: &str) -> ClientServiceConfig {
  type ServiceType (line 83) | pub enum ServiceType {
  function default_service_type (line 91) | fn default_service_type() -> ServiceType {
  type ServerServiceConfig (line 99) | pub struct ServerServiceConfig {
    method with_name (line 110) | pub fn with_name(name: &str) -> ServerServiceConfig {
  type TlsConfig (line 119) | pub struct TlsConfig {
  function default_noise_pattern (line 126) | fn default_noise_pattern() -> String {
  type NoiseConfig (line 132) | pub struct NoiseConfig {
  type WebsocketConfig (line 142) | pub struct WebsocketConfig {
  function default_nodelay (line 146) | fn default_nodelay() -> bool {
  function default_keepalive_secs (line 150) | fn default_keepalive_secs() -> u64 {
  function default_keepalive_interval (line 154) | fn default_keepalive_interval() -> u64 {
  type TcpConfig (line 160) | pub struct TcpConfig {
  method default (line 171) | fn default() -> Self {
  type TransportConfig (line 183) | pub struct TransportConfig {
  function default_heartbeat_timeout (line 193) | fn default_heartbeat_timeout() -> u64 {
  function default_client_retry_interval (line 197) | fn default_client_retry_interval() -> u64 {
  type ClientConfig (line 203) | pub struct ClientConfig {
  function default_heartbeat_interval (line 216) | fn default_heartbeat_interval() -> u64 {
  type ServerConfig (line 222) | pub struct ServerConfig {
  type Config (line 234) | pub struct Config {
    method from_str (line 240) | fn from_str(s: &str) -> Result<Config> {
    method validate_server_config (line 258) | fn validate_server_config(server: &mut ServerConfig) -> Result<()> {
    method validate_client_config (line 275) | fn validate_client_config(client: &mut ClientConfig) -> Result<()> {
    method validate_transport_config (line 295) | fn validate_transport_config(config: &TransportConfig, is_server: bool...
    method from_file (line 329) | pub async fn from_file(path: &Path) -> Result<Config> {
  function list_config_files (line 346) | fn list_config_files<T: AsRef<Path>>(root: T) -> Result<Vec<PathBuf>> {
  function get_all_example_config (line 360) | fn get_all_example_config() -> Result<Vec<PathBuf>> {
  function test_example_config (line 368) | fn test_example_config() -> Result<()> {
  function test_valid_config (line 378) | fn test_valid_config() -> Result<()> {
  function test_invalid_config (line 388) | fn test_invalid_config() -> Result<()> {
  function test_validate_server_config (line 398) | fn test_validate_server_config() -> Result<()> {
  function test_validate_client_config (line 448) | fn test_validate_client_config() -> Result<()> {

FILE: src/config_watcher.rs
  type ConfigChange (line 18) | pub enum ConfigChange {
  type ClientServiceChange (line 25) | pub enum ClientServiceChange {
  type ServerServiceChange (line 31) | pub enum ServerServiceChange {
  type InstanceConfig (line 36) | trait InstanceConfig: Clone {
    method equal_without_service (line 38) | fn equal_without_service(&self, rhs: &Self) -> bool;
    method service_delete_change (line 39) | fn service_delete_change(s: String) -> ConfigChange;
    method service_add_change (line 40) | fn service_add_change(cfg: Self::ServiceConfig) -> ConfigChange;
    method get_services (line 41) | fn get_services(&self) -> &HashMap<String, Self::ServiceConfig>;
    type ServiceConfig (line 45) | type ServiceConfig = ServerServiceConfig;
    method equal_without_service (line 46) | fn equal_without_service(&self, rhs: &Self) -> bool {
    method service_delete_change (line 59) | fn service_delete_change(s: String) -> ConfigChange {
    method service_add_change (line 62) | fn service_add_change(cfg: Self::ServiceConfig) -> ConfigChange {
    method get_services (line 65) | fn get_services(&self) -> &HashMap<String, Self::ServiceConfig> {
    type ServiceConfig (line 71) | type ServiceConfig = ClientServiceConfig;
    method equal_without_service (line 72) | fn equal_without_service(&self, rhs: &Self) -> bool {
    method service_delete_change (line 85) | fn service_delete_change(s: String) -> ConfigChange {
    method service_add_change (line 88) | fn service_add_change(cfg: Self::ServiceConfig) -> ConfigChange {
    method get_services (line 91) | fn get_services(&self) -> &HashMap<String, Self::ServiceConfig> {
  type ConfigWatcherHandle (line 96) | pub struct ConfigWatcherHandle {
    method new (line 101) | pub async fn new(path: &Path, shutdown_rx: broadcast::Receiver<bool>) ...
  function config_watcher (line 123) | async fn config_watcher(
  function config_watcher (line 136) | async fn config_watcher(
  function calculate_events (line 202) | fn calculate_events(old: &Config, new: &Config) -> Option<Vec<ConfigChan...
  function calculate_instance_config_events (line 239) | fn calculate_instance_config_events<T: InstanceConfig>(
  function test_calculate_events (line 279) | fn test_calculate_events() {

FILE: src/constants.rs
  constant UDP_BUFFER_SIZE (line 6) | pub const UDP_BUFFER_SIZE: usize = 2048;
  constant UDP_SENDQ_SIZE (line 7) | pub const UDP_SENDQ_SIZE: usize = 1024;
  constant UDP_TIMEOUT (line 8) | pub const UDP_TIMEOUT: u64 = 60;
  function listen_backoff (line 10) | pub fn listen_backoff() -> ExponentialBackoff {
  function run_control_chan_backoff (line 18) | pub fn run_control_chan_backoff(interval: u64) -> ExponentialBackoff {

FILE: src/helper.rs
  function try_set_tcp_keepalive (line 19) | pub fn try_set_tcp_keepalive(
  function feature_not_compile (line 39) | pub fn feature_not_compile(feature: &str) -> ! {
  function feature_neither_compile (line 47) | pub fn feature_neither_compile(feature1: &str, feature2: &str) -> ! {
  function to_socket_addr (line 54) | pub async fn to_socket_addr<A: ToSocketAddrs>(addr: A) -> Result<SocketA...
  function host_port_pair (line 61) | pub fn host_port_pair(s: &str) -> Result<(&str, u16)> {
  function udp_connect (line 67) | pub async fn udp_connect<A: ToSocketAddrs>(addr: A, prefer_ipv6: bool) -...
  function tcp_connect_with_proxy (line 111) | pub async fn tcp_connect_with_proxy(
  function retry_notify_with_deadline (line 163) | pub async fn retry_notify_with_deadline<I, E, Fn, Fut, B, N>(
  function write_and_flush (line 186) | pub async fn write_and_flush<T>(conn: &mut T, data: &[u8]) -> Result<()>

FILE: src/lib.rs
  constant DEFAULT_CURVE (line 31) | const DEFAULT_CURVE: KeypairType = KeypairType::X25519;
  function get_str_from_keypair_type (line 33) | fn get_str_from_keypair_type(curve: KeypairType) -> &'static str {
  function genkey (line 41) | fn genkey(curve: Option<KeypairType>) -> Result<()> {
  function genkey (line 58) | fn genkey(curve: Option<KeypairType>) -> Result<()> {
  function run (line 62) | pub async fn run(args: Cli, shutdown_rx: broadcast::Receiver<bool>) -> R...
  function run_instance (line 117) | async fn run_instance(
  type RunMode (line 141) | enum RunMode {
  function determine_run_mode (line 147) | fn determine_run_mode(config: &Config, args: &Cli) -> RunMode {
  function test_determine_run_mode (line 169) | fn test_determine_run_mode() {

FILE: src/main.rs
  function main (line 8) | async fn main() -> Result<()> {

FILE: src/multi_map.rs
  type RawItem (line 5) | struct RawItem<K1, K2, V>(*mut (K1, K2, V));
  type MultiMap (line 12) | pub struct MultiMap<K1, K2, V> {
  type Key (line 17) | struct Key<T>(*const T);
  function borrow (line 23) | fn borrow(&self) -> &T {
  method hash (line 29) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 35) | fn eq(&self, other: &Self) -> bool {
  function new (line 43) | pub fn new() -> Self {
  function insert (line 58) | pub fn insert(&mut self, k1: K1, k2: K2, v: V) -> Result<(), (K1, K2, V)> {
  function get1 (line 71) | pub fn get1(&self, k1: &K1) -> Option<&V> {
  function get1_mut (line 77) | pub fn get1_mut(&mut self, k1: &K1) -> Option<&mut V> {
  function get2 (line 83) | pub fn get2(&self, k2: &K2) -> Option<&V> {
  function get_mut2 (line 89) | pub fn get_mut2(&mut self, k2: &K2) -> Option<&mut V> {
  function remove1 (line 95) | pub fn remove1(&mut self, k1: &K1) -> Option<V> {
  function remove2 (line 102) | pub fn remove2(&mut self, k2: &K2) -> Option<V> {
  method drop (line 111) | fn drop(&mut self) {

FILE: src/protocol.rs
  constant HASH_WIDTH_IN_BYTES (line 1) | pub const HASH_WIDTH_IN_BYTES: usize = 32;
  type ProtocolVersion (line 11) | type ProtocolVersion = u8;
  constant _PROTO_V0 (line 12) | const _PROTO_V0: u8 = 0u8;
  constant PROTO_V1 (line 13) | const PROTO_V1: u8 = 1u8;
  constant CURRENT_PROTO_VERSION (line 15) | pub const CURRENT_PROTO_VERSION: ProtocolVersion = PROTO_V1;
  type Digest (line 17) | pub type Digest = [u8; HASH_WIDTH_IN_BYTES];
  type Hello (line 20) | pub enum Hello {
  type Auth (line 26) | pub struct Auth(pub Digest);
  type Ack (line 29) | pub enum Ack {
    method fmt (line 36) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ControlChannelCmd (line 50) | pub enum ControlChannelCmd {
  type DataChannelCmd (line 56) | pub enum DataChannelCmd {
  type UdpPacketLen (line 61) | type UdpPacketLen = u16;
  type UdpHeader (line 63) | struct UdpHeader {
  type UdpTraffic (line 69) | pub struct UdpTraffic {
    method write (line 75) | pub async fn write<T: AsyncWrite + Unpin>(&self, writer: &mut T) -> Re...
    method write_slice (line 93) | pub async fn write_slice<T: AsyncWrite + Unpin>(
    method read (line 114) | pub async fn read<T: AsyncRead + Unpin>(reader: &mut T, hdr_len: u8) -...
  function digest (line 137) | pub fn digest(data: &[u8]) -> Digest {
  type PacketLength (line 143) | struct PacketLength {
    method new (line 152) | pub fn new() -> PacketLength {
  function read_hello (line 178) | pub async fn read_hello<T: AsyncRead + AsyncWrite + Unpin>(conn: &mut T)...
  function read_auth (line 209) | pub async fn read_auth<T: AsyncRead + AsyncWrite + Unpin>(conn: &mut T) ...
  function read_ack (line 217) | pub async fn read_ack<T: AsyncRead + AsyncWrite + Unpin>(conn: &mut T) -...
  function read_control_cmd (line 225) | pub async fn read_control_cmd<T: AsyncRead + AsyncWrite + Unpin>(
  function read_data_cmd (line 235) | pub async fn read_data_cmd<T: AsyncRead + AsyncWrite + Unpin>(

FILE: src/server.rs
  type ServiceDigest (line 33) | type ServiceDigest = protocol::Digest;
  type Nonce (line 34) | type Nonce = protocol::Digest;
  constant TCP_POOL_SIZE (line 36) | const TCP_POOL_SIZE: usize = 8;
  constant UDP_POOL_SIZE (line 37) | const UDP_POOL_SIZE: usize = 2;
  constant CHAN_SIZE (line 38) | const CHAN_SIZE: usize = 2048;
  constant HANDSHAKE_TIMEOUT (line 39) | const HANDSHAKE_TIMEOUT: u64 = 5;
  function run_server (line 42) | pub async fn run_server(
  type ControlChannelMap (line 93) | type ControlChannelMap<T> = MultiMap<ServiceDigest, Nonce, ControlChanne...
  type Server (line 96) | struct Server<T: Transport> {
  function generate_service_hashmap (line 109) | fn generate_service_hashmap(
  function from (line 121) | pub async fn from(config: ServerConfig) -> Result<Server<T>> {
  function run (line 135) | pub async fn run(
  function handle_hot_reload (line 225) | async fn handle_hot_reload(&mut self, e: ConfigChange) {
  function handle_connection (line 250) | async fn handle_connection<T: 'static + Transport>(
  function do_control_channel_handshake (line 276) | async fn do_control_channel_handshake<T: 'static + Transport>(
  function do_data_channel_handshake (line 361) | async fn do_data_channel_handshake<T: 'static + Transport>(
  type ControlChannelHandle (line 388) | pub struct ControlChannelHandle<T: Transport> {
  function new (line 402) | fn new(
  type ControlChannel (line 492) | struct ControlChannel<T: Transport> {
  function write_and_flush (line 500) | async fn write_and_flush(&mut self, data: &[u8]) -> Result<()> {
  function run (line 508) | async fn run(mut self) -> Result<()> {
  function tcp_listen_and_send (line 547) | fn tcp_listen_and_send(
  function run_tcp_connection_pool (line 626) | async fn run_tcp_connection_pool<T: Transport>(
  function run_udp_connection_pool (line 660) | async fn run_udp_connection_pool<T: Transport>(

FILE: src/transport/mod.rs
  constant DEFAULT_NODELAY (line 12) | pub const DEFAULT_NODELAY: bool = true;
  constant DEFAULT_KEEPALIVE_SECS (line 14) | pub const DEFAULT_KEEPALIVE_SECS: u64 = 20;
  constant DEFAULT_KEEPALIVE_INTERVAL (line 15) | pub const DEFAULT_KEEPALIVE_INTERVAL: u64 = 8;
  type AddrMaybeCached (line 18) | pub struct AddrMaybeCached {
    method new (line 24) | pub fn new(addr: &str) -> AddrMaybeCached {
    method resolve (line 31) | pub async fn resolve(&mut self) -> Result<()> {
  method fmt (line 43) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Transport (line 53) | pub trait Transport: Debug + Send + Sync {
    method new (line 58) | fn new(config: &TransportConfig) -> Result<Self>
    method hint (line 62) | fn hint(conn: &Self::Stream, opts: SocketOpts);
    method bind (line 63) | async fn bind<T: ToSocketAddrs + Send + Sync>(&self, addr: T) -> Resul...
    method accept (line 65) | async fn accept(&self, a: &Self::Acceptor) -> Result<(Self::RawStream,...
    method handshake (line 66) | async fn handshake(&self, conn: Self::RawStream) -> Result<Self::Stream>;
    method connect (line 67) | async fn connect(&self, addr: &AddrMaybeCached) -> Result<Self::Stream>;
  type Keepalive (line 99) | struct Keepalive {
  type SocketOpts (line 107) | pub struct SocketOpts {
    method none (line 115) | fn none() -> SocketOpts {
    method for_control_channel (line 123) | pub fn for_control_channel() -> SocketOpts {
    method from_cfg (line 132) | pub fn from_cfg(cfg: &TcpConfig) -> SocketOpts {
    method from_client_cfg (line 142) | pub fn from_client_cfg(cfg: &ClientServiceConfig) -> SocketOpts {
    method from_server_cfg (line 149) | pub fn from_server_cfg(cfg: &ServerServiceConfig) -> SocketOpts {
    method apply (line 156) | pub fn apply(&self, conn: &TcpStream) {

FILE: src/transport/native_tls.rs
  type TlsTransport (line 14) | pub struct TlsTransport {
  type Acceptor (line 23) | type Acceptor = TcpListener;
  type RawStream (line 24) | type RawStream = TcpStream;
  type Stream (line 25) | type Stream = TlsStream<TcpStream>;
  method new (line 27) | fn new(config: &TransportConfig) -> Result<Self> {
  method hint (line 74) | fn hint(conn: &Self::Stream, opt: SocketOpts) {
  method bind (line 78) | async fn bind<A: ToSocketAddrs + Send + Sync>(&self, addr: A) -> Result<...
  method accept (line 85) | async fn accept(&self, a: &Self::Acceptor) -> Result<(Self::RawStream, S...
  method handshake (line 92) | async fn handshake(&self, conn: Self::RawStream) -> Result<Self::Stream> {
  method connect (line 97) | async fn connect(&self, addr: &AddrMaybeCached) -> Result<Self::Stream> {
  function get_tcpstream (line 114) | pub(crate) fn get_tcpstream(s: &TlsStream<TcpStream>) -> &TcpStream {

FILE: src/transport/noise.rs
  type NoiseTransport (line 10) | pub struct NoiseTransport {
    method fmt (line 19) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt:...
    method builder (line 25) | fn builder(&self) -> Builder {
  type Acceptor (line 36) | type Acceptor = TcpListener;
  type RawStream (line 37) | type RawStream = TcpStream;
  type Stream (line 38) | type Stream = snowstorm::stream::NoiseStream<TcpStream>;
  method new (line 40) | fn new(config: &TransportConfig) -> Result<Self> {
  method hint (line 73) | fn hint(conn: &Self::Stream, opt: SocketOpts) {
  method bind (line 77) | async fn bind<T: ToSocketAddrs + Send + Sync>(&self, addr: T) -> Result<...
  method accept (line 81) | async fn accept(&self, a: &Self::Acceptor) -> Result<(Self::RawStream, S...
  method handshake (line 88) | async fn handshake(&self, conn: Self::RawStream) -> Result<Self::Stream> {
  method connect (line 95) | async fn connect(&self, addr: &AddrMaybeCached) -> Result<Self::Stream> {

FILE: src/transport/rustls.rs
  type TlsTransport (line 18) | pub struct TlsTransport {
  method fmt (line 27) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function load_server_config (line 35) | fn load_server_config(config: &TlsConfig) -> Result<Option<ServerConfig>> {
  function load_client_config (line 57) | fn load_client_config(config: &TlsConfig) -> Result<Option<ClientConfig>> {
  type Acceptor (line 86) | type Acceptor = TcpListener;
  type RawStream (line 87) | type RawStream = TcpStream;
  type Stream (line 88) | type Stream = TlsStream<TcpStream>;
  method new (line 90) | fn new(config: &TransportConfig) -> Result<Self> {
  method hint (line 112) | fn hint(conn: &Self::Stream, opt: SocketOpts) {
  method bind (line 116) | async fn bind<A: ToSocketAddrs + Send + Sync>(&self, addr: A) -> Result<...
  method accept (line 123) | async fn accept(&self, a: &Self::Acceptor) -> Result<(Self::RawStream, S...
  method handshake (line 130) | async fn handshake(&self, conn: Self::RawStream) -> Result<Self::Stream> {
  method connect (line 135) | async fn connect(&self, addr: &AddrMaybeCached) -> Result<Self::Stream> {
  function get_tcpstream (line 154) | pub(crate) fn get_tcpstream(s: &TlsStream<TcpStream>) -> &TcpStream {

FILE: src/transport/tcp.rs
  type TcpTransport (line 13) | pub struct TcpTransport {
  type Acceptor (line 20) | type Acceptor = TcpListener;
  type Stream (line 21) | type Stream = TcpStream;
  type RawStream (line 22) | type RawStream = TcpStream;
  method new (line 24) | fn new(config: &TransportConfig) -> Result<Self> {
  method hint (line 31) | fn hint(conn: &Self::Stream, opt: SocketOpts) {
  method bind (line 35) | async fn bind<T: ToSocketAddrs + Send + Sync>(&self, addr: T) -> Result<...
  method accept (line 39) | async fn accept(&self, a: &Self::Acceptor) -> Result<(Self::RawStream, S...
  method handshake (line 45) | async fn handshake(&self, conn: Self::RawStream) -> Result<Self::Stream> {
  method connect (line 49) | async fn connect(&self, addr: &AddrMaybeCached) -> Result<Self::Stream> {

FILE: src/transport/websocket.rs
  type TransportStream (line 28) | enum TransportStream {
    method get_tcpstream (line 34) | fn get_tcpstream(&self) -> &TcpStream {
  method poll_read (line 43) | fn poll_read(
  method poll_write (line 56) | fn poll_write(
  method poll_flush (line 67) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 74) | fn poll_shutdown(
  type StreamWrapper (line 86) | struct StreamWrapper {
  type Item (line 91) | type Item = Result<Bytes, Error>;
  method poll_next (line 93) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method size_hint (line 113) | fn size_hint(&self) -> (usize, Option<usize>) {
  type WebsocketTunnel (line 119) | pub struct WebsocketTunnel {
  method poll_read (line 124) | fn poll_read(
  method poll_fill_buf (line 134) | fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std...
  method consume (line 138) | fn consume(self: Pin<&mut Self>, amt: usize) {
  method poll_write (line 144) | fn poll_write(
  method poll_flush (line 160) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 166) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  type SubTransport (line 174) | enum SubTransport {
  type WebsocketTransport (line 180) | pub struct WebsocketTransport {
  type Acceptor (line 187) | type Acceptor = TcpListener;
  type RawStream (line 188) | type RawStream = TcpStream;
  type Stream (line 189) | type Stream = WebsocketTunnel;
  method new (line 191) | fn new(config: &TransportConfig) -> anyhow::Result<Self> {
  method hint (line 208) | fn hint(conn: &Self::Stream, opt: SocketOpts) {
  method bind (line 212) | async fn bind<A: ToSocketAddrs + Send + Sync>(
  method accept (line 219) | async fn accept(&self, a: &Self::Acceptor) -> anyhow::Result<(Self::RawS...
  method handshake (line 227) | async fn handshake(&self, conn: Self::RawStream) -> anyhow::Result<Self:...
  method connect (line 239) | async fn connect(&self, addr: &AddrMaybeCached) -> anyhow::Result<Self::...

FILE: tests/common/mod.rs
  constant PING (line 10) | pub const PING: &str = "ping";
  constant PONG (line 11) | pub const PONG: &str = "pong";
  function run_rathole_server (line 13) | pub async fn run_rathole_server(
  function run_rathole_client (line 26) | pub async fn run_rathole_client(
  function echo_server (line 42) | pub async fn echo_server<A: ToSocketAddrs>(addr: A) -> Result<()> {
  function pingpong_server (line 53) | pub async fn pingpong_server<A: ToSocketAddrs>(addr: A) -> Result<()> {
  function echo (line 64) | async fn echo(conn: TcpStream) -> Result<()> {
  function pingpong (line 71) | async fn pingpong(mut conn: TcpStream) -> Result<()> {
  function echo_server (line 90) | pub async fn echo_server<A: ToSocketAddrs>(addr: A) -> Result<()> {
  function pingpong_server (line 102) | pub async fn pingpong_server<A: ToSocketAddrs>(addr: A) -> Result<()> {

FILE: tests/integration_test.rs
  constant ECHO_SERVER_ADDR (line 18) | const ECHO_SERVER_ADDR: &str = "127.0.0.1:8080";
  constant PINGPONG_SERVER_ADDR (line 19) | const PINGPONG_SERVER_ADDR: &str = "127.0.0.1:8081";
  constant ECHO_SERVER_ADDR_EXPOSED (line 20) | const ECHO_SERVER_ADDR_EXPOSED: &str = "127.0.0.1:2334";
  constant PINGPONG_SERVER_ADDR_EXPOSED (line 21) | const PINGPONG_SERVER_ADDR_EXPOSED: &str = "127.0.0.1:2335";
  constant HITTER_NUM (line 22) | const HITTER_NUM: usize = 4;
  type Type (line 25) | enum Type {
  function init (line 30) | fn init() {
  function tcp (line 40) | async fn tcp() -> Result<()> {
  function udp (line 81) | async fn udp() -> Result<()> {
  function test (line 122) | async fn test(config_path: &'static str, t: Type) -> Result<()> {
  function echo_hitter (line 224) | async fn echo_hitter(addr: &'static str, t: Type) -> Result<()> {
  function pingpong_hitter (line 231) | async fn pingpong_hitter(addr: &'static str, t: Type) -> Result<()> {
  function tcp_echo_hitter (line 238) | async fn tcp_echo_hitter(addr: &'static str) -> Result<()> {
  function udp_echo_hitter (line 253) | async fn udp_echo_hitter(addr: &'static str) -> Result<()> {
  function tcp_pingpong_hitter (line 273) | async fn tcp_pingpong_hitter(addr: &'static str) -> Result<()> {
  function udp_pingpong_hitter (line 288) | async fn udp_pingpong_hitter(addr: &'static str) -> Result<()> {