RSM/converters/resource_status_failure_unpacker.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 //  This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19 //  platform project (RICP).
  20
  21 package converters
  22
  23 // #cgo CFLAGS: -I../3rdparty/asn1codec/inc/ -I../3rdparty/asn1codec/e2ap_engine/
  24 // #cgo LDFLAGS: -L ../3rdparty/asn1codec/lib/ -L../3rdparty/asn1codec/e2ap_engine/ -le2ap_codec -lasncodec
  25 // #include <asn1codec_utils.h>
  26 // #include <resource_status_response_wrapper.h>
  27 import "C"
  28 import (
  29         "fmt"
  30         "rsm/models"
  31         "unsafe"
  32 )
  33
  34 type ResourceStatusFailureConverter struct {
  35         X2apPduUnpacker
  36 }
  37
  38 func NewResourceStatusFailureConverter(unpacker X2apPduUnpacker) ResourceStatusFailureConverter {
  39         return ResourceStatusFailureConverter{unpacker}
  40 }
  41
  42 func convertCompleteFailureCauseInformation(completeFailureCauseInformation_List *C.CompleteFailureCauseInformation_List_t) ([]*models.MeasurementInitiationResult, error) {
  43         var measurementInitiationResults []*models.MeasurementInitiationResult
  44
  45         count := int(completeFailureCauseInformation_List.list.count)
  46         if count < 1 || count > maxCellineNB {
  47                 return nil, fmt.Errorf("invalid number of complete failure cause information elements, %d", count)
  48         }
  49         completeFailureCauseInformation_ItemIEs_slice := (*[1 << 30]*C.CompleteFailureCauseInformation_ItemIEs_t)(unsafe.Pointer(completeFailureCauseInformation_List.list.array))[:count:count]
  50         for _, itemIE := range completeFailureCauseInformation_ItemIEs_slice {
  51
  52                 switch itemIE.value.present {
  53                 case C.CompleteFailureCauseInformation_ItemIEs__value_PR_CompleteFailureCauseInformation_Item:
  54                         item := (*C.CompleteFailureCauseInformation_Item_t)(unsafe.Pointer(&itemIE.value.choice[0]))
  55                         measurementInitiationResult := models.MeasurementInitiationResult{CellId: buildCellId(item.cell_ID)}
  56                         if err:=convertMeasurementFailureCauses(&item.measurementFailureCause_List, &measurementInitiationResult); err != nil {
  57                                 return nil, err
  58                         }
  59                         measurementInitiationResults = append(measurementInitiationResults, &measurementInitiationResult)
  60                 }
  61         }
  62
  63         return measurementInitiationResults, nil
  64 }
  65
  66 func convertResourceFailureIEs(resourceStatusFailure *C.ResourceStatusFailure_t, response *models.ResourceStatusResponse) error {
  67         count := int(resourceStatusFailure.protocolIEs.list.count)
  68         resourceStatusFailure_IEs_slice := (*[1 << 30]*C.ResourceStatusFailure_IEs_t)(unsafe.Pointer(resourceStatusFailure.protocolIEs.list.array))[:count:count]
  69         for _, resourceStatusFailure_IEs := range resourceStatusFailure_IEs_slice {
  70                 switch resourceStatusFailure_IEs.value.present {
  71                 case C.ResourceStatusFailure_IEs__value_PR_Measurement_ID:
  72                         measurement_ID := (*C.Measurement_ID_t)(unsafe.Pointer(&resourceStatusFailure_IEs.value.choice[0]))
  73                         if resourceStatusFailure_IEs.id == C.ProtocolIE_ID_id_ENB1_Measurement_ID {
  74                                 response.ENB1_Measurement_ID = int64(*measurement_ID)
  75                         }
  76                         if resourceStatusFailure_IEs.id == C.ProtocolIE_ID_id_ENB2_Measurement_ID {
  77                                 response.ENB2_Measurement_ID = int64(*measurement_ID)
  78                         }
  79                 case C.ResourceStatusFailure_IEs__value_PR_CriticalityDiagnostics:
  80                         /*ignored*/
  81                 case C.ResourceStatusFailure_IEs__value_PR_Cause:
  82                         /*ignored*/
  83                 case C.ResourceStatusFailure_IEs__value_PR_CompleteFailureCauseInformation_List:
  84                         measurementInitiationResults, err := convertCompleteFailureCauseInformation((*C.CompleteFailureCauseInformation_List_t)(unsafe.Pointer(&resourceStatusFailure_IEs.value.choice[0])))
  85                         if err != nil {
  86                                 return err
  87                         }
  88                         response.MeasurementInitiationResults = measurementInitiationResults
  89                 }
  90         }
  91         return nil
  92 }
  93
  94 func convertResourceStatusFailure(pdu *C.E2AP_PDU_t) (*models.ResourceStatusResponse, error) {
  95         response := models.ResourceStatusResponse{}
  96
  97         if pdu.present != C.E2AP_PDU_PR_unsuccessfulOutcome {
  98                 return &response, fmt.Errorf("unexpected PDU, %d", int(pdu.present))
  99         }
 100
 101         //dereference a union of pointers (C union is represented as a byte array with the size of the largest member)
 102         unsuccessfulOutcome := *(**C.UnsuccessfulOutcome_t)(unsafe.Pointer(&pdu.choice[0]))
 103         if unsuccessfulOutcome == nil || unsuccessfulOutcome.value.present != C.UnsuccessfulOutcome__value_PR_ResourceStatusFailure {
 104                 return &response, fmt.Errorf("unexpected PDU - not a resource status failure")
 105         }
 106
 107         resourceStatusFailure := (*C.ResourceStatusFailure_t)(unsafe.Pointer(&unsuccessfulOutcome.value.choice[0]))
 108         if resourceStatusFailure.protocolIEs.list.count == 0 {
 109                 return &response, fmt.Errorf("unexpected PDU - no protocolIEs found")
 110         }
 111
 112         if err := convertResourceFailureIEs(resourceStatusFailure, &response); err != nil {
 113                 return &response, err
 114         }
 115
 116         return &response, nil
 117 }
 118
 119 // Convert pdu to public ResourceStatusResponse
 120 func (r ResourceStatusFailureConverter) Convert(packedBuf []byte) (*models.ResourceStatusResponse, error) {
 121         pdu, err := r.UnpackX2apPdu(packedBuf)
 122         if err != nil {
 123                 return nil, err
 124         }
 125
 126         defer C.delete_pdu(pdu)
 127         return convertResourceStatusFailure(pdu)
 128 }