adding test cases for ipv4 parsing

Author: jonstout

README.md

@@ -15,8 +15,7 @@ controller.RegisterApplication(NewDemoInstance)
 
 ### Receive
 To receive OpenFlow messages, applications should implement the interfaces
-found in `protocol/ofp10/interface.go` or `protocol/ofp13/interface.go`. You
-only need to implement the interfaces you're interested in.
+found in `protocol/ofp10/interface.go` or `protocol/ofp13/interface.go`.
 ```
 func (b *DemoInstance) ConnectionUp(dpid net.HardwareAddr) {
   log.Println("Switch connected:", dpid)
@@ -39,7 +38,7 @@ req := ofp10.NewEchoRequest()
 
 // If switch dpid is known, returns its OFPSwitch struct. The
 // switch is not guaranteed to have an active connection.
-if sw, ok := core.Switch(dpid string); ok {
+if sw, ok := ogo.Switch(dpid string); ok {
   sw.Send(req)
 }
 ```

protocol/eth/ethernet.go

@@ -121,9 +121,7 @@ func (e *Ethernet) UnmarshalBinary(data []byte) error {
 	default:
 		e.Data = new(util.Buffer)
 	}
-	err := e.Data.UnmarshalBinary(data[n:])
-	
-	return err
+	return e.Data.UnmarshalBinary(data[n:])
 }
 
 const (

protocol/ipv4/ip.go

@@ -4,7 +4,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"net"
-	
+
 	"github.com/jonstout/ogo/protocol/icmp"
 	"github.com/jonstout/ogo/protocol/udp"
 	"github.com/jonstout/ogo/protocol/util"
@@ -36,71 +36,109 @@ type IPv4 struct {
 	Data           util.Message
 }
 
+func New() *IPv4 {
+	ip := new(IPv4)
+	ip.NWSrc = make([]byte, 4)
+	ip.NWDst = make([]byte, 4)
+	ip.Options = *new(util.Buffer)
+	return ip
+}
+
 func (i *IPv4) Len() (n uint16) {
+	i.IHL = 5
 	if i.Data != nil {
 		return uint16(i.IHL*4) + i.Data.Len()
 	}
 	return uint16(i.IHL * 4)
 }
 
 func (i *IPv4) MarshalBinary() (data []byte, err error) {
-	data = make([]byte, int(i.IHL * 4))
+	data = make([]byte, int(i.Len()))
+	b := make([]byte, 0)
+	n := 0
+
 	var ihl uint8 = (i.Version << 4) + i.IHL
-	data[0] = ihl
+	data[n] = ihl
+	n += 1
 	var ecn uint8 = (i.DSCP << 2) + i.ECN
-	data[1] = ecn
-	binary.BigEndian.PutUint16(data[2:4], i.Length)
-	binary.BigEndian.PutUint16(data[4:6], i.Id)
+	data[n] = ecn
+	n += 1
+	binary.BigEndian.PutUint16(data[n:], i.Length)
+	n += 2
+	binary.BigEndian.PutUint16(data[n:], i.Id)
+	n += 2
 	var flg uint16 = (i.Flags << 13) + i.FragmentOffset
-	binary.BigEndian.PutUint16(data[6:8], flg)
-	data[8] = i.TTL
-	data[9] = i.Protocol
-	binary.BigEndian.PutUint16(data[10:12], i.Checksum)
-	copy(data[12:16], i.NWSrc)
-	copy(data[16:20], i.NWDst)
-	n := 20 + i.Options.Len()
-	i.Options.Read(data[20:n])
-
-	bytes, err := i.Data.MarshalBinary()
-	if err != nil {
-		return
+	binary.BigEndian.PutUint16(data[n:], flg)
+	n += 2
+	data[n] = i.TTL
+	n += 1
+	data[n] = i.Protocol
+	n += 1
+	binary.BigEndian.PutUint16(data[n:], i.Checksum)
+	n += 2
+
+	copy(data[n:], i.NWSrc.To4())
+	n += 4 // Underlying rep can be 16 bytes.
+	copy(data[n:], i.NWDst.To4())
+	n += 4 // Underlying rep can be 16 bytes.
+
+	b, err = i.Options.MarshalBinary()
+	copy(data[n:], b)
+	n += len(b)
+
+	if i.Data != nil {
+		b, err = i.Data.MarshalBinary()
+		if err != nil {
+			return
+		}
+		copy(data[n:], b)
+		n += len(b)
 	}
-	data = append(data, bytes...)
 	return
 }
 
 func (i *IPv4) UnmarshalBinary(data []byte) error {
 	if len(data) < 20 {
 		return errors.New("The []byte is too short to unmarshal a full IPv4 message.")
 	}
+	n := 0
+
 	var ihl uint8
-	ihl = data[0]
+	ihl = data[n]
 	i.Version = ihl >> 4
 	i.IHL = ihl & 0x0f
+	n += 1
 
 	var ecn uint8
-	ecn = data[1]
+	ecn = data[n]
 	i.DSCP = ecn >> 2
 	i.ECN = ecn & 0x03
+	n += 1
 
-	i.Length = binary.BigEndian.Uint16(data[2:4])
-	i.Id = binary.BigEndian.Uint16(data[4:6])
+	i.Length = binary.BigEndian.Uint16(data[n:])
+	n += 2
+	i.Id = binary.BigEndian.Uint16(data[n:])
+	n += 2
 
 	var flg uint16
-	flg = binary.BigEndian.Uint16(data[6:8])
+	flg = binary.BigEndian.Uint16(data[n:])
 	i.Flags = flg >> 13
 	i.FragmentOffset = flg & 0x1fff
+	n += 2
 
-	i.TTL = data[8]
-	i.Protocol = data[9]
-	i.Checksum = binary.BigEndian.Uint16(data[10:12])
-	i.NWSrc = data[12:16]
-	i.NWDst = data[16:20]
-	n := 20
+	i.TTL = data[n]
+	n += 1
+	i.Protocol = data[n]
+	n += 1
+	i.Checksum = binary.BigEndian.Uint16(data[n:])
+	n += 2
+	i.NWSrc = data[n:n+4]
+	n += 4
+	i.NWDst = data[n:n+4]
+	n += 4
 
-	i.Options = *new(util.Buffer)
 	i.Options.UnmarshalBinary(data[n:int(i.IHL * 4)])
-	n += int(i.IHL *4)
+	n += int(i.IHL * 4) - n
 
 	switch i.Protocol {
 	case Type_ICMP:
@@ -110,6 +148,5 @@ func (i *IPv4) UnmarshalBinary(data []byte) error {
 	default:
 		i.Data = new(util.Buffer)
 	}
-	err := i.Data.UnmarshalBinary(data[n:])
-	return err
+	return i.Data.UnmarshalBinary(data[n:])
 }

protocol/ipv4/ip_test.go

@@ -0,0 +1,76 @@
+package ipv4
+
+import (
+	"bytes"
+	"encoding/hex"
+	"net"
+	"strings"
+	"testing"
+)
+
+func TestIPv4MarshalBinary(t *testing.T) {
+	b := "   55 " + // Version, IHL
+		"00 " + // DSCP, ECN
+		"00 14 " + // Length
+		"00 00 " + // Id
+		"00 00 " + // Flags, FragmentOffset
+		"01 " + // TTL
+		"06 " + // Protocol
+		"00 00 " + // Checksum
+		"7f 00 00 01 " + // NWSrc
+		"08 08 08 08 "   // NWDst
+	b = strings.Replace(b, " ", "", -1)
+
+	ip := New()
+	ip.NWSrc = net.ParseIP("127.0.0.1")
+	ip.NWDst = net.ParseIP("8.8.8.8")
+	ip.Version = 5
+	ip.Length = 20
+	ip.TTL = 1
+	ip.Protocol = Type_TCP
+
+	data, _ := ip.MarshalBinary()
+	d := hex.EncodeToString(data)
+	if (len(b) != len(d)) || (b != d) {
+		t.Log("Exp:", b)
+		t.Log("Rec:", d)
+		t.Errorf("Received length of %d, expected %d", len(d), len(b))
+	}
+}
+
+func TestIPv4UnmarshalBinary(t *testing.T) {
+	b := "   55 " + // Version, IHL
+		"00 " + // DSCP, ECN
+		"00 14 " + // Length
+		"00 00 " + // Id
+		"00 00 " + // Flags, FragmentOffset
+		"01 " + // TTL
+		"06 " + // Protocol
+		"09 af " + // Checksum
+		"7f 00 00 01 " + // NWSrc
+		"08 08 08 08 "   // NWDst
+	b = strings.Replace(b, " ", "", -1)
+	byte, _ := hex.DecodeString(b)
+
+	ip := New()
+	ip.UnmarshalBinary(byte)
+
+	src := net.ParseIP("127.0.0.1").To4()
+	dst := net.ParseIP("8.8.8.8").To4()
+	
+	if int(ip.Len()) != len(byte) {
+		t.Errorf("Got length of %d, expected %d.", ip.Len(), len(byte))
+	} else if ip.Version != 5 {
+		t.Errorf("Got type %d, expected %d.", ip.Version, 5)
+	} else if ip.Length != 20 {
+		t.Errorf("Got length %d, expected %d.", ip.Length, 20)
+	} else if ip.TTL != 1 {
+		t.Errorf("Got ttl %d, expected %d.", ip.TTL, 1)
+	} else if ip.Protocol != Type_TCP {
+		t.Errorf("Got protocol %d, expected %d.", ip.Protocol, Type_TCP)
+	} else if bytes.Compare(ip.NWSrc, src) != 0 {
+		t.Errorf("Got nw-src %d, expected %d.", ip.NWSrc, src)
+	} else if bytes.Compare(ip.NWDst, dst) != 0 {
+		t.Errorf("Got nw-dst %d, expected %d.", ip.NWDst, dst)
+	}
+}

protocol/util/buffer.go

@@ -13,7 +13,7 @@ func NewBuffer(buf []byte) *Buffer {
 }
 
 func (b *Buffer) Len() uint16 {
-	return uint16(b.Len())
+	return uint16(b.Buffer.Len())
 }
 
 func (b *Buffer) MarshalBinary() (data []byte, err error) {