RSM/3rdparty/asn1codec/src/resource_status_request_wrapper.c

   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 /*
  19  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20  * platform project (RICP).
  21  */
  22
  23
  24 #include <string.h>
  25 #include <errno.h>
  26 #undef NDEBUG
  27 #include <assert.h>
  28 #include <InitiatingMessage.h>
  29 #include <ProtocolIE-ID.h>
  30 #include <resource_status_request_wrapper.h>
  31
  32 #define pLMN_Identity_size 3
  33 #define eUTRANcellIdentifier_size 28
  34
  35 static void assignPLMN_Identity (PLMN_Identity_t *pLMN_Identity, uint8_t const* pLMNId);
  36 static void assignEUTRANcellIdentifier (EUTRANCellIdentifier_t *eUTRANCellIdentifier, uint8_t const* eUTRANCellId);
  37 /*
  38  * Build and pack resource status request.
  39  * Abort the process on allocation failure.
  40  *  packed_buf_size - in: size of packed_buf; out: number of chars used.
  41  */
  42
  43 bool
  44 build_pack_resource_status_request(
  45                 uint8_t const** pLMN_Identities,
  46                 uint8_t const** eUTRANCellIdentifiers,
  47                 size_t nECGIs,
  48                 Measurement_ID_t measurement_ID, Measurement_ID_t measurement_ID2,
  49                 Registration_Request_t registration_Request /*Registration_Request_start,Registration_Request_stop,Registration_Request_partial_stop, Registration_Request_add*/,
  50                 uint32_t reportCharacteristics,
  51                 ReportingPeriodicity_t reportingPeriodicity /*ReportingPeriodicity_one_thousand_ms,     ReportingPeriodicity_two_thousand_ms, ReportingPeriodicity_five_thousand_ms,ReportingPeriodicity_ten_thousand_ms*/,
  52                 PartialSuccessIndicator_t partialSuccessIndicator /*PartialSuccessIndicator_partial_success_allowed*/,
  53                 ReportingPeriodicityRSRPMR_t reportingPeriodicityRSRPMR /*ReportingPeriodicityRSRPMR_one_hundred_20_ms, ReportingPeriodicityRSRPMR_two_hundred_40_ms, ReportingPeriodicityRSRPMR_four_hundred_80_ms,ReportingPeriodicityRSRPMR_six_hundred_40_ms*/,
  54                 ReportingPeriodicityCSIR_t reportingPeriodicityCSIR /*ReportingPeriodicityCSIR_ms5, ReportingPeriodicityCSIR_ms10,ReportingPeriodicityCSIR_ms20,ReportingPeriodicityCSIR_ms40,ReportingPeriodicityCSIR_ms80*/,
  55                 size_t* packed_buf_size, unsigned char* packed_buf,size_t err_buf_size, char* err_buf
  56 )
  57 {
  58         return build_pack_resource_status_request_aux(
  59                         pLMN_Identities,
  60             eUTRANCellIdentifiers,
  61             nECGIs,
  62                         measurement_ID, measurement_ID2,
  63                         registration_Request,
  64                         reportCharacteristics,
  65                         reportingPeriodicity,
  66                         partialSuccessIndicator,
  67                         reportingPeriodicityRSRPMR,
  68                         reportingPeriodicityCSIR,
  69                         packed_buf_size, packed_buf,err_buf_size,err_buf,ATS_ALIGNED_BASIC_PER);
  70
  71 }
  72
  73 bool
  74 build_pack_resource_status_request_aux(
  75                 uint8_t const** pLMN_Identities,
  76                 uint8_t const** eUTRANCellIdentifiers,
  77                 size_t nECGIs,
  78                 Measurement_ID_t measurement_ID, Measurement_ID_t measurement_ID2,
  79                 Registration_Request_t registration_Request /*Registration_Request_start,Registration_Request_stop,Registration_Request_partial_stop, Registration_Request_add*/,
  80                 uint32_t reportCharacteristics,
  81                 ReportingPeriodicity_t reportingPeriodicity /*ReportingPeriodicity_one_thousand_ms,     ReportingPeriodicity_two_thousand_ms, ReportingPeriodicity_five_thousand_ms,ReportingPeriodicity_ten_thousand_ms*/,
  82                 PartialSuccessIndicator_t partialSuccessIndicator /*PartialSuccessIndicator_partial_success_allowed*/,
  83                 ReportingPeriodicityRSRPMR_t reportingPeriodicityRSRPMR /*ReportingPeriodicityRSRPMR_one_hundred_20_ms, ReportingPeriodicityRSRPMR_two_hundred_40_ms, ReportingPeriodicityRSRPMR_four_hundred_80_ms,ReportingPeriodicityRSRPMR_six_hundred_40_ms*/,
  84                 ReportingPeriodicityCSIR_t reportingPeriodicityCSIR /*  ReportingPeriodicityCSIR_ms5, ReportingPeriodicityCSIR_ms10,ReportingPeriodicityCSIR_ms20,ReportingPeriodicityCSIR_ms40,ReportingPeriodicityCSIR_ms80*/,
  85                 size_t* packed_buf_size, unsigned char* packed_buf,size_t err_buf_size, char* err_buf,enum asn_transfer_syntax syntax
  86 )
  87 {
  88         bool rc = true;
  89         E2AP_PDU_t *pdu = calloc(1, sizeof(E2AP_PDU_t));
  90         InitiatingMessage_t *initiatingMessage = calloc(1, sizeof(InitiatingMessage_t));
  91         ResourceStatusRequest_t *request;
  92
  93     assert(pdu != 0);
  94     assert(initiatingMessage != 0);
  95
  96
  97     pdu->present = E2AP_PDU_PR_initiatingMessage;
  98     pdu->choice.initiatingMessage = initiatingMessage;
  99
 100     initiatingMessage->procedureCode = ProcedureCode_id_resourceStatusReportingInitiation;
 101     initiatingMessage->criticality = Criticality_reject;
 102     initiatingMessage->value.present = InitiatingMessage__value_PR_ResourceStatusRequest;
 103     request = &initiatingMessage->value.choice.ResourceStatusRequest;
 104
 105     ResourceStatusRequest_IEs_t *measurementID_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 106     assert(measurementID_ie != 0);
 107     ASN_SEQUENCE_ADD(&request->protocolIEs, measurementID_ie);
 108
 109     measurementID_ie->id = ProtocolIE_ID_id_ENB1_Measurement_ID;
 110     measurementID_ie->criticality = Criticality_reject;
 111     measurementID_ie->value.present = ResourceStatusRequest_IEs__value_PR_Measurement_ID;
 112     measurementID_ie->value.choice.Measurement_ID = measurement_ID;
 113
 114
 115     if (registration_Request == Registration_Request_stop
 116                 || registration_Request == Registration_Request_partial_stop
 117                         || registration_Request == Registration_Request_add) {
 118                 ResourceStatusRequest_IEs_t *measurementID2_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 119                 assert(measurementID2_ie != 0);
 120                 ASN_SEQUENCE_ADD(&request->protocolIEs, measurementID2_ie);
 121
 122                 measurementID2_ie->id = ProtocolIE_ID_id_ENB2_Measurement_ID;
 123                 measurementID2_ie->criticality = Criticality_reject;
 124                 measurementID2_ie->value.present = ResourceStatusRequest_IEs__value_PR_Measurement_ID;
 125                 measurementID2_ie->value.choice.Measurement_ID = measurement_ID2;
 126     }
 127
 128     ResourceStatusRequest_IEs_t *registration_Request_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 129     assert(registration_Request_ie != 0);
 130     ASN_SEQUENCE_ADD(&request->protocolIEs, registration_Request_ie);
 131
 132     registration_Request_ie->id = ProtocolIE_ID_id_Registration_Request;
 133     registration_Request_ie->criticality = Criticality_reject;
 134     registration_Request_ie->value.present = ResourceStatusRequest_IEs__value_PR_Registration_Request;
 135     registration_Request_ie->value.choice.Registration_Request = registration_Request;
 136
 137     if (reportCharacteristics){
 138                 ResourceStatusRequest_IEs_t *reportCharacteristics_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 139                 assert(reportCharacteristics_ie != 0);
 140                 ASN_SEQUENCE_ADD(&request->protocolIEs, reportCharacteristics_ie);
 141
 142                 reportCharacteristics_ie->id = ProtocolIE_ID_id_ReportCharacteristics;
 143                 reportCharacteristics_ie->criticality = Criticality_reject;
 144                 reportCharacteristics_ie->value.present = ResourceStatusRequest_IEs__value_PR_ReportCharacteristics;
 145                 reportCharacteristics_ie->value.choice.ReportCharacteristics.size = sizeof(uint32_t);
 146                 reportCharacteristics_ie->value.choice.ReportCharacteristics.bits_unused = 0;
 147                 reportCharacteristics_ie->value.choice.ReportCharacteristics.buf = calloc(1, reportCharacteristics_ie->value.choice.ReportCharacteristics.size);
 148
 149                 assert(reportCharacteristics_ie->value.choice.ReportCharacteristics.buf != 0);
 150                 memcpy(reportCharacteristics_ie->value.choice.ReportCharacteristics.buf, &reportCharacteristics, reportCharacteristics_ie->value.choice.ReportCharacteristics.size);
 151     }
 152
 153     ResourceStatusRequest_IEs_t *cellToReport_List_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 154     assert(cellToReport_List_ie != 0);
 155     ASN_SEQUENCE_ADD(&request->protocolIEs, cellToReport_List_ie);
 156
 157     cellToReport_List_ie->id = ProtocolIE_ID_id_CellToReport;
 158     cellToReport_List_ie->criticality = Criticality_ignore;
 159     cellToReport_List_ie->value.present = ResourceStatusRequest_IEs__value_PR_CellToReport_List;
 160
 161     for (size_t i = 0; i < nECGIs; i++){
 162         CellToReport_ItemIEs_t *item = calloc(1, sizeof(CellToReport_ItemIEs_t));
 163         assert(item != 0);
 164         ASN_SEQUENCE_ADD(&cellToReport_List_ie->value.choice.CellToReport_List, item);
 165
 166         item->id = ProtocolIE_ID_id_CellToReport_Item;
 167         item->criticality = Criticality_ignore;
 168         item->value.present = CellToReport_ItemIEs__value_PR_CellToReport_Item;
 169         assignPLMN_Identity(&item->value.choice.CellToReport_Item.cell_ID.pLMN_Identity, pLMN_Identities[i]);
 170         assignEUTRANcellIdentifier(&item->value.choice.CellToReport_Item.cell_ID.eUTRANcellIdentifier,eUTRANCellIdentifiers[i]);
 171     }
 172
 173         if (reportingPeriodicity >= 0){
 174                 ResourceStatusRequest_IEs_t *reportingPeriodicity_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 175                 assert(reportingPeriodicity_ie != 0);
 176                 ASN_SEQUENCE_ADD(&request->protocolIEs, reportingPeriodicity_ie);
 177
 178                 reportingPeriodicity_ie->id = ProtocolIE_ID_id_ReportingPeriodicity;
 179                 reportingPeriodicity_ie->criticality = Criticality_ignore;
 180                 reportingPeriodicity_ie->value.present = ResourceStatusRequest_IEs__value_PR_ReportingPeriodicity;
 181                 reportingPeriodicity_ie->value.choice.ReportingPeriodicity = reportingPeriodicity;
 182         }
 183
 184         if (partialSuccessIndicator >= 0){
 185                 ResourceStatusRequest_IEs_t *partialSuccessIndicator_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 186                 assert(partialSuccessIndicator_ie != 0);
 187                 ASN_SEQUENCE_ADD(&request->protocolIEs, partialSuccessIndicator_ie);
 188
 189                 partialSuccessIndicator_ie->id = ProtocolIE_ID_id_PartialSuccessIndicator;
 190                 partialSuccessIndicator_ie->criticality = Criticality_ignore;
 191                 partialSuccessIndicator_ie->value.present = ResourceStatusRequest_IEs__value_PR_PartialSuccessIndicator;
 192                 partialSuccessIndicator_ie->value.choice.PartialSuccessIndicator = partialSuccessIndicator;
 193     }
 194
 195     if (reportingPeriodicityRSRPMR >= 0){
 196                 ResourceStatusRequest_IEs_t *reportingPeriodicityRSRPMR_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 197                 assert(reportingPeriodicityRSRPMR_ie != 0);
 198                 ASN_SEQUENCE_ADD(&request->protocolIEs, reportingPeriodicityRSRPMR_ie);
 199
 200                 reportingPeriodicityRSRPMR_ie->id = ProtocolIE_ID_id_ReportingPeriodicityRSRPMR;
 201                 reportingPeriodicityRSRPMR_ie->criticality = Criticality_ignore;
 202                 reportingPeriodicityRSRPMR_ie->value.present = ResourceStatusRequest_IEs__value_PR_ReportingPeriodicityRSRPMR;
 203                 reportingPeriodicityRSRPMR_ie->value.choice.ReportingPeriodicityRSRPMR = reportingPeriodicityRSRPMR;
 204     }
 205
 206     if (reportingPeriodicityCSIR >= 0){
 207                 ResourceStatusRequest_IEs_t *reportingPeriodicityCSIR_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 208                 assert(reportingPeriodicityCSIR_ie != 0);
 209                 ASN_SEQUENCE_ADD(&request->protocolIEs, reportingPeriodicityCSIR_ie);
 210
 211                 reportingPeriodicityCSIR_ie->id = ProtocolIE_ID_id_ReportingPeriodicityCSIR;
 212                 reportingPeriodicityCSIR_ie->criticality = Criticality_ignore;
 213                 reportingPeriodicityCSIR_ie->value.present = ResourceStatusRequest_IEs__value_PR_ReportingPeriodicityCSIR;
 214                 reportingPeriodicityCSIR_ie->value.choice.ReportingPeriodicityCSIR = reportingPeriodicityCSIR;
 215     }
 216
 217     rc = pack_pdu_aux(pdu, packed_buf_size, packed_buf,err_buf_size, err_buf,syntax);
 218
 219         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 220         return rc;
 221 }
 222
 223 static void assignPLMN_Identity (PLMN_Identity_t *pLMN_Identity, uint8_t const* pLMNId)
 224 {
 225         pLMN_Identity->size = pLMN_Identity_size;
 226         pLMN_Identity->buf = calloc(1,pLMN_Identity->size);
 227         assert(pLMN_Identity->buf != 0);
 228         memcpy(pLMN_Identity->buf, pLMNId, pLMN_Identity->size);
 229 }
 230
 231 // Assume that eUTRANCellId value is already pushed to the left
 232 static void assignEUTRANcellIdentifier (EUTRANCellIdentifier_t *eUTRANCellIdentifier, uint8_t const* eUTRANCellId)
 233 {
 234         size_t size_in_bytes = (eUTRANcellIdentifier_size / 8) + ((eUTRANcellIdentifier_size % 8) > 0);
 235         int unused_bits = 8 - (eUTRANcellIdentifier_size % 8);
 236
 237         eUTRANCellIdentifier->size = size_in_bytes;
 238         eUTRANCellIdentifier->bits_unused = unused_bits;
 239         eUTRANCellIdentifier->buf = calloc(1, eUTRANCellIdentifier->size);
 240         assert(eUTRANCellIdentifier->buf != 0);
 241         memcpy(eUTRANCellIdentifier->buf, eUTRANCellId, size_in_bytes);
 242 }