omci

package module
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 5, 2019 License: Apache-2.0 Imports: 7 Imported by: 7

README

OMCI

OMCI gopacket library supports the encoding and decoding of ITU G.988 OMCI messages. It is currently a work in progress.

Message Types supported and under unit test

The following OMCI message types currently have been coded and are covered by unit tests.

  • CreateRequest
  • MibResetRequest
  • MibResetResponse

Message Types supported but lacking full unit test

The following OMCI message types currently have been coded and are partially covered by unit tests, but work still remains for sufficient unit test coverage.

  • CreateResponse
  • SetRequest
  • SetResponse
  • GetRequest
  • GetResponse
  • GetAllAlarmsRequest
  • GetAllAlarmsResponse
  • MibUploadRequest
  • MibUploadResponse
  • MibUploadNextRequest
  • MibUploadNextResponse
  • SynchronizeTimeRequest
  • SynchronizeTimeResponse
  • AttributeValueChange

Message Types supported but lacking any unit test

The following OMCI message types currently have been coded but any unit test coverage.

  • DeleteRequest
  • DeleteResponse
  • GetAllAlarmsNextRequest
  • GetAllAlarmsNextResponse
  • RebootRequest
  • RebootResponse
  • StartSoftwareDownloadResponse
  • StartSoftwareDownloadRequest
  • DownloadSectionRequest
  • DownloadSectionResponse
  • EndSoftwareDownloadRequest
  • EndSoftwareDownloadResponse
  • ActivateSoftwareRequest
  • ActivateSoftwareResponse
  • CommitSoftwareRequest
  • CommitSoftwareResponse
  • GetNextRequest
  • GetNextResponse
  • GetCurrentDataRequest
  • GetCurrentDataResponse
  • AlarmNotification

Message Types not yet supported

The following OMCI message types currently have not been coded.

  • TestResult
  • TestRequest
  • TestResponse
  • SetTableRequest
  • SetTableResponse

Other outstanding items

Besides OMCI Message decode/serialization, and associated unit tests, the following items would be needed or useful in a first official release of this library. Some changes are to be done in the generated OMCI ME code as well.

  • Specific examples of how to use this library (expand upon DecodeEncode.go examples) Include unknown ME examples and how to catch various common or expected errors
  • Add Alarm Table Support (generated MEs also)
  • Add AVC flag for appropriate attributes
  • For serialization, check early for message size exceeded
  • Check proper gopacket use of Payload/Contents properties and make sure we follow guidelines (if there are any)
  • For 'mebase.go' string output, look up ME name and output as needed
  • Look through 'error' messages and see if there are a few very common ones that could be moved to a custom class to allow for better user interception/decode of these errors.

The following would be 'nice' to have but are not necessary for initial code release

  • Extended message support
  • MIC Encode/Decode support

Documentation

Overview

* Copyright (c) 2018 - present. Boling Consulting Solutions (bcsw.net) * * 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. *

* Copyright (c) 2018 - present. Boling Consulting Solutions (bcsw.net) * * 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. *

* Copyright (c) 2018 - present. Boling Consulting Solutions (bcsw.net) * * 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.

* NOTE: This file was generated, manual edits will be overwritten! * * Generated by 'goCodeGenerator.py': * https://github.com/cboling/OMCI-parser/README.md

* Copyright (c) 2018 - present. Boling Consulting Solutions (bcsw.net) * * 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. *

* Copyright (c) 2018 - present. Boling Consulting Solutions (bcsw.net) * * 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. *

* Copyright (c) 2018 - present. Boling Consulting Solutions (bcsw.net) * * 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. *

Index

Constants

View Source 
const AlarmBitmapSize = 224

/////////////////////////////////////////////////////////////////////////// AlarmNotificationMsg

View Source 
const MaxBaselineLength = 48

MaxBaselineLength is the maximum number of octets allowed in an OMCI Baseline message. Depending on the adapter, it may or may not include the

View Source 
const MaxExtendedLength = 1980

MaxExtendedLength is the maximum number of octets allowed in an OMCI Extended message (including header).

Variables

View Source 
var (
	LayerTypeCreateRequest                gopacket.LayerType
	LayerTypeDeleteRequest                gopacket.LayerType
	LayerTypeSetRequest                   gopacket.LayerType
	LayerTypeGetRequest                   gopacket.LayerType
	LayerTypeGetAllAlarmsRequest          gopacket.LayerType
	LayerTypeGetAllAlarmsNextRequest      gopacket.LayerType
	LayerTypeMibUploadRequest             gopacket.LayerType
	LayerTypeMibUploadNextRequest         gopacket.LayerType
	LayerTypeMibResetRequest              gopacket.LayerType
	LayerTypeTestRequest                  gopacket.LayerType
	LayerTypeStartSoftwareDownloadRequest gopacket.LayerType
	LayerTypeDownloadSectionRequest       gopacket.LayerType
	LayerTypeDownloadSectionLastRequest   gopacket.LayerType
	LayerTypeEndSoftwareDownloadRequest   gopacket.LayerType
	LayerTypeActivateSoftwareRequest      gopacket.LayerType
	LayerTypeCommitSoftwareRequest        gopacket.LayerType
	LayerTypeSynchronizeTimeRequest       gopacket.LayerType
	LayerTypeRebootRequest                gopacket.LayerType
	LayerTypeGetNextRequest               gopacket.LayerType
	LayerTypeGetCurrentDataRequest        gopacket.LayerType
	LayerTypeSetTableRequest              gopacket.LayerType
)
View Source 
var (
	LayerTypeCreateResponse                gopacket.LayerType
	LayerTypeDeleteResponse                gopacket.LayerType
	LayerTypeSetResponse                   gopacket.LayerType
	LayerTypeGetResponse                   gopacket.LayerType
	LayerTypeGetAllAlarmsResponse          gopacket.LayerType
	LayerTypeGetAllAlarmsNextResponse      gopacket.LayerType
	LayerTypeMibUploadResponse             gopacket.LayerType
	LayerTypeMibUploadNextResponse         gopacket.LayerType
	LayerTypeMibResetResponse              gopacket.LayerType
	LayerTypeAlarmNotification             gopacket.LayerType
	LayerTypeAttributeValueChange          gopacket.LayerType
	LayerTypeTestResponse                  gopacket.LayerType
	LayerTypeStartSoftwareDownloadResponse gopacket.LayerType
	LayerTypeDownloadSectionResponse       gopacket.LayerType
	LayerTypeEndSoftwareDownloadResponse   gopacket.LayerType
	LayerTypeActivateSoftwareResponse      gopacket.LayerType
	LayerTypeCommitSoftwareResponse        gopacket.LayerType
	LayerTypeSynchronizeTimeResponse       gopacket.LayerType
	LayerTypeRebootResponse                gopacket.LayerType
	LayerTypeGetNextResponse               gopacket.LayerType
	LayerTypeTestResult                    gopacket.LayerType
	LayerTypeGetCurrentDataResponse        gopacket.LayerType
	LayerTypeSetTableResponse              gopacket.LayerType
)
View Source 
var (
	LayerTypeOMCI gopacket.LayerType
)
View Source 
var OmciIK = []byte{0x18, 0x4b, 0x8a, 0xd4, 0xd1, 0xac, 0x4a, 0xf4,
	0xdd, 0x4b, 0x33, 0x9e, 0xcc, 0x0d, 0x33, 0x70}

Functions

func MsgTypeToNextLayer 

func MsgTypeToNextLayer(mt MessageType) (gopacket.LayerType, error)

Types

type ActivateSoftwareRequest 

type ActivateSoftwareRequest struct {
	MeBasePacket  // Note: EntityInstance for software download is two specific values
	ActivateFlags byte
}

///////////////////////////////////////////////////////////////////////////

func (*ActivateSoftwareRequest) DecodeFromBytes 

func (omci *ActivateSoftwareRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*ActivateSoftwareRequest) SerializeTo 

func (omci *ActivateSoftwareRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type ActivateSoftwareResponse 

type ActivateSoftwareResponse struct {
	MeBasePacket
	Result me.Results
}

///////////////////////////////////////////////////////////////////////////

func (*ActivateSoftwareResponse) DecodeFromBytes 

func (omci *ActivateSoftwareResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*ActivateSoftwareResponse) SerializeTo 

func (omci *ActivateSoftwareResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type AlarmNotificationMsg 

type AlarmNotificationMsg struct {
	MeBasePacket
	AlarmBitmap [AlarmBitmapSize / 8]byte

	AlarmSequenceNumber byte
	// contains filtered or unexported fields
}

func (*AlarmNotificationMsg) ActivateAlarm 

func (omci *AlarmNotificationMsg) ActivateAlarm(alarmNumber uint8) error

func (*AlarmNotificationMsg) ClearAlarm 

func (omci *AlarmNotificationMsg) ClearAlarm(alarmNumber uint8) error

func (*AlarmNotificationMsg) DecodeFromBytes 

func (omci *AlarmNotificationMsg) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*AlarmNotificationMsg) IsAlarmActive 

func (omci *AlarmNotificationMsg) IsAlarmActive(alarmNumber uint8) (bool, error)

func (*AlarmNotificationMsg) IsAlarmClear 

func (omci *AlarmNotificationMsg) IsAlarmClear(alarmNumber uint8) (bool, error)

func (*AlarmNotificationMsg) SerializeTo 

func (omci *AlarmNotificationMsg) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*AlarmNotificationMsg) String 

func (omci *AlarmNotificationMsg) String() string

type AttributeValueChangeMsg 

type AttributeValueChangeMsg struct {
	MeBasePacket
	AttributeMask uint16
	Attributes    me.AttributeValueMap
}

/////////////////////////////////////////////////////////////////////////// AttributeValueChangeMsg

func (*AttributeValueChangeMsg) DecodeFromBytes 

func (omci *AttributeValueChangeMsg) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*AttributeValueChangeMsg) SerializeTo 

func (omci *AttributeValueChangeMsg) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*AttributeValueChangeMsg) String 

func (omci *AttributeValueChangeMsg) String() string

type BaseManagedEntityInstance 

type BaseManagedEntityInstance struct {
	MEDefinition  me.IManagedEntityDefinition
	AttributeMask uint16
	Attributes    me.AttributeValueMap
}

func (*BaseManagedEntityInstance) DecodeFromBytes 

func (bme *BaseManagedEntityInstance) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

DecodeFromBytes is typically used to decode an ME in a message payload for messages of type MibUploadNextResponse, AVC Notifications, ...

func (*BaseManagedEntityInstance) GetAttributeMask 

func (bme *BaseManagedEntityInstance) GetAttributeMask() uint16

func (*BaseManagedEntityInstance) GetAttributes 

func (bme *BaseManagedEntityInstance) GetAttributes() me.AttributeValueMap

func (*BaseManagedEntityInstance) SerializeTo 

func (bme *BaseManagedEntityInstance) SerializeTo(b gopacket.SerializeBuffer) error

func (*BaseManagedEntityInstance) SetAttributeMask 

func (bme *BaseManagedEntityInstance) SetAttributeMask(mask uint16) error

func (*BaseManagedEntityInstance) SetAttributes 

func (bme *BaseManagedEntityInstance) SetAttributes(attributes me.AttributeValueMap) error

func (*BaseManagedEntityInstance) String 

func (bme *BaseManagedEntityInstance) String() string

type CommitSoftwareRequest 

type CommitSoftwareRequest struct {
	MeBasePacket
}

///////////////////////////////////////////////////////////////////////////

func (*CommitSoftwareRequest) DecodeFromBytes 

func (omci *CommitSoftwareRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*CommitSoftwareRequest) SerializeTo 

func (omci *CommitSoftwareRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type CommitSoftwareResponse 

type CommitSoftwareResponse struct {
	MeBasePacket
}

///////////////////////////////////////////////////////////////////////////

func (*CommitSoftwareResponse) DecodeFromBytes 

func (omci *CommitSoftwareResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*CommitSoftwareResponse) SerializeTo 

func (omci *CommitSoftwareResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type CreateRequest 

type CreateRequest struct {
	MeBasePacket
	Attributes me.AttributeValueMap
}

/////////////////////////////////////////////////////////////////////////// CreateRequest

func (*CreateRequest) DecodeFromBytes 

func (omci *CreateRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*CreateRequest) SerializeTo 

func (omci *CreateRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*CreateRequest) String 

func (omci *CreateRequest) String() string

type CreateResponse 

type CreateResponse struct {
	MeBasePacket
	Result                 me.Results
	AttributeExecutionMask uint16
}

/////////////////////////////////////////////////////////////////////////// CreateResponse

func (*CreateResponse) DecodeFromBytes 

func (omci *CreateResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*CreateResponse) SerializeTo 

func (omci *CreateResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*CreateResponse) String 

func (omci *CreateResponse) String() string

type DeleteRequest 

type DeleteRequest struct {
	MeBasePacket
}

/////////////////////////////////////////////////////////////////////////// DeleteRequest

func (*DeleteRequest) DecodeFromBytes 

func (omci *DeleteRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*DeleteRequest) SerializeTo 

func (omci *DeleteRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*DeleteRequest) String 

func (omci *DeleteRequest) String() string

type DeleteResponse 

type DeleteResponse struct {
	MeBasePacket
	Result me.Results
}

/////////////////////////////////////////////////////////////////////////// DeleteResponse

func (*DeleteResponse) DecodeFromBytes 

func (omci *DeleteResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*DeleteResponse) SerializeTo 

func (omci *DeleteResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*DeleteResponse) String 

func (omci *DeleteResponse) String() string

type DeviceIdent 

type DeviceIdent byte
const (
	BaselineIdent DeviceIdent = 0x0A // All G-PON OLTs and ONUs support the baseline message set
	ExtendedIdent DeviceIdent = 0x0B
)

func (DeviceIdent) String 

func (di DeviceIdent) String() string

type DownloadSectionRequest 

type DownloadSectionRequest struct {
	MeBasePacket  // Note: EntityInstance for software download is two specific values
	SectionNumber byte
	SectionData   [29]byte // 0 padding if final transfer requires only a partial block
}

///////////////////////////////////////////////////////////////////////////

func (*DownloadSectionRequest) DecodeFromBytes 

func (omci *DownloadSectionRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*DownloadSectionRequest) SerializeTo 

func (omci *DownloadSectionRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type DownloadSectionResponse 

type DownloadSectionResponse struct {
	MeBasePacket  // Note: EntityInstance for software download is two specific values
	Result        me.Results
	SectionNumber byte
}

///////////////////////////////////////////////////////////////////////////

func (*DownloadSectionResponse) DecodeFromBytes 

func (omci *DownloadSectionResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*DownloadSectionResponse) SerializeTo 

func (omci *DownloadSectionResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type EndSoftwareDownloadRequest 

type EndSoftwareDownloadRequest struct {
	MeBasePacket      // Note: EntityInstance for software download is two specific values
	CRC32             uint32
	ImageSize         uint32
	NumberOfInstances byte
	ImageInstances    []uint16
}

///////////////////////////////////////////////////////////////////////////

func (*EndSoftwareDownloadRequest) DecodeFromBytes 

func (omci *EndSoftwareDownloadRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*EndSoftwareDownloadRequest) SerializeTo 

func (omci *EndSoftwareDownloadRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type EndSoftwareDownloadResponse 

type EndSoftwareDownloadResponse struct {
	MeBasePacket      // Note: EntityInstance for software download is two specific values
	Result            me.Results
	NumberOfInstances byte
	MeResults         []downloadResults
}

///////////////////////////////////////////////////////////////////////////

func (*EndSoftwareDownloadResponse) DecodeFromBytes 

func (omci *EndSoftwareDownloadResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*EndSoftwareDownloadResponse) SerializeTo 

func (omci *EndSoftwareDownloadResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type FrameOption 

type FrameOption func(*options)

A FrameOption sets options such as frame format, etc.

func AttributeExecutionMask 

func AttributeExecutionMask(m uint16) FrameOption

AttributeExecutionMask is used by the Create and Set Response frames to indicate attributes that failed to be created/set.

func AttributeMask 

func AttributeMask(m uint16) FrameOption

AttributeMask determines the attributes to encode into the frame. The default value is 0xFFFF which specifies all available attributes in the frame

func AttributeUnsupportedMask 

func AttributeUnsupportedMask(m uint16) FrameOption

AttributeUnsupportedMask is used by the Set Response frames to indicate attributes that failed to be set by the ONU due to not being supported

func FailIfTruncated 

func FailIfTruncated(f bool) FrameOption

FailIfTruncated determines whether a request to encode a frame that does not have enough room for all requested options should fail and return an error.

If set to 'false', the behaviour depends on the message type/operation requested. The table below provides more information: 

  Request Type	Behavour
	 ------------------------------------------------------------------------
	 CreateRequest  A single CreateRequest struct is always returned as the
                 CreateRequest message does not have an Attributes Mask
                 field and a Baseline OMCI message is large enough to
                 support all Set-By-Create attributes.

  SetRequest		If multiple OMCI frames will be needed to support setting
					all of the requested attributes, multiple SetRequest
					structs will be returned with Attributes encoded in
					decreasing Attribute mask bit order. Since this is an
					operation that should only occur on an OLT, it is the
					responsibility for the OLT application to clone the OMCI
					structure returned should it wish to send more than the
					initial SetRequest in the returned array.

  GetResponse	If multiple OMCI response frames are needed to return
					all requested attributes, multiple GetResponse structs
					will be returned. Since this is an operation that should
					only occur on an ONU, there are several ways in which
					the responses will be encoded.

					If this is an ME that simply has simple attributes that
					when combined will exceed the OMCI frame size, the first
					(and only) GetResponse struct will be encoded with as many
					attributes as possible and the Results field set to 1001
					(AttributeFailure) and the FailedAttributeMask field
					set to the attributes that could not be returned

					If this is an ME with an attribute that is a table, the
					first GetResponse struct will return the size of the
					attribute and the following GetNextResponse structs will
					contain the attribute data. The ONU application is
					responsible for stashing these extra struct(s) away in
					anticipation of possible GetNext Requests occuring for
					the attribute.  See the discussion on Table Attributes
					in the GetResponse section of ITU G.988 for more
					information.

If set to 'true', no struct(s) are returned and an error is provided.

The default value is 'false'

func FrameFormat 

func FrameFormat(ff DeviceIdent) FrameOption

FrameFormat determines determines the OMCI message format used on the fiber. The default value is BaselineIdent

type GetAllAlarmsNextRequest 

type GetAllAlarmsNextRequest struct {
	MeBasePacket
	CommandSequenceNumber uint16
}

/////////////////////////////////////////////////////////////////////////// GetAllAlarms

func (*GetAllAlarmsNextRequest) DecodeFromBytes 

func (omci *GetAllAlarmsNextRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetAllAlarmsNextRequest) SerializeTo 

func (omci *GetAllAlarmsNextRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*GetAllAlarmsNextRequest) String 

func (omci *GetAllAlarmsNextRequest) String() string

type GetAllAlarmsNextResponse 

type GetAllAlarmsNextResponse struct {
	MeBasePacket
	AlarmBitMap [28]byte // 224 bits
}

/////////////////////////////////////////////////////////////////////////// GetAllAlarms

func (*GetAllAlarmsNextResponse) DecodeFromBytes 

func (omci *GetAllAlarmsNextResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetAllAlarmsNextResponse) SerializeTo 

func (omci *GetAllAlarmsNextResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*GetAllAlarmsNextResponse) String 

func (omci *GetAllAlarmsNextResponse) String() string

type GetAllAlarmsRequest 

type GetAllAlarmsRequest struct {
	MeBasePacket
	AlarmRetrievalMode byte
}

/////////////////////////////////////////////////////////////////////////// GetAllAlarms

func (*GetAllAlarmsRequest) DecodeFromBytes 

func (omci *GetAllAlarmsRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetAllAlarmsRequest) SerializeTo 

func (omci *GetAllAlarmsRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*GetAllAlarmsRequest) String 

func (omci *GetAllAlarmsRequest) String() string

type GetAllAlarmsResponse 

type GetAllAlarmsResponse struct {
	MeBasePacket
	NumberOfCommands uint16
}

/////////////////////////////////////////////////////////////////////////// GetAllAlarms

func (*GetAllAlarmsResponse) DecodeFromBytes 

func (omci *GetAllAlarmsResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetAllAlarmsResponse) SerializeTo 

func (omci *GetAllAlarmsResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*GetAllAlarmsResponse) String 

func (omci *GetAllAlarmsResponse) String() string

type GetCurrentDataRequest 

type GetCurrentDataRequest struct {
	MeBasePacket
	AttributeMask uint16
}

///////////////////////////////////////////////////////////////////////////

func (*GetCurrentDataRequest) DecodeFromBytes 

func (omci *GetCurrentDataRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetCurrentDataRequest) SerializeTo 

func (omci *GetCurrentDataRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type GetCurrentDataResponse 

type GetCurrentDataResponse struct {
	MeBasePacket
	Result        me.Results
	AttributeMask uint16
	Attributes    me.AttributeValueMap
}

///////////////////////////////////////////////////////////////////////////

func (*GetCurrentDataResponse) DecodeFromBytes 

func (omci *GetCurrentDataResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetCurrentDataResponse) SerializeTo 

func (omci *GetCurrentDataResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type GetNextRequest 

type GetNextRequest struct {
	MeBasePacket
	AttributeMask  uint16
	SequenceNumber uint16
}

///////////////////////////////////////////////////////////////////////////

func (*GetNextRequest) DecodeFromBytes 

func (omci *GetNextRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetNextRequest) SerializeTo 

func (omci *GetNextRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type GetNextResponse 

type GetNextResponse struct {
	MeBasePacket
	AttributeMask uint16
	Attributes    me.AttributeValueMap
}

///////////////////////////////////////////////////////////////////////////

func (*GetNextResponse) DecodeFromBytes 

func (omci *GetNextResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetNextResponse) SerializeTo 

func (omci *GetNextResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type GetRequest 

type GetRequest struct {
	MeBasePacket
	AttributeMask uint16
}

/////////////////////////////////////////////////////////////////////////// GetRequest

func (*GetRequest) DecodeFromBytes 

func (omci *GetRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetRequest) SerializeTo 

func (omci *GetRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*GetRequest) String 

func (omci *GetRequest) String() string

type GetResponse 

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

/////////////////////////////////////////////////////////////////////////// GetResponse

func (*GetResponse) DecodeFromBytes 

func (omci *GetResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*GetResponse) SerializeTo 

func (omci *GetResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*GetResponse) String 

func (omci *GetResponse) String() string

type IManagedEntity 

type IManagedEntity interface {
	GetClassId() uint16
	GetInstanceId() uint16
	SetInstanceId(uint16) error
	GetAttributesMap() *me.AttributeValueMap
	GetManagedEntityDefinition() (me.IManagedEntityDefinition, error)
	EncodeFrame(messageType byte, opt ...FrameOption) (*OMCI, []interface{}, error)
}

IManagedEntity provides an interface definition for a simplified ME that can be used in a variety of applications (MIB database, ONU driver, OLT application, ...) where the serialization into a packet may not always be desired.

type IManagedEntityInstance 

type IManagedEntityInstance interface {
	me.IManagedEntityDefinition

	GetAttributeMask() uint16
	SetAttributeMask(uint16) error

	GetAttributes() me.AttributeValueMap // TODO: Can we use interface from generated?
	SetAttributes(me.AttributeValueMap) error
}

type ManagedEntity 

type ManagedEntity struct {
	ClassId    uint16
	InstanceId uint16
	Attributes me.AttributeValueMap
}

ManagedEntity is intended to be a lighter weight version of a specific managed entity. It is intended to be used by generated Managed Entity classes as a base class which is easier to use within an application outside of just decode and serialization of OMCI Packets

func NewManagedEntity 

func NewManagedEntity(meDef me.IManagedEntityDefinition, params ...me.ParamData) (*ManagedEntity, error)

func (*ManagedEntity) EncodeFrame 

func (m *ManagedEntity) EncodeFrame(messageType MessageType, opt ...FrameOption) (*OMCI, gopacket.SerializableLayer, error)

EncodeFrame will encode the Managed Entity specific protocol struct and an OMCILayer struct. This struct can be provided to the gopacket.SerializeLayers() function to be serialized into a buffer for transmission.

func (*ManagedEntity) GetAttributesMap 

func (m *ManagedEntity) GetAttributesMap() me.AttributeValueMap

func (*ManagedEntity) GetClassId 

func (m *ManagedEntity) GetClassId() uint16

func (*ManagedEntity) GetInstanceId 

func (m *ManagedEntity) GetInstanceId() uint16

func (*ManagedEntity) GetManagedEntityDefinition 

func (m *ManagedEntity) GetManagedEntityDefinition() (me.IManagedEntityDefinition, error)

GetManagedEntityDefinition returns a definition of what message types this ME supports as well as detailed information on the attributes of this ME.

func (*ManagedEntity) SetInstanceId 

func (m *ManagedEntity) SetInstanceId(id uint16) error

func (*ManagedEntity) String 

func (m *ManagedEntity) String() string

String provides a simple string that describes this struct

type MeBasePacket 

type MeBasePacket struct {
	EntityClass    uint16
	EntityInstance uint16 // TODO: Change attribute values to map and move this into the map

	gopacket.Layer
	layers.BaseLayer
	MsgLayerType gopacket.LayerType
}

func (*MeBasePacket) CanDecode 

func (msg *MeBasePacket) CanDecode() gopacket.LayerClass

func (*MeBasePacket) DecodeFromBytes 

func (msg *MeBasePacket) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*MeBasePacket) LayerContents 

func (msg *MeBasePacket) LayerContents() []byte

func (*MeBasePacket) LayerPayload 

func (msg *MeBasePacket) LayerPayload() []byte

func (*MeBasePacket) LayerType 

func (msg *MeBasePacket) LayerType() gopacket.LayerType

Layer Interface implementations

func (*MeBasePacket) NextLayerType 

func (msg *MeBasePacket) NextLayerType() gopacket.LayerType

layerDecodingLayer Interface implementations

func (*MeBasePacket) SerializeTo 

func (msg *MeBasePacket) SerializeTo(b gopacket.SerializeBuffer) error

func (*MeBasePacket) String 

func (msg *MeBasePacket) String() string

type MessageType added in v0.0.2 

type MessageType byte

MessageType is the OMCI Message Type or'ed with the AR/AK flags as appropriate. 

const (
	CreateRequestType                 MessageType = MessageType(byte(me.Create) | me.AR)
	CreateResponseType                MessageType = MessageType(byte(me.Create) | me.AK)
	DeleteRequestType                 MessageType = MessageType(byte(me.Delete) | me.AR)
	DeleteResponseType                MessageType = MessageType(byte(me.Delete) | me.AK)
	SetRequestType                    MessageType = MessageType(byte(me.Set) | me.AR)
	SetResponseType                   MessageType = MessageType(byte(me.Set) | me.AK)
	GetRequestType                    MessageType = MessageType(byte(me.Get) | me.AR)
	GetResponseType                   MessageType = MessageType(byte(me.Get) | me.AK)
	GetAllAlarmsRequestType           MessageType = MessageType(byte(me.GetAllAlarms) | me.AR)
	GetAllAlarmsResponseType          MessageType = MessageType(byte(me.GetAllAlarms) | me.AK)
	GetAllAlarmsNextRequestType       MessageType = MessageType(byte(me.GetAllAlarmsNext) | me.AR)
	GetAllAlarmsNextResponseType      MessageType = MessageType(byte(me.GetAllAlarmsNext) | me.AK)
	MibUploadRequestType              MessageType = MessageType(byte(me.MibUpload) | me.AR)
	MibUploadResponseType             MessageType = MessageType(byte(me.MibUpload) | me.AK)
	MibUploadNextRequestType          MessageType = MessageType(byte(me.MibUploadNext) | me.AR)
	MibUploadNextResponseType         MessageType = MessageType(byte(me.MibUploadNext) | me.AK)
	MibResetRequestType               MessageType = MessageType(byte(me.MibReset) | me.AR)
	MibResetResponseType              MessageType = MessageType(byte(me.MibReset) | me.AK)
	TestRequestType                   MessageType = MessageType(byte(me.Test) | me.AR)
	TestResponseType                  MessageType = MessageType(byte(me.Test) | me.AK)
	StartSoftwareDownloadRequestType  MessageType = MessageType(byte(me.StartSoftwareDownload) | me.AR)
	StartSoftwareDownloadResponseType MessageType = MessageType(byte(me.StartSoftwareDownload) | me.AK)
	DownloadSectionRequestType        MessageType = MessageType(byte(me.DownloadSection) | me.AR)
	DownloadSectionResponseType       MessageType = MessageType(byte(me.DownloadSection) | me.AK)
	EndSoftwareDownloadRequestType    MessageType = MessageType(byte(me.EndSoftwareDownload) | me.AR)
	EndSoftwareDownloadResponseType   MessageType = MessageType(byte(me.EndSoftwareDownload) | me.AK)
	ActivateSoftwareRequestType       MessageType = MessageType(byte(me.ActivateSoftware) | me.AR)
	ActivateSoftwareResponseType      MessageType = MessageType(byte(me.ActivateSoftware) | me.AK)
	CommitSoftwareRequestType         MessageType = MessageType(byte(me.CommitSoftware) | me.AR)
	CommitSoftwareResponseType        MessageType = MessageType(byte(me.CommitSoftware) | me.AK)
	SynchronizeTimeRequestType        MessageType = MessageType(byte(me.SynchronizeTime) | me.AR)
	SynchronizeTimeResponseType       MessageType = MessageType(byte(me.SynchronizeTime) | me.AK)
	RebootRequestType                 MessageType = MessageType(byte(me.Reboot) | me.AR)
	RebootResponseType                MessageType = MessageType(byte(me.Reboot) | me.AK)
	GetNextRequestType                MessageType = MessageType(byte(me.GetNext) | me.AR)
	GetNextResponseType               MessageType = MessageType(byte(me.GetNext) | me.AK)
	GetCurrentDataRequestType         MessageType = MessageType(byte(me.GetCurrentData) | me.AR)
	GetCurrentDataResponseType        MessageType = MessageType(byte(me.GetCurrentData) | me.AK)
	SetTableRequestType               MessageType = MessageType(byte(me.SetTable) | me.AR)
	SetTableResponseType              MessageType = MessageType(byte(me.SetTable) | me.AK)
)

type MibResetRequest 

type MibResetRequest struct {
	MeBasePacket
}

/////////////////////////////////////////////////////////////////////////// MibResetRequest

func (*MibResetRequest) DecodeFromBytes 

func (omci *MibResetRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*MibResetRequest) SerializeTo 

func (omci *MibResetRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*MibResetRequest) String 

func (omci *MibResetRequest) String() string

type MibResetResponse 

type MibResetResponse struct {
	MeBasePacket
	Result me.Results
}

/////////////////////////////////////////////////////////////////////////// MibResetResponse

func (*MibResetResponse) DecodeFromBytes 

func (omci *MibResetResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*MibResetResponse) SerializeTo 

func (omci *MibResetResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*MibResetResponse) String 

func (omci *MibResetResponse) String() string

type MibUploadNextRequest 

type MibUploadNextRequest struct {
	MeBasePacket
	CommandSequenceNumber uint16
}

///////////////////////////////////////////////////////////////////////////

func (*MibUploadNextRequest) DecodeFromBytes 

func (omci *MibUploadNextRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*MibUploadNextRequest) SerializeTo 

func (omci *MibUploadNextRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*MibUploadNextRequest) String 

func (omci *MibUploadNextRequest) String() string

type MibUploadNextResponse 

type MibUploadNextResponse struct {
	MeBasePacket
	ReportedME BaseManagedEntityInstance
}

///////////////////////////////////////////////////////////////////////////

func (*MibUploadNextResponse) DecodeFromBytes 

func (omci *MibUploadNextResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*MibUploadNextResponse) SerializeTo 

func (omci *MibUploadNextResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*MibUploadNextResponse) String 

func (omci *MibUploadNextResponse) String() string

type MibUploadRequest 

type MibUploadRequest struct {
	MeBasePacket
}

/////////////////////////////////////////////////////////////////////////// MibUploadRequest

func (*MibUploadRequest) DecodeFromBytes 

func (omci *MibUploadRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*MibUploadRequest) SerializeTo 

func (omci *MibUploadRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*MibUploadRequest) String 

func (omci *MibUploadRequest) String() string

type MibUploadResponse 

type MibUploadResponse struct {
	MeBasePacket
	NumberOfCommands uint16
}

/////////////////////////////////////////////////////////////////////////// MibUploadResponse

func (*MibUploadResponse) DecodeFromBytes 

func (omci *MibUploadResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*MibUploadResponse) SerializeTo 

func (omci *MibUploadResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*MibUploadResponse) String 

func (omci *MibUploadResponse) String() string

type OMCI 

type OMCI struct {
	layers.BaseLayer
	TransactionID    uint16
	MessageType      MessageType
	DeviceIdentifier DeviceIdent
	Payload          []byte

	Length uint16
	MIC    uint32
	// contains filtered or unexported fields
}

OMCI defines the common protocol. Extended will be added once I can get basic working (and layered properly). See ITU-T G.988 11/2017 section A.3 for more information

func (*OMCI) CanDecode 

func (omci *OMCI) CanDecode() gopacket.LayerClass

func (*OMCI) DecodeFromBytes 

func (omci *OMCI) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*OMCI) LayerContents 

func (omci *OMCI) LayerContents() []byte

func (*OMCI) LayerType 

func (omci *OMCI) LayerType() gopacket.LayerType

LayerType returns LayerTypeOMCI

func (*OMCI) NextLayerType 

func (omci *OMCI) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

func (*OMCI) SerializeTo 

func (omci *OMCI) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

func (*OMCI) String 

func (omci *OMCI) String() string

type RebootRequest 

type RebootRequest struct {
	MeBasePacket
	RebootCondition byte
}

///////////////////////////////////////////////////////////////////////////

func (*RebootRequest) DecodeFromBytes 

func (omci *RebootRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*RebootRequest) SerializeTo 

func (omci *RebootRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type RebootResponse 

type RebootResponse struct {
	MeBasePacket
	Result me.Results
}

///////////////////////////////////////////////////////////////////////////

func (*RebootResponse) DecodeFromBytes 

func (omci *RebootResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*RebootResponse) SerializeTo 

func (omci *RebootResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type SetRequest 

type SetRequest struct {
	MeBasePacket
	AttributeMask uint16
	Attributes    me.AttributeValueMap
}

/////////////////////////////////////////////////////////////////////////// SetRequest

func (*SetRequest) DecodeFromBytes 

func (omci *SetRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*SetRequest) SerializeTo 

func (omci *SetRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*SetRequest) String 

func (omci *SetRequest) String() string

type SetResponse 

type SetResponse struct {
	MeBasePacket
	Result                   me.Results
	UnsupportedAttributeMask uint16
	FailedAttributeMask      uint16
}

/////////////////////////////////////////////////////////////////////////// SetResponse

func (*SetResponse) DecodeFromBytes 

func (omci *SetResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*SetResponse) SerializeTo 

func (omci *SetResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*SetResponse) String 

func (omci *SetResponse) String() string

type SetTableRequest 

type SetTableRequest struct {
	MeBasePacket
}

///////////////////////////////////////////////////////////////////////////

func (*SetTableRequest) DecodeFromBytes 

func (omci *SetTableRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*SetTableRequest) SerializeTo 

func (omci *SetTableRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type SetTableResponse 

type SetTableResponse struct {
	MeBasePacket
}

///////////////////////////////////////////////////////////////////////////

func (*SetTableResponse) DecodeFromBytes 

func (omci *SetTableResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*SetTableResponse) SerializeTo 

func (omci *SetTableResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type StartSoftwareDownloadRequest 

type StartSoftwareDownloadRequest struct {
	MeBasePacket                // Note: EntityInstance for software download is two specific values
	WindowSize           byte   // Window Size -1
	ImageSize            uint32 // Octets
	NumberOfCircuitPacks byte
	MSBInstance          []uint16 // MSB & LSB of software image instance
}

///////////////////////////////////////////////////////////////////////////

func (*StartSoftwareDownloadRequest) DecodeFromBytes 

func (omci *StartSoftwareDownloadRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*StartSoftwareDownloadRequest) SerializeTo 

func (omci *StartSoftwareDownloadRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type StartSoftwareDownloadResponse 

type StartSoftwareDownloadResponse struct {
	MeBasePacket      // Note: EntityInstance for software download is two specific values
	Result            me.Results
	WindowSize        byte // Window Size -1
	NumberOfInstances byte
	MeResults         []downloadResults
}

func (*StartSoftwareDownloadResponse) DecodeFromBytes 

func (omci *StartSoftwareDownloadResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*StartSoftwareDownloadResponse) SerializeTo 

func (omci *StartSoftwareDownloadResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type SynchronizeTimeRequest 

type SynchronizeTimeRequest struct {
	MeBasePacket
	Year   uint16
	Month  uint8
	Day    uint8
	Hour   uint8
	Minute uint8
	Second uint8
}

///////////////////////////////////////////////////////////////////////////

func (*SynchronizeTimeRequest) DecodeFromBytes 

func (omci *SynchronizeTimeRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*SynchronizeTimeRequest) SerializeTo 

func (omci *SynchronizeTimeRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type SynchronizeTimeResponse 

type SynchronizeTimeResponse struct {
	MeBasePacket
	Results        me.Results
	SuccessResults uint8 // Only if 'Results' is 0 -> success
}

///////////////////////////////////////////////////////////////////////////

func (*SynchronizeTimeResponse) DecodeFromBytes 

func (omci *SynchronizeTimeResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*SynchronizeTimeResponse) SerializeTo 

func (omci *SynchronizeTimeResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type TestRequest 

type TestRequest struct {
	MeBasePacket
}

///////////////////////////////////////////////////////////////////////////

func (*TestRequest) DecodeFromBytes 

func (omci *TestRequest) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*TestRequest) SerializeTo 

func (omci *TestRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

func (*TestRequest) String 

func (omci *TestRequest) String() string

type TestResponse 

type TestResponse struct {
	MeBasePacket
}

/////////////////////////////////////////////////////////////////////////// TestResponse: TODO: Not yet implemented

func (*TestResponse) DecodeFromBytes 

func (omci *TestResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*TestResponse) SerializeTo 

func (omci *TestResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type TestResultMsg 

type TestResultMsg struct {
	MeBasePacket
}

///////////////////////////////////////////////////////////////////////////

func (*TestResultMsg) DecodeFromBytes 

func (omci *TestResultMsg) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*TestResultMsg) SerializeTo 

func (omci *TestResultMsg) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

type UnsupportedMessageTypeResponse 

type UnsupportedMessageTypeResponse struct {
	MeBasePacket
	Result me.Results
}

///////////////////////////////////////////////////////////////////////////

func (*UnsupportedMessageTypeResponse) DecodeFromBytes 

func (omci *UnsupportedMessageTypeResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error

func (*UnsupportedMessageTypeResponse) SerializeTo 

func (omci *UnsupportedMessageTypeResponse) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

Source Files

View all Source files

Directories

Path Synopsis
examples
misc
sequences command
* Copyright (c) 2018 - present.
 * Copyright (c) 2018 - present.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.