Struct Connection 

pub struct Connection<R: ProtocolPacket, W: ProtocolPacket> {
    pub reader: ReadConnection<R>,
    pub writer: WriteConnection<W>,
}

A connection that can read and write packets.

Examples

Join an offline-mode server and go through the handshake.

use azalea_protocol::{
    connect::Connection,
    packets::{
        self, ClientIntention, PROTOCOL_VERSION,
        handshake::ServerboundIntention,
        login::{ClientboundLoginPacket, ServerboundHello, ServerboundKey},
    },
    resolver,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resolved_address = resolver::resolve_address(&"localhost".try_into().unwrap()).await?;
    let mut conn = Connection::new(&resolved_address).await?;

    // handshake
    conn.write(ServerboundIntention {
        protocol_version: PROTOCOL_VERSION,
        hostname: resolved_address.ip().to_string(),
        port: resolved_address.port(),
        intention: ClientIntention::Login,
    })
    .await?;

    let mut conn = conn.login();

    // login
    conn.write(ServerboundHello {
        name: "bot".to_owned(),
        profile_id: uuid::Uuid::nil(),
    })
    .await?;

    let (conn, game_profile) = loop {
        let packet = conn.read().await?;
        match packet {
            ClientboundLoginPacket::Hello(p) => {
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                conn.write(ServerboundKey {
                    key_bytes: e.encrypted_public_key,
                    encrypted_challenge: e.encrypted_challenge,
                })
                .await?;
                conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                break (conn.config(), p.game_profile);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                eprintln!("login disconnect: {}", p.reason);
                return Err("login disconnect".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {}
            ClientboundLoginPacket::CookieRequest(p) => {
                conn.write(packets::login::ServerboundCookieResponse {
                    key: p.key,
                    payload: None,
                })
                .await?;
            }
        }
    };

    Ok(())
}

Fields

reader: ReadConnection<R>

writer: WriteConnection<W>

Implementations

impl<R, W> Connection<R, W>

where R: ProtocolPacket + Debug, W: ProtocolPacket + Debug,

pub async fn read(&mut self) -> Result<R, Box<ReadPacketError>>

Read a packet from the other side of the connection.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 106)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy, reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy, wait for them to send the `Hello` packet to log
        // their username and uuid, then start proxying their connection.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{}\' from {} logging in with uuid: {}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(proxy_conn(conn).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

azalea-protocol/examples/handshake_proxy.rs (line 76)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy,
        // reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy,
        // wait for them to send the `Hello` packet to
        // log their username and uuid, then forward the
        // connection along to the proxy target.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{0}\' from {1} logging in with uuid: {2}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(transfer(conn.unwrap()?, intent, hello).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

pub fn try_read(&mut self) -> Result<Option<R>, Box<ReadPacketError>>

Try to read a packet from the other side of the connection, or return Ok(None) if there’s no packet to read.

pub async fn write(&mut self, packet: impl Packet<W>) -> Result<()>

Write a packet to the other side of the connection.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (lines 135-141)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy, reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy, wait for them to send the `Hello` packet to log
        // their username and uuid, then start proxying their connection.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{}\' from {} logging in with uuid: {}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(proxy_conn(conn).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

azalea-protocol/examples/handshake_proxy.rs (lines 106-112)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy,
        // reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy,
        // wait for them to send the `Hello` packet to
        // log their username and uuid, then forward the
        // connection along to the proxy target.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{0}\' from {1} logging in with uuid: {2}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(transfer(conn.unwrap()?, intent, hello).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

async fn transfer(
    mut inbound: TcpStream,
    intent: ServerboundIntention,
    hello: ServerboundHello,
) -> Result<(), Box<dyn Error>> {
    let outbound = TcpStream::connect(PROXY_ADDR).await?;
    let name = hello.name.clone();
    outbound.set_nodelay(true)?;

    // Repeat the intent and hello packet
    // received earlier to the proxy target
    let mut outbound_conn: Connection<ClientboundHandshakePacket, ServerboundHandshakePacket> =
        Connection::wrap(outbound);
    outbound_conn.write(intent).await?;

    let mut outbound_conn = outbound_conn.login();
    outbound_conn.write(hello).await?;

    let mut outbound = outbound_conn.unwrap()?;

    // Split the incoming and outgoing connections in
    // halves and handle each pair on separate threads.
    let (mut ri, mut wi) = inbound.split();
    let (mut ro, mut wo) = outbound.split();

    let client_to_server = async {
        io::copy(&mut ri, &mut wo).await?;
        wo.shutdown().await
    };

    let server_to_client = async {
        io::copy(&mut ro, &mut wi).await?;
        wi.shutdown().await
    };

    tokio::try_join!(client_to_server, server_to_client)?;
    info!("Player \'{name}\' left the game");

    Ok(())
}

pub fn into_split(self) -> (ReadConnection<R>, WriteConnection<W>)

Split the reader and writer into two objects.

This doesn’t allocate.

pub fn into_split_raw(self) -> (RawReadConnection, RawWriteConnection)

Split the reader and writer into the state-agnostic RawReadConnection and RawWriteConnection types.

This is meant to help with some types of proxies.

impl Connection<ClientboundHandshakePacket, ServerboundHandshakePacket>

pub async fn new(address: &SocketAddr) -> Result<Self, ConnectionError>

Create a new connection to the given address.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 212)

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

pub async fn new_with_proxy( address: &SocketAddr, proxy: Proxy, ) -> Result<Self, ConnectionError>

Create a new connection to the given address and SOCKS5 proxy.

If you’re not using a proxy, use Self::new instead.

pub async fn new_from_stream(stream: TcpStream) -> Result<Self, ConnectionError>

Create a new connection from an existing stream.

Useful if you want to set custom options on the stream. Otherwise, just use Self::new.

pub fn login(self) -> Connection<ClientboundLoginPacket, ServerboundLoginPacket>

Change our state from handshake to login.

This is the state that is used for logging in.

Examples found in repository

azalea-protocol/examples/handshake_proxy.rs (line 193)

async fn transfer(
    mut inbound: TcpStream,
    intent: ServerboundIntention,
    hello: ServerboundHello,
) -> Result<(), Box<dyn Error>> {
    let outbound = TcpStream::connect(PROXY_ADDR).await?;
    let name = hello.name.clone();
    outbound.set_nodelay(true)?;

    // Repeat the intent and hello packet
    // received earlier to the proxy target
    let mut outbound_conn: Connection<ClientboundHandshakePacket, ServerboundHandshakePacket> =
        Connection::wrap(outbound);
    outbound_conn.write(intent).await?;

    let mut outbound_conn = outbound_conn.login();
    outbound_conn.write(hello).await?;

    let mut outbound = outbound_conn.unwrap()?;

    // Split the incoming and outgoing connections in
    // halves and handle each pair on separate threads.
    let (mut ri, mut wi) = inbound.split();
    let (mut ro, mut wo) = outbound.split();

    let client_to_server = async {
        io::copy(&mut ri, &mut wo).await?;
        wo.shutdown().await
    };

    let server_to_client = async {
        io::copy(&mut ro, &mut wi).await?;
        wi.shutdown().await
    };

    tokio::try_join!(client_to_server, server_to_client)?;
    info!("Player \'{name}\' left the game");

    Ok(())
}

azalea-protocol/examples/packet_logger.rs (line 229)

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

pub fn status( self, ) -> Connection<ClientboundStatusPacket, ServerboundStatusPacket>

Change our state from handshake to status.

This is the state that is used for pinging the server.

impl Connection<ClientboundLoginPacket, ServerboundLoginPacket>

pub fn set_compression_threshold(&mut self, threshold: i32)

Set our compression threshold, i.e. the maximum size that a packet is allowed to be without getting compressed.

Setting it to 0 means every packet will be compressed. If you set it to less than 0 then compression is disabled.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 290)

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

pub fn set_encryption_key(&mut self, key: [u8; 16])

Set the encryption key that is used to encrypt and decrypt packets.

It’s the same for both reading and writing.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 286)

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

pub fn config( self, ) -> Connection<ClientboundConfigPacket, ServerboundConfigPacket>

Change our state from login to configuration.

This is the state where the server sends us the registries and the resource pack.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 298)

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

pub async fn authenticate( &self, access_token: &str, uuid: &Uuid, private_key: [u8; 16], packet: &ClientboundHello, sessionserver_proxy: Option<Proxy>, ) -> Result<(), ClientSessionServerError>

Authenticate with Minecraft’s servers, which is required to join online-mode servers.

This must happen when you get a ClientboundLoginPacket::Hello packet.

Examples

use azalea_auth::AuthResult;
use azalea_protocol::{
    connect::Connection,
    packets::login::{ClientboundLoginPacket, ServerboundKey},
};
use uuid::Uuid;

let AuthResult {
    access_token,
    profile,
} = azalea_auth::auth("[email protected]", azalea_auth::AuthOpts::default())
    .await
    .expect("Couldn't authenticate");

let mut conn = Connection::new(&resolved_address).await?;

// transition to the login state, in a real program we would have done a handshake first
let mut conn = conn.login();

match conn.read().await? {
    ClientboundLoginPacket::Hello(p) => {
        // tell Mojang we're joining the server & enable encryption
        let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();
        conn.authenticate(&access_token, &profile.id, e.secret_key, &p, None)
            .await?;
        conn.write(ServerboundKey {
            key_bytes: e.encrypted_public_key,
            encrypted_challenge: e.encrypted_challenge,
        })
        .await?;
        conn.set_encryption_key(e.secret_key);
    }
    _ => {}
}

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 256)

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

impl Connection<ServerboundHandshakePacket, ClientboundHandshakePacket>

pub fn login(self) -> Connection<ServerboundLoginPacket, ClientboundLoginPacket>

Change our state from handshake to login.

This is the state that is used while negotiating encryption and authenticating with Mojang.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 164)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy, reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy, wait for them to send the `Hello` packet to log
        // their username and uuid, then start proxying their connection.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{}\' from {} logging in with uuid: {}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(proxy_conn(conn).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

azalea-protocol/examples/handshake_proxy.rs (line 137)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy,
        // reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy,
        // wait for them to send the `Hello` packet to
        // log their username and uuid, then forward the
        // connection along to the proxy target.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{0}\' from {1} logging in with uuid: {2}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(transfer(conn.unwrap()?, intent, hello).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

pub fn status( self, ) -> Connection<ServerboundStatusPacket, ClientboundStatusPacket>

Change our state from handshake to status.

This is the state that is used for pinging the server.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 130)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy, reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy, wait for them to send the `Hello` packet to log
        // their username and uuid, then start proxying their connection.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{}\' from {} logging in with uuid: {}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(proxy_conn(conn).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

azalea-protocol/examples/handshake_proxy.rs (line 101)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy,
        // reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy,
        // wait for them to send the `Hello` packet to
        // log their username and uuid, then forward the
        // connection along to the proxy target.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{0}\' from {1} logging in with uuid: {2}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(transfer(conn.unwrap()?, intent, hello).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

impl Connection<ServerboundLoginPacket, ClientboundLoginPacket>

pub fn set_compression_threshold(&mut self, threshold: i32)

Set our compression threshold, i.e. the maximum size that a packet is allowed to be without getting compressed.

If you set it to less than 0 then compression gets disabled.

pub fn set_encryption_key(&mut self, key: [u8; 16])

Set the encryption key that is used to encrypt and decrypt packets.

It’s the same for both reading and writing.

pub fn game(self) -> Connection<ServerboundGamePacket, ClientboundGamePacket>

Change our state from login to game.

This is the state that’s used when the client is actually in the game.

pub async fn authenticate( &self, username: &str, public_key: &[u8], private_key: &[u8; 16], ip: Option<&str>, ) -> Result<GameProfile, ServerSessionServerError>

Verify connecting clients have authenticated with Minecraft’s servers. This must happen after the client sends a ServerboundLoginPacket::Key packet.

pub fn config( self, ) -> Connection<ServerboundConfigPacket, ClientboundConfigPacket>

Change our state back to configuration.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 326)

async fn proxy_conn(
    mut client_conn: Connection<ServerboundLoginPacket, ClientboundLoginPacket>,
) -> Result<(), Box<dyn Error>> {
    // resolve TARGET_ADDR
    let parsed_target_addr = ServerAddr::try_from(TARGET_ADDR).unwrap();
    let resolved_target_addr = resolve_address(&parsed_target_addr).await?;

    let mut server_conn = Connection::new(&resolved_target_addr).await?;

    let account = if ACCOUNT.contains('@') {
        Account::microsoft(ACCOUNT).await?
    } else {
        Account::offline(ACCOUNT)
    };
    println!("got account: {:?}", account);

    server_conn
        .write(ServerboundIntention {
            protocol_version: PROTOCOL_VERSION,
            hostname: parsed_target_addr.host,
            port: parsed_target_addr.port,
            intention: ClientIntention::Login,
        })
        .await?;
    let mut server_conn = server_conn.login();

    // login
    server_conn
        .write(ServerboundHello {
            name: account.username().to_owned(),
            profile_id: account.uuid(),
        })
        .await?;

    let (server_conn, login_finished) = loop {
        let packet = server_conn.read().await?;

        println!("got packet: {:?}", packet);

        match packet {
            ClientboundLoginPacket::Hello(p) => {
                debug!("Got encryption request");
                let e = azalea_crypto::encrypt(&p.public_key, &p.challenge).unwrap();

                if let Some(access_token) = account.access_token() {
                    // keep track of the number of times we tried
                    // authenticating so we can give up after too many
                    let mut attempts: usize = 1;

                    while let Err(e) = {
                        server_conn
                            .authenticate(&access_token, &account.uuid(), e.secret_key, &p, None)
                            .await
                    } {
                        if attempts >= 2 {
                            // if this is the second attempt and we failed
                            // both times, give up
                            return Err(e.into());
                        }
                        if matches!(
                            e,
                            ClientSessionServerError::InvalidSession
                                | ClientSessionServerError::ForbiddenOperation
                        ) {
                            // uh oh, we got an invalid session and have
                            // to reauthenticate now
                            account.refresh().await?;
                        } else {
                            return Err(e.into());
                        }
                        attempts += 1;
                    }
                }

                server_conn
                    .write(ServerboundKey {
                        key_bytes: e.encrypted_public_key,
                        encrypted_challenge: e.encrypted_challenge,
                    })
                    .await?;

                server_conn.set_encryption_key(e.secret_key);
            }
            ClientboundLoginPacket::LoginCompression(p) => {
                debug!("Got compression request {:?}", p.compression_threshold);
                server_conn.set_compression_threshold(p.compression_threshold);
            }
            ClientboundLoginPacket::LoginFinished(p) => {
                debug!(
                    "Got profile {:?}. handshake is finished and we're now switching to the configuration state",
                    p.game_profile
                );
                // server_conn.write(ServerboundLoginAcknowledged {}).await?;
                break (server_conn.config(), p);
            }
            ClientboundLoginPacket::LoginDisconnect(p) => {
                error!("Got disconnect {p:?}");
                return Err("Disconnected".into());
            }
            ClientboundLoginPacket::CustomQuery(p) => {
                debug!("Got custom query {:?}", p);
                // replying to custom query is done in
                // packet_handling::login::process_packet_events
            }
            ClientboundLoginPacket::CookieRequest(p) => {
                debug!("Got cookie request {:?}", p);

                server_conn
                    .write(packets::login::ServerboundCookieResponse {
                        key: p.key,
                        // cookies aren't implemented
                        payload: None,
                    })
                    .await?;
            }
        }
    };

    // give the client the login_finished
    println!("got the login_finished: {:?}", login_finished);
    client_conn.write(login_finished).await?;
    let client_conn = client_conn.config();

    info!("started direct bridging");

    // bridge packets
    let listen_raw_reader = client_conn.reader.raw;
    let listen_raw_writer = client_conn.writer.raw;

    let target_raw_reader = server_conn.reader.raw;
    let target_raw_writer = server_conn.writer.raw;

    let packet_logs_txt = Arc::new(tokio::sync::Mutex::new(
        File::create("combined.txt").await.unwrap(),
    ));

    let packet_logs_txt_clone = packet_logs_txt.clone();
    let copy_listen_to_target = tokio::spawn(async move {
        let mut listen_raw_reader = listen_raw_reader;
        let mut target_raw_writer = target_raw_writer;

        let packet_logs_txt = packet_logs_txt_clone;

        let mut serverbound_parsed_txt = File::create("serverbound.txt").await.unwrap();

        loop {
            let packet = match listen_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from listen: {e}");
                    return;
                }
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ServerboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = serverbound_parsed_txt
                    .write_all(format!("{timestamp} {:?}\n", decoded_packet).as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} <- {:?}\n", decoded_packet).as_bytes())
                    .await;
            }

            match target_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to target: {e}");
                    return;
                }
            }
        }
    });

    // write to clientbound.txt in a separate task so it doesn't block receiving
    // packets
    let (clientbound_tx, mut clientbound_rx) = tokio::sync::mpsc::unbounded_channel::<Box<[u8]>>();
    let copy_clientbound_to_file = tokio::spawn(async move {
        let mut clientbound_parsed_txt = File::create("clientbound.txt").await.unwrap();

        loop {
            let Some(packet) = clientbound_rx.recv().await else {
                return;
            };

            // decode as a game packet
            let decoded_packet = azalea_protocol::read::deserialize_packet::<ClientboundGamePacket>(
                &mut Cursor::new(&packet),
            );

            if let Ok(decoded_packet) = decoded_packet {
                let timestamp = chrono::Utc::now();
                let _ = clientbound_parsed_txt
                    .write_all(format!("{timestamp} {decoded_packet:?}\n").as_bytes())
                    .await;
                let _ = packet_logs_txt
                    .lock()
                    .await
                    .write_all(format!("{timestamp} -> {decoded_packet:?}\n").as_bytes())
                    .await;
            }
        }
    });

    let copy_remote_to_local = tokio::spawn(async move {
        let mut target_raw_reader = target_raw_reader;
        let mut listen_raw_writer = listen_raw_writer;

        loop {
            let packet = match target_raw_reader.read().await {
                Ok(p) => p,
                Err(e) => {
                    error!("Error reading packet from target: {e}");
                    return;
                }
            };

            clientbound_tx.send(packet.clone()).unwrap();

            match listen_raw_writer.write(&packet).await {
                Ok(_) => {}
                Err(e) => {
                    error!("Error writing packet to listen: {e}");
                    return;
                }
            }
        }
    });

    tokio::try_join!(
        copy_listen_to_target,
        copy_remote_to_local,
        copy_clientbound_to_file
    )?;

    Ok(())
}

impl Connection<ServerboundConfigPacket, ClientboundConfigPacket>

pub fn game(self) -> Connection<ServerboundGamePacket, ClientboundGamePacket>

Change our state from configuration to game.

This is the state that’s used when the client is actually in the world.

impl Connection<ClientboundConfigPacket, ServerboundConfigPacket>

pub fn game(self) -> Connection<ClientboundGamePacket, ServerboundGamePacket>

Change our state from configuration to game.

This is the state that’s used when the client is actually in the world.

impl Connection<ClientboundGamePacket, ServerboundGamePacket>

pub fn config( self, ) -> Connection<ClientboundConfigPacket, ServerboundConfigPacket>

Change our state back to configuration.

impl Connection<ServerboundGamePacket, ClientboundGamePacket>

pub fn config( self, ) -> Connection<ServerboundConfigPacket, ClientboundConfigPacket>

Change our state back to configuration.

impl<R1, W1> Connection<R1, W1>

where R1: ProtocolPacket + Debug, W1: ProtocolPacket + Debug,

pub fn from<R2, W2>(connection: Connection<R1, W1>) -> Connection<R2, W2>

where R2: ProtocolPacket + Debug, W2: ProtocolPacket + Debug,

Creates a Connection of a type from a Connection of another type. Useful for servers or custom packets.

pub fn wrap(stream: TcpStream) -> Connection<R1, W1>

Convert an existing TcpStream into a Connection. Useful for servers.

Examples found in repository

azalea-protocol/examples/packet_logger.rs (line 101)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy, reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy, wait for them to send the `Hello` packet to log
        // their username and uuid, then start proxying their connection.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{}\' from {} logging in with uuid: {}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(proxy_conn(conn).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

azalea-protocol/examples/handshake_proxy.rs (line 71)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy,
        // reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy,
        // wait for them to send the `Hello` packet to
        // log their username and uuid, then forward the
        // connection along to the proxy target.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{0}\' from {1} logging in with uuid: {2}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(transfer(conn.unwrap()?, intent, hello).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

async fn transfer(
    mut inbound: TcpStream,
    intent: ServerboundIntention,
    hello: ServerboundHello,
) -> Result<(), Box<dyn Error>> {
    let outbound = TcpStream::connect(PROXY_ADDR).await?;
    let name = hello.name.clone();
    outbound.set_nodelay(true)?;

    // Repeat the intent and hello packet
    // received earlier to the proxy target
    let mut outbound_conn: Connection<ClientboundHandshakePacket, ServerboundHandshakePacket> =
        Connection::wrap(outbound);
    outbound_conn.write(intent).await?;

    let mut outbound_conn = outbound_conn.login();
    outbound_conn.write(hello).await?;

    let mut outbound = outbound_conn.unwrap()?;

    // Split the incoming and outgoing connections in
    // halves and handle each pair on separate threads.
    let (mut ri, mut wi) = inbound.split();
    let (mut ro, mut wo) = outbound.split();

    let client_to_server = async {
        io::copy(&mut ri, &mut wo).await?;
        wo.shutdown().await
    };

    let server_to_client = async {
        io::copy(&mut ro, &mut wi).await?;
        wi.shutdown().await
    };

    tokio::try_join!(client_to_server, server_to_client)?;
    info!("Player \'{name}\' left the game");

    Ok(())
}

pub fn unwrap(self) -> Result<TcpStream, ReuniteError>

Convert from a Connection into a TcpStream. Useful for servers.

Examples found in repository

azalea-protocol/examples/handshake_proxy.rs (line 149)

async fn handle_connection(stream: TcpStream) -> eyre::Result<()> {
    stream.set_nodelay(true)?;
    let ip = stream.peer_addr()?;
    let mut conn: Connection<ServerboundHandshakePacket, ClientboundHandshakePacket> =
        Connection::wrap(stream);

    // The first packet sent from a client is the intent packet.
    // This specifies whether the client is pinging
    // the server or is going to join the game.
    let intent = match conn.read().await {
        Ok(packet) => match packet {
            ServerboundHandshakePacket::Intention(packet) => {
                info!(
                    "New connection from {}, hostname {:?}:{}, version {}, {:?}",
                    ip.ip(),
                    packet.hostname,
                    packet.port,
                    packet.protocol_version,
                    packet.intention
                );
                packet
            }
        },
        Err(e) => {
            let e = e.into();
            warn!("Error during intent: {e}");
            return Err(e);
        }
    };

    match intent.intention {
        // If the client is pinging the proxy,
        // reply with the information below.
        ClientIntention::Status => {
            let mut conn = conn.status();
            loop {
                match conn.read().await {
                    Ok(p) => match p {
                        ServerboundStatusPacket::StatusRequest(_) => {
                            conn.write(ClientboundStatusResponse {
                                description: PROXY_DESC.into(),
                                favicon: PROXY_FAVICON.clone(),
                                players: PROXY_PLAYERS.clone(),
                                version: PROXY_VERSION.clone(),
                                enforces_secure_chat: PROXY_SECURE_CHAT,
                            })
                            .await?;
                        }
                        ServerboundStatusPacket::PingRequest(p) => {
                            conn.write(ClientboundPongResponse { time: p.time }).await?;
                            break;
                        }
                    },
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during status: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        // If the client intends to join the proxy,
        // wait for them to send the `Hello` packet to
        // log their username and uuid, then forward the
        // connection along to the proxy target.
        ClientIntention::Login => {
            let mut conn = conn.login();
            loop {
                match conn.read().await {
                    Ok(p) => {
                        if let ServerboundLoginPacket::Hello(hello) = p {
                            info!(
                                "Player \'{0}\' from {1} logging in with uuid: {2}",
                                hello.name,
                                ip.ip(),
                                hello.profile_id.to_string()
                            );

                            tokio::spawn(transfer(conn.unwrap()?, intent, hello).map(|r| {
                                if let Err(e) = r {
                                    error!("Failed to proxy: {e}");
                                }
                            }));

                            break;
                        }
                    }
                    Err(e) => match *e {
                        ReadPacketError::ConnectionClosed => {
                            break;
                        }
                        e => {
                            warn!("Error during login: {e}");
                            return Err(e.into());
                        }
                    },
                }
            }
        }
        ClientIntention::Transfer => {
            warn!("Client attempted to join via transfer")
        }
    }

    Ok(())
}

async fn transfer(
    mut inbound: TcpStream,
    intent: ServerboundIntention,
    hello: ServerboundHello,
) -> Result<(), Box<dyn Error>> {
    let outbound = TcpStream::connect(PROXY_ADDR).await?;
    let name = hello.name.clone();
    outbound.set_nodelay(true)?;

    // Repeat the intent and hello packet
    // received earlier to the proxy target
    let mut outbound_conn: Connection<ClientboundHandshakePacket, ServerboundHandshakePacket> =
        Connection::wrap(outbound);
    outbound_conn.write(intent).await?;

    let mut outbound_conn = outbound_conn.login();
    outbound_conn.write(hello).await?;

    let mut outbound = outbound_conn.unwrap()?;

    // Split the incoming and outgoing connections in
    // halves and handle each pair on separate threads.
    let (mut ri, mut wi) = inbound.split();
    let (mut ro, mut wo) = outbound.split();

    let client_to_server = async {
        io::copy(&mut ri, &mut wo).await?;
        wo.shutdown().await
    };

    let server_to_client = async {
        io::copy(&mut ro, &mut wi).await?;
        wi.shutdown().await
    };

    tokio::try_join!(client_to_server, server_to_client)?;
    info!("Player \'{name}\' left the game");

    Ok(())
}