ping-rust 0.3.2

Menu-driven installer and manager for the shoes proxy server
use std::{collections::BTreeMap, path::Path};

use anyhow::Result;
use uuid::Uuid;

use super::{
    super::{
        generate_reality_keypair, random_hex, Credentials, InnerProtocol, RealityTarget,
        ServerConfig, ServerProtocol, XhttpMode, XhttpSettings,
    },
    GeneratedPreset, GenerationRequest,
};

pub(super) fn generate(
    request: &GenerationRequest,
    _parent: &Path,
    _profile_id: Uuid,
) -> Result<GeneratedPreset> {
    let keypair = generate_reality_keypair();
    let user_id = Uuid::new_v4();
    let short_id = request
        .options
        .reality_short_id
        .clone()
        .unwrap_or_else(|| random_hex(8));
    let xhttp = XhttpSettings {
        path: request
            .options
            .xhttp_path
            .clone()
            .unwrap_or_else(|| format!("/{}", random_hex(8))),
        mode: XhttpMode::Auto,
    };
    Ok(GeneratedPreset {
        server: ServerConfig {
            address: format!("0.0.0.0:{}", request.port),
            transport: None,
            quic_settings: None,
            protocol: ServerProtocol::Tls {
                tls_targets: BTreeMap::new(),
                shadowtls_targets: BTreeMap::new(),
                reality_targets: BTreeMap::from([(
                    request.server_name.clone(),
                    RealityTarget {
                        private_key: keypair.private_key.clone(),
                        short_ids: vec![short_id.clone()],
                        dest: request
                            .reality_dest
                            .clone()
                            .unwrap_or_else(|| format!("{}:443", request.server_name)),
                        max_time_diff: request.options.reality_max_time_diff,
                        vision: false,
                        protocol: InnerProtocol::Xhttp {
                            path: xhttp.path.clone(),
                            mode: xhttp.mode,
                            limits: None,
                            protocol: Box::new(InnerProtocol::Vless {
                                user_id,
                                udp_enabled: request.options.udp_enabled,
                            }),
                        },
                    },
                )]),
            },
            rules: Vec::new(),
        },
        credentials: Credentials::VlessXhttpReality {
            user_id,
            private_key: keypair.private_key,
            public_key: keypair.public_key,
            short_id,
            server_name: request.server_name.clone(),
            xhttp,
        },
        certificate_path: None,
        certificate_key_path: None,
        naive_certificate_validity: None,
    })
}