Beispiel #1
0
func NewClient(originURL, targetURL string, settings map[string]interface{}) (c *websocket.Conn, response *http.Response, err error) {
	u, err := url.Parse(targetURL)
	if err != nil {
		return nil, nil, err
	}

	dialer := net.Dialer{}

	timeoutInterface, ok := settings["Timeout"]
	if ok {
		dialer.Timeout = timeoutInterface.(time.Duration)
	}

	keepAliveInterface, ok := settings["KeepAlive"]
	if ok {
		dialer.KeepAlive = keepAliveInterface.(time.Duration)
	}

	rawConn, err := dialer.Dial("tcp", u.Host)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"Error": err.Error(),
		}).Errorf("TCP connection error when dialing %v", u.Host)

		return nil, nil, err
	}

	wsHeaders := http.Header{
		"Origin": {originURL},
		// your milage may differ
		"Sec-WebSocket-Extensions": {"permessage-deflate; client_max_window_bits, x-webkit-deflate-frame"},
	}

	return websocket.NewClient(rawConn, u, wsHeaders, 1024, 1024)
}
Beispiel #2
0
func ConnectSrv(Config ConfigT) net.Conn {
	var dialer net.Dialer
	dialer.Timeout = time.Second
	dialer.KeepAlive = time.Minute
	chandesc, err := dialer.Dial("tcp", ConcatStr(":", Config.Main.Server, Config.Main.Port))
	if err != nil {
		LogErr(err, "serv dial")
		return nil
	} else {
		var send string = Config.Main.CCID
		for _, target := range Config.Main.TargetID {
			send = ConcatStr(" ", send, target)
		}
		fmt.Fprintf(chandesc, "%s", send)
		return chandesc
	}
}
Beispiel #3
0
func Dial(_s Stream) (err error) {
	switch w := _s.(type) {
	case *wrapperStream:
		switch s := w.base.(type) {
		case *dummyStream:
			x := &xmppStream{to: s.to, onCloseFunc: w.onErrorFunc}
			var (
				host, port string
				dial       net.Dialer
			)
			if host, port, err = srv.Resolve(x.to); err == nil {
				dial.KeepAlive = 10 * time.Second
				if x.conn, err = dial.Dial("tcp", host+":"+port); err == nil {
					x.ctrl = make(chan bool)
					x.data = make(chan pack, 256)
					go func(stream *xmppStream) {
						<-stream.ctrl
						stream.conn.Close()
					}(x)

					doSplit := func(stream *xmppStream, onErr func(error)) {
						for data := range spl1t(stream.conn, onErr) {
							//log.Println("SPLIT")
							//log.Println(string(data))
							//log.Println()
							stream.data <- pack{data: data, hash: adler32.Checksum(data)}
						}
					}

					var onErr func(error)
					onErr = func(_err error) {
						switch e := _err.(type) {
						case net.Error:
							if e.Temporary() {
								go doSplit(x, onErr)
							} else {
								x.closeStream()
								x.onClose(e)
								w.base = s
							}
						default:
							panic(fmt.Sprint(reflect.TypeOf(e), e))
						}
					}

					go doSplit(x, onErr)
					w.base = x
				} else {
					x.onClose(err)
				}
			} else {
				x.onClose(err)
			}
		default:
			err = errors.New("already connected")
		}
	default:
		halt.As(100, reflect.TypeOf(_s))
	}
	return
}