src/connectivity/network/netstack/ifconfig/ifconfig.go - fuchsia - Git at Google

 // Copyright 2017 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // +build !build_with_native_toolchain

 package ifconfig

 import (
 	"context"
 	"fmt"
 	"net"
 	"os"
 	"strconv"
 	"strings"
 	"syscall/zx"

 	"go.fuchsia.dev/fuchsia/src/connectivity/network/netstack/fidlconv"
 	"go.fuchsia.dev/fuchsia/src/lib/component"

 	netfidl "fidl/fuchsia/net"
 	"fidl/fuchsia/net/dhcp"
 	"fidl/fuchsia/netstack"

 	"gvisor.dev/gvisor/pkg/tcpip"
 )

 type netstackClientApp struct {
 	ctx      *component.Context
 	netstack *netstack.NetstackWithCtxInterface
 }

 func (a *netstackClientApp) printAll() {
 	ifaces, err := a.netstack.GetInterfaces2(context.Background())
 	if err != nil {
 		fmt.Print("ifconfig: failed to fetch interfaces\n")
 		return
 	}

 	for _, iface := range ifaces {
 		a.printIface(iface)
 	}
 }

 func getIfaceByNameFromIfaces(name string, ifaces []netstack.NetInterface2) *netstack.NetInterface2 {
 	var candidate *netstack.NetInterface2
 	for i, iface := range ifaces {
 		if strings.HasPrefix(iface.Name, name) {
 			if candidate != nil {
 				return nil
 			}
 			candidate = &ifaces[i]
 		}
 	}
 	return candidate
 }

 func getIfaceByIdFromIfaces(id uint32, ifaces []netstack.NetInterface2) *netstack.NetInterface2 {
 	for _, iface := range ifaces {
 		if iface.Id == id {
 			return &iface
 		}
 	}
 	return nil
 }

 func (a *netstackClientApp) printIface(iface netstack.NetInterface2) {
 	fmt.Printf("%s\tHWaddr %s Id:%d\n", iface.Name, hwAddrToString(iface.Hwaddr), iface.Id)
 	fmt.Printf("\tinet addr:%s  Bcast:%s  Mask:%s\n", netAddrToString(iface.Addr), netAddrToString(iface.Broadaddr), netAddrToString(iface.Netmask))
 	for _, addr := range iface.Ipv6addrs {
 		// TODO: scopes
 		fmt.Printf("\tinet6 addr: %s/%d Scope:Link\n", netAddrToString(addr.Addr), addr.PrefixLen)
 	}
 	fmt.Printf("\tmetric:%d\n", iface.Metric)
 	fmt.Printf("\t%s\n", iface.Flags)
 }

 func (a *netstackClientApp) setStatus(iface netstack.NetInterface2, up bool) {
 	a.netstack.SetInterfaceStatus(context.Background(), iface.Id, up)
 }

 func (a *netstackClientApp) addIfaceAddress(iface netstack.NetInterface2, cidr string) {
 	netAddr, prefixLen := validateCidr(os.Args[3])
 	result, _ := a.netstack.SetInterfaceAddress(context.Background(), iface.Id, netAddr, prefixLen)
 	if result.Status != netstack.StatusOk {
 		fmt.Printf("Error setting interface address: %s\n", result.Message)
 	}
 }

 func (a *netstackClientApp) removeIfaceAddress(iface netstack.NetInterface2, cidr string) {
 	netAddr, prefixLen := validateCidr(os.Args[3])
 	result, _ := a.netstack.RemoveInterfaceAddress(context.Background(), iface.Id, netAddr, prefixLen)
 	if result.Status != netstack.StatusOk {
 		fmt.Printf("Error setting interface address: %s\n", result.Message)
 	}
 }

 func (a *netstackClientApp) parseRouteAttribute(in *netstack.RouteTableEntry2, args []string) (remaining []string, err error) {
 	if len(args) < 2 {
 		return args, fmt.Errorf("not enough args to make attribute")
 	}
 	var attr, val string
 	switch attr, val, remaining = args[0], args[1], args[2:]; attr {
 	case "gateway":
 		gateway := toIpAddress(net.ParseIP(val))
 		in.Gateway = &gateway
 	case "metric":
 		m, err := strconv.ParseUint(val, 10, 32)
 		if err != nil {
 			return remaining, fmt.Errorf("metric value '%s' is not uint32: %s", val, err)
 		}
 		in.Metric = uint32(m)
 	case "iface":
 		ifaces, err := a.netstack.GetInterfaces2(context.Background())
 		if err != nil {
 			return remaining, err
 		}
 		iface := getIfaceByNameFromIfaces(val, ifaces)
 		if err != nil {
 			return remaining, err
 		}
 		if iface == nil {
 			return remaining, fmt.Errorf("no such interface '%s'\n", val)
 		}

 		in.Nicid = iface.Id
 	default:
 		return remaining, fmt.Errorf("unknown route attribute: %s %s", attr, val)
 	}

 	return remaining, nil
 }

 func (a *netstackClientApp) newRouteFromArgs(args []string) (route netstack.RouteTableEntry2, err error) {
 	destination, remaining := args[0], args[1:]
 	_, dstSubnet, err := net.ParseCIDR(destination)
 	if err != nil {
 		return route, fmt.Errorf("invalid destination (destination must be provided in CIDR format): %s", destination)
 	}

 	route.Destination = toIpAddress(dstSubnet.IP)
 	route.Netmask = toIpAddress(net.IP(dstSubnet.Mask))

 	for len(remaining) > 0 {
 		remaining, err = a.parseRouteAttribute(&route, remaining)
 		if err != nil {
 			return route, err
 		}
 	}

 	if len(remaining) != 0 {
 		return route, fmt.Errorf("could not parse all route arguments. remaining: %s", remaining)
 	}

 	return route, nil
 }

 func (a *netstackClientApp) addRoute(r netstack.RouteTableEntry2) error {
 	if r.Gateway == nil && r.Nicid == 0 {
 		return fmt.Errorf("either gateway or iface must be provided when adding a route")
 	}

 	req, transactionInterface, err := netstack.NewRouteTableTransactionWithCtxInterfaceRequest()
 	if err != nil {
 		return fmt.Errorf("could not make a new route table transaction: %s", err)
 	}
 	defer req.Close()
 	status, err := a.netstack.StartRouteTableTransaction(context.Background(), req)
 	if err != nil || zx.Status(status) != zx.ErrOk {
 		return fmt.Errorf("could not start a route table transaction: %s (%s)", err, zx.Status(status))
 	}

 	status, err = transactionInterface.AddRoute(context.Background(), r)
 	if err != nil {
 		return fmt.Errorf("could not add route due to transaction interface error: %s", err)
 	}
 	if zx.Status(status) != zx.ErrOk {
 		return fmt.Errorf("could not add route in netstack: %s", zx.Status(status))
 	}
 	return nil
 }

 func (a *netstackClientApp) deleteRoute(r netstack.RouteTableEntry2) error {
 	req, transactionInterface, err := netstack.NewRouteTableTransactionWithCtxInterfaceRequest()
 	if err != nil {
 		return fmt.Errorf("could not make a new route table transaction: %s", err)
 	}
 	defer req.Close()
 	status, err := a.netstack.StartRouteTableTransaction(context.Background(), req)
 	if err != nil || zx.Status(status) != zx.ErrOk {
 		return fmt.Errorf("could not start a route table transaction (maybe the route table is locked?): %s", err)
 	}

 	status, err = transactionInterface.DelRoute(context.Background(), r)
 	if err != nil {
 		return fmt.Errorf("could not delete route due to transaction interface error: %s", err)
 	}
 	if zx.Status(status) != zx.ErrOk {
 		return fmt.Errorf("could not delete route in netstack: %s", zx.Status(status))
 	}
 	return nil
 }

 func routeTableEntryToString(r netstack.RouteTableEntry2, ifaces []netstack.NetInterface2) string {
 	iface := getIfaceByIdFromIfaces(r.Nicid, ifaces)
 	var ifaceName string
 	if iface == nil {
 		ifaceName = fmt.Sprintf("Nicid:%d", r.Nicid)
 	} else {
 		ifaceName = iface.Name
 	}
 	var netAndMask net.IPNet
 	switch r.Destination.Which() {
 	case netfidl.IpAddressIpv4:
 		netAndMask = net.IPNet{IP: r.Destination.Ipv4.Addr[:], Mask: r.Netmask.Ipv4.Addr[:]}
 	case netfidl.IpAddressIpv6:
 		netAndMask = net.IPNet{IP: r.Destination.Ipv6.Addr[:], Mask: r.Netmask.Ipv6.Addr[:]}
 	}
 	if r.Gateway != nil {
 		return fmt.Sprintf("%s via %s %s metric %v", netAndMask.String(), netAddrToString(*r.Gateway), ifaceName, r.Metric)
 	}
 	return fmt.Sprintf("%s via %s metric %v", netAndMask.String(), ifaceName, r.Metric)
 }

 func (a *netstackClientApp) showRoutes() error {
 	rs, err := a.netstack.GetRouteTable2(context.Background())
 	if err != nil {
 		return fmt.Errorf("Could not get route table from netstack: %s", err)
 	}
 	ifaces, err := a.netstack.GetInterfaces2(context.Background())
 	if err != nil {
 		return err
 	}
 	for _, r := range rs {
 		fmt.Printf("%s\n", routeTableEntryToString(r, ifaces))
 	}
 	return nil
 }

 func (a *netstackClientApp) bridge(ifNames []string) (uint32, error) {
 	ifs := make([]*netstack.NetInterface2, len(ifNames))
 	nicIDs := make([]uint32, len(ifNames))
 	// first, validate that all interfaces exist
 	ifaces, err := a.netstack.GetInterfaces2(context.Background())
 	if err != nil {
 		return 0, err
 	}
 	for i, ifName := range ifNames {
 		iface := getIfaceByNameFromIfaces(ifName, ifaces)
 		if iface == nil {
 			return 0, fmt.Errorf("no such interface '%s'\n", ifName)
 		}
 		ifs[i] = iface
 		nicIDs[i] = iface.Id
 	}

 	result, nicid, _ := a.netstack.BridgeInterfaces(context.Background(), nicIDs)
 	if result.Status != netstack.StatusOk {
 		return 0, fmt.Errorf("error bridging interfaces: %s, result: %s", ifNames, result)
 	}

 	return nicid, nil
 }

 func (a *netstackClientApp) setDHCP(iface netstack.NetInterface2, startStop string) error {
 	req, client, err := dhcp.NewClientWithCtxInterfaceRequest()
 	if err != nil {
 		return err
 	}

 	res, err := a.netstack.GetDhcpClient(context.Background(), iface.Id, req)
 	if err != nil {
 		return err
 	}

 	switch res.Which() {
 	case netstack.NetstackGetDhcpClientResultErr:
 		return fmt.Errorf("failed to get DHCP client controller for interface %d: %s", iface.Id, zx.Status(res.Err))
 	case netstack.NetstackGetDhcpClientResultResponse:
 	}

 	switch startStop {
 	case "start":
 		res, err := client.Start(context.Background())
 		if err != nil {
 			return fmt.Errorf("failed to start client: %w", err)
 		}
 		switch res.Which() {
 		case dhcp.ClientStartResultErr:
 			return &zx.Error{Text: "dhcp client.Start()", Status: zx.Status(res.Err)}
 		case dhcp.ClientStartResultResponse:
 		}
 	case "stop":
 		res, err := client.Stop(context.Background())
 		if err != nil {
 			return fmt.Errorf("failed to stop client: %w", err)
 		}
 		switch res.Which() {
 		case dhcp.ClientStopResultErr:
 			return &zx.Error{Text: "dhcp client.Stop()", Status: zx.Status(res.Err)}
 		case dhcp.ClientStopResultResponse:
 		}
 	default:
 		usage()
 	}

 	return nil
 }

 func hwAddrToString(hwaddr []uint8) string {
 	var b strings.Builder
 	for i, d := range hwaddr {
 		if i > 0 {
 			b.WriteByte(':')
 		}
 		fmt.Fprintf(&b, "%02x", d)
 	}
 	return b.String()
 }

 func netAddrToString(addr netfidl.IpAddress) string {
 	return fidlconv.ToTCPIPAddress(addr).String()
 }

 func toIpAddress(addr net.IP) netfidl.IpAddress {
 	// TODO(eyalsoha): this doesn't correctly handle IPv6-mapped IPv4 addresses.
 	if ipv4 := addr.To4(); ipv4 != nil {
 		addr = ipv4
 	}
 	return fidlconv.ToNetIpAddress(tcpip.Address(addr))
 }

 func validateCidr(cidr string) (address netfidl.IpAddress, prefixLength uint8) {
 	netAddr, netSubnet, err := net.ParseCIDR(cidr)
 	if err != nil {
 		fmt.Printf("Error parsing CIDR notation: %s, error: %v\n", cidr, err)
 		usage()
 	}
 	prefixLen, _ := netSubnet.Mask.Size()

 	return toIpAddress(netAddr), uint8(prefixLen)
 }

 // bytesToString returns a human-friendly display of the given byte count.
 // Values over 1K have an approximation appended in parentheses.
 // bytesToString(42) => "42"
 // bytesToString(42*1024 + 200) => "43208 (42.2 KB)"
 func bytesToString(bytes uint64) string {
 	if bytes == 0 {
 		return "0"
 	}

 	units := "BKMGT"
 	unitSize := uint64(1)
 	unit := "B"

 	for i := 0; i+1 < len(units) && bytes >= unitSize*1024; i++ {
 		unitSize *= 1024
 		unit = string(units[i+1]) + "B"
 	}

 	if unitSize == 1 {
 		return fmt.Sprintf("%d", bytes)
 	} else {
 		value := float32(bytes) / float32(unitSize)
 		return fmt.Sprintf("%d (%.1f %s)", bytes, value, unit)
 	}
 }

 func usage() {
 	fmt.Printf("Usage:\n")
 	fmt.Printf("  %s [<interface>]\n", os.Args[0])
 	fmt.Printf("  %s <interface> {up|down}\n", os.Args[0])
 	fmt.Printf("  %s <interface> {add|del} <address>/<mask>\n", os.Args[0])
 	fmt.Printf("  %s <interface> metric <metric>\n", os.Args[0])
 	fmt.Printf("  %s <interface> dhcp {start|stop}\n", os.Args[0])
 	fmt.Printf("  %s route {add|del} <address>/<mask> [iface <name>] [gateway <address>] [metric <metric>]\n", os.Args[0])
 	fmt.Printf("  %s route show\n", os.Args[0])
 	fmt.Printf("  %s bridge [<interface>]+\n", os.Args[0])
 	os.Exit(1)
 }

 func Main() {
 	a := &netstackClientApp{ctx: component.NewContextFromStartupInfo()}
 	req, pxy, err := netstack.NewNetstackWithCtxInterfaceRequest()
 	if err != nil {
 		panic(err.Error())
 	}
 	a.netstack = pxy
 	defer a.netstack.Close()
 	a.ctx.ConnectToEnvService(req)

 	if len(os.Args) == 1 {
 		a.printAll()
 		return
 	}

 	var iface *netstack.NetInterface2
 	switch os.Args[1] {
 	case "route":
 		if len(os.Args) == 2 || os.Args[2] == "show" {
 			err = a.showRoutes()
 			if err != nil {
 				fmt.Printf("Error showing routes: %s\n", err)
 			}
 			return
 		}
 		if len(os.Args) < 4 {
 			fmt.Printf("Not enough arguments to `ifconfig route`; at least a destination and one of iface name or gateway must be provided\n")
 			usage()
 		}
 		routeFlags := os.Args[3:]
 		r, err := a.newRouteFromArgs(routeFlags)
 		if err != nil {
 			fmt.Printf("Error parsing route from args: %s, error: %s\n", routeFlags, err)
 			usage()
 		}

 		op := os.Args[2]
 		switch op {
 		case "add":
 			if err = a.addRoute(r); err != nil {
 				fmt.Printf("Error adding route to route table: %s\n", err)
 				usage()
 			}
 		case "del":
 			err = a.deleteRoute(r)
 			if err != nil {
 				fmt.Printf("Error deleting route from route table: %s\n", err)
 				usage()
 			}
 		default:
 			fmt.Printf("Unknown route operation: %s\n", op)
 			usage()
 		}

 		return
 	case "bridge":
 		ifaces := os.Args[2:]
 		nicid, err := a.bridge(ifaces)
 		if err != nil {
 			fmt.Printf("error creating bridge: %s\n", err)
 		} else {
 			interfaces, _ := a.netstack.GetInterfaces2(context.Background())
 			bridge := getIfaceByIdFromIfaces(uint32(nicid), interfaces)
 			fmt.Printf("Bridged interfaces %s.\nInterface '%s' created.\nPlease run `ifconfig %[2]s up` to enable it.\n", ifaces, bridge.Name)
 		}
 		return
 	case "help":
 		usage()
 		return
 	default:
 		ifaces, err := a.netstack.GetInterfaces2(context.Background())
 		if err != nil {
 			fmt.Printf("Error finding interface name: %s\n", err)
 			return
 		}
 		iface = getIfaceByNameFromIfaces(os.Args[1], ifaces)
 		if err != nil {
 			fmt.Printf("Error finding interface name: %s\n", err)
 			return
 		}
 		if iface == nil {
 			fmt.Printf("ifconfig: no such interface '%s'\n", os.Args[1])
 			return
 		}
 	}

 	switch len(os.Args) {
 	case 2:
 		a.printIface(*iface)
 	case 3:
 		switch os.Args[2] {
 		case "up":
 			a.setStatus(*iface, true)
 		case "down":
 			a.setStatus(*iface, false)
 		default:
 			usage()
 		}
 	case 4:
 		switch os.Args[2] {
 		case "add":
 			a.addIfaceAddress(*iface, os.Args[3])
 		case "del":
 			a.removeIfaceAddress(*iface, os.Args[3])
 		case "dhcp":
 			if err := a.setDHCP(*iface, os.Args[3]); err != nil {
 				fmt.Printf("ifconfig: a.setDHCP(%+v, %s) failed: %s", *iface, os.Args[3], err)
 			}
 		case "metric":
 			metric, err := strconv.ParseUint(os.Args[3], 10, 32)
 			if err != nil {
 				fmt.Printf("ifconfig: metric value '%s' is not uint32: %s\n", os.Args[3], err)
 				return
 			}
 			a.netstack.SetInterfaceMetric(context.Background(), iface.Id, uint32(metric))
 		default:
 			usage()
 		}

 	default:
 		usage()
 	}
 }
	// Copyright 2017 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// +build !build_with_native_toolchain

	package ifconfig

	import (
	"context"
	"fmt"
	"net"
	"os"
	"strconv"
	"strings"
	"syscall/zx"

	"go.fuchsia.dev/fuchsia/src/connectivity/network/netstack/fidlconv"
	"go.fuchsia.dev/fuchsia/src/lib/component"

	netfidl "fidl/fuchsia/net"
	"fidl/fuchsia/net/dhcp"
	"fidl/fuchsia/netstack"

	"gvisor.dev/gvisor/pkg/tcpip"
	)

	type netstackClientApp struct {
	ctx *component.Context
	netstack *netstack.NetstackWithCtxInterface
	}

	func (a *netstackClientApp) printAll() {
	ifaces, err := a.netstack.GetInterfaces2(context.Background())
	if err != nil {
	fmt.Print("ifconfig: failed to fetch interfaces\n")
	return
	}

	for _, iface := range ifaces {
	a.printIface(iface)
	}
	}

	func getIfaceByNameFromIfaces(name string, ifaces []netstack.NetInterface2) *netstack.NetInterface2 {
	var candidate *netstack.NetInterface2
	for i, iface := range ifaces {
	if strings.HasPrefix(iface.Name, name) {
	if candidate != nil {
	return nil
	}
	candidate = &ifaces[i]
	}
	}
	return candidate
	}

	func getIfaceByIdFromIfaces(id uint32, ifaces []netstack.NetInterface2) *netstack.NetInterface2 {
	for _, iface := range ifaces {
	if iface.Id == id {
	return &iface
	}
	}
	return nil
	}

	func (a *netstackClientApp) printIface(iface netstack.NetInterface2) {
	fmt.Printf("%s\tHWaddr %s Id:%d\n", iface.Name, hwAddrToString(iface.Hwaddr), iface.Id)
	fmt.Printf("\tinet addr:%s Bcast:%s Mask:%s\n", netAddrToString(iface.Addr), netAddrToString(iface.Broadaddr), netAddrToString(iface.Netmask))
	for _, addr := range iface.Ipv6addrs {
	// TODO: scopes
	fmt.Printf("\tinet6 addr: %s/%d Scope:Link\n", netAddrToString(addr.Addr), addr.PrefixLen)
	}
	fmt.Printf("\tmetric:%d\n", iface.Metric)
	fmt.Printf("\t%s\n", iface.Flags)
	}

	func (a *netstackClientApp) setStatus(iface netstack.NetInterface2, up bool) {
	a.netstack.SetInterfaceStatus(context.Background(), iface.Id, up)
	}

	func (a *netstackClientApp) addIfaceAddress(iface netstack.NetInterface2, cidr string) {
	netAddr, prefixLen := validateCidr(os.Args[3])
	result, _ := a.netstack.SetInterfaceAddress(context.Background(), iface.Id, netAddr, prefixLen)
	if result.Status != netstack.StatusOk {
	fmt.Printf("Error setting interface address: %s\n", result.Message)
	}
	}

	func (a *netstackClientApp) removeIfaceAddress(iface netstack.NetInterface2, cidr string) {
	netAddr, prefixLen := validateCidr(os.Args[3])
	result, _ := a.netstack.RemoveInterfaceAddress(context.Background(), iface.Id, netAddr, prefixLen)
	if result.Status != netstack.StatusOk {
	fmt.Printf("Error setting interface address: %s\n", result.Message)
	}
	}

	func (a netstackClientApp) parseRouteAttribute(in netstack.RouteTableEntry2, args []string) (remaining []string, err error) {
	if len(args) < 2 {
	return args, fmt.Errorf("not enough args to make attribute")
	}
	var attr, val string
	switch attr, val, remaining = args[0], args[1], args[2:]; attr {
	case "gateway":
	gateway := toIpAddress(net.ParseIP(val))
	in.Gateway = &gateway
	case "metric":
	m, err := strconv.ParseUint(val, 10, 32)
	if err != nil {
	return remaining, fmt.Errorf("metric value '%s' is not uint32: %s", val, err)
	}
	in.Metric = uint32(m)
	case "iface":
	ifaces, err := a.netstack.GetInterfaces2(context.Background())
	if err != nil {
	return remaining, err
	}
	iface := getIfaceByNameFromIfaces(val, ifaces)
	if err != nil {
	return remaining, err
	}
	if iface == nil {
	return remaining, fmt.Errorf("no such interface '%s'\n", val)
	}

	in.Nicid = iface.Id
	default:
	return remaining, fmt.Errorf("unknown route attribute: %s %s", attr, val)
	}

	return remaining, nil
	}

	func (a *netstackClientApp) newRouteFromArgs(args []string) (route netstack.RouteTableEntry2, err error) {
	destination, remaining := args[0], args[1:]
	_, dstSubnet, err := net.ParseCIDR(destination)
	if err != nil {
	return route, fmt.Errorf("invalid destination (destination must be provided in CIDR format): %s", destination)
	}

	route.Destination = toIpAddress(dstSubnet.IP)
	route.Netmask = toIpAddress(net.IP(dstSubnet.Mask))

	for len(remaining) > 0 {
	remaining, err = a.parseRouteAttribute(&route, remaining)
	if err != nil {
	return route, err
	}
	}

	if len(remaining) != 0 {
	return route, fmt.Errorf("could not parse all route arguments. remaining: %s", remaining)
	}

	return route, nil
	}

	func (a *netstackClientApp) addRoute(r netstack.RouteTableEntry2) error {
	if r.Gateway == nil && r.Nicid == 0 {
	return fmt.Errorf("either gateway or iface must be provided when adding a route")
	}

	req, transactionInterface, err := netstack.NewRouteTableTransactionWithCtxInterfaceRequest()
	if err != nil {
	return fmt.Errorf("could not make a new route table transaction: %s", err)
	}
	defer req.Close()
	status, err := a.netstack.StartRouteTableTransaction(context.Background(), req)
	if err != nil \|\| zx.Status(status) != zx.ErrOk {
	return fmt.Errorf("could not start a route table transaction: %s (%s)", err, zx.Status(status))
	}

	status, err = transactionInterface.AddRoute(context.Background(), r)
	if err != nil {
	return fmt.Errorf("could not add route due to transaction interface error: %s", err)
	}
	if zx.Status(status) != zx.ErrOk {
	return fmt.Errorf("could not add route in netstack: %s", zx.Status(status))
	}
	return nil
	}

	func (a *netstackClientApp) deleteRoute(r netstack.RouteTableEntry2) error {
	req, transactionInterface, err := netstack.NewRouteTableTransactionWithCtxInterfaceRequest()
	if err != nil {
	return fmt.Errorf("could not make a new route table transaction: %s", err)
	}
	defer req.Close()
	status, err := a.netstack.StartRouteTableTransaction(context.Background(), req)
	if err != nil \|\| zx.Status(status) != zx.ErrOk {
	return fmt.Errorf("could not start a route table transaction (maybe the route table is locked?): %s", err)
	}

	status, err = transactionInterface.DelRoute(context.Background(), r)
	if err != nil {
	return fmt.Errorf("could not delete route due to transaction interface error: %s", err)
	}
	if zx.Status(status) != zx.ErrOk {
	return fmt.Errorf("could not delete route in netstack: %s", zx.Status(status))
	}
	return nil
	}

	func routeTableEntryToString(r netstack.RouteTableEntry2, ifaces []netstack.NetInterface2) string {
	iface := getIfaceByIdFromIfaces(r.Nicid, ifaces)
	var ifaceName string
	if iface == nil {
	ifaceName = fmt.Sprintf("Nicid:%d", r.Nicid)
	} else {
	ifaceName = iface.Name
	}
	var netAndMask net.IPNet
	switch r.Destination.Which() {
	case netfidl.IpAddressIpv4:
	netAndMask = net.IPNet{IP: r.Destination.Ipv4.Addr[:], Mask: r.Netmask.Ipv4.Addr[:]}
	case netfidl.IpAddressIpv6:
	netAndMask = net.IPNet{IP: r.Destination.Ipv6.Addr[:], Mask: r.Netmask.Ipv6.Addr[:]}
	}
	if r.Gateway != nil {
	return fmt.Sprintf("%s via %s %s metric %v", netAndMask.String(), netAddrToString(*r.Gateway), ifaceName, r.Metric)
	}
	return fmt.Sprintf("%s via %s metric %v", netAndMask.String(), ifaceName, r.Metric)
	}

	func (a *netstackClientApp) showRoutes() error {
	rs, err := a.netstack.GetRouteTable2(context.Background())
	if err != nil {
	return fmt.Errorf("Could not get route table from netstack: %s", err)
	}
	ifaces, err := a.netstack.GetInterfaces2(context.Background())
	if err != nil {
	return err
	}
	for _, r := range rs {
	fmt.Printf("%s\n", routeTableEntryToString(r, ifaces))
	}
	return nil
	}

	func (a *netstackClientApp) bridge(ifNames []string) (uint32, error) {
	ifs := make([]*netstack.NetInterface2, len(ifNames))
	nicIDs := make([]uint32, len(ifNames))
	// first, validate that all interfaces exist
	ifaces, err := a.netstack.GetInterfaces2(context.Background())
	if err != nil {
	return 0, err
	}
	for i, ifName := range ifNames {
	iface := getIfaceByNameFromIfaces(ifName, ifaces)
	if iface == nil {
	return 0, fmt.Errorf("no such interface '%s'\n", ifName)
	}
	ifs[i] = iface
	nicIDs[i] = iface.Id
	}

	result, nicid, _ := a.netstack.BridgeInterfaces(context.Background(), nicIDs)
	if result.Status != netstack.StatusOk {
	return 0, fmt.Errorf("error bridging interfaces: %s, result: %s", ifNames, result)
	}

	return nicid, nil
	}

	func (a *netstackClientApp) setDHCP(iface netstack.NetInterface2, startStop string) error {
	req, client, err := dhcp.NewClientWithCtxInterfaceRequest()
	if err != nil {
	return err
	}

	res, err := a.netstack.GetDhcpClient(context.Background(), iface.Id, req)
	if err != nil {
	return err
	}

	switch res.Which() {
	case netstack.NetstackGetDhcpClientResultErr:
	return fmt.Errorf("failed to get DHCP client controller for interface %d: %s", iface.Id, zx.Status(res.Err))
	case netstack.NetstackGetDhcpClientResultResponse:
	}

	switch startStop {
	case "start":
	res, err := client.Start(context.Background())
	if err != nil {
	return fmt.Errorf("failed to start client: %w", err)
	}
	switch res.Which() {
	case dhcp.ClientStartResultErr:
	return &zx.Error{Text: "dhcp client.Start()", Status: zx.Status(res.Err)}
	case dhcp.ClientStartResultResponse:
	}
	case "stop":
	res, err := client.Stop(context.Background())
	if err != nil {
	return fmt.Errorf("failed to stop client: %w", err)
	}
	switch res.Which() {
	case dhcp.ClientStopResultErr:
	return &zx.Error{Text: "dhcp client.Stop()", Status: zx.Status(res.Err)}
	case dhcp.ClientStopResultResponse:
	}
	default:
	usage()
	}

	return nil
	}

	func hwAddrToString(hwaddr []uint8) string {
	var b strings.Builder
	for i, d := range hwaddr {
	if i > 0 {
	b.WriteByte(':')
	}
	fmt.Fprintf(&b, "%02x", d)
	}
	return b.String()
	}

	func netAddrToString(addr netfidl.IpAddress) string {
	return fidlconv.ToTCPIPAddress(addr).String()
	}

	func toIpAddress(addr net.IP) netfidl.IpAddress {
	// TODO(eyalsoha): this doesn't correctly handle IPv6-mapped IPv4 addresses.
	if ipv4 := addr.To4(); ipv4 != nil {
	addr = ipv4
	}
	return fidlconv.ToNetIpAddress(tcpip.Address(addr))
	}

	func validateCidr(cidr string) (address netfidl.IpAddress, prefixLength uint8) {
	netAddr, netSubnet, err := net.ParseCIDR(cidr)
	if err != nil {
	fmt.Printf("Error parsing CIDR notation: %s, error: %v\n", cidr, err)
	usage()
	}
	prefixLen, _ := netSubnet.Mask.Size()

	return toIpAddress(netAddr), uint8(prefixLen)
	}

	// bytesToString returns a human-friendly display of the given byte count.
	// Values over 1K have an approximation appended in parentheses.
	// bytesToString(42) => "42"
	// bytesToString(42*1024 + 200) => "43208 (42.2 KB)"
	func bytesToString(bytes uint64) string {
	if bytes == 0 {
	return "0"
	}

	units := "BKMGT"
	unitSize := uint64(1)
	unit := "B"

	for i := 0; i+1 < len(units) && bytes >= unitSize*1024; i++ {
	unitSize *= 1024
	unit = string(units[i+1]) + "B"
	}

	if unitSize == 1 {
	return fmt.Sprintf("%d", bytes)
	} else {
	value := float32(bytes) / float32(unitSize)
	return fmt.Sprintf("%d (%.1f %s)", bytes, value, unit)
	}
	}

	func usage() {
	fmt.Printf("Usage:\n")
	fmt.Printf(" %s [<interface>]\n", os.Args[0])
	fmt.Printf(" %s <interface> {up\|down}\n", os.Args[0])
	fmt.Printf(" %s <interface> {add\|del} <address>/<mask>\n", os.Args[0])
	fmt.Printf(" %s <interface> metric <metric>\n", os.Args[0])
	fmt.Printf(" %s <interface> dhcp {start\|stop}\n", os.Args[0])
	fmt.Printf(" %s route {add\|del} <address>/<mask> [iface <name>] [gateway <address>] [metric <metric>]\n", os.Args[0])
	fmt.Printf(" %s route show\n", os.Args[0])
	fmt.Printf(" %s bridge [<interface>]+\n", os.Args[0])
	os.Exit(1)
	}

	func Main() {
	a := &netstackClientApp{ctx: component.NewContextFromStartupInfo()}
	req, pxy, err := netstack.NewNetstackWithCtxInterfaceRequest()
	if err != nil {
	panic(err.Error())
	}
	a.netstack = pxy
	defer a.netstack.Close()
	a.ctx.ConnectToEnvService(req)

	if len(os.Args) == 1 {
	a.printAll()
	return
	}

	var iface *netstack.NetInterface2
	switch os.Args[1] {
	case "route":
	if len(os.Args) == 2 \|\| os.Args[2] == "show" {
	err = a.showRoutes()
	if err != nil {
	fmt.Printf("Error showing routes: %s\n", err)
	}
	return
	}
	if len(os.Args) < 4 {
	fmt.Printf("Not enough arguments to `ifconfig route`; at least a destination and one of iface name or gateway must be provided\n")
	usage()
	}
	routeFlags := os.Args[3:]
	r, err := a.newRouteFromArgs(routeFlags)
	if err != nil {
	fmt.Printf("Error parsing route from args: %s, error: %s\n", routeFlags, err)
	usage()
	}

	op := os.Args[2]
	switch op {
	case "add":
	if err = a.addRoute(r); err != nil {
	fmt.Printf("Error adding route to route table: %s\n", err)
	usage()
	}
	case "del":
	err = a.deleteRoute(r)
	if err != nil {
	fmt.Printf("Error deleting route from route table: %s\n", err)
	usage()
	}
	default:
	fmt.Printf("Unknown route operation: %s\n", op)
	usage()
	}

	return
	case "bridge":
	ifaces := os.Args[2:]
	nicid, err := a.bridge(ifaces)
	if err != nil {
	fmt.Printf("error creating bridge: %s\n", err)
	} else {
	interfaces, _ := a.netstack.GetInterfaces2(context.Background())
	bridge := getIfaceByIdFromIfaces(uint32(nicid), interfaces)
	fmt.Printf("Bridged interfaces %s.\nInterface '%s' created.\nPlease run `ifconfig %[2]s up` to enable it.\n", ifaces, bridge.Name)
	}
	return
	case "help":
	usage()
	return
	default:
	ifaces, err := a.netstack.GetInterfaces2(context.Background())
	if err != nil {
	fmt.Printf("Error finding interface name: %s\n", err)
	return
	}
	iface = getIfaceByNameFromIfaces(os.Args[1], ifaces)
	if err != nil {
	fmt.Printf("Error finding interface name: %s\n", err)
	return
	}
	if iface == nil {
	fmt.Printf("ifconfig: no such interface '%s'\n", os.Args[1])
	return
	}
	}

	switch len(os.Args) {
	case 2:
	a.printIface(*iface)
	case 3:
	switch os.Args[2] {
	case "up":
	a.setStatus(*iface, true)
	case "down":
	a.setStatus(*iface, false)
	default:
	usage()
	}
	case 4:
	switch os.Args[2] {
	case "add":
	a.addIfaceAddress(*iface, os.Args[3])
	case "del":
	a.removeIfaceAddress(*iface, os.Args[3])
	case "dhcp":
	if err := a.setDHCP(*iface, os.Args[3]); err != nil {
	fmt.Printf("ifconfig: a.setDHCP(%+v, %s) failed: %s", *iface, os.Args[3], err)
	}
	case "metric":
	metric, err := strconv.ParseUint(os.Args[3], 10, 32)
	if err != nil {
	fmt.Printf("ifconfig: metric value '%s' is not uint32: %s\n", os.Args[3], err)
	return
	}
	a.netstack.SetInterfaceMetric(context.Background(), iface.Id, uint32(metric))
	default:
	usage()
	}

	default:
	usage()
	}
	}