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

   1
   2
   3 /*****************************************************************************
   4 #                                                                            *
   5 # Copyright 2019 AT&T Intellectual Property                                  *
   6 # Copyright 2019 Nokia                                                       *
   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 #include "kpm_callbacks.hpp"
  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 = get_function_id_from_subscription(pdu);
 119           SubscriptionCallback cb = e2sim->get_subscription_callback(func_id);
 120           cb(pdu);
 121           //      callback_kpm_subscription_request(pdu, socket_fd);
 122
 123         }
 124           break;
 125
 126         case E2AP_PDU_PR_successfulOutcome:
 127           LOG_I("[E2AP] Received RIC-SUBSCRIPTION-RESPONSE");
 128           break;
 129
 130         case E2AP_PDU_PR_unsuccessfulOutcome:
 131           LOG_I("[E2AP] Received RIC-SUBSCRIPTION-FAILURE");
 132           break;
 133
 134         default:
 135           LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU", index);
 136           break;
 137         }
 138       break;
 139
 140     case ProcedureCode_id_RICindication: // 205
 141       switch(index)
 142         {
 143         case E2AP_PDU_PR_initiatingMessage: //initiatingMessage
 144           LOG_I("[E2AP] Received RIC-INDICATION-REQUEST");
 145           // e2ap_handle_RICSubscriptionRequest(pdu, socket_fd);
 146           break;
 147         case E2AP_PDU_PR_successfulOutcome:
 148           LOG_I("[E2AP] Received RIC-INDICATION-RESPONSE");
 149           break;
 150
 151         case E2AP_PDU_PR_unsuccessfulOutcome:
 152           LOG_I("[E2AP] Received RIC-INDICATION-FAILURE");
 153           break;
 154
 155         default:
 156           LOG_E("[E2AP] Invalid message index=%d in E2AP-PDU %d", index,
 157                                     (int)ProcedureCode_id_RICindication);
 158           break;
 159         }
 160       break;
 161
 162     default:
 163
 164       LOG_E("[E2AP] No available handler for procedureCode=%d", procedureCode);
 165
 166       break;
 167     }
 168 }
 169
 170 void e2ap_handle_E2SetupRequest(E2AP_PDU_t* pdu, int &socket_fd) {
 171
 172
 173   E2AP_PDU_t* res_pdu = (E2AP_PDU_t*)calloc(1, sizeof(E2AP_PDU));
 174   generate_e2apv1_setup_response(res_pdu);
 175
 176
 177   LOG_D("[E2AP] Created E2-SETUP-RESPONSE");
 178
 179   e2ap_asn1c_print_pdu(res_pdu);
 180
 181
 182   auto buffer_size = MAX_SCTP_BUFFER;
 183   unsigned char buffer[MAX_SCTP_BUFFER];
 184
 185   sctp_buffer_t data;
 186   auto er = asn_encode_to_buffer(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, res_pdu, buffer, buffer_size);
 187
 188   data.len = er.encoded;
 189   fprintf(stderr, "er encoded is %d\n", er.encoded);
 190
 191   //data.len = e2ap_asn1c_encode_pdu(res_pdu, &buf);
 192   memcpy(data.buffer, buffer, er.encoded);
 193
 194   //send response data over sctp
 195   if(sctp_send_data(socket_fd, data) > 0) {
 196     LOG_I("[SCTP] Sent E2-SETUP-RESPONSE");
 197   } else {
 198     LOG_E("[SCTP] Unable to send E2-SETUP-RESPONSE to peer");
 199   }
 200
 201   sleep(5);
 202
 203   //Sending Subscription Request
 204
 205   E2AP_PDU_t* pdu_sub = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU));
 206
 207   generate_e2apv1_subscription_request(pdu_sub);
 208
 209   xer_fprint(stderr, &asn_DEF_E2AP_PDU, pdu_sub);
 210
 211   auto buffer_size2 = MAX_SCTP_BUFFER;
 212   unsigned char buffer2[MAX_SCTP_BUFFER];
 213
 214   sctp_buffer_t data2;
 215
 216   auto er2 = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_sub, buffer2, buffer_size2);
 217
 218   data2.len = er2.encoded;
 219   memcpy(data2.buffer, buffer2, er2.encoded);
 220
 221   fprintf(stderr, "er encded is %d\n", er2.encoded);
 222
 223   if(sctp_send_data(socket_fd, data2) > 0) {
 224     LOG_I("[SCTP] Sent E2-SUBSCRIPTION-REQUEST");
 225   } else {
 226     LOG_E("[SCTP] Unable to send E2-SUBSCRIPTION-REQUEST to peer");
 227   }
 228
 229
 230 }
 231
 232
 233 void e2ap_handle_RICSubscriptionRequest(E2AP_PDU_t* pdu, int &socket_fd)
 234 {
 235
 236   //Send back Subscription Success Response
 237
 238   E2AP_PDU_t* pdu_resp = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU));
 239
 240   generate_e2apv1_subscription_response(pdu_resp, pdu);
 241
 242   fprintf(stderr, "Subscription Response\n");
 243
 244   xer_fprint(stderr, &asn_DEF_E2AP_PDU, pdu_resp);
 245
 246   auto buffer_size2 = MAX_SCTP_BUFFER;
 247   unsigned char buffer2[MAX_SCTP_BUFFER];
 248
 249   sctp_buffer_t data2;
 250
 251   auto er2 = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_resp, buffer2, buffer_size2);
 252   data2.len = er2.encoded;
 253
 254   fprintf(stderr, "er encded is %d\n", er2.encoded);
 255
 256   memcpy(data2.buffer, buffer2, er2.encoded);
 257
 258   if(sctp_send_data(socket_fd, data2) > 0) {
 259     LOG_I("[SCTP] Sent RIC-SUBSCRIPTION-RESPONSE");
 260   } else {
 261     LOG_E("[SCTP] Unable to send RIC-SUBSCRIPTION-RESPONSE to peer");
 262   }
 263
 264
 265   //Send back an Indication
 266
 267   E2AP_PDU_t* pdu_ind = (E2AP_PDU_t*)calloc(1,sizeof(E2AP_PDU));
 268
 269   generate_e2apv1_indication_request(pdu_ind);
 270
 271   xer_fprint(stderr, &asn_DEF_E2AP_PDU, pdu_ind);
 272
 273   auto buffer_size = MAX_SCTP_BUFFER;
 274   unsigned char buffer[MAX_SCTP_BUFFER];
 275
 276   sctp_buffer_t data;
 277
 278   auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu_ind, buffer, buffer_size);
 279   data.len = er.encoded;
 280
 281   fprintf(stderr, "er encded is %d\n", er.encoded);
 282
 283   memcpy(data.buffer, buffer, er.encoded);
 284
 285   if(sctp_send_data(socket_fd, data) > 0) {
 286     LOG_I("[SCTP] Sent RIC-INDICATION-REQUEST");
 287   } else {
 288     LOG_E("[SCTP] Unable to send RIC-INDICATION-REQUEST to peer");
 289   }
 290
 291 }
 292
 293
 294
 295