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