awgctrl

type Client struct {
	// contains filtered or unexported fields
}

type Config struct {
	// PrivateKey specifies a private key configuration, if not nil.
	//
	// A non-nil, zero-value Key will clear the private key.
	PrivateKey *Key

	// ListenPort specifies a device's listening port, if not nil.
	ListenPort *uint16

	// FirewallMark specifies a device's firewall mark, if not nil.
	//
	// If non-nil and set to 0, the firewall mark will be cleared.
	FirewallMark *uint32

	// JunkCount sets the number of junk packets, if not nil.
	//
	// Values: 1-128
	// Recommended: 4-12
	JunkCount *uint16

	// JunkMin specifies the minimum size of junk packets, if not nil.
	//
	// Values: JunkMax > JunkMin < MTU
	// Recommended: 8
	JunkMin *uint16

	// JunkMax specifies the maximum size of junk packets, if not nil.
	//
	// Values: JunkMin < JunkMax <= MTU
	// Recommended: 80
	JunkMax *uint16

	// S1 specifies init packet junk size, if not nil.
	// Values: S1 <= (MTU - 148) && S1 + 56 != S2
	// Recommended: 15-150
	S1 *uint16

	// S2 specifies response packet junk size, if not nil.
	// Values: S2 <= (MTU - 92)
	// Recommended: 15-150
	S2 *uint16

	// H* specifies packet magic header, if not nil.
	// H1 - init | H2 - response | H3 - underload | H4 - transport.
	// Values: (H* <= MaxInt32); unique among each other
	// Recommended: 5-MaxInt32
	H1, H2, H3, H4 *uint32

	// ReplacePeers specifies if the Peers in this configuration should replace
	// the existing peer list, instead of appending them to the existing list.
	ReplacePeers bool

	// Peers specifies a list of peer configurations to apply to a device.
	Peers []PeerConfig
}

type Device struct {
	// Name is the name of the device.
	Name string

	// PrivateKey is the device's private key.
	PrivateKey Key

	// PublicKey is the device's public key, computed from its PrivateKey.
	PublicKey Key

	// ListenPort is the device's network listening port.
	ListenPort uint16

	// FirewallMark is the device's current firewall mark.
	//
	// The firewall mark can be used in conjunction with firewall software to
	// take action on outgoing WireGuard packets.
	FirewallMark uint32

	// JunkCount is a number of junk packets.
	JunkCount uint16

	// JunkMin and JunkMax specify the minimum and maximum size of junk packets.
	JunkMin, JunkMax uint16

	// S1 and S2 is a init and response junk packet sizes.
	S1, S2 uint16

	// H* is a packet magic header.
	// H1 - init | H2 - response | H3 - underload | H4 - transport.
	H1, H2, H3, H4 uint32

	// Peers is the list of network peers associated with this device.
	Peers []Peer
}

type Encoder struct{ *netlink.AttributeEncoder }

type Key [KeyLen]byte

type Peer struct {
	// PublicKey is the public key of a peer, computed from its private key.
	//
	// PublicKey is always present in a Peer.
	PublicKey Key

	// PresharedKey is an optional preshared key which may be used as an
	// additional layer of security for peer communications.
	//
	// A zero-value Key means no preshared key is configured.
	PresharedKey Key

	// Endpoint is the most recent source address used for communication by
	// this Peer.
	Endpoint *net.UDPAddr

	// PersistentKeepaliveInterval specifies how often an "empty" packet is sent
	// to a peer to keep a connection alive.
	//
	// A value of 0 indicates that persistent keepalives are disabled.
	PersistentKeepaliveInterval time.Duration

	// LastHandshakeTime indicates the most recent time a handshake was performed
	// with this peer.
	//
	// A zero-value time.Time indicates that no handshake has taken place with
	// this peer.
	LastHandshakeTime time.Time

	// ReceiveBytes indicates the number of bytes received from this peer.
	ReceiveBytes int64

	// TransmitBytes indicates the number of bytes transmitted to this peer.
	TransmitBytes int64

	// AllowedIPs specifies which IPv4 and IPv6 addresses this peer is allowed
	// to communicate on.
	//
	// 0.0.0.0/0 indicates that all IPv4 addresses are allowed, and ::/0
	// indicates that all IPv6 addresses are allowed.
	AllowedIPs []net.IPNet

	// ProtocolVersion specifies which version of the WireGuard protocol is used
	// for this Peer.
	//
	// A value of 0 indicates that the most recent protocol version will be used.
	ProtocolVersion int
}

type PeerConfig struct {
	// PublicKey specifies the public key of this peer.  PublicKey is a
	// mandatory field for all PeerConfigs.
	PublicKey Key

	// Remove specifies if the peer with this public key should be removed
	// from a device's peer list.
	Remove bool

	// UpdateOnly specifies that an operation will only occur on this peer
	// if the peer already exists as part of the interface.
	UpdateOnly bool

	// PresharedKey specifies a peer's preshared key configuration, if not nil.
	//
	// A non-nil, zero-value Key will clear the preshared key.
	PresharedKey *Key

	// Endpoint specifies the endpoint of this peer entry, if not nil.
	Endpoint *net.UDPAddr

	// PersistentKeepaliveInterval specifies the persistent keepalive interval
	// for this peer, if not nil.
	//
	// A non-nil value of 0 will clear the persistent keepalive interval.
	PersistentKeepaliveInterval *time.Duration

	// ReplaceAllowedIPs specifies if the allowed IPs specified in this peer
	// configuration should replace any existing ones, instead of appending them
	// to the allowed IPs list.
	ReplaceAllowedIPs bool

	// AllowedIPs specifies a list of allowed IP addresses in CIDR notation
	// for this peer.
	AllowedIPs []net.IPNet
}