func ListenUDP(address v2net.Address, port v2net.Port, option ListenOption) (*UDPHub, error) {
udpConn, err := net.ListenUDP("udp", &net.UDPAddr{
IP: address.IP(),
Port: int(port),
})
if err != nil {
return nil, err
}
if option.ReceiveOriginalDest {
fd, err := internal.GetSysFd(udpConn)
if err != nil {
log.Warning("UDP|Listener: Failed to get fd: ", err)
return nil, err
}
err = SetOriginalDestOptions(fd)
if err != nil {
log.Warning("UDP|Listener: Failed to set socket options: ", err)
return nil, err
}
}
hub := &UDPHub{
conn: udpConn,
option: option,
}
go hub.start()
return hub, nil
}
func ListenUDP(address v2net.Address, port v2net.Port, option ListenOption) (*UDPHub, error) {
if option.Concurrency < 1 {
option.Concurrency = 1
}
udpConn, err := net.ListenUDP("udp", &net.UDPAddr{
IP: address.IP(),
Port: int(port),
})
if err != nil {
return nil, err
}
if option.ReceiveOriginalDest {
fd, err := internal.GetSysFd(udpConn)
if err != nil {
log.Warning("UDP|Listener: Failed to get fd: ", err)
return nil, err
}
err = SetOriginalDestOptions(fd)
if err != nil {
log.Warning("UDP|Listener: Failed to set socket options: ", err)
return nil, err
}
}
hub := &UDPHub{
conn: udpConn,
queue: NewUDPPayloadQueue(option),
option: option,
cancel: signal.NewCloseSignal(),
}
go hub.start()
return hub, nil
}
func Dial(src v2net.Address, dest v2net.Destination, options internet.DialerOptions) (internet.Connection, error) {
log.Info("WebSocket|Dailer: Creating connection to ", dest)
if src == nil {
src = v2net.AnyIP
}
networkSettings, err := options.Stream.GetEffectiveNetworkSettings()
if err != nil {
return nil, err
}
wsSettings := networkSettings.(*Config)
id := src.String() + "-" + dest.NetAddr()
var conn *wsconn
if dest.Network == v2net.Network_TCP && wsSettings.ConnectionReuse.IsEnabled() {
connt := globalCache.Get(id)
if connt != nil {
conn = connt.(*wsconn)
}
}
if conn == nil {
var err error
conn, err = wsDial(src, dest, options)
if err != nil {
log.Warning("WebSocket|Dialer: Dial failed: ", err)
return nil, err
}
}
return NewConnection(id, conn, globalCache, wsSettings), nil
}
func writeSocks4Response(writer io.Writer, errCode byte, address v2net.Address, port v2net.Port) error {
buffer := buf.NewLocal(32)
buffer.AppendBytes(0x00, errCode)
buffer.AppendSupplier(serial.WriteUint16(port.Value()))
buffer.Append(address.IP())
_, err := writer.Write(buffer.Bytes())
return err
}
func (v *Assert) Address(value net.Address) *AddressSubject {
return &AddressSubject{
Subject: Subject{
disp: value.String(),
a: v,
},
value: value,
}
}
func (this *Assert) Address(value v2net.Address) *AddressSubject {
return &AddressSubject{
Subject: Subject{
disp: value.String(),
a: this,
},
value: value,
}
}
func ListenRawTCP(address v2net.Address, port v2net.Port) (internet.Listener, error) {
listener, err := net.ListenTCP("tcp", &net.TCPAddr{
IP: address.IP(),
Port: int(port),
})
if err != nil {
return nil, err
}
return &RawTCPListener{
accepting: true,
listener: listener,
}, nil
}
func Dial(src v2net.Address, dest v2net.Destination, options internet.DialerOptions) (internet.Connection, error) {
log.Info("Dailing TCP to ", dest)
if src == nil {
src = v2net.AnyIP
}
networkSettings, err := options.Stream.GetEffectiveNetworkSettings()
if err != nil {
return nil, err
}
tcpSettings := networkSettings.(*Config)
id := src.String() + "-" + dest.NetAddr()
var conn net.Conn
if dest.Network == v2net.Network_TCP && tcpSettings.ConnectionReuse.IsEnabled() {
conn = globalCache.Get(id)
}
if conn == nil {
var err error
conn, err = internet.DialToDest(src, dest)
if err != nil {
return nil, err
}
if options.Stream != nil && options.Stream.HasSecuritySettings() {
securitySettings, err := options.Stream.GetEffectiveSecuritySettings()
if err != nil {
log.Error("TCP: Failed to get security settings: ", err)
return nil, err
}
tlsConfig, ok := securitySettings.(*v2tls.Config)
if ok {
config := tlsConfig.GetTLSConfig()
if dest.Address.Family().IsDomain() {
config.ServerName = dest.Address.Domain()
}
conn = tls.Client(conn, config)
}
}
if tcpSettings.HeaderSettings != nil {
headerConfig, err := tcpSettings.HeaderSettings.GetInstance()
if err != nil {
return nil, errors.New("TCP: Failed to get header settings: " + err.Error())
}
auth, err := internet.CreateConnectionAuthenticator(tcpSettings.HeaderSettings.Type, headerConfig)
if err != nil {
return nil, errors.New("TCP: Failed to create header authenticator: " + err.Error())
}
conn = auth.Client(conn)
}
}
return NewConnection(id, conn, globalCache, tcpSettings), nil
}
func appendAddress(buffer *buf.Buffer, address v2net.Address, port v2net.Port) {
switch address.Family() {
case v2net.AddressFamilyIPv4:
buffer.AppendBytes(0x01)
buffer.Append(address.IP())
case v2net.AddressFamilyIPv6:
buffer.AppendBytes(0x04)
buffer.Append(address.IP())
case v2net.AddressFamilyDomain:
buffer.AppendBytes(0x03, byte(len(address.Domain())))
buffer.AppendSupplier(serial.WriteString(address.Domain()))
}
buffer.AppendSupplier(serial.WriteUint16(port.Value()))
}
func ListenTCP(address v2net.Address, port v2net.Port) (internet.Listener, error) {
listener, err := net.ListenTCP("tcp", &net.TCPAddr{
IP: address.IP(),
Port: int(port),
})
if err != nil {
return nil, err
}
l := &TCPListener{
acccepting: true,
listener: listener,
awaitingConns: make(chan *ConnectionWithError, 32),
}
go l.KeepAccepting()
return l, nil
}
func appendAddress(request []byte, address v2net.Address) []byte {
switch address.Family() {
case v2net.AddressFamilyIPv4:
request = append(request, byte(0x01))
request = append(request, address.IP()...)
case v2net.AddressFamilyIPv6:
request = append(request, byte(0x04))
request = append(request, address.IP()...)
case v2net.AddressFamilyDomain:
request = append(request, byte(0x03), byte(len(address.Domain())))
request = append(request, []byte(address.Domain())...)
}
return request
}
func ListenTCP(address v2net.Address, port v2net.Port, options internet.ListenOptions) (internet.Listener, error) {
listener, err := net.ListenTCP("tcp", &net.TCPAddr{
IP: address.IP(),
Port: int(port),
})
if err != nil {
return nil, err
}
log.Info("TCP|Listener: Listening on ", address, ":", port)
networkSettings, err := options.Stream.GetEffectiveTransportSettings()
if err != nil {
return nil, err
}
tcpSettings := networkSettings.(*Config)
l := &TCPListener{
acccepting: true,
listener: listener,
awaitingConns: make(chan *ConnectionWithError, 32),
config: tcpSettings,
}
if options.Stream != nil && options.Stream.HasSecuritySettings() {
securitySettings, err := options.Stream.GetEffectiveSecuritySettings()
if err != nil {
log.Error("TCP: Failed to get security config: ", err)
return nil, err
}
tlsConfig, ok := securitySettings.(*v2tls.Config)
if ok {
l.tlsConfig = tlsConfig.GetTLSConfig()
}
}
if tcpSettings.HeaderSettings != nil {
headerConfig, err := tcpSettings.HeaderSettings.GetInstance()
if err != nil {
return nil, errors.Base(err).Message("Internet|TCP: Invalid header settings.")
}
auth, err := internet.CreateConnectionAuthenticator(headerConfig)
if err != nil {
return nil, errors.Base(err).Message("Internet|TCP: Invalid header settings.")
}
l.authConfig = auth
}
go l.KeepAccepting()
return l, nil
}
func Dial(src v2net.Address, dest v2net.Destination) (internet.Connection, error) {
log.Info("Dailing TCP to ", dest)
if src == nil {
src = v2net.AnyIP
}
id := src.String() + "-" + dest.NetAddr()
var conn net.Conn
if dest.IsTCP() && effectiveConfig.ConnectionReuse {
conn = globalCache.Get(id)
}
if conn == nil {
var err error
conn, err = internet.DialToDest(src, dest)
if err != nil {
return nil, err
}
}
return NewConnection(id, conn, globalCache), nil
}
func (this *DefaultSystemDialer) Dial(src v2net.Address, dest v2net.Destination) (net.Conn, error) {
dialer := &net.Dialer{
Timeout: time.Second * 60,
DualStack: true,
}
if src != nil && src != v2net.AnyIP {
var addr net.Addr
if dest.IsTCP() {
addr = &net.TCPAddr{
IP: src.IP(),
Port: 0,
}
} else {
addr = &net.UDPAddr{
IP: src.IP(),
Port: 0,
}
}
dialer.LocalAddr = addr
}
return dialer.Dial(dest.Network().String(), dest.NetAddr())
}
func Dial(src v2net.Address, dest v2net.Destination) (internet.Connection, error) {
log.Info("WebSocket|Dailer: Creating connection to ", dest)
if src == nil {
src = v2net.AnyIP
}
id := src.String() + "-" + dest.NetAddr()
var conn *wsconn
if dest.IsTCP() && effectiveConfig.ConnectionReuse {
connt := globalCache.Get(id)
if connt != nil {
conn = connt.(*wsconn)
}
}
if conn == nil {
var err error
conn, err = wsDial(src, dest)
if err != nil {
log.Warning("WebSocket|Dialer: Dial failed: ", err)
return nil, err
}
}
return NewConnection(id, conn, globalCache), nil
}
func (subject *AddressSubject) NotEquals(another v2net.Address) {
if subject.value == another {
subject.Fail("not equals to", another.String())
}
}
func (subject *AddressSubject) Equals(another net.Address) {
if subject.value != another {
subject.Fail("equals to", another.String())
}
}
func (subject *AddressSubject) Equals(another v2net.Address) {
if !subject.value.Equals(another) {
subject.Fail("equals to", another.String())
}
}
func (wsl *WSListener) listenws(address v2net.Address, port v2net.Port) error {
http.HandleFunc("/"+wsl.config.Path, func(w http.ResponseWriter, r *http.Request) {
con, err := wsl.converttovws(w, r)
if err != nil {
log.Warning("WebSocket|Listener: Failed to convert connection: ", err)
return
}
select {
case wsl.awaitingConns <- &ConnectionWithError{
conn: con,
}:
default:
if con != nil {
con.Close()
}
}
return
})
errchan := make(chan error)
listenerfunc := func() error {
ol, err := net.Listen("tcp", address.String()+":"+strconv.Itoa(int(port.Value())))
if err != nil {
return err
}
wsl.listener, err = NewStoppableListener(ol)
if err != nil {
return err
}
return http.Serve(wsl.listener, nil)
}
if wsl.tlsConfig != nil {
listenerfunc = func() error {
var err error
wsl.listener, err = getstopableTLSlistener(wsl.tlsConfig, address.String()+":"+strconv.Itoa(int(port.Value())))
if err != nil {
return err
}
return http.Serve(wsl.listener, nil)
}
}
go func() {
err := listenerfunc()
errchan <- err
return
}()
var err error
select {
case err = <-errchan:
case <-time.After(time.Second * 2):
//Should this listen fail after 2 sec, it could gone untracked.
}
if err != nil {
log.Error("WebSocket|Listener: Failed to serve: ", err)
}
return err
}
