Release 2018.10.4

AUTH-1188: add failure page for non-upgrade request (more styling to come)

AUTH-1188: hide ssh command for now

AUTH-1188: fixes for login page

AUTH-1229: printing ssh config instructions

AUTH-1249 and AUTH-1250

AUTH-1255, AUTH-1256, AUTH-1257, AUTH-1258

hide commands for release

Makefile

@@ -23,10 +23,6 @@ endif
 .PHONY: all
 all: cloudflared test
 
-.PHONY: clean
-clean:
-	go clean
-
 .PHONY: cloudflared
 cloudflared:
 	go build -v $(VERSION_FLAGS) $(IMPORT_PATH)/cmd/cloudflared

RELEASE_NOTES

@@ -1,21 +1,14 @@
-2018.11.0
-- 2018-10-31 AUTH-1282: Fixed an issue where we were receiving as opposed sending on the channel.
-- 2018-11-06 TUN-1179: Fix log message in cmd/cloudflared/transfer.Run
-- 2018-11-13 AUTH-1308: get jwt even when you are already logged in
-- 2018-11-12 TUN-1190: check URL parse error when starting SSH proxy server
-- 2018-11-15 AUTH-1320: Fixed request issue and unhide the ssh command
-
-2018.10.5
-- 2018-10-18 TUN-968: Flow control for large requests/responses
-- 2018-10-26 TUN-1158: Windows: use process arguments rather than trivial service arguments
-- 2018-10-20 #30: Fix the Content-Length header for HTTP2->HTTP1
-- 2018-10-29 TUN-1160: pass Host header during origin url validation
+2018.10.4
+- 2018-09-21 AUTH-1070: added SSH/protocol forwarding
+- 2018-10-19 AUTH-1235: fixed packaging of deb dev file
+- 2018-10-19 TUN-1097: Host missing from WebSocket request
+- 2018-10-25 Release 2018.10.4
+- 2018-10-19 AUTH-1188: UX feedback, move warnings to debug
 
 2018.10.4
 - 2018-09-21 AUTH-1070: added SSH/protocol forwarding
 - 2018-10-19 AUTH-1235: fixed packaging of deb dev file
 - 2018-10-19 TUN-1097: Host missing from WebSocket request
-- 2018-10-19 AUTH-1188: UX Review and Changes for CLI SSH Access
 
 2018.10.3
 - 2018-10-08 TUN-1099: Bring back changes in 2018.10.1

carrier/carrier.go

@@ -89,7 +89,6 @@ func createWebsocketStream(originURL string) (*websocket.Conn, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	wsConn, resp, err := websocket.ClientConnect(req, nil)
 	if err != nil && resp != nil && resp.StatusCode > 300 {
 		location, err := resp.Location()
@@ -126,14 +125,7 @@ func buildAccessRequest(originURL string) (*http.Request, error) {
 	if err != nil {
 		return nil, err
 	}
+	req.Header.Set("cf-access-token", token)
 
-	// We need to create a new request as FetchToken will modify req (boo mutable)
-	// as it has to follow redirect on the API and such, so here we init a new one
-	originRequest, err := http.NewRequest(http.MethodGet, originURL, nil)
-	if err != nil {
-		return nil, err
-	}
-	originRequest.Header.Set("cf-access-token", token)
-
-	return originRequest, nil
+	return req, nil
 }

carrier/carrier_test.go

@@ -66,16 +66,11 @@ func TestStartServer(t *testing.T) {
 	defer ts.Close()
 
 	go func() {
-		err := StartServer(logger, listenerAddress, "http://"+ts.Listener.Addr().String(), shutdownC)
-		if err != nil {
-			t.Fatalf("Error starting server: %v", err)
-		}
+		StartServer(logger, listenerAddress, "http://"+ts.Listener.Addr().String(), shutdownC)
 	}()
 
 	conn, err := net.Dial("tcp", listenerAddress)
-	if err != nil {
-		t.Fatalf("Error connecting to server: %v", err)
-	}
+	assert.NoError(t, err)
 	conn.Write([]byte(message))
 
 	readBuffer := make([]byte, len(message))

cmd/cloudflared/access/cmd.go

@@ -89,12 +89,14 @@ func Commands() []*cli.Command {
 					Usage:       "",
 					ArgsUsage:   "",
 					Description: `The ssh subcommand sends data over a proxy to the Cloudflare edge.`,
+					Hidden:      true,
 					Flags: []cli.Flag{
 						&cli.StringFlag{
 							Name: "hostname",
 						},
 						&cli.StringFlag{
-							Name: "url",
+							Name:   "url",
+							Hidden: true,
 						},
 					},
 				},
@@ -103,6 +105,7 @@ func Commands() []*cli.Command {
 					Action:      sshConfig,
 					Usage:       "ssh-config",
 					Description: `Prints an example configuration ~/.ssh/config`,
+					Hidden:      true,
 				},
 			},
 		},

cmd/cloudflared/transfer/transfer.go

@@ -43,7 +43,7 @@ func Run(transferURL *url.URL, resourceName, key, value, path string, shouldEncr
 
 	err = shell.OpenBrowser(requestURL)
 	if err != nil {
-		fmt.Fprintf(os.Stdout, "Please open the following URL and log in with your Cloudflare account:\n\n%s\n\nLeave cloudflared running to download the %s automatically.\n", requestURL, resourceName)
+		fmt.Fprintf(os.Stdout, "Please open the following URL and log in with your Cloudflare account:\n\n%s\n\nLeave cloudflared running to download the %s automatically.\n", resourceName, requestURL)
 	} else {
 		fmt.Fprintf(os.Stdout, "A browser window should have opened at the following URL:\n\n%s\n\nIf the browser failed to open, open it yourself and visit the URL above.\n", requestURL)
 	}
@@ -83,19 +83,21 @@ func Run(transferURL *url.URL, resourceName, key, value, path string, shouldEncr
 
 // BuildRequestURL creates a request suitable for a resource transfer.
 // it will return a constructed url based off the base url and query key/value provided.
-// cli will build a url for cli transfer request.
-func buildRequestURL(baseURL *url.URL, key, value string, cli bool) (string, error) {
+// follow will follow redirects.
+func buildRequestURL(baseURL *url.URL, key, value string, follow bool) (string, error) {
 	q := baseURL.Query()
 	q.Set(key, value)
 	baseURL.RawQuery = q.Encode()
-	if !cli {
+	if !follow {
 		return baseURL.String(), nil
 	}
 
-	q.Set("redirect_url", baseURL.String()) // we add the token as a query param on both the redirect_url
-	baseURL.RawQuery = q.Encode()           // and this actual baseURL.
-	baseURL.Path = "cdn-cgi/access/cli"
-	return baseURL.String(), nil
+	response, err := http.Get(baseURL.String())
+	if err != nil {
+		return "", err
+	}
+	return response.Request.URL.String(), nil
+
 }
 
 // transferRequest downloads the requested resource from the request URL

cmd/cloudflared/tunnel/cmd.go

@@ -311,7 +311,7 @@ func StartServer(c *cli.Context, version string, shutdownC, graceShutdownC chan
 		c.Set("url", "https://"+helloListener.Addr().String())
 	}
 
-	if uri, err := url.Parse(c.String("url")); err == nil && uri.Scheme == "ssh" {
+	if uri, _ := url.Parse(c.String("url")); uri.Scheme == "ssh" {
 		host := uri.Host
 		if uri.Port() == "" { // default to 22
 			host = uri.Hostname() + ":22"

cmd/cloudflared/tunnel/configuration.go

@@ -192,7 +192,7 @@ func prepareTunnelConfig(c *cli.Context, buildInfo *origin.BuildInfo, version st
 		httpTransport.TLSClientConfig.ServerName = c.String("origin-server-name")
 	}
 
-	err = validation.ValidateHTTPService(originURL, hostname, httpTransport)
+	err = validation.ValidateHTTPService(originURL, httpTransport)
 	if err != nil {
 		logger.WithError(err).Error("unable to connect to the origin")
 		return nil, errors.Wrap(err, "unable to connect to the origin")

cmd/cloudflared/windows_service.go

@@ -87,20 +87,7 @@ type windowsService struct {
 }
 
 // called by the package code at the start of the service
-func (s *windowsService) Execute(serviceArgs []string, r <-chan svc.ChangeRequest, statusChan chan<- svc.Status) (ssec bool, errno uint32) {
-	// the arguments passed here are only meaningful if they were manually
-	// specified by the user, e.g. using the Services console or `sc start`.
-	// https://docs.microsoft.com/en-us/windows/desktop/services/service-entry-point
-	// https://stackoverflow.com/a/6235139
-	var args []string
-	if len(serviceArgs) > 1 {
-		args = serviceArgs
-	} else {
-		// fall back to the arguments from ImagePath (or, as sc calls it, binPath)
-		args = os.Args
-	}
-	s.elog.Info(1, fmt.Sprintf("%s service arguments: %v", windowsServiceName, args))
-
+func (s *windowsService) Execute(args []string, r <-chan svc.ChangeRequest, statusChan chan<- svc.Status) (ssec bool, errno uint32) {
 	const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown
 	statusChan <- svc.Status{State: svc.StartPending}
 	errC := make(chan error)

h2mux/h2mux.go

@@ -15,12 +15,11 @@ import (
 )
 
 const (
-	defaultFrameSize         uint32        = 1 << 14       // Minimum frame size in http2 spec
-	defaultWindowSize        uint32        = (1 << 16) - 1 // Minimum window size in http2 spec
-	maxWindowSize            uint32        = (1 << 31) - 1 // 2^31-1 = 2147483647, max window size in http2 spec
-	defaultTimeout           time.Duration = 5 * time.Second
-	defaultRetries           uint64        = 5
-	defaultWriteBufferMaxLen int           = 1024 * 1024 * 512 // 500mb
+	defaultFrameSize  uint32        = 1 << 14 // Minimum frame size in http2 spec
+	defaultWindowSize uint32        = 65535
+	maxWindowSize     uint32        = (1 << 31) - 1 // 2^31-1 = 2147483647, max window size specified in http2 spec
+	defaultTimeout    time.Duration = 5 * time.Second
+	defaultRetries    uint64        = 5
 
 	SettingMuxerMagic http2.SettingID = 0x42db
 	MuxerMagicOrigin  uint32          = 0xa2e43c8b
@@ -50,12 +49,6 @@ type MuxerConfig struct {
 	// Logger to use
 	Logger             *log.Entry
 	CompressionQuality CompressionSetting
-	// Initial size for HTTP2 flow control windows
-	DefaultWindowSize uint32
-	// Largest allowable size for HTTP2 flow control windows
-	MaxWindowSize uint32
-	// Largest allowable capacity for the buffer of data to be sent
-	StreamWriteBufferMaxLen int
 }
 
 type Muxer struct {
@@ -105,15 +98,6 @@ func Handshake(
 	if config.Timeout == 0 {
 		config.Timeout = defaultTimeout
 	}
-	if config.DefaultWindowSize == 0 {
-		config.DefaultWindowSize = defaultWindowSize
-	}
-	if config.MaxWindowSize == 0 {
-		config.MaxWindowSize = maxWindowSize
-	}
-	if config.StreamWriteBufferMaxLen == 0 {
-		config.StreamWriteBufferMaxLen = defaultWriteBufferMaxLen
-	}
 	// Initialise connection state fields
 	m := &Muxer{
 		f:             http2.NewFramer(w, r), // A framer that writes to w and reads from r
@@ -195,9 +179,8 @@ func Handshake(
 		abortChan:               m.abortChan,
 		pingTimestamp:           pingTimestamp,
 		connActive:              connActive,
-		initialStreamWindow:     m.config.DefaultWindowSize,
-		streamWindowMax:         m.config.MaxWindowSize,
-		streamWriteBufferMaxLen: m.config.StreamWriteBufferMaxLen,
+		initialStreamWindow:     defaultWindowSize,
+		streamWindowMax:         maxWindowSize,
 		r:                       m.r,
 		updateRTTChan:           updateRTTChan,
 		updateReceiveWindowChan: updateReceiveWindowChan,
@@ -392,12 +375,10 @@ func (m *Muxer) OpenStream(headers []Header, body io.Reader) (*MuxedStream, erro
 		responseHeadersReceived: make(chan struct{}),
 		readBuffer:              NewSharedBuffer(),
 		writeBuffer:             &bytes.Buffer{},
-		writeBufferMaxLen:       m.config.StreamWriteBufferMaxLen,
-		writeBufferHasSpace:     make(chan struct{}, 1),
-		receiveWindow:           m.config.DefaultWindowSize,
-		receiveWindowCurrentMax: m.config.DefaultWindowSize,
-		receiveWindowMax:        m.config.MaxWindowSize,
-		sendWindow:              m.config.DefaultWindowSize,
+		receiveWindow:           defaultWindowSize,
+		receiveWindowCurrentMax: defaultWindowSize, // Initial window size limit. exponentially increase it when receiveWindow is exhausted
+		receiveWindowMax:        maxWindowSize,
+		sendWindow:              defaultWindowSize,
 		readyList:               m.readyList,
 		writeHeaders:            headers,
 		dictionaries:            m.muxReader.dictionaries,

h2mux/h2mux_test.go

@@ -39,26 +39,20 @@ func NewDefaultMuxerPair() *DefaultMuxerPair {
 	origin, edge := net.Pipe()
 	return &DefaultMuxerPair{
 		OriginMuxConfig: MuxerConfig{
-			Timeout:                 time.Second,
-			IsClient:                true,
-			Name:                    "origin",
-			Logger:                  log.NewEntry(log.New()),
-			DefaultWindowSize:       (1 << 8) - 1,
-			MaxWindowSize:           (1 << 15) - 1,
-			StreamWriteBufferMaxLen: 1024,
+			Timeout: time.Second,
+			IsClient: true,
+			Name: "origin",
+			Logger: log.NewEntry(log.New()),
 		},
-		OriginConn: origin,
-		EdgeMuxConfig: MuxerConfig{
-			Timeout:                 time.Second,
-			IsClient:                false,
-			Name:                    "edge",
-			Logger:                  log.NewEntry(log.New()),
-			DefaultWindowSize:       (1 << 8) - 1,
-			MaxWindowSize:           (1 << 15) - 1,
-			StreamWriteBufferMaxLen: 1024,
+		OriginConn:      origin,
+		EdgeMuxConfig:   MuxerConfig{
+			Timeout: time.Second,
+			IsClient: false,
+			Name: "edge",
+			Logger: log.NewEntry(log.New()),
 		},
-		EdgeConn: edge,
-		doneC:    make(chan struct{}),
+		EdgeConn:        edge,
+		doneC:           make(chan struct{}),
 	}
 }
 
@@ -66,22 +60,22 @@ func NewCompressedMuxerPair(quality CompressionSetting) *DefaultMuxerPair {
 	origin, edge := net.Pipe()
 	return &DefaultMuxerPair{
 		OriginMuxConfig: MuxerConfig{
-			Timeout:            time.Second,
-			IsClient:           true,
-			Name:               "origin",
+			Timeout: time.Second,
+			IsClient: true,
+			Name: "origin",
 			CompressionQuality: quality,
-			Logger:             log.NewEntry(log.New()),
+			Logger: log.NewEntry(log.New()),
 		},
-		OriginConn: origin,
-		EdgeMuxConfig: MuxerConfig{
-			Timeout:            time.Second,
-			IsClient:           false,
-			Name:               "edge",
+		OriginConn:      origin,
+		EdgeMuxConfig:   MuxerConfig{
+			Timeout: time.Second,
+			IsClient: false,
+			Name: "edge",
 			CompressionQuality: quality,
-			Logger:             log.NewEntry(log.New()),
+			Logger: log.NewEntry(log.New()),
 		},
-		EdgeConn: edge,
-		doneC:    make(chan struct{}),
+		EdgeConn:        edge,
+		doneC:           make(chan struct{}),
 	}
 }
 
@@ -236,6 +230,7 @@ func TestSingleStream(t *testing.T) {
 func TestSingleStreamLargeResponseBody(t *testing.T) {
 	muxPair := NewDefaultMuxerPair()
 	bodySize := 1 << 24
+	streamReady := make(chan struct{})
 	muxPair.OriginMuxConfig.Handler = MuxedStreamFunc(func(stream *MuxedStream) error {
 		if len(stream.Headers) != 1 {
 			t.Fatalf("expected %d headers, got %d", 1, len(stream.Headers))
@@ -262,6 +257,8 @@ func TestSingleStreamLargeResponseBody(t *testing.T) {
 		if n != len(payload) {
 			t.Fatalf("origin short write: %d/%d bytes", n, len(payload))
 		}
+		t.Log("Payload written; signaling that the stream is ready")
+		streamReady <- struct{}{}
 
 		return nil
 	})
@@ -285,6 +282,9 @@ func TestSingleStreamLargeResponseBody(t *testing.T) {
 	}
 	responseBody := make([]byte, bodySize)
 
+	<-streamReady
+	t.Log("Received stream ready signal; resuming the test")
+
 	n, err := io.ReadFull(stream, responseBody)
 	if err != nil {
 		t.Fatalf("error from (*MuxedStream).Read: %s", err)
@@ -367,13 +367,14 @@ func TestMultipleStreams(t *testing.T) {
 		log.Error(err)
 	}
 	if testFail {
-		t.Fatalf("TestMultipleStreams failed")
+		t.Fatalf("TestMultipleStreamsFlowControl failed")
 	}
 }
 
 func TestMultipleStreamsFlowControl(t *testing.T) {
 	maxStreams := 32
 	errorsC := make(chan error, maxStreams)
+	streamReady := make(chan struct{})
 	responseSizes := make([]int32, maxStreams)
 	for i := 0; i < maxStreams; i++ {
 		responseSizes[i] = rand.Int31n(int32(defaultWindowSize << 4))
@@ -397,6 +398,7 @@ func TestMultipleStreamsFlowControl(t *testing.T) {
 			payload[i] = byte(i % 256)
 		}
 		n, err := stream.Write(payload)
+		streamReady <- struct{}{}
 		if err != nil {
 			t.Fatalf("origin write error: %s", err)
 		}
@@ -433,6 +435,7 @@ func TestMultipleStreamsFlowControl(t *testing.T) {
 				return
 			}
 
+			<-streamReady
 			responseBody := make([]byte, responseSizes[(stream.streamID-2)/2])
 			n, err := io.ReadFull(stream, responseBody)
 			if err != nil {
@@ -779,11 +782,9 @@ func TestMultipleStreamsWithDictionaries(t *testing.T) {
 		}
 
 		wg.Add(len(paths))
-		errorsC := make(chan error, len(paths))
 
 		for i, s := range paths {
 			go func(i int, path string) {
-				defer wg.Done()
 				stream, err := muxPair.EdgeMux.OpenStream(
 					[]Header{
 						{Name: ":method", Value: "GET"},
@@ -804,30 +805,22 @@ func TestMultipleStreamsWithDictionaries(t *testing.T) {
 				responseBody := make([]byte, len(expectBody)*2)
 				n, err := stream.Read(responseBody)
 				if err != nil {
-					errorsC <- fmt.Errorf("stream %d error from (*MuxedStream).Read: %s", stream.streamID, err)
-					return
+					log.Printf("error from (*MuxedStream).Read: %s", err)
+					t.Fatalf("error from (*MuxedStream).Read: %s", err)
 				}
 				if n != len(expectBody) {
-					errorsC <- fmt.Errorf("stream %d expected response body to have %d bytes, got %d", stream.streamID, len(expectBody), n)
-					return
+					log.Printf("expected response body to have %d bytes, got %d", len(expectBody), n)
+					t.Fatalf("expected response body to have %d bytes, got %d", len(expectBody), n)
 				}
 				if string(responseBody[:n]) != expectBody {
-					errorsC <- fmt.Errorf("stream %d expected response body %s, got %s", stream.streamID, expectBody, responseBody[:n])
-					return
+					log.Printf("expected response body %s, got %s", expectBody, responseBody[:n])
+					t.Fatalf("expected response body %s, got %s", expectBody, responseBody[:n])
 				}
+				wg.Done()
 			}(i, s)
+			time.Sleep(1 * time.Millisecond)
 		}
-
 		wg.Wait()
-		close(errorsC)
-		testFail := false
-		for err := range errorsC {
-			testFail = true
-			log.Error(err)
-		}
-		if testFail {
-			t.Fatalf("TestMultipleStreams failed")
-		}
 
 		if q > CompressionNone && muxPair.OriginMux.muxMetricsUpdater.compBytesBefore.Value() <= 10*muxPair.OriginMux.muxMetricsUpdater.compBytesAfter.Value() {
 			t.Fatalf("Cross-stream compression is expected to give a better compression ratio")

h2mux/muxedstream.go

@@ -17,51 +17,32 @@ type ReadWriteClosedCloser interface {
 	Closed() bool
 }
 
-// MuxedStream is logically an HTTP/2 stream, with an additional buffer for outgoing data.
 type MuxedStream struct {
+	Headers []Header
+
 	streamID uint32
 
-	// The "Receive" end of the stream
-	readBufferLock sync.RWMutex
-	readBuffer     ReadWriteClosedCloser
-	// This is the amount of bytes that are in our receive window
-	// (how much data we can receive into this stream).
-	receiveWindow uint32
-	// current receive window size limit. Exponentially increase it when it's exhausted
-	receiveWindowCurrentMax uint32
-	// hard limit set in http2 spec. 2^31-1
-	receiveWindowMax uint32
-	// The desired size increment for receiveWindow.
-	// If this is nonzero, a WINDOW_UPDATE frame needs to be sent.
-	windowUpdate uint32
-	// The headers that were most recently received.
-	// Particularly:
-	//     * for an eyeball-initiated stream (as passed to TunnelHandler::ServeStream),
-	//       these are the request headers
-	//     * for a cloudflared-initiated stream (as created by Register/UnregisterTunnel),
-	//       these are the response headers.
-	// They are useful in both of these contexts; hence `Headers` is public.
-	Headers []Header
-	// For use in the context of a cloudflared-initiated stream.
 	responseHeadersReceived chan struct{}
 
-	// The "Send" end of the stream
-	writeLock   sync.Mutex
+	readBuffer    ReadWriteClosedCloser
+	receiveWindow uint32
+	// current window size limit. Exponentially increase it when it's exhausted
+	receiveWindowCurrentMax uint32
+	// limit set in http2 spec. 2^31-1
+	receiveWindowMax uint32
+
+	// nonzero if a WINDOW_UPDATE frame for a stream needs to be sent
+	windowUpdate uint32
+
+	writeLock sync.Mutex
+	// The zero value for Buffer is an empty buffer ready to use.
 	writeBuffer ReadWriteLengther
-	// The maximum capacity that the send buffer should grow to.
-	writeBufferMaxLen int
-	// A channel to be notified when the send buffer is not full.
-	writeBufferHasSpace chan struct{}
-	// This is the amount of bytes that are in the peer's receive window
-	// (how much data we can send from this stream).
+
 	sendWindow uint32
-	// Reference to the muxer's readyList; signal this for stream data to be sent.
-	readyList *ReadyList
-	// The headers that should be sent, and a flag so we only send them once.
+
+	readyList    *ReadyList
 	headersSent  bool
 	writeHeaders []Header
-
-	// EOF-related fields
 	// true if the write end of this stream has been closed
 	writeEOF bool
 	// true if we have sent EOF to the peer
@@ -69,63 +50,40 @@ type MuxedStream struct {
 	// true if the peer sent us an EOF
 	receivedEOF bool
 
-	// Compression-related fields
+	// dictionary that was used to compress the stream
 	receivedUseDict bool
 	method          string
 	contentType     string
 	path            string
 	dictionaries    h2Dictionaries
+	readBufferLock  sync.RWMutex
 }
 
 func (s *MuxedStream) Read(p []byte) (n int, err error) {
-	var readBuffer ReadWriteClosedCloser
 	if s.dictionaries.read != nil {
 		s.readBufferLock.RLock()
-		readBuffer = s.readBuffer
+		b := s.readBuffer
 		s.readBufferLock.RUnlock()
-	} else {
-		readBuffer = s.readBuffer
+		return b.Read(p)
 	}
-	n, err = readBuffer.Read(p)
-	s.replenishReceiveWindow(uint32(n))
-	return
+	return s.readBuffer.Read(p)
 }
 
-// Blocks until len(p) bytes have been written to the buffer
-func (s *MuxedStream) Write(p []byte) (int, error) {
-	// If assignDictToStream returns success, then it will have acquired the
-	// writeLock. Otherwise we must acquire it ourselves.
+func (s *MuxedStream) Write(p []byte) (n int, err error) {
 	ok := assignDictToStream(s, p)
 	if !ok {
 		s.writeLock.Lock()
 	}
 	defer s.writeLock.Unlock()
-
 	if s.writeEOF {
 		return 0, io.EOF
 	}
-	totalWritten := 0
-	for totalWritten < len(p) {
-		// If the buffer is full, block till there is more room.
-		// Use a loop to recheck the buffer size after the lock is reacquired.
-		for s.writeBufferMaxLen <= s.writeBuffer.Len() {
-			s.writeLock.Unlock()
-			<-s.writeBufferHasSpace
-			s.writeLock.Lock()
-		}
-		amountToWrite := len(p) - totalWritten
-		spaceAvailable := s.writeBufferMaxLen - s.writeBuffer.Len()
-		if spaceAvailable < amountToWrite {
-			amountToWrite = spaceAvailable
-		}
-		amountWritten, err := s.writeBuffer.Write(p[totalWritten : totalWritten+amountToWrite])
-		totalWritten += amountWritten
-		if err != nil {
-			return totalWritten, err
-		}
-		s.writeNotify()
+	n, err = s.writeBuffer.Write(p)
+	if n != len(p) || err != nil {
+		return n, err
 	}
-	return totalWritten, nil
+	s.writeNotify()
+	return n, nil
 }
 
 func (s *MuxedStream) Close() error {
@@ -206,9 +164,9 @@ func (s *MuxedStream) writeNotify() {
 // receive window (how much data we can send).
 func (s *MuxedStream) replenishSendWindow(bytes uint32) {
 	s.writeLock.Lock()
-	defer s.writeLock.Unlock()
 	s.sendWindow += bytes
 	s.writeNotify()
+	s.writeLock.Unlock()
 }
 
 // Call by muxreader when it receives a data frame
@@ -220,30 +178,17 @@ func (s *MuxedStream) consumeReceiveWindow(bytes uint32) bool {
 		return false
 	}
 	s.receiveWindow -= bytes
-	if s.receiveWindow < s.receiveWindowCurrentMax/2 && s.receiveWindowCurrentMax < s.receiveWindowMax {
+	if s.receiveWindow < s.receiveWindowCurrentMax/2 {
 		// exhausting client send window (how much data client can send)
-		// and there is room to grow the receive window
-		newMax := s.receiveWindowCurrentMax << 1
-		if newMax > s.receiveWindowMax {
-			newMax = s.receiveWindowMax
+		if s.receiveWindowCurrentMax < s.receiveWindowMax {
+			s.receiveWindowCurrentMax <<= 1
 		}
-		s.windowUpdate += newMax - s.receiveWindowCurrentMax
-		s.receiveWindowCurrentMax = newMax
-		// notify MuxWriter to write WINDOW_UPDATE frame
+		s.windowUpdate += s.receiveWindowCurrentMax - s.receiveWindow
 		s.writeNotify()
 	}
 	return true
 }
 
-// Arranges for the MuxWriter to send a WINDOW_UPDATE
-// Called by MuxedStream::Read when data has left the read buffer.
-func (s *MuxedStream) replenishReceiveWindow(bytes uint32) {
-	s.writeLock.Lock()
-	defer s.writeLock.Unlock()
-	s.windowUpdate += bytes
-	s.writeNotify()
-}
-
 // receiveEOF should be called when the peer indicates no more data will be sent.
 // Returns true if the socket is now closed (i.e. the write side is already closed).
 func (s *MuxedStream) receiveEOF() (closed bool) {
@@ -281,8 +226,7 @@ type streamChunk struct {
 	// true if a HEADERS frame should be sent
 	sendHeaders bool
 	headers     []Header
-	// nonzero if a WINDOW_UPDATE frame should be sent;
-	// in that case, it is the increment value to use
+	// nonzero if a WINDOW_UPDATE frame should be sent
 	windowUpdate uint32
 	// true if data frames should be sent
 	sendData bool
@@ -305,23 +249,11 @@ func (s *MuxedStream) getChunk() *streamChunk {
 		eof:          s.writeEOF && uint32(s.writeBuffer.Len()) <= s.sendWindow,
 	}
 
-	// Copy at most s.sendWindow bytes, adjust the sendWindow accordingly
+	// Copies at most s.sendWindow bytes
 	writeLen, _ := io.CopyN(&chunk.buffer, s.writeBuffer, int64(s.sendWindow))
 	s.sendWindow -= uint32(writeLen)
-
-	// Non-blocking channel send. This will allow MuxedStream::Write() to continue, if needed
-	if s.writeBuffer.Len() < s.writeBufferMaxLen {
-		select {
-		case s.writeBufferHasSpace <- struct{}{}:
-		default:
-		}
-	}
-
-	// When we write the chunk, we'll write the WINDOW_UPDATE frame if needed
 	s.receiveWindow += s.windowUpdate
 	s.windowUpdate = 0
-
-	// When we write the chunk, we'll write the headers if needed
 	s.headersSent = true
 
 	// if this chunk contains the end of the stream, close the stream now

h2mux/muxedstream_test.go

@@ -23,55 +23,47 @@ func TestFlowControlSingleStream(t *testing.T) {
 		sendWindow:              testWindowSize,
 		readyList:               NewReadyList(),
 	}
-	var tempWindowUpdate uint32
-	var tempStreamChunk *streamChunk
-
 	assert.True(t, stream.consumeReceiveWindow(testWindowSize/2))
 	dataSent := testWindowSize / 2
 	assert.Equal(t, testWindowSize-dataSent, stream.receiveWindow)
 	assert.Equal(t, testWindowSize, stream.receiveWindowCurrentMax)
-	assert.Equal(t, testWindowSize, stream.sendWindow)
 	assert.Equal(t, uint32(0), stream.windowUpdate)
+	tempWindowUpdate := stream.windowUpdate
 
-	tempStreamChunk = stream.getChunk()
-	assert.Equal(t, uint32(0), tempStreamChunk.windowUpdate)
+	streamChunk := stream.getChunk()
+	assert.Equal(t, tempWindowUpdate, streamChunk.windowUpdate)
 	assert.Equal(t, testWindowSize-dataSent, stream.receiveWindow)
-	assert.Equal(t, testWindowSize, stream.receiveWindowCurrentMax)
-	assert.Equal(t, testWindowSize, stream.sendWindow)
 	assert.Equal(t, uint32(0), stream.windowUpdate)
+	assert.Equal(t, testWindowSize, stream.sendWindow)
 
 	assert.True(t, stream.consumeReceiveWindow(2))
 	dataSent += 2
 	assert.Equal(t, testWindowSize-dataSent, stream.receiveWindow)
 	assert.Equal(t, testWindowSize<<1, stream.receiveWindowCurrentMax)
-	assert.Equal(t, testWindowSize, stream.sendWindow)
-	assert.Equal(t, testWindowSize, stream.windowUpdate)
+	assert.Equal(t, (testWindowSize<<1)-stream.receiveWindow, stream.windowUpdate)
 	tempWindowUpdate = stream.windowUpdate
 
-	tempStreamChunk = stream.getChunk()
-	assert.Equal(t, tempWindowUpdate, tempStreamChunk.windowUpdate)
-	assert.Equal(t, (testWindowSize<<1)-dataSent, stream.receiveWindow)
-	assert.Equal(t, testWindowSize<<1, stream.receiveWindowCurrentMax)
-	assert.Equal(t, testWindowSize, stream.sendWindow)
+	streamChunk = stream.getChunk()
+	assert.Equal(t, tempWindowUpdate, streamChunk.windowUpdate)
+	assert.Equal(t, testWindowSize<<1, stream.receiveWindow)
 	assert.Equal(t, uint32(0), stream.windowUpdate)
+	assert.Equal(t, testWindowSize, stream.sendWindow)
 
 	assert.True(t, stream.consumeReceiveWindow(testWindowSize+10))
-	dataSent += testWindowSize + 10
+	dataSent = testWindowSize + 10
 	assert.Equal(t, (testWindowSize<<1)-dataSent, stream.receiveWindow)
 	assert.Equal(t, testWindowSize<<2, stream.receiveWindowCurrentMax)
-	assert.Equal(t, testWindowSize, stream.sendWindow)
-	assert.Equal(t, testWindowSize<<1, stream.windowUpdate)
+	assert.Equal(t, (testWindowSize<<2)-stream.receiveWindow, stream.windowUpdate)
 	tempWindowUpdate = stream.windowUpdate
 
-	tempStreamChunk = stream.getChunk()
-	assert.Equal(t, tempWindowUpdate, tempStreamChunk.windowUpdate)
-	assert.Equal(t, (testWindowSize<<2)-dataSent, stream.receiveWindow)
-	assert.Equal(t, testWindowSize<<2, stream.receiveWindowCurrentMax)
-	assert.Equal(t, testWindowSize, stream.sendWindow)
+	streamChunk = stream.getChunk()
+	assert.Equal(t, tempWindowUpdate, streamChunk.windowUpdate)
+	assert.Equal(t, testWindowSize<<2, stream.receiveWindow)
 	assert.Equal(t, uint32(0), stream.windowUpdate)
+	assert.Equal(t, testWindowSize, stream.sendWindow)
 
 	assert.False(t, stream.consumeReceiveWindow(testMaxWindowSize+1))
-	assert.Equal(t, (testWindowSize<<2)-dataSent, stream.receiveWindow)
+	assert.Equal(t, testWindowSize<<2, stream.receiveWindow)
 	assert.Equal(t, testMaxWindowSize, stream.receiveWindowCurrentMax)
 }
 

h2mux/muxreader.go

@@ -35,8 +35,6 @@ type MuxReader struct {
 	initialStreamWindow uint32
 	// The max value for the send window of a stream.
 	streamWindowMax uint32
-	// The max size for the write buffer of a stream
-	streamWriteBufferMaxLen int
 	// r is a reference to the underlying connection used when shutting down.
 	r io.Closer
 	// updateRTTChan is the channel to send new RTT measurement to muxerMetricsUpdater
@@ -155,8 +153,6 @@ func (r *MuxReader) newMuxedStream(streamID uint32) *MuxedStream {
 		streamID:                streamID,
 		readBuffer:              NewSharedBuffer(),
 		writeBuffer:             &bytes.Buffer{},
-		writeBufferMaxLen:       r.streamWriteBufferMaxLen,
-		writeBufferHasSpace:     make(chan struct{}, 1),
 		receiveWindow:           r.initialStreamWindow,
 		receiveWindowCurrentMax: r.initialStreamWindow,
 		receiveWindowMax:        r.streamWindowMax,

origin/tunnel.go

@@ -431,12 +431,6 @@ func H2RequestHeadersToH1Request(h2 []h2mux.Header, h1 *http.Request) error {
 				return fmt.Errorf("invalid path")
 			}
 			h1.URL = resolved
-		case "content-length":
-			contentLength, err := strconv.ParseInt(header.Value, 10, 64)
-			if err != nil {
-				return fmt.Errorf("unparseable content length")
-			}
-			h1.ContentLength = contentLength
 		default:
 			h1.Header.Add(http.CanonicalHeaderKey(header.Name), header.Value)
 		}

validation/validation.go

@@ -6,10 +6,9 @@ import (
 	"net/url"
 	"strings"
 
-	"net/http"
-
 	"github.com/pkg/errors"
 	"golang.org/x/net/idna"
+	"net/http"
 )
 
 const defaultScheme = "http"
@@ -138,7 +137,7 @@ func validateIP(scheme, host, port string) (string, error) {
 	return fmt.Sprintf("%s://%s", scheme, host), nil
 }
 
-func ValidateHTTPService(originURL string, hostname string, transport http.RoundTripper) error {
+func ValidateHTTPService(originURL string, transport http.RoundTripper) error {
 	parsedURL, err := url.Parse(originURL)
 	if err != nil {
 		return err
@@ -146,27 +145,18 @@ func ValidateHTTPService(originURL string, hostname string, transport http.Round
 
 	client := &http.Client{Transport: transport}
 
-	initialRequest, err := http.NewRequest("GET", parsedURL.String(), nil)
-	if err != nil {
-		return err
-	}
-	initialRequest.Host = hostname
-	initialResponse, initialErr := client.Do(initialRequest)
+	initialResponse, initialErr := client.Get(parsedURL.String())
 	if initialErr != nil || initialResponse.StatusCode != http.StatusOK {
 		// Attempt the same endpoint via the other protocol (http/https); maybe we have better luck?
 		oldScheme := parsedURL.Scheme
 		parsedURL.Scheme = toggleProtocol(parsedURL.Scheme)
 
-		secondRequest, err := http.NewRequest("GET", parsedURL.String(), nil)
-		if err != nil {
-			return err
-		}
-		secondRequest.Host = hostname
-		secondResponse, _ := client.Do(secondRequest)
+		secondResponse, _ := client.Get(parsedURL.String())
+
 		if secondResponse != nil && secondResponse.StatusCode == http.StatusOK { // Worked this time--advise the user to switch protocols
 			return errors.Errorf(
 				"%s doesn't seem to work over %s, but does seem to work over %s. Consider changing the origin URL to %s",
-				parsedURL.Host,
+				parsedURL.Hostname(),
 				oldScheme,
 				parsedURL.Scheme,
 				parsedURL,

validation/validation_test.go

@@ -7,13 +7,12 @@ import (
 	"context"
 	"crypto/tls"
 	"crypto/x509"
+	"github.com/stretchr/testify/assert"
 	"net"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"strings"
-
-	"github.com/stretchr/testify/assert"
 )
 
 func TestValidateHostname(t *testing.T) {
@@ -152,88 +151,57 @@ func TestToggleProtocol(t *testing.T) {
 }
 
 func TestValidateHTTPService_HTTP2HTTP(t *testing.T) {
-	originURL := "http://127.0.0.1/"
-	hostname := "example.com"
 	server, client, err := createMockServerAndClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		assert.Equal(t, hostname, r.Host)
 		w.WriteHeader(200)
 	}))
 	assert.NoError(t, err)
 	defer server.Close()
 
-	assert.Equal(t, nil, ValidateHTTPService(originURL, hostname, client.Transport))
+	assert.Equal(t, nil, ValidateHTTPService("http://example.com/", client.Transport))
 }
 
 func TestValidateHTTPService_ServerNonOKResponse(t *testing.T) {
-	originURL := "http://127.0.0.1/"
-	hostname := "example.com"
 	server, client, err := createMockServerAndClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method == "CONNECT" {
-			assert.Equal(t, "127.0.0.1:443", r.Host)
-		} else {
-			assert.Equal(t, hostname, r.Host)
-		}
 		w.WriteHeader(400)
 	}))
 	assert.NoError(t, err)
 	defer server.Close()
 
-	assert.Equal(t, nil, ValidateHTTPService(originURL, hostname, client.Transport))
+	assert.Equal(t, nil, ValidateHTTPService("http://example.com/", client.Transport))
 }
 
 func TestValidateHTTPService_HTTPS2HTTP(t *testing.T) {
-	originURL := "https://127.0.0.1:1234/"
-	hostname := "example.com"
 	server, client, err := createMockServerAndClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method == "CONNECT" {
-			assert.Equal(t, "127.0.0.1:1234", r.Host)
-		} else {
-			assert.Equal(t, hostname, r.Host)
-		}
 		w.WriteHeader(200)
 	}))
 	assert.NoError(t, err)
 	defer server.Close()
 
 	assert.Equal(t,
-		"127.0.0.1:1234 doesn't seem to work over https, but does seem to work over http. Consider changing the origin URL to http://127.0.0.1:1234/",
-		ValidateHTTPService(originURL, hostname, client.Transport).Error())
+		"example.com doesn't seem to work over https, but does seem to work over http. Consider changing the origin URL to http://example.com:1234/",
+		ValidateHTTPService("https://example.com:1234/", client.Transport).Error())
 }
 
 func TestValidateHTTPService_HTTPS2HTTPS(t *testing.T) {
-	originURL := "https://127.0.0.1/"
-	hostname := "example.com"
 	server, client, err := createSecureMockServerAndClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method == "CONNECT" {
-			assert.Equal(t, "127.0.0.1:443", r.Host)
-		} else {
-			assert.Equal(t, hostname, r.Host)
-		}
 		w.WriteHeader(200)
 	}))
 	assert.NoError(t, err)
 	defer server.Close()
 
-	assert.Equal(t, nil, ValidateHTTPService(originURL, hostname, client.Transport))
+	assert.Equal(t, nil, ValidateHTTPService("https://example.com/", client.Transport))
 }
 
 func TestValidateHTTPService_HTTP2HTTPS(t *testing.T) {
-	originURL := "http://127.0.0.1:1234/"
-	hostname := "example.com"
 	server, client, err := createSecureMockServerAndClient(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method == "CONNECT" {
-			assert.Equal(t, "127.0.0.1:1234", r.Host)
-		} else {
-			assert.Equal(t, hostname, r.Host)
-		}
 		w.WriteHeader(200)
 	}))
 	assert.NoError(t, err)
 	defer server.Close()
 
 	assert.Equal(t,
-		"127.0.0.1:1234 doesn't seem to work over http, but does seem to work over https. Consider changing the origin URL to https://127.0.0.1:1234/",
-		ValidateHTTPService(originURL, hostname, client.Transport).Error())
+		"example.com doesn't seem to work over http, but does seem to work over https. Consider changing the origin URL to https://example.com:1234/",
+		ValidateHTTPService("http://example.com:1234/", client.Transport).Error())
 }
 
 func createMockServerAndClient(handler http.Handler) (*httptest.Server, *http.Client, error) {

websocket/websocket.go

@@ -150,7 +150,7 @@ func StartProxyServer(logger *logrus.Logger, listener net.Listener, remote strin
 		done := make(chan struct{})
 		go pinger(logger, conn, done)
 		defer func() {
-			done <- struct{}{}
+			<-done
 			conn.Close()
 		}()
 		Stream(&Conn{conn}, stream)