From 58ad1b71614a4ba044369db36cccb71b2f74288b Mon Sep 17 00:00:00 2001 From: David Scott Date: Thu, 21 Apr 2016 14:45:55 +0100 Subject: [PATCH 1/8] proxy: map TCP ports at 0x10000-0x20000, and UDP at 0x20000- The proxy process command-line arguments assume we're exposing TCP or UDP ports on Moby's public IPs. Instead we're forwarding over vsock where we must map the Moby ports onto vsock ports. Normally TCP and UDP ports are different, but with vsock there is only one space of port numbers so we have to map them into different ranges. This patch maps Moby ports as follows: - TCP port x onto vsock port 0x10000 + x - UDP port x onto vsock port 0x20000 + x Signed-off-by: David Scott --- alpine/packages/proxy/proxy.go | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/alpine/packages/proxy/proxy.go b/alpine/packages/proxy/proxy.go index ee52bf6b5..30d7b11be 100644 --- a/alpine/packages/proxy/proxy.go +++ b/alpine/packages/proxy/proxy.go @@ -28,8 +28,11 @@ func sendOK() { f.Close() } -// Map dynamic ports onto vsock ports over this offset -var vSockPortOffset = 0x10000 +// Map dynamic TCP ports onto vsock ports over this offset +var vSockTCPPortOffset = 0x10000 + +// Map dynamic UDP ports onto vsock ports over this offset +var vSockUDPPortOffset = 0x20000 // From docker/libnetwork/portmapper/proxy.go: @@ -49,11 +52,11 @@ func parseHostContainerAddrs() (host net.Addr, port int, container net.Addr) { switch *proto { case "tcp": host = &net.TCPAddr{IP: net.ParseIP(*hostIP), Port: *hostPort} - port = vSockPortOffset + *hostPort + port = vSockTCPPortOffset + *hostPort container = &net.TCPAddr{IP: net.ParseIP(*containerIP), Port: *containerPort} case "udp": host = &net.UDPAddr{IP: net.ParseIP(*hostIP), Port: *hostPort} - port = vSockPortOffset + *hostPort + port = vSockUDPPortOffset + *hostPort container = &net.UDPAddr{IP: net.ParseIP(*containerIP), Port: *containerPort} default: log.Fatalf("unsupported protocol %s", *proto) From abbafd82f10a301e4eb882516952e255b66404fa Mon Sep 17 00:00:00 2001 From: David Scott Date: Thu, 21 Apr 2016 15:06:09 +0100 Subject: [PATCH 2/8] proxy: create a `udpListener` interface This represents what is needed from the frontend side of the proxy: - the ability to receive a UDP datagram and know who it is from - the ability to send a UDP datagram to a particular destination - the ability to close Signed-off-by: David Scott --- alpine/packages/proxy/libproxy/proxy.go | 6 +++++- alpine/packages/proxy/libproxy/udp_proxy.go | 21 ++++++++++++--------- 2 files changed, 17 insertions(+), 10 deletions(-) diff --git a/alpine/packages/proxy/libproxy/proxy.go b/alpine/packages/proxy/libproxy/proxy.go index 2e6bb569b..e8fbbe0c5 100644 --- a/alpine/packages/proxy/libproxy/proxy.go +++ b/alpine/packages/proxy/libproxy/proxy.go @@ -31,7 +31,11 @@ type Proxy interface { func NewProxy(frontendAddr, backendAddr net.Addr) (Proxy, error) { switch frontendAddr.(type) { case *net.UDPAddr: - return NewUDPProxy(frontendAddr.(*net.UDPAddr), backendAddr.(*net.UDPAddr)) + listener, err := net.ListenUDP("udp", frontendAddr.(*net.UDPAddr)) + if err != nil { + return nil, err + } + return NewUDPProxy(frontendAddr, listener, backendAddr.(*net.UDPAddr)) case *net.TCPAddr: listener, err := net.Listen("tcp", frontendAddr.String()) if err != nil { diff --git a/alpine/packages/proxy/libproxy/udp_proxy.go b/alpine/packages/proxy/libproxy/udp_proxy.go index 7b59466b0..9b6cefc42 100644 --- a/alpine/packages/proxy/libproxy/udp_proxy.go +++ b/alpine/packages/proxy/libproxy/udp_proxy.go @@ -18,6 +18,12 @@ const ( UDPBufSize = 65507 ) +type udpListener interface { + ReadFromUDP(b []byte) (int, *net.UDPAddr, error) + WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) + Close() error +} + // A net.Addr where the IP is split into two fields so you can use it as a key // in a map: type connTrackKey struct { @@ -47,22 +53,19 @@ type connTrackMap map[connTrackKey]*net.UDPConn // interface to handle UDP traffic forwarding between the frontend and backend // addresses. type UDPProxy struct { - listener *net.UDPConn - frontendAddr *net.UDPAddr + listener udpListener + frontendAddr net.Addr backendAddr *net.UDPAddr connTrackTable connTrackMap connTrackLock sync.Mutex } // NewUDPProxy creates a new UDPProxy. -func NewUDPProxy(frontendAddr, backendAddr *net.UDPAddr) (*UDPProxy, error) { - listener, err := net.ListenUDP("udp", frontendAddr) - if err != nil { - return nil, err - } +func NewUDPProxy(frontendAddr net.Addr, listener udpListener, backendAddr *net.UDPAddr) (*UDPProxy, error) { + return &UDPProxy{ listener: listener, - frontendAddr: listener.LocalAddr().(*net.UDPAddr), + frontendAddr: frontendAddr, backendAddr: backendAddr, connTrackTable: make(connTrackMap), }, nil @@ -112,7 +115,7 @@ func (proxy *UDPProxy) Run() { // ECONNREFUSED like Read do (see comment in // UDPProxy.replyLoop) if !isClosedError(err) { - logrus.Printf("Stopping proxy on udp/%v for udp/%v (%s)", proxy.frontendAddr, proxy.backendAddr, err) + logrus.Printf("Stopping proxy on %v for udp/%v (%s)", proxy.frontendAddr, proxy.backendAddr, err) } break } From 3870705eafdb21fff53cfabbf0ecbff23bf7fd3b Mon Sep 17 00:00:00 2001 From: David Scott Date: Thu, 21 Apr 2016 16:26:28 +0100 Subject: [PATCH 3/8] proxy: prepare to encapsulate UDP datagrams over a vsock connection A net.UDPListener is the datagram equivalent of a net.Conn. This patch accepts at most one connection from vsock and attempts to read and write UDP datagrams along it. Signed-off-by: David Scott --- alpine/packages/proxy/libproxy/proxy.go | 16 +-- .../proxy/libproxy/udp_encapsulation.go | 100 ++++++++++++++++++ alpine/packages/proxy/libproxy/udp_proxy.go | 6 -- 3 files changed, 105 insertions(+), 17 deletions(-) create mode 100644 alpine/packages/proxy/libproxy/udp_encapsulation.go diff --git a/alpine/packages/proxy/libproxy/proxy.go b/alpine/packages/proxy/libproxy/proxy.go index e8fbbe0c5..457b1ba6e 100644 --- a/alpine/packages/proxy/libproxy/proxy.go +++ b/alpine/packages/proxy/libproxy/proxy.go @@ -28,22 +28,16 @@ type Proxy interface { // NewProxy creates a Proxy according to the specified frontendAddr and backendAddr. -func NewProxy(frontendAddr, backendAddr net.Addr) (Proxy, error) { - switch frontendAddr.(type) { +func NewProxy(frontendAddr *vsock.VsockAddr, backendAddr net.Addr) (Proxy, error) { + switch backendAddr.(type) { case *net.UDPAddr: - listener, err := net.ListenUDP("udp", frontendAddr.(*net.UDPAddr)) + listener, err := vsock.Listen(frontendAddr.Port) if err != nil { return nil, err } - return NewUDPProxy(frontendAddr, listener, backendAddr.(*net.UDPAddr)) + return NewUDPProxy(frontendAddr, NewUDPListener(listener), backendAddr.(*net.UDPAddr)) case *net.TCPAddr: - listener, err := net.Listen("tcp", frontendAddr.String()) - if err != nil { - return nil, err - } - return NewTCPProxy(listener, backendAddr.(*net.TCPAddr)) - case *vsock.VsockAddr: - listener, err := vsock.Listen(frontendAddr.(*vsock.VsockAddr).Port) + listener, err := vsock.Listen(frontendAddr.Port) if err != nil { return nil, err } diff --git a/alpine/packages/proxy/libproxy/udp_encapsulation.go b/alpine/packages/proxy/libproxy/udp_encapsulation.go new file mode 100644 index 000000000..8f9fa1277 --- /dev/null +++ b/alpine/packages/proxy/libproxy/udp_encapsulation.go @@ -0,0 +1,100 @@ +package libproxy + +import ( + //"encoding/binary" + "errors" + "net" + //"strings" + "sync" + //"syscall" + + "github.com/Sirupsen/logrus" +) + +type udpListener interface { + ReadFromUDP(b []byte) (int, *net.UDPAddr, error) + WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) + Close() error +} + +type udpEncapsulator struct { + conn *net.Conn + listener net.Listener + m *sync.Mutex + r *sync.Mutex + w *sync.Mutex +} + +func (u *udpEncapsulator) getConn() (net.Conn, error) { + u.m.Lock() + defer u.m.Unlock() + if u.conn != nil { + return *u.conn, nil + } + conn, err := u.listener.Accept() + if err != nil { + logrus.Printf("Failed to accept connection: %#v", err) + return nil, err + } + u.conn = &conn + return conn, nil +} + +func (u *udpEncapsulator) ReadFromUDP(b []byte) (int, *net.UDPAddr, error) { + conn, err := u.getConn() + if err != nil { + return 0, nil, err + } + u.r.Lock() + defer u.r.Unlock() + datagram := &udpDatagram{payload: b} + err = datagram.Unmarshal(conn) + if err != nil { + return 0, nil, err + } + return len(datagram.payload), &net.UDPAddr{IP: *datagram.IP, Port: datagram.Port, Zone: datagram.Zone}, nil +} + +func (u *udpEncapsulator) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) { + conn, err := u.getConn() + if err != nil { + return 0, err + } + u.w.Lock() + defer u.w.Unlock() + datagram := &udpDatagram{payload: b, IP: &addr.IP, Port: addr.Port, Zone: addr.Zone} + return len(b), datagram.Marshal(conn) +} + +func (u *udpEncapsulator) Close() error { + if u.conn != nil { + conn := *u.conn + conn.Close() + } + u.listener.Close() + return nil +} + +func NewUDPListener(listener net.Listener) udpListener { + var m sync.Mutex; + return &udpEncapsulator{ + conn: nil, + listener: listener, + m: &m, + } +} + +type udpDatagram struct { + payload []byte + IP *net.IP + Port int + Zone string +} + +func (u *udpDatagram) Marshal(conn net.Conn) error { + return errors.New("Marshal unimplemented") +} + +func (u *udpDatagram) Unmarshal(conn net.Conn) error { + return errors.New("Unmarshal unimplemented") +} diff --git a/alpine/packages/proxy/libproxy/udp_proxy.go b/alpine/packages/proxy/libproxy/udp_proxy.go index 9b6cefc42..3e5a971c6 100644 --- a/alpine/packages/proxy/libproxy/udp_proxy.go +++ b/alpine/packages/proxy/libproxy/udp_proxy.go @@ -18,12 +18,6 @@ const ( UDPBufSize = 65507 ) -type udpListener interface { - ReadFromUDP(b []byte) (int, *net.UDPAddr, error) - WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) - Close() error -} - // A net.Addr where the IP is split into two fields so you can use it as a key // in a map: type connTrackKey struct { From 03ea4419333d8bb173868d83a3850a8ab22593d5 Mon Sep 17 00:00:00 2001 From: David Scott Date: Thu, 21 Apr 2016 16:52:31 +0100 Subject: [PATCH 4/8] proxy: implement the UDP marshalling/unmarshalling Signed-off-by: David Scott --- .../proxy/libproxy/udp_encapsulation.go | 72 ++++++++++++++++--- 1 file changed, 63 insertions(+), 9 deletions(-) diff --git a/alpine/packages/proxy/libproxy/udp_encapsulation.go b/alpine/packages/proxy/libproxy/udp_encapsulation.go index 8f9fa1277..1891aa234 100644 --- a/alpine/packages/proxy/libproxy/udp_encapsulation.go +++ b/alpine/packages/proxy/libproxy/udp_encapsulation.go @@ -1,12 +1,11 @@ package libproxy import ( - //"encoding/binary" - "errors" + "bytes" + "encoding/binary" + "io" "net" - //"strings" "sync" - //"syscall" "github.com/Sirupsen/logrus" ) @@ -52,7 +51,7 @@ func (u *udpEncapsulator) ReadFromUDP(b []byte) (int, *net.UDPAddr, error) { if err != nil { return 0, nil, err } - return len(datagram.payload), &net.UDPAddr{IP: *datagram.IP, Port: datagram.Port, Zone: datagram.Zone}, nil + return len(datagram.payload), &net.UDPAddr{IP: *datagram.IP, Port: int(datagram.Port), Zone: datagram.Zone}, nil } func (u *udpEncapsulator) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) { @@ -62,7 +61,7 @@ func (u *udpEncapsulator) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) { } u.w.Lock() defer u.w.Unlock() - datagram := &udpDatagram{payload: b, IP: &addr.IP, Port: addr.Port, Zone: addr.Zone} + datagram := &udpDatagram{payload: b, IP: &addr.IP, Port: uint16(addr.Port), Zone: addr.Zone} return len(b), datagram.Marshal(conn) } @@ -87,14 +86,69 @@ func NewUDPListener(listener net.Listener) udpListener { type udpDatagram struct { payload []byte IP *net.IP - Port int + Port uint16 Zone string } func (u *udpDatagram) Marshal(conn net.Conn) error { - return errors.New("Marshal unimplemented") + var length uint16 + length = uint16(len(*u.IP)) + if err := binary.Write(conn, binary.LittleEndian, &length); err != nil { + return err + } + if err := binary.Write(conn, binary.LittleEndian, &u.IP); err != nil { + return err + } + if err := binary.Write(conn, binary.LittleEndian, &u.Port); err != nil { + return err + } + length = uint16(len(u.Zone)) + if err := binary.Write(conn, binary.LittleEndian, &length); err != nil { + return err + } + if err := binary.Write(conn, binary.LittleEndian, &u.Zone); err != nil { + return nil + } + length = uint16(len(u.payload)) + if err := binary.Write(conn, binary.LittleEndian, &length); err != nil { + return nil + } + payload := bytes.NewBuffer(u.payload) + _, err := io.Copy(conn, payload) + if err != nil { + return err + } + return nil } func (u *udpDatagram) Unmarshal(conn net.Conn) error { - return errors.New("Unmarshal unimplemented") + var length uint16 + if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { + return err + } + var IP net.IP + IP = make([]byte, length) + if err := binary.Read(conn, binary.LittleEndian, &IP); err != nil { + return err + } + u.IP = &IP + if err := binary.Read(conn, binary.LittleEndian, &u.Port); err != nil { + return err + } + if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { + return err + } + Zone := make([]byte, length) + if err := binary.Read(conn, binary.LittleEndian, &Zone); err != nil { + return err + } + u.Zone = string(Zone) + if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { + return err + } + u.payload = make([]byte, length) + if err := binary.Read(conn, binary.LittleEndian, &u.payload); err != nil { + return err + } + return nil } From caeb0d53cc056e061a5406cbd7bc72d33889baac Mon Sep 17 00:00:00 2001 From: David Scott Date: Fri, 22 Apr 2016 11:42:24 +0100 Subject: [PATCH 5/8] proxy: add an initial length to the marshalled frames Since the header is variable length it's useful to write a length field first, so the peer can read the rest of the packet as a block. Signed-off-by: David Scott --- .../proxy/libproxy/udp_encapsulation.go | 26 ++++++++++++++----- 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/alpine/packages/proxy/libproxy/udp_encapsulation.go b/alpine/packages/proxy/libproxy/udp_encapsulation.go index 1891aa234..df837a896 100644 --- a/alpine/packages/proxy/libproxy/udp_encapsulation.go +++ b/alpine/packages/proxy/libproxy/udp_encapsulation.go @@ -91,30 +91,40 @@ type udpDatagram struct { } func (u *udpDatagram) Marshal(conn net.Conn) error { + // marshal the variable length header to a temporary buffer + var header bytes.Buffer var length uint16 length = uint16(len(*u.IP)) - if err := binary.Write(conn, binary.LittleEndian, &length); err != nil { + if err := binary.Write(&header, binary.LittleEndian, &length); err != nil { return err } - if err := binary.Write(conn, binary.LittleEndian, &u.IP); err != nil { + if err := binary.Write(&header, binary.LittleEndian, &u.IP); err != nil { return err } - if err := binary.Write(conn, binary.LittleEndian, &u.Port); err != nil { + if err := binary.Write(&header, binary.LittleEndian, &u.Port); err != nil { return err } length = uint16(len(u.Zone)) - if err := binary.Write(conn, binary.LittleEndian, &length); err != nil { + if err := binary.Write(&header, binary.LittleEndian, &length); err != nil { return err } - if err := binary.Write(conn, binary.LittleEndian, &u.Zone); err != nil { + if err := binary.Write(&header, binary.LittleEndian, &u.Zone); err != nil { return nil } length = uint16(len(u.payload)) + if err := binary.Write(&header, binary.LittleEndian, &length); err != nil { + return nil + } + length = uint16(header.Len() + len(u.payload)) if err := binary.Write(conn, binary.LittleEndian, &length); err != nil { return nil } + _, err := io.Copy(conn, &header) + if err != nil { + return err + } payload := bytes.NewBuffer(u.payload) - _, err := io.Copy(conn, payload) + _, err = io.Copy(conn, payload) if err != nil { return err } @@ -123,6 +133,10 @@ func (u *udpDatagram) Marshal(conn net.Conn) error { func (u *udpDatagram) Unmarshal(conn net.Conn) error { var length uint16 + // frame length + if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { + return err + } if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { return err } From e940e12abcc4571c411905e1971a5f206a403bfb Mon Sep 17 00:00:00 2001 From: David Scott Date: Fri, 22 Apr 2016 15:17:56 +0100 Subject: [PATCH 6/8] proxy: listen on vsock before requesting a connection The 9P operations tell the host to connect to the vsock port in the UDP case, so always listen before sending the 9P request. Signed-off-by: David Scott --- alpine/packages/proxy/main.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/alpine/packages/proxy/main.go b/alpine/packages/proxy/main.go index a7c125a2a..a7ab17b15 100644 --- a/alpine/packages/proxy/main.go +++ b/alpine/packages/proxy/main.go @@ -14,17 +14,17 @@ import ( func main() { host, port, container := parseHostContainerAddrs() + p, err := libproxy.NewProxy(&vsock.VsockAddr{Port: uint(port)}, container) + if err != nil { + sendError(err) + } ctl, err := exposePort(host, port) if err != nil { sendError(err) } - p, err := libproxy.NewProxy(&vsock.VsockAddr{Port: uint(port)}, container) - if err != nil { - sendError(err) - } - go handleStopSignals(p) + // TODO: avoid this line if we are running in a TTY sendOK() p.Run() ctl.Close() // ensure ctl remains alive and un-GCed until here @@ -32,7 +32,7 @@ func main() { } func exposePort(host net.Addr, port int) (*os.File, error) { - name := host.String() + name := host.Network() + ":" + host.String() log.Printf("exposePort %s\n", name) err := os.Mkdir("/port/"+name, 0) if err != nil { From 610dac2fb70571b4f614ead7582e9887bf0e6af5 Mon Sep 17 00:00:00 2001 From: David Scott Date: Fri, 22 Apr 2016 15:17:56 +0100 Subject: [PATCH 7/8] proxy: fix the marshalling of the UDP frames - the initial length field should be the total length of the whole frame including the variable length field and including the length field - when unmarshalling, return the number of bytes of payload actually unmarshalled and not the size of the unmarshal buffer Signed-off-by: David Scott --- .../proxy/libproxy/udp_encapsulation.go | 45 ++++++++++++------- 1 file changed, 28 insertions(+), 17 deletions(-) diff --git a/alpine/packages/proxy/libproxy/udp_encapsulation.go b/alpine/packages/proxy/libproxy/udp_encapsulation.go index df837a896..34f8632e3 100644 --- a/alpine/packages/proxy/libproxy/udp_encapsulation.go +++ b/alpine/packages/proxy/libproxy/udp_encapsulation.go @@ -47,11 +47,12 @@ func (u *udpEncapsulator) ReadFromUDP(b []byte) (int, *net.UDPAddr, error) { u.r.Lock() defer u.r.Unlock() datagram := &udpDatagram{payload: b} - err = datagram.Unmarshal(conn) + length, err := datagram.Unmarshal(conn) if err != nil { return 0, nil, err } - return len(datagram.payload), &net.UDPAddr{IP: *datagram.IP, Port: int(datagram.Port), Zone: datagram.Zone}, nil + udpAddr := net.UDPAddr{IP: *datagram.IP, Port: int(datagram.Port), Zone: datagram.Zone} + return length, &udpAddr, nil } func (u *udpEncapsulator) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) { @@ -76,10 +77,14 @@ func (u *udpEncapsulator) Close() error { func NewUDPListener(listener net.Listener) udpListener { var m sync.Mutex; + var r sync.Mutex; + var w sync.Mutex; return &udpEncapsulator{ conn: nil, listener: listener, m: &m, + r: &r, + w: &w, } } @@ -98,24 +103,30 @@ func (u *udpDatagram) Marshal(conn net.Conn) error { if err := binary.Write(&header, binary.LittleEndian, &length); err != nil { return err } - if err := binary.Write(&header, binary.LittleEndian, &u.IP); err != nil { + + if err := binary.Write(&header, binary.LittleEndian, u.IP); err != nil { return err } + if err := binary.Write(&header, binary.LittleEndian, &u.Port); err != nil { return err } + length = uint16(len(u.Zone)) if err := binary.Write(&header, binary.LittleEndian, &length); err != nil { return err } - if err := binary.Write(&header, binary.LittleEndian, &u.Zone); err != nil { + + if err := binary.Write(&header, binary.LittleEndian, []byte(u.Zone)); err != nil { return nil } + length = uint16(len(u.payload)) if err := binary.Write(&header, binary.LittleEndian, &length); err != nil { return nil } - length = uint16(header.Len() + len(u.payload)) + + length = uint16(2 + header.Len() + len(u.payload)) if err := binary.Write(conn, binary.LittleEndian, &length); err != nil { return nil } @@ -131,38 +142,38 @@ func (u *udpDatagram) Marshal(conn net.Conn) error { return nil } -func (u *udpDatagram) Unmarshal(conn net.Conn) error { +func (u *udpDatagram) Unmarshal(conn net.Conn) (int, error) { var length uint16 // frame length if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { - return err + return 0, err } if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { - return err + return 0, err } var IP net.IP IP = make([]byte, length) if err := binary.Read(conn, binary.LittleEndian, &IP); err != nil { - return err + return 0, err } u.IP = &IP if err := binary.Read(conn, binary.LittleEndian, &u.Port); err != nil { - return err + return 0, err } if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { - return err + return 0, err } Zone := make([]byte, length) if err := binary.Read(conn, binary.LittleEndian, &Zone); err != nil { - return err + return 0, err } u.Zone = string(Zone) if err := binary.Read(conn, binary.LittleEndian, &length); err != nil { - return err + return 0, err } - u.payload = make([]byte, length) - if err := binary.Read(conn, binary.LittleEndian, &u.payload); err != nil { - return err + _, err := io.ReadFull(conn, u.payload[0:length]) + if err != nil { + return 0, err } - return nil + return int(length), nil } From 5dee7f7bfde92f842c903bdae0c7b87b742c1b33 Mon Sep 17 00:00:00 2001 From: David Scott Date: Fri, 22 Apr 2016 16:10:36 +0100 Subject: [PATCH 8/8] proxy: fix `gofmt` violations Signed-off-by: David Scott --- alpine/packages/proxy/libproxy/proxy.go | 4 +--- .../packages/proxy/libproxy/udp_encapsulation.go | 16 ++++++++-------- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/alpine/packages/proxy/libproxy/proxy.go b/alpine/packages/proxy/libproxy/proxy.go index 457b1ba6e..b7b89f27d 100644 --- a/alpine/packages/proxy/libproxy/proxy.go +++ b/alpine/packages/proxy/libproxy/proxy.go @@ -4,8 +4,8 @@ package libproxy import ( "fmt" - "net" "github.com/djs55/vsock" + "net" ) // Proxy defines the behavior of a proxy. It forwards traffic back and forth @@ -25,8 +25,6 @@ type Proxy interface { BackendAddr() net.Addr } - - // NewProxy creates a Proxy according to the specified frontendAddr and backendAddr. func NewProxy(frontendAddr *vsock.VsockAddr, backendAddr net.Addr) (Proxy, error) { switch backendAddr.(type) { diff --git a/alpine/packages/proxy/libproxy/udp_encapsulation.go b/alpine/packages/proxy/libproxy/udp_encapsulation.go index 34f8632e3..0f5d421de 100644 --- a/alpine/packages/proxy/libproxy/udp_encapsulation.go +++ b/alpine/packages/proxy/libproxy/udp_encapsulation.go @@ -11,7 +11,7 @@ import ( ) type udpListener interface { - ReadFromUDP(b []byte) (int, *net.UDPAddr, error) + ReadFromUDP(b []byte) (int, *net.UDPAddr, error) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) Close() error } @@ -76,15 +76,15 @@ func (u *udpEncapsulator) Close() error { } func NewUDPListener(listener net.Listener) udpListener { - var m sync.Mutex; - var r sync.Mutex; - var w sync.Mutex; + var m sync.Mutex + var r sync.Mutex + var w sync.Mutex return &udpEncapsulator{ - conn: nil, + conn: nil, listener: listener, - m: &m, - r: &r, - w: &w, + m: &m, + r: &r, + w: &w, } }