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