RSM/asn1codec/src/resource_status_request_wrapper.c

   1 /*
   2  *
   3  * Copyright 2019 AT&T Intellectual Property
   4  * Copyright 2019 Nokia
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <string.h>
  21 #include <errno.h>
  22 #undef NDEBUG
  23 #include <assert.h>
  24 #include <InitiatingMessage.h>
  25 #include <ProtocolIE-ID.h>
  26 #include <resource_status_request_wrapper.h>
  27
  28 #define pLMN_Identity_size 3
  29 #define eUTRANcellIdentifier_size 28
  30
  31 static void assignPLMN_Identity (PLMN_Identity_t *pLMN_Identity, uint8_t const* pLMNId);
  32 static void assignEUTRANcellIdentifier (EUTRANCellIdentifier_t *eUTRANCellIdentifier, uint8_t const* eUTRANCellId);
  33 /*
  34  * Build and pack resource status request.
  35  * Abort the process on allocation failure.
  36  *  packed_buf_size - in: size of packed_buf; out: number of chars used.
  37  */
  38
  39 bool
  40 build_pack_resource_status_request(
  41                 uint8_t const* pLMN_Identity,
  42                 uint8_t const* eUTRANCellIdentifier,
  43                 Measurement_ID_t measurement_ID, Measurement_ID_t measurement_ID2,
  44                 Registration_Request_t registration_Request /*Registration_Request_start,Registration_Request_stop,Registration_Request_partial_stop, Registration_Request_add*/,
  45                 uint32_t reportCharacteristics,
  46                 ReportingPeriodicity_t reportingPeriodicity /*ReportingPeriodicity_one_thousand_ms,     ReportingPeriodicity_two_thousand_ms, ReportingPeriodicity_five_thousand_ms,ReportingPeriodicity_ten_thousand_ms*/,
  47                 PartialSuccessIndicator_t partialSuccessIndicator /*PartialSuccessIndicator_partial_success_allowed*/,
  48                 ReportingPeriodicityRSRPMR_t reportingPeriodicityRSRPMR /*ReportingPeriodicityRSRPMR_one_hundred_20_ms, ReportingPeriodicityRSRPMR_two_hundred_40_ms, ReportingPeriodicityRSRPMR_four_hundred_80_ms,ReportingPeriodicityRSRPMR_six_hundred_40_ms*/,
  49                 ReportingPeriodicityCSIR_t reportingPeriodicityCSIR /*ReportingPeriodicityCSIR_ms5, ReportingPeriodicityCSIR_ms10,ReportingPeriodicityCSIR_ms20,ReportingPeriodicityCSIR_ms40,ReportingPeriodicityCSIR_ms80*/,
  50                 size_t* packed_buf_size, unsigned char* packed_buf,size_t err_buf_size, char* err_buf
  51 )
  52 {
  53         return build_pack_resource_status_request_aux(
  54                         pLMN_Identity,
  55             eUTRANCellIdentifier,
  56                         measurement_ID, measurement_ID2,
  57                         registration_Request,
  58                         reportCharacteristics,
  59                         reportingPeriodicity,
  60                         partialSuccessIndicator,
  61                         reportingPeriodicityRSRPMR,
  62                         reportingPeriodicityCSIR,
  63                         packed_buf_size, packed_buf,err_buf_size,err_buf,ATS_ALIGNED_BASIC_PER);
  64
  65 }
  66
  67 bool
  68 build_pack_resource_status_request_aux(
  69                 uint8_t const* pLMN_Identity,
  70                 uint8_t const* eUTRANCellIdentifier,
  71                 Measurement_ID_t measurement_ID, Measurement_ID_t measurement_ID2,
  72                 Registration_Request_t registration_Request /*Registration_Request_start,Registration_Request_stop,Registration_Request_partial_stop, Registration_Request_add*/,
  73                 uint32_t reportCharacteristics,
  74                 ReportingPeriodicity_t reportingPeriodicity /*ReportingPeriodicity_one_thousand_ms,     ReportingPeriodicity_two_thousand_ms, ReportingPeriodicity_five_thousand_ms,ReportingPeriodicity_ten_thousand_ms*/,
  75                 PartialSuccessIndicator_t partialSuccessIndicator /*PartialSuccessIndicator_partial_success_allowed*/,
  76                 ReportingPeriodicityRSRPMR_t reportingPeriodicityRSRPMR /*ReportingPeriodicityRSRPMR_one_hundred_20_ms, ReportingPeriodicityRSRPMR_two_hundred_40_ms, ReportingPeriodicityRSRPMR_four_hundred_80_ms,ReportingPeriodicityRSRPMR_six_hundred_40_ms*/,
  77                 ReportingPeriodicityCSIR_t reportingPeriodicityCSIR /*  ReportingPeriodicityCSIR_ms5, ReportingPeriodicityCSIR_ms10,ReportingPeriodicityCSIR_ms20,ReportingPeriodicityCSIR_ms40,ReportingPeriodicityCSIR_ms80*/,
  78                 size_t* packed_buf_size, unsigned char* packed_buf,size_t err_buf_size, char* err_buf,enum asn_transfer_syntax syntax
  79 )
  80 {
  81         bool rc = true;
  82         E2AP_PDU_t *pdu = calloc(1, sizeof(E2AP_PDU_t));
  83         InitiatingMessage_t *initiatingMessage = calloc(1, sizeof(InitiatingMessage_t));
  84         ResourceStatusRequest_t *request;
  85
  86     assert(pdu != 0);
  87     assert(initiatingMessage != 0);
  88
  89
  90     pdu->present = E2AP_PDU_PR_initiatingMessage;
  91     pdu->choice.initiatingMessage = initiatingMessage;
  92
  93     initiatingMessage->procedureCode = ProcedureCode_id_resourceStatusReportingInitiation;
  94     initiatingMessage->criticality = Criticality_reject;
  95     initiatingMessage->value.present = InitiatingMessage__value_PR_ResourceStatusRequest;
  96     request = &initiatingMessage->value.choice.ResourceStatusRequest;
  97
  98     ResourceStatusRequest_IEs_t *measurementID_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
  99     assert(measurementID_ie != 0);
 100     ASN_SEQUENCE_ADD(&request->protocolIEs, measurementID_ie);
 101
 102     measurementID_ie->id = ProtocolIE_ID_id_ENB1_Measurement_ID;
 103     measurementID_ie->criticality = Criticality_reject;
 104     measurementID_ie->value.present = ResourceStatusRequest_IEs__value_PR_Measurement_ID;
 105     measurementID_ie->value.choice.Measurement_ID = measurement_ID;
 106
 107
 108     if (registration_Request == Registration_Request_stop
 109                 || registration_Request == Registration_Request_partial_stop
 110                         || registration_Request == Registration_Request_add) {
 111                 ResourceStatusRequest_IEs_t *measurementID2_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 112                 assert(measurementID2_ie != 0);
 113                 ASN_SEQUENCE_ADD(&request->protocolIEs, measurementID2_ie);
 114
 115                 measurementID2_ie->id = ProtocolIE_ID_id_ENB2_Measurement_ID;
 116                 measurementID2_ie->criticality = Criticality_reject;
 117                 measurementID2_ie->value.present = ResourceStatusRequest_IEs__value_PR_Measurement_ID;
 118                 measurementID2_ie->value.choice.Measurement_ID = measurement_ID2;
 119     }
 120
 121     ResourceStatusRequest_IEs_t *registration_Request_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 122     assert(registration_Request_ie != 0);
 123     ASN_SEQUENCE_ADD(&request->protocolIEs, registration_Request_ie);
 124
 125     registration_Request_ie->id = ProtocolIE_ID_id_Registration_Request;
 126     registration_Request_ie->criticality = Criticality_reject;
 127     registration_Request_ie->value.present = ResourceStatusRequest_IEs__value_PR_Registration_Request;
 128     registration_Request_ie->value.choice.Registration_Request = registration_Request;
 129
 130     if (reportCharacteristics){
 131                 ResourceStatusRequest_IEs_t *reportCharacteristics_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 132                 assert(reportCharacteristics_ie != 0);
 133                 ASN_SEQUENCE_ADD(&request->protocolIEs, reportCharacteristics_ie);
 134
 135                 reportCharacteristics_ie->id = ProtocolIE_ID_id_ReportCharacteristics;
 136                 reportCharacteristics_ie->criticality = Criticality_reject;
 137                 reportCharacteristics_ie->value.present = ResourceStatusRequest_IEs__value_PR_ReportCharacteristics;
 138                 reportCharacteristics_ie->value.choice.ReportCharacteristics.size = sizeof(uint32_t);
 139                 reportCharacteristics_ie->value.choice.ReportCharacteristics.bits_unused = 0;
 140                 reportCharacteristics_ie->value.choice.ReportCharacteristics.buf = calloc(1, reportCharacteristics_ie->value.choice.ReportCharacteristics.size);
 141
 142                 assert(reportCharacteristics_ie->value.choice.ReportCharacteristics.buf != 0);
 143                 memcpy(reportCharacteristics_ie->value.choice.ReportCharacteristics.buf, &reportCharacteristics, reportCharacteristics_ie->value.choice.ReportCharacteristics.size);
 144     }
 145
 146     ResourceStatusRequest_IEs_t *cellToReport_List_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 147     assert(cellToReport_List_ie != 0);
 148     ASN_SEQUENCE_ADD(&request->protocolIEs, cellToReport_List_ie);
 149
 150     cellToReport_List_ie->id = ProtocolIE_ID_id_CellToReport;
 151     cellToReport_List_ie->criticality = Criticality_ignore;
 152     cellToReport_List_ie->value.present = ResourceStatusRequest_IEs__value_PR_CellToReport_List;
 153
 154     CellToReport_ItemIEs_t *item = calloc(1, sizeof(CellToReport_ItemIEs_t));
 155     assert(item != 0);
 156     ASN_SEQUENCE_ADD(&cellToReport_List_ie->value.choice.CellToReport_List, item);
 157
 158     item->id = ProtocolIE_ID_id_CellToReport_Item;
 159         item->criticality = Criticality_ignore;
 160         item->value.present = CellToReport_ItemIEs__value_PR_CellToReport_Item;
 161         assignPLMN_Identity(&item->value.choice.CellToReport_Item.cell_ID.pLMN_Identity, pLMN_Identity);
 162         assignEUTRANcellIdentifier(&item->value.choice.CellToReport_Item.cell_ID.eUTRANcellIdentifier,eUTRANCellIdentifier);
 163
 164         if (reportingPeriodicity >= 0){
 165                 ResourceStatusRequest_IEs_t *reportingPeriodicity_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 166                 assert(reportingPeriodicity_ie != 0);
 167                 ASN_SEQUENCE_ADD(&request->protocolIEs, reportingPeriodicity_ie);
 168
 169                 reportingPeriodicity_ie->id = ProtocolIE_ID_id_ReportingPeriodicity;
 170                 reportingPeriodicity_ie->criticality = Criticality_ignore;
 171                 reportingPeriodicity_ie->value.present = ResourceStatusRequest_IEs__value_PR_ReportingPeriodicity;
 172                 reportingPeriodicity_ie->value.choice.ReportingPeriodicity = reportingPeriodicity;
 173         }
 174
 175         if (partialSuccessIndicator >= 0){
 176                 ResourceStatusRequest_IEs_t *partialSuccessIndicator_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 177                 assert(partialSuccessIndicator_ie != 0);
 178                 ASN_SEQUENCE_ADD(&request->protocolIEs, partialSuccessIndicator_ie);
 179
 180                 partialSuccessIndicator_ie->id = ProtocolIE_ID_id_PartialSuccessIndicator;
 181                 partialSuccessIndicator_ie->criticality = Criticality_ignore;
 182                 partialSuccessIndicator_ie->value.present = ResourceStatusRequest_IEs__value_PR_PartialSuccessIndicator;
 183                 partialSuccessIndicator_ie->value.choice.PartialSuccessIndicator = partialSuccessIndicator;
 184     }
 185
 186     if (reportingPeriodicityRSRPMR >= 0){
 187                 ResourceStatusRequest_IEs_t *reportingPeriodicityRSRPMR_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 188                 assert(reportingPeriodicityRSRPMR_ie != 0);
 189                 ASN_SEQUENCE_ADD(&request->protocolIEs, reportingPeriodicityRSRPMR_ie);
 190
 191                 reportingPeriodicityRSRPMR_ie->id = ProtocolIE_ID_id_ReportingPeriodicityRSRPMR;
 192                 reportingPeriodicityRSRPMR_ie->criticality = Criticality_ignore;
 193                 reportingPeriodicityRSRPMR_ie->value.present = ResourceStatusRequest_IEs__value_PR_ReportingPeriodicityRSRPMR;
 194                 reportingPeriodicityRSRPMR_ie->value.choice.ReportingPeriodicityRSRPMR = reportingPeriodicityRSRPMR;
 195     }
 196
 197     if (reportingPeriodicityCSIR >= 0){
 198                 ResourceStatusRequest_IEs_t *reportingPeriodicityCSIR_ie = calloc(1, sizeof(ResourceStatusRequest_IEs_t));
 199                 assert(reportingPeriodicityCSIR_ie != 0);
 200                 ASN_SEQUENCE_ADD(&request->protocolIEs, reportingPeriodicityCSIR_ie);
 201
 202                 reportingPeriodicityCSIR_ie->id = ProtocolIE_ID_id_ReportingPeriodicityCSIR;
 203                 reportingPeriodicityCSIR_ie->criticality = Criticality_ignore;
 204                 reportingPeriodicityCSIR_ie->value.present = ResourceStatusRequest_IEs__value_PR_ReportingPeriodicityCSIR;
 205                 reportingPeriodicityCSIR_ie->value.choice.ReportingPeriodicityCSIR = reportingPeriodicityCSIR;
 206     }
 207
 208     rc = pack_pdu_aux(pdu, packed_buf_size, packed_buf,err_buf_size, err_buf,syntax);
 209
 210         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 211         return rc;
 212 }
 213
 214 static void assignPLMN_Identity (PLMN_Identity_t *pLMN_Identity, uint8_t const* pLMNId)
 215 {
 216         pLMN_Identity->size = pLMN_Identity_size;
 217         pLMN_Identity->buf = calloc(1,pLMN_Identity->size);
 218         assert(pLMN_Identity->buf != 0);
 219         memcpy(pLMN_Identity->buf, pLMNId, pLMN_Identity->size);
 220 }
 221
 222 // Assume that eUTRANCellId value is already pushed to the left
 223 static void assignEUTRANcellIdentifier (EUTRANCellIdentifier_t *eUTRANCellIdentifier, uint8_t const* eUTRANCellId)
 224 {
 225         size_t size_in_bytes = (eUTRANcellIdentifier_size / 8) + ((eUTRANcellIdentifier_size % 8) > 0);
 226         int unused_bits = 8 - (eUTRANcellIdentifier_size % 8);
 227
 228         eUTRANCellIdentifier->size = size_in_bytes;
 229         eUTRANCellIdentifier->bits_unused = unused_bits;
 230         eUTRANCellIdentifier->buf = calloc(1, eUTRANCellIdentifier->size);
 231         assert(eUTRANCellIdentifier->buf != 0);
 232         memcpy(eUTRANCellIdentifier->buf, eUTRANCellId, size_in_bytes);
 233 }