package constant import ( "encoding/json" "fmt" "net" "net/netip" "strconv" "github.com/Dreamacro/clash/transport/socks5" ) // Socks addr type const ( TCP NetWork = iota UDP ALLNet HTTP Type = iota HTTPS SOCKS4 SOCKS5 SHADOWSOCKS VMESS REDIR TPROXY TUNNEL TUN TUIC INNER ) type NetWork int func (n NetWork) String() string { if n == TCP { return "tcp" } else if n == UDP { return "udp" } return "all" } func (n NetWork) MarshalJSON() ([]byte, error) { return json.Marshal(n.String()) } type Type int func (t Type) String() string { switch t { case HTTP: return "HTTP" case HTTPS: return "HTTPS" case SOCKS4: return "Socks4" case SOCKS5: return "Socks5" case SHADOWSOCKS: return "ShadowSocks" case VMESS: return "Vmess" case REDIR: return "Redir" case TPROXY: return "TProxy" case TUNNEL: return "Tunnel" case TUN: return "Tun" case TUIC: return "Tuic" case INNER: return "Inner" default: return "Unknown" } } func ParseType(t string) (*Type, error) { var res Type switch t { case "HTTP": res = HTTP case "HTTPS": res = HTTPS case "SOCKS4": res = SOCKS4 case "SOCKS5": res = SOCKS5 case "SHADOWSOCKS": res = SHADOWSOCKS case "VMESS": res = VMESS case "REDIR": res = REDIR case "TPROXY": res = TPROXY case "TUNNEL": res = TUNNEL case "TUN": res = TUN case "TUIC": res = TUIC case "INNER": res = INNER default: return nil, fmt.Errorf("unknown type: %s", t) } return &res, nil } func (t Type) MarshalJSON() ([]byte, error) { return json.Marshal(t.String()) } // Metadata is used to store connection address type Metadata struct { NetWork NetWork `json:"network"` Type Type `json:"type"` SrcIP netip.Addr `json:"sourceIP"` DstIP netip.Addr `json:"destinationIP"` SrcPort string `json:"sourcePort"` DstPort string `json:"destinationPort"` InIP netip.Addr `json:"inboundIP"` InPort string `json:"inboundPort"` InName string `json:"inboundName"` Host string `json:"host"` DNSMode DNSMode `json:"dnsMode"` Uid uint32 `json:"uid"` Process string `json:"process"` ProcessPath string `json:"processPath"` SpecialProxy string `json:"specialProxy"` SpecialRules string `json:"specialRules"` RemoteDst string `json:"remoteDestination"` // Only domain rule SniffHost string } func (m *Metadata) RemoteAddress() string { return net.JoinHostPort(m.String(), m.DstPort) } func (m *Metadata) SourceAddress() string { return net.JoinHostPort(m.SrcIP.String(), m.SrcPort) } func (m *Metadata) SourceDetail() string { if m.Type == INNER { return fmt.Sprintf("[%s]", ClashName) } switch { case m.Process != "" && m.Uid != 0: return fmt.Sprintf("%s(%s, uid=%d)", m.SourceAddress(), m.Process, m.Uid) case m.Uid != 0: return fmt.Sprintf("%s(uid=%d)", m.SourceAddress(), m.Uid) case m.Process != "": return fmt.Sprintf("%s(%s)", m.SourceAddress(), m.Process) default: return fmt.Sprintf("%s", m.SourceAddress()) } } func (m *Metadata) AddrType() int { switch true { case m.Host != "" || !m.DstIP.IsValid(): return socks5.AtypDomainName case m.DstIP.Is4(): return socks5.AtypIPv4 default: return socks5.AtypIPv6 } } func (m *Metadata) Resolved() bool { return m.DstIP.IsValid() } func (m *Metadata) RuleHost() string { if len(m.SniffHost) == 0 { return m.Host } else { return m.SniffHost } } // Pure is used to solve unexpected behavior // when dialing proxy connection in DNSMapping mode. func (m *Metadata) Pure() *Metadata { if (m.DNSMode == DNSMapping || m.DNSMode == DNSHosts) && m.DstIP.IsValid() { copyM := *m copyM.Host = "" return ©M } return m } func (m *Metadata) UDPAddr() *net.UDPAddr { if m.NetWork != UDP || !m.DstIP.IsValid() { return nil } port, _ := strconv.ParseUint(m.DstPort, 10, 16) return &net.UDPAddr{ IP: m.DstIP.AsSlice(), Port: int(port), } } func (m *Metadata) String() string { if m.Host != "" { return m.Host } else if m.DstIP.IsValid() { return m.DstIP.String() } else { return "" } } func (m *Metadata) Valid() bool { return m.Host != "" || m.DstIP.IsValid() }