115 lines
2.7 KiB
Go
115 lines
2.7 KiB
Go
package ships
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
|
|
"github.com/safing/portbase/log"
|
|
"github.com/safing/portmaster/service/netenv"
|
|
"github.com/safing/portmaster/spn/hub"
|
|
)
|
|
|
|
// Launch launches a new ship to the given Hub.
|
|
func Launch(ctx context.Context, h *hub.Hub, transport *hub.Transport, ip net.IP) (Ship, error) {
|
|
var transports []*hub.Transport
|
|
var ips []net.IP
|
|
|
|
// choose transports
|
|
if transport != nil {
|
|
transports = []*hub.Transport{transport}
|
|
} else {
|
|
if h.Info == nil {
|
|
return nil, hub.ErrMissingInfo
|
|
}
|
|
transports = h.Info.ParsedTransports()
|
|
// If there are no transports, check if they were parsed.
|
|
if len(transports) == 0 && len(h.Info.Transports) > 0 {
|
|
log.Errorf("ships: %s has no parsed transports, but transports are %v", h, h.Info.Transports)
|
|
// Attempt to parse transports now.
|
|
transports, _ = hub.ParseTransports(h.Info.Transports)
|
|
}
|
|
// Fail if there are not transports.
|
|
if len(transports) == 0 {
|
|
return nil, hub.ErrMissingTransports
|
|
}
|
|
}
|
|
|
|
// choose IPs
|
|
if ip != nil {
|
|
ips = []net.IP{ip}
|
|
} else {
|
|
if h.Info == nil {
|
|
return nil, hub.ErrMissingInfo
|
|
}
|
|
ips = make([]net.IP, 0, 3)
|
|
// If IPs have been verified, check if we can use a virtual network address.
|
|
var vnetForced bool
|
|
if h.VerifiedIPs {
|
|
vnet := GetVirtualNetworkConfig()
|
|
if vnet != nil {
|
|
virtIP := vnet.Mapping[h.ID]
|
|
if virtIP != nil {
|
|
ips = append(ips, virtIP)
|
|
if vnet.Force {
|
|
vnetForced = true
|
|
log.Infof("spn/ships: forcing virtual network address %s for %s", virtIP, h)
|
|
} else {
|
|
log.Infof("spn/ships: using virtual network address %s for %s", virtIP, h)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Add Hub's IPs if no virtual address was forced.
|
|
if !vnetForced {
|
|
// prioritize IPv4
|
|
if h.Info.IPv4 != nil {
|
|
ips = append(ips, h.Info.IPv4)
|
|
}
|
|
if h.Info.IPv6 != nil && netenv.IPv6Enabled() {
|
|
ips = append(ips, h.Info.IPv6)
|
|
}
|
|
}
|
|
if len(ips) == 0 {
|
|
return nil, hub.ErrMissingIPs
|
|
}
|
|
}
|
|
|
|
// connect
|
|
var firstErr error
|
|
for _, ip := range ips {
|
|
for _, tr := range transports {
|
|
ship, err := connectTo(ctx, h, tr, ip)
|
|
if err == nil {
|
|
return ship, nil // return on success
|
|
}
|
|
|
|
// Check if context is canceled.
|
|
if ctx.Err() != nil {
|
|
return nil, ctx.Err()
|
|
}
|
|
|
|
// Save first error.
|
|
if firstErr == nil {
|
|
firstErr = err
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil, firstErr
|
|
}
|
|
|
|
func connectTo(ctx context.Context, h *hub.Hub, transport *hub.Transport, ip net.IP) (Ship, error) {
|
|
builder := GetBuilder(transport.Protocol)
|
|
if builder == nil {
|
|
return nil, fmt.Errorf("protocol %s not supported", transport.Protocol)
|
|
}
|
|
|
|
ship, err := builder.LaunchShip(ctx, transport, ip)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to connect to %s using %s (%s): %w", h, transport, ip, err)
|
|
}
|
|
|
|
return ship, nil
|
|
}
|