From 40e86e393f24d24cf5996c23011d873a30a5bcac Mon Sep 17 00:00:00 2001 From: "Arrobo, Gabriel" Date: Tue, 28 Jul 2026 15:12:10 -0700 Subject: [PATCH 1/2] Add optional/conditional IEs introduced in Rel-16/17/18 releases Signed-off-by: Arrobo, Gabriel --- VERSION | 2 +- nasMessage/NAS_AuthenticationResult.go | 14 +- nasMessage/NAS_ConfigurationUpdateCommand.go | 136 ++++++++++++++ nasMessage/NAS_ControlPlaneServiceRequest.go | 53 +++++- nasMessage/NAS_DLNASTransport.go | 12 ++ ...ationRequestUEOriginatingDeregistration.go | 30 ++- ...rationRequestUETerminatedDeregistration.go | 105 ++++++++++- .../NAS_PDUSessionEstablishmentAccept.go | 104 +++++++++++ .../NAS_PDUSessionEstablishmentReject.go | 36 ++++ .../NAS_PDUSessionModificationCommand.go | 96 ++++++++++ .../NAS_PDUSessionModificationReject.go | 24 +++ nasMessage/NAS_PDUSessionReleaseCommand.go | 44 +++++ nasMessage/NAS_RegistrationAccept.go | 171 ++++++++++++++++++ nasMessage/NAS_RegistrationReject.go | 131 +++++++++++++- nasMessage/NAS_RegistrationRequest.go | 12 ++ nasMessage/NAS_SecurityModeCommand.go | 12 ++ nasMessage/NAS_SecurityModeComplete.go | 12 ++ nasMessage/NAS_ServiceAccept.go | 49 +++++ nasMessage/NAS_ServiceReject.go | 94 +++++++++- nasMessage/NAS_ULNASTransport.go | 63 ++++++- nasType/NAS_ATSSSContainer.go | 32 ++++ .../NAS_AdditionalConfigurationIndication.go | 33 ++++ nasType/NAS_AlternativeNSSAI.go | 45 +++++ nasType/NAS_CIoTSmallDataContainer.go | 32 ++++ nasType/NAS_ControlPlaneOnlyIndication.go | 33 ++++ .../NAS_DiscontinuousCoverageMaxTimeOffset.go | 35 ++++ nasType/NAS_EquivalentSNPNs.go | 32 ++++ ..._EthernetHeaderCompressionConfiguration.go | 32 ++++ nasType/NAS_FeatureAuthorizationIndication.go | 35 ++++ nasType/NAS_FiveGSMNetworkFeatureSupport.go | 35 ++++ ...NAS_Fivegsmcongestionreattemptindicator.go | 33 ++++ .../NAS_IPHeaderCompressionConfiguration.go | 35 ++++ nasType/NAS_LowerBoundTimerValue.go | 67 +++++++ nasType/NAS_MAPDUSessionInformation.go | 41 +++++ nasType/NAS_MasterSessionKey.go | 32 ++++ nasType/NAS_N3IWFIdentifier.go | 32 ++++ nasType/NAS_N3QAI.go | 32 ++++ ...AS_Non3GPPAccessPathSwitchingIndication.go | 32 ++++ nasType/NAS_PartiallyAllowedNSSAI.go | 33 ++++ nasType/NAS_PartiallyRejectedNSSAI.go | 33 ++++ nasType/NAS_PayloadContainerInformation.go | 33 ++++ nasType/NAS_PendingNSSAI.go | 45 +++++ nasType/NAS_PriorityIndicator.go | 33 ++++ nasType/NAS_RANTimingSynchronization.go | 32 ++++ nasType/NAS_ReAttemptIndicator.go | 41 +++++ nasType/NAS_ReceivedMBSContainer.go | 32 ++++ nasType/NAS_ReleaseAssistanceIndication.go | 41 +++++ .../NAS_SNSSAILocationValidityInformation.go | 35 ++++ nasType/NAS_SNSSAITimeValidityInformation.go | 35 ++++ nasType/NAS_ServingPLMNRateControl.go | 32 ++++ nasType/NAS_T3448Value.go | 54 ++++++ nasType/NAS_TNANInformation.go | 32 ++++ .../NAS_UpdatedPEIPSAssistanceInformation.go | 35 ++++ 53 files changed, 2362 insertions(+), 32 deletions(-) create mode 100644 nasType/NAS_ATSSSContainer.go create mode 100644 nasType/NAS_AdditionalConfigurationIndication.go create mode 100644 nasType/NAS_AlternativeNSSAI.go create mode 100644 nasType/NAS_CIoTSmallDataContainer.go create mode 100644 nasType/NAS_ControlPlaneOnlyIndication.go create mode 100644 nasType/NAS_DiscontinuousCoverageMaxTimeOffset.go create mode 100644 nasType/NAS_EquivalentSNPNs.go create mode 100644 nasType/NAS_EthernetHeaderCompressionConfiguration.go create mode 100644 nasType/NAS_FeatureAuthorizationIndication.go create mode 100644 nasType/NAS_FiveGSMNetworkFeatureSupport.go create mode 100644 nasType/NAS_Fivegsmcongestionreattemptindicator.go create mode 100644 nasType/NAS_IPHeaderCompressionConfiguration.go create mode 100644 nasType/NAS_LowerBoundTimerValue.go create mode 100644 nasType/NAS_MAPDUSessionInformation.go create mode 100644 nasType/NAS_MasterSessionKey.go create mode 100644 nasType/NAS_N3IWFIdentifier.go create mode 100644 nasType/NAS_N3QAI.go create mode 100644 nasType/NAS_Non3GPPAccessPathSwitchingIndication.go create mode 100644 nasType/NAS_PartiallyAllowedNSSAI.go create mode 100644 nasType/NAS_PartiallyRejectedNSSAI.go create mode 100644 nasType/NAS_PayloadContainerInformation.go create mode 100644 nasType/NAS_PendingNSSAI.go create mode 100644 nasType/NAS_PriorityIndicator.go create mode 100644 nasType/NAS_RANTimingSynchronization.go create mode 100644 nasType/NAS_ReAttemptIndicator.go create mode 100644 nasType/NAS_ReceivedMBSContainer.go create mode 100644 nasType/NAS_ReleaseAssistanceIndication.go create mode 100644 nasType/NAS_SNSSAILocationValidityInformation.go create mode 100644 nasType/NAS_SNSSAITimeValidityInformation.go create mode 100644 nasType/NAS_ServingPLMNRateControl.go create mode 100644 nasType/NAS_T3448Value.go create mode 100644 nasType/NAS_TNANInformation.go create mode 100644 nasType/NAS_UpdatedPEIPSAssistanceInformation.go diff --git a/VERSION b/VERSION index 7c7e0966..ccbccc3d 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.1.1-dev +2.2.0 diff --git a/nasMessage/NAS_AuthenticationResult.go b/nasMessage/NAS_AuthenticationResult.go index 93cb1e45..d6de9950 100644 --- a/nasMessage/NAS_AuthenticationResult.go +++ b/nasMessage/NAS_AuthenticationResult.go @@ -19,6 +19,7 @@ type AuthenticationResult struct { nasType.SpareHalfOctetAndNgksi nasType.EAPMessage *nasType.ABBA + *nasType.MasterSessionKey } func NewAuthenticationResult(iei uint8) (authenticationResult *AuthenticationResult) { @@ -27,7 +28,8 @@ func NewAuthenticationResult(iei uint8) (authenticationResult *AuthenticationRes } const ( - AuthenticationResultABBAType uint8 = 0x38 + AuthenticationResultABBAType uint8 = 0x38 + AuthenticationResultMasterSessionKeyType uint8 = 0x55 ) func (a *AuthenticationResult) EncodeAuthenticationResult(buffer *bytes.Buffer) { @@ -42,6 +44,11 @@ func (a *AuthenticationResult) EncodeAuthenticationResult(buffer *bytes.Buffer) binary.Write(buffer, binary.BigEndian, a.ABBA.GetLen()) binary.Write(buffer, binary.BigEndian, &a.ABBA.Buffer) } + if a.MasterSessionKey != nil { + binary.Write(buffer, binary.BigEndian, a.MasterSessionKey.GetIei()) + binary.Write(buffer, binary.BigEndian, a.MasterSessionKey.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.MasterSessionKey.Buffer) + } } func (a *AuthenticationResult) DecodeAuthenticationResult(byteArray *[]byte) { @@ -68,6 +75,11 @@ func (a *AuthenticationResult) DecodeAuthenticationResult(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &a.ABBA.Len) a.ABBA.SetLen(a.ABBA.GetLen()) binary.Read(buffer, binary.BigEndian, a.ABBA.Buffer[:a.ABBA.GetLen()]) + case AuthenticationResultMasterSessionKeyType: + a.MasterSessionKey = nasType.NewMasterSessionKey(ieiN) + binary.Read(buffer, binary.BigEndian, &a.MasterSessionKey.Len) + a.MasterSessionKey.SetLen(a.MasterSessionKey.GetLen()) + binary.Read(buffer, binary.BigEndian, a.MasterSessionKey.Buffer[:a.MasterSessionKey.GetLen()]) default: } } diff --git a/nasMessage/NAS_ConfigurationUpdateCommand.go b/nasMessage/NAS_ConfigurationUpdateCommand.go index 78cf5f39..52a003bd 100644 --- a/nasMessage/NAS_ConfigurationUpdateCommand.go +++ b/nasMessage/NAS_ConfigurationUpdateCommand.go @@ -45,6 +45,18 @@ type ConfigurationUpdateCommand struct { *nasType.ExtendedCAGInformationList *nasType.NSAGInformation *nasType.ExtendedLADNInformation + *nasType.RegistrationResult5GS + *nasType.AdditionalConfigurationIndication + *nasType.UpdatedPEIPSAssistanceInformation + *nasType.PriorityIndicator + *nasType.RANTimingSynchronization + *nasType.AlternativeNSSAI + *nasType.SNSSAILocationValidityInformation + *nasType.SNSSAITimeValidityInformation + *nasType.DiscontinuousCoverageMaxTimeOffset + *nasType.PartiallyAllowedNSSAI + *nasType.PartiallyRejectedNSSAI + *nasType.FeatureAuthorizationIndication } func NewConfigurationUpdateCommand(iei uint8) (configurationUpdateCommand *ConfigurationUpdateCommand) { @@ -83,6 +95,18 @@ const ( ConfigurationUpdateCommandExtendedCAGInformationListType uint8 = 0x71 ConfigurationUpdateCommandNSAGInformationType uint8 = 0x73 ConfigurationUpdateCommandExtendedLADNInformationType uint8 = 0x78 + ConfigurationUpdateCommandRegistrationResult5GSType uint8 = 0x44 + ConfigurationUpdateCommandAdditionalConfigurationIndicationType uint8 = 0x0C + ConfigurationUpdateCommandUpdatedPEIPSAssistanceInformationType uint8 = 0x1F + ConfigurationUpdateCommandPriorityIndicatorType uint8 = 0x0E + ConfigurationUpdateCommandRANTimingSynchronizationType uint8 = 0x4B + ConfigurationUpdateCommandAlternativeNSSAIType uint8 = 0x4C + ConfigurationUpdateCommandSNSSAILocationValidityInformationType uint8 = 0x7D + ConfigurationUpdateCommandSNSSAITimeValidityInformationType uint8 = 0x5B + ConfigurationUpdateCommandDiscontinuousCoverageMaxTimeOffsetType uint8 = 0x4F + ConfigurationUpdateCommandPartiallyAllowedNSSAIType uint8 = 0x74 + ConfigurationUpdateCommandPartiallyRejectedNSSAIType uint8 = 0x7A + ConfigurationUpdateCommandFeatureAuthorizationIndicationType uint8 = 0x5C ) func (a *ConfigurationUpdateCommand) EncodeConfigurationUpdateCommand(buffer *bytes.Buffer) { @@ -227,6 +251,62 @@ func (a *ConfigurationUpdateCommand) EncodeConfigurationUpdateCommand(buffer *by binary.Write(buffer, binary.BigEndian, a.ExtendedLADNInformation.GetLen()) binary.Write(buffer, binary.BigEndian, &a.ExtendedLADNInformation.Buffer) } + if a.RegistrationResult5GS != nil { + binary.Write(buffer, binary.BigEndian, a.RegistrationResult5GS.GetIei()) + binary.Write(buffer, binary.BigEndian, a.RegistrationResult5GS.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.RegistrationResult5GS.Octet) + } + if a.AdditionalConfigurationIndication != nil { + binary.Write(buffer, binary.BigEndian, &a.AdditionalConfigurationIndication.Octet) + } + if a.UpdatedPEIPSAssistanceInformation != nil { + binary.Write(buffer, binary.BigEndian, a.UpdatedPEIPSAssistanceInformation.GetIei()) + binary.Write(buffer, binary.BigEndian, a.UpdatedPEIPSAssistanceInformation.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.UpdatedPEIPSAssistanceInformation.Buffer) + } + if a.PriorityIndicator != nil { + binary.Write(buffer, binary.BigEndian, &a.PriorityIndicator.Octet) + } + if a.RANTimingSynchronization != nil { + binary.Write(buffer, binary.BigEndian, a.RANTimingSynchronization.GetIei()) + binary.Write(buffer, binary.BigEndian, a.RANTimingSynchronization.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.RANTimingSynchronization.Buffer) + } + if a.AlternativeNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.AlternativeNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.AlternativeNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.AlternativeNSSAI.Buffer) + } + if a.SNSSAILocationValidityInformation != nil { + binary.Write(buffer, binary.BigEndian, a.SNSSAILocationValidityInformation.GetIei()) + binary.Write(buffer, binary.BigEndian, a.SNSSAILocationValidityInformation.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.SNSSAILocationValidityInformation.Buffer) + } + if a.SNSSAITimeValidityInformation != nil { + binary.Write(buffer, binary.BigEndian, a.SNSSAITimeValidityInformation.GetIei()) + binary.Write(buffer, binary.BigEndian, a.SNSSAITimeValidityInformation.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.SNSSAITimeValidityInformation.Buffer) + } + if a.DiscontinuousCoverageMaxTimeOffset != nil { + binary.Write(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.GetIei()) + binary.Write(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Buffer) + } + if a.PartiallyAllowedNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.PartiallyAllowedNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.PartiallyAllowedNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.PartiallyAllowedNSSAI.Buffer) + } + if a.PartiallyRejectedNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.PartiallyRejectedNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.PartiallyRejectedNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.PartiallyRejectedNSSAI.Buffer) + } + if a.FeatureAuthorizationIndication != nil { + binary.Write(buffer, binary.BigEndian, a.FeatureAuthorizationIndication.GetIei()) + binary.Write(buffer, binary.BigEndian, a.FeatureAuthorizationIndication.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.FeatureAuthorizationIndication.Buffer) + } } func (a *ConfigurationUpdateCommand) DecodeConfigurationUpdateCommand(byteArray *[]byte) { @@ -386,6 +466,62 @@ func (a *ConfigurationUpdateCommand) DecodeConfigurationUpdateCommand(byteArray binary.Read(buffer, binary.BigEndian, &a.ExtendedLADNInformation.Len) a.ExtendedLADNInformation.SetLen(a.ExtendedLADNInformation.GetLen()) binary.Read(buffer, binary.BigEndian, a.ExtendedLADNInformation.Buffer[:a.ExtendedLADNInformation.GetLen()]) + case ConfigurationUpdateCommandRegistrationResult5GSType: + a.RegistrationResult5GS = nasType.NewRegistrationResult5GS(ieiN) + binary.Read(buffer, binary.BigEndian, &a.RegistrationResult5GS.Len) + a.RegistrationResult5GS.SetLen(a.RegistrationResult5GS.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.RegistrationResult5GS.Octet) + case ConfigurationUpdateCommandAdditionalConfigurationIndicationType: + a.AdditionalConfigurationIndication = nasType.NewAdditionalConfigurationIndication(ieiN) + a.AdditionalConfigurationIndication.Octet = ieiN + case ConfigurationUpdateCommandUpdatedPEIPSAssistanceInformationType: + a.UpdatedPEIPSAssistanceInformation = nasType.NewUpdatedPEIPSAssistanceInformation(ieiN) + binary.Read(buffer, binary.BigEndian, &a.UpdatedPEIPSAssistanceInformation.Len) + a.UpdatedPEIPSAssistanceInformation.SetLen(a.UpdatedPEIPSAssistanceInformation.GetLen()) + binary.Read(buffer, binary.BigEndian, a.UpdatedPEIPSAssistanceInformation.Buffer[:a.UpdatedPEIPSAssistanceInformation.GetLen()]) + case ConfigurationUpdateCommandPriorityIndicatorType: + a.PriorityIndicator = nasType.NewPriorityIndicator(ieiN) + a.PriorityIndicator.Octet = ieiN + case ConfigurationUpdateCommandRANTimingSynchronizationType: + a.RANTimingSynchronization = nasType.NewRANTimingSynchronization(ieiN) + binary.Read(buffer, binary.BigEndian, &a.RANTimingSynchronization.Len) + a.RANTimingSynchronization.SetLen(a.RANTimingSynchronization.GetLen()) + binary.Read(buffer, binary.BigEndian, a.RANTimingSynchronization.Buffer[:a.RANTimingSynchronization.GetLen()]) + case ConfigurationUpdateCommandAlternativeNSSAIType: + a.AlternativeNSSAI = nasType.NewAlternativeNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.AlternativeNSSAI.Len) + a.AlternativeNSSAI.SetLen(a.AlternativeNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.AlternativeNSSAI.Buffer[:a.AlternativeNSSAI.GetLen()]) + case ConfigurationUpdateCommandSNSSAILocationValidityInformationType: + a.SNSSAILocationValidityInformation = nasType.NewSNSSAILocationValidityInformation(ieiN) + binary.Read(buffer, binary.BigEndian, &a.SNSSAILocationValidityInformation.Len) + a.SNSSAILocationValidityInformation.SetLen(a.SNSSAILocationValidityInformation.GetLen()) + binary.Read(buffer, binary.BigEndian, a.SNSSAILocationValidityInformation.Buffer[:a.SNSSAILocationValidityInformation.GetLen()]) + case ConfigurationUpdateCommandSNSSAITimeValidityInformationType: + a.SNSSAITimeValidityInformation = nasType.NewSNSSAITimeValidityInformation(ieiN) + binary.Read(buffer, binary.BigEndian, &a.SNSSAITimeValidityInformation.Len) + a.SNSSAITimeValidityInformation.SetLen(a.SNSSAITimeValidityInformation.GetLen()) + binary.Read(buffer, binary.BigEndian, a.SNSSAITimeValidityInformation.Buffer[:a.SNSSAITimeValidityInformation.GetLen()]) + case ConfigurationUpdateCommandDiscontinuousCoverageMaxTimeOffsetType: + a.DiscontinuousCoverageMaxTimeOffset = nasType.NewDiscontinuousCoverageMaxTimeOffset(ieiN) + binary.Read(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Len) + a.DiscontinuousCoverageMaxTimeOffset.SetLen(a.DiscontinuousCoverageMaxTimeOffset.GetLen()) + binary.Read(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.Buffer[:a.DiscontinuousCoverageMaxTimeOffset.GetLen()]) + case ConfigurationUpdateCommandPartiallyAllowedNSSAIType: + a.PartiallyAllowedNSSAI = nasType.NewPartiallyAllowedNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.PartiallyAllowedNSSAI.Len) + a.PartiallyAllowedNSSAI.SetLen(a.PartiallyAllowedNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.PartiallyAllowedNSSAI.Buffer[:a.PartiallyAllowedNSSAI.GetLen()]) + case ConfigurationUpdateCommandPartiallyRejectedNSSAIType: + a.PartiallyRejectedNSSAI = nasType.NewPartiallyRejectedNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.PartiallyRejectedNSSAI.Len) + a.PartiallyRejectedNSSAI.SetLen(a.PartiallyRejectedNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.PartiallyRejectedNSSAI.Buffer[:a.PartiallyRejectedNSSAI.GetLen()]) + case ConfigurationUpdateCommandFeatureAuthorizationIndicationType: + a.FeatureAuthorizationIndication = nasType.NewFeatureAuthorizationIndication(ieiN) + binary.Read(buffer, binary.BigEndian, &a.FeatureAuthorizationIndication.Len) + a.FeatureAuthorizationIndication.SetLen(a.FeatureAuthorizationIndication.GetLen()) + binary.Read(buffer, binary.BigEndian, a.FeatureAuthorizationIndication.Buffer[:a.FeatureAuthorizationIndication.GetLen()]) default: } } diff --git a/nasMessage/NAS_ControlPlaneServiceRequest.go b/nasMessage/NAS_ControlPlaneServiceRequest.go index 1f4d3c31..65a219d5 100644 --- a/nasMessage/NAS_ControlPlaneServiceRequest.go +++ b/nasMessage/NAS_ControlPlaneServiceRequest.go @@ -22,6 +22,10 @@ type ControlPlaneServiceRequest struct { *nasType.AllowedPDUSessionStatus *nasType.UERequestType *nasType.PagingRestriction + *nasType.CIoTSmallDataContainer + *nasType.PduSessionID2Value + *nasType.AdditionalInformation + *nasType.ReleaseAssistanceIndication } func NewControlPlaneServiceRequest(iei uint8) (controlPlaneServiceRequest *ControlPlaneServiceRequest) { @@ -30,12 +34,16 @@ func NewControlPlaneServiceRequest(iei uint8) (controlPlaneServiceRequest *Contr } const ( - ControlPlaneServiceRequestPDUSessionStatusType uint8 = 0x50 - ControlPlaneServiceRequestUplinkDataStatusType uint8 = 0x40 - ControlPlaneServiceRequestNASMessageContainerType uint8 = 0x71 - ControlPlaneServiceRequestAllowedPDUSessionStatusType uint8 = 0x25 - ControlPlaneServiceRequestUERequestTypeType uint8 = 0x29 - ControlPlaneServiceRequestPagingRestrictionType uint8 = 0x28 + ControlPlaneServiceRequestPDUSessionStatusType uint8 = 0x50 + ControlPlaneServiceRequestUplinkDataStatusType uint8 = 0x40 + ControlPlaneServiceRequestNASMessageContainerType uint8 = 0x71 + ControlPlaneServiceRequestAllowedPDUSessionStatusType uint8 = 0x25 + ControlPlaneServiceRequestUERequestTypeType uint8 = 0x29 + ControlPlaneServiceRequestPagingRestrictionType uint8 = 0x28 + ControlPlaneServiceRequestCIoTSmallDataContainerType uint8 = 0x6F + ControlPlaneServiceRequestPduSessionIDType uint8 = 0x12 + ControlPlaneServiceRequestAdditionalInformationType uint8 = 0x24 + ControlPlaneServiceRequestReleaseAssistanceIndicationType uint8 = 0x0F ) func (a *ControlPlaneServiceRequest) EncodeControlPlaneServiceRequest(buffer *bytes.Buffer) { @@ -73,6 +81,23 @@ func (a *ControlPlaneServiceRequest) EncodeControlPlaneServiceRequest(buffer *by binary.Write(buffer, binary.BigEndian, uint8(a.PagingRestriction.GetLen())) binary.Write(buffer, binary.BigEndian, a.PagingRestriction.Buffer[:uint8(a.PagingRestriction.GetLen())]) } + if a.CIoTSmallDataContainer != nil { + binary.Write(buffer, binary.BigEndian, a.CIoTSmallDataContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.CIoTSmallDataContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.CIoTSmallDataContainer.Buffer) + } + if a.PduSessionID2Value != nil { + binary.Write(buffer, binary.BigEndian, a.PduSessionID2Value.GetIei()) + binary.Write(buffer, binary.BigEndian, &a.PduSessionID2Value.Octet) + } + if a.AdditionalInformation != nil { + binary.Write(buffer, binary.BigEndian, a.AdditionalInformation.GetIei()) + binary.Write(buffer, binary.BigEndian, a.AdditionalInformation.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.AdditionalInformation.Buffer) + } + if a.ReleaseAssistanceIndication != nil { + binary.Write(buffer, binary.BigEndian, &a.ReleaseAssistanceIndication.Octet) + } } func (a *ControlPlaneServiceRequest) DecodeControlPlaneServiceRequest(byteArray *[]byte) { @@ -123,6 +148,22 @@ func (a *ControlPlaneServiceRequest) DecodeControlPlaneServiceRequest(byteArray binary.Read(buffer, binary.BigEndian, &lenN1) a.PagingRestriction.SetLen(uint16(lenN1)) binary.Read(buffer, binary.BigEndian, a.PagingRestriction.Buffer[:lenN1]) + case ControlPlaneServiceRequestCIoTSmallDataContainerType: + a.CIoTSmallDataContainer = nasType.NewCIoTSmallDataContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.CIoTSmallDataContainer.Len) + a.CIoTSmallDataContainer.SetLen(a.CIoTSmallDataContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.CIoTSmallDataContainer.Buffer[:a.CIoTSmallDataContainer.GetLen()]) + case ControlPlaneServiceRequestPduSessionIDType: + a.PduSessionID2Value = nasType.NewPduSessionID2Value(ieiN) + binary.Read(buffer, binary.BigEndian, &a.PduSessionID2Value.Octet) + case ControlPlaneServiceRequestAdditionalInformationType: + a.AdditionalInformation = nasType.NewAdditionalInformation(ieiN) + binary.Read(buffer, binary.BigEndian, &a.AdditionalInformation.Len) + a.AdditionalInformation.SetLen(a.AdditionalInformation.GetLen()) + binary.Read(buffer, binary.BigEndian, a.AdditionalInformation.Buffer[:a.AdditionalInformation.GetLen()]) + case ControlPlaneServiceRequestReleaseAssistanceIndicationType: + a.ReleaseAssistanceIndication = nasType.NewReleaseAssistanceIndication(ieiN) + a.ReleaseAssistanceIndication.Octet = ieiN default: } } diff --git a/nasMessage/NAS_DLNASTransport.go b/nasMessage/NAS_DLNASTransport.go index f4900ed9..5e44ab2e 100644 --- a/nasMessage/NAS_DLNASTransport.go +++ b/nasMessage/NAS_DLNASTransport.go @@ -23,6 +23,7 @@ type DLNASTransport struct { *nasType.AdditionalInformation *nasType.Cause5GMM *nasType.BackoffTimerValue + *nasType.LowerBoundTimerValue Ipaddr string } @@ -36,6 +37,7 @@ const ( DLNASTransportAdditionalInformationType uint8 = 0x24 DLNASTransportCause5GMMType uint8 = 0x58 DLNASTransportBackoffTimerValueType uint8 = 0x37 + DLNASTransportLowerBoundTimerValueType uint8 = 0x3A ) func (a *DLNASTransport) EncodeDLNASTransport(buffer *bytes.Buffer) { @@ -63,6 +65,11 @@ func (a *DLNASTransport) EncodeDLNASTransport(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, a.BackoffTimerValue.GetLen()) binary.Write(buffer, binary.BigEndian, &a.BackoffTimerValue.Octet) } + if a.LowerBoundTimerValue != nil { + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetIei()) + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + } } func (a *DLNASTransport) DecodeDLNASTransport(byteArray *[]byte) { @@ -140,6 +147,11 @@ func (a *DLNASTransport) DecodeDLNASTransport(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &a.BackoffTimerValue.Len) a.BackoffTimerValue.SetLen(a.BackoffTimerValue.GetLen()) binary.Read(buffer, binary.BigEndian, &a.BackoffTimerValue.Octet) + case DLNASTransportLowerBoundTimerValueType: + a.LowerBoundTimerValue = nasType.NewLowerBoundTimerValue(ieiN) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Len) + a.LowerBoundTimerValue.SetLen(a.LowerBoundTimerValue.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) default: } } diff --git a/nasMessage/NAS_DeregistrationRequestUEOriginatingDeregistration.go b/nasMessage/NAS_DeregistrationRequestUEOriginatingDeregistration.go index b701b753..a3f07a37 100644 --- a/nasMessage/NAS_DeregistrationRequestUEOriginatingDeregistration.go +++ b/nasMessage/NAS_DeregistrationRequestUEOriginatingDeregistration.go @@ -1,7 +1,6 @@ +// Copyright (C) 2026 Intel Corporation // Copyright 2019 free5GC.org -// // SPDX-License-Identifier: Apache-2.0 -// package nasMessage @@ -18,6 +17,8 @@ type DeregistrationRequestUEOriginatingDeregistration struct { nasType.DeregistrationRequestMessageIdentity nasType.NgksiAndDeregistrationType nasType.MobileIdentity5GS + *nasType.LowerBoundTimerValue + *nasType.NASMessageContainer } func NewDeregistrationRequestUEOriginatingDeregistration(iei uint8) (deregistrationRequestUEOriginatingDeregistration *DeregistrationRequestUEOriginatingDeregistration) { @@ -25,6 +26,11 @@ func NewDeregistrationRequestUEOriginatingDeregistration(iei uint8) (deregistrat return deregistrationRequestUEOriginatingDeregistration } +const ( + DeregistrationRequestUEOriginatingDeregistrationUnavailabilityPeriodType uint8 = 0x3C + DeregistrationRequestUEOriginatingDeregistrationNASMessageContainerType uint8 = 0x71 +) + func (a *DeregistrationRequestUEOriginatingDeregistration) EncodeDeregistrationRequestUEOriginatingDeregistration(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, &a.ExtendedProtocolDiscriminator.Octet) binary.Write(buffer, binary.BigEndian, &a.SpareHalfOctetAndSecurityHeaderType.Octet) @@ -32,6 +38,16 @@ func (a *DeregistrationRequestUEOriginatingDeregistration) EncodeDeregistrationR binary.Write(buffer, binary.BigEndian, &a.NgksiAndDeregistrationType.Octet) binary.Write(buffer, binary.BigEndian, a.MobileIdentity5GS.GetLen()) binary.Write(buffer, binary.BigEndian, &a.MobileIdentity5GS.Buffer) + if a.LowerBoundTimerValue != nil { + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetIei()) + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + } + if a.NASMessageContainer != nil { + binary.Write(buffer, binary.BigEndian, a.NASMessageContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.NASMessageContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.NASMessageContainer.Buffer) + } } func (a *DeregistrationRequestUEOriginatingDeregistration) DecodeDeregistrationRequestUEOriginatingDeregistration(byteArray *[]byte) { @@ -53,6 +69,16 @@ func (a *DeregistrationRequestUEOriginatingDeregistration) DecodeDeregistrationR tmpIeiN = ieiN } switch tmpIeiN { + case DeregistrationRequestUEOriginatingDeregistrationUnavailabilityPeriodType: + a.LowerBoundTimerValue = nasType.NewLowerBoundTimerValue(ieiN) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Len) + a.LowerBoundTimerValue.SetLen(a.LowerBoundTimerValue.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + case DeregistrationRequestUEOriginatingDeregistrationNASMessageContainerType: + a.NASMessageContainer = nasType.NewNASMessageContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.NASMessageContainer.Len) + a.NASMessageContainer.SetLen(a.NASMessageContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.NASMessageContainer.Buffer) default: } } diff --git a/nasMessage/NAS_DeregistrationRequestUETerminatedDeregistration.go b/nasMessage/NAS_DeregistrationRequestUETerminatedDeregistration.go index 65e197a1..c8dc5074 100644 --- a/nasMessage/NAS_DeregistrationRequestUETerminatedDeregistration.go +++ b/nasMessage/NAS_DeregistrationRequestUETerminatedDeregistration.go @@ -1,7 +1,6 @@ +// Copyright (C) 2026 Intel Corporation // Copyright 2019 free5GC.org -// // SPDX-License-Identifier: Apache-2.0 -// package nasMessage @@ -19,6 +18,14 @@ type DeregistrationRequestUETerminatedDeregistration struct { nasType.SpareHalfOctetAndDeregistrationType *nasType.Cause5GMM *nasType.T3346Value + *nasType.RejectedNSSAI + *nasType.CAGInformationList + *nasType.ExtendedRejectedNSSAI + DisasterReturnWaitRange *nasType.RegistrationWaitRange + *nasType.ExtendedCAGInformationList + *nasType.LowerBoundTimerValue + ForbiddenTAIRoaming *nasType.TAIList + ForbiddenTAIRegionalProvision *nasType.TAIList } func NewDeregistrationRequestUETerminatedDeregistration(iei uint8) (deregistrationRequestUETerminatedDeregistration *DeregistrationRequestUETerminatedDeregistration) { @@ -27,8 +34,16 @@ func NewDeregistrationRequestUETerminatedDeregistration(iei uint8) (deregistrati } const ( - DeregistrationRequestUETerminatedDeregistrationCause5GMMType uint8 = 0x58 - DeregistrationRequestUETerminatedDeregistrationT3346ValueType uint8 = 0x5F + DeregistrationRequestUETerminatedDeregistrationCause5GMMType uint8 = 0x58 + DeregistrationRequestUETerminatedDeregistrationT3346ValueType uint8 = 0x5F + DeregistrationRequestUETerminatedDeregistrationRejectedNSSAIType uint8 = 0x6D + DeregistrationRequestUETerminatedDeregistrationCAGInformationListType uint8 = 0x75 + DeregistrationRequestUETerminatedDeregistrationExtendedRejectedNSSAIType uint8 = 0x68 + DeregistrationRequestUETerminatedDeregistrationDisasterReturnWaitRangeType uint8 = 0x2C + DeregistrationRequestUETerminatedDeregistrationExtendedCAGInformationListType uint8 = 0x71 + DeregistrationRequestUETerminatedDeregistrationLowerBoundTimerValueType uint8 = 0x3A + DeregistrationRequestUETerminatedDeregistrationForbiddenTAIRoamingType uint8 = 0x1D + DeregistrationRequestUETerminatedDeregistrationForbiddenTAIRegionalProvisionType uint8 = 0x1E ) func (a *DeregistrationRequestUETerminatedDeregistration) EncodeDeregistrationRequestUETerminatedDeregistration(buffer *bytes.Buffer) { @@ -45,6 +60,46 @@ func (a *DeregistrationRequestUETerminatedDeregistration) EncodeDeregistrationRe binary.Write(buffer, binary.BigEndian, a.T3346Value.GetLen()) binary.Write(buffer, binary.BigEndian, &a.T3346Value.Octet) } + if a.RejectedNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.RejectedNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.RejectedNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.RejectedNSSAI.Buffer) + } + if a.CAGInformationList != nil { + binary.Write(buffer, binary.BigEndian, a.CAGInformationList.GetIei()) + binary.Write(buffer, binary.BigEndian, a.CAGInformationList.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.CAGInformationList.Buffer) + } + if a.ExtendedRejectedNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.ExtendedRejectedNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.ExtendedRejectedNSSAI.GetLen())) + binary.Write(buffer, binary.BigEndian, a.ExtendedRejectedNSSAI.Buffer[:uint8(a.ExtendedRejectedNSSAI.GetLen())]) + } + if a.DisasterReturnWaitRange != nil { + binary.Write(buffer, binary.BigEndian, a.DisasterReturnWaitRange.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.DisasterReturnWaitRange.GetLen())) + binary.Write(buffer, binary.BigEndian, a.DisasterReturnWaitRange.Buffer[:uint8(a.DisasterReturnWaitRange.GetLen())]) + } + if a.ExtendedCAGInformationList != nil { + binary.Write(buffer, binary.BigEndian, a.ExtendedCAGInformationList.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ExtendedCAGInformationList.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ExtendedCAGInformationList.Buffer) + } + if a.LowerBoundTimerValue != nil { + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetIei()) + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + } + if a.ForbiddenTAIRoaming != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Buffer) + } + if a.ForbiddenTAIRegionalProvision != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Buffer) + } } func (a *DeregistrationRequestUETerminatedDeregistration) DecodeDeregistrationRequestUETerminatedDeregistration(byteArray *[]byte) { @@ -71,6 +126,48 @@ func (a *DeregistrationRequestUETerminatedDeregistration) DecodeDeregistrationRe binary.Read(buffer, binary.BigEndian, &a.T3346Value.Len) a.T3346Value.SetLen(a.T3346Value.GetLen()) binary.Read(buffer, binary.BigEndian, &a.T3346Value.Octet) + case DeregistrationRequestUETerminatedDeregistrationRejectedNSSAIType: + a.RejectedNSSAI = nasType.NewRejectedNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.RejectedNSSAI.Len) + a.RejectedNSSAI.SetLen(a.RejectedNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.RejectedNSSAI.Buffer[:a.RejectedNSSAI.GetLen()]) + case DeregistrationRequestUETerminatedDeregistrationCAGInformationListType: + a.CAGInformationList = nasType.NewCAGInformationList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.CAGInformationList.Len) + a.CAGInformationList.SetLen(a.CAGInformationList.GetLen()) + binary.Read(buffer, binary.BigEndian, a.CAGInformationList.Buffer[:a.CAGInformationList.GetLen()]) + case DeregistrationRequestUETerminatedDeregistrationExtendedRejectedNSSAIType: + a.ExtendedRejectedNSSAI = nasType.NewExtendedRejectedNSSAI(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.ExtendedRejectedNSSAI.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.ExtendedRejectedNSSAI.Buffer[:l]) + case DeregistrationRequestUETerminatedDeregistrationDisasterReturnWaitRangeType: + a.DisasterReturnWaitRange = nasType.NewRegistrationWaitRange(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.DisasterReturnWaitRange.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.DisasterReturnWaitRange.Buffer[:l]) + case DeregistrationRequestUETerminatedDeregistrationExtendedCAGInformationListType: + a.ExtendedCAGInformationList = nasType.NewExtendedCAGInformationList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ExtendedCAGInformationList.Len) + a.ExtendedCAGInformationList.SetLen(a.ExtendedCAGInformationList.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ExtendedCAGInformationList.Buffer[:a.ExtendedCAGInformationList.GetLen()]) + case DeregistrationRequestUETerminatedDeregistrationLowerBoundTimerValueType: + a.LowerBoundTimerValue = nasType.NewLowerBoundTimerValue(ieiN) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Len) + a.LowerBoundTimerValue.SetLen(a.LowerBoundTimerValue.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + case DeregistrationRequestUETerminatedDeregistrationForbiddenTAIRoamingType: + a.ForbiddenTAIRoaming = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Len) + a.ForbiddenTAIRoaming.SetLen(a.ForbiddenTAIRoaming.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.Buffer[:a.ForbiddenTAIRoaming.GetLen()]) + case DeregistrationRequestUETerminatedDeregistrationForbiddenTAIRegionalProvisionType: + a.ForbiddenTAIRegionalProvision = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Len) + a.ForbiddenTAIRegionalProvision.SetLen(a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.Buffer[:a.ForbiddenTAIRegionalProvision.GetLen()]) default: } } diff --git a/nasMessage/NAS_PDUSessionEstablishmentAccept.go b/nasMessage/NAS_PDUSessionEstablishmentAccept.go index 83c049fb..e60c99e0 100644 --- a/nasMessage/NAS_PDUSessionEstablishmentAccept.go +++ b/nasMessage/NAS_PDUSessionEstablishmentAccept.go @@ -30,6 +30,15 @@ type PDUSessionEstablishmentAccept struct { *nasType.AuthorizedQosFlowDescriptions *nasType.ExtendedProtocolConfigurationOptions *nasType.DNN + *nasType.FiveGSMNetworkFeatureSupport + *nasType.ServingPLMNRateControl + *nasType.ATSSSContainer + *nasType.ControlPlaneOnlyIndication + *nasType.IPHeaderCompressionConfiguration + *nasType.EthernetHeaderCompressionConfiguration + *nasType.ServiceLevelAAContainer + *nasType.ReceivedMBSContainer + *nasType.N3QAI } func NewPDUSessionEstablishmentAccept(iei uint8) (pDUSessionEstablishmentAccept *PDUSessionEstablishmentAccept) { @@ -48,6 +57,15 @@ const ( PDUSessionEstablishmentAcceptAuthorizedQosFlowDescriptionsType uint8 = 0x79 PDUSessionEstablishmentAcceptExtendedProtocolConfigurationOptionsType uint8 = 0x7B PDUSessionEstablishmentAcceptDNNType uint8 = 0x25 + PDUSessionEstablishmentAcceptFiveGSMNetworkFeatureSupportType uint8 = 0x17 + PDUSessionEstablishmentAcceptServingPLMNRateControlType uint8 = 0x18 + PDUSessionEstablishmentAcceptATSSSContainerType uint8 = 0x77 + PDUSessionEstablishmentAcceptControlPlaneOnlyIndicationType uint8 = 0x0C + PDUSessionEstablishmentAcceptIPHeaderCompressionConfigurationType uint8 = 0x66 + PDUSessionEstablishmentAcceptEthernetHeaderCompressionConfigType uint8 = 0x1F + PDUSessionEstablishmentAcceptServiceLevelAAContainerType uint8 = 0x72 + PDUSessionEstablishmentAcceptReceivedMBSContainerType uint8 = 0x71 + PDUSessionEstablishmentAcceptN3QAIType uint8 = 0x70 ) func (a *PDUSessionEstablishmentAccept) EncodePDUSessionEstablishmentAccept(buffer *bytes.Buffer) { @@ -106,6 +124,49 @@ func (a *PDUSessionEstablishmentAccept) EncodePDUSessionEstablishmentAccept(buff binary.Write(buffer, binary.BigEndian, a.DNN.GetLen()) binary.Write(buffer, binary.BigEndian, &a.DNN.Buffer) } + if a.FiveGSMNetworkFeatureSupport != nil { + binary.Write(buffer, binary.BigEndian, a.FiveGSMNetworkFeatureSupport.GetIei()) + binary.Write(buffer, binary.BigEndian, a.FiveGSMNetworkFeatureSupport.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.FiveGSMNetworkFeatureSupport.Buffer) + } + if a.ServingPLMNRateControl != nil { + binary.Write(buffer, binary.BigEndian, a.ServingPLMNRateControl.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ServingPLMNRateControl.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ServingPLMNRateControl.Buffer) + } + if a.ATSSSContainer != nil { + binary.Write(buffer, binary.BigEndian, a.ATSSSContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ATSSSContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ATSSSContainer.Buffer) + } + if a.ControlPlaneOnlyIndication != nil { + binary.Write(buffer, binary.BigEndian, &a.ControlPlaneOnlyIndication.Octet) + } + if a.IPHeaderCompressionConfiguration != nil { + binary.Write(buffer, binary.BigEndian, a.IPHeaderCompressionConfiguration.GetIei()) + binary.Write(buffer, binary.BigEndian, a.IPHeaderCompressionConfiguration.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.IPHeaderCompressionConfiguration.Buffer) + } + if a.EthernetHeaderCompressionConfiguration != nil { + binary.Write(buffer, binary.BigEndian, a.EthernetHeaderCompressionConfiguration.GetIei()) + binary.Write(buffer, binary.BigEndian, a.EthernetHeaderCompressionConfiguration.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.EthernetHeaderCompressionConfiguration.Octet) + } + if a.ServiceLevelAAContainer != nil { + binary.Write(buffer, binary.BigEndian, a.ServiceLevelAAContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ServiceLevelAAContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ServiceLevelAAContainer.Buffer) + } + if a.ReceivedMBSContainer != nil { + binary.Write(buffer, binary.BigEndian, a.ReceivedMBSContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ReceivedMBSContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ReceivedMBSContainer.Buffer) + } + if a.N3QAI != nil { + binary.Write(buffer, binary.BigEndian, a.N3QAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.N3QAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.N3QAI.Buffer) + } } func (a *PDUSessionEstablishmentAccept) DecodePDUSessionEstablishmentAccept(byteArray *[]byte) { @@ -175,6 +236,49 @@ func (a *PDUSessionEstablishmentAccept) DecodePDUSessionEstablishmentAccept(byte binary.Read(buffer, binary.BigEndian, &a.DNN.Len) a.DNN.SetLen(a.DNN.GetLen()) binary.Read(buffer, binary.BigEndian, a.DNN.Buffer[:a.DNN.GetLen()]) + case PDUSessionEstablishmentAcceptFiveGSMNetworkFeatureSupportType: + a.FiveGSMNetworkFeatureSupport = nasType.NewFiveGSMNetworkFeatureSupport(ieiN) + binary.Read(buffer, binary.BigEndian, &a.FiveGSMNetworkFeatureSupport.Len) + a.FiveGSMNetworkFeatureSupport.SetLen(a.FiveGSMNetworkFeatureSupport.GetLen()) + binary.Read(buffer, binary.BigEndian, a.FiveGSMNetworkFeatureSupport.Buffer[:a.FiveGSMNetworkFeatureSupport.GetLen()]) + case PDUSessionEstablishmentAcceptServingPLMNRateControlType: + a.ServingPLMNRateControl = nasType.NewServingPLMNRateControl(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ServingPLMNRateControl.Len) + a.ServingPLMNRateControl.SetLen(a.ServingPLMNRateControl.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ServingPLMNRateControl.Buffer[:a.ServingPLMNRateControl.GetLen()]) + case PDUSessionEstablishmentAcceptATSSSContainerType: + a.ATSSSContainer = nasType.NewATSSSContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ATSSSContainer.Len) + a.ATSSSContainer.SetLen(a.ATSSSContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ATSSSContainer.Buffer[:a.ATSSSContainer.GetLen()]) + case PDUSessionEstablishmentAcceptControlPlaneOnlyIndicationType: + a.ControlPlaneOnlyIndication = nasType.NewControlPlaneOnlyIndication(ieiN) + a.ControlPlaneOnlyIndication.Octet = ieiN + case PDUSessionEstablishmentAcceptIPHeaderCompressionConfigurationType: + a.IPHeaderCompressionConfiguration = nasType.NewIPHeaderCompressionConfiguration(ieiN) + binary.Read(buffer, binary.BigEndian, &a.IPHeaderCompressionConfiguration.Len) + a.IPHeaderCompressionConfiguration.SetLen(a.IPHeaderCompressionConfiguration.GetLen()) + binary.Read(buffer, binary.BigEndian, a.IPHeaderCompressionConfiguration.Buffer[:a.IPHeaderCompressionConfiguration.GetLen()]) + case PDUSessionEstablishmentAcceptEthernetHeaderCompressionConfigType: + a.EthernetHeaderCompressionConfiguration = nasType.NewEthernetHeaderCompressionConfiguration(ieiN) + binary.Read(buffer, binary.BigEndian, &a.EthernetHeaderCompressionConfiguration.Len) + a.EthernetHeaderCompressionConfiguration.SetLen(a.EthernetHeaderCompressionConfiguration.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.EthernetHeaderCompressionConfiguration.Octet) + case PDUSessionEstablishmentAcceptServiceLevelAAContainerType: + a.ServiceLevelAAContainer = nasType.NewServiceLevelAAContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ServiceLevelAAContainer.Len) + a.ServiceLevelAAContainer.SetLen(a.ServiceLevelAAContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ServiceLevelAAContainer.Buffer[:a.ServiceLevelAAContainer.GetLen()]) + case PDUSessionEstablishmentAcceptReceivedMBSContainerType: + a.ReceivedMBSContainer = nasType.NewReceivedMBSContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ReceivedMBSContainer.Len) + a.ReceivedMBSContainer.SetLen(a.ReceivedMBSContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ReceivedMBSContainer.Buffer[:a.ReceivedMBSContainer.GetLen()]) + case PDUSessionEstablishmentAcceptN3QAIType: + a.N3QAI = nasType.NewN3QAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.N3QAI.Len) + a.N3QAI.SetLen(a.N3QAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.N3QAI.Buffer[:a.N3QAI.GetLen()]) default: } } diff --git a/nasMessage/NAS_PDUSessionEstablishmentReject.go b/nasMessage/NAS_PDUSessionEstablishmentReject.go index e1d345f9..67c131f1 100644 --- a/nasMessage/NAS_PDUSessionEstablishmentReject.go +++ b/nasMessage/NAS_PDUSessionEstablishmentReject.go @@ -22,6 +22,9 @@ type PDUSessionEstablishmentReject struct { *nasType.AllowedSSCMode *nasType.EAPMessage *nasType.ExtendedProtocolConfigurationOptions + *nasType.Fivegsmcongestionreattemptindicator + *nasType.ReAttemptIndicator + *nasType.ServiceLevelAAContainer } func NewPDUSessionEstablishmentReject(iei uint8) (pDUSessionEstablishmentReject *PDUSessionEstablishmentReject) { @@ -34,6 +37,9 @@ const ( PDUSessionEstablishmentRejectAllowedSSCModeType uint8 = 0x0F PDUSessionEstablishmentRejectEAPMessageType uint8 = 0x78 PDUSessionEstablishmentRejectExtendedProtocolConfigurationOptionsType uint8 = 0x7B + PDUSessionEstablishmentRejectFivegsmcongestionreattemptindicatorType uint8 = 0x61 + PDUSessionEstablishmentRejectReAttemptIndicatorType uint8 = 0x1D + PDUSessionEstablishmentRejectServiceLevelAAContainerType uint8 = 0x72 ) func (a *PDUSessionEstablishmentReject) EncodePDUSessionEstablishmentReject(buffer *bytes.Buffer) { @@ -60,6 +66,21 @@ func (a *PDUSessionEstablishmentReject) EncodePDUSessionEstablishmentReject(buff binary.Write(buffer, binary.BigEndian, a.ExtendedProtocolConfigurationOptions.GetLen()) binary.Write(buffer, binary.BigEndian, &a.ExtendedProtocolConfigurationOptions.Buffer) } + if a.Fivegsmcongestionreattemptindicator != nil { + binary.Write(buffer, binary.BigEndian, a.Fivegsmcongestionreattemptindicator.GetIei()) + binary.Write(buffer, binary.BigEndian, a.Fivegsmcongestionreattemptindicator.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Octet) + } + if a.ReAttemptIndicator != nil { + binary.Write(buffer, binary.BigEndian, a.ReAttemptIndicator.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ReAttemptIndicator.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ReAttemptIndicator.Octet) + } + if a.ServiceLevelAAContainer != nil { + binary.Write(buffer, binary.BigEndian, a.ServiceLevelAAContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ServiceLevelAAContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ServiceLevelAAContainer.Buffer) + } } func (a *PDUSessionEstablishmentReject) DecodePDUSessionEstablishmentReject(byteArray *[]byte) { @@ -97,6 +118,21 @@ func (a *PDUSessionEstablishmentReject) DecodePDUSessionEstablishmentReject(byte binary.Read(buffer, binary.BigEndian, &a.ExtendedProtocolConfigurationOptions.Len) a.ExtendedProtocolConfigurationOptions.SetLen(a.ExtendedProtocolConfigurationOptions.GetLen()) binary.Read(buffer, binary.BigEndian, a.ExtendedProtocolConfigurationOptions.Buffer[:a.ExtendedProtocolConfigurationOptions.GetLen()]) + case PDUSessionEstablishmentRejectFivegsmcongestionreattemptindicatorType: + a.Fivegsmcongestionreattemptindicator = nasType.NewFivegsmcongestionreattemptindicator(ieiN) + binary.Read(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Len) + a.Fivegsmcongestionreattemptindicator.SetLen(a.Fivegsmcongestionreattemptindicator.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Octet) + case PDUSessionEstablishmentRejectReAttemptIndicatorType: + a.ReAttemptIndicator = nasType.NewReAttemptIndicator(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ReAttemptIndicator.Len) + a.ReAttemptIndicator.SetLen(a.ReAttemptIndicator.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.ReAttemptIndicator.Octet) + case PDUSessionEstablishmentRejectServiceLevelAAContainerType: + a.ServiceLevelAAContainer = nasType.NewServiceLevelAAContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ServiceLevelAAContainer.Len) + a.ServiceLevelAAContainer.SetLen(a.ServiceLevelAAContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ServiceLevelAAContainer.Buffer[:a.ServiceLevelAAContainer.GetLen()]) default: } } diff --git a/nasMessage/NAS_PDUSessionModificationCommand.go b/nasMessage/NAS_PDUSessionModificationCommand.go index 2924e1a3..e7a2f760 100644 --- a/nasMessage/NAS_PDUSessionModificationCommand.go +++ b/nasMessage/NAS_PDUSessionModificationCommand.go @@ -25,6 +25,14 @@ type PDUSessionModificationCommand struct { *nasType.MappedEPSBearerContexts *nasType.AuthorizedQosFlowDescriptions *nasType.ExtendedProtocolConfigurationOptions + *nasType.ATSSSContainer + *nasType.IPHeaderCompressionConfiguration + *nasType.ServingPLMNRateControl + *nasType.EthernetHeaderCompressionConfiguration + *nasType.ReceivedMBSContainer + *nasType.ServiceLevelAAContainer + AlternativeSNSSAI *nasType.SNSSAI + *nasType.N3QAI } func NewPDUSessionModificationCommand(iei uint8) (pDUSessionModificationCommand *PDUSessionModificationCommand) { @@ -41,6 +49,14 @@ const ( PDUSessionModificationCommandMappedEPSBearerContextsType uint8 = 0x7F PDUSessionModificationCommandAuthorizedQosFlowDescriptionsType uint8 = 0x79 PDUSessionModificationCommandExtendedProtocolConfigurationOptionsType uint8 = 0x7B + PDUSessionModificationCommandATSSSContainerType uint8 = 0x77 + PDUSessionModificationCommandIPHeaderCompressionConfigurationType uint8 = 0x66 + PDUSessionModificationCommandServingPLMNRateControlType uint8 = 0x1E + PDUSessionModificationCommandEthernetHeaderCompressionConfigType uint8 = 0x1F + PDUSessionModificationCommandReceivedMBSContainerType uint8 = 0x71 + PDUSessionModificationCommandServiceLevelAAContainerType uint8 = 0x72 + PDUSessionModificationCommandAlternativeSNSSAIType uint8 = 0x5A + PDUSessionModificationCommandN3QAIType uint8 = 0x70 ) func (a *PDUSessionModificationCommand) EncodePDUSessionModificationCommand(buffer *bytes.Buffer) { @@ -84,6 +100,46 @@ func (a *PDUSessionModificationCommand) EncodePDUSessionModificationCommand(buff binary.Write(buffer, binary.BigEndian, a.ExtendedProtocolConfigurationOptions.GetLen()) binary.Write(buffer, binary.BigEndian, &a.ExtendedProtocolConfigurationOptions.Buffer) } + if a.ATSSSContainer != nil { + binary.Write(buffer, binary.BigEndian, a.ATSSSContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ATSSSContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ATSSSContainer.Buffer) + } + if a.IPHeaderCompressionConfiguration != nil { + binary.Write(buffer, binary.BigEndian, a.IPHeaderCompressionConfiguration.GetIei()) + binary.Write(buffer, binary.BigEndian, a.IPHeaderCompressionConfiguration.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.IPHeaderCompressionConfiguration.Buffer) + } + if a.ServingPLMNRateControl != nil { + binary.Write(buffer, binary.BigEndian, a.ServingPLMNRateControl.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ServingPLMNRateControl.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ServingPLMNRateControl.Buffer) + } + if a.EthernetHeaderCompressionConfiguration != nil { + binary.Write(buffer, binary.BigEndian, a.EthernetHeaderCompressionConfiguration.GetIei()) + binary.Write(buffer, binary.BigEndian, a.EthernetHeaderCompressionConfiguration.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.EthernetHeaderCompressionConfiguration.Octet) + } + if a.ReceivedMBSContainer != nil { + binary.Write(buffer, binary.BigEndian, a.ReceivedMBSContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ReceivedMBSContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ReceivedMBSContainer.Buffer) + } + if a.ServiceLevelAAContainer != nil { + binary.Write(buffer, binary.BigEndian, a.ServiceLevelAAContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ServiceLevelAAContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ServiceLevelAAContainer.Buffer) + } + if a.AlternativeSNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.Octet[:a.AlternativeSNSSAI.GetLen()]) + } + if a.N3QAI != nil { + binary.Write(buffer, binary.BigEndian, a.N3QAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.N3QAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.N3QAI.Buffer) + } } func (a *PDUSessionModificationCommand) DecodePDUSessionModificationCommand(byteArray *[]byte) { @@ -136,6 +192,46 @@ func (a *PDUSessionModificationCommand) DecodePDUSessionModificationCommand(byte binary.Read(buffer, binary.BigEndian, &a.ExtendedProtocolConfigurationOptions.Len) a.ExtendedProtocolConfigurationOptions.SetLen(a.ExtendedProtocolConfigurationOptions.GetLen()) binary.Read(buffer, binary.BigEndian, a.ExtendedProtocolConfigurationOptions.Buffer[:a.ExtendedProtocolConfigurationOptions.GetLen()]) + case PDUSessionModificationCommandATSSSContainerType: + a.ATSSSContainer = nasType.NewATSSSContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ATSSSContainer.Len) + a.ATSSSContainer.SetLen(a.ATSSSContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ATSSSContainer.Buffer[:a.ATSSSContainer.GetLen()]) + case PDUSessionModificationCommandIPHeaderCompressionConfigurationType: + a.IPHeaderCompressionConfiguration = nasType.NewIPHeaderCompressionConfiguration(ieiN) + binary.Read(buffer, binary.BigEndian, &a.IPHeaderCompressionConfiguration.Len) + a.IPHeaderCompressionConfiguration.SetLen(a.IPHeaderCompressionConfiguration.GetLen()) + binary.Read(buffer, binary.BigEndian, a.IPHeaderCompressionConfiguration.Buffer[:a.IPHeaderCompressionConfiguration.GetLen()]) + case PDUSessionModificationCommandServingPLMNRateControlType: + a.ServingPLMNRateControl = nasType.NewServingPLMNRateControl(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ServingPLMNRateControl.Len) + a.ServingPLMNRateControl.SetLen(a.ServingPLMNRateControl.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ServingPLMNRateControl.Buffer[:a.ServingPLMNRateControl.GetLen()]) + case PDUSessionModificationCommandEthernetHeaderCompressionConfigType: + a.EthernetHeaderCompressionConfiguration = nasType.NewEthernetHeaderCompressionConfiguration(ieiN) + binary.Read(buffer, binary.BigEndian, &a.EthernetHeaderCompressionConfiguration.Len) + a.EthernetHeaderCompressionConfiguration.SetLen(a.EthernetHeaderCompressionConfiguration.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.EthernetHeaderCompressionConfiguration.Octet) + case PDUSessionModificationCommandReceivedMBSContainerType: + a.ReceivedMBSContainer = nasType.NewReceivedMBSContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ReceivedMBSContainer.Len) + a.ReceivedMBSContainer.SetLen(a.ReceivedMBSContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ReceivedMBSContainer.Buffer[:a.ReceivedMBSContainer.GetLen()]) + case PDUSessionModificationCommandServiceLevelAAContainerType: + a.ServiceLevelAAContainer = nasType.NewServiceLevelAAContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ServiceLevelAAContainer.Len) + a.ServiceLevelAAContainer.SetLen(a.ServiceLevelAAContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ServiceLevelAAContainer.Buffer[:a.ServiceLevelAAContainer.GetLen()]) + case PDUSessionModificationCommandAlternativeSNSSAIType: + a.AlternativeSNSSAI = nasType.NewSNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.AlternativeSNSSAI.Len) + a.AlternativeSNSSAI.SetLen(a.AlternativeSNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.AlternativeSNSSAI.Octet[:a.AlternativeSNSSAI.GetLen()]) + case PDUSessionModificationCommandN3QAIType: + a.N3QAI = nasType.NewN3QAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.N3QAI.Len) + a.N3QAI.SetLen(a.N3QAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.N3QAI.Buffer[:a.N3QAI.GetLen()]) default: } } diff --git a/nasMessage/NAS_PDUSessionModificationReject.go b/nasMessage/NAS_PDUSessionModificationReject.go index 110747c6..a98ed4c3 100644 --- a/nasMessage/NAS_PDUSessionModificationReject.go +++ b/nasMessage/NAS_PDUSessionModificationReject.go @@ -20,6 +20,8 @@ type PDUSessionModificationReject struct { nasType.Cause5GSM *nasType.BackoffTimerValue *nasType.ExtendedProtocolConfigurationOptions + *nasType.Fivegsmcongestionreattemptindicator + *nasType.ReAttemptIndicator } func NewPDUSessionModificationReject(iei uint8) (pDUSessionModificationReject *PDUSessionModificationReject) { @@ -30,6 +32,8 @@ func NewPDUSessionModificationReject(iei uint8) (pDUSessionModificationReject *P const ( PDUSessionModificationRejectBackoffTimerValueType uint8 = 0x37 PDUSessionModificationRejectExtendedProtocolConfigurationOptionsType uint8 = 0x7B + PDUSessionModificationRejectFivegsmcongestionreattemptindicatorType uint8 = 0x61 + PDUSessionModificationRejectReAttemptIndicatorType uint8 = 0x1D ) func (a *PDUSessionModificationReject) EncodePDUSessionModificationReject(buffer *bytes.Buffer) { @@ -48,6 +52,16 @@ func (a *PDUSessionModificationReject) EncodePDUSessionModificationReject(buffer binary.Write(buffer, binary.BigEndian, a.ExtendedProtocolConfigurationOptions.GetLen()) binary.Write(buffer, binary.BigEndian, &a.ExtendedProtocolConfigurationOptions.Buffer) } + if a.Fivegsmcongestionreattemptindicator != nil { + binary.Write(buffer, binary.BigEndian, a.Fivegsmcongestionreattemptindicator.GetIei()) + binary.Write(buffer, binary.BigEndian, a.Fivegsmcongestionreattemptindicator.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Octet) + } + if a.ReAttemptIndicator != nil { + binary.Write(buffer, binary.BigEndian, a.ReAttemptIndicator.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ReAttemptIndicator.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ReAttemptIndicator.Octet) + } } func (a *PDUSessionModificationReject) DecodePDUSessionModificationReject(byteArray *[]byte) { @@ -77,6 +91,16 @@ func (a *PDUSessionModificationReject) DecodePDUSessionModificationReject(byteAr binary.Read(buffer, binary.BigEndian, &a.ExtendedProtocolConfigurationOptions.Len) a.ExtendedProtocolConfigurationOptions.SetLen(a.ExtendedProtocolConfigurationOptions.GetLen()) binary.Read(buffer, binary.BigEndian, a.ExtendedProtocolConfigurationOptions.Buffer[:a.ExtendedProtocolConfigurationOptions.GetLen()]) + case PDUSessionModificationRejectFivegsmcongestionreattemptindicatorType: + a.Fivegsmcongestionreattemptindicator = nasType.NewFivegsmcongestionreattemptindicator(ieiN) + binary.Read(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Len) + a.Fivegsmcongestionreattemptindicator.SetLen(a.Fivegsmcongestionreattemptindicator.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Octet) + case PDUSessionModificationRejectReAttemptIndicatorType: + a.ReAttemptIndicator = nasType.NewReAttemptIndicator(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ReAttemptIndicator.Len) + a.ReAttemptIndicator.SetLen(a.ReAttemptIndicator.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.ReAttemptIndicator.Octet) default: } } diff --git a/nasMessage/NAS_PDUSessionReleaseCommand.go b/nasMessage/NAS_PDUSessionReleaseCommand.go index 3ad47432..6d00df14 100644 --- a/nasMessage/NAS_PDUSessionReleaseCommand.go +++ b/nasMessage/NAS_PDUSessionReleaseCommand.go @@ -21,6 +21,10 @@ type PDUSessionReleaseCommand struct { *nasType.BackoffTimerValue *nasType.EAPMessage *nasType.ExtendedProtocolConfigurationOptions + *nasType.Fivegsmcongestionreattemptindicator + *nasType.SpareHalfOctetAndAccessType + *nasType.ServiceLevelAAContainer + AlternativeSNSSAI *nasType.SNSSAI } func NewPDUSessionReleaseCommand(iei uint8) (pDUSessionReleaseCommand *PDUSessionReleaseCommand) { @@ -32,6 +36,10 @@ const ( PDUSessionReleaseCommandBackoffTimerValueType uint8 = 0x37 PDUSessionReleaseCommandEAPMessageType uint8 = 0x78 PDUSessionReleaseCommandExtendedProtocolConfigurationOptionsType uint8 = 0x7B + PDUSessionReleaseCommandFivegsmcongestionreattemptindicatorType uint8 = 0x61 + PDUSessionReleaseCommandAccessTypeType uint8 = 0x0D + PDUSessionReleaseCommandServiceLevelAAContainerType uint8 = 0x72 + PDUSessionReleaseCommandAlternativeSNSSAIType uint8 = 0x5A ) func (a *PDUSessionReleaseCommand) EncodePDUSessionReleaseCommand(buffer *bytes.Buffer) { @@ -55,6 +63,24 @@ func (a *PDUSessionReleaseCommand) EncodePDUSessionReleaseCommand(buffer *bytes. binary.Write(buffer, binary.BigEndian, a.ExtendedProtocolConfigurationOptions.GetLen()) binary.Write(buffer, binary.BigEndian, &a.ExtendedProtocolConfigurationOptions.Buffer) } + if a.Fivegsmcongestionreattemptindicator != nil { + binary.Write(buffer, binary.BigEndian, a.Fivegsmcongestionreattemptindicator.GetIei()) + binary.Write(buffer, binary.BigEndian, a.Fivegsmcongestionreattemptindicator.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Octet) + } + if a.SpareHalfOctetAndAccessType != nil { + binary.Write(buffer, binary.BigEndian, &a.SpareHalfOctetAndAccessType.Octet) + } + if a.ServiceLevelAAContainer != nil { + binary.Write(buffer, binary.BigEndian, a.ServiceLevelAAContainer.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ServiceLevelAAContainer.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ServiceLevelAAContainer.Buffer) + } + if a.AlternativeSNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.Octet[:a.AlternativeSNSSAI.GetLen()]) + } } func (a *PDUSessionReleaseCommand) DecodePDUSessionReleaseCommand(byteArray *[]byte) { @@ -89,6 +115,24 @@ func (a *PDUSessionReleaseCommand) DecodePDUSessionReleaseCommand(byteArray *[]b binary.Read(buffer, binary.BigEndian, &a.ExtendedProtocolConfigurationOptions.Len) a.ExtendedProtocolConfigurationOptions.SetLen(a.ExtendedProtocolConfigurationOptions.GetLen()) binary.Read(buffer, binary.BigEndian, a.ExtendedProtocolConfigurationOptions.Buffer[:a.ExtendedProtocolConfigurationOptions.GetLen()]) + case PDUSessionReleaseCommandFivegsmcongestionreattemptindicatorType: + a.Fivegsmcongestionreattemptindicator = nasType.NewFivegsmcongestionreattemptindicator(ieiN) + binary.Read(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Len) + a.Fivegsmcongestionreattemptindicator.SetLen(a.Fivegsmcongestionreattemptindicator.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.Fivegsmcongestionreattemptindicator.Octet) + case PDUSessionReleaseCommandAccessTypeType: + a.SpareHalfOctetAndAccessType = nasType.NewSpareHalfOctetAndAccessType() + a.SpareHalfOctetAndAccessType.Octet = ieiN + case PDUSessionReleaseCommandServiceLevelAAContainerType: + a.ServiceLevelAAContainer = nasType.NewServiceLevelAAContainer(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ServiceLevelAAContainer.Len) + a.ServiceLevelAAContainer.SetLen(a.ServiceLevelAAContainer.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ServiceLevelAAContainer.Buffer[:a.ServiceLevelAAContainer.GetLen()]) + case PDUSessionReleaseCommandAlternativeSNSSAIType: + a.AlternativeSNSSAI = nasType.NewSNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.AlternativeSNSSAI.Len) + a.AlternativeSNSSAI.SetLen(a.AlternativeSNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.AlternativeSNSSAI.Octet[:a.AlternativeSNSSAI.GetLen()]) default: } } diff --git a/nasMessage/NAS_RegistrationAccept.go b/nasMessage/NAS_RegistrationAccept.go index 5d5e82a8..aa7e4e0d 100644 --- a/nasMessage/NAS_RegistrationAccept.go +++ b/nasMessage/NAS_RegistrationAccept.go @@ -57,6 +57,20 @@ type RegistrationAccept struct { *nasType.ListOfPLMNsForDisasterCondition *nasType.ExtendedCAGInformationList *nasType.NSAGInformation + *nasType.PendingNSSAI + NegotiatedNBN1ModeDRXParameters *nasType.NBN1ModeDRXParameters + NegotiatedWUSAssistanceInformation *nasType.WUSAssistanceInformation + NegotiatedPEIPSAssistanceInformation *nasType.PEIPSAssistanceInformation + ForbiddenTAIRoaming *nasType.TAIList + ForbiddenTAIRegionalProvision *nasType.TAIList + *nasType.EquivalentSNPNs + *nasType.NID + *nasType.RANTimingSynchronization + *nasType.AlternativeNSSAI + *nasType.DiscontinuousCoverageMaxTimeOffset + *nasType.SNSSAITimeValidityInformation + UnavailabilityPeriodDuration *nasType.LowerBoundTimerValue + *nasType.FeatureAuthorizationIndication } func NewRegistrationAccept(iei uint8) (registrationAccept *RegistrationAccept) { @@ -106,6 +120,20 @@ const ( RegistrationAcceptExtendedCAGInformationListType uint8 = 0x71 RegistrationAcceptNSAGInformationType uint8 = 0x7C RegistrationAcceptNon3GPPNWProvidedPoliciesType uint8 = 0x0D + RegistrationAcceptPendingNSSAIType uint8 = 0x39 + RegistrationAcceptNegotiatedNBN1ModeDRXParametersType uint8 = 0x29 + RegistrationAcceptNegotiatedWUSAssistanceInformationType uint8 = 0x1C + RegistrationAcceptNegotiatedPEIPSAssistanceInformationType uint8 = 0x33 + RegistrationAcceptForbiddenTAIRoamingType uint8 = 0x1D + RegistrationAcceptForbiddenTAIRegionalProvisionType uint8 = 0x1E + RegistrationAcceptEquivalentSNPNsType uint8 = 0x3D + RegistrationAcceptNIDType uint8 = 0x32 + RegistrationAcceptRANTimingSynchronizationType uint8 = 0x4B + RegistrationAcceptAlternativeNSSAIType uint8 = 0x4C + RegistrationAcceptDiscontinuousCoverageMaxTimeOffsetType uint8 = 0x4F + RegistrationAcceptSNSSAITimeValidityInformationType uint8 = 0x5B + RegistrationAcceptUnavailabilityPeriodDurationType uint8 = 0x3C + RegistrationAcceptFeatureAuthorizationIndicationType uint8 = 0x5C ) func (a *RegistrationAccept) EncodeRegistrationAccept(buffer *bytes.Buffer) { @@ -309,6 +337,76 @@ func (a *RegistrationAccept) EncodeRegistrationAccept(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, a.NSAGInformation.GetLen()) binary.Write(buffer, binary.BigEndian, &a.NSAGInformation.Buffer) } + if a.PendingNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.PendingNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.PendingNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.PendingNSSAI.Buffer) + } + if a.NegotiatedNBN1ModeDRXParameters != nil { + binary.Write(buffer, binary.BigEndian, a.NegotiatedNBN1ModeDRXParameters.GetIei()) + binary.Write(buffer, binary.BigEndian, a.NegotiatedNBN1ModeDRXParameters.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.NegotiatedNBN1ModeDRXParameters.Buffer) + } + if a.NegotiatedWUSAssistanceInformation != nil { + binary.Write(buffer, binary.BigEndian, a.NegotiatedWUSAssistanceInformation.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.NegotiatedWUSAssistanceInformation.GetLen())) + binary.Write(buffer, binary.BigEndian, a.NegotiatedWUSAssistanceInformation.Buffer[:uint8(a.NegotiatedWUSAssistanceInformation.GetLen())]) + } + if a.NegotiatedPEIPSAssistanceInformation != nil { + binary.Write(buffer, binary.BigEndian, a.NegotiatedPEIPSAssistanceInformation.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.NegotiatedPEIPSAssistanceInformation.GetLen())) + binary.Write(buffer, binary.BigEndian, a.NegotiatedPEIPSAssistanceInformation.Buffer[:uint8(a.NegotiatedPEIPSAssistanceInformation.GetLen())]) + } + if a.ForbiddenTAIRoaming != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Buffer) + } + if a.ForbiddenTAIRegionalProvision != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Buffer) + } + if a.EquivalentSNPNs != nil { + binary.Write(buffer, binary.BigEndian, a.EquivalentSNPNs.GetIei()) + binary.Write(buffer, binary.BigEndian, a.EquivalentSNPNs.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.EquivalentSNPNs.Buffer) + } + if a.NID != nil { + binary.Write(buffer, binary.BigEndian, a.NID.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.NID.GetLen())) + binary.Write(buffer, binary.BigEndian, a.NID.Buffer[:uint8(a.NID.GetLen())]) + } + if a.RANTimingSynchronization != nil { + binary.Write(buffer, binary.BigEndian, a.RANTimingSynchronization.GetIei()) + binary.Write(buffer, binary.BigEndian, a.RANTimingSynchronization.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.RANTimingSynchronization.Buffer) + } + if a.AlternativeNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.AlternativeNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.AlternativeNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.AlternativeNSSAI.Buffer) + } + if a.DiscontinuousCoverageMaxTimeOffset != nil { + binary.Write(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.GetIei()) + binary.Write(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Buffer) + } + if a.SNSSAITimeValidityInformation != nil { + binary.Write(buffer, binary.BigEndian, a.SNSSAITimeValidityInformation.GetIei()) + binary.Write(buffer, binary.BigEndian, a.SNSSAITimeValidityInformation.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.SNSSAITimeValidityInformation.Buffer) + } + if a.UnavailabilityPeriodDuration != nil { + binary.Write(buffer, binary.BigEndian, a.UnavailabilityPeriodDuration.GetIei()) + binary.Write(buffer, binary.BigEndian, a.UnavailabilityPeriodDuration.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.UnavailabilityPeriodDuration.Octet) + } + if a.FeatureAuthorizationIndication != nil { + binary.Write(buffer, binary.BigEndian, a.FeatureAuthorizationIndication.GetIei()) + binary.Write(buffer, binary.BigEndian, a.FeatureAuthorizationIndication.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.FeatureAuthorizationIndication.Buffer) + } } func (a *RegistrationAccept) DecodeRegistrationAccept(byteArray *[]byte) { @@ -533,6 +631,79 @@ func (a *RegistrationAccept) DecodeRegistrationAccept(byteArray *[]byte) { case RegistrationAcceptNon3GPPNWProvidedPoliciesType: a.Non3GPPNWProvidedPolicies = nasType.NewNon3GPPNWProvidedPolicies(ieiN) a.Non3GPPNWProvidedPolicies.Octet = ieiN + case RegistrationAcceptPendingNSSAIType: + a.PendingNSSAI = nasType.NewPendingNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.PendingNSSAI.Len) + a.PendingNSSAI.SetLen(a.PendingNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.PendingNSSAI.Buffer[:a.PendingNSSAI.GetLen()]) + case RegistrationAcceptNegotiatedNBN1ModeDRXParametersType: + a.NegotiatedNBN1ModeDRXParameters = nasType.NewNBN1ModeDRXParameters(ieiN) + binary.Read(buffer, binary.BigEndian, &a.NegotiatedNBN1ModeDRXParameters.Len) + a.NegotiatedNBN1ModeDRXParameters.SetLen(a.NegotiatedNBN1ModeDRXParameters.GetLen()) + binary.Read(buffer, binary.BigEndian, a.NegotiatedNBN1ModeDRXParameters.Buffer[:a.NegotiatedNBN1ModeDRXParameters.GetLen()]) + case RegistrationAcceptNegotiatedWUSAssistanceInformationType: + a.NegotiatedWUSAssistanceInformation = nasType.NewWUSAssistanceInformation(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.NegotiatedWUSAssistanceInformation.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.NegotiatedWUSAssistanceInformation.Buffer[:l]) + case RegistrationAcceptNegotiatedPEIPSAssistanceInformationType: + a.NegotiatedPEIPSAssistanceInformation = nasType.NewPEIPSAssistanceInformation(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.NegotiatedPEIPSAssistanceInformation.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.NegotiatedPEIPSAssistanceInformation.Buffer[:l]) + case RegistrationAcceptForbiddenTAIRoamingType: + a.ForbiddenTAIRoaming = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Len) + a.ForbiddenTAIRoaming.SetLen(a.ForbiddenTAIRoaming.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.Buffer[:a.ForbiddenTAIRoaming.GetLen()]) + case RegistrationAcceptForbiddenTAIRegionalProvisionType: + a.ForbiddenTAIRegionalProvision = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Len) + a.ForbiddenTAIRegionalProvision.SetLen(a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.Buffer[:a.ForbiddenTAIRegionalProvision.GetLen()]) + case RegistrationAcceptEquivalentSNPNsType: + a.EquivalentSNPNs = nasType.NewEquivalentSNPNs(ieiN) + binary.Read(buffer, binary.BigEndian, &a.EquivalentSNPNs.Len) + a.EquivalentSNPNs.SetLen(a.EquivalentSNPNs.GetLen()) + binary.Read(buffer, binary.BigEndian, a.EquivalentSNPNs.Buffer[:a.EquivalentSNPNs.GetLen()]) + case RegistrationAcceptNIDType: + a.NID = nasType.NewNID(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.NID.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.NID.Buffer[:l]) + case RegistrationAcceptRANTimingSynchronizationType: + a.RANTimingSynchronization = nasType.NewRANTimingSynchronization(ieiN) + binary.Read(buffer, binary.BigEndian, &a.RANTimingSynchronization.Len) + a.RANTimingSynchronization.SetLen(a.RANTimingSynchronization.GetLen()) + binary.Read(buffer, binary.BigEndian, a.RANTimingSynchronization.Buffer[:a.RANTimingSynchronization.GetLen()]) + case RegistrationAcceptAlternativeNSSAIType: + a.AlternativeNSSAI = nasType.NewAlternativeNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.AlternativeNSSAI.Len) + a.AlternativeNSSAI.SetLen(a.AlternativeNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.AlternativeNSSAI.Buffer[:a.AlternativeNSSAI.GetLen()]) + case RegistrationAcceptDiscontinuousCoverageMaxTimeOffsetType: + a.DiscontinuousCoverageMaxTimeOffset = nasType.NewDiscontinuousCoverageMaxTimeOffset(ieiN) + binary.Read(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Len) + a.DiscontinuousCoverageMaxTimeOffset.SetLen(a.DiscontinuousCoverageMaxTimeOffset.GetLen()) + binary.Read(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.Buffer[:a.DiscontinuousCoverageMaxTimeOffset.GetLen()]) + case RegistrationAcceptSNSSAITimeValidityInformationType: + a.SNSSAITimeValidityInformation = nasType.NewSNSSAITimeValidityInformation(ieiN) + binary.Read(buffer, binary.BigEndian, &a.SNSSAITimeValidityInformation.Len) + a.SNSSAITimeValidityInformation.SetLen(a.SNSSAITimeValidityInformation.GetLen()) + binary.Read(buffer, binary.BigEndian, a.SNSSAITimeValidityInformation.Buffer[:a.SNSSAITimeValidityInformation.GetLen()]) + case RegistrationAcceptUnavailabilityPeriodDurationType: + a.UnavailabilityPeriodDuration = nasType.NewLowerBoundTimerValue(ieiN) + binary.Read(buffer, binary.BigEndian, &a.UnavailabilityPeriodDuration.Len) + a.UnavailabilityPeriodDuration.SetLen(a.UnavailabilityPeriodDuration.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.UnavailabilityPeriodDuration.Octet) + case RegistrationAcceptFeatureAuthorizationIndicationType: + a.FeatureAuthorizationIndication = nasType.NewFeatureAuthorizationIndication(ieiN) + binary.Read(buffer, binary.BigEndian, &a.FeatureAuthorizationIndication.Len) + a.FeatureAuthorizationIndication.SetLen(a.FeatureAuthorizationIndication.GetLen()) + binary.Read(buffer, binary.BigEndian, a.FeatureAuthorizationIndication.Buffer[:a.FeatureAuthorizationIndication.GetLen()]) default: } } diff --git a/nasMessage/NAS_RegistrationReject.go b/nasMessage/NAS_RegistrationReject.go index 7d6a5624..734e4e64 100644 --- a/nasMessage/NAS_RegistrationReject.go +++ b/nasMessage/NAS_RegistrationReject.go @@ -1,7 +1,6 @@ +// Copyright (C) 2026 Intel Corporation // Copyright 2019 free5GC.org -// // SPDX-License-Identifier: Apache-2.0 -// package nasMessage @@ -20,6 +19,16 @@ type RegistrationReject struct { *nasType.T3346Value *nasType.T3502Value *nasType.EAPMessage + *nasType.RejectedNSSAI + *nasType.CAGInformationList + *nasType.ExtendedRejectedNSSAI + DisasterReturnWaitRange *nasType.RegistrationWaitRange + *nasType.ExtendedCAGInformationList + *nasType.LowerBoundTimerValue + ForbiddenTAIRoaming *nasType.TAIList + ForbiddenTAIRegionalProvision *nasType.TAIList + *nasType.N3IWFIdentifier + *nasType.TNANInformation } func NewRegistrationReject(iei uint8) (registrationReject *RegistrationReject) { @@ -28,9 +37,19 @@ func NewRegistrationReject(iei uint8) (registrationReject *RegistrationReject) { } const ( - RegistrationRejectT3346ValueType uint8 = 0x5F - RegistrationRejectT3502ValueType uint8 = 0x16 - RegistrationRejectEAPMessageType uint8 = 0x78 + RegistrationRejectT3346ValueType uint8 = 0x5F + RegistrationRejectT3502ValueType uint8 = 0x16 + RegistrationRejectEAPMessageType uint8 = 0x78 + RegistrationRejectRejectedNSSAIType uint8 = 0x69 + RegistrationRejectCAGInformationListType uint8 = 0x75 + RegistrationRejectExtendedRejectedNSSAIType uint8 = 0x68 + RegistrationRejectDisasterReturnWaitRangeType uint8 = 0x2C + RegistrationRejectExtendedCAGInformationListType uint8 = 0x71 + RegistrationRejectLowerBoundTimerValueType uint8 = 0x3A + RegistrationRejectForbiddenTAIRoamingType uint8 = 0x1D + RegistrationRejectForbiddenTAIRegionalProvisionType uint8 = 0x1E + RegistrationRejectN3IWFIdentifierType uint8 = 0x3E + RegistrationRejectTNANInformationType uint8 = 0x4D ) func (a *RegistrationReject) EncodeRegistrationReject(buffer *bytes.Buffer) { @@ -53,6 +72,56 @@ func (a *RegistrationReject) EncodeRegistrationReject(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, a.EAPMessage.GetLen()) binary.Write(buffer, binary.BigEndian, &a.EAPMessage.Buffer) } + if a.RejectedNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.RejectedNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.RejectedNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.RejectedNSSAI.Buffer) + } + if a.CAGInformationList != nil { + binary.Write(buffer, binary.BigEndian, a.CAGInformationList.GetIei()) + binary.Write(buffer, binary.BigEndian, a.CAGInformationList.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.CAGInformationList.Buffer) + } + if a.ExtendedRejectedNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.ExtendedRejectedNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.ExtendedRejectedNSSAI.GetLen())) + binary.Write(buffer, binary.BigEndian, a.ExtendedRejectedNSSAI.Buffer[:uint8(a.ExtendedRejectedNSSAI.GetLen())]) + } + if a.DisasterReturnWaitRange != nil { + binary.Write(buffer, binary.BigEndian, a.DisasterReturnWaitRange.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.DisasterReturnWaitRange.GetLen())) + binary.Write(buffer, binary.BigEndian, a.DisasterReturnWaitRange.Buffer[:uint8(a.DisasterReturnWaitRange.GetLen())]) + } + if a.ExtendedCAGInformationList != nil { + binary.Write(buffer, binary.BigEndian, a.ExtendedCAGInformationList.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ExtendedCAGInformationList.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ExtendedCAGInformationList.Buffer) + } + if a.LowerBoundTimerValue != nil { + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetIei()) + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + } + if a.ForbiddenTAIRoaming != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Buffer) + } + if a.ForbiddenTAIRegionalProvision != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Buffer) + } + if a.N3IWFIdentifier != nil { + binary.Write(buffer, binary.BigEndian, a.N3IWFIdentifier.GetIei()) + binary.Write(buffer, binary.BigEndian, a.N3IWFIdentifier.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.N3IWFIdentifier.Buffer) + } + if a.TNANInformation != nil { + binary.Write(buffer, binary.BigEndian, a.TNANInformation.GetIei()) + binary.Write(buffer, binary.BigEndian, a.TNANInformation.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.TNANInformation.Buffer) + } } func (a *RegistrationReject) DecodeRegistrationReject(byteArray *[]byte) { @@ -86,6 +155,58 @@ func (a *RegistrationReject) DecodeRegistrationReject(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &a.EAPMessage.Len) a.EAPMessage.SetLen(a.EAPMessage.GetLen()) binary.Read(buffer, binary.BigEndian, a.EAPMessage.Buffer[:a.EAPMessage.GetLen()]) + case RegistrationRejectRejectedNSSAIType: + a.RejectedNSSAI = nasType.NewRejectedNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.RejectedNSSAI.Len) + a.RejectedNSSAI.SetLen(a.RejectedNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.RejectedNSSAI.Buffer[:a.RejectedNSSAI.GetLen()]) + case RegistrationRejectCAGInformationListType: + a.CAGInformationList = nasType.NewCAGInformationList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.CAGInformationList.Len) + a.CAGInformationList.SetLen(a.CAGInformationList.GetLen()) + binary.Read(buffer, binary.BigEndian, a.CAGInformationList.Buffer[:a.CAGInformationList.GetLen()]) + case RegistrationRejectExtendedRejectedNSSAIType: + a.ExtendedRejectedNSSAI = nasType.NewExtendedRejectedNSSAI(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.ExtendedRejectedNSSAI.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.ExtendedRejectedNSSAI.Buffer[:l]) + case RegistrationRejectDisasterReturnWaitRangeType: + a.DisasterReturnWaitRange = nasType.NewRegistrationWaitRange(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.DisasterReturnWaitRange.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.DisasterReturnWaitRange.Buffer[:l]) + case RegistrationRejectExtendedCAGInformationListType: + a.ExtendedCAGInformationList = nasType.NewExtendedCAGInformationList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ExtendedCAGInformationList.Len) + a.ExtendedCAGInformationList.SetLen(a.ExtendedCAGInformationList.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ExtendedCAGInformationList.Buffer[:a.ExtendedCAGInformationList.GetLen()]) + case RegistrationRejectLowerBoundTimerValueType: + a.LowerBoundTimerValue = nasType.NewLowerBoundTimerValue(ieiN) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Len) + a.LowerBoundTimerValue.SetLen(a.LowerBoundTimerValue.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + case RegistrationRejectForbiddenTAIRoamingType: + a.ForbiddenTAIRoaming = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Len) + a.ForbiddenTAIRoaming.SetLen(a.ForbiddenTAIRoaming.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.Buffer[:a.ForbiddenTAIRoaming.GetLen()]) + case RegistrationRejectForbiddenTAIRegionalProvisionType: + a.ForbiddenTAIRegionalProvision = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Len) + a.ForbiddenTAIRegionalProvision.SetLen(a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.Buffer[:a.ForbiddenTAIRegionalProvision.GetLen()]) + case RegistrationRejectN3IWFIdentifierType: + a.N3IWFIdentifier = nasType.NewN3IWFIdentifier(ieiN) + binary.Read(buffer, binary.BigEndian, &a.N3IWFIdentifier.Len) + a.N3IWFIdentifier.SetLen(a.N3IWFIdentifier.GetLen()) + binary.Read(buffer, binary.BigEndian, a.N3IWFIdentifier.Buffer[:a.N3IWFIdentifier.GetLen()]) + case RegistrationRejectTNANInformationType: + a.TNANInformation = nasType.NewTNANInformation(ieiN) + binary.Read(buffer, binary.BigEndian, &a.TNANInformation.Len) + a.TNANInformation.SetLen(a.TNANInformation.GetLen()) + binary.Read(buffer, binary.BigEndian, a.TNANInformation.Buffer[:a.TNANInformation.GetLen()]) default: } } diff --git a/nasMessage/NAS_RegistrationRequest.go b/nasMessage/NAS_RegistrationRequest.go index 9d17894f..ceabf513 100644 --- a/nasMessage/NAS_RegistrationRequest.go +++ b/nasMessage/NAS_RegistrationRequest.go @@ -56,6 +56,7 @@ type RegistrationRequest struct { *nasType.TimeDuration *nasType.Non3GPPPathSwitchingInformation *nasType.AUN3Indication + *nasType.T3512Value } func NewRegistrationRequest(iei uint8) (registrationRequest *RegistrationRequest) { @@ -103,6 +104,7 @@ const ( RegistrationRequestAUN3IndicationType uint8 = 0x56 RegistrationRequestMobileStationClassmark2Type uint8 = 0x41 RegistrationRequestSupportedCodecsType uint8 = 0x42 + RegistrationRequestRequestedT3512ValueType uint8 = 0x3B ) func (a *RegistrationRequest) EncodeRegistrationRequest(buffer *bytes.Buffer) { @@ -298,6 +300,11 @@ func (a *RegistrationRequest) EncodeRegistrationRequest(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, uint8(a.AUN3Indication.GetLen())) binary.Write(buffer, binary.BigEndian, a.AUN3Indication.Buffer[:uint8(a.AUN3Indication.GetLen())]) } + if a.T3512Value != nil { + binary.Write(buffer, binary.BigEndian, a.T3512Value.GetIei()) + binary.Write(buffer, binary.BigEndian, a.T3512Value.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.T3512Value.Octet) + } } func (a *RegistrationRequest) DecodeRegistrationRequest(byteArray *[]byte) { @@ -521,6 +528,11 @@ func (a *RegistrationRequest) DecodeRegistrationRequest(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &lenN) a.SupportedCodecs.SetLen(uint16(lenN)) binary.Read(buffer, binary.BigEndian, a.SupportedCodecs.Buffer[:lenN]) + case RegistrationRequestRequestedT3512ValueType: + a.T3512Value = nasType.NewT3512Value(ieiN) + binary.Read(buffer, binary.BigEndian, &a.T3512Value.Len) + a.T3512Value.SetLen(a.T3512Value.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.T3512Value.Octet) default: } } diff --git a/nasMessage/NAS_SecurityModeCommand.go b/nasMessage/NAS_SecurityModeCommand.go index f68b0739..8024faef 100644 --- a/nasMessage/NAS_SecurityModeCommand.go +++ b/nasMessage/NAS_SecurityModeCommand.go @@ -25,6 +25,7 @@ type SecurityModeCommand struct { *nasType.EAPMessage *nasType.ABBA *nasType.ReplayedS1UESecurityCapabilities + *nasType.MasterSessionKey } func NewSecurityModeCommand(iei uint8) (securityModeCommand *SecurityModeCommand) { @@ -39,6 +40,7 @@ const ( SecurityModeCommandEAPMessageType uint8 = 0x78 SecurityModeCommandABBAType uint8 = 0x38 SecurityModeCommandReplayedS1UESecurityCapabilitiesType uint8 = 0x19 + SecurityModeCommandMasterSessionKeyType uint8 = 0x55 ) func (a *SecurityModeCommand) EncodeSecurityModeCommand(buffer *bytes.Buffer) { @@ -76,6 +78,11 @@ func (a *SecurityModeCommand) EncodeSecurityModeCommand(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, a.ReplayedS1UESecurityCapabilities.GetLen()) binary.Write(buffer, binary.BigEndian, &a.ReplayedS1UESecurityCapabilities.Buffer) } + if a.MasterSessionKey != nil { + binary.Write(buffer, binary.BigEndian, a.MasterSessionKey.GetIei()) + binary.Write(buffer, binary.BigEndian, a.MasterSessionKey.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.MasterSessionKey.Buffer) + } } func (a *SecurityModeCommand) DecodeSecurityModeCommand(byteArray *[]byte) { @@ -124,6 +131,11 @@ func (a *SecurityModeCommand) DecodeSecurityModeCommand(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &a.ReplayedS1UESecurityCapabilities.Len) a.ReplayedS1UESecurityCapabilities.SetLen(a.ReplayedS1UESecurityCapabilities.GetLen()) binary.Read(buffer, binary.BigEndian, a.ReplayedS1UESecurityCapabilities.Buffer[:a.ReplayedS1UESecurityCapabilities.GetLen()]) + case SecurityModeCommandMasterSessionKeyType: + a.MasterSessionKey = nasType.NewMasterSessionKey(ieiN) + binary.Read(buffer, binary.BigEndian, &a.MasterSessionKey.Len) + a.MasterSessionKey.SetLen(a.MasterSessionKey.GetLen()) + binary.Read(buffer, binary.BigEndian, a.MasterSessionKey.Buffer[:a.MasterSessionKey.GetLen()]) default: } } diff --git a/nasMessage/NAS_SecurityModeComplete.go b/nasMessage/NAS_SecurityModeComplete.go index dfcbc3fe..11562f03 100644 --- a/nasMessage/NAS_SecurityModeComplete.go +++ b/nasMessage/NAS_SecurityModeComplete.go @@ -18,6 +18,7 @@ type SecurityModeComplete struct { nasType.SecurityModeCompleteMessageIdentity *nasType.IMEISV *nasType.NASMessageContainer + NonIMEISVPEI *nasType.MobileIdentity5GS } func NewSecurityModeComplete(iei uint8) (securityModeComplete *SecurityModeComplete) { @@ -28,6 +29,7 @@ func NewSecurityModeComplete(iei uint8) (securityModeComplete *SecurityModeCompl const ( SecurityModeCompleteIMEISVType uint8 = 0x77 SecurityModeCompleteNASMessageContainerType uint8 = 0x71 + SecurityModeCompleteNonIMEISVPEIType uint8 = 0x78 ) func (a *SecurityModeComplete) EncodeSecurityModeComplete(buffer *bytes.Buffer) { @@ -44,6 +46,11 @@ func (a *SecurityModeComplete) EncodeSecurityModeComplete(buffer *bytes.Buffer) binary.Write(buffer, binary.BigEndian, a.NASMessageContainer.GetLen()) binary.Write(buffer, binary.BigEndian, &a.NASMessageContainer.Buffer) } + if a.NonIMEISVPEI != nil { + binary.Write(buffer, binary.BigEndian, a.NonIMEISVPEI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.NonIMEISVPEI.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.NonIMEISVPEI.Buffer) + } } func (a *SecurityModeComplete) DecodeSecurityModeComplete(byteArray *[]byte) { @@ -71,6 +78,11 @@ func (a *SecurityModeComplete) DecodeSecurityModeComplete(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &a.NASMessageContainer.Len) a.NASMessageContainer.SetLen(a.NASMessageContainer.GetLen()) binary.Read(buffer, binary.BigEndian, a.NASMessageContainer.Buffer[:a.NASMessageContainer.GetLen()]) + case SecurityModeCompleteNonIMEISVPEIType: + a.NonIMEISVPEI = nasType.NewMobileIdentity5GS(ieiN) + binary.Read(buffer, binary.BigEndian, &a.NonIMEISVPEI.Len) + a.NonIMEISVPEI.SetLen(a.NonIMEISVPEI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.NonIMEISVPEI.Buffer[:a.NonIMEISVPEI.GetLen()]) default: } } diff --git a/nasMessage/NAS_ServiceAccept.go b/nasMessage/NAS_ServiceAccept.go index fbb6ed96..d213e43c 100644 --- a/nasMessage/NAS_ServiceAccept.go +++ b/nasMessage/NAS_ServiceAccept.go @@ -20,6 +20,10 @@ type ServiceAccept struct { *nasType.PDUSessionReactivationResult *nasType.PDUSessionReactivationResultErrorCause *nasType.EAPMessage + *nasType.T3448Value + *nasType.FiveGSAdditionalRequestResult + ForbiddenTAIRoaming *nasType.TAIList + ForbiddenTAIRegionalProvision *nasType.TAIList } func NewServiceAccept(iei uint8) (serviceAccept *ServiceAccept) { @@ -32,6 +36,10 @@ const ( ServiceAcceptPDUSessionReactivationResultType uint8 = 0x26 ServiceAcceptPDUSessionReactivationResultErrorCauseType uint8 = 0x72 ServiceAcceptEAPMessageType uint8 = 0x78 + ServiceAcceptT3448ValueType uint8 = 0x6B + ServiceAcceptFiveGSAdditionalRequestResultType uint8 = 0x34 + ServiceAcceptForbiddenTAIRoamingType uint8 = 0x1D + ServiceAcceptForbiddenTAIRegionalProvisionType uint8 = 0x1E ) func (a *ServiceAccept) EncodeServiceAccept(buffer *bytes.Buffer) { @@ -58,6 +66,26 @@ func (a *ServiceAccept) EncodeServiceAccept(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, a.EAPMessage.GetLen()) binary.Write(buffer, binary.BigEndian, &a.EAPMessage.Buffer) } + if a.T3448Value != nil { + binary.Write(buffer, binary.BigEndian, a.T3448Value.GetIei()) + binary.Write(buffer, binary.BigEndian, a.T3448Value.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.T3448Value.Octet) + } + if a.FiveGSAdditionalRequestResult != nil { + binary.Write(buffer, binary.BigEndian, a.FiveGSAdditionalRequestResult.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.FiveGSAdditionalRequestResult.GetLen())) + binary.Write(buffer, binary.BigEndian, a.FiveGSAdditionalRequestResult.Buffer[:uint8(a.FiveGSAdditionalRequestResult.GetLen())]) + } + if a.ForbiddenTAIRoaming != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Buffer) + } + if a.ForbiddenTAIRegionalProvision != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Buffer) + } } func (a *ServiceAccept) DecodeServiceAccept(byteArray *[]byte) { @@ -95,6 +123,27 @@ func (a *ServiceAccept) DecodeServiceAccept(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &a.EAPMessage.Len) a.EAPMessage.SetLen(a.EAPMessage.GetLen()) binary.Read(buffer, binary.BigEndian, a.EAPMessage.Buffer[:a.EAPMessage.GetLen()]) + case ServiceAcceptT3448ValueType: + a.T3448Value = nasType.NewT3448Value(ieiN) + binary.Read(buffer, binary.BigEndian, &a.T3448Value.Len) + a.T3448Value.SetLen(a.T3448Value.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.T3448Value.Octet) + case ServiceAcceptFiveGSAdditionalRequestResultType: + a.FiveGSAdditionalRequestResult = nasType.NewFiveGSAdditionalRequestResult(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.FiveGSAdditionalRequestResult.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.FiveGSAdditionalRequestResult.Buffer[:l]) + case ServiceAcceptForbiddenTAIRoamingType: + a.ForbiddenTAIRoaming = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Len) + a.ForbiddenTAIRoaming.SetLen(a.ForbiddenTAIRoaming.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.Buffer[:a.ForbiddenTAIRoaming.GetLen()]) + case ServiceAcceptForbiddenTAIRegionalProvisionType: + a.ForbiddenTAIRegionalProvision = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Len) + a.ForbiddenTAIRegionalProvision.SetLen(a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.Buffer[:a.ForbiddenTAIRegionalProvision.GetLen()]) default: } } diff --git a/nasMessage/NAS_ServiceReject.go b/nasMessage/NAS_ServiceReject.go index f7ccdaad..a03b7dfe 100644 --- a/nasMessage/NAS_ServiceReject.go +++ b/nasMessage/NAS_ServiceReject.go @@ -1,7 +1,6 @@ +// Copyright (C) 2026 Intel Corporation // Copyright 2019 free5GC.org -// // SPDX-License-Identifier: Apache-2.0 -// package nasMessage @@ -20,6 +19,13 @@ type ServiceReject struct { *nasType.PDUSessionStatus *nasType.T3346Value *nasType.EAPMessage + *nasType.T3448Value + *nasType.CAGInformationList + DisasterReturnWaitRange *nasType.RegistrationWaitRange + *nasType.ExtendedCAGInformationList + *nasType.LowerBoundTimerValue + ForbiddenTAIRoaming *nasType.TAIList + ForbiddenTAIRegionalProvision *nasType.TAIList } func NewServiceReject(iei uint8) (serviceReject *ServiceReject) { @@ -28,9 +34,16 @@ func NewServiceReject(iei uint8) (serviceReject *ServiceReject) { } const ( - ServiceRejectPDUSessionStatusType uint8 = 0x50 - ServiceRejectT3346ValueType uint8 = 0x5F - ServiceRejectEAPMessageType uint8 = 0x78 + ServiceRejectPDUSessionStatusType uint8 = 0x50 + ServiceRejectT3346ValueType uint8 = 0x5F + ServiceRejectEAPMessageType uint8 = 0x78 + ServiceRejectT3448ValueType uint8 = 0x6B + ServiceRejectCAGInformationListType uint8 = 0x75 + ServiceRejectDisasterReturnWaitRangeType uint8 = 0x2C + ServiceRejectExtendedCAGInformationListType uint8 = 0x71 + ServiceRejectLowerBoundTimerValueType uint8 = 0x3A + ServiceRejectForbiddenTAIRoamingType uint8 = 0x1D + ServiceRejectForbiddenTAIRegionalProvisionType uint8 = 0x1E ) func (a *ServiceReject) EncodeServiceReject(buffer *bytes.Buffer) { @@ -53,6 +66,41 @@ func (a *ServiceReject) EncodeServiceReject(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, a.EAPMessage.GetLen()) binary.Write(buffer, binary.BigEndian, &a.EAPMessage.Buffer) } + if a.T3448Value != nil { + binary.Write(buffer, binary.BigEndian, a.T3448Value.GetIei()) + binary.Write(buffer, binary.BigEndian, a.T3448Value.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.T3448Value.Octet) + } + if a.CAGInformationList != nil { + binary.Write(buffer, binary.BigEndian, a.CAGInformationList.GetIei()) + binary.Write(buffer, binary.BigEndian, a.CAGInformationList.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.CAGInformationList.Buffer) + } + if a.DisasterReturnWaitRange != nil { + binary.Write(buffer, binary.BigEndian, a.DisasterReturnWaitRange.GetIei()) + binary.Write(buffer, binary.BigEndian, uint8(a.DisasterReturnWaitRange.GetLen())) + binary.Write(buffer, binary.BigEndian, a.DisasterReturnWaitRange.Buffer[:uint8(a.DisasterReturnWaitRange.GetLen())]) + } + if a.ExtendedCAGInformationList != nil { + binary.Write(buffer, binary.BigEndian, a.ExtendedCAGInformationList.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ExtendedCAGInformationList.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ExtendedCAGInformationList.Buffer) + } + if a.LowerBoundTimerValue != nil { + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetIei()) + binary.Write(buffer, binary.BigEndian, a.LowerBoundTimerValue.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + } + if a.ForbiddenTAIRoaming != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Buffer) + } + if a.ForbiddenTAIRegionalProvision != nil { + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetIei()) + binary.Write(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Buffer) + } } func (a *ServiceReject) DecodeServiceReject(byteArray *[]byte) { @@ -86,6 +134,42 @@ func (a *ServiceReject) DecodeServiceReject(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &a.EAPMessage.Len) a.EAPMessage.SetLen(a.EAPMessage.GetLen()) binary.Read(buffer, binary.BigEndian, a.EAPMessage.Buffer[:a.EAPMessage.GetLen()]) + case ServiceRejectT3448ValueType: + a.T3448Value = nasType.NewT3448Value(ieiN) + binary.Read(buffer, binary.BigEndian, &a.T3448Value.Len) + a.T3448Value.SetLen(a.T3448Value.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.T3448Value.Octet) + case ServiceRejectCAGInformationListType: + a.CAGInformationList = nasType.NewCAGInformationList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.CAGInformationList.Len) + a.CAGInformationList.SetLen(a.CAGInformationList.GetLen()) + binary.Read(buffer, binary.BigEndian, a.CAGInformationList.Buffer[:a.CAGInformationList.GetLen()]) + case ServiceRejectDisasterReturnWaitRangeType: + a.DisasterReturnWaitRange = nasType.NewRegistrationWaitRange(ieiN) + var l uint8 + binary.Read(buffer, binary.BigEndian, &l) + a.DisasterReturnWaitRange.SetLen(uint16(l)) + binary.Read(buffer, binary.BigEndian, a.DisasterReturnWaitRange.Buffer[:l]) + case ServiceRejectExtendedCAGInformationListType: + a.ExtendedCAGInformationList = nasType.NewExtendedCAGInformationList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ExtendedCAGInformationList.Len) + a.ExtendedCAGInformationList.SetLen(a.ExtendedCAGInformationList.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ExtendedCAGInformationList.Buffer[:a.ExtendedCAGInformationList.GetLen()]) + case ServiceRejectLowerBoundTimerValueType: + a.LowerBoundTimerValue = nasType.NewLowerBoundTimerValue(ieiN) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Len) + a.LowerBoundTimerValue.SetLen(a.LowerBoundTimerValue.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.LowerBoundTimerValue.Octet) + case ServiceRejectForbiddenTAIRoamingType: + a.ForbiddenTAIRoaming = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRoaming.Len) + a.ForbiddenTAIRoaming.SetLen(a.ForbiddenTAIRoaming.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRoaming.Buffer[:a.ForbiddenTAIRoaming.GetLen()]) + case ServiceRejectForbiddenTAIRegionalProvisionType: + a.ForbiddenTAIRegionalProvision = nasType.NewTAIList(ieiN) + binary.Read(buffer, binary.BigEndian, &a.ForbiddenTAIRegionalProvision.Len) + a.ForbiddenTAIRegionalProvision.SetLen(a.ForbiddenTAIRegionalProvision.GetLen()) + binary.Read(buffer, binary.BigEndian, a.ForbiddenTAIRegionalProvision.Buffer[:a.ForbiddenTAIRegionalProvision.GetLen()]) default: } } diff --git a/nasMessage/NAS_ULNASTransport.go b/nasMessage/NAS_ULNASTransport.go index eb7cea24..266479a4 100644 --- a/nasMessage/NAS_ULNASTransport.go +++ b/nasMessage/NAS_ULNASTransport.go @@ -1,7 +1,6 @@ +// Copyright (C) 2026 Intel Corporation // Copyright 2019 free5GC.org -// // SPDX-License-Identifier: Apache-2.0 -// package nasMessage @@ -24,6 +23,11 @@ type ULNASTransport struct { *nasType.SNSSAI *nasType.DNN *nasType.AdditionalInformation + *nasType.MAPDUSessionInformation + *nasType.ReleaseAssistanceIndication + *nasType.Non3GPPAccessPathSwitchingIndication + AlternativeSNSSAI *nasType.SNSSAI + *nasType.PayloadContainerInformation } func NewULNASTransport(iei uint8) (uLNASTransport *ULNASTransport) { @@ -32,12 +36,17 @@ func NewULNASTransport(iei uint8) (uLNASTransport *ULNASTransport) { } const ( - ULNASTransportPduSessionID2ValueType uint8 = 0x12 - ULNASTransportOldPDUSessionIDType uint8 = 0x59 - ULNASTransportRequestTypeType uint8 = 0x08 - ULNASTransportSNSSAIType uint8 = 0x22 - ULNASTransportDNNType uint8 = 0x25 - ULNASTransportAdditionalInformationType uint8 = 0x24 + ULNASTransportPduSessionID2ValueType uint8 = 0x12 + ULNASTransportOldPDUSessionIDType uint8 = 0x59 + ULNASTransportRequestTypeType uint8 = 0x08 + ULNASTransportSNSSAIType uint8 = 0x22 + ULNASTransportDNNType uint8 = 0x25 + ULNASTransportAdditionalInformationType uint8 = 0x24 + ULNASTransportMAPDUSessionInformationType uint8 = 0x0A + ULNASTransportReleaseAssistanceIndicationType uint8 = 0x0F + ULNASTransportNon3GPPAccessPathSwitchingIndicationType uint8 = 0x4E + ULNASTransportAlternativeSNSSAIType uint8 = 0x5A + ULNASTransportPayloadContainerInformationType uint8 = 0x09 ) func (a *ULNASTransport) EncodeULNASTransport(buffer *bytes.Buffer) { @@ -73,6 +82,25 @@ func (a *ULNASTransport) EncodeULNASTransport(buffer *bytes.Buffer) { binary.Write(buffer, binary.BigEndian, a.AdditionalInformation.GetLen()) binary.Write(buffer, binary.BigEndian, &a.AdditionalInformation.Buffer) } + if a.MAPDUSessionInformation != nil { + binary.Write(buffer, binary.BigEndian, &a.MAPDUSessionInformation.Octet) + } + if a.ReleaseAssistanceIndication != nil { + binary.Write(buffer, binary.BigEndian, &a.ReleaseAssistanceIndication.Octet) + } + if a.Non3GPPAccessPathSwitchingIndication != nil { + binary.Write(buffer, binary.BigEndian, a.Non3GPPAccessPathSwitchingIndication.GetIei()) + binary.Write(buffer, binary.BigEndian, a.Non3GPPAccessPathSwitchingIndication.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.Non3GPPAccessPathSwitchingIndication.Octet) + } + if a.AlternativeSNSSAI != nil { + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.GetIei()) + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.GetLen()) + binary.Write(buffer, binary.BigEndian, a.AlternativeSNSSAI.Octet[:a.AlternativeSNSSAI.GetLen()]) + } + if a.PayloadContainerInformation != nil { + binary.Write(buffer, binary.BigEndian, &a.PayloadContainerInformation.Octet) + } } func (a *ULNASTransport) DecodeULNASTransport(byteArray *[]byte) { @@ -118,6 +146,25 @@ func (a *ULNASTransport) DecodeULNASTransport(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, &a.AdditionalInformation.Len) a.AdditionalInformation.SetLen(a.AdditionalInformation.GetLen()) binary.Read(buffer, binary.BigEndian, a.AdditionalInformation.Buffer[:a.AdditionalInformation.GetLen()]) + case ULNASTransportMAPDUSessionInformationType: + a.MAPDUSessionInformation = nasType.NewMAPDUSessionInformation(ieiN) + a.MAPDUSessionInformation.Octet = ieiN + case ULNASTransportReleaseAssistanceIndicationType: + a.ReleaseAssistanceIndication = nasType.NewReleaseAssistanceIndication(ieiN) + a.ReleaseAssistanceIndication.Octet = ieiN + case ULNASTransportNon3GPPAccessPathSwitchingIndicationType: + a.Non3GPPAccessPathSwitchingIndication = nasType.NewNon3GPPAccessPathSwitchingIndication(ieiN) + binary.Read(buffer, binary.BigEndian, &a.Non3GPPAccessPathSwitchingIndication.Len) + a.Non3GPPAccessPathSwitchingIndication.SetLen(a.Non3GPPAccessPathSwitchingIndication.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.Non3GPPAccessPathSwitchingIndication.Octet) + case ULNASTransportAlternativeSNSSAIType: + a.AlternativeSNSSAI = nasType.NewSNSSAI(ieiN) + binary.Read(buffer, binary.BigEndian, &a.AlternativeSNSSAI.Len) + a.AlternativeSNSSAI.SetLen(a.AlternativeSNSSAI.GetLen()) + binary.Read(buffer, binary.BigEndian, a.AlternativeSNSSAI.Octet[:a.AlternativeSNSSAI.GetLen()]) + case ULNASTransportPayloadContainerInformationType: + a.PayloadContainerInformation = nasType.NewPayloadContainerInformation(ieiN) + a.PayloadContainerInformation.Octet = ieiN default: } } diff --git a/nasType/NAS_ATSSSContainer.go b/nasType/NAS_ATSSSContainer.go new file mode 100644 index 00000000..1bf8349b --- /dev/null +++ b/nasType/NAS_ATSSSContainer.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// ATSSSContainer 9.11.4.22 +type ATSSSContainer struct { + Iei uint8 + Len uint16 + Buffer []uint8 +} + +func NewATSSSContainer(iei uint8) (x *ATSSSContainer) { + x = &ATSSSContainer{} + x.SetIei(iei) + return x +} + +func (a *ATSSSContainer) GetIei() (iei uint8) { return a.Iei } +func (a *ATSSSContainer) SetIei(iei uint8) { a.Iei = iei } +func (a *ATSSSContainer) GetLen() (len uint16) { return a.Len } +func (a *ATSSSContainer) SetLen(len uint16) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *ATSSSContainer) GetATSSSContainer() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *ATSSSContainer) SetATSSSContainer(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_AdditionalConfigurationIndication.go b/nasType/NAS_AdditionalConfigurationIndication.go new file mode 100644 index 00000000..482b2e70 --- /dev/null +++ b/nasType/NAS_AdditionalConfigurationIndication.go @@ -0,0 +1,33 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// AdditionalConfigurationIndication 9.11.3.74 +// Iei Row, sBit, len = [0, 0], 8 , 4 +// SCMR Row, sBit, len = [0, 0], 1 , 1 +type AdditionalConfigurationIndication struct { + Octet uint8 +} + +func NewAdditionalConfigurationIndication(iei uint8) (x *AdditionalConfigurationIndication) { + x = &AdditionalConfigurationIndication{} + x.SetIei(iei) + return x +} + +func (a *AdditionalConfigurationIndication) GetIei() (iei uint8) { + return a.Octet & GetBitMask(8, 4) >> 4 +} + +func (a *AdditionalConfigurationIndication) SetIei(iei uint8) { + a.Octet = (a.Octet & 0x0F) | ((iei & 0x0F) << 4) +} + +func (a *AdditionalConfigurationIndication) GetSCMR() (scmr uint8) { + return a.Octet & GetBitMask(1, 0) +} + +func (a *AdditionalConfigurationIndication) SetSCMR(scmr uint8) { + a.Octet = (a.Octet & 0xFE) | (scmr & 0x01) +} diff --git a/nasType/NAS_AlternativeNSSAI.go b/nasType/NAS_AlternativeNSSAI.go new file mode 100644 index 00000000..94d1f037 --- /dev/null +++ b/nasType/NAS_AlternativeNSSAI.go @@ -0,0 +1,45 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// AlternativeNSSAI 9.11.3.97 +// SNSSAIValue Row, sBit, len = [0, 0], 0 , INF +type AlternativeNSSAI struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewAlternativeNSSAI(iei uint8) (alternativeNSSAI *AlternativeNSSAI) { + alternativeNSSAI = &AlternativeNSSAI{} + alternativeNSSAI.SetIei(iei) + return alternativeNSSAI +} + +func (a *AlternativeNSSAI) GetIei() (iei uint8) { + return a.Iei +} + +func (a *AlternativeNSSAI) SetIei(iei uint8) { + a.Iei = iei +} + +func (a *AlternativeNSSAI) GetLen() (len uint8) { + return a.Len +} + +func (a *AlternativeNSSAI) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *AlternativeNSSAI) GetSNSSAIValue() (sNSSAIValue []uint8) { + sNSSAIValue = make([]uint8, len(a.Buffer)) + copy(sNSSAIValue, a.Buffer) + return sNSSAIValue +} + +func (a *AlternativeNSSAI) SetSNSSAIValue(sNSSAIValue []uint8) { + copy(a.Buffer, sNSSAIValue) +} diff --git a/nasType/NAS_CIoTSmallDataContainer.go b/nasType/NAS_CIoTSmallDataContainer.go new file mode 100644 index 00000000..b970c435 --- /dev/null +++ b/nasType/NAS_CIoTSmallDataContainer.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// CIoTSmallDataContainer 9.11.3.18B +type CIoTSmallDataContainer struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewCIoTSmallDataContainer(iei uint8) (x *CIoTSmallDataContainer) { + x = &CIoTSmallDataContainer{} + x.SetIei(iei) + return x +} + +func (a *CIoTSmallDataContainer) GetIei() (iei uint8) { return a.Iei } +func (a *CIoTSmallDataContainer) SetIei(iei uint8) { a.Iei = iei } +func (a *CIoTSmallDataContainer) GetLen() (len uint8) { return a.Len } +func (a *CIoTSmallDataContainer) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *CIoTSmallDataContainer) GetCIoTSmallDataContainer() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *CIoTSmallDataContainer) SetCIoTSmallDataContainer(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_ControlPlaneOnlyIndication.go b/nasType/NAS_ControlPlaneOnlyIndication.go new file mode 100644 index 00000000..1239a4c7 --- /dev/null +++ b/nasType/NAS_ControlPlaneOnlyIndication.go @@ -0,0 +1,33 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// ControlPlaneOnlyIndication 9.11.4.23 +// Iei Row, sBit, len = [0, 0], 8 , 4 +// CPOI Row, sBit, len = [0, 0], 1 , 1 +type ControlPlaneOnlyIndication struct { + Octet uint8 +} + +func NewControlPlaneOnlyIndication(iei uint8) (x *ControlPlaneOnlyIndication) { + x = &ControlPlaneOnlyIndication{} + x.SetIei(iei) + return x +} + +func (a *ControlPlaneOnlyIndication) GetIei() (iei uint8) { + return a.Octet & GetBitMask(8, 4) >> 4 +} + +func (a *ControlPlaneOnlyIndication) SetIei(iei uint8) { + a.Octet = (a.Octet & 0x0F) | ((iei & 0x0F) << 4) +} + +func (a *ControlPlaneOnlyIndication) GetCPOI() (cpoi uint8) { + return a.Octet & GetBitMask(1, 0) +} + +func (a *ControlPlaneOnlyIndication) SetCPOI(cpoi uint8) { + a.Octet = (a.Octet & 0xFE) | (cpoi & 0x01) +} diff --git a/nasType/NAS_DiscontinuousCoverageMaxTimeOffset.go b/nasType/NAS_DiscontinuousCoverageMaxTimeOffset.go new file mode 100644 index 00000000..1f84b088 --- /dev/null +++ b/nasType/NAS_DiscontinuousCoverageMaxTimeOffset.go @@ -0,0 +1,35 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// DiscontinuousCoverageMaxTimeOffset 9.11.x +type DiscontinuousCoverageMaxTimeOffset struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewDiscontinuousCoverageMaxTimeOffset(iei uint8) (x *DiscontinuousCoverageMaxTimeOffset) { + x = &DiscontinuousCoverageMaxTimeOffset{} + x.SetIei(iei) + return x +} + +func (a *DiscontinuousCoverageMaxTimeOffset) GetIei() (iei uint8) { return a.Iei } +func (a *DiscontinuousCoverageMaxTimeOffset) SetIei(iei uint8) { a.Iei = iei } +func (a *DiscontinuousCoverageMaxTimeOffset) GetLen() (len uint8) { return a.Len } +func (a *DiscontinuousCoverageMaxTimeOffset) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *DiscontinuousCoverageMaxTimeOffset) GetDiscontinuousCoverageMaxTimeOffset() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} + +func (a *DiscontinuousCoverageMaxTimeOffset) SetDiscontinuousCoverageMaxTimeOffset(v []uint8) { + copy(a.Buffer, v) +} diff --git a/nasType/NAS_EquivalentSNPNs.go b/nasType/NAS_EquivalentSNPNs.go new file mode 100644 index 00000000..2a26e614 --- /dev/null +++ b/nasType/NAS_EquivalentSNPNs.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// EquivalentSNPNs 9.11.3.x +type EquivalentSNPNs struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewEquivalentSNPNs(iei uint8) (x *EquivalentSNPNs) { + x = &EquivalentSNPNs{} + x.SetIei(iei) + return x +} + +func (a *EquivalentSNPNs) GetIei() (iei uint8) { return a.Iei } +func (a *EquivalentSNPNs) SetIei(iei uint8) { a.Iei = iei } +func (a *EquivalentSNPNs) GetLen() (len uint8) { return a.Len } +func (a *EquivalentSNPNs) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *EquivalentSNPNs) GetEquivalentSNPNs() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *EquivalentSNPNs) SetEquivalentSNPNs(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_EthernetHeaderCompressionConfiguration.go b/nasType/NAS_EthernetHeaderCompressionConfiguration.go new file mode 100644 index 00000000..800a263e --- /dev/null +++ b/nasType/NAS_EthernetHeaderCompressionConfiguration.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// EthernetHeaderCompressionConfiguration 9.11.4.28 +// Iei Row, sBit, len = [], 8, 8 +// Len Row, sBit, len = [], 8, 8 +// Value Row, sBit, len = [0, 0], 8, 8 +type EthernetHeaderCompressionConfiguration struct { + Iei uint8 + Len uint8 + Octet uint8 +} + +func NewEthernetHeaderCompressionConfiguration(iei uint8) (x *EthernetHeaderCompressionConfiguration) { + x = &EthernetHeaderCompressionConfiguration{} + x.SetIei(iei) + return x +} + +func (a *EthernetHeaderCompressionConfiguration) GetIei() (iei uint8) { return a.Iei } +func (a *EthernetHeaderCompressionConfiguration) SetIei(iei uint8) { a.Iei = iei } +func (a *EthernetHeaderCompressionConfiguration) GetLen() (len uint8) { return a.Len } +func (a *EthernetHeaderCompressionConfiguration) SetLen(len uint8) { a.Len = len } +func (a *EthernetHeaderCompressionConfiguration) GetEHCI() (ehci uint8) { + return a.Octet & GetBitMask(2, 1) >> 1 +} + +func (a *EthernetHeaderCompressionConfiguration) SetEHCI(ehci uint8) { + a.Octet = (a.Octet & 253) + ((ehci & 1) << 1) +} diff --git a/nasType/NAS_FeatureAuthorizationIndication.go b/nasType/NAS_FeatureAuthorizationIndication.go new file mode 100644 index 00000000..e09baa9f --- /dev/null +++ b/nasType/NAS_FeatureAuthorizationIndication.go @@ -0,0 +1,35 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// FeatureAuthorizationIndication 9.11.3.x +type FeatureAuthorizationIndication struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewFeatureAuthorizationIndication(iei uint8) (x *FeatureAuthorizationIndication) { + x = &FeatureAuthorizationIndication{} + x.SetIei(iei) + return x +} + +func (a *FeatureAuthorizationIndication) GetIei() (iei uint8) { return a.Iei } +func (a *FeatureAuthorizationIndication) SetIei(iei uint8) { a.Iei = iei } +func (a *FeatureAuthorizationIndication) GetLen() (len uint8) { return a.Len } +func (a *FeatureAuthorizationIndication) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *FeatureAuthorizationIndication) GetFeatureAuthorizationIndication() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} + +func (a *FeatureAuthorizationIndication) SetFeatureAuthorizationIndication(v []uint8) { + copy(a.Buffer, v) +} diff --git a/nasType/NAS_FiveGSMNetworkFeatureSupport.go b/nasType/NAS_FiveGSMNetworkFeatureSupport.go new file mode 100644 index 00000000..57ea6045 --- /dev/null +++ b/nasType/NAS_FiveGSMNetworkFeatureSupport.go @@ -0,0 +1,35 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// FiveGSMNetworkFeatureSupport 9.11.4.18 +type FiveGSMNetworkFeatureSupport struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewFiveGSMNetworkFeatureSupport(iei uint8) (x *FiveGSMNetworkFeatureSupport) { + x = &FiveGSMNetworkFeatureSupport{} + x.SetIei(iei) + return x +} + +func (a *FiveGSMNetworkFeatureSupport) GetIei() (iei uint8) { return a.Iei } +func (a *FiveGSMNetworkFeatureSupport) SetIei(iei uint8) { a.Iei = iei } +func (a *FiveGSMNetworkFeatureSupport) GetLen() (len uint8) { return a.Len } +func (a *FiveGSMNetworkFeatureSupport) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *FiveGSMNetworkFeatureSupport) GetFiveGSMNetworkFeatureSupport() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} + +func (a *FiveGSMNetworkFeatureSupport) SetFiveGSMNetworkFeatureSupport(v []uint8) { + copy(a.Buffer, v) +} diff --git a/nasType/NAS_Fivegsmcongestionreattemptindicator.go b/nasType/NAS_Fivegsmcongestionreattemptindicator.go new file mode 100644 index 00000000..24657950 --- /dev/null +++ b/nasType/NAS_Fivegsmcongestionreattemptindicator.go @@ -0,0 +1,33 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// Fivegsmcongestionreattemptindicator 9.11.4.21 +// Iei Row, sBit, len = [], 8, 8 +// Len Row, sBit, len = [], 8, 8 +// BackOffTimerUnit Row, sBit, len = [0, 0], 4, 1 +// RATO Row, sBit, len = [0, 0], 1, 1 +type Fivegsmcongestionreattemptindicator struct { + Iei uint8 + Len uint8 + Octet uint8 +} + +func NewFivegsmcongestionreattemptindicator(iei uint8) (x *Fivegsmcongestionreattemptindicator) { + x = &Fivegsmcongestionreattemptindicator{} + x.SetIei(iei) + return x +} + +func (a *Fivegsmcongestionreattemptindicator) GetIei() (iei uint8) { return a.Iei } +func (a *Fivegsmcongestionreattemptindicator) SetIei(iei uint8) { a.Iei = iei } +func (a *Fivegsmcongestionreattemptindicator) GetLen() (len uint8) { return a.Len } +func (a *Fivegsmcongestionreattemptindicator) SetLen(len uint8) { a.Len = len } +func (a *Fivegsmcongestionreattemptindicator) GetRATO() uint8 { + return a.Octet & GetBitMask(1, 0) +} + +func (a *Fivegsmcongestionreattemptindicator) SetRATO(rato uint8) { + a.Octet = (a.Octet & 254) + (rato & 1) +} diff --git a/nasType/NAS_IPHeaderCompressionConfiguration.go b/nasType/NAS_IPHeaderCompressionConfiguration.go new file mode 100644 index 00000000..ec405749 --- /dev/null +++ b/nasType/NAS_IPHeaderCompressionConfiguration.go @@ -0,0 +1,35 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// IPHeaderCompressionConfiguration 9.11.4.24 +type IPHeaderCompressionConfiguration struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewIPHeaderCompressionConfiguration(iei uint8) (x *IPHeaderCompressionConfiguration) { + x = &IPHeaderCompressionConfiguration{} + x.SetIei(iei) + return x +} + +func (a *IPHeaderCompressionConfiguration) GetIei() (iei uint8) { return a.Iei } +func (a *IPHeaderCompressionConfiguration) SetIei(iei uint8) { a.Iei = iei } +func (a *IPHeaderCompressionConfiguration) GetLen() (len uint8) { return a.Len } +func (a *IPHeaderCompressionConfiguration) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *IPHeaderCompressionConfiguration) GetIPHeaderCompressionConfiguration() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} + +func (a *IPHeaderCompressionConfiguration) SetIPHeaderCompressionConfiguration(v []uint8) { + copy(a.Buffer, v) +} diff --git a/nasType/NAS_LowerBoundTimerValue.go b/nasType/NAS_LowerBoundTimerValue.go new file mode 100644 index 00000000..c54b969e --- /dev/null +++ b/nasType/NAS_LowerBoundTimerValue.go @@ -0,0 +1,67 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// LowerBoundTimerValue 9.11.2.5 +// UnitTimerValue Row, sBit, len = [0, 0], 8 , 3 +// TimerValue Row, sBit, len = [0, 0], 5 , 5 +type LowerBoundTimerValue struct { + Iei uint8 + Len uint8 + Octet uint8 +} + +func NewLowerBoundTimerValue(iei uint8) (lowerBoundTimerValue *LowerBoundTimerValue) { + lowerBoundTimerValue = &LowerBoundTimerValue{} + lowerBoundTimerValue.SetIei(iei) + return lowerBoundTimerValue +} + +// LowerBoundTimerValue 9.11.2.5 +// Iei Row, sBit, len = [], 8, 8 +func (a *LowerBoundTimerValue) GetIei() (iei uint8) { + return a.Iei +} + +// LowerBoundTimerValue 9.11.2.5 +// Iei Row, sBit, len = [], 8, 8 +func (a *LowerBoundTimerValue) SetIei(iei uint8) { + a.Iei = iei +} + +// LowerBoundTimerValue 9.11.2.5 +// Len Row, sBit, len = [], 8, 8 +func (a *LowerBoundTimerValue) GetLen() (len uint8) { + return a.Len +} + +// LowerBoundTimerValue 9.11.2.5 +// Len Row, sBit, len = [], 8, 8 +func (a *LowerBoundTimerValue) SetLen(len uint8) { + a.Len = len +} + +// LowerBoundTimerValue 9.11.2.5 +// UnitTimerValue Row, sBit, len = [0, 0], 8 , 3 +func (a *LowerBoundTimerValue) GetUnitTimerValue() (unitTimerValue uint8) { + return a.Octet & GetBitMask(8, 5) >> (5) +} + +// LowerBoundTimerValue 9.11.2.5 +// UnitTimerValue Row, sBit, len = [0, 0], 8 , 3 +func (a *LowerBoundTimerValue) SetUnitTimerValue(unitTimerValue uint8) { + a.Octet = (a.Octet & 31) + ((unitTimerValue & 7) << 5) +} + +// LowerBoundTimerValue 9.11.2.5 +// TimerValue Row, sBit, len = [0, 0], 5 , 5 +func (a *LowerBoundTimerValue) GetTimerValue() (timerValue uint8) { + return a.Octet & GetBitMask(5, 0) +} + +// LowerBoundTimerValue 9.11.2.5 +// TimerValue Row, sBit, len = [0, 0], 5 , 5 +func (a *LowerBoundTimerValue) SetTimerValue(timerValue uint8) { + a.Octet = (a.Octet & 224) + (timerValue & 31) +} diff --git a/nasType/NAS_MAPDUSessionInformation.go b/nasType/NAS_MAPDUSessionInformation.go new file mode 100644 index 00000000..0a0fd9d7 --- /dev/null +++ b/nasType/NAS_MAPDUSessionInformation.go @@ -0,0 +1,41 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// MAPDUSessionInformation 9.11.3.31A +// Iei Row, sBit, len = [0, 0], 8 , 4 +// MAPSI Row, sBit, len = [0, 0], 4 , 4 +type MAPDUSessionInformation struct { + Octet uint8 +} + +func NewMAPDUSessionInformation(iei uint8) (x *MAPDUSessionInformation) { + x = &MAPDUSessionInformation{} + x.SetIei(iei) + return x +} + +// MAPDUSessionInformation 9.11.3.31A +// Iei Row, sBit, len = [0, 0], 8 , 4 +func (a *MAPDUSessionInformation) GetIei() (iei uint8) { + return a.Octet & GetBitMask(8, 4) >> 4 +} + +// MAPDUSessionInformation 9.11.3.31A +// Iei Row, sBit, len = [0, 0], 8 , 4 +func (a *MAPDUSessionInformation) SetIei(iei uint8) { + a.Octet = (a.Octet & 0x0F) | ((iei & 0x0F) << 4) +} + +// MAPDUSessionInformation 9.11.3.31A +// MAPSI Row, sBit, len = [0, 0], 4 , 4 +func (a *MAPDUSessionInformation) GetMAPSI() (mapsi uint8) { + return a.Octet & GetBitMask(4, 0) +} + +// MAPDUSessionInformation 9.11.3.31A +// MAPSI Row, sBit, len = [0, 0], 4 , 4 +func (a *MAPDUSessionInformation) SetMAPSI(mapsi uint8) { + a.Octet = (a.Octet & 0xF0) | (mapsi & 0x0F) +} diff --git a/nasType/NAS_MasterSessionKey.go b/nasType/NAS_MasterSessionKey.go new file mode 100644 index 00000000..fc79f107 --- /dev/null +++ b/nasType/NAS_MasterSessionKey.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// MasterSessionKey 9.11.3.107 +type MasterSessionKey struct { + Iei uint8 + Len uint16 + Buffer []uint8 +} + +func NewMasterSessionKey(iei uint8) (x *MasterSessionKey) { + x = &MasterSessionKey{} + x.SetIei(iei) + return x +} + +func (a *MasterSessionKey) GetIei() (iei uint8) { return a.Iei } +func (a *MasterSessionKey) SetIei(iei uint8) { a.Iei = iei } +func (a *MasterSessionKey) GetLen() (len uint16) { return a.Len } +func (a *MasterSessionKey) SetLen(len uint16) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *MasterSessionKey) GetMasterSessionKey() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *MasterSessionKey) SetMasterSessionKey(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_N3IWFIdentifier.go b/nasType/NAS_N3IWFIdentifier.go new file mode 100644 index 00000000..ea4e64d1 --- /dev/null +++ b/nasType/NAS_N3IWFIdentifier.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// N3IWFIdentifier 9.11.3.93 +type N3IWFIdentifier struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewN3IWFIdentifier(iei uint8) (x *N3IWFIdentifier) { + x = &N3IWFIdentifier{} + x.SetIei(iei) + return x +} + +func (a *N3IWFIdentifier) GetIei() (iei uint8) { return a.Iei } +func (a *N3IWFIdentifier) SetIei(iei uint8) { a.Iei = iei } +func (a *N3IWFIdentifier) GetLen() (len uint8) { return a.Len } +func (a *N3IWFIdentifier) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *N3IWFIdentifier) GetN3IWFIdentifier() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *N3IWFIdentifier) SetN3IWFIdentifier(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_N3QAI.go b/nasType/NAS_N3QAI.go new file mode 100644 index 00000000..84322f91 --- /dev/null +++ b/nasType/NAS_N3QAI.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// N3QAI 9.11.4.36 +type N3QAI struct { + Iei uint8 + Len uint16 + Buffer []uint8 +} + +func NewN3QAI(iei uint8) (x *N3QAI) { + x = &N3QAI{} + x.SetIei(iei) + return x +} + +func (a *N3QAI) GetIei() (iei uint8) { return a.Iei } +func (a *N3QAI) SetIei(iei uint8) { a.Iei = iei } +func (a *N3QAI) GetLen() (len uint16) { return a.Len } +func (a *N3QAI) SetLen(len uint16) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *N3QAI) GetN3QAI() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *N3QAI) SetN3QAI(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_Non3GPPAccessPathSwitchingIndication.go b/nasType/NAS_Non3GPPAccessPathSwitchingIndication.go new file mode 100644 index 00000000..71fcc4b8 --- /dev/null +++ b/nasType/NAS_Non3GPPAccessPathSwitchingIndication.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// Non3GPPAccessPathSwitchingIndication 9.11.3.99 +// Iei Row, sBit, len = [], 8, 8 +// Len Row, sBit, len = [], 8, 8 +// NAPSI Row, sBit, len = [0, 0], 1 , 1 +type Non3GPPAccessPathSwitchingIndication struct { + Iei uint8 + Len uint8 + Octet uint8 +} + +func NewNon3GPPAccessPathSwitchingIndication(iei uint8) (x *Non3GPPAccessPathSwitchingIndication) { + x = &Non3GPPAccessPathSwitchingIndication{} + x.SetIei(iei) + return x +} + +func (a *Non3GPPAccessPathSwitchingIndication) GetIei() (iei uint8) { return a.Iei } +func (a *Non3GPPAccessPathSwitchingIndication) SetIei(iei uint8) { a.Iei = iei } +func (a *Non3GPPAccessPathSwitchingIndication) GetLen() (len uint8) { return a.Len } +func (a *Non3GPPAccessPathSwitchingIndication) SetLen(len uint8) { a.Len = len } +func (a *Non3GPPAccessPathSwitchingIndication) GetNAPSI() uint8 { + return a.Octet & GetBitMask(1, 0) +} + +func (a *Non3GPPAccessPathSwitchingIndication) SetNAPSI(napsi uint8) { + a.Octet = (a.Octet & 0xFE) | (napsi & 0x01) +} diff --git a/nasType/NAS_PartiallyAllowedNSSAI.go b/nasType/NAS_PartiallyAllowedNSSAI.go new file mode 100644 index 00000000..ebe654db --- /dev/null +++ b/nasType/NAS_PartiallyAllowedNSSAI.go @@ -0,0 +1,33 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// PartiallyAllowedNSSAI 9.11.3.37 +// SNSSAIValue Row, sBit, len = [0, 0], 0 , INF +type PartiallyAllowedNSSAI struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewPartiallyAllowedNSSAI(iei uint8) (x *PartiallyAllowedNSSAI) { + x = &PartiallyAllowedNSSAI{} + x.SetIei(iei) + return x +} + +func (a *PartiallyAllowedNSSAI) GetIei() (iei uint8) { return a.Iei } +func (a *PartiallyAllowedNSSAI) SetIei(iei uint8) { a.Iei = iei } +func (a *PartiallyAllowedNSSAI) GetLen() (len uint8) { return a.Len } +func (a *PartiallyAllowedNSSAI) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *PartiallyAllowedNSSAI) GetSNSSAIValue() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *PartiallyAllowedNSSAI) SetSNSSAIValue(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_PartiallyRejectedNSSAI.go b/nasType/NAS_PartiallyRejectedNSSAI.go new file mode 100644 index 00000000..0d6e0611 --- /dev/null +++ b/nasType/NAS_PartiallyRejectedNSSAI.go @@ -0,0 +1,33 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// PartiallyRejectedNSSAI 9.11.3.37 +// SNSSAIValue Row, sBit, len = [0, 0], 0 , INF +type PartiallyRejectedNSSAI struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewPartiallyRejectedNSSAI(iei uint8) (x *PartiallyRejectedNSSAI) { + x = &PartiallyRejectedNSSAI{} + x.SetIei(iei) + return x +} + +func (a *PartiallyRejectedNSSAI) GetIei() (iei uint8) { return a.Iei } +func (a *PartiallyRejectedNSSAI) SetIei(iei uint8) { a.Iei = iei } +func (a *PartiallyRejectedNSSAI) GetLen() (len uint8) { return a.Len } +func (a *PartiallyRejectedNSSAI) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *PartiallyRejectedNSSAI) GetSNSSAIValue() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *PartiallyRejectedNSSAI) SetSNSSAIValue(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_PayloadContainerInformation.go b/nasType/NAS_PayloadContainerInformation.go new file mode 100644 index 00000000..2e343d0d --- /dev/null +++ b/nasType/NAS_PayloadContainerInformation.go @@ -0,0 +1,33 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// PayloadContainerInformation 9.11.3.106 +// Iei Row, sBit, len = [0, 0], 8 , 4 +// Value Row, sBit, len = [0, 0], 4 , 4 +type PayloadContainerInformation struct { + Octet uint8 +} + +func NewPayloadContainerInformation(iei uint8) (x *PayloadContainerInformation) { + x = &PayloadContainerInformation{} + x.SetIei(iei) + return x +} + +func (a *PayloadContainerInformation) GetIei() (iei uint8) { + return a.Octet & GetBitMask(8, 4) >> 4 +} + +func (a *PayloadContainerInformation) SetIei(iei uint8) { + a.Octet = (a.Octet & 0x0F) | ((iei & 0x0F) << 4) +} + +func (a *PayloadContainerInformation) GetValue() uint8 { + return a.Octet & GetBitMask(4, 0) +} + +func (a *PayloadContainerInformation) SetValue(v uint8) { + a.Octet = (a.Octet & 0xF0) | (v & 0x0F) +} diff --git a/nasType/NAS_PendingNSSAI.go b/nasType/NAS_PendingNSSAI.go new file mode 100644 index 00000000..060190c9 --- /dev/null +++ b/nasType/NAS_PendingNSSAI.go @@ -0,0 +1,45 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// PendingNSSAI 9.11.3.37 +// SNSSAIValue Row, sBit, len = [0, 0], 0 , INF +type PendingNSSAI struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewPendingNSSAI(iei uint8) (pendingNSSAI *PendingNSSAI) { + pendingNSSAI = &PendingNSSAI{} + pendingNSSAI.SetIei(iei) + return pendingNSSAI +} + +func (a *PendingNSSAI) GetIei() (iei uint8) { + return a.Iei +} + +func (a *PendingNSSAI) SetIei(iei uint8) { + a.Iei = iei +} + +func (a *PendingNSSAI) GetLen() (len uint8) { + return a.Len +} + +func (a *PendingNSSAI) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *PendingNSSAI) GetSNSSAIValue() (sNSSAIValue []uint8) { + sNSSAIValue = make([]uint8, len(a.Buffer)) + copy(sNSSAIValue, a.Buffer) + return sNSSAIValue +} + +func (a *PendingNSSAI) SetSNSSAIValue(sNSSAIValue []uint8) { + copy(a.Buffer, sNSSAIValue) +} diff --git a/nasType/NAS_PriorityIndicator.go b/nasType/NAS_PriorityIndicator.go new file mode 100644 index 00000000..eb817a90 --- /dev/null +++ b/nasType/NAS_PriorityIndicator.go @@ -0,0 +1,33 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// PriorityIndicator 9.11.3.91 +// Iei Row, sBit, len = [0, 0], 8 , 4 +// MPP Row, sBit, len = [0, 0], 1 , 1 +type PriorityIndicator struct { + Octet uint8 +} + +func NewPriorityIndicator(iei uint8) (x *PriorityIndicator) { + x = &PriorityIndicator{} + x.SetIei(iei) + return x +} + +func (a *PriorityIndicator) GetIei() (iei uint8) { + return a.Octet & GetBitMask(8, 4) >> 4 +} + +func (a *PriorityIndicator) SetIei(iei uint8) { + a.Octet = (a.Octet & 0x0F) | ((iei & 0x0F) << 4) +} + +func (a *PriorityIndicator) GetMPP() (mpp uint8) { + return a.Octet & GetBitMask(1, 0) +} + +func (a *PriorityIndicator) SetMPP(mpp uint8) { + a.Octet = (a.Octet & 0xFE) | (mpp & 0x01) +} diff --git a/nasType/NAS_RANTimingSynchronization.go b/nasType/NAS_RANTimingSynchronization.go new file mode 100644 index 00000000..17509bc6 --- /dev/null +++ b/nasType/NAS_RANTimingSynchronization.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// RANTimingSynchronization 9.11.3.95 +type RANTimingSynchronization struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewRANTimingSynchronization(iei uint8) (x *RANTimingSynchronization) { + x = &RANTimingSynchronization{} + x.SetIei(iei) + return x +} + +func (a *RANTimingSynchronization) GetIei() (iei uint8) { return a.Iei } +func (a *RANTimingSynchronization) SetIei(iei uint8) { a.Iei = iei } +func (a *RANTimingSynchronization) GetLen() (len uint8) { return a.Len } +func (a *RANTimingSynchronization) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *RANTimingSynchronization) GetRANTimingSynchronization() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *RANTimingSynchronization) SetRANTimingSynchronization(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_ReAttemptIndicator.go b/nasType/NAS_ReAttemptIndicator.go new file mode 100644 index 00000000..ec0e7768 --- /dev/null +++ b/nasType/NAS_ReAttemptIndicator.go @@ -0,0 +1,41 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// ReAttemptIndicator 9.11.4.17 +// Iei Row, sBit, len = [], 8, 8 +// Len Row, sBit, len = [], 8, 8 +// RATC Row, sBit, len = [0, 0], 2, 1 +// EPLMNC Row, sBit, len = [0, 0], 1, 1 +type ReAttemptIndicator struct { + Iei uint8 + Len uint8 + Octet uint8 +} + +func NewReAttemptIndicator(iei uint8) (x *ReAttemptIndicator) { + x = &ReAttemptIndicator{} + x.SetIei(iei) + return x +} + +func (a *ReAttemptIndicator) GetIei() (iei uint8) { return a.Iei } +func (a *ReAttemptIndicator) SetIei(iei uint8) { a.Iei = iei } +func (a *ReAttemptIndicator) GetLen() (len uint8) { return a.Len } +func (a *ReAttemptIndicator) SetLen(len uint8) { a.Len = len } +func (a *ReAttemptIndicator) GetRATAC() uint8 { + return a.Octet & GetBitMask(2, 1) >> 1 +} + +func (a *ReAttemptIndicator) SetRATAC(ratac uint8) { + a.Octet = (a.Octet & 253) + ((ratac & 1) << 1) +} + +func (a *ReAttemptIndicator) GetEPLMNC() uint8 { + return a.Octet & GetBitMask(1, 0) +} + +func (a *ReAttemptIndicator) SetEPLMNC(eplmnc uint8) { + a.Octet = (a.Octet & 254) + (eplmnc & 1) +} diff --git a/nasType/NAS_ReceivedMBSContainer.go b/nasType/NAS_ReceivedMBSContainer.go new file mode 100644 index 00000000..83e382ac --- /dev/null +++ b/nasType/NAS_ReceivedMBSContainer.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// ReceivedMBSContainer 9.11.4.31 +type ReceivedMBSContainer struct { + Iei uint8 + Len uint16 + Buffer []uint8 +} + +func NewReceivedMBSContainer(iei uint8) (x *ReceivedMBSContainer) { + x = &ReceivedMBSContainer{} + x.SetIei(iei) + return x +} + +func (a *ReceivedMBSContainer) GetIei() (iei uint8) { return a.Iei } +func (a *ReceivedMBSContainer) SetIei(iei uint8) { a.Iei = iei } +func (a *ReceivedMBSContainer) GetLen() (len uint16) { return a.Len } +func (a *ReceivedMBSContainer) SetLen(len uint16) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *ReceivedMBSContainer) GetReceivedMBSContainer() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *ReceivedMBSContainer) SetReceivedMBSContainer(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_ReleaseAssistanceIndication.go b/nasType/NAS_ReleaseAssistanceIndication.go new file mode 100644 index 00000000..a787c39e --- /dev/null +++ b/nasType/NAS_ReleaseAssistanceIndication.go @@ -0,0 +1,41 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// ReleaseAssistanceIndication 9.11.3.46A +// Iei Row, sBit, len = [0, 0], 8 , 4 +// PDDEI Row, sBit, len = [0, 0], 2 , 2 +type ReleaseAssistanceIndication struct { + Octet uint8 +} + +func NewReleaseAssistanceIndication(iei uint8) (x *ReleaseAssistanceIndication) { + x = &ReleaseAssistanceIndication{} + x.SetIei(iei) + return x +} + +// ReleaseAssistanceIndication 9.11.3.46A +// Iei Row, sBit, len = [0, 0], 8 , 4 +func (a *ReleaseAssistanceIndication) GetIei() (iei uint8) { + return a.Octet & GetBitMask(8, 4) >> 4 +} + +// ReleaseAssistanceIndication 9.11.3.46A +// Iei Row, sBit, len = [0, 0], 8 , 4 +func (a *ReleaseAssistanceIndication) SetIei(iei uint8) { + a.Octet = (a.Octet & 0x0F) | ((iei & 0x0F) << 4) +} + +// ReleaseAssistanceIndication 9.11.3.46A +// PDDEI Row, sBit, len = [0, 0], 2 , 2 +func (a *ReleaseAssistanceIndication) GetPDDEI() (pDDEI uint8) { + return a.Octet & GetBitMask(2, 0) +} + +// ReleaseAssistanceIndication 9.11.3.46A +// PDDEI Row, sBit, len = [0, 0], 2 , 2 +func (a *ReleaseAssistanceIndication) SetPDDEI(pDDEI uint8) { + a.Octet = (a.Octet & 0xFC) | (pDDEI & 0x03) +} diff --git a/nasType/NAS_SNSSAILocationValidityInformation.go b/nasType/NAS_SNSSAILocationValidityInformation.go new file mode 100644 index 00000000..729bc33b --- /dev/null +++ b/nasType/NAS_SNSSAILocationValidityInformation.go @@ -0,0 +1,35 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// SNSSAILocationValidityInformation 9.11.3.100 +type SNSSAILocationValidityInformation struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewSNSSAILocationValidityInformation(iei uint8) (x *SNSSAILocationValidityInformation) { + x = &SNSSAILocationValidityInformation{} + x.SetIei(iei) + return x +} + +func (a *SNSSAILocationValidityInformation) GetIei() (iei uint8) { return a.Iei } +func (a *SNSSAILocationValidityInformation) SetIei(iei uint8) { a.Iei = iei } +func (a *SNSSAILocationValidityInformation) GetLen() (len uint8) { return a.Len } +func (a *SNSSAILocationValidityInformation) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *SNSSAILocationValidityInformation) GetSNSSAILocationValidityInformation() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} + +func (a *SNSSAILocationValidityInformation) SetSNSSAILocationValidityInformation(v []uint8) { + copy(a.Buffer, v) +} diff --git a/nasType/NAS_SNSSAITimeValidityInformation.go b/nasType/NAS_SNSSAITimeValidityInformation.go new file mode 100644 index 00000000..e7338684 --- /dev/null +++ b/nasType/NAS_SNSSAITimeValidityInformation.go @@ -0,0 +1,35 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// SNSSAITimeValidityInformation 9.11.3.101 +type SNSSAITimeValidityInformation struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewSNSSAITimeValidityInformation(iei uint8) (x *SNSSAITimeValidityInformation) { + x = &SNSSAITimeValidityInformation{} + x.SetIei(iei) + return x +} + +func (a *SNSSAITimeValidityInformation) GetIei() (iei uint8) { return a.Iei } +func (a *SNSSAITimeValidityInformation) SetIei(iei uint8) { a.Iei = iei } +func (a *SNSSAITimeValidityInformation) GetLen() (len uint8) { return a.Len } +func (a *SNSSAITimeValidityInformation) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *SNSSAITimeValidityInformation) GetSNSSAITimeValidityInformation() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} + +func (a *SNSSAITimeValidityInformation) SetSNSSAITimeValidityInformation(v []uint8) { + copy(a.Buffer, v) +} diff --git a/nasType/NAS_ServingPLMNRateControl.go b/nasType/NAS_ServingPLMNRateControl.go new file mode 100644 index 00000000..44d9bec7 --- /dev/null +++ b/nasType/NAS_ServingPLMNRateControl.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// ServingPLMNRateControl 9.11.4.20 +type ServingPLMNRateControl struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewServingPLMNRateControl(iei uint8) (x *ServingPLMNRateControl) { + x = &ServingPLMNRateControl{} + x.SetIei(iei) + return x +} + +func (a *ServingPLMNRateControl) GetIei() (iei uint8) { return a.Iei } +func (a *ServingPLMNRateControl) SetIei(iei uint8) { a.Iei = iei } +func (a *ServingPLMNRateControl) GetLen() (len uint8) { return a.Len } +func (a *ServingPLMNRateControl) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *ServingPLMNRateControl) GetServingPLMNRateControl() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *ServingPLMNRateControl) SetServingPLMNRateControl(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_T3448Value.go b/nasType/NAS_T3448Value.go new file mode 100644 index 00000000..2768cd34 --- /dev/null +++ b/nasType/NAS_T3448Value.go @@ -0,0 +1,54 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// T3448Value 9.11.2.4 +// GPRSTimer2Value Row, sBit, len = [0, 0], 8 , 8 +type T3448Value struct { + Iei uint8 + Len uint8 + Octet uint8 +} + +func NewT3448Value(iei uint8) (t3448Value *T3448Value) { + t3448Value = &T3448Value{} + t3448Value.SetIei(iei) + return t3448Value +} + +// T3448Value 9.11.2.4 +// Iei Row, sBit, len = [], 8, 8 +func (a *T3448Value) GetIei() (iei uint8) { + return a.Iei +} + +// T3448Value 9.11.2.4 +// Iei Row, sBit, len = [], 8, 8 +func (a *T3448Value) SetIei(iei uint8) { + a.Iei = iei +} + +// T3448Value 9.11.2.4 +// Len Row, sBit, len = [], 8, 8 +func (a *T3448Value) GetLen() (len uint8) { + return a.Len +} + +// T3448Value 9.11.2.4 +// Len Row, sBit, len = [], 8, 8 +func (a *T3448Value) SetLen(len uint8) { + a.Len = len +} + +// T3448Value 9.11.2.4 +// GPRSTimer2Value Row, sBit, len = [0, 0], 8 , 8 +func (a *T3448Value) GetGPRSTimer2Value() (gPRSTimer2Value uint8) { + return a.Octet +} + +// T3448Value 9.11.2.4 +// GPRSTimer2Value Row, sBit, len = [0, 0], 8 , 8 +func (a *T3448Value) SetGPRSTimer2Value(gPRSTimer2Value uint8) { + a.Octet = gPRSTimer2Value +} diff --git a/nasType/NAS_TNANInformation.go b/nasType/NAS_TNANInformation.go new file mode 100644 index 00000000..c03981e5 --- /dev/null +++ b/nasType/NAS_TNANInformation.go @@ -0,0 +1,32 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// TNANInformation 9.11.3.94 +type TNANInformation struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewTNANInformation(iei uint8) (x *TNANInformation) { + x = &TNANInformation{} + x.SetIei(iei) + return x +} + +func (a *TNANInformation) GetIei() (iei uint8) { return a.Iei } +func (a *TNANInformation) SetIei(iei uint8) { a.Iei = iei } +func (a *TNANInformation) GetLen() (len uint8) { return a.Len } +func (a *TNANInformation) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *TNANInformation) GetTNANInformation() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} +func (a *TNANInformation) SetTNANInformation(v []uint8) { copy(a.Buffer, v) } diff --git a/nasType/NAS_UpdatedPEIPSAssistanceInformation.go b/nasType/NAS_UpdatedPEIPSAssistanceInformation.go new file mode 100644 index 00000000..6514cf89 --- /dev/null +++ b/nasType/NAS_UpdatedPEIPSAssistanceInformation.go @@ -0,0 +1,35 @@ +// Copyright (C) 2026 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 + +package nasType + +// UpdatedPEIPSAssistanceInformation 9.11.3.x +type UpdatedPEIPSAssistanceInformation struct { + Iei uint8 + Len uint8 + Buffer []uint8 +} + +func NewUpdatedPEIPSAssistanceInformation(iei uint8) (x *UpdatedPEIPSAssistanceInformation) { + x = &UpdatedPEIPSAssistanceInformation{} + x.SetIei(iei) + return x +} + +func (a *UpdatedPEIPSAssistanceInformation) GetIei() (iei uint8) { return a.Iei } +func (a *UpdatedPEIPSAssistanceInformation) SetIei(iei uint8) { a.Iei = iei } +func (a *UpdatedPEIPSAssistanceInformation) GetLen() (len uint8) { return a.Len } +func (a *UpdatedPEIPSAssistanceInformation) SetLen(len uint8) { + a.Len = len + a.Buffer = make([]uint8, a.Len) +} + +func (a *UpdatedPEIPSAssistanceInformation) GetUpdatedPEIPSAssistanceInformation() []uint8 { + v := make([]uint8, len(a.Buffer)) + copy(v, a.Buffer) + return v +} + +func (a *UpdatedPEIPSAssistanceInformation) SetUpdatedPEIPSAssistanceInformation(v []uint8) { + copy(a.Buffer, v) +} From b4ce1541ed6885c4aacb732051a9d0c1d34fc182 Mon Sep 17 00:00:00 2001 From: "Arrobo, Gabriel" Date: Tue, 28 Jul 2026 17:54:15 -0700 Subject: [PATCH 2/2] Address Copilot's comments Signed-off-by: Arrobo, Gabriel --- nasMessage/NAS_ConfigurationUpdateCommand.go | 4 +- .../NAS_ConfigurationUpdateCommand_test.go | 47 +++++++++++++++++ nasMessage/NAS_RegistrationAccept.go | 4 +- nasMessage/NAS_RegistrationRequest.go | 11 ++-- nasMessage/NAS_ULNASTransport_test.go | 51 +++++++++++++++++++ nasType/NAS_AUN3Indication.go | 41 ++++++--------- .../NAS_DiscontinuousCoverageMaxTimeOffset.go | 34 ++++++++----- nasType/NAS_EquivalentSNPNs.go | 2 +- ..._EthernetHeaderCompressionConfiguration.go | 10 ++-- nasType/NAS_FeatureAuthorizationIndication.go | 18 ++++++- ...NAS_Fivegsmcongestionreattemptindicator.go | 18 +++++-- nasType/NAS_N5GCIndication.go | 14 ++--- ...AS_Non3GPPAccessPathSwitchingIndication.go | 8 +-- nasType/NAS_Non3GPPNWProvidedPolicies.go | 2 +- nasType/NAS_PartiallyAllowedNSSAI.go | 12 ++--- nasType/NAS_PartiallyRejectedNSSAI.go | 12 ++--- nasType/NAS_PayloadContainerInformation.go | 10 ++-- nasType/NAS_PriorityIndicator.go | 8 +-- nasType/NAS_ReAttemptIndicator.go | 6 +-- .../NAS_UpdatedPEIPSAssistanceInformation.go | 2 +- 20 files changed, 216 insertions(+), 98 deletions(-) diff --git a/nasMessage/NAS_ConfigurationUpdateCommand.go b/nasMessage/NAS_ConfigurationUpdateCommand.go index 52a003bd..88e647a1 100644 --- a/nasMessage/NAS_ConfigurationUpdateCommand.go +++ b/nasMessage/NAS_ConfigurationUpdateCommand.go @@ -290,7 +290,7 @@ func (a *ConfigurationUpdateCommand) EncodeConfigurationUpdateCommand(buffer *by if a.DiscontinuousCoverageMaxTimeOffset != nil { binary.Write(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.GetIei()) binary.Write(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.GetLen()) - binary.Write(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Buffer) + binary.Write(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Octet) } if a.PartiallyAllowedNSSAI != nil { binary.Write(buffer, binary.BigEndian, a.PartiallyAllowedNSSAI.GetIei()) @@ -506,7 +506,7 @@ func (a *ConfigurationUpdateCommand) DecodeConfigurationUpdateCommand(byteArray a.DiscontinuousCoverageMaxTimeOffset = nasType.NewDiscontinuousCoverageMaxTimeOffset(ieiN) binary.Read(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Len) a.DiscontinuousCoverageMaxTimeOffset.SetLen(a.DiscontinuousCoverageMaxTimeOffset.GetLen()) - binary.Read(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.Buffer[:a.DiscontinuousCoverageMaxTimeOffset.GetLen()]) + binary.Read(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Octet) case ConfigurationUpdateCommandPartiallyAllowedNSSAIType: a.PartiallyAllowedNSSAI = nasType.NewPartiallyAllowedNSSAI(ieiN) binary.Read(buffer, binary.BigEndian, &a.PartiallyAllowedNSSAI.Len) diff --git a/nasMessage/NAS_ConfigurationUpdateCommand_test.go b/nasMessage/NAS_ConfigurationUpdateCommand_test.go index 2e3df459..b351626b 100644 --- a/nasMessage/NAS_ConfigurationUpdateCommand_test.go +++ b/nasMessage/NAS_ConfigurationUpdateCommand_test.go @@ -266,3 +266,50 @@ func TestConfigurationUpdateCommandNewIEsEncodeDecode(t *testing.T) { t.Errorf("ConfigurationUpdateCommand new IEs encode/decode mismatch") } } + +func TestConfigurationUpdateCommandRel1718IEsEncodeDecode(t *testing.T) { + a := nasMessage.NewConfigurationUpdateCommand(0) + b := nasMessage.NewConfigurationUpdateCommand(0) + if a == nil { + t.Fatal("Expected value not to be nil") + } + if b == nil { + t.Fatal("Expected value not to be nil") + } + + a.ExtendedProtocolDiscriminator.SetExtendedProtocolDiscriminator(nasMessage.Epd5GSMobilityManagementMessage) + a.SpareHalfOctetAndSecurityHeaderType.SetSecurityHeaderType(0x00) + a.SpareHalfOctetAndSecurityHeaderType.SetSpareHalfOctet(0x00) + a.ConfigurationUpdateCommandMessageIdentity.SetMessageType(nas.MsgTypeConfigurationUpdateCommand) + + a.RegistrationResult5GS = nasType.NewRegistrationResult5GS(nasMessage.ConfigurationUpdateCommandRegistrationResult5GSType) + a.RegistrationResult5GS.SetLen(1) + a.RegistrationResult5GS.Octet = 0x01 + + a.AdditionalConfigurationIndication = nasType.NewAdditionalConfigurationIndication(nasMessage.ConfigurationUpdateCommandAdditionalConfigurationIndicationType) + a.AdditionalConfigurationIndication.SetSCMR(0x01) + + a.UpdatedPEIPSAssistanceInformation = nasType.NewUpdatedPEIPSAssistanceInformation(nasMessage.ConfigurationUpdateCommandUpdatedPEIPSAssistanceInformationType) + a.UpdatedPEIPSAssistanceInformation.SetLen(2) + copy(a.UpdatedPEIPSAssistanceInformation.Buffer, []byte{0xAA, 0xBB}) + + a.PriorityIndicator = nasType.NewPriorityIndicator(nasMessage.ConfigurationUpdateCommandPriorityIndicatorType) + a.PriorityIndicator.SetMPSI(0x01) + + a.RANTimingSynchronization = nasType.NewRANTimingSynchronization(nasMessage.ConfigurationUpdateCommandRANTimingSynchronizationType) + a.RANTimingSynchronization.SetLen(2) + copy(a.RANTimingSynchronization.Buffer, []byte{0x01, 0x02}) + + buff := new(bytes.Buffer) + a.EncodeConfigurationUpdateCommand(buff) + logger.NasMsgLog.Debugln("Encode: ", a) + + data := make([]byte, buff.Len()) + buff.Read(data) + b.DecodeConfigurationUpdateCommand(&data) + logger.NasMsgLog.Debugln("Decode: ", b) + + if reflect.DeepEqual(a, b) != true { + t.Errorf("ConfigurationUpdateCommand Rel-17/18 IEs encode/decode mismatch") + } +} diff --git a/nasMessage/NAS_RegistrationAccept.go b/nasMessage/NAS_RegistrationAccept.go index aa7e4e0d..f28902fd 100644 --- a/nasMessage/NAS_RegistrationAccept.go +++ b/nasMessage/NAS_RegistrationAccept.go @@ -390,7 +390,7 @@ func (a *RegistrationAccept) EncodeRegistrationAccept(buffer *bytes.Buffer) { if a.DiscontinuousCoverageMaxTimeOffset != nil { binary.Write(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.GetIei()) binary.Write(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.GetLen()) - binary.Write(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Buffer) + binary.Write(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Octet) } if a.SNSSAITimeValidityInformation != nil { binary.Write(buffer, binary.BigEndian, a.SNSSAITimeValidityInformation.GetIei()) @@ -688,7 +688,7 @@ func (a *RegistrationAccept) DecodeRegistrationAccept(byteArray *[]byte) { a.DiscontinuousCoverageMaxTimeOffset = nasType.NewDiscontinuousCoverageMaxTimeOffset(ieiN) binary.Read(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Len) a.DiscontinuousCoverageMaxTimeOffset.SetLen(a.DiscontinuousCoverageMaxTimeOffset.GetLen()) - binary.Read(buffer, binary.BigEndian, a.DiscontinuousCoverageMaxTimeOffset.Buffer[:a.DiscontinuousCoverageMaxTimeOffset.GetLen()]) + binary.Read(buffer, binary.BigEndian, &a.DiscontinuousCoverageMaxTimeOffset.Octet) case RegistrationAcceptSNSSAITimeValidityInformationType: a.SNSSAITimeValidityInformation = nasType.NewSNSSAITimeValidityInformation(ieiN) binary.Read(buffer, binary.BigEndian, &a.SNSSAITimeValidityInformation.Len) diff --git a/nasMessage/NAS_RegistrationRequest.go b/nasMessage/NAS_RegistrationRequest.go index ceabf513..d8697473 100644 --- a/nasMessage/NAS_RegistrationRequest.go +++ b/nasMessage/NAS_RegistrationRequest.go @@ -297,8 +297,8 @@ func (a *RegistrationRequest) EncodeRegistrationRequest(buffer *bytes.Buffer) { } if a.AUN3Indication != nil { binary.Write(buffer, binary.BigEndian, a.AUN3Indication.GetIei()) - binary.Write(buffer, binary.BigEndian, uint8(a.AUN3Indication.GetLen())) - binary.Write(buffer, binary.BigEndian, a.AUN3Indication.Buffer[:uint8(a.AUN3Indication.GetLen())]) + binary.Write(buffer, binary.BigEndian, a.AUN3Indication.GetLen()) + binary.Write(buffer, binary.BigEndian, &a.AUN3Indication.Octet) } if a.T3512Value != nil { binary.Write(buffer, binary.BigEndian, a.T3512Value.GetIei()) @@ -512,10 +512,9 @@ func (a *RegistrationRequest) DecodeRegistrationRequest(byteArray *[]byte) { binary.Read(buffer, binary.BigEndian, a.Non3GPPPathSwitchingInformation.Buffer[:lenN]) case RegistrationRequestAUN3IndicationType: a.AUN3Indication = nasType.NewAUN3Indication(ieiN) - var lenN uint8 - binary.Read(buffer, binary.BigEndian, &lenN) - a.AUN3Indication.SetLen(uint16(lenN)) - binary.Read(buffer, binary.BigEndian, a.AUN3Indication.Buffer[:lenN]) + binary.Read(buffer, binary.BigEndian, &a.AUN3Indication.Len) + a.AUN3Indication.SetLen(a.AUN3Indication.GetLen()) + binary.Read(buffer, binary.BigEndian, &a.AUN3Indication.Octet) case RegistrationRequestMobileStationClassmark2Type: a.MobileStationClassmark2 = nasType.NewMobileStationClassmark2(ieiN) var lenN uint8 diff --git a/nasMessage/NAS_ULNASTransport_test.go b/nasMessage/NAS_ULNASTransport_test.go index 580c837a..afd7a496 100644 --- a/nasMessage/NAS_ULNASTransport_test.go +++ b/nasMessage/NAS_ULNASTransport_test.go @@ -134,3 +134,54 @@ func TestNasTypeNewULNASTransportMessage(t *testing.T) { } } } + +func TestULNASTransportNewIEsEncodeDecode(t *testing.T) { + a := nasMessage.NewULNASTransport(0) + b := nasMessage.NewULNASTransport(0) + if a == nil { + t.Fatal("Expected value not to be nil") + } + if b == nil { + t.Fatal("Expected value not to be nil") + } + + a.ExtendedProtocolDiscriminator.SetExtendedProtocolDiscriminator(nasMessage.Epd5GSMobilityManagementMessage) + a.SpareHalfOctetAndSecurityHeaderType.SetSecurityHeaderType(0x00) + a.SpareHalfOctetAndSecurityHeaderType.SetSpareHalfOctet(0x00) + a.ULNASTRANSPORTMessageIdentity.SetMessageType(nas.MsgTypeULNASTransport) + a.SpareHalfOctetAndPayloadContainerType.Octet = 0x01 + a.PayloadContainer.SetLen(2) + copy(a.PayloadContainer.Buffer, []uint8{0x01, 0x02}) + + a.MAPDUSessionInformation = nasType.NewMAPDUSessionInformation(nasMessage.ULNASTransportMAPDUSessionInformationType) + a.MAPDUSessionInformation.SetMAPSI(0x03) + + a.ReleaseAssistanceIndication = nasType.NewReleaseAssistanceIndication(nasMessage.ULNASTransportReleaseAssistanceIndicationType) + a.ReleaseAssistanceIndication.SetPDDEI(0x02) + + a.Non3GPPAccessPathSwitchingIndication = nasType.NewNon3GPPAccessPathSwitchingIndication(nasMessage.ULNASTransportNon3GPPAccessPathSwitchingIndicationType) + a.Non3GPPAccessPathSwitchingIndication.SetLen(1) + a.Non3GPPAccessPathSwitchingIndication.SetNAPS(0x01) + + a.AlternativeSNSSAI = nasType.NewSNSSAI(nasMessage.ULNASTransportAlternativeSNSSAIType) + a.AlternativeSNSSAI.SetLen(2) + a.AlternativeSNSSAI.Octet[0] = 0x11 + a.AlternativeSNSSAI.Octet[1] = 0x22 + + a.PayloadContainerInformation = nasType.NewPayloadContainerInformation(nasMessage.ULNASTransportPayloadContainerInformationType) + a.PayloadContainerInformation.SetPRU(0x05) + + buff := new(bytes.Buffer) + a.EncodeULNASTransport(buff) + logger.NasMsgLog.Debugln("Encode: ", a) + + data := make([]byte, buff.Len()) + buff.Read(data) + logger.NasMsgLog.Debugln(data) + b.DecodeULNASTransport(&data) + logger.NasMsgLog.Debugln("Decode: ", b) + + if reflect.DeepEqual(a, b) != true { + t.Errorf("ULNASTransport new IEs encode/decode mismatch") + } +} diff --git a/nasType/NAS_AUN3Indication.go b/nasType/NAS_AUN3Indication.go index b13bc104..171243db 100644 --- a/nasType/NAS_AUN3Indication.go +++ b/nasType/NAS_AUN3Indication.go @@ -4,42 +4,31 @@ package nasType // AUN3Indication 9.11.3.104 -// AUN3Indication Row, sBit, len = [0, INF], 8 , INF +// Iei Row, sBit, len = [], 8, 8 +// Len Row, sBit, len = [], 8, 8 +// AUN3REG Row, sBit, len = [0, 0], 1, 1 type AUN3Indication struct { - Iei uint8 - Len uint16 - Buffer []uint8 + Iei uint8 + Len uint8 + Octet uint8 } func NewAUN3Indication(iei uint8) (x *AUN3Indication) { x = &AUN3Indication{} x.SetIei(iei) + x.Len = 1 return x } -func (a *AUN3Indication) GetIei() (iei uint8) { - return a.Iei -} - -func (a *AUN3Indication) SetIei(iei uint8) { - a.Iei = iei -} - -func (a *AUN3Indication) GetLen() (len uint16) { - return a.Len -} - -func (a *AUN3Indication) SetLen(len uint16) { - a.Len = len - a.Buffer = make([]uint8, a.Len) -} +func (a *AUN3Indication) GetIei() (iei uint8) { return a.Iei } +func (a *AUN3Indication) SetIei(iei uint8) { a.Iei = iei } +func (a *AUN3Indication) GetLen() (len uint8) { return a.Len } +func (a *AUN3Indication) SetLen(len uint8) { a.Len = len } -func (a *AUN3Indication) GetAUN3Indication() (contents []uint8) { - contents = make([]uint8, len(a.Buffer)) - copy(contents, a.Buffer) - return contents +func (a *AUN3Indication) GetAUN3REG() uint8 { + return a.Octet & GetBitMask(1, 0) } -func (a *AUN3Indication) SetAUN3Indication(contents []uint8) { - copy(a.Buffer, contents) +func (a *AUN3Indication) SetAUN3REG(aun3reg uint8) { + a.Octet = (a.Octet & 0xFE) | (aun3reg & 0x01) } diff --git a/nasType/NAS_DiscontinuousCoverageMaxTimeOffset.go b/nasType/NAS_DiscontinuousCoverageMaxTimeOffset.go index 1f84b088..b323cb03 100644 --- a/nasType/NAS_DiscontinuousCoverageMaxTimeOffset.go +++ b/nasType/NAS_DiscontinuousCoverageMaxTimeOffset.go @@ -3,33 +3,41 @@ package nasType -// DiscontinuousCoverageMaxTimeOffset 9.11.x +// DiscontinuousCoverageMaxTimeOffset 9.11.2.5 +// Iei Row, sBit, len = [], 8, 8 +// Len Row, sBit, len = [], 8, 8 +// UnitTimerValue Row, sBit, len = [0, 0], 8 , 3 +// TimerValue Row, sBit, len = [0, 0], 5 , 5 type DiscontinuousCoverageMaxTimeOffset struct { - Iei uint8 - Len uint8 - Buffer []uint8 + Iei uint8 + Len uint8 + Octet uint8 } func NewDiscontinuousCoverageMaxTimeOffset(iei uint8) (x *DiscontinuousCoverageMaxTimeOffset) { x = &DiscontinuousCoverageMaxTimeOffset{} x.SetIei(iei) + x.Len = 1 return x } func (a *DiscontinuousCoverageMaxTimeOffset) GetIei() (iei uint8) { return a.Iei } func (a *DiscontinuousCoverageMaxTimeOffset) SetIei(iei uint8) { a.Iei = iei } func (a *DiscontinuousCoverageMaxTimeOffset) GetLen() (len uint8) { return a.Len } -func (a *DiscontinuousCoverageMaxTimeOffset) SetLen(len uint8) { - a.Len = len - a.Buffer = make([]uint8, a.Len) +func (a *DiscontinuousCoverageMaxTimeOffset) SetLen(len uint8) { a.Len = len } + +func (a *DiscontinuousCoverageMaxTimeOffset) GetUnitTimerValue() uint8 { + return a.Octet & GetBitMask(8, 5) >> 5 +} + +func (a *DiscontinuousCoverageMaxTimeOffset) SetUnitTimerValue(unitTimerValue uint8) { + a.Octet = (a.Octet & 0x1F) | ((unitTimerValue & 0x07) << 5) } -func (a *DiscontinuousCoverageMaxTimeOffset) GetDiscontinuousCoverageMaxTimeOffset() []uint8 { - v := make([]uint8, len(a.Buffer)) - copy(v, a.Buffer) - return v +func (a *DiscontinuousCoverageMaxTimeOffset) GetTimerValue() uint8 { + return a.Octet & GetBitMask(5, 0) } -func (a *DiscontinuousCoverageMaxTimeOffset) SetDiscontinuousCoverageMaxTimeOffset(v []uint8) { - copy(a.Buffer, v) +func (a *DiscontinuousCoverageMaxTimeOffset) SetTimerValue(timerValue uint8) { + a.Octet = (a.Octet & 0xE0) | (timerValue & 0x1F) } diff --git a/nasType/NAS_EquivalentSNPNs.go b/nasType/NAS_EquivalentSNPNs.go index 2a26e614..8b4bc12c 100644 --- a/nasType/NAS_EquivalentSNPNs.go +++ b/nasType/NAS_EquivalentSNPNs.go @@ -3,7 +3,7 @@ package nasType -// EquivalentSNPNs 9.11.3.x +// EquivalentSNPNs 9.11.3.92 type EquivalentSNPNs struct { Iei uint8 Len uint8 diff --git a/nasType/NAS_EthernetHeaderCompressionConfiguration.go b/nasType/NAS_EthernetHeaderCompressionConfiguration.go index 800a263e..6252c67f 100644 --- a/nasType/NAS_EthernetHeaderCompressionConfiguration.go +++ b/nasType/NAS_EthernetHeaderCompressionConfiguration.go @@ -6,7 +6,7 @@ package nasType // EthernetHeaderCompressionConfiguration 9.11.4.28 // Iei Row, sBit, len = [], 8, 8 // Len Row, sBit, len = [], 8, 8 -// Value Row, sBit, len = [0, 0], 8, 8 +// CIDLen Row, sBit, len = [0, 0], 2, 2 type EthernetHeaderCompressionConfiguration struct { Iei uint8 Len uint8 @@ -23,10 +23,10 @@ func (a *EthernetHeaderCompressionConfiguration) GetIei() (iei uint8) { return a func (a *EthernetHeaderCompressionConfiguration) SetIei(iei uint8) { a.Iei = iei } func (a *EthernetHeaderCompressionConfiguration) GetLen() (len uint8) { return a.Len } func (a *EthernetHeaderCompressionConfiguration) SetLen(len uint8) { a.Len = len } -func (a *EthernetHeaderCompressionConfiguration) GetEHCI() (ehci uint8) { - return a.Octet & GetBitMask(2, 1) >> 1 +func (a *EthernetHeaderCompressionConfiguration) GetCIDLen() (cidLen uint8) { + return a.Octet & GetBitMask(2, 0) } -func (a *EthernetHeaderCompressionConfiguration) SetEHCI(ehci uint8) { - a.Octet = (a.Octet & 253) + ((ehci & 1) << 1) +func (a *EthernetHeaderCompressionConfiguration) SetCIDLen(cidLen uint8) { + a.Octet = (a.Octet & 0xFC) | (cidLen & 0x03) } diff --git a/nasType/NAS_FeatureAuthorizationIndication.go b/nasType/NAS_FeatureAuthorizationIndication.go index e09baa9f..91657cc2 100644 --- a/nasType/NAS_FeatureAuthorizationIndication.go +++ b/nasType/NAS_FeatureAuthorizationIndication.go @@ -3,7 +3,10 @@ package nasType -// FeatureAuthorizationIndication 9.11.3.x +// FeatureAuthorizationIndication 9.11.3.105 +// Iei Row, sBit, len = [], 8, 8 +// Len Row, sBit, len = [], 8, 8 +// MBSRAI Row, sBit, len = [0, 0], 2, 2 type FeatureAuthorizationIndication struct { Iei uint8 Len uint8 @@ -33,3 +36,16 @@ func (a *FeatureAuthorizationIndication) GetFeatureAuthorizationIndication() []u func (a *FeatureAuthorizationIndication) SetFeatureAuthorizationIndication(v []uint8) { copy(a.Buffer, v) } + +func (a *FeatureAuthorizationIndication) GetMBSRAI() uint8 { + if len(a.Buffer) == 0 { + return 0 + } + return a.Buffer[0] & GetBitMask(2, 0) +} + +func (a *FeatureAuthorizationIndication) SetMBSRAI(mbsrai uint8) { + if len(a.Buffer) > 0 { + a.Buffer[0] = (a.Buffer[0] & 0xFC) | (mbsrai & 0x03) + } +} diff --git a/nasType/NAS_Fivegsmcongestionreattemptindicator.go b/nasType/NAS_Fivegsmcongestionreattemptindicator.go index 24657950..bac357d1 100644 --- a/nasType/NAS_Fivegsmcongestionreattemptindicator.go +++ b/nasType/NAS_Fivegsmcongestionreattemptindicator.go @@ -6,8 +6,8 @@ package nasType // Fivegsmcongestionreattemptindicator 9.11.4.21 // Iei Row, sBit, len = [], 8, 8 // Len Row, sBit, len = [], 8, 8 -// BackOffTimerUnit Row, sBit, len = [0, 0], 4, 1 -// RATO Row, sBit, len = [0, 0], 1, 1 +// CATBO Row, sBit, len = [0, 0], 2, 1 +// ABO Row, sBit, len = [0, 0], 1, 1 type Fivegsmcongestionreattemptindicator struct { Iei uint8 Len uint8 @@ -24,10 +24,18 @@ func (a *Fivegsmcongestionreattemptindicator) GetIei() (iei uint8) { return a.Ie func (a *Fivegsmcongestionreattemptindicator) SetIei(iei uint8) { a.Iei = iei } func (a *Fivegsmcongestionreattemptindicator) GetLen() (len uint8) { return a.Len } func (a *Fivegsmcongestionreattemptindicator) SetLen(len uint8) { a.Len = len } -func (a *Fivegsmcongestionreattemptindicator) GetRATO() uint8 { +func (a *Fivegsmcongestionreattemptindicator) GetCATBO() uint8 { + return a.Octet & GetBitMask(2, 1) >> 1 +} + +func (a *Fivegsmcongestionreattemptindicator) SetCATBO(catbo uint8) { + a.Octet = (a.Octet & 0xFD) + ((catbo & 1) << 1) +} + +func (a *Fivegsmcongestionreattemptindicator) GetABO() uint8 { return a.Octet & GetBitMask(1, 0) } -func (a *Fivegsmcongestionreattemptindicator) SetRATO(rato uint8) { - a.Octet = (a.Octet & 254) + (rato & 1) +func (a *Fivegsmcongestionreattemptindicator) SetABO(abo uint8) { + a.Octet = (a.Octet & 0xFE) + (abo & 1) } diff --git a/nasType/NAS_N5GCIndication.go b/nasType/NAS_N5GCIndication.go index e04955de..7de7f2e4 100644 --- a/nasType/NAS_N5GCIndication.go +++ b/nasType/NAS_N5GCIndication.go @@ -5,7 +5,7 @@ package nasType // N5GCIndication 9.11.3.72 // Iei Row, sBit, len = [0, 0], 8 , 4 -// N5GCIValue Row, sBit, len = [0, 0], 4 , 4 +// N5GCREG Row, sBit, len = [0, 0], 1 , 1 type N5GCIndication struct { Octet uint8 } @@ -29,13 +29,13 @@ func (a *N5GCIndication) SetIei(iei uint8) { } // N5GCIndication 9.11.3.72 -// N5GCIValue Row, sBit, len = [0, 0], 4 , 4 -func (a *N5GCIndication) GetN5GCIValue() (n5GCIValue uint8) { - return a.Octet & GetBitMask(4, 0) +// N5GCREG Row, sBit, len = [0, 0], 1 , 1 +func (a *N5GCIndication) GetN5GCREG() (n5GCREG uint8) { + return a.Octet & GetBitMask(1, 0) } // N5GCIndication 9.11.3.72 -// N5GCIValue Row, sBit, len = [0, 0], 4 , 4 -func (a *N5GCIndication) SetN5GCIValue(n5GCIValue uint8) { - a.Octet = (a.Octet & 240) + (n5GCIValue & 15) +// N5GCREG Row, sBit, len = [0, 0], 1 , 1 +func (a *N5GCIndication) SetN5GCREG(n5GCREG uint8) { + a.Octet = (a.Octet & 0xFE) | (n5GCREG & 0x01) } diff --git a/nasType/NAS_Non3GPPAccessPathSwitchingIndication.go b/nasType/NAS_Non3GPPAccessPathSwitchingIndication.go index 71fcc4b8..7155186d 100644 --- a/nasType/NAS_Non3GPPAccessPathSwitchingIndication.go +++ b/nasType/NAS_Non3GPPAccessPathSwitchingIndication.go @@ -6,7 +6,7 @@ package nasType // Non3GPPAccessPathSwitchingIndication 9.11.3.99 // Iei Row, sBit, len = [], 8, 8 // Len Row, sBit, len = [], 8, 8 -// NAPSI Row, sBit, len = [0, 0], 1 , 1 +// NAPS Row, sBit, len = [0, 0], 1 , 1 type Non3GPPAccessPathSwitchingIndication struct { Iei uint8 Len uint8 @@ -23,10 +23,10 @@ func (a *Non3GPPAccessPathSwitchingIndication) GetIei() (iei uint8) { return a.I func (a *Non3GPPAccessPathSwitchingIndication) SetIei(iei uint8) { a.Iei = iei } func (a *Non3GPPAccessPathSwitchingIndication) GetLen() (len uint8) { return a.Len } func (a *Non3GPPAccessPathSwitchingIndication) SetLen(len uint8) { a.Len = len } -func (a *Non3GPPAccessPathSwitchingIndication) GetNAPSI() uint8 { +func (a *Non3GPPAccessPathSwitchingIndication) GetNAPS() uint8 { return a.Octet & GetBitMask(1, 0) } -func (a *Non3GPPAccessPathSwitchingIndication) SetNAPSI(napsi uint8) { - a.Octet = (a.Octet & 0xFE) | (napsi & 0x01) +func (a *Non3GPPAccessPathSwitchingIndication) SetNAPS(naps uint8) { + a.Octet = (a.Octet & 0xFE) | (naps & 0x01) } diff --git a/nasType/NAS_Non3GPPNWProvidedPolicies.go b/nasType/NAS_Non3GPPNWProvidedPolicies.go index e5cf156d..16f0a10b 100644 --- a/nasType/NAS_Non3GPPNWProvidedPolicies.go +++ b/nasType/NAS_Non3GPPNWProvidedPolicies.go @@ -5,7 +5,7 @@ package nasType // Non3GPPNWProvidedPolicies 9.11.3.36A // Iei Row, sBit, len = [0, 0], 8 , 4 -// Non3GPPNWProvidedPoliciesValue Row, sBit, len = [0, 0], 4 , 4 +// Value Row, sBit, len = [0, 0], 4 , 4 type Non3GPPNWProvidedPolicies struct { Octet uint8 } diff --git a/nasType/NAS_PartiallyAllowedNSSAI.go b/nasType/NAS_PartiallyAllowedNSSAI.go index ebe654db..b75d8e73 100644 --- a/nasType/NAS_PartiallyAllowedNSSAI.go +++ b/nasType/NAS_PartiallyAllowedNSSAI.go @@ -3,11 +3,11 @@ package nasType -// PartiallyAllowedNSSAI 9.11.3.37 +// PartiallyAllowedNSSAI 9.11.3.103 // SNSSAIValue Row, sBit, len = [0, 0], 0 , INF type PartiallyAllowedNSSAI struct { Iei uint8 - Len uint8 + Len uint16 Buffer []uint8 } @@ -17,10 +17,10 @@ func NewPartiallyAllowedNSSAI(iei uint8) (x *PartiallyAllowedNSSAI) { return x } -func (a *PartiallyAllowedNSSAI) GetIei() (iei uint8) { return a.Iei } -func (a *PartiallyAllowedNSSAI) SetIei(iei uint8) { a.Iei = iei } -func (a *PartiallyAllowedNSSAI) GetLen() (len uint8) { return a.Len } -func (a *PartiallyAllowedNSSAI) SetLen(len uint8) { +func (a *PartiallyAllowedNSSAI) GetIei() (iei uint8) { return a.Iei } +func (a *PartiallyAllowedNSSAI) SetIei(iei uint8) { a.Iei = iei } +func (a *PartiallyAllowedNSSAI) GetLen() (len uint16) { return a.Len } +func (a *PartiallyAllowedNSSAI) SetLen(len uint16) { a.Len = len a.Buffer = make([]uint8, a.Len) } diff --git a/nasType/NAS_PartiallyRejectedNSSAI.go b/nasType/NAS_PartiallyRejectedNSSAI.go index 0d6e0611..435b62f7 100644 --- a/nasType/NAS_PartiallyRejectedNSSAI.go +++ b/nasType/NAS_PartiallyRejectedNSSAI.go @@ -3,11 +3,11 @@ package nasType -// PartiallyRejectedNSSAI 9.11.3.37 +// PartiallyRejectedNSSAI 9.11.3.103 // SNSSAIValue Row, sBit, len = [0, 0], 0 , INF type PartiallyRejectedNSSAI struct { Iei uint8 - Len uint8 + Len uint16 Buffer []uint8 } @@ -17,10 +17,10 @@ func NewPartiallyRejectedNSSAI(iei uint8) (x *PartiallyRejectedNSSAI) { return x } -func (a *PartiallyRejectedNSSAI) GetIei() (iei uint8) { return a.Iei } -func (a *PartiallyRejectedNSSAI) SetIei(iei uint8) { a.Iei = iei } -func (a *PartiallyRejectedNSSAI) GetLen() (len uint8) { return a.Len } -func (a *PartiallyRejectedNSSAI) SetLen(len uint8) { +func (a *PartiallyRejectedNSSAI) GetIei() (iei uint8) { return a.Iei } +func (a *PartiallyRejectedNSSAI) SetIei(iei uint8) { a.Iei = iei } +func (a *PartiallyRejectedNSSAI) GetLen() (len uint16) { return a.Len } +func (a *PartiallyRejectedNSSAI) SetLen(len uint16) { a.Len = len a.Buffer = make([]uint8, a.Len) } diff --git a/nasType/NAS_PayloadContainerInformation.go b/nasType/NAS_PayloadContainerInformation.go index 2e343d0d..10d0b637 100644 --- a/nasType/NAS_PayloadContainerInformation.go +++ b/nasType/NAS_PayloadContainerInformation.go @@ -5,7 +5,7 @@ package nasType // PayloadContainerInformation 9.11.3.106 // Iei Row, sBit, len = [0, 0], 8 , 4 -// Value Row, sBit, len = [0, 0], 4 , 4 +// PRU Row, sBit, len = [0, 0], 1 , 1 type PayloadContainerInformation struct { Octet uint8 } @@ -24,10 +24,10 @@ func (a *PayloadContainerInformation) SetIei(iei uint8) { a.Octet = (a.Octet & 0x0F) | ((iei & 0x0F) << 4) } -func (a *PayloadContainerInformation) GetValue() uint8 { - return a.Octet & GetBitMask(4, 0) +func (a *PayloadContainerInformation) GetPRU() uint8 { + return a.Octet & GetBitMask(1, 0) } -func (a *PayloadContainerInformation) SetValue(v uint8) { - a.Octet = (a.Octet & 0xF0) | (v & 0x0F) +func (a *PayloadContainerInformation) SetPRU(pru uint8) { + a.Octet = (a.Octet & 0xFE) | (pru & 0x01) } diff --git a/nasType/NAS_PriorityIndicator.go b/nasType/NAS_PriorityIndicator.go index eb817a90..c3a274a3 100644 --- a/nasType/NAS_PriorityIndicator.go +++ b/nasType/NAS_PriorityIndicator.go @@ -5,7 +5,7 @@ package nasType // PriorityIndicator 9.11.3.91 // Iei Row, sBit, len = [0, 0], 8 , 4 -// MPP Row, sBit, len = [0, 0], 1 , 1 +// MPSI Row, sBit, len = [0, 0], 1 , 1 type PriorityIndicator struct { Octet uint8 } @@ -24,10 +24,10 @@ func (a *PriorityIndicator) SetIei(iei uint8) { a.Octet = (a.Octet & 0x0F) | ((iei & 0x0F) << 4) } -func (a *PriorityIndicator) GetMPP() (mpp uint8) { +func (a *PriorityIndicator) GetMPSI() (mpsi uint8) { return a.Octet & GetBitMask(1, 0) } -func (a *PriorityIndicator) SetMPP(mpp uint8) { - a.Octet = (a.Octet & 0xFE) | (mpp & 0x01) +func (a *PriorityIndicator) SetMPSI(mpsi uint8) { + a.Octet = (a.Octet & 0xFE) | (mpsi & 0x01) } diff --git a/nasType/NAS_ReAttemptIndicator.go b/nasType/NAS_ReAttemptIndicator.go index ec0e7768..0d5fd128 100644 --- a/nasType/NAS_ReAttemptIndicator.go +++ b/nasType/NAS_ReAttemptIndicator.go @@ -24,12 +24,12 @@ func (a *ReAttemptIndicator) GetIei() (iei uint8) { return a.Iei } func (a *ReAttemptIndicator) SetIei(iei uint8) { a.Iei = iei } func (a *ReAttemptIndicator) GetLen() (len uint8) { return a.Len } func (a *ReAttemptIndicator) SetLen(len uint8) { a.Len = len } -func (a *ReAttemptIndicator) GetRATAC() uint8 { +func (a *ReAttemptIndicator) GetRATC() uint8 { return a.Octet & GetBitMask(2, 1) >> 1 } -func (a *ReAttemptIndicator) SetRATAC(ratac uint8) { - a.Octet = (a.Octet & 253) + ((ratac & 1) << 1) +func (a *ReAttemptIndicator) SetRATC(ratc uint8) { + a.Octet = (a.Octet & 253) + ((ratc & 1) << 1) } func (a *ReAttemptIndicator) GetEPLMNC() uint8 { diff --git a/nasType/NAS_UpdatedPEIPSAssistanceInformation.go b/nasType/NAS_UpdatedPEIPSAssistanceInformation.go index 6514cf89..d0f2ad9a 100644 --- a/nasType/NAS_UpdatedPEIPSAssistanceInformation.go +++ b/nasType/NAS_UpdatedPEIPSAssistanceInformation.go @@ -3,7 +3,7 @@ package nasType -// UpdatedPEIPSAssistanceInformation 9.11.3.x +// UpdatedPEIPSAssistanceInformation 9.11.3.80 type UpdatedPEIPSAssistanceInformation struct { Iei uint8 Len uint8