func wsDial(src v2net.Address, dest v2net.Destination, options internet.DialerOptions) (*wsconn, error) {
networkSettings, err := options.Stream.GetEffectiveNetworkSettings()
if err != nil {
return nil, err
}
wsSettings := networkSettings.(*Config)
commonDial := func(network, addr string) (net.Conn, error) {
return internet.DialToDest(src, dest)
}
dialer := websocket.Dialer{
NetDial: commonDial,
ReadBufferSize: 65536,
WriteBufferSize: 65536,
}
protocol := "ws"
if options.Stream != nil && options.Stream.HasSecuritySettings() {
protocol = "wss"
securitySettings, err := options.Stream.GetEffectiveSecuritySettings()
if err != nil {
log.Error("WebSocket: Failed to create security settings: ", err)
return nil, err
}
tlsConfig, ok := securitySettings.(*v2tls.Config)
if ok {
dialer.TLSClientConfig = tlsConfig.GetTLSConfig()
if dest.Address.Family().IsDomain() {
dialer.TLSClientConfig.ServerName = dest.Address.Domain()
}
}
}
uri := func(dst v2net.Destination, pto string, path string) string {
return fmt.Sprintf("%v://%v/%v", pto, dst.NetAddr(), path)
}(dest, protocol, wsSettings.Path)
conn, resp, err := dialer.Dial(uri, nil)
if err != nil {
if resp != nil {
reason, reasonerr := ioutil.ReadAll(resp.Body)
log.Info(string(reason), reasonerr)
}
return nil, err
}
return func() internet.Connection {
connv2ray := &wsconn{
wsc: conn,
connClosing: false,
config: wsSettings,
}
connv2ray.setup()
return connv2ray
}().(*wsconn), nil
}
func wsDial(ctx context.Context, dest v2net.Destination) (*wsconn, error) {
src := internet.DialerSourceFromContext(ctx)
wsSettings := internet.TransportSettingsFromContext(ctx).(*Config)
commonDial := func(network, addr string) (net.Conn, error) {
return internet.DialSystem(src, dest)
}
dialer := websocket.Dialer{
NetDial: commonDial,
ReadBufferSize: 32 * 1024,
WriteBufferSize: 32 * 1024,
}
protocol := "ws"
if securitySettings := internet.SecuritySettingsFromContext(ctx); securitySettings != nil {
tlsConfig, ok := securitySettings.(*v2tls.Config)
if ok {
protocol = "wss"
dialer.TLSClientConfig = tlsConfig.GetTLSConfig()
if dest.Address.Family().IsDomain() {
dialer.TLSClientConfig.ServerName = dest.Address.Domain()
}
}
}
host := dest.NetAddr()
if (protocol == "ws" && dest.Port == 80) || (protocol == "wss" && dest.Port == 443) {
host = dest.Address.String()
}
uri := protocol + "://" + host + "/" + wsSettings.Path
conn, resp, err := dialer.Dial(uri, nil)
if err != nil {
if resp != nil {
reason, reasonerr := ioutil.ReadAll(resp.Body)
log.Info(string(reason), reasonerr)
}
return nil, err
}
return func() internet.Connection {
connv2ray := &wsconn{
wsc: conn,
connClosing: false,
config: wsSettings,
}
connv2ray.setup()
return connv2ray
}().(*wsconn), nil
}
// Connect create new bitfinex websocket connection
func (w *WebSocketService) Connect() error {
var d = websocket.Dialer{
Subprotocols: []string{"p1", "p2"},
ReadBufferSize: 1024,
WriteBufferSize: 1024,
Proxy: http.ProxyFromEnvironment,
}
if w.client.WebSocketTLSSkipVerify {
d.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
}
ws, _, err := d.Dial(w.client.WebSocketURL, nil)
if err != nil {
return err
}
w.ws = ws
return nil
}
func (w *WebSocketService) ConnectPrivate(ch chan TermData) {
var d = websocket.Dialer{
Subprotocols: []string{"p1", "p2"},
ReadBufferSize: 1024,
WriteBufferSize: 1024,
Proxy: http.ProxyFromEnvironment,
}
ws, _, err := d.Dial(w.client.WebSocketURL, nil)
if w.client.WebSocketTLSSkipVerify {
d.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
}
ws, _, err = d.Dial(w.client.WebSocketURL, nil)
if err != nil {
ch <- TermData{
Error: err.Error(),
}
return
}
payload := "AUTH" + fmt.Sprintf("%v", time.Now().Unix())
connectMsg, _ := json.Marshal(&privateConnect{
Event: "auth",
ApiKey: w.client.ApiKey,
AuthSig: w.client.signPayload(payload),
AuthPayload: payload,
})
// Send auth message
err = ws.WriteMessage(websocket.TextMessage, connectMsg)
if err != nil {
ch <- TermData{
Error: err.Error(),
}
ws.Close()
return
}
var msg string
for {
_, p, err := ws.ReadMessage()
if err != nil {
ch <- TermData{
Error: err.Error(),
}
ws.Close()
return
} else {
msg = string(p)
event := &privateResponse{}
err = json.Unmarshal([]byte(msg), &event)
if err != nil {
// received data update
var data []interface{}
err = json.Unmarshal([]byte(msg), &data)
if err == nil {
dataTerm := data[1].(string)
dataList := data[2].([]interface{})
// check for empty data
if len(dataList) > 0 {
if reflect.TypeOf(dataList[0]) == reflect.TypeOf([]interface{}{}) {
// received list of lists
for _, v := range dataList {
ch <- TermData{
Term: dataTerm,
Data: v.([]interface{}),
}
}
} else {
// received flat list
ch <- TermData{
Term: dataTerm,
Data: dataList,
}
}
}
}
} else {
// received auth response
if event.Event == "auth" && event.Status != "OK" {
ch <- TermData{
Error: "Error connecting to private web socket channel.",
}
ws.Close()
}
}
}
}
}