ric_benchmarking/e2-interface/e2sim/previous/e2apv1sim/e2sim/src/E2APr/e2ap_message_handler.cpp

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