go.ligato.io/vpp-agent/v3@v3.5.0/proto/ligato/linux/interfaces/interface.proto

syntax = "proto3";

package ligato.linux.interfaces;

option go_package = "go.ligato.io/vpp-agent/v3/proto/ligato/linux/interfaces;linux_interfaces";

import "ligato/linux/namespace/namespace.proto";
import "ligato/annotations.proto";

message Interface {
    enum Type {
        UNDEFINED = 0;
        VETH = 1;
        TAP_TO_VPP = 2; // TAP created by VPP to have the Linux-side further configured

        // LOOPBACK is used to attach configuration to an existing "lo" interface,
        // but unlike EXISTING type it is not limited to the default network namespace
        // (i.e. loopbacks in other containers can be referenced also).
        // To create an additional interface which effectively acts as a loopback,
        // use DUMMY interface (see below).
        LOOPBACK = 3;

        // Wait for and potentially attach additional network configuration to an interface
        // created externally (i.e. not by this agent) in the default network namespace
        // (i.e. same as used by the agent).
        // Behaviour of the EXISTING interface depends on the values of ip_addresses and
        // link_only attributes as follows:
        // 1. link_only=false and ip_addresses are empty: agent waits for interface to be created
        //    externally and then configures it in the L2-only mode (resync will remove any IP addresses
        //    configured from outside of the agent)
        // 2. link_only=false and ip_addresses are non-empty: agent waits for interface to be created
        //    externally and then attaches the selected IP addresses to it (resync removes any other
        //    IPs added externally)
        // 3. link_only=true and ip_addresses are empty: agent only waits for the interface
        //    to exists (it doesn't wait for or change any IP addresses attached to it)
        // 4. link_only=true and ip_addresses are non empty: agent waits for the interface
        //    to exists and the selected IP addresses to be assigned (i.e. there will be derived
        //    value for each expected IP address in the PENDING state until the address is assigned
        //    to the interface externally)
        EXISTING = 4;

        // In Linux, VRF is implemented as yet another type of netdevice (i.e. listed with `ip link show`).
        // Network interfaces are then assigned to VRF simply by enslaving them to the VRF device.
        // For more information, visit: https://www.kernel.org/doc/Documentation/networking/vrf.txt
        VRF_DEVICE = 5;

        // Create a dummy Linux interface which effectively behaves just like the loopback.
        DUMMY = 6;
    };

    // Name is mandatory field representing logical name for the interface.
    // It must be unique across all configured interfaces.
    string name = 1;

    // Type represents the type of interface and It must match with actual Link.
    Type type = 2;

    // Namespace is a reference to a Linux network namespace where the interface
    // should be put into.
    linux.namespace.NetNamespace namespace = 3;

    // Name of the interface in the host OS. If not set, the host name will be
    // the same as the interface logical name.
    string host_if_name = 4;

    // Enabled controls if the interface should be UP.
    bool enabled = 5;

    // IPAddresses define list of IP addresses for the interface and must be
    // defined in the following format: <ipAddress>/<ipPrefix>.
    // Interface IP address can be also allocated via netalloc plugin and
    // referenced here, see: api/models/netalloc/netalloc.proto
    repeated string ip_addresses = 6  [(ligato_options).type = IP_WITH_MASK];

    // PhysAddress represents physical address (MAC) of the interface.
    // Random address will be assigned if left empty.
    // Not used (and not supported) by VRF devices.
    string phys_address = 7;

    // MTU is the maximum transmission unit value.
    uint32 mtu = 8   [(ligato_options).int_range = {minimum: 0 maximum: 9216}];

    oneof link {
        // VETH-specific configuration
        VethLink veth = 20;

        // TAP_TO_VPP-specific configuration
        TapLink tap = 21;

        // VRF_DEVICE-specific configuration
        VrfDevLink vrf_dev = 22;
    };

    // Configure/Resync link only. IP/MAC addresses are expected to be configured
    // externally - i.e. by a different agent or manually via CLI.
    bool link_only = 9;

    // Reference to the logical name of a VRF_DEVICE interface.
    // If defined, this interface will be enslaved to the VRF device and will thus become
    // part of the VRF (L3-level separation) that the device represents.
    // Interfaces enslaved to the same VRF_DEVICE master interface therefore
    // comprise single VRF with a separate routing table.
    string vrf_master_interface = 10;
};

message VethLink {
    // Name of the VETH peer, i.e. other end of the linux veth (mandatory for VETH)
    string peer_if_name = 1;

    enum ChecksumOffloading {
        CHKSM_OFFLOAD_DEFAULT = 0;
        CHKSM_OFFLOAD_ENABLED = 1;
        CHKSM_OFFLOAD_DISABLED = 2;
    }

    // Checksum offloading - Rx side (enabled by default)
    ChecksumOffloading rx_checksum_offloading = 2;

    // Checksum offloading - Tx side (enabled by default)
    ChecksumOffloading tx_checksum_offloading = 3;
};

message TapLink {
    // Logical name of the VPP TAP interface (mandatory for TAP_TO_VPP)
    string vpp_tap_if_name = 1;
};


message VrfDevLink {
    // Routing table associated with the VRF.
    // Table ID is an 8-bit unsigned integer value. Please note that 253, 254 and 255 are reserved values
    // for special routing tables (main, default, local).
    // Multiple VRFs inside the same network namespace should each use a different routing table.
    // For more information, visit: http://linux-ip.net/html/routing-tables.html
    uint32 routing_table = 1;
};