2018-12-22 15:56:42 +00:00
|
|
|
package adapters
|
|
|
|
|
|
|
|
import (
|
2019-07-02 11:18:03 +00:00
|
|
|
"context"
|
2018-12-22 15:56:42 +00:00
|
|
|
"encoding/json"
|
2019-04-23 15:29:36 +00:00
|
|
|
"errors"
|
2019-03-15 16:43:16 +00:00
|
|
|
"net"
|
|
|
|
"net/http"
|
|
|
|
"time"
|
2018-12-22 15:56:42 +00:00
|
|
|
|
2019-03-17 06:52:39 +00:00
|
|
|
"github.com/Dreamacro/clash/common/queue"
|
2018-12-22 15:56:42 +00:00
|
|
|
C "github.com/Dreamacro/clash/constant"
|
|
|
|
)
|
|
|
|
|
2019-07-17 16:12:01 +00:00
|
|
|
var (
|
|
|
|
defaultURLTestTimeout = time.Second * 5
|
|
|
|
)
|
|
|
|
|
2018-12-22 15:56:42 +00:00
|
|
|
type Base struct {
|
|
|
|
name string
|
|
|
|
tp C.AdapterType
|
2019-04-23 15:29:36 +00:00
|
|
|
udp bool
|
2018-12-22 15:56:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Base) Name() string {
|
|
|
|
return b.name
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Base) Type() C.AdapterType {
|
|
|
|
return b.tp
|
|
|
|
}
|
|
|
|
|
2019-08-08 17:28:37 +00:00
|
|
|
func (b *Base) DialUDP(metadata *C.Metadata) (C.PacketConn, net.Addr, error) {
|
2019-04-23 15:29:36 +00:00
|
|
|
return nil, nil, errors.New("no support")
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Base) SupportUDP() bool {
|
|
|
|
return b.udp
|
|
|
|
}
|
|
|
|
|
2019-03-15 16:43:16 +00:00
|
|
|
func (b *Base) Destroy() {}
|
|
|
|
|
2018-12-22 15:56:42 +00:00
|
|
|
func (b *Base) MarshalJSON() ([]byte, error) {
|
|
|
|
return json.Marshal(map[string]string{
|
|
|
|
"type": b.Type().String(),
|
|
|
|
})
|
|
|
|
}
|
2019-03-15 16:43:16 +00:00
|
|
|
|
2019-08-08 17:28:37 +00:00
|
|
|
type conn struct {
|
|
|
|
net.Conn
|
|
|
|
chain C.Chain
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *conn) Chains() C.Chain {
|
|
|
|
return c.chain
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *conn) AppendToChains(a C.ProxyAdapter) {
|
|
|
|
c.chain = append(c.chain, a.Name())
|
|
|
|
}
|
|
|
|
|
|
|
|
func newConn(c net.Conn, a C.ProxyAdapter) C.Conn {
|
|
|
|
return &conn{c, []string{a.Name()}}
|
|
|
|
}
|
|
|
|
|
|
|
|
type packetConn struct {
|
|
|
|
net.PacketConn
|
|
|
|
chain C.Chain
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *packetConn) Chains() C.Chain {
|
|
|
|
return c.chain
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *packetConn) AppendToChains(a C.ProxyAdapter) {
|
|
|
|
c.chain = append(c.chain, a.Name())
|
|
|
|
}
|
|
|
|
|
|
|
|
func newPacketConn(c net.PacketConn, a C.ProxyAdapter) C.PacketConn {
|
|
|
|
return &packetConn{c, []string{a.Name()}}
|
|
|
|
}
|
|
|
|
|
2019-03-15 16:43:16 +00:00
|
|
|
type Proxy struct {
|
|
|
|
C.ProxyAdapter
|
2019-03-17 06:52:39 +00:00
|
|
|
history *queue.Queue
|
|
|
|
alive bool
|
2019-03-15 16:43:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (p *Proxy) Alive() bool {
|
|
|
|
return p.alive
|
|
|
|
}
|
|
|
|
|
2019-08-08 17:28:37 +00:00
|
|
|
func (p *Proxy) Dial(metadata *C.Metadata) (C.Conn, error) {
|
2019-03-15 16:43:16 +00:00
|
|
|
conn, err := p.ProxyAdapter.Dial(metadata)
|
2019-03-28 11:00:41 +00:00
|
|
|
if err != nil {
|
|
|
|
p.alive = false
|
|
|
|
}
|
2019-03-15 16:43:16 +00:00
|
|
|
return conn, err
|
|
|
|
}
|
|
|
|
|
2019-03-17 06:52:39 +00:00
|
|
|
func (p *Proxy) DelayHistory() []C.DelayHistory {
|
|
|
|
queue := p.history.Copy()
|
|
|
|
histories := []C.DelayHistory{}
|
|
|
|
for _, item := range queue {
|
|
|
|
histories = append(histories, item.(C.DelayHistory))
|
|
|
|
}
|
|
|
|
return histories
|
|
|
|
}
|
|
|
|
|
2019-09-07 08:23:43 +00:00
|
|
|
// LastDelay return last history record. if proxy is not alive, return the max value of uint16.
|
2019-03-17 06:52:39 +00:00
|
|
|
func (p *Proxy) LastDelay() (delay uint16) {
|
2019-03-23 08:29:27 +00:00
|
|
|
var max uint16 = 0xffff
|
|
|
|
if !p.alive {
|
|
|
|
return max
|
|
|
|
}
|
|
|
|
|
2019-03-17 06:52:39 +00:00
|
|
|
head := p.history.First()
|
|
|
|
if head == nil {
|
2019-03-23 08:29:27 +00:00
|
|
|
return max
|
2019-03-17 06:52:39 +00:00
|
|
|
}
|
|
|
|
history := head.(C.DelayHistory)
|
|
|
|
if history.Delay == 0 {
|
2019-03-23 08:29:27 +00:00
|
|
|
return max
|
2019-03-17 06:52:39 +00:00
|
|
|
}
|
|
|
|
return history.Delay
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *Proxy) MarshalJSON() ([]byte, error) {
|
|
|
|
inner, err := p.ProxyAdapter.MarshalJSON()
|
|
|
|
if err != nil {
|
|
|
|
return inner, err
|
|
|
|
}
|
|
|
|
|
|
|
|
mapping := map[string]interface{}{}
|
|
|
|
json.Unmarshal(inner, &mapping)
|
|
|
|
mapping["history"] = p.DelayHistory()
|
|
|
|
return json.Marshal(mapping)
|
|
|
|
}
|
|
|
|
|
2019-03-15 16:43:16 +00:00
|
|
|
// URLTest get the delay for the specified URL
|
2019-07-02 11:18:03 +00:00
|
|
|
func (p *Proxy) URLTest(ctx context.Context, url string) (t uint16, err error) {
|
2019-03-17 06:52:39 +00:00
|
|
|
defer func() {
|
2019-03-28 11:00:41 +00:00
|
|
|
p.alive = err == nil
|
2019-03-17 06:52:39 +00:00
|
|
|
record := C.DelayHistory{Time: time.Now()}
|
|
|
|
if err == nil {
|
|
|
|
record.Delay = t
|
|
|
|
}
|
|
|
|
p.history.Put(record)
|
|
|
|
if p.history.Len() > 10 {
|
|
|
|
p.history.Pop()
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2019-03-15 16:43:16 +00:00
|
|
|
addr, err := urlToMetadata(url)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
start := time.Now()
|
2019-03-23 08:29:27 +00:00
|
|
|
instance, err := p.Dial(&addr)
|
2019-03-15 16:43:16 +00:00
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
defer instance.Close()
|
2019-07-02 11:18:03 +00:00
|
|
|
|
2019-08-09 07:39:13 +00:00
|
|
|
req, err := http.NewRequest(http.MethodHead, url, nil)
|
2019-07-02 11:18:03 +00:00
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
req = req.WithContext(ctx)
|
|
|
|
|
2019-03-15 16:43:16 +00:00
|
|
|
transport := &http.Transport{
|
|
|
|
Dial: func(string, string) (net.Conn, error) {
|
|
|
|
return instance, nil
|
|
|
|
},
|
|
|
|
// from http.DefaultTransport
|
|
|
|
MaxIdleConns: 100,
|
|
|
|
IdleConnTimeout: 90 * time.Second,
|
|
|
|
TLSHandshakeTimeout: 10 * time.Second,
|
|
|
|
ExpectContinueTimeout: 1 * time.Second,
|
|
|
|
}
|
2019-07-02 11:18:03 +00:00
|
|
|
|
2019-03-15 16:43:16 +00:00
|
|
|
client := http.Client{Transport: transport}
|
2019-07-02 11:18:03 +00:00
|
|
|
resp, err := client.Do(req)
|
2019-03-15 16:43:16 +00:00
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
resp.Body.Close()
|
2019-03-17 06:52:39 +00:00
|
|
|
t = uint16(time.Since(start) / time.Millisecond)
|
2019-03-15 16:43:16 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewProxy(adapter C.ProxyAdapter) *Proxy {
|
2019-03-17 06:52:39 +00:00
|
|
|
return &Proxy{adapter, queue.New(10), true}
|
2019-03-15 16:43:16 +00:00
|
|
|
}
|