fix compile error (ginuerzh#280)

xinst · ginuerzh · commit 84dc5a612e4f · 2018-07-09T18:04:42.000+08:00
diff --git a/examples/bench/srv.go b/examples/bench/srv.go
@@ -52,19 +52,18 @@ func main() {
 }
 
 func httpServer() {
-	s := &gost.Server{}
 	ln, err := gost.TCPListener(":18080")
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.HTTPHandler(
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func socks5Server() {
-	s := &gost.Server{}
 	ln, err := gost.TCPListener(":11080")
 	if err != nil {
 		log.Fatal(err)
@@ -73,79 +72,79 @@ func socks5Server() {
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 		gost.TLSConfigHandlerOption(tlsConfig()),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func shadowServer() {
-	s := &gost.Server{}
 	ln, err := gost.TCPListener(":18338")
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.ShadowHandler(
 		gost.UsersHandlerOption(url.UserPassword("chacha20", "123456")),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func tlsServer() {
-	s := &gost.Server{}
 	ln, err := gost.TLSListener(":11443", tlsConfig())
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.HTTPHandler(
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func wsServer() {
-	s := &gost.Server{}
 	ln, err := gost.WSListener(":18000", nil)
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.HTTPHandler(
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func wssServer() {
-	s := &gost.Server{}
 	ln, err := gost.WSSListener(":18443", tlsConfig(), nil)
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.HTTPHandler(
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func kcpServer() {
-	s := &gost.Server{}
 	ln, err := gost.KCPListener(":18388", nil)
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.HTTPHandler()
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func tcpForwardServer() {
-	s := &gost.Server{}
 	ln, err := gost.TCPListener(":2222")
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.TCPDirectForwardHandler("localhost:22")
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func tcpRemoteForwardServer() {
-	s := &gost.Server{}
 	ln, err := gost.TCPRemoteForwardListener(
 		":1222",
 		/*
@@ -171,11 +170,11 @@ func tcpRemoteForwardServer() {
 		":22",
 		//gost.AddrHandlerOption("127.0.0.1:22"),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func rudpForwardServer() {
-	s := &gost.Server{}
 	ln, err := gost.UDPRemoteForwardListener(
 		":10053",
 		gost.NewChain(
@@ -196,47 +195,47 @@ func rudpForwardServer() {
 		log.Fatal()
 	}
 	h := gost.UDPRemoteForwardHandler("localhost:53")
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func tcpRedirectServer() {
-	s := &gost.Server{}
 	ln, err := gost.TCPListener(":8008")
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.TCPRedirectHandler()
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func sshTunnelServer() {
-	s := &gost.Server{}
 	ln, err := gost.SSHTunnelListener(":12222", &gost.SSHConfig{TLSConfig: tlsConfig()})
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.HTTPHandler(
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func http2Server() {
 	// http2.VerboseLogs = true
 
-	s := &gost.Server{}
 	ln, err := gost.HTTP2Listener(":1443", tlsConfig())
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.HTTP2Handler(
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func http2TunnelServer() {
-	s := &gost.Server{}
 	ln, err := gost.H2Listener(":8443", tlsConfig()) // HTTP2 h2 mode
 	// ln, err := gost.H2CListener(":8443") // HTTP2 h2c mode
 	if err != nil {
@@ -249,23 +248,23 @@ func http2TunnelServer() {
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 		gost.TLSConfigHandlerOption(tlsConfig()),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func quicServer() {
-	s := &gost.Server{}
 	ln, err := gost.QUICListener("localhost:6121", &gost.QUICConfig{TLSConfig: tlsConfig()})
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.HTTPHandler(
 		gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 func shadowUDPServer() {
-	s := &gost.Server{}
 	ln, err := gost.ShadowUDPListener(":18338", url.UserPassword("chacha20", "123456"), 30*time.Second)
 	if err != nil {
 		log.Fatal(err)
@@ -286,7 +285,8 @@ func shadowUDPServer() {
 		)),
 	*/
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 var (
diff --git a/examples/forward/direct/server.go b/examples/forward/direct/server.go
@@ -12,7 +12,6 @@ func main() {
 }
 
 func sshForwardServer() {
-	s := &gost.Server{}
 	ln, err := gost.TCPListener(":11222")
 	if err != nil {
 		log.Fatal(err)
@@ -22,7 +21,8 @@ func sshForwardServer() {
 		// gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 		gost.TLSConfigHandlerOption(tlsConfig()),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 var (
diff --git a/examples/forward/remote/server.go b/examples/forward/remote/server.go
@@ -12,7 +12,6 @@ func main() {
 }
 
 func sshRemoteForwardServer() {
-	s := &gost.Server{}
 	ln, err := gost.TCPListener(":11222")
 	if err != nil {
 		log.Fatal(err)
@@ -22,7 +21,8 @@ func sshRemoteForwardServer() {
 		// gost.UsersHandlerOption(url.UserPassword("admin", "123456")),
 		gost.TLSConfigHandlerOption(tlsConfig()),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 var (
diff --git a/examples/forward/udp/direct.go b/examples/forward/udp/direct.go
@@ -31,7 +31,6 @@ func main() {
 }
 
 func udpDirectForwardServer() {
-	s := &gost.Server{}
 	ln, err := gost.UDPDirectForwardListener(laddr, time.Second*30)
 	if err != nil {
 		log.Fatal(err)
@@ -53,5 +52,6 @@ func udpDirectForwardServer() {
 		})),
 	*/
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
diff --git a/examples/forward/udp/remote.go b/examples/forward/udp/remote.go
@@ -31,7 +31,6 @@ func main() {
 }
 
 func udpRemoteForwardServer() {
-	s := &gost.Server{}
 	ln, err := gost.UDPRemoteForwardListener(
 		laddr,
 		/*
@@ -56,5 +55,6 @@ func udpRemoteForwardServer() {
 	h := gost.UDPRemoteForwardHandler(
 		faddr,
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
diff --git a/examples/http2/http2.go b/examples/http2/http2.go
@@ -50,7 +50,6 @@ func http2Server() {
 		}
 	}
 
-	s := &gost.Server{}
 	ln, err := gost.HTTP2Listener(laddr, &tls.Config{Certificates: []tls.Certificate{cert}})
 	if err != nil {
 		log.Fatal(err)
@@ -65,7 +64,8 @@ func http2Server() {
 		gost.UsersHandlerOption(users...),
 		gost.AddrHandlerOption(laddr),
 	)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 var (
diff --git a/examples/quic/quics.go b/examples/quic/quics.go
@@ -32,14 +32,15 @@ func main() {
 }
 
 func quicServer() {
-	s := &gost.Server{}
 	ln, err := gost.QUICListener(laddr, &gost.QUICConfig{TLSConfig: tlsConfig()})
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.SOCKS5Handler(gost.TLSConfigHandlerOption(tlsConfig()))
 	log.Println("server listen on", laddr)
-	log.Fatal(s.Serve(ln, h))
+
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 var (
diff --git a/examples/ssh/sshd.go b/examples/ssh/sshd.go
@@ -32,14 +32,14 @@ func main() {
 }
 
 func sshTunnelServer() {
-	s := &gost.Server{}
 	ln, err := gost.SSHTunnelListener(laddr, &gost.SSHConfig{TLSConfig: tlsConfig()})
 	if err != nil {
 		log.Fatal(err)
 	}
 	h := gost.SOCKS5Handler(gost.TLSConfigHandlerOption(tlsConfig()))
 	log.Println("server listen on", laddr)
-	log.Fatal(s.Serve(ln, h))
+	s := &gost.Server{ln}
+	log.Fatal(s.Serve(h))
 }
 
 var (

Original file line number	Diff line number	Diff line change
`@@ -52,19 +52,18 @@ func main() {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`func httpServer() {`
`55`		`- s := &gost.Server{}`
`56`	`55`	`ln, err := gost.TCPListener(":18080")`
`57`	`56`	`if err != nil {`
`58`	`57`	`log.Fatal(err)`
`59`	`58`	`}`
`60`	`59`	`h := gost.HTTPHandler(`
`61`	`60`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`62`	`61`	`)`
`63`		`- log.Fatal(s.Serve(ln, h))`
	`62`	`+ s := &gost.Server{ln}`
	`63`	`+ log.Fatal(s.Serve(h))`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`func socks5Server() {`
`67`		`- s := &gost.Server{}`
`68`	`67`	`ln, err := gost.TCPListener(":11080")`
`69`	`68`	`if err != nil {`
`70`	`69`	`log.Fatal(err)`
`@@ -73,79 +72,79 @@ func socks5Server() {`
`73`	`72`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`74`	`73`	`gost.TLSConfigHandlerOption(tlsConfig()),`
`75`	`74`	`)`
`76`		`- log.Fatal(s.Serve(ln, h))`
	`75`	`+ s := &gost.Server{ln}`
	`76`	`+ log.Fatal(s.Serve(h))`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`func shadowServer() {`
`80`		`- s := &gost.Server{}`
`81`	`80`	`ln, err := gost.TCPListener(":18338")`
`82`	`81`	`if err != nil {`
`83`	`82`	`log.Fatal(err)`
`84`	`83`	`}`
`85`	`84`	`h := gost.ShadowHandler(`
`86`	`85`	`gost.UsersHandlerOption(url.UserPassword("chacha20", "123456")),`
`87`	`86`	`)`
`88`		`- log.Fatal(s.Serve(ln, h))`
	`87`	`+ s := &gost.Server{ln}`
	`88`	`+ log.Fatal(s.Serve(h))`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`func tlsServer() {`
`92`		`- s := &gost.Server{}`
`93`	`92`	`ln, err := gost.TLSListener(":11443", tlsConfig())`
`94`	`93`	`if err != nil {`
`95`	`94`	`log.Fatal(err)`
`96`	`95`	`}`
`97`	`96`	`h := gost.HTTPHandler(`
`98`	`97`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`99`	`98`	`)`
`100`		`- log.Fatal(s.Serve(ln, h))`
	`99`	`+ s := &gost.Server{ln}`
	`100`	`+ log.Fatal(s.Serve(h))`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`func wsServer() {`
`104`		`- s := &gost.Server{}`
`105`	`104`	`ln, err := gost.WSListener(":18000", nil)`
`106`	`105`	`if err != nil {`
`107`	`106`	`log.Fatal(err)`
`108`	`107`	`}`
`109`	`108`	`h := gost.HTTPHandler(`
`110`	`109`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`111`	`110`	`)`
`112`		`- log.Fatal(s.Serve(ln, h))`
	`111`	`+ s := &gost.Server{ln}`
	`112`	`+ log.Fatal(s.Serve(h))`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`func wssServer() {`
`116`		`- s := &gost.Server{}`
`117`	`116`	`ln, err := gost.WSSListener(":18443", tlsConfig(), nil)`
`118`	`117`	`if err != nil {`
`119`	`118`	`log.Fatal(err)`
`120`	`119`	`}`
`121`	`120`	`h := gost.HTTPHandler(`
`122`	`121`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`123`	`122`	`)`
`124`		`- log.Fatal(s.Serve(ln, h))`
	`123`	`+ s := &gost.Server{ln}`
	`124`	`+ log.Fatal(s.Serve(h))`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`func kcpServer() {`
`128`		`- s := &gost.Server{}`
`129`	`128`	`ln, err := gost.KCPListener(":18388", nil)`
`130`	`129`	`if err != nil {`
`131`	`130`	`log.Fatal(err)`
`132`	`131`	`}`
`133`	`132`	`h := gost.HTTPHandler()`
`134`		`- log.Fatal(s.Serve(ln, h))`
	`133`	`+ s := &gost.Server{ln}`
	`134`	`+ log.Fatal(s.Serve(h))`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`func tcpForwardServer() {`
`138`		`- s := &gost.Server{}`
`139`	`138`	`ln, err := gost.TCPListener(":2222")`
`140`	`139`	`if err != nil {`
`141`	`140`	`log.Fatal(err)`
`142`	`141`	`}`
`143`	`142`	`h := gost.TCPDirectForwardHandler("localhost:22")`
`144`		`- log.Fatal(s.Serve(ln, h))`
	`143`	`+ s := &gost.Server{ln}`
	`144`	`+ log.Fatal(s.Serve(h))`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`func tcpRemoteForwardServer() {`
`148`		`- s := &gost.Server{}`
`149`	`148`	`ln, err := gost.TCPRemoteForwardListener(`
`150`	`149`	`":1222",`
`151`	`150`	`/*`
`@@ -171,11 +170,11 @@ func tcpRemoteForwardServer() {`
`171`	`170`	`":22",`
`172`	`171`	`//gost.AddrHandlerOption("127.0.0.1:22"),`
`173`	`172`	`)`
`174`		`- log.Fatal(s.Serve(ln, h))`
	`173`	`+ s := &gost.Server{ln}`
	`174`	`+ log.Fatal(s.Serve(h))`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`func rudpForwardServer() {`
`178`		`- s := &gost.Server{}`
`179`	`178`	`ln, err := gost.UDPRemoteForwardListener(`
`180`	`179`	`":10053",`
`181`	`180`	`gost.NewChain(`
`@@ -196,47 +195,47 @@ func rudpForwardServer() {`
`196`	`195`	`log.Fatal()`
`197`	`196`	`}`
`198`	`197`	`h := gost.UDPRemoteForwardHandler("localhost:53")`
`199`		`- log.Fatal(s.Serve(ln, h))`
	`198`	`+ s := &gost.Server{ln}`
	`199`	`+ log.Fatal(s.Serve(h))`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`func tcpRedirectServer() {`
`203`		`- s := &gost.Server{}`
`204`	`203`	`ln, err := gost.TCPListener(":8008")`
`205`	`204`	`if err != nil {`
`206`	`205`	`log.Fatal(err)`
`207`	`206`	`}`
`208`	`207`	`h := gost.TCPRedirectHandler()`
`209`		`- log.Fatal(s.Serve(ln, h))`
	`208`	`+ s := &gost.Server{ln}`
	`209`	`+ log.Fatal(s.Serve(h))`
`210`	`210`	`}`
`211`	`211`
`212`	`212`	`func sshTunnelServer() {`
`213`		`- s := &gost.Server{}`
`214`	`213`	`ln, err := gost.SSHTunnelListener(":12222", &gost.SSHConfig{TLSConfig: tlsConfig()})`
`215`	`214`	`if err != nil {`
`216`	`215`	`log.Fatal(err)`
`217`	`216`	`}`
`218`	`217`	`h := gost.HTTPHandler(`
`219`	`218`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`220`	`219`	`)`
`221`		`- log.Fatal(s.Serve(ln, h))`
	`220`	`+ s := &gost.Server{ln}`
	`221`	`+ log.Fatal(s.Serve(h))`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	`func http2Server() {`
`225`	`225`	`// http2.VerboseLogs = true`
`226`	`226`
`227`		`- s := &gost.Server{}`
`228`	`227`	`ln, err := gost.HTTP2Listener(":1443", tlsConfig())`
`229`	`228`	`if err != nil {`
`230`	`229`	`log.Fatal(err)`
`231`	`230`	`}`
`232`	`231`	`h := gost.HTTP2Handler(`
`233`	`232`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`234`	`233`	`)`
`235`		`- log.Fatal(s.Serve(ln, h))`
	`234`	`+ s := &gost.Server{ln}`
	`235`	`+ log.Fatal(s.Serve(h))`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`func http2TunnelServer() {`
`239`		`- s := &gost.Server{}`
`240`	`239`	`ln, err := gost.H2Listener(":8443", tlsConfig()) // HTTP2 h2 mode`
`241`	`240`	`// ln, err := gost.H2CListener(":8443") // HTTP2 h2c mode`
`242`	`241`	`if err != nil {`
`@@ -249,23 +248,23 @@ func http2TunnelServer() {`
`249`	`248`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`250`	`249`	`gost.TLSConfigHandlerOption(tlsConfig()),`
`251`	`250`	`)`
`252`		`- log.Fatal(s.Serve(ln, h))`
	`251`	`+ s := &gost.Server{ln}`
	`252`	`+ log.Fatal(s.Serve(h))`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`func quicServer() {`
`256`		`- s := &gost.Server{}`
`257`	`256`	`ln, err := gost.QUICListener("localhost:6121", &gost.QUICConfig{TLSConfig: tlsConfig()})`
`258`	`257`	`if err != nil {`
`259`	`258`	`log.Fatal(err)`
`260`	`259`	`}`
`261`	`260`	`h := gost.HTTPHandler(`
`262`	`261`	`gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`263`	`262`	`)`
`264`		`- log.Fatal(s.Serve(ln, h))`
	`263`	`+ s := &gost.Server{ln}`
	`264`	`+ log.Fatal(s.Serve(h))`
`265`	`265`	`}`
`266`	`266`
`267`	`267`	`func shadowUDPServer() {`
`268`		`- s := &gost.Server{}`
`269`	`268`	`ln, err := gost.ShadowUDPListener(":18338", url.UserPassword("chacha20", "123456"), 30*time.Second)`
`270`	`269`	`if err != nil {`
`271`	`270`	`log.Fatal(err)`
`@@ -286,7 +285,8 @@ func shadowUDPServer() {`
`286`	`285`	`)),`
`287`	`286`	`*/`
`288`	`287`	`)`
`289`		`- log.Fatal(s.Serve(ln, h))`
	`288`	`+ s := &gost.Server{ln}`
	`289`	`+ log.Fatal(s.Serve(h))`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`var (`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,6 @@ func main() {`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`func sshForwardServer() {`
`15`		`- s := &gost.Server{}`
`16`	`15`	`ln, err := gost.TCPListener(":11222")`
`17`	`16`	`if err != nil {`
`18`	`17`	`log.Fatal(err)`
`@@ -22,7 +21,8 @@ func sshForwardServer() {`
`22`	`21`	`// gost.UsersHandlerOption(url.UserPassword("admin", "123456")),`
`23`	`22`	`gost.TLSConfigHandlerOption(tlsConfig()),`
`24`	`23`	`)`
`25`		`- log.Fatal(s.Serve(ln, h))`
	`24`	`+ s := &gost.Server{ln}`
	`25`	`+ log.Fatal(s.Serve(h))`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`var (`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,6 @@ func main() {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`func udpDirectForwardServer() {`
`34`		`- s := &gost.Server{}`
`35`	`34`	`ln, err := gost.UDPDirectForwardListener(laddr, time.Second*30)`
`36`	`35`	`if err != nil {`
`37`	`36`	`log.Fatal(err)`
`@@ -53,5 +52,6 @@ func udpDirectForwardServer() {`
`53`	`52`	`})),`
`54`	`53`	`*/`
`55`	`54`	`)`
`56`		`- log.Fatal(s.Serve(ln, h))`
	`55`	`+ s := &gost.Server{ln}`
	`56`	`+ log.Fatal(s.Serve(h))`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,6 @@ func http2Server() {`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`		`- s := &gost.Server{}`
`54`	`53`	`ln, err := gost.HTTP2Listener(laddr, &tls.Config{Certificates: []tls.Certificate{cert}})`
`55`	`54`	`if err != nil {`
`56`	`55`	`log.Fatal(err)`
`@@ -65,7 +64,8 @@ func http2Server() {`
`65`	`64`	`gost.UsersHandlerOption(users...),`
`66`	`65`	`gost.AddrHandlerOption(laddr),`
`67`	`66`	`)`
`68`		`- log.Fatal(s.Serve(ln, h))`
	`67`	`+ s := &gost.Server{ln}`
	`68`	`+ log.Fatal(s.Serve(h))`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`var (`
Original file line number	Diff line number	Diff line change
`@@ -32,14 +32,15 @@ func main() {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`func quicServer() {`
`35`		`- s := &gost.Server{}`
`36`	`35`	`ln, err := gost.QUICListener(laddr, &gost.QUICConfig{TLSConfig: tlsConfig()})`
`37`	`36`	`if err != nil {`
`38`	`37`	`log.Fatal(err)`
`39`	`38`	`}`
`40`	`39`	`h := gost.SOCKS5Handler(gost.TLSConfigHandlerOption(tlsConfig()))`
`41`	`40`	`log.Println("server listen on", laddr)`
`42`		`- log.Fatal(s.Serve(ln, h))`
	`41`	`+`
	`42`	`+ s := &gost.Server{ln}`
	`43`	`+ log.Fatal(s.Serve(h))`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`var (`
Original file line number	Diff line number	Diff line change
`@@ -32,14 +32,14 @@ func main() {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`func sshTunnelServer() {`
`35`		`- s := &gost.Server{}`
`36`	`35`	`ln, err := gost.SSHTunnelListener(laddr, &gost.SSHConfig{TLSConfig: tlsConfig()})`
`37`	`36`	`if err != nil {`
`38`	`37`	`log.Fatal(err)`
`39`	`38`	`}`
`40`	`39`	`h := gost.SOCKS5Handler(gost.TLSConfigHandlerOption(tlsConfig()))`
`41`	`40`	`log.Println("server listen on", laddr)`
`42`		`- log.Fatal(s.Serve(ln, h))`
	`41`	`+ s := &gost.Server{ln}`
	`42`	`+ log.Fatal(s.Serve(h))`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`var (`