registration

type IATable interface {
	// Register a new entry for AS ia with the specified public, bind and
	// services addresses and associate a value with the entry. Lookup calls
	// for matching addresses will return the associated value.
	//
	// A LookupPublic call will select an entry with a matching public address.
	// For IPv4, this is either a perfect match or a 0.0.0.0 entry. For IPv6,
	// this is either a perfect match or a :: entry. If the public address to
	// register matches an existing entry, an error is returned. Using port 0
	// for the public address will allocate a valid port.
	//
	// A LookupService call will select an entry with matching bind and service
	// addresses. Binds for 0.0.0.0 or :: are not allowed. The port is
	// inherited from the public address. To not register for a service, use a
	// bind of nil and a svc of none. For more information about SVC behavior,
	// see the documentation for SVCTable.
	//
	// To unregister from the table, free the returned reference.
	Register(ia addr.IA, public *net.UDPAddr, bind net.IP, svc addr.HostSVC,
		value interface{}) (RegReference, error)
	// LookupPublic returns the value associated with the selected public
	// address. Wildcard addresses are supported. If an entry is found, the
	// returned boolean is set to true. Otherwise, it is set to false.
	LookupPublic(ia addr.IA, public *net.UDPAddr) (interface{}, bool)
	// LookupService returns the entries associated with svc and bind.
	//
	// If SVC is an anycast address, at most one entry is returned. The bind
	// address is used to narrow down the set of possible entries. If multiple
	// entries exist, one is selected arbitrarily.
	//
	// Note that nil bind addresses are supported for anycasts (the address is
	// in this case ignored), but support for this might be dropped in the
	// future.
	//
	// If SVC is a multicast address, more than one entry can be returned. The
	// bind address is ignored in this case.
	LookupService(ia addr.IA, svc addr.HostSVC, bind net.IP) []interface{}
	// LookupID returns the entry associated with the SCMP General class ID id.
	// The ID is used for SCMP Echo, TraceRoute, and RecordPath functionality.
	// If an entry is found, the returned boolean is set to true. Otherwise, it
	// is set to false.
	LookupID(ia addr.IA, id uint64) (interface{}, bool)
}

type IPTable map[string]interface{}

type Reference interface {
	// Free removes the object from its parent collection, cleaning up any allocations.
	Free()
}

type RegReference interface {
	Reference
	// UDPAddr returns the UDP address associated with this reference
	UDPAddr() *net.UDPAddr
	// SVCAddr returns the SVC address associated with this reference. If no
	// SVC address is associated, it returns SvcNone.
	SVCAddr() addr.HostSVC
	// RegisterID attaches an SCMP ID to this reference. The ID is released
	// when the reference is freed. Registering another ID does not overwrite
	// the previous; instead, multiple IDs get associated with the reference.
	// SCMP messages targeted at the ID will get sent to the socket associated
	// with the reference. The IA of the id is set to the IA of the reference.
	RegisterID(id uint64) error
}

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

type SVCTable interface {
	// Register adds a new entry for the select svc, IP address and port. Both
	// IPv4 and IPv6 are supported. IP addresses 0.0.0.0 and :: are not
	// supported. Port must not be 0.
	//
	// If an entry for the same svc, IP address and port exists, an error is
	// returned and the reference is nil.
	//
	// To clean up resources, call Free on the returned Reference. Calling Free
	// more than once will cause a panic.
	Register(svc addr.HostSVC, address *net.UDPAddr, value interface{}) (Reference, error)
	// Lookup returns the entries associated with svc and ip.
	//
	// If SVC is an anycast address, at most one entry is returned. The ip
	// address is used in case to narrow down the set of possible entries. If
	// multiple entries exist, one is selected arbitrarily.
	//
	// Note that nil addresses are supported for anycasts (the address is then
	// ignored), but support for this might be dropped in the future.
	//
	// If SVC is a multicast address, more than one entry can be returned. The
	// ip address is ignored in this case.
	Lookup(svc addr.HostSVC, ip net.IP) []interface{}
	String() string
}

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

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

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

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