blob: 403efa4db229f4f60e7f65383656b86f9adbf5e7 [file] [log] [blame]
/*
* 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