在Rust中进行Linux网络编程，你可以使用标准库中的std::net模块，它提供了一些基本的类型和函数来处理网络连接。此外，还有一些第三方库，如tokio和mio，它们提供了异步I/O操作，这对于构建高性能的网络服务非常有用。

以下是一个简单的例子，展示了如何使用Rust的标准库创建一个TCP服务器和客户端。

创建一个TCP服务器

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 1024];

    // 从客户端读取数据
    match stream.read(&mut buffer) {
        Ok(size) => {
            if size == 0 {
                println!("Client disconnected");
                return;
            }

            // 向客户端发送数据
            println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));
            stream.write_all(b"Hello from server!").unwrap();
        }
        Err(error) => {
            eprintln!("Error reading from socket: {}", error);
        }
    }
}

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7878")?;

    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                // 为每个连接创建一个新的线程
                std::thread::spawn(|| handle_client(stream));
            }
            Err(error) => {
                eprintln!("Error: {}", error);
            }
        }
    }

    Ok(())
}

创建一个TCP客户端

use std::io::{Read, Write};
use std::net::TcpStream;

fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:7878")?;

    // 向服务器发送数据
    stream.write_all(b"Hello from client!")?;

    let mut buffer = [0; 1024];
    // 从服务器读取数据
    match stream.read(&mut buffer) {
        Ok(size) => {
            println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));
        }
        Err(error) => {
            eprintln!("Error reading from socket: {}", error);
        }
    }

    Ok(())
}

在这个例子中，服务器监听本地的7878端口，并为每个连接创建一个新的线程来处理客户端请求。客户端连接到服务器，发送一条消息，然后读取服务器的响应。

如果你想要构建异步网络应用程序，你可以使用tokio库。以下是使用tokio创建一个简单的异步TCP回声服务器的例子：

use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:7878").await?;

    loop {
        let (mut socket, _) = listener.accept().await?;

        tokio::spawn(async move {
            let mut buf = [0; 1024];

            // 在循环中读取数据，直到客户端关闭连接
            loop {
                match socket.read(&mut buf).await {
                    Ok(0) => {
                        println!("Client disconnected");
                        return;
                    }
                    Ok(n) => {
                        // 将接收到的数据写回客户端
                        if socket.write_all(&buf[..n]).await.is_err() {
                            eprintln!("Failed to write to socket");
                            return;
                        }
                    }
                    Err(_) => {
                        eprintln!("Failed to read from socket");
                        return;
                    }
                }
            }
        });
    }
}

在这个例子中，服务器使用tokio::spawn来异步处理每个连接。这样可以同时处理多个连接，而不需要为每个连接创建一个新的线程。

在开始之前，请确保你的Rust环境已经设置好，并且你已经添加了必要的依赖项（如果使用第三方库）。对于tokio，你可以在Cargo.toml文件中添加以下依赖：

[dependencies]
tokio = { version = "1", features = ["full"] }

然后运行cargo build来编译你的项目。