package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"crypto/x509/pkix"
	"fmt"
	"io"
	"math/big"
	"net"
	"net/http"
	"os"
	"strings"
	"time"
)

func tlsListener() (net.Listener, error) {
	key, err := rsa.GenerateKey(rand.Reader, 1024)
	if err != nil {
		return nil, err
	}

	template := &x509.Certificate{
		SerialNumber:          big.NewInt(1),
		NotBefore:             time.Now(),
		NotAfter:              time.Now().AddDate(0, 0, 1),
		Subject:               pkix.Name{CommonName: "localhost"},
		BasicConstraintsValid: true,
		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
		DNSNames:              []string{"localhost"},
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
	}

	cert, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key)
	if err != nil {
		return nil, err
	}

	l, err := net.Listen("tcp", ":8443")
	if err != nil {
		return nil, err
	}

	return tls.NewListener(l, &tls.Config{
		Certificates: []tls.Certificate{
			{
				Certificate: [][]byte{
					cert,
				},
				PrivateKey: key,
			},
		},
		NextProtos: []string{"h2"},
	}), nil
}

func run() error {
	l, err := tlsListener()
	if err != nil {
		return err
	}

	s := &http.Server{
		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.URL.Path == "/bad" {
				r.Body.Close()
			}
			if r.URL.Path == "/echo" {
				io.Copy(w, r.Body)
			}
		}),
	}

	go func() {
		err := s.Serve(l)
		if err != nil {
			panic(err)
		}
	}()

	c := &http.Client{
		Transport: &http.Transport{
			TLSClientConfig: &tls.Config{
				InsecureSkipVerify: true,
			},
			ForceAttemptHTTP2: true, // because we're setting TLSClientConfig
		},
	}

	for {
		c.Post("https://localhost:8443/bad", "", strings.NewReader(strings.Repeat("x", 4096)))

		resp, err := c.Post("https://localhost:8443/echo", "", strings.NewReader("hello\n"))
		if err != nil {
			return err
		}

		fmt.Println(resp.Proto)
		io.Copy(os.Stdout, resp.Body)
		resp.Body.Close()
	}
}

func main() {
	if err := run(); err != nil {
		panic(err)
	}
}

	if p.breakErr != nil {
		return len(d), nil // discard when there is no reader
	}