server

Documentation

Index

• Constants
• Variables
• func GenerateBandwidthLimit() (l model.BandwidthLimit, err error)
• func GetHeader(out model.Out, lisa *config.Lisa) (header *protocol.Header, err error)
• func InitLimitedDialer()
• func NewDialer(name string, nextDialer netproxy.Dialer, header *protocol.Header) (netproxy.Dialer, error)
• func Register(name string, c Creator)
• func RelayTCP(lConn, rConn netproxy.Conn) (err error)
• func RelayUDP(dst *net.UDPConn, laddr net.Addr, src net.PacketConn, timeout time.Duration) (err error)
• func RelayUDPToConn(dst netproxy.FullConn, src netproxy.PacketConn, timeout time.Duration, ...) (err error)
• func SelectTimeout(packet []byte) time.Duration
• func SyncPassages(s Server, passages []Passage) (err error)
• type Argument
• type ContentionCache
  • func NewContentionCache() *ContentionCache
  • func (c *ContentionCache) Check(key string, protectTime time.Duration, ip net.IP) (accept bool, conflictIP net.IP)
• type ContentionCountdown
• type Creator
• type ForceNetworkType
• type LimitedDNSConn
  • func (c *LimitedDNSConn) Read(b []byte) (int, error)
  • func (c *LimitedDNSConn) Write(b []byte) (int, error)
• type Passage
  • func (p *Passage) Use() (use PassageUse)
• type PassageUse
• type PrivateLimitedDialer
  • func NewLimitedDialer(fullCone bool, forceNetwork ForceNetworkType) *PrivateLimitedDialer
  • func (d *PrivateLimitedDialer) Dial(network, addr string) (c netproxy.Conn, err error)
  • func (d *PrivateLimitedDialer) DialTcp(addr string) (c netproxy.Conn, err error)
  • func (d *PrivateLimitedDialer) DialUdp(addr string) (netproxy.PacketConn, error)
• type PrivateLimitedUDPConn
  • func (c *PrivateLimitedUDPConn) ReadFrom(p []byte) (n int, addr netip.AddrPort, err error)
  • func (c *PrivateLimitedUDPConn) WriteMsgUDP(b, oob []byte, addr *net.UDPAddr) (n, oobn int, err error)
  • func (c *PrivateLimitedUDPConn) WriteTo(b []byte, addr string) (int, error)
  • func (c *PrivateLimitedUDPConn) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error)
• type Server
  • func NewServer(valueCtx context.Context, dialer netproxy.Dialer, protocol string, ...) (Server, error)
• type WriteCloser

Constants

const (
	LostThreshold = 5 * time.Minute

	JuicityDomain = "software.download.prss.microsoft.com"
)

const (
	DefaultNatTimeout = 3 * time.Minute
	DnsQueryTimeout   = 17 * time.Second // RFC 5452
	DialTimeout       = 10 * time.Second
)

Variables

var ErrDialPrivateAddress = fmt.Errorf("request to dial a private address")

var (
	ErrPassageAbuse = fmt.Errorf("passage abuse")
)

var FullconePrivateLimitedDialer netproxy.Dialer

var Mapper = make(map[string]Creator)

var (
	// ProtectTime is the cooling time of a client IP changing for the same passage
	ProtectTime = map[PassageUse]time.Duration{
		PassageUseUser:    0,
		PassageUseRelay:   90 * time.Second,
		PassageUseManager: 90 * time.Second,
	}
)

var SymmetricPrivateLimitedDialer netproxy.Dialer

Functions

func GenerateBandwidthLimit

func GenerateBandwidthLimit() (l model.BandwidthLimit, err error)

func GetHeader

func GetHeader(out model.Out, lisa *config.Lisa) (header *protocol.Header, err error)

func InitLimitedDialer

func InitLimitedDialer()

func NewDialer

func NewDialer(name string, nextDialer netproxy.Dialer, header *protocol.Header) (netproxy.Dialer, error)

func Register

func Register(name string, c Creator)

func RelayTCP

func RelayTCP(lConn, rConn netproxy.Conn) (err error)

func RelayUDP

func RelayUDP(dst *net.UDPConn, laddr net.Addr, src net.PacketConn, timeout time.Duration) (err error)

func RelayUDPToConn

func RelayUDPToConn(dst netproxy.FullConn, src netproxy.PacketConn, timeout time.Duration, bufSize int) (err error)

func SelectTimeout

func SelectTimeout(packet []byte) time.Duration

SelectTimeout selects an appropriate timeout for UDP packet.

func SyncPassages

func SyncPassages(s Server, passages []Passage) (err error)

Types

type Argument

type Argument struct {
	Ticket string

	ServerName string
	Hostnames  string
	Port       int

	NoRelay bool
}

type ContentionCache

type ContentionCache struct {
	// contains filtered or unexported fields
}

func NewContentionCache

func NewContentionCache() *ContentionCache

func (*ContentionCache) Check

func (c *ContentionCache) Check(key string, protectTime time.Duration, ip net.IP) (accept bool, conflictIP net.IP)

Check return if the IP should be allowed for the key.

type ContentionCountdown

type ContentionCountdown struct {
	// contains filtered or unexported fields
}

type Creator

type Creator func(valueCtx context.Context, dialer netproxy.Dialer, sweetLisaHost config.Lisa, arg Argument) (Server, error)

type ForceNetworkType

type ForceNetworkType int

const (
	Force4 ForceNetworkType = iota
	Force6
	KeepOrigin
)

type LimitedDNSConn

type LimitedDNSConn struct {
	net.Conn
	// contains filtered or unexported fields
}

LimitedDNSConn adheres to RFC 7766 section 5, "Transport Protocol Selection".

func (*LimitedDNSConn) Read

func (c *LimitedDNSConn) Read(b []byte) (int, error)

func (*LimitedDNSConn) Write

func (c *LimitedDNSConn) Write(b []byte) (int, error)

type Passage

type Passage struct {
	model.Passage
	Manager bool
}

func (*Passage) Use

func (p *Passage) Use() (use PassageUse)

type PassageUse

type PassageUse string

const (
	PassageUseUser    PassageUse = "user"
	PassageUseRelay   PassageUse = "relay"
	PassageUseManager PassageUse = "manager"
)

type PrivateLimitedDialer

type PrivateLimitedDialer struct {
	// contains filtered or unexported fields
}

func NewLimitedDialer

func NewLimitedDialer(fullCone bool, forceNetwork ForceNetworkType) *PrivateLimitedDialer

func (*PrivateLimitedDialer) Dial

func (d *PrivateLimitedDialer) Dial(network, addr string) (c netproxy.Conn, err error)

func (*PrivateLimitedDialer) DialTcp

func (d *PrivateLimitedDialer) DialTcp(addr string) (c netproxy.Conn, err error)

func (*PrivateLimitedDialer) DialUdp

func (d *PrivateLimitedDialer) DialUdp(addr string) (netproxy.PacketConn, error)

type PrivateLimitedUDPConn

type PrivateLimitedUDPConn struct {
	*net.UDPConn
	FullCone bool
}

func (*PrivateLimitedUDPConn) ReadFrom

func (c *PrivateLimitedUDPConn) ReadFrom(p []byte) (n int, addr netip.AddrPort, err error)

func (*PrivateLimitedUDPConn) WriteMsgUDP

func (c *PrivateLimitedUDPConn) WriteMsgUDP(b, oob []byte, addr *net.UDPAddr) (n, oobn int, err error)

func (*PrivateLimitedUDPConn) WriteTo

func (c *PrivateLimitedUDPConn) WriteTo(b []byte, addr string) (int, error)

func (*PrivateLimitedUDPConn) WriteToUDP

func (c *PrivateLimitedUDPConn) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error)

type Server

type Server interface {
	Listen(addr string) (err error)
	AddPassages(passages []Passage) (err error)
	RemovePassages(passages []Passage, alsoManager bool) (err error)
	SyncPassages(passages []Passage) (err error)
	Passages() (passages []Passage)
	io.Closer
}

func NewServer

func NewServer(valueCtx context.Context, dialer netproxy.Dialer, protocol string, sweetLisaHost config.Lisa, arg Argument) (Server, error)

type WriteCloser

type WriteCloser interface {
	CloseWrite() error
}