120 lines
2.0 KiB
Go
120 lines
2.0 KiB
Go
package server
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"sync"
|
|
|
|
"github.com/LandaMm/hsp-go/hsp"
|
|
)
|
|
|
|
type Server struct {
|
|
Addr hsp.Adddress
|
|
routePrefix string // TODO: Support route prefix, e.g listening on localhost/api
|
|
Running bool
|
|
ConnChan chan *hsp.Connection
|
|
listener net.Listener
|
|
mu sync.Mutex
|
|
}
|
|
|
|
func NewServer(addr hsp.Adddress) *Server {
|
|
return &Server{
|
|
Addr: addr,
|
|
routePrefix: addr.Route,
|
|
Running: false,
|
|
}
|
|
}
|
|
|
|
func (s *Server) SetListener(ln chan *hsp.Connection) {
|
|
s.ConnChan = ln
|
|
}
|
|
|
|
func (s *Server) Start() error {
|
|
ln, err := net.Listen("tcp", s.Addr.String())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
s.mu.Lock()
|
|
s.listener = ln
|
|
s.Running = true
|
|
s.mu.Unlock()
|
|
|
|
for s.IsRunning() {
|
|
conn, err := ln.Accept()
|
|
if err != nil {
|
|
if !s.IsRunning() {
|
|
break
|
|
}
|
|
return err
|
|
}
|
|
|
|
keys, err := hsp.GenerateKeyPair()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Receive client's public key
|
|
clientKey := make([]byte, 32)
|
|
n, err := io.ReadFull(conn, clientKey)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if n != 32 {
|
|
return fmt.Errorf("Received invalid client's key with %d bytes (expected 32 bytes)", n)
|
|
}
|
|
|
|
// Send our public key to client
|
|
n, err = conn.Write(keys.Public[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if n != 32 {
|
|
return fmt.Errorf("Couldn't send 32 bytes of public key (%d sent instead)", n)
|
|
}
|
|
|
|
sharedKey, err := hsp.DeriveSharedKey(keys.Private, [32]byte(clientKey))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if s.ConnChan != nil {
|
|
connection := hsp.NewConnection(conn, keys, sharedKey)
|
|
s.ConnChan <- connection
|
|
} else {
|
|
conn.Close()
|
|
}
|
|
}
|
|
|
|
s.mu.Lock()
|
|
s.Running = false
|
|
s.listener = nil
|
|
s.mu.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Server) Stop() error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
s.Running = false
|
|
if s.listener != nil {
|
|
return s.listener.Close()
|
|
}
|
|
if s.ConnChan != nil {
|
|
close(s.ConnChan)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Server) IsRunning() bool {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.Running
|
|
}
|