fix bug

client.go

@@ -11,10 +11,10 @@ import (
 	"github.com/shadowsocks/shadowsocks-go/shadowsocks"
 	"io"
 	"io/ioutil"
-	"net/url"
 	"log"
 	"net"
 	"net/http"
+	"net/url"
 	"strconv"
 	"strings"
 	//"sync/atomic"
@@ -65,11 +65,9 @@ func clientMethodSelected(method uint8, conn net.Conn) (net.Conn, error) {
 		cipher, _ := shadowsocks.NewCipher(Methods[method], Password)
 		conn = shadowsocks.NewConn(conn, cipher)
 	case gosocks5.MethodNoAcceptable:
-		fallthrough
-	default:
 		return nil, gosocks5.ErrBadMethod
 	}
-	
+
 	return conn, nil
 }
 
@@ -81,54 +79,35 @@ func cliHandle(conn net.Conn) {
 			fmt.Println("session end", atomic.AddInt64(&sessionCount, -1))
 		}()
 	*/
-	addr := Saddr
+
-	if strings.HasPrefix(addr, "http://") {
+	//log.Println("connect:", Saddr)
-		u, err := url.Parse(addr)
+	c, err := Connect(Saddr, Proxy)
-		if err != nil {
-			log.Println(err)
-			return
-		}
-		addr = u.Host
-		if !strings.Contains(addr, ":") {
-			addr += ":80"
-		}
-	}
-	if strings.HasPrefix(addr, "https://") {
-		u, err := url.Parse(addr)
-		if err != nil {
-			log.Println(err)
-			return
-		}
-		addr = u.Host
-		if !strings.Contains(addr, ":") {
-			addr += ":443"
-		}
-	}
-	log.Println("connect:", addr)
-	c, err := Connect(addr, Proxy)
 	if err != nil {
 		log.Println(err)
 		return
 	}
 	defer c.Close()
-	
+
 	if Websocket {
-		u, err := url.Parse(addr)
+		url := &url.URL{
-		if err != nil {
+			Host: Saddr,
-			log.Println(err)
-			return
 		}
-		ws, resp, err := websocket.NewClient(c, u, nil, 8192, 8192)
+		ws, resp, err := websocket.NewClient(c, url, nil, 8192, 8192)
 		if err != nil {
 			log.Println(err)
 			return
 		}
 		resp.Body.Close()
-		
+
 		c = NewWSConn(ws)
 	}
-	
+
-	c = gosocks5.ClientConn(c, clientConfig)
+	sc := gosocks5.ClientConn(c, clientConfig)
+	if err := sc.Handleshake(); err != nil {
+		log.Println(err)
+		return
+	}
+	c = sc
 
 	if Shadows {
 		cipher, _ := shadowsocks.NewCipher(SMethod, SPassword)
@@ -186,7 +165,7 @@ func handleSocks5(conn net.Conn, sconn net.Conn) {
 	if err != nil {
 		return
 	}
-	//log.Println(req)
+	log.Println(req)
 
 	switch req.Cmd {
 	case gosocks5.CmdConnect, gosocks5.CmdBind:

util.go

@@ -11,6 +11,7 @@ import (
 	"net/http"
 	"net/url"
 	"strconv"
+	"strings"
 )
 
 const (
@@ -51,6 +52,9 @@ func ToSocksAddr(addr net.Addr) *gosocks5.Addr {
 }
 
 func Connect(addr, proxy string) (net.Conn, error) {
+	if !strings.Contains(addr, ":") {
+		addr += ":80"
+	}
 	if len(proxy) == 0 {
 		taddr, err := net.ResolveTCPAddr("tcp", addr)
 		if err != nil {

ws.go

@@ -1,69 +1,71 @@
 package main
 
 import (
-    "github.com/gorilla/websocket"
+	"github.com/ginuerzh/gosocks5"
-    "net/http"
+	"github.com/gorilla/websocket"
-    "log"
+	"log"
-    "time"
+	"net/http"
-    "github.com/ginuerzh/gosocks5"
+	"time"
 )
 
 type WSConn struct {
-    *websocket.Conn
+	*websocket.Conn
 }
 
 func NewWSConn(conn *websocket.Conn) *WSConn {
-    c := &WSConn{}
+	c := &WSConn{}
-    c.Conn = conn
+	c.Conn = conn
-    
+
-    return c
+	return c
 }
 
 func (conn *WSConn) Read(b []byte) (n int, err error) {
-    _, b, err = conn.ReadMessage()
+	_, r, err := conn.NextReader()
-    n = len(b)
+	if err != nil {
-    
+		return
-    return
+	}
+	return r.Read(b)
 }
 
 func (conn *WSConn) Write(b []byte) (n int, err error) {
-    n = len(b)
+	w, err := conn.NextWriter(websocket.BinaryMessage)
-    err = conn.WriteMessage(websocket.BinaryMessage, b)
+	if err != nil {
-    return
+		return
+	}
+	defer w.Close()
+	return w.Write(b)
 }
 
 func (conn *WSConn) SetDeadline(t time.Time) error {
-    if err := conn.SetReadDeadline(t); err != nil {
+	if err := conn.SetReadDeadline(t); err != nil {
-        return err
+		return err
-    }
+	}
-    return conn.SetWriteDeadline(t)
+	return conn.SetWriteDeadline(t)
 }
 
 type WSServer struct {
-    Addr string
+	Addr string
 }
 
 var upgrader = websocket.Upgrader{
-    ReadBufferSize:  8192,
+	ReadBufferSize:  8192,
-    WriteBufferSize: 8192,
+	WriteBufferSize: 8192,
-    CheckOrigin: func(r *http.Request) bool{ return true;},
+	CheckOrigin:     func(r *http.Request) bool { return true },
 }
 
-
 func (s *WSServer) handle(w http.ResponseWriter, r *http.Request) {
-    conn, err := upgrader.Upgrade(w, r, nil)
+	conn, err := upgrader.Upgrade(w, r, nil)
-    if err != nil {
+	if err != nil {
-        log.Println(err)
+		log.Println(err)
-        return
+		return
-    }
+	}
-    defer conn.Close()
+	defer conn.Close()
-    
+
-    c := NewWSConn(conn)
+	c := gosocks5.ServerConn(NewWSConn(conn), serverConfig)
-    
+	socks5Handle(c)
-    socks5Handle(gosocks5.ServerConn(c, serverConfig))
 }
 
 func (s *WSServer) ListenAndServe() error {
-    http.HandleFunc("/", s.handle)
+	http.HandleFunc("/", s.handle)
-    return http.ListenAndServe(s.Addr, nil)
+	return http.ListenAndServe(s.Addr, nil)
-}
+}