clash/listener/listener.go

400 lines
7.9 KiB
Go
Raw Normal View History

2018-07-15 14:23:20 +00:00
package proxy
import (
2018-11-21 05:47:46 +00:00
"fmt"
"github.com/Dreamacro/clash/listener/inner"
2018-11-21 05:47:46 +00:00
"net"
"os"
2018-11-21 05:47:46 +00:00
"strconv"
"sync"
2018-07-15 14:23:20 +00:00
2021-06-13 09:23:10 +00:00
"github.com/Dreamacro/clash/adapter/inbound"
2021-11-17 08:03:47 +00:00
"github.com/Dreamacro/clash/config"
2021-06-13 09:23:10 +00:00
C "github.com/Dreamacro/clash/constant"
"github.com/Dreamacro/clash/listener/http"
"github.com/Dreamacro/clash/listener/mixed"
"github.com/Dreamacro/clash/listener/redir"
"github.com/Dreamacro/clash/listener/socks"
"github.com/Dreamacro/clash/listener/tproxy"
2021-11-17 08:03:47 +00:00
"github.com/Dreamacro/clash/listener/tun"
"github.com/Dreamacro/clash/listener/tun/ipstack"
"github.com/Dreamacro/clash/log"
2018-07-15 14:23:20 +00:00
)
var (
allowLan = false
bindAddress = "*"
2018-11-21 05:47:46 +00:00
socksListener *socks.Listener
socksUDPListener *socks.UDPListener
httpListener *http.Listener
redirListener *redir.Listener
redirUDPListener *tproxy.UDPListener
tproxyListener *tproxy.Listener
tproxyUDPListener *tproxy.UDPListener
mixedListener *mixed.Listener
mixedUDPLister *socks.UDPListener
2022-03-08 21:08:35 +00:00
tunStackListener ipstack.Stack
// lock for recreate function
socksMux sync.Mutex
httpMux sync.Mutex
redirMux sync.Mutex
tproxyMux sync.Mutex
mixedMux sync.Mutex
2021-11-17 08:03:47 +00:00
tunMux sync.Mutex
2018-07-15 14:23:20 +00:00
)
2018-11-21 05:47:46 +00:00
type Ports struct {
Port int `json:"port"`
SocksPort int `json:"socks-port"`
RedirPort int `json:"redir-port"`
TProxyPort int `json:"tproxy-port"`
MixedPort int `json:"mixed-port"`
2018-11-21 05:47:46 +00:00
}
func AllowLan() bool {
return allowLan
}
func BindAddress() string {
return bindAddress
}
2018-11-21 05:47:46 +00:00
func SetAllowLan(al bool) {
allowLan = al
2018-07-15 14:23:20 +00:00
}
func SetBindAddress(host string) {
bindAddress = host
}
func ReCreateHTTP(port int, tcpIn chan<- C.ConnContext) {
httpMux.Lock()
defer httpMux.Unlock()
var err error
defer func() {
if err != nil {
log.Errorln("Start HTTP server error: %s", err.Error())
}
}()
addr := genAddr(bindAddress, port, allowLan)
2018-11-21 05:47:46 +00:00
if httpListener != nil {
2021-07-31 16:35:37 +00:00
if httpListener.RawAddress() == addr {
return
2018-11-21 05:47:46 +00:00
}
httpListener.Close()
2018-11-21 05:47:46 +00:00
httpListener = nil
}
if portIsZero(addr) {
return
2018-07-15 14:23:20 +00:00
}
2021-06-13 09:23:10 +00:00
httpListener, err = http.New(addr, tcpIn)
2018-07-15 14:23:20 +00:00
if err != nil {
2022-01-04 09:58:50 +00:00
log.Errorln("Start HTTP server error: %s", err.Error())
return
2018-07-15 14:23:20 +00:00
}
2021-06-13 09:23:10 +00:00
log.Infoln("HTTP proxy listening at: %s", httpListener.Address())
2018-07-15 14:23:20 +00:00
}
func ReCreateSocks(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) {
socksMux.Lock()
defer socksMux.Unlock()
var err error
defer func() {
if err != nil {
log.Errorln("Start SOCKS server error: %s", err.Error())
}
}()
inner.New(tcpIn)
addr := genAddr(bindAddress, port, allowLan)
2018-11-21 05:47:46 +00:00
shouldTCPIgnore := false
shouldUDPIgnore := false
2018-11-21 05:47:46 +00:00
if socksListener != nil {
2021-07-31 16:35:37 +00:00
if socksListener.RawAddress() != addr {
socksListener.Close()
socksListener = nil
} else {
shouldTCPIgnore = true
}
}
if socksUDPListener != nil {
2021-07-31 16:35:37 +00:00
if socksUDPListener.RawAddress() != addr {
socksUDPListener.Close()
socksUDPListener = nil
} else {
shouldUDPIgnore = true
2018-11-21 05:47:46 +00:00
}
}
if shouldTCPIgnore && shouldUDPIgnore {
return
}
2018-11-21 05:47:46 +00:00
if portIsZero(addr) {
return
2018-07-15 14:23:20 +00:00
}
2021-06-13 09:23:10 +00:00
tcpListener, err := socks.New(addr, tcpIn)
2018-07-15 14:23:20 +00:00
if err != nil {
return
2018-07-15 14:23:20 +00:00
}
2021-06-13 09:23:10 +00:00
udpListener, err := socks.NewUDP(addr, udpIn)
if err != nil {
tcpListener.Close()
return
}
socksListener = tcpListener
socksUDPListener = udpListener
log.Infoln("SOCKS proxy listening at: %s", socksListener.Address())
2018-07-15 14:23:20 +00:00
}
func ReCreateRedir(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) {
redirMux.Lock()
defer redirMux.Unlock()
var err error
defer func() {
if err != nil {
log.Errorln("Start Redir server error: %s", err.Error())
}
}()
addr := genAddr(bindAddress, port, allowLan)
2018-11-21 05:47:46 +00:00
if redirListener != nil {
2021-07-31 16:35:37 +00:00
if redirListener.RawAddress() == addr {
return
2018-11-21 05:47:46 +00:00
}
redirListener.Close()
2018-11-21 05:47:46 +00:00
redirListener = nil
}
if redirUDPListener != nil {
2021-07-31 16:35:37 +00:00
if redirUDPListener.RawAddress() == addr {
return
}
redirUDPListener.Close()
redirUDPListener = nil
}
2018-11-21 05:47:46 +00:00
if portIsZero(addr) {
return
2018-08-11 20:00:34 +00:00
}
2021-06-13 09:23:10 +00:00
redirListener, err = redir.New(addr, tcpIn)
2018-08-11 20:00:34 +00:00
if err != nil {
return
2018-08-11 20:00:34 +00:00
}
2021-06-13 09:23:10 +00:00
redirUDPListener, err = tproxy.NewUDP(addr, udpIn)
if err != nil {
log.Warnln("Failed to start Redir UDP Listener: %s", err)
}
2021-06-13 09:23:10 +00:00
log.Infoln("Redirect proxy listening at: %s", redirListener.Address())
2018-08-11 20:00:34 +00:00
}
func ReCreateTProxy(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) {
tproxyMux.Lock()
defer tproxyMux.Unlock()
var err error
defer func() {
if err != nil {
log.Errorln("Start TProxy server error: %s", err.Error())
}
}()
addr := genAddr(bindAddress, port, allowLan)
if tproxyListener != nil {
2021-07-31 16:35:37 +00:00
if tproxyListener.RawAddress() == addr {
return
}
tproxyListener.Close()
tproxyListener = nil
}
if tproxyUDPListener != nil {
2021-07-31 16:35:37 +00:00
if tproxyUDPListener.RawAddress() == addr {
return
}
tproxyUDPListener.Close()
tproxyUDPListener = nil
}
if portIsZero(addr) {
return
}
2021-06-13 09:23:10 +00:00
tproxyListener, err = tproxy.New(addr, tcpIn)
if err != nil {
return
}
2021-06-13 09:23:10 +00:00
tproxyUDPListener, err = tproxy.NewUDP(addr, udpIn)
if err != nil {
log.Warnln("Failed to start TProxy UDP Listener: %s", err)
}
2021-06-13 09:23:10 +00:00
log.Infoln("TProxy server listening at: %s", tproxyListener.Address())
}
func ReCreateMixed(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) {
mixedMux.Lock()
defer mixedMux.Unlock()
var err error
defer func() {
if err != nil {
log.Errorln("Start Mixed(http+socks) server error: %s", err.Error())
}
}()
addr := genAddr(bindAddress, port, allowLan)
shouldTCPIgnore := false
shouldUDPIgnore := false
if mixedListener != nil {
2021-07-31 16:35:37 +00:00
if mixedListener.RawAddress() != addr {
mixedListener.Close()
mixedListener = nil
} else {
shouldTCPIgnore = true
}
}
if mixedUDPLister != nil {
2021-07-31 16:35:37 +00:00
if mixedUDPLister.RawAddress() != addr {
mixedUDPLister.Close()
mixedUDPLister = nil
} else {
shouldUDPIgnore = true
}
}
if shouldTCPIgnore && shouldUDPIgnore {
return
}
if portIsZero(addr) {
return
}
2021-06-13 09:23:10 +00:00
mixedListener, err = mixed.New(addr, tcpIn)
if err != nil {
return
}
2021-06-13 09:23:10 +00:00
mixedUDPLister, err = socks.NewUDP(addr, udpIn)
if err != nil {
mixedListener.Close()
return
}
log.Infoln("Mixed(http+socks) proxy listening at: %s", mixedListener.Address())
}
func ReCreateTun(tunConf *config.Tun, dnsCfg *config.DNS, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) {
2021-11-17 08:03:47 +00:00
tunMux.Lock()
defer tunMux.Unlock()
var err error
defer func() {
if err != nil {
2022-03-08 21:08:35 +00:00
log.Errorln("Start TUN listening error: %s", err.Error())
os.Exit(2)
}
}()
2022-03-08 21:08:35 +00:00
if tunStackListener != nil {
tunStackListener.Close()
tunStackListener = nil
2021-11-17 08:03:47 +00:00
}
2022-03-08 21:08:35 +00:00
if !tunConf.Enable {
return
2021-11-17 08:03:47 +00:00
}
tunStackListener, err = tun.New(tunConf, dnsCfg, tcpIn, udpIn)
if err != nil {
log.Warnln("Failed to start TUN interface: %s", err.Error())
}
2021-11-17 08:03:47 +00:00
}
2018-11-21 05:47:46 +00:00
// GetPorts return the ports of proxy servers
func GetPorts() *Ports {
ports := &Ports{}
if httpListener != nil {
_, portStr, _ := net.SplitHostPort(httpListener.Address())
2018-11-21 05:47:46 +00:00
port, _ := strconv.Atoi(portStr)
ports.Port = port
}
if socksListener != nil {
_, portStr, _ := net.SplitHostPort(socksListener.Address())
2018-11-21 05:47:46 +00:00
port, _ := strconv.Atoi(portStr)
ports.SocksPort = port
2018-07-15 14:23:20 +00:00
}
2018-11-21 05:47:46 +00:00
if redirListener != nil {
_, portStr, _ := net.SplitHostPort(redirListener.Address())
2018-11-21 05:47:46 +00:00
port, _ := strconv.Atoi(portStr)
ports.RedirPort = port
}
if tproxyListener != nil {
_, portStr, _ := net.SplitHostPort(tproxyListener.Address())
port, _ := strconv.Atoi(portStr)
ports.TProxyPort = port
}
if mixedListener != nil {
_, portStr, _ := net.SplitHostPort(mixedListener.Address())
port, _ := strconv.Atoi(portStr)
ports.MixedPort = port
}
2018-11-21 05:47:46 +00:00
return ports
}
2018-07-15 14:23:20 +00:00
2018-11-21 05:47:46 +00:00
func portIsZero(addr string) bool {
_, port, err := net.SplitHostPort(addr)
if port == "0" || port == "" || err != nil {
return true
}
return false
2018-07-15 14:23:20 +00:00
}
func genAddr(host string, port int, allowLan bool) string {
2018-11-21 05:47:46 +00:00
if allowLan {
if host == "*" {
return fmt.Sprintf(":%d", port)
}
2021-03-23 17:00:21 +00:00
return fmt.Sprintf("%s:%d", host, port)
2018-11-21 05:47:46 +00:00
}
2018-11-21 05:47:46 +00:00
return fmt.Sprintf("127.0.0.1:%d", port)
2018-07-15 14:23:20 +00:00
}
2021-11-17 08:03:47 +00:00
func Cleanup() {
if tunStackListener != nil {
_ = tunStackListener.Close()
2021-11-17 08:03:47 +00:00
}
}