ping-rust 0.2.0

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::{
        direct_rules, generate_shadowsocks_password, generated_password, Credentials,
        InnerProtocol, ServerConfig, ServerProtocol, ShadowTlsCredentials, ShadowTlsHandshake,
        ShadowTlsTarget, ShadowsocksMode,
    },
    GeneratedPreset, GenerationRequest,
};

pub(super) fn generate(
    request: &GenerationRequest,
    _parent: &Path,
    _profile_id: Uuid,
) -> Result<GeneratedPreset> {
    let cipher = request.options.shadowsocks_cipher;
    let password = request
        .options
        .shadowsocks_password
        .clone()
        .unwrap_or_else(|| generate_shadowsocks_password(cipher));
    if request.options.shadowsocks_mode == ShadowsocksMode::ShadowTlsV3 {
        let shadowtls_password = request
            .options
            .shadowtls_password
            .clone()
            .unwrap_or_else(generated_password);
        let handshake_address = request
            .options
            .shadowtls_handshake
            .clone()
            .unwrap_or_else(|| format!("{}:443", request.server_name));
        let shadowtls = ShadowTlsCredentials {
            password: shadowtls_password.clone(),
            server_name: request.server_name.clone(),
            handshake_address: handshake_address.clone(),
        };
        let mut shadowtls_targets = BTreeMap::new();
        shadowtls_targets.insert(
            request.server_name.clone(),
            ShadowTlsTarget {
                password: shadowtls_password,
                handshake: ShadowTlsHandshake {
                    address: handshake_address,
                },
                protocol: InnerProtocol::Shadowsocks {
                    cipher: cipher.as_str().to_owned(),
                    password: password.clone(),
                    udp_enabled: false,
                },
            },
        );
        return 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,
                    reality_targets: BTreeMap::new(),
                },
                rules: direct_rules(),
            },
            credentials: Credentials::Shadowsocks {
                cipher,
                password,
                udp_enabled: false,
                shadowtls: Some(shadowtls),
            },
            certificate_path: None,
            certificate_key_path: None,
        });
    }
    Ok(GeneratedPreset {
        server: ServerConfig {
            address: format!("0.0.0.0:{}", request.port),
            transport: None,
            quic_settings: None,
            protocol: ServerProtocol::Shadowsocks {
                cipher: cipher.as_str().to_owned(),
                password: password.clone(),
                udp_enabled: request.options.udp_enabled,
            },
            rules: direct_rules(),
        },
        credentials: Credentials::Shadowsocks {
            cipher,
            password,
            udp_enabled: request.options.udp_enabled,
            shadowtls: None,
        },
        certificate_path: None,
        certificate_key_path: None,
    })
}