RIC-851: Updated submgr to trigger Delete Subscription Procedure

[ric-plt/submgr.git] / e2ap / pkg / e2ap_wrapper / packer_e2ap.go

diff --git a/e2ap/pkg/e2ap_wrapper/packer_e2ap.go b/e2ap/pkg/e2ap_wrapper/packer_e2ap.go
index b01baeb..3ebd689 100644 (file)
--- a/e2ap/pkg/e2ap_wrapper/packer_e2ap.go
+++ b/e2ap/pkg/e2ap_wrapper/packer_e2ap.go
@@ -19,7 +19,7 @@
 
 package e2ap_wrapper
 
-// #cgo LDFLAGS: -le2ap_wrapper -le2ap -lstdc++
+// #cgo LDFLAGS: -le2ap_wrapper -le2ap  -lstdc++
 // #include <stdlib.h>
 // #include <c_types.h>
 // #include <E2AP_if.h>
@@ -43,6 +43,9 @@ package e2ap_wrapper
 // void initSubsDeleteFailure(RICSubscriptionDeleteFailure_t *data){
 //   bzero(data,sizeof(RICSubscriptionDeleteFailure_t));
 // }
+// void initSubsDeleteRequired(RICSubsDeleteRequired_t *data){
+//      bzero(data,sizeof(RICSubsDeleteRequired_t));
+// }
 //
 import "C"
 
@@ -97,7 +100,6 @@ func cMessageInfoToMessageInfo(minfo *C.E2MessageInfo_t) *e2ap.MessageInfo {
                        msgInfo.MsgId = e2ap.E2AP_RICSubscriptionDeleteFailure
                        return msgInfo
                }
-
        }
        return nil
 }
@@ -111,13 +113,13 @@ type e2apEntryRequestID struct {
 
 func (e2Item *e2apEntryRequestID) set(id *e2ap.RequestId) error {
        e2Item.entry.ricRequestorID = (C.uint32_t)(id.Id)
-       e2Item.entry.ricRequestSequenceNumber = (C.uint32_t)(id.Seq)
+       e2Item.entry.ricInstanceID = (C.uint32_t)(id.InstanceId)
        return nil
 }
 
 func (e2Item *e2apEntryRequestID) get(id *e2ap.RequestId) error {
        id.Id = (uint32)(e2Item.entry.ricRequestorID)
-       id.Seq = (uint32)(e2Item.entry.ricRequestSequenceNumber)
+       id.InstanceId = (uint32)(e2Item.entry.ricInstanceID)
        return nil
 }
 
@@ -132,14 +134,12 @@ func (e2Item *e2apEntryActionToBeSetupItem) set(id *e2ap.ActionToBeSetupItem) er
 
        e2Item.entry.ricActionID = (C.ulong)(id.ActionId)
        e2Item.entry.ricActionType = (C.uint64_t)(id.ActionType)
-
-       if id.ActionDefinition.Present {
+       if id.RicActionDefinitionPresent {
                e2Item.entry.ricActionDefinitionPresent = true
-               e2Item.entry.ricActionDefinition.styleID = (C.uint64_t)(id.ActionDefinition.StyleId)
-               e2Item.entry.ricActionDefinition.sequenceOfActionParameters.parameterID = (C.uint32_t)(id.ActionDefinition.ParamId)
-               //e2Item.entry.ricActionDefinition.sequenceOfActionParameters.ParameterValue = id.ActionDefinition.ParamValue
+               if err := (&e2apEntryActionDefinitionChoice{entry: &e2Item.entry.ricActionDefinitionChoice}).set(&id.ActionDefinitionChoice); err != nil {
+                       return err
+               }
        }
-
        if id.SubsequentAction.Present {
                e2Item.entry.ricSubsequentActionPresent = true
                e2Item.entry.ricSubsequentAction.ricSubsequentActionType = (C.uint64_t)(id.SubsequentAction.Type)
@@ -152,14 +152,12 @@ func (e2Item *e2apEntryActionToBeSetupItem) get(id *e2ap.ActionToBeSetupItem) er
 
        id.ActionId = (uint64)(e2Item.entry.ricActionID)
        id.ActionType = (uint64)(e2Item.entry.ricActionType)
-
        if e2Item.entry.ricActionDefinitionPresent {
-               id.ActionDefinition.Present = true
-               id.ActionDefinition.StyleId = (uint64)(e2Item.entry.ricActionDefinition.styleID)
-               id.ActionDefinition.ParamId = (uint32)(e2Item.entry.ricActionDefinition.sequenceOfActionParameters.parameterID)
-               //id.ActionDefinition.ParamValue=e2Item.entry.ricActionDefinition.sequenceOfActionParameters.ParameterValue
+               id.RicActionDefinitionPresent = true
+               if err := (&e2apEntryActionDefinitionChoice{entry: &e2Item.entry.ricActionDefinitionChoice}).get(&id.ActionDefinitionChoice); err != nil {
+                       return err
+               }
        }
-
        if e2Item.entry.ricSubsequentActionPresent {
                id.SubsequentAction.Present = true
                id.SubsequentAction.Type = (uint64)(e2Item.entry.ricSubsequentAction.ricSubsequentActionType)
@@ -168,6 +166,30 @@ func (e2Item *e2apEntryActionToBeSetupItem) get(id *e2ap.ActionToBeSetupItem) er
        return nil
 }
 
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+type e2apEntryActionDefinitionChoice struct {
+       entry *C.RICActionDefinitionChoice_t
+}
+
+func (e2Item *e2apEntryActionDefinitionChoice) set(id *e2ap.ActionDefinitionChoice) error {
+       if id.Data.Length > 0 {
+               e2Item.entry.octetString.contentLength = C.size_t(id.Data.Length)
+               C.memcpy(unsafe.Pointer(&e2Item.entry.octetString.data[0]), unsafe.Pointer(&id.Data.Data[0]), C.size_t(e2Item.entry.octetString.contentLength))
+       }
+       return nil
+}
+
+func (e2Item *e2apEntryActionDefinitionChoice) get(id *e2ap.ActionDefinitionChoice) error {
+       id.Data.Length = (uint64)(e2Item.entry.octetString.contentLength)
+       if id.Data.Length > 0 {
+               id.Data.Data = make([]uint8, id.Data.Length)
+               C.memcpy(unsafe.Pointer(&id.Data.Data[0]), unsafe.Pointer(&e2Item.entry.octetString.data[0]), C.size_t(e2Item.entry.octetString.contentLength))
+       }
+       return nil
+}
+
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
@@ -175,22 +197,26 @@ type e2apEntryPlmnIdentity struct {
        entry *C.PLMNIdentity_t
 }
 
-func (plmnId *e2apEntryPlmnIdentity) set(id *conv.PlmnIdentity) error {
+func (plmnId *e2apEntryPlmnIdentity) set(id conv.PlmnIdentityIf) error {
 
-       plmnId.entry.contentLength = (C.uint8_t)(len(id.Val))
-       for i := 0; i < len(id.Val); i++ {
-               plmnId.entry.pLMNIdentityVal[i] = (C.uint8_t)(id.Val[i])
+       buf := new(bytes.Buffer)
+       id.EncodeTo(buf)
+       data := buf.Bytes()
+       plmnId.entry.contentLength = (C.uint8_t)(len(data))
+       for i := 0; i < len(data); i++ {
+               plmnId.entry.pLMNIdentityVal[i] = (C.uint8_t)(data[i])
        }
        return nil
 }
 
-func (plmnId *e2apEntryPlmnIdentity) get(id *conv.PlmnIdentity) error {
+func (plmnId *e2apEntryPlmnIdentity) get(id conv.PlmnIdentityIf) error {
        conlen := (int)(plmnId.entry.contentLength)
        bcdBuf := make([]uint8, conlen)
        for i := 0; i < conlen; i++ {
                bcdBuf[i] = (uint8)(plmnId.entry.pLMNIdentityVal[i])
        }
-       id.BcdPut(bcdBuf)
+       reader := bytes.NewReader(bcdBuf)
+       id.DecodeFrom(reader)
        return nil
 }
 
@@ -314,17 +340,22 @@ type e2apEntryEventTrigger struct {
 }
 
 func (evtTrig *e2apEntryEventTrigger) set(id *e2ap.EventTriggerDefinition) error {
-       evtTrig.entry.interfaceDirection = (C.uint8_t)(id.InterfaceDirection)
-       evtTrig.entry.interfaceMessageType.procedureCode = (C.uint8_t)(id.ProcedureCode)
-       evtTrig.entry.interfaceMessageType.typeOfMessage = (C.uint8_t)(id.TypeOfMessage)
-       return (&e2apEntryInterfaceId{entry: &evtTrig.entry.interfaceID}).set(&id.InterfaceId)
+
+       if id.Data.Length > 0 {
+               evtTrig.entry.octetString.contentLength = C.size_t(id.Data.Length)
+               C.memcpy(unsafe.Pointer(&evtTrig.entry.octetString.data[0]), unsafe.Pointer(&id.Data.Data[0]), C.size_t(evtTrig.entry.octetString.contentLength))
+       }
+       return nil
 }
 
 func (evtTrig *e2apEntryEventTrigger) get(id *e2ap.EventTriggerDefinition) error {
-       id.InterfaceDirection = (uint32)(evtTrig.entry.interfaceDirection)
-       id.ProcedureCode = (uint32)(evtTrig.entry.interfaceMessageType.procedureCode)
-       id.TypeOfMessage = (uint64)(evtTrig.entry.interfaceMessageType.typeOfMessage)
-       return (&e2apEntryInterfaceId{entry: &evtTrig.entry.interfaceID}).get(&id.InterfaceId)
+
+       id.Data.Length = (uint64)(evtTrig.entry.octetString.contentLength)
+       if id.Data.Length > 0 {
+               id.Data.Data = make([]uint8, id.Data.Length)
+               C.memcpy(unsafe.Pointer(&id.Data.Data[0]), unsafe.Pointer(&evtTrig.entry.octetString.data[0]), C.size_t(evtTrig.entry.octetString.contentLength))
+       }
+       return nil
 }
 
 //-----------------------------------------------------------------------------
@@ -373,8 +404,8 @@ func (item *e2apEntryNotAdmittedList) set(data *e2ap.ActionNotAdmittedList) erro
        item.entry.contentLength = 0
        for i := 0; i < len(data.Items); i++ {
                item.entry.RICActionNotAdmittedItem[item.entry.contentLength].ricActionID = (C.ulong)(data.Items[i].ActionId)
-               item.entry.RICActionNotAdmittedItem[item.entry.contentLength].ricCause.content = (C.uchar)(data.Items[i].Cause.Content)
-               item.entry.RICActionNotAdmittedItem[item.entry.contentLength].ricCause.cause = (C.uchar)(data.Items[i].Cause.CauseVal)
+               item.entry.RICActionNotAdmittedItem[item.entry.contentLength].cause.content = (C.uchar)(data.Items[i].Cause.Content)
+               item.entry.RICActionNotAdmittedItem[item.entry.contentLength].cause.causeVal = (C.uchar)(data.Items[i].Cause.Value)
                item.entry.contentLength++
        }
 
@@ -386,8 +417,8 @@ func (item *e2apEntryNotAdmittedList) get(data *e2ap.ActionNotAdmittedList) erro
        data.Items = make([]e2ap.ActionNotAdmittedItem, conlen)
        for i := 0; i < conlen; i++ {
                data.Items[i].ActionId = (uint64)(item.entry.RICActionNotAdmittedItem[i].ricActionID)
-               data.Items[i].Cause.Content = (uint8)(item.entry.RICActionNotAdmittedItem[i].ricCause.content)
-               data.Items[i].Cause.CauseVal = (uint8)(item.entry.RICActionNotAdmittedItem[i].ricCause.cause)
+               data.Items[i].Cause.Content = (uint8)(item.entry.RICActionNotAdmittedItem[i].cause.content)
+               data.Items[i].Cause.Value = (uint8)(item.entry.RICActionNotAdmittedItem[i].cause.causeVal)
        }
        return nil
 }
@@ -559,6 +590,7 @@ func (e2apMsg *e2apMsgPackerSubscriptionRequest) init() {
 func (e2apMsg *e2apMsgPackerSubscriptionRequest) Pack(data *e2ap.E2APSubscriptionRequest) (error, *e2ap.PackedData) {
 
        e2apMsg.init()
+
        defer e2apMsg.fini()
        e2apMsg.msgG = data
 
@@ -566,21 +598,20 @@ func (e2apMsg *e2apMsgPackerSubscriptionRequest) Pack(data *e2ap.E2APSubscriptio
        if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
                return err, nil
        }
-       if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition}).set(&e2apMsg.msgG.EventTriggerDefinition); err != nil {
+       if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition}).set(&e2apMsg.msgG.EventTriggerDefinition); err != nil {
                return err, nil
        }
        if len(e2apMsg.msgG.ActionSetups) > 16 {
                return fmt.Errorf("IndicationMessage.InterfaceMessage: too long %d while allowed %d", len(e2apMsg.msgG.ActionSetups), 16), nil
        }
-       e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength = 0
+       e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength = 0
        for i := 0; i < len(e2apMsg.msgG.ActionSetups); i++ {
-               item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength]}
-               e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength += 1
+               item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength]}
+               e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength += 1
                if err := item.set(&e2apMsg.msgG.ActionSetups[i]); err != nil {
                        return err, nil
                }
        }
-
        errorNro := C.packRICSubscriptionRequest(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
        if err := e2apMsg.checkerr(errorNro); err != nil {
                return err, nil
@@ -596,6 +627,7 @@ func (e2apMsg *e2apMsgPackerSubscriptionRequest) UnPack(msg *e2ap.PackedData) (e
        if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
                return err, e2apMsg.msgG
        }
+
        errorNro := C.getRICSubscriptionRequestData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
        if err := e2apMsg.checkerr(errorNro); err != nil {
                return err, e2apMsg.msgG
@@ -605,13 +637,13 @@ func (e2apMsg *e2apMsgPackerSubscriptionRequest) UnPack(msg *e2ap.PackedData) (e
        if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
                return err, e2apMsg.msgG
        }
-       if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition}).get(&e2apMsg.msgG.EventTriggerDefinition); err != nil {
+       if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition}).get(&e2apMsg.msgG.EventTriggerDefinition); err != nil {
                return err, e2apMsg.msgG
        }
-       conlen := (int)(e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength)
+       conlen := (int)(e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength)
        e2apMsg.msgG.ActionSetups = make([]e2ap.ActionToBeSetupItem, conlen)
        for i := 0; i < conlen; i++ {
-               item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[i]}
+               item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[i]}
                if err := item.get(&e2apMsg.msgG.ActionSetups[i]); err != nil {
                        return err, e2apMsg.msgG
                }
@@ -625,50 +657,21 @@ func (e2apMsg *e2apMsgPackerSubscriptionRequest) String() string {
        fmt.Fprintln(&b, "ricSubscriptionRequest.")
        fmt.Fprintln(&b, "  ricRequestID.")
        fmt.Fprintln(&b, "     ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
-       fmt.Fprintln(&b, "     ricRequestSequenceNumber =", e2apMsg.msgC.ricRequestID.ricRequestSequenceNumber)
+       fmt.Fprintln(&b, "     ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
        fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
-       fmt.Fprintln(&b, "  ricSubscription.")
-       fmt.Fprintln(&b, "    ricEventTriggerDefinition.")
-       fmt.Fprintln(&b, "      contentLength =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.octetString.contentLength)
-       fmt.Fprintln(&b, "      interfaceID.globalENBIDPresent =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalENBIDPresent)
-       if e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalENBIDPresent {
-               fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.contentLength =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.contentLength)
-               fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[0] =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[0])
-               fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[1] =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[1])
-               fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[2] =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[2])
-               fmt.Fprintln(&b, "      interfaceID.globalENBID.nodeID.bits =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalENBID.nodeID.bits)
-               fmt.Fprintln(&b, "      interfaceID.globalENBID.nodeID.nodeID =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID)
-       }
-       fmt.Fprintln(&b, "      interfaceID.globalGNBIDPresent =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalGNBIDPresent)
-       if e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalGNBIDPresent {
-               fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.contentLength =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.contentLength)
-               fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[0] =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[0])
-               fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[1] =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[1])
-               fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[2] =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[2])
-               fmt.Fprintln(&b, "      interfaceID.globalGNBID.nodeID.bits =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalGNBID.nodeID.bits)
-               fmt.Fprintln(&b, "      interfaceID.globalGNBID.nodeID.nodeID =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceID.globalGNBID.nodeID.nodeID)
-       }
-       fmt.Fprintln(&b, "      interfaceDirection= ", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceDirection)
-       fmt.Fprintln(&b, "      interfaceMessageType.procedureCode =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceMessageType.procedureCode)
-       fmt.Fprintln(&b, "      interfaceMessageType.typeOfMessage =", e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition.interfaceMessageType.typeOfMessage)
+       fmt.Fprintln(&b, "  ricSubscriptionDetails.")
        fmt.Fprintln(&b, "    ricActionToBeSetupItemIEs.")
-       fmt.Fprintln(&b, "      contentLength =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength)
+       fmt.Fprintln(&b, "      contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength)
        var index uint8
        index = 0
-       for (C.uchar)(index) < e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength {
-               fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionID =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID)
-               fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionType =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType)
-
-               fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionPresent =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent)
-               if e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent {
-                       fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinition.styleID =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinition.styleID)
-                       fmt.Fprintln(&b, "      ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinition.sequenceOfActionParameters.parameterID =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinition.sequenceOfActionParameters.parameterID)
-               }
-
-               fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentActionPresent =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent)
-               if e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent {
-                       fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType)
-                       fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait =", e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait)
+       for (C.uchar)(index) < e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength {
+               fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionID =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID)
+               fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionType =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType)
+               fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent)
+               fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentActionPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent)
+               if e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent {
+                       fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType)
+                       fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait)
                }
                index++
        }
@@ -751,7 +754,7 @@ func (e2apMsg *e2apMsgPackerSubscriptionResponse) String() string {
        fmt.Fprintln(&b, "ricSubscriptionResponse.")
        fmt.Fprintln(&b, "  ricRequestID.")
        fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
-       fmt.Fprintln(&b, "    ricRequestSequenceNumber =", e2apMsg.msgC.ricRequestID.ricRequestSequenceNumber)
+       fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
        fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
        fmt.Fprintln(&b, "  ricActionAdmittedList.")
        fmt.Fprintln(&b, "    contentLength =", e2apMsg.msgC.ricActionAdmittedList.contentLength)
@@ -768,8 +771,8 @@ func (e2apMsg *e2apMsgPackerSubscriptionResponse) String() string {
                index = 0
                for (C.uchar)(index) < e2apMsg.msgC.ricActionNotAdmittedList.contentLength {
                        fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].ricActionID =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID)
-                       fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].ricCause.content =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricCause.content)
-                       fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].ricCause.cause =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricCause.cause)
+                       fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].cause.content =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content)
+                       fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].cause.causeVal =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal)
                        index++
                }
        }
@@ -801,9 +804,8 @@ func (e2apMsg *e2apMsgPackerSubscriptionFailure) Pack(data *e2ap.E2APSubscriptio
        if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
                return err, nil
        }
-       if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).set(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
-               return err, nil
-       }
+       e2apMsg.msgC.cause.content = (C.uchar)(e2apMsg.msgG.Cause.Content)
+       e2apMsg.msgC.cause.causeVal = (C.uchar)(e2apMsg.msgG.Cause.Value)
        e2apMsg.msgC.criticalityDiagnosticsPresent = false
        if e2apMsg.msgG.CriticalityDiagnostics.Present {
                e2apMsg.msgC.criticalityDiagnosticsPresent = true
@@ -835,9 +837,8 @@ func (e2apMsg *e2apMsgPackerSubscriptionFailure) UnPack(msg *e2ap.PackedData) (e
        if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
                return err, e2apMsg.msgG
        }
-       if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).get(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
-               return err, e2apMsg.msgG
-       }
+       e2apMsg.msgG.Cause.Content = (uint8)(e2apMsg.msgC.cause.content)
+       e2apMsg.msgG.Cause.Value = (uint8)(e2apMsg.msgC.cause.causeVal)
        if e2apMsg.msgC.criticalityDiagnosticsPresent == true {
                e2apMsg.msgG.CriticalityDiagnostics.Present = true
                if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).get(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
@@ -852,18 +853,12 @@ func (e2apMsg *e2apMsgPackerSubscriptionFailure) String() string {
        fmt.Fprintln(&b, "ricSubscriptionFailure.")
        fmt.Fprintln(&b, "  ricRequestID.")
        fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
-       fmt.Fprintln(&b, "    ricRequestSequenceNumber =", e2apMsg.msgC.ricRequestID.ricRequestSequenceNumber)
+       fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
        fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
        fmt.Fprintln(&b, "  ricActionNotAdmittedList.")
-       fmt.Fprintln(&b, "    contentLength =", e2apMsg.msgC.ricActionNotAdmittedList.contentLength)
-       var index uint8
-       index = 0
-       for (C.uchar)(index) < e2apMsg.msgC.ricActionNotAdmittedList.contentLength {
-               fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].ricActionID =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID)
-               fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].ricCause.content =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricCause.content)
-               fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].ricCause.cause =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricCause.cause)
-               index++
-       }
+       fmt.Fprintln(&b, "    cause.content =", e2apMsg.msgC.cause.content)
+       fmt.Fprintln(&b, "    cause.causeVal =", e2apMsg.msgC.cause.causeVal)
+
        /* NOT SUPPORTED
        if e2apMsg.msgC.criticalityDiagnosticsPresent {
                fmt.Fprintln(&b, "  criticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnosticsPresent)
@@ -947,7 +942,7 @@ func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) String() string {
        fmt.Fprintln(&b, "ricSubscriptionDeleteRequest.")
        fmt.Fprintln(&b, "  ricRequestID.")
        fmt.Fprintln(&b, "     ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
-       fmt.Fprintln(&b, "     ricRequestSequenceNumber =", e2apMsg.msgC.ricRequestID.ricRequestSequenceNumber)
+       fmt.Fprintln(&b, "     ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
        fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
        return b.String()
 }
@@ -1009,7 +1004,7 @@ func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) String() string {
        fmt.Fprintln(&b, "ricSubscriptionDeleteResponse.")
        fmt.Fprintln(&b, "  ricRequestID.")
        fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
-       fmt.Fprintln(&b, "    ricRequestSequenceNumber =", e2apMsg.msgC.ricRequestID.ricRequestSequenceNumber)
+       fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
        fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
        return b.String()
 }
@@ -1039,8 +1034,8 @@ func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) Pack(data *e2ap.E2APSubsc
        if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
                return err, nil
        }
-       e2apMsg.msgC.ricCause.content = (C.uchar)(e2apMsg.msgG.Cause.Content)
-       e2apMsg.msgC.ricCause.cause = (C.uchar)(e2apMsg.msgG.Cause.CauseVal)
+       e2apMsg.msgC.cause.content = (C.uchar)(e2apMsg.msgG.Cause.Content)
+       e2apMsg.msgC.cause.causeVal = (C.uchar)(e2apMsg.msgG.Cause.Value)
        e2apMsg.msgC.criticalityDiagnosticsPresent = false
        if e2apMsg.msgG.CriticalityDiagnostics.Present {
                e2apMsg.msgC.criticalityDiagnosticsPresent = true
@@ -1072,8 +1067,8 @@ func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) UnPack(msg *e2ap.PackedDa
        if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
                return err, e2apMsg.msgG
        }
-       e2apMsg.msgG.Cause.Content = (uint8)(e2apMsg.msgC.ricCause.content)
-       e2apMsg.msgG.Cause.CauseVal = (uint8)(e2apMsg.msgC.ricCause.cause)
+       e2apMsg.msgG.Cause.Content = (uint8)(e2apMsg.msgC.cause.content)
+       e2apMsg.msgG.Cause.Value = (uint8)(e2apMsg.msgC.cause.causeVal)
        if e2apMsg.msgC.criticalityDiagnosticsPresent == true {
                e2apMsg.msgG.CriticalityDiagnostics.Present = true
                if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).get(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
@@ -1088,7 +1083,7 @@ func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) String() string {
        fmt.Fprintln(&b, "ricSubscriptionDeleteFailure.")
        fmt.Fprintln(&b, "  ricRequestID.")
        fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
-       fmt.Fprintln(&b, "    ricRequestSequenceNumber =", e2apMsg.msgC.ricRequestID.ricRequestSequenceNumber)
+       fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
        fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
        /*      NOT SUPPORTED
                if e2apMsg.msgC.criticalityDiagnosticsPresent {
@@ -1115,6 +1110,109 @@ func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) String() string {
        return b.String()
 }
 
+//-----------------------------------------------------------------------------
+// Changes to support "RIC_SUB_DEL_REQUIRED"
+//-----------------------------------------------------------------------------
+type e2apMsgPackerSubscriptionDeleteRequired struct {
+       e2apMessagePacker
+       msgC *C.RICSubsDeleteRequired_t
+       msgG *e2ap.SubscriptionDeleteRequiredList
+}
+
+func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequired) init() {
+       e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2InitiatingMessage, C.cRICSubscriptionDeleteRequired})
+       e2apMsg.msgC = &C.RICSubsDeleteRequired_t{}
+       e2apMsg.msgG = &e2ap.SubscriptionDeleteRequiredList{}
+       C.initSubsDeleteRequired(e2apMsg.msgC)
+}
+
+func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequired) Pack(data *e2ap.SubscriptionDeleteRequiredList) (error, *e2ap.PackedData) {
+       e2apMsg.init()
+       defer e2apMsg.fini()
+       e2apMsg.msgG = data
+
+       e2apMsg.msgC.noOfRanSubscriptions = C.int(len(e2apMsg.msgG.E2APSubscriptionDeleteRequiredRequests))
+       for idx, subs := range e2apMsg.msgG.E2APSubscriptionDeleteRequiredRequests {
+
+               // RIC Request ID
+               e2apMsg.msgC.ranSubscriptionsDelRequired[idx].ricRequestID.ricInstanceID = (C.uint32_t)(subs.RequestId.InstanceId)
+               e2apMsg.msgC.ranSubscriptionsDelRequired[idx].ricRequestID.ricRequestorID = (C.uint32_t)(subs.RequestId.Id)
+
+               // RAN Function ID
+               e2apMsg.msgC.ranSubscriptionsDelRequired[idx].ranFunctionID = (C.uint16_t)(subs.FunctionId)
+
+               // RIC Cause
+               e2apMsg.msgC.ranSubscriptionsDelRequired[idx].cause.content = (C.uint8_t)(subs.Cause.Content)
+               e2apMsg.msgC.ranSubscriptionsDelRequired[idx].cause.causeVal = (C.uint8_t)(subs.Cause.Value)
+
+       }
+
+       errorNro := C.packRICSubscriptionDeleteRequired(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
+       if err := e2apMsg.checkerr(errorNro); err != nil {
+               fmt.Printf("ERROR: %s", err.Error())
+               return err, nil
+       }
+       return nil, e2apMsg.packeddata()
+}
+
+func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequired) UnPack(msg *e2ap.PackedData) (error, *e2ap.SubscriptionDeleteRequiredList) {
+       e2apMsg.init()
+       defer e2apMsg.fini()
+
+       if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
+               return err, e2apMsg.msgG
+       }
+       errorNro := C.getRICSubscriptionDeleteRequiredData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
+       if err := e2apMsg.checkerr(errorNro); err != nil {
+               return err, e2apMsg.msgG
+       }
+
+       //TODO: Fill List of RIC Subscriptions to be Removed
+       for idx := 0; idx < int(e2apMsg.msgC.noOfRanSubscriptions); idx++ {
+               var ricSubsToBeRemove e2ap.E2APSubscriptionDeleteRequired
+               // RIC RequestID
+               if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ranSubscriptionsDelRequired[idx].ricRequestID}).get(&ricSubsToBeRemove.RequestId); err != nil {
+                       return err, e2apMsg.msgG
+               }
+               // RAN Function ID
+               ricSubsToBeRemove.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranSubscriptionsDelRequired[idx].ranFunctionID)
+
+               // RIC Cause
+               ricSubsToBeRemove.Cause.Content = (uint8)(e2apMsg.msgC.ranSubscriptionsDelRequired[idx].cause.content)
+               ricSubsToBeRemove.Cause.Value = (uint8)(e2apMsg.msgC.ranSubscriptionsDelRequired[idx].cause.causeVal)
+
+               e2apMsg.msgG.E2APSubscriptionDeleteRequiredRequests = append(e2apMsg.msgG.E2APSubscriptionDeleteRequiredRequests, ricSubsToBeRemove)
+       }
+
+       return nil, e2apMsg.msgG
+}
+
+func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequired) String() string {
+       var b bytes.Buffer
+       for idx := 0; idx < int(e2apMsg.msgC.noOfRanSubscriptions); idx++ {
+               fmt.Fprintln(&b, "ricSubscriptionDeleteRequired.")
+               fmt.Fprintln(&b, "  ricRequestID.")
+               fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ranSubscriptionsDelRequired[idx].ricRequestID.ricRequestorID)
+               fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ranSubscriptionsDelRequired[idx].ricRequestID.ricInstanceID)
+               fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranSubscriptionsDelRequired[idx].ranFunctionID)
+       }
+
+       return b.String()
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func SetASN1DebugPrintStatus(logLevel int) {
+       if logLevel >= 4 {
+               //fmt.Println("ASN1 debug prints ON")
+               C.allowASN1DebugPrints(true)
+       } else {
+               //fmt.Println("ASN1 debug prints OFF")
+               C.allowASN1DebugPrints(false)
+       }
+}
+
 //-----------------------------------------------------------------------------
 // Public E2AP packer creators
 //-----------------------------------------------------------------------------
@@ -1145,6 +1243,11 @@ func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteFailure() e2ap.E2APMsgPacke
        return &e2apMsgPackerSubscriptionDeleteFailure{}
 }
 
+// Changes to support "RIC_SUB_DEL_REQUIRED"
+func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteRequired() e2ap.E2APMsgPackerSubscriptionDeleteRequiredIf {
+       return &e2apMsgPackerSubscriptionDeleteRequired{}
+}
+
 func NewAsn1E2Packer() e2ap.E2APPackerIf {
        return &cppasn1E2APPacker{}
 }