fou_linux.go 3.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
  1. // +build linux
  2. package netlink
  3. import (
  4. "encoding/binary"
  5. "errors"
  6. "github.com/vishvananda/netlink/nl"
  7. "golang.org/x/sys/unix"
  8. )
  9. const (
  10. FOU_GENL_NAME = "fou"
  11. )
  12. const (
  13. FOU_CMD_UNSPEC uint8 = iota
  14. FOU_CMD_ADD
  15. FOU_CMD_DEL
  16. FOU_CMD_GET
  17. FOU_CMD_MAX = FOU_CMD_GET
  18. )
  19. const (
  20. FOU_ATTR_UNSPEC = iota
  21. FOU_ATTR_PORT
  22. FOU_ATTR_AF
  23. FOU_ATTR_IPPROTO
  24. FOU_ATTR_TYPE
  25. FOU_ATTR_REMCSUM_NOPARTIAL
  26. FOU_ATTR_MAX = FOU_ATTR_REMCSUM_NOPARTIAL
  27. )
  28. const (
  29. FOU_ENCAP_UNSPEC = iota
  30. FOU_ENCAP_DIRECT
  31. FOU_ENCAP_GUE
  32. FOU_ENCAP_MAX = FOU_ENCAP_GUE
  33. )
  34. var fouFamilyId int
  35. func FouFamilyId() (int, error) {
  36. if fouFamilyId != 0 {
  37. return fouFamilyId, nil
  38. }
  39. fam, err := GenlFamilyGet(FOU_GENL_NAME)
  40. if err != nil {
  41. return -1, err
  42. }
  43. fouFamilyId = int(fam.ID)
  44. return fouFamilyId, nil
  45. }
  46. func FouAdd(f Fou) error {
  47. return pkgHandle.FouAdd(f)
  48. }
  49. func (h *Handle) FouAdd(f Fou) error {
  50. fam_id, err := FouFamilyId()
  51. if err != nil {
  52. return err
  53. }
  54. // setting ip protocol conflicts with encapsulation type GUE
  55. if f.EncapType == FOU_ENCAP_GUE && f.Protocol != 0 {
  56. return errors.New("GUE encapsulation doesn't specify an IP protocol")
  57. }
  58. req := h.newNetlinkRequest(fam_id, unix.NLM_F_ACK)
  59. // int to byte for port
  60. bp := make([]byte, 2)
  61. binary.BigEndian.PutUint16(bp[0:2], uint16(f.Port))
  62. attrs := []*nl.RtAttr{
  63. nl.NewRtAttr(FOU_ATTR_PORT, bp),
  64. nl.NewRtAttr(FOU_ATTR_TYPE, []byte{uint8(f.EncapType)}),
  65. nl.NewRtAttr(FOU_ATTR_AF, []byte{uint8(f.Family)}),
  66. nl.NewRtAttr(FOU_ATTR_IPPROTO, []byte{uint8(f.Protocol)}),
  67. }
  68. raw := []byte{FOU_CMD_ADD, 1, 0, 0}
  69. for _, a := range attrs {
  70. raw = append(raw, a.Serialize()...)
  71. }
  72. req.AddRawData(raw)
  73. _, err = req.Execute(unix.NETLINK_GENERIC, 0)
  74. return err
  75. }
  76. func FouDel(f Fou) error {
  77. return pkgHandle.FouDel(f)
  78. }
  79. func (h *Handle) FouDel(f Fou) error {
  80. fam_id, err := FouFamilyId()
  81. if err != nil {
  82. return err
  83. }
  84. req := h.newNetlinkRequest(fam_id, unix.NLM_F_ACK)
  85. // int to byte for port
  86. bp := make([]byte, 2)
  87. binary.BigEndian.PutUint16(bp[0:2], uint16(f.Port))
  88. attrs := []*nl.RtAttr{
  89. nl.NewRtAttr(FOU_ATTR_PORT, bp),
  90. nl.NewRtAttr(FOU_ATTR_AF, []byte{uint8(f.Family)}),
  91. }
  92. raw := []byte{FOU_CMD_DEL, 1, 0, 0}
  93. for _, a := range attrs {
  94. raw = append(raw, a.Serialize()...)
  95. }
  96. req.AddRawData(raw)
  97. _, err = req.Execute(unix.NETLINK_GENERIC, 0)
  98. if err != nil {
  99. return err
  100. }
  101. return nil
  102. }
  103. func FouList(fam int) ([]Fou, error) {
  104. return pkgHandle.FouList(fam)
  105. }
  106. func (h *Handle) FouList(fam int) ([]Fou, error) {
  107. fam_id, err := FouFamilyId()
  108. if err != nil {
  109. return nil, err
  110. }
  111. req := h.newNetlinkRequest(fam_id, unix.NLM_F_DUMP)
  112. attrs := []*nl.RtAttr{
  113. nl.NewRtAttr(FOU_ATTR_AF, []byte{uint8(fam)}),
  114. }
  115. raw := []byte{FOU_CMD_GET, 1, 0, 0}
  116. for _, a := range attrs {
  117. raw = append(raw, a.Serialize()...)
  118. }
  119. req.AddRawData(raw)
  120. msgs, err := req.Execute(unix.NETLINK_GENERIC, 0)
  121. if err != nil {
  122. return nil, err
  123. }
  124. fous := make([]Fou, 0, len(msgs))
  125. for _, m := range msgs {
  126. f, err := deserializeFouMsg(m)
  127. if err != nil {
  128. return fous, err
  129. }
  130. fous = append(fous, f)
  131. }
  132. return fous, nil
  133. }
  134. func deserializeFouMsg(msg []byte) (Fou, error) {
  135. // we'll skip to byte 4 to first attribute
  136. msg = msg[3:]
  137. var shift int
  138. fou := Fou{}
  139. for {
  140. // attribute header is at least 16 bits
  141. if len(msg) < 4 {
  142. return fou, ErrAttrHeaderTruncated
  143. }
  144. lgt := int(binary.BigEndian.Uint16(msg[0:2]))
  145. if len(msg) < lgt+4 {
  146. return fou, ErrAttrBodyTruncated
  147. }
  148. attr := binary.BigEndian.Uint16(msg[2:4])
  149. shift = lgt + 3
  150. switch attr {
  151. case FOU_ATTR_AF:
  152. fou.Family = int(msg[5])
  153. case FOU_ATTR_PORT:
  154. fou.Port = int(binary.BigEndian.Uint16(msg[5:7]))
  155. // port is 2 bytes
  156. shift = lgt + 2
  157. case FOU_ATTR_IPPROTO:
  158. fou.Protocol = int(msg[5])
  159. case FOU_ATTR_TYPE:
  160. fou.EncapType = int(msg[5])
  161. }
  162. msg = msg[shift:]
  163. if len(msg) < 4 {
  164. break
  165. }
  166. }
  167. return fou, nil
  168. }