RSM/converters/resource_status_response_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 const (
  35         maxCellineNB         = 256
  36         maxFailedMeasObjects = 32
  37 )
  38
  39 type IResourceStatusResponseConverter interface {
  40         Convert(packedBuf []byte) (*models.ResourceStatusResponse, error)
  41         UnpackX2apPduAsString(packedBuf []byte, maxMessageBufferSize int) (string, error)
  42 }
  43
  44 type ResourceStatusResponseConverter struct {
  45         X2apPduUnpacker
  46 }
  47
  48 func NewResourceStatusResponseConverter(unpacker X2apPduUnpacker) ResourceStatusResponseConverter {
  49         return ResourceStatusResponseConverter{unpacker}
  50 }
  51
  52 func buildCellId(cellId C.ECGI_t) string {
  53         plmnId := C.GoBytes(unsafe.Pointer(cellId.pLMN_Identity.buf), C.int(cellId.pLMN_Identity.size))
  54         eutranCellIdentifier := C.GoBytes(unsafe.Pointer(cellId.eUTRANcellIdentifier.buf), C.int(cellId.eUTRANcellIdentifier.size))
  55         return fmt.Sprintf("%x:%x", plmnId, eutranCellIdentifier)
  56 }
  57
  58 func convertMeasurementFailureCauses(measurementFailureCause_List *C.MeasurementFailureCause_List_t, measurementInitiationResult *models.MeasurementInitiationResult) error {
  59         var MeasurementFailureCauses []*models.MeasurementFailureCause
  60
  61         count := int(measurementFailureCause_List.list.count)
  62         if count < 1 || count > maxFailedMeasObjects {
  63                 return fmt.Errorf("invalid number of failure cause elements, %d", int(count))
  64         }
  65
  66         measurementFailureCause_ItemIEs_slice := (*[1 << 30]*C.MeasurementFailureCause_ItemIEs_t)(unsafe.Pointer(measurementFailureCause_List.list.array))[:count:count]
  67         for _, itemIE := range measurementFailureCause_ItemIEs_slice {
  68                 switch itemIE.value.present {
  69                 case C.MeasurementFailureCause_ItemIEs__value_PR_MeasurementFailureCause_Item:
  70                         item := (*C.MeasurementFailureCause_Item_t)(unsafe.Pointer(&itemIE.value.choice[0]))
  71                         measurementFailedReportCharacteristics := C.GoBytes(unsafe.Pointer(item.measurementFailedReportCharacteristics.buf), C.int(item.measurementFailedReportCharacteristics.size))
  72                         measurementFailureCause := models.MeasurementFailureCause{MeasurementFailedReportCharacteristics: measurementFailedReportCharacteristics}
  73                         MeasurementFailureCauses = append(MeasurementFailureCauses, &measurementFailureCause)
  74                         /*Cause ignored - only need to know that the request failed and, possibly, which report characteristics failed*/
  75                 }
  76                 measurementInitiationResult.MeasurementFailureCauses = MeasurementFailureCauses
  77         }
  78
  79         return nil
  80 }
  81
  82 func convertMeasurementInitiationResult(measurementInitiationResult_List *C.MeasurementInitiationResult_List_t) ([]*models.MeasurementInitiationResult, error) {
  83         var measurementInitiationResults []*models.MeasurementInitiationResult
  84
  85         count := int(measurementInitiationResult_List.list.count)
  86         if count < 1 || count > maxCellineNB {
  87                 return nil, fmt.Errorf("invalid number of measurement initiation result elements, %d", count)
  88         }
  89         measurementInitiationResult_ItemIEs_slice := (*[1 << 30]*C.MeasurementInitiationResult_ItemIEs_t)(unsafe.Pointer(measurementInitiationResult_List.list.array))[:count:count]
  90         for _, itemIE := range measurementInitiationResult_ItemIEs_slice {
  91                 switch itemIE.value.present {
  92                 case C.MeasurementInitiationResult_ItemIEs__value_PR_MeasurementInitiationResult_Item:
  93                         item := (*C.MeasurementInitiationResult_Item_t)(unsafe.Pointer(&itemIE.value.choice[0]))
  94                         measurementInitiationResult := models.MeasurementInitiationResult{CellId: buildCellId(item.cell_ID)}
  95                         if item.measurementFailureCause_List != nil {
  96                                 if err:= convertMeasurementFailureCauses(item.measurementFailureCause_List, &measurementInitiationResult); err != nil {
  97                                         return nil, err
  98                                 }
  99                         }
 100                         measurementInitiationResults = append(measurementInitiationResults, &measurementInitiationResult)
 101                 }
 102
 103         }
 104
 105         return measurementInitiationResults, nil
 106 }
 107
 108 func convertResourceStatusIEs(resourceStatusResponse *C.ResourceStatusResponse_t, response *models.ResourceStatusResponse) error {
 109         count := int(resourceStatusResponse.protocolIEs.list.count)
 110         resourceStatusResponse_IEs_slice := (*[1 << 30]*C.ResourceStatusResponse_IEs_t)(unsafe.Pointer(resourceStatusResponse.protocolIEs.list.array))[:count:count]
 111         for _, resourceStatusResponse_IEs := range resourceStatusResponse_IEs_slice {
 112                 switch resourceStatusResponse_IEs.value.present {
 113                 case C.ResourceStatusResponse_IEs__value_PR_Measurement_ID:
 114                         measurement_ID := (*C.Measurement_ID_t)(unsafe.Pointer(&resourceStatusResponse_IEs.value.choice[0]))
 115                         if resourceStatusResponse_IEs.id == C.ProtocolIE_ID_id_ENB1_Measurement_ID {
 116                                 response.ENB1_Measurement_ID = int64(*measurement_ID)
 117                         }
 118                         if resourceStatusResponse_IEs.id == C.ProtocolIE_ID_id_ENB2_Measurement_ID {
 119                                 response.ENB2_Measurement_ID = int64(*measurement_ID)
 120                         }
 121                 case C.ResourceStatusResponse_IEs__value_PR_CriticalityDiagnostics:
 122                         /*ignored*/
 123
 124                 case C.ResourceStatusResponse_IEs__value_PR_MeasurementInitiationResult_List:
 125                         measurementInitiationResults, err := convertMeasurementInitiationResult((*C.MeasurementInitiationResult_List_t)(unsafe.Pointer(&resourceStatusResponse_IEs.value.choice[0])))
 126                         if err != nil {
 127                                 return err
 128                         }
 129                         response.MeasurementInitiationResults = measurementInitiationResults
 130                 }
 131         }
 132         return nil
 133 }
 134
 135 func convertResourceStatusResponse(pdu *C.E2AP_PDU_t) (*models.ResourceStatusResponse, error) {
 136         response := models.ResourceStatusResponse{}
 137
 138         if pdu.present != C.E2AP_PDU_PR_successfulOutcome {
 139                 return &response, fmt.Errorf("unexpected PDU, %d", int(pdu.present))
 140         }
 141
 142         //dereference a union of pointers (C union is represented as a byte array with the size of the largest member)
 143         successfulOutcome := *(**C.SuccessfulOutcome_t)(unsafe.Pointer(&pdu.choice[0]))
 144         if successfulOutcome == nil || successfulOutcome.value.present != C.SuccessfulOutcome__value_PR_ResourceStatusResponse {
 145                 return &response, fmt.Errorf("unexpected PDU - not a resource status response")
 146         }
 147
 148         resourceStatusResponse := (*C.ResourceStatusResponse_t)(unsafe.Pointer(&successfulOutcome.value.choice[0]))
 149         if resourceStatusResponse.protocolIEs.list.count == 0 {
 150                 return &response, fmt.Errorf("unexpected PDU - no protocolIEs found")
 151         }
 152
 153         if err := convertResourceStatusIEs(resourceStatusResponse, &response); err != nil {
 154                 return &response, err
 155         }
 156
 157         return &response, nil
 158 }
 159
 160 // Convert pdu to public ResourceStatusResponse
 161 func (r ResourceStatusResponseConverter) Convert(packedBuf []byte) (*models.ResourceStatusResponse, error) {
 162         pdu, err := r.UnpackX2apPdu(packedBuf)
 163         if err != nil {
 164                 return nil, err
 165         }
 166
 167         defer C.delete_pdu(pdu)
 168         return convertResourceStatusResponse(pdu)
 169 }