tc

tcIface := "ExampleFlower"

rtnl, err := setupDummyInterface(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not setup dummy interface: %v\n", err)
	return
}
defer rtnl.Close()

devID, err := net.InterfaceByName(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get interface ID: %v\n", err)
	return
}
defer func(devID uint32, rtnl *rtnetlink.Conn) {
	if err := rtnl.Link.Delete(devID); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete interface: %v\n", err)
	}
}(uint32(devID.Index), rtnl)

tcnl, err := tc.Open(&tc.Config{})
if err != nil {
	fmt.Fprintf(os.Stderr, "could not open rtnetlink socket: %v\n", err)
	return
}
defer func() {
	if err := tcnl.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "could not close rtnetlink socket: %v\n", err)
	}
}()

qdisc := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  core.BuildHandle(tc.HandleRoot, 0),
		Parent:  tc.HandleIngress,
		Info:    0,
	},
	tc.Attribute{
		Kind: "clsact",
	},
}

if err := tcnl.Qdisc().Add(&qdisc); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign clsact to lo: %v\n", err)
	return
}

defer func() {
	if err := tcnl.Qdisc().Delete(&qdisc); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete qdisc from iface (%d): %v\n", devID.Index, err)
		return
	}
}()

srcMac, _ := net.ParseMAC("00:00:5e:00:53:01")
actions := []*tc.Action{
	{
		Kind: "gact",
		Gact: &tc.Gact{
			Parms: &tc.GactParms{
				Action: 2, // action drop
			},
		},
	},
}

filter := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  0,
		Parent:  tc.HandleIngress + 1,
		Info:    768,
	},
	tc.Attribute{
		Kind: "flower",
		Flower: &tc.Flower{
			KeyEthSrc: &srcMac,
			Actions:   &actions,
		},
	},
}

// tc filter add dev ExampleFlower ingress protocol all prio 1 \
// flower src_mac 00:00:5e:00:53:01 \
// action gact drop
if err := tcnl.Filter().Add(&filter); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign flower filter to iface (%d): %v\n", devID.Index, err)
	return
}

tcIface := "ExampleFQCodel"

rtnl, err := setupDummyInterface(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not setup dummy interface: %v\n", err)
	return
}
defer rtnl.Close()

devID, err := net.InterfaceByName(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get interface ID: %v\n", err)
	return
}
defer func(devID uint32, rtnl *rtnetlink.Conn) {
	if err := rtnl.Link.Delete(devID); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete interface: %v\n", err)
	}
}(uint32(devID.Index), rtnl)

tcnl, err := tc.Open(&tc.Config{})
if err != nil {
	fmt.Fprintf(os.Stderr, "could not open rtnetlink socket: %v\n", err)
	return
}
defer func() {
	if err := tcnl.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "could not close rtnetlink socket: %v\n", err)
	}
}()

target := uint32(0xbb8)
limit := uint32(0x7d0)
interval := uint32(0x9c40)
ecn := uint32(0x0)

qdisc := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  core.BuildHandle(0x1, 0x0),
		Parent:  tc.HandleRoot,
		Info:    0,
	},
	tc.Attribute{
		Kind: "fq_codel",
		// http://man7.org/linux/man-pages/man8/tc-fq_codel.8.html
		// fq_codel limit 2000 target 3ms interval 40ms noecn
		FqCodel: &tc.FqCodel{
			Target:   &target,
			Limit:    &limit,
			Interval: &interval,
			ECN:      &ecn,
		},
	},
}

if err := tcnl.Qdisc().Add(&qdisc); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign htb to lo: %v\n", err)
	return
}
defer func() {
	if err := tcnl.Qdisc().Delete(&qdisc); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete htb qdisc of lo: %v\n", err)
		return
	}
}()
qdiscs, err := tcnl.Qdisc().Get()
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get all qdiscs: %v\n", err)
}

for _, qdisc := range qdiscs {
	iface, err := net.InterfaceByIndex(int(qdisc.Ifindex))
	if err != nil {
		fmt.Fprintf(os.Stderr, "could not get interface from id %d: %v", qdisc.Ifindex, err)
		return
	}
	fmt.Printf("%20s\t%s\n", iface.Name, qdisc.Kind)
}

//go:build linux
// +build linux

package main

import (
	"fmt"
	"net"
	"os"

	"github.com/jsimonetti/rtnetlink"
	"github.com/xcxinng/go-tc"
	"github.com/xcxinng/go-tc/core"
	"golang.org/x/sys/unix"
)

// setupDummyInterface installs a temporary dummy interface
func setupDummyInterface(iface string) (*rtnetlink.Conn, error) {
	con, err := rtnetlink.Dial(nil)
	if err != nil {
		return &rtnetlink.Conn{}, err
	}

	if err := con.Link.New(&rtnetlink.LinkMessage{
		Family: unix.AF_UNSPEC,
		Type:   unix.ARPHRD_NETROM,
		Index:  0,
		Flags:  unix.IFF_UP,
		Change: unix.IFF_UP,
		Attributes: &rtnetlink.LinkAttributes{
			Name: iface,
			Info: &rtnetlink.LinkInfo{Kind: "dummy"},
		},
	}); err != nil {
		return con, err
	}

	return con, err
}

func addHfscClass(class *tc.Class, devID, maj, min uint32, serviceCurve *tc.ServiceCurve) (*tc.Object, error) {
	hfsc := tc.Object{
		tc.Msg{
			Family:  unix.AF_UNSPEC,
			Ifindex: devID,
			Handle:  core.BuildHandle(maj, min),
			Parent:  0x10000,
			Info:    0,
		},
		tc.Attribute{
			Kind: "hfsc",
			Hfsc: &tc.Hfsc{
				Rsc: serviceCurve,
				Fsc: serviceCurve,
				Usc: serviceCurve,
			},
		},
	}

	if err := class.Add(&hfsc); err != nil {
		fmt.Fprintf(os.Stderr, "could not assign hfsc class: %v\n", err)
		return nil, err
	}
	return &hfsc, nil
}

func main() {
	var rtnl *rtnetlink.Conn
	var err error

	tcIface := "tcDev"

	if rtnl, err = setupDummyInterface(tcIface); err != nil {
		fmt.Fprintf(os.Stderr, "could not setup dummy interface: %v\n", err)
		return
	}
	defer rtnl.Close()

	devID, err := net.InterfaceByName(tcIface)
	if err != nil {
		fmt.Fprintf(os.Stderr, "could not get interface ID: %v\n", err)
		return
	}
	defer func(devID uint32, rtnl *rtnetlink.Conn) {
		if err := rtnl.Link.Delete(devID); err != nil {
			fmt.Fprintf(os.Stderr, "could not delete interface: %v\n", err)
		}
	}(uint32(devID.Index), rtnl)

	tcnl, err := tc.Open(&tc.Config{})
	if err != nil {
		fmt.Fprintf(os.Stderr, "could not open rtnetlink socket: %v\n", err)
		return
	}
	defer func() {
		if err := tcnl.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "could not close rtnetlink socket: %v\n", err)
		}
	}()

	qdisc := tc.Object{
		tc.Msg{
			Family:  unix.AF_UNSPEC,
			Ifindex: uint32(devID.Index),
			Handle:  0x10000,
			Parent:  tc.HandleRoot,
			Info:    0,
		},
		// tc qdisc add dev tcDev stab linklayer ethernet mtu 1500 root handle 1: hfsc default 3
		// http://man7.org/linux/man-pages/man8/tc-stab.8.html
		tc.Attribute{
			Kind: "hfsc",
			HfscQOpt: &tc.HfscQOpt{
				DefCls: 3,
			},
			Stab: &tc.Stab{
				Base: &tc.SizeSpec{
					CellLog:   0,
					SizeLog:   0,
					CellAlign: 0,
					Overhead:  0,
					LinkLayer: 1,
					MPU:       0,
					MTU:       1500,
					TSize:     0,
				},
			},
		},
	}

	if err := tcnl.Qdisc().Add(&qdisc); err != nil {
		fmt.Fprintf(os.Stderr, "could not assign hfsc to %s: %v\n", tcIface, err)
		return
	}
	defer func() {
		if err := tcnl.Qdisc().Delete(&qdisc); err != nil {
			fmt.Fprintf(os.Stderr, "could not delete htb qdisc of %s: %v\n", tcIface, err)
			return
		}
	}()

	class1, err := addHfscClass(tcnl.Class(), uint32(devID.Index), 0x10000, 0x1, &tc.ServiceCurve{M2: 0x1e848})
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to add hfsc: %v\n", err)
		return
	}
	defer func() {
		if err := tcnl.Class().Delete(class1); err != nil {
			fmt.Fprintf(os.Stderr, "could not delete hfsc class of %s: %v\n", tcIface, err)
			return
		}
	}()

	class2, err := addHfscClass(tcnl.Class(), uint32(devID.Index), 0x10000, 0x2, &tc.ServiceCurve{M2: 0x1e848})
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to add hfsc: %v\n", err)
		return
	}
	defer func() {
		if err := tcnl.Class().Delete(class2); err != nil {
			fmt.Fprintf(os.Stderr, "could not delete hfsc class of %s: %v\n", tcIface, err)
			return
		}
	}()

	class3, err := addHfscClass(tcnl.Class(), uint32(devID.Index), 0x10000, 0x3, &tc.ServiceCurve{M2: 0x1e848})
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to add hfsc: %v\n", err)
		return
	}
	defer func() {
		if err := tcnl.Class().Delete(class3); err != nil {
			fmt.Fprintf(os.Stderr, "could not delete hfsc class of %s: %v\n", tcIface, err)
			return
		}
	}()

	classes, err := tcnl.Class().Get(&tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index)})
	if err != nil {
		fmt.Fprintf(os.Stderr, "could not get all classes: %v\n", err)
	}

	for _, class := range classes {
		iface, err := net.InterfaceByIndex(int(qdisc.Ifindex))
		if err != nil {
			fmt.Fprintf(os.Stderr, "could not get interface from id %d: %v", qdisc.Ifindex, err)
			return
		}
		fmt.Printf("%20s\t%s\n", iface.Name, class.Kind)
	}
}

Output:

tcIface := "ExampleHtb"

rtnl, err := setupDummyInterface(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not setup dummy interface: %v\n", err)
	return
}
defer rtnl.Close()

devID, err := net.InterfaceByName(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get interface ID: %v\n", err)
	return
}
defer func(devID uint32, rtnl *rtnetlink.Conn) {
	if err := rtnl.Link.Delete(devID); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete interface: %v\n", err)
	}
}(uint32(devID.Index), rtnl)

tcnl, err := tc.Open(&tc.Config{})
if err != nil {
	fmt.Fprintf(os.Stderr, "could not open rtnetlink socket: %v\n", err)
	return
}
defer func() {
	if err := tcnl.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "could not close rtnetlink socket: %v\n", err)
	}
}()

qdisc := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  core.BuildHandle(0x1, 0x0),
		Parent:  tc.HandleRoot,
		Info:    0,
	},
	// configure a very basic hierarchy token bucket (htb) qdisc
	tc.Attribute{
		Kind: "htb",
		Htb: &tc.Htb{
			Init: &tc.HtbGlob{
				Version:      0x3,
				Rate2Quantum: 0xa,
			},
		},
	},
}

if err := tcnl.Qdisc().Add(&qdisc); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign htb to lo: %v\n", err)
	return
}
// delete the qdisc, if this program terminates
defer func() {
	if err := tcnl.Qdisc().Delete(&qdisc); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete htb qdisc of lo: %v\n", err)
		return
	}
}()
qdiscs, err := tcnl.Qdisc().Get()
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get all qdiscs: %v\n", err)
}

for _, qdisc := range qdiscs {
	iface, err := net.InterfaceByIndex(int(qdisc.Ifindex))
	if err != nil {
		fmt.Fprintf(os.Stderr, "could not get interface from id %d: %v", qdisc.Ifindex, err)
		return
	}
	fmt.Printf("%20s\t%s\n", iface.Name, qdisc.Kind)
}

tcIface := "ExampleNetem"

rtnl, err := setupDummyInterface(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not setup dummy interface: %v\n", err)
	return
}
defer rtnl.Close()

devID, err := net.InterfaceByName(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get interface ID: %v\n", err)
	return
}
defer func(devID uint32, rtnl *rtnetlink.Conn) {
	if err := rtnl.Link.Delete(devID); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete interface: %v\n", err)
	}
}(uint32(devID.Index), rtnl)

tcnl, err := tc.Open(&tc.Config{})
if err != nil {
	fmt.Fprintf(os.Stderr, "could not open rtnetlink socket: %v\n", err)
	return
}
defer func() {
	if err := tcnl.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "could not close rtnetlink socket: %v\n", err)
	}
}()

var ecn uint32 = 1
qdisc := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  core.BuildHandle(0x1, 0x0),
		Parent:  tc.HandleRoot,
		Info:    0,
	},
	tc.Attribute{
		Kind: "netem",
		// tc qdisc replace dev tcDev root netem loss 1% ecn
		Netem: &tc.Netem{
			Qopt: tc.NetemQopt{
				Limit: 1000,
				Loss:  42949673},
			Ecn: &ecn,
		},
	},
}

if err := tcnl.Qdisc().Replace(&qdisc); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign qdisc netem to lo: %v\n", err)
	return
}
defer func() {
	if err := tcnl.Qdisc().Delete(&qdisc); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete netem qdisc of lo: %v\n", err)
		return
	}
}()
qdiscs, err := tcnl.Qdisc().Get()
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get all qdiscs: %v\n", err)
}

for _, qdisc := range qdiscs {
	iface, err := net.InterfaceByIndex(int(qdisc.Ifindex))
	if err != nil {
		fmt.Fprintf(os.Stderr, "could not get interface from id %d: %v", qdisc.Ifindex, err)
		return
	}
	fmt.Printf("%20s\t%s\n", iface.Name, qdisc.Kind)
}

This example demonstraces how to add a qdisc to an interface and delete it again

tcIface := "ExampleQdisc"

rtnl, err := setupDummyInterface(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not setup dummy interface: %v\n", err)
	return
}
defer rtnl.Close()

devID, err := net.InterfaceByName(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get interface ID: %v\n", err)
	return
}
defer func(devID uint32, rtnl *rtnetlink.Conn) {
	if err := rtnl.Link.Delete(devID); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete interface: %v\n", err)
	}
}(uint32(devID.Index), rtnl)

// open a rtnetlink socket
tcnl, err := tc.Open(&tc.Config{})
if err != nil {
	fmt.Fprintf(os.Stderr, "could not open rtnetlink socket: %v\n", err)
	return
}
defer func() {
	if err := rtnl.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "could not close rtnetlink socket: %v\n", err)
	}
}()

qdisc := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  core.BuildHandle(0xFFFF, 0x0000),
		Parent:  0xFFFFFFF1,
		Info:    0,
	},
	tc.Attribute{
		Kind: "clsact",
	},
}

if err := tcnl.Qdisc().Add(&qdisc); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign clsact to lo: %v\n", err)
	return
}
if err := tcnl.Qdisc().Delete(&qdisc); err != nil {
	fmt.Fprintf(os.Stderr, "could not delete clsact qdisc from lo: %v\n", err)
	return
}

tcIface := "tcExampleTbf"

rtnl, err := setupDummyInterface(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not setup dummy interface: %v\n", err)
	return
}
defer rtnl.Close()

devID, err := net.InterfaceByName(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get interface ID: %v\n", err)
	return
}
defer func(devID uint32, rtnl *rtnetlink.Conn) {
	if err := rtnl.Link.Delete(devID); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete interface: %v\n", err)
	}
}(uint32(devID.Index), rtnl)

tcnl, err := tc.Open(&tc.Config{})
if err != nil {
	fmt.Fprintf(os.Stderr, "could not open rtnetlink socket: %v\n", err)
	return
}
defer func() {
	if err := tcnl.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "could not close rtnetlink socket: %v\n", err)
	}
}()

linklayerEthernet := uint8(1)
burst := uint32(0x500000)

qdisc := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  core.BuildHandle(tc.HandleRoot, 0x0),
		Parent:  tc.HandleRoot,
		Info:    0,
	},

	tc.Attribute{
		Kind: "tbf",
		Tbf: &tc.Tbf{
			Parms: &tc.TbfQopt{
				Mtu:   1514,
				Limit: 0x5000,
				Rate: tc.RateSpec{
					Rate:      0x7d00,
					Linklayer: linklayerEthernet,
					CellLog:   0x3,
				},
			},
			Burst: &burst,
		},
	},
}

// tc qdisc add dev tcExampleTbf root tbf burst 20480 limit 20480 mtu 1514 rate 32000bps
if err := tcnl.Qdisc().Add(&qdisc); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign tbf to %s: %v\n", tcIface, err)
	return
}
defer func() {
	if err := tcnl.Qdisc().Delete(&qdisc); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete tbf qdisc of %s: %v\n", tcIface, err)
		return
	}
}()

qdiscs, err := tcnl.Qdisc().Get()
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get all qdiscs: %v\n", err)
	//return
}

fmt.Println("## qdiscs:")
for _, qdisc := range qdiscs {

	iface, err := net.InterfaceByIndex(int(qdisc.Ifindex))
	if err != nil {
		fmt.Fprintf(os.Stderr, "could not get interface from id %d: %v", qdisc.Ifindex, err)
		return
	}
	fmt.Printf("%20s\t%-11s\n", iface.Name, qdisc.Kind)
}

// example from http://man7.org/linux/man-pages/man8/tc-police.8.html
tcIface := "ExampleU32"

rtnl, err := setupDummyInterface(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not setup dummy interface: %v\n", err)
	return
}
defer rtnl.Close()

devID, err := net.InterfaceByName(tcIface)
if err != nil {
	fmt.Fprintf(os.Stderr, "could not get interface ID: %v\n", err)
	return
}
defer func(devID uint32, rtnl *rtnetlink.Conn) {
	if err := rtnl.Link.Delete(devID); err != nil {
		fmt.Fprintf(os.Stderr, "could not delete interface: %v\n", err)
	}
}(uint32(devID.Index), rtnl)

tcnl, err := tc.Open(&tc.Config{})
if err != nil {
	fmt.Fprintf(os.Stderr, "could not open rtnetlink socket: %v\n", err)
	return
}
defer func() {
	if err := tcnl.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "could not close rtnetlink socket: %v\n", err)
	}
}()

qdisc := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  0,
		Parent:  0xFFFF0000,
		Info:    768,
	},
	tc.Attribute{
		Kind: "u32",
		U32: &tc.U32{
			Sel: &tc.U32Sel{
				Flags: 0x1,
				NKeys: 0x3,
				Keys: []tc.U32Key{
					//  match ip protocol 6 0xff
					{Mask: 0xff0000, Val: 0x60000, Off: 0x800, OffMask: 0x0},
					{Mask: 0xff000f00, Val: 0x5c0, Off: 0x0, OffMask: 0x0},
					{Mask: 0xff0000, Val: 0x100000, Off: 0x2000, OffMask: 0x0},
				},
			},
			Police: &tc.Police{
				Tbf: &tc.Policy{
					Action: 0x1,
					Burst:  0xc35000,
					Rate: tc.RateSpec{
						CellLog:   0x3,
						Linklayer: 0x1,
						CellAlign: 0xffff,
						Rate:      0x1e848,
					},
				},
			},
		},
	},
}

if err := tcnl.Qdisc().Add(&qdisc); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign clsact to lo: %v\n", err)
	return
}
// when deleting the qdisc, the applied filter will also be gone
defer tcnl.Qdisc().Delete(&qdisc)

ops := []byte{0x6, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff}
opsLen := uint16(1)
classID := uint32(0x1001)
flags := uint32(0x1)

filter := tc.Object{
	tc.Msg{
		Family:  unix.AF_UNSPEC,
		Ifindex: uint32(devID.Index),
		Handle:  0,
		Parent:  tc.HandleIngress,
		Info:    0x300,
	},
	tc.Attribute{
		Kind: "bpf",
		BPF: &tc.Bpf{
			Ops:     &ops,
			OpsLen:  &opsLen,
			ClassID: &classID,
			Flags:   &flags,
		},
	},
}
if err := tcnl.Filter().Add(&filter); err != nil {
	fmt.Fprintf(os.Stderr, "could not assign cBPF: %v\n", err)
	return
}