Rust HTTP请求处理库paw-raw的使用指南

概述

paw-raw是一个专门用于高效解析和操作原始HTTP请求数据的Rust库。它提供了对HTTP请求的低级访问，特别适合需要处理原始HTTP数据或构建自定义HTTP服务器的场景。

主要特性

• 零拷贝解析HTTP请求
• 支持流式处理
• 提供原始HTTP数据访问
• 高性能的请求解析
• 灵活的API设计

安装方法

在Cargo.toml中添加依赖：

[dependencies]
paw-raw = "0.3"

基本使用方法

1. 解析HTTP请求

use paw_raw::{Request, Method};

fn main() {
    let raw_request = b"GET /index.html HTTP/1.1\r\nHost: example.com\r\n\r\n";
    
    match Request::parse(raw_request) {
        Ok(request) => {
            println!("Method: {:?}", request.method());
            println!("Path: {}", request.path());
            println!("Version: {:?}", request.version());
        }
        Err(e) => eprintln!("解析错误: {}", e),
    }
}

2. 访问请求头

use paw_raw::Request;

fn process_headers(request: &Request) {
    for header in request.headers() {
        println!("{}: {}", header.name(), header.value());
    }
    
    // 获取特定头
    if let Some(host) = request.header("Host") {
        println!("Host头值: {}", host);
    }
}

3. 处理请求体

use paw_raw::Request;

fn handle_request_body(request: &Request) {
    if let Some(body) = request.body() {
        println!("请求体长度: {}", body.len());
        println!("请求体内容: {:?}", body);
    }
}

4. 构建自定义请求处理器

use paw_raw::{Request, Response, StatusCode};

fn handle_request(raw_request: &[u8]) -> Vec<u8> {
    match Request::parse(raw_request) {
        Ok(request) => {
            // 自定义处理逻辑
            let response = Response::builder()
                .status(StatusCode::OK)
                .header("Content-Type", "text/plain")
                .body(b"Hello from paw-raw!".to_vec())
                .unwrap();
            
            response.into_bytes()
        }
        Err(_) => {
            // 返回错误响应
            Response::builder()
                .status(StatusCode::BAD_REQUEST)
                .body(b"Invalid request".to_vec())
                .unwrap()
                .into_bytes()
        }
    }
}

5. 流式处理示例

use paw_raw::{RequestParser, ParseResult};
use std::io::{self, Read};

fn process_stream<T: Read>(mut stream: T) -> io::Result<()> {
    let mut parser = RequestParser::new();
    let mut buffer = [0; 1024];
    
    loop {
        let bytes_read = stream.read(&mut buffer)?;
        if bytes_read == 0 {
            break;
        }
        
        match parser.parse(&buffer[..bytes_read]) {
            ParseResult::Complete(request) => {
                println!("收到完整请求: {:?}", request.method());
                parser.reset();
            }
            ParseResult::Partial => continue,
            ParseResult::Error(e) => {
                eprintln!("解析错误: {}", e);
                break;
            }
        }
    }
    
    Ok(())
}

高级用法

自定义解析配置

use paw_raw::{RequestParser, ParserConfig};

let config = ParserConfig::new()
    .max_headers(100)
    .max_header_length(8192)
    .max_body_length(1024 * 1024); // 1MB

let parser = RequestParser::with_config(config);

处理分块传输编码

use paw_raw::{Request, ChunkedDecoder};

fn handle_chunked_request(request: &Request) {
    if let Some(decoder) = ChunkedDecoder::new(request.body().unwrap()) {
        for chunk in decoder {
            match chunk {
                Ok(data) => println!("收到分块数据: {:?}", data),
                Err(e) => eprintln!("分块解码错误: {}", e),
            }
        }
    }
}

性能提示

1. 重用RequestParser实例以避免重复分配
2. 使用slice操作而不是拷贝数据
3. 合理配置解析器限制以防止DoS攻击
4. 对于高性能场景，考虑使用异步处理

错误处理

use paw_raw::{Request, ParseError};

fn safe_parse(data: &[u8]) -> Result<Request, String> {
    match Request::parse(data) {
        Ok(req) => Ok(req),
        Err(ParseError::Incomplete) => Err("数据不完整".to_string()),
        Err(ParseError::Invalid) => Err("无效的HTTP请求".to_string()),
        Err(ParseError::TooLarge) => Err("请求过大".to_string()),
    }
}

完整示例demo

use paw_raw::{Request, Response, StatusCode, RequestParser, ParseResult, ParseError};
use std::io::{self, Read};
use std::net::{TcpListener, TcpStream};

// 简单的HTTP服务器示例
fn main() -> io::Result<()> {
    // 创建TCP监听器
    let listener = TcpListener::bind("127.0.0.1:8080")?;
    println!("服务器启动在 127.0.0.1:8080");
    
    // 处理传入连接
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                // 处理每个连接
                if let Err(e) = handle_client(stream) {
                    eprintln!("处理客户端错误: {}", e);
                }
            }
            Err(e) => eprintln!("连接错误: {}", e),
        }
    }
    
    Ok(())
}

// 处理客户端连接
fn handle_client(mut stream: TcpStream) -> io::Result<()> {
    let mut parser = RequestParser::new();
    let mut buffer = [0; 1024];
    
    loop {
        // 读取数据
        let bytes_read = stream.read(&mut buffer)?;
        if bytes_read == 0 {
            break;
        }
        
        // 解析请求
        match parser.parse(&buffer[..bytes_read]) {
            ParseResult::Complete(request) => {
                println!("收到请求: {} {}", request.method(), request.path());
                
                // 生成响应
                let response = build_response(&request);
                
                // 发送响应
                stream.write_all(&response)?;
                
                // 重置解析器以处理下一个请求
                parser.reset();
            }
            ParseResult::Partial => {
                // 继续读取更多数据
                continue;
            }
            ParseResult::Error(e) => {
                // 发送错误响应
                let error_response = Response::builder()
                    .status(StatusCode::BAD_REQUEST)
                    .body(format!("解析错误: {}", e).into_bytes())
                    .unwrap()
                    .into_bytes();
                
                stream.write_all(&error_response)?;
                break;
            }
        }
    }
    
    Ok(())
}

// 构建响应
fn build_response(request: &Request) -> Vec<u8> {
    // 根据请求路径返回不同响应
    match request.path() {
        "/" => {
            Response::builder()
                .status(StatusCode::OK)
                .header("Content-Type", "text/html")
                .body(b"<h1>欢迎使用paw-raw!</h1>".to_vec())
                .unwrap()
                .into_bytes()
        }
        "/api/data" => {
            Response::builder()
                .status(StatusCode::OK)
                .header("Content-Type", "application/json")
                .body(br#"{"message": "Hello from API"}"#.to_vec())
                .unwrap()
                .into_bytes()
        }
        _ => {
            Response::builder()
                .status(StatusCode::NOT_FOUND)
                .body(b"404 Not Found".to_vec())
                .unwrap()
                .into_bytes()
        }
    }
}

// 错误处理示例
fn safe_request_processing(data: &[u8]) -> Result<Vec<u8>, String> {
    match Request::parse(data) {
        Ok(request) => {
            // 处理请求并返回响应
            Ok(build_response(&request))
        }
        Err(ParseError::Incomplete) => Err("请求数据不完整".to_string()),
        Err(ParseError::Invalid) => Err("无效的HTTP请求格式".to_string()),
        Err(ParseError::TooLarge) => Err("请求过大".to_string()),
    }
}

// 流式处理增强版
fn advanced_stream_processing<T: Read>(mut stream: T) -> io::Result<Vec<u8>> {
    let mut parser = RequestParser::new();
    let mut buffer = [0; 4096]; // 使用更大的缓冲区
    let mut request_data = Vec::new();
    
    loop {
        let bytes_read = stream.read(&mut buffer)?;
        if bytes_read == 0 {
            break;
        }
        
        request_data.extend_from_slice(&buffer[..bytes_read]);
        
        match parser.parse(&request_data) {
            ParseResult::Complete(request) => {
                // 处理完整的请求
                let response = build_response(&request);
                return Ok(response);
            }
            ParseResult::Partial => continue,
            ParseResult::Error(e) => {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidData,
                    format!("解析错误: {}", e)
                ));
            }
        }
    }
    
    Err(io::Error::new(io::ErrorKind::UnexpectedEof, "连接意外关闭"))
}

这个库为需要处理原始HTTP数据的开发者提供了强大而灵活的工具，特别适合构建自定义HTTP服务器、代理或中间件。