get.go

/*
 * Copyright (c) 2018 - present.  Boling Consulting Solutions (bcsw.net)
 * Copyright 2020-present Open Networking Foundation

 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at

 * http://www.apache.org/licenses/LICENSE-2.0

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package omci

import (
	"encoding/binary"
	"errors"
	"fmt"
	"github.com/google/gopacket"
	me "github.com/opencord/omci-lib-go/generated"
)

type GetRequest struct {
	MeBasePacket
	AttributeMask uint16
}

func (omci *GetRequest) String() string {
	return fmt.Sprintf("%v, Mask: %#x",
		omci.MeBasePacket.String(), omci.AttributeMask)
}

// LayerType returns LayerTypeGetRequest
func (omci *GetRequest) LayerType() gopacket.LayerType {
	return LayerTypeGetRequest
}

// CanDecode returns the set of layer types that this DecodingLayer can decode
func (omci *GetRequest) CanDecode() gopacket.LayerClass {
	return LayerTypeGetRequest
}

// NextLayerType returns the layer type contained by this DecodingLayer.
func (omci *GetRequest) NextLayerType() gopacket.LayerType {
	return gopacket.LayerTypePayload
}

// DecodeFromBytes decodes the given bytes of a Get Request into this layer
func (omci *GetRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
	// Common ClassID/EntityID decode in msgBase
	var hdrSize int
	if omci.Extended {
		hdrSize = 6 + 2
	} else {
		hdrSize = 4 + 2
	}
	err := omci.MeBasePacket.DecodeFromBytes(data, p, hdrSize)
	if err != nil {
		return err
	}
	meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
		me.ParamData{EntityID: omci.EntityInstance})
	if omciErr.StatusCode() != me.Success {
		return omciErr.GetError()
	}
	// ME needs to support Get
	if !me.SupportsMsgType(meDefinition, me.Get) {
		return me.NewProcessingError("managed entity does not support Get Message-Type")
	}
	if omci.Extended {
		if len(data) < 8 {
			p.SetTruncated()
			return errors.New("frame too small")
		}
		omci.AttributeMask = binary.BigEndian.Uint16(data[6:])
	} else {
		omci.AttributeMask = binary.BigEndian.Uint16(data[4:])
	}
	return nil
}

func decodeGetRequest(data []byte, p gopacket.PacketBuilder) error {
	omci := &GetRequest{}
	omci.MsgLayerType = LayerTypeGetRequest
	return decodingLayerDecoder(omci, data, p)
}

func decodeGetRequestExtended(data []byte, p gopacket.PacketBuilder) error {
	omci := &GetRequest{}
	omci.MsgLayerType = LayerTypeGetRequest
	omci.Extended = true
	return decodingLayerDecoder(omci, data, p)
}

// SerializeTo provides serialization of an Get Request message
func (omci *GetRequest) SerializeTo(b gopacket.SerializeBuffer, _ gopacket.SerializeOptions) error {
	// Basic (common) OMCI Header is 8 octets, 10
	err := omci.MeBasePacket.SerializeTo(b)
	if err != nil {
		return err
	}
	meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
		me.ParamData{EntityID: omci.EntityInstance})
	if omciErr.StatusCode() != me.Success {
		return omciErr.GetError()
	}
	// ME needs to support Set
	if !me.SupportsMsgType(meDefinition, me.Get) {
		return me.NewProcessingError("managed entity does not support Get Message-Type")
	}
	maskOffset := 0
	if omci.Extended {
		maskOffset = 2
	}
	bytes, err := b.AppendBytes(2 + maskOffset)
	if err != nil {
		return err
	}
	if omci.Extended {
		binary.BigEndian.PutUint16(bytes, uint16(2))
	}
	binary.BigEndian.PutUint16(bytes[maskOffset:], omci.AttributeMask)
	return nil
}

type GetResponse struct {
	MeBasePacket
	Result                   me.Results
	AttributeMask            uint16
	Attributes               me.AttributeValueMap
	UnsupportedAttributeMask uint16
	FailedAttributeMask      uint16
}

func (omci *GetResponse) String() string {
	return fmt.Sprintf("%v, Result: %d (%v), Mask: %#x, Unsupported: %#x, Failed: %#x, attributes: %v",
		omci.MeBasePacket.String(), omci.Result, omci.Result, omci.AttributeMask,
		omci.UnsupportedAttributeMask, omci.FailedAttributeMask, omci.Attributes)
}

// LayerType returns LayerTypeGetResponse
func (omci *GetResponse) LayerType() gopacket.LayerType {
	return LayerTypeGetResponse
}

// CanDecode returns the set of layer types that this DecodingLayer can decode
func (omci *GetResponse) CanDecode() gopacket.LayerClass {
	return LayerTypeGetResponse
}

// NextLayerType returns the layer type contained by this DecodingLayer.
func (omci *GetResponse) NextLayerType() gopacket.LayerType {
	return gopacket.LayerTypePayload
}

// DecodeFromBytes decodes the given bytes of a Get Response into this layer
func (omci *GetResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
	// Common ClassID/EntityID decode in msgBase
	err := omci.MeBasePacket.DecodeFromBytes(data, p, 4+3)
	if err != nil {
		return err
	}
	meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
		me.ParamData{EntityID: omci.EntityInstance})
	if omciErr.StatusCode() != me.Success {
		return omciErr.GetError()
	}
	// ME needs to support Get
	if !me.SupportsMsgType(meDefinition, me.Get) {
		return me.NewProcessingError("managed entity does not support Get Message-Type")
	}
	if omci.Extended {
		if len(data) < 13 {
			p.SetTruncated()
			return errors.New("frame too small")
		}
		omci.Result = me.Results(data[6])
		omci.AttributeMask = binary.BigEndian.Uint16(data[7:])

		// If Attribute failed or Unknown, decode optional attribute mask
		if omci.Result == me.AttributeFailure {
			omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[9:])
			omci.FailedAttributeMask = binary.BigEndian.Uint16(data[11:])
		}
	} else {
		omci.Result = me.Results(data[4])
		omci.AttributeMask = binary.BigEndian.Uint16(data[5:])

		// If Attribute failed or Unknown, decode optional attribute mask
		if omci.Result == me.AttributeFailure {
			omci.UnsupportedAttributeMask = binary.BigEndian.Uint16(data[32:34])
			omci.FailedAttributeMask = binary.BigEndian.Uint16(data[34:36])
		}
	}
	// 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.  So accommodate
	//                   this behaviour in favor of greater interoperability.
	firstOctet := 7
	lastOctet := 36
	if omci.Extended {
		firstOctet = 13
		lastOctet = len(data)
	}

	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 {
			lastOctet = 32
		}
	}
	omci.Attributes, err = meDefinition.DecodeAttributes(omci.AttributeMask,
		data[firstOctet:lastOctet], p, byte(GetResponseType))
	if err != nil {
		return err
	}
	// 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 decodeGetResponse(data []byte, p gopacket.PacketBuilder) error {
	omci := &GetResponse{}
	omci.MsgLayerType = LayerTypeGetResponse
	return decodingLayerDecoder(omci, data, p)
}

func decodeGetResponseExtended(data []byte, p gopacket.PacketBuilder) error {
	omci := &GetResponse{}
	omci.MsgLayerType = LayerTypeGetResponse
	omci.Extended = true
	return decodingLayerDecoder(omci, data, p)
}

// SerializeTo provides serialization of an Get Response message
func (omci *GetResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
	// Basic (common) OMCI Header is 8 octets, 10
	if err := omci.MeBasePacket.SerializeTo(b); err != nil {
		return err
	}
	meDefinition, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
		me.ParamData{EntityID: omci.EntityInstance})

	if omciErr.StatusCode() != me.Success {
		return omciErr.GetError()
	}
	// ME needs to support Get
	if !me.SupportsMsgType(meDefinition, me.Get) {
		return me.NewProcessingError("managed entity does not support the Get Message-Type")
	}
	resultOffset := 0
	attributeErrExtra := 0

	if omci.Extended {
		resultOffset = 2
		attributeErrExtra = 4 // Attribute mask + attribute error masks
	}
	// Space for result + mask (both types) + (len & error masks if extended)
	buffer, err := b.AppendBytes(3 + resultOffset + attributeErrExtra)
	if err != nil {
		return err
	}
	// Save result and initial mask. Other header fields updated after
	// attribute copy
	buffer[resultOffset] = byte(omci.Result)
	binary.BigEndian.PutUint16(buffer[resultOffset+1:], omci.AttributeMask)

	// Validate all attributes requested 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 && (attr.Mask&omci.AttributeMask != 0) && !me.SupportsAttributeAccess(*attr, me.Read) {
			msg := fmt.Sprintf("attribute '%v' does not support read access", attrName)
			return me.NewProcessingError(msg)
		}
	}
	// Attribute serialization
	switch omci.Result {
	default:
		if omci.Extended {
			// Minimum length is 7 for extended an need to write error masks
			binary.BigEndian.PutUint16(buffer, uint16(7))
			binary.BigEndian.PutUint32(buffer[resultOffset+3:], 0)
		}
		break

	case me.Success, me.AttributeFailure:
		// TODO: Baseline only supported at this time)
		var available int
		if omci.Extended {
			available = MaxExtendedLength - 18 - 4 // Less: header, mic
		} else {
			available = MaxBaselineLength - 11 - 4 - 8 // Less: header, failed attributes, length, mic
		}
		// 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(GetResponseType), available, opts.FixLengths)

		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
			buffer[resultOffset] = byte(omci.Result)
			binary.BigEndian.PutUint16(buffer[resultOffset+1:], omci.AttributeMask)
		}
		if omci.Extended {
			// Set length and any failure masks
			binary.BigEndian.PutUint16(buffer, uint16(len(attributeBuffer.Bytes())+7))

			if omci.Result == me.AttributeFailure {
				binary.BigEndian.PutUint16(buffer[resultOffset+3:], omci.UnsupportedAttributeMask)
				binary.BigEndian.PutUint16(buffer[resultOffset+5:], omci.FailedAttributeMask)
			} else {
				binary.BigEndian.PutUint32(buffer[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
}