Clean dead code

git-svn-id: http://svn.eurecom.fr/openair4G/trunk@7537 818b1a75-f10b-46b9-bf7c-635c3b92a50f

openair-cn/OAISIM_MME/oaisim_mme.c

@@ -48,7 +48,6 @@
 #include "log.h"
 #include "timer.h"
 #include "sgw_lite_defs.h"
-#include "sgi.h"
 #include "mme_app_extern.h"
 #include "nas_defs.h"
 #include "s11_mme.h"
@@ -74,12 +73,10 @@ int main(int argc, char *argv[])
   CHECK_INIT_RETURN(udp_init(&mme_config));
   CHECK_INIT_RETURN(s11_mme_init(&mme_config));
   CHECK_INIT_RETURN(s1ap_mme_init(&mme_config));
-  //     if (sgi_init(&mme_config) < 0) return -1;
   //     if (gtpv1u_init(&mme_config) < 0) return -1;
   CHECK_INIT_RETURN(mme_app_init(&mme_config));
 
   CHECK_INIT_RETURN(s6a_init(&mme_config));
-  //     if (sgw_lite_init(&mme_config) < 0) return -1;
 
   /* Handle signals here */
   itti_wait_tasks_end();

openair-cn/OAI_EPC/oai_epc.c

@@ -55,7 +55,6 @@
 #include "log.h"
 #include "timer.h"
 #include "sgw_lite_defs.h"
-#include "sgi.h"
 #include "mme_app_extern.h"
 #include "nas_defs.h"
 
@@ -85,9 +84,6 @@ int main(int argc, char *argv[])
   CHECK_INIT_RETURN(mme_app_init(&mme_config));
   CHECK_INIT_RETURN(s6a_init(&mme_config));
   CHECK_INIT_RETURN(sgw_lite_init(mme_config.config_file));
-#if ! defined(ENABLE_USE_GTPU_IN_KERNEL)
-  CHECK_INIT_RETURN(sgi_init(&spgw_config.pgw_config));
-#endif
   /* Handle signals here */
   itti_wait_tasks_end();
 

openair-cn/OAI_SGW/oai_sgw.c

@@ -54,7 +54,6 @@
 #include "s11_sgw.h"
 #include "sgw_lite_defs.h"
 #include "gtpv1u_sgw_defs.h"
-#include "sgi.h"
 
 #include "oai_sgw.h"
 
@@ -70,7 +69,6 @@ int main(int argc, char *argv[])
   CHECK_INIT_RETURN(udp_init(&mme_config));
   CHECK_INIT_RETURN(s11_sgw_init(&mme_config));
   CHECK_INIT_RETURN(gtpv1u_init(&mme_config));
-  CHECK_INIT_RETURN(sgi_init(&pgw_config));
 
   CHECK_INIT_RETURN(sgw_lite_init(mme_config.config_file));
 

openair-cn/S6A/s6a_peer.c

@@ -59,12 +59,6 @@ void s6a_peer_connected_cb(struct peer_info *info, void *arg)
 
     itti_send_msg_to_task(TASK_S1AP, INSTANCE_DEFAULT, message_p);
 
-#if ! defined(ENABLE_USE_GTPU_IN_KERNEL)
-    /* Inform SGI that connection to HSS is established */
-    message_p = itti_alloc_new_message(TASK_S6A, ACTIVATE_MESSAGE);
-
-    itti_send_msg_to_task(TASK_FW_IP, INSTANCE_DEFAULT, message_p);
-#endif
   }
 
   /* For test */

openair-cn/SGW-LITE/sgw_lite_context_manager.h

@@ -119,9 +119,7 @@ typedef struct pgw_eps_bearer_context_information_s {
 
 // A primary key for a EPS Bearer entry  can be a tuple (eps bearer id, imsi)
 typedef struct sgw_eps_bearer_entry_s {
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
   PAA_t                paa;
-#endif
   ebi_t                eps_bearer_id;                         ///< An EPS bearer identity uniquely identifies an EPS bearer for one UE accessing via E-UTRAN
   // TO DO traffic_flow_template_t tft;                   ///< Traffic Flow Template
 

openair-cn/SGW-LITE/sgw_lite_handlers.c

@@ -213,7 +213,6 @@ sgw_lite_handle_create_session_request(
       return -1;
     }
 
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
     {
       Gtpv1uCreateTunnelResp           createTunnelResp;
 
@@ -223,14 +222,6 @@ sgw_lite_handle_create_session_request(
       createTunnelResp.S1u_teid      = sgw_get_new_teid();
       sgw_lite_handle_gtpv1uCreateTunnelResp(&createTunnelResp);
     }
-#else
-    message_p->ittiMsg.gtpv1uCreateTunnelReq.context_teid  = new_endpoint_p->local_teid;
-    message_p->ittiMsg.gtpv1uCreateTunnelReq.eps_bearer_id = session_req_pP->bearer_to_create.eps_bearer_id;
-    SPGW_APP_DEBUG("Tx GTPV1U_CREATE_TUNNEL_REQ -> TASK_GTPV1_U, Context: S-GW S11 teid %u eps bearer id %d (from session req)\n",
-                   message_p->ittiMsg.gtpv1uCreateTunnelReq.context_teid,
-                   message_p->ittiMsg.gtpv1uCreateTunnelReq.eps_bearer_id);
-    return itti_send_msg_to_task(TASK_GTPV1_U, INSTANCE_DEFAULT, message_p);
-#endif
   } else {
     SPGW_APP_WARN("Could not create new transaction for SESSION_CREATE message\n");
     free(new_endpoint_p);
@@ -289,7 +280,6 @@ sgw_lite_handle_sgi_endpoint_created(
       create_session_response_p->ambr.br_dl = 100000000;
       create_session_response_p->ambr.br_ul = 40000000;
 
-#if defined(ENABLE_USE_GTPU_IN_KERNEL)
       {
         sgw_eps_bearer_entry_t*                       eps_bearer_entry_p                 = NULL;
         hash_rc = hashtable_get (new_bearer_ctxt_info_p->sgw_eps_bearer_context_information.pdn_connection.sgw_eps_bearers,
@@ -305,7 +295,6 @@ sgw_lite_handle_sgi_endpoint_created(
                  sizeof(PAA_t));
         }
       }
-#endif
       memcpy(&create_session_response_p->paa,
              &resp_pP->paa,
              sizeof(PAA_t));
@@ -401,7 +390,6 @@ sgw_lite_handle_gtpv1uCreateTunnelResp(
 
     sgw_lite_display_s11_bearer_context_information_mapping();
 
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
     SGICreateEndpointResp  sgi_create_endpoint_resp;
 
     memset(&sgi_create_endpoint_resp, 0, sizeof(SGICreateEndpointResp));
@@ -469,81 +457,6 @@ sgw_lite_handle_gtpv1uCreateTunnelResp(
 
     sgi_create_endpoint_resp.status         = SGI_STATUS_OK;
     sgw_lite_handle_sgi_endpoint_created(&sgi_create_endpoint_resp);
-#else
-    /* SEND IP_FW_CREATE_IP_ENDPOINT_REQUEST to FW_IP task */
-    message_p = itti_alloc_new_message(TASK_SPGW_APP, SGI_CREATE_ENDPOINT_REQUEST);
-
-    if (message_p == NULL) {
-      return -1;
-    }
-
-    sgi_create_endpoint_req_p = &message_p->ittiMsg.sgiCreateEndpointReq;
-    memset(sgi_create_endpoint_req_p, 0, sizeof(SGICreateEndpointReq));
-    // IP forward will forward packets to this teid
-    sgi_create_endpoint_req_p->context_teid  = endpoint_created_pP->context_teid;
-    sgi_create_endpoint_req_p->sgw_S1u_teid  = endpoint_created_pP->S1u_teid;
-    sgi_create_endpoint_req_p->eps_bearer_id = endpoint_created_pP->eps_bearer_id;
-
-    // TO DO NOW
-    sgi_create_endpoint_req_p->paa.pdn_type = new_bearer_ctxt_info_p->sgw_eps_bearer_context_information.saved_message.pdn_type;
-
-    switch (sgi_create_endpoint_req_p->paa.pdn_type) {
-    case IPv4_OR_v6:
-      if (pgw_lite_get_free_ipv4_paa_address(&inaddr) == 0) {
-        IN_ADDR_TO_BUFFER(inaddr, sgi_create_endpoint_req_p->paa.ipv4_address);
-      } else {
-        SPGW_APP_WARN("Failed to allocate IPv4 PAA for PDN type IPv4_OR_v6\n");
-
-        if (pgw_lite_get_free_ipv6_paa_prefix(&in6addr) == 0) {
-          IN6_ADDR_TO_BUFFER(in6addr, sgi_create_endpoint_req_p->paa.ipv6_address);
-        } else {
-          SPGW_APP_ERROR("Failed to allocate IPv6 PAA for PDN type IPv4_OR_v6\n");
-        }
-      }
-
-      break;
-
-    case IPv4:
-      if (pgw_lite_get_free_ipv4_paa_address(&inaddr) == 0) {
-        IN_ADDR_TO_BUFFER(inaddr, sgi_create_endpoint_req_p->paa.ipv4_address);
-      } else {
-        SPGW_APP_ERROR("Failed to allocate IPv4 PAA for PDN type IPv4\n");
-      }
-
-      break;
-
-    case IPv6:
-      if (pgw_lite_get_free_ipv6_paa_prefix(&in6addr) == 0) {
-        IN6_ADDR_TO_BUFFER(in6addr, sgi_create_endpoint_req_p->paa.ipv6_address);
-      } else {
-        SPGW_APP_ERROR("Failed to allocate IPv6 PAA for PDN type IPv6\n");
-      }
-
-      break;
-
-    case IPv4_AND_v6:
-      if (pgw_lite_get_free_ipv4_paa_address(&inaddr) == 0) {
-        IN_ADDR_TO_BUFFER(inaddr, sgi_create_endpoint_req_p->paa.ipv4_address);
-      } else {
-        SPGW_APP_ERROR("Failed to allocate IPv4 PAA for PDN type IPv4_AND_v6\n");
-      }
-
-      if (pgw_lite_get_free_ipv6_paa_prefix(&in6addr) == 0) {
-        IN6_ADDR_TO_BUFFER(in6addr, sgi_create_endpoint_req_p->paa.ipv6_address);
-      } else {
-        SPGW_APP_ERROR("Failed to allocate IPv6 PAA for PDN type IPv4_AND_v6\n");
-      }
-
-      break;
-
-    default:
-      AssertFatal(0,"BAD paa.pdn_type %d", sgi_create_endpoint_req_p->paa.pdn_type);
-      break;
-    }
-
-    // TO DO TFT, QOS
-    return itti_send_msg_to_task(TASK_FW_IP, INSTANCE_DEFAULT, message_p);
-#endif
   } else {
     SPGW_APP_DEBUG("Rx SGW_S1U_ENDPOINT_CREATED, Context: teid %u NOT FOUND\n", endpoint_created_pP->context_teid);
     message_p = itti_alloc_new_message(TASK_SPGW_APP, SGW_CREATE_SESSION_RESPONSE);
@@ -683,11 +596,9 @@ sgw_lite_handle_sgi_endpoint_updated(
   sgw_eps_bearer_entry_t                            *eps_bearer_entry_p     = NULL;
   hashtable_rc_t                                     hash_rc;
   task_id_t                                          to_task;
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
   static uint8_t                                     iptable_uplink_remove_gtpu = FALSE;
   char                                               cmd[256];
   int                                                ret;
-#endif
 
 #if defined(ENABLE_STANDALONE_EPC)
   to_task = TASK_MME_APP;
@@ -749,7 +660,6 @@ sgw_lite_handle_sgi_endpoint_updated(
       modify_response_p->bearer_choice.bearer_contexts_modified.cause         = REQUEST_ACCEPTED;
       modify_response_p->cause                                                = REQUEST_ACCEPTED;
       modify_response_p->trxn                                                 = new_bearer_ctxt_info_p->sgw_eps_bearer_context_information.trxn;
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
       // if default bearer
 #warning "TODO define constant for default eps_bearer id"
 
@@ -819,7 +729,6 @@ sgw_lite_handle_sgi_endpoint_updated(
         SPGW_APP_ERROR("ERROR in setting up downlink TUNNEL\n");
       }
 
-#endif
     }
     MSC_LOG_TX_MESSAGE(
   		MSC_SP_GWAPP_MME,
@@ -928,7 +837,6 @@ sgw_lite_handle_modify_bearer_request(
       FTEID_T_2_IP_ADDRESS_T( (&modify_bearer_pP->bearer_context_to_modify.s1_eNB_fteid) , (&eps_bearer_entry_p->enb_ip_address_for_S1u) );
       eps_bearer_entry_p->enb_teid_for_S1u = modify_bearer_pP->bearer_context_to_modify.s1_eNB_fteid.teid;
 
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
       {
         SGIUpdateEndpointResp sgi_update_end_point_resp;
         sgi_update_end_point_resp.context_teid  = modify_bearer_pP->teid;
@@ -938,29 +846,6 @@ sgw_lite_handle_modify_bearer_request(
         sgi_update_end_point_resp.status        = 0x00;
         sgw_lite_handle_sgi_endpoint_updated(&sgi_update_end_point_resp);
       }
-#else
-      // UPDATE GTPV1U mapping tables with eNB references (teid, addresses)
-      message_p = itti_alloc_new_message(TASK_SPGW_APP, GTPV1U_UPDATE_TUNNEL_REQ);
-
-      if (message_p == NULL) {
-        return -1;
-      }
-
-      gtpv1u_update_tunnel_req_p = &message_p->ittiMsg.gtpv1uUpdateTunnelReq;
-      memset(gtpv1u_update_tunnel_req_p, 0, sizeof(Gtpv1uUpdateTunnelReq));
-      gtpv1u_update_tunnel_req_p->context_teid           = modify_bearer_pP->teid;
-      gtpv1u_update_tunnel_req_p->sgw_S1u_teid           = eps_bearer_entry_p->s_gw_teid_for_S1u_S12_S4_up;     ///< SGW S1U local Tunnel Endpoint Identifier
-      gtpv1u_update_tunnel_req_p->enb_S1u_teid           = eps_bearer_entry_p->enb_teid_for_S1u;                ///< eNB S1U Tunnel Endpoint Identifier
-      gtpv1u_update_tunnel_req_p->enb_ip_address_for_S1u = eps_bearer_entry_p->enb_ip_address_for_S1u;
-      gtpv1u_update_tunnel_req_p->eps_bearer_id          = eps_bearer_entry_p->eps_bearer_id;
-      SPGW_APP_DEBUG("Rx MODIFY_BEARER_REQUEST, gtpv1u_update_tunnel_req_p->context_teid           = %u\n",modify_bearer_pP->teid);
-      SPGW_APP_DEBUG("Rx MODIFY_BEARER_REQUEST, gtpv1u_update_tunnel_req_p->sgw_S1u_teid           = %u\n",gtpv1u_update_tunnel_req_p->sgw_S1u_teid);
-      SPGW_APP_DEBUG("Rx MODIFY_BEARER_REQUEST, gtpv1u_update_tunnel_req_p->enb_S1u_teid           = %u\n",gtpv1u_update_tunnel_req_p->enb_S1u_teid);
-      //SPGW_APP_DEBUG("Rx MODIFY_BEARER_REQUEST, gtpv1u_update_tunnel_req_p->enb_ip_address_for_S1u = %u\n",modify_bearer_pP->enb_ip_address_for_S1u);
-      SPGW_APP_DEBUG("Rx MODIFY_BEARER_REQUEST, gtpv1u_update_tunnel_req_p->eps_bearer_id          = %u\n",gtpv1u_update_tunnel_req_p->eps_bearer_id);
-
-      return itti_send_msg_to_task(TASK_GTPV1_U, INSTANCE_DEFAULT, message_p);
-#endif
     }
   } else {
     message_p = itti_alloc_new_message(TASK_SPGW_APP, SGW_MODIFY_BEARER_RESPONSE);

openair-cn/SGW-LITE/sgw_lite_task.c

@@ -137,7 +137,6 @@ static void *sgw_lite_intertask_interface(void *args_p)
 int sgw_lite_init(char* config_file_name_pP)
 {
   SPGW_APP_DEBUG("Initializing SPGW-APP  task interface\n");
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
   spgw_system("modprobe ip_tables",    SPGW_ABORT_ON_ERROR, __FILE__, __LINE__);
   spgw_system("modprobe x_tables",     SPGW_ABORT_ON_ERROR, __FILE__, __LINE__);
   spgw_system("iptables -P INPUT ACCEPT", SPGW_WARN_ON_ERROR, __FILE__, __LINE__);
@@ -180,7 +179,7 @@ int sgw_lite_init(char* config_file_name_pP)
   spgw_system("sysctl -w net.ipv4.conf.all.route_localnet=1",SPGW_WARN_ON_ERROR, __FILE__, __LINE__);
   spgw_system("sysctl -w net.ipv4.conf.all.rp_filter=0",SPGW_WARN_ON_ERROR, __FILE__, __LINE__);
   spgw_system("sync",                    SPGW_ABORT_ON_ERROR, __FILE__, __LINE__);
-#endif
+
   spgw_config_init(config_file_name_pP, &spgw_config);
   pgw_lite_load_pool_ip_addresses();
 

openair-cn/SGW-LITE/spgw_config.c

@@ -212,9 +212,7 @@ int spgw_config_process(spgw_config_t* config_pP)
   }
 
 
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
   ret += spgw_system("echo 0 > /proc/sys/net/ipv4/conf/all/send_redirects", SPGW_ABORT_ON_ERROR, __FILE__, __LINE__);
-#endif
 
 
   if (snprintf(system_cmd, 256,
@@ -367,26 +365,6 @@ int spgw_config_init(char* lib_config_file_name_pP, spgw_config_t* config_pP)
       }
 
     }
-
-    if(  (
-           config_setting_lookup_string( setting_sgw, SGW_CONFIG_STRING_SGW_DROP_UPLINK_S1U_TRAFFIC,
-                                         (const char **)&sgw_drop_uplink_s1u_traffic)
-           && config_setting_lookup_string( setting_sgw, SGW_CONFIG_STRING_SGW_DROP_DOWNLINK_S1U_TRAFFIC,
-                                            (const char **)&sgw_drop_downlink_s1u_traffic)
-         )
-      ) {
-      if (strcasecmp(sgw_drop_uplink_s1u_traffic, "yes") == 0) {
-        config_pP->sgw_config.sgw_drop_uplink_traffic=1;
-      } else {
-        config_pP->sgw_config.sgw_drop_uplink_traffic=0;
-      }
-
-      if (strcasecmp(sgw_drop_downlink_s1u_traffic, "yes") == 0) {
-        config_pP->sgw_config.sgw_drop_downlink_traffic=1;
-      } else {
-        config_pP->sgw_config.sgw_drop_downlink_traffic=0;
-      }
-    }
   }
 
   setting_pgw = config_lookup(&cfg, PGW_CONFIG_STRING_PGW_CONFIG);
@@ -477,7 +455,7 @@ int spgw_config_init(char* lib_config_file_name_pP, spgw_config_t* config_pP)
               // valid address
               atoken2 = strtok(NULL, PGW_CONFIG_STRING_IPV4_PREFIX_DELIMITER);
               prefix_mask = atoi(atoken2);
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
+
               in_addr_var.s_addr = config_pP->sgw_config.ipv4.sgw_ipv4_address_for_S1u_S12_S4_up;
 
               if (snprintf(system_cmd, 256,
@@ -489,7 +467,7 @@ int spgw_config_init(char* lib_config_file_name_pP, spgw_config_t* config_pP)
               }
 
               if (snprintf(system_cmd, 256,
-                  "iptables -I OUTPUT -t mangle -m mark -s %s/%s ! --mark 0 -j CONNMARK --save-mark",
+                  "iptables -I OUTPUT -t mangle -s %s/%s -m mark  ! --mark 0 -j CONNMARK --save-mark",
                   astring, atoken2) > 0) {
                 spgw_system(system_cmd, SPGW_ABORT_ON_ERROR, __FILE__, __LINE__);
               } else {
@@ -503,7 +481,6 @@ int spgw_config_init(char* lib_config_file_name_pP, spgw_config_t* config_pP)
             	SPGW_APP_ERROR("Route for UEs\n");
               }
 
-#endif
 
               if ((prefix_mask >= 2)&&(prefix_mask < 32)) {
                 memcpy (&addr_start, buf_in_addr, sizeof(struct in_addr));

openair-cn/SGW-LITE/spgw_config.h

@@ -50,8 +50,6 @@
 #define SGW_CONFIG_STRING_SGW_IPV4_ADDRESS_FOR_S5_S8_UP         "SGW_IPV4_ADDRESS_FOR_S5_S8_UP"
 #define SGW_CONFIG_STRING_SGW_INTERFACE_NAME_FOR_S11            "SGW_INTERFACE_NAME_FOR_S11"
 #define SGW_CONFIG_STRING_SGW_IPV4_ADDRESS_FOR_S11              "SGW_IPV4_ADDRESS_FOR_S11"
-#define SGW_CONFIG_STRING_SGW_DROP_UPLINK_S1U_TRAFFIC           "SGW_DROP_UPLINK_S1U_TRAFFIC"
-#define SGW_CONFIG_STRING_SGW_DROP_DOWNLINK_S1U_TRAFFIC         "SGW_DROP_DOWNLINK_S1U_TRAFFIC"
 
 #define PGW_CONFIG_STRING_PGW_CONFIG                            "P-GW"
 #define PGW_CONFIG_STRING_NETWORK_INTERFACES_CONFIG             "NETWORK_INTERFACES"

openair-cn/UDP/udp_primitives_server.c

@@ -336,7 +336,6 @@ static void *udp_intertask_interface(void *args_p)
     itti_receive_msg(TASK_UDP, &received_message_p);
 
     if (received_message_p != NULL) {
-#if !defined(ENABLE_USE_GTPU_IN_KERNEL)
 
       switch (ITTI_MSG_ID(received_message_p)) {
       case UDP_INIT: {
@@ -422,7 +421,6 @@ static void *udp_intertask_interface(void *args_p)
       break;
       }
 
-#endif
 on_error:
       rc = itti_free(ITTI_MSG_ORIGIN_ID(received_message_p), received_message_p);
       AssertFatal(rc == EXIT_SUCCESS, "Failed to free memory (%d)!\n", rc);

openair-cn/UTILS/mme_config.c

@@ -202,9 +202,7 @@ static int config_parse_file(mme_config_t *mme_config_p)
   char             *mme_interface_name_for_S11       = NULL;
   char             *mme_ip_address_for_S11           = NULL;
   char             *sgw_ip_address_for_S11           = NULL;
-#if defined (ENABLE_USE_GTPU_IN_KERNEL)
   char                system_cmd[256];
-#endif
 
   config_init(&cfg);