func routeTests(ncc client.NCC) {
	gateway, err := ncc.RouteDefaultIPv4()
	if err != nil {
		log.Fatalf("Failed to get IPv4 default route: %v", err)
	}
	log.Printf("Got IPv4 default route - %v", gateway)
}

func lbInterface(ncc client.NCC) client.LBInterface {
	iface := *testIface
	nodeIP := net.ParseIP(*nodeIPStr)
	nodeIPv6 := net.ParseIP(*nodeIPv6Str)
	if nodeIP == nil && nodeIPv6 == nil {
		log.Fatalf("Invalid node IP/IPv6 - %q/%q", *nodeIPStr, *nodeIPv6Str)
	}

	unicastVIP := net.ParseIP(*unicastVIPStr)
	if unicastVIP == nil {
		log.Fatalf("Invalid unicast VIP - %q", *unicastVIPStr)
	}
	vip := net.ParseIP(*clusterVIPStr)
	if vip == nil {
		log.Fatalf("Invalid cluster VIP - %q", *clusterVIPStr)
	}
	if *vrID < 1 || *vrID > 255 {
		log.Fatalf("Invalid VRID - %q", *vrID)
	}
	rtID := uint8(*routingTableID)
	// TODO(jsing): Change this to allow both IPv4 and IPv6 addresses.
	lbCfg := &types.LBConfig{
		ClusterVIP:     seesaw.Host{IPv4Addr: vip},
		Node:           seesaw.Host{IPv4Addr: nodeIP, IPv6Addr: nodeIPv6},
		DummyInterface: "dummy0",
		NodeInterface:  "eth0",
		RoutingTableID: rtID,
		VRID:           uint8(*vrID),
	}
	lb := ncc.NewLBInterface(iface, lbCfg)
	if err := lb.Init(); err != nil {
		log.Fatalf("Failed to initialise the LB interface: %v", err)
	}
	return lb
}

func arpTests(ncc client.NCC) {
	// Send a gratuitous ARP message.
	vip := net.ParseIP(*clusterVIPStr)
	if vip == nil {
		log.Fatalf("Invalid cluster VIP - %q", *clusterVIPStr)
	}
	log.Print("Sending gratuitous ARP...")
	if err := ncc.ARPSendGratuitous(*testIface, vip); err != nil {
		log.Fatalf("Failed to send gratuitous ARP: %v", err)
	}
	log.Print("Done.")
}

func bgpTests(ncc client.NCC) {
	// Display the BGP neighbors.
	log.Print("Getting BGP neighbors...")
	neighbors, err := ncc.BGPNeighbors()
	if err != nil {
		log.Fatalf("Failed to get BGP neighbors")
	}
	for _, n := range neighbors {
		log.Printf("- BGP neighbor %v, remote AS %d, state %v, uptime %v seconds",
			n.IP, n.ASN, n.BGPState, n.Uptime.Seconds())
	}

	// Withdraw all existing network advertisements.
	log.Printf("Withdrawing all network advertisements")
	if err := ncc.BGPWithdrawAll(); err != nil {
		log.Fatalf("Failed to withdraw BGP advertisements: %v", err)
	}

	// Advertise and withdraw the test-anycast VIP.
	log.Printf("Advertising and withdrawing VIP %v", testAnycast)
	if err := ncc.BGPAdvertiseVIP(testAnycast); err != nil {
		log.Fatalf("Failed to advertise VIP %v: %v", testAnycast, err)
	}
	cfg, err := ncc.BGPConfig()
	if err != nil {
		log.Fatal("Failed to get BGP configuration")
	}
	found := false
	ns := fmt.Sprintf(" network %v/32", testAnycast)
	for _, l := range cfg {
		if l == ns {
			found = true
			break
		}
	}
	if !found {
		log.Fatal("Failed to find network statement")
	}
	if err := ncc.BGPWithdrawVIP(testAnycast); err != nil {
		log.Fatalf("Failed to withdraw VIP %v: %v", testAnycast, err)
	}
}

func ipvsAddLoadTest(ncc client.NCC, services, dests int) {
	log.Printf("Starting IPVS add load test - %d services, each with %d destinations", services, dests)

	if err := ncc.IPVSFlush(); err != nil {
		log.Fatalf("Failed to flush the IPVS table: %v", err)
	}

	done := make(chan bool)
	for i := 0; i < services; i++ {
		go ipvsAddService(done, i, dests)
	}
	for i := 0; i < services; i++ {
		<-done
	}

	if err := ncc.IPVSFlush(); err != nil {
		log.Fatalf("Failed to flush the IPVS table: %v", err)
	}

	log.Printf("Completed IPVS add load test")
}

func ipvsTests(ncc client.NCC) {

	// Manipulate the IPVS table.
	if err := ncc.IPVSFlush(); err != nil {
		log.Fatalf("Failed to flush the IPVS table: %v", err)
	}

	log.Printf("Adding IPVS service %v with %d destinations", testSvc, len(testSvc.Destinations))
	if err := ncc.IPVSAddService(testSvc); err != nil {
		log.Fatalf("Failed to add IPVS service: %v", err)
	}

	svcs, err := ncc.IPVSGetServices()
	if err != nil {
		log.Fatalf("Failed to get IPVS services: %v", err)
	}
	for _, svc := range svcs {
		log.Printf("Got IPVS service %v with %d destinations",
			svc, len(svc.Destinations))
	}
	if len(svcs) != 1 {
		log.Fatalf("IPVSGetServices returned %d services, expected 1", len(svcs))
	}
	if len(svcs[0].Destinations) != len(testSvc.Destinations) {
		log.Fatalf("IPVSGetServices returned %d destinations, expected %d",
			len(svcs[0].Destinations), len(testSvc.Destinations))
	}

	dst := testSvc.Destinations[0]
	if err := ncc.IPVSDeleteDestination(testSvc, dst); err != nil {
		log.Fatalf("Failed to delete destination: %v", err)
	}

	svc, err := ncc.IPVSGetService(testSvc)
	if err != nil {
		log.Fatalf("Failed to get IPVS service: %v", err)
	}
	if len(svc.Destinations) != len(testSvc.Destinations)-1 {
		log.Fatalf("IPVSGetService returned %d destinations, expected %d",
			len(svc.Destinations), len(testSvc.Destinations)-1)
	}

	ipvsGetLoadTest(4, 10*time.Second)

	if err := ncc.IPVSDeleteService(testSvc); err != nil {
		log.Fatalf("Failed to delete IPVS service: %v", err)
	}

	ipvsAddLoadTest(ncc, 20, 50)

	// Clean up after ourselves...
	if err := ncc.IPVSFlush(); err != nil {
		log.Fatalf("Failed to flush the IPVS table: %v", err)
	}
}