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 package converters
  19
  20 // #cgo CFLAGS: -I../asn1codec/inc/ -I../asn1codec/e2ap_engine/
  21 // #cgo LDFLAGS: -L ../asn1codec/lib/ -L../asn1codec/e2ap_engine/ -le2ap_codec -lasncodec
  22 // #include <asn1codec_utils.h>
  23 // #include <resource_status_response_wrapper.h>
  24 import "C"
  25 import (
  26         "fmt"
  27         "rsm/models"
  28         "unsafe"
  29 )
  30
  31 type ResourceStatusFailureConverter struct {
  32         X2apPduUnpacker
  33 }
  34
  35 func NewResourceStatusFailureConverter(unpacker X2apPduUnpacker) ResourceStatusFailureConverter {
  36         return ResourceStatusFailureConverter{unpacker}
  37 }
  38
  39 func convertCompleteFailureCauseInformation(completeFailureCauseInformation_List *C.CompleteFailureCauseInformation_List_t) ([]*models.MeasurementInitiationResult, error) {
  40         var measurementInitiationResults []*models.MeasurementInitiationResult
  41
  42         count := int(completeFailureCauseInformation_List.list.count)
  43         if count < 1 || count > maxCellineNB {
  44                 return nil, fmt.Errorf("invalid number of complete failure cause information elements, %d", count)
  45         }
  46         completeFailureCauseInformation_ItemIEs_slice := (*[1 << 30]*C.CompleteFailureCauseInformation_ItemIEs_t)(unsafe.Pointer(completeFailureCauseInformation_List.list.array))[:count:count]
  47         for _, itemIE := range completeFailureCauseInformation_ItemIEs_slice {
  48
  49                 switch itemIE.value.present {
  50                 case C.CompleteFailureCauseInformation_ItemIEs__value_PR_CompleteFailureCauseInformation_Item:
  51                         item := (*C.CompleteFailureCauseInformation_Item_t)(unsafe.Pointer(&itemIE.value.choice[0]))
  52                         measurementInitiationResult := models.MeasurementInitiationResult{CellId: buildCellId(item.cell_ID)}
  53                         if err:=convertMeasurementFailureCauses(&item.measurementFailureCause_List, &measurementInitiationResult); err != nil {
  54                                 return nil, err
  55                         }
  56                         measurementInitiationResults = append(measurementInitiationResults, &measurementInitiationResult)
  57                 }
  58         }
  59
  60         return measurementInitiationResults, nil
  61 }
  62
  63 func convertResourceFailureIEs(resourceStatusFailure *C.ResourceStatusFailure_t, response *models.ResourceStatusResponse) error {
  64         count := int(resourceStatusFailure.protocolIEs.list.count)
  65         resourceStatusFailure_IEs_slice := (*[1 << 30]*C.ResourceStatusFailure_IEs_t)(unsafe.Pointer(resourceStatusFailure.protocolIEs.list.array))[:count:count]
  66         for _, resourceStatusFailure_IEs := range resourceStatusFailure_IEs_slice {
  67                 switch resourceStatusFailure_IEs.value.present {
  68                 case C.ResourceStatusFailure_IEs__value_PR_Measurement_ID:
  69                         measurement_ID := (*C.Measurement_ID_t)(unsafe.Pointer(&resourceStatusFailure_IEs.value.choice[0]))
  70                         if resourceStatusFailure_IEs.id == C.ProtocolIE_ID_id_ENB1_Measurement_ID {
  71                                 response.ENB1_Measurement_ID = int64(*measurement_ID)
  72                         }
  73                         if resourceStatusFailure_IEs.id == C.ProtocolIE_ID_id_ENB2_Measurement_ID {
  74                                 response.ENB2_Measurement_ID = int64(*measurement_ID)
  75                         }
  76                 case C.ResourceStatusFailure_IEs__value_PR_CriticalityDiagnostics:
  77                         /*ignored*/
  78                 case C.ResourceStatusFailure_IEs__value_PR_Cause:
  79                         /*ignored*/
  80                 case C.ResourceStatusFailure_IEs__value_PR_CompleteFailureCauseInformation_List:
  81                         measurementInitiationResults, err := convertCompleteFailureCauseInformation((*C.CompleteFailureCauseInformation_List_t)(unsafe.Pointer(&resourceStatusFailure_IEs.value.choice[0])))
  82                         if err != nil {
  83                                 return err
  84                         }
  85                         response.MeasurementInitiationResults = measurementInitiationResults
  86                 }
  87         }
  88         return nil
  89 }
  90
  91 func convertResourceStatusFailure(pdu *C.E2AP_PDU_t) (*models.ResourceStatusResponse, error) {
  92         response := models.ResourceStatusResponse{}
  93
  94         if pdu.present != C.E2AP_PDU_PR_unsuccessfulOutcome {
  95                 return &response, fmt.Errorf("unexpected PDU, %d", int(pdu.present))
  96         }
  97
  98         //dereference a union of pointers (C union is represented as a byte array with the size of the largest member)
  99         unsuccessfulOutcome := *(**C.UnsuccessfulOutcome_t)(unsafe.Pointer(&pdu.choice[0]))
 100         if unsuccessfulOutcome == nil || unsuccessfulOutcome.value.present != C.UnsuccessfulOutcome__value_PR_ResourceStatusFailure {
 101                 return &response, fmt.Errorf("unexpected PDU - not a resource status failure")
 102         }
 103
 104         resourceStatusFailure := (*C.ResourceStatusFailure_t)(unsafe.Pointer(&unsuccessfulOutcome.value.choice[0]))
 105         if resourceStatusFailure.protocolIEs.list.count == 0 {
 106                 return &response, fmt.Errorf("unexpected PDU - no protocolIEs found")
 107         }
 108
 109         if err := convertResourceFailureIEs(resourceStatusFailure, &response); err != nil {
 110                 return &response, err
 111         }
 112
 113         return &response, nil
 114 }
 115
 116 // Convert pdu to public ResourceStatusResponse
 117 func (r ResourceStatusFailureConverter) Convert(packedBuf []byte) (*models.ResourceStatusResponse, error) {
 118         pdu, err := r.UnpackX2apPdu(packedBuf)
 119         if err != nil {
 120                 return nil, err
 121         }
 122
 123         defer C.delete_pdu(pdu)
 124         return convertResourceStatusFailure(pdu)
 125 }