tun_netbsd.go 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233
  1. //go:build !e2e_testing
  2. // +build !e2e_testing
  3. package overlay
  4. import (
  5. "fmt"
  6. "io"
  7. "net"
  8. "os"
  9. "os/exec"
  10. "regexp"
  11. "strconv"
  12. "sync/atomic"
  13. "syscall"
  14. "unsafe"
  15. "github.com/sirupsen/logrus"
  16. "github.com/slackhq/nebula/cidr"
  17. "github.com/slackhq/nebula/config"
  18. "github.com/slackhq/nebula/iputil"
  19. "github.com/slackhq/nebula/util"
  20. )
  21. type ifreqDestroy struct {
  22. Name [16]byte
  23. pad [16]byte
  24. }
  25. type tun struct {
  26. Device string
  27. cidr *net.IPNet
  28. MTU int
  29. Routes atomic.Pointer[[]Route]
  30. routeTree atomic.Pointer[cidr.Tree4[iputil.VpnIp]]
  31. l *logrus.Logger
  32. io.ReadWriteCloser
  33. }
  34. func (t *tun) Close() error {
  35. if t.ReadWriteCloser != nil {
  36. if err := t.ReadWriteCloser.Close(); err != nil {
  37. return err
  38. }
  39. s, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_IP)
  40. if err != nil {
  41. return err
  42. }
  43. defer syscall.Close(s)
  44. ifreq := ifreqDestroy{Name: t.deviceBytes()}
  45. err = ioctl(uintptr(s), syscall.SIOCIFDESTROY, uintptr(unsafe.Pointer(&ifreq)))
  46. return err
  47. }
  48. return nil
  49. }
  50. func newTunFromFd(_ *config.C, _ *logrus.Logger, _ int, _ *net.IPNet) (*tun, error) {
  51. return nil, fmt.Errorf("newTunFromFd not supported in NetBSD")
  52. }
  53. var deviceNameRE = regexp.MustCompile(`^tun[0-9]+$`)
  54. func newTun(c *config.C, l *logrus.Logger, cidr *net.IPNet, _ bool) (*tun, error) {
  55. // Try to open tun device
  56. var file *os.File
  57. var err error
  58. deviceName := c.GetString("tun.dev", "")
  59. if deviceName == "" {
  60. return nil, fmt.Errorf("a device name in the format of /dev/tunN must be specified")
  61. }
  62. if !deviceNameRE.MatchString(deviceName) {
  63. return nil, fmt.Errorf("a device name in the format of /dev/tunN must be specified")
  64. }
  65. file, err = os.OpenFile("/dev/"+deviceName, os.O_RDWR, 0)
  66. if err != nil {
  67. return nil, err
  68. }
  69. t := &tun{
  70. ReadWriteCloser: file,
  71. Device: deviceName,
  72. cidr: cidr,
  73. MTU: c.GetInt("tun.mtu", DefaultMTU),
  74. l: l,
  75. }
  76. err = t.reload(c, true)
  77. if err != nil {
  78. return nil, err
  79. }
  80. c.RegisterReloadCallback(func(c *config.C) {
  81. err := t.reload(c, false)
  82. if err != nil {
  83. util.LogWithContextIfNeeded("failed to reload tun device", err, t.l)
  84. }
  85. })
  86. return t, nil
  87. }
  88. func (t *tun) Activate() error {
  89. var err error
  90. // TODO use syscalls instead of exec.Command
  91. cmd := exec.Command("/sbin/ifconfig", t.Device, t.cidr.String(), t.cidr.IP.String())
  92. t.l.Debug("command: ", cmd.String())
  93. if err = cmd.Run(); err != nil {
  94. return fmt.Errorf("failed to run 'ifconfig': %s", err)
  95. }
  96. cmd = exec.Command("/sbin/route", "-n", "add", "-net", t.cidr.String(), t.cidr.IP.String())
  97. t.l.Debug("command: ", cmd.String())
  98. if err = cmd.Run(); err != nil {
  99. return fmt.Errorf("failed to run 'route add': %s", err)
  100. }
  101. cmd = exec.Command("/sbin/ifconfig", t.Device, "mtu", strconv.Itoa(t.MTU))
  102. t.l.Debug("command: ", cmd.String())
  103. if err = cmd.Run(); err != nil {
  104. return fmt.Errorf("failed to run 'ifconfig': %s", err)
  105. }
  106. // Unsafe path routes
  107. return t.addRoutes(false)
  108. }
  109. func (t *tun) reload(c *config.C, initial bool) error {
  110. change, routes, err := getAllRoutesFromConfig(c, t.cidr, initial)
  111. if err != nil {
  112. return err
  113. }
  114. if !initial && !change {
  115. return nil
  116. }
  117. routeTree, err := makeRouteTree(t.l, routes, false)
  118. if err != nil {
  119. return err
  120. }
  121. // Teach nebula how to handle the routes before establishing them in the system table
  122. oldRoutes := t.Routes.Swap(&routes)
  123. t.routeTree.Store(routeTree)
  124. if !initial {
  125. // Remove first, if the system removes a wanted route hopefully it will be re-added next
  126. err := t.removeRoutes(findRemovedRoutes(routes, *oldRoutes))
  127. if err != nil {
  128. util.LogWithContextIfNeeded("Failed to remove routes", err, t.l)
  129. }
  130. // Ensure any routes we actually want are installed
  131. err = t.addRoutes(true)
  132. if err != nil {
  133. // Catch any stray logs
  134. util.LogWithContextIfNeeded("Failed to add routes", err, t.l)
  135. }
  136. }
  137. return nil
  138. }
  139. func (t *tun) RouteFor(ip iputil.VpnIp) iputil.VpnIp {
  140. _, r := t.routeTree.Load().MostSpecificContains(ip)
  141. return r
  142. }
  143. func (t *tun) Cidr() *net.IPNet {
  144. return t.cidr
  145. }
  146. func (t *tun) Name() string {
  147. return t.Device
  148. }
  149. func (t *tun) NewMultiQueueReader() (io.ReadWriteCloser, error) {
  150. return nil, fmt.Errorf("TODO: multiqueue not implemented for netbsd")
  151. }
  152. func (t *tun) addRoutes(logErrors bool) error {
  153. routes := *t.Routes.Load()
  154. for _, r := range routes {
  155. if r.Via == nil || !r.Install {
  156. // We don't allow route MTUs so only install routes with a via
  157. continue
  158. }
  159. cmd := exec.Command("/sbin/route", "-n", "add", "-net", r.Cidr.String(), t.cidr.IP.String())
  160. t.l.Debug("command: ", cmd.String())
  161. if err := cmd.Run(); err != nil {
  162. retErr := util.NewContextualError("failed to run 'route add' for unsafe_route", map[string]interface{}{"route": r}, err)
  163. if logErrors {
  164. retErr.Log(t.l)
  165. } else {
  166. return retErr
  167. }
  168. }
  169. }
  170. return nil
  171. }
  172. func (t *tun) removeRoutes(routes []Route) error {
  173. for _, r := range routes {
  174. if !r.Install {
  175. continue
  176. }
  177. cmd := exec.Command("/sbin/route", "-n", "delete", "-net", r.Cidr.String(), t.cidr.IP.String())
  178. t.l.Debug("command: ", cmd.String())
  179. if err := cmd.Run(); err != nil {
  180. t.l.WithError(err).WithField("route", r).Error("Failed to remove route")
  181. } else {
  182. t.l.WithField("route", r).Info("Removed route")
  183. }
  184. }
  185. return nil
  186. }
  187. func (t *tun) deviceBytes() (o [16]byte) {
  188. for i, c := range t.Device {
  189. o[i] = byte(c)
  190. }
  191. return
  192. }