rework bundle decoding and tests

Bump actions/setup-go from 6 to 7

.github/workflows/release-makeosc.yml

@@ -36,7 +36,7 @@ jobs:
           - goarch: "386"
             goos: darwin
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: wangyoucao577/go-release-action@v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release-receiveosc.yml

@@ -36,7 +36,7 @@ jobs:
           - goarch: "386"
             goos: darwin
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: wangyoucao577/go-release-action@v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release-sendosc.yml

@@ -36,7 +36,7 @@ jobs:
           - goarch: "386"
             goos: darwin
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: wangyoucao577/go-release-action@v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -9,16 +9,16 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v7
         with:
           go-version-file: go.mod
       - name: Run tests
         run: go test -v -coverprofile=coverage.txt .
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v6
+        uses: codecov/codecov-action@v7
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: coverage.txt

bundle.go

@@ -45,54 +45,43 @@ func BundleFromBytes(bytes []byte) (*OSCBundle, []byte, error) {
 		return nil, bytesAfterBundleHeader, errors.New("OSC Bundle must start with #bundle string")
 	}
 
-	timeTag, bytesAfterTimeTag, err := readOSCTimeTag(bytesAfterBundleHeader)
+	timeTag, bytesAfterTimeTag, _ := readOSCTimeTag(bytesAfterBundleHeader)
-
-	if err != nil {
-		return nil, bytesAfterBundleHeader, err
-	}
 
 	bundleContents := []OSCPacket{}
 
-	endOfBundle := false
-
 	remainingBytes := bytesAfterTimeTag
 
-	for !endOfBundle {
+	contentSize, bytesAfterContentSize, _ := readOSCInt32(remainingBytes)
-		contentSize, bytesAfterContentSize, err := readOSCInt32(remainingBytes)
 
+	remainingBytes = bytesAfterContentSize
+
+	if contentSize <= 0 {
+		return nil, remainingBytes, errors.New("bundle content size must be positive")
+	}
+
+	if len(remainingBytes) < int(contentSize) {
+		return nil, remainingBytes, errors.New("bundle doesn't have enough bytes for the content size it specifies")
+	}
+
+	bundleContentBytes := remainingBytes[0:contentSize]
+
+	switch bundleContentBytes[0] {
+	case 35: // #
+		content, _, err := BundleFromBytes(bundleContentBytes)
 		if err != nil {
 			return nil, remainingBytes, err
 		}
-
+		bundleContents = append(bundleContents, content)
-		remainingBytes = bytesAfterContentSize
+	case 47: // /
-
+		content, err := MessageFromBytes(bundleContentBytes)
-		if len(remainingBytes) < int(contentSize) {
+		if err != nil {
-			return nil, remainingBytes, errors.New("bundle doesn't have enough bytes for the content size it specifies")
+			return nil, remainingBytes, err
 		}
-
+		bundleContents = append(bundleContents, content)
-		bundleContentBytes := remainingBytes[0:contentSize]
+	default:
-
+		return nil, remainingBytes, errors.New("bundle contents does not look a bundle or message")
-		if bundleContentBytes[0] == 35 {
-			content, _, err := BundleFromBytes(bundleContentBytes)
-			if err != nil {
-				return nil, remainingBytes, err
-			}
-			bundleContents = append(bundleContents, content)
-		} else if bundleContentBytes[0] == 47 {
-			content, err := MessageFromBytes(bundleContentBytes)
-			if err != nil {
-				return nil, remainingBytes, err
-			}
-			bundleContents = append(bundleContents, content)
-		} else {
-			return nil, remainingBytes, errors.New("bundle contents does not look a bundle or message")
-		}
-		remainingBytes = bytesAfterContentSize[contentSize:]
-		if len(remainingBytes) == 0 {
-			endOfBundle = true
-		}
-
 	}
+	remainingBytes = bytesAfterContentSize[contentSize:]
 
 	return &OSCBundle{
 			TimeTag:  timeTag,

bundle_test.go

@@ -194,6 +194,24 @@ func TestBadOSCBundleDecoding(t *testing.T) {
 				0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 			errorString: "bundle contents does not look a bundle or message",
 		},
+		{
+			name: "bundle with bad bundle inside",
+			bytes: []byte{35, 98, 117, 110, 100, 108, 101, 0, // #bundle
+				0, 0, 0, 32, 0, 0, 0, 0, // time tag
+				0, 0, 0, 19, // content size
+				35, 98, 117, 110, 100, 108, 101, 0, // #bundle
+				0, 0, 0, 64, 0, 0, 0, 0, // time tag
+				0, 0, 0},
+			errorString: "OSC Bundle has to be at least 20 bytes",
+		},
+		{
+			name: "bundle with bad message inside",
+			bytes: []byte{35, 98, 117, 110, 100, 108, 101, 0, // #bundle
+				0, 0, 0, 32, 0, 0, 0, 0, // time tag
+				0, 0, 0, 5, // content size
+				47, 104, 101, 108, 108, 111},
+			errorString: "OSC string must be null-terminated",
+		},
 	}
 
 	for _, testCase := range testCases {
@@ -210,3 +228,31 @@ func TestBadOSCBundleDecoding(t *testing.T) {
 		})
 	}
 }
+
+func FuzzBundleFromBytes(f *testing.F) {
+	seedBytes := [][]byte{
+		{},
+		{35, 98, 117, 110, 100, 108, 101, 0, 0, 0, 0,
+			32, 0, 0, 0, 0, 0, 0, 0, 32, 47, 111,
+			115, 99, 105, 108, 108, 97, 116, 111, 114, 47, 52,
+			47, 102, 114, 101, 113, 117, 101, 110, 99, 121, 0,
+			44, 102, 0, 0, 67, 220, 0, 0},
+		{35, 98, 117, 110, 100, 108, 101, 0, // #bundle
+			0, 0, 0, 32, 0, 0, 0, 0, // time tag
+			0, 0, 0, 52, // content size
+			35, 98, 117, 110, 100, 108, 101, 0, // #bundle
+			0, 0, 0, 64, 0, 0, 0, 0, // time tag
+			0, 0, 0, 32, // content size
+			47, 111, 115, 99, 105, 108, 108, 97, 116, 111, 114, 47, 52,
+			47, 102, 114, 101, 113, 117, 101, 110, 99, 121, 0,
+			44, 102, 0, 0, 67, 220, 0, 0},
+	}
+
+	for _, seed := range seedBytes {
+		f.Add(seed)
+	}
+
+	f.Fuzz(func(t *testing.T, data []byte) {
+		_, _, _ = BundleFromBytes(data)
+	})
+}

cmd/makeosc/makeosc.go

@@ -141,11 +141,12 @@ func slipEncode(bytes []byte) []byte {
 	var encodedBytes = []byte{END}
 
 	for _, byteToEncode := range bytes {
-		if byteToEncode == END {
+		switch byteToEncode {
+		case END:
 			encodedBytes = append(encodedBytes, ESC, ESC_END)
-		} else if byteToEncode == ESC {
+		case ESC:
 			encodedBytes = append(encodedBytes, ESC, ESC_ESC)
-		} else {
+		default:
 			encodedBytes = append(encodedBytes, byteToEncode)
 		}
 	}
@@ -178,8 +179,5 @@ func makeMsg(address string, args []string, types []string, slip bool) {
 	if slip {
 		oscMessageBuffer = slipEncode(oscMessageBuffer)
 	}
-
-	//TODO write buffer to stdout
 	os.Stdout.Write(oscMessageBuffer)
-
 }

cmd/receiveosc/receiveosc.go

@@ -120,9 +120,10 @@ func (s *SLIP) decode(bytes []byte) {
 		}
 
 		if escapeNext {
-			if packetByte == ESC_END {
+			switch packetByte {
+			case ESC_END:
 				s.pendingBytes = append(s.pendingBytes, END)
-			} else if packetByte == ESC_ESC {
+			case ESC_ESC:
 				s.pendingBytes = append(s.pendingBytes, ESC)
 			}
 			escapeNext = false
@@ -203,23 +204,23 @@ func handleBundle(bundle *osc.OSCBundle, format string) {
 
 func listenUDP(netAddress string, format string) {
 
-	s, err := net.ResolveUDPAddr("udp4", netAddress)
+	laddr, err := net.ResolveUDPAddr("udp4", netAddress)
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
 
-	connection, err := net.ListenUDP("udp4", s)
+	conn, err := net.ListenUDP("udp4", laddr)
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
 
-	defer connection.Close()
+	defer conn.Close()
 	buffer := make([]byte, 1024)
 
 	for {
-		bytesRead, _, err := connection.ReadFromUDP(buffer)
+		bytesRead, _, err := conn.ReadFromUDP(buffer)
 
 		if err != nil {
 			panic(err)

cmd/sendosc/sendosc.go

@@ -169,11 +169,12 @@ func slipEncode(bytes []byte) []byte {
 	var encodedBytes = []byte{END}
 
 	for _, byteToEncode := range bytes {
-		if byteToEncode == END {
+		switch byteToEncode {
+		case END:
 			encodedBytes = append(encodedBytes, ESC, ESC_END)
-		} else if byteToEncode == ESC {
+		case ESC:
 			encodedBytes = append(encodedBytes, ESC, ESC_ESC)
-		} else {
+		default:
 			encodedBytes = append(encodedBytes, byteToEncode)
 		}
 	}

go.mod

@@ -2,4 +2,4 @@ module github.com/jwetzell/osc-go
 
 go 1.25.1
 
-require github.com/urfave/cli/v3 v3.8.0
+require github.com/urfave/cli/v3 v3.10.1

go.sum

@@ -4,7 +4,7 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/urfave/cli/v3 v3.8.0 h1:XqKPrm0q4P0q5JpoclYoCAv0/MIvH/jZ2umzuf8pNTI=
+github.com/urfave/cli/v3 v3.10.1 h1:7Kx9H50hrHbRbyxgO1KP6/BcbiGRz0uYh5YyQ30JEEY=
-github.com/urfave/cli/v3 v3.8.0/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
+github.com/urfave/cli/v3 v3.10.1/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

message_test.go

@@ -511,3 +511,46 @@ func TestBadOSCMessageDecoding(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkMessageToBytes(b *testing.B) {
+	message := &OSCMessage{
+		Address: "/hello",
+		Args: []OSCArg{
+			{Type: "i", Value: 35},
+		},
+	}
+
+	for b.Loop() {
+		_, err := message.ToBytes()
+		if err != nil {
+			b.Fatalf("failed to encode properly: %s", err.Error())
+		}
+	}
+}
+
+func BenchmarkMessageFromBytes(b *testing.B) {
+	bytes := []byte{47, 104, 101, 108, 108, 111, 0, 0, 44, 105, 0, 0, 0, 0, 0, 35}
+
+	for b.Loop() {
+		_, err := MessageFromBytes(bytes)
+		if err != nil {
+			b.Fatalf("failed to decode properly: %s", err.Error())
+		}
+	}
+}
+
+func FuzzMessageFromBytes(f *testing.F) {
+	seedBytes := [][]byte{
+		{},
+		{47, 104, 101, 108, 108, 111, 0, 0},
+		{47, 104, 101, 108, 108, 111, 0, 0, 44, 105, 0, 0, 0, 0, 0, 35},
+	}
+
+	for _, seed := range seedBytes {
+		f.Add(seed)
+	}
+
+	f.Fuzz(func(t *testing.T, data []byte) {
+		_, _ = MessageFromBytes(data)
+	})
+}

osc.go

@@ -318,7 +318,7 @@ func readOSCArg(bytes []byte, oscType string) (OSCArg, []byte, error) {
 	oscArg := OSCArg{}
 	oscArg.Type = oscType
 
-	remainingBytes := []byte{}
+	var remainingBytes []byte
 	//TODO(jwetzell): add error handling
 	switch oscType {
 	case "s":

osc_test.go

@@ -292,14 +292,26 @@ func TestBadPacketFromBytes(t *testing.T) {
 		bytes       []byte
 		errorString string
 	}{
-		{name: "empty bytes",
+		{
+			name:        "empty bytes",
 			bytes:       []byte{},
 			errorString: "cannot create OSC Packet from empty byte array",
 		},
-		{name: "packet that does not start with / or #",
+		{
+			name:        "packet that does not start with / or #",
 			bytes:       []byte{0, 1, 2, 3},
 			errorString: "OSC Packet must start with # for bundle or / for message",
 		},
+		{
+			name:        "bundle with not enough bytes",
+			bytes:       []byte{35, 98, 117, 110, 100, 108, 101, 0},
+			errorString: "OSC Bundle has to be at least 20 bytes",
+		},
+		{
+			name:        "message without null terminated address",
+			bytes:       []byte{47, 104, 101, 108, 108, 111},
+			errorString: "OSC string must be null-terminated",
+		},
 	}
 
 	for _, testCase := range testCases {

testdata/fuzz/FuzzBundleFromBytes/39e8ac474312e7e0

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("#bundle\x0000000000\x00\x00\x00\x00")

testdata/fuzz/FuzzMessageFromBytes/986355228ada9f19

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("/00\x00,b0\x00\xff000")

testdata/fuzz/FuzzMessageFromBytes/b52972290d937e09

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("/00\x00,b0\x00\x00\x00\x00\x010")

testdata/fuzz/FuzzMessageFromBytes/c9b3b4e809eeacd2

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("/00\x00,d\x0000000")