Create a local tunnel interface about go-gtp HOT 4 CLOSED

"github.com/songgao/water"
"github.com/vishvananda/netlink"

// Until peer information is registered by AddPeer(), it just drops packets.
func (r *RelayToOS) Run() {
	// from left to right
	go func() {
		buf := make([]byte, 1600)
		for {
			select {
			case <-r.closed():
				return
			default:
				// do nothing and go forward.
			}

			n, err := r.leftConn.Read(buf)
			if err != nil {
				continue
			}

			if _, err := r.rightConn.WriteToGTP(r.rightConnPeer.teid, buf[:n], r.rightConnPeer.addr); err != nil {
				continue
			}
		}
	}()

	// from right to left
	go func() {
		buf := make([]byte, 1600)
		for {
			select {
			case <-r.closed():
				return
			default:
				// do nothing and go forward.
			}

			n, _, _, err := r.rightConn.ReadFromGTP(buf)
			if err != nil {
				continue
			}

			if _, err := r.leftConn.Write(buf[:n]); err != nil {
				continue
			}
		}
	}()
}

// Close closes Relay. It does not close the UPlaneConn given at first.
func (r *RelayToOS) Close() error {
	//FIXME original line was: r.leftConn.SetReadDeadline(time.Now().Add(time.Duration(1 * time.Millisecond)))
	if err := r.leftConn.Close(); err != nil {
		return err
	}
	if err := r.rightConn.SetReadDeadline(time.Now().Add(time.Duration(1 * time.Millisecond))); err != nil {
		return err
	}
	close(r.closeCh)
	return nil
}

func (r *RelayToOS) closed() <-chan struct{} {
	return r.closeCh
}

// AddPeer adds a peer information with the TEID contained in the incoming meesage.
func (r *RelayToOS) AddPeer(teid uint32, raddr net.Addr) {
	r.mu.Lock()
	defer r.mu.Unlock()

	r.rightConnPeer = &peer{teid, raddr}
}

func (m mockUEeNB) run(errCh chan error) {
	if uConn == nil {
		// Listen on eNB S1-U interface.
		enbUPlaneAddr, err := net.ResolveUDPAddr("udp", *s1enb)
		if err != nil {
			log.Fatal(err)
		}
		m.laddr = enbUPlaneAddr

		uConn, err = v1.ListenAndServeUPlane(m.laddr, 0, errCh)
		if err != nil {
			errCh <- err
			return
		}

		ifce, err := water.New(water.Config{
			DeviceType: water.TUN,
		})
		if err != nil {
			log.Fatal(err)
		}
		loggerCh <- fmt.Sprintf("Created ifce %s", ifce.Name())
		
		//On MAC
		//Assign subscriber IP to interface
		_, err = exec.Command("/sbin/ifconfig", "utun2", m.subscriberIP, m.subscriberIP, "up").Output()

		// handle it here
		if err != nil {
			fmt.Printf("%s", err)
		}

		relayToOS := v1.NewRelayToOS(ifce, uConn)
		relayToOS.AddPeer(m.teidOut, m.raddr)
		go relayToOS.Run()
	}

func (m mockUEeNB) run(errCh chan error) {
	if uConn == nil {
		// Listen on eNB S1-U interface.
		enbUPlaneAddr, err := net.ResolveUDPAddr("udp", *s1enb)
		if err != nil {
			log.Fatal(err)
		}
		m.laddr = enbUPlaneAddr

		uConn, err = v1.ListenAndServeUPlane(m.laddr, 0, errCh)
		if err != nil {
			errCh <- err
			return
		}
		
		//On MAC
		/*ifce, err := water.New(water.Config{
			DeviceType: water.TUN,
		})
		if err != nil {
			log.Fatal(err)
		}
		loggerCh <- fmt.Sprintf("Created ifce %s", ifce.Name())

		//On Linux
		ifce, err := water.New(water.Config{
			DeviceType: water.TUN,
		})
		if err != nil {
			log.Fatal(err)
		}
		loggerCh <- fmt.Sprintf("Created ifce %s", ifce.Name())

		tun, _ := netlink.LinkByName(ifce.Name())
		addr, _ := netlink.ParseAddr(m.subscriberIP + "/32")
		loggerCh <- fmt.Sprintf("Address for tun %s", addr)
		
		//add IP address from subscriber session
		err = netlink.AddrAdd(tun, addr)
		if err != nil {
			log.Fatal(err)
		}
		
		//bring up the interface
		err = netlink.LinkSetUp(tun)
		if err != nil {
			log.Fatal(err)
		}

		//delete existing default route
		dst := &net.IPNet{
			IP:   net.IPv4(0, 0, 0, 0),
			Mask: net.CIDRMask(0, 0),
		}
		err = netlink.RouteDel(&netlink.Route{LinkIndex: tun.Attrs().Index, Dst: dst})
		if err != nil {
			fmt.Printf("%s", err)
		}

		//add new default route via tun interface
		err = netlink.RouteAdd(&netlink.Route{LinkIndex: tun.Attrs().Index, Dst: dst})
		if err != nil {
			log.Fatal(err)
		}


		relayToOS := v1.NewRelayToOS(ifce, uConn)
		relayToOS.AddPeer(m.teidOut, m.raddr)
		go relayToOS.Run()
	}