VOL-4143: Implementation of missing decode/serialize of baseline Get Current Data message type
Change-Id: I56605b7d75d70f8bf36c220b3b90b8f1f25745d0
diff --git a/README.md b/README.md
index 3308803..a2aa972 100644
--- a/README.md
+++ b/README.md
@@ -49,6 +49,8 @@
- TestResult
- TestRequest
- TestResponse
+ - GetCurrentDataRequest
+ - GetCurrentDataResponse
## Message Types supported but lacking any unit test
The following OMCI message types currently have been coded but do not
@@ -57,8 +59,6 @@
- StartSoftwareDownloadResponse
- ActivateSoftwareRequest
- ActivateSoftwareResponse
- - GetCurrentDataRequest
- - GetCurrentDataResponse
## Message Types not yet supported
diff --git a/VERSION b/VERSION
index f0bb29e..3a3cd8c 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.3.0
+1.3.1
diff --git a/messagetypes.go b/messagetypes.go
index 4709f79..5e5dd74 100644
--- a/messagetypes.go
+++ b/messagetypes.go
@@ -3955,7 +3955,18 @@
// DecodeFromBytes decodes the given bytes of a Get Current Data Request into this layer
func (omci *GetCurrentDataRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
- err := omci.MeBasePacket.DecodeFromBytes(data, p, 4+2)
+ var offset int
+ if omci.Extended {
+ offset = 6
+ } else {
+ offset = 4
+ }
+ hdrSize := offset + 2
+ if len(data) < hdrSize {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ err := omci.MeBasePacket.DecodeFromBytes(data, p, hdrSize)
if err != nil {
return err
}
@@ -3970,7 +3981,7 @@
}
// Note: G.988 specifies that an error code of (3) should result if more
// than one attribute is requested
- omci.AttributeMask = binary.BigEndian.Uint16(data[4:6])
+ omci.AttributeMask = binary.BigEndian.Uint16(data[offset:])
return nil
}
@@ -4008,9 +4019,11 @@
//
type GetCurrentDataResponse struct {
MeBasePacket
- Result me.Results
- AttributeMask uint16
- Attributes me.AttributeValueMap
+ Result me.Results
+ AttributeMask uint16
+ UnsupportedAttributeMask uint16
+ FailedAttributeMask uint16
+ Attributes me.AttributeValueMap
}
func (omci *GetCurrentDataResponse) String() string {
@@ -4021,7 +4034,20 @@
// DecodeFromBytes decodes the given bytes of a Get Current Data Respnse into this layer
func (omci *GetCurrentDataResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
- err := omci.MeBasePacket.DecodeFromBytes(data, p, 4+3)
+ var offset, length int
+ if omci.Extended {
+ offset = 6
+ length = 7
+ } else {
+ offset = 4
+ length = 3
+ }
+ hdrSize := offset + length
+ if len(data) < hdrSize {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ err := omci.MeBasePacket.DecodeFromBytes(data, p, hdrSize)
if err != nil {
return err
}
@@ -4034,18 +4060,47 @@
if !me.SupportsMsgType(meDefinition, me.GetCurrentData) {
return me.NewProcessingError("managed entity does not support Get Current Data Message-Type")
}
- omci.AttributeMask = binary.BigEndian.Uint16(data[4:6])
-
+ omci.Result = me.Results(data[offset])
+ omci.AttributeMask = binary.BigEndian.Uint16(data[offset+1:])
switch omci.Result {
case me.ProcessingError, me.NotSupported, me.UnknownEntity, me.UnknownInstance, me.DeviceBusy:
return nil // Done (do not try and decode attributes)
+ case me.AttributeFailure:
+ if omci.Extended {
+ omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[offset+3:])
+ omci.FailedAttributeMask = binary.BigEndian.Uint16(data[offset+5:])
+ } else {
+ omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[32:])
+ omci.FailedAttributeMask = binary.BigEndian.Uint16(data[34:])
+ }
}
- // Attribute decode
- omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask, data[6:], p, byte(GetCurrentDataResponseType))
+ // Attribute decode. Note that the ITU-T G.988 specification states that the
+ // Unsupported and Failed attribute masks are always present
+ // but only valid if the status code== 9. However some XGS
+ // ONUs (T&W and Alpha, perhaps more) will use these last 4
+ // octets for data if the status code == 0 in a baseline GET
+ // Response. So this behaviour is anticipated here as well
+ // and will be allowed in favor of greater interoperability.
+ omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask, data[hdrSize:], p, byte(GetCurrentDataResponseType))
if err != nil {
return err
}
- return nil
+ // Validate all attributes support read
+ for attrName := range omci.Attributes {
+ attr, err := me.GetAttributeDefinitionByName(meDefinition.GetAttributeDefinitions(), attrName)
+ if err != nil {
+ return err
+ }
+ if attr.Index != 0 && !me.SupportsAttributeAccess(*attr, me.Read) {
+ msg := fmt.Sprintf("attribute '%v' does not support read access", attrName)
+ return me.NewProcessingError(msg)
+ }
+ }
+ if eidDef, eidDefOK := meDefinition.GetAttributeDefinitions()[0]; eidDefOK {
+ omci.Attributes[eidDef.GetName()] = omci.EntityInstance
+ return nil
+ }
+ return errors.New("All Managed Entities have an EntityID attribute")
}
func decodeGetCurrentDataResponse(data []byte, p gopacket.PacketBuilder) error {
@@ -4070,26 +4125,107 @@
if !me.SupportsMsgType(meDefinition, me.GetCurrentData) {
return me.NewProcessingError("managed entity does not support the Get Current Data Message-Type")
}
- bytes, err := b.AppendBytes(2)
+ var resultOffset, hdrSize int
+
+ if omci.Extended {
+ resultOffset = 2
+ hdrSize = resultOffset + 1 + 2 + 2 + 2 // length + result + masks
+ } else {
+ resultOffset = 0
+ hdrSize = resultOffset + 1 + 2 // length + result + attr-mask
+ }
+ bytes, err := b.AppendBytes(hdrSize)
if err != nil {
return err
}
- binary.BigEndian.PutUint16(bytes[0:2], omci.AttributeMask)
+ bytes[resultOffset] = byte(omci.Result)
+ binary.BigEndian.PutUint16(bytes[resultOffset+1:], omci.AttributeMask)
+ // Validate all attributes support read
+ for attrName := range omci.Attributes {
+ var attr *me.AttributeDefinition
+ attr, err = me.GetAttributeDefinitionByName(meDefinition.GetAttributeDefinitions(), attrName)
+ if err != nil {
+ return err
+ }
+ if attr.Index != 0 && !me.SupportsAttributeAccess(*attr, me.Read) {
+ msg := fmt.Sprintf("attribute '%v' does not support read access", attrName)
+ return me.NewProcessingError(msg)
+ }
+ }
// Attribute serialization
- // TODO: Only Baseline supported at this time
- bytesAvailable := MaxBaselineLength - 9 - 8
- var failedMask uint16
+ switch omci.Result {
+ default:
+ if omci.Extended {
+ binary.BigEndian.PutUint16(bytes, 7) // Length
+ binary.BigEndian.PutUint32(bytes[resultOffset+3:], 0)
+ }
+ break
- err, failedMask = meDefinition.SerializeAttributes(omci.Attributes, omci.AttributeMask, b,
- byte(GetCurrentDataResponseType), bytesAvailable, opts.FixLengths)
+ case me.Success, me.AttributeFailure:
+ var available int
+ if omci.Extended {
+ available = MaxExtendedLength - 10 - 3 - 4 - 4 // Less: header, result+mask, optional-masks mic
+ } else {
+ available = MaxBaselineLength - 8 - 3 - 4 - 8 // hdr, result+mask, optional-masks, trailer
+ }
+ // Serialize to temporary buffer if we may need to reset values due to
+ // recoverable truncation errors
+ attributeBuffer := gopacket.NewSerializeBuffer()
+ var failedMask uint16
+ err, failedMask = meDefinition.SerializeAttributes(omci.Attributes, omci.AttributeMask,
+ attributeBuffer, byte(GetCurrentDataResponseType), available, opts.FixLengths)
- if failedMask != 0 {
- // TODO: See GetResponse serialization above for the steps here
- return me.NewMessageTruncatedError("getCurrentData attribute truncation not yet supported")
- }
- if err != nil {
- return err
+ if err != nil {
+ return err
+ }
+ if failedMask != 0 {
+ // Not all attributes would fit
+ omci.FailedAttributeMask |= failedMask
+ omci.AttributeMask &= ^failedMask
+ omci.Result = me.AttributeFailure
+
+ // Adjust already recorded values
+ bytes[resultOffset] = byte(omci.Result)
+ binary.BigEndian.PutUint16(bytes[resultOffset+1:], omci.AttributeMask)
+ }
+ if omci.Extended {
+ // Set length and any failure masks
+ binary.BigEndian.PutUint16(bytes, uint16(len(attributeBuffer.Bytes())+7))
+
+ if omci.Result == me.AttributeFailure {
+ binary.BigEndian.PutUint16(bytes[resultOffset+3:], omci.UnsupportedAttributeMask)
+ binary.BigEndian.PutUint16(bytes[resultOffset+5:], omci.FailedAttributeMask)
+ } else {
+ binary.BigEndian.PutUint32(bytes[resultOffset+3:], 0)
+ }
+ }
+ // Copy over attributes to the original serialization buffer
+ var newSpace []byte
+
+ newSpace, err = b.AppendBytes(len(attributeBuffer.Bytes()))
+ if err != nil {
+ return err
+ }
+ copy(newSpace, attributeBuffer.Bytes())
+
+ if !omci.Extended {
+ // Calculate space left. Max - msgType header - OMCI trailer - spacedUsedSoFar
+ bytesLeft := MaxBaselineLength - 4 - 8 - len(b.Bytes())
+
+ var remainingBytes []byte
+ remainingBytes, err = b.AppendBytes(bytesLeft + 4)
+
+ if err != nil {
+ return me.NewMessageTruncatedError(err.Error())
+ }
+ copy(remainingBytes, lotsOfZeros[:])
+
+ if omci.Result == me.AttributeFailure {
+ binary.BigEndian.PutUint16(remainingBytes[bytesLeft-4:bytesLeft-2], omci.UnsupportedAttributeMask)
+ binary.BigEndian.PutUint16(remainingBytes[bytesLeft-2:bytesLeft], omci.FailedAttributeMask)
+ }
+ }
}
return nil
}
diff --git a/messagetypes_test.go b/messagetypes_test.go
index 5420e99..30672c6 100644
--- a/messagetypes_test.go
+++ b/messagetypes_test.go
@@ -2740,8 +2740,7 @@
assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
}
-// TODO: Create request/response tests for all of the following types//GetCurrentData,
-//SetTable}
+// TODO: Create request/response tests for all of the following types -> SetTable
func TestAlarmNotificationDecode(t *testing.T) {
goodMessage := "0000100a000b0104800000000000000000000000000000000000000000000000000000000000000500000028"
@@ -4404,5 +4403,138 @@
assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
}
+func TestGetCurrentDataRequestDecode(t *testing.T) {
+ goodMessage := "035e5c0a01aa0000004400000000000000000000000000000000000000000000000000000000000000000028"
+ data, err := stringToPacket(goodMessage)
+ assert.NoError(t, err)
+
+ packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+ assert.NotNil(t, packet)
+
+ omciLayer := packet.Layer(LayerTypeOMCI)
+ assert.NotNil(t, omciLayer)
+
+ omciMsg, ok := omciLayer.(*OMCI)
+ assert.True(t, ok)
+ assert.Equal(t, uint16(0x035e), omciMsg.TransactionID)
+ assert.Equal(t, GetCurrentDataRequestType, omciMsg.MessageType)
+ assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeGetCurrentDataRequest)
+ assert.NotNil(t, msgLayer)
+
+ request, ok2 := msgLayer.(*GetCurrentDataRequest)
+ assert.True(t, ok2)
+ assert.NotNil(t, request)
+ assert.Equal(t, me.EthernetFrameExtendedPm64BitClassID, request.EntityClass)
+ assert.Equal(t, uint16(0), request.EntityInstance)
+ assert.Equal(t, uint16(0x0044), request.AttributeMask)
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestGetCurrentDataRequestSerialize(t *testing.T) {
+ goodMessage := "035e5c0a01aa0000004400000000000000000000000000000000000000000000000000000000000000000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0x035e,
+ MessageType: GetCurrentDataRequestType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ request := &GetCurrentDataRequest{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.EthernetFrameExtendedPm64BitClassID,
+ EntityInstance: uint16(0),
+ },
+ AttributeMask: uint16(0x0044),
+ }
+ // Test serialization back to former string
+ var options gopacket.SerializeOptions
+ options.FixLengths = true
+
+ buffer := gopacket.NewSerializeBuffer()
+ err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+ assert.NoError(t, err)
+
+ outgoingPacket := buffer.Bytes()
+ reconstituted := packetToString(outgoingPacket)
+ assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
+}
+
+func TestGetCurrentDataResponseDecode(t *testing.T) {
+ goodMessage := "035e3c0a01aa0000000044123456781234dbcb432187654321dac1000000000000000000000000000028"
+ data, err := stringToPacket(goodMessage)
+ assert.NoError(t, err)
+
+ packet := gopacket.NewPacket(data, LayerTypeOMCI, gopacket.NoCopy)
+ assert.NotNil(t, packet)
+
+ omciLayer := packet.Layer(LayerTypeOMCI)
+ assert.NotNil(t, omciLayer)
+
+ omciMsg, ok := omciLayer.(*OMCI)
+ assert.True(t, ok)
+ assert.Equal(t, uint16(0x035e), omciMsg.TransactionID)
+ assert.Equal(t, GetCurrentDataResponseType, omciMsg.MessageType)
+ assert.Equal(t, BaselineIdent, omciMsg.DeviceIdentifier)
+ assert.Equal(t, uint16(40), omciMsg.Length)
+
+ msgLayer := packet.Layer(LayerTypeGetCurrentDataResponse)
+ assert.NotNil(t, msgLayer)
+
+ response, ok2 := msgLayer.(*GetCurrentDataResponse)
+ assert.True(t, ok2)
+ assert.NotNil(t, response)
+ assert.Equal(t, me.EthernetFrameExtendedPm64BitClassID, response.EntityClass)
+ assert.Equal(t, uint16(0), response.EntityInstance)
+ assert.Equal(t, me.Success, response.Result)
+ assert.Equal(t, uint16(0x0044), response.AttributeMask)
+ assert.Equal(t, uint64(0x123456781234dbcb), response.Attributes["OversizeFrames"])
+ assert.Equal(t, uint64(0x432187654321dac1), response.Attributes["Frames256To511Octets"])
+
+ // Verify string output for message
+ packetString := packet.String()
+ assert.NotZero(t, len(packetString))
+}
+
+func TestGetCurrentDataResponseSerialize(t *testing.T) {
+ goodMessage := "035e3c0a01aa0000000044123456781234dbcb432187654321dac10000000000000000000000000000000028"
+
+ omciLayer := &OMCI{
+ TransactionID: 0x035e,
+ MessageType: GetCurrentDataResponseType,
+ // DeviceIdentifier: omci.BaselineIdent, // Optional, defaults to Baseline
+ // Length: 0x28, // Optional, defaults to 40 octets
+ }
+ request := &GetCurrentDataResponse{
+ MeBasePacket: MeBasePacket{
+ EntityClass: me.EthernetFrameExtendedPm64BitClassID,
+ EntityInstance: uint16(0),
+ },
+ Result: 0,
+ AttributeMask: uint16(0x0044),
+ Attributes: me.AttributeValueMap{
+ "OversizeFrames": uint64(0x123456781234dbcb),
+ "Frames256To511Octets": uint64(0x432187654321dac1),
+ // BroadcastFrames can be supplied but will not be encoded since not in attribute mask.
+ "BroadcastFrames": uint64(0x0123456789abcdef)},
+ }
+ // Test serialization back to former string
+ var options gopacket.SerializeOptions
+ options.FixLengths = true
+
+ buffer := gopacket.NewSerializeBuffer()
+ err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
+ assert.NoError(t, err)
+
+ outgoingPacket := buffer.Bytes()
+ reconstituted := packetToString(outgoingPacket)
+ assert.Equal(t, strings.ToLower(goodMessage), reconstituted)
+}
+
// TODO: Also remember to add extended message tests to the meframe_test.go
// unit tests as more message types are supported