maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
60094de81f64967cbec7b5f0cba830b0bedbf021
openairinterface5g/openair3/M3AP/m3ap_MME.c
T
Robert Schmidt dfa012162b Rewrite sctp_create_new_listener() to handle DNS, IPv6 
Rewrite sctp_create_new_listener() to use getaddrinfo() to look up
IPv4/IPv6 addresses via a common interface. This allows to use e.g. DNS,
and enables the SCTP library to listen on IPv6 ports.

To support the above, the corresponding message is changed to not take
an IPv4 address on 4 bytes (and separate IPv6), but a single name that
will be resolved via getaddrinfo()

The previous init message used to allow multiple IPv4/IPv6 addresses;
since this is not used anywhere, remove the corresponding functionality.

Modify all uses of this ITTI message to copy te SCTP init bind addr into
ITTI message.
2024-04-13 05:15:11 +02:00

701 lines
28 KiB
C
Raw Blame History

/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
/*! \file m3ap_MME.c
* \brief m3ap tasks for MME
* \author Javier Morgade <javier.morgade@ieee.org>
* \date 2019
* \version 0.1
*/
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <arpa/inet.h>
#include "intertask_interface.h"
#include "m3ap_MME.h"
#include "m3ap_MME_defs.h"
#include "m3ap_MME_management_procedures.h"
#include "m3ap_MME_handler.h"
//#include "m3ap_MME_generate_messages.h"
#include "m3ap_common.h"
#include "m3ap_MME_interface_management.h"
#include "m3ap_ids.h"
#include "m3ap_timers.h"
#include "queue.h"
#include "assertions.h"
#include "conversions.h"
struct m3ap_mme_map;
struct m3ap_MME_data_s;
m3ap_setup_req_t *m3ap_mme_data_from_mce;
RB_PROTOTYPE(m3ap_mme_map, m3ap_MME_data_s, entry, m3ap_MME_compare_assoc_id);
static
void m3ap_MME_handle_sctp_data_ind(instance_t instance, sctp_data_ind_t *sctp_data_ind);
static
void m3ap_MME_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp);
static
void m3ap_MME_handle_sctp_association_ind(instance_t instance, sctp_new_association_ind_t *sctp_new_association_ind);
//static
//void m3ap_MME_handle_register_MME(instance_t instance,
// m3ap_register_mce_req_t *m3ap_register_MME);
static
void m3ap_MME_register_MME(m3ap_MME_instance_t *instance_p,
net_ip_address_t *target_MME_ip_addr,
net_ip_address_t *local_ip_addr,
uint16_t in_streams,
uint16_t out_streams,
uint32_t mme_port_for_M3C,
int multi_sd);
//static
//void m3ap_MME_handle_handover_req(instance_t instance,
// m3ap_handover_req_t *m3ap_handover_req);
//
//static
//void m3ap_MME_handle_handover_req_ack(instance_t instance,
// m3ap_handover_req_ack_t *m3ap_handover_req_ack);
//
//static
//void m3ap_MME_ue_context_release(instance_t instance,
// m3ap_ue_context_release_t *m3ap_ue_context_release);
//
static
void m3ap_MME_handle_sctp_data_ind(instance_t instance, sctp_data_ind_t *sctp_data_ind) {
int result;
DevAssert(sctp_data_ind != NULL);
m3ap_MME_handle_message(instance, sctp_data_ind->assoc_id, sctp_data_ind->stream,
sctp_data_ind->buffer, sctp_data_ind->buffer_length);
result = itti_free(TASK_UNKNOWN, sctp_data_ind->buffer);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
}
static
void m3ap_MME_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp) {
DevAssert(sctp_new_association_resp != NULL);
if (sctp_new_association_resp->sctp_state != SCTP_STATE_ESTABLISHED) {
LOG_W(M3AP, "Received unsuccessful result for SCTP association (%u), instance %ld, cnx_id %u\n",
sctp_new_association_resp->sctp_state,
instance,
sctp_new_association_resp->ulp_cnx_id);
if (sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN)
return;
}
// go to an init func
m3ap_mme_data_from_mce = (m3ap_setup_req_t *)calloc(1, sizeof(m3ap_setup_req_t));
// save the assoc id
m3ap_mme_data_from_mce->assoc_id = sctp_new_association_resp->assoc_id;
m3ap_mme_data_from_mce->sctp_in_streams = sctp_new_association_resp->in_streams;
m3ap_mme_data_from_mce->sctp_out_streams = sctp_new_association_resp->out_streams;
// m3ap_MME_instance_t *instance_p;
// m3ap_MME_data_t *m3ap_mme_data_p;
// DevAssert(sctp_new_association_resp != NULL);
// printf("m3ap_MME_handle_sctp_association_resp at 1\n");
// dump_mme_trees_m3();
// instance_p = instance;//m3ap_MME_get_instance(instance);
// DevAssert(instance_p != NULL);
// /* if the assoc_id is already known, it is certainly because an IND was received
// * before. In this case, just update streams and return
// */
// if (sctp_new_association_resp->assoc_id != -1) {
// m3ap_mme_data_p = m3ap_get_MME(instance_p, sctp_new_association_resp->assoc_id,
// sctp_new_association_resp->ulp_cnx_id);
// if (m3ap_mme_data_p != NULL) {
// /* some sanity check - to be refined at some point */
// if (sctp_new_association_resp->sctp_state != SCTP_STATE_ESTABLISHED) {
// M3AP_ERROR("m3ap_mme_data_p not NULL and sctp state not SCTP_STATE_ESTABLISHED, what to do?\n");
// abort();
// }
// m3ap_mme_data_p->in_streams = sctp_new_association_resp->in_streams;
// m3ap_mme_data_p->out_streams = sctp_new_association_resp->out_streams;
// return;
// }
// }
// m3ap_mme_data_p = m3ap_get_MME(instance_p, -1,
// sctp_new_association_resp->ulp_cnx_id);
// DevAssert(m3ap_mme_data_p != NULL);
// printf("m3ap_MME_handle_sctp_association_resp at 2\n");
// dump_mme_trees_m3();
// if (sctp_new_association_resp->sctp_state != SCTP_STATE_ESTABLISHED) {
// M3AP_WARN("Received unsuccessful result for SCTP association (%u), instance %d, cnx_id %u\n",
// sctp_new_association_resp->sctp_state,
// instance,
// sctp_new_association_resp->ulp_cnx_id);
// //m3ap_eNB_handle_m3_setup_message(instance_p, m3ap_mme_data_p,
// //sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN);
// return;
// }
// printf("m3ap_MME_handle_sctp_association_resp at 3\n");
// dump_mme_trees_m3();
// /* Update parameters */
// m3ap_mme_data_p->assoc_id = sctp_new_association_resp->assoc_id;
// m3ap_mme_data_p->in_streams = sctp_new_association_resp->in_streams;
// m3ap_mme_data_p->out_streams = sctp_new_association_resp->out_streams;
// printf("m3ap_MME_handle_sctp_association_resp at 4\n");
// dump_mme_trees_m3();
// /* Prepare new m3 Setup Request */
// //m3ap_MME_generate_m3_setup_request(instance_p, m3ap_mme_data_p);
}
static
void m3ap_MME_handle_sctp_association_ind(instance_t instance, sctp_new_association_ind_t *sctp_new_association_ind) {
//m3ap_MME_instance_t *instance_p;
//m3ap_MME_data_t *m3ap_mme_data_p;
//printf("m3ap_MME_handle_sctp_association_ind at 1 (called for instance %d)\n", instance);
///dump_mme_trees_m3();
///DevAssert(sctp_new_association_ind != NULL);
///instance_p = instance;//m3ap_MME_get_instance(instance);
///DevAssert(instance_p != NULL);
///m3ap_mme_data_p = m3ap_get_MME(instance_p, sctp_new_association_ind->assoc_id, -1);
///if (m3ap_mme_data_p != NULL) abort();
///// DevAssert(m3ap_enb_data_p != NULL);
///if (m3ap_mme_data_p == NULL) {
/// /* Create new MME descriptor */
/// m3ap_mme_data_p = calloc(1, sizeof(*m3ap_mme_data_p));
/// DevAssert(m3ap_mme_data_p != NULL);
/// m3ap_mme_data_p->cnx_id = m3ap_MME_fetch_add_global_cnx_id();
/// m3ap_mme_data_p->m3ap_MME_instance = instance_p;
/// /* Insert the new descriptor in list of known MME
/// * but not yet associated.
/// */
/// RB_INSERT(m3ap_mme_map, &instance_p->m3ap_mme_head, m3ap_mme_data_p);
/// m3ap_mme_data_p->state = M3AP_MME_STATE_CONNECTED;
/// instance_p->m3_target_mme_nb++;
/// if (instance_p->m3_target_mme_pending_nb > 0) {
/// instance_p->m3_target_mme_pending_nb--;
/// }
///} else {
/// M3AP_WARN("m3ap_mme_data_p already exists\n");
///}
///printf("m3ap_MME_handle_sctp_association_ind at 2\n");
///dump_mme_trees_m3();
////* Update parameters */
///m3ap_mme_data_p->assoc_id = sctp_new_association_ind->assoc_id;
///m3ap_mme_data_p->in_streams = sctp_new_association_ind->in_streams;
///m3ap_mme_data_p->out_streams = sctp_new_association_ind->out_streams;
///printf("m3ap_MME_handle_sctp_association_ind at 3\n");
///dump_mme_trees_m3();
}
int m3ap_MME_init_sctp (m3ap_MME_instance_t *instance_p,
net_ip_address_t *local_ip_addr,
uint32_t mme_port_for_M3C) {
// Create and alloc new message
DevAssert(instance_p != NULL);
DevAssert(local_ip_addr != NULL);
size_t addr_len = strlen(local_ip_addr->ipv4_address) + 1;
MessageDef *message = itti_alloc_new_message_sized(TASK_M3AP_MME, 0, SCTP_INIT_MSG_MULTI_REQ, sizeof(sctp_init_t) + addr_len);
sctp_init_t *sctp_init = &message->ittiMsg.sctp_init_multi;
sctp_init->port = mme_port_for_M3C;
sctp_init->ppid = M3AP_SCTP_PPID;
char *addr_buf = (char *) (sctp_init + 1);
sctp_init->bind_address = addr_buf;
memcpy(addr_buf, local_ip_addr->ipv4_address, addr_len);
return itti_send_msg_to_task (TASK_SCTP, instance_p->instance, message);
}
static void m3ap_MME_register_MME(m3ap_MME_instance_t *instance_p,
net_ip_address_t *target_MME_ip_address,
net_ip_address_t *local_ip_addr,
uint16_t in_streams,
uint16_t out_streams,
uint32_t mme_port_for_M3C,
int multi_sd) {
// MessageDef *message = NULL;
// sctp_new_association_req_multi_t *sctp_new_association_req = NULL;
// m3ap_MME_data_t *m3ap_mme_data = NULL;
// DevAssert(instance_p != NULL);
// DevAssert(target_MME_ip_address != NULL);
// message = itti_alloc_new_message(TASK_M3AP_MME, 0, SCTP_NEW_ASSOCIATION_REQ_MULTI);
// sctp_new_association_req = &message->ittiMsg.sctp_new_association_req_multi;
// sctp_new_association_req->port = mme_port_for_M3C;
// sctp_new_association_req->ppid = M3AP_SCTP_PPID;
// sctp_new_association_req->in_streams = in_streams;
// sctp_new_association_req->out_streams = out_streams;
// sctp_new_association_req->multi_sd = multi_sd;
// memcpy(&sctp_new_association_req->remote_address,
// target_MME_ip_address,
// sizeof(*target_MME_ip_address));
// memcpy(&sctp_new_association_req->local_address,
// local_ip_addr,
// sizeof(*local_ip_addr));
// /* Create new MME descriptor */
// m3ap_mme_data = calloc(1, sizeof(*m3ap_mme_data));
// DevAssert(m3ap_mme_data != NULL);
// m3ap_mme_data->cnx_id = m3ap_MME_fetch_add_global_cnx_id();
// sctp_new_association_req->ulp_cnx_id = m3ap_mme_data->cnx_id;
// m3ap_mme_data->assoc_id = -1;
// m3ap_mme_data->m3ap_MME_instance = instance_p;
// /* Insert the new descriptor in list of known MME
// * but not yet associated.
// */
// RB_INSERT(m3ap_mme_map, &instance_p->m3ap_mme_head, m3ap_mme_data);
// m3ap_mme_data->state = M3AP_MME_STATE_WAITING;
// instance_p->m3_target_mme_nb ++;
// instance_p->m3_target_mme_pending_nb ++;
// itti_send_msg_to_task(TASK_SCTP, instance_p->instance, message);
}
//static
//void m3ap_MME_handle_register_MME(instance_t instance,
// m3ap_register_mce_req_t *m3ap_register_MME) {
// m3ap_MME_instance_t *new_instance;
// DevAssert(m3ap_register_MME != NULL);
// /* Look if the provided instance already exists */
// new_instance = m3ap_MME_get_instance(instance);
//
// if (new_instance != NULL) {
// /* Checks if it is a retry on the same MME */
// DevCheck(new_instance->MME_id == m3ap_register_MME->MME_id, new_instance->MME_id, m3ap_register_MME->MME_id, 0);
// DevCheck(new_instance->cell_type == m3ap_register_MME->cell_type, new_instance->cell_type, m3ap_register_MME->cell_type, 0);
// DevCheck(new_instance->tac == m3ap_register_MME->tac, new_instance->tac, m3ap_register_MME->tac, 0);
// DevCheck(new_instance->mcc == m3ap_register_MME->mcc, new_instance->mcc, m3ap_register_MME->mcc, 0);
// DevCheck(new_instance->mnc == m3ap_register_MME->mnc, new_instance->mnc, m3ap_register_MME->mnc, 0);
// M3AP_WARN("MME[%d] already registered\n", instance);
// } else {
// new_instance = calloc(1, sizeof(m3ap_MME_instance_t));
// DevAssert(new_instance != NULL);
// RB_INIT(&new_instance->m3ap_mme_head);
// /* Copy usefull parameters */
// new_instance->instance = instance;
// new_instance->MME_name = m3ap_register_MME->MME_name;
// new_instance->MME_id = m3ap_register_MME->MME_id;
// new_instance->cell_type = m3ap_register_MME->cell_type;
// new_instance->tac = m3ap_register_MME->tac;
// new_instance->mcc = m3ap_register_MME->mcc;
// new_instance->mnc = m3ap_register_MME->mnc;
// new_instance->mnc_digit_length = m3ap_register_MME->mnc_digit_length;
// new_instance->num_cc = m3ap_register_MME->num_cc;
//
// m3ap_id_manager_init(&new_instance->id_manager);
// m3ap_timers_init(&new_instance->timers,
// m3ap_register_MME->t_reloc_prep,
// m3ap_register_MME->tm3_reloc_overall);
//
// for (int i = 0; i< m3ap_register_MME->num_cc; i++) {
// new_instance->eutra_band[i] = m3ap_register_MME->eutra_band[i];
// new_instance->downlink_frequency[i] = m3ap_register_MME->downlink_frequency[i];
// new_instance->uplink_frequency_offset[i] = m3ap_register_MME->uplink_frequency_offset[i];
// new_instance->Nid_cell[i] = m3ap_register_MME->Nid_cell[i];
// new_instance->N_RB_DL[i] = m3ap_register_MME->N_RB_DL[i];
// new_instance->frame_type[i] = m3ap_register_MME->frame_type[i];
// new_instance->fdd_earfcn_DL[i] = m3ap_register_MME->fdd_earfcn_DL[i];
// new_instance->fdd_earfcn_UL[i] = m3ap_register_MME->fdd_earfcn_UL[i];
// }
//
// DevCheck(m3ap_register_MME->nb_m3 <= M3AP_MAX_NB_MME_IP_ADDRESS,
// M3AP_MAX_NB_MME_IP_ADDRESS, m3ap_register_MME->nb_m3, 0);
// memcpy(new_instance->target_mme_m3_ip_address,
// m3ap_register_MME->target_mme_m3_ip_address,
// m3ap_register_MME->nb_m3 * sizeof(net_ip_address_t));
// new_instance->nb_m3 = m3ap_register_MME->nb_m3;
// new_instance->mme_m3_ip_address = m3ap_register_MME->mme_m3_ip_address;
// new_instance->sctp_in_streams = m3ap_register_MME->sctp_in_streams;
// new_instance->sctp_out_streams = m3ap_register_MME->sctp_out_streams;
// new_instance->mme_port_for_M3C = m3ap_register_MME->mme_port_for_M3C;
// /* Add the new instance to the list of MME (meaningfull in virtual mode) */
// m3ap_MME_insert_new_instance(new_instance);
// M3AP_INFO("Registered new MME[%d] and %s MME id %u\n",
// instance,
// m3ap_register_MME->cell_type == CELL_MACRO_ENB ? "macro" : "home",
// m3ap_register_MME->MME_id);
//
// /* initiate the SCTP listener */
// if (m3ap_MME_init_sctp(new_instance,&m3ap_register_MME->mme_m3_ip_address,m3ap_register_MME->mme_port_for_M3C) < 0 ) {
// M3AP_ERROR ("Error while sending SCTP_INIT_MSG to SCTP \n");
// return;
// }
//
// M3AP_INFO("MME[%d] MME id %u acting as a listner (server)\n",
// instance, m3ap_register_MME->MME_id);
// }
//}
static
void m3ap_MME_handle_sctp_init_msg_multi_cnf(
instance_t instance_id,
sctp_init_msg_multi_cnf_t *m) {
m3ap_MME_instance_t *instance;
int index;
DevAssert(m != NULL);
instance = m3ap_MME_get_instance(instance_id);
DevAssert(instance != NULL);
instance->multi_sd = m->multi_sd;
/* Exit if CNF message reports failure.
* Failure means multi_sd < 0.
*/
if (instance->multi_sd < 0) {
M3AP_ERROR("Error: be sure to properly configure M2 in your configuration file.\n");
DevAssert(instance->multi_sd >= 0);
}
/* Trying to connect to the provided list of MME ip address */
for (index = 0; index < instance->nb_m3; index++) {
M3AP_INFO("MME[%ld] MME id %u acting as an initiator (client)\n",
instance_id, instance->MME_id);
m3ap_MME_register_MME(instance,
&instance->target_mme_m3_ip_address[index],
&instance->mme_m3_ip_address,
instance->sctp_in_streams,
instance->sctp_out_streams,
instance->mme_port_for_M3C,
instance->multi_sd);
}
}
//static
//void m3ap_MME_handle_handover_req(instance_t instance,
// m3ap_handover_req_t *m3ap_handover_req)
//{
// m3ap_MME_instance_t *instance_p;
// m3ap_MME_data_t *target;
// m3ap_id_manager *id_manager;
// int ue_id;
//
// int target_pci = m3ap_handover_req->target_physCellId;
//
// instance_p = m3ap_MME_get_instance(instance);
// DevAssert(instance_p != NULL);
//
// target = m3ap_is_MME_pci_in_list(target_pci);
// DevAssert(target != NULL);
//
// /* allocate m3ap ID */
// id_manager = &instance_p->id_manager;
// ue_id = m3ap_allocate_new_id(id_manager);
// if (ue_id == -1) {
// M3AP_ERROR("could not allocate a new M3AP UE ID\n");
// /* TODO: cancel handover: send (to be defined) message to RRC */
// exit(1);
// }
// /* id_source is ue_id, id_target is unknown yet */
// m3ap_set_ids(id_manager, ue_id, m3ap_handover_req->rnti, ue_id, -1);
// m3ap_id_set_state(id_manager, ue_id, M2ID_STATE_SOURCE_PREPARE);
// m3ap_set_reloc_prep_timer(id_manager, ue_id,
// m3ap_timer_get_tti(&instance_p->timers));
// m3ap_id_set_target(id_manager, ue_id, target);
//
// m3ap_MME_generate_m3_handover_request(instance_p, target, m3ap_handover_req, ue_id);
//}
//static
//void m3ap_MME_handle_handover_req_ack(instance_t instance,
// m3ap_handover_req_ack_t *m3ap_handover_req_ack)
//{
// /* TODO: remove this hack (the goal is to find the correct
// * eNodeB structure for the other end) - we need a proper way for RRC
// * and M3AP to identify eNodeBs
// * RRC knows about mod_id and M3AP knows about MME_id (MME_ID in
// * the configuration file)
// * as far as I understand.. CROUX
// */
// m3ap_MME_instance_t *instance_p;
// m3ap_MME_data_t *target;
// int source_assoc_id = m3ap_handover_req_ack->source_assoc_id;
// int ue_id;
// int id_source;
// int id_target;
//
// instance_p = m3ap_MME_get_instance(instance);
// DevAssert(instance_p != NULL);
//
// target = m3ap_get_MME(NULL, source_assoc_id, 0);
// DevAssert(target != NULL);
//
// /* rnti is a new information, save it */
// ue_id = m3ap_handover_req_ack->m3_id_target;
// id_source = m3ap_id_get_id_source(&instance_p->id_manager, ue_id);
// id_target = ue_id;
// m3ap_set_ids(&instance_p->id_manager, ue_id, m3ap_handover_req_ack->rnti, id_source, id_target);
//
// m3ap_MME_generate_m3_handover_request_ack(instance_p, target, m3ap_handover_req_ack);
//}
//
//static
//void m3ap_MME_ue_context_release(instance_t instance,
// m3ap_ue_context_release_t *m3ap_ue_context_release)
//{
// m3ap_MME_instance_t *instance_p;
// m3ap_MME_data_t *target;
// int source_assoc_id = m3ap_ue_context_release->source_assoc_id;
// int ue_id;
// instance_p = m3ap_MME_get_instance(instance);
// DevAssert(instance_p != NULL);
//
// target = m3ap_get_MME(NULL, source_assoc_id, 0);
// DevAssert(target != NULL);
//
// m3ap_MME_generate_m3_ue_context_release(instance_p, target, m3ap_ue_context_release);
//
// /* free the M3AP UE ID */
// ue_id = m3ap_find_id_from_rnti(&instance_p->id_manager, m3ap_ue_context_release->rnti);
// if (ue_id == -1) {
// M3AP_ERROR("could not find UE %x\n", m3ap_ue_context_release->rnti);
// exit(1);
// }
// m3ap_release_id(&instance_p->id_manager, ue_id);
//}
void MME_task_send_sctp_init_req(instance_t enb_id, m3ap_mme_sctp_req_t * m3ap_mme_sctp_req) {
// 1. get the itti msg, and retrive the enb_id from the message
// 2. use RC.rrc[enb_id] to fill the sctp_init_t with the ip, port
// 3. creat an itti message to init
size_t addr_len = m3ap_mme_sctp_req != NULL ? strlen(m3ap_mme_sctp_req->mme_m3_ip_address.ipv4_address) + 1 : strlen("127.0.0.8") + 1; // the previous code might hardcode, support this
MessageDef *message_p = itti_alloc_new_message_sized(TASK_M3AP_MME, 0, SCTP_INIT_MSG, sizeof(sctp_init_t) + addr_len);
sctp_init_t *init = &SCTP_INIT_MSG(message_p);
char *addr_buf = (char *) (init + 1); // address after ITTI message end, allocated above
init->bind_address = addr_buf;
if (m3ap_mme_sctp_req == NULL) {
LOG_I(M3AP, "M3AP_SCTP_REQ(create socket)\n");
init->port = M3AP_PORT_NUMBER;
init->ppid = M3AP_SCTP_PPID;
memcpy(addr_buf, "127.0.0.8", addr_len);
} else {
LOG_I(M3AP, "M3AP_SCTP_REQ(create socket) for %s %ld\n", m3ap_mme_sctp_req->mme_m3_ip_address.ipv4_address, addr_len);
init->port = m3ap_mme_sctp_req->mme_port_for_M3C;
init->ppid = M3AP_SCTP_PPID;
memcpy(addr_buf, m3ap_mme_sctp_req->mme_m3_ip_address.ipv4_address, addr_len);
}
itti_send_msg_to_task(TASK_SCTP, enb_id, message_p);
}
void *m3ap_MME_task(void *arg) {
MessageDef *received_msg = NULL;
int result;
M3AP_DEBUG("Starting M3AP layer\n");
m3ap_MME_prepare_internal_data();
itti_mark_task_ready(TASK_M3AP_MME);
//MME_task_send_sctp_init_req(0,NULL);
while (1) {
itti_receive_msg(TASK_M3AP_MME, &received_msg);
switch (ITTI_MSG_ID(received_msg)) {
case MESSAGE_TEST:
LOG_W(M3AP,"MME Received MESSAGE_TEST Message\n");
//MessageDef * message_p = itti_alloc_new_message(TASK_M3AP_MME, 0, MESSAGE_TEST);
//itti_send_msg_to_task(TASK_M3AP, 1/*ctxt_pP->module_id*/, message_p);
break;
case TERMINATE_MESSAGE:
M3AP_WARN(" *** Exiting M3AP thread\n");
itti_exit_task();
break;
// case M3AP_SUBFRAME_PROCESS:
// m3ap_check_timers(ITTI_MSG_DESTINATION_INSTANCE(received_msg));
// break;
//
// case M3AP_REGISTER_MME_REQ:
// LOG_W(M3AP,"MME Received M3AP_REGISTER_MME_REQ Message\n");
// m3ap_MME_handle_register_MME(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_REGISTER_MME_REQ(received_msg));
// break;
//
case M3AP_MME_SCTP_REQ:
MME_task_send_sctp_init_req(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
&M3AP_MME_SCTP_REQ(received_msg));
break;
case M3AP_SETUP_RESP:
LOG_I(M3AP,"MME Received M3AP_SETUP_RESP Message\n");
MME_send_M3_SETUP_RESPONSE(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
&M3AP_SETUP_RESP(received_msg));
break;
// break;
//
// case M3AP_SETUP_FAILURE:
// LOG_W(M3AP,"MME Received M3AP_SETUP_FAILURE Message\n");
// MME_send_M2_SETUP_FAILURE(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_SETUP_FAILURE(received_msg));
// break;
//
// case M3AP_MBMS_SCHEDULING_INFORMATION:
// LOG_W(M3AP,"MME Received M3AP_MBMS_SCHEDULING_INFORMATION Message\n");
// MME_send_MBMS_SCHEDULING_INFORMATION(0,
// &M3AP_MBMS_SCHEDULING_INFORMATION(received_msg));
//
case M3AP_MBMS_SESSION_START_REQ:
LOG_I(M3AP,"MME Received M3AP_MBMS_SESSION_START_REQ Message\n");
MME_send_MBMS_SESSION_START_REQUEST(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
&M3AP_MBMS_SESSION_START_REQ(received_msg));
break;
//
case M3AP_MBMS_SESSION_STOP_REQ:
LOG_I(M3AP,"MME Received M3AP_MBMS_SESSION_STOP_REQ Message\n");
MME_send_MBMS_SESSION_STOP_REQUEST(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
&M3AP_MBMS_SESSION_STOP_REQ(received_msg));
break;
//
case M3AP_MBMS_SESSION_UPDATE_REQ:
LOG_I(M3AP,"MME Received M3AP_MBMS_SESSION_UPDATE_REQ Message\n");
// MME_send_MBMS_SESSION_UPDATE_REQUEST(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_MBMS_SESSION_UPDATE_REQ(received_msg));
break;
//
// case M3AP_RESET:
// LOG_W(M3AP,"MME Received M3AP_RESET Message\n");
// MME_send_RESET(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_RESET(received_msg));
// break;
//
// case M3AP_ENB_CONFIGURATION_UPDATE_ACK:
// LOG_W(M3AP,"MME Received M3AP_ENB_CONFIGURATION_UPDATE_ACK Message\n");
// MME_send_ENB_CONFIGURATION_UPDATE_ACKNOWLEDGE(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_ENB_CONFIGURATION_UPDATE_ACK(received_msg));
// break;
//
// case M3AP_ENB_CONFIGURATION_UPDATE_FAILURE:
// LOG_W(M3AP,"MME Received M3AP_ENB_CONFIGURATION_UPDATE_FAILURE Message\n");
// MME_send_ENB_CONFIGURATION_UPDATE_FAILURE(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_ENB_CONFIGURATION_UPDATE_FAILURE(received_msg))// break;
//
//
// case M3AP_MME_CONFIGURATION_UPDATE:
// LOG_W(M3AP,"MME Received M3AP_MME_CONFIGURATION_UPDATE Message\n");
// MME_send_MME_CONFIGURATION_UPDATE(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_MME_CONFIGURATION_UPDATE(received_msg));
// break;
//
// case M3AP_HANDOVER_REQ:
// m3ap_MME_handle_handover_req(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_HANDOVER_REQ(received_msg));
// break;
//
// case M3AP_HANDOVER_REQ_ACK:
// m3ap_MME_handle_handover_req_ack(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_HANDOVER_REQ_ACK(received_msg));
// break;
//
// case M3AP_UE_CONTEXT_RELEASE:
// m3ap_MME_ue_context_release(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
// &M3AP_UE_CONTEXT_RELEASE(received_msg));
// break;
//
case SCTP_INIT_MSG_MULTI_CNF:
LOG_E(M3AP,"MME Received SCTP_INIT_MSG_MULTI_CNF Message ... shoudn't be happening ... it doesn't at leaast with M2AP_MCEC\n");
m3ap_MME_handle_sctp_init_msg_multi_cnf(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
&received_msg->ittiMsg.sctp_init_msg_multi_cnf);
break;
case SCTP_NEW_ASSOCIATION_RESP:
LOG_D(M3AP,"MME Received SCTP_NEW_ASSOCIATION_RESP Message\n");
m3ap_MME_handle_sctp_association_resp(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
&received_msg->ittiMsg.sctp_new_association_resp);
break;
case SCTP_NEW_ASSOCIATION_IND:
LOG_D(M3AP,"MME Received SCTP_NEW_ASSOCIATION Message\n");
m3ap_MME_handle_sctp_association_ind(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
&received_msg->ittiMsg.sctp_new_association_ind);
break;
case SCTP_DATA_IND:
LOG_D(M3AP,"MME Received SCTP_DATA_IND Message\n");
m3ap_MME_handle_sctp_data_ind(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
&received_msg->ittiMsg.sctp_data_ind);
break;
default:
M3AP_ERROR("MME Received unhandled message: %d:%s\n",
ITTI_MSG_ID(received_msg), ITTI_MSG_NAME(received_msg));
break;
}
result = itti_free (ITTI_MSG_ORIGIN_ID(received_msg), received_msg);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
received_msg = NULL;
}
return NULL;
}
#include "common/config/config_userapi.h"
int is_m3ap_MME_enabled(void)
{
static volatile int config_loaded = 0;
static volatile int enabled = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
if (pthread_mutex_lock(&mutex)) goto mutex_error;
if (config_loaded) {
if (pthread_mutex_unlock(&mutex)) goto mutex_error;
return enabled;
}
char *enable_m3 = NULL;
paramdef_t p[] = {
{ "enable_mme_m3", "yes/no", 0, .strptr=&enable_m3, .defstrval="", TYPE_STRING, 0 }
};
/* TODO: do it per module - we check only first MME */
config_get(config_get_if(), p, sizeofArray(p), "MMEs.[0]");
if (enable_m3 != NULL && strcmp(enable_m3, "yes") == 0)
enabled = 1;
config_loaded = 1;
if (pthread_mutex_unlock(&mutex)) goto mutex_error;
return enabled;
mutex_error:
LOG_E(M3AP, "mutex error\n");
exit(1);
}
Reference in New Issue View Git Blame Copy Permalink