link.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800
  1. package netlink
  2. import (
  3. "fmt"
  4. "net"
  5. )
  6. // Link represents a link device from netlink. Shared link attributes
  7. // like name may be retrieved using the Attrs() method. Unique data
  8. // can be retrieved by casting the object to the proper type.
  9. type Link interface {
  10. Attrs() *LinkAttrs
  11. Type() string
  12. }
  13. type (
  14. NsPid int
  15. NsFd int
  16. )
  17. // LinkAttrs represents data shared by most link types
  18. type LinkAttrs struct {
  19. Index int
  20. MTU int
  21. TxQLen int // Transmit Queue Length
  22. Name string
  23. HardwareAddr net.HardwareAddr
  24. Flags net.Flags
  25. RawFlags uint32
  26. ParentIndex int // index of the parent link device
  27. MasterIndex int // must be the index of a bridge
  28. Namespace interface{} // nil | NsPid | NsFd
  29. Alias string
  30. Statistics *LinkStatistics
  31. Promisc int
  32. Xdp *LinkXdp
  33. EncapType string
  34. Protinfo *Protinfo
  35. OperState LinkOperState
  36. NetNsID int
  37. }
  38. // LinkOperState represents the values of the IFLA_OPERSTATE link
  39. // attribute, which contains the RFC2863 state of the interface.
  40. type LinkOperState uint8
  41. const (
  42. OperUnknown = iota // Status can't be determined.
  43. OperNotPresent // Some component is missing.
  44. OperDown // Down.
  45. OperLowerLayerDown // Down due to state of lower layer.
  46. OperTesting // In some test mode.
  47. OperDormant // Not up but pending an external event.
  48. OperUp // Up, ready to send packets.
  49. )
  50. func (s LinkOperState) String() string {
  51. switch s {
  52. case OperNotPresent:
  53. return "not-present"
  54. case OperDown:
  55. return "down"
  56. case OperLowerLayerDown:
  57. return "lower-layer-down"
  58. case OperTesting:
  59. return "testing"
  60. case OperDormant:
  61. return "dormant"
  62. case OperUp:
  63. return "up"
  64. default:
  65. return "unknown"
  66. }
  67. }
  68. // NewLinkAttrs returns LinkAttrs structure filled with default values
  69. func NewLinkAttrs() LinkAttrs {
  70. return LinkAttrs{
  71. TxQLen: -1,
  72. }
  73. }
  74. type LinkStatistics LinkStatistics64
  75. /*
  76. Ref: struct rtnl_link_stats {...}
  77. */
  78. type LinkStatistics32 struct {
  79. RxPackets uint32
  80. TxPackets uint32
  81. RxBytes uint32
  82. TxBytes uint32
  83. RxErrors uint32
  84. TxErrors uint32
  85. RxDropped uint32
  86. TxDropped uint32
  87. Multicast uint32
  88. Collisions uint32
  89. RxLengthErrors uint32
  90. RxOverErrors uint32
  91. RxCrcErrors uint32
  92. RxFrameErrors uint32
  93. RxFifoErrors uint32
  94. RxMissedErrors uint32
  95. TxAbortedErrors uint32
  96. TxCarrierErrors uint32
  97. TxFifoErrors uint32
  98. TxHeartbeatErrors uint32
  99. TxWindowErrors uint32
  100. RxCompressed uint32
  101. TxCompressed uint32
  102. }
  103. func (s32 LinkStatistics32) to64() *LinkStatistics64 {
  104. return &LinkStatistics64{
  105. RxPackets: uint64(s32.RxPackets),
  106. TxPackets: uint64(s32.TxPackets),
  107. RxBytes: uint64(s32.RxBytes),
  108. TxBytes: uint64(s32.TxBytes),
  109. RxErrors: uint64(s32.RxErrors),
  110. TxErrors: uint64(s32.TxErrors),
  111. RxDropped: uint64(s32.RxDropped),
  112. TxDropped: uint64(s32.TxDropped),
  113. Multicast: uint64(s32.Multicast),
  114. Collisions: uint64(s32.Collisions),
  115. RxLengthErrors: uint64(s32.RxLengthErrors),
  116. RxOverErrors: uint64(s32.RxOverErrors),
  117. RxCrcErrors: uint64(s32.RxCrcErrors),
  118. RxFrameErrors: uint64(s32.RxFrameErrors),
  119. RxFifoErrors: uint64(s32.RxFifoErrors),
  120. RxMissedErrors: uint64(s32.RxMissedErrors),
  121. TxAbortedErrors: uint64(s32.TxAbortedErrors),
  122. TxCarrierErrors: uint64(s32.TxCarrierErrors),
  123. TxFifoErrors: uint64(s32.TxFifoErrors),
  124. TxHeartbeatErrors: uint64(s32.TxHeartbeatErrors),
  125. TxWindowErrors: uint64(s32.TxWindowErrors),
  126. RxCompressed: uint64(s32.RxCompressed),
  127. TxCompressed: uint64(s32.TxCompressed),
  128. }
  129. }
  130. /*
  131. Ref: struct rtnl_link_stats64 {...}
  132. */
  133. type LinkStatistics64 struct {
  134. RxPackets uint64
  135. TxPackets uint64
  136. RxBytes uint64
  137. TxBytes uint64
  138. RxErrors uint64
  139. TxErrors uint64
  140. RxDropped uint64
  141. TxDropped uint64
  142. Multicast uint64
  143. Collisions uint64
  144. RxLengthErrors uint64
  145. RxOverErrors uint64
  146. RxCrcErrors uint64
  147. RxFrameErrors uint64
  148. RxFifoErrors uint64
  149. RxMissedErrors uint64
  150. TxAbortedErrors uint64
  151. TxCarrierErrors uint64
  152. TxFifoErrors uint64
  153. TxHeartbeatErrors uint64
  154. TxWindowErrors uint64
  155. RxCompressed uint64
  156. TxCompressed uint64
  157. }
  158. type LinkXdp struct {
  159. Fd int
  160. Attached bool
  161. Flags uint32
  162. ProgId uint32
  163. }
  164. // Device links cannot be created via netlink. These links
  165. // are links created by udev like 'lo' and 'etho0'
  166. type Device struct {
  167. LinkAttrs
  168. }
  169. func (device *Device) Attrs() *LinkAttrs {
  170. return &device.LinkAttrs
  171. }
  172. func (device *Device) Type() string {
  173. return "device"
  174. }
  175. // Dummy links are dummy ethernet devices
  176. type Dummy struct {
  177. LinkAttrs
  178. }
  179. func (dummy *Dummy) Attrs() *LinkAttrs {
  180. return &dummy.LinkAttrs
  181. }
  182. func (dummy *Dummy) Type() string {
  183. return "dummy"
  184. }
  185. // Ifb links are advanced dummy devices for packet filtering
  186. type Ifb struct {
  187. LinkAttrs
  188. }
  189. func (ifb *Ifb) Attrs() *LinkAttrs {
  190. return &ifb.LinkAttrs
  191. }
  192. func (ifb *Ifb) Type() string {
  193. return "ifb"
  194. }
  195. // Bridge links are simple linux bridges
  196. type Bridge struct {
  197. LinkAttrs
  198. MulticastSnooping *bool
  199. HelloTime *uint32
  200. }
  201. func (bridge *Bridge) Attrs() *LinkAttrs {
  202. return &bridge.LinkAttrs
  203. }
  204. func (bridge *Bridge) Type() string {
  205. return "bridge"
  206. }
  207. // Vlan links have ParentIndex set in their Attrs()
  208. type Vlan struct {
  209. LinkAttrs
  210. VlanId int
  211. }
  212. func (vlan *Vlan) Attrs() *LinkAttrs {
  213. return &vlan.LinkAttrs
  214. }
  215. func (vlan *Vlan) Type() string {
  216. return "vlan"
  217. }
  218. type MacvlanMode uint16
  219. const (
  220. MACVLAN_MODE_DEFAULT MacvlanMode = iota
  221. MACVLAN_MODE_PRIVATE
  222. MACVLAN_MODE_VEPA
  223. MACVLAN_MODE_BRIDGE
  224. MACVLAN_MODE_PASSTHRU
  225. MACVLAN_MODE_SOURCE
  226. )
  227. // Macvlan links have ParentIndex set in their Attrs()
  228. type Macvlan struct {
  229. LinkAttrs
  230. Mode MacvlanMode
  231. }
  232. func (macvlan *Macvlan) Attrs() *LinkAttrs {
  233. return &macvlan.LinkAttrs
  234. }
  235. func (macvlan *Macvlan) Type() string {
  236. return "macvlan"
  237. }
  238. // Macvtap - macvtap is a virtual interfaces based on macvlan
  239. type Macvtap struct {
  240. Macvlan
  241. }
  242. func (macvtap Macvtap) Type() string {
  243. return "macvtap"
  244. }
  245. type TuntapMode uint16
  246. type TuntapFlag uint16
  247. // Tuntap links created via /dev/tun/tap, but can be destroyed via netlink
  248. type Tuntap struct {
  249. LinkAttrs
  250. Mode TuntapMode
  251. Flags TuntapFlag
  252. }
  253. func (tuntap *Tuntap) Attrs() *LinkAttrs {
  254. return &tuntap.LinkAttrs
  255. }
  256. func (tuntap *Tuntap) Type() string {
  257. return "tuntap"
  258. }
  259. // Veth devices must specify PeerName on create
  260. type Veth struct {
  261. LinkAttrs
  262. PeerName string // veth on create only
  263. }
  264. func (veth *Veth) Attrs() *LinkAttrs {
  265. return &veth.LinkAttrs
  266. }
  267. func (veth *Veth) Type() string {
  268. return "veth"
  269. }
  270. // GenericLink links represent types that are not currently understood
  271. // by this netlink library.
  272. type GenericLink struct {
  273. LinkAttrs
  274. LinkType string
  275. }
  276. func (generic *GenericLink) Attrs() *LinkAttrs {
  277. return &generic.LinkAttrs
  278. }
  279. func (generic *GenericLink) Type() string {
  280. return generic.LinkType
  281. }
  282. type Vxlan struct {
  283. LinkAttrs
  284. VxlanId int
  285. VtepDevIndex int
  286. SrcAddr net.IP
  287. Group net.IP
  288. TTL int
  289. TOS int
  290. Learning bool
  291. Proxy bool
  292. RSC bool
  293. L2miss bool
  294. L3miss bool
  295. UDPCSum bool
  296. NoAge bool
  297. GBP bool
  298. FlowBased bool
  299. Age int
  300. Limit int
  301. Port int
  302. PortLow int
  303. PortHigh int
  304. }
  305. func (vxlan *Vxlan) Attrs() *LinkAttrs {
  306. return &vxlan.LinkAttrs
  307. }
  308. func (vxlan *Vxlan) Type() string {
  309. return "vxlan"
  310. }
  311. type IPVlanMode uint16
  312. const (
  313. IPVLAN_MODE_L2 IPVlanMode = iota
  314. IPVLAN_MODE_L3
  315. IPVLAN_MODE_L3S
  316. IPVLAN_MODE_MAX
  317. )
  318. type IPVlan struct {
  319. LinkAttrs
  320. Mode IPVlanMode
  321. }
  322. func (ipvlan *IPVlan) Attrs() *LinkAttrs {
  323. return &ipvlan.LinkAttrs
  324. }
  325. func (ipvlan *IPVlan) Type() string {
  326. return "ipvlan"
  327. }
  328. // BondMode type
  329. type BondMode int
  330. func (b BondMode) String() string {
  331. s, ok := bondModeToString[b]
  332. if !ok {
  333. return fmt.Sprintf("BondMode(%d)", b)
  334. }
  335. return s
  336. }
  337. // StringToBondMode returns bond mode, or uknonw is the s is invalid.
  338. func StringToBondMode(s string) BondMode {
  339. mode, ok := StringToBondModeMap[s]
  340. if !ok {
  341. return BOND_MODE_UNKNOWN
  342. }
  343. return mode
  344. }
  345. // Possible BondMode
  346. const (
  347. BOND_MODE_BALANCE_RR BondMode = iota
  348. BOND_MODE_ACTIVE_BACKUP
  349. BOND_MODE_BALANCE_XOR
  350. BOND_MODE_BROADCAST
  351. BOND_MODE_802_3AD
  352. BOND_MODE_BALANCE_TLB
  353. BOND_MODE_BALANCE_ALB
  354. BOND_MODE_UNKNOWN
  355. )
  356. var bondModeToString = map[BondMode]string{
  357. BOND_MODE_BALANCE_RR: "balance-rr",
  358. BOND_MODE_ACTIVE_BACKUP: "active-backup",
  359. BOND_MODE_BALANCE_XOR: "balance-xor",
  360. BOND_MODE_BROADCAST: "broadcast",
  361. BOND_MODE_802_3AD: "802.3ad",
  362. BOND_MODE_BALANCE_TLB: "balance-tlb",
  363. BOND_MODE_BALANCE_ALB: "balance-alb",
  364. }
  365. var StringToBondModeMap = map[string]BondMode{
  366. "balance-rr": BOND_MODE_BALANCE_RR,
  367. "active-backup": BOND_MODE_ACTIVE_BACKUP,
  368. "balance-xor": BOND_MODE_BALANCE_XOR,
  369. "broadcast": BOND_MODE_BROADCAST,
  370. "802.3ad": BOND_MODE_802_3AD,
  371. "balance-tlb": BOND_MODE_BALANCE_TLB,
  372. "balance-alb": BOND_MODE_BALANCE_ALB,
  373. }
  374. // BondArpValidate type
  375. type BondArpValidate int
  376. // Possible BondArpValidate value
  377. const (
  378. BOND_ARP_VALIDATE_NONE BondArpValidate = iota
  379. BOND_ARP_VALIDATE_ACTIVE
  380. BOND_ARP_VALIDATE_BACKUP
  381. BOND_ARP_VALIDATE_ALL
  382. )
  383. // BondPrimaryReselect type
  384. type BondPrimaryReselect int
  385. // Possible BondPrimaryReselect value
  386. const (
  387. BOND_PRIMARY_RESELECT_ALWAYS BondPrimaryReselect = iota
  388. BOND_PRIMARY_RESELECT_BETTER
  389. BOND_PRIMARY_RESELECT_FAILURE
  390. )
  391. // BondArpAllTargets type
  392. type BondArpAllTargets int
  393. // Possible BondArpAllTargets value
  394. const (
  395. BOND_ARP_ALL_TARGETS_ANY BondArpAllTargets = iota
  396. BOND_ARP_ALL_TARGETS_ALL
  397. )
  398. // BondFailOverMac type
  399. type BondFailOverMac int
  400. // Possible BondFailOverMac value
  401. const (
  402. BOND_FAIL_OVER_MAC_NONE BondFailOverMac = iota
  403. BOND_FAIL_OVER_MAC_ACTIVE
  404. BOND_FAIL_OVER_MAC_FOLLOW
  405. )
  406. // BondXmitHashPolicy type
  407. type BondXmitHashPolicy int
  408. func (b BondXmitHashPolicy) String() string {
  409. s, ok := bondXmitHashPolicyToString[b]
  410. if !ok {
  411. return fmt.Sprintf("XmitHashPolicy(%d)", b)
  412. }
  413. return s
  414. }
  415. // StringToBondXmitHashPolicy returns bond lacp arte, or uknonw is the s is invalid.
  416. func StringToBondXmitHashPolicy(s string) BondXmitHashPolicy {
  417. lacp, ok := StringToBondXmitHashPolicyMap[s]
  418. if !ok {
  419. return BOND_XMIT_HASH_POLICY_UNKNOWN
  420. }
  421. return lacp
  422. }
  423. // Possible BondXmitHashPolicy value
  424. const (
  425. BOND_XMIT_HASH_POLICY_LAYER2 BondXmitHashPolicy = iota
  426. BOND_XMIT_HASH_POLICY_LAYER3_4
  427. BOND_XMIT_HASH_POLICY_LAYER2_3
  428. BOND_XMIT_HASH_POLICY_ENCAP2_3
  429. BOND_XMIT_HASH_POLICY_ENCAP3_4
  430. BOND_XMIT_HASH_POLICY_UNKNOWN
  431. )
  432. var bondXmitHashPolicyToString = map[BondXmitHashPolicy]string{
  433. BOND_XMIT_HASH_POLICY_LAYER2: "layer2",
  434. BOND_XMIT_HASH_POLICY_LAYER3_4: "layer3+4",
  435. BOND_XMIT_HASH_POLICY_LAYER2_3: "layer2+3",
  436. BOND_XMIT_HASH_POLICY_ENCAP2_3: "encap2+3",
  437. BOND_XMIT_HASH_POLICY_ENCAP3_4: "encap3+4",
  438. }
  439. var StringToBondXmitHashPolicyMap = map[string]BondXmitHashPolicy{
  440. "layer2": BOND_XMIT_HASH_POLICY_LAYER2,
  441. "layer3+4": BOND_XMIT_HASH_POLICY_LAYER3_4,
  442. "layer2+3": BOND_XMIT_HASH_POLICY_LAYER2_3,
  443. "encap2+3": BOND_XMIT_HASH_POLICY_ENCAP2_3,
  444. "encap3+4": BOND_XMIT_HASH_POLICY_ENCAP3_4,
  445. }
  446. // BondLacpRate type
  447. type BondLacpRate int
  448. func (b BondLacpRate) String() string {
  449. s, ok := bondLacpRateToString[b]
  450. if !ok {
  451. return fmt.Sprintf("LacpRate(%d)", b)
  452. }
  453. return s
  454. }
  455. // StringToBondLacpRate returns bond lacp arte, or uknonw is the s is invalid.
  456. func StringToBondLacpRate(s string) BondLacpRate {
  457. lacp, ok := StringToBondLacpRateMap[s]
  458. if !ok {
  459. return BOND_LACP_RATE_UNKNOWN
  460. }
  461. return lacp
  462. }
  463. // Possible BondLacpRate value
  464. const (
  465. BOND_LACP_RATE_SLOW BondLacpRate = iota
  466. BOND_LACP_RATE_FAST
  467. BOND_LACP_RATE_UNKNOWN
  468. )
  469. var bondLacpRateToString = map[BondLacpRate]string{
  470. BOND_LACP_RATE_SLOW: "slow",
  471. BOND_LACP_RATE_FAST: "fast",
  472. }
  473. var StringToBondLacpRateMap = map[string]BondLacpRate{
  474. "slow": BOND_LACP_RATE_SLOW,
  475. "fast": BOND_LACP_RATE_FAST,
  476. }
  477. // BondAdSelect type
  478. type BondAdSelect int
  479. // Possible BondAdSelect value
  480. const (
  481. BOND_AD_SELECT_STABLE BondAdSelect = iota
  482. BOND_AD_SELECT_BANDWIDTH
  483. BOND_AD_SELECT_COUNT
  484. )
  485. // BondAdInfo represents ad info for bond
  486. type BondAdInfo struct {
  487. AggregatorId int
  488. NumPorts int
  489. ActorKey int
  490. PartnerKey int
  491. PartnerMac net.HardwareAddr
  492. }
  493. // Bond representation
  494. type Bond struct {
  495. LinkAttrs
  496. Mode BondMode
  497. ActiveSlave int
  498. Miimon int
  499. UpDelay int
  500. DownDelay int
  501. UseCarrier int
  502. ArpInterval int
  503. ArpIpTargets []net.IP
  504. ArpValidate BondArpValidate
  505. ArpAllTargets BondArpAllTargets
  506. Primary int
  507. PrimaryReselect BondPrimaryReselect
  508. FailOverMac BondFailOverMac
  509. XmitHashPolicy BondXmitHashPolicy
  510. ResendIgmp int
  511. NumPeerNotif int
  512. AllSlavesActive int
  513. MinLinks int
  514. LpInterval int
  515. PackersPerSlave int
  516. LacpRate BondLacpRate
  517. AdSelect BondAdSelect
  518. // looking at iproute tool AdInfo can only be retrived. It can't be set.
  519. AdInfo *BondAdInfo
  520. AdActorSysPrio int
  521. AdUserPortKey int
  522. AdActorSystem net.HardwareAddr
  523. TlbDynamicLb int
  524. }
  525. func NewLinkBond(atr LinkAttrs) *Bond {
  526. return &Bond{
  527. LinkAttrs: atr,
  528. Mode: -1,
  529. ActiveSlave: -1,
  530. Miimon: -1,
  531. UpDelay: -1,
  532. DownDelay: -1,
  533. UseCarrier: -1,
  534. ArpInterval: -1,
  535. ArpIpTargets: nil,
  536. ArpValidate: -1,
  537. ArpAllTargets: -1,
  538. Primary: -1,
  539. PrimaryReselect: -1,
  540. FailOverMac: -1,
  541. XmitHashPolicy: -1,
  542. ResendIgmp: -1,
  543. NumPeerNotif: -1,
  544. AllSlavesActive: -1,
  545. MinLinks: -1,
  546. LpInterval: -1,
  547. PackersPerSlave: -1,
  548. LacpRate: -1,
  549. AdSelect: -1,
  550. AdActorSysPrio: -1,
  551. AdUserPortKey: -1,
  552. AdActorSystem: nil,
  553. TlbDynamicLb: -1,
  554. }
  555. }
  556. // Flag mask for bond options. Bond.Flagmask must be set to on for option to work.
  557. const (
  558. BOND_MODE_MASK uint64 = 1 << (1 + iota)
  559. BOND_ACTIVE_SLAVE_MASK
  560. BOND_MIIMON_MASK
  561. BOND_UPDELAY_MASK
  562. BOND_DOWNDELAY_MASK
  563. BOND_USE_CARRIER_MASK
  564. BOND_ARP_INTERVAL_MASK
  565. BOND_ARP_VALIDATE_MASK
  566. BOND_ARP_ALL_TARGETS_MASK
  567. BOND_PRIMARY_MASK
  568. BOND_PRIMARY_RESELECT_MASK
  569. BOND_FAIL_OVER_MAC_MASK
  570. BOND_XMIT_HASH_POLICY_MASK
  571. BOND_RESEND_IGMP_MASK
  572. BOND_NUM_PEER_NOTIF_MASK
  573. BOND_ALL_SLAVES_ACTIVE_MASK
  574. BOND_MIN_LINKS_MASK
  575. BOND_LP_INTERVAL_MASK
  576. BOND_PACKETS_PER_SLAVE_MASK
  577. BOND_LACP_RATE_MASK
  578. BOND_AD_SELECT_MASK
  579. )
  580. // Attrs implementation.
  581. func (bond *Bond) Attrs() *LinkAttrs {
  582. return &bond.LinkAttrs
  583. }
  584. // Type implementation fro Vxlan.
  585. func (bond *Bond) Type() string {
  586. return "bond"
  587. }
  588. // Gretap devices must specify LocalIP and RemoteIP on create
  589. type Gretap struct {
  590. LinkAttrs
  591. IKey uint32
  592. OKey uint32
  593. EncapSport uint16
  594. EncapDport uint16
  595. Local net.IP
  596. Remote net.IP
  597. IFlags uint16
  598. OFlags uint16
  599. PMtuDisc uint8
  600. Ttl uint8
  601. Tos uint8
  602. EncapType uint16
  603. EncapFlags uint16
  604. Link uint32
  605. FlowBased bool
  606. }
  607. func (gretap *Gretap) Attrs() *LinkAttrs {
  608. return &gretap.LinkAttrs
  609. }
  610. func (gretap *Gretap) Type() string {
  611. return "gretap"
  612. }
  613. type Iptun struct {
  614. LinkAttrs
  615. Ttl uint8
  616. Tos uint8
  617. PMtuDisc uint8
  618. Link uint32
  619. Local net.IP
  620. Remote net.IP
  621. }
  622. func (iptun *Iptun) Attrs() *LinkAttrs {
  623. return &iptun.LinkAttrs
  624. }
  625. func (iptun *Iptun) Type() string {
  626. return "ipip"
  627. }
  628. type Vti struct {
  629. LinkAttrs
  630. IKey uint32
  631. OKey uint32
  632. Link uint32
  633. Local net.IP
  634. Remote net.IP
  635. }
  636. func (vti *Vti) Attrs() *LinkAttrs {
  637. return &vti.LinkAttrs
  638. }
  639. func (iptun *Vti) Type() string {
  640. return "vti"
  641. }
  642. type Gretun struct {
  643. LinkAttrs
  644. Link uint32
  645. IFlags uint16
  646. OFlags uint16
  647. IKey uint32
  648. OKey uint32
  649. Local net.IP
  650. Remote net.IP
  651. Ttl uint8
  652. Tos uint8
  653. PMtuDisc uint8
  654. }
  655. func (gretun *Gretun) Attrs() *LinkAttrs {
  656. return &gretun.LinkAttrs
  657. }
  658. func (gretun *Gretun) Type() string {
  659. return "gre"
  660. }
  661. type Vrf struct {
  662. LinkAttrs
  663. Table uint32
  664. }
  665. func (vrf *Vrf) Attrs() *LinkAttrs {
  666. return &vrf.LinkAttrs
  667. }
  668. func (vrf *Vrf) Type() string {
  669. return "vrf"
  670. }
  671. type GTP struct {
  672. LinkAttrs
  673. FD0 int
  674. FD1 int
  675. Role int
  676. PDPHashsize int
  677. }
  678. func (gtp *GTP) Attrs() *LinkAttrs {
  679. return &gtp.LinkAttrs
  680. }
  681. func (gtp *GTP) Type() string {
  682. return "gtp"
  683. }
  684. // iproute2 supported devices;
  685. // vlan | veth | vcan | dummy | ifb | macvlan | macvtap |
  686. // bridge | bond | ipoib | ip6tnl | ipip | sit | vxlan |
  687. // gre | gretap | ip6gre | ip6gretap | vti | nlmon |
  688. // bond_slave | ipvlan
  689. // LinkNotFoundError wraps the various not found errors when
  690. // getting/reading links. This is intended for better error
  691. // handling by dependent code so that "not found error" can
  692. // be distinguished from other errors
  693. type LinkNotFoundError struct {
  694. error
  695. }