### Add netstat2 dependency

Source: https://github.com/ohadravid/netstat2-rs/blob/main/README.md

Include the library in your Cargo.toml file.

```toml
# Cargo.toml
[dependencies]
netstat2 = "0.11"
```

--------------------------------

### Query Sockets by Protocol

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Use ProtocolFlags to specify TCP, UDP, or both when querying sockets. Combine with AddressFamilyFlags for specific address family filtering.

```rust
use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo};

fn main() -> Result<(), netstat2::error::Error> {
    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;

    // Query only TCP sockets
    let tcp_sockets = get_sockets_info(af_flags, ProtocolFlags::TCP)?;
    println!("TCP sockets: {}", tcp_sockets.len());

    // Query only UDP sockets
    let udp_sockets = get_sockets_info(af_flags, ProtocolFlags::UDP)?;
    println!("UDP sockets: {}", udp_sockets.len());

    // Query all protocols using bitwise OR
    let all_sockets = get_sockets_info(af_flags, ProtocolFlags::TCP | ProtocolFlags::UDP)?;
    println!("All sockets: {}", all_sockets.len());

    Ok(())
}
```

--------------------------------

### Retrieve all socket information with get_sockets_info

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Collects all network socket information into a vector for processing. Use this when you need the complete list of sockets available at the time of the call.

```rust
use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo, TcpState};

fn main() -> Result<(), netstat2::error::Error> {
    // Query all IPv4 and IPv6 TCP and UDP sockets
    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
    let proto_flags = ProtocolFlags::TCP | ProtocolFlags::UDP;

    let sockets_info = get_sockets_info(af_flags, proto_flags)?;

    for si in sockets_info {
        match si.protocol_socket_info {
            ProtocolSocketInfo::Tcp(tcp_si) => println!(
                "TCP {}:{} -> {}:{} {:?} - {}",
                tcp_si.local_addr,
                tcp_si.local_port,
                tcp_si.remote_addr,
                tcp_si.remote_port,
                si.associated_pids,
                tcp_si.state
            ),
            ProtocolSocketInfo::Udp(udp_si) => println!(
                "UDP {}:{} -> *:* {:?}",
                udp_si.local_addr, udp_si.local_port, si.associated_pids
            ),
        }
    }

    Ok(())
}
```

--------------------------------

### Handle netstat2 errors in Rust

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Demonstrates how to match against the custom Error enum returned by get_sockets_info to handle various platform-specific failure scenarios.

```rust
use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags};
use netstat2::error::Error;

fn main() {
    let result = get_sockets_info(
        AddressFamilyFlags::IPV4,
        ProtocolFlags::TCP
    );

    match result {
        Ok(sockets) => {
            println!("Found {} sockets", sockets.len());
        }
        Err(Error::OsError(e)) => {
            eprintln!("OS error occurred: {}", e);
        }
        Err(Error::FailedToListProcesses(e)) => {
            eprintln!("Could not list processes for PID lookup: {}", e);
        }
        Err(Error::FailedToGetTcpTable(code)) => {
            eprintln!("Failed to get TCP table, error code: {}", code);
        }
        Err(Error::FailedToGetUdpTable(code)) => {
            eprintln!("Failed to get UDP table, error code: {}", code);
        }
        #[cfg(any(target_os = "linux", target_os = "android"))]
        Err(Error::NetLinkError) => {
            eprintln!("Netlink communication error");
        }
        Err(e) => {
            eprintln!("Other error: {}", e);
        }
    }
}
```

--------------------------------

### Query Sockets by Address Family

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Use AddressFamilyFlags to specify IPv4, IPv6, or both when querying sockets. Combine with ProtocolFlags for specific protocol filtering.

```rust
use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags};

fn main() -> Result<(), netstat2::error::Error> {
    // Query only IPv4 sockets
    let ipv4_sockets = get_sockets_info(
        AddressFamilyFlags::IPV4,
        ProtocolFlags::TCP | ProtocolFlags::UDP
    )?;
    println!("IPv4 sockets: {}", ipv4_sockets.len());

    // Query only IPv6 sockets
    let ipv6_sockets = get_sockets_info(
        AddressFamilyFlags::IPV6,
        ProtocolFlags::TCP | ProtocolFlags::UDP
    )?;
    println!("IPv6 sockets: {}", ipv6_sockets.len());

    // Query all address families
    let all_sockets = get_sockets_info(
        AddressFamilyFlags::all(),
        ProtocolFlags::TCP | ProtocolFlags::UDP
    )?;
    println!("All sockets: {}", all_sockets.len());

    Ok(())
}
```

--------------------------------

### iterate_sockets_info_without_pids (Linux/Android only)

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

A performance-optimized function for Linux/Android that retrieves socket information without PID lookups, significantly faster when process information is not needed.

```APIDOC
## iterate_sockets_info_without_pids (Linux/Android only)

### Description
A performance-optimized function that retrieves socket information without performing PID lookups via procfs. This is significantly faster when process information is not needed.

### Platform
Linux, Android

### Parameters
#### Query Parameters
- **address_family_flags** (AddressFamilyFlags) - Required - Flags to filter by address family (e.g., IPv4, IPv6).
- **protocol_flags** (ProtocolFlags) - Required - Flags to filter by protocol (e.g., TCP, UDP).

### Response
#### Success Response (200)
- **Iterator<Result<SocketInfo, Error>>** - An iterator yielding `SocketInfo` structs (without PID information) or errors.

### Request Example
```rust
#[cfg(any(target_os = "linux", target_os = "android"))]
use netstat2::{iterate_sockets_info_without_pids, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo};

#[cfg(any(target_os = "linux", target_os = "android"))]
fn count_established_connections() -> Result<usize, netstat2::error::Error> {
    use netstat2::TcpState;

    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
    let proto_flags = ProtocolFlags::TCP;

    let count = iterate_sockets_info_without_pids(af_flags, proto_flags)?
        .filter_map(|r| r.ok())
        .filter(|si| {
            matches!(
                &si.protocol_socket_info,
                ProtocolSocketInfo::Tcp(tcp) if tcp.state == TcpState::Established
            )
        })
        .count();

    Ok(count)
}
```
```

--------------------------------

### Retrieve and iterate over network sockets

Source: https://github.com/ohadravid/netstat2-rs/blob/main/README.md

Use get_sockets_info to fetch socket data and match against protocol types to access specific TCP or UDP information.

```rust
use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
    let proto_flags = ProtocolFlags::TCP | ProtocolFlags::UDP;
    let sockets_info = get_sockets_info(af_flags, proto_flags)?;
    
    for si in sockets_info {
        match si.protocol_socket_info {
            ProtocolSocketInfo::Tcp(tcp_si) => println!(
                "TCP {}:{} -> {}:{} {:?} - {}",
                tcp_si.local_addr,
                tcp_si.local_port,
                tcp_si.remote_addr,
                tcp_si.remote_port,
                si.associated_pids,
                tcp_si.state
            ),
            ProtocolSocketInfo::Udp(udp_si) => println!(
                "UDP {}:{} -> *:* {:?}",
                udp_si.local_addr, udp_si.local_port, si.associated_pids
            ),
        }
    }

    Ok(())
}
```

--------------------------------

### Iterate over socket information with iterate_sockets_info

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Provides an iterator over socket information to avoid upfront memory allocation. Ideal for processing large datasets or implementing short-circuiting logic.

```rust
use netstat2::{iterate_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo, TcpState};

fn find_listening_port(port: u16) -> Result<Option<Vec<u32>>, netstat2::error::Error> {
    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
    let proto_flags = ProtocolFlags::TCP;

    for socket_result in iterate_sockets_info(af_flags, proto_flags)? {
        let socket = socket_result?;
        if let ProtocolSocketInfo::Tcp(tcp_si) = &socket.protocol_socket_info {
            if tcp_si.local_port == port && tcp_si.state == TcpState::Listen {
                return Ok(Some(socket.associated_pids));
            }
        }
    }

    Ok(None)
}

fn main() -> Result<(), netstat2::error::Error> {
    // Find which process is listening on port 8080
    match find_listening_port(8080)? {
        Some(pids) => println!("Port 8080 is used by PIDs: {:?}", pids),
        None => println!("Port 8080 is not in use"),
    }
    Ok(())
}
```

--------------------------------

### Retrieve socket information without PID lookups

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

A performance-optimized iterator for Linux and Android that skips PID lookups. Use this when process association is not required to significantly improve execution speed.

```rust
#[cfg(any(target_os = "linux", target_os = "android"))]
use netstat2::{iterate_sockets_info_without_pids, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo};

#[cfg(any(target_os = "linux", target_os = "android"))]
fn count_established_connections() -> Result<usize, netstat2::error::Error> {
    use netstat2::TcpState;

    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
    let proto_flags = ProtocolFlags::TCP;

    let count = iterate_sockets_info_without_pids(af_flags, proto_flags)?
        .filter_map(|r| r.ok())
        .filter(|si| {
            matches!(
                &si.protocol_socket_info,
                ProtocolSocketInfo::Tcp(tcp) if tcp.state == TcpState::Established
            )
        })
        .count();

    Ok(count)
}
```

--------------------------------

### iterate_sockets_info

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Returns an iterator over socket information, useful for processing large numbers of sockets without upfront memory allocation or for short-circuiting.

```APIDOC
## iterate_sockets_info

### Description
Returns an iterator over socket information instead of collecting into a vector. This is useful for processing large numbers of sockets without allocating memory for all results upfront, or for short-circuiting when a specific socket is found.

### Parameters
#### Query Parameters
- **address_family_flags** (AddressFamilyFlags) - Required - Flags to filter by address family (e.g., IPv4, IPv6).
- **protocol_flags** (ProtocolFlags) - Required - Flags to filter by protocol (e.g., TCP, UDP).

### Response
#### Success Response (200)
- **Iterator<Result<SocketInfo, Error>>** - An iterator yielding `SocketInfo` structs or errors.

### Request Example
```rust
use netstat2::{iterate_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo, TcpState};

fn find_listening_port(port: u16) -> Result<Option<Vec<u32>>, netstat2::error::Error> {
    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
    let proto_flags = ProtocolFlags::TCP;

    for socket_result in iterate_sockets_info(af_flags, proto_flags)? {
        let socket = socket_result?;
        if let ProtocolSocketInfo::Tcp(tcp_si) = &socket.protocol_socket_info {
            if tcp_si.local_port == port && tcp_si.state == TcpState::Listen {
                return Ok(Some(socket.associated_pids));
            }
        }
    }

    Ok(None)
}

fn main() -> Result<(), netstat2::error::Error> {
    // Find which process is listening on port 8080
    match find_listening_port(8080)? {
        Some(pids) => println!("Port 8080 is used by PIDs: {:?}", pids),
        None => println!("Port 8080 is not in use"),
    }
    Ok(())
}
```
```

--------------------------------

### get_sockets_info

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Retrieves all network socket information for specified address families and protocols. It returns a vector of SocketInfo structs.

```APIDOC
## get_sockets_info

### Description
The primary function for retrieving all network socket information. It accepts address family flags (IPv4/IPv6) and protocol flags (TCP/UDP) to filter results, returning a vector of `SocketInfo` structs containing socket details and associated process IDs.

### Parameters
#### Query Parameters
- **address_family_flags** (AddressFamilyFlags) - Required - Flags to filter by address family (e.g., IPv4, IPv6).
- **protocol_flags** (ProtocolFlags) - Required - Flags to filter by protocol (e.g., TCP, UDP).

### Response
#### Success Response (200)
- **Vec<SocketInfo>** - A vector containing `SocketInfo` structs for each matching socket.

### Request Example
```rust
use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo, TcpState};

fn main() -> Result<(), netstat2::error::Error> {
    // Query all IPv4 and IPv6 TCP and UDP sockets
    let af_flags = AddressFamilyFlags::IPV4 | AddressFamilyFlags::IPV6;
    let proto_flags = ProtocolFlags::TCP | ProtocolFlags::UDP;

    let sockets_info = get_sockets_info(af_flags, proto_flags)?;

    for si in sockets_info {
        match si.protocol_socket_info {
            ProtocolSocketInfo::Tcp(tcp_si) => println!(
                "TCP {}:{} -> {}:{} {:?} - {}",
                tcp_si.local_addr,
                tcp_si.local_port,
                tcp_si.remote_addr,
                tcp_si.remote_port,
                si.associated_pids,
                tcp_si.state
            ),
            ProtocolSocketInfo::Udp(udp_si) => println!(
                "UDP {}:{} -> *:* {:?}",
                udp_si.local_addr,
                udp_si.local_port,
                si.associated_pids
            ),
        }
    }

    Ok(())
}
```
```

--------------------------------

### Accessing Socket Information

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Iterate through socket query results to access local address, port, associated PIDs, and protocol-specific details. Platform-specific fields like inode and UID are available on Linux/Android.

```rust
use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo};
use std::net::IpAddr;

fn main() -> Result<(), netstat2::error::Error> {
    let sockets = get_sockets_info(
        AddressFamilyFlags::IPV4,
        ProtocolFlags::TCP
    )?;

    for socket in sockets {
        // Use helper methods for common access patterns
        let local_addr: IpAddr = socket.local_addr();
        let local_port: u16 = socket.local_port();
        let pids: &Vec<u32> = &socket.associated_pids;

        println!("Socket at {}:{} owned by PIDs: ?", local_addr, local_port, pids);

        // Access protocol-specific information via pattern matching
        match &socket.protocol_socket_info {
            ProtocolSocketInfo::Tcp(tcp) => {
                println!("  Remote: {}:{}", tcp.remote_addr, tcp.remote_port);
                println!("  State: {}", tcp.state);
            }
            ProtocolSocketInfo::Udp(udp) => {
                println!("  UDP local: {}:{}", udp.local_addr, udp.local_port);
            }
        }

        // Linux/Android-specific fields
        #[cfg(any(target_os = "linux", target_os = "android"))]
        println!("  Inode: {}, UID: {}", socket.inode, socket.uid);
    }

    Ok(())
}
```

--------------------------------

### Analyzing TCP Connection States

Source: https://context7.com/ohadravid/netstat2-rs/llms.txt

Query TCP sockets and count occurrences of each TCP state using a HashMap. The TcpState enum provides human-readable representations of connection states.

```rust
use netstat2::{get_sockets_info, AddressFamilyFlags, ProtocolFlags, ProtocolSocketInfo, TcpState};

fn main() -> Result<(), netstat2::error::Error> {
    let sockets = get_sockets_info(AddressFamilyFlags::all(), ProtocolFlags::TCP)?;

    // Count sockets by state
    let mut state_counts = std::collections::HashMap::new();

    for socket in &sockets {
        if let ProtocolSocketInfo::Tcp(tcp) = &socket.protocol_socket_info {
            *state_counts.entry(tcp.state).or_insert(0) += 1;
        }
    }

    // Available TCP states:
    // TcpState::Closed, TcpState::Listen, TcpState::SynSent, TcpState::SynReceived,
    // TcpState::Established, TcpState::FinWait1, TcpState::FinWait2, TcpState::CloseWait,
    // TcpState::Closing, TcpState::LastAck, TcpState::TimeWait, TcpState::DeleteTcb,
    // TcpState::Unknown

    println!("TCP Socket States:");
    if let Some(&count) = state_counts.get(&TcpState::Listen) {
        println!("  LISTEN: {}", count);
    }
    if let Some(&count) = state_counts.get(&TcpState::Established) {
        println!("  ESTABLISHED: {}", count);
    }
    if let Some(&count) = state_counts.get(&TcpState::TimeWait) {
        println!("  TIME_WAIT: {}", count);
    }
    if let Some(&count) = state_counts.get(&TcpState::CloseWait) {
        println!("  CLOSE_WAIT: {}", count);
    }

    Ok(())
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.