UE: rename _nas_user_data to at_response and move it to nas_user_t

openair3/NAS/UE/nas_ue_task.c

@@ -88,6 +88,12 @@ void *nas_ue_task(void *args_p)
       itti_subscribe_event_fd (TASK_NAS_UE, user->fd);
     }
 
+    user->at_response = calloc(1, sizeof(at_response_t));
+    if ( user->at_response == NULL ) {
+        LOG_E(NAS, "[UE %d] Can't allocate memory for user_at_commands\n", 0);
+        // FIXME stop here
+    }
+
     /* Initialize NAS user */
     nas_user_initialize (user, &user_api_emm_callback, &user_api_esm_callback, FIRMWARE_VERSION);
   }

openair3/NAS/UE/nas_user.c

@@ -115,12 +115,6 @@ static _nas_user_procedure_t _nas_user_procedure[AT_COMMAND_ID_MAX] = {
   _nas_user_proc_cgpaddr, /* CGPADDR */
 };
 
-/*
- * Internal representation of data structure returned to the user
- * as the result of NAS procedure function call
- */
-static at_response_t _nas_user_data = {};
-
 /*
  * ---------------------------------------------------------------------
  *              Local UE context
@@ -275,7 +269,7 @@ int nas_user_receive_and_process(nas_user_t *user, char *message)
     /* Send response to UserProcess (If not in simulated reception) */
     if (message == NULL) {
       /* Encode the user data message */
-      bytes = user_api_encode_data (nas_user_get_data (), i == nb_command - 1);
+      bytes = user_api_encode_data (nas_user_get_data (user), i == nb_command - 1);
 
       if (bytes == RETURNerror) {
         /* Failed to encode the user data message;
@@ -313,12 +307,12 @@ int nas_user_receive_and_process(nas_user_t *user, char *message)
  ** Outputs:     None                                                      **
  **      Return:    RETURNok if the command has been success-  **
  **             fully executed; RETURNerror otherwise      **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 int nas_user_process_data(nas_user_t *user, const void *data)
 {
   LOG_FUNC_IN;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNerror;
 
@@ -340,15 +334,15 @@ int nas_user_process_data(nas_user_t *user, const void *data)
       ret_code = (*nas_procedure)(user, user_data);
     } else {
       /* AT command related to result format only */
-      _nas_user_data.id = user_data->id;
-      _nas_user_data.type = user_data->type;
-      _nas_user_data.mask = user_data->mask;
-      _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+      at_response->id = user_data->id;
+      at_response->type = user_data->type;
+      at_response->mask = user_data->mask;
+      at_response->cause_code = AT_ERROR_SUCCESS;
       ret_code = RETURNok;
     }
   } else {
     LOG_TRACE(ERROR, "USR-MAIN  - Data to be processed is null");
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
   }
 
   LOG_FUNC_RETURN (ret_code);
@@ -371,10 +365,10 @@ int nas_user_process_data(nas_user_t *user, const void *data)
  **          Others:    None                                       **
  **                                                                        **
  ***************************************************************************/
-const void *nas_user_get_data(void)
+const void *nas_user_get_data(nas_user_t *user)
 {
   LOG_FUNC_IN;
-  LOG_FUNC_RETURN ((void *) &_nas_user_data);
+  LOG_FUNC_RETURN ((void *) user->at_response);
 }
 
 /****************************************************************************/
@@ -396,21 +390,21 @@ const void *nas_user_get_data(void)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgsn(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgsn_resp_t *cgsn = &_nas_user_data.response.cgsn;
+  at_cgsn_resp_t *cgsn = &at_response->response.cgsn;
   memset(cgsn, 0, sizeof(at_cgsn_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CGSN_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CGSN_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
@@ -426,7 +420,7 @@ static int _nas_user_proc_cgsn(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGSN command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -447,21 +441,21 @@ static int _nas_user_proc_cgsn(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgmi(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgmi_resp_t *cgmi = &_nas_user_data.response.cgmi;
+  at_cgmi_resp_t *cgmi = &at_response->response.cgmi;
   memset(cgmi, 0, sizeof(at_cgmi_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CGMI_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CGMI_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
@@ -477,7 +471,7 @@ static int _nas_user_proc_cgmi(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGMI command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -498,21 +492,21 @@ static int _nas_user_proc_cgmi(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgmm(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgmm_resp_t *cgmm = &_nas_user_data.response.cgmm;
+  at_cgmm_resp_t *cgmm = &at_response->response.cgmm;
   memset(cgmm, 0, sizeof(at_cgmm_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CGMM_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CGMM_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
@@ -528,7 +522,7 @@ static int _nas_user_proc_cgmm(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGMM command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -550,22 +544,22 @@ static int _nas_user_proc_cgmm(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgmr(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgmr_resp_t *cgmr = &_nas_user_data.response.cgmr;
+  at_cgmr_resp_t *cgmr = &at_response->response.cgmr;
   memset(cgmr, 0, sizeof(at_cgmr_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CGMR_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CGMR_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
@@ -581,7 +575,7 @@ static int _nas_user_proc_cgmr(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGMR command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -606,27 +600,27 @@ static int _nas_user_proc_cgmr(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cimi(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cimi_resp_t *cimi = &_nas_user_data.response.cimi;
+  at_cimi_resp_t *cimi = &at_response->response.cimi;
   memset(cimi, 0, sizeof(at_cimi_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CIMI_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CIMI_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -635,7 +629,7 @@ static int _nas_user_proc_cimi(nas_user_t *user, const at_command_t *data)
 
     if (ret_code != RETURNok) {
       LOG_TRACE(ERROR, "USR-MAIN  - Failed to get IMSI number");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -647,7 +641,7 @@ static int _nas_user_proc_cimi(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CIMI command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -667,24 +661,24 @@ static int _nas_user_proc_cimi(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cfun(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cfun_resp_t *cfun = &_nas_user_data.response.cfun;
+  at_cfun_resp_t *cfun = &at_response->response.cfun;
   memset(cfun, 0, sizeof(at_cfun_resp_t));
 
   int fun = AT_CFUN_FUN_DEFAULT;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CFUN_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CFUN_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
@@ -700,7 +694,7 @@ static int _nas_user_proc_cfun(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <rst> parameter is not valid"
                   " (%d)", data->command.cfun.rst);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -713,7 +707,7 @@ static int _nas_user_proc_cfun(nas_user_t *user, const at_command_t *data)
          * is not valid; return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <fun> parameter is not valid"
                   " (%d)", data->command.cfun.fun);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -759,7 +753,7 @@ static int _nas_user_proc_cfun(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CFUN command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -786,15 +780,16 @@ static int _nas_user_proc_cpin(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cpin_resp_t *cpin = &_nas_user_data.response.cpin;
+  at_cpin_resp_t *cpin = &at_response->response.cpin;
   memset(cpin, 0, sizeof(at_cpin_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CPIN_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CPIN_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
@@ -810,7 +805,7 @@ static int _nas_user_proc_cpin(nas_user_t *user, const at_command_t *data)
         /* The PIN code is NOT matching; return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - PIN code is not correct "
                   "(%s)", data->command.cpin.pin);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PASSWD;
+        at_response->cause_code = AT_ERROR_INCORRECT_PASSWD;
         ret_code = RETURNerror;
       } else {
         /* The PIN code is matching; update the user's PIN
@@ -820,7 +815,7 @@ static int _nas_user_proc_cpin(nas_user_t *user, const at_command_t *data)
     } else {
       /* The MT is NOT waiting for PIN password;
        * return an error message */
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_ALLOWED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_ALLOWED;
       ret_code = RETURNerror;
     }
 
@@ -844,7 +839,7 @@ static int _nas_user_proc_cpin(nas_user_t *user, const at_command_t *data)
     /* Other types of AT CPIN command are not valid */
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CPIN command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -865,27 +860,27 @@ static int _nas_user_proc_cpin(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_csq(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_csq_resp_t *csq = &_nas_user_data.response.csq;
+  at_csq_resp_t *csq = &at_response->response.csq;
   memset(csq, 0, sizeof(at_csq_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CSQ_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CSQ_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -906,7 +901,7 @@ static int _nas_user_proc_csq(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CSQ command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -926,27 +921,27 @@ static int _nas_user_proc_csq(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cesq(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cesq_resp_t *cesq = &_nas_user_data.response.cesq;
+  at_cesq_resp_t *cesq = &at_response->response.cesq;
   memset(cesq, 0, sizeof(at_cesq_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CESQ_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CESQ_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -969,7 +964,7 @@ static int _nas_user_proc_cesq(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CESQ command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -991,16 +986,16 @@ static int _nas_user_proc_cesq(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cops_resp_t *cops = &_nas_user_data.response.cops;
+  at_cops_resp_t *cops = &at_response->response.cops;
   memset(cops, 0, sizeof(at_cops_resp_t));
 
   static int read_format = AT_COPS_FORMAT_DEFAULT;
@@ -1013,15 +1008,15 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
 
   int oper_is_selected;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_NO_PARAM;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_NO_PARAM;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -1057,7 +1052,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
         /* <oper> field shall be present */
         if ( !(data->mask & AT_COPS_OPER_MASK) ) {
           LOG_TRACE(ERROR, "USR-MAIN  - <oper> parameter is not present");
-          _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+          at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
           ret_code = RETURNerror;
           break;
         }
@@ -1065,7 +1060,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
         /* <format> field shall be present */
         if ( !(data->mask & AT_COPS_FORMAT_MASK) ) {
           LOG_TRACE(ERROR, "USR-MAIN  - <format> parameter is not present");
-          _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+          at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
           ret_code = RETURNerror;
           break;
         }
@@ -1076,7 +1071,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
           /* The value of <format> field is not valid */
           LOG_TRACE(ERROR, "USR-MAIN  - <format> parameter is not valid (%d)",
                     data->command.cops.format);
-          _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+          at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
           ret_code = RETURNerror;
           break;
         }
@@ -1090,7 +1085,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
             /* The value of <AcT> field is not valid */
             LOG_TRACE(ERROR, "USR-MAIN  - <AcT> parameter is not valid (%d)",
                       data->command.cops.AcT);
-            _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+            at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
             ret_code = RETURNerror;
             break;
           }
@@ -1118,7 +1113,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
             /* The value of <format> field is not valid */
             LOG_TRACE(ERROR, "USR-MAIN  - <format> parameter is not valid (%d)",
                       data->command.cops.format);
-            _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+            at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
             ret_code = RETURNerror;
             break;
           }
@@ -1134,7 +1129,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
 
       default:
         LOG_TRACE(ERROR, "USR-MAIN  - <mode> parameter is not supported (%d)", mode);
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
         ret_code = RETURNerror;
         break;
       }
@@ -1150,7 +1145,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
 
         if (ret_code != RETURNok) {
           LOG_TRACE(ERROR, "USR-MAIN  - Network deregistration failed");
-          _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+          at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
           break;
         }
       } else if (mode != AT_COPS_FORMAT) {
@@ -1161,7 +1156,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
 
         if (ret_code != RETURNok) {
           LOG_TRACE(ERROR, "USR-MAIN  - Network registration failed (<mode>=%d)", mode);
-          _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+          at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
           break;
         }
       }
@@ -1183,7 +1178,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
     if (ret_code != RETURNok) {
       LOG_TRACE(ERROR, "USR-MAIN  - Failed to get registration data (<mode>=%d)",
                 mode);
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       break;
     }
 
@@ -1199,11 +1194,11 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
     /* Set optional parameter bitmask */
     if (oper_is_selected) {
       cops->get.format = read_format;
-      _nas_user_data.mask |= (AT_COPS_RESP_FORMAT_MASK |
+      at_response->mask |= (AT_COPS_RESP_FORMAT_MASK |
                               AT_COPS_RESP_OPER_MASK);
 
       if (cops->get.AcT != NET_ACCESS_UNAVAILABLE) {
-        _nas_user_data.mask |= AT_COPS_RESP_ACT_MASK;
+        at_response->mask |= AT_COPS_RESP_ACT_MASK;
       }
     }
 
@@ -1220,7 +1215,7 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+COPS command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -1240,27 +1235,27 @@ static int _nas_user_proc_cops(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgatt(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgatt_resp_t *cgatt = &_nas_user_data.response.cgatt;
+  at_cgatt_resp_t *cgatt = &at_response->response.cgatt;
   memset(cgatt, 0, sizeof(at_cgatt_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CGATT_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CGATT_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -1275,7 +1270,7 @@ static int _nas_user_proc_cgatt(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <state> parameter is not valid (%d)",
                   data->command.cgatt.state);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1295,7 +1290,7 @@ static int _nas_user_proc_cgatt(nas_user_t *user, const at_command_t *data)
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to attach/detach "
                   "to/from EPS service (<state>=%d)",
                   data->command.cgatt.state);
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
     }
 
@@ -1324,7 +1319,7 @@ static int _nas_user_proc_cgatt(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGATT command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -1345,29 +1340,29 @@ static int _nas_user_proc_cgatt(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_creg(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_creg_resp_t *creg = &_nas_user_data.response.creg;
+  at_creg_resp_t *creg = &at_response->response.creg;
   memset(creg, 0, sizeof(at_creg_resp_t));
 
   static int n = AT_CREG_N_DEFAULT;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_NO_PARAM;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_NO_PARAM;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -1384,7 +1379,7 @@ static int _nas_user_proc_creg(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <n> parameter is not valid"
                   " (%d)", data->command.creg.n);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1410,7 +1405,7 @@ static int _nas_user_proc_creg(nas_user_t *user, const at_command_t *data)
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR,
                   "USR-MAIN  - Failed to disable logging of network notification");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1425,7 +1420,7 @@ static int _nas_user_proc_creg(nas_user_t *user, const at_command_t *data)
 
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to enable logging of registration status");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1456,7 +1451,7 @@ static int _nas_user_proc_creg(nas_user_t *user, const at_command_t *data)
 
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to get registration status");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1473,7 +1468,7 @@ static int _nas_user_proc_creg(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CREG command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -1494,29 +1489,29 @@ static int _nas_user_proc_creg(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgreg(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgreg_resp_t *cgreg = &_nas_user_data.response.cgreg;
+  at_cgreg_resp_t *cgreg = &at_response->response.cgreg;
   memset(cgreg, 0, sizeof(at_cgreg_resp_t));
 
   static int n = AT_CGREG_N_DEFAULT;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_NO_PARAM;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_NO_PARAM;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -1533,7 +1528,7 @@ static int _nas_user_proc_cgreg(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <n> parameter is not valid"
                   " (%d)", data->command.cgreg.n);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1559,7 +1554,7 @@ static int _nas_user_proc_cgreg(nas_user_t *user, const at_command_t *data)
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR,
                   "USR-MAIN  - Failed to disable logging of network notification");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1574,7 +1569,7 @@ static int _nas_user_proc_cgreg(nas_user_t *user, const at_command_t *data)
 
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to enable logging of registration status");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1605,7 +1600,7 @@ static int _nas_user_proc_cgreg(nas_user_t *user, const at_command_t *data)
 
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to get registration status");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1622,7 +1617,7 @@ static int _nas_user_proc_cgreg(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGREG command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -1643,29 +1638,29 @@ static int _nas_user_proc_cgreg(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cereg_resp_t *cereg = &_nas_user_data.response.cereg;
+  at_cereg_resp_t *cereg = &at_response->response.cereg;
   memset(cereg, 0, sizeof(at_cereg_resp_t));
 
   static int n = AT_CEREG_N_DEFAULT;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_NO_PARAM;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_NO_PARAM;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -1682,7 +1677,7 @@ static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <n> parameter is not valid"
                   " (%d)",  data->command.cereg.n);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1708,7 +1703,7 @@ static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR,
                   "USR-MAIN  - Failed to disable logging of network notification");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1719,7 +1714,7 @@ static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
 
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to enable logging of location information");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1731,7 +1726,7 @@ static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
 
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to enable logging of registration status");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1759,16 +1754,16 @@ static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
 
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to get location information");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
         break;
       }
 
       if (cereg->tac[0] != 0) {
-        _nas_user_data.mask |= (AT_CEREG_RESP_TAC_MASK |
+        at_response->mask |= (AT_CEREG_RESP_TAC_MASK |
                                 AT_CEREG_RESP_CI_MASK);
 
         if (cereg->AcT != NET_ACCESS_UNAVAILABLE) {
-          _nas_user_data.mask |= (AT_CEREG_RESP_ACT_MASK);
+          at_response->mask |= (AT_CEREG_RESP_ACT_MASK);
         }
       }
 
@@ -1781,7 +1776,7 @@ static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
 
       if (ret_code != RETURNok) {
         LOG_TRACE(ERROR, "USR-MAIN  - Failed to get registration status");
-        _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+        at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       }
 
       break;
@@ -1798,7 +1793,7 @@ static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CEREG command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -1824,16 +1819,16 @@ static int _nas_user_proc_cereg(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgdcont_get_t *cgdcont = &_nas_user_data.response.cgdcont.get;
+  at_cgdcont_get_t *cgdcont = &at_response->response.cgdcont.get;
   memset(cgdcont, 0, sizeof(at_cgdcont_resp_t));
 
   int cid = AT_CGDCONT_CID_DEFAULT;
@@ -1845,15 +1840,15 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
   int im_cn_signalling = AT_CGDCONT_IM_CM_DEFAULT;
   int reset_pdn = TRUE;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_NO_PARAM;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_NO_PARAM;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -1867,7 +1862,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <cid> parameter is not valid"
                   " (%d)", data->command.cgdcont.cid);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1887,7 +1882,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <PDN_type> parameter is not "
                   "valid (%s)", data->command.cgdcont.PDP_type);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1906,7 +1901,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
          * not valid; return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <d_comp> parameter is not "
                   "valid (%d)", data->command.cgdcont.d_comp);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1921,7 +1916,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
          * not valid; return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <h_comp> parameter is not "
                   "valid (%d)", data->command.cgdcont.h_comp);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1937,7 +1932,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
         LOG_TRACE(ERROR, "USR-MAIN  - <IPv4AddrAlloc> parameter "
                   "is not valid (%d)",
                   data->command.cgdcont.IPv4AddrAlloc);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1953,7 +1948,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
         LOG_TRACE(ERROR, "USR-MAIN  - <emergency indication> "
                   "parameter is not valid (%d)",
                   data->command.cgdcont.emergency_indication);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1969,7 +1964,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
         LOG_TRACE(ERROR, "USR-MAIN  - <P-CSCF_discovery> "
                   "parameter is not valid (%d)",
                   data->command.cgdcont.P_CSCF_discovery);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -1986,7 +1981,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
         LOG_TRACE(ERROR, "USR-MAIN  - <IM_CN_Signalling_Flag_Ind> "
                   "parameter is not valid (%d)",
                   data->command.cgdcont.IM_CN_Signalling_Flag_Ind);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -2011,7 +2006,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
     if (ret_code != RETURNok) {
       LOG_TRACE(ERROR, "USR-MAIN  - Failed to setup PDN connection "
                 "(<cid>=%d)", data->command.cgdcont.cid);
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -2028,7 +2023,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
 
     if (cgdcont->n_pdns == 0) {
       LOG_TRACE(ERROR, "USR-MAIN  - No any PDN context is defined");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -2043,11 +2038,11 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
 
     if (cid_max > AT_CGDCONT_RESP_SIZE) {
       /* The range is defined by the user interface */
-      _nas_user_data.response.cgdcont.tst.n_cid =
+      at_response->response.cgdcont.tst.n_cid =
         AT_CGDCONT_RESP_SIZE;
     } else {
       /* The range is defined by the ESM sublayer application */
-      _nas_user_data.response.cgdcont.tst.n_cid = cid_max;
+      at_response->response.cgdcont.tst.n_cid = cid_max;
     }
   }
   break;
@@ -2055,7 +2050,7 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGDCONT command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -2076,30 +2071,30 @@ static int _nas_user_proc_cgdcont(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgact(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgact_resp_t *cgact = &_nas_user_data.response.cgact;
+  at_cgact_resp_t *cgact = &at_response->response.cgact;
   memset(cgact, 0, sizeof(at_cgact_resp_t));
 
   int cid = -1;
   int state = AT_CGACT_STATE_DEFAULT;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CGACT_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CGACT_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -2114,7 +2109,7 @@ static int _nas_user_proc_cgact(nas_user_t *user, const at_command_t *data)
          * not valid; return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <state> parameter is "
                   "not valid (%d)",  data->command.cgact.state);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -2128,7 +2123,7 @@ static int _nas_user_proc_cgact(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <cid> parameter is "
                   "not valid (%d)",  data->command.cgact.cid);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -2152,7 +2147,7 @@ static int _nas_user_proc_cgact(nas_user_t *user, const at_command_t *data)
                 "(<state>=%d,<cid>=%d)",
                 (state != AT_CGACT_ACTIVATED)? "deactivate" :
                 "activate", state, cid);
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -2167,7 +2162,7 @@ static int _nas_user_proc_cgact(nas_user_t *user, const at_command_t *data)
 
     if (cgact->n_pdns == 0) {
       LOG_TRACE(ERROR, "USR-MAIN  - No any PDN context is defined");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -2182,7 +2177,7 @@ static int _nas_user_proc_cgact(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGACT command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -2204,7 +2199,6 @@ static int _nas_user_proc_cgact(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cmee(nas_user_t *user, const at_command_t *data)
@@ -2212,15 +2206,16 @@ static int _nas_user_proc_cmee(nas_user_t *user, const at_command_t *data)
   LOG_FUNC_IN;
 
   int ret_code = RETURNok;
-  at_cmee_resp_t *cmee = &_nas_user_data.response.cmee;
+  at_response_t *at_response = user->at_response;
+  at_cmee_resp_t *cmee = &at_response->response.cmee;
   memset(cmee, 0, sizeof(at_cmee_resp_t));
 
   int n = AT_CMEE_N_DEFAULT;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CMEE_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CMEE_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:    /* ATV0, ATV1 response format commands */
@@ -2238,7 +2233,7 @@ static int _nas_user_proc_cmee(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <n> parameter is not valid"
                   " (%d)", data->command.cmee.n);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -2282,7 +2277,7 @@ static int _nas_user_proc_cmee(nas_user_t *user, const at_command_t *data)
 
     if (cmee->n == RETURNerror) {
       LOG_TRACE(ERROR, "USR-MAIN  - Failed to get format of the final result code");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -2296,7 +2291,7 @@ static int _nas_user_proc_cmee(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CMEE command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -2317,21 +2312,21 @@ static int _nas_user_proc_cmee(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_clck(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_clck_resp_t *clck = &_nas_user_data.response.clck;
+  at_clck_resp_t *clck = &at_response->response.clck;
   memset(clck, 0, sizeof(at_clck_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CLCK_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CLCK_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
@@ -2347,7 +2342,7 @@ static int _nas_user_proc_clck(nas_user_t *user, const at_command_t *data)
       /* Facilities other than SIM is not supported */
       LOG_TRACE(ERROR, "USR-MAIN  - Facility is not supported (%s)",
                 data->command.clck.fac);
-      _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+      at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
       ret_code = RETURNerror;
       break;
     }
@@ -2360,7 +2355,7 @@ static int _nas_user_proc_clck(nas_user_t *user, const at_command_t *data)
         /* The PIN code is NOT matching; return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - Password is not correct "
                   "(%s)", data->command.clck.passwd);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PASSWD;
+        at_response->cause_code = AT_ERROR_INCORRECT_PASSWD;
         ret_code = RETURNerror;
         break;
       }
@@ -2375,14 +2370,14 @@ static int _nas_user_proc_clck(nas_user_t *user, const at_command_t *data)
         /* unlock requires password */
         LOG_TRACE(ERROR, "USR-MAIN  - unlock mode of operation "
                   "requires a password");
-        _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+        at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
         ret_code = RETURNerror;
         break;
       }
 
       LOG_TRACE(ERROR, "USR-MAIN  - unlock mode of operation "
                 "is not supported");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       ret_code = RETURNerror;
       break;
 
@@ -2393,14 +2388,14 @@ static int _nas_user_proc_clck(nas_user_t *user, const at_command_t *data)
         /* unlock requires password */
         LOG_TRACE(ERROR, "USR-MAIN  - lock mode of operation "
                   "requires a password");
-        _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+        at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
         ret_code = RETURNerror;
         break;
       }
 
       LOG_TRACE(ERROR, "USR-MAIN  - lock mode of operation "
                 "is not supported");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
       ret_code = RETURNerror;
       break;
 
@@ -2412,7 +2407,7 @@ static int _nas_user_proc_clck(nas_user_t *user, const at_command_t *data)
     default:
       LOG_TRACE(ERROR, "USR-MAIN  - <mode> parameter is not valid"
                 " (%d)", data->command.clck.mode);
-      _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+      at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
       ret_code = RETURNerror;
       break;
     }
@@ -2428,7 +2423,7 @@ static int _nas_user_proc_clck(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CLCK command type %d is not supported",
               data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -2448,29 +2443,29 @@ static int _nas_user_proc_clck(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cgpaddr(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cgpaddr_resp_t *cgpaddr = &_nas_user_data.response.cgpaddr;
+  at_cgpaddr_resp_t *cgpaddr = &at_response->response.cgpaddr;
   memset(cgpaddr, 0, sizeof(at_cgpaddr_resp_t));
 
   int cid = -1;
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CGPADDR_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CGPADDR_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_SET:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -2484,7 +2479,7 @@ static int _nas_user_proc_cgpaddr(nas_user_t *user, const at_command_t *data)
          * return an error message */
         LOG_TRACE(ERROR, "USR-MAIN  - <cid> parameter is "
                   "not valid (%d)",  data->command.cgpaddr.cid);
-        _nas_user_data.cause_code = AT_ERROR_INCORRECT_PARAMETERS;
+        at_response->cause_code = AT_ERROR_INCORRECT_PARAMETERS;
         ret_code = RETURNerror;
         break;
       }
@@ -2502,7 +2497,7 @@ static int _nas_user_proc_cgpaddr(nas_user_t *user, const at_command_t *data)
 
     if (cgpaddr->n_pdns == 0) {
       LOG_TRACE(ERROR, "USR-MAIN  - No any PDN context is defined");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -2520,7 +2515,7 @@ static int _nas_user_proc_cgpaddr(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CGPADDR command type %d is "
               "not supported", data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -2540,27 +2535,27 @@ static int _nas_user_proc_cgpaddr(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_cnum(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
   nas_user_context_t *nas_user_context = user->nas_user_context;
+  at_response_t *at_response = user->at_response;
 
   int ret_code = RETURNok;
-  at_cnum_resp_t *cnum = &_nas_user_data.response.cnum;
+  at_cnum_resp_t *cnum = &at_response->response.cnum;
   memset(cnum, 0, sizeof(at_cnum_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CNUM_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CNUM_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
     if (nas_user_context->sim_status != NAS_USER_READY) {
-      _nas_user_data.cause_code = AT_ERROR_SIM_PIN_REQUIRED;
+      at_response->cause_code = AT_ERROR_SIM_PIN_REQUIRED;
       LOG_FUNC_RETURN(RETURNerror);
     }
 
@@ -2569,7 +2564,7 @@ static int _nas_user_proc_cnum(nas_user_t *user, const at_command_t *data)
 
     if (ret_code != RETURNok) {
       LOG_TRACE(ERROR, "USR-MAIN  - Failed to get MS dialing number");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -2581,7 +2576,7 @@ static int _nas_user_proc_cnum(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CNUM command type %d is "
               "not supported", data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }
@@ -2601,21 +2596,20 @@ static int _nas_user_proc_cnum(nas_user_t *user, const at_command_t *data)
  **                                                                        **
  ** Outputs:     None                                                      **
  **      Return:    RETURNok; RETURNerror;                     **
- **          Others:    _nas_user_data                             **
  **                                                                        **
  ***************************************************************************/
 static int _nas_user_proc_clac(nas_user_t *user, const at_command_t *data)
 {
   LOG_FUNC_IN;
-
+  at_response_t *at_response = user->at_response;
   int ret_code = RETURNok;
-  at_clac_resp_t *clac = &_nas_user_data.response.clac;
+  at_clac_resp_t *clac = &at_response->response.clac;
   memset(clac, 0, sizeof(at_clac_resp_t));
 
-  _nas_user_data.id = data->id;
-  _nas_user_data.type = data->type;
-  _nas_user_data.mask = AT_RESPONSE_CLAC_MASK;
-  _nas_user_data.cause_code = AT_ERROR_SUCCESS;
+  at_response->id = data->id;
+  at_response->type = data->type;
+  at_response->mask = AT_RESPONSE_CLAC_MASK;
+  at_response->cause_code = AT_ERROR_SUCCESS;
 
   switch (data->type) {
   case AT_COMMAND_ACT:
@@ -2625,7 +2619,7 @@ static int _nas_user_proc_clac(nas_user_t *user, const at_command_t *data)
     if (clac->n_acs == 0) {
       LOG_TRACE(ERROR, "USR-MAIN  - Failed to get the list of "
                 "supported AT commands");
-      _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+      at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     }
 
     break;
@@ -2637,7 +2631,7 @@ static int _nas_user_proc_clac(nas_user_t *user, const at_command_t *data)
   default:
     LOG_TRACE(ERROR, "USR-MAIN  - AT+CLAC command type %d is "
               "not supported", data->type);
-    _nas_user_data.cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
+    at_response->cause_code = AT_ERROR_OPERATION_NOT_SUPPORTED;
     ret_code = RETURNerror;
     break;
   }

openair3/NAS/UE/nas_user.h

@@ -67,6 +67,6 @@ int nas_user_receive_and_process(nas_user_t *user, char *message);
 
 int nas_user_process_data(nas_user_t *user, const void *data);
 
-const void *nas_user_get_data(void);
+const void *nas_user_get_data(nas_user_t *nas_user);
 
 #endif /* __NAS_USER_H__*/

openair3/NAS/UE/user_defs.h

@@ -55,6 +55,7 @@ Description NAS type definition to manage a user equipment
 #include "API/USIM/usim_api.h"
 #include "SecurityModeControl.h"
 #include "userDef.h"
+#include "at_response.h"
 
 typedef struct {
   int fd;
@@ -74,6 +75,7 @@ typedef struct {
   user_nvdata_t *nas_user_nvdata; //UE parameters stored in the UE's non-volatile memory device
   //
   nas_user_context_t *nas_user_context;
+  at_response_t *at_response; // data structure returned to the user as the result of NAS procedure function call
 } nas_user_t;
 
 #endif