README cleanup.

Co-authored-by: jdl <jdl@desktop>
Reviewed-on: #4

README.md

@@ -1,5 +1,9 @@
 # vppn: Virtual Potentially Private Network
 
+## TO DO
+
+* Double buffering in IFReader and ConnReader ?
+
 ## Hub Server Configuration
 
 ```
@@ -9,7 +13,6 @@ adduser user
 # Enable ssh.
 cp -r ~/.ssh /home/user/
 chown -R user:user /home/user/.ssh
-
 ```
 
 Upload `hub` executable:
@@ -38,6 +41,7 @@ Add and start the hub server:
 
 ```
 systemctl daemon-reload
+systemctl enable hub
 systemctl start hub
 ```
 
@@ -55,17 +59,24 @@ Install the binary somewhere, for example `~/bin/vppn`.
 
 Create systemd file in `/etc/systemd/system/vppn.service`.
 
-
 ```
 [Service]
 AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_NET_ADMIN
 Type=simple
 User=user
 WorkingDirectory=/home/user/
-ExecStart=/home/user/vppn -name vppn -hub-address https://my.hub -api-key 1234567890
+ExecStart=/home/user/vppn -name mynetwork -hub-address https://my.hub -api-key 1234567890
 Restart=always
 RestartSec=8
 
 [Install]
-WantedBy=default.target
+WantedBy=multi-user.target
+```
+
+Add and start the service:
+
+```
+systemctl daemon-reload
+systemctl enable vppn
+systemctl start vppn
 ```

go.mod

@@ -3,13 +3,13 @@ module vppn
 go 1.24.1
 
 require (
-	git.crumpington.com/lib/go v0.8.1
-	golang.org/x/crypto v0.29.0
-	golang.org/x/sys v0.27.0
+	git.crumpington.com/lib/go v0.9.0
+	golang.org/x/crypto v0.36.0
+	golang.org/x/sys v0.31.0
 )
 
 require (
 	github.com/mattn/go-sqlite3 v1.14.24 // indirect
-	golang.org/x/net v0.31.0 // indirect
-	golang.org/x/text v0.20.0 // indirect
+	golang.org/x/net v0.37.0 // indirect
+	golang.org/x/text v0.23.0 // indirect
 )

go.sum

@@ -1,12 +1,12 @@
-git.crumpington.com/lib/go v0.8.1 h1:rWjddllSxQ4yReraqDaGZAod4NpRD9LtGx1yV71ytcU=
-git.crumpington.com/lib/go v0.8.1/go.mod h1:XjQaf2NFlje9BJ1EevZL8NNioPrAe7WwHpKUhcDw2Lk=
+git.crumpington.com/lib/go v0.9.0 h1:QXoMhsycSgEUWNiiPZWl0jgBls+NI9TNR5Z6nNXslCM=
+git.crumpington.com/lib/go v0.9.0/go.mod h1:i3DXiPDo/pgPMHAxUTpyo1Xj2spcvXwXcBef3aSYlnQ=
 github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
 github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
-golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
-golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
-golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
-golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
-golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
+golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=

hub/api/api.go

@@ -54,17 +54,11 @@ func (a *API) ensurePassword() error {
 	log.Printf("Setting password: %s", pwd)
 
 	hashed, err := bcrypt.GenerateFromPassword([]byte(pwd), bcrypt.DefaultCost)
-
 	if err != nil {
 		return err
 	}
 
-	conf := &Config{
-		ConfigID:   1,
-		VPNNetwork: []byte{10, 1, 1, 0},
-		Password:   hashed,
-	}
-
+	conf := &Config{ConfigID: 1, Password: hashed}
 	return db.Config_Insert(a.db, conf)
 }
 
@@ -80,10 +74,6 @@ func (a *API) Config_Update(conf *Config) error {
 	return db.Config_Update(a.db, conf)
 }
 
-func (a *API) Config_UpdatePassword(pwdHash []byte) error {
-	return db.Config_UpdatePassword(a.db, pwdHash)
-}
-
 func (a *API) Session_Delete(sessionID string) error {
 	return db.Session_Delete(a.db, sessionID)
 }
@@ -137,6 +127,24 @@ func (a *API) Session_SignIn(s *Session, pwd string) error {
 	return db.Session_SetSignedIn(a.db, s.SessionID)
 }
 
+func (a *API) Network_Create(n *Network) error {
+	n.NetworkID = idgen.NextID(0)
+	return db.Network_Insert(a.db, n)
+}
+
+func (a *API) Network_Delete(n *Network) error {
+	return db.Network_Delete(a.db, n.NetworkID)
+}
+
+func (a *API) Network_Get(id int64) (*Network, error) {
+	return db.Network_Get(a.db, id)
+}
+
+func (a *API) Network_List() ([]*Network, error) {
+	const query = db.Network_SelectQuery + ` ORDER BY Name ASC`
+	return db.Network_List(a.db, query)
+}
+
 func (a *API) Peer_CreateNew(p *Peer) error {
 	p.Version = idgen.NextID(0)
 	p.PubKey = []byte{}
@@ -146,7 +154,7 @@ func (a *API) Peer_CreateNew(p *Peer) error {
 	return db.Peer_Insert(a.db, p)
 }
 
-func (a *API) Peer_Init(peer *Peer, args m.PeerInitArgs) (*m.PeerConfig, error) {
+func (a *API) Peer_Init(peer *Peer, args m.PeerInitArgs) error {
 	a.lock.Lock()
 	defer a.lock.Unlock()
 
@@ -154,19 +162,7 @@ func (a *API) Peer_Init(peer *Peer, args m.PeerInitArgs) (*m.PeerConfig, error)
 	peer.PubKey = args.EncPubKey
 	peer.PubSignKey = args.PubSignKey
 
-	if err := db.Peer_UpdateFull(a.db, peer); err != nil {
-		return nil, err
-	}
-
-	conf := a.Config_Get()
-
-	return &m.PeerConfig{
-		PeerIP:   peer.PeerIP,
-		Network:  conf.VPNNetwork,
-		PublicIP: peer.PublicIP,
-		Port:     peer.Port,
-		Relay:    peer.Relay,
-	}, nil
+	return db.Peer_UpdateFull(a.db, peer)
 }
 
 func (a *API) Peer_Update(p *Peer) error {
@@ -177,16 +173,16 @@ func (a *API) Peer_Update(p *Peer) error {
 	return db.Peer_Update(a.db, p)
 }
 
-func (a *API) Peer_Delete(ip byte) error {
-	return db.Peer_Delete(a.db, ip)
+func (a *API) Peer_Delete(networkID int64, peerIP byte) error {
+	return db.Peer_Delete(a.db, networkID, peerIP)
 }
 
-func (a *API) Peer_List() ([]*Peer, error) {
-	return db.Peer_ListAll(a.db)
+func (a *API) Peer_List(networkID int64) ([]*Peer, error) {
+	return db.Peer_ListAll(a.db, networkID)
 }
 
-func (a *API) Peer_Get(ip byte) (*Peer, error) {
-	return db.Peer_Get(a.db, ip)
+func (a *API) Peer_Get(networkID int64, ip byte) (*Peer, error) {
+	return db.Peer_Get(a.db, networkID, ip)
 }
 
 func (a *API) Peer_GetByAPIKey(key string) (*Peer, error) {

hub/api/db/generated.go

@@ -17,12 +17,10 @@ type TX interface {
 
 type Config struct {
 	ConfigID int64
-	HubAddress string
-	VPNNetwork []byte
 	Password []byte
 }
 
-const Config_SelectQuery = "SELECT ConfigID,HubAddress,VPNNetwork,Password FROM config"
+const Config_SelectQuery = "SELECT ConfigID,Password FROM config"
 
 func Config_Insert(
 	tx TX,
@@ -33,7 +31,7 @@ func Config_Insert(
 		return err
 	}
 
-	_, err = tx.Exec("INSERT INTO config(ConfigID,HubAddress,VPNNetwork,Password) VALUES(?,?,?,?)", row.ConfigID, row.HubAddress, row.VPNNetwork, row.Password)
+	_, err = tx.Exec("INSERT INTO config(ConfigID,Password) VALUES(?,?)", row.ConfigID, row.Password)
 	return err
 }
 
@@ -46,7 +44,7 @@ func Config_Update(
 		return err
 	}
 
-	result, err := tx.Exec("UPDATE config SET HubAddress=?,VPNNetwork=? WHERE ConfigID=?", row.HubAddress, row.VPNNetwork, row.ConfigID)
+	result, err := tx.Exec("UPDATE config SET Password=? WHERE ConfigID=?", row.Password, row.ConfigID)
 	if err != nil {
 		return err
 	}
@@ -74,7 +72,7 @@ func Config_UpdateFull(
 		return err
 	}
 
-	result, err := tx.Exec("UPDATE config SET HubAddress=?,VPNNetwork=?,Password=? WHERE ConfigID=?", row.HubAddress, row.VPNNetwork, row.Password, row.ConfigID)
+	result, err := tx.Exec("UPDATE config SET Password=? WHERE ConfigID=?", row.Password, row.ConfigID)
 	if err != nil {
 		return err
 	}
@@ -124,8 +122,8 @@ func Config_Get(
 	err error,
 ) {
 	row = &Config{}
-	r := tx.QueryRow("SELECT ConfigID,HubAddress,VPNNetwork,Password FROM config WHERE ConfigID=?", ConfigID)
-	err = r.Scan(&row.ConfigID, &row.HubAddress, &row.VPNNetwork, &row.Password)
+	r := tx.QueryRow("SELECT ConfigID,Password FROM config WHERE ConfigID=?", ConfigID)
+	err = r.Scan(&row.ConfigID, &row.Password)
 	return
 }
 
@@ -139,7 +137,7 @@ func Config_GetWhere(
 ) {
 	row = &Config{}
 	r := tx.QueryRow(query, args...)
-	err = r.Scan(&row.ConfigID, &row.HubAddress, &row.VPNNetwork, &row.Password)
+	err = r.Scan(&row.ConfigID, &row.Password)
 	return
 }
 
@@ -159,7 +157,7 @@ func Config_Iterate(
 		defer rows.Close()
 		for rows.Next() {
 			row := &Config{}
-			err := rows.Scan(&row.ConfigID, &row.HubAddress, &row.VPNNetwork, &row.Password)
+			err := rows.Scan(&row.ConfigID, &row.Password)
 			if !yield(row, err) {
 				return
 			}
@@ -302,11 +300,156 @@ func Session_List(
 	return l, nil
 }
 
+// ----------------------------------------------------------------------------
+// Table: networks
+// ----------------------------------------------------------------------------
+
+type Network struct {
+	NetworkID int64
+	Name      string
+	Network   []byte
+}
+
+const Network_SelectQuery = "SELECT NetworkID,Name,Network FROM networks"
+
+func Network_Insert(
+	tx TX,
+	row *Network,
+) (err error) {
+	Network_Sanitize(row)
+	if err = Network_Validate(row); err != nil {
+		return err
+	}
+
+	_, err = tx.Exec("INSERT INTO networks(NetworkID,Name,Network) VALUES(?,?,?)", row.NetworkID, row.Name, row.Network)
+	return err
+}
+
+func Network_UpdateFull(
+	tx TX,
+	row *Network,
+) (err error) {
+	Network_Sanitize(row)
+	if err = Network_Validate(row); err != nil {
+		return err
+	}
+
+	result, err := tx.Exec("UPDATE networks SET Name=?,Network=? WHERE NetworkID=?", row.Name, row.Network, row.NetworkID)
+	if err != nil {
+		return err
+	}
+
+	n, err := result.RowsAffected()
+	if err != nil {
+		panic(err)
+	}
+	switch n {
+	case 0:
+		return sql.ErrNoRows
+	case 1:
+		return nil
+	default:
+		panic("multiple rows updated")
+	}
+}
+
+func Network_Delete(
+	tx TX,
+	NetworkID int64,
+) (err error) {
+	result, err := tx.Exec("DELETE FROM networks WHERE NetworkID=?", NetworkID)
+	if err != nil {
+		return err
+	}
+
+	n, err := result.RowsAffected()
+	if err != nil {
+		panic(err)
+	}
+	switch n {
+	case 0:
+		return sql.ErrNoRows
+	case 1:
+		return nil
+	default:
+		panic("multiple rows deleted")
+	}
+}
+
+func Network_Get(
+	tx TX,
+	NetworkID int64,
+) (
+	row *Network,
+	err error,
+) {
+	row = &Network{}
+	r := tx.QueryRow("SELECT NetworkID,Name,Network FROM networks WHERE NetworkID=?", NetworkID)
+	err = r.Scan(&row.NetworkID, &row.Name, &row.Network)
+	return
+}
+
+func Network_GetWhere(
+	tx TX,
+	query string,
+	args ...any,
+) (
+	row *Network,
+	err error,
+) {
+	row = &Network{}
+	r := tx.QueryRow(query, args...)
+	err = r.Scan(&row.NetworkID, &row.Name, &row.Network)
+	return
+}
+
+func Network_Iterate(
+	tx TX,
+	query string,
+	args ...any,
+) iter.Seq2[*Network, error] {
+	rows, err := tx.Query(query, args...)
+	if err != nil {
+		return func(yield func(*Network, error) bool) {
+			yield(nil, err)
+		}
+	}
+
+	return func(yield func(*Network, error) bool) {
+		defer rows.Close()
+		for rows.Next() {
+			row := &Network{}
+			err := rows.Scan(&row.NetworkID, &row.Name, &row.Network)
+			if !yield(row, err) {
+				return
+			}
+		}
+	}
+}
+
+func Network_List(
+	tx TX,
+	query string,
+	args ...any,
+) (
+	l []*Network,
+	err error,
+) {
+	for row, err := range Network_Iterate(tx, query, args...) {
+		if err != nil {
+			return nil, err
+		}
+		l = append(l, row)
+	}
+	return l, nil
+}
+
 // ----------------------------------------------------------------------------
 // Table: peers
 // ----------------------------------------------------------------------------
 
 type Peer struct {
+	NetworkID  int64
 	PeerIP     byte
 	Version    int64
 	APIKey     string
@@ -318,7 +461,7 @@ type Peer struct {
 	PubSignKey []byte
 }
 
-const Peer_SelectQuery = "SELECT PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey FROM peers"
+const Peer_SelectQuery = "SELECT NetworkID,PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey FROM peers"
 
 func Peer_Insert(
 	tx TX,
@@ -329,7 +472,7 @@ func Peer_Insert(
 		return err
 	}
 
-	_, err = tx.Exec("INSERT INTO peers(PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey) VALUES(?,?,?,?,?,?,?,?,?)", row.PeerIP, row.Version, row.APIKey, row.Name, row.PublicIP, row.Port, row.Relay, row.PubKey, row.PubSignKey)
+	_, err = tx.Exec("INSERT INTO peers(NetworkID,PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey) VALUES(?,?,?,?,?,?,?,?,?,?)", row.NetworkID, row.PeerIP, row.Version, row.APIKey, row.Name, row.PublicIP, row.Port, row.Relay, row.PubKey, row.PubSignKey)
 	return err
 }
 
@@ -342,7 +485,7 @@ func Peer_Update(
 		return err
 	}
 
-	result, err := tx.Exec("UPDATE peers SET Version=?,Name=?,PublicIP=?,Port=?,Relay=? WHERE PeerIP=?", row.Version, row.Name, row.PublicIP, row.Port, row.Relay, row.PeerIP)
+	result, err := tx.Exec("UPDATE peers SET Version=?,Name=?,PublicIP=?,Port=?,Relay=? WHERE NetworkID=? AND PeerIP=?", row.Version, row.Name, row.PublicIP, row.Port, row.Relay, row.NetworkID, row.PeerIP)
 	if err != nil {
 		return err
 	}
@@ -370,7 +513,7 @@ func Peer_UpdateFull(
 		return err
 	}
 
-	result, err := tx.Exec("UPDATE peers SET Version=?,APIKey=?,Name=?,PublicIP=?,Port=?,Relay=?,PubKey=?,PubSignKey=? WHERE PeerIP=?", row.Version, row.APIKey, row.Name, row.PublicIP, row.Port, row.Relay, row.PubKey, row.PubSignKey, row.PeerIP)
+	result, err := tx.Exec("UPDATE peers SET Version=?,APIKey=?,Name=?,PublicIP=?,Port=?,Relay=?,PubKey=?,PubSignKey=? WHERE NetworkID=? AND PeerIP=?", row.Version, row.APIKey, row.Name, row.PublicIP, row.Port, row.Relay, row.PubKey, row.PubSignKey, row.NetworkID, row.PeerIP)
 	if err != nil {
 		return err
 	}
@@ -391,9 +534,10 @@ func Peer_UpdateFull(
 
 func Peer_Delete(
 	tx TX,
+	NetworkID int64,
 	PeerIP byte,
 ) (err error) {
-	result, err := tx.Exec("DELETE FROM peers WHERE PeerIP=?", PeerIP)
+	result, err := tx.Exec("DELETE FROM peers WHERE NetworkID=? AND PeerIP=?", NetworkID, PeerIP)
 	if err != nil {
 		return err
 	}
@@ -414,14 +558,15 @@ func Peer_Delete(
 
 func Peer_Get(
 	tx TX,
+	NetworkID int64,
 	PeerIP byte,
 ) (
 	row *Peer,
 	err error,
 ) {
 	row = &Peer{}
-	r := tx.QueryRow("SELECT PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey FROM peers WHERE PeerIP=?", PeerIP)
-	err = r.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
+	r := tx.QueryRow("SELECT NetworkID,PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey FROM peers WHERE NetworkID=? AND PeerIP=?", NetworkID, PeerIP)
+	err = r.Scan(&row.NetworkID, &row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
 	return
 }
 
@@ -435,7 +580,7 @@ func Peer_GetWhere(
 ) {
 	row = &Peer{}
 	r := tx.QueryRow(query, args...)
-	err = r.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
+	err = r.Scan(&row.NetworkID, &row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
 	return
 }
 
@@ -455,7 +600,7 @@ func Peer_Iterate(
 		defer rows.Close()
 		for rows.Next() {
 			row := &Peer{}
-			err := rows.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
+			err := rows.Scan(&row.NetworkID, &row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
 			if !yield(row, err) {
 				return
 			}

hub/api/db/sanitize-validate.go

@@ -3,35 +3,21 @@ package db
 import (
 	"errors"
 	"net/netip"
-	"net/url"
 	"strings"
 )
 
 var (
 	ErrInvalidIP       = errors.New("invalid IP")
+	ErrNonPrivateIP    = errors.New("non-private IP")
 	ErrInvalidPort     = errors.New("invalid port")
+	ErrInvalidNetName  = errors.New("invalid network name")
+	ErrInvalidPeerName = errors.New("invalid peer name")
 )
 
 func Config_Sanitize(c *Config) {
-	if u, err := url.Parse(c.HubAddress); err == nil {
-		c.HubAddress = u.String()
-	}
-
-	if addr, ok := netip.AddrFromSlice(c.VPNNetwork); ok {
-		c.VPNNetwork = addr.AsSlice()
-	}
 }
 
 func Config_Validate(c *Config) error {
-	if _, err := url.Parse(c.HubAddress); err != nil {
-		return err
-	}
-
-	addr, ok := netip.AddrFromSlice(c.VPNNetwork)
-	if !ok || !addr.Is4() || addr.As4()[3] != 0 || addr.As4()[0] == 0 {
-		return ErrInvalidIP
-	}
-
 	return nil
 }
 
@@ -42,6 +28,42 @@ func Session_Validate(s *Session) error {
 	return nil
 }
 
+func Network_Sanitize(n *Network) {
+	n.Name = strings.TrimSpace(n.Name)
+
+	if addr, ok := netip.AddrFromSlice(n.Network); ok {
+		n.Network = addr.AsSlice()
+	}
+}
+
+func Network_Validate(c *Network) error {
+	// 16 bytes is linux limit for network interface names.
+	if len(c.Name) == 0 || len(c.Name) > 16 {
+		return ErrInvalidNetName
+	}
+
+	for _, c := range c.Name {
+		if c >= 'a' && c <= 'z' {
+			continue
+		}
+		if c >= '0' && c <= '9' {
+			continue
+		}
+		return ErrInvalidNetName
+	}
+
+	addr, ok := netip.AddrFromSlice(c.Network)
+	if !ok || !addr.Is4() || addr.As4()[3] != 0 || addr.As4()[0] == 0 {
+		return ErrInvalidIP
+	}
+
+	if !addr.IsPrivate() {
+		return ErrNonPrivateIP
+	}
+
+	return nil
+}
+
 func Peer_Sanitize(p *Peer) {
 	p.Name = strings.TrimSpace(p.Name)
 	if len(p.PublicIP) != 0 {
@@ -65,5 +87,20 @@ func Peer_Validate(p *Peer) error {
 	if p.Port == 0 {
 		return ErrInvalidPort
 	}
+
+	for _, c := range p.Name {
+		if c >= 'a' && c <= 'z' {
+			continue
+		}
+		if c >= '0' && c <= '9' {
+			continue
+		}
+		if c == '.' || c == '-' || c == '_' {
+			continue
+		}
+
+		return ErrInvalidPeerName
+	}
+
 	return nil
 }

hub/api/db/tables.defs

@@ -1,8 +1,6 @@
 TABLE config OF Config (
   ConfigID    int64  PK,
-  HubAddress  string,
-  VPNNetwork  []byte,
-  Password    []byte NoUpdate
+  Password    []byte
 );
 
 TABLE sessions OF Session NoUpdate (
@@ -13,7 +11,14 @@ TABLE sessions OF Session NoUpdate (
   LastSeenAt int64
 );
 
+TABLE networks OF Network (
+  NetworkID int64 PK,
+  Name      string NoUpdate,
+  Network   []byte NoUpdate
+);
+
 TABLE peers OF Peer (
+  NetworkID  int64 PK,
   PeerIP     byte PK,
   Version    int64,
   APIKey     string NoUpdate,

hub/api/db/written.go

@@ -26,16 +26,9 @@ func Session_DeleteBefore(
 	return err
 }
 
-func Config_UpdatePassword(
-	tx TX,
-	pwdHash []byte,
-) (err error) {
-	_, err = tx.Exec("UPDATE config SET Password=? WHERE ConfigID=1", pwdHash)
-	return err
-}
-
-func Peer_ListAll(tx TX) ([]*Peer, error) {
-	return Peer_List(tx, Peer_SelectQuery)
+func Peer_ListAll(tx TX, networkID int64) ([]*Peer, error) {
+	const query = Peer_SelectQuery + ` WHERE NetworkID=? ORDER BY PeerIP ASC`
+	return Peer_List(tx, query, networkID)
 }
 
 func Peer_GetByAPIKey(tx TX, apiKey string) (*Peer, error) {
@@ -45,7 +38,8 @@ func Peer_GetByAPIKey(tx TX, apiKey string) (*Peer, error) {
 		apiKey)
 }
 
-func Peer_Exists(tx TX, ip byte) (exists bool, err error) {
-	err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM peers WHERE PeerIP=?)`, ip).Scan(&exists)
+func Peer_Exists(tx TX, networkID int64, ip byte) (exists bool, err error) {
+	const query = `SELECT EXISTS(SELECT 1 FROM peers WHERE NetworkID=? AND PeerIP=?)`
+	err = tx.QueryRow(query, networkID, ip).Scan(&exists)
 	return
 }

hub/api/migrations/2024-11-30-init.sql

@@ -1,7 +1,5 @@
 CREATE TABLE config (
   ConfigID    INTEGER NOT NULL PRIMARY KEY, -- Always 1.
-  HubAddress  TEXT    NOT NULL, -- https://for.example.com
-  VPNNetwork  BLOB    NOT NULL, -- Network (/24), example 10.51.50.0
   Password    BLOB    NOT NULL  -- bcrypt password for web interface
 ) WITHOUT ROWID;
 
@@ -15,13 +13,22 @@ CREATE TABLE sessions (
 
 CREATE INDEX sessions_last_seen_index ON sessions(LastSeenAt);
 
+CREATE TABLE networks (
+  NetworkID   INTEGER NOT NULL PRIMARY KEY,
+  Name        TEXT    NOT NULL UNIQUE, -- Network/interface name.
+  Network     BLOB    NOT NULL UNIQUE  -- Network (/24), example 10.51.50.0
+) WITHOUT ROWID;
+
 CREATE TABLE peers (
-  PeerIP     INTEGER NOT NULL PRIMARY KEY, -- Final byte.
-  Version    INTEGER NOT NULL,
-  APIKey     TEXT    NOT NULL UNIQUE,
+  NetworkID  INTEGER NOT NULL,
+  PeerIP     INTEGER NOT NULL,             -- Final byte of IP.
+  Version    INTEGER NOT NULL,             -- Changes when updated.
+  APIKey     TEXT    NOT NULL UNIQUE,      -- Peer's secret API key.
   Name       TEXT    NOT NULL UNIQUE,      -- For humans.
   PublicIP   BLOB    NOT NULL,
   Port       INTEGER NOT NULL,
   Relay      INTEGER NOT NULL DEFAULT 0,   -- Boolean if peer will forward packets. Must also have public address.
-  PubKey     BLOB    NOT NULL
+  PubKey     BLOB    NOT NULL,
+  PubSignKey BLOB    NOT NULL,
+  PRIMARY KEY(NetworkID, PeerIP)
 ) WITHOUT ROWID;

hub/api/migrations/2024-12-27-signing-keys.sql

@@ -1 +0,0 @@
-ALTER TABLE peers ADD COLUMN PubSignKey BLOB NOT NULL DEFAULT '';

hub/api/types.go

@@ -4,4 +4,5 @@ import "vppn/hub/api/db"
 
 type Config = db.Config
 type Session = db.Session
+type Network = db.Network
 type Peer = db.Peer

hub/form.go

@@ -0,0 +1,42 @@
+package hub
+
+import (
+	"net/url"
+	"vppn/hub/api"
+
+	"git.crumpington.com/lib/go/webutil"
+)
+
+func (app *App) formGetNetwork(form url.Values) (*api.Network, error) {
+	var id int64
+	if err := webutil.NewFormScanner(form).Scan("NetworkID", &id).Error(); err != nil {
+		return nil, err
+	}
+
+	return app.api.Network_Get(id)
+}
+
+func (app *App) formGetNetworkPeers(form url.Values) (*api.Network, []*api.Peer, error) {
+	n, err := app.formGetNetwork(form)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	peers, err := app.api.Peer_List(n.NetworkID)
+	return n, peers, err
+}
+
+func (app *App) formGetPeer(form url.Values) (*api.Network, *api.Peer, error) {
+	net, err := app.formGetNetwork(form)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var ip byte
+	if err := webutil.NewFormScanner(form).Scan("PeerIP", &ip).Error(); err != nil {
+		return nil, nil, err
+	}
+
+	peer, err := app.api.Peer_Get(net.NetworkID, ip)
+	return net, peer, err
+}

hub/handlers.go

@@ -16,7 +16,7 @@ import (
 
 func (a *App) _root(s *api.Session, w http.ResponseWriter, r *http.Request) error {
 	if s.SignedIn {
-		return a.redirect(w, r, "/admin/config/")
+		return a.redirect(w, r, "/admin/network/list/")
 	} else {
 		return a.redirect(w, r, "/sign-in/")
 	}
@@ -54,54 +54,219 @@ func (a *App) _adminSignOutSubmit(s *api.Session, w http.ResponseWriter, r *http
 	return a.redirect(w, r, "/")
 }
 
-func (a *App) _adminConfig(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	peers, err := a.api.Peer_List()
+func (a *App) _adminNetworkList(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	l, err := a.api.Network_List()
 	if err != nil {
 		return err
 	}
-
-	return a.render("/admin-config.html", w, struct {
+	return a.render("/admin-network-list.html", w, struct {
 		Session  *api.Session
-		Peers   []*api.Peer
-		Config  *api.Config
-	}{
-		s,
-		peers,
-		a.api.Config_Get(),
-	})
+		Networks []*api.Network
+	}{s, l})
 }
 
-func (a *App) _adminConfigEdit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	return a.render("/admin-config-edit.html", w, struct {
-		Session *api.Session
-		Config  *api.Config
-	}{
-		s,
-		a.api.Config_Get(),
-	})
+func (a *App) _adminNetworkCreate(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	return a.render("/admin-network-create.html", w, struct{ Session *api.Session }{s})
 }
 
-func (a *App) _adminConfigEditSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	var (
-		conf  = a.api.Config_Get()
-		ipStr string
-	)
+func (a *App) _adminNetworkCreateSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	n := &api.Network{}
+	var netStr string
 
 	err := webutil.NewFormScanner(r.Form).
-		Scan("HubAddress", &conf.HubAddress).
-		Scan("VPNNetwork", &ipStr).
+		Scan("Name", &n.Name).
+		Scan("Network", &netStr).
 		Error()
 	if err != nil {
 		return err
 	}
 
-	if conf.VPNNetwork, err = stringToIP(ipStr); err != nil {
+	n.Network, err = stringToIP(netStr)
+	if err != nil {
 		return err
 	}
-	if err := a.api.Config_Update(conf); err != nil {
+
+	if err := a.api.Network_Create(n); err != nil {
 		return err
 	}
-	return a.redirect(w, r, "/admin/config/")
+
+	return a.redirect(w, r, "/admin/network/view/?NetworkID=%d", n.NetworkID)
+}
+
+func (a *App) _adminNetworkView(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	n, peers, err := a.formGetNetworkPeers(r.Form)
+	if err != nil {
+		return err
+	}
+
+	return a.render("/network/network-view.html", w, struct {
+		Session *api.Session
+		Network *api.Network
+		Peers   []*api.Peer
+	}{s, n, peers})
+}
+
+func (a *App) _adminNetworkDelete(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	n, peers, err := a.formGetNetworkPeers(r.Form)
+	if err != nil {
+		return err
+	}
+
+	return a.render("/network/network-delete.html", w, struct {
+		Session *api.Session
+		Network *api.Network
+		Peers   []*api.Peer
+	}{s, n, peers})
+}
+
+func (a *App) _adminNetworkDeleteSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	n, err := a.formGetNetwork(r.Form)
+	if err != nil {
+		return err
+	}
+
+	if err = a.api.Network_Delete(n); err != nil {
+		return err
+	}
+	return a.redirect(w, r, "/admin/network/list/")
+}
+
+func (a *App) _adminPeerCreate(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	n, err := a.formGetNetwork(r.Form)
+	if err != nil {
+		return err
+	}
+
+	return a.render("/network/peer-create.html", w, struct {
+		Session *api.Session
+		Network *api.Network
+	}{s, n})
+}
+
+func (a *App) _adminPeerCreateSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	var ipStr string
+
+	p := &api.Peer{}
+	err := webutil.NewFormScanner(r.Form).
+		Scan("NetworkID", &p.NetworkID).
+		Scan("IP", &p.PeerIP).
+		Scan("Name", &p.Name).
+		Scan("PublicIP", &ipStr).
+		Scan("Port", &p.Port).
+		Scan("Relay", &p.Relay).
+		Error()
+	if err != nil {
+		return err
+	}
+
+	if p.PublicIP, err = stringToIP(ipStr); err != nil {
+		return err
+	}
+
+	if err := a.api.Peer_CreateNew(p); err != nil {
+		return err
+	}
+	return a.redirect(w, r, "/admin/peer/view/?NetworkID=%d&PeerIP=%d", p.NetworkID, p.PeerIP)
+}
+
+func (a *App) _adminPeerView(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	net, peer, err := a.formGetPeer(r.Form)
+	if err != nil {
+		return err
+	}
+
+	return a.render("/network/peer-view.html", w, struct {
+		Session *api.Session
+		Network *api.Network
+		Peer    *api.Peer
+	}{s, net, peer})
+}
+
+func (a *App) _adminPeerEdit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	net, peer, err := a.formGetPeer(r.Form)
+	if err != nil {
+		return err
+	}
+
+	return a.render("/network/peer-edit.html", w, struct {
+		Session *api.Session
+		Network *api.Network
+		Peer    *api.Peer
+	}{s, net, peer})
+}
+
+func (a *App) _adminPeerEditSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	_, peer, err := a.formGetPeer(r.Form)
+	if err != nil {
+		return err
+	}
+
+	var ipStr string
+
+	err = webutil.NewFormScanner(r.Form).
+		Scan("Name", &peer.Name).
+		Scan("PublicIP", &ipStr).
+		Scan("Port", &peer.Port).
+		Scan("Relay", &peer.Relay).
+		Error()
+	if err != nil {
+		return err
+	}
+
+	if peer.PublicIP, err = stringToIP(ipStr); err != nil {
+		return err
+	}
+
+	if err = a.api.Peer_Update(peer); err != nil {
+		return err
+	}
+
+	return a.redirect(w, r, "/admin/peer/view/?NetworkID=%d&PeerIP=%d", peer.NetworkID, peer.PeerIP)
+}
+
+func (a *App) _adminPeerDelete(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	n, peer, err := a.formGetPeer(r.Form)
+	if err != nil {
+		return err
+	}
+
+	return a.render("/network/peer-delete.html", w, struct {
+		Session *api.Session
+		Network *api.Network
+		Peer    *api.Peer
+	}{s, n, peer})
+}
+
+func (a *App) _adminPeerDeleteSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	n, peer, err := a.formGetPeer(r.Form)
+	if err != nil {
+		return err
+	}
+	if err := a.api.Peer_Delete(n.NetworkID, peer.PeerIP); err != nil {
+		return err
+	}
+	return a.redirect(w, r, "/admin/network/view/?NetworkID=%d", n.NetworkID)
+}
+
+func (a *App) _adminNetworkHosts(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	n, peers, err := a.formGetNetworkPeers(r.Form)
+	if err != nil {
+		return err
+	}
+
+	b := strings.Builder{}
+
+	for _, peer := range peers {
+		ip := n.Network
+		ip[3] = peer.PeerIP
+		b.WriteString(netip.AddrFrom4([4]byte(ip)).String())
+		b.WriteString(" ")
+		b.WriteString(peer.Name)
+		b.WriteString("\n")
+	}
+
+	w.Write([]byte(b.String()))
+	return nil
 }
 
 func (a *App) _adminPasswordEdit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
@@ -143,194 +308,61 @@ func (a *App) _adminPasswordSubmit(s *api.Session, w http.ResponseWriter, r *htt
 		return err
 	}
 
-	if err := a.api.Config_UpdatePassword(hash); err != nil {
+	conf.Password = hash
+
+	if err := a.api.Config_Update(conf); err != nil {
 		return err
 	}
 
 	return a.redirect(w, r, "/admin/config/")
 }
 
-func (a *App) _adminHosts(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	conf := a.api.Config_Get()
-
-	peers, err := a.api.Peer_List()
-	if err != nil {
-		return err
-	}
-
-	b := strings.Builder{}
-
-	for _, peer := range peers {
-		ip := conf.VPNNetwork
-		ip[3] = peer.PeerIP
-		b.WriteString(netip.AddrFrom4([4]byte(ip)).String())
-		b.WriteString(" ")
-		b.WriteString(peer.Name)
-		b.WriteString("\n")
-	}
-
-	w.Write([]byte(b.String()))
-	return nil
-}
-
-func (a *App) _adminPeerCreate(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	return a.render("/admin-peer-create.html", w, struct{ Session *api.Session }{s})
-}
-
-func (a *App) _adminPeerCreateSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	var ipStr string
-
-	p := &api.Peer{}
-	err := webutil.NewFormScanner(r.Form).
-		Scan("IP", &p.PeerIP).
-		Scan("Name", &p.Name).
-		Scan("PublicIP", &ipStr).
-		Scan("Port", &p.Port).
-		Scan("Relay", &p.Relay).
-		Error()
-	if err != nil {
-		return err
-	}
-
-	if p.PublicIP, err = stringToIP(ipStr); err != nil {
-		return err
-	}
-
-	if err := a.api.Peer_CreateNew(p); err != nil {
-		return err
-	}
-	return a.redirect(w, r, "/admin/peer/view/?PeerIP=%d", p.PeerIP)
-}
-
-func (a *App) _adminPeerView(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	var peerIP byte
-	err := webutil.NewFormScanner(r.Form).Scan("PeerIP", &peerIP).Error()
-	if err != nil {
-		return err
-	}
-
-	peer, err := a.api.Peer_Get(peerIP)
-	if err != nil {
-		return err
-	}
-
-	return a.render("/admin-peer-view.html", w, struct {
-		Session *api.Session
-		Peer    *api.Peer
-	}{s, peer})
-}
-
-func (a *App) _adminPeerEdit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	var peerIP byte
-	err := webutil.NewFormScanner(r.Form).Scan("PeerIP", &peerIP).Error()
-	if err != nil {
-		return err
-	}
-
-	peer, err := a.api.Peer_Get(peerIP)
-	if err != nil {
-		return err
-	}
-
-	return a.render("/admin-peer-edit.html", w, struct {
-		Session *api.Session
-		Peer    *api.Peer
-	}{s, peer})
-}
-
-func (a *App) _adminPeerEditSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	var (
-		peerIP byte
-		ipStr  string
-	)
-
-	err := webutil.NewFormScanner(r.Form).Scan("PeerIP", &peerIP).Error()
-	if err != nil {
-		return err
-	}
-
-	peer, err := a.api.Peer_Get(peerIP)
-	if err != nil {
-		return err
-	}
-	err = webutil.NewFormScanner(r.Form).
-		Scan("Name", &peer.Name).
-		Scan("PublicIP", &ipStr).
-		Scan("Port", &peer.Port).
-		Scan("Relay", &peer.Relay).
-		Error()
-	if err != nil {
-		return err
-	}
-
-	if peer.PublicIP, err = stringToIP(ipStr); err != nil {
-		return err
-	}
-
-	if err = a.api.Peer_Update(peer); err != nil {
-		return err
-	}
-
-	return a.redirect(w, r, "/admin/peer/view/?PeerIP=%d", peer.PeerIP)
-}
-
-func (a *App) _adminPeerDelete(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	var peerIP byte
-	err := webutil.NewFormScanner(r.Form).Scan("PeerIP", &peerIP).Error()
-	if err != nil {
-		return err
-	}
-
-	peer, err := a.api.Peer_Get(peerIP)
-	if err != nil {
-		return err
-	}
-
-	return a.render("/admin-peer-delete.html", w, struct {
-		Session *api.Session
-		Peer    *api.Peer
-	}{s, peer})
-}
-
-func (a *App) _adminPeerDeleteSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	var peerIP byte
-	err := webutil.NewFormScanner(r.Form).Scan("PeerIP", &peerIP).Error()
-	if err != nil {
-		return err
-	}
-
-	if err := a.api.Peer_Delete(peerIP); err != nil {
-		return err
-	}
-
-	return a.redirect(w, r, "/admin/peer/list/")
-}
-
 func (a *App) _peerInit(peer *api.Peer, w http.ResponseWriter, r *http.Request) error {
 	args := m.PeerInitArgs{}
 	if err := json.NewDecoder(r.Body).Decode(&args); err != nil {
 		return err
 	}
 
-	conf, err := a.api.Peer_Init(peer, args)
+	net, err := a.api.Network_Get(peer.NetworkID)
 	if err != nil {
 		return err
 	}
 
-	return a.sendJSON(w, conf)
+	if err := a.api.Peer_Init(peer, args); err != nil {
+		return err
+	}
+
+	resp := m.PeerInitResp{
+		PeerIP:  peer.PeerIP,
+		Network: net.Network,
+	}
+
+	resp.NetworkState.Peers, err = a.peersArray(net.NetworkID)
+	if err != nil {
+		return err
+	}
+
+	return a.sendJSON(w, resp)
 }
 
 func (a *App) _peerFetchState(peer *api.Peer, w http.ResponseWriter, r *http.Request) error {
-	peers, err := a.api.Peer_List()
+
+	peers, err := a.peersArray(peer.NetworkID)
 	if err != nil {
 		return err
 	}
+	return a.sendJSON(w, m.NetworkState{Peers: peers})
+}
 
-	state := m.NetworkState{}
+func (a *App) peersArray(networkID int64) (peers [256]*m.Peer, err error) {
+	l, err := a.api.Peer_List(networkID)
+	if err != nil {
+		return peers, err
+	}
 
-	for _, p := range peers {
+	for _, p := range l {
 		if len(p.PubKey) != 0 {
-			state.Peers[p.PeerIP] = &m.Peer{
+			peers[p.PeerIP] = &m.Peer{
 				PeerIP:     p.PeerIP,
 				Version:    p.Version,
 				Name:       p.Name,
@@ -343,5 +375,5 @@ func (a *App) _peerFetchState(peer *api.Peer, w http.ResponseWriter, r *http.Req
 		}
 	}
 
-	return a.sendJSON(w, state)
+	return
 }

hub/routes.go

@@ -9,14 +9,17 @@ func (a *App) registerRoutes() {
 	a.handleNotSignedIn("GET  /sign-in/", a._signin)
 	a.handleNotSignedIn("POST /sign-in/", a._signinSubmit)
 
-	a.handleSignedIn("GET  /admin/config/", a._adminConfig)
-	a.handleSignedIn("GET  /admin/config/edit/", a._adminConfigEdit)
-	a.handleSignedIn("POST /admin/config/edit/", a._adminConfigEditSubmit)
 	a.handleSignedIn("GET  /admin/sign-out/", a._adminSignOut)
 	a.handleSignedIn("POST /admin/sign-out/", a._adminSignOutSubmit)
-	a.handleSignedIn("GET  /admin/password/edit/", a._adminPasswordEdit)
-	a.handleSignedIn("POST /admin/password/edit/", a._adminPasswordSubmit)
-	a.handleSignedIn("GET  /admin/peer/hosts/", a._adminHosts)
+
+	a.handleSignedIn("GET  /admin/network/list/", a._adminNetworkList)
+	a.handleSignedIn("GET  /admin/network/create/", a._adminNetworkCreate)
+	a.handleSignedIn("POST /admin/network/create/", a._adminNetworkCreateSubmit)
+	a.handleSignedIn("GET  /admin/network/delete/", a._adminNetworkDelete)
+	a.handleSignedIn("POST /admin/network/delete/", a._adminNetworkDeleteSubmit)
+
+	a.handleSignedIn("GET  /admin/network/view/", a._adminNetworkView)
+	a.handleSignedIn("GET  /admin/network/hosts/", a._adminNetworkHosts)
 	a.handleSignedIn("GET  /admin/peer/create/", a._adminPeerCreate)
 	a.handleSignedIn("POST /admin/peer/create/", a._adminPeerCreateSubmit)
 	a.handleSignedIn("GET  /admin/peer/view/", a._adminPeerView)
@@ -25,6 +28,9 @@ func (a *App) registerRoutes() {
 	a.handleSignedIn("GET  /admin/peer/delete/", a._adminPeerDelete)
 	a.handleSignedIn("POST /admin/peer/delete/", a._adminPeerDeleteSubmit)
 
+	a.handleSignedIn("GET  /admin/password/edit/", a._adminPasswordEdit)
+	a.handleSignedIn("POST /admin/password/edit/", a._adminPasswordSubmit)
+
 	a.handlePeer("POST /peer/init/", a._peerInit)
 	a.handlePeer("GET /peer/fetch-state/", a._peerFetchState)
 }

hub/templates/admin-config-edit.html

@@ -1,20 +0,0 @@
-{{define "body" -}}
-<h2>Config</h2>
-
-<form method="POST">
-  <input type="hidden" name="CSRF" value="{{.Session.CSRF}}">
-  <p>
-    <label>Hub Address</label><br>
-    <input type="url" name="HubAddress" value="{{.Config.HubAddress}}">
-  </p>
-  <p>
-    <label>VPN Network</label><br>
-    <input type="text" name="VPNNetwork" value="{{ipToString .Config.VPNNetwork}}">
-  </p>
-  <p>
-    <button type="submit">Save</button>
-    <a href="/admin/config/">Cancel</a>
-  </p>
-</form>
-
-{{- end}}

hub/templates/admin-network-create.html

@@ -0,0 +1,19 @@
+{{define "body" -}}
+<h2>Create Network</h2>
+
+<form method="POST">
+  <input type="hidden" name="CSRF" value="{{.Session.CSRF}}">
+  <p>
+    <label>Name</label><br>
+    <input type="text" name="Name">
+  </p>
+  <p>
+    <label>Network /24</label><br>
+    <input type="text" name="Network">
+  </p>
+  <p>
+    <button type="submit">Save</button>
+    <a href="/admin/network/list/">Cancel</a>
+  </p>
+</form>
+{{- end}}

hub/templates/admin-network-list.html

@@ -0,0 +1,38 @@
+{{define "body" -}}
+<h2>Networks</h2>
+
+<p>
+  <a href="/admin/network/create/">Create</a>
+</p>
+
+{{if .Networks -}}
+<table>
+  <thead>
+    <tr>
+      <th>Name</th>
+      <th>Network</th>
+    </tr>
+  </thead>
+  <tbody>
+  {{range .Networks -}}
+  <tr>
+    <td>
+      <a href="/admin/network/view/?NetworkID={{.NetworkID}}">
+        {{.Name}}
+      </a>
+    </td>
+    <td>{{ipToString .Network}}</td>
+  </tr>
+  </tbody>
+  {{- end}}
+</table>
+{{- else}}
+<p>No networks.</p>
+{{- end}}
+
+<h3>Settings</h3>
+
+<ul>
+  <li><a href="/admin/password/edit/">Password</a></li>
+</ul>
+{{- end}}

hub/templates/admin-peer-delete.html

@@ -1,36 +0,0 @@
-{{define "body" -}}
-<h2>Delete Peer</h2>
-
-{{with .Peer -}}
-<form method="POST">
-  <input type="hidden" name="CSRF" value="{{$.Session.CSRF}}">
-  <p>
-    <label>Peer IP</label><br>
-    <input type="number" name="PeerIP" value="{{.PeerIP}}" disabled>
-  </p>
-  <p>
-    <label>Name</label><br>
-    <input type="text" value="{{.Name}}" disabled>
-  </p>
-  <p>
-    <label>Public IP</label><br>
-    <input type="text" value="{{ipToString .PublicIP}}" disabled>
-  </p>
-  <p>
-    <label>Port</label><br>
-    <input type="number" value="{{.Port}}" disabled>
-  </p>
-  <p>
-    <label>
-      <input type="checkbox" {{if .Relay}}checked{{end}} disabled>
-      Relay
-    </label>
-  </p>
-  <p>
-    <button type="submit">Delete</button>
-    <a href="/admin/peer/view/?PeerIP={{.PeerIP}}">Cancel</a>
-  </p>
-</form>
-{{- end}}
-
-{{- end}}

hub/templates/admin-peer-init.html

@@ -1,13 +0,0 @@
-{{define "body" -}}
-<h2>Initialize Peer</h2>
-
-<p>
-  Configure the peer with the following URL:
-</p>
-<pre>
-  {{.HubAddress}}/peer/init/?Code={{.Code}}
-</pre>
-<p>
-  <a href="/admin/config/">Done</a>
-</p>
-{{- end}}

hub/templates/admin-peer-intent.html

@@ -1,13 +0,0 @@
-{{define "body" -}}
-<h2>Create Peer</h2>
-
-<p>
-  Configure the peer with the following URL:
-</p>
-<pre>
-  {{.HubAddress}}/peer/create/?Code={{.Code}}
-</pre>
-<p>
-  <a href="/admin/config/">Done</a>
-</p>
-{{- end}}

hub/templates/admin-sign-out.html

@@ -5,7 +5,7 @@
   <input type="hidden" name="CSRF" value="{{.Session.CSRF}}">
   <p>
     <button type="submit">Sign Out</button>
-    <a href="/admin/config/">Cancel</a>
+    <a href="/">Cancel</a>
   </p>
 </form>
 {{- end}}

hub/templates/base.html

@@ -10,7 +10,7 @@
     <h1>VPPN</h1>
     <nav>
       {{if .Session.SignedIn -}}
-      <a href="/admin/config/">Home</a> /
+      <a href="/admin/networks/list/">Home</a> /
       <a href="/admin/sign-out/">Sign out</a>
       {{- end}}
     </nav>

hub/templates/network/base.html

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>VPPN Hub</title>
+  <link rel="stylesheet" href="/static/new.min.css">
+    <link rel="stylesheet" href="/static/custom.css">
+</head>
+<body>
+  <header>
+    <h1>VPPN</h1>
+    <nav>
+      {{if .Session.SignedIn -}}
+      <a href="/admin/networks/list/">Home</a> /
+      <a href="/admin/sign-out/">Sign out</a>
+      {{- end}}
+    </nav>
+  </header>
+  <h2>
+    Network:
+    <a href="/admin/network/view/?NetworkID={{.Network.NetworkID}}">{{.Network.Name}}</a>
+  </h2>
+
+  {{block "body" .}}There's nothing here.{{end}}
+</body>
+</html>

hub/templates/network/network-delete.html

@@ -0,0 +1,16 @@
+{{define "body" -}}
+<h3>Delete</h3>
+
+{{if .Peers -}}
+<p>You must first delete all peers.</p>
+{{- else -}}
+<form method="POST">
+  <input type="hidden" name="CSRF" value="{{.Session.CSRF}}">
+  <input type="hidden" name="NetworkID" value="{{.Network.NetworkID}}">
+  <p>
+    <button type="submit">Delete</button>
+    <a href="/admin/network/view/?NetworkID={{.Network.NetworkID}}">Cancel</a>
+  </p>
+</form>
+{{- end}}
+{{- end}}

hub/templates/network/network-view.html

@@ -1,27 +1,20 @@
 {{define "body" -}}
-<h2>Config</h2>
-
 <p>
-  <a href="/admin/config/edit/">Edit</a> /
-  <a href="/admin/password/edit/">Change Password</a>
+  <a href="/admin/network/delete/?NetworkID={{.Network.NetworkID}}">Delete</a> /
+  <a href="/admin/network/hosts/?NetworkID={{.Network.NetworkID}}">Hosts</a>
 </p>
 
 <table class="def-list">
   <tr>
-    <td>Hub Address</td>
-    <td>{{.Config.HubAddress}}</td>
-  </tr>
-  <tr>
-    <td>VPN Network</td>
-    <td>{{ipToString .Config.VPNNetwork}}</td>
+    <td>Network</td>
+    <td>{{ipToString .Network.Network}}/24</td>
   </tr>
 </table>
 
-<h2>Peers</h2>
+<h3>Peers</h3>
 
 <p>
-  <a href="/admin/peer/create/">Add Peer</a> /
-  <a href="/admin/peer/hosts/">Hosts</a>
+  <a href="/admin/peer/create/?NetworkID={{.Network.NetworkID}}">Create</a>
 </p>
 
 {{if .Peers -}}
@@ -39,7 +32,7 @@
   {{range .Peers -}}
   <tr>
     <td>
-      <a href="/admin/peer/view/?PeerIP={{.PeerIP}}">
+      <a href="/admin/peer/view/?NetworkID={{$.Network.NetworkID}}&PeerIP={{.PeerIP}}">
         {{.PeerIP}}
       </a>
     </td>

hub/templates/network/peer-create.html

@@ -1,8 +1,9 @@
 {{define "body" -}}
-<h2>New Peer</h2>
+<h3>New Peer</h3>
 
 <form method="POST">
   <input type="hidden" name="CSRF" value="{{.Session.CSRF}}">
+  <input type="hidden" name="NetworkID" value="{{.Network.NetworkID}}">
   <p>
     <label>IP</label><br>
     <input type="number" name="IP" min="1" max="255" value="0">
@@ -27,7 +28,7 @@
   </p>
   <p>
     <button type="submit">Save</button>
-    <a href="/admin/config/">Cancel</a>
+    <a href="/admin/network/view/?NetworkID={{.Network.NetworkID}}">Cancel</a>
   </p>
 </form>
 

hub/templates/network/peer-delete.html

@@ -0,0 +1,15 @@
+{{define "body" -}}
+<h3>Delete {{.Peer.Name}}</h3>
+
+{{with .Peer -}}
+<form method="POST">
+  <input type="hidden" name="CSRF" value="{{$.Session.CSRF}}">
+  <input type="hidden" name="NetworkID" value="{{.NetworkID}}">
+  <input type="hidden" name="NetworkID" value="{{.PeerIP}}">
+  <p>
+    <button type="submit">Delete</button>
+    <a href="/admin/peer/view/?PeerIP={{.PeerIP}}&NetworkID={{.NetworkID}}">Cancel</a>
+  </p>
+</form>
+{{- end}}
+{{- end}}

hub/templates/network/peer-edit.html

@@ -6,7 +6,7 @@
   <input type="hidden" name="CSRF" value="{{$.Session.CSRF}}">
   <p>
     <label>Peer IP</label><br>
-    <input type="number" name="PeerIP" value="{{.PeerIP}}" disabled>
+    <input type="text" value="{{.PeerIP}}" disabled>
   </p>
   <p>
     <label>Name</label><br>
@@ -28,9 +28,8 @@
   </p>
   <p>
     <button type="submit">Save</button>
-    <a href="/admin/peer/view/?PeerIP={{.PeerIP}}">Cancel</a>
+    <a href="/admin/peer/view/?NetworkID={{$.Network.NetworkID}}&PeerIP={{.PeerIP}}">Cancel</a>
   </p>
 </form>
 {{- end}}
-
 {{- end}}

hub/templates/network/peer-view.html

@@ -1,20 +1,25 @@
 {{define "body" -}}
-<h2>Peer</h2>
-
+<h3>{{.Peer.Name}}</h3>
 <p>
-  <a href="/admin/peer/edit/?PeerIP={{.Peer.PeerIP}}">Edit</a> /
-  <a href="/admin/peer/delete/?PeerIP={{.Peer.PeerIP}}">Delete</a>
+  <a href="/admin/peer/edit/?NetworkID={{.Network.NetworkID}}&PeerIP={{.Peer.PeerIP}}">Edit</a> /
+  <a href="/admin/peer/delete/?NetworkID={{.Network.NetworkID}}&PeerIP={{.Peer.PeerIP}}">Delete</a>
 </p>
 
 {{with .Peer -}}
 <table class="def-list">
   <tr><td>Peer IP</td><td>{{.PeerIP}}</td></tr>
-  <tr><td>Name</td><td>{{.Name}}</td></tr>
   <tr><td>Public IP</td><td>{{ipToString .PublicIP}}</td></tr>
   <tr><td>Port</td><td>{{.Port}}</td></tr>
   <tr><td>Relay</td><td>{{if .Relay}}T{{else}}F{{end}}</td></tr>
-  <tr><td>API Key</td><td>{{.APIKey}}</td></tr>
+</td></tr>
 </table>
+
+<details>
+  <summary>API Key</summary>
+  <p>{{.APIKey}}</p>
+</details>
+
+
 {{- end}}
 
 {{- end}}

m/models.go

@@ -6,12 +6,10 @@ type PeerInitArgs struct {
 	PubSignKey []byte
 }
 
-type PeerConfig struct {
+type PeerInitResp struct {
 	PeerIP       byte
 	Network      []byte
-	PublicIP []byte
-	Port     uint16
-	Relay    bool
+	NetworkState NetworkState
 }
 
 type Peer struct {

peer/cipher-control.go

@@ -12,7 +12,7 @@ func newControlCipher(privKey, pubKey []byte) *controlCipher {
 	return &controlCipher{shared}
 }
 
-func (cc *controlCipher) Encrypt(h header, data, out []byte) []byte {
+func (cc *controlCipher) Encrypt(h Header, data, out []byte) []byte {
 	const s = controlHeaderSize
 	out = out[:s+controlCipherOverhead+len(data)]
 	h.Marshal(out[:s])

peer/cipher-control_test.go

@@ -40,7 +40,7 @@ func TestControlCipher(t *testing.T) {
 	}
 
 	for _, plaintext := range testCases {
-		h1 := header{
+		h1 := Header{
 			StreamID: controlStreamID,
 			Counter:  235153,
 			SourceIP: 4,
@@ -51,7 +51,7 @@ func TestControlCipher(t *testing.T) {
 
 		encrypted = c1.Encrypt(h1, plaintext, encrypted)
 
-		h2 := header{}
+		h2 := Header{}
 		h2.Parse(encrypted)
 		if !reflect.DeepEqual(h1, h2) {
 			t.Fatal(h1, h2)
@@ -80,7 +80,7 @@ func TestControlCipher_ShortCiphertext(t *testing.T) {
 
 func BenchmarkControlCipher_Encrypt(b *testing.B) {
 	c1, _ := newControlCipherForTesting()
-	h1 := header{
+	h1 := Header{
 		Counter:  235153,
 		SourceIP: 4,
 		DestIP:   88,
@@ -100,7 +100,7 @@ func BenchmarkControlCipher_Encrypt(b *testing.B) {
 func BenchmarkControlCipher_Decrypt(b *testing.B) {
 	c1, c2 := newControlCipherForTesting()
 
-	h1 := header{
+	h1 := Header{
 		Counter:  235153,
 		SourceIP: 4,
 		DestIP:   88,

peer/cipher-data.go

@@ -1,6 +1,7 @@
 package peer
 
 import (
+	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/rand"
@@ -38,7 +39,11 @@ func (sc *dataCipher) Key() [32]byte {
 	return sc.key
 }
 
-func (sc *dataCipher) Encrypt(h header, data, out []byte) []byte {
+func (sc *dataCipher) HasKey(k [32]byte) bool {
+	return bytes.Equal(k[:], sc.key[:])
+}
+
+func (sc *dataCipher) Encrypt(h Header, data, out []byte) []byte {
 	const s = dataHeaderSize
 	out = out[:s+dataCipherOverhead+len(data)]
 	h.Marshal(out[:s])

peer/cipher-data_test.go

@@ -22,7 +22,7 @@ func TestDataCipher(t *testing.T) {
 	}
 
 	for _, plaintext := range testCases {
-		h1 := header{
+		h1 := Header{
 			StreamID: dataStreamID,
 			Counter:  235153,
 			SourceIP: 4,
@@ -33,7 +33,7 @@ func TestDataCipher(t *testing.T) {
 
 		dc1 := newDataCipher()
 		encrypted = dc1.Encrypt(h1, plaintext, encrypted)
-		h2 := header{}
+		h2 := Header{}
 		h2.Parse(encrypted)
 
 		dc2 := newDataCipherFromKey(dc1.Key())
@@ -67,7 +67,7 @@ func TestDataCipher_ModifyCiphertext(t *testing.T) {
 	}
 
 	for _, plaintext := range testCases {
-		h1 := header{
+		h1 := Header{
 			Counter:  235153,
 			SourceIP: 4,
 			DestIP:   88,
@@ -99,7 +99,7 @@ func TestDataCipher_ShortCiphertext(t *testing.T) {
 }
 
 func BenchmarkDataCipher_Encrypt(b *testing.B) {
-	h1 := header{
+	h1 := Header{
 		Counter:  235153,
 		SourceIP: 4,
 		DestIP:   88,
@@ -118,7 +118,7 @@ func BenchmarkDataCipher_Encrypt(b *testing.B) {
 }
 
 func BenchmarkDataCipher_Decrypt(b *testing.B) {
-	h1 := header{
+	h1 := Header{
 		Counter:  235153,
 		SourceIP: 4,
 		DestIP:   88,

peer/cipher-discovery.go

@@ -1,13 +0,0 @@
-package peer
-
-/*
-func signData(privKey *[64]byte, h header, data, out []byte) []byte {
-	out = out[:headerSize]
-	h.Marshal(out)
-	return sign.Sign(out, data, privKey)
-}
-
-func openData(pubKey *[32]byte, signed, out []byte) (data []byte, ok bool) {
-	return sign.Open(out[:0], signed[headerSize:], pubKey)
-}
-*/

peer/connreader.go

@@ -1,56 +1,34 @@
 package peer
 
 import (
-	"io"
 	"log"
+	"net"
 	"net/netip"
-	"sync/atomic"
 )
 
-type connReader struct {
-	// Input
-	readFromUDPAddrPort func([]byte) (int, netip.AddrPort, error)
-
-	// Output
-	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error)
-	iface              io.Writer
-	handleControlMsg   func(fromIP byte, pkt any)
-
-	localIP byte
-	rt      *atomic.Pointer[routingTable]
-
+type ConnReader struct {
+	Globals
+	conn *net.UDPConn
 	buf  []byte
-	decBuf []byte
 }
 
-func newConnReader(
-	readFromUDPAddrPort func([]byte) (int, netip.AddrPort, error),
-	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error),
-	iface io.Writer,
-	handleControlMsg func(fromIP byte, pkt any),
-	rt *atomic.Pointer[routingTable],
-) *connReader {
-	return &connReader{
-		readFromUDPAddrPort: readFromUDPAddrPort,
-		writeToUDPAddrPort:  writeToUDPAddrPort,
-		iface:               iface,
-		handleControlMsg:    handleControlMsg,
-		localIP:             rt.Load().LocalIP,
-		rt:                  rt,
-		buf:                 newBuf(),
-		decBuf:              newBuf(),
+func NewConnReader(g Globals, conn *net.UDPConn) *ConnReader {
+	return &ConnReader{
+		Globals: g,
+		conn:    conn,
+		buf:     make([]byte, bufferSize),
 	}
 }
 
-func (r *connReader) Run() {
+func (r *ConnReader) Run() {
 	for {
 		r.handleNextPacket()
 	}
 }
 
-func (r *connReader) handleNextPacket() {
+func (r *ConnReader) handleNextPacket() {
 	buf := r.buf[:bufferSize]
-	n, remoteAddr, err := r.readFromUDPAddrPort(buf)
+	n, remoteAddr, err := r.conn.ReadFromUDPAddrPort(buf)
 	if err != nil {
 		log.Fatalf("Failed to read from UDP port: %v", err)
 	}
@@ -64,77 +42,5 @@ func (r *connReader) handleNextPacket() {
 	buf = buf[:n]
 	h := parseHeader(buf)
 
-	rt := r.rt.Load()
-	peer := rt.Peers[h.SourceIP]
-
-	switch h.StreamID {
-	case controlStreamID:
-		r.handleControlPacket(remoteAddr, peer, h, buf)
-	case dataStreamID:
-		r.handleDataPacket(rt, peer, h, buf)
-	default:
-		r.logf("Unknown stream ID: %d", h.StreamID)
-	}
-}
-
-func (r *connReader) handleControlPacket(
-	remoteAddr netip.AddrPort,
-	peer remotePeer,
-	h header,
-	enc []byte,
-) {
-	if peer.ControlCipher == nil {
-		r.logf("No control cipher for peer: %d", h.SourceIP)
-		return
-	}
-
-	if h.DestIP != r.localIP {
-		r.logf("Incorrect destination IP on control packet: %d", h.DestIP)
-		return
-	}
-
-	msg, err := peer.DecryptControlPacket(remoteAddr, h, enc, r.decBuf)
-	if err != nil {
-		r.logf("Failed to decrypt control packet: %v", err)
-		return
-	}
-
-	r.handleControlMsg(h.SourceIP, msg)
-}
-
-func (r *connReader) handleDataPacket(
-	rt *routingTable,
-	peer remotePeer,
-	h header,
-	enc []byte,
-) {
-	if !peer.Up {
-		r.logf("Not connected (recv).")
-		return
-	}
-
-	data, err := peer.DecryptDataPacket(h, enc, r.decBuf)
-	if err != nil {
-		r.logf("Failed to decrypt data packet: %v", err)
-		return
-	}
-
-	if h.DestIP == r.localIP {
-		if _, err := r.iface.Write(data); err != nil {
-			log.Fatalf("Failed to write to interface: %v", err)
-		}
-		return
-	}
-
-	remote := rt.Peers[h.DestIP]
-	if !remote.Direct {
-		r.logf("Unable to relay data to %d.", h.DestIP)
-		return
-	}
-
-	r.writeToUDPAddrPort(data, remote.DirectAddr)
-}
-
-func (r *connReader) logf(format string, args ...any) {
-	log.Printf("[ConnReader] "+format, args...)
+	r.RemotePeers[h.SourceIP].Load().HandlePacket(h, remoteAddr, buf)
 }

peer/crypto_test.go

@@ -1,191 +0,0 @@
-package peer
-
-import (
-	"net/netip"
-	"reflect"
-	"testing"
-)
-
-func newRoutePairForTesting() (*remotePeer, *remotePeer) {
-	keys1 := generateKeys()
-	keys2 := generateKeys()
-
-	r1 := newRemotePeer(1)
-	r1.PubSignKey = keys1.PubSignKey
-	r1.ControlCipher = newControlCipher(keys1.PrivKey, keys2.PubKey)
-	r1.DataCipher = newDataCipher()
-
-	r2 := newRemotePeer(2)
-	r2.PubSignKey = keys2.PubSignKey
-	r2.ControlCipher = newControlCipher(keys2.PrivKey, keys1.PubKey)
-	r2.DataCipher = r1.DataCipher
-
-	return r1, r2
-}
-
-func TestDecryptControlPacket(t *testing.T) {
-	var (
-		r1, r2 = newRoutePairForTesting()
-		tmp    = make([]byte, bufferSize)
-		out    = make([]byte, bufferSize)
-	)
-
-	in := packetSyn{
-		TraceID:   newTraceID(),
-		SharedKey: r1.DataCipher.Key(),
-		Direct:    true,
-	}
-
-	enc := r1.EncryptControlPacket(in, tmp, out)
-	h := parseHeader(enc)
-
-	iMsg, err := r2.DecryptControlPacket(netip.AddrPort{}, h, enc, tmp)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	msg, ok := iMsg.(controlMsg[packetSyn])
-	if !ok {
-		t.Fatal(ok)
-	}
-
-	if !reflect.DeepEqual(msg.Packet, in) {
-		t.Fatal(msg)
-	}
-}
-
-/*
-	func TestDecryptControlPacket_decryptionFailed(t *testing.T) {
-		var (
-			r1, r2 = newRoutePairForTesting()
-			tmp    = make([]byte, bufferSize)
-			out    = make([]byte, bufferSize)
-		)
-
-		in := packetSyn{
-			TraceID:   newTraceID(),
-			SharedKey: r1.DataCipher.Key(),
-			Direct:    true,
-		}
-
-		enc := encryptControlPacket(r1.IP, r2, in, tmp, out)
-		h := parseHeader(enc)
-
-		for i := range enc {
-			x := bytes.Clone(enc)
-			x[i]++
-			_, err := decryptControlPacket(r2, netip.AddrPort{}, h, x, tmp)
-			if !errors.Is(err, errDecryptionFailed) {
-				t.Fatal(i, err)
-			}
-		}
-	}
-
-	func TestDecryptControlPacket_duplicate(t *testing.T) {
-		var (
-			r1, r2 = newRoutePairForTesting()
-			tmp    = make([]byte, bufferSize)
-			out    = make([]byte, bufferSize)
-		)
-
-		in := packetSyn{
-			TraceID:   newTraceID(),
-			SharedKey: r1.DataCipher.Key(),
-			Direct:    true,
-		}
-
-		enc := encryptControlPacket(r1.IP, r2, in, tmp, out)
-		h := parseHeader(enc)
-
-		if _, err := decryptControlPacket(r2, netip.AddrPort{}, h, enc, tmp); err != nil {
-			t.Fatal(err)
-		}
-
-		_, err := decryptControlPacket(r2, netip.AddrPort{}, h, enc, tmp)
-		if !errors.Is(err, errDuplicateSeqNum) {
-			t.Fatal(err)
-		}
-	}
-
-	func TestDecryptControlPacket_invalidPacket(t *testing.T) {
-		var (
-			r1, r2 = newRoutePairForTesting()
-			tmp    = make([]byte, bufferSize)
-			out    = make([]byte, bufferSize)
-		)
-
-		in := testPacket("hello!")
-
-		enc := encryptControlPacket(r1.IP, r2, in, tmp, out)
-		h := parseHeader(enc)
-
-		_, err := decryptControlPacket(r2, netip.AddrPort{}, h, enc, tmp)
-		if !errors.Is(err, errUnknownPacketType) {
-			t.Fatal(err)
-		}
-	}
-
-func TestDecryptDataPacket(t *testing.T) {
-	var (
-		r1, r2 = newRoutePairForTesting()
-		out    = make([]byte, bufferSize)
-		data   = make([]byte, 1024)
-	)
-
-	rand.Read(data)
-
-	enc := encryptDataPacket(r1.IP, r2.IP, r2, data, out)
-	h := parseHeader(enc)
-
-	out, err := decryptDataPacket(r1, h, bytes.Clone(enc), out)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !bytes.Equal(data, out) {
-		t.Fatal(data, out)
-	}
-}
-
-func TestDecryptDataPacket_incorrectCipher(t *testing.T) {
-	var (
-		r1, r2 = newRoutePairForTesting()
-		out    = make([]byte, bufferSize)
-		data   = make([]byte, 1024)
-	)
-
-	rand.Read(data)
-
-	enc := encryptDataPacket(r1.IP, r2.IP, r2, data, bytes.Clone(out))
-	h := parseHeader(enc)
-
-	r1.DataCipher = newDataCipher()
-	_, err := decryptDataPacket(r1, h, enc, bytes.Clone(out))
-	if !errors.Is(err, errDecryptionFailed) {
-		t.Fatal(err)
-	}
-}
-
-func TestDecryptDataPacket_duplicate(t *testing.T) {
-	var (
-		r1, r2 = newRoutePairForTesting()
-		out    = make([]byte, bufferSize)
-		data   = make([]byte, 1024)
-	)
-
-	rand.Read(data)
-
-	enc := encryptDataPacket(r1.IP, r2.IP, r2, data, bytes.Clone(out))
-	h := parseHeader(enc)
-
-	_, err := decryptDataPacket(r1, h, enc, bytes.Clone(out))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = decryptDataPacket(r1, h, enc, bytes.Clone(out))
-	if !errors.Is(err, errDuplicateSeqNum) {
-		t.Fatal(err)
-	}
-}
-*/

peer/data-flow.dot

@@ -1,12 +1,11 @@
 digraph d {
-    ifReader   -> connWriter;
-    connReader -> ifWriter;
-    connReader -> connWriter;
-    connReader -> supervisor;
-    mcReader   -> supervisor;
-    supervisor -> connWriter;
-    supervisor -> mcWriter;
-    hubPoller  -> supervisor;
+    ifReader   -> remote;
+
+    connReader -> remote;
+    mcReader   -> remote;
+    remote -> connWriter;
+    remote -> ifWriter;
+    hubPoller  -> remote;
 
     connWriter [shape="box"];
     mcWriter [shape="box"];

peer/dupcheck.go

@@ -51,7 +51,7 @@ func (dc *dupCheck) IsDup(counter uint64) bool {
 	}
 
 	// Clear if necessary.
-	for i := 0; i < int(delta); i++ {
+	for range delta {
 		dc.put(false)
 	}
 

peer/errors.go

@@ -3,8 +3,6 @@ package peer
 import "errors"
 
 var (
-	errDecryptionFailed  = errors.New("decryption failed")
-	errDuplicateSeqNum   = errors.New("duplicate sequence number")
 	errMalformedPacket   = errors.New("malformed packet")
 	errUnknownPacketType = errors.New("unknown packet type")
 )

peer/files.go

@@ -8,14 +8,19 @@ import (
 	"vppn/m"
 )
 
-type localConfig struct {
-	m.PeerConfig
+type LocalConfig struct {
+	LocalPeerIP byte
+	Network     []byte
 	PubKey      []byte
 	PrivKey     []byte
 	PubSignKey  []byte
 	PrivSignKey []byte
 }
 
+type startupCount struct {
+	Count uint16
+}
+
 func configDir(netName string) string {
 	d, err := os.UserHomeDir()
 	if err != nil {
@@ -25,11 +30,15 @@ func configDir(netName string) string {
 }
 
 func peerConfigPath(netName string) string {
-	return filepath.Join(configDir(netName), "peer-config.json")
+	return filepath.Join(configDir(netName), "config.json")
 }
 
 func peerStatePath(netName string) string {
-	return filepath.Join(configDir(netName), "peer-state.json")
+	return filepath.Join(configDir(netName), "state.json")
+}
+
+func startupCountPath(netName string) string {
+	return filepath.Join(configDir(netName), "startup_count.json")
 }
 
 func storeJson(x any, outPath string) error {
@@ -64,7 +73,7 @@ func storeJson(x any, outPath string) error {
 	return os.Rename(tmpPath, outPath)
 }
 
-func storePeerConfig(netName string, pc localConfig) error {
+func storePeerConfig(netName string, pc LocalConfig) error {
 	return storeJson(pc, peerConfigPath(netName))
 }
 
@@ -81,10 +90,18 @@ func loadJson(dataPath string, ptr any) error {
 	return json.Unmarshal(data, ptr)
 }
 
-func loadPeerConfig(netName string) (pc localConfig, err error) {
+func loadPeerConfig(netName string) (pc LocalConfig, err error) {
 	return pc, loadJson(peerConfigPath(netName), &pc)
 }
 
 func loadNetworkState(netName string) (ps m.NetworkState, err error) {
 	return ps, loadJson(peerStatePath(netName), &ps)
 }
+
+func loadStartupCount(netName string) (c startupCount, err error) {
+	return c, loadJson(startupCountPath(netName), &c)
+}
+
+func storeStartupCount(netName string, c startupCount) error {
+	return storeJson(c, startupCountPath(netName))
+}

peer/files_test.go

@@ -16,12 +16,12 @@ func TestFilePaths(t *testing.T) {
 	}
 
 	path := peerConfigPath("netName")
-	if path != filepath.Join(confDir, "peer-config.json") {
+	if path != filepath.Join(confDir, "config.json") {
 		t.Fatal(path)
 	}
 
 	path = peerStatePath("netName")
-	if path != filepath.Join(confDir, "peer-state.json") {
+	if path != filepath.Join(confDir, "state.json") {
 		t.Fatal(path)
 	}
 }

peer/globals.go

@@ -1,15 +1,18 @@
 package peer
 
 import (
+	"io"
 	"net"
 	"net/netip"
+	"sync"
+	"sync/atomic"
 	"time"
 )
 
 const (
 	version = 1
 
-	bufferSize = 1536
+	bufferSize = 8192 // Enough for data packets and encryption buffers.
 
 	if_mtu       = 1200
 	if_queue_len = 2048
@@ -28,10 +31,79 @@ var multicastAddr = net.UDPAddrFromAddrPort(netip.AddrPortFrom(
 	netip.AddrFrom4([4]byte{224, 0, 0, 157}),
 	4560))
 
-func newBuf() []byte {
-	return make([]byte, bufferSize)
+// ----------------------------------------------------------------------------
+
+type Globals struct {
+	LocalConfig // Embed, immutable.
+
+	// The number of startups
+	StartupCount uint16
+
+	// Local public address (if available). Immutable.
+	LocalAddr netip.AddrPort
+
+	// True if local public address is valid. Immutable.
+	LocalAddrValid bool
+
+	// All remote peers by VPN IP.
+	RemotePeers [256]*atomic.Pointer[Remote]
+
+	// Discovered public addresses.
+	PubAddrs *pubAddrStore
+
+	// Attempts to ensure that we have a relay available.
+	RelayHandler *relayHandler
+
+	// Send UDP - Global function to write UDP packets.
+	SendUDP func(b []byte, addr netip.AddrPort) (n int, err error)
+
+	// Global TUN interface.
+	IFace io.ReadWriteCloser
+
+	// For trace ID.
+	NewTraceID func() uint64
 }
 
-type marshaller interface {
-	Marshal([]byte) []byte
+func NewGlobals(
+	localConfig LocalConfig,
+	startupCount startupCount,
+	localAddr netip.AddrPort,
+	conn *net.UDPConn,
+	iface io.ReadWriteCloser,
+) (g Globals) {
+	g.LocalConfig = localConfig
+	g.StartupCount = startupCount.Count
+
+	g.LocalAddr = localAddr
+	g.LocalAddrValid = localAddr.IsValid()
+
+	g.PubAddrs = newPubAddrStore(localAddr)
+
+	g.RelayHandler = newRelayHandler()
+
+	// Use a lock here avoids starvation, at least on my Linux machine.
+	sendLock := sync.Mutex{}
+	g.SendUDP = func(b []byte, addr netip.AddrPort) (int, error) {
+		sendLock.Lock()
+		n, err := conn.WriteToUDPAddrPort(b, addr)
+		sendLock.Unlock()
+		return n, err
+	}
+
+	g.IFace = iface
+
+	traceID := (uint64(g.StartupCount) << 48) + 1
+	g.NewTraceID = func() uint64 {
+		return atomic.AddUint64(&traceID, 1)
+	}
+
+	for i := range g.RemotePeers {
+		g.RemotePeers[i] = &atomic.Pointer[Remote]{}
+	}
+
+	for i := range g.RemotePeers {
+		g.RemotePeers[i].Store(newRemote(g, byte(i)))
+	}
+
+	return g
 }

peer/header.go

@@ -6,13 +6,14 @@ import "unsafe"
 
 const (
 	headerSize        = 12
-	controlStreamID   = 2
 	controlHeaderSize = 24
-	dataStreamID      = 1
 	dataHeaderSize    = 12
+
+	dataStreamID    = 1
+	controlStreamID = 2
 )
 
-type header struct {
+type Header struct {
 	Version  byte
 	StreamID byte
 	SourceIP byte
@@ -20,7 +21,7 @@ type header struct {
 	Counter  uint64 // Init with time.Now().Unix << 30 to ensure monotonic.
 }
 
-func parseHeader(b []byte) (h header) {
+func parseHeader(b []byte) (h Header) {
 	h.Version = b[0]
 	h.StreamID = b[1]
 	h.SourceIP = b[2]
@@ -29,7 +30,7 @@ func parseHeader(b []byte) (h header) {
 	return h
 }
 
-func (h *header) Parse(b []byte) {
+func (h *Header) Parse(b []byte) {
 	h.Version = b[0]
 	h.StreamID = b[1]
 	h.SourceIP = b[2]
@@ -37,7 +38,7 @@ func (h *header) Parse(b []byte) {
 	h.Counter = *(*uint64)(unsafe.Pointer(&b[4]))
 }
 
-func (h *header) Marshal(buf []byte) {
+func (h *Header) Marshal(buf []byte) {
 	buf[0] = h.Version
 	buf[1] = h.StreamID
 	buf[2] = h.SourceIP

peer/header_test.go

@@ -3,7 +3,7 @@ package peer
 import "testing"
 
 func TestHeaderMarshalParse(t *testing.T) {
-	nIn := header{
+	nIn := Header{
 		StreamID: 23,
 		Counter:  3212,
 		SourceIP: 34,
@@ -13,7 +13,7 @@ func TestHeaderMarshalParse(t *testing.T) {
 	buf := make([]byte, headerSize)
 	nIn.Marshal(buf)
 
-	nOut := header{}
+	nOut := Header{}
 	nOut.Parse(buf)
 	if nIn != nOut {
 		t.Fatal(nIn, nOut)

peer/hubpoller.go

@@ -10,22 +10,20 @@ import (
 	"vppn/m"
 )
 
-type hubPoller struct {
+type HubPoller struct {
+	Globals
 	client   *http.Client
 	req      *http.Request
 	versions [256]int64
-	localIP          byte
 	netName  string
-	handleControlMsg func(fromIP byte, msg any)
 }
 
-func newHubPoller(
-	localIP byte,
+func NewHubPoller(
+	g Globals,
 	netName,
 	hubURL,
 	apiKey string,
-	handleControlMsg func(byte, any),
-) (*hubPoller, error) {
+) (*HubPoller, error) {
 	u, err := url.Parse(hubURL)
 	if err != nil {
 		return nil, err
@@ -41,20 +39,19 @@ func newHubPoller(
 	}
 	req.SetBasicAuth("", apiKey)
 
-	return &hubPoller{
+	return &HubPoller{
+		Globals: g,
 		client:  client,
 		req:     req,
-		localIP:          localIP,
 		netName: netName,
-		handleControlMsg: handleControlMsg,
 	}, nil
 }
 
-func (hp *hubPoller) logf(s string, args ...any) {
+func (hp *HubPoller) logf(s string, args ...any) {
 	log.Printf("[HubPoller] "+s, args...)
 }
 
-func (hp *hubPoller) Run() {
+func (hp *HubPoller) Run() {
 	state, err := loadNetworkState(hp.netName)
 	if err != nil {
 		hp.logf("Failed to load network state: %v", err)
@@ -69,7 +66,7 @@ func (hp *hubPoller) Run() {
 	}
 }
 
-func (hp *hubPoller) pollHub() {
+func (hp *HubPoller) pollHub() {
 	var state m.NetworkState
 
 	resp, err := hp.client.Do(hp.req)
@@ -89,22 +86,26 @@ func (hp *hubPoller) pollHub() {
 		return
 	}
 
-	hp.applyNetworkState(state)
-
 	if err := storeNetworkState(hp.netName, state); err != nil {
 		hp.logf("Failed to store network state: %v", err)
 	}
+
+	hp.applyNetworkState(state)
 }
 
-func (hp *hubPoller) applyNetworkState(state m.NetworkState) {
+func (hp *HubPoller) applyNetworkState(state m.NetworkState) {
 	for i, peer := range state.Peers {
-		if i != int(hp.localIP) {
-			if peer == nil || peer.Version != hp.versions[i] {
-				hp.handleControlMsg(byte(i), peerUpdateMsg{Peer: state.Peers[i]})
+		if i == int(hp.LocalPeerIP) {
+			continue
+		}
+
+		if peer != nil && peer.Version == hp.versions[i] {
+			continue
+		}
+
+		hp.RemotePeers[i].Load().HandlePeerUpdate(peerUpdateMsg{Peer: state.Peers[i]})
 		if peer != nil {
 			hp.versions[i] = peer.Version
 		}
 	}
-		}
-	}
 }

peer/ifreader.go

@@ -1,67 +1,35 @@
 package peer
 
 import (
-	"io"
 	"log"
-	"net/netip"
-	"sync/atomic"
 )
 
-type ifReader struct {
-	iface              io.Reader
-	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error)
-	rt                 *atomic.Pointer[routingTable]
-	buf1               []byte
-	buf2               []byte
+type IFReader struct {
+	Globals
 }
 
-func newIFReader(
-	iface io.Reader,
-	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error),
-	rt *atomic.Pointer[routingTable],
-) *ifReader {
-	return &ifReader{iface, writeToUDPAddrPort, rt, newBuf(), newBuf()}
+func NewIFReader(g Globals) *IFReader {
+	return &IFReader{Globals: g}
 }
 
-func (r *ifReader) Run() {
-	packet := newBuf()
+func (r *IFReader) Run() {
+	packet := make([]byte, bufferSize)
 	for {
 		r.handleNextPacket(packet)
 	}
 }
 
-func (r *ifReader) handleNextPacket(packet []byte) {
+func (r *IFReader) handleNextPacket(packet []byte) {
 	packet = r.readNextPacket(packet)
 	remoteIP, ok := r.parsePacket(packet)
 	if !ok {
 		return
 	}
-
-	rt := r.rt.Load()
-	peer := rt.Peers[remoteIP]
-	if !peer.Up {
-		r.logf("Peer %d not up.", peer.IP)
-		return
-	}
-
-	enc := peer.EncryptDataPacket(peer.IP, packet, r.buf1)
-	if peer.Direct {
-		r.writeToUDPAddrPort(enc, peer.DirectAddr)
-		return
-	}
-
-	relay, ok := rt.GetRelay()
-	if !ok {
-		r.logf("Relay not available for peer %d.", peer.IP)
-		return
-	}
-
-	enc = relay.EncryptDataPacket(peer.IP, enc, r.buf2)
-	r.writeToUDPAddrPort(enc, relay.DirectAddr)
+	r.RemotePeers[remoteIP].Load().SendDataTo(packet)
 }
 
-func (r *ifReader) readNextPacket(buf []byte) []byte {
-	n, err := r.iface.Read(buf[:cap(buf)])
+func (r *IFReader) readNextPacket(buf []byte) []byte {
+	n, err := r.IFace.Read(buf[:cap(buf)])
 	if err != nil {
 		log.Fatalf("Failed to read from interface: %v", err)
 	}
@@ -69,7 +37,9 @@ func (r *ifReader) readNextPacket(buf []byte) []byte {
 	return buf[:n]
 }
 
-func (r *ifReader) parsePacket(buf []byte) (byte, bool) {
+// parsePacket returns the VPN ip for the packet, and a boolean indicating
+// success.
+func (r *IFReader) parsePacket(buf []byte) (byte, bool) {
 	n := len(buf)
 	if n == 0 {
 		return 0, false
@@ -98,6 +68,6 @@ func (r *ifReader) parsePacket(buf []byte) (byte, bool) {
 	}
 }
 
-func (*ifReader) logf(s string, args ...any) {
+func (*IFReader) logf(s string, args ...any) {
 	log.Printf("[IFReader] "+s, args...)
 }

peer/main.go

@@ -6,18 +6,18 @@ import (
 )
 
 func Main() {
-	conf := peerConfig{}
+	args := mainArgs{}
 
-	flag.StringVar(&conf.NetName, "name", "", "[REQUIRED] The network name.")
-	flag.StringVar(&conf.HubAddress, "hub-address", "", "[REQUIRED] The hub address.")
-	flag.StringVar(&conf.APIKey, "api-key", "", "[REQUIRED] The node's API key.")
+	flag.StringVar(&args.NetName, "name", "", "[REQUIRED] The network name.")
+	flag.StringVar(&args.HubAddress, "hub-address", "", "[REQUIRED] The hub address.")
+	flag.StringVar(&args.APIKey, "api-key", "", "[REQUIRED] The node's API key.")
 	flag.Parse()
 
-	if conf.NetName == "" || conf.HubAddress == "" || conf.APIKey == "" {
+	if args.NetName == "" || args.HubAddress == "" || args.APIKey == "" {
 		flag.Usage()
 		os.Exit(1)
 	}
 
-	peer := newPeerMain(conf)
+	peer := newPeerMain(args)
 	peer.Run()
 }

peer/main_test.go

@@ -0,0 +1,5 @@
+package peer
+
+func newBuf() []byte {
+	return make([]byte, bufferSize)
+}

peer/mcreader.go

@@ -3,27 +3,19 @@ package peer
 import (
 	"log"
 	"net"
-	"sync/atomic"
 	"time"
 )
 
-func runMCReader(
-	rt *atomic.Pointer[routingTable],
-	handleControlMsg func(destIP byte, msg any),
-) {
+func RunMCReader(g Globals) {
 	for {
-		runMCReaderInner(rt, handleControlMsg)
+		runMCReaderInner(g)
 		time.Sleep(broadcastErrorTimeoutInterval)
 	}
 }
 
-func runMCReaderInner(
-	rt *atomic.Pointer[routingTable],
-	handleControlMsg func(destIP byte, msg any),
-) {
+func runMCReaderInner(g Globals) {
 	var (
-		raw  = newBuf()
-		buf  = newBuf()
+		buf  = make([]byte, bufferSize)
 		logf = func(s string, args ...any) {
 			log.Printf("[MCReader] "+s, args...)
 		}
@@ -37,34 +29,19 @@ func runMCReaderInner(
 
 	for {
 		conn.SetReadDeadline(time.Now().Add(32 * time.Second))
-		n, remoteAddr, err := conn.ReadFromUDPAddrPort(raw[:bufferSize])
+		n, remoteAddr, err := conn.ReadFromUDPAddrPort(buf[:bufferSize])
 		if err != nil {
 			logf("Failed to read from UDP port): %v", err)
 			return
 		}
 
-		raw = raw[:n]
-		h, ok := headerFromLocalDiscoveryPacket(raw)
+		buf = buf[:n]
+		h, ok := headerFromLocalDiscoveryPacket(buf)
 		if !ok {
 			logf("Failed to open discovery packet?")
 			continue
 		}
 
-		peer := rt.Load().Peers[h.SourceIP]
-		if peer.PubSignKey == nil {
-			logf("No signing key for peer %d.", h.SourceIP)
-			continue
-		}
-
-		if !verifyLocalDiscoveryPacket(raw, buf, peer.PubSignKey) {
-			logf("Invalid signature from peer: %d", h.SourceIP)
-			continue
-		}
-
-		msg := controlMsg[packetLocalDiscovery]{
-			SrcIP:   h.SourceIP,
-			SrcAddr: remoteAddr,
-		}
-		handleControlMsg(h.SourceIP, msg)
+		g.RemotePeers[h.SourceIP].Load().HandleLocalDiscoveryPacket(h, remoteAddr, buf)
 	}
 }

peer/mcwriter.go

@@ -9,7 +9,7 @@ import (
 )
 
 func createLocalDiscoveryPacket(localIP byte, signingKey []byte) []byte {
-	h := header{
+	h := Header{
 		SourceIP: localIP,
 		DestIP:   255,
 	}
@@ -19,7 +19,7 @@ func createLocalDiscoveryPacket(localIP byte, signingKey []byte) []byte {
 	return sign.Sign(out[:0], buf, (*[64]byte)(signingKey))
 }
 
-func headerFromLocalDiscoveryPacket(pkt []byte) (h header, ok bool) {
+func headerFromLocalDiscoveryPacket(pkt []byte) (h Header, ok bool) {
 	if len(pkt) != headerSize+signOverhead {
 		return
 	}
@@ -36,7 +36,7 @@ func verifyLocalDiscoveryPacket(pkt, buf []byte, pubSignKey []byte) bool {
 
 // ----------------------------------------------------------------------------
 
-func runMCWriter(localIP byte, signingKey []byte) {
+func RunMCWriter(localIP byte, signingKey []byte) {
 	discoveryPacket := createLocalDiscoveryPacket(localIP, signingKey)
 
 	conn, err := net.ListenMulticastUDP("udp", nil, multicastAddr)
@@ -45,6 +45,7 @@ func runMCWriter(localIP byte, signingKey []byte) {
 	}
 
 	for range time.Tick(broadcastInterval) {
+		log.Printf("[MCWriter] Broadcasting on %v...", multicastAddr)
 		_, err := conn.WriteToUDP(discoveryPacket, multicastAddr)
 		if err != nil {
 			log.Printf("[MCWriter] Failed to write multicast: %v", err)

peer/packets-util.go

@@ -2,17 +2,9 @@ package peer
 
 import (
 	"net/netip"
-	"sync/atomic"
-	"time"
 	"unsafe"
 )
 
-var traceIDCounter uint64 = uint64(time.Now().Unix()<<30) + 1
-
-func newTraceID() uint64 {
-	return atomic.AddUint64(&traceIDCounter, 1)
-}
-
 // ----------------------------------------------------------------------------
 
 type binWriter struct {

peer/packets_test.go

@@ -9,9 +9,7 @@ import (
 
 func TestSynPacket(t *testing.T) {
 	p := packetSyn{
-		TraceID: newTraceID(),
-		//SentAt:        time.Now().UnixMilli(),
-		//SharedKeyType: 1,
+		TraceID: 2342342345,
 		Direct:  true,
 	}
 	rand.Read(p.SharedKey[:])
@@ -32,7 +30,7 @@ func TestSynPacket(t *testing.T) {
 
 func TestAckPacket(t *testing.T) {
 	p := packetAck{
-		TraceID: newTraceID(),
+		TraceID: 123213,
 		ToAddr:  netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 2, 3, 4}), 234),
 	}
 
@@ -52,7 +50,7 @@ func TestAckPacket(t *testing.T) {
 
 func TestProbePacket(t *testing.T) {
 	p := packetProbe{
-		TraceID: newTraceID(),
+		TraceID: 12345,
 	}
 
 	buf := p.Marshal(newBuf())

peer/peer.go

@@ -6,54 +6,74 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"math"
 	"net"
 	"net/http"
 	"net/netip"
 	"net/url"
-	"sync"
-	"sync/atomic"
+	"os"
 	"vppn/m"
 )
 
 type peerMain struct {
-	conf       localConfig
-	rt         *atomic.Pointer[routingTable]
-	ifReader   *ifReader
-	connReader *connReader
-	iface      io.Writer
-	hubPoller  *hubPoller
-	super      *supervisor
+	Globals
+	ifReader   *IFReader
+	connReader *ConnReader
+	hubPoller  *HubPoller
 }
 
-type peerConfig struct {
+type mainArgs struct {
 	NetName    string
 	HubAddress string
 	APIKey     string
 }
 
-func newPeerMain(conf peerConfig) *peerMain {
+func newPeerMain(args mainArgs) *peerMain {
 	logf := func(s string, args ...any) {
 		log.Printf("[Main] "+s, args...)
 	}
 
-	config, err := loadPeerConfig(conf.NetName)
+	config, err := loadPeerConfig(args.NetName)
 	if err != nil {
 		logf("Failed to load configuration: %v", err)
 		logf("Initializing...")
-		initPeerWithHub(conf)
+		initPeerWithHub(args)
 
-		config, err = loadPeerConfig(conf.NetName)
+		config, err = loadPeerConfig(args.NetName)
 		if err != nil {
 			log.Fatalf("Failed to load configuration: %v", err)
 		}
 	}
 
-	iface, err := openInterface(config.Network, config.PeerIP, conf.NetName)
+	state, err := loadNetworkState(args.NetName)
+	if err != nil {
+		log.Fatalf("Failed to load network state: %v", err)
+	}
+
+	startupCount, err := loadStartupCount(args.NetName)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			log.Fatalf("Failed to load startup count: %v", err)
+		}
+	}
+
+	if startupCount.Count == math.MaxUint16 {
+		log.Fatalf("Startup counter overflow.")
+	}
+	startupCount.Count += 1
+
+	if err := storeStartupCount(args.NetName, startupCount); err != nil {
+		log.Fatalf("Failed to write startup count: %v", err)
+	}
+
+	iface, err := openInterface(config.Network, config.LocalPeerIP, args.NetName)
 	if err != nil {
 		log.Fatalf("Failed to open interface: %v", err)
 	}
 
-	myAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", config.Port))
+	localPeer := state.Peers[config.LocalPeerIP]
+
+	myAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", localPeer.Port))
 	if err != nil {
 		log.Fatalf("Failed to resolve UDP address: %v", err)
 	}
@@ -67,78 +87,62 @@ func newPeerMain(conf peerConfig) *peerMain {
 	conn.SetReadBuffer(1024 * 1024 * 8)
 	conn.SetWriteBuffer(1024 * 1024 * 8)
 
-	// Wrap write function - this is necessary to avoid starvation.
-	writeLock := sync.Mutex{}
-	writeToUDPAddrPort := func(b []byte, addr netip.AddrPort) (n int, err error) {
-		writeLock.Lock()
-		n, err = conn.WriteToUDPAddrPort(b, addr)
-		if err != nil {
-			logf("Failed to write packet: %v", err)
-		}
-		writeLock.Unlock()
-		return n, err
-	}
-
 	var localAddr netip.AddrPort
-	ip, localAddrValid := netip.AddrFromSlice(config.PublicIP)
+	ip, localAddrValid := netip.AddrFromSlice(localPeer.PublicIP)
 	if localAddrValid {
-		localAddr = netip.AddrPortFrom(ip, config.Port)
+		localAddr = netip.AddrPortFrom(ip, localPeer.Port)
 	}
 
-	rt := newRoutingTable(config.PeerIP, localAddr)
-	rtPtr := &atomic.Pointer[routingTable]{}
-	rtPtr.Store(&rt)
+	g := NewGlobals(config, startupCount, localAddr, conn, iface)
 
-	ifReader := newIFReader(iface, writeToUDPAddrPort, rtPtr)
-	super := newSupervisor(writeToUDPAddrPort, rtPtr, config.PrivKey)
-	connReader := newConnReader(conn.ReadFromUDPAddrPort, writeToUDPAddrPort, iface, super.HandleControlMsg, rtPtr)
-	hubPoller, err := newHubPoller(config.PeerIP, conf.NetName, conf.HubAddress, conf.APIKey, super.HandleControlMsg)
+	hubPoller, err := NewHubPoller(g, args.NetName, args.HubAddress, args.APIKey)
 	if err != nil {
 		log.Fatalf("Failed to create hub poller: %v", err)
 	}
 
 	return &peerMain{
-		conf:       config,
-		rt:         rtPtr,
-		iface:      iface,
-		ifReader:   ifReader,
-		connReader: connReader,
+		Globals:    g,
+		ifReader:   NewIFReader(g),
+		connReader: NewConnReader(g, conn),
 		hubPoller:  hubPoller,
-		super:      super,
 	}
 }
 
 func (p *peerMain) Run() {
+	for i := range p.RemotePeers {
+		remote := p.RemotePeers[i].Load()
+		go newRemoteFSM(remote).Run()
+	}
 
 	go p.ifReader.Run()
 	go p.connReader.Run()
-	p.super.Start()
 
-	if !p.rt.Load().LocalAddr.IsValid() {
-		go runMCWriter(p.conf.PeerIP, p.conf.PrivSignKey)
-		go runMCReader(p.rt, p.super.HandleControlMsg)
+	if !p.LocalAddrValid {
+		go RunMCWriter(p.LocalPeerIP, p.PrivSignKey)
+		go RunMCReader(p.Globals)
 	}
 
 	go p.hubPoller.Run()
+
 	select {}
 }
 
-func initPeerWithHub(conf peerConfig) {
+func initPeerWithHub(args mainArgs) {
 	keys := generateKeys()
 
-	initURL, err := url.Parse(conf.HubAddress)
+	initURL, err := url.Parse(args.HubAddress)
 	if err != nil {
 		log.Fatalf("Failed to parse hub URL: %v", err)
 	}
 	initURL.Path = "/peer/init/"
 
-	args := m.PeerInitArgs{
+	initArgs := m.PeerInitArgs{
 		EncPubKey:  keys.PubKey,
 		PubSignKey: keys.PubSignKey,
 	}
 
 	buf := &bytes.Buffer{}
-	if err := json.NewEncoder(buf).Encode(args); err != nil {
+	if err := json.NewEncoder(buf).Encode(initArgs); err != nil {
 		log.Fatalf("Failed to encode init args: %v", err)
 	}
 
@@ -146,7 +150,7 @@ func initPeerWithHub(conf peerConfig) {
 	if err != nil {
 		log.Fatalf("Failed to construct request: %v", err)
 	}
-	req.SetBasicAuth("", conf.APIKey)
+	req.SetBasicAuth("", args.APIKey)
 
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
@@ -159,17 +163,24 @@ func initPeerWithHub(conf peerConfig) {
 		log.Fatalf("Failed to read response body: %v", err)
 	}
 
-	peerConfig := localConfig{}
-	if err := json.Unmarshal(data, &peerConfig.PeerConfig); err != nil {
+	initResp := m.PeerInitResp{}
+	if err := json.Unmarshal(data, &initResp); err != nil {
 		log.Fatalf("Failed to parse configuration: %v\n%s", err, data)
 	}
 
-	peerConfig.PubKey = keys.PubKey
-	peerConfig.PrivKey = keys.PrivKey
-	peerConfig.PubSignKey = keys.PubSignKey
-	peerConfig.PrivSignKey = keys.PrivSignKey
+	config := LocalConfig{}
+	config.LocalPeerIP = initResp.PeerIP
+	config.Network = initResp.Network
+	config.PubKey = keys.PubKey
+	config.PrivKey = keys.PrivKey
+	config.PubSignKey = keys.PubSignKey
+	config.PrivSignKey = keys.PrivSignKey
 
-	if err := storePeerConfig(conf.NetName, peerConfig); err != nil {
+	if err := storeNetworkState(args.NetName, initResp.NetworkState); err != nil {
+		log.Fatalf("Failed to store network state: %v", err)
+	}
+
+	if err := storePeerConfig(args.NetName, config); err != nil {
 		log.Fatalf("Failed to store configuration: %v", err)
 	}
 

peer/peer_test.go

@@ -1,114 +0,0 @@
-package peer
-
-import (
-	"bytes"
-	"crypto/rand"
-	mrand "math/rand"
-	"net/netip"
-	"sync/atomic"
-)
-
-// A test peer.
-type P struct {
-	cryptoKeys
-	RT         *atomic.Pointer[routingTable]
-	Conn       *TestUDPConn
-	IFace      *TestIFace
-	ConnReader *connReader
-	IFReader   *ifReader
-}
-
-func NewPeerForTesting(n *TestNetwork, ip byte, addr netip.AddrPort) P {
-	p := P{
-		cryptoKeys: generateKeys(),
-		RT:         &atomic.Pointer[routingTable]{},
-		IFace:      NewTestIFace(),
-	}
-
-	rt := newRoutingTable(ip, addr)
-	p.RT.Store(&rt)
-	p.Conn = n.NewUDPConn(addr)
-	//p.ConnWriter = NewConnWriter(p.Conn.WriteToUDPAddrPort, p.RT)
-
-	return p
-}
-
-func ConnectPeers(p1, p2 *P) {
-	rt1 := p1.RT.Load()
-	rt2 := p2.RT.Load()
-
-	ip1 := rt1.LocalIP
-	ip2 := rt2.LocalIP
-
-	rt1.Peers[ip2].Up = true
-	rt1.Peers[ip2].Direct = true
-	rt1.Peers[ip2].Relay = true
-	rt1.Peers[ip2].DirectAddr = rt2.LocalAddr
-	rt1.Peers[ip2].PubSignKey = p2.PubSignKey
-	rt1.Peers[ip2].ControlCipher = newControlCipher(p1.PrivKey, p2.PubKey)
-	rt1.Peers[ip2].DataCipher = newDataCipher()
-
-	rt2.Peers[ip1].Up = true
-	rt2.Peers[ip1].Direct = true
-	rt2.Peers[ip1].Relay = true
-	rt2.Peers[ip1].DirectAddr = rt1.LocalAddr
-	rt2.Peers[ip1].PubSignKey = p1.PubSignKey
-	rt2.Peers[ip1].ControlCipher = newControlCipher(p2.PrivKey, p1.PubKey)
-	rt2.Peers[ip1].DataCipher = rt1.Peers[ip2].DataCipher
-}
-
-func NewPeersForTesting() (p1, p2, p3 P) {
-	n := NewTestNetwork()
-
-	p1 = NewPeerForTesting(
-		n,
-		1,
-		netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 1}), 100))
-
-	p2 = NewPeerForTesting(
-		n,
-		2,
-		netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 2}), 200))
-
-	p3 = NewPeerForTesting(
-		n,
-		3,
-		netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 3}), 300))
-
-	ConnectPeers(&p1, &p2)
-	ConnectPeers(&p1, &p3)
-	ConnectPeers(&p2, &p3)
-
-	return
-}
-
-func RandPacket() []byte {
-	n := mrand.Intn(1200)
-	b := make([]byte, n)
-	rand.Read(b)
-	return b
-}
-
-func ModifyPacket(in []byte) []byte {
-	x := make([]byte, 1)
-
-	for {
-		rand.Read(x)
-		out := bytes.Clone(in)
-		idx := mrand.Intn(len(out))
-		if out[idx] != x[0] {
-			out[idx] = x[0]
-			return out
-		}
-	}
-}
-
-// ----------------------------------------------------------------------------
-
-type UnknownControlPacket struct {
-	TraceID uint64
-}
-
-func (p UnknownControlPacket) Marshal(buf []byte) []byte {
-	return newBinWriter(buf).Byte(255).Uint64(p.TraceID).Build()
-}

peer/peerfsm.dot

@@ -0,0 +1,28 @@
+digraph d {
+        disconnected -> peerUpdating;
+        peerUpdating -> disconnected;
+        peerUpdating -> server;
+        peerUpdating -> clientInit;
+        server -> peerUpdating;
+        clientInit -> peerUpdating;
+        clientInit -> clientInit;
+        clientInit -> client;
+        client -> clientInit;
+        client -> peerUpdating;
+
+        clientInitializing -> clientSyncing;
+        clientSyncing -> clientInitializing;
+        clientSyncing -> clientUpIndirect;
+        clientSyncing -> clientUpDirect;
+        clientUpIndirect -> clientUpDirect;
+        clientUpIndirect -> clientInitializing;
+        clientUpDirect -> clientInitializing;
+
+        serverInitializing -> serverSyncing;
+        serverSyncing -> serverInitializing;
+        serverSyncing -> serverUpIndirect;
+        serverSyncing -> serverUpDirect;
+        serverUpIndirect -> serverUpDirect;
+        serverUpIndirect -> serverInitializing;
+        serverUpDirect -> serverInitializing;
+}

peer/peerstates_test.go

@@ -1,371 +0,0 @@
-package peer
-
-import (
-	"testing"
-	"vppn/m"
-)
-
-// ----------------------------------------------------------------------------
-
-func TestPeerState_OnPeerUpdate_nilPeer(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.PeerUpdate(nil)
-	assertType[*stateDisconnected](t, h.State)
-}
-
-func TestPeerState_OnPeerUpdate_publicLocalIsServer(t *testing.T) {
-	keys := generateKeys()
-	h := NewPeerStateTestHarness()
-
-	state := h.State.(*stateDisconnected)
-	state.localAddr = addrPort4(1, 1, 1, 2, 200)
-
-	peer := &m.Peer{
-		PeerIP:     3,
-		Port:       456,
-		PubKey:     keys.PubKey,
-		PubSignKey: keys.PubSignKey,
-	}
-
-	h.PeerUpdate(peer)
-	assertEqual(t, h.Published.Up, false)
-	assertType[*stateServer](t, h.State)
-}
-
-/*
-
-func TestPeerState_OnPeerUpdate_clientDirect(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-}
-
-/*
-func TestPeerState_OnPeerUpdate_clientRelayed(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-}
-
-/*
-func TestStateServer_directSyn(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-
-	assertEqual(t, h.Published.Up, false)
-
-	synMsg := controlMsg[packetSyn]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 1, 1, 3, 300),
-		Packet: packetSyn{
-			TraceID: newTraceID(),
-			//SentAt:        time.Now().UnixMilli(),
-			//SharedKeyType: 1,
-			Direct: true,
-		},
-	}
-
-	h.State = h.State.OnMsg(synMsg)
-
-	assertEqual(t, len(h.Sent), 1)
-	ack := assertType[packetAck](t, h.Sent[0].Packet)
-	assertEqual(t, ack.TraceID, synMsg.Packet.TraceID)
-	assertEqual(t, h.Sent[0].Peer.IP, 3)
-	assertEqual(t, ack.PossibleAddrs[0].IsValid(), false)
-	assertEqual(t, h.Published.Up, true)
-}
-
-func TestStateServer_relayedSyn(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	state := h.ConfigServer_Relayed(t)
-
-	state.pubAddrs.Store(addrPort4(4, 5, 6, 7, 1234))
-
-	assertEqual(t, h.Published.Up, false)
-
-	synMsg := controlMsg[packetSyn]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 1, 1, 3, 300),
-		Packet: packetSyn{
-			TraceID: newTraceID(),
-			//SentAt:        time.Now().UnixMilli(),
-			//SharedKeyType: 1,
-			Direct: false,
-		},
-	}
-	synMsg.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 3, 300)
-	synMsg.Packet.PossibleAddrs[1] = addrPort4(2, 2, 2, 3, 300)
-
-	h.State = h.State.OnMsg(synMsg)
-
-	assertEqual(t, len(h.Sent), 3)
-
-	ack := assertType[packetAck](t, h.Sent[0].Packet)
-	assertEqual(t, ack.TraceID, synMsg.Packet.TraceID)
-	assertEqual(t, h.Sent[0].Peer.IP, 3)
-	assertEqual(t, ack.PossibleAddrs[0], addrPort4(4, 5, 6, 7, 1234))
-	assertEqual(t, ack.PossibleAddrs[1].IsValid(), false)
-	assertEqual(t, h.Published.Up, true)
-
-	assertType[packetProbe](t, h.Sent[1].Packet)
-	assertType[packetProbe](t, h.Sent[2].Packet)
-	assertEqual(t, h.Sent[1].Peer.DirectAddr, addrPort4(1, 1, 1, 3, 300))
-	assertEqual(t, h.Sent[2].Peer.DirectAddr, addrPort4(2, 2, 2, 3, 300))
-}
-
-func TestStateServer_onProbe(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-	assertEqual(t, h.Published.Up, false)
-
-	probeMsg := controlMsg[packetProbe]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 1, 1, 3, 300),
-		Packet:  packetProbe{TraceID: newTraceID()},
-	}
-
-	h.State = h.State.OnMsg(probeMsg)
-
-	assertEqual(t, len(h.Sent), 1)
-
-	probe := assertType[packetProbe](t, h.Sent[0].Packet)
-	assertEqual(t, probe.TraceID, probeMsg.Packet.TraceID)
-	assertEqual(t, h.Sent[0].Peer.DirectAddr, addrPort4(1, 1, 1, 3, 300))
-}
-
-func TestStateServer_OnPingTimer_timeout(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-
-	synMsg := controlMsg[packetSyn]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 1, 1, 3, 300),
-		Packet: packetSyn{
-			TraceID: newTraceID(),
-			//SentAt:        time.Now().UnixMilli(),
-			//SharedKeyType: 1,
-			Direct: true,
-		},
-	}
-
-	h.State = h.State.OnMsg(synMsg)
-	assertEqual(t, len(h.Sent), 1)
-	assertEqual(t, h.Published.Up, true)
-
-	// Ping shouldn't timeout.
-	h.OnPingTimer()
-	assertEqual(t, h.Published.Up, true)
-
-	// Advance the time, then ping.
-	state := assertType[*stateServer](t, h.State)
-	state.lastSeen = time.Now().Add(-timeoutInterval - time.Second)
-
-	h.OnPingTimer()
-	assertEqual(t, h.Published.Up, false)
-}
-
-func TestStateClientDirect_OnAck(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-
-	assertEqual(t, h.Published.Up, false)
-
-	// On entering the state, a SYN should have been sent.
-	assertEqual(t, len(h.Sent), 1)
-	syn := assertType[packetSyn](t, h.Sent[0].Packet)
-
-	ack := controlMsg[packetAck]{
-		Packet: packetAck{TraceID: syn.TraceID},
-	}
-	h.State = h.State.OnMsg(ack)
-	assertEqual(t, h.Published.Up, true)
-}
-
-func TestStateClientDirect_OnAck_incorrectTraceID(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-
-	assertEqual(t, h.Published.Up, false)
-
-	// On entering the state, a SYN should have been sent.
-	assertEqual(t, len(h.Sent), 1)
-	syn := assertType[packetSyn](t, h.Sent[0].Packet)
-
-	ack := controlMsg[packetAck]{
-		Packet: packetAck{TraceID: syn.TraceID + 1},
-	}
-	h.State = h.State.OnMsg(ack)
-	assertEqual(t, h.Published.Up, false)
-}
-
-func TestStateClientDirect_OnPingTimer(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-
-	// On entering the state, a SYN should have been sent.
-	assertEqual(t, len(h.Sent), 1)
-	assertType[packetSyn](t, h.Sent[0].Packet)
-
-	h.OnPingTimer()
-
-	// On ping timer, another syn should be sent. Additionally, we should remain
-	// in the same state.
-	assertEqual(t, len(h.Sent), 2)
-	assertType[packetSyn](t, h.Sent[1].Packet)
-	assertType[*stateClientDirect](t, h.State)
-	assertEqual(t, h.Published.Up, false)
-}
-
-func TestStateClientDirect_OnPingTimer_timeout(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-
-	assertEqual(t, h.Published.Up, false)
-
-	// On entering the state, a SYN should have been sent.
-	assertEqual(t, len(h.Sent), 1)
-	syn := assertType[packetSyn](t, h.Sent[0].Packet)
-
-	ack := controlMsg[packetAck]{
-		Packet: packetAck{TraceID: syn.TraceID},
-	}
-	h.State = h.State.OnMsg(ack)
-	assertEqual(t, h.Published.Up, true)
-
-	state := assertType[*stateClientDirect](t, h.State)
-	state.lastSeen = time.Now().Add(-(timeoutInterval + time.Second))
-
-	h.OnPingTimer()
-
-	// On ping timer, we should timeout, causing the client to reset. Another SYN
-	// will be sent when re-entering the state, but the connection should be down.
-	assertEqual(t, len(h.Sent), 2)
-	assertType[packetSyn](t, h.Sent[1].Packet)
-	assertType[*stateClientDirect](t, h.State)
-	assertEqual(t, h.Published.Up, false)
-}
-
-func TestStateClientRelayed_OnAck(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	assertEqual(t, h.Published.Up, false)
-
-	// On entering the state, a SYN should have been sent.
-	assertEqual(t, len(h.Sent), 1)
-	syn := assertType[packetSyn](t, h.Sent[0].Packet)
-
-	ack := controlMsg[packetAck]{
-		Packet: packetAck{TraceID: syn.TraceID},
-	}
-	h.State = h.State.OnMsg(ack)
-	assertEqual(t, h.Published.Up, true)
-}
-
-func TestStateClientRelayed_OnPingTimer_noAddrs(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	assertEqual(t, h.Published.Up, false)
-
-	// On entering the state, a SYN should have been sent.
-	assertEqual(t, len(h.Sent), 1)
-
-	// If we haven't had an ack yet, we won't have addresses to probe. Therefore
-	// we'll have just one more syn packet sent.
-	h.OnPingTimer()
-	assertEqual(t, len(h.Sent), 2)
-}
-
-func TestStateClientRelayed_OnPingTimer_withAddrs(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	assertEqual(t, h.Published.Up, false)
-
-	// On entering the state, a SYN should have been sent.
-	assertEqual(t, len(h.Sent), 1)
-
-	syn := assertType[packetSyn](t, h.Sent[0].Packet)
-
-	ack := controlMsg[packetAck]{Packet: packetAck{TraceID: syn.TraceID}}
-	ack.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 1, 300)
-	ack.Packet.PossibleAddrs[1] = addrPort4(1, 1, 1, 2, 300)
-
-	h.State = h.State.OnMsg(ack)
-
-	// Add a local discovery address. Note that the port will be configured port
-	// and no the one provided here.
-	h.State = h.State.OnMsg(controlMsg[packetLocalDiscovery]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(2, 2, 2, 3, 300),
-	})
-
-	// We should see one SYN and three probe packets.
-	h.OnPingTimer()
-	assertEqual(t, len(h.Sent), 5)
-	assertType[packetSyn](t, h.Sent[1].Packet)
-	assertType[packetProbe](t, h.Sent[2].Packet)
-	assertType[packetProbe](t, h.Sent[3].Packet)
-	assertType[packetProbe](t, h.Sent[4].Packet)
-
-	assertEqual(t, h.Sent[2].Peer.DirectAddr, addrPort4(1, 1, 1, 1, 300))
-	assertEqual(t, h.Sent[3].Peer.DirectAddr, addrPort4(1, 1, 1, 2, 300))
-	assertEqual(t, h.Sent[4].Peer.DirectAddr, addrPort4(2, 2, 2, 3, 456))
-}
-
-func TestStateClientRelayed_OnPingTimer_timeout(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	// On entering the state, a SYN should have been sent.
-	assertEqual(t, len(h.Sent), 1)
-	syn := assertType[packetSyn](t, h.Sent[0].Packet)
-
-	ack := controlMsg[packetAck]{
-		Packet: packetAck{TraceID: syn.TraceID},
-	}
-	h.State = h.State.OnMsg(ack)
-	assertEqual(t, h.Published.Up, true)
-
-	state := assertType[*stateClientRelayed](t, h.State)
-	state.lastSeen = time.Now().Add(-(timeoutInterval + time.Second))
-
-	h.OnPingTimer()
-
-	// On ping timer, we should timeout, causing the client to reset. Another SYN
-	// will be sent when re-entering the state, but the connection should be down.
-	assertEqual(t, len(h.Sent), 2)
-	assertType[packetSyn](t, h.Sent[1].Packet)
-	assertType[*stateClientRelayed](t, h.State)
-	assertEqual(t, h.Published.Up, false)
-}
-
-func TestStateClientRelayed_OnProbe_unknownAddr(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	h.OnProbe(controlMsg[packetProbe]{
-		Packet: packetProbe{TraceID: newTraceID()},
-	})
-
-	assertType[*stateClientRelayed](t, h.State)
-}
-
-func TestStateClientRelayed_OnProbe_upgradeDirect(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	syn := assertType[packetSyn](t, h.Sent[0].Packet)
-
-	ack := controlMsg[packetAck]{Packet: packetAck{TraceID: syn.TraceID}}
-	ack.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 1, 300)
-	ack.Packet.PossibleAddrs[1] = addrPort4(1, 1, 1, 2, 300)
-
-	h.State = h.State.OnMsg(ack)
-	h.OnPingTimer()
-
-	probe := assertType[packetProbe](t, h.Sent[2].Packet)
-	h.OnProbe(controlMsg[packetProbe]{Packet: probe})
-
-	assertType[*stateClientDirect](t, h.State)
-}
-*/

peer/peersuper.go

@@ -1,148 +0,0 @@
-package peer
-
-import (
-	"net/netip"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"git.crumpington.com/lib/go/ratelimiter"
-)
-
-type supervisor struct {
-	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error)
-	staged             routingTable
-	shared             *atomic.Pointer[routingTable]
-	peers              [256]*peerSuper
-	lock               sync.Mutex
-
-	buf1 []byte
-	buf2 []byte
-}
-
-func newSupervisor(
-	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error),
-	rt *atomic.Pointer[routingTable],
-	privKey []byte,
-) *supervisor {
-
-	routes := rt.Load()
-
-	s := &supervisor{
-		writeToUDPAddrPort: writeToUDPAddrPort,
-		staged:             *routes,
-		shared:             rt,
-		buf1:               newBuf(),
-		buf2:               newBuf(),
-	}
-
-	pubAddrs := newPubAddrStore(routes.LocalAddr)
-
-	for i := range s.peers {
-		state := &peerData{
-			publish:           s.publish,
-			sendControlPacket: s.send,
-			pingTimer:         time.NewTicker(timeoutInterval),
-			localIP:           routes.LocalIP,
-			remoteIP:          byte(i),
-			privKey:           privKey,
-			localAddr:         routes.LocalAddr,
-			pubAddrs:          pubAddrs,
-			staged:            routes.Peers[i],
-			limiter: ratelimiter.New(ratelimiter.Config{
-				FillPeriod:   20 * time.Millisecond,
-				MaxWaitCount: 1,
-			}),
-		}
-		s.peers[i] = newPeerSuper(state, state.pingTimer)
-	}
-
-	return s
-}
-
-func (s *supervisor) Start() {
-	for i := range s.peers {
-		go s.peers[i].Run()
-	}
-}
-
-func (s *supervisor) HandleControlMsg(destIP byte, msg any) {
-	s.peers[destIP].HandleControlMsg(msg)
-}
-
-func (s *supervisor) send(peer remotePeer, pkt marshaller) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	enc := peer.EncryptControlPacket(pkt, s.buf1, s.buf2)
-	if peer.Direct {
-		s.writeToUDPAddrPort(enc, peer.DirectAddr)
-		return
-	}
-
-	relay, ok := s.staged.GetRelay()
-	if !ok {
-		return
-	}
-
-	enc = relay.EncryptDataPacket(peer.IP, enc, s.buf1)
-	s.writeToUDPAddrPort(enc, relay.DirectAddr)
-}
-
-func (s *supervisor) publish(rp remotePeer) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.staged.Peers[rp.IP] = rp
-	s.ensureRelay()
-	copy := s.staged
-	s.shared.Store(&copy)
-}
-
-func (s *supervisor) ensureRelay() {
-	if _, ok := s.staged.GetRelay(); ok {
-		return
-	}
-
-	// TODO: Random selection? Something else?
-	for _, peer := range s.staged.Peers {
-		if peer.Up && peer.Direct && peer.Relay {
-			s.staged.RelayIP = peer.IP
-			return
-		}
-	}
-}
-
-// ----------------------------------------------------------------------------
-
-type peerSuper struct {
-	messages  chan any
-	state     peerState
-	pingTimer *time.Ticker
-}
-
-func newPeerSuper(state *peerData, pingTimer *time.Ticker) *peerSuper {
-	return &peerSuper{
-		messages:  make(chan any, 8),
-		state:     initPeerState(state, nil),
-		pingTimer: pingTimer,
-	}
-}
-
-func (s *peerSuper) HandleControlMsg(msg any) {
-	select {
-	case s.messages <- msg:
-	default:
-	}
-}
-
-func (s *peerSuper) Run() {
-	for {
-		select {
-		case <-s.pingTimer.C:
-			s.state = s.state.OnMsg(pingTimerMsg{})
-		case raw := <-s.messages:
-			s.state = s.state.OnMsg(raw)
-		}
-	}
-}

peer/relayhandler.go

@@ -0,0 +1,54 @@
+package peer
+
+import (
+	"log"
+	"sync"
+	"sync/atomic"
+)
+
+type relayHandler struct {
+	lock   sync.Mutex
+	relays map[byte]*Remote
+	relay  atomic.Pointer[Remote]
+}
+
+func newRelayHandler() *relayHandler {
+	return &relayHandler{
+		relays: make(map[byte]*Remote, 256),
+	}
+}
+
+func (h *relayHandler) Add(r *Remote) {
+	h.lock.Lock()
+	defer h.lock.Unlock()
+
+	h.relays[r.RemotePeerIP] = r
+
+	if h.relay.Load() == nil {
+		log.Printf("Setting Relay: %v", r.conf().Peer.Name)
+		h.relay.Store(r)
+	}
+}
+
+func (h *relayHandler) Remove(r *Remote) {
+	h.lock.Lock()
+	defer h.lock.Unlock()
+
+	log.Printf("Removing relay %d...", r.RemotePeerIP)
+	delete(h.relays, r.RemotePeerIP)
+
+	if h.relay.Load() == r {
+		// Remove current relay.
+		h.relay.Store(nil)
+
+		// Find new relay.
+		for _, r := range h.relays {
+			h.relay.Store(r)
+			break
+		}
+	}
+}
+
+func (h *relayHandler) Load() *Remote {
+	return h.relay.Load()
+}

peer/remote.go

@@ -0,0 +1,327 @@
+package peer
+
+import (
+	"fmt"
+	"log"
+	"net/netip"
+	"strings"
+	"sync/atomic"
+	"vppn/m"
+)
+
+// ----------------------------------------------------------------------------
+// The remoteConfig is the shared, immutable configuration for a remote
+// peer. It's read and written atomically. See remote.config.
+// ----------------------------------------------------------------------------
+
+type remoteConfig struct {
+	Up            bool           // True if peer is up and we can send data.
+	Server        bool           // True if role is server.
+	Direct        bool           // True if this is a direct connection.
+	DirectAddr    netip.AddrPort // Remote address if directly connected.
+	ControlCipher *controlCipher
+	DataCipher    *dataCipher
+	Peer          *m.Peer
+}
+
+// CanRelay returns true if the remote configuration is able to relay packets.
+// to other hosts.
+func (rc remoteConfig) CanRelay() bool {
+	return rc.Up && rc.Direct && rc.Peer.Relay
+}
+
+// A Remote represents a remote peer and contains functions for handling
+// incoming control, data, and multicast packets, peer udpates, as well as
+// sending, forwarding, and relaying packets.
+type Remote struct {
+	Globals
+	RemotePeerIP byte // Immutable.
+
+	dupCheck    *dupCheck
+	sendCounter uint64 // init to startupCount << 48. Atomic access only.
+
+	// config should be accessed via conf() and updateConf(...) methods.
+	config   atomic.Pointer[remoteConfig]
+	messages chan any
+}
+
+func newRemote(g Globals, remotePeerIP byte) *Remote {
+	r := &Remote{
+		Globals:      g,
+		RemotePeerIP: remotePeerIP,
+		dupCheck:     newDupCheck(0),
+		sendCounter:  (uint64(g.StartupCount) << 48) + 1,
+		messages:     make(chan any, 8),
+	}
+	r.config.Store(&remoteConfig{})
+	return r
+}
+
+// ----------------------------------------------------------------------------
+
+func (r *Remote) conf() remoteConfig {
+	return *(r.config.Load())
+}
+
+func (r *Remote) updateConf(conf remoteConfig) {
+	old := r.config.Load()
+	r.config.Store(&conf)
+
+	if !old.CanRelay() && conf.CanRelay() {
+		r.RelayHandler.Add(r)
+	}
+
+	if old.CanRelay() && !conf.CanRelay() {
+		r.RelayHandler.Remove(r)
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+func (r *Remote) sendUDP(b []byte, addr netip.AddrPort) {
+	if _, err := r.SendUDP(b, addr); err != nil {
+		r.logf("Failed to send UDP packet: %v", err)
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+func (r *Remote) encryptData(conf remoteConfig, destIP byte, packet []byte) []byte {
+	h := Header{
+		StreamID: dataStreamID,
+		Counter:  atomic.AddUint64(&r.sendCounter, 1),
+		SourceIP: r.Globals.LocalPeerIP,
+		DestIP:   destIP,
+	}
+	return conf.DataCipher.Encrypt(h, packet, packet[len(packet):cap(packet)])
+}
+
+func (r *Remote) encryptControl(conf remoteConfig, packet []byte) []byte {
+	h := Header{
+		StreamID: controlStreamID,
+		Counter:  atomic.AddUint64(&r.sendCounter, 1),
+		SourceIP: r.LocalPeerIP,
+		DestIP:   r.RemotePeerIP,
+	}
+	return conf.ControlCipher.Encrypt(h, packet, packet[len(packet):cap(packet)])
+}
+
+// ----------------------------------------------------------------------------
+
+// SendDataTo sends a data packet to the remote, called by the IFReader.
+func (r *Remote) SendDataTo(data []byte) {
+	conf := r.conf()
+	if !conf.Up {
+		r.logf("Cannot send: link down")
+		return
+	}
+
+	// Direct:
+
+	if conf.Direct {
+		r.sendUDP(r.encryptData(conf, conf.Peer.PeerIP, data), conf.DirectAddr)
+		return
+	}
+
+	// Relayed:
+	relay := r.RelayHandler.Load()
+
+	if relay == nil {
+		r.logf("Connot send: no relay")
+		return
+	}
+
+	relay.relayData(conf.Peer.PeerIP, r.encryptData(conf, conf.Peer.PeerIP, data))
+}
+
+func (r *Remote) relayData(toIP byte, enc []byte) {
+	conf := r.conf()
+	if !conf.Up || !conf.Direct {
+		r.logf("Cannot relay: not up or not a direct connection")
+		return
+	}
+	r.sendUDP(r.encryptData(conf, toIP, enc), conf.DirectAddr)
+}
+
+func (r *Remote) sendControl(conf remoteConfig, data []byte) {
+	// Direct:
+
+	if conf.Direct {
+		enc := r.encryptControl(conf, data)
+		r.sendUDP(enc, conf.DirectAddr)
+		return
+	}
+
+	// Relayed:
+
+	relay := r.RelayHandler.Load()
+
+	if relay == nil {
+		r.logf("Connot send: no relay")
+		return
+	}
+
+	relay.relayData(conf.Peer.PeerIP, r.encryptControl(conf, data))
+}
+
+func (r *Remote) sendControlToAddr(buf []byte, addr netip.AddrPort) {
+	enc := r.encryptControl(r.conf(), buf)
+	r.sendUDP(enc, addr)
+}
+
+func (r *Remote) forwardPacket(data []byte) {
+	conf := r.conf()
+	if !conf.Up || !conf.Direct {
+		r.logf("Cannot forward to %d: not a direct connection", conf.Peer.PeerIP)
+		return
+	}
+	r.sendUDP(data, conf.DirectAddr)
+}
+
+// ----------------------------------------------------------------------------
+
+// HandlePacket is called by the ConnReader to handle an incoming packet.
+func (r *Remote) HandlePacket(h Header, srcAddr netip.AddrPort, data []byte) {
+	switch h.StreamID {
+	case controlStreamID:
+		r.handleControlPacket(h, srcAddr, data)
+	case dataStreamID:
+		r.handleDataPacket(h, data)
+	default:
+		r.logf("Unknown stream ID: %d", h.StreamID)
+	}
+}
+
+// Handle a control packet. Decrypt, verify, etc.
+func (r *Remote) handleControlPacket(h Header, srcAddr netip.AddrPort, data []byte) {
+	conf := r.conf()
+	if conf.ControlCipher == nil {
+		r.logf("No control cipher")
+		return
+	}
+
+	dec, ok := conf.ControlCipher.Decrypt(data, data[len(data):cap(data)])
+	if !ok {
+		r.logf("Failed to decrypt control packet")
+		return
+	}
+
+	if r.dupCheck.IsDup(h.Counter) {
+		r.logf("Dropping control packet as duplicate: %d", h.Counter)
+		return
+	}
+
+	msg, err := parseControlMsg(h.SourceIP, srcAddr, dec)
+	if err != nil {
+		r.logf("Failed to parse control packet: %v", err)
+		return
+	}
+
+	select {
+	case r.messages <- msg:
+	default:
+		r.logf("Dropping control message")
+	}
+}
+
+func (r *Remote) handleDataPacket(h Header, data []byte) {
+	conf := r.conf()
+	if conf.DataCipher == nil {
+		return
+	}
+
+	dec, ok := conf.DataCipher.Decrypt(data, data[len(data):cap(data)])
+	if !ok {
+		r.logf("Failed to decrypt data packet")
+		return
+	}
+
+	if r.dupCheck.IsDup(h.Counter) {
+		r.logf("Dropping data packet as duplicate: %d", h.Counter)
+		return
+	}
+
+	// For local.
+	if h.DestIP == r.LocalPeerIP {
+		if _, err := r.IFace.Write(dec); err != nil {
+			// This could be a malformed packet from a peer, so we don't crash if it
+			// happens.
+			r.logf("Failed to write to interface: %v", err)
+		}
+		return
+	}
+
+	// Forward.
+	dest := r.RemotePeers[h.DestIP].Load()
+	dest.forwardPacket(dec)
+}
+
+// ----------------------------------------------------------------------------
+
+// HandleLocalDiscoveryPacket is called by the MCReader.
+func (r *Remote) HandleLocalDiscoveryPacket(h Header, srcAddr netip.AddrPort, data []byte) {
+	conf := r.conf()
+	if conf.Peer.PubSignKey == nil {
+		r.logf("No signing key for discovery packet.")
+		return
+	}
+
+	if !verifyLocalDiscoveryPacket(data, data[len(data):cap(data)], conf.Peer.PubSignKey) {
+		r.logf("Invalid signature on discovery packet.")
+		return
+	}
+
+	msg := controlMsg[packetLocalDiscovery]{
+		SrcIP:   h.SourceIP,
+		SrcAddr: srcAddr,
+	}
+
+	select {
+	case r.messages <- msg:
+	default:
+		r.logf("Dropping discovery message.")
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+// HandlePeerUpdate is called by the HubPoller when it gets a new version of
+// the associated peer configuration.
+func (r *Remote) HandlePeerUpdate(msg peerUpdateMsg) {
+	r.messages <- msg
+}
+
+// ----------------------------------------------------------------------------
+
+func (s *Remote) logf(format string, args ...any) {
+	conf := s.conf()
+
+	b := strings.Builder{}
+	name := ""
+	if conf.Peer != nil {
+		name = conf.Peer.Name
+	}
+	b.WriteString(fmt.Sprintf("%03d", s.RemotePeerIP))
+
+	b.WriteString(fmt.Sprintf("%30s: ", name))
+
+	if conf.Server {
+		b.WriteString("SERVER | ")
+	} else {
+		b.WriteString("CLIENT | ")
+	}
+
+	if conf.Direct {
+		b.WriteString("DIRECT  | ")
+	} else {
+		b.WriteString("RELAYED | ")
+	}
+
+	if conf.Up {
+		b.WriteString("UP   | ")
+	} else {
+		b.WriteString("DOWN | ")
+	}
+
+	log.Printf(b.String()+format, args...)
+}

peer/remotefsm.go

@@ -0,0 +1,447 @@
+package peer
+
+import (
+	"net/netip"
+	"time"
+	"vppn/m"
+)
+
+type stateFunc func(msg any) stateFunc
+
+type sentProbe struct {
+	SentAt time.Time
+	Addr   netip.AddrPort
+}
+
+type remoteFSM struct {
+	*Remote
+
+	pingTimer *time.Ticker
+	lastSeen  time.Time
+	traceID   uint64
+	probes    map[uint64]sentProbe
+
+	buf []byte
+}
+
+func newRemoteFSM(r *Remote) *remoteFSM {
+	fsm := &remoteFSM{
+		Remote:    r,
+		pingTimer: time.NewTicker(timeoutInterval),
+		probes:    map[uint64]sentProbe{},
+		buf:       make([]byte, bufferSize),
+	}
+	fsm.pingTimer.Stop()
+	return fsm
+}
+
+func (r *remoteFSM) Run() {
+	go func() {
+		for range r.pingTimer.C {
+			r.messages <- pingTimerMsg{}
+		}
+	}()
+	state := r.enterDisconnected()
+	for msg := range r.messages {
+		state = state(msg)
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+func (r *remoteFSM) enterDisconnected() stateFunc {
+	r.updateConf(remoteConfig{})
+	return r.stateDisconnected
+}
+
+func (r *remoteFSM) stateDisconnected(iMsg any) stateFunc {
+	switch msg := iMsg.(type) {
+	case peerUpdateMsg:
+		return r.enterPeerUpdating(msg.Peer)
+	case controlMsg[packetInit]:
+		r.logf("Unexpected INIT")
+	case controlMsg[packetSyn]:
+		r.logf("Unexpected SYN")
+	case controlMsg[packetAck]:
+		r.logf("Unexpected ACK")
+	case controlMsg[packetProbe]:
+		r.logf("Unexpected probe")
+	case controlMsg[packetLocalDiscovery]:
+		// Ignore
+	case pingTimerMsg:
+		r.logf("Unexpected ping")
+	default:
+		r.logf("Ignoring message: %#v", iMsg)
+	}
+
+	return r.stateDisconnected
+}
+
+// ----------------------------------------------------------------------------
+
+func (r *remoteFSM) enterPeerUpdating(peer *m.Peer) stateFunc {
+	if peer == nil {
+		return r.enterDisconnected()
+	}
+
+	conf := remoteConfig{
+		Peer:          peer,
+		ControlCipher: newControlCipher(r.PrivKey, peer.PubKey),
+	}
+	r.updateConf(conf)
+
+	if _, isValid := netip.AddrFromSlice(peer.PublicIP); isValid {
+		if r.LocalAddrValid && r.LocalPeerIP < peer.PeerIP {
+			return r.enterServer()
+		}
+		return r.enterClientInit()
+	}
+
+	if r.LocalAddrValid || r.LocalPeerIP < peer.PeerIP {
+		return r.enterServer()
+	}
+
+	return r.enterClientInit()
+}
+
+// ----------------------------------------------------------------------------
+
+func (r *remoteFSM) enterServer() stateFunc {
+
+	conf := r.conf()
+	conf.Server = true
+	r.updateConf(conf)
+	r.logf("==> Server")
+
+	r.pingTimer.Reset(pingInterval)
+	r.lastSeen = time.Now()
+	return r.stateServer
+}
+
+func (r *remoteFSM) stateServer(iMsg any) stateFunc {
+	switch msg := iMsg.(type) {
+	case peerUpdateMsg:
+		return r.enterPeerUpdating(msg.Peer)
+	case controlMsg[packetInit]:
+		r.stateServer_onInit(msg)
+	case controlMsg[packetSyn]:
+		r.stateServer_onSyn(msg)
+	case controlMsg[packetAck]:
+		r.logf("Unexpected ACK")
+	case controlMsg[packetProbe]:
+		r.stateServer_onProbe(msg)
+	case controlMsg[packetLocalDiscovery]:
+		// Ignore
+	case pingTimerMsg:
+		r.stateServer_onPingTimer()
+	default:
+		r.logf("Unexpected message: %#v", iMsg)
+	}
+
+	return r.stateServer
+}
+
+func (r *remoteFSM) stateServer_onInit(msg controlMsg[packetInit]) {
+	conf := r.conf()
+	conf.Up = false
+	conf.Direct = msg.Packet.Direct
+	conf.DirectAddr = msg.SrcAddr
+	r.updateConf(conf)
+
+	init := packetInit{
+		TraceID: msg.Packet.TraceID,
+		Direct:  conf.Direct,
+		Version: version,
+	}
+
+	r.sendControl(conf, init.Marshal(r.buf))
+}
+
+func (r *remoteFSM) stateServer_onSyn(msg controlMsg[packetSyn]) {
+	r.lastSeen = time.Now()
+	p := msg.Packet
+
+	// Before we can respond to this packet, we need to make sure the
+	// route is setup properly.
+	conf := r.conf()
+	logSyn := !conf.Up || conf.Direct != p.Direct
+
+	conf.Up = true
+	conf.Direct = p.Direct
+	conf.DirectAddr = msg.SrcAddr
+
+	// Update data cipher if the key has changed.
+	if !conf.DataCipher.HasKey(p.SharedKey) {
+		conf.DataCipher = newDataCipherFromKey(p.SharedKey)
+	}
+
+	r.updateConf(conf)
+
+	if logSyn {
+		r.logf("Got SYN.")
+	}
+
+	r.sendControl(conf, packetAck{
+		TraceID:       p.TraceID,
+		ToAddr:        conf.DirectAddr,
+		PossibleAddrs: r.PubAddrs.Get(),
+	}.Marshal(r.buf))
+
+	if p.Direct {
+		return
+	}
+
+	// Send probes if not a direct connection.
+	for _, addr := range msg.Packet.PossibleAddrs {
+		if !addr.IsValid() {
+			break
+		}
+		r.logf("Probing %v...", addr)
+		r.sendControlToAddr(packetProbe{TraceID: r.NewTraceID()}.Marshal(r.buf), addr)
+	}
+}
+
+func (r *remoteFSM) stateServer_onProbe(msg controlMsg[packetProbe]) {
+	if !msg.SrcAddr.IsValid() {
+		return
+	}
+
+	data := packetProbe{TraceID: msg.Packet.TraceID}.Marshal(r.buf)
+	r.sendControlToAddr(data, msg.SrcAddr)
+}
+
+func (r *remoteFSM) stateServer_onPingTimer() {
+	conf := r.conf()
+	if time.Since(r.lastSeen) > timeoutInterval && conf.Up {
+		conf.Up = false
+		r.updateConf(conf)
+		r.logf("Timeout.")
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+func (r *remoteFSM) enterClientInit() stateFunc {
+	conf := r.conf()
+	ip, ipValid := netip.AddrFromSlice(conf.Peer.PublicIP)
+
+	conf.Up = false
+	conf.Server = false
+	conf.Direct = ipValid
+	conf.DirectAddr = netip.AddrPortFrom(ip, conf.Peer.Port)
+	conf.DataCipher = newDataCipher()
+
+	r.updateConf(conf)
+	r.logf("==> ClientInit")
+
+	r.lastSeen = time.Now()
+	r.pingTimer.Reset(pingInterval)
+	r.stateClientInit_sendInit()
+	return r.stateClientInit
+}
+
+func (r *remoteFSM) stateClientInit(iMsg any) stateFunc {
+	switch msg := iMsg.(type) {
+	case peerUpdateMsg:
+		return r.enterPeerUpdating(msg.Peer)
+	case controlMsg[packetInit]:
+		return r.stateClientInit_onInit(msg)
+	case controlMsg[packetSyn]:
+		r.logf("Unexpected SYN")
+	case controlMsg[packetAck]:
+		r.logf("Unexpected ACK")
+	case controlMsg[packetProbe]:
+		// Ignore
+	case controlMsg[packetLocalDiscovery]:
+		// Ignore
+	case pingTimerMsg:
+		return r.stateClientInit_onPing()
+	default:
+		r.logf("Unexpected message: %#v", iMsg)
+	}
+
+	return r.stateClientInit
+}
+
+func (r *remoteFSM) stateClientInit_sendInit() {
+	conf := r.conf()
+	r.traceID = r.NewTraceID()
+	init := packetInit{
+		TraceID: r.traceID,
+		Direct:  conf.Direct,
+		Version: version,
+	}
+	r.sendControl(conf, init.Marshal(r.buf))
+}
+
+func (r *remoteFSM) stateClientInit_onInit(msg controlMsg[packetInit]) stateFunc {
+	if msg.Packet.TraceID != r.traceID {
+		r.logf("Invalid trace ID on INIT.")
+		return r.stateClientInit
+	}
+	r.logf("Got INIT version %d.", msg.Packet.Version)
+	return r.enterClient()
+}
+
+func (r *remoteFSM) stateClientInit_onPing() stateFunc {
+	if time.Since(r.lastSeen) < timeoutInterval {
+		r.stateClientInit_sendInit()
+		return r.stateClientInit
+	}
+
+	// Direct connect failed. Try indirect.
+	conf := r.conf()
+
+	if conf.Direct {
+		conf.Direct = false
+		r.updateConf(conf)
+		r.lastSeen = time.Now()
+		r.stateClientInit_sendInit()
+		r.logf("Direct connection failed. Attempting indirect connection.")
+		return r.stateClientInit
+	}
+
+	// Indirect failed. Re-enter init state.
+	r.logf("Timeout.")
+	return r.enterClientInit()
+}
+
+// ----------------------------------------------------------------------------
+
+func (r *remoteFSM) enterClient() stateFunc {
+	conf := r.conf()
+	r.probes = make(map[uint64]sentProbe, 8)
+
+	r.traceID = r.NewTraceID()
+	r.stateClient_sendSyn(conf)
+
+	r.pingTimer.Reset(pingInterval)
+	r.logf("==> Client")
+	return r.stateClient
+}
+
+func (r *remoteFSM) stateClient(iMsg any) stateFunc {
+	switch msg := iMsg.(type) {
+	case peerUpdateMsg:
+		return r.enterPeerUpdating(msg.Peer)
+	case controlMsg[packetAck]:
+		r.stateClient_onAck(msg)
+	case controlMsg[packetProbe]:
+		r.stateClient_onProbe(msg)
+	case controlMsg[packetLocalDiscovery]:
+		r.stateClient_onLocalDiscovery(msg)
+	case pingTimerMsg:
+		return r.stateClient_onPingTimer()
+	default:
+		r.logf("Ignoring message: %v", iMsg)
+	}
+	return r.stateClient
+}
+
+func (r *remoteFSM) stateClient_onAck(msg controlMsg[packetAck]) {
+	if msg.Packet.TraceID != r.traceID {
+		return
+	}
+
+	r.lastSeen = time.Now()
+
+	conf := r.conf()
+	if !conf.Up {
+		conf.Up = true
+		r.updateConf(conf)
+		r.logf("Got ACK.")
+	}
+
+	if conf.Direct {
+		r.PubAddrs.Store(msg.Packet.ToAddr)
+		return
+	}
+
+	// Relayed.
+
+	r.stateClient_cleanProbes()
+
+	for _, addr := range msg.Packet.PossibleAddrs {
+		if !addr.IsValid() {
+			break
+		}
+		r.stateClient_sendProbeTo(addr)
+	}
+}
+
+func (r *remoteFSM) stateClient_cleanProbes() {
+	for key, sent := range r.probes {
+		if time.Since(sent.SentAt) > pingInterval {
+			delete(r.probes, key)
+		}
+	}
+}
+
+func (r *remoteFSM) stateClient_sendProbeTo(addr netip.AddrPort) {
+	probe := packetProbe{TraceID: r.NewTraceID()}
+	r.probes[probe.TraceID] = sentProbe{
+		SentAt: time.Now(),
+		Addr:   addr,
+	}
+	r.logf("Probing %v...", addr)
+	r.sendControlToAddr(probe.Marshal(r.buf), addr)
+}
+
+func (r *remoteFSM) stateClient_onProbe(msg controlMsg[packetProbe]) {
+	conf := r.conf()
+	if conf.Direct {
+		return
+	}
+
+	r.stateClient_cleanProbes()
+
+	sent, ok := r.probes[msg.Packet.TraceID]
+	if !ok {
+		return
+	}
+
+	conf.Direct = true
+	conf.DirectAddr = sent.Addr
+	r.updateConf(conf)
+
+	r.traceID = r.NewTraceID()
+	r.stateClient_sendSyn(conf)
+	r.logf("Successful probe to %v.", sent.Addr)
+}
+
+func (r *remoteFSM) stateClient_onLocalDiscovery(msg controlMsg[packetLocalDiscovery]) {
+	conf := r.conf()
+	if conf.Direct {
+		return
+	}
+
+	// The source port will be the multicast port, so we'll have to
+	// construct the correct address using the peer's listed port.
+	addr := netip.AddrPortFrom(msg.SrcAddr.Addr(), conf.Peer.Port)
+	r.stateClient_sendProbeTo(addr)
+}
+
+func (r *remoteFSM) stateClient_onPingTimer() stateFunc {
+	conf := r.conf()
+
+	if time.Since(r.lastSeen) > timeoutInterval {
+		if conf.Up {
+			r.logf("Timeout.")
+		}
+		return r.enterClientInit()
+	}
+
+	r.stateClient_sendSyn(conf)
+	return r.stateClient
+}
+
+func (r *remoteFSM) stateClient_sendSyn(conf remoteConfig) {
+	syn := packetSyn{
+		TraceID:       r.traceID,
+		SharedKey:     conf.DataCipher.Key(),
+		Direct:        conf.Direct,
+		PossibleAddrs: r.PubAddrs.Get(),
+	}
+
+	r.sendControl(conf, syn.Marshal(r.buf))
+}

peer/routingtable.go

@@ -1,138 +0,0 @@
-package peer
-
-import (
-	"net/netip"
-	"sync/atomic"
-	"time"
-)
-
-// TODO: Remove
-func newRemotePeer(ip byte) *remotePeer {
-	counter := uint64(time.Now().Unix()<<30 + 1)
-	return &remotePeer{
-		IP:       ip,
-		counter:  &counter,
-		dupCheck: newDupCheck(0),
-	}
-}
-
-// ----------------------------------------------------------------------------
-
-type remotePeer struct {
-	localIP       byte
-	IP            byte           // VPN IP of peer (last byte).
-	Up            bool           // True if data can be sent on the peer.
-	Relay         bool           // True if the peer is a relay.
-	Direct        bool           // True if this is a direct connection.
-	DirectAddr    netip.AddrPort // Remote address if directly connected.
-	PubSignKey    []byte
-	ControlCipher *controlCipher
-	DataCipher    *dataCipher
-
-	counter  *uint64   // For sending to. Atomic access only.
-	dupCheck *dupCheck // For receiving from. Not safe for concurrent use.
-}
-
-func (p remotePeer) EncryptDataPacket(destIP byte, data, out []byte) []byte {
-	h := header{
-		StreamID: dataStreamID,
-		Counter:  atomic.AddUint64(p.counter, 1),
-		SourceIP: p.localIP,
-		DestIP:   destIP,
-	}
-	return p.DataCipher.Encrypt(h, data, out)
-}
-
-// Decrypts and de-dups incoming data packets.
-func (p remotePeer) DecryptDataPacket(h header, enc, out []byte) ([]byte, error) {
-	dec, ok := p.DataCipher.Decrypt(enc, out)
-	if !ok {
-		return nil, errDecryptionFailed
-	}
-
-	if p.dupCheck.IsDup(h.Counter) {
-		return nil, errDuplicateSeqNum
-	}
-
-	return dec, nil
-}
-
-// Peer must have a ControlCipher.
-func (p remotePeer) EncryptControlPacket(pkt marshaller, tmp, out []byte) []byte {
-	tmp = pkt.Marshal(tmp)
-	h := header{
-		StreamID: controlStreamID,
-		Counter:  atomic.AddUint64(p.counter, 1),
-		SourceIP: p.localIP,
-		DestIP:   p.IP,
-	}
-
-	return p.ControlCipher.Encrypt(h, tmp, out)
-}
-
-// Returns a controlMsg[PacketType]. Peer must have a non-nil ControlCipher.
-//
-// This function also drops packets with duplicate sequence numbers.
-func (p remotePeer) DecryptControlPacket(fromAddr netip.AddrPort, h header, enc, tmp []byte) (any, error) {
-	out, ok := p.ControlCipher.Decrypt(enc, tmp)
-	if !ok {
-		return nil, errDecryptionFailed
-	}
-
-	if p.dupCheck.IsDup(h.Counter) {
-		return nil, errDuplicateSeqNum
-	}
-
-	msg, err := parseControlMsg(h.SourceIP, fromAddr, out)
-	if err != nil {
-		return nil, err
-	}
-
-	return msg, nil
-}
-
-// ----------------------------------------------------------------------------
-
-type routingTable struct {
-	// The LocalIP is the configured IP address of the local peer on the VPN.
-	//
-	// This value is constant.
-	LocalIP byte
-
-	// The LocalAddr is the configured local public address of the peer on the
-	// internet. If LocalAddr.IsValid(), then the local peer has a public
-	// address.
-	//
-	// This value is constant.
-	LocalAddr netip.AddrPort
-
-	// The remote peer configurations. These are updated by
-	Peers [256]remotePeer
-
-	// The current relay's VPN IP address, or zero if no relay is available.
-	RelayIP byte
-}
-
-func newRoutingTable(localIP byte, localAddr netip.AddrPort) routingTable {
-	rt := routingTable{
-		LocalIP:   localIP,
-		LocalAddr: localAddr,
-	}
-
-	for i := range rt.Peers {
-		counter := uint64(time.Now().Unix()<<30 + 1)
-		rt.Peers[i] = remotePeer{
-			localIP:  localIP,
-			IP:       byte(i),
-			counter:  &counter,
-			dupCheck: newDupCheck(0),
-		}
-	}
-
-	return rt
-}
-
-func (rt *routingTable) GetRelay() (remotePeer, bool) {
-	relay := rt.Peers[rt.RelayIP]
-	return relay, relay.Up && relay.Direct
-}

peer/routingtable_test.go

@@ -1,169 +0,0 @@
-package peer
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-)
-
-func TestRemotePeer_DecryptDataPacket(t *testing.T) {
-	p1, p2, _ := NewPeersForTesting()
-	orig := RandPacket()
-
-	peer2 := p1.RT.Load().Peers[2]
-	peer1 := p2.RT.Load().Peers[1]
-
-	enc := peer2.EncryptDataPacket(2, orig, newBuf())
-
-	h := parseHeader(enc)
-	if h.DestIP != 2 || h.SourceIP != 1 {
-		t.Fatal(h)
-	}
-
-	dec, err := peer1.DecryptDataPacket(h, enc, newBuf())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !bytes.Equal(orig, dec) {
-		t.Fatal(dec)
-	}
-}
-
-func TestRemotePeer_DecryptDataPacket_packetAltered(t *testing.T) {
-	p1, p2, _ := NewPeersForTesting()
-	orig := RandPacket()
-
-	peer2 := p1.RT.Load().Peers[2]
-	peer1 := p2.RT.Load().Peers[1]
-
-	enc := peer2.EncryptDataPacket(2, orig, newBuf())
-
-	h := parseHeader(enc)
-
-	for range 2048 {
-		_, err := peer1.DecryptDataPacket(h, ModifyPacket(enc), newBuf())
-		if err == nil {
-			t.Fatal(enc)
-		}
-	}
-}
-
-func TestRemotePeer_DecryptDataPacket_duplicateSequenceNumber(t *testing.T) {
-	p1, p2, _ := NewPeersForTesting()
-	orig := RandPacket()
-
-	peer2 := p1.RT.Load().Peers[2]
-	peer1 := p2.RT.Load().Peers[1]
-
-	enc := peer2.EncryptDataPacket(2, orig, newBuf())
-	h := parseHeader(enc)
-
-	if _, err := peer1.DecryptDataPacket(h, enc, newBuf()); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := peer1.DecryptDataPacket(h, enc, newBuf()); err == nil {
-		t.Fatal(err)
-	}
-}
-
-func TestRemotePeer_DecryptControlPacket(t *testing.T) {
-	p1, p2, _ := NewPeersForTesting()
-
-	peer2 := p1.RT.Load().Peers[2]
-	peer1 := p2.RT.Load().Peers[1]
-
-	orig := packetProbe{TraceID: newTraceID()}
-
-	enc := peer2.EncryptControlPacket(orig, newBuf(), newBuf())
-
-	h := parseHeader(enc)
-	if h.DestIP != 2 || h.SourceIP != 1 {
-		t.Fatal(h)
-	}
-
-	ctrlMsg, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, enc, newBuf())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	dec, ok := ctrlMsg.(controlMsg[packetProbe])
-	if !ok {
-		t.Fatal(ctrlMsg)
-	}
-
-	if dec.SrcIP != 1 || dec.SrcAddr != p1.RT.Load().LocalAddr {
-		t.Fatal(dec)
-	}
-
-	if !reflect.DeepEqual(dec.Packet, orig) {
-		t.Fatal(dec)
-	}
-}
-
-func TestRemotePeer_DecryptControlPacket_packetAltered(t *testing.T) {
-	p1, p2, _ := NewPeersForTesting()
-
-	peer2 := p1.RT.Load().Peers[2]
-	peer1 := p2.RT.Load().Peers[1]
-
-	orig := packetProbe{TraceID: newTraceID()}
-
-	enc := peer2.EncryptControlPacket(orig, newBuf(), newBuf())
-
-	h := parseHeader(enc)
-	if h.DestIP != 2 || h.SourceIP != 1 {
-		t.Fatal(h)
-	}
-
-	for range 2048 {
-		ctrlMsg, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, ModifyPacket(enc), newBuf())
-		if err == nil {
-			t.Fatal(ctrlMsg)
-		}
-	}
-}
-
-func TestRemotePeer_DecryptControlPacket_duplicateSequenceNumber(t *testing.T) {
-	p1, p2, _ := NewPeersForTesting()
-
-	peer2 := p1.RT.Load().Peers[2]
-	peer1 := p2.RT.Load().Peers[1]
-
-	orig := packetProbe{TraceID: newTraceID()}
-
-	enc := peer2.EncryptControlPacket(orig, newBuf(), newBuf())
-
-	h := parseHeader(enc)
-	if h.DestIP != 2 || h.SourceIP != 1 {
-		t.Fatal(h)
-	}
-
-	if _, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, enc, newBuf()); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, enc, newBuf()); err == nil {
-		t.Fatal(err)
-	}
-}
-
-func TestRemotePeer_DecryptControlPacket_unknownPacketType(t *testing.T) {
-	p1, p2, _ := NewPeersForTesting()
-
-	peer2 := p1.RT.Load().Peers[2]
-	peer1 := p2.RT.Load().Peers[1]
-
-	orig := UnknownControlPacket{TraceID: newTraceID()}
-
-	enc := peer2.EncryptControlPacket(orig, newBuf(), newBuf())
-
-	h := parseHeader(enc)
-	if h.DestIP != 2 || h.SourceIP != 1 {
-		t.Fatal(h)
-	}
-
-	if _, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, enc, newBuf()); err == nil {
-		t.Fatal(err)
-	}
-}

peer/state-client.go

@@ -1,162 +0,0 @@
-package peer
-
-import (
-	"net/netip"
-	"time"
-)
-
-type sentProbe struct {
-	SentAt time.Time
-	Addr   netip.AddrPort
-}
-
-type stateClient struct {
-	*peerData
-	lastSeen time.Time
-	syn      packetSyn
-	probes   map[uint64]sentProbe
-}
-
-func enterStateClient(data *peerData) peerState {
-	ip, ipValid := netip.AddrFromSlice(data.peer.PublicIP)
-
-	data.staged.Relay = data.peer.Relay && ipValid
-	data.staged.Direct = ipValid
-	data.staged.DirectAddr = netip.AddrPortFrom(ip, data.peer.Port)
-	data.publish(data.staged)
-
-	state := &stateClient{
-		peerData: data,
-		lastSeen: time.Now(),
-		syn: packetSyn{
-			TraceID:       newTraceID(),
-			SharedKey:     data.staged.DataCipher.Key(),
-			Direct:        data.staged.Direct,
-			PossibleAddrs: data.pubAddrs.Get(),
-		},
-		probes: map[uint64]sentProbe{},
-	}
-
-	state.Send(state.staged, state.syn)
-
-	data.pingTimer.Reset(pingInterval)
-
-	state.logf("==> Client")
-	return state
-}
-
-func (s *stateClient) logf(str string, args ...any) {
-	s.peerData.logf("CLNT | "+str, args...)
-}
-
-func (s *stateClient) OnMsg(raw any) peerState {
-	switch msg := raw.(type) {
-	case peerUpdateMsg:
-		return initPeerState(s.peerData, msg.Peer)
-	case controlMsg[packetAck]:
-		s.onAck(msg)
-	case controlMsg[packetProbe]:
-		return s.onProbe(msg)
-	case controlMsg[packetLocalDiscovery]:
-		s.onLocalDiscovery(msg)
-	case pingTimerMsg:
-		return s.onPingTimer()
-	default:
-		s.logf("Ignoring message: %v", raw)
-	}
-	return s
-}
-
-func (s *stateClient) onAck(msg controlMsg[packetAck]) {
-	if msg.Packet.TraceID != s.syn.TraceID {
-		return
-	}
-
-	s.lastSeen = time.Now()
-
-	if !s.staged.Up {
-		s.staged.Up = true
-		s.publish(s.staged)
-		s.logf("Got ACK.")
-	}
-
-	if s.staged.Direct {
-		s.pubAddrs.Store(msg.Packet.ToAddr)
-		return
-	}
-
-	// Relayed below.
-
-	s.cleanProbes()
-
-	for _, addr := range msg.Packet.PossibleAddrs {
-		if !addr.IsValid() {
-			break
-		}
-		s.sendProbeTo(addr)
-	}
-}
-
-func (s *stateClient) onPingTimer() peerState {
-	if time.Since(s.lastSeen) > timeoutInterval {
-		if s.staged.Up {
-			s.logf("Timeout.")
-		}
-		return initPeerState(s.peerData, s.peer)
-	}
-
-	s.Send(s.staged, s.syn)
-	return s
-}
-
-func (s *stateClient) onProbe(msg controlMsg[packetProbe]) peerState {
-	if s.staged.Direct {
-		return s
-	}
-
-	s.cleanProbes()
-
-	sent, ok := s.probes[msg.Packet.TraceID]
-	if !ok {
-		return s
-	}
-
-	s.staged.Direct = true
-	s.staged.DirectAddr = sent.Addr
-	s.publish(s.staged)
-
-	s.syn.TraceID = newTraceID()
-	s.syn.Direct = true
-	s.Send(s.staged, s.syn)
-	s.logf("Successful probe to %v.", sent.Addr)
-	return s
-}
-
-func (s *stateClient) onLocalDiscovery(msg controlMsg[packetLocalDiscovery]) {
-	if s.staged.Direct {
-		return
-	}
-
-	// The source port will be the multicast port, so we'll have to
-	// construct the correct address using the peer's listed port.
-	addr := netip.AddrPortFrom(msg.SrcAddr.Addr(), s.peer.Port)
-	s.sendProbeTo(addr)
-}
-
-func (s *stateClient) cleanProbes() {
-	for key, sent := range s.probes {
-		if time.Since(sent.SentAt) > pingInterval {
-			delete(s.probes, key)
-		}
-	}
-}
-
-func (s *stateClient) sendProbeTo(addr netip.AddrPort) {
-	probe := packetProbe{TraceID: newTraceID()}
-	s.probes[probe.TraceID] = sentProbe{
-		SentAt: time.Now(),
-		Addr:   addr,
-	}
-	s.logf("Probing %v...", addr)
-	s.SendTo(probe, addr)
-}

peer/state-client_test.go

@@ -1,193 +0,0 @@
-package peer
-
-import (
-	"testing"
-	"time"
-)
-
-func TestStateClient_peerUpdate(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-	h.PeerUpdate(nil)
-	assertType[*stateDisconnected](t, h.State)
-}
-
-func TestStateClient_initialPackets(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-
-	assertEqual(t, len(h.Sent), 2)
-	assertType[packetInit](t, h.Sent[0].Packet)
-	assertType[packetSyn](t, h.Sent[1].Packet)
-}
-
-func TestStateClient_onAck_incorrectTraceID(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-	h.Sent = h.Sent[:0]
-
-	ack := controlMsg[packetAck]{
-		Packet: packetAck{TraceID: newTraceID()},
-	}
-	h.OnAck(ack)
-
-	// Nothing should have happened.
-	assertType[*stateClient](t, h.State)
-	assertEqual(t, len(h.Sent), 0)
-}
-
-func TestStateClient_onAck_direct_downToUp(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-
-	assertEqual(t, len(h.Sent), 2)
-	syn := assertType[packetSyn](t, h.Sent[1].Packet)
-	h.Sent = h.Sent[:0]
-
-	assertEqual(t, h.Published.Up, false)
-
-	ack := controlMsg[packetAck]{
-		Packet: packetAck{TraceID: syn.TraceID},
-	}
-
-	h.OnAck(ack)
-
-	assertEqual(t, len(h.Sent), 0)
-}
-
-func TestStateClient_onAck_relayed_sendsProbes(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	assertEqual(t, len(h.Sent), 2)
-	syn := assertType[packetSyn](t, h.Sent[1].Packet)
-	h.Sent = h.Sent[:0]
-
-	assertEqual(t, h.Published.Up, false)
-
-	ack := controlMsg[packetAck]{
-		Packet: packetAck{TraceID: syn.TraceID},
-	}
-	ack.Packet.PossibleAddrs[0] = addrPort4(1, 2, 3, 4, 100)
-	ack.Packet.PossibleAddrs[1] = addrPort4(2, 3, 4, 5, 200)
-
-	h.OnAck(ack)
-
-	assertEqual(t, len(h.Sent), 2)
-	assertType[packetProbe](t, h.Sent[0].Packet)
-	assertEqual(t, h.Sent[0].Peer.DirectAddr, ack.Packet.PossibleAddrs[0])
-	assertType[packetProbe](t, h.Sent[1].Packet)
-	assertEqual(t, h.Sent[1].Peer.DirectAddr, ack.Packet.PossibleAddrs[1])
-}
-
-func TestStateClient_onPing(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-	h.Sent = h.Sent[:0]
-	h.OnPingTimer()
-	assertEqual(t, len(h.Sent), 1)
-	assertType[*stateClient](t, h.State)
-	assertType[packetSyn](t, h.Sent[0].Packet)
-}
-
-func TestStateClient_onPing_timeout(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-	h.Sent = h.Sent[:0]
-	state := assertType[*stateClient](t, h.State)
-	state.lastSeen = time.Now().Add(-2 * timeoutInterval)
-	state.staged.Up = true
-	h.OnPingTimer()
-
-	newState := assertType[*stateClientInit](t, h.State)
-	assertEqual(t, newState.staged.Up, false)
-	assertEqual(t, len(h.Sent), 1)
-	assertType[packetInit](t, h.Sent[0].Packet)
-}
-
-func TestStateClient_onProbe_direct(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-
-	h.Sent = h.Sent[:0]
-	probe := controlMsg[packetProbe]{
-		Packet: packetProbe{
-			TraceID: newTraceID(),
-		},
-	}
-
-	h.OnProbe(probe)
-	assertType[*stateClient](t, h.State)
-	assertEqual(t, len(h.Sent), 0)
-}
-
-func TestStateClient_onProbe_noMatch(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	h.Sent = h.Sent[:0]
-	probe := controlMsg[packetProbe]{
-		Packet: packetProbe{
-			TraceID: newTraceID(),
-		},
-	}
-
-	h.OnProbe(probe)
-	assertType[*stateClient](t, h.State)
-	assertEqual(t, len(h.Sent), 0)
-}
-
-func TestStateClient_onProbe_directUpgrade(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	state := assertType[*stateClient](t, h.State)
-	traceID := newTraceID()
-	state.probes[traceID] = sentProbe{
-		SentAt: time.Now(),
-		Addr:   addrPort4(1, 2, 3, 4, 500),
-	}
-
-	probe := controlMsg[packetProbe]{
-		Packet: packetProbe{TraceID: traceID},
-	}
-
-	assertEqual(t, h.Published.Direct, false)
-	h.Sent = h.Sent[:0]
-	h.OnProbe(probe)
-	assertEqual(t, h.Published.Direct, true)
-
-	assertEqual(t, len(h.Sent), 1)
-	assertType[packetSyn](t, h.Sent[0].Packet)
-}
-
-func TestStateClient_onLocalDiscovery_direct(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientDirect(t)
-
-	h.Sent = h.Sent[:0]
-	pkt := controlMsg[packetLocalDiscovery]{
-		Packet: packetLocalDiscovery{},
-	}
-
-	h.OnLocalDiscovery(pkt)
-	assertType[*stateClient](t, h.State)
-	assertEqual(t, len(h.Sent), 0)
-}
-
-func TestStateClient_onLocalDiscovery_relayed(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientRelayed(t)
-
-	h.Sent = h.Sent[:0]
-	pkt := controlMsg[packetLocalDiscovery]{
-		SrcAddr: addrPort4(1, 2, 3, 4, 500),
-		Packet:  packetLocalDiscovery{},
-	}
-
-	h.OnLocalDiscovery(pkt)
-	assertType[*stateClient](t, h.State)
-	assertEqual(t, len(h.Sent), 1)
-	assertType[packetProbe](t, h.Sent[0].Packet)
-	assertEqual(t, h.Sent[0].Peer.DirectAddr, addrPort4(1, 2, 3, 4, 456))
-}

peer/state-clientinit.go

@@ -1,104 +0,0 @@
-package peer
-
-import (
-	"net/netip"
-	"time"
-)
-
-type stateClientInit struct {
-	*peerData
-	startedAt time.Time
-	traceID   uint64
-}
-
-func enterStateClientInit(data *peerData) peerState {
-	ip, ipValid := netip.AddrFromSlice(data.peer.PublicIP)
-
-	data.staged.Up = false
-	data.staged.Relay = false
-	data.staged.Direct = ipValid
-	data.staged.DirectAddr = netip.AddrPortFrom(ip, data.peer.Port)
-	data.staged.PubSignKey = data.peer.PubSignKey
-	data.staged.ControlCipher = newControlCipher(data.privKey, data.peer.PubKey)
-	data.staged.DataCipher = newDataCipher()
-
-	data.publish(data.staged)
-
-	state := &stateClientInit{
-		peerData:  data,
-		startedAt: time.Now(),
-		traceID:   newTraceID(),
-	}
-	state.sendInit()
-
-	data.pingTimer.Reset(pingInterval)
-
-	state.logf("==> ClientInit")
-	return state
-}
-
-func (s *stateClientInit) logf(str string, args ...any) {
-	s.peerData.logf("INIT | "+str, args...)
-}
-
-func (s *stateClientInit) OnMsg(raw any) peerState {
-	switch msg := raw.(type) {
-	case peerUpdateMsg:
-		return initPeerState(s.peerData, msg.Peer)
-	case controlMsg[packetInit]:
-		return s.onInit(msg)
-	case controlMsg[packetSyn]:
-		s.logf("Unexpected SYN")
-		return s
-	case controlMsg[packetAck]:
-		s.logf("Unexpected ACK")
-		return s
-	case controlMsg[packetProbe]:
-		return s
-	case controlMsg[packetLocalDiscovery]:
-		return s
-	case pingTimerMsg:
-		return s.onPing()
-	default:
-		s.logf("Ignoring message: %#v", raw)
-		return s
-	}
-}
-
-func (s *stateClientInit) onInit(msg controlMsg[packetInit]) peerState {
-	if msg.Packet.TraceID != s.traceID {
-		s.logf("Invalid trace ID on INIT.")
-		return s
-	}
-	s.logf("Got INIT version %d.", msg.Packet.Version)
-	return enterStateClient(s.peerData)
-}
-
-func (s *stateClientInit) onPing() peerState {
-	if time.Since(s.startedAt) < timeoutInterval {
-		s.sendInit()
-		return s
-	}
-
-	if s.staged.Direct {
-		s.staged.Direct = false
-		s.publish(s.staged)
-		s.startedAt = time.Now()
-		s.sendInit()
-		s.logf("Direct connection failed. Attempting indirect connection.")
-		return s
-	}
-
-	s.logf("Timeout.")
-	return initPeerState(s.peerData, s.peer)
-}
-
-func (s *stateClientInit) sendInit() {
-	s.traceID = newTraceID()
-	init := packetInit{
-		TraceID: s.traceID,
-		Direct:  s.staged.Direct,
-		Version: version,
-	}
-	s.Send(s.staged, init)
-}

peer/state-clientinit_test.go

@@ -1,92 +0,0 @@
-package peer
-
-import (
-	"testing"
-	"time"
-)
-
-func TestPeerState_ClientInit_initWithIncorrectTraceID(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientInit(t)
-
-	// Should have sent the first init packet.
-	assertEqual(t, len(h.Sent), 1)
-	init := assertType[packetInit](t, h.Sent[0].Packet)
-
-	init.TraceID = newTraceID()
-	h.OnInit(controlMsg[packetInit]{Packet: init})
-
-	assertType[*stateClientInit](t, h.State)
-}
-
-func TestPeerState_ClientInit_init(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientInit(t)
-
-	// Should have sent the first init packet.
-	assertEqual(t, len(h.Sent), 1)
-	init := assertType[packetInit](t, h.Sent[0].Packet)
-	h.OnInit(controlMsg[packetInit]{Packet: init})
-
-	assertType[*stateClient](t, h.State)
-}
-
-func TestPeerState_ClientInit_onPing(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientInit(t)
-
-	// Should have sent the first init packet.
-	assertEqual(t, len(h.Sent), 1)
-	h.Sent = h.Sent[:0]
-
-	for range 3 {
-		h.OnPingTimer()
-	}
-
-	assertEqual(t, len(h.Sent), 3)
-
-	for i := range h.Sent {
-		assertType[packetInit](t, h.Sent[i].Packet)
-	}
-}
-
-func TestPeerState_ClientInit_onPingTimeout(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientInit(t)
-
-	state := assertType[*stateClientInit](t, h.State)
-	state.startedAt = time.Now().Add(-2 * timeoutInterval)
-	assertEqual(t, state.staged.Direct, true)
-
-	h.OnPingTimer()
-
-	// Should now try indirect connection.
-	state = assertType[*stateClientInit](t, h.State)
-	assertEqual(t, state.staged.Direct, false)
-
-	// Should re-initialize the peer after another timeout, so should be direct
-	// again.
-	state.startedAt = time.Now().Add(-2 * timeoutInterval)
-	h.OnPingTimer()
-
-	assertEqual(t, state.staged.Direct, true)
-}
-
-func TestPeerState_ClientInit_onPeerUpdate(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientInit(t)
-
-	h.PeerUpdate(nil)
-
-	// Should have moved into the client state due to timeout.
-	assertType[*stateDisconnected](t, h.State)
-}
-
-func TestPeerState_ClientInit_ignoreMessage(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigClientInit(t)
-	h.OnProbe(controlMsg[packetProbe]{})
-
-	// Shouldn't do anything.
-	assertType[*stateClientInit](t, h.State)
-}

peer/state-disconnected.go

@@ -1,50 +0,0 @@
-package peer
-
-import "net/netip"
-
-type stateDisconnected struct {
-	*peerData
-}
-
-func enterStateDisconnected(data *peerData) peerState {
-	data.staged.Up = false
-	data.staged.Relay = false
-	data.staged.Direct = false
-	data.staged.DirectAddr = netip.AddrPort{}
-	data.staged.PubSignKey = nil
-	data.staged.ControlCipher = nil
-	data.staged.DataCipher = nil
-
-	data.publish(data.staged)
-
-	data.pingTimer.Stop()
-
-	return &stateDisconnected{data}
-}
-
-func (s *stateDisconnected) OnMsg(raw any) peerState {
-	switch msg := raw.(type) {
-	case peerUpdateMsg:
-		return initPeerState(s.peerData, msg.Peer)
-	case controlMsg[packetInit]:
-		s.logf("Unexpected INIT")
-		return s
-	case controlMsg[packetSyn]:
-		s.logf("Unexpected SYN")
-		return s
-	case controlMsg[packetAck]:
-		s.logf("Unexpected ACK")
-		return s
-	case controlMsg[packetProbe]:
-		s.logf("Unexpected probe")
-		return s
-	case controlMsg[packetLocalDiscovery]:
-		return s
-	case pingTimerMsg:
-		s.logf("Unexpected ping")
-		return s
-	default:
-		s.logf("Ignoring message: %#v", raw)
-		return s
-	}
-}

peer/state-server.go

@@ -1,136 +0,0 @@
-package peer
-
-import (
-	"net/netip"
-	"time"
-)
-
-type stateServer struct {
-	*peerData
-	lastSeen   time.Time
-	synTraceID uint64 // Last syn trace ID.
-}
-
-func enterStateServer(data *peerData) peerState {
-	data.staged.Up = false
-	data.staged.Relay = false
-	data.staged.Direct = false
-	data.staged.DirectAddr = netip.AddrPort{}
-	data.staged.PubSignKey = data.peer.PubSignKey
-	data.staged.ControlCipher = newControlCipher(data.privKey, data.peer.PubKey)
-	data.staged.DataCipher = nil
-
-	data.publish(data.staged)
-
-	data.pingTimer.Reset(pingInterval)
-
-	state := &stateServer{
-		peerData: data,
-		lastSeen: time.Now(),
-	}
-	state.logf("==> Server")
-	return state
-}
-
-func (s *stateServer) logf(str string, args ...any) {
-	s.peerData.logf("SRVR | "+str, args...)
-}
-
-func (s *stateServer) OnMsg(raw any) peerState {
-	switch msg := raw.(type) {
-	case peerUpdateMsg:
-		return initPeerState(s.peerData, msg.Peer)
-	case controlMsg[packetInit]:
-		return s.onInit(msg)
-	case controlMsg[packetSyn]:
-		return s.onSyn(msg)
-	case controlMsg[packetAck]:
-		s.logf("Unexpected ACK")
-		return s
-	case controlMsg[packetProbe]:
-		return s.onProbe(msg)
-	case controlMsg[packetLocalDiscovery]:
-		return s
-	case pingTimerMsg:
-		return s.onPingTimer()
-	default:
-		s.logf("Unexpected message: %#v", raw)
-		return s
-	}
-}
-
-func (s *stateServer) onInit(msg controlMsg[packetInit]) peerState {
-	s.staged.Up = false
-	s.staged.Direct = msg.Packet.Direct
-	s.staged.DirectAddr = msg.SrcAddr
-	s.publish(s.staged)
-
-	init := packetInit{
-		TraceID: msg.Packet.TraceID,
-		Direct:  s.staged.Direct,
-		Version: version,
-	}
-
-	s.Send(s.staged, init)
-
-	return s
-}
-
-func (s *stateServer) onSyn(msg controlMsg[packetSyn]) peerState {
-	s.lastSeen = time.Now()
-	p := msg.Packet
-
-	// Before we can respond to this packet, we need to make sure the
-	// route is setup properly.
-	//
-	// The client will update the syn's TraceID whenever there's a change.
-	// The server will follow the client's request.
-	if p.TraceID != s.synTraceID || !s.staged.Up {
-		s.synTraceID = p.TraceID
-		s.staged.Up = true
-		s.staged.Direct = p.Direct
-		s.staged.DataCipher = newDataCipherFromKey(p.SharedKey)
-		s.staged.DirectAddr = msg.SrcAddr
-		s.publish(s.staged)
-		s.logf("Got SYN.")
-	}
-
-	// Always respond.
-	s.Send(s.staged, packetAck{
-		TraceID:       p.TraceID,
-		ToAddr:        s.staged.DirectAddr,
-		PossibleAddrs: s.pubAddrs.Get(),
-	})
-
-	if p.Direct {
-		return s
-	}
-
-	// Send probes if not a direct connection.
-	for _, addr := range msg.Packet.PossibleAddrs {
-		if !addr.IsValid() {
-			break
-		}
-		s.logf("Probing %v...", addr)
-		s.SendTo(packetProbe{TraceID: newTraceID()}, addr)
-	}
-
-	return s
-}
-
-func (s *stateServer) onProbe(msg controlMsg[packetProbe]) peerState {
-	if msg.SrcAddr.IsValid() {
-		s.logf("Probe response %v...", msg.SrcAddr)
-		s.SendTo(packetProbe{TraceID: msg.Packet.TraceID}, msg.SrcAddr)
-	}
-	return s
-}
-
-func (s *stateServer) onPingTimer() peerState {
-	if time.Since(s.lastSeen) > timeoutInterval && s.staged.Up {
-		s.staged.Up = false
-		s.publish(s.staged)
-		s.logf("Timeout.")
-	}
-	return s
-}

peer/state-server_test.go

@@ -1,164 +0,0 @@
-package peer
-
-import (
-	"testing"
-	"time"
-)
-
-func TestStateServer_peerUpdate(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Public(t)
-	h.PeerUpdate(nil)
-	assertType[*stateDisconnected](t, h.State)
-}
-
-func TestStateServer_onInit(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Public(t)
-
-	msg := controlMsg[packetInit]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 2, 3, 4, 1000),
-		Packet: packetInit{
-			TraceID: newTraceID(),
-			Direct:  true,
-			Version: 4,
-		},
-	}
-
-	h.OnInit(msg)
-	assertEqual(t, len(h.Sent), 1)
-	assertEqual(t, h.Sent[0].Peer.DirectAddr, msg.SrcAddr)
-	resp := assertType[packetInit](t, h.Sent[0].Packet)
-	assertEqual(t, msg.Packet.TraceID, resp.TraceID)
-	assertEqual(t, resp.Version, version)
-}
-
-func TestStateServer_onSynDirect(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Public(t)
-
-	msg := controlMsg[packetSyn]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 2, 3, 4, 1000),
-		Packet: packetSyn{
-			TraceID: newTraceID(),
-			Direct:  true,
-		},
-	}
-
-	msg.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 1, 1000)
-	msg.Packet.PossibleAddrs[1] = addrPort4(1, 1, 1, 2, 2000)
-
-	h.OnSyn(msg)
-	assertEqual(t, len(h.Sent), 1)
-	assertEqual(t, h.Sent[0].Peer.DirectAddr, msg.SrcAddr)
-	resp := assertType[packetAck](t, h.Sent[0].Packet)
-	assertEqual(t, msg.Packet.TraceID, resp.TraceID)
-}
-
-func TestStateServer_onSynRelayed(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-
-	msg := controlMsg[packetSyn]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 2, 3, 4, 1000),
-		Packet: packetSyn{
-			TraceID: newTraceID(),
-		},
-	}
-
-	msg.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 1, 1000)
-	msg.Packet.PossibleAddrs[1] = addrPort4(1, 1, 1, 2, 2000)
-
-	h.OnSyn(msg)
-	assertEqual(t, len(h.Sent), 3)
-	assertEqual(t, h.Sent[0].Peer.DirectAddr, msg.SrcAddr)
-	resp := assertType[packetAck](t, h.Sent[0].Packet)
-	assertEqual(t, msg.Packet.TraceID, resp.TraceID)
-
-	for i, pkt := range h.Sent[1:] {
-		assertEqual(t, pkt.Peer.DirectAddr, msg.Packet.PossibleAddrs[i])
-		assertType[packetProbe](t, pkt.Packet)
-	}
-}
-
-func TestStateServer_onProbe(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-
-	msg := controlMsg[packetProbe]{
-		SrcIP: 3,
-		Packet: packetProbe{
-			TraceID: newTraceID(),
-		},
-	}
-	h.Sent = h.Sent[:0]
-
-	h.OnProbe(msg)
-	assertEqual(t, len(h.Sent), 0)
-}
-
-func TestStateServer_onProbe_valid(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-
-	msg := controlMsg[packetProbe]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 2, 3, 4, 100),
-		Packet: packetProbe{
-			TraceID: newTraceID(),
-		},
-	}
-	h.Sent = h.Sent[:0]
-
-	h.OnProbe(msg)
-	assertEqual(t, len(h.Sent), 1)
-	assertType[packetProbe](t, h.Sent[0].Packet)
-	assertEqual(t, h.Sent[0].Peer.DirectAddr, msg.SrcAddr)
-}
-
-func TestStateServer_onPing(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-	h.Sent = h.Sent[:0]
-	h.OnPingTimer()
-	assertEqual(t, len(h.Sent), 0)
-	assertType[*stateServer](t, h.State)
-}
-
-func TestStateServer_onPing_timeout(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-
-	h.Sent = h.Sent[:0]
-	state := assertType[*stateServer](t, h.State)
-	state.staged.Up = true
-	state.lastSeen = time.Now().Add(-2 * timeoutInterval)
-
-	h.OnPingTimer()
-	state = assertType[*stateServer](t, h.State)
-	assertEqual(t, len(h.Sent), 0)
-	assertEqual(t, state.staged.Up, false)
-}
-
-func TestStateServer_onLocalDiscovery(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-
-	msg := controlMsg[packetLocalDiscovery]{
-		SrcIP:   3,
-		SrcAddr: addrPort4(1, 2, 3, 4, 100),
-	}
-	h.OnLocalDiscovery(msg)
-	assertType[*stateServer](t, h.State)
-}
-
-func TestStateServer_onAck(t *testing.T) {
-	h := NewPeerStateTestHarness()
-	h.ConfigServer_Relayed(t)
-	msg := controlMsg[packetAck]{}
-	h.OnAck(msg)
-	assertType[*stateServer](t, h.State)
-}

peer/state-util_test.go

@@ -1,151 +0,0 @@
-package peer
-
-import (
-	"net/netip"
-	"testing"
-	"time"
-	"vppn/m"
-
-	"git.crumpington.com/lib/go/ratelimiter"
-)
-
-type PeerStateControlMsg struct {
-	Peer   remotePeer
-	Packet any
-}
-
-type PeerStateTestHarness struct {
-	data      *peerData
-	State     peerState
-	Published remotePeer
-	Sent      []PeerStateControlMsg
-}
-
-func NewPeerStateTestHarness() *PeerStateTestHarness {
-	h := &PeerStateTestHarness{}
-
-	keys := generateKeys()
-
-	state := &peerData{
-		publish: func(rp remotePeer) {
-			h.Published = rp
-		},
-		sendControlPacket: func(rp remotePeer, pkt marshaller) {
-			h.Sent = append(h.Sent, PeerStateControlMsg{rp, pkt})
-		},
-		pingTimer: time.NewTicker(pingInterval),
-		localIP:   2,
-		remoteIP:  3,
-		privKey:   keys.PrivKey,
-		pubAddrs:  newPubAddrStore(netip.AddrPort{}),
-		limiter: ratelimiter.New(ratelimiter.Config{
-			FillPeriod:   20 * time.Millisecond,
-			MaxWaitCount: 1,
-		}),
-	}
-	h.data = state
-
-	h.State = enterStateDisconnected(state)
-	return h
-}
-
-func (h *PeerStateTestHarness) PeerUpdate(p *m.Peer) {
-	h.State = h.State.OnMsg(peerUpdateMsg{p})
-}
-
-func (h *PeerStateTestHarness) OnInit(msg controlMsg[packetInit]) {
-	h.State = h.State.OnMsg(msg)
-}
-
-func (h *PeerStateTestHarness) OnSyn(msg controlMsg[packetSyn]) {
-	h.State = h.State.OnMsg(msg)
-}
-
-func (h *PeerStateTestHarness) OnAck(msg controlMsg[packetAck]) {
-	h.State = h.State.OnMsg(msg)
-}
-
-func (h *PeerStateTestHarness) OnProbe(msg controlMsg[packetProbe]) {
-	h.State = h.State.OnMsg(msg)
-}
-
-func (h *PeerStateTestHarness) OnLocalDiscovery(msg controlMsg[packetLocalDiscovery]) {
-	h.State = h.State.OnMsg(msg)
-}
-
-func (h *PeerStateTestHarness) OnPingTimer() {
-	h.State = h.State.OnMsg(pingTimerMsg{})
-}
-
-func (h *PeerStateTestHarness) ConfigServer_Public(t *testing.T) *stateServer {
-	keys := generateKeys()
-
-	state := h.State.(*stateDisconnected)
-	state.localAddr = addrPort4(1, 1, 1, 2, 200)
-
-	peer := &m.Peer{
-		PeerIP:     3,
-		PublicIP:   []byte{1, 1, 1, 3},
-		Port:       456,
-		PubKey:     keys.PubKey,
-		PubSignKey: keys.PubSignKey,
-	}
-
-	h.PeerUpdate(peer)
-	assertEqual(t, h.Published.Up, false)
-	return assertType[*stateServer](t, h.State)
-}
-
-func (h *PeerStateTestHarness) ConfigServer_Relayed(t *testing.T) *stateServer {
-	keys := generateKeys()
-	peer := &m.Peer{
-		PeerIP:     3,
-		Port:       456,
-		PubKey:     keys.PubKey,
-		PubSignKey: keys.PubSignKey,
-	}
-
-	h.PeerUpdate(peer)
-	assertEqual(t, h.Published.Up, false)
-	return assertType[*stateServer](t, h.State)
-}
-
-func (h *PeerStateTestHarness) ConfigClientInit(t *testing.T) *stateClientInit {
-	// Remote IP should be less than local IP.
-	h.data.localIP = 4
-	keys := generateKeys()
-	peer := &m.Peer{
-		PeerIP:     3,
-		PublicIP:   []byte{1, 2, 3, 4},
-		Port:       456,
-		PubKey:     keys.PubKey,
-		PubSignKey: keys.PubSignKey,
-	}
-
-	h.PeerUpdate(peer)
-	assertEqual(t, h.Published.Up, false)
-	return assertType[*stateClientInit](t, h.State)
-}
-
-func (h *PeerStateTestHarness) ConfigClientDirect(t *testing.T) *stateClient {
-	h.ConfigClientInit(t)
-	init := assertType[packetInit](t, h.Sent[0].Packet)
-	h.OnInit(controlMsg[packetInit]{
-		Packet: init,
-	})
-
-	return assertType[*stateClient](t, h.State)
-}
-
-func (h *PeerStateTestHarness) ConfigClientRelayed(t *testing.T) *stateClient {
-	h.ConfigClientInit(t)
-	state := assertType[*stateClientInit](t, h.State)
-	state.peer.PublicIP = nil // Force relay.
-
-	init := assertType[packetInit](t, h.Sent[0].Packet)
-	h.OnInit(controlMsg[packetInit]{
-		Packet: init,
-	})
-
-	return assertType[*stateClient](t, h.State)
-}

peer/statedata.go

@@ -1,109 +0,0 @@
-package peer
-
-import (
-	"fmt"
-	"log"
-	"net/netip"
-	"strings"
-	"time"
-	"vppn/m"
-
-	"git.crumpington.com/lib/go/ratelimiter"
-)
-
-type peerState interface {
-	OnMsg(raw any) peerState
-}
-
-// ----------------------------------------------------------------------------
-
-type peerData struct {
-	// Output.
-	publish           func(remotePeer)
-	sendControlPacket func(remotePeer, marshaller)
-	pingTimer         *time.Ticker
-
-	// Immutable data.
-	localIP   byte
-	remoteIP  byte
-	privKey   []byte
-	localAddr netip.AddrPort // If valid, then local peer is publicly accessible.
-
-	pubAddrs *pubAddrStore
-
-	// The purpose of this state machine is to manage the RemotePeer object,
-	// publishing it as necessary.
-	staged remotePeer // Local copy of shared data. See publish().
-
-	// Mutable peer data.
-	peer *m.Peer
-
-	// We rate limit per remote endpoint because if we don't we tend to lose
-	// packets.
-	limiter *ratelimiter.Limiter
-}
-
-func (s *peerData) logf(format string, args ...any) {
-	b := strings.Builder{}
-	name := ""
-	if s.peer != nil {
-		name = s.peer.Name
-	}
-	b.WriteString(fmt.Sprintf("%03d", s.remoteIP))
-
-	b.WriteString(fmt.Sprintf("%30s: ", name))
-
-	if s.staged.Direct {
-		b.WriteString("DIRECT  | ")
-	} else {
-		b.WriteString("RELAYED | ")
-	}
-
-	if s.staged.Up {
-		b.WriteString("UP   | ")
-	} else {
-		b.WriteString("DOWN | ")
-	}
-
-	log.Printf(b.String()+format, args...)
-}
-
-// ----------------------------------------------------------------------------
-
-func (s *peerData) SendTo(pkt marshaller, addr netip.AddrPort) {
-	if !addr.IsValid() {
-		return
-	}
-	route := s.staged
-	route.Direct = true
-	route.DirectAddr = addr
-	s.Send(route, pkt)
-}
-
-func (s *peerData) Send(peer remotePeer, pkt marshaller) {
-	if err := s.limiter.Limit(); err != nil {
-		s.logf("Rate limited.")
-		return
-	}
-	s.sendControlPacket(peer, pkt)
-}
-
-func initPeerState(data *peerData, peer *m.Peer) peerState {
-	data.peer = peer
-
-	if peer == nil {
-		return enterStateDisconnected(data)
-	}
-
-	if _, isValid := netip.AddrFromSlice(peer.PublicIP); isValid {
-		if data.localAddr.IsValid() && data.localIP < data.remoteIP {
-			return enterStateServer(data)
-		}
-		return enterStateClientInit(data)
-	}
-
-	if data.localAddr.IsValid() || data.localIP < data.remoteIP {
-		return enterStateServer(data)
-	}
-	return enterStateClientInit(data)
-}

peer/util_test.go

@@ -1,26 +0,0 @@
-package peer
-
-import (
-	"net/netip"
-	"testing"
-)
-
-func addrPort4(a, b, c, d byte, port uint16) netip.AddrPort {
-	return netip.AddrPortFrom(netip.AddrFrom4([4]byte{a, b, c, d}), port)
-}
-
-func assertType[T any](t *testing.T, obj any) T {
-	t.Helper()
-	x, ok := obj.(T)
-	if !ok {
-		t.Fatalf("invalid type: %#v", obj)
-	}
-	return x
-}
-
-func assertEqual[T comparable](t *testing.T, a, b T) {
-	t.Helper()
-	if a != b {
-		t.Fatal(a, " != ", b)
-	}
-}