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 dcf84ab..3ebd689 100644 (file)
--- a/e2ap/pkg/e2ap_wrapper/packer_e2ap.go
+++ b/e2ap/pkg/e2ap_wrapper/packer_e2ap.go
@@ -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"
 
@@ -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 {
@@ -855,15 +856,9 @@ func (e2apMsg *e2apMsgPackerSubscriptionFailure) String() string {
        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].cause.content =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content)
-               fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].cause.causeVal =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal)
-               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)
@@ -1115,15 +1110,105 @@ 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("Setting ASN1 debug prints ON")
+               //fmt.Println("ASN1 debug prints ON")
                C.allowASN1DebugPrints(true)
        } else {
-               fmt.Println("Setting ASN1 debug prints OFF")
+               //fmt.Println("ASN1 debug prints OFF")
                C.allowASN1DebugPrints(false)
        }
 }
@@ -1158,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{}
 }