Evan Reichard
2e73689762
All checks were successful
continuous-integration/drone/push Build is passing
105 lines
2.1 KiB
Go
105 lines
2.1 KiB
Go
package tunnel
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httputil"
|
|
"net/url"
|
|
"sync"
|
|
)
|
|
|
|
func HTTPConnectionBuilder(targetURL *url.URL) (ConnBuilder, error) {
|
|
multiConnListener := newMultiConnListener()
|
|
|
|
// Create Reverse Proxy
|
|
proxy := &httputil.ReverseProxy{
|
|
Director: func(req *http.Request) {
|
|
req.Host = targetURL.Host
|
|
req.URL.Host = targetURL.Host
|
|
req.URL.Scheme = targetURL.Scheme
|
|
},
|
|
ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, fmt.Sprintf("Proxy error: %v", err), http.StatusBadGateway)
|
|
},
|
|
}
|
|
|
|
// Start HTTP Proxy
|
|
go func() {
|
|
defer multiConnListener.Close()
|
|
_ = http.Serve(multiConnListener, proxy)
|
|
}()
|
|
|
|
// Return Connection Builder
|
|
return func() (conn io.ReadWriteCloser, err error) {
|
|
clientConn, serverConn := net.Pipe()
|
|
|
|
if err := multiConnListener.addConn(serverConn); err != nil {
|
|
_ = clientConn.Close()
|
|
_ = serverConn.Close()
|
|
return nil, err
|
|
}
|
|
|
|
return clientConn, nil
|
|
}, nil
|
|
}
|
|
|
|
type multiConnListener struct {
|
|
connCh chan net.Conn
|
|
closed chan struct{}
|
|
once sync.Once
|
|
}
|
|
|
|
func newMultiConnListener() *multiConnListener {
|
|
return &multiConnListener{
|
|
connCh: make(chan net.Conn, 100),
|
|
closed: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
func (l *multiConnListener) Accept() (net.Conn, error) {
|
|
select {
|
|
case conn := <-l.connCh:
|
|
if conn == nil {
|
|
return nil, fmt.Errorf("listener closed")
|
|
}
|
|
return conn, nil
|
|
case <-l.closed:
|
|
return nil, fmt.Errorf("listener closed")
|
|
}
|
|
}
|
|
|
|
func (l *multiConnListener) Close() error {
|
|
l.once.Do(func() {
|
|
close(l.closed)
|
|
// Drain any remaining connections
|
|
go func() {
|
|
for conn := range l.connCh {
|
|
if conn != nil {
|
|
conn.Close()
|
|
}
|
|
}
|
|
}()
|
|
close(l.connCh)
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func (l *multiConnListener) Addr() net.Addr {
|
|
return &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0}
|
|
}
|
|
|
|
func (l *multiConnListener) addConn(conn net.Conn) error {
|
|
select {
|
|
case l.connCh <- conn:
|
|
return nil
|
|
case <-l.closed:
|
|
conn.Close()
|
|
return fmt.Errorf("listener is closed")
|
|
default:
|
|
conn.Close()
|
|
return fmt.Errorf("connection queue full")
|
|
}
|
|
}
|