fake conn and ls in golang

fake_conn_ls.go

package main

import (
	"crypto/tls"
	"log"
	"net"
	"net/http"
	"time"
)

type FakeConn struct {
	real net.Conn
}

func (f *FakeConn) Read(b []byte) (n int, err error) {
	n, err = f.real.Read(b)
	log.Println("fake conn read is:", string(b), n, err)
	return n, err
}

func (f *FakeConn) Write(b []byte) (n int, err error) {
	n, err = f.real.Write(b)
	log.Println("fake conn write is:", string(b), n, err)
	return n, err
}

func (f *FakeConn) Close() error {
	err := f.real.Close()
	log.Println("fake conn close:", err)
	return err
}

func (f *FakeConn) LocalAddr() net.Addr {
	a := f.real.LocalAddr()
	log.Println("fake conn localaddr is:", a)
	return a
}

func (f *FakeConn) RemoteAddr() net.Addr {
	a := f.real.RemoteAddr()
	log.Println("fake conn remoteaddr is:", a)
	return a
}

func (f *FakeConn) SetDeadline(t time.Time) error {
	log.Println("fake conn setdeadline:", t)
	return f.real.SetDeadline(t)
}

func (f *FakeConn) SetReadDeadline(t time.Time) error {
	log.Println("fake conn set read deadline:", t)
	return f.real.SetReadDeadline(t)
}

func (f *FakeConn) SetWriteDeadline(t time.Time) error {
	log.Println("fake conn set write deadline:", t)
	return f.real.SetWriteDeadline(t)
}

type FakeListener struct {
	real net.Listener
}

func (f *FakeListener) Accept() (net.Conn, error) {
	c, err := f.real.Accept()
	if err != nil {
		log.Println("fakels.accept error:", err)
		return c, err
	}
	var fakeConn FakeConn
	fakeConn.real = c
	return &fakeConn, nil
}

func (f *FakeListener) Close() error {
	err := f.real.Close()
	log.Println("fake ls close")
	return err
}

func (f *FakeListener) Addr() net.Addr {
	a := f.real.Addr()
	log.Println("fake ls addr:", a)
	return a
}

func FakeListenAndServeTLS(srv *http.Server, cert, key string) error {
	addr := srv.Addr
	if addr == "" {
		addr = ":https"
	}

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

	defer ln.Close()
	var fakeLn FakeListener
	fakeLn.real = ln

	return srv.ServeTLS(&fakeLn, cert, key)
}

func RunTLSServer() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		w.Header().Add("Strict-Transport-Security", "max-age=63072000; includeSubDomains")
		w.Write([]byte("This is an example server.\n"))
	})
	cfg := &tls.Config{
		MinVersion:               tls.VersionTLS12,
		CurvePreferences:         []tls.CurveID{tls.CurveP521, tls.CurveP384, tls.CurveP256},
		PreferServerCipherSuites: true,
		CipherSuites: []uint16{
			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
			tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
			tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
			tls.TLS_RSA_WITH_AES_256_CBC_SHA,
		},
	}
	srv := &http.Server{
		Addr:         ":1443",
		Handler:      mux,
		TLSConfig:    cfg,
		TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler), 0),
	}
	log.Fatal(FakeListenAndServeTLS(srv, CertPath, KeyPath))
}