VOL-4337: Code upgrade for 3/2020 G.988 support and remaining Extended Message Set support
Change-Id: I6c5e1a167216ad9b51e9da89460e9909465ae1bc
diff --git a/synctime.go b/synctime.go
new file mode 100644
index 0000000..7e7cad0
--- /dev/null
+++ b/synctime.go
@@ -0,0 +1,314 @@
+/*
+ * 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 SynchronizeTimeRequest struct {
+ MeBasePacket
+ Year uint16
+ Month uint8
+ Day uint8
+ Hour uint8
+ Minute uint8
+ Second uint8
+}
+
+func (omci *SynchronizeTimeRequest) String() string {
+ return fmt.Sprintf("%v, Date-Time: %d/%d/%d-%02d:%02d:%02d",
+ omci.MeBasePacket.String(), omci.Year, omci.Month, omci.Day, omci.Hour, omci.Minute, omci.Second)
+}
+
+// LayerType returns LayerTypeSynchronizeTimeRequest
+func (omci *SynchronizeTimeRequest) LayerType() gopacket.LayerType {
+ return LayerTypeSynchronizeTimeRequest
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode
+func (omci *SynchronizeTimeRequest) CanDecode() gopacket.LayerClass {
+ return LayerTypeSynchronizeTimeRequest
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (omci *SynchronizeTimeRequest) NextLayerType() gopacket.LayerType {
+ return gopacket.LayerTypePayload
+}
+
+// DecodeFromBytes decodes the given bytes of a Synchronize Time Request into this layer
+func (omci *SynchronizeTimeRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
+ // Common ClassID/EntityID decode in msgBase
+ getDateAndTime := true
+ var offset, hdrSize int
+ if omci.Extended {
+ offset = 6
+ hdrSize = offset + 7
+ // Extended format allows for the OLT to support not setting the date and
+ // time (not present in the message)
+ // TODO: There is not a way to indicate this to the user at this time, currently
+ // all date/time fields will be zero
+ if len(data) < offset {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ if len(data) < hdrSize {
+ getDateAndTime = false
+ hdrSize = len(data)
+ }
+ } else {
+ offset = 4
+ hdrSize := offset + 7
+ if len(data) < hdrSize {
+ p.SetTruncated()
+ return errors.New("frame too small")
+ }
+ }
+ 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 Synchronize Time
+ if !me.SupportsMsgType(meDefinition, me.SynchronizeTime) {
+ return me.NewProcessingError("managed entity does not support Synchronize Time Message-Type")
+ }
+ // Synchronize Time Entity Class are always ONU-G (256) and Entity Instance of 0
+ if omci.EntityClass != me.OnuGClassID {
+ return me.NewProcessingError("invalid Entity Class for Synchronize Time request")
+ }
+ if omci.EntityInstance != 0 {
+ return me.NewUnknownInstanceError("invalid Entity Instance for Synchronize Time request")
+ }
+
+ if getDateAndTime {
+ omci.Year = binary.BigEndian.Uint16(data[offset:])
+ omci.Month = data[offset+2]
+ omci.Day = data[offset+3]
+ omci.Hour = data[offset+4]
+ omci.Minute = data[offset+5]
+ omci.Second = data[offset+6]
+ }
+ return nil
+}
+
+func decodeSynchronizeTimeRequest(data []byte, p gopacket.PacketBuilder) error {
+ omci := &SynchronizeTimeRequest{}
+ omci.MsgLayerType = LayerTypeSynchronizeTimeRequest
+ return decodingLayerDecoder(omci, data, p)
+}
+
+func decodeSynchronizeTimeRequestExtended(data []byte, p gopacket.PacketBuilder) error {
+ omci := &SynchronizeTimeRequest{}
+ omci.MsgLayerType = LayerTypeSynchronizeTimeRequest
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+}
+
+// SerializeTo provides serialization of an Synchronize Time Request message
+func (omci *SynchronizeTimeRequest) 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
+ }
+ entity, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
+ me.ParamData{EntityID: omci.EntityInstance})
+ if omciErr.StatusCode() != me.Success {
+ return omciErr.GetError()
+ }
+ // ME needs to support Synchronize Time
+ if !me.SupportsMsgType(entity, me.SynchronizeTime) {
+ return me.NewProcessingError("managed entity does not support the Synchronize Time Message-Type")
+ }
+ var offset, length int
+ if omci.Extended {
+ // TODO: Extended format allows for the OLT to support not setting the date and
+ // time (not present in the message). This needs to be supported in a future
+ // version of the software.
+ offset = 2
+ length = 7
+ } else {
+ offset = 0
+ length = 7
+ }
+ bytes, err := b.AppendBytes(offset + length)
+ if err != nil {
+ return err
+ }
+ if omci.Extended {
+ binary.BigEndian.PutUint16(bytes, uint16(length))
+ }
+ binary.BigEndian.PutUint16(bytes[offset:], omci.Year)
+ if length > 0 {
+ bytes[offset+2] = omci.Month
+ bytes[offset+3] = omci.Day
+ bytes[offset+4] = omci.Hour
+ bytes[offset+5] = omci.Minute
+ bytes[offset+6] = omci.Second
+ }
+ return nil
+}
+
+type SynchronizeTimeResponse struct {
+ MeBasePacket
+ Result me.Results
+ SuccessResults uint8 // Only if 'Result' is 0 -> success
+}
+
+func (omci *SynchronizeTimeResponse) String() string {
+ return fmt.Sprintf("%v, Results: %d (%v), Success: %d",
+ omci.MeBasePacket.String(), omci.Result, omci.Result, omci.SuccessResults)
+}
+
+// LayerType returns LayerTypeSynchronizeTimeResponse
+func (omci *SynchronizeTimeResponse) LayerType() gopacket.LayerType {
+ return LayerTypeSynchronizeTimeResponse
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode
+func (omci *SynchronizeTimeResponse) CanDecode() gopacket.LayerClass {
+ return LayerTypeSynchronizeTimeResponse
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (omci *SynchronizeTimeResponse) NextLayerType() gopacket.LayerType {
+ return gopacket.LayerTypePayload
+}
+
+// DecodeFromBytes decodes the given bytes of a Synchronize Time Response into this layer
+func (omci *SynchronizeTimeResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
+ // Common ClassID/EntityID decode in msgBase
+ var hdrSize, offset int
+ if omci.Extended {
+ offset = 6
+ hdrSize = offset + 1
+ // TODO: Extended message set allows for the optional encoding of the of the
+ // 12th octet (success results) even if the result code is not 0/success.
+ // This functionality is not currently supported.
+ } else {
+ offset = 4
+ hdrSize = offset + 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 Synchronize Time
+ if !me.SupportsMsgType(meDefinition, me.SynchronizeTime) {
+ return me.NewProcessingError("managed entity does not support Synchronize Time Message-Type")
+ }
+ // Synchronize Time Entity Class are always ONU-G (256) and Entity Instance of 0
+ if omci.EntityClass != me.OnuGClassID {
+ return me.NewProcessingError("invalid Entity Class for Synchronize Time response")
+ }
+ if omci.EntityInstance != 0 {
+ return me.NewUnknownInstanceError("invalid Entity Instance for Synchronize Time response")
+ }
+
+ omci.Result = me.Results(data[offset])
+ if omci.Result > me.DeviceBusy {
+ msg := fmt.Sprintf("invalid results code: %v, must be 0..6", omci.Result)
+ return errors.New(msg)
+ }
+ if omci.Result == me.Success && len(data) > offset+1 {
+ omci.SuccessResults = data[offset+1]
+ } else if omci.Extended && len(data) > offset+1 {
+ omci.SuccessResults = data[offset+1]
+ }
+ return nil
+}
+
+func decodeSynchronizeTimeResponse(data []byte, p gopacket.PacketBuilder) error {
+ omci := &SynchronizeTimeResponse{}
+ omci.MsgLayerType = LayerTypeSynchronizeTimeResponse
+ return decodingLayerDecoder(omci, data, p)
+}
+
+func decodeSynchronizeTimeResponseExtended(data []byte, p gopacket.PacketBuilder) error {
+ omci := &SynchronizeTimeResponse{}
+ omci.MsgLayerType = LayerTypeSynchronizeTimeResponse
+ omci.Extended = true
+ return decodingLayerDecoder(omci, data, p)
+}
+
+// SerializeTo provides serialization of an Synchronize Time Response message
+func (omci *SynchronizeTimeResponse) 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
+ }
+ entity, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
+ me.ParamData{EntityID: omci.EntityInstance})
+ if omciErr.StatusCode() != me.Success {
+ return omciErr.GetError()
+ }
+ // Synchronize Time Entity Class are always ONU DATA (2) and Entity Instance of 0
+ if omci.EntityClass != me.OnuGClassID {
+ return me.NewProcessingError("invalid Entity Class for Synchronize Time response")
+ }
+ if omci.EntityInstance != 0 {
+ return me.NewUnknownInstanceError("invalid Entity Instance for Synchronize Time response")
+ }
+ // ME needs to support Synchronize Time
+ if !me.SupportsMsgType(entity, me.SynchronizeTime) {
+ return me.NewProcessingError("managed entity does not support the Synchronize Time Message-Type")
+ }
+ var offset int
+ if omci.Extended {
+ offset = 2
+ } else {
+ offset = 0
+ }
+ numBytes := 2
+ if omci.Result != me.Success {
+ // TODO: Extended message set allows for the optional encoding of the of the
+ // 12th octet (success results) even if the result code is not 0/success.
+ // This functionality is not currently supported
+ numBytes = 1
+ }
+ bytes, err := b.AppendBytes(offset + numBytes)
+ if err != nil {
+ return err
+ }
+ if omci.Extended {
+ binary.BigEndian.PutUint16(bytes, uint16(numBytes))
+ }
+ bytes[offset] = uint8(omci.Result)
+ if omci.Result == me.Success {
+ // TODO: Extended message set allows for the optional encoding of the of the
+ // 12th octet (success results) even if the result code is not 0/success.
+ // This functionality is not currently supported
+ bytes[offset+1] = omci.SuccessResults
+ }
+ return nil
+}