Struct RawReadConnection 

pub struct RawReadConnection {
    pub read_stream: OwnedReadHalf,
    pub buffer: Cursor<Vec<u8>>,
    pub compression_threshold: Option<u32>,
    pub dec_cipher: Option<Aes128CfbDec>,
}

Fields

read_stream: OwnedReadHalf

buffer: Cursor<Vec<u8>>

compression_threshold: Option<u32>

dec_cipher: Option<Aes128CfbDec>

Implementations

impl RawReadConnection

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

Examples found in repository

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

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 try_read(&mut self) -> Result<Option<Box<[u8]>>, Box<ReadPacketError>>