configitems

type Bond struct {
	api.Bond
	// IfName : name of the Bond interface in the OS.
	IfName string
	// AggregatedPhysIfs : list of physical interfaces aggregated by this bond.
	AggregatedPhysIfs []PhysIf
}

type BondConfigurator struct {
	MacLookup *maclookup.MacLookup
}

type Bridge struct {
	// IfName : name of the Bridge in the OS.
	IfName string
	// LogicalLabel : label used within the network model.
	LogicalLabel string
	// PhysIfs : physical interfaces to put under the bridge.
	PhysIfs []PhysIf
	// BondIfs : *interface names* of bonds to put under the bridge.
	BondIfs []string
	// VLANs : list of VLANs used with this bridge.
	// If empty then this bridge is used without VLAN filtering.
	VLANs []uint16
}

type BridgeConfigurator struct {
	MacLookup *maclookup.MacLookup
}

type DhcpClient struct {
	// PhysIf : physical interface to associate the client with.
	PhysIf PhysIf
	// LogFile : where to put dhcpcd logs.
	LogFile string
}

type DhcpClientConfigurator struct {
	MacLookup *maclookup.MacLookup
}

type DhcpServer struct {
	// ServerName : logical name for the DHCP server.
	ServerName string
	// NetNamespace : network namespace where the server should be running.
	NetNamespace string
	// VethName : logical name of the veth pair on which the server operates.
	// (other types of interfaces are currently not supported)
	VethName string
	// VethPeerIfName : interface name of that side of the veth pair on which
	// the server should listen. It should be inside NetNamespace.
	VethPeerIfName string
	// Subnet : network address + netmask (IPv4 or IPv6).
	Subnet *net.IPNet
	// IPRange : a range of IP addresses to allocate from.
	// Not applicable for IPv6 (SLAAC is used instead).
	IPRange IPRange
	// StaticEntries : list of MAC->IP entries statically configured for the DHCP server.
	StaticEntries []MACToIP
	// GatewayIP : address of the default gateway to advertise (DHCP option 3).
	GatewayIP net.IP
	// DomainName : name of the domain assigned to the network.
	// It is propagated to clients using the DHCP option 15 (24 in DHCPv6).
	DomainName string
	// DNSServers : list of IP addresses of DNS servers to announce via DHCP option 6.
	DNSServers []net.IP
	// NTP server to announce via DHCP option 42 (56 in DHCPv6).
	// Optional argument, leave empty to disable.
	NTPServer string
	// WPAD : URL with a location of a PAC file, announced using the Web Proxy Auto-Discovery
	// Protocol (WPAD) and DHCP.
	// The client will learn the PAC file location using the DHCP option 252.
	// Optional argument, leave empty to disable.
	WPAD string
}

type DhcpServerConfigurator struct{}

type DnsEntry struct {
	FQDN string
	IP   net.IP
}

type DnsServer struct {
	// ServerName : logical name for the DNS server.
	ServerName string
	// NetNamespace : network namespace where the server should be running.
	NetNamespace string
	// VethName : logical name of the veth pair on which the server operates.
	// (other types of interfaces are currently not supported)
	VethName string
	// VethPeerIfName : interface name of that side of the veth pair on which
	// the server should listen. It should be inside NetNamespace.
	VethPeerIfName string
	// StaticEntries : list of FQDN->IP entries statically configured for the server.
	StaticEntries []DnsEntry
	// UpstreamServers : list of IP addresses of public DNS servers to forward
	// requests to (unless there is a static entry).
	UpstreamServers []net.IP
}

type DnsServerConfigurator struct{}

type HttpProxy struct {
	sdnapi.Proxy
	// ProxyName : logical name for the HTTP proxy.
	ProxyName string
	// NetNamespace : network namespace where the server should be running.
	NetNamespace string
	// VethName : logical name of the veth pair on which the proxy operates.
	// (other types of interfaces are currently not supported)
	// Can be empty (if the proxy is not associated with any particular interface).
	VethName string
	// ListenIP : IP address on which the proxy should listen.
	// Can be empty to listen on all available interfaces instead of just
	// the interface with the given host address
	ListenIP net.IP
	// Hostname : domain name of the proxy.
	Hostname string
	// HTTPPort : specify on which port+protocol to listen for requests
	// to proxy HTTP traffic.
	// Zero port number can be used to disable HTTP proxying.
	HTTPPort sdnapi.ProxyPort
	// HTTPSPorts : specify on which port(s)+protocol(s) to listen
	// for requests to proxy HTTPS traffic.
	// Empty list can be used to disable HTTPS proxying.
	HTTPSPorts []sdnapi.ProxyPort
	// Transparent : enable for transparent proxy (not known to the client).
	Transparent bool
	// Users : define for username/password authentication, leave empty otherwise.
	Users []sdnapi.UserCredentials
}

type HttpProxyConfigurator struct{}

type HttpServer struct {
	// ServerName : logical name for the HTTP server.
	ServerName string
	// NetNamespace : network namespace where the server should be running.
	NetNamespace string
	// VethName : logical name of the veth pair on which the server operates.
	// (other types of interfaces are currently not supported)
	// Can be empty (if the server is not associated with any particular interface).
	VethName string
	// ListenIP : IP address on which the server should listen.
	// Can be empty to listen on all available interfaces instead of just
	// the interface with the given host address
	ListenIP net.IP
	// HTTPPort : port to listen for HTTP requests.
	// Zero value can be used to disable HTTP.
	HTTPPort uint16
	// HTTPSPort : port to listen for HTTPS requests.
	// Zero value can be used to disable HTTPS.
	HTTPSPort uint16
	// CertPEM : Server certificate in the PEM format. Required for HTTPS.
	CertPEM string
	// KeyPEM : Server key in the PEM format. Required for HTTPS.
	KeyPEM string
	// Maps URL Path to a content to be returned inside the HTTP(s) response body.
	Paths map[string]sdnapi.HTTPContent
}

type HttpServerConfigurator struct{}

type IPRange struct {
	// FromIP : start of the range (includes the address itself).
	FromIP net.IP
	// ToIP : end of the range (includes the address itself).
	ToIP net.IP
}

type IPRule struct {
	SrcNet   *net.IPNet
	DstNet   *net.IPNet
	Table    int
	Priority int
}

type IPRuleConfigurator struct{}

type IfHandle struct {
	// PhysIf : physical interface associated with this handle.
	PhysIf PhysIf
	// Usage : How is the physical network interface being used.
	Usage IfUsage
	// ParentLL : Logical label of the parent bridge or bond if the physical interface
	// is bridged or aggregated, respectively.
	// Leave empty for L3 interfaces.
	ParentLL string
	// AdminUP : enable to put the physical interface administratively UP.
	AdminUP bool
	// MTU : Maximum transmission unit.
	MTU uint16
}

type IfHandleConfigurator struct {
	MacLookup *maclookup.MacLookup
}

type IfUsage uint8

type IptablesChain struct {
	// NetNamespace : network namespace where the chain should be created.
	NetNamespace string
	ChainName    string
	Table        string
	ForIPv6      bool
	Rules        []IptablesRule
	// RefersChains : names of chains referred from rules.
	// We could probably extract this from IptablesRule.Args, but let's keep things
	// simple and not dive into the iptables semantics too much.
	RefersChains []string
	// RefersVeths : names of VETH interfaces referred from rules.
	RefersVeths []string
	// PreCreated : a custom chain which already exists (as empty).
	PreCreated bool
}

type IptablesChainConfigurator struct{}

type IptablesRule struct {
	// Args : any arguments except for -t, -A, -D, -I, -R.
	Args []string
	// Description : optionally describe the rule.
	Description string
}

type MACToIP struct {
	MAC net.HardwareAddr
	IP  net.IP
}

type MasterBridge struct {
	// IfName : interface name of the bridge to put the veth peer under.
	IfName string
	// VLAN for which this VETH is an access port.
	// Leave zero to not use with VLAN.
	VLAN uint16
}

type NetNamespace struct {
	// NsName : name of the network namespace.
	NsName     string
	ResolvConf ResolvConf
}

type NetNamespaceConfigurator struct{}

type PhysIf struct {
	// MAC address assigned by Eden.
	MAC net.HardwareAddr
	// LogicalLabel : label used within the network model.
	LogicalLabel string
}

type ResolvConf struct {
	// Create resolv.conf specifically for this network namespace
	// with the DNS server entries listed below.
	// Otherwise the namespace will use the global resolv.conf.
	Create     bool
	DNSServers []net.IP
}

type Route struct {
	// NetNamespace : network namespace where the route should be created.
	NetNamespace string
	// DstNet : destination network that the route matches.
	// Mandatory argument (should not be nil).
	DstNet *net.IPNet
	// OutputIf : output interface for the routed traffic.
	// Leave undefined if the destination is unreachable.
	OutputIf RouteOutIf
	// Gw : IP address of the gateway to route the traffic via.
	// Leave undefined for unreachable or link-local destination.
	GwIP net.IP
	// Table : routing table to put the entry into.
	Table int
	// Metric : route metric (basically the "cost").
	// The higher the value, the lower the priority is.
	// Highest priority is 0, lowest is ^uint32(0).
	Metric uint32
}

type RouteConfigurator struct {
	MacLookup *maclookup.MacLookup
}

type RouteOutIf struct {
	// VethName : logical name of the veth pair used as the output device for the route.
	// Define either PhysIf or VethName + VethPeerIfName.
	VethName string
	// VethPeerIfName : interface name of that side of the veth pair which the routed
	// traffic is entering.
	VethPeerIfName string
	// PhysIf : physical interface to use as the output device.
	// Define either PhysIf or VethName + VethPeerIfName.
	PhysIf PhysIf
}

type Sysctl struct {
	// NetNamespace : network namespace name
	NetNamespace          string
	EnableIPv4Forwarding  bool
	EnableIPv6Forwarding  bool
	BridgeNfCallIptables  bool
	BridgeNfCallIp6tables bool
}

type SysctlConfigurator struct{}

type TrafficControl struct {
	api.TrafficControl
	// PhysIf : target physical network interface for traffic control.
	PhysIf PhysIf
}

type TrafficControlConfigurator struct {
	MacLookup *maclookup.MacLookup
}

type Veth struct {
	// VethName : logical name for the veth pair as a whole.
	VethName string
	Peer1    VethPeer
	Peer2    VethPeer
}

type VethConfigurator struct{}

type VethPeer struct {
	// IfName : name of the veth peer.
	IfName string
	// MasterBridge : bridge to put veth peer under.
	// Leave nil to use veth peer without bridge.
	// Do not combine with non-main NetNamespace (bridges are limited to main ns)
	// and IPAddresses.
	MasterBridge *MasterBridge
	// NetNamespace : network namespace where the veth peer should be placed into.
	// Do not combine non-main namespace with MasterBridge.
	NetNamespace string
	// IPAddresses : IP addresses to assign to the veth peer.
	// The peer should be in the L3 mode, not under a bridge.
	IPAddresses []*net.IPNet
	// MTU : Maximum transmission unit.
	MTU uint16
}