MME2 changes - Propped commits from openmme/paging branch. Added scripts
for code gen
Change-Id: Ie55032217232214ac8544ca76ea34335205329e4
diff --git a/src/mme-app/structs.cpp b/src/mme-app/structs.cpp
new file mode 100644
index 0000000..63f25c5
--- /dev/null
+++ b/src/mme-app/structs.cpp
@@ -0,0 +1,477 @@
+/*
+ * Copyright (c) 2019, Infosys Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <string>
+#include <sstream>
+#include <cstring>
+#include <iomanip>
+#include "structs.h"
+#include "log.h"
+
+using namespace std;
+
+uint8_t ASCII_TO_BCD(uint8_t left, uint8_t right)
+{
+ uint8_t bcd_value;
+
+ if(left >= '0' && left <= '9') // 0-9 range
+ {
+ bcd_value = ( left - 0x30) << 4 ; // 48 for '0' ASCII offset
+ }
+ else
+ {
+ bcd_value = 0x0f << 4; // filler 1111
+ }
+
+ if(right >= '0' && right <= '9') // 0-9 range
+ {
+ bcd_value |= ( right - 0x30); // 48 for '0' ASCII offset
+ }
+ else
+ {
+ bcd_value |= 0x0f; // filler 1111
+ }
+
+ return bcd_value;
+}
+
+/*******************************************************
+ *TAI
+********************************************************/
+Tai::Tai()
+{
+ memset( &tai_m, 0, sizeof( tai_m ));
+}
+
+Tai::Tai( const TAI& tai_i )
+{
+ memset( &tai_m, 0, sizeof( tai_m ));
+ memcpy( &tai_m, &tai_i, sizeof( tai_i ));
+}
+
+Tai::~Tai()
+{
+}
+
+void Tai::operator = ( const Tai& tai_i )
+{
+ memcpy( &tai_m, &(tai_i.tai_m), sizeof( tai_i.tai_m ));
+}
+
+/*******************************************************
+ *CGI
+********************************************************/
+Cgi::Cgi()
+{
+ memset( &cgi_m, 0, sizeof( cgi_m ));
+}
+
+Cgi::Cgi( const CGI& cgi_i )
+{
+ memset( &cgi_m, 0, sizeof( cgi_m ));
+ memcpy( &cgi_m, &cgi_i, sizeof(cgi_i));
+}
+
+Cgi::~Cgi()
+{
+}
+
+void Cgi::operator = ( const Cgi& cgi_i )
+{
+ memcpy( &cgi_m, &(cgi_i.cgi_m), sizeof(cgi_i.cgi_m));
+}
+
+/*******************************************************
+ *STMSI
+********************************************************/
+Stmsi::Stmsi()
+{
+ memset( &stmsi_m, 0, sizeof( stmsi_m ));
+}
+
+Stmsi::Stmsi( const STMSI& stmsi_i )
+{
+ memset( &stmsi_m, 0, sizeof( stmsi_m ));
+ memcpy( &stmsi_m, &stmsi_i, sizeof( stmsi_i ));
+}
+
+Stmsi::~Stmsi()
+{
+}
+
+void Stmsi::operator = ( const Stmsi& stmsi_i )
+{
+ memcpy( &stmsi_m, &(stmsi_i.stmsi_m), sizeof( stmsi_i.stmsi_m ));
+}
+
+/*******************************************************
+ *ARP
+********************************************************/
+Arp::Arp()
+{
+ memset( &arp_m, 0, sizeof( arp_m ));
+}
+
+Arp::Arp( const ARP& arp_i )
+{
+ memset( &arp_m, 0, sizeof( arp_m ));
+ memcpy( &arp_m, &arp_i, sizeof( arp_i ));
+}
+
+Arp::~Arp()
+{
+}
+
+void Arp::operator = ( const Arp& arp_i )
+{
+ memcpy( &arp_m, &(arp_i.arp_m), sizeof( arp_i.arp_m ));
+}
+
+
+/*******************************************************
+ *Ms_net_capab
+********************************************************/
+Ms_net_capab::Ms_net_capab()
+{
+ memset( &ms_net_capab_m, 0, sizeof( ms_net_capab_m ));
+}
+
+Ms_net_capab::Ms_net_capab( const MS_net_capab& net_cap_i )
+{
+ memset( &ms_net_capab_m, 0, sizeof( ms_net_capab_m ));
+ memcpy( &ms_net_capab_m, &net_cap_i, sizeof( net_cap_i ));
+}
+
+Ms_net_capab::~Ms_net_capab()
+{
+}
+
+void Ms_net_capab::operator = ( const Ms_net_capab& net_cap_i )
+{
+ memcpy( &ms_net_capab_m, &(net_cap_i.ms_net_capab_m), sizeof( net_cap_i.ms_net_capab_m ));
+}
+
+/*******************************************************
+*Ue_net_capab
+********************************************************/
+Ue_net_capab::Ue_net_capab()
+{
+ memset( &ue_net_capab_m, 0, sizeof( ue_net_capab_m ));
+}
+
+Ue_net_capab::Ue_net_capab( const UE_net_capab& net_cap_i )
+{
+ memset( &ue_net_capab_m, 0, sizeof( ue_net_capab_m ));
+ memcpy( &ue_net_capab_m, &net_cap_i, sizeof( net_cap_i ));
+}
+
+Ue_net_capab::~Ue_net_capab()
+{
+}
+
+void Ue_net_capab::operator = ( const Ue_net_capab& net_cap_i )
+{
+ memcpy( &ue_net_capab_m, &(net_cap_i.ue_net_capab_m), sizeof( net_cap_i.ue_net_capab_m ));
+}
+
+/*******************************************************
+*Secinfo
+********************************************************/
+Secinfo::Secinfo()
+{
+ memset( &secinfo_m, 0, sizeof( secinfo_m ));
+}
+
+Secinfo::Secinfo( const secinfo& sec_i )
+{
+ memset( &secinfo_m, 0, sizeof( secinfo_m ));
+ memcpy( &secinfo_m, &sec_i, sizeof( sec_i ));
+}
+
+Secinfo::~Secinfo()
+{
+}
+
+void Secinfo::operator = ( const Secinfo& sec_i )
+{
+ memcpy( &secinfo_m, &(sec_i.secinfo_m), sizeof( sec_i.secinfo_m ));
+}
+
+/*******************************************************
+*Ambr
+********************************************************/
+Ambr::Ambr()
+{
+ memset( &ambr_m, 0, sizeof( ambr_m ));
+}
+
+Ambr::Ambr( const AMBR& ambr_i )
+{
+ memset( &ambr_m, 0, sizeof( ambr_m ));
+ memcpy( &ambr_m, &ambr_i, sizeof( ambr_i ));
+}
+
+Ambr::~Ambr()
+{
+}
+
+void Ambr::operator = ( const Ambr& ambr_i )
+{
+ memcpy( &ambr_m, &(ambr_i.ambr_m), sizeof( ambr_i.ambr_m ));
+}
+
+/*******************************************************
+*E_utran_sec_vector
+********************************************************/
+E_utran_sec_vector::E_utran_sec_vector():AiaSecInfo_mp( NULL )
+{
+ AiaSecInfo_mp = (struct E_UTRAN_sec_vector*)calloc(sizeof(struct E_UTRAN_sec_vector), 1);
+}
+
+E_utran_sec_vector::E_utran_sec_vector( const E_UTRAN_sec_vector& secinfo_i )
+{
+ AiaSecInfo_mp = (struct E_UTRAN_sec_vector*)calloc(sizeof(struct E_UTRAN_sec_vector), 1);
+ memcpy( AiaSecInfo_mp, &secinfo_i, sizeof( E_UTRAN_sec_vector ));
+}
+
+E_utran_sec_vector::~E_utran_sec_vector()
+{
+ free(AiaSecInfo_mp);
+}
+
+void E_utran_sec_vector::operator = ( const E_utran_sec_vector& secinfo_i )
+{
+ if( NULL != secinfo_i.AiaSecInfo_mp )
+ {
+ memcpy( AiaSecInfo_mp, secinfo_i.AiaSecInfo_mp, sizeof( E_UTRAN_sec_vector ));
+ }
+}
+
+std::ostream& operator << ( std::ostream& os, const E_utran_sec_vector& data_i )
+{
+ os << "RAND ";
+ for ( uint32_t i = 0; i < data_i.AiaSecInfo_mp->rand.len; i++)
+ {
+ os << setfill('0') << setw(2) << std::hex <<
+ static_cast<uint32_t>(data_i.AiaSecInfo_mp->rand.val[i]);
+ }
+ os << std::endl;
+
+ os << "RES ";
+ for ( uint32_t i = 0; i < data_i.AiaSecInfo_mp->xres.len; i++)
+ {
+ os << setfill('0') << setw(2) << std::hex <<
+ static_cast<uint32_t>(data_i.AiaSecInfo_mp->xres.val[i]);
+ }
+ os << std::endl;
+
+ os << "AUTN ";
+ for ( uint32_t i = 0; i < data_i.AiaSecInfo_mp->autn.len; i++)
+ {
+ os << setfill('0') << setw(2) << std::hex <<
+ static_cast<uint32_t>(data_i.AiaSecInfo_mp->autn.val[i]);
+ }
+ os << std::endl;
+
+ os << "KASME ";
+ for ( uint32_t i = 0; i < data_i.AiaSecInfo_mp->kasme.len; i++)
+ {
+ os << setfill('0') << setw(2) << std::hex <<
+ static_cast<uint32_t>(data_i.AiaSecInfo_mp->kasme.val[i]);
+ }
+ os << std::endl;
+
+ return os;
+}
+
+/*******************************************************
+*Fteid
+********************************************************/
+Fteid::Fteid()
+{
+ memset( &fteid_m, 0, sizeof( fteid_m ));
+}
+
+Fteid::Fteid( const fteid& fteid_i )
+{
+ memset( &fteid_m, 0, sizeof( fteid_m ));
+ memcpy( &fteid_m, &fteid_i, sizeof( fteid_i ));
+}
+
+Fteid::~Fteid()
+{
+}
+
+void Fteid::operator = ( const Fteid& fteid_i )
+{
+ memcpy( &fteid_m, &(fteid_i.fteid_m), sizeof( fteid_i.fteid_m ));
+}
+
+/*******************************************************
+*Paa
+********************************************************/
+Paa::Paa()
+{
+ memset( &paa_m, 0, sizeof( paa_m ));
+}
+
+Paa::Paa( const PAA& paa_i )
+{
+ memset( &paa_m, 0, sizeof( paa_m ));
+ memcpy( &paa_m, &paa_i, sizeof( paa_i ));
+}
+
+Paa::~Paa()
+{
+}
+
+void Paa::operator = ( const Paa& paa_i )
+{
+ memcpy( &paa_m, &(paa_i.paa_m), sizeof( paa_i.paa_m ));
+}
+
+/*******************************************************
+*Apn_name
+********************************************************/
+Apn_name::Apn_name()
+{
+ memset( &apnname_m, 0, sizeof( apnname_m ));
+}
+
+Apn_name::Apn_name( const apn_name& apn_name_i )
+{
+ memset( &apnname_m, 0, sizeof( apnname_m ));
+ memcpy( &apnname_m, &apn_name_i, sizeof( apn_name_i ));
+}
+
+Apn_name::~Apn_name()
+{
+}
+
+void Apn_name::operator = ( const Apn_name& apn_name_i )
+{
+ memcpy( &apnname_m, &(apn_name_i.apnname_m), sizeof( apn_name_i.apnname_m ));
+}
+
+/*******************************************************
+*DigitRegister15
+********************************************************/
+DigitRegister15::DigitRegister15()
+{
+ memset(&digitsArray,0,15);
+}
+
+void DigitRegister15::convertToBcdArray( uint8_t * arrayOut ) const
+{
+ for( int i=0; i < 7; i++ )
+ {
+ arrayOut[i] = ASCII_TO_BCD(digitsArray[2*i+1],digitsArray[2*i]);
+ }
+ arrayOut[7] = ASCII_TO_BCD(0x0f,digitsArray[14]);
+}
+
+void DigitRegister15::convertFromBcdArray( const uint8_t* bcdArrayIn )
+{
+ // For the imsi value upper nibble of first octect should only be considered
+ if(( bcdArrayIn[0] & 0x0f ) == 0x0f )
+ {
+ digitsArray[0] = (uint8_t)(((bcdArrayIn[0] >> 4) & 0x0f ) + 0x30);
+ for( int i = 1; i < 8; i++ )
+ {
+ digitsArray[2*i] = (uint8_t)(((bcdArrayIn[i] >> 4) & 0x0f) + 0x30);
+ digitsArray[2*i-1] = (uint8_t)((bcdArrayIn[i] & 0x0f) + 0x30);
+ }
+ }
+ else
+ {
+ for( int i = 0; i < 7; i++ )
+ {
+ digitsArray[2*i+1] = (uint8_t)(((bcdArrayIn[i] >> 4) & 0x0f) + 0x30);
+ digitsArray[2*i] = (uint8_t)((bcdArrayIn[i] & 0x0f) + 0x30);
+ }
+ digitsArray[7] = (uint8_t)(((bcdArrayIn[7] >> 4) & 0x0f) + 0x30);
+ }
+ return;
+}
+
+
+void DigitRegister15::setImsiDigits( uint8_t* digitsArrayIn )
+{
+ memcpy( digitsArray, digitsArrayIn, 15);
+}
+
+void DigitRegister15::getImsiDigits( uint8_t* digitsArrayIn ) const
+{
+ memcpy( digitsArrayIn, digitsArray, 15);
+}
+
+bool DigitRegister15::isValid() const
+{
+ bool rc = false;
+ for (uint32_t i = 0; i < 15; i++)
+ {
+ if (digitsArray[i] != 0)
+ {
+ rc = true;
+ break;
+ }
+ }
+ return rc;
+}
+
+void DigitRegister15::operator = ( const DigitRegister15& data_i )
+{
+ memcpy( digitsArray, data_i.digitsArray, sizeof( data_i.digitsArray ));
+}
+
+bool DigitRegister15::operator == ( const DigitRegister15& data_i )const
+{
+ int data_cmp = memcmp(digitsArray, data_i.digitsArray, sizeof( data_i.digitsArray));
+ bool rc = false;
+ if(data_cmp == 0)
+ rc = true;
+ return rc;
+}
+
+bool DigitRegister15::operator < ( const DigitRegister15& data_i )const
+{
+ bool rc = true;
+ if(*this == data_i)
+ rc = false;
+ else
+ {
+ for(int i=0; i<15; i++)
+ {
+ if(digitsArray[i] > data_i.digitsArray[i])
+ {
+ rc = false;
+ break;
+ }
+ }
+ }
+ return rc;
+}
+
+std::ostream& operator << ( std::ostream& os, const DigitRegister15& data_i )
+{
+ for( auto x : data_i.digitsArray )
+ {
+ if( x != 0x0f )
+ os << x - 0x30;
+ }
+ os << "\0";
+ return os;
+}
+