src/xapp-mgmt/msgs_proc.cc

   1 /*
   2 ==================================================================================
   3
   4         Copyright (c) 2018-2019 AT&T Intellectual Property.
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19 /*
  20  * msgs_proc.cc
  21  * Created on: 2019
  22  * Author: Ashwin Shridharan, Shraboni Jana
  23  */
  24
  25
  26 #include "msgs_proc.hpp"
  27
  28 //sending messages are encoded.
  29 bool XappMsgHandler::encode_subscription_request(unsigned char* buffer, size_t *buf_len)
  30 {
  31         int request_id = 2; // will be over-written by subscription handler
  32         int req_seq = 1;
  33         int function_id = 0;
  34         int action_id = 1;
  35         int action_type = 0;
  36         int subsequent_action = 0; // continue
  37         int time_to_wait = 4; // 10ms
  38
  39         int message_type = 1;
  40         int procedure_code = 27;
  41         std::string egnb_id = "Testgnb";
  42         std::string plmn_id = "Testplmn";
  43
  44         unsigned char event_buf[128];
  45         size_t event_buf_len = 128;
  46         bool res;
  47
  48
  49         e2sm_event_trigger_helper trigger_data;
  50         e2sm_event_trigger event_trigger;
  51
  52         trigger_data.egNB_id = egnb_id;
  53         trigger_data.plmn_id = plmn_id;
  54         trigger_data.egNB_id_type = 2;
  55         trigger_data.interface_direction = 1;
  56         trigger_data.procedure_code = procedure_code;
  57         trigger_data.message_type = message_type;
  58         //======================================================
  59
  60         // Encode the event trigger definition
  61         res = event_trigger.encode_event_trigger(&event_buf[0], &event_buf_len, trigger_data);
  62         if (!res){
  63                 mdclog_write(MDCLOG_ERR, "Error : %s, %d: Could not encode subscription Request. Reason = %s\n", __FILE__, __LINE__, event_trigger.get_error().c_str());
  64                 return false;
  65         }
  66         mdclog_write(MDCLOG_INFO, "Encoded event trigger definition into PDU of size %lu bytes\n", event_buf_len);
  67
  68
  69         // create the subscription
  70         subscription_helper subscr_req;
  71         subscription_request e2ap_sub_req;
  72
  73         subscr_req.clear();
  74         subscr_req.set_request(request_id, req_seq);
  75         subscr_req.set_function_id(function_id);
  76         subscr_req.add_action(action_id, action_type, "", subsequent_action, time_to_wait);
  77
  78         subscr_req.set_event_def(&event_buf[0], event_buf_len);
  79         // generate the request pdu
  80         res = e2ap_sub_req.encode_e2ap_subscription(&buffer[0], buf_len, subscr_req);
  81         if(! res){
  82                 mdclog_write(MDCLOG_ERR, "%s, %d: Error encoding subscription pdu. Reason = ", __FILE__, __LINE__);
  83                 return false;
  84         }
  85         return true;
  86 }
  87 bool XappMsgHandler::encode_subscription_delete_request(unsigned char* buffer, size_t *buf_len){
  88
  89         subscription_helper sub_helper;
  90         sub_helper.set_request(0, 0); // requirement of subscription manager ... ?
  91         sub_helper.set_function_id(0);
  92
  93         subscription_delete e2ap_sub_req_del;
  94
  95           // generate the delete request pdu
  96
  97           bool res = e2ap_sub_req_del.encode_e2ap_subscription(&buffer[0], buf_len, sub_helper);
  98           if(! res){
  99             mdclog_write(MDCLOG_ERR, "%s, %d: Error encoding subscription delete request pdu. Reason = %s", __FILE__, __LINE__, e2ap_sub_req_del.get_error().c_str());
 100             return false;
 101           }
 102
 103         return true;
 104
 105 }
 106
 107 bool XappMsgHandler::decode_subscription_response(unsigned char* data_buf, size_t data_size){
 108
 109         bool res = true;
 110         E2N_E2AP_PDU_t *e2pdu = 0;
 111
 112         asn_dec_rval_t rval;
 113
 114         ASN_STRUCT_RESET(asn_DEF_E2N_E2AP_PDU, e2pdu);
 115
 116         rval = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&e2pdu, data_buf, data_size);
 117         switch(rval.code)
 118         {
 119                 case RC_OK:
 120                           //Put in Subscription Response Object.
 121                            asn_fprint(stdout, &asn_DEF_E2N_E2AP_PDU, e2pdu);
 122
 123                            break;
 124                 case RC_WMORE:
 125                                 mdclog_write(MDCLOG_ERR, "RC_WMORE");
 126                                 res = false;
 127                                 break;
 128                 case RC_FAIL:
 129                                 mdclog_write(MDCLOG_ERR, "RC_FAIL");
 130                                 res = false;
 131                                 break;
 132                 default:
 133                                 break;
 134          }
 135         ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2pdu);
 136         return res;
 137
 138 }
 139 bool XappMsgHandler::decode_subscription_delete_response(unsigned char* data_buf, size_t data_size){
 140
 141         bool res = true;
 142         E2N_E2AP_PDU_t *e2pdu = 0;
 143
 144         asn_dec_rval_t rval;
 145
 146         ASN_STRUCT_RESET(asn_DEF_E2N_E2AP_PDU, e2pdu);
 147
 148         rval = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&e2pdu, data_buf, data_size);
 149         switch(rval.code)
 150         {
 151                 case RC_OK:
 152                           //Put in Subscription Delete Response Object.
 153                            asn_fprint(stdout, &asn_DEF_E2N_E2AP_PDU, e2pdu);
 154                            break;
 155                 case RC_WMORE:
 156                                 mdclog_write(MDCLOG_ERR, "RC_WMORE");
 157                                 res = false;
 158                                 break;
 159                 case RC_FAIL:
 160                                 mdclog_write(MDCLOG_ERR, "RC_FAIL");
 161                                 res = false;
 162                                 break;
 163                 default:
 164                                 break;
 165          }
 166         ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2pdu);
 167         return res;
 168
 169 }
 170 bool XappMsgHandler::decode_subscription_response_failure(unsigned char* data_buf, size_t data_size){
 171
 172         bool res = true;
 173         E2N_E2AP_PDU_t *e2pdu = 0;
 174
 175         asn_dec_rval_t rval;
 176
 177         ASN_STRUCT_RESET(asn_DEF_E2N_E2AP_PDU, e2pdu);
 178
 179         rval = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&e2pdu, data_buf, data_size);
 180         switch(rval.code)
 181         {
 182                 case RC_OK:
 183                           //Extract Subscription Response Failure.
 184                            asn_fprint(stdout, &asn_DEF_E2N_E2AP_PDU, e2pdu);
 185                            break;
 186                 case RC_WMORE:
 187                                 mdclog_write(MDCLOG_ERR, "RC_WMORE");
 188                                 res = false;
 189                                 break;
 190                 case RC_FAIL:
 191                                 mdclog_write(MDCLOG_ERR, "RC_FAIL");
 192                                 res = false;
 193                                 break;
 194                 default:
 195                                 break;
 196          }
 197         ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2pdu);
 198         return res;
 199
 200 }
 201
 202 bool XappMsgHandler::decode_subscription_delete_response_failure(unsigned char* data_buf, size_t data_size){
 203
 204         bool res = true;
 205         E2N_E2AP_PDU_t *e2pdu = 0;
 206
 207         asn_dec_rval_t rval;
 208
 209         ASN_STRUCT_RESET(asn_DEF_E2N_E2AP_PDU, e2pdu);
 210
 211         rval = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, (void**)&e2pdu, data_buf, data_size);
 212         switch(rval.code)
 213         {
 214                 case RC_OK:
 215                           //Extract Subscription Delete Response Failure.
 216                            asn_fprint(stdout, &asn_DEF_E2N_E2AP_PDU, e2pdu);
 217                                 break;
 218                 case RC_WMORE:
 219                                 mdclog_write(MDCLOG_ERR, "RC_WMORE");
 220                                 res = false;
 221                                 break;
 222                 case RC_FAIL:
 223                                 mdclog_write(MDCLOG_ERR, "RC_FAIL");
 224                                 res = false;
 225                                 break;
 226                 default:
 227                                 break;
 228          }
 229         ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2pdu);
 230         return res;
 231
 232 }
 233
 234 //For processing received messages.
 235 void XappMsgHandler::operator()(rmr_mbuf_t *message, bool *resend){
 236
 237   if (message->len > MAX_RMR_RECV_SIZE){
 238     mdclog_write(MDCLOG_ERR, "Error : %s, %d, RMR message larger than %d. Ignoring ...", __FILE__, __LINE__, MAX_RMR_RECV_SIZE);
 239     return;
 240   }
 241
 242   switch(message->mtype){
 243           //need to fix the health check.
 244           case (RIC_HEALTH_CHECK_REQ):
 245                 message->mtype = RIC_HEALTH_CHECK_RESP;        // if we're here we are running and all is ok
 246             message->sub_id = -1;
 247                 strncpy( (char*)message->payload, "HELLOWORLD OK\n", rmr_payload_size( message) );
 248             *resend = true;
 249           break;
 250
 251           case (RIC_SUB_RESP):
 252                 //Received Subscription Response Message
 253                 decode_subscription_response(message->payload,message->len);
 254           break;
 255
 256           case (RIC_SUB_DEL_RESP):
 257                 decode_subscription_delete_response(message->payload,message->len);
 258           break;
 259
 260           case (RIC_SUB_FAILURE):
 261                 decode_subscription_response_failure(message->payload, message->len);
 262       break;
 263
 264           case (RIC_SUB_DEL_FAILURE):
 265                 decode_subscription_delete_response_failure(message->payload,message->len);
 266           break;
 267           //  case A1_POLICY_REQ:
 268          // break;
 269
 270
 271   default:
 272         *resend = false;
 273     mdclog_write(MDCLOG_ERR, "Error :: Unknown message type %d received from RMR", message->mtype);
 274
 275   }
 276
 277   return;
 278
 279 };
 280
 281