ric_benchmarking/e2-interface/e2sim/src/messagerouting/e2ap_message_handler.cpp

   1
   2
   3 /*****************************************************************************
   4 #                                                                            *
   5 # Copyright 2020 AT&T Intellectual Property                                  *
   6 # Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved.      *
   7 #                                                                            *
   8 # Licensed under the Apache License, Version 2.0 (the "License");            *
   9 # you may not use this file except in compliance with the License.           *
  10 # You may obtain a copy of the License at                                    *
  11 #                                                                            *
  12 #      http://www.apache.org/licenses/LICENSE-2.0                            *
  13 #                                                                            *
  14 # Unless required by applicable law or agreed to in writing, software        *
  15 # distributed under the License is distributed on an "AS IS" BASIS,          *
  16 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
  17 # See the License for the specific language governing permissions and        *
  18 # limitations under the License.                                             *
  19 #                                                                            *
  20 ******************************************************************************/
  21 #include "e2ap_message_handler.hpp"
  22
  23 //#include <iostream>
  24 //#include <vector>
  25
  26 #include "encode_e2apv1.hpp"
  27
  28
  29 #include <unistd.h>
  30
  31 void e2ap_handle_sctp_data(int &socket_fd, sctp_buffer_t &data, bool xmlenc, E2Sim *e2sim)
  32 {
  33   fprintf(stderr, "in e2ap_handle_sctp_data()\n");
  34   //decode the data into E2AP-PDU
  35   E2AP_PDU_t* pdu = (E2AP_PDU_t*)calloc(1, sizeof(E2AP_PDU));
  36   ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu);
  37
  38   fprintf(stderr, "decoding...\n");
  39
  40   asn_transfer_syntax syntax;
  41
  42
  43   syntax = ATS_ALIGNED_BASIC_PER;
  44
  45
  46   fprintf(stderr, "full buffer\n%s\n", data.buffer);
  47   //  e2ap_asn1c_decode_pdu(pdu, data.buffer, data.len);
  48
  49   auto rval = asn_decode(nullptr, syntax, &asn_DEF_E2AP_PDU, (void **) &pdu,
  50                     data.buffer, data.len);
  51
  52
  53   int index = (int)pdu->present;
  54   fprintf(stderr, "length of data %d\n", rval.consumed);
  55   fprintf(stderr, "result %d\n", rval.code);
  56   fprintf(stderr, "index is %d\n", index);
  57
  58   fprintf(stderr, "showing xer of data\n");
  59
  60   xer_fprint(stderr, &asn_DEF_E2AP_PDU, pdu);
  61
  62   int procedureCode = e2ap_asn1c_get_procedureCode(pdu);
  63   index = (int)pdu->present;
  64
  65   LOG_D("[E2AP] Unpacked E2AP-PDU: index = %d, procedureCode = %d\n",
  66                             index, procedureCode);
  67
  68   switch(procedureCode)
  69     {
  70
  71     case ProcedureCode_id_E2setup:
  72       switch(index)
  73         {
  74         case E2AP_PDU_PR_initiatingMessage:
  75           e2ap_handle_E2SetupRequest(pdu, socket_fd);
  76           LOG_I("[E2AP] Received SETUP-REQUEST");
  77           break;
  78
  79         case E2AP_PDU_PR_successfulOutcome:
  80           LOG_I("[E2AP] Received SETUP-RESPONSE-SUCCESS");
  81           break;
  82
  83         case E2AP_PDU_PR_unsuccessfulOutcome:
  84           LOG_I("[E2AP] Received SETUP-RESPONSE-FAILURE");
  85           break;
  86
  87         default:
  88           LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU", index);
  89           break;
  90         }
  91       break;
  92
  93     case ProcedureCode_id_Reset: //reset = 7
  94       switch(index)
  95         {
  96         case E2AP_PDU_PR_initiatingMessage:
  97           LOG_I("[E2AP] Received RESET-REQUEST");
  98           break;
  99
 100         case E2AP_PDU_PR_successfulOutcome:
 101           break;
 102
 103         case E2AP_PDU_PR_unsuccessfulOutcome:
 104           break;
 105
 106         default:
 107           LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU", index);
 108           break;
 109         }
 110       break;
 111
 112     case ProcedureCode_id_RICsubscription: //RIC SUBSCRIPTION = 201
 113       switch(index)
 114         {
 115         case E2AP_PDU_PR_initiatingMessage: { //initiatingMessage
 116           LOG_I("[E2AP] Received RIC-SUBSCRIPTION-REQUEST");
 117           //          e2ap_handle_RICSubscriptionRequest(pdu, socket_fd);
 118           long func_id = encoding::get_function_id_from_subscription(pdu);
 119           fprintf(stderr, "Function Id of message is %d\n", func_id);
 120           SubscriptionCallback cb;
 121
 122           bool func_exists = true;
 123
 124           try {
 125             cb = e2sim->get_subscription_callback(func_id);
 126           } catch(const std::out_of_range& e) {
 127             func_exists = false;
 128           }
 129
 130           if (func_exists) {
 131             fprintf(stderr, "Calling callback function\n");
 132             cb(pdu);
 133           } else {
 134             fprintf(stderr, "Error: No RAN Function with this ID exists\n");
 135           }
 136           //      callback_kpm_subscription_request(pdu, socket_fd);
 137
 138         }
 139           break;
 140
 141         case E2AP_PDU_PR_successfulOutcome:
 142           LOG_I("[E2AP] Received RIC-SUBSCRIPTION-RESPONSE");
 143           break;
 144
 145         case E2AP_PDU_PR_unsuccessfulOutcome:
 146           LOG_I("[E2AP] Received RIC-SUBSCRIPTION-FAILURE");
 147           break;
 148
 149         default:
 150           LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU", index);
 151           break;
 152         }
 153       break;
 154
 155     case ProcedureCode_id_RICindication: // 205
 156       switch(index)
 157         {
 158         case E2AP_PDU_PR_initiatingMessage: //initiatingMessage
 159           LOG_I("[E2AP] Received RIC-INDICATION-REQUEST");
 160           // e2ap_handle_RICSubscriptionRequest(pdu, socket_fd);
 161           break;
 162         case E2AP_PDU_PR_successfulOutcome:
 163           LOG_I("[E2AP] Received RIC-INDICATION-RESPONSE");
 164           break;
 165
 166         case E2AP_PDU_PR_unsuccessfulOutcome:
 167           LOG_I("[E2AP] Received RIC-INDICATION-FAILURE");
 168           break;
 169
 170         default:
 171           LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU %d", index,
 172                                     (int)ProcedureCode_id_RICindication);
 173           break;
 174         }
 175       break;
 176
 177     case ProcedureCode_id_RICserviceQuery:
 178       switch (index)
 179         {
 180           case E2AP_PDU_PR_initiatingMessage:
 181           LOG_I("[E2AP] Received RIC-Service-Query")
 182           e2ap_handle_E2SeviceRequest(pdu, socket_fd, e2sim);
 183           break;
 184
 185           default:
 186             LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU %d", index,
 187                                     (int)ProcedureCode_id_RICserviceQuery);
 188           break;
 189         }
 190       break;
 191
 192     case ProcedureCode_id_RICserviceUpdate:
 193       switch (index)
 194         {
 195           case E2AP_PDU_PR_successfulOutcome:
 196           LOG_I("[E2AP] Received RIC-SERVICE-UPDATE-SUCCESS")
 197           break;
 198
 199           case E2AP_PDU_PR_unsuccessfulOutcome:
 200           LOG_I("[E2AP] Received RIC-SERVICE-UPDATE-FAILURE")
 201           break;
 202
 203           default:
 204             LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU %d", index,
 205                                     (int)ProcedureCode_id_RICserviceUpdate);
 206           break;
 207         }
 208       break;
 209
 210     default:
 211
 212       LOG_E("[E2AP] No available handler for procedureCode=%d", procedureCode);
 213
 214       break;
 215     }
 216 }
 217
 218 void e2ap_handle_E2SeviceRequest(E2AP_PDU_t* pdu, int &socket_fd, E2Sim *e2sim) {
 219
 220   auto buffer_size = MAX_SCTP_BUFFER;
 221   unsigned char buffer[MAX_SCTP_BUFFER];
 222   E2AP_PDU_t* res_pdu = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU));
 223
 224   // prepare ran function defination
 225   std::vector<encoding::ran_func_info> all_funcs;
 226
 227   //Loop through RAN function definitions that are registered
 228
 229   for (std::pair<long, OCTET_STRING_t*> elem : e2sim->getRegistered_ran_functions()) {
 230     printf("looping through ran func\n");
 231     encoding::ran_func_info next_func;
 232
 233     next_func.ranFunctionId = elem.first;
 234     next_func.ranFunctionDesc = elem.second;
 235     next_func.ranFunctionRev = (long)3;
 236     all_funcs.push_back(next_func);
 237   }
 238
 239   printf("about to call service update encode\n");
 240
 241   encoding::generate_e2apv1_service_update(res_pdu, all_funcs);
 242
 243   LOG_D("[E2AP] Created E2-SERVICE-UPDATE");
 244
 245   e2ap_asn1c_print_pdu(res_pdu);
 246
 247   sctp_buffer_t data;
 248
 249   char *error_buf = (char*)calloc(300, sizeof(char));
 250   size_t errlen;
 251
 252   asn_check_constraints(&asn_DEF_E2AP_PDU, res_pdu, error_buf, &errlen);
 253   printf("error length %d\n", errlen);
 254   printf("error buf %s\n", error_buf);
 255
 256   auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, res_pdu, buffer, buffer_size);
 257
 258   data.len = er.encoded;
 259   fprintf(stderr, "er encoded is %d\n", er.encoded);
 260
 261   memcpy(data.buffer, buffer, er.encoded);
 262
 263   //send response data over sctp
 264   if(sctp_send_data(socket_fd, data) > 0) {
 265     LOG_I("[SCTP] Sent E2-SERVICE-UPDATE");
 266   } else {
 267     LOG_E("[SCTP] Unable to send E2-SERVICE-UPDATE to peer");
 268   }
 269 }
 270
 271 void e2ap_handle_E2SetupRequest(E2AP_PDU_t* pdu, int &socket_fd) {
 272
 273
 274   E2AP_PDU_t* res_pdu = (E2AP_PDU_t*)calloc(1, sizeof(E2AP_PDU));
 275   encoding::generate_e2apv1_setup_response(res_pdu);
 276
 277
 278   LOG_D("[E2AP] Created E2-SETUP-RESPONSE");
 279
 280   e2ap_asn1c_print_pdu(res_pdu);
 281
 282
 283   auto buffer_size = MAX_SCTP_BUFFER;
 284   unsigned char buffer[MAX_SCTP_BUFFER];
 285
 286   sctp_buffer_t data;
 287   auto er = asn_encode_to_buffer(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, res_pdu, buffer, buffer_size);
 288
 289   data.len = er.encoded;
 290   fprintf(stderr, "er encoded is %d\n", er.encoded);
 291
 292   //data.len = e2ap_asn1c_encode_pdu(res_pdu, &buf);
 293   memcpy(data.buffer, buffer, er.encoded);
 294
 295   //send response data over sctp
 296   if(sctp_send_data(socket_fd, data) > 0) {
 297     LOG_I("[SCTP] Sent E2-SETUP-RESPONSE");
 298   } else {
 299     LOG_E("[SCTP] Unable to send E2-SETUP-RESPONSE to peer");
 300   }
 301
 302   sleep(5);
 303
 304   //Sending Subscription Request
 305
 306   E2AP_PDU_t* pdu_sub = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU));
 307
 308   encoding::generate_e2apv1_subscription_request(pdu_sub);
 309
 310   xer_fprint(stderr, &asn_DEF_E2AP_PDU, pdu_sub);
 311
 312   auto buffer_size2 = MAX_SCTP_BUFFER;
 313   unsigned char buffer2[MAX_SCTP_BUFFER];
 314
 315   sctp_buffer_t data2;
 316
 317   auto er2 = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_sub, buffer2, buffer_size2);
 318
 319   data2.len = er2.encoded;
 320   memcpy(data2.buffer, buffer2, er2.encoded);
 321
 322   fprintf(stderr, "er encded is %d\n", er2.encoded);
 323
 324   if(sctp_send_data(socket_fd, data2) > 0) {
 325     LOG_I("[SCTP] Sent E2-SUBSCRIPTION-REQUEST");
 326   } else {
 327     LOG_E("[SCTP] Unable to send E2-SUBSCRIPTION-REQUEST to peer");
 328   }
 329
 330
 331 }
 332
 333 /*
 334 void e2ap_handle_RICSubscriptionRequest(E2AP_PDU_t* pdu, int &socket_fd)
 335 {
 336
 337   //Send back Subscription Success Response
 338
 339   E2AP_PDU_t* pdu_resp = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU));
 340
 341   generate_e2apv1_subscription_response(pdu_resp, pdu);
 342
 343   fprintf(stderr, "Subscription Response\n");
 344
 345   xer_fprint(stderr, &asn_DEF_E2AP_PDU, pdu_resp);
 346
 347   auto buffer_size2 = MAX_SCTP_BUFFER;
 348   unsigned char buffer2[MAX_SCTP_BUFFER];
 349
 350   sctp_buffer_t data2;
 351
 352   auto er2 = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_resp, buffer2, buffer_size2);
 353   data2.len = er2.encoded;
 354
 355   fprintf(stderr, "er encded is %d\n", er2.encoded);
 356
 357   memcpy(data2.buffer, buffer2, er2.encoded);
 358
 359   if(sctp_send_data(socket_fd, data2) > 0) {
 360     LOG_I("[SCTP] Sent RIC-SUBSCRIPTION-RESPONSE");
 361   } else {
 362     LOG_E("[SCTP] Unable to send RIC-SUBSCRIPTION-RESPONSE to peer");
 363   }
 364
 365
 366   //Send back an Indication
 367
 368   E2AP_PDU_t* pdu_ind = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU));
 369
 370   generate_e2apv1_indication_request(pdu_ind);
 371
 372   xer_fprint(stderr, &asn_DEF_E2AP_PDU, pdu_ind);
 373
 374   auto buffer_size = MAX_SCTP_BUFFER;
 375   unsigned char buffer[MAX_SCTP_BUFFER];
 376
 377   sctp_buffer_t data;
 378
 379   auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_ind, buffer, buffer_size);
 380   data.len = er.encoded;
 381
 382   fprintf(stderr, "er encded is %d\n", er.encoded);
 383
 384   memcpy(data.buffer, buffer, er.encoded);
 385
 386   if(sctp_send_data(socket_fd, data) > 0) {
 387     LOG_I("[SCTP] Sent RIC-INDICATION-REQUEST");
 388   } else {
 389     LOG_E("[SCTP] Unable to send RIC-INDICATION-REQUEST to peer");
 390   }
 391
 392 }
 393 */
 394
 395
 396