e2sim/e2apv1sim/src/E2AP/e2ap_message_handler.cpp

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