Move code to pkg

tcp/router.go

@@ -1,216 +0,0 @@
-package tcp
-
-import (
-	"bufio"
-	"bytes"
-	"crypto/tls"
-	"io"
-	"net"
-	"net/http"
-	"strings"
-
-	"github.com/containous/traefik/log"
-)
-
-// Router is a TCP router
-type Router struct {
-	routingTable   map[string]Handler
-	httpForwarder  Handler
-	httpsForwarder Handler
-	httpHandler    http.Handler
-	httpsHandler   http.Handler
-	httpsTLSConfig *tls.Config
-	catchAllNoTLS  Handler
-}
-
-// ServeTCP forwards the connection to the right TCP/HTTP handler
-func (r *Router) ServeTCP(conn net.Conn) {
-	// FIXME -- Check if ProxyProtocol changes the first bytes of the request
-
-	br := bufio.NewReader(conn)
-	serverName, tls, peeked := clientHelloServerName(br)
-	if !tls {
-		switch {
-		case r.catchAllNoTLS != nil:
-			r.catchAllNoTLS.ServeTCP(r.GetConn(conn, peeked))
-		case r.httpForwarder != nil:
-			r.httpForwarder.ServeTCP(r.GetConn(conn, peeked))
-		default:
-			conn.Close()
-		}
-		return
-	}
-
-	// FIXME Optimize and test the routing table before helloServerName
-	serverName = strings.ToLower(serverName)
-	if r.routingTable != nil && serverName != "" {
-		if target, ok := r.routingTable[serverName]; ok {
-			target.ServeTCP(r.GetConn(conn, peeked))
-			return
-		}
-	}
-
-	// FIXME Needs tests
-	if target, ok := r.routingTable["*"]; ok {
-		target.ServeTCP(r.GetConn(conn, peeked))
-		return
-	}
-
-	if r.httpsForwarder != nil {
-		r.httpsForwarder.ServeTCP(r.GetConn(conn, peeked))
-	} else {
-		conn.Close()
-	}
-}
-
-// AddRoute defines a handler for a given sniHost (* is the only valid option)
-func (r *Router) AddRoute(sniHost string, target Handler) {
-	if r.routingTable == nil {
-		r.routingTable = map[string]Handler{}
-	}
-	r.routingTable[strings.ToLower(sniHost)] = target
-}
-
-// AddRouteTLS defines a handler for a given sniHost and sets the matching tlsConfig
-func (r *Router) AddRouteTLS(sniHost string, target Handler, config *tls.Config) {
-	r.AddRoute(sniHost, &TLSHandler{
-		Next:   target,
-		Config: config,
-	})
-}
-
-// AddCatchAllNoTLS defines the fallback tcp handler
-func (r *Router) AddCatchAllNoTLS(handler Handler) {
-	r.catchAllNoTLS = handler
-}
-
-// GetConn creates a connection proxy with a peeked string
-func (r *Router) GetConn(conn net.Conn, peeked string) net.Conn {
-	// FIXME should it really be on Router ?
-	conn = &Conn{
-		Peeked: []byte(peeked),
-		Conn:   conn,
-	}
-	return conn
-}
-
-// GetHTTPHandler gets the attached http handler
-func (r *Router) GetHTTPHandler() http.Handler {
-	return r.httpHandler
-}
-
-// GetHTTPSHandler gets the attached https handler
-func (r *Router) GetHTTPSHandler() http.Handler {
-	return r.httpsHandler
-}
-
-// HTTPForwarder sets the tcp handler that will forward the connections to an http handler
-func (r *Router) HTTPForwarder(handler Handler) {
-	r.httpForwarder = handler
-}
-
-// HTTPSForwarder sets the tcp handler that will forward the TLS connections to an http handler
-func (r *Router) HTTPSForwarder(handler Handler) {
-	r.httpsForwarder = &TLSHandler{
-		Next:   handler,
-		Config: r.httpsTLSConfig,
-	}
-}
-
-// HTTPHandler attaches http handlers on the router
-func (r *Router) HTTPHandler(handler http.Handler) {
-	r.httpHandler = handler
-}
-
-// HTTPSHandler attaches https handlers on the router
-func (r *Router) HTTPSHandler(handler http.Handler, config *tls.Config) {
-	r.httpsHandler = handler
-	r.httpsTLSConfig = config
-}
-
-// Conn is a connection proxy that handles Peeked bytes
-type Conn struct {
-	// Peeked are the bytes that have been read from Conn for the
-	// purposes of route matching, but have not yet been consumed
-	// by Read calls. It set to nil by Read when fully consumed.
-	Peeked []byte
-
-	// Conn is the underlying connection.
-	// It can be type asserted against *net.TCPConn or other types
-	// as needed. It should not be read from directly unless
-	// Peeked is nil.
-	net.Conn
-}
-
-// Read reads bytes from the connection (using the buffer prior to actually reading)
-func (c *Conn) Read(p []byte) (n int, err error) {
-	if len(c.Peeked) > 0 {
-		n = copy(p, c.Peeked)
-		c.Peeked = c.Peeked[n:]
-		if len(c.Peeked) == 0 {
-			c.Peeked = nil
-		}
-		return n, nil
-	}
-	return c.Conn.Read(p)
-}
-
-// clientHelloServerName returns the SNI server name inside the TLS ClientHello,
-// without consuming any bytes from br.
-// On any error, the empty string is returned.
-func clientHelloServerName(br *bufio.Reader) (string, bool, string) {
-	hdr, err := br.Peek(1)
-	if err != nil {
-		log.Errorf("Error while Peeking first byte: %s", err)
-		return "", false, ""
-	}
-	const recordTypeHandshake = 0x16
-	if hdr[0] != recordTypeHandshake {
-		// log.Errorf("Error not tls")
-		return "", false, getPeeked(br) // Not TLS.
-	}
-
-	const recordHeaderLen = 5
-	hdr, err = br.Peek(recordHeaderLen)
-	if err != nil {
-		log.Errorf("Error while Peeking hello: %s", err)
-		return "", false, getPeeked(br)
-	}
-	recLen := int(hdr[3])<<8 | int(hdr[4]) // ignoring version in hdr[1:3]
-	helloBytes, err := br.Peek(recordHeaderLen + recLen)
-	if err != nil {
-		log.Errorf("Error while Hello: %s", err)
-		return "", true, getPeeked(br)
-	}
-	sni := ""
-	server := tls.Server(sniSniffConn{r: bytes.NewReader(helloBytes)}, &tls.Config{
-		GetConfigForClient: func(hello *tls.ClientHelloInfo) (*tls.Config, error) {
-			sni = hello.ServerName
-			return nil, nil
-		},
-	})
-	_ = server.Handshake()
-	return sni, true, getPeeked(br)
-}
-
-func getPeeked(br *bufio.Reader) string {
-	peeked, err := br.Peek(br.Buffered())
-	if err != nil {
-		log.Errorf("Could not get anything: %s", err)
-		return ""
-	}
-	return string(peeked)
-}
-
-// sniSniffConn is a net.Conn that reads from r, fails on Writes,
-// and crashes otherwise.
-type sniSniffConn struct {
-	r        io.Reader
-	net.Conn // nil; crash on any unexpected use
-}
-
-// Read reads from the underlying reader
-func (c sniSniffConn) Read(p []byte) (int, error) { return c.r.Read(p) }
-
-// Write crashes all the time
-func (sniSniffConn) Write(p []byte) (int, error) { return 0, io.EOF }