src/xapp-mgmt/msgs_proc.cc

   1 /*
   2 ==================================================================================
   3
   4         Copyright (c) 2019-2020 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
  29 bool XappMsgHandler::encode_subscription_delete_request(unsigned char* buffer, size_t *buf_len){
  30
  31         subscription_helper sub_helper;
  32         sub_helper.set_request(0); // requirement of subscription manager ... ?
  33         sub_helper.set_function_id(0);
  34
  35         subscription_delete e2ap_sub_req_del;
  36
  37           // generate the delete request pdu
  38
  39           bool res = e2ap_sub_req_del.encode_e2ap_subscription(&buffer[0], buf_len, sub_helper);
  40           if(! res){
  41             mdclog_write(MDCLOG_ERR, "%s, %d: Error encoding subscription delete request pdu. Reason = %s", __FILE__, __LINE__, e2ap_sub_req_del.get_error().c_str());
  42             return false;
  43           }
  44
  45         return true;
  46
  47 }
  48
  49 bool XappMsgHandler::decode_subscription_response(unsigned char* data_buf, size_t data_size){
  50
  51         subscription_helper subhelper;
  52         subscription_response subresponse;
  53         bool res = true;
  54         E2AP_PDU_t *e2pdu = 0;
  55
  56         asn_dec_rval_t rval;
  57
  58         ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, e2pdu);
  59
  60         rval = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&e2pdu, data_buf, data_size);
  61         switch(rval.code)
  62         {
  63                 case RC_OK:
  64                            //Put in Subscription Response Object.
  65                            //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
  66                            break;
  67                 case RC_WMORE:
  68                                 mdclog_write(MDCLOG_ERR, "RC_WMORE");
  69                                 res = false;
  70                                 break;
  71                 case RC_FAIL:
  72                                 mdclog_write(MDCLOG_ERR, "RC_FAIL");
  73                                 res = false;
  74                                 break;
  75                 default:
  76                                 break;
  77          }
  78         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2pdu);
  79         return res;
  80
  81 }
  82
  83 bool  XappMsgHandler::a1_policy_handler(char * message, int *message_len, a1_policy_helper &helper){
  84
  85   rapidjson::Document doc;
  86   if (doc.Parse<kParseStopWhenDoneFlag>(message).HasParseError()){
  87     mdclog_write(MDCLOG_ERR, "Error: %s, %d :: Could not decode A1 JSON message %s\n", __FILE__, __LINE__, message);
  88     return false;
  89   }
  90
  91   //Extract Operation
  92   rapidjson::Pointer temp1("/operation");
  93     rapidjson::Value * ref1 = temp1.Get(doc);
  94     if (ref1 == NULL){
  95       mdclog_write(MDCLOG_ERR, "Error : %s, %d:: Could not extract policy type id from %s\n", __FILE__, __LINE__, message);
  96       return false;
  97     }
  98
  99    helper.operation = ref1->GetString();
 100
 101   // Extract policy id type
 102   rapidjson::Pointer temp2("/policy_type_id");
 103   rapidjson::Value * ref2 = temp2.Get(doc);
 104   if (ref2 == NULL){
 105     mdclog_write(MDCLOG_ERR, "Error : %s, %d:: Could not extract policy type id from %s\n", __FILE__, __LINE__, message);
 106     return false;
 107   }
 108    //helper.policy_type_id = ref2->GetString();
 109     helper.policy_type_id = to_string(ref2->GetInt());
 110
 111     // Extract policy instance id
 112     rapidjson::Pointer temp("/policy_instance_id");
 113     rapidjson::Value * ref = temp.Get(doc);
 114     if (ref == NULL){
 115       mdclog_write(MDCLOG_ERR, "Error : %s, %d:: Could not extract policy type id from %s\n", __FILE__, __LINE__, message);
 116       return false;
 117     }
 118     helper.policy_instance_id = ref->GetString();
 119
 120     if (helper.policy_type_id == "1" && helper.operation == "CREATE"){
 121         helper.status = "OK";
 122         Document::AllocatorType& alloc = doc.GetAllocator();
 123
 124         Value handler_id;
 125         handler_id.SetString(helper.handler_id.c_str(), helper.handler_id.length(), alloc);
 126
 127         Value status;
 128         status.SetString(helper.status.c_str(), helper.status.length(), alloc);
 129
 130
 131         doc.AddMember("handler_id", handler_id, alloc);
 132         doc.AddMember("status",status, alloc);
 133         doc.RemoveMember("operation");
 134         StringBuffer buffer;
 135         Writer<StringBuffer> writer(buffer);
 136         doc.Accept(writer);
 137         strncpy(message,buffer.GetString(), buffer.GetLength());
 138         *message_len = buffer.GetLength();
 139         return true;
 140     }
 141     return false;
 142  }
 143
 144
 145 //For processing received messages.XappMsgHandler should mention if resend is required or not.
 146 void XappMsgHandler::operator()(rmr_mbuf_t *message, bool *resend){
 147
 148         if (message->len > MAX_RMR_RECV_SIZE){
 149                 mdclog_write(MDCLOG_ERR, "Error : %s, %d, RMR message larger than %d. Ignoring ...", __FILE__, __LINE__, MAX_RMR_RECV_SIZE);
 150                 return;
 151         }
 152         a1_policy_helper helper;
 153         bool res=false;
 154         std::string str_meid;
 155         switch(message->mtype){
 156                 //need to fix the health check.
 157                 case (RIC_HEALTH_CHECK_REQ):
 158                                 message->mtype = RIC_HEALTH_CHECK_RESP;        // if we're here we are running and all is ok
 159                                 message->sub_id = -1;
 160                                 strncpy( (char*)message->payload, "HELLOWORLD OK\n", rmr_payload_size( message) );
 161                                 *resend = true;
 162                                 break;
 163
 164                 case (RIC_SUB_RESP):
 165                         mdclog_write(MDCLOG_INFO, "Received subscription message of type = %d", message->mtype);
 166                                 unsigned char *me_id;
 167                                 if( (me_id = (unsigned char *) malloc( sizeof( unsigned char ) * RMR_MAX_MEID )) == NULL ) {
 168                                         mdclog_write(MDCLOG_ERR, "Error :  %s, %d : malloc failed for me_id", __FILE__, __LINE__);
 169                                         me_id = rmr_get_meid(message, NULL);
 170                                 } else {
 171                                         rmr_get_meid(message, me_id);
 172                                 }
 173                                 mdclog_write(MDCLOG_INFO,"RMR Received MEID: %s",me_id);
 174                                 str_meid.insert(0,(char*)me_id);
 175                                 if(_ref_sub_handler !=NULL){
 176                                         _ref_sub_handler->manage_subscription_response(message->mtype, str_meid);
 177                                 } else {
 178                                         mdclog_write(MDCLOG_ERR, " Error :: %s, %d : Subscription handler not assigned in message processor !", __FILE__, __LINE__);
 179                                 }
 180                                 *resend = false;
 181                                 if (me_id != NULL) {
 182                                         mdclog_write(MDCLOG_INFO, "Free RMR Received MEID memory: %s(0x%x)", me_id, me_id);
 183                                         free(me_id);
 184                                 }
 185                                 break;
 186
 187         case A1_POLICY_REQ:
 188
 189                     mdclog_write(MDCLOG_INFO, "In Message Handler: Received A1_POLICY_REQ.");
 190                         helper.handler_id = xapp_id;
 191
 192                         res = a1_policy_handler((char*)message->payload, &message->len, helper);
 193                         if(res){
 194                                 message->mtype = A1_POLICY_RESP;        // if we're here we are running and all is ok
 195                                 message->sub_id = -1;
 196                                 *resend = true;
 197                         }
 198                         break;
 199
 200         default:
 201                 {
 202                         mdclog_write(MDCLOG_ERR, "Error :: Unknown message type %d received from RMR", message->mtype);
 203                         *resend = false;
 204                 }
 205         }
 206
 207         return;
 208
 209 };
 210
 211