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 |
|---|---|---|---|---|
Host: host,
Port: port,
Path: v.option.WSOpts.Path,
MaxEarlyData: v.option.WSOpts.MaxEarlyData,
EarlyDataHeaderName: v.option.WSOpts.EarlyDataHeaderName, | <mask> switch v.option.Network {
<mask> case "ws":
<mask> host, port, _ := net.SplitHostPort(v.addr)
<mask> wsOpts := &vmess.WebsocketConfig{
<mask> Host: host,
<mask> Port: port,
<mask> Path: v.option.WSPath,
<mask> }
<mask>
<mask> if len(v.option.WSHeaders) != 0 {
<mask> header := http.Header{}
<mask> for key, value := range v.option.WSHeaders {
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove if len(v.option.WSHeaders) != 0 {
</s> add if len(v.option.WSOpts.Headers) != 0 { </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | adapter/outbound/vmess.go |
if len(v.option.WSOpts.Headers) != 0 { | <mask> Port: port,
<mask> Path: v.option.WSPath,
<mask> }
<mask>
<mask> if len(v.option.WSHeaders) != 0 {
<mask> header := http.Header{}
<mask> for key, value := range v.option.WSHeaders {
<mask> header.Add(key, value)
<mask> }
<mask> wsOpts.Headers = header
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove Host: host,
Port: port,
Path: v.option.WSPath,
</s> add Host: host,
Port: port,
Path: v.option.WSOpts.Path,
MaxEarlyData: v.option.WSOpts.MaxEarlyData,
EarlyDataHeaderName: v.option.WSOpts.EarlyDataHeaderName, </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { </s> remove if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
}
</s> add mbuf.Write(h.Sum(nil)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | adapter/outbound/vmess.go |
mbuf := &bytes.Buffer{}
| <mask> timestamp := time.Now()
<mask>
<mask> if !vc.isAead {
<mask> h := hmac.New(md5.New, vc.id.UUID.Bytes())
<mask> binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
<mask> mbuf.Write(h.Sum(nil))
<mask> }
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
}
</s> add mbuf.Write(h.Sum(nil)) </s> remove if len(v.option.WSHeaders) != 0 {
</s> add if len(v.option.WSOpts.Headers) != 0 { </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/conn.go |
mbuf.Write(h.Sum(nil)) | <mask>
<mask> if !vc.isAead {
<mask> h := hmac.New(md5.New, vc.id.UUID.Bytes())
<mask> binary.Write(h, binary.BigEndian, uint64(timestamp.Unix()))
<mask> if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
<mask> return err
<mask> }
<mask> }
<mask>
<mask> buf := &bytes.Buffer{}
<mask>
<mask> // Ver IV Key V Opt
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { </s> remove _, err = vc.Conn.Write(buf.Bytes())
</s> add mbuf.Write(buf.Bytes())
_, err = vc.Conn.Write(mbuf.Bytes()) </s> remove if len(v.option.WSHeaders) != 0 {
</s> add if len(v.option.WSOpts.Headers) != 0 { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/conn.go |
mbuf.Write(buf.Bytes())
_, err = vc.Conn.Write(mbuf.Bytes()) | <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> var fixedLengthCmdKey [16]byte
<mask> copy(fixedLengthCmdKey[:], vc.id.CmdKey)
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { </s> remove if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
}
</s> add mbuf.Write(h.Sum(nil)) </s> remove if len(v.option.WSHeaders) != 0 {
</s> add if len(v.option.WSOpts.Headers) != 0 { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/conn.go |
"bytes"
"context" | <mask> package vmess
<mask>
<mask> import (
<mask> "crypto/tls"
<mask> "encoding/base64"
<mask> "errors"
<mask> "fmt"
<mask> "io"
<mask> "net"
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { </s> remove Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
</s> add Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
MaxEarlyData int
EarlyDataHeaderName string | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/websocket.go |
"encoding/base64"
"errors" | <mask> "context"
<mask> "crypto/tls"
<mask> "fmt"
<mask> "io"
<mask> "net"
<mask> "net/http"
<mask> "net/url"
<mask> "strings"
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { </s> remove Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
</s> add Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
MaxEarlyData int
EarlyDataHeaderName string | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/websocket.go |
type websocketWithEarlyDataConn struct {
net.Conn
underlay net.Conn
closed bool
dialed chan bool
cancel context.CancelFunc
ctx context.Context
config *WebsocketConfig
} | <mask> // https://godoc.org/github.com/gorilla/websocket#hdr-Concurrency
<mask> rMux sync.Mutex
<mask> wMux sync.Mutex
<mask> }
<mask>
<mask> type WebsocketConfig struct {
<mask> Host string
<mask> Port string
<mask> Path string
<mask> Headers http.Header
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
</s> add Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
MaxEarlyData int
EarlyDataHeaderName string </s> remove if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
}
</s> add mbuf.Write(h.Sum(nil)) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/websocket.go |
Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
MaxEarlyData int
EarlyDataHeaderName string | <mask> wMux sync.Mutex
<mask> }
<mask>
<mask> type WebsocketConfig struct {
<mask> Host string
<mask> Port string
<mask> Path string
<mask> Headers http.Header
<mask> TLS bool
<mask> SkipCertVerify bool
<mask> ServerName string
<mask> }
<mask>
<mask> // Read implements net.Conn.Read()
<mask> func (wsc *websocketConn) Read(b []byte) (int, error) {
<mask> wsc.rMux.Lock()
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/websocket.go |
func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { | <mask> func (wsc *websocketConn) SetWriteDeadline(t time.Time) error {
<mask> return wsc.conn.SetWriteDeadline(t)
<mask> }
<mask>
<mask> func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
<mask> dialer := &websocket.Dialer{
<mask> NetDial: func(network, addr string) (net.Conn, error) {
<mask> return conn, nil
<mask> },
<mask> ReadBufferSize: 4 * 1024,
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
</s> add Host string
Port string
Path string
Headers http.Header
TLS bool
SkipCertVerify bool
ServerName string
MaxEarlyData int
EarlyDataHeaderName string </s> remove if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
}
</s> add mbuf.Write(h.Sum(nil)) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/websocket.go |
if earlyData != nil {
if c.EarlyDataHeaderName == "" {
uri.Path += earlyData.String()
} else {
headers.Set(c.EarlyDataHeaderName, earlyData.String())
}
}
| <mask> }
<mask>
<mask> wsConn, resp, err := dialer.Dial(uri.String(), headers)
<mask> if err != nil {
<mask> reason := err.Error()
<mask> if resp != nil {
<mask> reason = resp.Status
<mask> }
</s> Feature: add vmess WebSocket early data (#1505)
Co-authored-by: ShinyGwyn <79344143+ShinyGwyn@users.noreply.github.com> </s> remove func StreamWebsocketConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
</s> add func (wsedc *websocketWithEarlyDataConn) Dial(earlyData []byte) error {
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())
}
if errc := base64EarlyDataEncoder.Close(); errc != nil {
return errors.New("failed to encode early data tail: " + errc.Error())
}
var err error
if wsedc.Conn, err = streamWebsocketConn(wsedc.underlay, wsedc.config, earlyDataBuf); err != nil {
wsedc.Close()
return errors.New("failed to dial WebSocket: " + err.Error())
}
wsedc.dialed <- true
if n != int64(len(earlyData)) {
_, err = wsedc.Conn.Write(earlyData[n:])
}
return err
}
func (wsedc *websocketWithEarlyDataConn) Write(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
if err := wsedc.Dial(b); err != nil {
return 0, err
}
return len(b), nil
}
return wsedc.Conn.Write(b)
}
func (wsedc *websocketWithEarlyDataConn) Read(b []byte) (int, error) {
if wsedc.closed {
return 0, io.ErrClosedPipe
}
if wsedc.Conn == nil {
select {
case <-wsedc.ctx.Done():
return 0, io.ErrUnexpectedEOF
case <-wsedc.dialed:
}
}
return wsedc.Conn.Read(b)
}
func (wsedc *websocketWithEarlyDataConn) Close() error {
wsedc.closed = true
wsedc.cancel()
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.Close()
}
func (wsedc *websocketWithEarlyDataConn) LocalAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.LocalAddr()
}
return wsedc.Conn.LocalAddr()
}
func (wsedc *websocketWithEarlyDataConn) RemoteAddr() net.Addr {
if wsedc.Conn == nil {
return wsedc.underlay.RemoteAddr()
}
return wsedc.Conn.RemoteAddr()
}
func (wsedc *websocketWithEarlyDataConn) SetDeadline(t time.Time) error {
if err := wsedc.SetReadDeadline(t); err != nil {
return err
}
return wsedc.SetWriteDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetReadDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetReadDeadline(t)
}
func (wsedc *websocketWithEarlyDataConn) SetWriteDeadline(t time.Time) error {
if wsedc.Conn == nil {
return nil
}
return wsedc.Conn.SetWriteDeadline(t)
}
func streamWebsocketWithEarlyDataConn(conn net.Conn, c *WebsocketConfig) (net.Conn, error) {
ctx, cancel := context.WithCancel(context.Background())
conn = &websocketWithEarlyDataConn{
dialed: make(chan bool, 1),
cancel: cancel,
ctx: ctx,
underlay: conn,
config: c,
}
return conn, nil
}
func streamWebsocketConn(conn net.Conn, c *WebsocketConfig, earlyData *bytes.Buffer) (net.Conn, error) { </s> remove if _, err := vc.Conn.Write(h.Sum(nil)); err != nil {
return err
}
</s> add mbuf.Write(h.Sum(nil)) </s> remove if len(v.option.WSHeaders) != 0 {
</s> add if len(v.option.WSOpts.Headers) != 0 { </s> remove Host: host,
Port: port,
Path: v.option.WSPath,
</s> add Host: host,
Port: port,
Path: v.option.WSOpts.Path,
MaxEarlyData: v.option.WSOpts.MaxEarlyData,
EarlyDataHeaderName: v.option.WSOpts.EarlyDataHeaderName, | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0267b2efad9a6b0f447efde20589e124ad369a15 | transport/vmess/websocket.go |
ret, err, shared := r.group.Do(q.String(), func() (interface{}, error) {
isIPReq := isIPRequest(q)
if isIPReq {
return r.fallbackExchange(m) | <mask> // ExchangeWithoutCache a batch of dns request, and it do NOT GET from cache
<mask> func (r *Resolver) exchangeWithoutCache(m *D.Msg) (msg *D.Msg, err error) {
<mask> q := m.Question[0]
<mask>
<mask> defer func() {
<mask> if msg == nil {
<mask> return
<mask> }
<mask>
<mask> putMsgToCache(r.lruCache, q.String(), msg)
<mask> if r.mapping || r.fakeip {
<mask> ips := r.msgToIP(msg)
</s> Fix: write msg cache multiple times (#812)
Co-authored-by: john.xu <john.xu@bytedance.com> </s> remove }()
ret, err, shared := r.group.Do(q.String(), func() (interface{}, error) {
isIPReq := isIPRequest(q)
if isIPReq {
return r.fallbackExchange(m)
}
return r.batchExchange(r.main, m)
</s> add return msg, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02c7fd8d70e09c91f9c07b737fc68fcdd6bf68e2 | dns/resolver.go |
msg, err := r.batchExchange(r.main, m)
if err != nil {
return nil, err
} | <mask> if isIPReq {
<mask> return r.fallbackExchange(m)
<mask> }
<mask>
<mask> putMsgToCache(r.lruCache, q.String(), msg)
<mask> if r.mapping || r.fakeip {
<mask> ips := r.msgToIP(msg)
<mask> for _, ip := range ips {
<mask> putMsgToCache(r.lruCache, ip.String(), msg)
</s> Fix: write msg cache multiple times (#812)
Co-authored-by: john.xu <john.xu@bytedance.com> </s> remove defer func() {
if msg == nil {
return
</s> add ret, err, shared := r.group.Do(q.String(), func() (interface{}, error) {
isIPReq := isIPRequest(q)
if isIPReq {
return r.fallbackExchange(m) </s> remove }()
ret, err, shared := r.group.Do(q.String(), func() (interface{}, error) {
isIPReq := isIPRequest(q)
if isIPReq {
return r.fallbackExchange(m)
}
return r.batchExchange(r.main, m)
</s> add return msg, nil | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02c7fd8d70e09c91f9c07b737fc68fcdd6bf68e2 | dns/resolver.go |
return msg, nil | <mask> for _, ip := range ips {
<mask> putMsgToCache(r.lruCache, ip.String(), msg)
<mask> }
<mask> }
<mask> }()
<mask>
<mask> ret, err, shared := r.group.Do(q.String(), func() (interface{}, error) {
<mask> isIPReq := isIPRequest(q)
<mask> if isIPReq {
<mask> return r.fallbackExchange(m)
<mask> }
<mask>
<mask> return r.batchExchange(r.main, m)
<mask> })
<mask>
<mask> if err == nil {
<mask> msg = ret.(*D.Msg)
<mask> if shared {
</s> Fix: write msg cache multiple times (#812)
Co-authored-by: john.xu <john.xu@bytedance.com> </s> remove defer func() {
if msg == nil {
return
</s> add ret, err, shared := r.group.Do(q.String(), func() (interface{}, error) {
isIPReq := isIPRequest(q)
if isIPReq {
return r.fallbackExchange(m) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02c7fd8d70e09c91f9c07b737fc68fcdd6bf68e2 | dns/resolver.go |
defer resp.Body.Close() | <mask> return nil, err
<mask> }
<mask>
<mask> buf, err := ioutil.ReadAll(resp.Body)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Fix: close http Response body on provider (#1154) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02d029dd2d7ad75ff493ca754c806d70abcda1f3 | adapters/provider/vehicle.go |
// it will be close at : `func (hc *h2Conn) Close() error` | <mask> }
<mask>
<mask> res, err := hc.ClientConn.RoundTrip(&req)
<mask> if err != nil {
<mask> return err
<mask> }
</s> Fix: close http Response body on provider (#1154) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02d029dd2d7ad75ff493ca754c806d70abcda1f3 | component/vmess/h2.go |
// resp will be closed after we call resp.Write()
// see https://golang.org/pkg/net/http/#Response.Write | <mask> }
<mask>
<mask> handleResponse:
<mask> resp, err := http.ReadResponse(outboundReader, req)
<mask> if err != nil {
<mask> break
<mask> }
<mask> inbound.RemoveHopByHopHeaders(resp.Header)
<mask>
</s> Fix: close http Response body on provider (#1154) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02d029dd2d7ad75ff493ca754c806d70abcda1f3 | tunnel/connection.go |
// skip the first xinpgen(24 bytes) block
for i := 24; i+itemSize <= len(buf); i += itemSize { | <mask> if metadata.NetWork == C.TCP {
<mask> // rup8(sizeof(xtcpcb_n))
<mask> itemSize += 208
<mask> }
<mask> // skip the first and last xinpgen(24 bytes) block
<mask> for i := 24; i < len(buf)-24; i += itemSize {
<mask> // offset of xinpcb_n and xsocket_n
<mask> inp, so := i, i+104
<mask>
<mask> srcPort := binary.BigEndian.Uint16(buf[inp+18 : inp+20])
<mask> if uint16(port) != srcPort {
</s> Fix: potential PCB buffer overflow on bsd systems (#941) </s> remove for i := 0; i < len(buf); i += itemSize {
</s> add for i := 0; i+itemSize <= len(buf); i += itemSize { </s> remove // skip the first and last xinpgen(64 bytes) block
for i := 64; i < len(buf)-64; i += itemSize {
</s> add // skip the first xinpgen(64 bytes) block
for i := 64; i+itemSize <= len(buf); i += itemSize { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02d9169b5d1e45a47f0f0355a32bff045838d621 | rules/process_darwin.go |
for i := 0; i+itemSize <= len(buf); i += itemSize { | <mask> buf := []byte(value)
<mask>
<mask> // struct xfile
<mask> itemSize := 128
<mask> for i := 0; i < len(buf); i += itemSize {
<mask> // xfile.xf_data
<mask> data := binary.BigEndian.Uint64(buf[i+56 : i+64])
<mask> if data == socket {
<mask> // xfile.xf_pid
<mask> pid := readNativeUint32(buf[i+8 : i+12])
</s> Fix: potential PCB buffer overflow on bsd systems (#941) </s> remove // skip the first and last xinpgen(24 bytes) block
for i := 24; i < len(buf)-24; i += itemSize {
</s> add // skip the first xinpgen(24 bytes) block
for i := 24; i+itemSize <= len(buf); i += itemSize { </s> remove // skip the first and last xinpgen(64 bytes) block
for i := 64; i < len(buf)-64; i += itemSize {
</s> add // skip the first xinpgen(64 bytes) block
for i := 64; i+itemSize <= len(buf); i += itemSize { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02d9169b5d1e45a47f0f0355a32bff045838d621 | rules/process_freebsd_amd64.go |
// skip the first xinpgen(64 bytes) block
for i := 64; i+itemSize <= len(buf); i += itemSize { | <mask> }
<mask>
<mask> buf := []byte(value)
<mask>
<mask> // skip the first and last xinpgen(64 bytes) block
<mask> for i := 64; i < len(buf)-64; i += itemSize {
<mask> inp := i + inpOffset
<mask>
<mask> srcPort := binary.BigEndian.Uint16(buf[inp+254 : inp+256])
<mask>
<mask> if uint16(port) != srcPort {
</s> Fix: potential PCB buffer overflow on bsd systems (#941) </s> remove for i := 0; i < len(buf); i += itemSize {
</s> add for i := 0; i+itemSize <= len(buf); i += itemSize { </s> remove // skip the first and last xinpgen(24 bytes) block
for i := 24; i < len(buf)-24; i += itemSize {
</s> add // skip the first xinpgen(24 bytes) block
for i := 24; i+itemSize <= len(buf); i += itemSize { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/02d9169b5d1e45a47f0f0355a32bff045838d621 | rules/process_freebsd_amd64.go |
"sync/atomic" | <mask>
<mask> import (
<mask> "errors"
<mask> "sync"
<mask> "time"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type URLTest struct {
</s> Improve: url-test will automatically speed test when the connection fails </s> remove return u.fast.Generator(metadata)
</s> add a, err := u.fast.Generator(metadata)
if err != nil {
go u.speedTest()
}
return a, err | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/03c563a58e993e2b19d5df8a89d724a9ded07940 | adapters/outbound/urltest.go |
once int32 | <mask> rawURL string
<mask> fast C.Proxy
<mask> interval time.Duration
<mask> done chan struct{}
<mask> }
<mask>
<mask> type URLTestOption struct {
<mask> Name string `proxy:"name"`
<mask> Proxies []string `proxy:"proxies"`
<mask> URL string `proxy:"url"`
</s> Improve: url-test will automatically speed test when the connection fails </s> remove return u.fast.Generator(metadata)
</s> add a, err := u.fast.Generator(metadata)
if err != nil {
go u.speedTest()
}
return a, err | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/03c563a58e993e2b19d5df8a89d724a9ded07940 | adapters/outbound/urltest.go |
a, err := u.fast.Generator(metadata)
if err != nil {
go u.speedTest()
}
return a, err | <mask> return u.fast.Name()
<mask> }
<mask>
<mask> func (u *URLTest) Generator(metadata *C.Metadata) (adapter C.ProxyAdapter, err error) {
<mask> return u.fast.Generator(metadata)
<mask> }
<mask>
<mask> func (u *URLTest) Close() {
<mask> u.done <- struct{}{}
<mask> }
</s> Improve: url-test will automatically speed test when the connection fails | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/03c563a58e993e2b19d5df8a89d724a9ded07940 | adapters/outbound/urltest.go |
if atomic.AddInt32(&u.once, 1) != 1 {
return
}
defer atomic.StoreInt32(&u.once, 0)
| <mask> }
<mask> }
<mask>
<mask> func (u *URLTest) speedTest() {
<mask> wg := sync.WaitGroup{}
<mask> wg.Add(len(u.proxies))
<mask> c := make(chan interface{})
<mask> fast := selectFast(c)
<mask> timer := time.NewTimer(u.interval)
</s> Improve: url-test will automatically speed test when the connection fails </s> remove return u.fast.Generator(metadata)
</s> add a, err := u.fast.Generator(metadata)
if err != nil {
go u.speedTest()
}
return a, err | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/03c563a58e993e2b19d5df8a89d724a9ded07940 | adapters/outbound/urltest.go |
once: 0, | <mask> fast: proxies[0],
<mask> interval: interval,
<mask> done: make(chan struct{}),
<mask> }
<mask> go urlTest.loop()
<mask> return urlTest, nil
<mask> }
</s> Improve: url-test will automatically speed test when the connection fails </s> remove return u.fast.Generator(metadata)
</s> add a, err := u.fast.Generator(metadata)
if err != nil {
go u.speedTest()
}
return a, err | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/03c563a58e993e2b19d5df8a89d724a9ded07940 | adapters/outbound/urltest.go |
golangci-lint run ./... | <mask>
<mask> releases: $(gz_releases) $(zip_releases)
<mask>
<mask> lint:
<mask> golangci-lint run --disable-all -E govet -E gofumpt -E megacheck ./...
<mask>
<mask> clean:
<mask> rm $(BINDIR)/*
</s> Chore: use golangci-lint config file </s> remove "golang.org/x/sys/unix"
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/03e4b5d525940ca3aaa33384767c1438711dae00 | Makefile |
<mask> import (
<mask> "net"
<mask> "syscall"
<mask>
<mask> "golang.org/x/sys/unix"
<mask>
<mask> "github.com/Dreamacro/clash/component/iface"
<mask> )
<mask>
<mask> type controlFn = func(network, address string, c syscall.RawConn) error
<mask>
</s> Chore: use golangci-lint config file </s> remove golangci-lint run --disable-all -E govet -E gofumpt -E megacheck ./...
</s> add golangci-lint run ./... | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/03e4b5d525940ca3aaa33384767c1438711dae00 | component/dialer/bind_darwin.go | |
"golang.org/x/sys/unix" | <mask> "syscall"
<mask>
<mask> "github.com/Dreamacro/clash/component/iface"
<mask> )
<mask>
<mask> type controlFn = func(network, address string, c syscall.RawConn) error
<mask>
<mask> func bindControl(ifaceIdx int, chain controlFn) controlFn {
</s> Chore: use golangci-lint config file </s> remove "golang.org/x/sys/unix"
</s> add </s> remove golangci-lint run --disable-all -E govet -E gofumpt -E megacheck ./...
</s> add golangci-lint run ./... | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/03e4b5d525940ca3aaa33384767c1438711dae00 | component/dialer/bind_darwin.go |
func getProvidersProxies(providers []provider.ProxyProvider, touch bool) []C.Proxy { | <mask> const (
<mask> defaultGetProxiesDuration = time.Second * 5
<mask> )
<mask>
<mask> func getProvidersProxies(providers []provider.ProxyProvider) []C.Proxy {
<mask> proxies := []C.Proxy{}
<mask> for _, provider := range providers {
<mask> proxies = append(proxies, provider.Proxies()...)
<mask> }
<mask> return proxies
</s> Feature: add `lazy` for proxy group and provider </s> remove proxies = append(proxies, provider.Proxies()...)
</s> add if touch {
proxies = append(proxies, provider.ProxiesWithTouch()...)
} else {
proxies = append(proxies, provider.Proxies()...)
} </s> remove func (r *Relay) proxies(metadata *C.Metadata) []C.Proxy {
proxies := r.rawProxies()
</s> add func (r *Relay) proxies(metadata *C.Metadata, touch bool) []C.Proxy {
proxies := r.rawProxies(touch) </s> remove func (f *Fallback) findAliveProxy() C.Proxy {
proxies := f.proxies()
</s> add func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
proxies := f.proxies(touch) </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/common.go |
if touch {
proxies = append(proxies, provider.ProxiesWithTouch()...)
} else {
proxies = append(proxies, provider.Proxies()...)
} | <mask>
<mask> func getProvidersProxies(providers []provider.ProxyProvider) []C.Proxy {
<mask> proxies := []C.Proxy{}
<mask> for _, provider := range providers {
<mask> proxies = append(proxies, provider.Proxies()...)
<mask> }
<mask> return proxies
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove func getProvidersProxies(providers []provider.ProxyProvider) []C.Proxy {
</s> add func getProvidersProxies(providers []provider.ProxyProvider, touch bool) []C.Proxy { </s> remove func (f *Fallback) findAliveProxy() C.Proxy {
proxies := f.proxies()
</s> add func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
proxies := f.proxies(touch) </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) </s> remove func (r *Relay) proxies(metadata *C.Metadata) []C.Proxy {
proxies := r.rawProxies()
</s> add func (r *Relay) proxies(metadata *C.Metadata, touch bool) []C.Proxy {
proxies := r.rawProxies(touch) </s> remove proxies := lb.proxies()
</s> add proxies := lb.proxies(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/common.go |
proxy := f.findAliveProxy(false) | <mask> providers []provider.ProxyProvider
<mask> }
<mask>
<mask> func (f *Fallback) Now() string {
<mask> proxy := f.findAliveProxy()
<mask> return proxy.Name()
<mask> }
<mask>
<mask> func (f *Fallback) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> proxy := f.findAliveProxy()
</s> Feature: add `lazy` for proxy group and provider </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove func (f *Fallback) proxies() []C.Proxy {
</s> add func (f *Fallback) proxies(touch bool) []C.Proxy { </s> remove return u.fast().Name()
</s> add return u.fast(false).Name() </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
proxy := f.findAliveProxy(true) | <mask> return proxy.Name()
<mask> }
<mask>
<mask> func (f *Fallback) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> proxy := f.findAliveProxy()
<mask> c, err := proxy.DialContext(ctx, metadata)
<mask> if err == nil {
<mask> c.AppendToChains(f)
<mask> }
<mask> return c, err
</s> Feature: add `lazy` for proxy group and provider </s> remove c, err := s.selectedProxy().DialContext(ctx, metadata)
</s> add c, err := s.selectedProxy(true).DialContext(ctx, metadata) </s> remove c, err = u.fast().DialContext(ctx, metadata)
</s> add c, err = u.fast(true).DialContext(ctx, metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove return u.fast().Name()
</s> add return u.fast(false).Name() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
proxy := f.findAliveProxy(true) | <mask> return c, err
<mask> }
<mask>
<mask> func (f *Fallback) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
<mask> proxy := f.findAliveProxy()
<mask> pc, err := proxy.DialUDP(metadata)
<mask> if err == nil {
<mask> pc.AppendToChains(f)
<mask> }
<mask> return pc, err
</s> Feature: add `lazy` for proxy group and provider </s> remove pc, err := u.fast().DialUDP(metadata)
</s> add pc, err := u.fast(true).DialUDP(metadata) </s> remove pc, err := s.selectedProxy().DialUDP(metadata)
</s> add pc, err := s.selectedProxy(true).DialUDP(metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove c, err := s.selectedProxy().DialContext(ctx, metadata)
</s> add c, err := s.selectedProxy(true).DialContext(ctx, metadata) </s> remove c, err = u.fast().DialContext(ctx, metadata)
</s> add c, err = u.fast(true).DialContext(ctx, metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
proxy := f.findAliveProxy(false) | <mask> if f.disableUDP {
<mask> return false
<mask> }
<mask>
<mask> proxy := f.findAliveProxy()
<mask> return proxy.SupportUDP()
<mask> }
<mask>
<mask> func (f *Fallback) MarshalJSON() ([]byte, error) {
<mask> var all []string
</s> Feature: add `lazy` for proxy group and provider </s> remove return s.selectedProxy().SupportUDP()
</s> add return s.selectedProxy(false).SupportUDP() </s> remove return u.fast().SupportUDP()
</s> add return u.fast(false).SupportUDP() </s> remove for _, proxy := range f.proxies() {
</s> add for _, proxy := range f.proxies(false) { </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove for _, proxy := range lb.proxies() {
</s> add for _, proxy := range lb.proxies(false) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
for _, proxy := range f.proxies(false) { | <mask> }
<mask>
<mask> func (f *Fallback) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range f.proxies() {
<mask> all = append(all, proxy.Name())
<mask> }
<mask> return json.Marshal(map[string]interface{}{
<mask> "type": f.Type().String(),
<mask> "now": f.Now(),
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range u.proxies() {
</s> add for _, proxy := range u.proxies(false) { </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove for _, proxy := range r.rawProxies() {
</s> add for _, proxy := range r.rawProxies(false) { </s> remove for _, proxy := range lb.proxies() {
</s> add for _, proxy := range lb.proxies(false) { </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
proxy := f.findAliveProxy(true) | <mask> })
<mask> }
<mask>
<mask> func (f *Fallback) Unwrap(metadata *C.Metadata) C.Proxy {
<mask> proxy := f.findAliveProxy()
<mask> return proxy
<mask> }
<mask>
<mask> func (f *Fallback) proxies() []C.Proxy {
<mask> elm, _, _ := f.single.Do(func() (interface{}, error) {
</s> Feature: add `lazy` for proxy group and provider </s> remove func (f *Fallback) proxies() []C.Proxy {
</s> add func (f *Fallback) proxies(touch bool) []C.Proxy { </s> remove return getProvidersProxies(f.providers), nil
</s> add return getProvidersProxies(f.providers, touch), nil </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) </s> remove func (f *Fallback) findAliveProxy() C.Proxy {
proxies := f.proxies()
</s> add func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
proxies := f.proxies(touch) </s> remove func (u *URLTest) proxies() []C.Proxy {
</s> add func (u *URLTest) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
func (f *Fallback) proxies(touch bool) []C.Proxy { | <mask> proxy := f.findAliveProxy()
<mask> return proxy
<mask> }
<mask>
<mask> func (f *Fallback) proxies() []C.Proxy {
<mask> elm, _, _ := f.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(f.providers), nil
<mask> })
<mask>
<mask> return elm.([]C.Proxy)
</s> Feature: add `lazy` for proxy group and provider </s> remove return getProvidersProxies(f.providers), nil
</s> add return getProvidersProxies(f.providers, touch), nil </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove return getProvidersProxies(lb.providers), nil
</s> add return getProvidersProxies(lb.providers, touch), nil </s> remove return getProvidersProxies(u.providers), nil
</s> add return getProvidersProxies(u.providers, touch), nil </s> remove func (lb *LoadBalance) proxies() []C.Proxy {
</s> add func (lb *LoadBalance) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
return getProvidersProxies(f.providers, touch), nil | <mask> }
<mask>
<mask> func (f *Fallback) proxies() []C.Proxy {
<mask> elm, _, _ := f.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(f.providers), nil
<mask> })
<mask>
<mask> return elm.([]C.Proxy)
<mask> }
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove func (f *Fallback) proxies() []C.Proxy {
</s> add func (f *Fallback) proxies(touch bool) []C.Proxy { </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove return getProvidersProxies(lb.providers), nil
</s> add return getProvidersProxies(lb.providers, touch), nil </s> remove return getProvidersProxies(u.providers), nil
</s> add return getProvidersProxies(u.providers, touch), nil </s> remove func (lb *LoadBalance) proxies() []C.Proxy {
</s> add func (lb *LoadBalance) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
proxies := f.proxies(touch) | <mask>
<mask> return elm.([]C.Proxy)
<mask> }
<mask>
<mask> func (f *Fallback) findAliveProxy() C.Proxy {
<mask> proxies := f.proxies()
<mask> for _, proxy := range proxies {
<mask> if proxy.Alive() {
<mask> return proxy
<mask> }
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range f.proxies() {
</s> add for _, proxy := range f.proxies(false) { </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) </s> remove func (f *Fallback) proxies() []C.Proxy {
</s> add func (f *Fallback) proxies(touch bool) []C.Proxy { </s> remove func (u *URLTest) fast() C.Proxy {
</s> add func (u *URLTest) fast(touch bool) C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
return proxies[0] | <mask> return proxy
<mask> }
<mask> }
<mask>
<mask> return f.proxies()[0]
<mask> }
<mask>
<mask> func NewFallback(options *GroupCommonOption, providers []provider.ProxyProvider) *Fallback {
<mask> return &Fallback{
<mask> Base: outbound.NewBase(options.Name, "", C.Fallback, false),
</s> Feature: add `lazy` for proxy group and provider </s> remove proxies = append(proxies, provider.Proxies()...)
</s> add if touch {
proxies = append(proxies, provider.ProxiesWithTouch()...)
} else {
proxies = append(proxies, provider.Proxies()...)
} </s> remove func getProvidersProxies(providers []provider.ProxyProvider) []C.Proxy {
</s> add func getProvidersProxies(providers []provider.ProxyProvider, touch bool) []C.Proxy { </s> remove return u.fast().Name()
</s> add return u.fast(false).Name() </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) </s> remove return u.fast().SupportUDP()
</s> add return u.fast(false).SupportUDP() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/fallback.go |
proxies := lb.proxies(true) | <mask> }
<mask> }
<mask>
<mask> func (lb *LoadBalance) Unwrap(metadata *C.Metadata) C.Proxy {
<mask> proxies := lb.proxies()
<mask> return lb.strategyFn(proxies, metadata)
<mask> }
<mask>
<mask> func (lb *LoadBalance) proxies() []C.Proxy {
<mask> elm, _, _ := lb.single.Do(func() (interface{}, error) {
</s> Feature: add `lazy` for proxy group and provider </s> remove func (lb *LoadBalance) proxies() []C.Proxy {
</s> add func (lb *LoadBalance) proxies(touch bool) []C.Proxy { </s> remove return getProvidersProxies(lb.providers), nil
</s> add return getProvidersProxies(lb.providers, touch), nil </s> remove for _, proxy := range lb.proxies() {
</s> add for _, proxy := range lb.proxies(false) { </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove return u.fast()
</s> add return u.fast(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/loadbalance.go |
func (lb *LoadBalance) proxies(touch bool) []C.Proxy { | <mask> proxies := lb.proxies()
<mask> return lb.strategyFn(proxies, metadata)
<mask> }
<mask>
<mask> func (lb *LoadBalance) proxies() []C.Proxy {
<mask> elm, _, _ := lb.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(lb.providers), nil
<mask> })
<mask>
<mask> return elm.([]C.Proxy)
</s> Feature: add `lazy` for proxy group and provider </s> remove proxies := lb.proxies()
</s> add proxies := lb.proxies(true) </s> remove return getProvidersProxies(lb.providers), nil
</s> add return getProvidersProxies(lb.providers, touch), nil </s> remove return getProvidersProxies(f.providers), nil
</s> add return getProvidersProxies(f.providers, touch), nil </s> remove return getProvidersProxies(u.providers), nil
</s> add return getProvidersProxies(u.providers, touch), nil </s> remove func (f *Fallback) proxies() []C.Proxy {
</s> add func (f *Fallback) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/loadbalance.go |
return getProvidersProxies(lb.providers, touch), nil | <mask> }
<mask>
<mask> func (lb *LoadBalance) proxies() []C.Proxy {
<mask> elm, _, _ := lb.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(lb.providers), nil
<mask> })
<mask>
<mask> return elm.([]C.Proxy)
<mask> }
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove func (lb *LoadBalance) proxies() []C.Proxy {
</s> add func (lb *LoadBalance) proxies(touch bool) []C.Proxy { </s> remove proxies := lb.proxies()
</s> add proxies := lb.proxies(true) </s> remove return getProvidersProxies(f.providers), nil
</s> add return getProvidersProxies(f.providers, touch), nil </s> remove return getProvidersProxies(u.providers), nil
</s> add return getProvidersProxies(u.providers, touch), nil </s> remove func (f *Fallback) proxies() []C.Proxy {
</s> add func (f *Fallback) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/loadbalance.go |
for _, proxy := range lb.proxies(false) { | <mask> }
<mask>
<mask> func (lb *LoadBalance) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range lb.proxies() {
<mask> all = append(all, proxy.Name())
<mask> }
<mask> return json.Marshal(map[string]interface{}{
<mask> "type": lb.Type().String(),
<mask> "all": all,
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range r.rawProxies() {
</s> add for _, proxy := range r.rawProxies(false) { </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove for _, proxy := range f.proxies() {
</s> add for _, proxy := range f.proxies(false) { </s> remove for _, proxy := range u.proxies() {
</s> add for _, proxy := range u.proxies(false) { </s> remove return u.fast().SupportUDP()
</s> add return u.fast(false).SupportUDP() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/loadbalance.go |
Lazy bool `group:"lazy,omitempty"` | <mask> Proxies []string `group:"proxies,omitempty"`
<mask> Use []string `group:"use,omitempty"`
<mask> URL string `group:"url,omitempty"`
<mask> Interval int `group:"interval,omitempty"`
<mask> DisableUDP bool `group:"disable-udp,omitempty"`
<mask> }
<mask>
<mask> func ParseProxyGroup(config map[string]interface{}, proxyMap map[string]C.Proxy, providersMap map[string]provider.ProxyProvider) (C.ProxyAdapter, error) {
</s> Feature: add `lazy` for proxy group and provider </s> remove groupOption := &GroupCommonOption{}
</s> add groupOption := &GroupCommonOption{
Lazy: true,
} </s> remove url string
proxies []C.Proxy
interval uint
done chan struct{}
</s> add url string
proxies []C.Proxy
interval uint
lazy bool
lastTouch *atomic.Int64
done chan struct{} </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) </s> remove return u.fast().SupportUDP()
</s> add return u.fast(false).SupportUDP() | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/parser.go |
groupOption := &GroupCommonOption{
Lazy: true,
} | <mask>
<mask> func ParseProxyGroup(config map[string]interface{}, proxyMap map[string]C.Proxy, providersMap map[string]provider.ProxyProvider) (C.ProxyAdapter, error) {
<mask> decoder := structure.NewDecoder(structure.Option{TagName: "group", WeaklyTypedInput: true})
<mask>
<mask> groupOption := &GroupCommonOption{}
<mask> if err := decoder.Decode(config, groupOption); err != nil {
<mask> return nil, errFormat
<mask> }
<mask>
<mask> if groupOption.Type == "" || groupOption.Name == "" {
</s> Feature: add `lazy` for proxy group and provider </s> remove hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy) </s> remove schema := &proxyProviderSchema{}
</s> add schema := &proxyProviderSchema{
HealthCheck: healthCheckSchema{
Lazy: true,
},
} </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/parser.go |
hc := provider.NewHealthCheck(ps, "", 0, true) | <mask> }
<mask>
<mask> // if Use not empty, drop health check options
<mask> if len(groupOption.Use) != 0 {
<mask> hc := provider.NewHealthCheck(ps, "", 0)
<mask> pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy) </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove schema := &proxyProviderSchema{}
</s> add schema := &proxyProviderSchema{
HealthCheck: healthCheckSchema{
Lazy: true,
},
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/parser.go |
hc := provider.NewHealthCheck(ps, "", 0, true) | <mask> }
<mask>
<mask> // select don't need health check
<mask> if groupOption.Type == "select" || groupOption.Type == "relay" {
<mask> hc := provider.NewHealthCheck(ps, "", 0)
<mask> pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy) </s> remove groupOption := &GroupCommonOption{}
</s> add groupOption := &GroupCommonOption{
Lazy: true,
} </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/parser.go |
hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy) | <mask> if groupOption.URL == "" || groupOption.Interval == 0 {
<mask> return nil, errMissHealthCheck
<mask> }
<mask>
<mask> hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
<mask> pd, err := provider.NewCompatibleProvider(groupName, ps, hc)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove groupOption := &GroupCommonOption{}
</s> add groupOption := &GroupCommonOption{
Lazy: true,
} </s> remove schema := &proxyProviderSchema{}
</s> add schema := &proxyProviderSchema{
HealthCheck: healthCheckSchema{
Lazy: true,
},
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/parser.go |
proxies := r.proxies(metadata, true) | <mask> providers []provider.ProxyProvider
<mask> }
<mask>
<mask> func (r *Relay) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> proxies := r.proxies(metadata)
<mask> if len(proxies) == 0 {
<mask> return nil, errors.New("proxy does not exist")
<mask> }
<mask> first := proxies[0]
<mask> last := proxies[len(proxies)-1]
</s> Feature: add `lazy` for proxy group and provider </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) </s> remove c, err := s.selectedProxy().DialContext(ctx, metadata)
</s> add c, err := s.selectedProxy(true).DialContext(ctx, metadata) </s> remove return s.selectedProxy()
</s> add return s.selectedProxy(true) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove return u.fast().Name()
</s> add return u.fast(false).Name() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/relay.go |
for _, proxy := range r.rawProxies(false) { | <mask> }
<mask>
<mask> func (r *Relay) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range r.rawProxies() {
<mask> all = append(all, proxy.Name())
<mask> }
<mask> return json.Marshal(map[string]interface{}{
<mask> "type": r.Type().String(),
<mask> "all": all,
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range lb.proxies() {
</s> add for _, proxy := range lb.proxies(false) { </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove for _, proxy := range f.proxies() {
</s> add for _, proxy := range f.proxies(false) { </s> remove for _, proxy := range u.proxies() {
</s> add for _, proxy := range u.proxies(false) { </s> remove return s.selectedProxy().SupportUDP()
</s> add return s.selectedProxy(false).SupportUDP() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/relay.go |
func (r *Relay) rawProxies(touch bool) []C.Proxy { | <mask> "all": all,
<mask> })
<mask> }
<mask>
<mask> func (r *Relay) rawProxies() []C.Proxy {
<mask> elm, _, _ := r.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(r.providers), nil
<mask> })
<mask>
<mask> return elm.([]C.Proxy)
</s> Feature: add `lazy` for proxy group and provider </s> remove return getProvidersProxies(r.providers), nil
</s> add return getProvidersProxies(r.providers, touch), nil </s> remove return getProvidersProxies(f.providers), nil
</s> add return getProvidersProxies(f.providers, touch), nil </s> remove return getProvidersProxies(lb.providers), nil
</s> add return getProvidersProxies(lb.providers, touch), nil </s> remove return getProvidersProxies(u.providers), nil
</s> add return getProvidersProxies(u.providers, touch), nil </s> remove for _, proxy := range r.rawProxies() {
</s> add for _, proxy := range r.rawProxies(false) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/relay.go |
return getProvidersProxies(r.providers, touch), nil | <mask> }
<mask>
<mask> func (r *Relay) rawProxies() []C.Proxy {
<mask> elm, _, _ := r.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(r.providers), nil
<mask> })
<mask>
<mask> return elm.([]C.Proxy)
<mask> }
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove func (r *Relay) rawProxies() []C.Proxy {
</s> add func (r *Relay) rawProxies(touch bool) []C.Proxy { </s> remove return getProvidersProxies(lb.providers), nil
</s> add return getProvidersProxies(lb.providers, touch), nil </s> remove return getProvidersProxies(f.providers), nil
</s> add return getProvidersProxies(f.providers, touch), nil </s> remove return getProvidersProxies(u.providers), nil
</s> add return getProvidersProxies(u.providers, touch), nil </s> remove func (f *Fallback) proxies() []C.Proxy {
</s> add func (f *Fallback) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/relay.go |
func (r *Relay) proxies(metadata *C.Metadata, touch bool) []C.Proxy {
proxies := r.rawProxies(touch) | <mask>
<mask> return elm.([]C.Proxy)
<mask> }
<mask>
<mask> func (r *Relay) proxies(metadata *C.Metadata) []C.Proxy {
<mask> proxies := r.rawProxies()
<mask>
<mask> for n, proxy := range proxies {
<mask> subproxy := proxy.Unwrap(metadata)
<mask> for subproxy != nil {
<mask> proxies[n] = subproxy
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range r.rawProxies() {
</s> add for _, proxy := range r.rawProxies(false) { </s> remove func (r *Relay) rawProxies() []C.Proxy {
</s> add func (r *Relay) rawProxies(touch bool) []C.Proxy { </s> remove func (f *Fallback) findAliveProxy() C.Proxy {
proxies := f.proxies()
</s> add func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
proxies := f.proxies(touch) </s> remove proxies = append(proxies, provider.Proxies()...)
</s> add if touch {
proxies = append(proxies, provider.ProxiesWithTouch()...)
} else {
proxies = append(proxies, provider.Proxies()...)
} </s> remove proxies := r.proxies(metadata)
</s> add proxies := r.proxies(metadata, true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/relay.go |
c, err := s.selectedProxy(true).DialContext(ctx, metadata) | <mask> providers []provider.ProxyProvider
<mask> }
<mask>
<mask> func (s *Selector) DialContext(ctx context.Context, metadata *C.Metadata) (C.Conn, error) {
<mask> c, err := s.selectedProxy().DialContext(ctx, metadata)
<mask> if err == nil {
<mask> c.AppendToChains(s)
<mask> }
<mask> return c, err
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove return u.fast().Name()
</s> add return u.fast(false).Name() </s> remove c, err = u.fast().DialContext(ctx, metadata)
</s> add c, err = u.fast(true).DialContext(ctx, metadata) </s> remove pc, err := s.selectedProxy().DialUDP(metadata)
</s> add pc, err := s.selectedProxy(true).DialUDP(metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
pc, err := s.selectedProxy(true).DialUDP(metadata) | <mask> return c, err
<mask> }
<mask>
<mask> func (s *Selector) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
<mask> pc, err := s.selectedProxy().DialUDP(metadata)
<mask> if err == nil {
<mask> pc.AppendToChains(s)
<mask> }
<mask> return pc, err
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove pc, err := u.fast().DialUDP(metadata)
</s> add pc, err := u.fast(true).DialUDP(metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove c, err := s.selectedProxy().DialContext(ctx, metadata)
</s> add c, err := s.selectedProxy(true).DialContext(ctx, metadata) </s> remove c, err = u.fast().DialContext(ctx, metadata)
</s> add c, err = u.fast(true).DialContext(ctx, metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
return s.selectedProxy(false).SupportUDP() | <mask> if s.disableUDP {
<mask> return false
<mask> }
<mask>
<mask> return s.selectedProxy().SupportUDP()
<mask> }
<mask>
<mask> func (s *Selector) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range getProvidersProxies(s.providers) {
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove return u.fast().SupportUDP()
</s> add return u.fast(false).SupportUDP() </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) </s> remove for _, proxy := range r.rawProxies() {
</s> add for _, proxy := range r.rawProxies(false) { </s> remove for _, proxy := range lb.proxies() {
</s> add for _, proxy := range lb.proxies(false) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
for _, proxy := range getProvidersProxies(s.providers, false) { | <mask> }
<mask>
<mask> func (s *Selector) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range getProvidersProxies(s.providers) {
<mask> all = append(all, proxy.Name())
<mask> }
<mask>
<mask> return json.Marshal(map[string]interface{}{
<mask> "type": s.Type().String(),
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range f.proxies() {
</s> add for _, proxy := range f.proxies(false) { </s> remove for _, proxy := range lb.proxies() {
</s> add for _, proxy := range lb.proxies(false) { </s> remove for _, proxy := range r.rawProxies() {
</s> add for _, proxy := range r.rawProxies(false) { </s> remove for _, proxy := range u.proxies() {
</s> add for _, proxy := range u.proxies(false) { </s> remove return s.selectedProxy().SupportUDP()
</s> add return s.selectedProxy(false).SupportUDP() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
return s.selectedProxy(false).Name() | <mask> })
<mask> }
<mask>
<mask> func (s *Selector) Now() string {
<mask> return s.selectedProxy().Name()
<mask> }
<mask>
<mask> func (s *Selector) Set(name string) error {
<mask> for _, proxy := range getProvidersProxies(s.providers) {
<mask> if proxy.Name() == name {
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove func (s *Selector) selectedProxy() C.Proxy {
</s> add func (s *Selector) selectedProxy(touch bool) C.Proxy { </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) </s> remove return s.selectedProxy()
</s> add return s.selectedProxy(true) </s> remove return s.selectedProxy().SupportUDP()
</s> add return s.selectedProxy(false).SupportUDP() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
for _, proxy := range getProvidersProxies(s.providers, false) { | <mask> return s.selectedProxy().Name()
<mask> }
<mask>
<mask> func (s *Selector) Set(name string) error {
<mask> for _, proxy := range getProvidersProxies(s.providers) {
<mask> if proxy.Name() == name {
<mask> s.selected = name
<mask> s.single.Reset()
<mask> return nil
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove return s.selectedProxy().Name()
</s> add return s.selectedProxy(false).Name() </s> remove func (s *Selector) selectedProxy() C.Proxy {
</s> add func (s *Selector) selectedProxy(touch bool) C.Proxy { </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) </s> remove return s.selectedProxy().SupportUDP()
</s> add return s.selectedProxy(false).SupportUDP() </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
return s.selectedProxy(true) | <mask> return errors.New("proxy not exist")
<mask> }
<mask>
<mask> func (s *Selector) Unwrap(metadata *C.Metadata) C.Proxy {
<mask> return s.selectedProxy()
<mask> }
<mask>
<mask> func (s *Selector) selectedProxy() C.Proxy {
<mask> elm, _, _ := s.single.Do(func() (interface{}, error) {
<mask> proxies := getProvidersProxies(s.providers)
</s> Feature: add `lazy` for proxy group and provider </s> remove func (s *Selector) selectedProxy() C.Proxy {
</s> add func (s *Selector) selectedProxy(touch bool) C.Proxy { </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) </s> remove return s.selectedProxy().Name()
</s> add return s.selectedProxy(false).Name() </s> remove proxies := lb.proxies()
</s> add proxies := lb.proxies(true) </s> remove return s.selectedProxy().SupportUDP()
</s> add return s.selectedProxy(false).SupportUDP() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
func (s *Selector) selectedProxy(touch bool) C.Proxy { | <mask> func (s *Selector) Unwrap(metadata *C.Metadata) C.Proxy {
<mask> return s.selectedProxy()
<mask> }
<mask>
<mask> func (s *Selector) selectedProxy() C.Proxy {
<mask> elm, _, _ := s.single.Do(func() (interface{}, error) {
<mask> proxies := getProvidersProxies(s.providers)
<mask> for _, proxy := range proxies {
<mask> if proxy.Name() == s.selected {
<mask> return proxy, nil
</s> Feature: add `lazy` for proxy group and provider </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) </s> remove return s.selectedProxy()
</s> add return s.selectedProxy(true) </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove return s.selectedProxy().Name()
</s> add return s.selectedProxy(false).Name() </s> remove proxies := lb.proxies()
</s> add proxies := lb.proxies(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
proxies := getProvidersProxies(s.providers, touch) | <mask> }
<mask>
<mask> func (s *Selector) selectedProxy() C.Proxy {
<mask> elm, _, _ := s.single.Do(func() (interface{}, error) {
<mask> proxies := getProvidersProxies(s.providers)
<mask> for _, proxy := range proxies {
<mask> if proxy.Name() == s.selected {
<mask> return proxy, nil
<mask> }
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove func (s *Selector) selectedProxy() C.Proxy {
</s> add func (s *Selector) selectedProxy(touch bool) C.Proxy { </s> remove return s.selectedProxy()
</s> add return s.selectedProxy(true) </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove return s.selectedProxy().Name()
</s> add return s.selectedProxy(false).Name() </s> remove proxies := lb.proxies()
</s> add proxies := lb.proxies(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/selector.go |
return u.fast(false).Name() | <mask> providers []provider.ProxyProvider
<mask> }
<mask>
<mask> func (u *URLTest) Now() string {
<mask> return u.fast().Name()
<mask> }
<mask>
<mask> func (u *URLTest) DialContext(ctx context.Context, metadata *C.Metadata) (c C.Conn, err error) {
<mask> c, err = u.fast().DialContext(ctx, metadata)
<mask> if err == nil {
</s> Feature: add `lazy` for proxy group and provider </s> remove c, err = u.fast().DialContext(ctx, metadata)
</s> add c, err = u.fast(true).DialContext(ctx, metadata) </s> remove c, err := s.selectedProxy().DialContext(ctx, metadata)
</s> add c, err := s.selectedProxy(true).DialContext(ctx, metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove pc, err := u.fast().DialUDP(metadata)
</s> add pc, err := u.fast(true).DialUDP(metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
c, err = u.fast(true).DialContext(ctx, metadata) | <mask> return u.fast().Name()
<mask> }
<mask>
<mask> func (u *URLTest) DialContext(ctx context.Context, metadata *C.Metadata) (c C.Conn, err error) {
<mask> c, err = u.fast().DialContext(ctx, metadata)
<mask> if err == nil {
<mask> c.AppendToChains(u)
<mask> }
<mask> return c, err
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove return u.fast().Name()
</s> add return u.fast(false).Name() </s> remove c, err := s.selectedProxy().DialContext(ctx, metadata)
</s> add c, err := s.selectedProxy(true).DialContext(ctx, metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove pc, err := u.fast().DialUDP(metadata)
</s> add pc, err := u.fast(true).DialUDP(metadata) </s> remove pc, err := s.selectedProxy().DialUDP(metadata)
</s> add pc, err := s.selectedProxy(true).DialUDP(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
pc, err := u.fast(true).DialUDP(metadata) | <mask> return c, err
<mask> }
<mask>
<mask> func (u *URLTest) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
<mask> pc, err := u.fast().DialUDP(metadata)
<mask> if err == nil {
<mask> pc.AppendToChains(u)
<mask> }
<mask> return pc, err
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove pc, err := s.selectedProxy().DialUDP(metadata)
</s> add pc, err := s.selectedProxy(true).DialUDP(metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove c, err = u.fast().DialContext(ctx, metadata)
</s> add c, err = u.fast(true).DialContext(ctx, metadata) </s> remove return u.fast()
</s> add return u.fast(true) </s> remove return u.fast().Name()
</s> add return u.fast(false).Name() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
return u.fast(true) | <mask> return pc, err
<mask> }
<mask>
<mask> func (u *URLTest) Unwrap(metadata *C.Metadata) C.Proxy {
<mask> return u.fast()
<mask> }
<mask>
<mask> func (u *URLTest) proxies() []C.Proxy {
<mask> elm, _, _ := u.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(u.providers), nil
</s> Feature: add `lazy` for proxy group and provider </s> remove func (u *URLTest) proxies() []C.Proxy {
</s> add func (u *URLTest) proxies(touch bool) []C.Proxy { </s> remove return getProvidersProxies(u.providers), nil
</s> add return getProvidersProxies(u.providers, touch), nil </s> remove pc, err := u.fast().DialUDP(metadata)
</s> add pc, err := u.fast(true).DialUDP(metadata) </s> remove func (u *URLTest) fast() C.Proxy {
</s> add func (u *URLTest) fast(touch bool) C.Proxy { </s> remove proxies := lb.proxies()
</s> add proxies := lb.proxies(true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
func (u *URLTest) proxies(touch bool) []C.Proxy { | <mask> func (u *URLTest) Unwrap(metadata *C.Metadata) C.Proxy {
<mask> return u.fast()
<mask> }
<mask>
<mask> func (u *URLTest) proxies() []C.Proxy {
<mask> elm, _, _ := u.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(u.providers), nil
<mask> })
<mask>
<mask> return elm.([]C.Proxy)
</s> Feature: add `lazy` for proxy group and provider </s> remove return u.fast()
</s> add return u.fast(true) </s> remove return getProvidersProxies(u.providers), nil
</s> add return getProvidersProxies(u.providers, touch), nil </s> remove func (u *URLTest) fast() C.Proxy {
</s> add func (u *URLTest) fast(touch bool) C.Proxy { </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) </s> remove return getProvidersProxies(f.providers), nil
</s> add return getProvidersProxies(f.providers, touch), nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
return getProvidersProxies(u.providers, touch), nil | <mask> }
<mask>
<mask> func (u *URLTest) proxies() []C.Proxy {
<mask> elm, _, _ := u.single.Do(func() (interface{}, error) {
<mask> return getProvidersProxies(u.providers), nil
<mask> })
<mask>
<mask> return elm.([]C.Proxy)
<mask> }
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove func (u *URLTest) proxies() []C.Proxy {
</s> add func (u *URLTest) proxies(touch bool) []C.Proxy { </s> remove return u.fast()
</s> add return u.fast(true) </s> remove return getProvidersProxies(f.providers), nil
</s> add return getProvidersProxies(f.providers, touch), nil </s> remove return getProvidersProxies(lb.providers), nil
</s> add return getProvidersProxies(lb.providers, touch), nil </s> remove func (f *Fallback) proxies() []C.Proxy {
</s> add func (f *Fallback) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
func (u *URLTest) fast(touch bool) C.Proxy { | <mask>
<mask> return elm.([]C.Proxy)
<mask> }
<mask>
<mask> func (u *URLTest) fast() C.Proxy {
<mask> elm, _, _ := u.fastSingle.Do(func() (interface{}, error) {
<mask> proxies := u.proxies()
<mask> fast := proxies[0]
<mask> min := fast.LastDelay()
<mask> for _, proxy := range proxies[1:] {
</s> Feature: add `lazy` for proxy group and provider </s> remove proxies := u.proxies()
</s> add proxies := u.proxies(touch) </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) </s> remove func (u *URLTest) proxies() []C.Proxy {
</s> add func (u *URLTest) proxies(touch bool) []C.Proxy { </s> remove func (s *Selector) selectedProxy() C.Proxy {
</s> add func (s *Selector) selectedProxy(touch bool) C.Proxy { </s> remove func (f *Fallback) findAliveProxy() C.Proxy {
proxies := f.proxies()
</s> add func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
proxies := f.proxies(touch) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
proxies := u.proxies(touch) | <mask> }
<mask>
<mask> func (u *URLTest) fast() C.Proxy {
<mask> elm, _, _ := u.fastSingle.Do(func() (interface{}, error) {
<mask> proxies := u.proxies()
<mask> fast := proxies[0]
<mask> min := fast.LastDelay()
<mask> for _, proxy := range proxies[1:] {
<mask> if !proxy.Alive() {
<mask> continue
</s> Feature: add `lazy` for proxy group and provider </s> remove func (u *URLTest) fast() C.Proxy {
</s> add func (u *URLTest) fast(touch bool) C.Proxy { </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) </s> remove func (s *Selector) selectedProxy() C.Proxy {
</s> add func (s *Selector) selectedProxy(touch bool) C.Proxy { </s> remove for _, proxy := range u.proxies() {
</s> add for _, proxy := range u.proxies(false) { </s> remove func (u *URLTest) proxies() []C.Proxy {
</s> add func (u *URLTest) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
return u.fast(false).SupportUDP() | <mask> if u.disableUDP {
<mask> return false
<mask> }
<mask>
<mask> return u.fast().SupportUDP()
<mask> }
<mask>
<mask> func (u *URLTest) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range u.proxies() {
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range u.proxies() {
</s> add for _, proxy := range u.proxies(false) { </s> remove return s.selectedProxy().SupportUDP()
</s> add return s.selectedProxy(false).SupportUDP() </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove for _, proxy := range r.rawProxies() {
</s> add for _, proxy := range r.rawProxies(false) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
for _, proxy := range u.proxies(false) { | <mask> }
<mask>
<mask> func (u *URLTest) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range u.proxies() {
<mask> all = append(all, proxy.Name())
<mask> }
<mask> return json.Marshal(map[string]interface{}{
<mask> "type": u.Type().String(),
<mask> "now": u.Now(),
</s> Feature: add `lazy` for proxy group and provider </s> remove for _, proxy := range f.proxies() {
</s> add for _, proxy := range f.proxies(false) { </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove for _, proxy := range lb.proxies() {
</s> add for _, proxy := range lb.proxies(false) { </s> remove for _, proxy := range r.rawProxies() {
</s> add for _, proxy := range r.rawProxies(false) { </s> remove return u.fast().SupportUDP()
</s> add return u.fast(false).SupportUDP() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/outboundgroup/urltest.go |
"go.uber.org/atomic" | <mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> const (
<mask> defaultURLTestTimeout = time.Second * 5
<mask> )
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove func getProvidersProxies(providers []provider.ProxyProvider) []C.Proxy {
</s> add func getProvidersProxies(providers []provider.ProxyProvider, touch bool) []C.Proxy { </s> remove url string
proxies []C.Proxy
interval uint
done chan struct{}
</s> add url string
proxies []C.Proxy
interval uint
lazy bool
lastTouch *atomic.Int64
done chan struct{} </s> remove proxies = append(proxies, provider.Proxies()...)
</s> add if touch {
proxies = append(proxies, provider.ProxiesWithTouch()...)
} else {
proxies = append(proxies, provider.Proxies()...)
} </s> remove hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval)
</s> add hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval, schema.HealthCheck.Lazy) </s> remove c, err = u.fast().DialContext(ctx, metadata)
</s> add c, err = u.fast(true).DialContext(ctx, metadata) | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/healthcheck.go |
url string
proxies []C.Proxy
interval uint
lazy bool
lastTouch *atomic.Int64
done chan struct{} | <mask> Interval uint
<mask> }
<mask>
<mask> type HealthCheck struct {
<mask> url string
<mask> proxies []C.Proxy
<mask> interval uint
<mask> done chan struct{}
<mask> }
<mask>
<mask> func (hc *HealthCheck) process() {
<mask> ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
<mask>
</s> Feature: add `lazy` for proxy group and provider </s> remove func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint, lazy bool) *HealthCheck { </s> remove func getProvidersProxies(providers []provider.ProxyProvider) []C.Proxy {
</s> add func getProvidersProxies(providers []provider.ProxyProvider, touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/healthcheck.go |
now := time.Now().Unix()
if !hc.lazy || now-hc.lastTouch.Load() < int64(hc.interval) {
hc.check()
} | <mask> go hc.check()
<mask> for {
<mask> select {
<mask> case <-ticker.C:
<mask> hc.check()
<mask> case <-hc.done:
<mask> ticker.Stop()
<mask> return
<mask> }
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove return u.fast().SupportUDP()
</s> add return u.fast(false).SupportUDP() </s> remove return s.selectedProxy().SupportUDP()
</s> add return s.selectedProxy(false).SupportUDP() </s> remove func (f *Fallback) findAliveProxy() C.Proxy {
proxies := f.proxies()
</s> add func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
proxies := f.proxies(touch) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/healthcheck.go |
func (hc *HealthCheck) touch() {
hc.lastTouch.Store(time.Now().Unix())
}
| <mask> return hc.interval != 0
<mask> }
<mask>
<mask> func (hc *HealthCheck) check() {
<mask> ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
<mask> for _, proxy := range hc.proxies {
<mask> go proxy.URLTest(ctx, hc.url)
</s> Feature: add `lazy` for proxy group and provider </s> remove func (f *Fallback) findAliveProxy() C.Proxy {
proxies := f.proxies()
</s> add func (f *Fallback) findAliveProxy(touch bool) C.Proxy {
proxies := f.proxies(touch) </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove func (r *Relay) proxies(metadata *C.Metadata) []C.Proxy {
proxies := r.rawProxies()
</s> add func (r *Relay) proxies(metadata *C.Metadata, touch bool) []C.Proxy {
proxies := r.rawProxies(touch) </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove proxies := getProvidersProxies(s.providers)
</s> add proxies := getProvidersProxies(s.providers, touch) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/healthcheck.go |
func NewHealthCheck(proxies []C.Proxy, url string, interval uint, lazy bool) *HealthCheck { | <mask> func (hc *HealthCheck) close() {
<mask> hc.done <- struct{}{}
<mask> }
<mask>
<mask> func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
<mask> return &HealthCheck{
<mask> proxies: proxies,
<mask> url: url,
<mask> interval: interval,
<mask> done: make(chan struct{}, 1),
</s> Feature: add `lazy` for proxy group and provider </s> remove proxies: proxies,
url: url,
interval: interval,
done: make(chan struct{}, 1),
</s> add proxies: proxies,
url: url,
interval: interval,
lazy: lazy,
lastTouch: atomic.NewInt64(0),
done: make(chan struct{}, 1), </s> remove url string
proxies []C.Proxy
interval uint
done chan struct{}
</s> add url string
proxies []C.Proxy
interval uint
lazy bool
lastTouch *atomic.Int64
done chan struct{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/healthcheck.go |
proxies: proxies,
url: url,
interval: interval,
lazy: lazy,
lastTouch: atomic.NewInt64(0),
done: make(chan struct{}, 1), | <mask> }
<mask>
<mask> func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
<mask> return &HealthCheck{
<mask> proxies: proxies,
<mask> url: url,
<mask> interval: interval,
<mask> done: make(chan struct{}, 1),
<mask> }
<mask> }
</s> Feature: add `lazy` for proxy group and provider </s> remove func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint, lazy bool) *HealthCheck { </s> remove url string
proxies []C.Proxy
interval uint
done chan struct{}
</s> add url string
proxies []C.Proxy
interval uint
lazy bool
lastTouch *atomic.Int64
done chan struct{} </s> remove schema := &proxyProviderSchema{}
</s> add schema := &proxyProviderSchema{
HealthCheck: healthCheckSchema{
Lazy: true,
},
} </s> remove return f.proxies()[0]
</s> add return proxies[0] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/healthcheck.go |
Lazy bool `provider:"lazy,omitempty"` | <mask> Enable bool `provider:"enable"`
<mask> URL string `provider:"url"`
<mask> Interval int `provider:"interval"`
<mask> }
<mask>
<mask> type proxyProviderSchema struct {
<mask> Type string `provider:"type"`
<mask> Path string `provider:"path"`
<mask> URL string `provider:"url,omitempty"`
</s> Feature: add `lazy` for proxy group and provider </s> remove url string
proxies []C.Proxy
interval uint
done chan struct{}
</s> add url string
proxies []C.Proxy
interval uint
lazy bool
lastTouch *atomic.Int64
done chan struct{} </s> remove return s.selectedProxy().Name()
</s> add return s.selectedProxy(false).Name() </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(false) </s> remove return u.fast().Name()
</s> add return u.fast(false).Name() | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/parser.go |
schema := &proxyProviderSchema{
HealthCheck: healthCheckSchema{
Lazy: true,
},
} | <mask>
<mask> func ParseProxyProvider(name string, mapping map[string]interface{}) (ProxyProvider, error) {
<mask> decoder := structure.NewDecoder(structure.Option{TagName: "provider", WeaklyTypedInput: true})
<mask>
<mask> schema := &proxyProviderSchema{}
<mask> if err := decoder.Decode(mapping, schema); err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> var hcInterval uint = 0
</s> Feature: add `lazy` for proxy group and provider </s> remove groupOption := &GroupCommonOption{}
</s> add groupOption := &GroupCommonOption{
Lazy: true,
} </s> remove hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval)
</s> add hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval, schema.HealthCheck.Lazy) </s> remove hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy) </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/parser.go |
hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval, schema.HealthCheck.Lazy) | <mask> var hcInterval uint = 0
<mask> if schema.HealthCheck.Enable {
<mask> hcInterval = uint(schema.HealthCheck.Interval)
<mask> }
<mask> hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval)
<mask>
<mask> path := C.Path.Resolve(schema.Path)
<mask>
<mask> var vehicle Vehicle
<mask> switch schema.Type {
</s> Feature: add `lazy` for proxy group and provider </s> remove schema := &proxyProviderSchema{}
</s> add schema := &proxyProviderSchema{
HealthCheck: healthCheckSchema{
Lazy: true,
},
} </s> remove for _, proxy := range getProvidersProxies(s.providers) {
</s> add for _, proxy := range getProvidersProxies(s.providers, false) { </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove for _, proxy := range u.proxies() {
</s> add for _, proxy := range u.proxies(false) { </s> remove for _, proxy := range f.proxies() {
</s> add for _, proxy := range f.proxies(false) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/parser.go |
// ProxiesWithTouch is used to inform the provider that the proxy is actually being used while getting the list of proxies.
// Commonly used in Dial and DialUDP
ProxiesWithTouch() []C.Proxy | <mask> Provider
<mask> Proxies() []C.Proxy
<mask> HealthCheck()
<mask> }
<mask>
<mask> type ProxySchema struct {
</s> Feature: add `lazy` for proxy group and provider </s> remove url string
proxies []C.Proxy
interval uint
done chan struct{}
</s> add url string
proxies []C.Proxy
interval uint
lazy bool
lastTouch *atomic.Int64
done chan struct{} </s> remove proxies = append(proxies, provider.Proxies()...)
</s> add if touch {
proxies = append(proxies, provider.ProxiesWithTouch()...)
} else {
proxies = append(proxies, provider.Proxies()...)
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/provider.go |
func (pp *proxySetProvider) ProxiesWithTouch() []C.Proxy {
pp.healthCheck.touch()
return pp.Proxies()
}
| <mask> func (pp *proxySetProvider) Proxies() []C.Proxy {
<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> }
</s> Feature: add `lazy` for proxy group and provider </s> remove schema := &proxyProviderSchema{}
</s> add schema := &proxyProviderSchema{
HealthCheck: healthCheckSchema{
Lazy: true,
},
} </s> remove hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy) </s> remove pc, err := u.fast().DialUDP(metadata)
</s> add pc, err := u.fast(true).DialUDP(metadata) </s> remove pc, err := s.selectedProxy().DialUDP(metadata)
</s> add pc, err := s.selectedProxy(true).DialUDP(metadata) </s> remove proxy := f.findAliveProxy()
</s> add proxy := f.findAliveProxy(true) | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/provider.go |
func (cp *compatibleProvider) ProxiesWithTouch() []C.Proxy {
cp.healthCheck.touch()
return cp.Proxies()
}
| <mask> func (cp *compatibleProvider) Proxies() []C.Proxy {
<mask> return cp.proxies
<mask> }
<mask>
<mask> func stopCompatibleProvider(pd *CompatibleProvider) {
<mask> pd.healthCheck.close()
<mask> }
<mask>
<mask> func NewCompatibleProvider(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvider, error) {
</s> Feature: add `lazy` for proxy group and provider </s> remove func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint, lazy bool) *HealthCheck { </s> remove proxies := lb.proxies()
</s> add proxies := lb.proxies(true) </s> remove func (lb *LoadBalance) proxies() []C.Proxy {
</s> add func (lb *LoadBalance) proxies(touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | adapters/provider/provider.go |
hc := provider.NewHealthCheck(ps, "", 0, true) | <mask> ps := []C.Proxy{}
<mask> for _, v := range proxyList {
<mask> ps = append(ps, proxies[v])
<mask> }
<mask> hc := provider.NewHealthCheck(ps, "", 0)
<mask> pd, _ := provider.NewCompatibleProvider(provider.ReservedName, ps, hc)
<mask> providersMap[provider.ReservedName] = pd
<mask>
<mask> global := outboundgroup.NewSelector(
<mask> &outboundgroup.GroupCommonOption{
</s> Feature: add `lazy` for proxy group and provider </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove hc := provider.NewHealthCheck(ps, "", 0)
</s> add hc := provider.NewHealthCheck(ps, "", 0, true) </s> remove hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval), groupOption.Lazy) </s> remove proxies = append(proxies, provider.Proxies()...)
</s> add if touch {
proxies = append(proxies, provider.ProxiesWithTouch()...)
} else {
proxies = append(proxies, provider.Proxies()...)
} </s> remove func getProvidersProxies(providers []provider.ProxyProvider) []C.Proxy {
</s> add func getProvidersProxies(providers []provider.ProxyProvider, touch bool) []C.Proxy { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/0402878daa904cc4c47cb459ff5b65168b864efc | config/config.go |
resolved bool
ipv6 bool
done bool | <mask>
<mask> type dialResult struct {
<mask> net.Conn
<mask> error
<mask> ipv6 bool
<mask> done bool
<mask> }
<mask> results := make(chan dialResult)
<mask> var primary, fallback dialResult
<mask>
<mask> startRacer := func(ctx context.Context, host string, ipv6 bool) {
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove if res.ipv6 {
</s> add if !res.ipv6 { </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if !strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | adapters/outbound/util.go |
result.resolved = true | <mask> return
<mask> }
<mask>
<mask> if ipv6 {
<mask> result.Conn, result.error = dialer.DialContext(ctx, "tcp6", net.JoinHostPort(ip.String(), port))
<mask> } else {
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove return nil, primary.error
</s> add if primary.resolved {
return nil, primary.error
} else if fallback.resolved {
return nil, fallback.error
} else {
return nil, primary.error
} </s> remove if res.ipv6 {
</s> add if !res.ipv6 { </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove ipv6 bool
done bool
</s> add resolved bool
ipv6 bool
done bool </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | adapters/outbound/util.go |
if !res.ipv6 { | <mask> if res.error == nil {
<mask> return res.Conn, nil
<mask> }
<mask>
<mask> if res.ipv6 {
<mask> primary = res
<mask> } else {
<mask> fallback = res
<mask> }
<mask>
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove return nil, primary.error
</s> add if primary.resolved {
return nil, primary.error
} else if fallback.resolved {
return nil, fallback.error
} else {
return nil, primary.error
} </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if !strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if len(ip) == net.IPv6len {
return ip, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | adapters/outbound/util.go |
if primary.resolved {
return nil, primary.error
} else if fallback.resolved {
return nil, fallback.error
} else {
return nil, primary.error
} | <mask> fallback = res
<mask> }
<mask>
<mask> if primary.done && fallback.done {
<mask> return nil, primary.error
<mask> }
<mask> }
<mask> }
<mask> }
<mask>
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove if res.ipv6 {
</s> add if !res.ipv6 { </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if !strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if len(ip) == net.IPv6len {
return ip, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | adapters/outbound/util.go |
"strings" | <mask> import (
<mask> "errors"
<mask> "net"
<mask> )
<mask>
<mask> var (
<mask> errIPNotFound = errors.New("cannot found ip")
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove ipv6 bool
done bool
</s> add resolved bool
ipv6 bool
done bool </s> remove if res.ipv6 {
</s> add if !res.ipv6 { </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if len(ip) == net.IPv6len {
return ip, nil | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | dns/iputil.go |
errIPVersion = errors.New("ip version error") | <mask>
<mask> var (
<mask> errIPNotFound = errors.New("cannot found ip")
<mask> )
<mask>
<mask> // ResolveIPv4 with a host, return ipv4
<mask> func ResolveIPv4(host string) (net.IP, error) {
<mask> if node := DefaultHosts.Search(host); node != nil {
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if len(ip) == net.IPv6len {
return ip, nil </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if len(ip) == net.IPv4len {
return ip, nil </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | dns/iputil.go |
if ip != nil {
if !strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion | <mask> }
<mask> }
<mask>
<mask> ip := net.ParseIP(host)
<mask> if ip4 := ip.To4(); ip4 != nil {
<mask> return ip4, nil
<mask> }
<mask>
<mask> if DefaultResolver != nil {
<mask> return DefaultResolver.ResolveIPv4(host)
<mask> }
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if len(ip) == net.IPv4len {
return ip, nil </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if len(ip) == net.IPv6len {
return ip, nil </s> remove if res.ipv6 {
</s> add if !res.ipv6 { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | dns/iputil.go |
if len(ip) == net.IPv4len {
return ip, nil | <mask> return nil, err
<mask> }
<mask>
<mask> for _, ip := range ipAddrs {
<mask> if ip4 := ip.To4(); ip4 != nil {
<mask> return ip4, nil
<mask> }
<mask> }
<mask>
<mask> return nil, errIPNotFound
<mask> }
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if len(ip) == net.IPv6len {
return ip, nil </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if !strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove return nil, primary.error
</s> add if primary.resolved {
return nil, primary.error
} else if fallback.resolved {
return nil, fallback.error
} else {
return nil, primary.error
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | dns/iputil.go |
if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion | <mask> }
<mask> }
<mask>
<mask> ip := net.ParseIP(host)
<mask> if ip6 := ip.To16(); ip6 != nil {
<mask> return ip6, nil
<mask> }
<mask>
<mask> if DefaultResolver != nil {
<mask> return DefaultResolver.ResolveIPv6(host)
<mask> }
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if len(ip) == net.IPv6len {
return ip, nil </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if !strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if len(ip) == net.IPv4len {
return ip, nil </s> remove if res.ipv6 {
</s> add if !res.ipv6 { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | dns/iputil.go |
if len(ip) == net.IPv6len {
return ip, nil | <mask> return nil, err
<mask> }
<mask>
<mask> for _, ip := range ipAddrs {
<mask> if ip6 := ip.To16(); ip6 != nil {
<mask> return ip6, nil
<mask> }
<mask> }
<mask>
<mask> return nil, errIPNotFound
<mask> }
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if len(ip) == net.IPv4len {
return ip, nil </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if dnsType == D.TypeAAAA {
if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
}
} else {
if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if !strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove return nil, primary.error
</s> add if primary.resolved {
return nil, primary.error
} else if fallback.resolved {
return nil, fallback.error
} else {
return nil, primary.error
} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | dns/iputil.go |
if ip != nil {
if dnsType == D.TypeAAAA && len(ip) == net.IPv6len {
return ip, nil
} else if dnsType == D.TypeA && len(ip) == net.IPv4len {
return ip, nil | <mask> }
<mask>
<mask> func (r *Resolver) resolveIP(host string, dnsType uint16) (ip net.IP, err error) {
<mask> ip = net.ParseIP(host)
<mask> if dnsType == D.TypeAAAA {
<mask> if ip6 := ip.To16(); ip6 != nil {
<mask> return ip6, nil
<mask> }
<mask> } else {
<mask> if ip4 := ip.To4(); ip4 != nil {
<mask> return ip4, nil
<mask> }
<mask> }
<mask>
<mask> query := &D.Msg{}
<mask> query.SetQuestion(D.Fqdn(host), dnsType)
</s> Fix: clearer error and ipv6 string parse (#325) </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if ip != nil {
if strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if ip != nil {
if !strings.Contains(host, ":") {
return ip, nil
}
return nil, errIPVersion </s> remove if ip6 := ip.To16(); ip6 != nil {
return ip6, nil
</s> add if len(ip) == net.IPv6len {
return ip, nil </s> remove if ip4 := ip.To4(); ip4 != nil {
return ip4, nil
</s> add if len(ip) == net.IPv4len {
return ip, nil </s> remove if res.ipv6 {
</s> add if !res.ipv6 { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/045c3a3ad4d6b50bab47818ef4f3e24166347529 | dns/resolver.go |
<mask> language: go
<mask> sudo: false
<mask> go:
<mask> - "1.11"
<mask> before_install:
<mask> - go get -u github.com/golang/dep/cmd/dep
<mask> install:
<mask> - "$GOPATH/bin/dep ensure"
<mask> env:
<mask> global:
<mask> - NAME=clash
</s> Feature: repalce dep with go module </s> remove - "$GOPATH/bin/dep ensure"
</s> add - "go mod download" </s> remove RUN curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh && \
mkdir -p /go/src/github.com/Dreamacro/clash
WORKDIR /go/src/github.com/Dreamacro/clash
COPY . /go/src/github.com/Dreamacro/clash
RUN dep ensure && \
</s> add WORKDIR /clash-src
COPY . /clash-src
RUN go mod download && \ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/04e05c6a859c71b8b7bb33d50a1ddeb936868212 | .travis.yml | |
- "go mod download" | <mask> - "1.11"
<mask> before_install:
<mask> - go get -u github.com/golang/dep/cmd/dep
<mask> install:
<mask> - "$GOPATH/bin/dep ensure"
<mask> env:
<mask> global:
<mask> - NAME=clash
<mask> - BINDIR=bin
<mask> script:
</s> Feature: repalce dep with go module </s> remove before_install:
- go get -u github.com/golang/dep/cmd/dep
</s> add </s> remove RUN curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh && \
mkdir -p /go/src/github.com/Dreamacro/clash
WORKDIR /go/src/github.com/Dreamacro/clash
COPY . /go/src/github.com/Dreamacro/clash
RUN dep ensure && \
</s> add WORKDIR /clash-src
COPY . /clash-src
RUN go mod download && \ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/04e05c6a859c71b8b7bb33d50a1ddeb936868212 | .travis.yml |
- GO111MODULE=on | <mask> global:
<mask> - NAME=clash
<mask> - BINDIR=bin
<mask> script:
<mask> - go test ./...
<mask> before_deploy: make -j releases
<mask> deploy:
</s> Feature: repalce dep with go module </s> remove before_install:
- go get -u github.com/golang/dep/cmd/dep
</s> add </s> remove - "$GOPATH/bin/dep ensure"
</s> add - "go mod download" </s> remove RUN curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh && \
mkdir -p /go/src/github.com/Dreamacro/clash
WORKDIR /go/src/github.com/Dreamacro/clash
COPY . /go/src/github.com/Dreamacro/clash
RUN dep ensure && \
</s> add WORKDIR /clash-src
COPY . /clash-src
RUN go mod download && \ | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/04e05c6a859c71b8b7bb33d50a1ddeb936868212 | .travis.yml |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.