docstring_tokens stringlengths 0 76.5k | code_tokens stringlengths 75 1.81M | label_window listlengths 4 2.12k | html_url stringlengths 74 116 | file_name stringlengths 3 311 |
|---|---|---|---|---|
<mask> import (
<mask> "encoding/json"
<mask> "errors"
<mask> "net"
<mask> "sort"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type Selector struct {
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove selected C.Proxy
proxies map[string]C.Proxy
</s> add selected C.Proxy
proxies map[string]C.Proxy
proxyList []string </s> remove var all []string
for k := range s.proxies {
all = append(all, k)
}
sort.Strings(all)
</s> add </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | adapters/outbound/selector.go | |
selected C.Proxy
proxies map[string]C.Proxy
proxyList []string | <mask> )
<mask>
<mask> type Selector struct {
<mask> *Base
<mask> selected C.Proxy
<mask> proxies map[string]C.Proxy
<mask> }
<mask>
<mask> type SelectorOption struct {
<mask> Name string `proxy:"name"`
<mask> Proxies []string `proxy:"proxies"`
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove "sort"
</s> add </s> remove "all": all,
</s> add "all": s.proxyList, </s> remove var all []string
for k := range s.proxies {
all = append(all, k)
}
sort.Strings(all)
</s> add </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | adapters/outbound/selector.go |
<mask> return s.selected.SupportUDP()
<mask> }
<mask>
<mask> func (s *Selector) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for k := range s.proxies {
<mask> all = append(all, k)
<mask> }
<mask> sort.Strings(all)
<mask> return json.Marshal(map[string]interface{}{
<mask> "type": s.Type().String(),
<mask> "now": s.Now(),
<mask> "all": all,
<mask> })
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove "all": all,
</s> add "all": s.proxyList, </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | adapters/outbound/selector.go | |
"all": s.proxyList, | <mask> sort.Strings(all)
<mask> return json.Marshal(map[string]interface{}{
<mask> "type": s.Type().String(),
<mask> "now": s.Now(),
<mask> "all": all,
<mask> })
<mask> }
<mask>
<mask> func (s *Selector) Now() string {
<mask> return s.selected.Name()
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove var all []string
for k := range s.proxies {
all = append(all, k)
}
sort.Strings(all)
</s> add </s> remove selected C.Proxy
proxies map[string]C.Proxy
</s> add selected C.Proxy
proxies map[string]C.Proxy
proxyList []string </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | adapters/outbound/selector.go |
proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { | <mask> return nil, errors.New("Provide at least one proxy")
<mask> }
<mask>
<mask> mapping := make(map[string]C.Proxy)
<mask> for _, proxy := range proxies {
<mask> mapping[proxy.Name()] = proxy
<mask> }
<mask>
<mask> s := &Selector{
<mask> Base: &Base{
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | adapters/outbound/selector.go |
proxyList[idx] = proxy.Name() | <mask> mapping := make(map[string]C.Proxy)
<mask> proxyList := make([]string, len(proxies))
<mask> for idx, proxy := range proxies {
<mask> mapping[proxy.Name()] = proxy
<mask> }
<mask>
<mask> s := &Selector{
<mask> Base: &Base{
<mask> name: name,
<mask> tp: C.Selector,
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { </s> remove proxies: mapping,
selected: proxies[0],
</s> add proxies: mapping,
selected: proxies[0],
proxyList: proxyList, </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | adapters/outbound/selector.go |
proxies: mapping,
selected: proxies[0],
proxyList: proxyList, | <mask> Base: &Base{
<mask> name: name,
<mask> tp: C.Selector,
<mask> },
<mask> proxies: mapping,
<mask> selected: proxies[0],
<mask> }
<mask> return s, nil
<mask> }
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) </s> remove var all []string
for k := range s.proxies {
all = append(all, k)
}
sort.Strings(all)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | adapters/outbound/selector.go |
proxyList := []string{} | <mask> }
<mask>
<mask> func parseProxies(cfg *rawConfig) (map[string]C.Proxy, error) {
<mask> proxies := make(map[string]C.Proxy)
<mask> proxiesConfig := cfg.Proxy
<mask> groupsConfig := cfg.ProxyGroup
<mask>
<mask> decoder := structure.NewDecoder(structure.Option{TagName: "proxy", WeaklyTypedInput: true})
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { </s> remove var all []string
for k := range s.proxies {
all = append(all, k)
}
sort.Strings(all)
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | config/config.go |
proxyList = append(proxyList, "DIRECT", "REJECT") | <mask> proxies["DIRECT"] = adapters.NewProxy(adapters.NewDirect())
<mask> proxies["REJECT"] = adapters.NewProxy(adapters.NewReject())
<mask>
<mask> // parse proxy
<mask> for idx, mapping := range proxiesConfig {
<mask> proxyType, existType := mapping["type"].(string)
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | config/config.go |
proxyList = append(proxyList, proxy.Name()) | <mask> if _, exist := proxies[proxy.Name()]; exist {
<mask> return nil, fmt.Errorf("Proxy %s is the duplicate name", proxy.Name())
<mask> }
<mask> proxies[proxy.Name()] = adapters.NewProxy(proxy)
<mask> }
<mask>
<mask> // parse proxy group
<mask> for idx, mapping := range groupsConfig {
<mask> groupType, existType := mapping["type"].(string)
<mask> groupName, existName := mapping["name"].(string)
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | config/config.go |
proxyList = append(proxyList, groupName) | <mask> }
<mask> proxies[groupName] = adapters.NewProxy(group)
<mask> }
<mask>
<mask> ps := []C.Proxy{}
<mask> for _, v := range proxyList {
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove for _, v := range proxies {
ps = append(ps, v)
</s> add for _, v := range proxyList {
ps = append(ps, proxies[v]) </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | config/config.go |
for _, v := range proxyList {
ps = append(ps, proxies[v]) | <mask> proxies[groupName] = adapters.NewProxy(group)
<mask> }
<mask>
<mask> ps := []C.Proxy{}
<mask> for _, v := range proxies {
<mask> ps = append(ps, v)
<mask> }
<mask>
<mask> global, _ := adapters.NewSelector("GLOBAL", ps)
<mask> proxies["GLOBAL"] = adapters.NewProxy(global)
<mask> return proxies, nil
</s> Feature: make the selector proxies order as same as the order in the config file (#180)
* make the proxies order the same as the order in config file
* formatting & rename variable </s> remove for _, proxy := range proxies {
</s> add proxyList := make([]string, len(proxies))
for idx, proxy := range proxies { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eccbb023c7bc7f426e1e5fd25632cca18e1a999 | config/config.go |
func (d *Direct) Type() C.AdapterType {
return C.Direct
}
| <mask> return "Direct"
<mask> }
<mask>
<mask> func (d *Direct) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
<mask> c, err := net.Dial("tcp", net.JoinHostPort(addr.String(), addr.Port))
<mask> if err != nil {
<mask> return
</s> Add: selector and proxys & rules router </s> remove w.WriteHeader(http.StatusInternalServerError)
</s> add w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | adapters/direct.go |
func (r *Reject) Type() C.AdapterType {
return C.Reject
}
| <mask> return "Reject"
<mask> }
<mask>
<mask> func (r *Reject) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
<mask> return &RejectAdapter{}, nil
<mask> }
<mask>
<mask> func NewReject() *Reject {
<mask> return &Reject{}
</s> Add: selector and proxys & rules router </s> remove r.Get("/", getConfig)
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | adapters/reject.go |
func (ss *ShadowSocks) Type() C.AdapterType {
return C.Shadowsocks
}
| <mask> func (ss *ShadowSocks) Name() string {
<mask> return ss.name
<mask> }
<mask>
<mask> func (ss *ShadowSocks) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
<mask> c, err := net.Dial("tcp", ss.server)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("%s connect error", ss.server)
<mask> }
<mask> c.(*net.TCPConn).SetKeepAlive(true)
</s> Add: selector and proxys & rules router </s> remove w.WriteHeader(http.StatusInternalServerError)
</s> add w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | adapters/shadowsocks.go |
func (u *URLTest) Type() C.AdapterType {
return C.URLTest
}
func (u *URLTest) Now() string {
return u.fast.Name()
}
| <mask> return u.name
<mask> }
<mask>
<mask> func (u *URLTest) Generator(addr *C.Addr) (adapter C.ProxyAdapter, err error) {
<mask> return u.fast.Generator(addr)
<mask> }
<mask>
</s> Add: selector and proxys & rules router </s> remove r.Get("/", getConfig)
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | adapters/urltest.go |
// Adapter Type
const (
Direct AdapterType = iota
Reject
Selector
Shadowsocks
URLTest
)
| <mask> "io"
<mask> "net"
<mask> )
<mask>
<mask> type ProxyAdapter interface {
<mask> ReadWriter() io.ReadWriter
<mask> Conn() net.Conn
<mask> Close()
</s> Add: selector and proxys & rules router </s> remove type Configs struct {
Proxys []Proxy `json:"proxys"`
Rules []Rule `json:"rules"`
}
type Proxy struct {
Name string `json:"name"`
}
type Rule struct {
Name string `json:"name"`
Payload string `json:"type"`
}
</s> add </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | constant/adapters.go |
Type() AdapterType | <mask> type Proxy interface {
<mask> Name() string
<mask> Generator(addr *Addr) (ProxyAdapter, error)
<mask> }
<mask>
<mask> // AdapterType is enum of adapter type
<mask> type AdapterType int
<mask>
</s> Add: selector and proxys & rules router </s> remove type Configs struct {
Proxys []Proxy `json:"proxys"`
Rules []Rule `json:"rules"`
}
type Proxy struct {
Name string `json:"name"`
}
type Rule struct {
Name string `json:"name"`
Payload string `json:"type"`
}
</s> add </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | constant/adapters.go |
"github.com/Dreamacro/clash/tunnel"
| <mask> "net/http"
<mask>
<mask> "github.com/go-chi/chi"
<mask> "github.com/go-chi/render"
<mask> )
<mask>
<mask> func configRouter() http.Handler {
</s> Add: selector and proxys & rules router </s> remove type Configs struct {
Proxys []Proxy `json:"proxys"`
Rules []Rule `json:"rules"`
}
type Proxy struct {
Name string `json:"name"`
}
type Rule struct {
Name string `json:"name"`
Payload string `json:"type"`
}
</s> add </s> remove r.Get("/", getConfig)
</s> add </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go |
<mask> "github.com/go-chi/chi"
<mask> "github.com/go-chi/render"
<mask> )
<mask>
<mask> type Configs struct {
<mask> Proxys []Proxy `json:"proxys"`
<mask> Rules []Rule `json:"rules"`
<mask> }
<mask>
<mask> type Proxy struct {
<mask> Name string `json:"name"`
<mask> }
<mask>
<mask> type Rule struct {
<mask> Name string `json:"name"`
<mask> Payload string `json:"type"`
<mask> }
<mask>
<mask> func configRouter() http.Handler {
<mask> r := chi.NewRouter()
<mask> r.Get("/", getConfig)
<mask> r.Put("/", updateConfig)
<mask> return r
</s> Add: selector and proxys & rules router </s> remove r.Get("/", getConfig)
</s> add </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go | |
<mask> }
<mask>
<mask> func configRouter() http.Handler {
<mask> r := chi.NewRouter()
<mask> r.Get("/", getConfig)
<mask> r.Put("/", updateConfig)
<mask> return r
<mask> }
<mask>
<mask> func getConfig(w http.ResponseWriter, r *http.Request) {
</s> Add: selector and proxys & rules router </s> remove type Configs struct {
Proxys []Proxy `json:"proxys"`
Rules []Rule `json:"rules"`
}
type Proxy struct {
Name string `json:"name"`
}
type Rule struct {
Name string `json:"name"`
Payload string `json:"type"`
}
</s> add </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} </s> remove err := tun.UpdateConfig()
</s> add general := &General{}
err := render.DecodeJSON(r.Body, general) </s> remove w.WriteHeader(http.StatusInternalServerError)
</s> add w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) </s> remove w.WriteHeader(http.StatusOK)
render.JSON(w, r, Configs{
Rules: rules,
Proxys: proxys,
})
</s> add var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go | |
type General struct {
Mode string `json:mode`
} | <mask> r.Put("/", updateConfig)
<mask> return r
<mask> }
<mask>
<mask> func getConfig(w http.ResponseWriter, r *http.Request) {
<mask> rulesCfg, proxysCfg := tun.Config()
<mask>
<mask> var (
<mask> rules []Rule
<mask> proxys []Proxy
<mask> )
<mask>
<mask> for _, rule := range rulesCfg {
<mask> rules = append(rules, Rule{
<mask> Name: rule.RuleType().String(),
<mask> Payload: rule.Payload(),
<mask> })
<mask> }
<mask>
<mask> for _, proxy := range proxysCfg {
<mask> proxys = append(proxys, Proxy{Name: proxy.Name()})
<mask> }
<mask>
<mask> w.WriteHeader(http.StatusOK)
<mask> render.JSON(w, r, Configs{
<mask> Rules: rules,
<mask> Proxys: proxys,
</s> Add: selector and proxys & rules router </s> remove w.WriteHeader(http.StatusOK)
render.JSON(w, r, Configs{
Rules: rules,
Proxys: proxys,
})
</s> add var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, </s> remove r.Get("/", getConfig)
</s> add </s> remove if len(rule) < 4 {
continue
}
</s> add </s> remove proxy := strings.Split(key.Value(), ",")
</s> add proxy := key.Strings(",") </s> remove type Configs struct {
Proxys []Proxy `json:"proxys"`
Rules []Rule `json:"rules"`
}
type Proxy struct {
Name string `json:"name"`
}
type Rule struct {
Name string `json:"name"`
Payload string `json:"type"`
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"k... | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go |
var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, | <mask> for _, proxy := range proxysCfg {
<mask> proxys = append(proxys, Proxy{Name: proxy.Name()})
<mask> }
<mask>
<mask> w.WriteHeader(http.StatusOK)
<mask> render.JSON(w, r, Configs{
<mask> Rules: rules,
<mask> Proxys: proxys,
<mask> })
<mask> }
<mask>
<mask> func updateConfig(w http.ResponseWriter, r *http.Request) {
<mask> err := tun.UpdateConfig()
<mask> if err != nil {
</s> Add: selector and proxys & rules router </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} </s> remove err := tun.UpdateConfig()
</s> add general := &General{}
err := render.DecodeJSON(r.Body, general) </s> remove w.WriteHeader(http.StatusInternalServerError)
</s> add w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) </s> remove proxy := strings.Split(key.Value(), ",")
</s> add proxy := key.Strings(",") </s> remove Error: err.Error(),
</s> add Error: "Mode error", | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go |
general := &General{}
err := render.DecodeJSON(r.Body, general) | <mask> })
<mask> }
<mask>
<mask> func updateConfig(w http.ResponseWriter, r *http.Request) {
<mask> err := tun.UpdateConfig()
<mask> if err != nil {
<mask> w.WriteHeader(http.StatusInternalServerError)
<mask> render.JSON(w, r, Error{
<mask> Error: err.Error(),
<mask> })
</s> Add: selector and proxys & rules router </s> remove w.WriteHeader(http.StatusInternalServerError)
</s> add w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) </s> remove Error: err.Error(),
</s> add Error: "Mode error", </s> remove w.WriteHeader(http.StatusOK)
render.JSON(w, r, Configs{
Rules: rules,
Proxys: proxys,
})
</s> add var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} </s> remove r.Get("/", getConfig)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go |
w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) | <mask>
<mask> func updateConfig(w http.ResponseWriter, r *http.Request) {
<mask> err := tun.UpdateConfig()
<mask> if err != nil {
<mask> w.WriteHeader(http.StatusInternalServerError)
<mask> render.JSON(w, r, Error{
<mask> Error: err.Error(),
<mask> })
<mask> return
<mask> }
</s> Add: selector and proxys & rules router </s> remove err := tun.UpdateConfig()
</s> add general := &General{}
err := render.DecodeJSON(r.Body, general) </s> remove Error: err.Error(),
</s> add Error: "Mode error", </s> remove w.WriteHeader(http.StatusOK)
render.JSON(w, r, Configs{
Rules: rules,
Proxys: proxys,
})
</s> add var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, </s> remove r.Get("/", getConfig)
</s> add </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go |
Error: "Mode error", | <mask> err := tun.UpdateConfig()
<mask> if err != nil {
<mask> w.WriteHeader(http.StatusInternalServerError)
<mask> render.JSON(w, r, Error{
<mask> Error: err.Error(),
<mask> })
<mask> return
<mask> }
<mask> w.WriteHeader(http.StatusNoContent)
<mask> }
</s> Add: selector and proxys & rules router </s> remove w.WriteHeader(http.StatusInternalServerError)
</s> add w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) </s> remove err := tun.UpdateConfig()
</s> add general := &General{}
err := render.DecodeJSON(r.Body, general) </s> remove w.WriteHeader(http.StatusOK)
render.JSON(w, r, Configs{
Rules: rules,
Proxys: proxys,
})
</s> add var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go |
tun.SetMode(mode) | <mask> Error: "Mode error",
<mask> })
<mask> return
<mask> }
<mask> w.WriteHeader(http.StatusNoContent)
<mask> }
</s> Add: selector and proxys & rules router </s> remove Error: err.Error(),
</s> add Error: "Mode error", </s> remove w.WriteHeader(http.StatusInternalServerError)
</s> add w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) </s> remove err := tun.UpdateConfig()
</s> add general := &General{}
err := render.DecodeJSON(r.Body, general) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/configs.go |
r.Mount("/proxys", proxyRouter())
r.Mount("/rules", ruleRouter()) | <mask>
<mask> r.Get("/traffic", traffic)
<mask> r.Get("/logs", getLogs)
<mask> r.Mount("/configs", configRouter())
<mask>
<mask> err := http.ListenAndServe(addr, r)
<mask> if err != nil {
<mask> log.Fatalf("External controller error: %s", err.Error())
<mask> }
<mask> }
</s> Add: selector and proxys & rules router </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} </s> remove Error: err.Error(),
</s> add Error: "Mode error", </s> remove w.WriteHeader(http.StatusInternalServerError)
</s> add w.WriteHeader(http.StatusBadRequest)
render.JSON(w, r, Error{
Error: "Format error",
})
return
}
mode, ok := modeMapping[general.Mode]
if !ok {
w.WriteHeader(http.StatusBadRequest) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | hub/server.go |
mode Mode
selector *adapters.Selector | <mask> configLock *sync.RWMutex
<mask> traffic *C.Traffic
<mask> }
<mask>
<mask> func (t *Tunnel) Add(req C.ServerAdapter) {
<mask> t.queue.In() <- req
<mask> }
<mask>
</s> Add: selector and proxys & rules router </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go |
func (t *Tunnel) SetMode(mode Mode) {
t.mode = mode
}
| <mask> }
<mask>
<mask> func (t *Tunnel) UpdateConfig() (err error) {
<mask> cfg, err := C.GetConfig()
<mask> if err != nil {
<mask> return
<mask> }
</s> Add: selector and proxys & rules router </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go |
proxy := key.Strings(",") | <mask> groupsConfig := cfg.Section("Proxy Group")
<mask>
<mask> // parse proxy
<mask> for _, key := range proxysConfig.Keys() {
<mask> proxy := strings.Split(key.Value(), ",")
<mask> if len(proxy) == 0 {
<mask> continue
<mask> }
<mask> proxy = trimArr(proxy)
<mask> switch proxy[0] {
</s> Add: selector and proxys & rules router </s> remove proxy = trimArr(proxy)
</s> add </s> remove if len(rule) < 4 {
continue
}
</s> add </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} </s> remove w.WriteHeader(http.StatusOK)
render.JSON(w, r, Configs{
Rules: rules,
Proxys: proxys,
})
</s> add var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go |
<mask> proxy := strings.Split(key.Value(), ",")
<mask> if len(proxy) == 0 {
<mask> continue
<mask> }
<mask> proxy = trimArr(proxy)
<mask> switch proxy[0] {
<mask> // ss, server, port, cipter, password
<mask> case "ss":
<mask> if len(proxy) < 5 {
<mask> continue
</s> Add: selector and proxys & rules router </s> remove proxy := strings.Split(key.Value(), ",")
</s> add proxy := key.Strings(",") </s> remove if len(rule) < 4 {
continue
}
</s> add </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} </s> remove w.WriteHeader(http.StatusOK)
render.JSON(w, r, Configs{
Rules: rules,
Proxys: proxys,
})
</s> add var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go | |
<mask>
<mask> // parse proxy groups
<mask> for _, key := range groupsConfig.Keys() {
<mask> rule := strings.Split(key.Value(), ",")
<mask> if len(rule) < 4 {
<mask> continue
<mask> }
<mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "url-test":
<mask> proxyNames := rule[1 : len(rule)-2]
<mask> delay, _ := strconv.Atoi(rule[len(rule)-1])
</s> Add: selector and proxys & rules router </s> remove proxy := strings.Split(key.Value(), ",")
</s> add proxy := key.Strings(",") </s> remove proxy = trimArr(proxy)
</s> add </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go | |
if len(rule) < 4 {
return fmt.Errorf("URLTest need more than 4 param")
} | <mask> rule = trimArr(rule)
<mask> switch rule[0] {
<mask> case "url-test":
<mask> proxyNames := rule[1 : len(rule)-2]
<mask> delay, _ := strconv.Atoi(rule[len(rule)-1])
<mask> url := rule[len(rule)-2]
<mask> var ps []C.Proxy
</s> Add: selector and proxys & rules router </s> remove if len(rule) < 4 {
continue
}
</s> add </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} </s> remove proxy = trimArr(proxy)
</s> add </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} </s> remove proxy := strings.Split(key.Value(), ",")
</s> add proxy := key.Strings(",") | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go |
s, err := adapters.NewSelector("Proxy", proxys)
if err != nil {
return err
}
| <mask> urlTest.Close()
<mask> }
<mask> }
<mask>
<mask> t.proxys = proxys
<mask> t.rules = rules
<mask> t.selector = s
<mask>
</s> Add: selector and proxys & rules router </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} </s> remove w.WriteHeader(http.StatusOK)
render.JSON(w, r, Configs{
Rules: rules,
Proxys: proxys,
})
</s> add var modeMapping = map[string]tunnel.Mode{
"global": tunnel.Global,
"rule": tunnel.Rule,
"direct": tunnel.Direct, | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go |
t.selector = s | <mask>
<mask> t.proxys = proxys
<mask> t.rules = rules
<mask>
<mask> return nil
<mask> }
<mask>
<mask> func (t *Tunnel) process() {
<mask> queue := t.queue.Out()
</s> Add: selector and proxys & rules router </s> remove func getConfig(w http.ResponseWriter, r *http.Request) {
rulesCfg, proxysCfg := tun.Config()
var (
rules []Rule
proxys []Proxy
)
for _, rule := range rulesCfg {
rules = append(rules, Rule{
Name: rule.RuleType().String(),
Payload: rule.Payload(),
})
}
for _, proxy := range proxysCfg {
proxys = append(proxys, Proxy{Name: proxy.Name()})
}
</s> add type General struct {
Mode string `json:mode`
} </s> remove proxy := t.match(addr)
</s> add var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go |
var proxy C.Proxy
switch t.mode {
case Direct:
proxy = t.proxys["DIRECT"]
case Global:
proxy = t.selector
// Rule
default:
proxy = t.match(addr)
} | <mask>
<mask> func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
<mask> addr := localConn.Addr()
<mask> proxy := t.match(addr)
<mask> remoConn, err := proxy.Generator(addr)
<mask> if err != nil {
<mask> t.logCh <- newLog(WARNING, "Proxy connect error: %s", err.Error())
<mask> return
<mask> }
</s> Add: selector and proxys & rules router | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go |
mode: Rule, | <mask> observable: observable.NewObservable(logCh),
<mask> logCh: logCh,
<mask> configLock: &sync.RWMutex{},
<mask> traffic: C.NewTraffic(time.Second),
<mask> }
<mask> go tunnel.process()
<mask> go tunnel.subscribeLogs()
<mask> return tunnel
</s> Add: selector and proxys & rules router | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0eef9bbf5d86bbbd2626dfcef7830d4268e8271c | tunnel/tunnel.go |
return newPacketConn(&socksUDPConn{PacketConn: pc, rAddr: targetAddr, tcpConn: c}, ss), addr, nil | <mask> // ASSOCIATE request arrived on terminates. RFC1928
<mask> pc.Close()
<mask> }()
<mask>
<mask> return newPacketConn(&socksUDPConn{PacketConn: pc, rAddr: targetAddr}, ss), addr, nil
<mask> }
<mask>
<mask> func NewSocks5(option Socks5Option) *Socks5 {
<mask> var tlsConfig *tls.Config
<mask> if option.TLS {
</s> Optimization: socks UDP & fix typo (#261) </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) </s> remove rawpc, naddr, err := proxy.DialUDP(metadata)
addr = naddr
pc = rawpc
</s> add rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc </s> remove defer remoConn.Close()
</s> add defer remoteConn.Close() </s> remove rAddr net.Addr
</s> add rAddr net.Addr
tcpConn net.Conn </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawpc.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | adapters/outbound/socks5.go |
rAddr net.Addr
tcpConn net.Conn | <mask> }
<mask>
<mask> type socksUDPConn struct {
<mask> net.PacketConn
<mask> rAddr net.Addr
<mask> }
<mask>
<mask> func (uc *socksUDPConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
<mask> packet, err := socks5.EncodeUDPPacket(uc.rAddr.String(), b)
<mask> if err != nil {
</s> Optimization: socks UDP & fix typo (#261) </s> remove rawpc, naddr, err := proxy.DialUDP(metadata)
addr = naddr
pc = rawpc
</s> add rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) </s> remove defer remoConn.Close()
</s> add defer remoteConn.Close() </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoConn.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoteConn.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | adapters/outbound/socks5.go |
func (uc *socksUDPConn) Close() error {
uc.tcpConn.Close()
return uc.PacketConn.Close()
} | <mask> }
<mask> copy(b, payload)
<mask> return n - len(addr) - 3, a, e
<mask> }
</s> Optimization: socks UDP & fix typo (#261) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawpc.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String()) </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) </s> remove t.handleHTTP(adapter, remoConn)
</s> add t.handleHTTP(adapter, remoteConn) </s> remove t.handleSocket(adapter, remoConn)
</s> add t.handleSocket(adapter, remoteConn) </s> remove defer remoConn.Close()
</s> add defer remoteConn.Close() | [
"keep",
"keep",
"keep",
"add"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | adapters/outbound/socks5.go |
rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc | <mask>
<mask> func (t *Tunnel) handleUDPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
<mask> pc, addr := natTable.Get(localConn.RemoteAddr())
<mask> if pc == nil {
<mask> rawpc, naddr, err := proxy.DialUDP(metadata)
<mask> addr = naddr
<mask> pc = rawpc
<mask> if err != nil {
<mask> log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
<mask> return
<mask> }
<mask>
</s> Optimization: socks UDP & fix typo (#261) </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) </s> remove rAddr net.Addr
</s> add rAddr net.Addr
tcpConn net.Conn </s> remove t.handleSocket(adapter, remoConn)
</s> add t.handleSocket(adapter, remoteConn) </s> remove defer remoConn.Close()
</s> add defer remoteConn.Close() </s> remove return newPacketConn(&socksUDPConn{PacketConn: pc, rAddr: targetAddr}, ss), addr, nil
</s> add return newPacketConn(&socksUDPConn{PacketConn: pc, rAddr: targetAddr, tcpConn: c}, ss), addr, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | tunnel/tunnel.go |
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String()) | <mask> return
<mask> }
<mask>
<mask> if rule != nil {
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawpc.Chains().String())
<mask> } else {
<mask> log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
<mask> }
<mask>
<mask> natTable.Set(localConn.RemoteAddr(), pc, addr)
</s> Optimization: socks UDP & fix typo (#261) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoConn.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoteConn.Chains().String()) </s> remove defer remoConn.Close()
</s> add defer remoteConn.Close() </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) </s> remove return newPacketConn(&socksUDPConn{PacketConn: pc, rAddr: targetAddr}, ss), addr, nil
</s> add return newPacketConn(&socksUDPConn{PacketConn: pc, rAddr: targetAddr, tcpConn: c}, ss), addr, nil </s> remove rAddr net.Addr
</s> add rAddr net.Addr
tcpConn net.Conn | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | tunnel/tunnel.go |
remoteConn, err := proxy.Dial(metadata) | <mask> t.handleUDPToRemote(localConn, pc, addr)
<mask> }
<mask>
<mask> func (t *Tunnel) handleTCPConn(localConn C.ServerAdapter, metadata *C.Metadata, proxy C.Proxy, rule C.Rule) {
<mask> remoConn, err := proxy.Dial(metadata)
<mask> if err != nil {
<mask> log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
<mask> return
<mask> }
<mask> defer remoConn.Close()
</s> Optimization: socks UDP & fix typo (#261) </s> remove rawpc, naddr, err := proxy.DialUDP(metadata)
addr = naddr
pc = rawpc
</s> add rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc </s> remove defer remoConn.Close()
</s> add defer remoteConn.Close() </s> remove t.handleSocket(adapter, remoConn)
</s> add t.handleSocket(adapter, remoteConn) </s> remove rAddr net.Addr
</s> add rAddr net.Addr
tcpConn net.Conn </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawpc.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | tunnel/tunnel.go |
defer remoteConn.Close() | <mask> if err != nil {
<mask> log.Warnln("dial %s error: %s", proxy.Name(), err.Error())
<mask> return
<mask> }
<mask> defer remoConn.Close()
<mask>
<mask> if rule != nil {
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoConn.Chains().String())
<mask> } else {
<mask> log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
</s> Optimization: socks UDP & fix typo (#261) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoConn.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoteConn.Chains().String()) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawpc.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String()) </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) </s> remove rawpc, naddr, err := proxy.DialUDP(metadata)
addr = naddr
pc = rawpc
</s> add rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc </s> remove rAddr net.Addr
</s> add rAddr net.Addr
tcpConn net.Conn | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | tunnel/tunnel.go |
log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoteConn.Chains().String()) | <mask> }
<mask> defer remoConn.Close()
<mask>
<mask> if rule != nil {
<mask> log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoConn.Chains().String())
<mask> } else {
<mask> log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
<mask> }
<mask>
<mask> switch adapter := localConn.(type) {
</s> Optimization: socks UDP & fix typo (#261) </s> remove defer remoConn.Close()
</s> add defer remoteConn.Close() </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawpc.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rawPc.Chains().String()) </s> remove t.handleHTTP(adapter, remoConn)
</s> add t.handleHTTP(adapter, remoteConn) </s> remove t.handleSocket(adapter, remoConn)
</s> add t.handleSocket(adapter, remoteConn) </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | tunnel/tunnel.go |
t.handleHTTP(adapter, remoteConn) | <mask> }
<mask>
<mask> switch adapter := localConn.(type) {
<mask> case *InboundAdapter.HTTPAdapter:
<mask> t.handleHTTP(adapter, remoConn)
<mask> case *InboundAdapter.SocketAdapter:
<mask> t.handleSocket(adapter, remoConn)
<mask> }
<mask> }
<mask>
</s> Optimization: socks UDP & fix typo (#261) </s> remove t.handleSocket(adapter, remoConn)
</s> add t.handleSocket(adapter, remoteConn) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoConn.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoteConn.Chains().String()) </s> remove rAddr net.Addr
</s> add rAddr net.Addr
tcpConn net.Conn </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | tunnel/tunnel.go |
t.handleSocket(adapter, remoteConn) | <mask> switch adapter := localConn.(type) {
<mask> case *InboundAdapter.HTTPAdapter:
<mask> t.handleHTTP(adapter, remoConn)
<mask> case *InboundAdapter.SocketAdapter:
<mask> t.handleSocket(adapter, remoConn)
<mask> }
<mask> }
<mask>
<mask> func (t *Tunnel) shouldResolveIP(rule C.Rule, metadata *C.Metadata) bool {
<mask> return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.DstIP == nil
</s> Optimization: socks UDP & fix typo (#261) </s> remove t.handleHTTP(adapter, remoConn)
</s> add t.handleHTTP(adapter, remoteConn) </s> remove rawpc, naddr, err := proxy.DialUDP(metadata)
addr = naddr
pc = rawpc
</s> add rawPc, nAddr, err := proxy.DialUDP(metadata)
addr = nAddr
pc = rawPc </s> remove remoConn, err := proxy.Dial(metadata)
</s> add remoteConn, err := proxy.Dial(metadata) </s> remove log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoConn.Chains().String())
</s> add log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), remoteConn.Chains().String()) </s> remove rAddr net.Addr
</s> add rAddr net.Addr
tcpConn net.Conn | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0f7f0a9b1a0bb48d9fb268a03701686576c00025 | tunnel/tunnel.go |
IsAead: option.AlterID == 0, | <mask> AlterID: uint16(option.AlterID),
<mask> Security: security,
<mask> HostName: option.Server,
<mask> Port: strconv.Itoa(option.Port),
<mask> })
<mask> if err != nil {
<mask> return nil, err
<mask> }
</s> Feature: add vmess aead header support </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove stream.XORKeyStream(buf, buf)
</s> add </s> remove block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
</s> add if !vc.isAead {
block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
return err
}
stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes()) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | adapters/outbound/vmess.go |
"crypto/sha256" | <mask> "crypto/cipher"
<mask> "crypto/hmac"
<mask> "crypto/md5"
<mask> "encoding/binary"
<mask> "errors"
<mask> "hash/fnv"
<mask> "io"
<mask> "math/rand"
</s> Feature: add vmess aead header support </s> remove return newConn(conn, c.user[r], dst, c.security)
</s> add return newConn(conn, c.user[r], dst, c.security, c.isAead) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
isAead bool | <mask> respBodyIV []byte
<mask> respBodyKey []byte
<mask> respV byte
<mask> security byte
<mask>
<mask> received bool
<mask> }
<mask>
<mask> func (vc *Conn) Write(b []byte) (int, error) {
<mask> return vc.writer.Write(b)
</s> Feature: add vmess aead header support </s> remove respBodyKey := md5.Sum(reqBodyKey[:])
respBodyIV := md5.Sum(reqBodyIV[:])
</s> add var (
respBodyKey []byte
respBodyIV []byte
)
if isAead {
bodyKey := sha256.Sum256(reqBodyKey)
bodyIV := sha256.Sum256(reqBodyIV)
respBodyKey = bodyKey[:16]
respBodyIV = bodyIV[:16]
} else {
bodyKey := md5.Sum(reqBodyKey)
bodyIV := md5.Sum(reqBodyIV)
respBodyKey = bodyKey[:]
respBodyIV = bodyIV[:]
} </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security, isAead bool) (*Conn, error) { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} | <mask>
<mask> func (vc *Conn) sendRequest() error {
<mask> timestamp := time.Now()
<mask>
<mask> h := hmac.New(md5.New, vc.id.UUID.Bytes())
<mask> binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
<mask> _, err := vc.Conn.Write(h.Sum(nil))
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> buf := &bytes.Buffer{}
<mask>
<mask> // Ver IV Key V Opt
</s> Feature: add vmess aead header support </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes())
</s> add var fixedLengthCmdKey [16]byte
copy(fixedLengthCmdKey[:], vc.id.CmdKey)
vmessout := sealVMessAEADHeader(fixedLengthCmdKey, buf.Bytes(), timestamp)
_, err := vc.Conn.Write(vmessout) </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
</s> add if !vc.isAead {
block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
return err
}
stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
if !vc.isAead {
block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
return err
}
stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes()) | <mask> fnv1a := fnv.New32a()
<mask> fnv1a.Write(buf.Bytes())
<mask> buf.Write(fnv1a.Sum(nil))
<mask>
<mask> block, err := aes.NewCipher(vc.id.CmdKey)
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
<mask> stream.XORKeyStream(buf.Bytes(), buf.Bytes())
</s> Feature: add vmess aead header support </s> remove stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes())
</s> add var fixedLengthCmdKey [16]byte
copy(fixedLengthCmdKey[:], vc.id.CmdKey)
vmessout := sealVMessAEADHeader(fixedLengthCmdKey, buf.Bytes(), timestamp)
_, err := vc.Conn.Write(vmessout) </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
_, err := vc.Conn.Write(h.Sum(nil))
if err != nil {
return err
</s> add if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
var fixedLengthCmdKey [16]byte
copy(fixedLengthCmdKey[:], vc.id.CmdKey)
vmessout := sealVMessAEADHeader(fixedLengthCmdKey, buf.Bytes(), timestamp)
_, err := vc.Conn.Write(vmessout) | <mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
<mask> stream.XORKeyStream(buf.Bytes(), buf.Bytes())
<mask> _, err = vc.Conn.Write(buf.Bytes())
<mask> return err
<mask> }
<mask>
<mask> func (vc *Conn) recvResponse() error {
<mask> block, err := aes.NewCipher(vc.respBodyKey[:])
</s> Feature: add vmess aead header support </s> remove block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
</s> add if !vc.isAead {
block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
return err
}
stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes()) </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
_, err := vc.Conn.Write(h.Sum(nil))
if err != nil {
return err
</s> add if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove stream.XORKeyStream(buf, buf)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} | <mask> return err
<mask> }
<mask>
<mask> func (vc *Conn) recvResponse() error {
<mask> block, err := aes.NewCipher(vc.respBodyKey[:])
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
<mask> buf := make([]byte, 4)
<mask> _, err = io.ReadFull(vc.Conn, buf)
<mask> if err != nil {
</s> Feature: add vmess aead header support </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes())
</s> add var fixedLengthCmdKey [16]byte
copy(fixedLengthCmdKey[:], vc.id.CmdKey)
vmessout := sealVMessAEADHeader(fixedLengthCmdKey, buf.Bytes(), timestamp)
_, err := vc.Conn.Write(vmessout) </s> remove h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
_, err := vc.Conn.Write(h.Sum(nil))
if err != nil {
return err
</s> add if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} </s> remove block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
</s> add if !vc.isAead {
block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
return err
}
stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes()) </s> remove stream.XORKeyStream(buf, buf)
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} | <mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
<mask> buf := make([]byte, 4)
<mask> _, err = io.ReadFull(vc.Conn, buf)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> stream.XORKeyStream(buf, buf)
<mask>
<mask> if buf[0] != vc.respV {
<mask> return errors.New("unexpected response header")
</s> Feature: add vmess aead header support </s> remove stream.XORKeyStream(buf, buf)
</s> add </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
</s> add if !vc.isAead {
block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
return err
}
stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes()) </s> remove h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
_, err := vc.Conn.Write(h.Sum(nil))
if err != nil {
return err
</s> add if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} </s> remove stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes())
</s> add var fixedLengthCmdKey [16]byte
copy(fixedLengthCmdKey[:], vc.id.CmdKey)
vmessout := sealVMessAEADHeader(fixedLengthCmdKey, buf.Bytes(), timestamp)
_, err := vc.Conn.Write(vmessout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
<mask> _, err = io.ReadFull(vc.Conn, buf)
<mask> if err != nil {
<mask> return err
<mask> }
<mask> stream.XORKeyStream(buf, buf)
<mask>
<mask> if buf[0] != vc.respV {
<mask> return errors.New("unexpected response header")
<mask> }
<mask>
</s> Feature: add vmess aead header support </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
</s> add if !vc.isAead {
block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
return err
}
stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes()) </s> remove h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
_, err := vc.Conn.Write(h.Sum(nil))
if err != nil {
return err
</s> add if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} </s> remove stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes())
</s> add var fixedLengthCmdKey [16]byte
copy(fixedLengthCmdKey[:], vc.id.CmdKey)
vmessout := sealVMessAEADHeader(fixedLengthCmdKey, buf.Bytes(), timestamp)
_, err := vc.Conn.Write(vmessout) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go | |
func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security, isAead bool) (*Conn, error) { | <mask> return md5hash.Sum(nil)
<mask> }
<mask>
<mask> // newConn return a Conn instance
<mask> func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) {
<mask> randBytes := make([]byte, 33)
<mask> rand.Read(randBytes)
<mask> reqBodyIV := make([]byte, 16)
<mask> reqBodyKey := make([]byte, 16)
<mask> copy(reqBodyIV[:], randBytes[:16])
</s> Feature: add vmess aead header support </s> remove return newConn(conn, c.user[r], dst, c.security)
</s> add return newConn(conn, c.user[r], dst, c.security, c.isAead) </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove respBodyKey := md5.Sum(reqBodyKey[:])
respBodyIV := md5.Sum(reqBodyIV[:])
</s> add var (
respBodyKey []byte
respBodyIV []byte
)
if isAead {
bodyKey := sha256.Sum256(reqBodyKey)
bodyIV := sha256.Sum256(reqBodyIV)
respBodyKey = bodyKey[:16]
respBodyIV = bodyIV[:16]
} else {
bodyKey := md5.Sum(reqBodyKey)
bodyIV := md5.Sum(reqBodyIV)
respBodyKey = bodyKey[:]
respBodyIV = bodyIV[:]
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
var (
respBodyKey []byte
respBodyIV []byte
)
if isAead {
bodyKey := sha256.Sum256(reqBodyKey)
bodyIV := sha256.Sum256(reqBodyIV)
respBodyKey = bodyKey[:16]
respBodyIV = bodyIV[:16]
} else {
bodyKey := md5.Sum(reqBodyKey)
bodyIV := md5.Sum(reqBodyIV)
respBodyKey = bodyKey[:]
respBodyIV = bodyIV[:]
} | <mask> copy(reqBodyIV[:], randBytes[:16])
<mask> copy(reqBodyKey[:], randBytes[16:32])
<mask> respV := randBytes[32]
<mask>
<mask> respBodyKey := md5.Sum(reqBodyKey[:])
<mask> respBodyIV := md5.Sum(reqBodyIV[:])
<mask>
<mask> var writer io.Writer
<mask> var reader io.Reader
<mask> switch security {
<mask> case SecurityNone:
</s> Feature: add vmess aead header support </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security, isAead bool) (*Conn, error) { </s> remove stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes())
</s> add var fixedLengthCmdKey [16]byte
copy(fixedLengthCmdKey[:], vc.id.CmdKey)
vmessout := sealVMessAEADHeader(fixedLengthCmdKey, buf.Bytes(), timestamp)
_, err := vc.Conn.Write(vmessout) </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
isAead: isAead, | <mask> reader: reader,
<mask> writer: writer,
<mask> security: security,
<mask> }
<mask> if err := c.sendRequest(); err != nil {
<mask> return nil, err
<mask> }
</s> Feature: add vmess aead header support </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
</s> add if !vc.isAead {
block, err := aes.NewCipher(vc.id.CmdKey)
if err != nil {
return err
}
stream := cipher.NewCFBEncrypter(block, hashTimestamp(timestamp))
stream.XORKeyStream(buf.Bytes(), buf.Bytes())
_, err = vc.Conn.Write(buf.Bytes()) </s> remove h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
_, err := vc.Conn.Write(h.Sum(nil))
if err != nil {
return err
</s> add if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/conn.go |
isAead bool | <mask> type Client struct {
<mask> user []*ID
<mask> uuid *uuid.UUID
<mask> security Security
<mask> }
<mask>
<mask> // Config of vmess
<mask> type Config struct {
<mask> UUID string
</s> Feature: add vmess aead header support </s> remove return newConn(conn, c.user[r], dst, c.security)
</s> add return newConn(conn, c.user[r], dst, c.security, c.isAead) </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security, isAead bool) (*Conn, error) { </s> remove respBodyKey := md5.Sum(reqBodyKey[:])
respBodyIV := md5.Sum(reqBodyIV[:])
</s> add var (
respBodyKey []byte
respBodyIV []byte
)
if isAead {
bodyKey := sha256.Sum256(reqBodyKey)
bodyIV := sha256.Sum256(reqBodyIV)
respBodyKey = bodyKey[:16]
respBodyIV = bodyIV[:16]
} else {
bodyKey := md5.Sum(reqBodyKey)
bodyIV := md5.Sum(reqBodyIV)
respBodyKey = bodyKey[:]
respBodyIV = bodyIV[:]
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/vmess.go |
IsAead bool | <mask> AlterID uint16
<mask> Security string
<mask> Port string
<mask> HostName string
<mask> }
<mask>
<mask> // StreamConn return a Conn with net.Conn and DstAddr
<mask> func (c *Client) StreamConn(conn net.Conn, dst *DstAddr) (net.Conn, error) {
<mask> r := rand.Intn(len(c.user))
<mask> return newConn(conn, c.user[r], dst, c.security, c.isAead)
</s> Feature: add vmess aead header support </s> remove return newConn(conn, c.user[r], dst, c.security)
</s> add return newConn(conn, c.user[r], dst, c.security, c.isAead) </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security, isAead bool) (*Conn, error) { </s> remove h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
_, err := vc.Conn.Write(h.Sum(nil))
if err != nil {
return err
</s> add if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/vmess.go |
return newConn(conn, c.user[r], dst, c.security, c.isAead) | <mask>
<mask> // StreamConn return a Conn with net.Conn and DstAddr
<mask> func (c *Client) StreamConn(conn net.Conn, dst *DstAddr) (net.Conn, error) {
<mask> r := rand.Intn(len(c.user))
<mask> return newConn(conn, c.user[r], dst, c.security)
<mask> }
<mask>
<mask> // NewClient return Client instance
<mask> func NewClient(config Config) (*Client, error) {
<mask> uid, err := uuid.FromString(config.UUID)
</s> Feature: add vmess aead header support </s> remove func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security) (*Conn, error) {
</s> add func newConn(conn net.Conn, id *ID, dst *DstAddr, security Security, isAead bool) (*Conn, error) { </s> remove h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
_, err := vc.Conn.Write(h.Sum(nil))
if err != nil {
return err
</s> add if !vc.isAead {
h := hmac.New(md5.New, vc.id.UUID.Bytes())
binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
} </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/vmess.go |
isAead: config.IsAead, | <mask> return &Client{
<mask> user: newAlterIDs(newID(&uid), config.AlterID),
<mask> uuid: &uid,
<mask> security: security,
<mask> }, nil
<mask> }
</s> Feature: add vmess aead header support </s> remove stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf := make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
</s> add stream := cipher.NewCFBDecrypter(block, vc.respBodyIV[:])
buf = make([]byte, 4)
_, err = io.ReadFull(vc.Conn, buf)
if err != nil {
return err
}
stream.XORKeyStream(buf, buf)
} else {
aeadResponseHeaderLengthEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderLenKey)[:16]
aeadResponseHeaderLengthEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderLenIV)[:12]
aeadResponseHeaderLengthEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderLengthEncryptionKey)
aeadResponseHeaderLengthEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderLengthEncryptionKeyAESBlock)
aeadEncryptedResponseHeaderLength := make([]byte, 18)
if _, err := io.ReadFull(vc.Conn, aeadEncryptedResponseHeaderLength); err != nil {
return err
}
decryptedResponseHeaderLengthBinaryBuffer, err := aeadResponseHeaderLengthEncryptionAEAD.Open(nil, aeadResponseHeaderLengthEncryptionIV, aeadEncryptedResponseHeaderLength[:], nil)
if err != nil {
return err
}
decryptedResponseHeaderLength := binary.BigEndian.Uint16(decryptedResponseHeaderLengthBinaryBuffer)
aeadResponseHeaderPayloadEncryptionKey := kdf(vc.respBodyKey[:], kdfSaltConstAEADRespHeaderPayloadKey)[:16]
aeadResponseHeaderPayloadEncryptionIV := kdf(vc.respBodyIV[:], kdfSaltConstAEADRespHeaderPayloadIV)[:12]
aeadResponseHeaderPayloadEncryptionKeyAESBlock, _ := aes.NewCipher(aeadResponseHeaderPayloadEncryptionKey)
aeadResponseHeaderPayloadEncryptionAEAD, _ := cipher.NewGCM(aeadResponseHeaderPayloadEncryptionKeyAESBlock)
encryptedResponseHeaderBuffer := make([]byte, decryptedResponseHeaderLength+16)
if _, err := io.ReadFull(vc.Conn, encryptedResponseHeaderBuffer); err != nil {
return err
}
buf, err = aeadResponseHeaderPayloadEncryptionAEAD.Open(nil, aeadResponseHeaderPayloadEncryptionIV, encryptedResponseHeaderBuffer, nil)
if err != nil {
return err
}
if len(buf) < 4 {
return errors.New("unexpected buffer length")
} </s> remove block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
}
</s> add var buf []byte
if !vc.isAead {
block, err := aes.NewCipher(vc.respBodyKey[:])
if err != nil {
return err
} </s> remove stream.XORKeyStream(buf, buf)
</s> add | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/109bfcb0f9bb07a23d55038ed4908b5d30037f31 | component/vmess/vmess.go |
server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port)) | <mask> return &ShadowsocksAdapter{conn: c}, err
<mask> }
<mask>
<mask> func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
<mask> server := fmt.Sprintf("%s:%d", option.Server, option.Port)
<mask> cipher := option.Cipher
<mask> password := option.Password
<mask> ciph, err := core.PickCipher(cipher, nil, password)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("ss %s initialize error: %s", server, err.Error())
</s> Fix: dial IPv6 host (#29) </s> remove server: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove addr: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove Host: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add Host: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/10e0231bc1f7d7997cc60390d3852737ed7b1bb8 | adapters/outbound/shadowsocks.go |
"strconv" | <mask> "errors"
<mask> "fmt"
<mask> "io"
<mask> "net"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask>
<mask> "github.com/Dreamacro/go-shadowsocks2/socks"
</s> Fix: dial IPv6 host (#29) </s> remove server: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove Host: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add Host: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove addr: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove server := fmt.Sprintf("%s:%d", option.Server, option.Port)
</s> add server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port)) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/10e0231bc1f7d7997cc60390d3852737ed7b1bb8 | adapters/outbound/socks5.go |
addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), | <mask> }
<mask> }
<mask>
<mask> return &Socks5{
<mask> addr: fmt.Sprintf("%s:%d", option.Server, option.Port),
<mask> name: option.Name,
<mask> tls: option.TLS,
<mask> skipCertVerify: option.SkipCertVerify,
<mask> tlsConfig: tlsConfig,
<mask> }
</s> Fix: dial IPv6 host (#29) </s> remove server: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove Host: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add Host: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove server := fmt.Sprintf("%s:%d", option.Server, option.Port)
</s> add server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/10e0231bc1f7d7997cc60390d3852737ed7b1bb8 | adapters/outbound/socks5.go |
Host: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), | <mask> UUID: option.UUID,
<mask> AlterID: uint16(option.AlterID),
<mask> Security: security,
<mask> TLS: option.TLS,
<mask> Host: fmt.Sprintf("%s:%d", option.Server, option.Port),
<mask> NetWork: option.Network,
<mask> WebSocketPath: option.WSPath,
<mask> SkipCertVerify: option.SkipCertVerify,
<mask> SessionCacahe: getClientSessionCache(),
<mask> })
</s> Fix: dial IPv6 host (#29) </s> remove addr: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove server: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove server := fmt.Sprintf("%s:%d", option.Server, option.Port)
</s> add server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/10e0231bc1f7d7997cc60390d3852737ed7b1bb8 | adapters/outbound/vmess.go |
server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), | <mask> }
<mask>
<mask> return &Vmess{
<mask> name: option.Name,
<mask> server: fmt.Sprintf("%s:%d", option.Server, option.Port),
<mask> client: client,
<mask> }, nil
<mask> }
<mask>
<mask> func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
</s> Fix: dial IPv6 host (#29) </s> remove addr: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), </s> remove server := fmt.Sprintf("%s:%d", option.Server, option.Port)
</s> add server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port)) </s> remove Host: fmt.Sprintf("%s:%d", option.Server, option.Port),
</s> add Host: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/10e0231bc1f7d7997cc60390d3852737ed7b1bb8 | adapters/outbound/vmess.go |
Image: ImageVmess, | <mask> }
<mask>
<mask> func TestClash_VmessWebsocket0RTT(t *testing.T) {
<mask> cfg := &container.Config{
<mask> Image: ImageXray,
<mask> ExposedPorts: defaultExposedPorts,
<mask> }
<mask> hostCfg := &container.HostConfig{
<mask> PortBindings: defaultPortBindings,
<mask> Binds: []string{
</s> Chore: adjust vmess 0rtt code and split xray test </s> remove fmt.Sprintf("%s:/etc/xray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")),
</s> add fmt.Sprintf("%s:/etc/v2ray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")), </s> remove earlyDataBuf := bytes.NewBuffer(nil)
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, earlyDataBuf)
earlydata := bytes.NewReader(earlyData)
limitedEarlyDatareader := io.LimitReader(earlydata, int64(wsedc.config.MaxEarlyData))
n, encerr := io.Copy(base64EarlyDataEncoder, limitedEarlyDatareader)
if encerr != nil {
return errors.New("failed to encode early data: " + encerr.Error())
</s> add base64DataBuf := &bytes.Buffer{}
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, base64DataBuf)
earlyDataBuf := bytes.NewBuffer(earlyData)
if _, err := base64EarlyDataEncoder.Write(earlyDataBuf.Next(wsedc.config.MaxEarlyData)); err != nil {
return errors.New("failed to encode early data: " + err.Error()) </s> remove
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
</s> add if earlyDataBuf.Len() != 0 {
_, err = wsedc.Conn.Write(earlyDataBuf.Bytes()) </s> remove if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
</s> add if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, base64DataBuf); err != nil { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/121bc910f6e5a5faa38c0e3f87e4eea1f0bd8f1b | test/vmess_test.go |
fmt.Sprintf("%s:/etc/v2ray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")), | <mask> }
<mask> hostCfg := &container.HostConfig{
<mask> PortBindings: defaultPortBindings,
<mask> Binds: []string{
<mask> fmt.Sprintf("%s:/etc/xray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")),
<mask> },
<mask> }
<mask>
<mask> id, err := startContainer(cfg, hostCfg, "vmess-ws-0rtt")
<mask> if err != nil {
</s> Chore: adjust vmess 0rtt code and split xray test </s> remove Image: ImageXray,
</s> add Image: ImageVmess, </s> remove earlyDataBuf := bytes.NewBuffer(nil)
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, earlyDataBuf)
earlydata := bytes.NewReader(earlyData)
limitedEarlyDatareader := io.LimitReader(earlydata, int64(wsedc.config.MaxEarlyData))
n, encerr := io.Copy(base64EarlyDataEncoder, limitedEarlyDatareader)
if encerr != nil {
return errors.New("failed to encode early data: " + encerr.Error())
</s> add base64DataBuf := &bytes.Buffer{}
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, base64DataBuf)
earlyDataBuf := bytes.NewBuffer(earlyData)
if _, err := base64EarlyDataEncoder.Write(earlyDataBuf.Next(wsedc.config.MaxEarlyData)); err != nil {
return errors.New("failed to encode early data: " + err.Error()) </s> remove if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
</s> add if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, base64DataBuf); err != nil { </s> remove
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
</s> add if earlyDataBuf.Len() != 0 {
_, err = wsedc.Conn.Write(earlyDataBuf.Bytes()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/121bc910f6e5a5faa38c0e3f87e4eea1f0bd8f1b | test/vmess_test.go |
base64DataBuf := &bytes.Buffer{}
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, base64DataBuf)
earlyDataBuf := bytes.NewBuffer(earlyData)
if _, err := base64EarlyDataEncoder.Write(earlyDataBuf.Next(wsedc.config.MaxEarlyData)); err != nil {
return errors.New("failed to encode early data: " + err.Error()) | <mask> return wsc.conn.SetWriteDeadline(t)
<mask> }
<mask>
<mask> func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
<mask> earlyDataBuf := bytes.NewBuffer(nil)
<mask> base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, earlyDataBuf)
<mask>
<mask> earlydata := bytes.NewReader(earlyData)
<mask> limitedEarlyDatareader := io.LimitReader(earlydata, int64(wsedc.config.MaxEarlyData))
<mask> n, encerr := io.Copy(base64EarlyDataEncoder, limitedEarlyDatareader)
<mask> if encerr != nil {
<mask> return errors.New("failed to encode early data: " + encerr.Error())
<mask> }
<mask>
<mask> if errc := base64EarlyDataEncoder.Close(); errc != nil {
<mask> return errors.New("failed to encode early data tail: " + errc.Error())
<mask> }
</s> Chore: adjust vmess 0rtt code and split xray test </s> remove if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
</s> add if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, base64DataBuf); err != nil { </s> remove
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
</s> add if earlyDataBuf.Len() != 0 {
_, err = wsedc.Conn.Write(earlyDataBuf.Bytes()) </s> remove fmt.Sprintf("%s:/etc/xray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")),
</s> add fmt.Sprintf("%s:/etc/v2ray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")), </s> remove Image: ImageXray,
</s> add Image: ImageVmess, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/121bc910f6e5a5faa38c0e3f87e4eea1f0bd8f1b | transport/vmess/websocket.go |
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, base64DataBuf); err != nil { | <mask> return errors.New("failed to encode early data tail: " + errc.Error())
<mask> }
<mask>
<mask> var err error
<mask> if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
<mask> wsedc.Close()
<mask> return errors.New("failed to dial WebSocket: " + err.Error())
<mask> }
<mask>
<mask> wsedc.dialed <- true
</s> Chore: adjust vmess 0rtt code and split xray test </s> remove
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
</s> add if earlyDataBuf.Len() != 0 {
_, err = wsedc.Conn.Write(earlyDataBuf.Bytes()) </s> remove earlyDataBuf := bytes.NewBuffer(nil)
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, earlyDataBuf)
earlydata := bytes.NewReader(earlyData)
limitedEarlyDatareader := io.LimitReader(earlydata, int64(wsedc.config.MaxEarlyData))
n, encerr := io.Copy(base64EarlyDataEncoder, limitedEarlyDatareader)
if encerr != nil {
return errors.New("failed to encode early data: " + encerr.Error())
</s> add base64DataBuf := &bytes.Buffer{}
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, base64DataBuf)
earlyDataBuf := bytes.NewBuffer(earlyData)
if _, err := base64EarlyDataEncoder.Write(earlyDataBuf.Next(wsedc.config.MaxEarlyData)); err != nil {
return errors.New("failed to encode early data: " + err.Error()) </s> remove fmt.Sprintf("%s:/etc/xray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")),
</s> add fmt.Sprintf("%s:/etc/v2ray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")), </s> remove Image: ImageXray,
</s> add Image: ImageVmess, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/121bc910f6e5a5faa38c0e3f87e4eea1f0bd8f1b | transport/vmess/websocket.go |
if earlyDataBuf.Len() != 0 {
_, err = wsedc.Conn.Write(earlyDataBuf.Bytes()) | <mask> return errors.New("failed to dial WebSocket: " + err.Error())
<mask> }
<mask>
<mask> wsedc.dialed <- true
<mask>
<mask> if n != int64(len(earlyData)) {
<mask> _, err = wsedc.Conn.Write(earlyData[n:])
<mask> }
<mask>
<mask> return err
<mask> }
<mask>
</s> Chore: adjust vmess 0rtt code and split xray test </s> remove if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
</s> add if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, base64DataBuf); err != nil { </s> remove earlyDataBuf := bytes.NewBuffer(nil)
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, earlyDataBuf)
earlydata := bytes.NewReader(earlyData)
limitedEarlyDatareader := io.LimitReader(earlydata, int64(wsedc.config.MaxEarlyData))
n, encerr := io.Copy(base64EarlyDataEncoder, limitedEarlyDatareader)
if encerr != nil {
return errors.New("failed to encode early data: " + encerr.Error())
</s> add base64DataBuf := &bytes.Buffer{}
base64EarlyDataEncoder := base64.NewEncoder(base64.RawURLEncoding, base64DataBuf)
earlyDataBuf := bytes.NewBuffer(earlyData)
if _, err := base64EarlyDataEncoder.Write(earlyDataBuf.Next(wsedc.config.MaxEarlyData)); err != nil {
return errors.New("failed to encode early data: " + err.Error()) </s> remove fmt.Sprintf("%s:/etc/xray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")),
</s> add fmt.Sprintf("%s:/etc/v2ray/config.json", C.Path.Resolve("vmess-ws-0rtt.json")), </s> remove Image: ImageXray,
</s> add Image: ImageVmess, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/121bc910f6e5a5faa38c0e3f87e4eea1f0bd8f1b | transport/vmess/websocket.go |
var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
} | <mask> func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
<mask> client := newClient(c.RemoteAddr(), in)
<mask> defer client.CloseIdleConnections()
<mask>
<mask> conn := N.NewBufferedConn(c)
<mask>
<mask> keepAlive := true
<mask> trusted := cache == nil // disable authenticate if cache is nil
<mask>
<mask> for keepAlive {
</s> Fix: listener tcp keepalive & reuse net.BufferedConn (#1987) </s> remove if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
}
</s> add </s> remove if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/132a6a6a2f45cd1db3dc1f0b756944b78adf4a24 | listener/http/proxy.go |
conn.(*net.TCPConn).SetKeepAlive(true)
| <mask> }
<mask>
<mask> func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
<mask> bufConn := N.NewBufferedConn(conn)
<mask> head, err := bufConn.Peek(1)
<mask> if err != nil {
<mask> return
<mask> }
<mask>
</s> Fix: listener tcp keepalive & reuse net.BufferedConn (#1987) </s> remove conn := N.NewBufferedConn(c)
</s> add var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
} </s> remove if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
}
</s> add </s> remove if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
}
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/132a6a6a2f45cd1db3dc1f0b756944b78adf4a24 | listener/mixed/mixed.go |
conn.(*net.TCPConn).SetKeepAlive(true) | <mask> }
<mask>
<mask> func handleSocks(conn net.Conn, in chan<- C.ConnContext) {
<mask> bufConn := N.NewBufferedConn(conn)
<mask> head, err := bufConn.Peek(1)
<mask> if err != nil {
<mask> conn.Close()
</s> Fix: listener tcp keepalive & reuse net.BufferedConn (#1987) </s> remove if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
}
</s> add </s> remove if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
}
</s> add </s> remove conn := N.NewBufferedConn(c)
</s> add var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/132a6a6a2f45cd1db3dc1f0b756944b78adf4a24 | listener/socks/tcp.go |
<mask> if err != nil {
<mask> conn.Close()
<mask> return
<mask> }
<mask> if c, ok := conn.(*net.TCPConn); ok {
<mask> c.SetKeepAlive(true)
<mask> }
<mask> in <- inbound.NewSocket(socks5.ParseAddr(addr), conn, C.SOCKS4)
<mask> }
<mask>
<mask> func HandleSocks5(conn net.Conn, in chan<- C.ConnContext) {
<mask> target, command, err := socks5.ServerHandshake(conn, authStore.Authenticator())
</s> Fix: listener tcp keepalive & reuse net.BufferedConn (#1987) </s> remove if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
}
</s> add </s> remove conn := N.NewBufferedConn(c)
</s> add var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/132a6a6a2f45cd1db3dc1f0b756944b78adf4a24 | listener/socks/tcp.go | |
<mask> if err != nil {
<mask> conn.Close()
<mask> return
<mask> }
<mask> if c, ok := conn.(*net.TCPConn); ok {
<mask> c.SetKeepAlive(true)
<mask> }
<mask> if command == socks5.CmdUDPAssociate {
<mask> defer conn.Close()
<mask> io.Copy(io.Discard, conn)
<mask> return
<mask> }
</s> Fix: listener tcp keepalive & reuse net.BufferedConn (#1987) </s> remove if c, ok := conn.(*net.TCPConn); ok {
c.SetKeepAlive(true)
}
</s> add </s> remove conn := N.NewBufferedConn(c)
</s> add var conn *N.BufferedConn
if bufConn, ok := c.(*N.BufferedConn); ok {
conn = bufConn
} else {
conn = N.NewBufferedConn(c)
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/132a6a6a2f45cd1db3dc1f0b756944b78adf4a24 | listener/socks/tcp.go | |
<mask>
<mask> func (m *Metadata) Valid() bool {
<mask> return m.Host != "" || m.IP != nil
<mask> }
<mask>
<mask> func (m *Metadata) NeedLoopUpHost() bool {
<mask> return m.Source == REDIR
<mask> }
</s> Fix: tun2socks not lookup IP </s> remove if metadata.NeedLoopUpHost() && t.hasResolver() {
</s> add if t.needLookupIP() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace"
] | https://github.com/Dreamacro/clash/commit/1339487ce48ccc30e6fe43409844f754ddad6af0 | constant/metadata.go | |
func (r *Resolver) IsMapping() bool {
return r.mapping
}
| <mask> return ch
<mask> }
<mask>
<mask> type NameServer struct {
<mask> Net string
<mask> Addr string
<mask> }
<mask>
</s> Fix: tun2socks not lookup IP </s> remove
func (m *Metadata) NeedLoopUpHost() bool {
return m.Source == REDIR
}
</s> add </s> remove if metadata.NeedLoopUpHost() && t.hasResolver() {
</s> add if t.needLookupIP() { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1339487ce48ccc30e6fe43409844f754ddad6af0 | dns/client.go |
func (t *Tunnel) needLookupIP() bool {
return t.hasResolver() && t.resolver.IsMapping()
}
| <mask> }
<mask>
<mask> func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
<mask> metadata := localConn.Metadata()
<mask>
</s> Fix: tun2socks not lookup IP </s> remove
func (m *Metadata) NeedLoopUpHost() bool {
return m.Source == REDIR
}
</s> add </s> remove if metadata.NeedLoopUpHost() && t.hasResolver() {
</s> add if t.needLookupIP() { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1339487ce48ccc30e6fe43409844f754ddad6af0 | tunnel/tunnel.go |
if t.needLookupIP() { | <mask> func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
<mask> defer localConn.Close()
<mask> metadata := localConn.Metadata()
<mask>
<mask> if metadata.NeedLoopUpHost() && t.hasResolver() {
<mask> host, exist := t.resolver.IPToHost(*metadata.IP)
<mask> if exist {
<mask> metadata.Host = host
<mask> metadata.AddrType = C.AtypDomainName
<mask> }
</s> Fix: tun2socks not lookup IP </s> remove
func (m *Metadata) NeedLoopUpHost() bool {
return m.Source == REDIR
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1339487ce48ccc30e6fe43409844f754ddad6af0 | tunnel/tunnel.go |
Filter string `provider:"filter,omitempty"` | <mask> URL string `provider:"url,omitempty"`
<mask> Interval int `provider:"interval,omitempty"`
<mask> HealthCheck healthCheckSchema `provider:"health-check,omitempty"`
<mask> }
<mask>
<mask> func ParseProxyProvider(name string, mapping map[string]interface{}) (types.ProxyProvider, error) {
<mask> decoder := structure.NewDecoder(structure.Option{TagName: "provider", WeaklyTypedInput: true})
<mask>
</s> Feature: add filter on proxy provider (#1511) </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider { </s> remove fetcher := newFetcher(name, interval, vehicle, proxiesParse, onUpdate)
</s> add proxiesParseAndFilter := func(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
filterReg := regexp.MustCompile(filter)
for idx, mapping := range schema.Proxies {
if name, ok := mapping["name"]; ok && len(filter) > 0 && !filterReg.MatchString(name.(string)) {
continue
}
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
if len(filter) > 0 {
return nil, errors.New("doesn't match any proxy, please check your filter")
}
return nil, errors.New("file doesn't have any proxy")
}
return proxies, nil
}
fetcher := newFetcher(name, interval, vehicle, proxiesParseAndFilter, onUpdate) </s> remove func proxiesParse(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
for idx, mapping := range schema.Proxies {
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
return nil, errors.New("file doesn't have any valid proxy")
}
return proxies, nil
}
</s> add </s> remove return NewProxySetProvider(name, interval, vehicle, hc), nil
</s> add filter := schema.Filter
return NewProxySetProvider(name, interval, filter, vehicle, hc), nil | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1401a82bb0c650a948d91c793369779439541f3e | adapter/provider/parser.go |
filter := schema.Filter
return NewProxySetProvider(name, interval, filter, vehicle, hc), nil | <mask> return nil, fmt.Errorf("%w: %s", errVehicleType, schema.Type)
<mask> }
<mask>
<mask> interval := time.Duration(uint(schema.Interval)) * time.Second
<mask> return NewProxySetProvider(name, interval, vehicle, hc), nil
<mask> }
</s> Feature: add filter on proxy provider (#1511) </s> remove fetcher := newFetcher(name, interval, vehicle, proxiesParse, onUpdate)
</s> add proxiesParseAndFilter := func(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
filterReg := regexp.MustCompile(filter)
for idx, mapping := range schema.Proxies {
if name, ok := mapping["name"]; ok && len(filter) > 0 && !filterReg.MatchString(name.(string)) {
continue
}
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
if len(filter) > 0 {
return nil, errors.New("doesn't match any proxy, please check your filter")
}
return nil, errors.New("file doesn't have any proxy")
}
return proxies, nil
}
fetcher := newFetcher(name, interval, vehicle, proxiesParseAndFilter, onUpdate) </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider { </s> remove func proxiesParse(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
for idx, mapping := range schema.Proxies {
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
return nil, errors.New("file doesn't have any valid proxy")
}
return proxies, nil
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/1401a82bb0c650a948d91c793369779439541f3e | adapter/provider/parser.go |
"regexp" | <mask> "encoding/json"
<mask> "errors"
<mask> "fmt"
<mask> "runtime"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapter"
<mask> C "github.com/Dreamacro/clash/constant"
</s> Feature: add filter on proxy provider (#1511) </s> remove fetcher := newFetcher(name, interval, vehicle, proxiesParse, onUpdate)
</s> add proxiesParseAndFilter := func(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
filterReg := regexp.MustCompile(filter)
for idx, mapping := range schema.Proxies {
if name, ok := mapping["name"]; ok && len(filter) > 0 && !filterReg.MatchString(name.(string)) {
continue
}
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
if len(filter) > 0 {
return nil, errors.New("doesn't match any proxy, please check your filter")
}
return nil, errors.New("file doesn't have any proxy")
}
return proxies, nil
}
fetcher := newFetcher(name, interval, vehicle, proxiesParseAndFilter, onUpdate) </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider { </s> remove func proxiesParse(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
for idx, mapping := range schema.Proxies {
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
return nil, errors.New("file doesn't have any valid proxy")
}
return proxies, nil
}
</s> add </s> remove return NewProxySetProvider(name, interval, vehicle, hc), nil
</s> add filter := schema.Filter
return NewProxySetProvider(name, interval, filter, vehicle, hc), nil | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1401a82bb0c650a948d91c793369779439541f3e | adapter/provider/provider.go |
<mask> pp.healthCheck.touch()
<mask> return pp.Proxies()
<mask> }
<mask>
<mask> func proxiesParse(buf []byte) (interface{}, error) {
<mask> schema := &ProxySchema{}
<mask>
<mask> if err := yaml.Unmarshal(buf, schema); err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> if schema.Proxies == nil {
<mask> return nil, errors.New("file must have a `proxies` field")
<mask> }
<mask>
<mask> proxies := []C.Proxy{}
<mask> for idx, mapping := range schema.Proxies {
<mask> proxy, err := adapter.ParseProxy(mapping)
<mask> if err != nil {
<mask> return nil, fmt.Errorf("proxy %d error: %w", idx, err)
<mask> }
<mask> proxies = append(proxies, proxy)
<mask> }
<mask>
<mask> if len(proxies) == 0 {
<mask> return nil, errors.New("file doesn't have any valid proxy")
<mask> }
<mask>
<mask> return proxies, nil
<mask> }
<mask>
<mask> func (pp *proxySetProvider) setProxies(proxies []C.Proxy) {
<mask> pp.proxies = proxies
<mask> pp.healthCheck.setProxy(proxies)
<mask> if pp.healthCheck.auto() {
<mask> go pp.healthCheck.check()
</s> Feature: add filter on proxy provider (#1511) </s> remove fetcher := newFetcher(name, interval, vehicle, proxiesParse, onUpdate)
</s> add proxiesParseAndFilter := func(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
filterReg := regexp.MustCompile(filter)
for idx, mapping := range schema.Proxies {
if name, ok := mapping["name"]; ok && len(filter) > 0 && !filterReg.MatchString(name.(string)) {
continue
}
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
if len(filter) > 0 {
return nil, errors.New("doesn't match any proxy, please check your filter")
}
return nil, errors.New("file doesn't have any proxy")
}
return proxies, nil
}
fetcher := newFetcher(name, interval, vehicle, proxiesParseAndFilter, onUpdate) </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider { </s> remove return NewProxySetProvider(name, interval, vehicle, hc), nil
</s> add filter := schema.Filter
return NewProxySetProvider(name, interval, filter, vehicle, hc), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/1401a82bb0c650a948d91c793369779439541f3e | adapter/provider/provider.go | |
func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider { | <mask> pd.healthCheck.close()
<mask> pd.fetcher.Destroy()
<mask> }
<mask>
<mask> func NewProxySetProvider(name string, interval time.Duration, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
<mask> if hc.auto() {
<mask> go hc.process()
<mask> }
<mask>
<mask> pd := &proxySetProvider{
</s> Feature: add filter on proxy provider (#1511) </s> remove func proxiesParse(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
for idx, mapping := range schema.Proxies {
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
return nil, errors.New("file doesn't have any valid proxy")
}
return proxies, nil
}
</s> add </s> remove fetcher := newFetcher(name, interval, vehicle, proxiesParse, onUpdate)
</s> add proxiesParseAndFilter := func(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
filterReg := regexp.MustCompile(filter)
for idx, mapping := range schema.Proxies {
if name, ok := mapping["name"]; ok && len(filter) > 0 && !filterReg.MatchString(name.(string)) {
continue
}
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
if len(filter) > 0 {
return nil, errors.New("doesn't match any proxy, please check your filter")
}
return nil, errors.New("file doesn't have any proxy")
}
return proxies, nil
}
fetcher := newFetcher(name, interval, vehicle, proxiesParseAndFilter, onUpdate) </s> remove return NewProxySetProvider(name, interval, vehicle, hc), nil
</s> add filter := schema.Filter
return NewProxySetProvider(name, interval, filter, vehicle, hc), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1401a82bb0c650a948d91c793369779439541f3e | adapter/provider/provider.go |
proxiesParseAndFilter := func(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
filterReg := regexp.MustCompile(filter)
for idx, mapping := range schema.Proxies {
if name, ok := mapping["name"]; ok && len(filter) > 0 && !filterReg.MatchString(name.(string)) {
continue
}
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
if len(filter) > 0 {
return nil, errors.New("doesn't match any proxy, please check your filter")
}
return nil, errors.New("file doesn't have any proxy")
}
return proxies, nil
}
fetcher := newFetcher(name, interval, vehicle, proxiesParseAndFilter, onUpdate) | <mask> ret := elm.([]C.Proxy)
<mask> pd.setProxies(ret)
<mask> }
<mask>
<mask> fetcher := newFetcher(name, interval, vehicle, proxiesParse, onUpdate)
<mask> pd.fetcher = fetcher
<mask>
<mask> wrapper := &ProxySetProvider{pd}
<mask> runtime.SetFinalizer(wrapper, stopProxyProvider)
<mask> return wrapper
</s> Feature: add filter on proxy provider (#1511) </s> remove return NewProxySetProvider(name, interval, vehicle, hc), nil
</s> add filter := schema.Filter
return NewProxySetProvider(name, interval, filter, vehicle, hc), nil </s> remove func proxiesParse(buf []byte) (interface{}, error) {
schema := &ProxySchema{}
if err := yaml.Unmarshal(buf, schema); err != nil {
return nil, err
}
if schema.Proxies == nil {
return nil, errors.New("file must have a `proxies` field")
}
proxies := []C.Proxy{}
for idx, mapping := range schema.Proxies {
proxy, err := adapter.ParseProxy(mapping)
if err != nil {
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
}
proxies = append(proxies, proxy)
}
if len(proxies) == 0 {
return nil, errors.New("file doesn't have any valid proxy")
}
return proxies, nil
}
</s> add </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1401a82bb0c650a948d91c793369779439541f3e | adapter/provider/provider.go |
func (s *Server) setReslover(r *Resolver) {
s.r = r
} | <mask> msg.SetReply(r)
<mask> w.WriteMsg(msg)
<mask> }
<mask>
<mask> func ReCreateServer(addr string, resolver *Resolver) error {
<mask> if server.Server != nil {
<mask> server.Shutdown()
<mask> }
<mask>
<mask> if addr == address {
<mask> return nil
<mask> }
<mask>
</s> Fix: dns hot reload no effect | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/14600a8170a8af630aa5a6d08c41c725a44816e9 | dns/server.go |
func ReCreateServer(addr string, resolver *Resolver) error { | <mask> func (s *Server) setReslover(r *Resolver) {
<mask> s.r = r
<mask> }
<mask>
<mask> if addr == address {
<mask> server.setReslover(resolver)
<mask> return nil
<mask> }
<mask>
</s> Fix: dns hot reload no effect </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
if server.Server != nil {
server.Shutdown()
}
</s> add func (s *Server) setReslover(r *Resolver) {
s.r = r
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/14600a8170a8af630aa5a6d08c41c725a44816e9 | dns/server.go |
server.setReslover(resolver) | <mask> }
<mask>
<mask> func ReCreateServer(addr string, resolver *Resolver) error {
<mask> if addr == address {
<mask> return nil
<mask> }
<mask>
<mask> if server.Server != nil {
<mask> server.Shutdown()
</s> Fix: dns hot reload no effect </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
if server.Server != nil {
server.Shutdown()
}
</s> add func (s *Server) setReslover(r *Resolver) {
s.r = r
} | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/14600a8170a8af630aa5a6d08c41c725a44816e9 | dns/server.go |
if server.Server != nil {
server.Shutdown()
}
| <mask> }
<mask>
<mask> _, port, err := net.SplitHostPort(addr)
<mask> if port == "0" || port == "" || err != nil {
<mask> return nil
<mask> }
</s> Fix: dns hot reload no effect </s> remove func ReCreateServer(addr string, resolver *Resolver) error {
if server.Server != nil {
server.Shutdown()
}
</s> add func (s *Server) setReslover(r *Resolver) {
s.r = r
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/14600a8170a8af630aa5a6d08c41c725a44816e9 | dns/server.go |
Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
WSHeaders map[string]string `proxy:"ws-headers,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"` | <mask> client *vmess.Client
<mask> }
<mask>
<mask> type VmessOption struct {
<mask> Name string `proxy:"name"`
<mask> Server string `proxy:"server"`
<mask> Port int `proxy:"port"`
<mask> UUID string `proxy:"uuid"`
<mask> AlterID int `proxy:"alterId"`
<mask> Cipher string `proxy:"cipher"`
<mask> TLS bool `proxy:"tls,omitempty"`
<mask> Network string `proxy:"network,omitempty"`
<mask> WSPath string `proxy:"ws-path,omitempty"`
<mask> SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
<mask> }
<mask>
<mask> func (v *Vmess) Name() string {
<mask> return v.name
<mask> }
</s> Feature: add websocket headers support in vmess </s> remove UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache
</s> add UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
WebSocketHeaders map[string]string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache </s> remove wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add headers := http.Header{}
if c.headers != nil {
for k, v := range c.headers {
headers.Set(k, v)
}
}
wsConn, resp, err := dialer.Dial(uri.String(), headers) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1607d3253fbe2216f5e2614d5128863b4eea5b2e | adapters/outbound/vmess.go |
UUID: option.UUID,
AlterID: uint16(option.AlterID),
Security: security,
TLS: option.TLS,
HostName: option.Server,
Port: strconv.Itoa(option.Port),
NetWork: option.Network,
WebSocketPath: option.WSPath,
WebSocketHeaders: option.WSHeaders,
SkipCertVerify: option.SkipCertVerify,
SessionCacahe: getClientSessionCache(), | <mask>
<mask> func NewVmess(option VmessOption) (*Vmess, error) {
<mask> security := strings.ToLower(option.Cipher)
<mask> client, err := vmess.NewClient(vmess.Config{
<mask> UUID: option.UUID,
<mask> AlterID: uint16(option.AlterID),
<mask> Security: security,
<mask> TLS: option.TLS,
<mask> HostName: option.Server,
<mask> Port: strconv.Itoa(option.Port),
<mask> NetWork: option.Network,
<mask> WebSocketPath: option.WSPath,
<mask> SkipCertVerify: option.SkipCertVerify,
<mask> SessionCacahe: getClientSessionCache(),
<mask> })
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Feature: add websocket headers support in vmess </s> remove wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add headers := http.Header{}
if c.headers != nil {
for k, v := range c.headers {
headers.Set(k, v)
}
}
wsConn, resp, err := dialer.Dial(uri.String(), headers) </s> remove UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache
</s> add UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
WebSocketHeaders map[string]string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
WSHeaders map[string]string `proxy:"ws-headers,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"` | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1607d3253fbe2216f5e2614d5128863b4eea5b2e | adapters/outbound/vmess.go |
// references: https://github.com/mitchellh/mapstructure
| <mask> package structure
<mask>
<mask> import (
<mask> "fmt"
<mask> "reflect"
<mask> "strconv"
<mask> "strings"
</s> Feature: add websocket headers support in vmess </s> remove wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add headers := http.Header{}
if c.headers != nil {
for k, v := range c.headers {
headers.Set(k, v)
}
}
wsConn, resp, err := dialer.Dial(uri.String(), headers) </s> remove UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache
</s> add UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
WebSocketHeaders map[string]string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1607d3253fbe2216f5e2614d5128863b4eea5b2e | common/structure/structure.go |
case reflect.Map:
return d.decodeMap(name, data, val) | <mask> case reflect.Bool:
<mask> return d.decodeBool(name, data, val)
<mask> case reflect.Slice:
<mask> return d.decodeSlice(name, data, val)
<mask> default:
<mask> return fmt.Errorf("type %s not support", val.Kind().String())
<mask> }
<mask> }
<mask>
<mask> func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) (err error) {
</s> Feature: add websocket headers support in vmess </s> remove UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache
</s> add UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
WebSocketHeaders map[string]string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache </s> remove UUID: option.UUID,
AlterID: uint16(option.AlterID),
Security: security,
TLS: option.TLS,
HostName: option.Server,
Port: strconv.Itoa(option.Port),
NetWork: option.Network,
WebSocketPath: option.WSPath,
SkipCertVerify: option.SkipCertVerify,
SessionCacahe: getClientSessionCache(),
</s> add UUID: option.UUID,
AlterID: uint16(option.AlterID),
Security: security,
TLS: option.TLS,
HostName: option.Server,
Port: strconv.Itoa(option.Port),
NetWork: option.Network,
WebSocketPath: option.WSPath,
WebSocketHeaders: option.WSHeaders,
SkipCertVerify: option.SkipCertVerify,
SessionCacahe: getClientSessionCache(), </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
WSHeaders map[string]string `proxy:"ws-headers,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"` </s> remove wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add headers := http.Header{}
if c.headers != nil {
for k, v := range c.headers {
headers.Set(k, v)
}
}
wsConn, resp, err := dialer.Dial(uri.String(), headers) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1607d3253fbe2216f5e2614d5128863b4eea5b2e | common/structure/structure.go |
UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
WebSocketHeaders map[string]string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache | <mask> }
<mask>
<mask> // Config of vmess
<mask> type Config struct {
<mask> UUID string
<mask> AlterID uint16
<mask> Security string
<mask> TLS bool
<mask> HostName string
<mask> Port string
<mask> NetWork string
<mask> WebSocketPath string
<mask> SkipCertVerify bool
<mask> SessionCacahe tls.ClientSessionCache
<mask> }
<mask>
<mask> // New return a Conn with net.Conn and DstAddr
<mask> func (c *Client) New(conn net.Conn, dst *DstAddr) (net.Conn, error) {
<mask> var err error
</s> Feature: add websocket headers support in vmess </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
WSHeaders map[string]string `proxy:"ws-headers,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"` </s> remove wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add headers := http.Header{}
if c.headers != nil {
for k, v := range c.headers {
headers.Set(k, v)
}
}
wsConn, resp, err := dialer.Dial(uri.String(), headers) </s> remove UUID: option.UUID,
AlterID: uint16(option.AlterID),
Security: security,
TLS: option.TLS,
HostName: option.Server,
Port: strconv.Itoa(option.Port),
NetWork: option.Network,
WebSocketPath: option.WSPath,
SkipCertVerify: option.SkipCertVerify,
SessionCacahe: getClientSessionCache(),
</s> add UUID: option.UUID,
AlterID: uint16(option.AlterID),
Security: security,
TLS: option.TLS,
HostName: option.Server,
Port: strconv.Itoa(option.Port),
NetWork: option.Network,
WebSocketPath: option.WSPath,
WebSocketHeaders: option.WSHeaders,
SkipCertVerify: option.SkipCertVerify,
SessionCacahe: getClientSessionCache(), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1607d3253fbe2216f5e2614d5128863b4eea5b2e | component/vmess/vmess.go |
headers: config.WebSocketHeaders, | <mask> if config.NetWork == "ws" {
<mask> wsConfig = &websocketConfig{
<mask> host: host,
<mask> path: config.WebSocketPath,
<mask> tls: config.TLS,
<mask> tlsConfig: tlsConfig,
<mask> }
<mask> }
<mask>
</s> Feature: add websocket headers support in vmess </s> remove wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add headers := http.Header{}
if c.headers != nil {
for k, v := range c.headers {
headers.Set(k, v)
}
}
wsConn, resp, err := dialer.Dial(uri.String(), headers) </s> remove UUID: option.UUID,
AlterID: uint16(option.AlterID),
Security: security,
TLS: option.TLS,
HostName: option.Server,
Port: strconv.Itoa(option.Port),
NetWork: option.Network,
WebSocketPath: option.WSPath,
SkipCertVerify: option.SkipCertVerify,
SessionCacahe: getClientSessionCache(),
</s> add UUID: option.UUID,
AlterID: uint16(option.AlterID),
Security: security,
TLS: option.TLS,
HostName: option.Server,
Port: strconv.Itoa(option.Port),
NetWork: option.Network,
WebSocketPath: option.WSPath,
WebSocketHeaders: option.WSHeaders,
SkipCertVerify: option.SkipCertVerify,
SessionCacahe: getClientSessionCache(), </s> remove Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
</s> add Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
UUID string `proxy:"uuid"`
AlterID int `proxy:"alterId"`
Cipher string `proxy:"cipher"`
TLS bool `proxy:"tls,omitempty"`
Network string `proxy:"network,omitempty"`
WSPath string `proxy:"ws-path,omitempty"`
WSHeaders map[string]string `proxy:"ws-headers,omitempty"`
SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"` </s> remove UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache
</s> add UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
WebSocketHeaders map[string]string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1607d3253fbe2216f5e2614d5128863b4eea5b2e | component/vmess/vmess.go |
"net/http" | <mask> "fmt"
<mask> "io"
<mask> "net"
<mask> "net/url"
<mask> "strings"
<mask> "time"
<mask>
<mask> "github.com/gorilla/websocket"
<mask> )
</s> Feature: add websocket headers support in vmess </s> remove wsConn, resp, err := dialer.Dial(uri.String(), nil)
</s> add headers := http.Header{}
if c.headers != nil {
for k, v := range c.headers {
headers.Set(k, v)
}
}
wsConn, resp, err := dialer.Dial(uri.String(), headers) </s> remove UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache
</s> add UUID string
AlterID uint16
Security string
TLS bool
HostName string
Port string
NetWork string
WebSocketPath string
WebSocketHeaders map[string]string
SkipCertVerify bool
SessionCacahe tls.ClientSessionCache | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/1607d3253fbe2216f5e2614d5128863b4eea5b2e | component/vmess/websocket.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.