lowtuncmds

var DHCPCommand = cli.Command{
	Name: "dhcp",
	Flags: []cli.Flag{
		cli.StringFlag{Name: "iface", Value: ""},
	},
	Action: func(c *cli.Context) error {
		var iname string = c.String("iface")
		if iname == "" {
			ifaceDefault, _, _, err := netutil.GetPublicRoute()
			if err != nil {
				log.Errorf("failed to get public route: %v", err)
				return err
			}
			iname = ifaceDefault.Name
		}
		rwc, ep, err := rwendpoint.NewPcapReadWriteCloserEndpointEx(iname, 1600)
		if err != nil {
			log.Errorf("failed to create pcap read write closer endpoint: %v", err)
			return err
		}
		defer rwc.Close()
		defer ep.Close()

		macAddr := rwc.GetDeviceHardwareAddr()

		ipAddr := rwc.GetIP4Address()
		getawayAddr := rwc.GetGatewayIP4Address()
		stackInstance, err := netstack.NewDefaultStack(
			ipAddr.String(),
			macAddr.String(),
			getawayAddr.String(),
			ep,
		)
		if err != nil {
			log.Errorf("failed to create default stack: %v", err)
			return err
		}
		for k, v := range stackInstance.NICInfo() {
			_ = v
			log.Infof("nic: %v", k)
		}

		ch := make(chan struct{})

		stackInstance.RemoveAddress(1, tcpip.AddrFrom4(rwc.GetIP4Address().As4()))
		stackInstance.SetRouteTable(nil)

		client := gvisorDHCP.NewClient(stackInstance, 1, 5*time.Second, 5*time.Second, 5*time.Second, func(ctx context.Context, lost, acquired tcpip.AddressWithPrefix, cfg gvisorDHCP.Config) {
			preferIp, perferNet, err := net.ParseCIDR(acquired.String())
			if err != nil {
				log.Errorf("failed to parse cidr: %v", err)
				return
			}

			log.Infof("reset nic addr: %v mac: %v", preferIp.String(), macAddr.String())

			err = netstack.WithMainNICIP(1, tcpip.AddrFromSlice(preferIp.To4()), macAddr)(stackInstance)
			if err != nil {
				log.Errorf("set nic ip failed: %v", err)
				return
			}
			stackInstance.AddRoute(tcpip.Route{
				Destination: header.IPv4EmptySubnet,
				Gateway: tcpip.AddrFrom4([4]byte{
					192, 168, 0, 1,
				}),
				NIC: 1,
				MTU: 1420,
			})
			stackInstance.SetForwardingDefaultAndAllNICs(header.IPv4ProtocolNumber, true)
			arpNep, epErr := stackInstance.GetNetworkEndpoint(1, arp.ProtocolNumber)
			if epErr != nil {
				log.Errorf("failed to create arp endpoint: %v", epErr)
				return
			}

			if arpErr := sendARPAnnouncement(stackInstance, arpNep, 1, tcpip.AddrFrom4([4]byte(preferIp.To4()))); arpErr != nil {
				log.Errorf("failed to send arp announcement: %v", arpErr)
			}

			_ = arpNep
			go func() {
				for {

					time.Sleep(time.Second)
				}
			}()

			ch <- struct{}{}

			getaway := cfg.ServerAddress.String()
			log.Infof("dhcp client fetched preferIp: %v, perferNet: %v, getaway: %v", preferIp, perferNet, getaway)
		})

		log.Info("start to run gvisor dhcp client")
		go func() {
			result := client.Run(context.Background())
			_ = result
		}()

		go func() {
			<-ch
			time.Sleep(4 * time.Second)
			log.Infof("dhcp finished, ip fetched")
			ctx := utils.TimeoutContextSeconds(10)
			target := tcpip.FullAddress{
				NIC:  1,
				Addr: tcpip.AddrFrom4(netip.MustParseAddr("23.192.228.150").As4()),
				Port: 80,
			}
			conn, err := gonet.DialContextTCP(ctx, stackInstance, target, header.IPv4ProtocolNumber)
			if err != nil {
				log.Errorf("failed to dial tcp: %v", err)
				return
			}
			conn.Write([]byte("GET / HTTP/1.1\r\nHost: www.baidu.com\r\n\r\n"))
			results := utils.StableReaderEx(conn, 5*time.Second, 1024)
			spew.Dump(results)
		}()
		stackInstance.Wait()
		return nil
	},
}