server

Documentation

Index

• Constants
• Variables
• func GenerateBandwidthLimit() (l model.BandwidthLimit, err error)
• func Register(name string, c Creator)
• 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 LimitedDNSConn
  • func (c *LimitedDNSConn) Read(b []byte) (int, error)
  • func (c *LimitedDNSConn) Write(b []byte) (int, error)
• type Passage
• type PassageUse
• type Server
  • func NewServer(valueCtx context.Context, protocol string, sweetLisaHost config.Lisa, ...) (Server, error)

Constants

const LostThreshold = 5 * time.Minute

Variables

var DefaultLimitedDialer = net.Dialer{
	Control: func(network, address string, c syscall.RawConn) error {
		host, _, err := net.SplitHostPort(address)
		if err != nil {
			return err
		}
		ip, err := netaddr.ParseIP(host)
		if err != nil {

			return err
		}
		if common.IsPrivate(ip.IPAddr().IP) {
			return fmt.Errorf("%w: %v", ErrDialPrivateAddress, ip.String())
		}
		return nil
	},
}

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

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: 300 * time.Second,
	}
)

Functions

func GenerateBandwidthLimit

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

func Register

func Register(name string, c Creator)

func SyncPassages

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

Types

type Argument

type Argument struct {
	Ticket string

	Name      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, sweetLisaHost config.Lisa, arg Argument) (Server, error)

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 {
	Manager bool
	model.Passage
}

type PassageUse

type PassageUse string

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

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, protocol string, sweetLisaHost config.Lisa, arg Argument) (Server, error)