142 lines
4.1 KiB
Go
142 lines
4.1 KiB
Go
// SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package network
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"time"
|
|
|
|
"github.com/ssbc/go-muxrpc/v2"
|
|
"github.com/ssbc/go-netwrap"
|
|
"github.com/ssbc/go-secretstream"
|
|
refs "github.com/ssbc/go-ssb-refs"
|
|
)
|
|
|
|
// ServerEndpointDetails encapsulates the endpoint information.
|
|
// Like domain name of the room, it's ssb/secret-handshake public key and the HTTP and MUXRPC TCP ports.
|
|
type ServerEndpointDetails struct {
|
|
RoomID refs.FeedRef
|
|
|
|
ListenAddressMUXRPC string // defaults to ":8008"
|
|
|
|
// Domain sets the DNS name for all the HTTP(S) URLs.
|
|
Domain string
|
|
PortHTTPS uint // 0 assumes default (443)
|
|
|
|
// UseSubdomainForAliases controls wether urls for alias resolving
|
|
// are generated as https://$alias.$domain instead of https://$domain/alias/$alias
|
|
UseSubdomainForAliases bool
|
|
|
|
// Development instructs url building to happen with http and include the http port
|
|
Development bool
|
|
}
|
|
|
|
func (sed ServerEndpointDetails) URLForAlias(a string) string {
|
|
var u url.URL
|
|
|
|
if sed.Development {
|
|
u.Path = "/alias/" + a
|
|
u.Scheme = "http"
|
|
u.Host = fmt.Sprintf("localhost:%d", sed.PortHTTPS)
|
|
return u.String()
|
|
}
|
|
|
|
u.Scheme = "https"
|
|
|
|
if sed.UseSubdomainForAliases {
|
|
u.Host = a + "." + sed.Domain
|
|
} else {
|
|
u.Host = sed.Domain
|
|
u.Path = "/alias/" + a
|
|
}
|
|
|
|
return u.String()
|
|
}
|
|
|
|
// MultiserverAddress returns net:domain:muxport~shs:roomPubKeyInBase64
|
|
// ie: the room servers https://github.com/ssbc/multiserver-address
|
|
func (sed ServerEndpointDetails) MultiserverAddress() string {
|
|
addr, err := net.ResolveTCPAddr("tcp", sed.ListenAddressMUXRPC)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
var roomPubKey = base64.StdEncoding.EncodeToString(sed.RoomID.PubKey())
|
|
return fmt.Sprintf("net:%s:%d~shs:%s", sed.Domain, addr.Port, roomPubKey)
|
|
}
|
|
|
|
// EndpointStat gives some information about a connected peer
|
|
type EndpointStat struct {
|
|
ID *refs.FeedRef
|
|
Addr net.Addr
|
|
Since time.Duration
|
|
Endpoint muxrpc.Endpoint
|
|
}
|
|
|
|
//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -o mocked/endpoints.go . Endpoints
|
|
|
|
// Endpoints returns the connected endpoint for the passed feed,
|
|
// or false if there is none.
|
|
type Endpoints interface {
|
|
GetEndpointFor(refs.FeedRef) (muxrpc.Endpoint, bool)
|
|
}
|
|
|
|
// Network supplies all network related functionalitiy
|
|
type Network interface {
|
|
Connect(ctx context.Context, addr net.Addr) error
|
|
Serve(context.Context, ...muxrpc.HandlerWrapper) error
|
|
GetListenAddr() net.Addr
|
|
|
|
GetAllEndpoints() []EndpointStat
|
|
Endpoints
|
|
|
|
GetConnTracker() ConnTracker
|
|
|
|
// WebsockHandler returns a "middleware" like thing that is able to upgrade a
|
|
// websocket request to a muxrpc connection and authenticate using shs.
|
|
// It calls the next handler if it fails to upgrade the connection to websocket.
|
|
// However, it will error on the request and not call the passed handler
|
|
// if the websocket upgrade is successfull.
|
|
WebsockHandler(next http.Handler) http.Handler
|
|
|
|
io.Closer
|
|
}
|
|
|
|
// ConnTracker decides if connections should be established and keeps track of them
|
|
type ConnTracker interface {
|
|
// Active returns true and since when a peer connection is active
|
|
Active(net.Addr) (bool, time.Duration)
|
|
|
|
// OnAccept receives a new connection as an argument.
|
|
// If it decides to accept it, it returns true and a context that will be canceled once it should shut down
|
|
// If it decides to deny it, it returns false (and a nil context)
|
|
OnAccept(context.Context, net.Conn) (bool, context.Context)
|
|
|
|
// OnClose notifies the tracker that a connection was closed
|
|
OnClose(conn net.Conn) time.Duration
|
|
|
|
// Count returns the number of open connections
|
|
Count() uint
|
|
|
|
// CloseAll closes all tracked connections
|
|
CloseAll()
|
|
}
|
|
|
|
// GetFeedRefFromAddr uses netwrap to get the secretstream address and then uses ParseFeedRef
|
|
func GetFeedRefFromAddr(addr net.Addr) (refs.FeedRef, error) {
|
|
addr = netwrap.GetAddr(addr, secretstream.NetworkString)
|
|
if addr == nil {
|
|
return refs.FeedRef{}, errors.New("no shs-bs address found")
|
|
}
|
|
ssAddr := addr.(secretstream.Addr)
|
|
return refs.ParseFeedRef(ssAddr.String())
|
|
}
|