Styjun

given that i own a net.Listener socket, how can i detect that an incoming connection is using ssl.

I work with below code which works fine to dispatch bt/http connections.

The code performs byte-to-byte comparison on the buffered conn, when nothing is found it defaults to the bt listener.

I want it to be able to dispatch ssl tls connections, ideally with sni support to perform host dispatching, if i m correct.

package server

import (
 "bufio"
 "bytes"
 "log"
 "net"
)

type SocketDispatcher struct 
 net.Listener
 Dispatchers []*Dispatcher


func (l *SocketDispatcher) Accept() (net.Conn, error) 
 for 
 conn, err := l.Listener.Accept()
 if err != nil 
 return nil, err
 
 var r *bufio.Reader
 r, conn = makePeekedConn(conn)
 if d := l.Snif(r); d != nil 
 d.Handle(conn)
 continue
 
 return conn, err
 


func (l *SocketDispatcher) Snif(r *bufio.Reader) *Dispatcher 
 for _, d := range l.Dispatchers 
 if d.Snif(r) 
 return d
 
 
 return nil


type Dispatcher struct 
 Snif func(r *bufio.Reader) bool
 accepted chan net.Conn


func (d *Dispatcher) Handle(conn net.Conn) error 
 go func() 
 d.accepted <- conn
 ()
 return nil


func (d *Dispatcher) Accept() (net.Conn, error) 
 conn := <-d.accepted
 return conn, nil


func CatchAll() *Dispatcher 
 return &Dispatcher
 Snif: func(r *bufio.Reader) bool 
 return true
 ,
 accepted: make(chan net.Conn),
 


func HTTPDispatcher() *Dispatcher 
 return &Dispatcher
 Snif: func(r *bufio.Reader) bool 
 return HTTPSnif(r)
 ,
 accepted: make(chan net.Conn),
 


//HTTPSnif detects http requests
func HTTPSnif(t *bufio.Reader) bool 
 ms := []string"GET", "PUT", "HEAD", "POST", "PATCH", "OPTION", "DELETE"
 longuest := 0
 for _, m := range ms 
 if longuest < len(m) 
 longuest = len(m)
 
 

 remains := [][]byte
 for _, m := range ms 
 b := []byte(m + " ")
 remains = append(remains, b)
 

 for e := 1; e <= longuest; e++ 
 p, err := t.Peek(e)
 if err != nil 
 log.Println("peek", err)
 return false
 
 remains = filter(remains, p)
 if len(remains) == 0 
 return false
 
 if len(remains) == 1 
 return true
 
 

 return true


func filter(remains [][]byte, cur []byte) [][]byte 
 rests := [][]byte
 for _, r := range remains 
 return rests


func peekCompare(t *bufio.Reader, search []byte) bool 
 var p []byte
 for i := 1; i <= len(search); i++ 
 var err error
 p, err = t.Peek(i)
 if err != nil 
 return false
 
 if !bytes.HasPrefix(search, p) 
 return false
 
 
 return bytes.Equal(search, p)