dnomd343
/
XProxy
mirror of https://github.com/dnomd343/XProxy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

style: optimize golang code

v1.x.x
dnomd343 2 years ago
parent
7928aaaf02
commit
06f91c1502
3 changed files with 71 additions and 93 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 57
      src/config.go
  2. 44
      src/load.go
  3. 63
      src/network.go

57
src/config.go
View File

@ -4,7 +4,6 @@ import (
log "github.com/sirupsen/logrus"
"gopkg.in/yaml.v3"
"net"
"strconv"
"strings"
)
@ -38,53 +37,39 @@ type Config struct {
}
}
func isIP(ipAddr string, isRange bool, ipLength int, ipFlag string) bool {
var address string
if isRange {
temp := strings.Split(ipAddr, "/")
if len(temp) != 2 { // not {IP_ADDRESS}/{LENGTH} format
return false
func isIP(ipAddr string, isCidr bool) bool {
if !isCidr {
return net.ParseIP(ipAddr) != nil
}
length, err := strconv.Atoi(temp[1])
if err != nil { // range length not a integer
return false
}
if length < 0 || length > ipLength { // length should between 0 ~ ipLength
return false
}
address = temp[0]
} else {
address = ipAddr
}
ip := net.ParseIP(address) // try to convert ip
return ip != nil && strings.Contains(address, ipFlag)
_, _, err := net.ParseCIDR(ipAddr)
return err == nil
}
func isIPv4(ipAddr string, isRange bool) bool {
return isIP(ipAddr, isRange, 32, ".")
func isIPv4(ipAddr string, isCidr bool) bool {
return isIP(ipAddr, isCidr) && strings.Contains(ipAddr, ".")
}
func isIPv6(ipAddr string, isRange bool) bool {
return isIP(ipAddr, isRange, 128, ":")
func isIPv6(ipAddr string, isCidr bool) bool {
return isIP(ipAddr, isCidr) && strings.Contains(ipAddr, ":")
}
func loadConfig(rawConfig []byte) {
config := Config{}
log.Debug("Decode yaml content -> \n", string(rawConfig))
log.Debugf("Decode yaml content -> \n%s", string(rawConfig))
err := yaml.Unmarshal(rawConfig, &config) // yaml (or json) decode
if err != nil {
panic(err)
log.Panicf("Decode config file error -> %v", err)
}
log.Debug("Decoded config -> ", config)
log.Debugf("Decoded config -> %v", config)
for _, address := range config.Network.DNS { // dns options
if isIPv4(address, false) || isIPv6(address, false) {
dnsServer = append(dnsServer, address)
} else {
panic("Invalid DNS server -> " + address)
log.Panicf("Invalid DNS server -> %s", address)
}
}
log.Info("DNS server -> ", dnsServer)
log.Infof("DNS server -> %v", dnsServer)
for _, address := range config.Network.ByPass { // bypass options
if isIPv4(address, true) {
@ -92,29 +77,29 @@ func loadConfig(rawConfig []byte) {
} else if isIPv6(address, true) {
v6Bypass = append(v6Bypass, address)
} else {
panic("Invalid bypass CIDR -> " + address)
log.Panicf("Invalid bypass CIDR -> %s", address)
}
}
log.Info("IPv4 bypass CIDR -> ", v4Bypass)
log.Info("IPv6 bypass CIDR -> ", v6Bypass)
log.Infof("IPv4 bypass CIDR -> %s", v4Bypass)
log.Infof("IPv6 bypass CIDR -> %s", v6Bypass)
v4Address = config.Network.IPv4.Address
v4Gateway = config.Network.IPv4.Gateway
if v4Address != "" && !isIPv4(v4Address, true) {
panic("Invalid IPv4 address -> " + v4Address)
log.Panicf("Invalid IPv4 address -> %s", v4Address)
}
if v4Gateway != "" && !isIPv4(v4Gateway, false) {
panic("Invalid IPv4 gateway -> " + v4Gateway)
log.Panicf("Invalid IPv4 gateway -> %s", v4Gateway)
}
log.Infof("IPv4 -> address = %s | gateway = %s", v4Address, v4Gateway)
v6Address = config.Network.IPv6.Address
v6Gateway = config.Network.IPv6.Gateway
if v6Address != "" && !isIPv6(v6Address, true) {
panic("Invalid IPv6 address -> " + v6Address)
log.Panicf("Invalid IPv6 address -> %s", v6Address)
}
if v6Gateway != "" && !isIPv6(v6Gateway, false) {
panic("Invalid IPv6 gateway -> " + v6Gateway)
log.Panicf("Invalid IPv6 gateway -> %s", v6Gateway)
}
log.Infof("IPv6 -> address = %s | gateway = %s", v6Address, v6Gateway)

44
src/load.go
View File

@ -50,6 +50,10 @@ var outboundsConfig = `{
]
}`
type inboundsSettings struct {
Inbounds []interface{} `json:"inbounds"`
}
type sniffSettings struct {
Enabled bool `json:"enabled"`
RouteOnly bool `json:"routeOnly"`
@ -65,11 +69,7 @@ type inboundSettings struct {
Sniffing sniffSettings `json:"sniffing"`
}
type inboundsSettings struct {
Inbounds []interface{} `json:"inbounds"`
}
func runCommand(command []string) (int, string) {
func runCommand(command ...string) (int, string) {
log.Debugf("Running system command -> %v", command)
process := exec.Command(command[0], command[1:]...)
output, _ := process.CombinedOutput()
@ -93,8 +93,7 @@ func createFolder(folderPath string) {
log.Debugf("Loading folder -> %s", folderPath)
err := os.MkdirAll(folderPath, 0755)
if err != nil {
log.Errorf("Failed to create folder -> %s", folderPath)
panic("Create folder failed")
log.Panicf("Failed to create folder -> %s", folderPath)
}
}
@ -102,8 +101,7 @@ func listFolder(folderPath string, suffix string) []string {
var fileList []string
files, err := ioutil.ReadDir(folderPath)
if err != nil {
log.Errorf("Failed to list folder -> %s", folderPath)
panic("List folder failed")
log.Panicf("Failed to list folder -> %s", folderPath)
}
for _, file := range files {
if strings.HasSuffix(file.Name(), suffix) {
@ -117,18 +115,15 @@ func copyFile(source string, target string) {
log.Infof("Copy file `%s` => `%s`", source, target)
srcFile, err := os.Open(source)
if err != nil {
log.Errorf("Failed to open file -> %s", source)
panic("Open file failed")
log.Panicf("Failed to open file -> %s", source)
}
dstFile, err := os.OpenFile(target, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644)
if err != nil {
log.Errorf("Failed to open file -> %s", target)
panic("Open file failed")
log.Panicf("Failed to open file -> %s", target)
}
_, err = io.Copy(dstFile, srcFile)
if err != nil {
log.Errorf("Failed to copy from `%s` to `%s`", source, target)
panic("Copy file failed")
log.Panicf("Failed to copy from `%s` to `%s`", source, target)
}
}
@ -141,8 +136,7 @@ func saveConfig(configDir string, caption string, content string, overwrite bool
log.Debugf("Loading %s -> \n%s", filePath, content)
err := os.WriteFile(filePath, []byte(content), 0644)
if err != nil {
log.Errorf("File %s -> %v", caption, err)
panic("File save error")
log.Panicf("File %s -> %v", caption, err)
}
}
@ -210,24 +204,24 @@ func loadProxy(configDir string, exposeDir string) {
logConfig = strings.ReplaceAll(logConfig, "${DIR}", exposeDir+"/log")
saveConfig(configDir, "log", logConfig+"\n", true)
inboundsObject := inboundsSettings{}
sniffObject := sniffSettings{
inbounds := inboundsSettings{}
sniff := sniffSettings{
Enabled: enableSniff,
RouteOnly: !enableRedirect,
DestOverride: []string{"http", "tls"},
}
inboundsObject.Inbounds = append(inboundsObject.Inbounds, loadTProxyConfig("tproxy", v4TProxyPort, sniffObject))
inboundsObject.Inbounds = append(inboundsObject.Inbounds, loadTProxyConfig("tproxy6", v6TProxyPort, sniffObject))
inbounds.Inbounds = append(inbounds.Inbounds, loadTProxyConfig("tproxy", v4TProxyPort, sniff))
inbounds.Inbounds = append(inbounds.Inbounds, loadTProxyConfig("tproxy6", v6TProxyPort, sniff))
for tag, port := range httpInbounds {
inboundsObject.Inbounds = append(inboundsObject.Inbounds, loadHttpConfig(tag, port, sniffObject))
inbounds.Inbounds = append(inbounds.Inbounds, loadHttpConfig(tag, port, sniff))
}
for tag, port := range socksInbounds {
inboundsObject.Inbounds = append(inboundsObject.Inbounds, loadSocksConfig(tag, port, sniffObject))
inbounds.Inbounds = append(inbounds.Inbounds, loadSocksConfig(tag, port, sniff))
}
for _, addon := range addOnInbounds {
inboundsObject.Inbounds = append(inboundsObject.Inbounds, addon)
inbounds.Inbounds = append(inbounds.Inbounds, addon)
}
inboundsConfig, _ := json.MarshalIndent(inboundsObject, "", " ") // json encode
inboundsConfig, _ := json.MarshalIndent(inbounds, "", " ") // json encode
saveConfig(configDir, "inbounds", string(inboundsConfig)+"\n", true)
for _, configFile := range listFolder(exposeDir+"/config", ".json") {

63
src/network.go
View File

@ -19,46 +19,45 @@ func loadDns() {
}
err := os.WriteFile("/etc/resolv.conf", []byte(dnsContent), 0644)
if err != nil {
log.Error("Setting up DNS failed")
panic("Setting up DNS failed")
log.Panic("Setting up DNS failed")
}
}
func loadNetwork() {
log.Info("Enabled IP forward")
runCommand([]string{"sysctl", "-w", "net.ipv4.ip_forward=1"})
runCommand([]string{"sysctl", "-w", "net.ipv6.conf.all.forwarding=1"})
runCommand("sysctl", "-w", "net.ipv4.ip_forward=1")
runCommand("sysctl", "-w", "net.ipv6.conf.all.forwarding=1")
log.Info("Flush system IP configure")
runCommand([]string{"ip", "link", "set", "eth0", "down"})
runCommand([]string{"ip", "-4", "addr", "flush", "dev", "eth0"})
runCommand([]string{"ip", "-6", "addr", "flush", "dev", "eth0"})
runCommand([]string{"ip", "link", "set", "eth0", "down"})
runCommand("ip", "link", "set", "eth0", "down")
runCommand("ip", "-4", "addr", "flush", "dev", "eth0")
runCommand("ip", "-6", "addr", "flush", "dev", "eth0")
runCommand("ip", "link", "set", "eth0", "down")
log.Info("Setting up system IP configure")
if v4Address != "" {
runCommand([]string{"ip", "-4", "addr", "add", v4Address, "dev", "eth0"})
runCommand("ip", "-4", "addr", "add", v4Address, "dev", "eth0")
}
if v4Gateway != "" {
runCommand([]string{"ip", "-4", "route", "add", "default", "via", v4Gateway})
runCommand("ip", "-4", "route", "add", "default", "via", v4Gateway)
}
if v6Address != "" {
runCommand([]string{"ip", "-6", "addr", "add", v6Address, "dev", "eth0"})
runCommand("ip", "-6", "addr", "add", v6Address, "dev", "eth0")
}
if v6Gateway != "" {
runCommand([]string{"ip", "-6", "route", "add", "default", "via", v6Gateway})
runCommand("ip", "-6", "route", "add", "default", "via", v6Gateway)
}
}
func v4SysBypass() {
_, output := runCommand([]string{"ip", "-4", "addr"})
_, output := runCommand("ip", "-4", "addr")
for _, temp := range regexp.MustCompile(`inet (\S+)`).FindAllStringSubmatch(output, -1) {
v4Bypass = append(v4Bypass, temp[1])
}
}
func v6SysBypass() {
_, output := runCommand([]string{"ip", "-6", "addr"})
_, output := runCommand("ip", "-6", "addr")
for _, temp := range regexp.MustCompile(`inet6 (\S+)`).FindAllStringSubmatch(output, -1) {
v6Bypass = append(v6Bypass, temp[1])
}
@ -67,33 +66,33 @@ func v6SysBypass() {
func loadTProxy() {
log.Info("Setting up TProxy of IPv4")
v4TableNum := strconv.Itoa(v4RouteTable)
runCommand([]string{"ip", "-4", "rule", "add", "fwmark", "1", "table", v4TableNum})
runCommand([]string{"ip", "-4", "route", "add", "local", "0.0.0.0/0", "dev", "lo", "table", v4TableNum})
runCommand([]string{"iptables", "-t", "mangle", "-N", "XPROXY"})
runCommand("ip", "-4", "rule", "add", "fwmark", "1", "table", v4TableNum)
runCommand("ip", "-4", "route", "add", "local", "0.0.0.0/0", "dev", "lo", "table", v4TableNum)
runCommand("iptables", "-t", "mangle", "-N", "XPROXY")
v4SysBypass()
log.Infof("Setting up IPv4 bypass CIDR -> %v", v4Bypass)
for _, cidr := range v4Bypass {
runCommand([]string{"iptables", "-t", "mangle", "-A", "XPROXY", "-d", cidr, "-j", "RETURN"})
runCommand("iptables", "-t", "mangle", "-A", "XPROXY", "-d", cidr, "-j", "RETURN")
}
runCommand([]string{"iptables", "-t", "mangle", "-A", "XPROXY", "-p", "tcp", "-j", "TPROXY",
"--on-port", strconv.Itoa(v4TProxyPort), "--tproxy-mark", "1"})
runCommand([]string{"iptables", "-t", "mangle", "-A", "XPROXY", "-p", "udp", "-j", "TPROXY",
"--on-port", strconv.Itoa(v4TProxyPort), "--tproxy-mark", "1"})
runCommand([]string{"iptables", "-t", "mangle", "-A", "PREROUTING", "-j", "XPROXY"})
runCommand("iptables", "-t", "mangle", "-A", "XPROXY", "-p", "tcp", "-j", "TPROXY",
"--on-port", strconv.Itoa(v4TProxyPort), "--tproxy-mark", "1")
runCommand("iptables", "-t", "mangle", "-A", "XPROXY", "-p", "udp", "-j", "TPROXY",
"--on-port", strconv.Itoa(v4TProxyPort), "--tproxy-mark", "1")
runCommand("iptables", "-t", "mangle", "-A", "PREROUTING", "-j", "XPROXY")
log.Info("Setting up TProxy of IPv6")
v6TableNum := strconv.Itoa(v6RouteTable)
runCommand([]string{"ip", "-6", "rule", "add", "fwmark", "1", "table", v6TableNum})
runCommand([]string{"ip", "-6", "route", "add", "local", "::/0", "dev", "lo", "table", v6TableNum})
runCommand([]string{"ip6tables", "-t", "mangle", "-N", "XPROXY6"})
runCommand("ip", "-6", "rule", "add", "fwmark", "1", "table", v6TableNum)
runCommand("ip", "-6", "route", "add", "local", "::/0", "dev", "lo", "table", v6TableNum)
runCommand("ip6tables", "-t", "mangle", "-N", "XPROXY6")
v6SysBypass()
log.Infof("Setting up IPv6 bypass CIDR -> %v", v6Bypass)
for _, cidr := range v6Bypass {
runCommand([]string{"ip6tables", "-t", "mangle", "-A", "XPROXY6", "-d", cidr, "-j", "RETURN"})
runCommand("ip6tables", "-t", "mangle", "-A", "XPROXY6", "-d", cidr, "-j", "RETURN")
}
runCommand([]string{"ip6tables", "-t", "mangle", "-A", "XPROXY6", "-p", "tcp", "-j", "TPROXY",
"--on-port", strconv.Itoa(v6TProxyPort), "--tproxy-mark", "1"})
runCommand([]string{"ip6tables", "-t", "mangle", "-A", "XPROXY6", "-p", "udp", "-j", "TPROXY",
"--on-port", strconv.Itoa(v6TProxyPort), "--tproxy-mark", "1"})
runCommand([]string{"ip6tables", "-t", "mangle", "-A", "PREROUTING", "-j", "XPROXY6"})
runCommand("ip6tables", "-t", "mangle", "-A", "XPROXY6", "-p", "tcp", "-j", "TPROXY",
"--on-port", strconv.Itoa(v6TProxyPort), "--tproxy-mark", "1")
runCommand("ip6tables", "-t", "mangle", "-A", "XPROXY6", "-p", "udp", "-j", "TPROXY",
"--on-port", strconv.Itoa(v6TProxyPort), "--tproxy-mark", "1")
runCommand("ip6tables", "-t", "mangle", "-A", "PREROUTING", "-j", "XPROXY6")
}

Write Preview
Loading…
Cancel
Save