rust-netlink / netlink-packet-utils Goto Github PK

#[test]
fn test_qdisc() {
    use netlink_packet_core::{
        NetlinkHeader, NetlinkMessage, NetlinkPayload, NLM_F_DUMP, NLM_F_REQUEST,
    };
    use netlink_sys::{protocols::NETLINK_ROUTE, Socket, SocketAddr};

    use crate::RtnlMessage;

    let socket = Socket::new(NETLINK_ROUTE).unwrap();
    socket.connect(&SocketAddr::new(0, 0)).unwrap();

    let mut nl_hdr = NetlinkHeader::default();
    nl_hdr.flags = NLM_F_REQUEST | NLM_F_DUMP;

    let mut packet = NetlinkMessage::new(
        nl_hdr,
        NetlinkPayload::from(RtnlMessage::GetQueueDiscipline(TcMessage::default())),
    );
    packet.finalize();

    let mut buf = vec![0; packet.header.length as usize];
    packet.serialize(&mut buf[..]);
    socket.send(&buf[..], 0).unwrap();

    let mut receive_buffer = vec![0; 4096];
    let mut offset = 0;

    let mut tc_messages = Vec::new();
    while let Ok(size) = socket.recv(&mut &mut receive_buffer[..], 0) {
        let mut i: u8 = 0;
        loop {
            i += 1;
            if i == 6 {
                println!("sfq");
            }
            let bytes = &receive_buffer[offset..];
            // !!! PANICS here !!!
            let rx_packet = <NetlinkMessage<RtnlMessage>>::deserialize(bytes).unwrap();

            let payload = rx_packet.payload;
            match payload {
                NetlinkPayload::InnerMessage(RtnlMessage::NewQueueDiscipline(message)) => {
                    tc_messages.push(message.clone())
                }
                NetlinkPayload::Error(error) => {
                    panic!("Received Netlink Error: {:?}", error);
                }
                NetlinkPayload::Done(_) => break,
                _ => {}
            }

            offset += rx_packet.header.length as usize;
            if offset == size || rx_packet.header.length == 0 {
                offset = 0;
                break;
            }
        }
    }
}