L3 RRC/NAS developments

src/ue/app/cmd_handler.cpp

@@ -69,7 +69,7 @@ bool UeCmdHandler::isAllPaused()
     return true;
 }
 
-void UeCmdHandler::handleCmd(NwUeCliCommand &msg)
+void UeCmdHandler::handleCmd(NmUeCliCommand &msg)
 {
     pauseTasks();
 
@@ -100,7 +100,7 @@ void UeCmdHandler::handleCmd(NwUeCliCommand &msg)
     unpauseTasks();
 }
 
-void UeCmdHandler::handleCmdImpl(NwUeCliCommand &msg)
+void UeCmdHandler::handleCmdImpl(NmUeCliCommand &msg)
 {
     switch (msg.cmd->present)
     {

src/ue/app/cmd_handler.hpp

@@ -24,7 +24,7 @@ class UeCmdHandler
     {
     }
 
-    void handleCmd(NwUeCliCommand &msg);
+    void handleCmd(NmUeCliCommand &msg);
 
   private:
     void pauseTasks();
@@ -32,7 +32,7 @@ class UeCmdHandler
     bool isAllPaused();
 
   private:
-    void handleCmdImpl(NwUeCliCommand &msg);
+    void handleCmdImpl(NmUeCliCommand &msg);
 
   private:
     void sendResult(const InetAddress &address, const std::string &output);

src/ue/app/task.cpp

@@ -52,14 +52,14 @@ void UeAppTask::onLoop()
     switch (msg->msgType)
     {
     case NtsMessageType::UE_RLS_TO_APP: {
-        auto *w = dynamic_cast<NwUeRlsToApp *>(msg);
+        auto *w = dynamic_cast<NmUeRlsToApp *>(msg);
         switch (w->present)
         {
-        case NwUeRlsToApp::DATA_PDU_DELIVERY: {
+        case NmUeRlsToApp::DATA_PDU_DELIVERY: {
             auto *tunTask = m_tunTasks[w->psi];
             if (tunTask)
             {
-                auto *nw = new NwAppToTun(NwAppToTun::DATA_PDU_DELIVERY);
+                auto *nw = new NmAppToTun(NmAppToTun::DATA_PDU_DELIVERY);
                 nw->psi = w->psi;
                 nw->data = std::move(w->pdu);
                 tunTask->push(nw);
@@ -70,17 +70,17 @@ void UeAppTask::onLoop()
         break;
     }
     case NtsMessageType::UE_TUN_TO_APP: {
-        auto *w = dynamic_cast<NwUeTunToApp *>(msg);
+        auto *w = dynamic_cast<NmUeTunToApp *>(msg);
         switch (w->present)
         {
-        case NwUeTunToApp::DATA_PDU_DELIVERY: {
-            auto *m = new NwUeAppToNas(NwUeAppToNas::UPLINK_DATA_DELIVERY);
+        case NmUeTunToApp::DATA_PDU_DELIVERY: {
+            auto *m = new NmUeAppToNas(NmUeAppToNas::UPLINK_DATA_DELIVERY);
             m->psi = w->psi;
             m->data = std::move(w->data);
             m_base->nasTask->push(m);
             break;
         }
-        case NwUeTunToApp::TUN_ERROR: {
+        case NmUeTunToApp::TUN_ERROR: {
             m_logger->err("TUN failure [%s]", w->error.c_str());
             break;
         }
@@ -88,10 +88,10 @@ void UeAppTask::onLoop()
         break;
     }
     case NtsMessageType::UE_NAS_TO_APP: {
-        auto *w = dynamic_cast<NwUeNasToApp *>(msg);
+        auto *w = dynamic_cast<NmUeNasToApp *>(msg);
         switch (w->present)
         {
-        case NwUeNasToApp::PERFORM_SWITCH_OFF: {
+        case NmUeNasToApp::PERFORM_SWITCH_OFF: {
             setTimer(SWITCH_OFF_TIMER_ID, SWITCH_OFF_DELAY);
             break;
         }
@@ -99,11 +99,11 @@ void UeAppTask::onLoop()
         break;
     }
     case NtsMessageType::UE_STATUS_UPDATE: {
-        receiveStatusUpdate(*dynamic_cast<NwUeStatusUpdate *>(msg));
+        receiveStatusUpdate(*dynamic_cast<NmUeStatusUpdate *>(msg));
         break;
     }
     case NtsMessageType::UE_CLI_COMMAND: {
-        auto *w = dynamic_cast<NwUeCliCommand *>(msg);
+        auto *w = dynamic_cast<NmUeCliCommand *>(msg);
         UeCmdHandler handler{m_base};
         handler.handleCmd(*w);
         break;
@@ -124,16 +124,16 @@ void UeAppTask::onLoop()
     delete msg;
 }
 
-void UeAppTask::receiveStatusUpdate(NwUeStatusUpdate &msg)
+void UeAppTask::receiveStatusUpdate(NmUeStatusUpdate &msg)
 {
-    if (msg.what == NwUeStatusUpdate::SESSION_ESTABLISHMENT)
+    if (msg.what == NmUeStatusUpdate::SESSION_ESTABLISHMENT)
     {
         auto *session = msg.pduSession;
         setupTunInterface(session);
         return;
     }
 
-    if (msg.what == NwUeStatusUpdate::SESSION_RELEASE)
+    if (msg.what == NmUeStatusUpdate::SESSION_RELEASE)
     {
         if (m_tunTasks[msg.psi] != nullptr)
         {
@@ -145,7 +145,7 @@ void UeAppTask::receiveStatusUpdate(NwUeStatusUpdate &msg)
         return;
     }
 
-    if (msg.what == NwUeStatusUpdate::CM_STATE)
+    if (msg.what == NmUeStatusUpdate::CM_STATE)
     {
         m_cmState = msg.cmState;
         return;

src/ue/app/task.hpp

@@ -42,7 +42,7 @@ class UeAppTask : public NtsTask
     void onQuit() override;
 
   private:
-    void receiveStatusUpdate(NwUeStatusUpdate &msg);
+    void receiveStatusUpdate(NmUeStatusUpdate &msg);
     void setupTunInterface(const PduSession *pduSession);
 };
 

src/ue/nas/mm/base.cpp

@@ -81,7 +81,7 @@ void NasMm::onQuit()
 
 void NasMm::triggerMmCycle()
 {
-    m_base->nasTask->push(new NwUeNasToNas(NwUeNasToNas::PERFORM_MM_CYCLE));
+    m_base->nasTask->push(new NmUeNasToNas(NmUeNasToNas::PERFORM_MM_CYCLE));
 }
 
 void NasMm::performMmCycle()
@@ -291,7 +291,7 @@ void NasMm::switchCmState(ECmState state)
 
     onSwitchCmState(oldState, m_cmState);
 
-    auto *statusUpdate = new NwUeStatusUpdate(NwUeStatusUpdate::CM_STATE);
+    auto *statusUpdate = new NmUeStatusUpdate(NmUeStatusUpdate::CM_STATE);
     statusUpdate->cmState = m_cmState;
     m_base->appTask->push(statusUpdate);
 

src/ue/nas/mm/dereg.cpp

@@ -69,7 +69,7 @@ void NasMm::sendDeregistration(EDeregCause deregCause)
     if (deregCause == EDeregCause::SWITCH_OFF)
     {
         onSwitchOff();
-        m_base->appTask->push(new NwUeNasToApp(NwUeNasToApp::PERFORM_SWITCH_OFF));
+        m_base->appTask->push(new NmUeNasToApp(NmUeNasToApp::PERFORM_SWITCH_OFF));
     }
     else if (deregCause == EDeregCause::USIM_REMOVAL)
     {

src/ue/nas/mm/messaging.cpp

@@ -166,7 +166,7 @@ void NasMm::sendNasMessage(const nas::PlainMmMessage &msg)
         }
     }
 
-    auto *nw = new NwUeNasToRrc(NwUeNasToRrc::UPLINK_NAS_DELIVERY);
+    auto *nw = new NmUeNasToRrc(NmUeNasToRrc::UPLINK_NAS_DELIVERY);
     nw->pduId = 0;
     nw->nasPdu = std::move(pdu);
     m_base->rrcTask->push(nw);

src/ue/nas/mm/mm.hpp

@@ -184,8 +184,8 @@ class NasMm
     void onTimerExpire(UeTimer &timer);
 
   private: /* Service Access Point */
-    void handleRrcEvent(const NwUeRrcToNas &msg);
-    void handleNasEvent(const NwUeNasToNas &msg);
+    void handleRrcEvent(const NmUeRrcToNas &msg);
+    void handleNasEvent(const NmUeNasToNas &msg);
 };
 
 } // namespace nr::ue
\ No newline at end of file

src/ue/nas/mm/radio.cpp

@@ -106,7 +106,7 @@ void NasMm::performPlmnSelection()
     else if (lastSelectedPlmn != selected)
     {
         m_logger->info("Selected plmn[%s]", ToJson(selected).str().c_str());
-        m_base->rrcTask->push(new NwUeNasToRrc(NwUeNasToRrc::RRC_NOTIFY));
+        m_base->rrcTask->push(new NmUeNasToRrc(NmUeNasToRrc::RRC_NOTIFY));
 
         resetRegAttemptCounter();
     }
@@ -268,7 +268,7 @@ void NasMm::localReleaseConnection()
 
     m_logger->info("Performing local release of NAS connection");
 
-    m_base->rrcTask->push(new NwUeNasToRrc(NwUeNasToRrc::LOCAL_RELEASE_CONNECTION));
+    m_base->rrcTask->push(new NmUeNasToRrc(NmUeNasToRrc::LOCAL_RELEASE_CONNECTION));
 }
 
 void NasMm::handlePaging(const std::vector<GutiMobileIdentity> &tmsiIds)

src/ue/nas/mm/register.cpp

@@ -359,7 +359,7 @@ void NasMm::receiveInitialRegistrationAccept(const nas::RegistrationAccept &msg)
     if (regType == nas::ERegistrationType::INITIAL_REGISTRATION ||
         regType == nas::ERegistrationType::EMERGENCY_REGISTRATION)
     {
-        m_base->nasTask->push(new NwUeNasToNas(NwUeNasToNas::ESTABLISH_INITIAL_SESSIONS));
+        m_base->nasTask->push(new NmUeNasToNas(NmUeNasToNas::ESTABLISH_INITIAL_SESSIONS));
     }
 
     if (regType == nas::ERegistrationType::INITIAL_REGISTRATION)

src/ue/nas/mm/sap.cpp

@@ -13,56 +13,56 @@
 namespace nr::ue
 {
 
-void NasMm::handleRrcEvent(const NwUeRrcToNas &msg)
+void NasMm::handleRrcEvent(const NmUeRrcToNas &msg)
 {
     switch (msg.present)
     {
-    case NwUeRrcToNas::RRC_CONNECTION_SETUP: {
+    case NmUeRrcToNas::RRC_CONNECTION_SETUP: {
         handleRrcConnectionSetup();
         break;
     }
-    case NwUeRrcToNas::NAS_DELIVERY: {
+    case NmUeRrcToNas::NAS_DELIVERY: {
         OctetView buffer{msg.nasPdu};
         auto nasMessage = nas::DecodeNasMessage(buffer);
         if (nasMessage != nullptr)
             receiveNasMessage(*nasMessage);
         break;
     }
-    case NwUeRrcToNas::RRC_CONNECTION_RELEASE: {
+    case NmUeRrcToNas::RRC_CONNECTION_RELEASE: {
         handleRrcConnectionRelease();
         break;
     }
-    case NwUeRrcToNas::RADIO_LINK_FAILURE: {
+    case NmUeRrcToNas::RADIO_LINK_FAILURE: {
         handleRadioLinkFailure();
         break;
     }
-    case NwUeRrcToNas::PAGING: {
+    case NmUeRrcToNas::PAGING: {
         handlePaging(msg.pagingTmsi);
         break;
     }
-    case NwUeRrcToNas::NAS_NOTIFY: {
+    case NmUeRrcToNas::NAS_NOTIFY: {
         triggerMmCycle();
         break;
     }
-    case NwUeRrcToNas::ACTIVE_CELL_CHANGED: {
+    case NmUeRrcToNas::ACTIVE_CELL_CHANGED: {
         handleActiveCellChange(msg.previousTai);
         break;
     }
-    case NwUeRrcToNas::RRC_ESTABLISHMENT_FAILURE: {
+    case NmUeRrcToNas::RRC_ESTABLISHMENT_FAILURE: {
         handleRrcEstablishmentFailure();
         break;
     }
     }
 }
 
-void NasMm::handleNasEvent(const NwUeNasToNas &msg)
+void NasMm::handleNasEvent(const NmUeNasToNas &msg)
 {
     switch (msg.present)
     {
-    case NwUeNasToNas::PERFORM_MM_CYCLE:
+    case NmUeNasToNas::PERFORM_MM_CYCLE:
         performMmCycle();
         break;
-    case NwUeNasToNas::NAS_TIMER_EXPIRE:
+    case NmUeNasToNas::NAS_TIMER_EXPIRE:
         onTimerExpire(*msg.timer);
         break;
     default:

src/ue/nas/sm/establishment.cpp

@@ -170,7 +170,7 @@ void NasSm::receiveEstablishmentAccept(const nas::PduSessionEstablishmentAccept
     else
         pduSession->pduAddress = {};
 
-    auto *statusUpdate = new NwUeStatusUpdate(NwUeStatusUpdate::SESSION_ESTABLISHMENT);
+    auto *statusUpdate = new NmUeStatusUpdate(NmUeStatusUpdate::SESSION_ESTABLISHMENT);
     statusUpdate->pduSession = pduSession;
     m_base->appTask->push(statusUpdate);
 

src/ue/nas/sm/resource.cpp

@@ -39,7 +39,7 @@ void NasSm::localReleaseSession(int psi)
 
     if (isEstablished)
     {
-        auto *statusUpdate = new NwUeStatusUpdate(NwUeStatusUpdate::SESSION_RELEASE);
+        auto *statusUpdate = new NmUeStatusUpdate(NmUeStatusUpdate::SESSION_RELEASE);
         statusUpdate->psi = psi;
         m_base->appTask->push(statusUpdate);
     }

src/ue/nas/sm/sap.cpp

@@ -19,11 +19,11 @@
 namespace nr::ue
 {
 
-void NasSm::handleNasEvent(const NwUeNasToNas &msg)
+void NasSm::handleNasEvent(const NmUeNasToNas &msg)
 {
     switch (msg.present)
     {
-    case NwUeNasToNas::NAS_TIMER_EXPIRE:
+    case NmUeNasToNas::NAS_TIMER_EXPIRE:
         onTimerExpire(*msg.timer);
         break;
     default:
@@ -58,7 +58,7 @@ void NasSm::handleUplinkDataRequest(int psi, OctetString &&data)
             handleUplinkStatusChange(psi, false);
         }
 
-        auto *nw = new NwUeNasToRls(NwUeNasToRls::DATA_PDU_DELIVERY);
+        auto *nw = new NmUeNasToRls(NmUeNasToRls::DATA_PDU_DELIVERY);
         nw->psi = psi;
         nw->pdu = std::move(data);
         m_base->rlsTask->push(nw);

src/ue/nas/sm/sm.hpp

@@ -89,7 +89,7 @@ class NasSm
     void abortProcedureByPtiOrPsi(int pti, int psi);
 
   private: /* Service Access Point */
-    void handleNasEvent(const NwUeNasToNas &msg);
+    void handleNasEvent(const NmUeNasToNas &msg);
     void onTimerTick();
     void handleUplinkDataRequest(int psi, OctetString &&data);
 };

src/ue/nas/task.cpp

@@ -57,25 +57,25 @@ void NasTask::onLoop()
     switch (msg->msgType)
     {
     case NtsMessageType::UE_RRC_TO_NAS: {
-        mm->handleRrcEvent(*dynamic_cast<NwUeRrcToNas *>(msg));
+        mm->handleRrcEvent(*dynamic_cast<NmUeRrcToNas *>(msg));
         break;
     }
     case NtsMessageType::UE_NAS_TO_NAS: {
-        auto *w = dynamic_cast<NwUeNasToNas *>(msg);
+        auto *w = dynamic_cast<NmUeNasToNas *>(msg);
         switch (w->present)
         {
-        case NwUeNasToNas::PERFORM_MM_CYCLE: {
+        case NmUeNasToNas::PERFORM_MM_CYCLE: {
             mm->handleNasEvent(*w);
             break;
         }
-        case NwUeNasToNas::NAS_TIMER_EXPIRE: {
+        case NmUeNasToNas::NAS_TIMER_EXPIRE: {
             if (w->timer->isMmTimer())
                 mm->handleNasEvent(*w);
             else
                 sm->handleNasEvent(*w);
             break;
         }
-        case NwUeNasToNas::ESTABLISH_INITIAL_SESSIONS: {
+        case NmUeNasToNas::ESTABLISH_INITIAL_SESSIONS: {
             sm->establishInitialSessions();
             break;
         }
@@ -85,10 +85,10 @@ void NasTask::onLoop()
         break;
     }
     case NtsMessageType::UE_APP_TO_NAS: {
-        auto *w = dynamic_cast<NwUeAppToNas *>(msg);
+        auto *w = dynamic_cast<NmUeAppToNas *>(msg);
         switch (w->present)
         {
-        case NwUeAppToNas::UPLINK_DATA_DELIVERY: {
+        case NmUeAppToNas::UPLINK_DATA_DELIVERY: {
             sm->handleUplinkDataRequest(w->psi, std::move(w->data));
             break;
         }
@@ -108,7 +108,7 @@ void NasTask::onLoop()
         if (timerId == NTS_TIMER_ID_MM_CYCLE)
         {
             setTimer(NTS_TIMER_ID_MM_CYCLE, NTS_TIMER_INTERVAL_MM_CYCLE);
-            mm->handleNasEvent(NwUeNasToNas{NwUeNasToNas::PERFORM_MM_CYCLE});
+            mm->handleNasEvent(NmUeNasToNas{NmUeNasToNas::PERFORM_MM_CYCLE});
         }
         break;
     }
@@ -123,7 +123,7 @@ void NasTask::onLoop()
 void NasTask::performTick()
 {
     auto sendExpireMsg = [this](UeTimer *timer) {
-        auto *nw = new NwUeNasToNas(NwUeNasToNas::NAS_TIMER_EXPIRE);
+        auto *nw = new NmUeNasToNas(NmUeNasToNas::NAS_TIMER_EXPIRE);
         nw->timer = timer;
         push(nw);
     };

src/ue/rls/ctl_task.cpp

@@ -49,22 +49,22 @@ void RlsControlTask::onLoop()
     switch (msg->msgType)
     {
     case NtsMessageType::UE_RLS_TO_RLS: {
-        auto *w = dynamic_cast<NwUeRlsToRls *>(msg);
+        auto *w = dynamic_cast<NmUeRlsToRls *>(msg);
         switch (w->present)
         {
-        case NwUeRlsToRls::SIGNAL_CHANGED:
+        case NmUeRlsToRls::SIGNAL_CHANGED:
             handleSignalChange(w->cellId, w->dbm);
             break;
-        case NwUeRlsToRls::RECEIVE_RLS_MESSAGE:
+        case NmUeRlsToRls::RECEIVE_RLS_MESSAGE:
             handleRlsMessage(w->cellId, *w->msg);
             break;
-        case NwUeRlsToRls::UPLINK_DATA:
+        case NmUeRlsToRls::UPLINK_DATA:
             handleUplinkDataDelivery(w->psi, std::move(w->data));
             break;
-        case NwUeRlsToRls::UPLINK_RRC:
+        case NmUeRlsToRls::UPLINK_RRC:
             handleUplinkRrcDelivery(w->cellId, w->pduId, w->rrcChannel, std::move(w->data));
             break;
-        case NwUeRlsToRls::ASSIGN_CURRENT_CELL:
+        case NmUeRlsToRls::ASSIGN_CURRENT_CELL:
             m_servingCell = w->cellId;
             break;
         default:
@@ -122,14 +122,14 @@ void RlsControlTask::handleRlsMessage(int cellId, rls::RlsMessage &msg)
                 return;
             }
 
-            auto *w = new NwUeRlsToRls(NwUeRlsToRls::DOWNLINK_DATA);
+            auto *w = new NmUeRlsToRls(NmUeRlsToRls::DOWNLINK_DATA);
             w->psi = static_cast<int>(m.payload);
             w->data = std::move(m.pdu);
             m_mainTask->push(w);
         }
         else if (m.pduType == rls::EPduType::RRC)
         {
-            auto *w = new NwUeRlsToRls(NwUeRlsToRls::DOWNLINK_RRC);
+            auto *w = new NmUeRlsToRls(NmUeRlsToRls::DOWNLINK_RRC);
             w->cellId = cellId;
             w->rrcChannel = static_cast<rrc::RrcChannel>(m.payload);
             w->data = std::move(m.pdu);
@@ -148,7 +148,7 @@ void RlsControlTask::handleRlsMessage(int cellId, rls::RlsMessage &msg)
 
 void RlsControlTask::handleSignalChange(int cellId, int dbm)
 {
-    auto *w = new NwUeRlsToRls(NwUeRlsToRls::SIGNAL_CHANGED);
+    auto *w = new NmUeRlsToRls(NmUeRlsToRls::SIGNAL_CHANGED);
     w->cellId = cellId;
     w->dbm = dbm;
     m_mainTask->push(w);
@@ -162,7 +162,7 @@ void RlsControlTask::handleUplinkRrcDelivery(int cellId, uint32_t pduId, rrc::Rr
         {
             m_pduMap.clear();
 
-            auto *w = new NwUeRlsToRls(NwUeRlsToRls::RADIO_LINK_FAILURE);
+            auto *w = new NmUeRlsToRls(NmUeRlsToRls::RADIO_LINK_FAILURE);
             w->rlfCause = rls::ERlfCause::PDU_ID_EXISTS;
             m_mainTask->push(w);
             return;
@@ -172,7 +172,7 @@ void RlsControlTask::handleUplinkRrcDelivery(int cellId, uint32_t pduId, rrc::Rr
         {
             m_pduMap.clear();
 
-            auto *w = new NwUeRlsToRls(NwUeRlsToRls::RADIO_LINK_FAILURE);
+            auto *w = new NmUeRlsToRls(NmUeRlsToRls::RADIO_LINK_FAILURE);
             w->rlfCause = rls::ERlfCause::PDU_ID_FULL;
             m_mainTask->push(w);
             return;
@@ -227,7 +227,7 @@ void RlsControlTask::onAckControlTimerExpired()
 
     if (!transmissionFailures.empty())
     {
-        auto *w = new NwUeRlsToRls(NwUeRlsToRls::TRANSMISSION_FAILURE);
+        auto *w = new NmUeRlsToRls(NmUeRlsToRls::TRANSMISSION_FAILURE);
         w->pduList = std::move(transmissionFailures);
         m_mainTask->push(w);
     }

src/ue/rls/task.cpp

@@ -44,38 +44,38 @@ void UeRlsTask::onLoop()
     switch (msg->msgType)
     {
     case NtsMessageType::UE_RLS_TO_RLS: {
-        auto *w = dynamic_cast<NwUeRlsToRls *>(msg);
+        auto *w = dynamic_cast<NmUeRlsToRls *>(msg);
         switch (w->present)
         {
-        case NwUeRlsToRls::SIGNAL_CHANGED: {
-            auto *m = new NwUeRlsToRrc(NwUeRlsToRrc::SIGNAL_CHANGED);
+        case NmUeRlsToRls::SIGNAL_CHANGED: {
+            auto *m = new NmUeRlsToRrc(NmUeRlsToRrc::SIGNAL_CHANGED);
             m->cellId = w->cellId;
             m->dbm = w->dbm;
             m_base->rrcTask->push(m);
             break;
         }
-        case NwUeRlsToRls::DOWNLINK_DATA: {
-            auto *m = new NwUeRlsToApp(NwUeRlsToApp::DATA_PDU_DELIVERY);
+        case NmUeRlsToRls::DOWNLINK_DATA: {
+            auto *m = new NmUeRlsToApp(NmUeRlsToApp::DATA_PDU_DELIVERY);
             m->psi = w->psi;
             m->pdu = std::move(w->data);
             m_base->appTask->push(m);
             break;
         }
-        case NwUeRlsToRls::DOWNLINK_RRC: {
-            auto *m = new NwUeRlsToRrc(NwUeRlsToRrc::DOWNLINK_RRC_DELIVERY);
+        case NmUeRlsToRls::DOWNLINK_RRC: {
+            auto *m = new NmUeRlsToRrc(NmUeRlsToRrc::DOWNLINK_RRC_DELIVERY);
             m->cellId = w->cellId;
             m->channel = w->rrcChannel;
             m->pdu = std::move(w->data);
             m_base->rrcTask->push(m);
             break;
         }
-        case NwUeRlsToRls::RADIO_LINK_FAILURE: {
-            auto *m = new NwUeRlsToRrc(NwUeRlsToRrc::RADIO_LINK_FAILURE);
+        case NmUeRlsToRls::RADIO_LINK_FAILURE: {
+            auto *m = new NmUeRlsToRrc(NmUeRlsToRrc::RADIO_LINK_FAILURE);
             m->rlfCause = w->rlfCause;
             m_base->rrcTask->push(m);
             break;
         }
-        case NwUeRlsToRls::TRANSMISSION_FAILURE: {
+        case NmUeRlsToRls::TRANSMISSION_FAILURE: {
             m_logger->debug("transmission failure [%d]", w->pduList.size());
             break;
         }
@@ -87,17 +87,17 @@ void UeRlsTask::onLoop()
         break;
     }
     case NtsMessageType::UE_RRC_TO_RLS: {
-        auto *w = dynamic_cast<NwUeRrcToRls *>(msg);
+        auto *w = dynamic_cast<NmUeRrcToRls *>(msg);
         switch (w->present)
         {
-        case NwUeRrcToRls::ASSIGN_CURRENT_CELL: {
-            auto *m = new NwUeRlsToRls(NwUeRlsToRls::ASSIGN_CURRENT_CELL);
+        case NmUeRrcToRls::ASSIGN_CURRENT_CELL: {
+            auto *m = new NmUeRlsToRls(NmUeRlsToRls::ASSIGN_CURRENT_CELL);
             m->cellId = w->cellId;
             m_ctlTask->push(m);
             break;
         }
-        case NwUeRrcToRls::RRC_PDU_DELIVERY: {
-            auto *m = new NwUeRlsToRls(NwUeRlsToRls::UPLINK_RRC);
+        case NmUeRrcToRls::RRC_PDU_DELIVERY: {
+            auto *m = new NmUeRlsToRls(NmUeRlsToRls::UPLINK_RRC);
             m->cellId = w->cellId;
             m->rrcChannel = w->channel;
             m->pduId = w->pduId;
@@ -109,11 +109,11 @@ void UeRlsTask::onLoop()
         break;
     }
     case NtsMessageType::UE_NAS_TO_RLS: {
-        auto *w = dynamic_cast<NwUeNasToRls *>(msg);
+        auto *w = dynamic_cast<NmUeNasToRls *>(msg);
         switch (w->present)
         {
-        case NwUeNasToRls::DATA_PDU_DELIVERY: {
-            auto *m = new NwUeRlsToRls(NwUeRlsToRls::UPLINK_DATA);
+        case NmUeNasToRls::DATA_PDU_DELIVERY: {
+            auto *m = new NmUeRlsToRls(NmUeRlsToRls::UPLINK_DATA);
             m->psi = w->psi;
             m->data = std::move(w->pdu);
             m_ctlTask->push(m);

src/ue/rls/udp_task.cpp

@@ -117,7 +117,7 @@ void RlsUdpTask::receiveRlsPdu(const InetAddress &addr, std::unique_ptr<rls::Rls
         return;
     }
 
-    auto *w = new NwUeRlsToRls(NwUeRlsToRls::RECEIVE_RLS_MESSAGE);
+    auto *w = new NmUeRlsToRls(NmUeRlsToRls::RECEIVE_RLS_MESSAGE);
     w->cellId = m_cells[msg->sti].cellId;
     w->msg = std::move(msg);
     m_ctlTask->push(w);
@@ -132,7 +132,7 @@ void RlsUdpTask::onSignalChangeOrLost(int cellId)
         dbm = m_cells[sti].dbm;
     }
 
-    auto *w = new NwUeRlsToRls(NwUeRlsToRls::SIGNAL_CHANGED);
+    auto *w = new NmUeRlsToRls(NmUeRlsToRls::SIGNAL_CHANGED);
     w->cellId = cellId;
     w->dbm = dbm;
     m_ctlTask->push(w);

src/ue/rrc/cells.cpp

@@ -87,7 +87,7 @@ void UeRrcTask::updateAvailablePlmns()
                 value.insert(cellDesc.second.sib1.plmn);
     });
 
-    m_base->nasTask->push(new NwUeRrcToNas(NwUeRrcToNas::NAS_NOTIFY));
+    m_base->nasTask->push(new NmUeRrcToNas(NmUeRrcToNas::NAS_NOTIFY));
 }
 
 } // namespace nr::ue

src/ue/rrc/channel.cpp

@@ -93,7 +93,7 @@ void UeRrcTask::sendRrcMessage(int cellId, ASN_RRC_UL_CCCH_Message *msg)
         return;
     }
 
-    auto *nw = new NwUeRrcToRls(NwUeRrcToRls::RRC_PDU_DELIVERY);
+    auto *nw = new NmUeRrcToRls(NmUeRrcToRls::RRC_PDU_DELIVERY);
     nw->cellId = cellId;
     nw->channel = rrc::RrcChannel::UL_CCCH;
     nw->pdu = std::move(pdu);
@@ -109,7 +109,7 @@ void UeRrcTask::sendRrcMessage(int cellId, ASN_RRC_UL_CCCH1_Message *msg)
         return;
     }
 
-    auto *nw = new NwUeRrcToRls(NwUeRrcToRls::RRC_PDU_DELIVERY);
+    auto *nw = new NmUeRrcToRls(NmUeRrcToRls::RRC_PDU_DELIVERY);
     nw->cellId = cellId;
     nw->channel = rrc::RrcChannel::UL_CCCH1;
     nw->pdu = std::move(pdu);
@@ -125,7 +125,7 @@ void UeRrcTask::sendRrcMessage(ASN_RRC_UL_DCCH_Message *msg)
         return;
     }
 
-    auto *nw = new NwUeRrcToRls(NwUeRrcToRls::RRC_PDU_DELIVERY);
+    auto *nw = new NmUeRrcToRls(NmUeRrcToRls::RRC_PDU_DELIVERY);
     nw->cellId = m_base->shCtx.currentCell.get<int>([](auto &value) { return value.cellId; });
     nw->channel = rrc::RrcChannel::UL_DCCH;
     nw->pdu = std::move(pdu);

src/ue/rrc/connection.cpp

@@ -99,7 +99,7 @@ void UeRrcTask::receiveRrcSetup(int cellId, const ASN_RRC_RRCSetup &msg)
 
     m_logger->info("RRC connection established");
     switchState(ERrcState::RRC_CONNECTED);
-    m_base->nasTask->push(new NwUeRrcToNas(NwUeRrcToNas::RRC_CONNECTION_SETUP));
+    m_base->nasTask->push(new NmUeRrcToNas(NmUeRrcToNas::RRC_CONNECTION_SETUP));
 }
 
 void UeRrcTask::receiveRrcReject(int cellId, const ASN_RRC_RRCReject &msg)
@@ -116,12 +116,12 @@ void UeRrcTask::receiveRrcRelease(const ASN_RRC_RRCRelease &msg)
 {
     m_logger->debug("RRC Release received");
     m_state = ERrcState::RRC_IDLE;
-    m_base->nasTask->push(new NwUeRrcToNas(NwUeRrcToNas::RRC_CONNECTION_RELEASE));
+    m_base->nasTask->push(new NmUeRrcToNas(NmUeRrcToNas::RRC_CONNECTION_RELEASE));
 }
 
 void UeRrcTask::handleEstablishmentFailure()
 {
-    m_base->nasTask->push(new NwUeRrcToNas(NwUeRrcToNas::RRC_ESTABLISHMENT_FAILURE));
+    m_base->nasTask->push(new NmUeRrcToNas(NmUeRrcToNas::RRC_ESTABLISHMENT_FAILURE));
 }
 
 } // namespace nr::ue

src/ue/rrc/failures.cpp

@@ -23,7 +23,7 @@ void UeRrcTask::declareRadioLinkFailure(rls::ERlfCause cause)
 void UeRrcTask::handleRadioLinkFailure(rls::ERlfCause cause)
 {
     m_state = ERrcState::RRC_IDLE;
-    m_base->nasTask->push(new NwUeRrcToNas(NwUeRrcToNas::RADIO_LINK_FAILURE));
+    m_base->nasTask->push(new NmUeRrcToNas(NmUeRrcToNas::RADIO_LINK_FAILURE));
 }
 
 } // namespace nr::ue
\ No newline at end of file

src/ue/rrc/handler.cpp

@@ -51,7 +51,7 @@ void UeRrcTask::receivePaging(const ASN_RRC_Paging &msg)
         }
     });
 
-    auto *w = new NwUeRrcToNas(NwUeRrcToNas::PAGING);
+    auto *w = new NmUeRrcToNas(NmUeRrcToNas::PAGING);
     w->pagingTmsi = std::move(tmsiIds);
     m_base->nasTask->push(w);
 }

src/ue/rrc/idle.cpp

@@ -98,11 +98,11 @@ void UeRrcTask::performCellSelection()
 
     if (selectedCell != lastCell.cellId)
     {
-        auto *w1 = new NwUeRrcToRls(NwUeRrcToRls::ASSIGN_CURRENT_CELL);
+        auto *w1 = new NmUeRrcToRls(NmUeRrcToRls::ASSIGN_CURRENT_CELL);
         w1->cellId = selectedCell;
         m_base->rlsTask->push(w1);
 
-        auto w2 = new NwUeRrcToNas(NwUeRrcToNas::ACTIVE_CELL_CHANGED);
+        auto w2 = new NmUeRrcToNas(NmUeRrcToNas::ACTIVE_CELL_CHANGED);
         w2->previousTai = Tai{lastCell.plmn, lastCell.tac};
         m_base->nasTask->push(w2);
     }

src/ue/rrc/nas.cpp

@@ -64,7 +64,7 @@ void UeRrcTask::receiveDownlinkInformationTransfer(const ASN_RRC_DLInformationTr
     OctetString nasPdu =
         asn::GetOctetString(*msg.criticalExtensions.choice.dlInformationTransfer->dedicatedNAS_Message);
 
-    auto *nw = new NwUeRrcToNas(NwUeRrcToNas::NAS_DELIVERY);
+    auto *nw = new NmUeRrcToNas(NmUeRrcToNas::NAS_DELIVERY);
     nw->nasPdu = std::move(nasPdu);
     m_base->nasTask->push(nw);
 }

src/ue/rrc/sap.cpp

@@ -15,41 +15,41 @@
 namespace nr::ue
 {
 
-void UeRrcTask::handleRlsSapMessage(NwUeRlsToRrc &msg)
+void UeRrcTask::handleRlsSapMessage(NmUeRlsToRrc &msg)
 {
     switch (msg.present)
     {
-    case NwUeRlsToRrc::SIGNAL_CHANGED: {
+    case NmUeRlsToRrc::SIGNAL_CHANGED: {
         handleCellSignalChange(msg.cellId, msg.dbm);
         break;
     }
-    case NwUeRlsToRrc::DOWNLINK_RRC_DELIVERY: {
+    case NmUeRlsToRrc::DOWNLINK_RRC_DELIVERY: {
         handleDownlinkRrc(msg.cellId, msg.channel, msg.pdu);
         break;
     }
-    case NwUeRlsToRrc::RADIO_LINK_FAILURE: {
+    case NmUeRlsToRrc::RADIO_LINK_FAILURE: {
         handleRadioLinkFailure(msg.rlfCause);
         break;
     }
     }
 }
 
-void UeRrcTask::handleNasSapMessage(NwUeNasToRrc &msg)
+void UeRrcTask::handleNasSapMessage(NmUeNasToRrc &msg)
 {
     switch (msg.present)
     {
-    case NwUeNasToRrc::UPLINK_NAS_DELIVERY: {
+    case NmUeNasToRrc::UPLINK_NAS_DELIVERY: {
         deliverUplinkNas(msg.pduId, std::move(msg.nasPdu));
         break;
     }
-    case NwUeNasToRrc::LOCAL_RELEASE_CONNECTION: {
+    case NmUeNasToRrc::LOCAL_RELEASE_CONNECTION: {
         // TODO
         // m_state = ERrcState::RRC_IDLE;
         // m_base->nasTask->push(new NwUeRrcToNas(NwUeRrcToNas::RRC_CONNECTION_RELEASE));
         // m_base->rlsTask->push(new NwUeRrcToRls(NwUeRrcToRls::RESET_STI));
         break;
     }
-    case NwUeNasToRrc::RRC_NOTIFY: {
+    case NmUeNasToRrc::RRC_NOTIFY: {
         triggerCycle();
         break;
     }

src/ue/rrc/state.cpp

@@ -18,7 +18,7 @@ namespace nr::ue
 
 void UeRrcTask::triggerCycle()
 {
-    push(new NwUeRrcToRrc(NwUeRrcToRrc::TRIGGER_CYCLE));
+    push(new NmUeRrcToRrc(NmUeRrcToRrc::TRIGGER_CYCLE));
 }
 
 void UeRrcTask::performCycle()

src/ue/rrc/task.cpp

@@ -53,18 +53,18 @@ void UeRrcTask::onLoop()
     switch (msg->msgType)
     {
     case NtsMessageType::UE_NAS_TO_RRC: {
-        handleNasSapMessage(*dynamic_cast<NwUeNasToRrc *>(msg));
+        handleNasSapMessage(*dynamic_cast<NmUeNasToRrc *>(msg));
         break;
     }
     case NtsMessageType::UE_RLS_TO_RRC: {
-        handleRlsSapMessage(*dynamic_cast<NwUeRlsToRrc *>(msg));
+        handleRlsSapMessage(*dynamic_cast<NmUeRlsToRrc *>(msg));
         break;
     }
     case NtsMessageType::UE_RRC_TO_RRC: {
-        auto *w = dynamic_cast<NwUeRrcToRrc *>(msg);
+        auto *w = dynamic_cast<NmUeRrcToRrc *>(msg);
         switch (w->present)
         {
-        case NwUeRrcToRrc::TRIGGER_CYCLE:
+        case NmUeRrcToRrc::TRIGGER_CYCLE:
             performCycle();
             break;
         }

src/ue/rrc/task.hpp

@@ -93,8 +93,8 @@ class UeRrcTask : public NtsTask
     void receiveRrcMessage(ASN_RRC_PCCH_Message *msg);
 
     /* Service Access Point */
-    void handleRlsSapMessage(NwUeRlsToRrc &msg);
-    void handleNasSapMessage(NwUeNasToRrc &msg);
+    void handleRlsSapMessage(NmUeRlsToRrc &msg);
+    void handleNasSapMessage(NmUeNasToRrc &msg);
 
     /* State Management */
     void triggerCycle();

src/ue/tun/task.cpp

@@ -35,9 +35,9 @@ static std::string GetErrorMessage(const std::string &cause)
     return what;
 }
 
-static nr::ue::NwUeTunToApp *NwError(std::string &&error)
+static nr::ue::NmUeTunToApp *NmError(std::string &&error)
 {
-    auto *nw = new nr::ue::NwUeTunToApp(nr::ue::NwUeTunToApp::TUN_ERROR);
+    auto *nw = new nr::ue::NmUeTunToApp(nr::ue::NmUeTunToApp::TUN_ERROR);
     nw->error = std::move(error);
     return nw;
 }
@@ -57,13 +57,13 @@ static void ReceiverThread(ReceiverArgs *args)
         int n = ::read(fd, buffer, RECEIVER_BUFFER_SIZE);
         if (n < 0)
         {
-            targetTask->push(NwError(GetErrorMessage("TUN device could not read")));
+            targetTask->push(NmError(GetErrorMessage("TUN device could not read")));
             return; // Abort receiver thread
         }
 
         if (n > 0)
         {
-            auto *nw = new nr::ue::NwUeTunToApp(nr::ue::NwUeTunToApp::DATA_PDU_DELIVERY);
+            auto *nw = new nr::ue::NmUeTunToApp(nr::ue::NmUeTunToApp::DATA_PDU_DELIVERY);
             nw->psi = psi;
             nw->data = OctetString::FromArray(buffer, static_cast<size_t>(n));
             targetTask->push(nw);
@@ -103,12 +103,12 @@ void TunTask::onLoop()
     switch (msg->msgType)
     {
     case NtsMessageType::UE_APP_TO_TUN: {
-        auto *w = dynamic_cast<NwAppToTun *>(msg);
+        auto *w = dynamic_cast<NmAppToTun *>(msg);
         int res = ::write(m_fd, w->data.data(), w->data.length());
         if (res < 0)
-            push(NwError(GetErrorMessage("TUN device could not write")));
+            push(NmError(GetErrorMessage("TUN device could not write")));
         else if (res != w->data.length())
-            push(NwError(GetErrorMessage("TUN device partially written")));
+            push(NmError(GetErrorMessage("TUN device partially written")));
         delete w;
         break;
     }

src/ue/ue.cpp

@@ -62,7 +62,7 @@ void UserEquipment::start()
 
 void UserEquipment::pushCommand(std::unique_ptr<app::UeCliCommand> cmd, const InetAddress &address)
 {
-    taskBase->appTask->push(new NwUeCliCommand(std::move(cmd), address));
+    taskBase->appTask->push(new NmUeCliCommand(std::move(cmd), address));
 }
 
 } // namespace nr::ue