tc actions

Signed-off-by: Florian Lehner <dev@der-flo.net>

actions.go

@@ -0,0 +1,77 @@
+package tc
+
+import (
+	"github.com/florianl/go-tc/internal/unix"
+	"github.com/mdlayher/netlink"
+)
+
+// Actions represents the actions part of rtnetlink
+type Actions struct {
+	Tc
+}
+
+// tcamsg is Actions specific
+type tcaMsg struct {
+	family uint8
+	_      uint8  // pad1
+	_      uint16 // pad2
+}
+
+// Actions allows to read and alter actions
+func (tc *Tc) Actions() *Actions {
+	return &Actions{*tc}
+}
+
+// Add creates a new actions
+func (a *Actions) Add(info []*Action) error {
+	if len(info) == 0 {
+		return ErrNoArg
+	}
+	options, err := validateActionsObject(unix.RTM_NEWACTION, info)
+	if err != nil {
+		return err
+	}
+	return a.action(unix.RTM_NEWACTION, netlink.Create|netlink.Excl, tcaMsg{
+		family: unix.AF_UNSPEC,
+	}, options)
+}
+
+// Replace add/remove an actions. If the node does not exist yet it is created
+func (a *Actions) Replace(info []*Action) error {
+	if len(info) == 0 {
+		return ErrNoArg
+	}
+	options, err := validateActionsObject(unix.RTM_NEWACTION, info)
+	if err != nil {
+		return err
+	}
+	return a.action(unix.RTM_NEWACTION, netlink.Create, tcaMsg{
+		family: unix.AF_UNSPEC,
+	}, options)
+}
+
+// Delete removes an actions
+func (a *Actions) Delete(info []*Action) error {
+	if len(info) == 0 {
+		return ErrNoArg
+	}
+	options, err := validateActionsObject(unix.RTM_DELACTION, info)
+	if err != nil {
+		return err
+	}
+	return a.action(unix.RTM_DELACTION, netlink.HeaderFlags(0), tcaMsg{
+		family: unix.AF_UNSPEC,
+	}, options)
+}
+
+func validateActionsObject(cmd int, info []*Action) ([]tcOption, error) {
+	options := []tcOption{}
+
+	data, err := marshalActions(cmd, info)
+	if err != nil {
+		return options, err
+	}
+	options = append(options, tcOption{Interpretation: vtBytes, Type: 1 /*TCA_ROOT_TAB*/, Data: data})
+
+	return options, nil
+}

example_actions_test.go

@@ -0,0 +1,50 @@
+//go:build linux
+// +build linux
+
+package tc_test
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/florianl/go-tc"
+)
+
+func ExampleActions() {
+	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)
+		}
+	}()
+
+	// Create a gact Actions.
+	if err := tcnl.Actions().Add([]*tc.Action{
+		{
+			Kind: "gact",
+			Gact: &tc.Gact{
+				Parms: &tc.GactParms{
+					Action: 2, // drop
+				},
+			},
+		},
+	}); err != nil {
+		fmt.Fprintf(os.Stderr, "failed to add actions: %v\n", err)
+		return
+	}
+
+	// Delete the gact Actions on Index 1.
+	if err := tcnl.Actions().Delete([]*tc.Action{
+		{
+			Kind:  "gact",
+			Index: 1,
+		},
+	}); err != nil {
+		fmt.Fprintf(os.Stderr, "failed to delete gact actions: %v\n", err)
+		return
+	}
+}

f_basic.go

@@ -79,7 +79,7 @@ func marshalBasic(info *Basic) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaBasicPolice, Data: data})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		multiError = concatError(multiError, err)
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaBasicAct, Data: data})
 	}

f_bpf.go

@@ -123,7 +123,7 @@ func marshalBpf(info *Bpf) ([]byte, error) {
 	}
 	if info.Action != nil {
 		actions := []*Action{info.Action}
-		data, err := marshalActions(actions)
+		data, err := marshalActions(0, actions)
 		if err != nil {
 			return []byte{}, err
 		}

f_cgroup.go

@@ -29,7 +29,7 @@ func marshalCgroup(info *Cgroup) ([]byte, error) {
 	var multiError error
 	// TODO: improve logic and check combinations
 	if info.Action != nil {
-		data, err := marshalAction(info.Action, tcaActOptions)
+		data, err := marshalAction(0, info.Action, tcaActOptions)
 		multiError = concatError(multiError, err)
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaCgroupAct, Data: data})
 

f_flow.go

@@ -124,7 +124,7 @@ func marshalFlow(info *Flow) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaFlowEMatches, Data: data})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		multiError = concatError(multiError, err)
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaFlowAct, Data: data})
 	}

f_flower.go

@@ -407,7 +407,7 @@ func marshalFlower(info *Flower) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtString, Type: tcaFlowerIndev, Data: *info.Indev})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		multiError = concatError(multiError, err)
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaFlowerAct, Data: data})
 	}

f_fw.go

@@ -81,7 +81,7 @@ func marshalFw(info *Fw) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaFwPolice, Data: data})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		multiError = concatError(multiError, err)
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaFwAct, Data: data})
 	}

f_matchall.go

@@ -66,7 +66,7 @@ func marshalMatchall(info *Matchall) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtUint32, Type: tcaMatchallClassID, Data: uint32Value(info.ClassID)})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		multiError = concatError(multiError, err)
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaMatchallAct, Data: data})
 	}

f_route4.go

@@ -77,7 +77,7 @@ func marshalRoute4(info *Route4) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtUint32, Type: tcaRoute4IIf, Data: uint32Value(info.IIf)})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		if err != nil {
 			return []byte{}, err
 		}

f_rsvp.go

@@ -93,7 +93,7 @@ func marshalRsvp(info *Rsvp) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaRsvpPolice, Data: data})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		multiError = concatError(multiError, err)
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaRsvpAct, Data: data})
 	}

f_tcindex.go

@@ -52,7 +52,7 @@ func marshalTcIndex(info *TcIndex) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtUint32, Type: tcaTcIndexClassID, Data: uint32Value(info.ClassID)})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		if err != nil {
 			return []byte{}, err
 		}

f_u32.go

@@ -78,7 +78,7 @@ func marshalU32(info *U32) ([]byte, error) {
 		options = append(options, tcOption{Interpretation: vtUint32, Type: tcaU32Flags, Data: uint32Value(info.Flags)})
 	}
 	if info.Actions != nil {
-		data, err := marshalActions(*info.Actions)
+		data, err := marshalActions(0, *info.Actions)
 		multiError = concatError(multiError, err)
 		options = append(options, tcOption{Interpretation: vtBytes, Type: tcaU32Act, Data: data})
 	}

internal/unix/types_linux.go

@@ -44,3 +44,10 @@ const (
 	RTM_DELCHAIN = linux.RTM_DELCHAIN
 	RTM_GETCHAIN = linux.RTM_GETCHAIN
 )
+
+// Make linter happy with this comment.
+const (
+	RTM_NEWACTION = linux.RTM_NEWACTION
+	RTM_DELACTION = linux.RTM_DELACTION
+	RTM_GETACTION = linux.RTM_GETACTION
+)

internal/unix/types_other.go

@@ -43,3 +43,9 @@ const (
 	RTM_DELCHAIN = 101
 	RTM_GETCHAIN = 102
 )
+
+const (
+	RTM_NEWACTION = 48
+	RTM_DELACTION = 49
+	RTM_GETACTION = 50
+)

m_action.go

@@ -1,8 +1,10 @@
 package tc
 
 import (
+	"errors"
 	"fmt"
 
+	"github.com/florianl/go-tc/internal/unix"
 	"github.com/mdlayher/netlink"
 )
 
@@ -14,6 +16,10 @@ const (
 	tcaActStats
 	tcaActPad
 	tcaActCookie
+	tcaActFlags
+	tcaActHwStats
+	tcaActUsedHwStats
+	tcaActInHwCount
 )
 
 // Various action binding types.
@@ -41,10 +47,15 @@ const (
 
 // Action represents action attributes of various filters and classes
 type Action struct {
-	Kind      string
-	Index     uint32
-	Stats     *GenStats
-	Cookie    *[]byte
+	Kind        string
+	Index       uint32
+	Stats       *GenStats
+	Cookie      *[]byte
+	Flags       *uint32 // 32-bit bitfield
+	HwStats     *uint32 // 32-bit bitfield
+	UsedHwStats *uint32 // 32-bit bitfield
+	InHwCount   *uint32
+
 	Bpf       *ActBpf
 	ConnMark  *Connmark
 	CSum      *Csum
@@ -103,6 +114,18 @@ func unmarshalAction(data []byte, info *Action) error {
 				return err
 			}
 			info.Stats = stats
+		case tcaActFlags:
+			flags := ad.Uint32()
+			info.Flags = &flags
+		case tcaActHwStats:
+			hwStats := ad.Uint32()
+			info.HwStats = &hwStats
+		case tcaActUsedHwStats:
+			usedHwStats := ad.Uint32()
+			info.UsedHwStats = &usedHwStats
+		case tcaActInHwCount:
+			inHwCount := ad.Uint32()
+			info.InHwCount = &inHwCount
 		case tcaActPad:
 			// padding does not contain data, we just skip it
 		default:
@@ -118,11 +141,11 @@ func unmarshalAction(data []byte, info *Action) error {
 	return ad.Err()
 }
 
-func marshalActions(info []*Action) ([]byte, error) {
+func marshalActions(cmd int, info []*Action) ([]byte, error) {
 	options := []tcOption{}
 
 	for i, action := range info {
-		data, err := marshalAction(action, tcaActOptions|nlaFNnested)
+		data, err := marshalAction(cmd, action, tcaActOptions|nlaFNnested)
 		if err != nil {
 			return []byte{}, err
 		}
@@ -133,7 +156,7 @@ func marshalActions(info []*Action) ([]byte, error) {
 }
 
 // marshalAction returns the binary encoding of Action
-func marshalAction(info *Action, actOption uint16) ([]byte, error) {
+func marshalAction(cmd int, info *Action, actOption uint16) ([]byte, error) {
 	options := []tcOption{}
 
 	if info == nil {
@@ -220,7 +243,7 @@ func marshalAction(info *Action, actOption uint16) ([]byte, error) {
 	}
 	options = append(options, tcOption{Interpretation: vtString, Type: tcaActKind, Data: info.Kind})
 
-	if multiError != nil {
+	if multiError != nil && !errors.Is(multiError, ErrNoArg) && cmd != unix.RTM_DELACTION {
 		return []byte{}, multiError
 	}
 

m_action_test.go

@@ -99,7 +99,7 @@ func TestAction(t *testing.T) {
 
 	for name, testcase := range tests {
 		t.Run(name, func(t *testing.T) {
-			data, err1 := marshalActions([]*Action{&testcase.val})
+			data, err1 := marshalActions(0, []*Action{&testcase.val})
 			if err1 != nil {
 				if !errors.Is(testcase.err1, err1) {
 					return
@@ -122,7 +122,7 @@ func TestAction(t *testing.T) {
 		})
 	}
 	t.Run("nil", func(t *testing.T) {
-		_, err := marshalAction(nil, tcaActOptions)
+		_, err := marshalAction(0, nil, tcaActOptions)
 		if !errors.Is(err, ErrNoArg) {
 			t.Fatalf("unexpected error: %v", err)
 		}

tc.go

@@ -79,7 +79,7 @@ func (tc *Tc) query(req netlink.Message) ([]netlink.Message, error) {
 	return tc.con.Receive()
 }
 
-func (tc *Tc) action(action int, flags netlink.HeaderFlags, msg *Msg, opts []tcOption) error {
+func (tc *Tc) action(action int, flags netlink.HeaderFlags, msg interface{}, opts []tcOption) error {
 	tcminfo, err := marshalStruct(msg)
 	if err != nil {
 		return err