mirror of
https://github.com/safing/portmaster
synced 2025-09-02 02:29:12 +00:00
135 lines
3.3 KiB
Go
135 lines
3.3 KiB
Go
package docks
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/safing/portbase/container"
|
|
"github.com/safing/portbase/formats/dsd"
|
|
"github.com/safing/portmaster/spn/terminal"
|
|
)
|
|
|
|
const (
|
|
// WhoAmIType is the type ID of the latency test operation.
|
|
WhoAmIType = "whoami"
|
|
|
|
whoAmITimeout = 3 * time.Second
|
|
)
|
|
|
|
// WhoAmIOp is used to request some metadata about the other side.
|
|
type WhoAmIOp struct {
|
|
terminal.OneOffOperationBase
|
|
|
|
response *WhoAmIResponse
|
|
}
|
|
|
|
// WhoAmIResponse is a whoami response.
|
|
type WhoAmIResponse struct {
|
|
// Timestamp in nanoseconds
|
|
Timestamp int64 `cbor:"t,omitempty" json:"t,omitempty"`
|
|
|
|
// Addr is the remote address as reported by the crane terminal (IP and port).
|
|
Addr string `cbor:"a,omitempty" json:"a,omitempty"`
|
|
}
|
|
|
|
// Type returns the type ID.
|
|
func (op *WhoAmIOp) Type() string {
|
|
return WhoAmIType
|
|
}
|
|
|
|
func init() {
|
|
terminal.RegisterOpType(terminal.OperationFactory{
|
|
Type: WhoAmIType,
|
|
Start: startWhoAmI,
|
|
})
|
|
}
|
|
|
|
// WhoAmI executes a whoami operation and returns the response.
|
|
func WhoAmI(t terminal.Terminal) (*WhoAmIResponse, *terminal.Error) {
|
|
whoami, err := NewWhoAmIOp(t)
|
|
if err.IsError() {
|
|
return nil, err
|
|
}
|
|
|
|
// Wait for response.
|
|
select {
|
|
case tErr := <-whoami.Result:
|
|
if tErr.IsError() {
|
|
return nil, tErr
|
|
}
|
|
return whoami.response, nil
|
|
case <-time.After(whoAmITimeout * 2):
|
|
return nil, terminal.ErrTimeout
|
|
}
|
|
}
|
|
|
|
// NewWhoAmIOp starts a new whoami operation.
|
|
func NewWhoAmIOp(t terminal.Terminal) (*WhoAmIOp, *terminal.Error) {
|
|
// Create operation and init.
|
|
op := &WhoAmIOp{}
|
|
op.OneOffOperationBase.Init()
|
|
|
|
// Send ping.
|
|
tErr := t.StartOperation(op, nil, whoAmITimeout)
|
|
if tErr != nil {
|
|
return nil, tErr
|
|
}
|
|
|
|
return op, nil
|
|
}
|
|
|
|
// Deliver delivers a message to the operation.
|
|
func (op *WhoAmIOp) Deliver(msg *terminal.Msg) *terminal.Error {
|
|
defer msg.Finish()
|
|
|
|
// Parse response.
|
|
response := &WhoAmIResponse{}
|
|
_, err := dsd.Load(msg.Data.CompileData(), response)
|
|
if err != nil {
|
|
return terminal.ErrMalformedData.With("failed to parse ping response: %w", err)
|
|
}
|
|
|
|
op.response = response
|
|
return terminal.ErrExplicitAck
|
|
}
|
|
|
|
func startWhoAmI(t terminal.Terminal, opID uint32, data *container.Container) (terminal.Operation, *terminal.Error) {
|
|
// Get crane terminal, if available.
|
|
ct, _ := t.(*CraneTerminal)
|
|
|
|
// Create response.
|
|
r := &WhoAmIResponse{
|
|
Timestamp: time.Now().UnixNano(),
|
|
}
|
|
if ct != nil {
|
|
r.Addr = ct.RemoteAddr().String()
|
|
}
|
|
response, err := dsd.Dump(r, dsd.CBOR)
|
|
if err != nil {
|
|
return nil, terminal.ErrInternalError.With("failed to create whoami response: %w", err)
|
|
}
|
|
|
|
// Send response.
|
|
msg := terminal.NewMsg(response)
|
|
msg.FlowID = opID
|
|
msg.Unit.MakeHighPriority()
|
|
if terminal.UsePriorityDataMsgs {
|
|
msg.Type = terminal.MsgTypePriorityData
|
|
}
|
|
tErr := t.Send(msg, whoAmITimeout)
|
|
if tErr != nil {
|
|
// Finish message unit on failure.
|
|
msg.Finish()
|
|
return nil, tErr.With("failed to send ping response")
|
|
}
|
|
|
|
// Operation is just one response and finished successfully.
|
|
return nil, nil
|
|
}
|
|
|
|
// HandleStop gives the operation the ability to cleanly shut down.
|
|
// The returned error is the error to send to the other side.
|
|
// Should never be called directly. Call Stop() instead.
|
|
func (op *WhoAmIOp) HandleStop(err *terminal.Error) (errorToSend *terminal.Error) {
|
|
// Continue with usual handling of inherited base.
|
|
return op.OneOffOperationBase.HandleStop(err)
|
|
}
|