ping-rust 0.3.2

Menu-driven installer and manager for the shoes proxy server
use anyhow::{bail, Result};
use clap::ValueEnum;
use rand::distr::{Alphanumeric, SampleString};
use serde::{Deserialize, Serialize};

pub const UNSUPPORTED: &str =
    "该客户端导出不支持 Xray FinalMask Sudoku,请用分享链接导入 v2rayN 或 Xray ≥ v26.3.27";

pub fn generate_password() -> String {
    Alphanumeric.sample_string(&mut rand::rng(), 24)
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, ValueEnum)]
#[serde(rename_all = "snake_case")]
pub enum SudokuAscii {
    #[default]
    PreferEntropy,
    Entropy,
    PreferAscii,
    Ascii,
}

impl SudokuAscii {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::PreferEntropy => "prefer_entropy",
            Self::Entropy => "entropy",
            Self::PreferAscii => "prefer_ascii",
            Self::Ascii => "ascii",
        }
    }
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SudokuConfig {
    pub password: String,
    #[serde(default)]
    pub ascii: SudokuAscii,
    #[serde(default)]
    pub padding_min: u8,
    #[serde(default)]
    pub padding_max: u8,
}

impl SudokuConfig {
    pub fn generated() -> Self {
        Self {
            password: generate_password(),
            ascii: SudokuAscii::default(),
            padding_min: 0,
            padding_max: 0,
        }
    }

    pub fn validate(&self) -> Result<()> {
        if self.padding_min > 100 || self.padding_max > 100 {
            bail!("Sudoku padding 必须在 0–100 范围内");
        }
        if self.padding_max < self.padding_min {
            bail!("Sudoku padding-max 不能小于 padding-min");
        }
        Ok(())
    }

    pub fn finalmask(&self) -> serde_json::Value {
        serde_json::json!({"tcp": [{"type": "sudoku", "settings": {
            "password": self.password, "ascii": self.ascii.as_str(),
            "paddingMin": self.padding_min, "paddingMax": self.padding_max
        }}]})
    }

    pub fn description(&self) -> String {
        format!(
            "外观:Sudoku({}、padding {}–{}%)",
            self.ascii.as_str(),
            self.padding_min,
            self.padding_max
        )
    }
}

#[derive(Clone, Debug, Default, clap::Args)]
pub struct SudokuOptions {
    /// 开启可选的 Sudoku TCP 外观(默认关闭)
    #[arg(id = "sudoku_enabled", long = "sudoku")]
    pub enabled: bool,
    /// Sudoku 共享密码,按原样使用;省略时安全随机生成 24 位字母数字
    #[arg(id = "sudoku_password", long = "sudoku-password")]
    pub password: Option<String>,
    /// Sudoku ASCII 模式(使用默认熵布局)
    #[arg(id = "sudoku_ascii", long = "sudoku-ascii", value_enum)]
    pub ascii: Option<SudokuAscii>,
    /// Sudoku 最小 padding 百分比
    #[arg(id = "sudoku_padding_min", long = "sudoku-padding-min", value_parser = clap::value_parser!(u8).range(0..=100))]
    pub padding_min: Option<u8>,
    /// Sudoku 最大 padding 百分比,不能小于 min
    #[arg(id = "sudoku_padding_max", long = "sudoku-padding-max", value_parser = clap::value_parser!(u8).range(0..=100))]
    pub padding_max: Option<u8>,
}

impl SudokuOptions {
    pub fn validate_for(&self, protocol: crate::config::Protocol) -> Result<()> {
        use crate::config::Protocol;
        let parameters = self.password.is_some()
            || self.ascii.is_some()
            || self.padding_min.is_some()
            || self.padding_max.is_some();
        if protocol != Protocol::VlessSudoku {
            if self.enabled && protocol != Protocol::VlessEnc {
                bail!("Sudoku 参数仅适用于 VLESS-ENC 或 VLESS-Sudoku");
            }
            if parameters && !self.enabled {
                bail!("VLESS-ENC 的 Sudoku 参数需要 --sudoku,其他协议不支持 Sudoku 参数");
            }
        }
        self.config_for(protocol)?;
        Ok(())
    }

    pub fn config_for(&self, protocol: crate::config::Protocol) -> Result<Option<SudokuConfig>> {
        let mut options = self.clone();
        options.enabled |= protocol == crate::config::Protocol::VlessSudoku;
        options.config()
    }
    pub fn config(&self) -> Result<Option<SudokuConfig>> {
        if !self.enabled {
            return Ok(None);
        }
        let config = SudokuConfig {
            password: self.password.clone().unwrap_or_else(generate_password),
            ascii: self.ascii.unwrap_or_default(),
            padding_min: self.padding_min.unwrap_or_default(),
            padding_max: self.padding_max.unwrap_or_default(),
        };
        config.validate()?;
        Ok(Some(config))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cli::{Cli, Command};
    use clap::Parser;

    fn options(args: &[&str]) -> Result<SudokuOptions> {
        let cli = Cli::try_parse_from(
            ["prs", "add", "vless-enc"]
                .into_iter()
                .chain(args.iter().copied()),
        )?;
        let Some(Command::Add(args)) = cli.command else {
            panic!()
        };
        Ok(args.vless_enc.sudoku)
    }

    #[test]
    fn sudoku_cli_help_is_concise_and_restricts_protocol() {
        use clap::CommandFactory;
        let mut cli = Cli::command();
        let help = cli
            .find_subcommand_mut("add")
            .unwrap()
            .render_long_help()
            .to_string();
        for removed in [
            "混淆",
            "4 倍",
            "TCP splice",
            "64 KiB",
            "UDP/QUIC",
            "v26.3.27",
        ] {
            assert!(!help.contains(removed), "{removed}");
        }
        let sudoku = options(&["--sudoku"]).unwrap();
        assert!(sudoku
            .validate_for(crate::config::Protocol::VlessEnc)
            .is_ok());
        assert!(sudoku
            .validate_for(crate::config::Protocol::Socks5)
            .is_err());
    }

    #[test]
    fn sudoku_cli_defaults_validation_and_password_preservation() {
        assert!(options(&[]).unwrap().config().unwrap().is_none());
        let config = options(&["--sudoku"]).unwrap().config().unwrap().unwrap();
        assert_eq!(config.ascii, SudokuAscii::PreferEntropy);
        assert_eq!((config.padding_min, config.padding_max), (0, 0));
        assert_eq!(config.password.len(), 24);
        assert!(config.password.bytes().all(|c| c.is_ascii_alphanumeric()));
        assert_ne!(config.password, SudokuConfig::generated().password);
        for (arg, expected) in [
            ("prefer-entropy", "prefer_entropy"),
            ("entropy", "entropy"),
            ("prefer-ascii", "prefer_ascii"),
            ("ascii", "ascii"),
        ] {
            let config = options(&[
                "--sudoku",
                "--sudoku-password",
                "  pass+%字  ",
                "--sudoku-ascii",
                arg,
                "--sudoku-padding-min",
                "10",
                "--sudoku-padding-max",
                "100",
            ])
            .unwrap()
            .config()
            .unwrap()
            .unwrap();
            assert_eq!(config.password, "  pass+%字  ");
            assert_eq!(config.ascii.as_str(), expected);
            assert_eq!((config.padding_min, config.padding_max), (10, 100));
        }
        for args in [
            vec!["--sudoku", "--sudoku-padding-min", "101"],
            vec!["--sudoku", "--sudoku-padding-max", "101"],
            vec!["--sudoku", "--sudoku-padding-min", "-1"],
            vec!["--sudoku", "--sudoku-ascii", "bad"],
        ] {
            assert!(options(&args).is_err(), "{args:?}");
        }
        // VLESS-Sudoku can omit --sudoku, so the shared semantic validator
        // now enforces this requirement for VLESS-ENC after clap parsing.
        for args in [
            vec!["--sudoku-password", "pass"],
            vec!["--sudoku-ascii", "ascii"],
            vec!["--sudoku-padding-min", "0"],
        ] {
            assert!(
                options(&args)
                    .unwrap()
                    .validate_for(crate::config::Protocol::VlessEnc)
                    .is_err(),
                "{args:?}"
            );
        }
        assert!(options(&[
            "--sudoku",
            "--sudoku-padding-min",
            "10",
            "--sudoku-padding-max",
            "9"
        ])
        .unwrap()
        .config()
        .is_err());
        let mask = SudokuConfig {
            padding_min: 101,
            ..SudokuConfig::generated()
        };
        assert!(mask.validate().is_err());
        let mask = SudokuConfig {
            padding_max: 101,
            ..SudokuConfig::generated()
        };
        assert!(mask.validate().is_err());
    }
}