test.go

package main

import (
	"crypto/tls"
	"fmt"
	"github.com/inconshreveable/muxado"
	"log"
	"net"
)

var (
	ServerAddr  = "127.0.0.1:10011"
	CertPath    = "cert.pem"
	KeyPath     = "key.pem"
	tlsInsecure = &tls.Config{InsecureSkipVerify: true}
)

func tlsConfig() *tls.Config {
	// Load the certificates
	cert, err := tls.LoadX509KeyPair(CertPath, KeyPath)
	if err != nil {
		panic(err)
	}

	// Create the tls config
	tlsConfig := &tls.Config{
		Certificates:           []tls.Certificate{cert},
		SessionTicketsDisabled: true,
	}
	return tlsConfig
}

func main() {
	// Start the server listener
	if l, err := net.Listen("tcp", ServerAddr); err != nil {
		panic(err)
	} else {
		tlsList := tls.NewListener(l, tlsConfig())
		serverListener := muxado.NewListener(tlsList)
		go serverAcceptor(serverListener)
	}

	if sess, err := muxado.DialTLS("tcp", ServerAddr, tlsInsecure); err != nil {
		panic(fmt.Errorf("Failed to connect to mux server: %v", err))
	} else {
		go clientAcceptor(sess)
	}

	select {}
}

func serverAcceptor(serverListener *muxado.Listener) {
	for {
		session, err := serverListener.Accept()
		if err != nil {
			frame, mErr, mDbg := session.Wait()
			log.Printf("[ERR] Failed to accept client: %v (%v, %v, %v)",
				err, frame, mErr, mDbg)
			continue
		}
		log.Printf("[DEBUG] Accepted server conn from %v", session.RemoteAddr())
		go handleServer(session)
	}
}

func handleServer(session muxado.Session) {
	defer session.Close()
	for {
		conn, err := session.Open()
		if err != nil {
			panic(err)
		}

		client := tls.Client(conn, tlsInsecure)

		n, err := client.Write([]byte("ping"))
		if err != nil {
			log.Printf("ERR: Failed to write ping: %v", err)
			continue
		}
		log.Printf("Sent ping: %d", n)

		recv := make([]byte, 4)
		_, err = client.Read(recv)
		if err != nil {
			panic(err)
		}
		log.Printf("Got response %s", recv)

		client.Close()
	}
}

func clientAcceptor(session muxado.Session) {
	defer session.Close()
	for {
		stream, err := session.Accept()
		if err != nil {
			frame, mErr, mDbg := session.Wait()
			log.Printf("[ERR] Failed to accept client: %v (%v, %v, %v)",
				err, frame, mErr, mDbg)
			return
		}
		log.Printf("[DEBUG] Accepted connection: %v", stream.RemoteAddr())
		go handleClient(stream)
	}
}

// handleClient is used to handle a single client connection
func handleClient(stream muxado.Stream) {
	conn := tls.Server(stream, tlsConfig())
	defer conn.Close()

	recv := make([]byte, 4)
	_, err := conn.Read(recv)
	if err != nil {
		panic(err)
	}
	log.Printf("Got %s", recv)

	_, err = conn.Write([]byte("pong"))
	if err != nil {
		panic(err)
	}
	log.Printf("Sent pong")
}