go.ligato.io/vpp-agent/v3@v3.5.0/proto/ligato/vpp/srv6/srv6.proto (about) 1 syntax = "proto3"; 2 3 package ligato.vpp.srv6; 4 5 option go_package = "go.ligato.io/vpp-agent/v3/proto/ligato/vpp/srv6;vpp_srv6"; 6 7 import "ligato/annotations.proto"; 8 9 10 message LocalSID { 11 string sid = 1 [(ligato_options).type = IPV6]; /* segment id (IPv6 Address) */ 12 uint32 installation_vrf_id = 2; /* ID of IPv6 VRF table where to install LocalSID routing components 13 (LocalSids with End.AD function ignore this setting due to missing setting 14 in the API. The End.AD functionality is separated from the SRv6 functionality 15 and have no binary API. It has only the CLI API and that doesn't have 16 the installation vrf id (in VPP API called FIB table) setting configurable.) 17 Non-zero VRF has to be explicitly created (see api/models/vpp/l3/vrf.proto) */ 18 19 /* Configuration for end functions (all end functions are mutually exclusive) */ 20 oneof end_function { 21 End base_end_function = 3; 22 EndX end_function_x = 4; 23 EndT end_function_t = 5; 24 EndDX2 end_function_dx2 = 6; 25 EndDX4 end_function_dx4 = 7; 26 EndDX6 end_function_dx6 = 8; 27 EndDT4 end_function_dt4 = 9; 28 EndDT6 end_function_dt6 = 10; 29 EndAD end_function_ad = 11; 30 } 31 32 /* TODO recheck whether PSP is not Localsid-scoped setting instead of some-end-functions-scoped setting */ 33 /* End function behavior of simple endpoint */ 34 message End { 35 bool psp = 1; /* use PSP (penultimate segment POP of the SRH) or by default use USP (Ultimate Segment Pop of the SRH) */ 36 } 37 38 /* End function behavior of endpoint with Layer-3 cross-connect (IPv6) */ 39 message EndX { 40 bool psp = 1; /* use PSP (penultimate segment POP of the SRH) or by default use USP (Ultimate Segment Pop of the SRH) */ 41 string outgoing_interface = 2; /* name of cross-connected outgoing interface */ 42 string next_hop = 3 [(ligato_options).type = IPV6]; /* IPv6 next hop address for cross-connected link */ 43 } 44 45 /* End function behavior of endpoint with specific IPv6 table lookup*/ 46 message EndT { 47 bool psp = 1; /* use PSP (penultimate segment POP of the SRH) or by default use USP (Ultimate Segment Pop of the SRH) */ 48 uint32 vrf_id = 2; /* vrf index of IPv6 table that should be used for lookup. 49 vrf_index and fib_table_id should refer to the same routing table. VRF index refer to it from client side 50 and FIB table id from VPP-internal side (index of memory allocated structure from pool)(source: https://wiki.fd.io/view/VPP/Per-feature_Notes). 51 Non-zero VRF has to be explicitly created (see api/models/vpp/l3/vrf.proto) */ 52 } 53 54 /* End function behavior of endpoint with decapsulation and Layer-2 cross-connect (or DX2 with egress VLAN rewrite when VLAN notzero - not supported this variant yet)*/ 55 message EndDX2 { 56 uint32 vlan_tag = 1; /* Outgoing VLAN tag */ 57 string outgoing_interface = 2; /* name of cross-connected outgoing interface */ 58 } 59 60 /* End function behavior of endpoint with decapsulation and IPv4 cross-connect*/ 61 message EndDX4 { 62 string outgoing_interface = 1; /* name of cross-connected outgoing interface */ 63 string next_hop = 2 [(ligato_options).type = IPV4]; /* next hop address for cross-connected link */ 64 } 65 66 /* End function behavior of endpoint with decapsulation and IPv6 cross-connect*/ 67 message EndDX6 { 68 string outgoing_interface = 1; /* name of cross-connected outgoing interface */ 69 string next_hop = 2 [(ligato_options).type = IPV6]; /* next hop address for cross-connected link */ 70 } 71 72 /* End function behavior of endpoint with decapsulation and specific IPv4 table lookup*/ 73 message EndDT4 { 74 uint32 vrf_id = 1; /* vrf index of IPv4 table that should be used for lookup. 75 vrf_index and fib_table_id should refer to the same routing table. VRF index refer to it from client side 76 and FIB table id from VPP-internal side (index of memory allocated structure from pool)(source: https://wiki.fd.io/view/VPP/Per-feature_Notes). 77 Non-zero VRF has to be explicitly created (see api/models/vpp/l3/vrf.proto) */ 78 } 79 80 /* End function behavior of endpoint with decapsulation and specific IPv6 table lookup*/ 81 message EndDT6 { 82 uint32 vrf_id = 1; /* vrf index of IPv6 table that should be used for lookup. 83 vrf_index and fib_table_id should refer to the same routing table. VRF index refer to it from client side 84 and FIB table id from VPP-internal side (index of memory allocated structure from pool)(source: https://wiki.fd.io/view/VPP/Per-feature_Notes). 85 Non-zero VRF has to be explicitly created (see api/models/vpp/l3/vrf.proto) */ 86 } 87 88 /* End function behavior of dynamic segment routing proxy endpoint */ 89 message EndAD { 90 string outgoing_interface = 2; /* name of interface on segment routing proxy side sending data to segment routing unaware service */ 91 string incoming_interface = 3; /* name of interface on segment routing proxy side receiving data from segment routing unaware service */ 92 string l3_service_address = 4 [(ligato_options).type = IP]; /* IPv6/IPv4 address of L3 SR-unaware service (address type depends whether service is IPv4 or IPv6 service), in case of L2 service it must be empty */ 93 } 94 } 95 96 97 /* Model for SRv6 policy (policy without at least one policy segment is only cached in ligato and not written to VPP)*/ 98 message Policy { 99 string bsid = 1 [(ligato_options).type = IPV6]; /* binding SID (IPv6 Address) */ 100 uint32 installation_vrf_id = 2; /* ID of IPv6 VRF table where to install Policy routing components (for loadbalancing/spray are used VPP features that are using VRF table) 101 Non-zero VRF has to be explicitly created (see api/models/vpp/l3/vrf.proto) */ 102 bool srh_encapsulation = 3; /* are SR headers handled by encapsulation? (no means insertion of SR headers) */ 103 bool spray_behaviour = 4; /* spray(multicast) to all policy segments? (no means to use PolicySegment.weight to loadbalance traffic)*/ 104 105 /* Model for SRv6 Segment List */ 106 message SegmentList { 107 uint32 weight = 1; /* used for loadbalancing in case of multiple policy segments in routing process (ignored in case of spray policies) */ 108 repeated string segments = 2 [(ligato_options).type = IPV6]; /* list of sids creating one segmented road */ 109 } 110 repeated SegmentList segment_lists = 5; 111 } 112 113 /* Model for steering traffic to SRv6 policy */ 114 message Steering { 115 string name = 5; /* globally unique steering identification (used in keys when is steering stored in key-value stores(i.e. ETCD)) */ 116 117 /* Referencing policy that should be used for steering traffic into (all policy references are mutual exclusive)*/ 118 oneof policy_ref { 119 string policy_bsid = 1 [(ligato_options).type = IPV6]; /* BSID identifier for policy to which we want to steer routing into (policyBSID and policyIndex are mutual exclusive) */ 120 uint32 policy_index = 2; /* (vpp-internal)Index identifier for policy to which we want to steer routing into (policyBSID and policyIndex are mutual exclusive) */ 121 } 122 123 /* Traffic configuration (all traffic messages are mutual exclusive)*/ 124 oneof traffic { 125 L2Traffic l2_traffic = 3; 126 L3Traffic l3_traffic = 4; 127 } 128 129 message L2Traffic { /* L2 traffic that should be steered into SR policy */ 130 string interface_name = 1; /* name of interface with incoming traffic that should be steered to SR policy */ 131 } 132 message L3Traffic { /* L3 traffic that should be steered into SR policy */ 133 uint32 installation_vrf_id = 1; /* ID of IPv4/IPv6 VRF table where to install L3 Steering routing components (VRF table type (IPv4/IPv6) is decided by prefix_address value) 134 Non-zero VRF has to be explicitly created (see api/models/vpp/l3/vrf.proto) */ 135 string prefix_address = 2 [(ligato_options).type = IP_WITH_MASK]; /* IPv4/IPv6 prefix address(CIRD format) of traffic destination. All traffic with given destination will be steered to given SR policy */ 136 } 137 } 138 139 /* Global SRv6 config */ 140 message SRv6Global { 141 string encap_source_address = 1 [(ligato_options).type = IPV6]; /* IPv6 source address for sr encapsulated packets */ 142 }