internal/common/omci/mibpackets.go

/*
 * Copyright 2018-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/hex"
	"github.com/cboling/omci"
	me "github.com/cboling/omci/generated"
	"github.com/google/gopacket"
	omcisim "github.com/opencord/omci-sim"
	log "github.com/sirupsen/logrus"
)

var omciLogger = log.WithFields(log.Fields{
	"module": "OMCI",
})

const galEthernetEID = uint16(1)
const maxGemPayloadSize = uint16(48)
const gemEID = uint16(1)

type txFrameCreator func() ([]byte, error)
type rxFrameParser func(gopacket.Packet) error

type ServiceStep struct {
	MakeTxFrame txFrameCreator
	RxHandler   rxFrameParser
}

func serialize(msgType omci.MessageType, request gopacket.SerializableLayer, tid uint16) ([]byte, error) {
	omciLayer := &omci.OMCI{
		TransactionID: tid,
		MessageType:   msgType,
	}
	var options gopacket.SerializeOptions
	options.FixLengths = true

	buffer := gopacket.NewSerializeBuffer()
	err := gopacket.SerializeLayers(buffer, options, omciLayer, request)
	if err != nil {
		return nil, err
	}
	return buffer.Bytes(), nil
}

func hexEncode(omciPkt []byte) ([]byte, error) {
	dst := make([]byte, hex.EncodedLen(len(omciPkt)))
	hex.Encode(dst, omciPkt)
	return dst, nil
}

func DecodeOmci(payload []byte) (omci.MessageType, gopacket.Packet) {
	// Perform base OMCI decode (common to all requests)
	packet := gopacket.NewPacket(payload, omci.LayerTypeOMCI, gopacket.NoCopy)

	if omciLayer := packet.Layer(omci.LayerTypeOMCI); omciLayer != nil {

		omciObj, omciOk := omciLayer.(*omci.OMCI)
		if !omciOk {
			panic("Not Expected") // TODO: Do something better or delete...
		}
		if byte(omciObj.MessageType) & ^me.AK == 0 {
			// Not a response, silently discard
			return 0, nil
		}
		return omciObj.MessageType, packet
	}

	// FIXME
	// if we can't properly decode the packet, try using shad helper method
	// most likely this won't be necessary once we move omci-sim to use cboling/omci
	// to generate packets
	_, _, msgType, _, _, _, err := omcisim.ParsePkt(payload)
	if err != nil {
		return 0, nil
	}
	if msgType == omcisim.MibReset {
		return omci.MibResetResponseType, nil
	}
	if msgType == omcisim.MibUpload {
		return omci.MibUploadResponseType, nil
	}
	if msgType == omcisim.MibUploadNext {
		return omci.MibUploadNextResponseType, nil
	}
	if msgType == omcisim.Create {
		return omci.CreateResponseType, nil
	}
	if msgType == omcisim.Set {
		return omci.SetResponseType, nil
	}

	omciLogger.Warnf("omci-sim returns msgType: %d", msgType)

	return 0, nil
}

func CreateMibResetRequest(tid uint16) ([]byte, error) {

	request := &omci.MibResetRequest{
		MeBasePacket: omci.MeBasePacket{
			EntityClass: me.OnuDataClassId,
		},
	}
	pkt, err := serialize(omci.MibResetRequestType, request, tid)
	if err != nil {
		omciLogger.WithFields(log.Fields{
			"Err": err,
		}).Fatalf("Cannot serialize MibResetRequest")
		return nil, err
	}
	return hexEncode(pkt)
}

func CreateMibUploadRequest(tid uint16) ([]byte, error) {
	request := &omci.MibUploadRequest{
		MeBasePacket: omci.MeBasePacket{
			EntityClass: me.OnuDataClassId,
			// Default Instance ID is 0
		},
	}
	pkt, err := serialize(omci.MibUploadRequestType, request, tid)
	if err != nil {
		omciLogger.WithFields(log.Fields{
			"Err": err,
		}).Fatalf("Cannot serialize MibUploadRequest")
		return nil, err
	}
	return hexEncode(pkt)
}

func CreateMibUploadNextRequest(tid uint16, seqNumber uint16) ([]byte, error) {

	request := &omci.MibUploadNextRequest{
		MeBasePacket: omci.MeBasePacket{
			EntityClass: me.OnuDataClassId,
			// Default Instance ID is 0
		},
		CommandSequenceNumber: seqNumber,
	}
	pkt, err := serialize(omci.MibUploadNextRequestType, request, tid)

	if err != nil {
		omciLogger.WithFields(log.Fields{
			"Err": err,
		}).Fatalf("Cannot serialize MibUploadNextRequest")
		return nil, err
	}
	return hexEncode(pkt)
}

// Return true if msg is an Omci Test Request
func IsTestRequest(payload []byte) (bool, error) {
	_, _, msgType, _, _, _, err := omcisim.ParsePkt(payload)
	if err != nil {
		return false, err
	}

	return ((msgType & 0x1F) == 18), nil
}

func BuildTestResult(payload []byte) ([]byte, error) {
	transactionId, deviceId, _, class, instance, _, err := omcisim.ParsePkt(payload)

	if err != nil {
		return []byte{}, err
	}

	resp := make([]byte, 26)
	resp[0] = byte(transactionId >> 8)
	resp[1] = byte(transactionId & 0xFF)
	resp[2] = 27 // Upper nibble 0x0 is fixed (0000), Lower nibbles defines msg type (TestResult=27)
	resp[3] = deviceId
	resp[4] = byte(class >> 8)
	resp[5] = byte(class & 0xFF)
	resp[6] = byte(instance >> 8)
	resp[7] = byte(instance & 0xFF)
	resp[8] = 0  // high byte of contents length
	resp[9] = 17 // low byte of contents length
	// Each of these is a 1-byte code
	// follow by a 2-byte (high, low) value
	resp[10] = 1 // power feed voltage
	resp[11] = 0
	resp[12] = 123 // feed voltage 123 mV, 20 mv res --> 6mv
	resp[13] = 3   // received optical power
	resp[14] = 1
	resp[15] = 200 // 456 decibel-microwatts, 0.002 dB res --> 0.912 db-mw
	resp[16] = 5   // mean optical launch power
	resp[17] = 3
	resp[18] = 21 // 789 uA, 2uA res --> 394uA
	resp[19] = 9  // laser bias current
	resp[20] = 38
	resp[21] = 148 // 9876 deg C, 1/256 resolution --> 38.57 Deg C
	resp[22] = 12  // temperature

	return resp, nil
}

// TODO understand and refactor

func CreateGalEnetRequest(tid uint16) ([]byte, error) {
	params := me.ParamData{
		EntityID:   galEthernetEID,
		Attributes: me.AttributeValueMap{"MaximumGemPayloadSize": maxGemPayloadSize},
	}
	meDef, _ := me.NewGalEthernetProfile(params)
	pkt, err := omci.GenFrame(meDef, omci.CreateRequestType, omci.TransactionID(tid))
	if err != nil {
		omciLogger.WithField("err", err).Fatalf("Can't generate GalEnetRequest")
	}
	return hexEncode(pkt)
}

func CreateEnableUniRequest(tid uint16, uniId uint16, enabled bool, isPtp bool) ([]byte, error) {

	var _enabled uint8
	if enabled {
		_enabled = uint8(1)
	} else {
		_enabled = uint8(0)
	}

	data := me.ParamData{
		EntityID: uniId,
		Attributes: me.AttributeValueMap{
			"AdministrativeState": _enabled,
		},
	}
	var medef *me.ManagedEntity
	var omciErr me.OmciErrors

	if isPtp {
		medef, omciErr = me.NewPhysicalPathTerminationPointEthernetUni(data)
	} else {
		medef, omciErr = me.NewVirtualEthernetInterfacePoint(data)
	}
	if omciErr != nil {
		return nil, omciErr.GetError()
	}
	pkt, err := omci.GenFrame(medef, omci.SetRequestType, omci.TransactionID(tid))
	if err != nil {
		omciLogger.WithField("err", err).Fatalf("Can't generate EnableUniRequest")
	}
	return hexEncode(pkt)
}

func CreateGemPortRequest(tid uint16) ([]byte, error) {
	params := me.ParamData{
		EntityID: gemEID,
		Attributes: me.AttributeValueMap{
			"PortId":                              1,
			"TContPointer":                        1,
			"Direction":                           0,
			"TrafficManagementPointerForUpstream": 0,
			"TrafficDescriptorProfilePointerForUpstream": 0,
			"UniCounter":                                   0,
			"PriorityQueuePointerForDownStream":            0,
			"EncryptionState":                              0,
			"TrafficDescriptorProfilePointerForDownstream": 0,
			"EncryptionKeyRing":                            0,
		},
	}
	meDef, _ := me.NewGemPortNetworkCtp(params)
	pkt, err := omci.GenFrame(meDef, omci.CreateRequestType, omci.TransactionID(tid))
	if err != nil {
		omciLogger.WithField("err", err).Fatalf("Can't generate GemPortRequest")
	}
	return hexEncode(pkt)
}

// END TODO