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

update: some fixes and upgrades

v1.x.x
dnomd343 2 years ago
parent
f40885765d
commit
716b0adaec
9 changed files with 64 additions and 53 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. 2
      cmd/config/decode.go
  2. 2
      cmd/config/default.go
  3. 1
      cmd/config/main.go
  4. 41
      cmd/controller.go
  5. 7
      cmd/network/main.go
  6. 25
      cmd/network/network.go
  7. 29
      cmd/network/tproxy.go
  8. 1
      cmd/xproxy.go
  9. 7
      src/main.go

2
cmd/config/decode.go
View File

@ -12,6 +12,7 @@ type yamlNetConfig struct {
}
type yamlConfig struct {
Log string `yaml:"log"`
Custom []string `yaml:"custom"`
Update struct {
Cron string `yaml:"cron"`
@ -126,6 +127,7 @@ func decodeCustom(rawConfig *yamlConfig) []string {
func decode(rawConfig yamlConfig) Config {
var config Config
config.LogLevel = rawConfig.Log
config.DNS = decodeDns(&rawConfig)
config.V4Bypass, config.V6Bypass = decodeBypass(&rawConfig)
config.V4Address, config.V4Gateway = decodeIPv4(&rawConfig)

2
cmd/config/default.go
View File

@ -1,6 +1,8 @@
package config
var defaultConfig = `# default configure file for xproxy
log: debug
proxy:
sniff: true
redirect: true

1
cmd/config/main.go
View File

@ -16,6 +16,7 @@ type Config struct {
V6Gateway string
Script []string
LogLevel string
UpdateCron string
UpdateUrls map[string]string

41
cmd/controller.go
View File

@ -2,11 +2,32 @@ package main
import (
"XProxy/cmd/asset"
"XProxy/cmd/common"
"XProxy/cmd/config"
"XProxy/cmd/network"
"XProxy/cmd/proxy"
log "github.com/sirupsen/logrus"
)
func loadAsset(settings *config.Config) {
asset.LoadGeoSite(assetFile, assetDir)
asset.LoadGeoIp(assetFile, assetDir)
asset.AutoUpdate(settings.UpdateCron, settings.UpdateUrls, assetDir)
}
func loadProxy(settings *config.Config) {
proxy.Load(configDir, exposeDir, proxy.Config{
Sniff: settings.EnableSniff,
Redirect: settings.EnableRedirect,
V4TProxyPort: v4TProxyPort,
V6TProxyPort: v6TProxyPort,
LogLevel: settings.LogLevel,
HttpInbounds: settings.HttpInbounds,
SocksInbounds: settings.SocksInbounds,
AddOnInbounds: settings.AddOnInbounds,
})
}
func loadNetwork(settings *config.Config) {
v4Settings := network.Config{
RouteTable: v4RouteTable,
@ -25,21 +46,9 @@ func loadNetwork(settings *config.Config) {
network.Load(settings.DNS, v4Settings, v6Settings)
}
func loadProxy(settings *config.Config) {
proxy.Load(configDir, exposeDir, proxy.Config{
Sniff: settings.EnableSniff,
Redirect: settings.EnableRedirect,
V4TProxyPort: v4TProxyPort,
V6TProxyPort: v6TProxyPort,
LogLevel: "warning",
HttpInbounds: settings.HttpInbounds,
SocksInbounds: settings.SocksInbounds,
AddOnInbounds: settings.AddOnInbounds,
})
func runScript(settings *config.Config) {
for _, script := range settings.Script {
log.Infof("Run script command -> %s", script)
common.RunCommand("sh", "-c", script)
}
func loadAsset(settings *config.Config) {
asset.LoadGeoSite(assetFile, assetDir)
asset.LoadGeoIp(assetFile, assetDir)
asset.AutoUpdate(settings.UpdateCron, settings.UpdateUrls, assetDir)
}

7
cmd/network/main.go
View File

@ -1,6 +1,9 @@
package network
import "time"
import (
"XProxy/cmd/common"
"time"
)
type Config struct {
RouteTable int
@ -10,6 +13,8 @@ type Config struct {
Bypass []string
}
var run = common.RunCommand
func Load(dns []string, ipv4 Config, ipv6 Config) {
loadDns(dns) // init dns server
flushNetwork() // clear network settings

25
cmd/network/network.go
View File

@ -1,14 +1,13 @@
package network
import (
"XProxy/cmd/common"
log "github.com/sirupsen/logrus"
"regexp"
)
func getV4Cidr() []string {
var v4Cidr []string
_, output := common.RunCommand("ip", "-4", "addr")
_, output := run("ip", "-4", "addr")
for _, temp := range regexp.MustCompile(`inet (\S+)`).FindAllStringSubmatch(output, -1) {
v4Cidr = append(v4Cidr, temp[1])
}
@ -17,7 +16,7 @@ func getV4Cidr() []string {
func getV6Cidr() []string {
var v6Cidr []string
_, output := common.RunCommand("ip", "-6", "addr")
_, output := run("ip", "-6", "addr")
for _, temp := range regexp.MustCompile(`inet6 (\S+)`).FindAllStringSubmatch(output, -1) {
v6Cidr = append(v6Cidr, temp[1])
}
@ -26,32 +25,32 @@ func getV6Cidr() []string {
func flushNetwork() {
log.Info("Flush system IP configure")
common.RunCommand("ip", "link", "set", "eth0", "down")
common.RunCommand("ip", "-4", "addr", "flush", "dev", "eth0")
common.RunCommand("ip", "-6", "addr", "flush", "dev", "eth0")
common.RunCommand("ip", "link", "set", "eth0", "down")
run("ip", "link", "set", "eth0", "down")
run("ip", "-4", "addr", "flush", "dev", "eth0")
run("ip", "-6", "addr", "flush", "dev", "eth0")
run("ip", "link", "set", "eth0", "down")
}
func loadV4Network(v4 Config) {
log.Info("Enabled IPv4 forward")
common.RunCommand("sysctl", "-w", "net.ipv4.ip_forward=1")
run("sysctl", "-w", "net.ipv4.ip_forward=1")
log.Info("Setting up system IPv4 configure")
if v4.Address != "" {
common.RunCommand("ip", "-4", "addr", "add", v4.Address, "dev", "eth0")
run("ip", "-4", "addr", "add", v4.Address, "dev", "eth0")
}
if v4.Gateway != "" {
common.RunCommand("ip", "-4", "route", "add", "default", "via", v4.Gateway)
run("ip", "-4", "route", "add", "default", "via", v4.Gateway)
}
}
func loadV6Network(v6 Config) {
log.Info("Enabled IPv6 forward")
common.RunCommand("sysctl", "-w", "net.ipv6.conf.all.forwarding=1")
run("sysctl", "-w", "net.ipv6.conf.all.forwarding=1")
log.Info("Setting up system IPv6 configure")
if v6.Address != "" {
common.RunCommand("ip", "-6", "addr", "add", v6.Address, "dev", "eth0")
run("ip", "-6", "addr", "add", v6.Address, "dev", "eth0")
}
if v6.Gateway != "" {
common.RunCommand("ip", "-6", "route", "add", "default", "via", v6.Gateway)
run("ip", "-6", "route", "add", "default", "via", v6.Gateway)
}
}

29
cmd/network/tproxy.go
View File

@ -1,7 +1,6 @@
package network
import (
"XProxy/cmd/common"
log "github.com/sirupsen/logrus"
"strconv"
)
@ -10,34 +9,34 @@ func loadV4TProxy(v4 Config, v4SysCidr []string) {
log.Info("Setting up TProxy of IPv4")
tableNum := strconv.Itoa(v4.RouteTable)
v4Bypass := append(v4SysCidr, v4.Bypass...)
common.RunCommand("ip", "-4", "rule", "add", "fwmark", "1", "table", tableNum)
common.RunCommand("ip", "-4", "route", "add", "local", "0.0.0.0/0", "dev", "lo", "table", tableNum)
common.RunCommand("iptables", "-t", "mangle", "-N", "XPROXY")
run("ip", "-4", "rule", "add", "fwmark", "1", "table", tableNum)
run("ip", "-4", "route", "add", "local", "0.0.0.0/0", "dev", "lo", "table", tableNum)
run("iptables", "-t", "mangle", "-N", "XPROXY")
log.Infof("Setting up IPv4 bypass CIDR -> %v", v4Bypass)
for _, cidr := range v4Bypass {
common.RunCommand("iptables", "-t", "mangle", "-A", "XPROXY", "-d", cidr, "-j", "RETURN")
run("iptables", "-t", "mangle", "-A", "XPROXY", "-d", cidr, "-j", "RETURN")
}
common.RunCommand("iptables", "-t", "mangle", "-A", "XPROXY",
run("iptables", "-t", "mangle", "-A", "XPROXY",
"-p", "tcp", "-j", "TPROXY", "--on-port", strconv.Itoa(v4.TProxyPort), "--tproxy-mark", "1")
common.RunCommand("iptables", "-t", "mangle", "-A", "XPROXY",
run("iptables", "-t", "mangle", "-A", "XPROXY",
"-p", "udp", "-j", "TPROXY", "--on-port", strconv.Itoa(v4.TProxyPort), "--tproxy-mark", "1")
common.RunCommand("iptables", "-t", "mangle", "-A", "PREROUTING", "-j", "XPROXY")
run("iptables", "-t", "mangle", "-A", "PREROUTING", "-j", "XPROXY")
}
func loadV6TProxy(v6 Config, v6SysCidr []string) {
log.Info("Setting up TProxy of IPv6")
tableNum := strconv.Itoa(v6.RouteTable)
v6Bypass := append(v6SysCidr, v6.Bypass...)
common.RunCommand("ip", "-6", "rule", "add", "fwmark", "1", "table", tableNum)
common.RunCommand("ip", "-6", "route", "add", "local", "::/0", "dev", "lo", "table", tableNum)
common.RunCommand("ip6tables", "-t", "mangle", "-N", "XPROXY6")
run("ip", "-6", "rule", "add", "fwmark", "1", "table", tableNum)
run("ip", "-6", "route", "add", "local", "::/0", "dev", "lo", "table", tableNum)
run("ip6tables", "-t", "mangle", "-N", "XPROXY6")
log.Infof("Setting up IPv6 bypass CIDR -> %v", v6Bypass)
for _, cidr := range v6Bypass {
common.RunCommand("ip6tables", "-t", "mangle", "-A", "XPROXY6", "-d", cidr, "-j", "RETURN")
run("ip6tables", "-t", "mangle", "-A", "XPROXY6", "-d", cidr, "-j", "RETURN")
}
common.RunCommand("ip6tables", "-t", "mangle", "-A", "XPROXY6",
run("ip6tables", "-t", "mangle", "-A", "XPROXY6",
"-p", "tcp", "-j", "TPROXY", "--on-port", strconv.Itoa(v6.TProxyPort), "--tproxy-mark", "1")
common.RunCommand("ip6tables", "-t", "mangle", "-A", "XPROXY6",
run("ip6tables", "-t", "mangle", "-A", "XPROXY6",
"-p", "udp", "-j", "TPROXY", "--on-port", strconv.Itoa(v6.TProxyPort), "--tproxy-mark", "1")
common.RunCommand("ip6tables", "-t", "mangle", "-A", "PREROUTING", "-j", "XPROXY6")
run("ip6tables", "-t", "mangle", "-A", "PREROUTING", "-j", "XPROXY6")
}

1
cmd/xproxy.go
View File

@ -27,6 +27,7 @@ func main() {
loadNetwork(&settings)
loadProxy(&settings)
loadAsset(&settings)
runScript(&settings)
// TODO: start xray service
}

7
src/main.go
View File

@ -7,8 +7,6 @@ import (
"syscall"
)
var preScript []string
func main() {
defer func() {
if err := recover(); err != nil {
@ -16,11 +14,6 @@ func main() {
}
}()
for _, script := range preScript {
log.Infof("Run script command -> %s", script)
runCommand("sh", "-c", script)
}
xray := newProcess("xray", "-confdir", "/etc/xproxy/config")
xray.startProcess(true, true)
subProcess = append(subProcess, xray)

Write Preview
Loading…
Cancel
Save