mirror of
https://github.com/shadowsocks/shadowsocks-rust.git
synced 2026-11-18 00:16:30 +00:00
1002 lines
30 KiB
Rust
1002 lines
30 KiB
Rust
//! This is a mod for storing and parsing configuration
|
|
//!
|
|
//! According to shadowsocks' official documentation, the standard configuration
|
|
//! file should be in JSON format:
|
|
//!
|
|
//! ```ignore
|
|
//! {
|
|
//! "server": "127.0.0.1",
|
|
//! "server_port": 1080,
|
|
//! "local_port": 8388,
|
|
//! "password": "the-password",
|
|
//! "timeout": 300,
|
|
//! "method": "aes-256-cfb",
|
|
//! "local_address": "127.0.0.1"
|
|
//! }
|
|
//! ```
|
|
//!
|
|
//! But this configuration is not for using multiple shadowsocks server, so we
|
|
//! introduce an extended configuration file format:
|
|
//!
|
|
//! ```ignore
|
|
//! {
|
|
//! "servers": [
|
|
//! {
|
|
//! "address": "127.0.0.1",
|
|
//! "port": 1080,
|
|
//! "password": "hellofuck",
|
|
//! "method": "bf-cfb"
|
|
//! },
|
|
//! {
|
|
//! "address": "127.0.0.1",
|
|
//! "port": 1081,
|
|
//! "password": "hellofuck",
|
|
//! "method": "aes-128-cfb"
|
|
//! }
|
|
//! ],
|
|
//! "local_port": 8388,
|
|
//! "local_address": "127.0.0.1"
|
|
//! }
|
|
//! ```
|
|
//!
|
|
//! These defined server will be used with a load balancing algorithm.
|
|
|
|
use std::{
|
|
collections::HashSet,
|
|
convert::From,
|
|
default::Default,
|
|
error,
|
|
fmt::{self, Debug, Display, Formatter},
|
|
fs::OpenOptions,
|
|
io::{self, Read},
|
|
net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
|
|
option::Option,
|
|
path::Path,
|
|
str::FromStr,
|
|
string::ToString,
|
|
time::Duration,
|
|
};
|
|
|
|
use base64::{decode_config, encode_config, URL_SAFE_NO_PAD};
|
|
use bytes::Bytes;
|
|
use json5;
|
|
use log::error;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_urlencoded;
|
|
#[cfg(feature = "trust-dns")]
|
|
use trust_dns_resolver::config::{NameServerConfigGroup, ResolverConfig};
|
|
use url::{self, Url};
|
|
|
|
use crate::{
|
|
context::Context,
|
|
crypto::cipher::CipherType,
|
|
plugin::PluginConfig,
|
|
relay::{dns_resolver::resolve_bind_addr, socks5::Address},
|
|
};
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Default)]
|
|
struct SSConfig {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
server: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
server_port: Option<u16>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
local_address: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
local_port: Option<u16>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
password: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
method: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
plugin: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
plugin_opts: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
timeout: Option<u64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
udp_timeout: Option<u64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
servers: Option<Vec<SSServerExtConfig>>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
forbidden_ip: Option<Vec<String>>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
dns: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
mode: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
no_delay: Option<bool>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
nofile: Option<u64>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
struct SSServerExtConfig {
|
|
address: String,
|
|
port: u16,
|
|
password: String,
|
|
method: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
plugin: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
plugin_opts: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
timeout: Option<u64>,
|
|
}
|
|
|
|
/// Server address
|
|
#[derive(Clone, Debug)]
|
|
pub enum ServerAddr {
|
|
/// IP Address
|
|
SocketAddr(SocketAddr),
|
|
/// Domain name address, eg. example.com:8080
|
|
DomainName(String, u16),
|
|
}
|
|
|
|
impl ServerAddr {
|
|
/// Get string representation of domain
|
|
pub fn host(&self) -> String {
|
|
match *self {
|
|
ServerAddr::SocketAddr(ref s) => s.ip().to_string(),
|
|
ServerAddr::DomainName(ref dm, _) => dm.clone(),
|
|
}
|
|
}
|
|
|
|
/// Get port
|
|
pub fn port(&self) -> u16 {
|
|
match *self {
|
|
ServerAddr::SocketAddr(ref s) => s.port(),
|
|
ServerAddr::DomainName(_, p) => p,
|
|
}
|
|
}
|
|
|
|
/// Convert for calling `bind()`
|
|
pub async fn bind_addr(&self, context: &Context) -> io::Result<SocketAddr> {
|
|
match resolve_bind_addr(context, self).await {
|
|
Ok(s) => Ok(s),
|
|
Err(err) => {
|
|
error!("Failed to resolve {} for bind(), error: {}", self, err);
|
|
Err(err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Parse `ServerAddr` error
|
|
#[derive(Debug)]
|
|
pub struct ServerAddrError;
|
|
|
|
impl FromStr for ServerAddr {
|
|
type Err = ServerAddrError;
|
|
|
|
fn from_str(s: &str) -> Result<ServerAddr, ServerAddrError> {
|
|
match s.parse::<SocketAddr>() {
|
|
Ok(addr) => Ok(ServerAddr::SocketAddr(addr)),
|
|
Err(..) => {
|
|
let mut sp = s.split(':');
|
|
match (sp.next(), sp.next()) {
|
|
(Some(dn), Some(port)) => match port.parse::<u16>() {
|
|
Ok(port) => Ok(ServerAddr::DomainName(dn.to_owned(), port)),
|
|
Err(..) => Err(ServerAddrError),
|
|
},
|
|
_ => Err(ServerAddrError),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for ServerAddr {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
match *self {
|
|
ServerAddr::SocketAddr(ref a) => write!(f, "{}", a),
|
|
ServerAddr::DomainName(ref d, port) => write!(f, "{}:{}", d, port),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<SocketAddr> for ServerAddr {
|
|
fn from(addr: SocketAddr) -> ServerAddr {
|
|
ServerAddr::SocketAddr(addr)
|
|
}
|
|
}
|
|
|
|
impl<I: Into<String>> From<(I, u16)> for ServerAddr {
|
|
fn from((dname, port): (I, u16)) -> ServerAddr {
|
|
ServerAddr::DomainName(dname.into(), port)
|
|
}
|
|
}
|
|
|
|
/// Configuration for a server
|
|
#[derive(Clone, Debug)]
|
|
pub struct ServerConfig {
|
|
/// Server address
|
|
addr: ServerAddr,
|
|
/// Encryption password (key)
|
|
password: String,
|
|
/// Encryption type (method)
|
|
method: CipherType,
|
|
/// Connection timeout
|
|
timeout: Option<Duration>,
|
|
/// Encryption key
|
|
enc_key: Bytes,
|
|
/// Plugin config
|
|
plugin: Option<PluginConfig>,
|
|
/// Plugin address
|
|
plugin_addr: Option<ServerAddr>,
|
|
}
|
|
|
|
impl ServerConfig {
|
|
/// Creates a new ServerConfig
|
|
pub fn new(
|
|
addr: ServerAddr,
|
|
pwd: String,
|
|
method: CipherType,
|
|
timeout: Option<Duration>,
|
|
plugin: Option<PluginConfig>,
|
|
) -> ServerConfig {
|
|
let enc_key = method.bytes_to_key(pwd.as_bytes());
|
|
ServerConfig {
|
|
addr,
|
|
password: pwd,
|
|
method,
|
|
timeout,
|
|
enc_key,
|
|
plugin,
|
|
plugin_addr: None,
|
|
}
|
|
}
|
|
|
|
/// Create a basic config
|
|
pub fn basic(addr: SocketAddr, password: String, method: CipherType) -> ServerConfig {
|
|
ServerConfig::new(ServerAddr::SocketAddr(addr), password, method, None, None)
|
|
}
|
|
|
|
/// Set encryption method
|
|
pub fn set_method(&mut self, t: CipherType, pwd: String) {
|
|
self.password = pwd;
|
|
self.method = t;
|
|
self.enc_key = t.bytes_to_key(self.password.as_bytes());
|
|
}
|
|
|
|
/// Set plugin
|
|
pub fn set_plugin(&mut self, p: PluginConfig) {
|
|
self.plugin = Some(p);
|
|
}
|
|
|
|
/// Set server addr
|
|
pub fn set_addr(&mut self, a: ServerAddr) {
|
|
self.addr = a;
|
|
}
|
|
|
|
/// Get server address
|
|
pub fn addr(&self) -> &ServerAddr {
|
|
&self.addr
|
|
}
|
|
|
|
/// Get encryption key
|
|
pub fn key(&self) -> &[u8] {
|
|
&self.enc_key[..]
|
|
}
|
|
|
|
/// Clone encryption key
|
|
pub fn clone_key(&self) -> Bytes {
|
|
self.enc_key.clone()
|
|
}
|
|
|
|
/// Get password
|
|
pub fn password(&self) -> &str {
|
|
&self.password[..]
|
|
}
|
|
|
|
/// Get method
|
|
pub fn method(&self) -> CipherType {
|
|
self.method
|
|
}
|
|
|
|
/// Get timeout
|
|
pub fn timeout(&self) -> Option<Duration> {
|
|
self.timeout
|
|
}
|
|
|
|
/// Get plugin
|
|
pub fn plugin(&self) -> Option<&PluginConfig> {
|
|
self.plugin.as_ref()
|
|
}
|
|
|
|
/// Set plugin address
|
|
pub fn set_plugin_addr(&mut self, a: ServerAddr) {
|
|
self.plugin_addr = Some(a);
|
|
}
|
|
|
|
/// Get plugin address
|
|
pub fn plugin_addr(&self) -> &Option<ServerAddr> {
|
|
&self.plugin_addr
|
|
}
|
|
|
|
/// Get URL for QRCode
|
|
/// ```plain
|
|
/// ss:// + base64(method:password@host:port)
|
|
/// ```
|
|
pub fn to_qrcode_url(&self) -> String {
|
|
let param = format!("{}:{}@{}", self.method(), self.password(), self.addr());
|
|
format!("ss://{}", encode_config(¶m, URL_SAFE_NO_PAD))
|
|
}
|
|
|
|
/// Get [SIP002](https://github.com/shadowsocks/shadowsocks-org/issues/27) URL
|
|
pub fn to_url(&self) -> String {
|
|
let user_info = format!("{}:{}", self.method(), self.password());
|
|
let encoded_user_info = encode_config(&user_info, URL_SAFE_NO_PAD);
|
|
|
|
let mut url = format!("ss://{}@{}", encoded_user_info, self.addr());
|
|
if let Some(c) = self.plugin() {
|
|
let mut plugin = c.plugin.clone();
|
|
if let Some(ref opt) = c.plugin_opt {
|
|
plugin += ";";
|
|
plugin += opt;
|
|
}
|
|
|
|
let plugin_param = [("plugin", &plugin)];
|
|
url += "/?";
|
|
url += &serde_urlencoded::to_string(&plugin_param).unwrap();
|
|
}
|
|
|
|
url
|
|
}
|
|
|
|
/// Parse from [SIP002](https://github.com/shadowsocks/shadowsocks-org/issues/27) URL
|
|
pub fn from_url(encoded: &str) -> Result<ServerConfig, UrlParseError> {
|
|
let parsed = Url::parse(encoded).map_err(UrlParseError::from)?;
|
|
|
|
if parsed.scheme() != "ss" {
|
|
return Err(UrlParseError::InvalidScheme);
|
|
}
|
|
|
|
let user_info = parsed.username();
|
|
let account = match decode_config(user_info, URL_SAFE_NO_PAD) {
|
|
Ok(account) => match String::from_utf8(account) {
|
|
Ok(ac) => ac,
|
|
Err(..) => {
|
|
return Err(UrlParseError::InvalidAuthInfo);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
error!("Failed to parse UserInfo with Base64, err: {}", err);
|
|
return Err(UrlParseError::InvalidUserInfo);
|
|
}
|
|
};
|
|
|
|
let host = match parsed.host_str() {
|
|
Some(host) => host,
|
|
None => return Err(UrlParseError::MissingHost),
|
|
};
|
|
|
|
let port = parsed.port().unwrap_or(8388);
|
|
let addr = format!("{}:{}", host, port);
|
|
|
|
let mut sp2 = account.splitn(2, ':');
|
|
let (method, pwd) = match (sp2.next(), sp2.next()) {
|
|
(Some(m), Some(p)) => (m, p),
|
|
_ => panic!("Malformed input"),
|
|
};
|
|
|
|
let addr = match addr.parse::<ServerAddr>() {
|
|
Ok(a) => a,
|
|
Err(err) => {
|
|
error!("Failed to parse \"{}\" to ServerAddr, err: {:?}", addr, err);
|
|
return Err(UrlParseError::InvalidServerAddr);
|
|
}
|
|
};
|
|
|
|
let mut plugin = None;
|
|
if let Some(q) = parsed.query() {
|
|
let query = match serde_urlencoded::from_bytes::<Vec<(String, String)>>(q.as_bytes()) {
|
|
Ok(q) => q,
|
|
Err(err) => {
|
|
error!("Failed to parse QueryString, err: {}", err);
|
|
return Err(UrlParseError::InvalidQueryString);
|
|
}
|
|
};
|
|
|
|
for (key, value) in query {
|
|
if key != "plugin" {
|
|
continue;
|
|
}
|
|
|
|
let mut vsp = value.splitn(2, ';');
|
|
match vsp.next() {
|
|
None => {}
|
|
Some(p) => {
|
|
plugin = Some(PluginConfig {
|
|
plugin: p.to_owned(),
|
|
plugin_opt: vsp.next().map(ToOwned::to_owned),
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let svrconfig = ServerConfig::new(addr, pwd.to_owned(), method.parse().unwrap(), None, plugin);
|
|
|
|
Ok(svrconfig)
|
|
}
|
|
}
|
|
|
|
impl FromStr for ServerConfig {
|
|
type Err = UrlParseError;
|
|
|
|
fn from_str(s: &str) -> Result<ServerConfig, Self::Err> {
|
|
ServerConfig::from_url(s)
|
|
}
|
|
}
|
|
|
|
/// Shadowsocks URL parsing Error
|
|
#[derive(Debug, Clone)]
|
|
pub enum UrlParseError {
|
|
ParseError(url::ParseError),
|
|
InvalidScheme,
|
|
InvalidUserInfo,
|
|
MissingHost,
|
|
InvalidAuthInfo,
|
|
InvalidServerAddr,
|
|
InvalidQueryString,
|
|
}
|
|
|
|
impl From<url::ParseError> for UrlParseError {
|
|
fn from(err: url::ParseError) -> UrlParseError {
|
|
UrlParseError::ParseError(err)
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for UrlParseError {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match *self {
|
|
UrlParseError::ParseError(ref err) => fmt::Display::fmt(err, f),
|
|
UrlParseError::InvalidScheme => write!(f, "URL must have \"ss://\" scheme"),
|
|
UrlParseError::InvalidUserInfo => write!(f, "invalid user info"),
|
|
UrlParseError::MissingHost => write!(f, "missing host"),
|
|
UrlParseError::InvalidAuthInfo => write!(f, "invalid authentication info"),
|
|
UrlParseError::InvalidServerAddr => write!(f, "invalid server address"),
|
|
UrlParseError::InvalidQueryString => write!(f, "invalid query string"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl error::Error for UrlParseError {
|
|
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
|
|
match *self {
|
|
UrlParseError::ParseError(ref err) => Some(err as &dyn error::Error),
|
|
UrlParseError::InvalidScheme => None,
|
|
UrlParseError::InvalidUserInfo => None,
|
|
UrlParseError::MissingHost => None,
|
|
UrlParseError::InvalidAuthInfo => None,
|
|
UrlParseError::InvalidServerAddr => None,
|
|
UrlParseError::InvalidQueryString => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Listening address
|
|
pub type ClientConfig = ServerAddr;
|
|
|
|
/// Server config type
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub enum ConfigType {
|
|
/// Config for socks5 local
|
|
///
|
|
/// Requires `local` configuration
|
|
Socks5Local,
|
|
|
|
/// Config for HTTP local
|
|
///
|
|
/// Requires `local` configuration
|
|
HttpLocal,
|
|
|
|
/// Config for tunnel local
|
|
///
|
|
/// Requires `local` and `forward` configuration
|
|
TunnelLocal,
|
|
|
|
/// Config for redir local
|
|
///
|
|
/// Requires `local` configuration
|
|
RedirLocal,
|
|
|
|
/// Config for server
|
|
Server,
|
|
}
|
|
|
|
impl ConfigType {
|
|
/// Check if it is local server type
|
|
pub fn is_local(self) -> bool {
|
|
match self {
|
|
ConfigType::Socks5Local | ConfigType::HttpLocal | ConfigType::TunnelLocal | ConfigType::RedirLocal => true,
|
|
ConfigType::Server => false,
|
|
}
|
|
}
|
|
|
|
/// Check if it is remote server type
|
|
pub fn is_server(self) -> bool {
|
|
match self {
|
|
ConfigType::Socks5Local | ConfigType::HttpLocal | ConfigType::TunnelLocal | ConfigType::RedirLocal => false,
|
|
ConfigType::Server => true,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Server mode
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub enum Mode {
|
|
TcpOnly,
|
|
TcpAndUdp,
|
|
UdpOnly,
|
|
}
|
|
|
|
impl Mode {
|
|
pub fn enable_udp(self) -> bool {
|
|
match self {
|
|
Mode::UdpOnly | Mode::TcpAndUdp => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub fn enable_tcp(self) -> bool {
|
|
match self {
|
|
Mode::TcpOnly | Mode::TcpAndUdp => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Mode {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match *self {
|
|
Mode::TcpOnly => f.write_str("tcp_only"),
|
|
Mode::TcpAndUdp => f.write_str("tcp_and_udp"),
|
|
Mode::UdpOnly => f.write_str("udp_only"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FromStr for Mode {
|
|
type Err = ();
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"tcp_only" => Ok(Mode::TcpOnly),
|
|
"tcp_and_udp" => Ok(Mode::TcpAndUdp),
|
|
"udp_only" => Ok(Mode::UdpOnly),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Configuration
|
|
#[derive(Clone, Debug)]
|
|
pub struct Config {
|
|
/// Remote ShadowSocks server configurations
|
|
pub server: Vec<ServerConfig>,
|
|
/// Local server's bind address, or ShadowSocks server's outbound address
|
|
pub local: Option<ClientConfig>,
|
|
/// Destination address for tunnel
|
|
pub forward: Option<Address>,
|
|
/// Ignored IPs
|
|
///
|
|
/// Suggested list: `["127.0.0.1", "::1"]`
|
|
pub forbidden_ip: HashSet<IpAddr>,
|
|
/// DNS configuration, uses system-wide DNS configuration by default
|
|
///
|
|
/// Value could be a `IpAddr`, uses UDP DNS protocol with port `53`. For example: `8.8.8.8`
|
|
///
|
|
/// Also Value could be some pre-defined DNS server names:
|
|
///
|
|
/// - `google`
|
|
/// - `cloudflare`, `cloudflare_tls`, `cloudflare_https`
|
|
/// - `quad9`, `quad9_tls`
|
|
pub dns: Option<String>,
|
|
/// Server mode, `tcp_only`, `tcp_and_udp`, and `udp_only`
|
|
pub mode: Mode,
|
|
/// Set `TCP_NODELAY` socket option
|
|
pub no_delay: bool,
|
|
/// Address of `ss-manager`. Send servers' statistic data to the manager server
|
|
pub manager_address: Option<ServerAddr>,
|
|
/// Config is for Client or Server
|
|
pub config_type: ConfigType,
|
|
/// Timeout for UDP Associations, default is 5 minutes
|
|
pub udp_timeout: Option<Duration>,
|
|
/// `RLIMIT_NOFILE` option for *nix systems
|
|
pub nofile: Option<u64>,
|
|
}
|
|
|
|
/// Configuration parsing error kind
|
|
#[derive(Copy, Clone, Debug)]
|
|
pub enum ErrorKind {
|
|
/// Missing required fields in JSON configuration
|
|
MissingField,
|
|
/// Missing some keys that must be provided together
|
|
Malformed,
|
|
/// Invalid value of some configuration keys
|
|
Invalid,
|
|
/// Invalid JSON
|
|
JsonParsingError,
|
|
/// `std::io::Error`
|
|
IoError,
|
|
}
|
|
|
|
/// Configuration parsing error
|
|
pub struct Error {
|
|
pub kind: ErrorKind,
|
|
pub desc: &'static str,
|
|
pub detail: Option<String>,
|
|
}
|
|
|
|
impl Error {
|
|
pub fn new(kind: ErrorKind, desc: &'static str, detail: Option<String>) -> Error {
|
|
Error { kind, desc, detail }
|
|
}
|
|
}
|
|
|
|
macro_rules! impl_from {
|
|
($error:ty, $kind:expr, $desc:expr) => {
|
|
impl From<$error> for Error {
|
|
fn from(err: $error) -> Self {
|
|
Error::new($kind, $desc, Some(format!("{:?}", err)))
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
impl_from!(::std::io::Error, ErrorKind::IoError, "error while reading file");
|
|
impl_from!(json5::Error, ErrorKind::JsonParsingError, "json parse error");
|
|
|
|
impl Debug for Error {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
match self.detail {
|
|
None => write!(f, "{}", self.desc),
|
|
Some(ref det) => write!(f, "{} {}", self.desc, det),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Config {
|
|
/// Creates an empty configuration
|
|
pub fn new(config_type: ConfigType) -> Config {
|
|
Config {
|
|
server: Vec::new(),
|
|
local: None,
|
|
forward: None,
|
|
forbidden_ip: HashSet::new(),
|
|
dns: None,
|
|
mode: Mode::TcpOnly,
|
|
no_delay: false,
|
|
manager_address: None,
|
|
config_type,
|
|
udp_timeout: None,
|
|
nofile: None,
|
|
}
|
|
}
|
|
|
|
fn load_from_ssconfig(config: SSConfig, config_type: ConfigType) -> Result<Config, Error> {
|
|
let check_local = config_type.is_local();
|
|
|
|
if check_local && config.local_address.is_none() {
|
|
let err = Error::new(ErrorKind::Malformed, "`local_address` is required for client", None);
|
|
return Err(err);
|
|
}
|
|
|
|
let mut nconfig = Config::new(config_type);
|
|
|
|
// Standard config
|
|
// Client
|
|
if let Some(la) = config.local_address {
|
|
let port = match config.local_port {
|
|
// Let system allocate port by default
|
|
None => 0,
|
|
Some(p) => {
|
|
if config_type.is_server() {
|
|
// Server can only bind to address, port should always be 0
|
|
0
|
|
} else {
|
|
p
|
|
}
|
|
}
|
|
};
|
|
|
|
let local = match la.parse::<IpAddr>() {
|
|
Ok(ip) => ServerAddr::from(SocketAddr::new(ip, port)),
|
|
Err(..) => {
|
|
// treated as domain
|
|
ServerAddr::from((la, port))
|
|
}
|
|
};
|
|
|
|
nconfig.local = Some(local);
|
|
}
|
|
|
|
// Standard config
|
|
// Server
|
|
match (config.server, config.server_port, config.password, config.method) {
|
|
(Some(address), Some(port), Some(pwd), Some(m)) => {
|
|
let addr = match address.parse::<Ipv4Addr>() {
|
|
Ok(v4) => ServerAddr::SocketAddr(SocketAddr::V4(SocketAddrV4::new(v4, port))),
|
|
Err(..) => match address.parse::<Ipv6Addr>() {
|
|
Ok(v6) => ServerAddr::SocketAddr(SocketAddr::V6(SocketAddrV6::new(v6, port, 0, 0))),
|
|
Err(..) => ServerAddr::DomainName(address, port),
|
|
},
|
|
};
|
|
|
|
let method = match m.parse::<CipherType>() {
|
|
Ok(m) => m,
|
|
Err(..) => {
|
|
let err = Error::new(
|
|
ErrorKind::Invalid,
|
|
"unsupported method",
|
|
Some(format!("`{}` is not a supported method", m)),
|
|
);
|
|
return Err(err);
|
|
}
|
|
};
|
|
|
|
let plugin = match config.plugin {
|
|
None => None,
|
|
Some(plugin) => Some(PluginConfig {
|
|
plugin,
|
|
plugin_opt: config.plugin_opts,
|
|
}),
|
|
};
|
|
|
|
let timeout = config.timeout.map(Duration::from_secs);
|
|
let nsvr = ServerConfig::new(addr, pwd, method, timeout, plugin);
|
|
|
|
nconfig.server.push(nsvr);
|
|
}
|
|
(None, None, None, None) => (),
|
|
_ => {
|
|
let err = Error::new(
|
|
ErrorKind::Malformed,
|
|
"`server`, `server_port`, `method`, `password` must be provided together",
|
|
None,
|
|
);
|
|
return Err(err);
|
|
}
|
|
}
|
|
|
|
// Ext servers
|
|
if let Some(servers) = config.servers {
|
|
for svr in servers {
|
|
let addr = match svr.address.parse::<Ipv4Addr>() {
|
|
Ok(v4) => ServerAddr::SocketAddr(SocketAddr::V4(SocketAddrV4::new(v4, svr.port))),
|
|
Err(..) => match svr.address.parse::<Ipv6Addr>() {
|
|
Ok(v6) => ServerAddr::SocketAddr(SocketAddr::V6(SocketAddrV6::new(v6, svr.port, 0, 0))),
|
|
Err(..) => ServerAddr::DomainName(svr.address, svr.port),
|
|
},
|
|
};
|
|
|
|
let method = match svr.method.parse::<CipherType>() {
|
|
Ok(m) => m,
|
|
Err(..) => {
|
|
let err = Error::new(
|
|
ErrorKind::Invalid,
|
|
"unsupported method",
|
|
Some(format!("`{}` is not a supported method", svr.method)),
|
|
);
|
|
return Err(err);
|
|
}
|
|
};
|
|
|
|
let plugin = match svr.plugin {
|
|
None => None,
|
|
Some(p) => Some(PluginConfig {
|
|
plugin: p,
|
|
plugin_opt: svr.plugin_opts,
|
|
}),
|
|
};
|
|
|
|
let timeout = svr.timeout.map(Duration::from_secs);
|
|
let nsvr = ServerConfig::new(addr, svr.password, method, timeout, plugin);
|
|
|
|
nconfig.server.push(nsvr);
|
|
}
|
|
}
|
|
|
|
// Forbidden IPs
|
|
if let Some(forbidden_ip) = config.forbidden_ip {
|
|
for fi in forbidden_ip {
|
|
match fi.parse::<IpAddr>() {
|
|
Ok(i) => {
|
|
nconfig.forbidden_ip.insert(i);
|
|
}
|
|
Err(err) => {
|
|
error!("Invalid forbidden_ip \"{}\", err: {}", fi, err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// DNS
|
|
nconfig.dns = config.dns;
|
|
|
|
// Mode
|
|
if let Some(m) = config.mode {
|
|
match m.parse::<Mode>() {
|
|
Ok(xm) => nconfig.mode = xm,
|
|
Err(..) => {
|
|
let e = Error::new(
|
|
ErrorKind::Malformed,
|
|
"malformed `mode`, must be one of `tcp_only`, `udp_only` and `tcp_and_udp`",
|
|
None,
|
|
);
|
|
return Err(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
// TCP nodelay
|
|
if let Some(b) = config.no_delay {
|
|
nconfig.no_delay = b;
|
|
}
|
|
|
|
// UDP
|
|
nconfig.udp_timeout = config.udp_timeout.map(Duration::from_secs);
|
|
|
|
// RLIMIT_NOFILE
|
|
nconfig.nofile = config.nofile;
|
|
|
|
Ok(nconfig)
|
|
}
|
|
|
|
/// Load Config from a `str`
|
|
pub fn load_from_str(s: &str, config_type: ConfigType) -> Result<Config, Error> {
|
|
let c = json5::from_str::<SSConfig>(s)?;
|
|
Config::load_from_ssconfig(c, config_type)
|
|
}
|
|
|
|
/// Load Config from a File
|
|
pub fn load_from_file(filename: &str, config_type: ConfigType) -> Result<Config, Error> {
|
|
let mut reader = OpenOptions::new().read(true).open(&Path::new(filename))?;
|
|
let mut content = String::new();
|
|
reader.read_to_string(&mut content)?;
|
|
Config::load_from_str(&content[..], config_type)
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
#[cfg(feature = "trust-dns")]
|
|
/// Get `trust-dns`'s `ResolverConfig` by DNS configuration string
|
|
pub fn get_dns_config(&self) -> Option<ResolverConfig> {
|
|
self.dns.as_ref().and_then(|ds| {
|
|
match &ds[..] {
|
|
"google" => Some(ResolverConfig::google()),
|
|
|
|
"cloudflare" => Some(ResolverConfig::cloudflare()),
|
|
"cloudflare_tls" => Some(ResolverConfig::cloudflare_tls()),
|
|
"cloudflare_https" => Some(ResolverConfig::cloudflare_https()),
|
|
|
|
"quad9" => Some(ResolverConfig::quad9()),
|
|
"quad9_tls" => Some(ResolverConfig::quad9_tls()),
|
|
|
|
_ => {
|
|
// Set ips directly
|
|
match ds.parse::<IpAddr>() {
|
|
Ok(ip) => Some(ResolverConfig::from_parts(
|
|
None,
|
|
vec![],
|
|
NameServerConfigGroup::from_ips_clear(&[ip], 53),
|
|
)),
|
|
Err(..) => {
|
|
error!(
|
|
"Failed to parse DNS \"{}\" in config to IpAddr, fallback to system config",
|
|
ds
|
|
);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Check if there are any plugin are enabled with servers
|
|
pub fn has_server_plugins(&self) -> bool {
|
|
for server in &self.server {
|
|
if server.plugin().is_some() {
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
/// Check if IP is forbidden
|
|
pub fn check_forbidden_ip(&self, ip: &IpAddr) -> bool {
|
|
self.forbidden_ip.contains(ip)
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Config {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
// Convert to json
|
|
|
|
let mut jconf = SSConfig::default();
|
|
|
|
if let Some(ref client) = self.local {
|
|
match *client {
|
|
ServerAddr::SocketAddr(ref sa) => {
|
|
jconf.local_address = Some(sa.ip().to_string());
|
|
jconf.local_port = Some(sa.port());
|
|
}
|
|
ServerAddr::DomainName(ref dname, port) => {
|
|
jconf.local_address = Some(dname.to_owned());
|
|
jconf.local_port = Some(port);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Servers
|
|
// For 1 servers, uses standard configure format
|
|
match self.server.len() {
|
|
0 => {}
|
|
1 => {
|
|
let svr = &self.server[0];
|
|
|
|
jconf.server = Some(match *svr.addr() {
|
|
ServerAddr::SocketAddr(ref sa) => sa.ip().to_string(),
|
|
ServerAddr::DomainName(ref dm, ..) => dm.to_string(),
|
|
});
|
|
jconf.server_port = Some(match *svr.addr() {
|
|
ServerAddr::SocketAddr(ref sa) => sa.port(),
|
|
ServerAddr::DomainName(.., port) => port,
|
|
});
|
|
jconf.method = Some(svr.method().to_string());
|
|
jconf.password = Some(svr.password().to_string());
|
|
jconf.plugin = svr.plugin().map(|p| p.plugin.to_string());
|
|
jconf.plugin_opts = svr.plugin().and_then(|p| p.plugin_opt.clone());
|
|
jconf.timeout = svr.timeout().map(|t| t.as_secs());
|
|
}
|
|
_ => {
|
|
let mut vsvr = Vec::new();
|
|
|
|
for svr in &self.server {
|
|
vsvr.push(SSServerExtConfig {
|
|
address: match *svr.addr() {
|
|
ServerAddr::SocketAddr(ref sa) => sa.ip().to_string(),
|
|
ServerAddr::DomainName(ref dm, ..) => dm.to_string(),
|
|
},
|
|
port: match *svr.addr() {
|
|
ServerAddr::SocketAddr(ref sa) => sa.port(),
|
|
ServerAddr::DomainName(.., port) => port,
|
|
},
|
|
password: svr.password().to_string(),
|
|
method: svr.method().to_string(),
|
|
plugin: svr.plugin().map(|p| p.plugin.to_string()),
|
|
plugin_opts: svr.plugin().and_then(|p| p.plugin_opt.clone()),
|
|
timeout: svr.timeout().map(|t| t.as_secs()),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
jconf.mode = Some(self.mode.to_string());
|
|
|
|
if self.no_delay {
|
|
jconf.no_delay = Some(self.no_delay);
|
|
}
|
|
|
|
if !self.forbidden_ip.is_empty() {
|
|
let mut vfi = Vec::new();
|
|
for fi in &self.forbidden_ip {
|
|
vfi.push(fi.to_string());
|
|
}
|
|
jconf.forbidden_ip = Some(vfi);
|
|
}
|
|
|
|
if let Some(ref dns) = self.dns {
|
|
jconf.dns = Some(dns.to_string());
|
|
}
|
|
|
|
jconf.udp_timeout = self.udp_timeout.map(|t| t.as_secs());
|
|
|
|
jconf.nofile = self.nofile;
|
|
|
|
write!(f, "{}", json5::to_string(&jconf).unwrap())
|
|
}
|
|
}
|