enb_config.c 28.3 KB
Newer Older
1
/*******************************************************************************
gauthier's avatar
gauthier committed
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
Eurecom OpenAirInterface 2
Copyright(c) 1999 - 2014 Eurecom

This program is free software; you can redistribute it and/or modify it
under the terms and conditions of the GNU General Public License,
version 2, as published by the Free Software Foundation.

This program is distributed in the hope it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

The full GNU General Public License is included in this distribution in
the file called "COPYING".

Contact Information
Openair Admin: openair_admin@eurecom.fr
Openair Tech : openair_tech@eurecom.fr
Forums       : http://forums.eurecom.fsr/openairinterface
Address      : EURECOM,
               Campus SophiaTech,
               450 Route des Chappes,
               CS 50193
               06904 Biot Sophia Antipolis cedex,
               FRANCE
*******************************************************************************/
/*
                                enb_config.c
                             -------------------
  AUTHOR  : Lionel GAUTHIER, Laurent Winckel
  COMPANY : EURECOM
  EMAIL   : Lionel.Gauthier@eurecom.fr
*/
39 40 41 42

#include <string.h>
#include <libconfig.h>

43
#include "log.h"
44 45
#include "assertions.h"
#include "enb_config.h"
winckel's avatar
winckel committed
46 47 48 49
#if defined(OAI_EMU)
# include "OCG.h"
# include "OCG_extern.h"
#endif
50 51 52 53 54 55 56 57 58 59
#if defined(ENABLE_ITTI)
# include "intertask_interface.h"
# if defined(ENABLE_USE_MME)
#   include "s1ap_eNB.h"
#   include "sctp_eNB_task.h"
# endif
#endif

#include "LAYER2/MAC/extern.h"

60 61 62 63 64 65 66 67 68 69 70 71 72 73
#define ENB_CONFIG_STRING_ACTIVE_ENBS                   "Active_eNBs"

#define ENB_CONFIG_STRING_ENB_LIST                      "eNBs"
#define ENB_CONFIG_STRING_ENB_ID                        "eNB_ID"
#define ENB_CONFIG_STRING_CELL_TYPE                     "cell_type"
#define ENB_CONFIG_STRING_ENB_NAME                      "eNB_name"

#define ENB_CONFIG_STRING_TRACKING_AREA_CODE            "tracking_area_code"
#define ENB_CONFIG_STRING_MOBILE_COUNTRY_CODE           "mobile_country_code"
#define ENB_CONFIG_STRING_MOBILE_NETWORK_CODE           "mobile_network_code"

#define ENB_CONFIG_STRING_DEFAULT_PAGING_DRX            "default_paging_drx"

#define ENB_CONFIG_STRING_FRAME_TYPE                    "frame_type"
74 75
#define ENB_CONFIG_STRING_TDD_CONFIG                    "tdd_config"
#define ENB_CONFIG_STRING_TDD_CONFIG_S                  "tdd_config_s"
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
#define ENB_CONFIG_STRING_PREFIX_TYPE                   "prefix_type"
#define ENB_CONFIG_STRING_EUTRA_BAND                    "eutra_band"
#define ENB_CONFIG_STRING_DOWNLINK_FREQUENCY            "downlink_frequency"
#define ENB_CONFIG_STRING_UPLINK_FREQUENCY_OFFSET       "uplink_frequency_offset"

#define ENB_CONFIG_STRING_MME_IP_ADDRESS                "mme_ip_address"
#define ENB_CONFIG_STRING_MME_IPV4_ADDRESS              "ipv4"
#define ENB_CONFIG_STRING_MME_IPV6_ADDRESS              "ipv6"
#define ENB_CONFIG_STRING_MME_IP_ADDRESS_ACTIVE         "active"
#define ENB_CONFIG_STRING_MME_IP_ADDRESS_PREFERENCE     "preference"

#define ENB_CONFIG_STRING_NETWORK_INTERFACES_CONFIG     "NETWORK_INTERFACES"
#define ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1_MME "ENB_INTERFACE_NAME_FOR_S1_MME"
#define ENB_CONFIG_STRING_ENB_IPV4_ADDRESS_FOR_S1_MME   "ENB_IPV4_ADDRESS_FOR_S1_MME"
#define ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1U    "ENB_INTERFACE_NAME_FOR_S1U"
#define ENB_CONFIG_STRING_ENB_IPV4_ADDR_FOR_S1U         "ENB_IPV4_ADDRESS_FOR_S1U"

gauthier's avatar
gauthier committed
93 94 95 96 97 98 99

#define ENB_CONFIG_STRING_ASN1_VERBOSITY                      "Asn1_verbosity"
#define ENB_CONFIG_STRING_ASN1_VERBOSITY_NONE                 "none"
#define ENB_CONFIG_STRING_ASN1_VERBOSITY_ANNOYING             "annoying"
#define ENB_CONFIG_STRING_ASN1_VERBOSITY_INFO                 "info"


100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
#define KHz (1000UL)
#define MHz (1000 * KHz)

typedef struct eutra_band_s
{
    int16_t             band;
    uint32_t            ul_min;
    uint32_t            ul_max;
    uint32_t            dl_min;
    uint32_t            dl_max;
    lte_frame_type_t    frame_type;
} eutra_band_t;

static const eutra_band_t eutra_bands[] =
{
    { 1, 1920    * MHz, 1980    * MHz, 2110    * MHz, 2170    * MHz, FDD},
    { 2, 1850    * MHz, 1910    * MHz, 1930    * MHz, 1990    * MHz, FDD},
    { 3, 1710    * MHz, 1785    * MHz, 1805    * MHz, 1880    * MHz, FDD},
    { 4, 1710    * MHz, 1755    * MHz, 2110    * MHz, 2155    * MHz, FDD},
    { 5,  824    * MHz,  849    * MHz,  869    * MHz,  894    * MHz, FDD},
    { 6,  830    * MHz,  840    * MHz,  875    * MHz,  885    * MHz, FDD},
    { 7, 2500    * MHz, 2570    * MHz, 2620    * MHz, 2690    * MHz, FDD},
    { 8,  880    * MHz,  915    * MHz,  925    * MHz,  960    * MHz, FDD},
    { 9, 1749900 * KHz, 1784900 * KHz, 1844900 * KHz, 1879900 * KHz, FDD},
    {10, 1710    * MHz, 1770    * MHz, 2110    * MHz, 2170    * MHz, FDD},
    {11, 1427900 * KHz, 1452900 * KHz, 1475900 * KHz, 1500900 * KHz, FDD},
    {12,  698    * MHz,  716    * MHz,  728    * MHz,  746    * MHz, FDD},
    {13,  777    * MHz,  787    * MHz,  746    * MHz,  756    * MHz, FDD},
    {14,  788    * MHz,  798    * MHz,  758    * MHz,  768    * MHz, FDD},

    {17,  704    * MHz,  716    * MHz,  734    * MHz,  746    * MHz, FDD},

    {33, 1900    * MHz, 1920    * MHz, 1900    * MHz, 1920    * MHz, TDD},
    {34, 2010    * MHz, 2025    * MHz, 2010    * MHz, 2025    * MHz, TDD},
    {35, 1850    * MHz, 1910    * MHz, 1850    * MHz, 1910    * MHz, TDD},
    {36, 1930    * MHz, 1990    * MHz, 1930    * MHz, 1990    * MHz, TDD},
    {37, 1910    * MHz, 1930    * MHz, 1910    * MHz, 1930    * MHz, TDD},
    {38, 2570    * MHz, 2620    * MHz, 2570    * MHz, 2630    * MHz, TDD},
    {39, 1880    * MHz, 1920    * MHz, 1880    * MHz, 1920    * MHz, TDD},
    {40, 2300    * MHz, 2400    * MHz, 2300    * MHz, 2400    * MHz, TDD},
};

142
static Enb_properties_array_t enb_properties;
143

144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
static void enb_config_display(void) {
    int i;

    printf( "\n----------------------------------------------------------------------\n");
    printf( " ENB CONFIG FILE CONTENT LOADED (TBC):\n");
    printf( "----------------------------------------------------------------------\n");
    for (i = 0; i < enb_properties.number; i++) {
        printf( "ENB CONFIG no %u:\n\n", i);
        printf( "\teNB name: \t%s:\n",enb_properties.properties[i]->eNB_name);
        printf( "\teNB ID:   \t%u:\n",enb_properties.properties[i]->eNB_id);
        printf( "\tCell type:\t%s:\n",enb_properties.properties[i]->cell_type == CELL_MACRO_ENB ? "CELL_MACRO_ENB":"CELL_HOME_ENB");
        printf( "\tTAC:      \t%u:\n",enb_properties.properties[i]->tac);
        printf( "\tMCC:      \t%u:\n",enb_properties.properties[i]->mcc);
        printf( "\tMNC:      \t%u:\n",enb_properties.properties[i]->mnc);
        printf( "\n--------------------------------------------------------\n");
    }
}


163 164 165 166 167 168 169
static int enb_check_band_frequencies(char* lib_config_file_name_pP,
                                      int enb_properties_index,
                                      int16_t band,
                                      uint32_t downlink_frequency,
                                      int32_t uplink_frequency_offset,
                                      lte_frame_type_t frame_type)
{
170
    int errors = 0;
171 172 173 174 175 176 177 178 179 180 181

    if (band > 0)
    {
        int band_index;

        for (band_index = 0; band_index < sizeof (eutra_bands) / sizeof (eutra_bands[0]); band_index++)
        {
            if (band == eutra_bands[band_index].band)
            {
                uint32_t uplink_frequency = downlink_frequency + uplink_frequency_offset;

182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
                AssertError (eutra_bands[band_index].dl_min < downlink_frequency, errors ++,
                             "Failed to parse eNB configuration file %s, enb %d downlink frequency %u too low (%u) for band %d!",
                             lib_config_file_name_pP, enb_properties_index, downlink_frequency, eutra_bands[band_index].dl_min, band);
                AssertError (downlink_frequency < eutra_bands[band_index].dl_max, errors ++,
                             "Failed to parse eNB configuration file %s, enb %d downlink frequency %u too high (%u) for band %d!",
                             lib_config_file_name_pP, enb_properties_index, downlink_frequency, eutra_bands[band_index].dl_max, band);

                AssertError (eutra_bands[band_index].ul_min < uplink_frequency, errors ++,
                             "Failed to parse eNB configuration file %s, enb %d uplink frequency %u too low (%u) for band %d!",
                             lib_config_file_name_pP, enb_properties_index, uplink_frequency, eutra_bands[band_index].ul_min, band);
                AssertError (uplink_frequency < eutra_bands[band_index].ul_max, errors ++,
                             "Failed to parse eNB configuration file %s, enb %d uplink frequency %u too high (%u) for band %d!",
                             lib_config_file_name_pP, enb_properties_index, uplink_frequency, eutra_bands[band_index].ul_max, band);

                AssertError (eutra_bands[band_index].frame_type == frame_type, errors ++,
                             "Failed to parse eNB configuration file %s, enb %d invalid frame type (%d/%d) for band %d!",
                             lib_config_file_name_pP, enb_properties_index, eutra_bands[band_index].frame_type, frame_type, band);
199 200 201
            }
        }
    }
202
    return errors;
203 204
}

gauthier's avatar
gauthier committed
205 206 207 208 209
#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
extern int asn_debug;
extern int asn1_xer_print;
#endif

210
const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP) {
211
  config_t          cfg;
gauthier's avatar
gauthier committed
212 213 214 215 216 217 218
  config_setting_t *setting                       = NULL;
  config_setting_t *subsetting                    = NULL;
  config_setting_t *setting_mme_addresses         = NULL;
  config_setting_t *setting_mme_address           = NULL;
  config_setting_t *setting_enb                   = NULL;
  int               num_enb_properties            = 0;
  int               enb_properties_index          = 0;
219 220 221 222
  int               num_enbs;
  int               num_mme_address;
  int               i;
  int               j;
gauthier's avatar
gauthier committed
223 224 225
  int               parse_errors                  = 0;
  long int          enb_id                        = 0;
  const char*       cell_type                     = NULL;
nikaeinn's avatar
nikaeinn committed
226
  const char*       tac                           = 0;
gauthier's avatar
gauthier committed
227
  const char*       enb_name                      = NULL;
nikaeinn's avatar
nikaeinn committed
228 229
  const char*       mcc                           = 0;
  const char*       mnc                           = 0;
gauthier's avatar
gauthier committed
230
  const char*       default_drx                   = NULL;
231
  const char*       frame_type;
232 233
  long int          tdd_config;
  long int          tdd_config_s;
234
  const char*       prefix_type;
235 236 237
  long int          eutra_band;
  double            downlink_frequency;
  double            uplink_frequency_offset;
gauthier's avatar
gauthier committed
238 239 240 241
  char*             ipv4                          = NULL;
  char*             ipv6                          = NULL;
  char*             active                        = NULL;
  char*             preference                    = NULL;
242
  const char*       active_enb[MAX_ENB];
gauthier's avatar
gauthier committed
243 244 245 246 247 248
  char*             enb_interface_name_for_S1U    = NULL;
  char*             enb_ipv4_address_for_S1U      = NULL;
  char*             enb_interface_name_for_S1_MME = NULL;
  char*             enb_ipv4_address_for_S1_MME   = NULL;
  char             *address                       = NULL;
  char             *cidr                          = NULL;
gauthier's avatar
gauthier committed
249
  char             *astring                       = NULL;
250

251
  memset((char*) (enb_properties.properties), 0 , MAX_ENB * sizeof(Enb_properties_t *));
252
  memset((char*)active_enb,     0 , MAX_ENB * sizeof(char*));
253 254 255

  config_init(&cfg);

winckel's avatar
winckel committed
256 257 258 259 260 261
  if(lib_config_file_name_pP != NULL)
  {
      /* Read the file. If there is an error, report it and exit. */
      if(! config_read_file(&cfg, lib_config_file_name_pP))
      {
          config_destroy(&cfg);
262
          AssertFatal (0, "Failed to parse eNB configuration file %s!\n", lib_config_file_name_pP);
winckel's avatar
winckel committed
263 264 265
      }
  }
  else
266 267
  {
      config_destroy(&cfg);
winckel's avatar
winckel committed
268
      AssertFatal (0, "No eNB configuration file provided!\n");
269 270
  }

gauthier's avatar
gauthier committed
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
#if defined(ENABLE_ITTI) && defined(ENABLE_USE_MME)
  if(  (config_lookup_string( &cfg, ENB_CONFIG_STRING_ASN1_VERBOSITY, (const char **)&astring) )) {
      if (strcasecmp(astring , ENB_CONFIG_STRING_ASN1_VERBOSITY_NONE) == 0) {
          asn_debug      = 1;
          asn1_xer_print = 0;
      } else if (strcasecmp(astring , ENB_CONFIG_STRING_ASN1_VERBOSITY_INFO) == 0) {
          asn_debug      = 1;
          asn1_xer_print = 1;
      } else if (strcasecmp(astring , ENB_CONFIG_STRING_ASN1_VERBOSITY_ANNOYING) == 0) {
          asn_debug      = 1;
          asn1_xer_print = 2;
      } else {
          asn_debug      = 0;
          asn1_xer_print = 0;
      }
  }
#endif
288 289 290 291 292 293 294 295 296 297 298 299
  // Get list of active eNBs, (only these will be configured)
  setting = config_lookup(&cfg, ENB_CONFIG_STRING_ACTIVE_ENBS);
  if(setting != NULL)
  {
      num_enbs = config_setting_length(setting);
      for (i = 0; i < num_enbs; i++) {
          setting_enb   = config_setting_get_elem(setting, i);
          active_enb[i] = config_setting_get_string (setting_enb);
          AssertFatal (active_enb[i] != NULL,
                       "Failed to parse config file %s, %uth attribute %s \n",
                       lib_config_file_name_pP, i, ENB_CONFIG_STRING_ACTIVE_ENBS);
          active_enb[i] = strdup(active_enb[i]);
300
          num_enb_properties += 1;
301 302 303 304 305 306 307 308
      }
  }

  /* Output a list of all eNBs. */
  setting = config_lookup(&cfg, ENB_CONFIG_STRING_ENB_LIST);
  if(setting != NULL)
  {
      enb_properties_index = 0;
309
      parse_errors      = 0;
310 311 312
      num_enbs = config_setting_length(setting);
      for (i = 0; i < num_enbs; i++) {
          setting_enb = config_setting_get_elem(setting, i);
313 314

          if(! config_setting_lookup_int(setting_enb, ENB_CONFIG_STRING_ENB_ID, &enb_id)) {
315 316
              /* Calculate a default eNB ID */
# if defined(ENABLE_USE_MME)
317 318 319 320
              uint32_t hash;

              hash = s1ap_generate_eNB_id ();
              enb_id = i + (hash & 0xFFFF8);
321 322 323
# else
              enb_id = i;
# endif
324 325 326
          }

          if(  !(       config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_CELL_TYPE,           &cell_type)
327
                     && config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_ENB_NAME,            &enb_name)
nikaeinn's avatar
nikaeinn committed
328 329 330
                     && config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_TRACKING_AREA_CODE,  &tac)
                     && config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_MOBILE_COUNTRY_CODE, &mcc)
                     && config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_MOBILE_NETWORK_CODE, &mnc)
331 332 333
                     && config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_DEFAULT_PAGING_DRX,  &default_drx)
                )
            ) {
334
              AssertError (0, parse_errors ++,
winckel's avatar
winckel committed
335
                      "Failed to parse eNB configuration file %s, %u th enb\n",
336 337 338
                      lib_config_file_name_pP, i);
          }
          // search if in active list
339
          for (j=0; j < num_enb_properties; j++) {
340
              if (strcmp(active_enb[j], enb_name) == 0) {
341
                  enb_properties.properties[enb_properties_index] = calloc(1, sizeof(Enb_properties_t));
342

343
                  enb_properties.properties[enb_properties_index]->eNB_id   = enb_id;
344
                  if (strcmp(cell_type, "CELL_MACRO_ENB") == 0) {
345
                      enb_properties.properties[enb_properties_index]->cell_type = CELL_MACRO_ENB;
346
                  } else  if (strcmp(cell_type, "CELL_HOME_ENB") == 0) {
347
                      enb_properties.properties[enb_properties_index]->cell_type = CELL_HOME_ENB;
348
                  } else {
349
                      AssertError (0, parse_errors ++,
350 351
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for cell_type choice: CELL_MACRO_ENB or CELL_HOME_ENB !\n",
                              lib_config_file_name_pP, i, cell_type);
352
                  }
nikaeinn's avatar
nikaeinn committed
353 354 355 356 357
                  enb_properties.properties[enb_properties_index]->eNB_name         = strdup(enb_name);
                  enb_properties.properties[enb_properties_index]->tac              = (uint16_t)atoi(tac);
                  enb_properties.properties[enb_properties_index]->mcc              = (uint16_t)atoi(mcc);
                  enb_properties.properties[enb_properties_index]->mnc              = (uint16_t)atoi(mnc);
                  enb_properties.properties[enb_properties_index]->mnc_digit_length = strlen(mnc);
358 359

                  if (strcmp(default_drx, "PAGING_DRX_32") == 0) {
360
                      enb_properties.properties[enb_properties_index]->default_drx = PAGING_DRX_32;
361
                  } else  if (strcmp(default_drx, "PAGING_DRX_64") == 0) {
362
                      enb_properties.properties[enb_properties_index]->default_drx = PAGING_DRX_64;
363
                  } else  if (strcmp(default_drx, "PAGING_DRX_128") == 0) {
364
                      enb_properties.properties[enb_properties_index]->default_drx = PAGING_DRX_128;
365
                  } else  if (strcmp(default_drx, "PAGING_DRX_256") == 0) {
366
                      enb_properties.properties[enb_properties_index]->default_drx = PAGING_DRX_256;
367
                  } else {
368
                      AssertError (0, parse_errors ++,
369 370 371 372 373 374 375
                              "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for default_drx choice: PAGING_DRX_32..PAGING_DRX_256 !\n",
                              lib_config_file_name_pP, i, default_drx);
                  }

                  // Parse optional physical parameters
                  if(config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_FRAME_TYPE, &frame_type)) {
                      if (strcmp(frame_type, "FDD") == 0) {
376
                          enb_properties.properties[enb_properties_index]->frame_type = FDD;
377
                      } else  if (strcmp(frame_type, "TDD") == 0) {
378
                          enb_properties.properties[enb_properties_index]->frame_type = TDD;
379
                      } else {
380
                          AssertError (0, parse_errors ++,
381 382 383 384
                                  "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for frame_type choice: FDD or TDD !\n",
                                  lib_config_file_name_pP, i, frame_type);
                      }
                  } else {
385
                      enb_properties.properties[enb_properties_index]->frame_type = FDD; // Default frame type
386 387
                  }

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
                  if(config_setting_lookup_int(setting_enb, ENB_CONFIG_STRING_TDD_CONFIG, &tdd_config)) {
                      enb_properties.properties[enb_properties_index]->tdd_config = tdd_config;
                      AssertError (tdd_config <= TDD_Config__subframeAssignment_sa6, parse_errors ++,
                              "Failed to parse eNB configuration file %s, enb %d illegal tdd_config %ld (should be 0-%d)!",
                              lib_config_file_name_pP, i, tdd_config, TDD_Config__subframeAssignment_sa6);
                  } else {
                      enb_properties.properties[enb_properties_index]->tdd_config = 3; // Default TDD sub-frame configuration
                  }

                  if(config_setting_lookup_int(setting_enb, ENB_CONFIG_STRING_TDD_CONFIG_S, &tdd_config_s)) {
                      enb_properties.properties[enb_properties_index]->tdd_config_s = tdd_config_s;
                      AssertError (tdd_config_s <= TDD_Config__specialSubframePatterns_ssp8, parse_errors ++,
                              "Failed to parse eNB configuration file %s, enb %d illegal tdd_config_s %ld (should be 0-%d)!",
                              lib_config_file_name_pP, i, tdd_config_s, TDD_Config__specialSubframePatterns_ssp8);
                  } else {
                      enb_properties.properties[enb_properties_index]->tdd_config_s = 0; // Default TDD S-sub-frame configuration
                  }

406 407
                  if(config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_PREFIX_TYPE, &prefix_type)) {
                      if (strcmp(prefix_type, "NORMAL") == 0) {
408
                          enb_properties.properties[enb_properties_index]->prefix_type = NORMAL;
409
                      } else  if (strcmp(prefix_type, "EXTENDED") == 0) {
410
                          enb_properties.properties[enb_properties_index]->prefix_type = EXTENDED;
411
                      } else {
412
                          AssertError (0, parse_errors ++,
413 414 415 416
                                  "Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for prefix_type choice: NORMAL or EXTENDED !\n",
                                  lib_config_file_name_pP, i, prefix_type);
                      }
                  } else {
417
                      enb_properties.properties[enb_properties_index]->prefix_type = NORMAL; // Default prefix type
418 419
                  }

420 421 422 423 424 425 426
                  if(config_setting_lookup_int(setting_enb, ENB_CONFIG_STRING_EUTRA_BAND, &eutra_band)) {
                      enb_properties.properties[enb_properties_index]->eutra_band = eutra_band;
                  } else {
                      enb_properties.properties[enb_properties_index]->eutra_band = 7; // Default band
                  }

                  if(config_setting_lookup_float(setting_enb, ENB_CONFIG_STRING_DOWNLINK_FREQUENCY, &downlink_frequency)) {
427
                      enb_properties.properties[enb_properties_index]->downlink_frequency = downlink_frequency;
428
                  } else {
429
                      enb_properties.properties[enb_properties_index]->downlink_frequency = 2680000000UL; // Default downlink frequency
430 431
                  }

432
                  if(config_setting_lookup_float(setting_enb, ENB_CONFIG_STRING_UPLINK_FREQUENCY_OFFSET, &uplink_frequency_offset)) {
433
                      enb_properties.properties[enb_properties_index]->uplink_frequency_offset = uplink_frequency_offset;
434
                  } else {
435 436 437 438 439 440
                      // Default uplink frequency offset
                      if (enb_properties.properties[enb_properties_index]->frame_type == FDD) {
                          enb_properties.properties[enb_properties_index]->uplink_frequency_offset = -120000000;
                      } else {
                          enb_properties.properties[enb_properties_index]->uplink_frequency_offset = 0;
                      }
441 442
                  }

443
                  parse_errors += enb_check_band_frequencies(lib_config_file_name_pP,
gauthier's avatar
gauthier committed
444 445 446 447 448
                                             enb_properties_index,
                                             enb_properties.properties[enb_properties_index]->eutra_band,
                                             enb_properties.properties[enb_properties_index]->downlink_frequency,
                                             enb_properties.properties[enb_properties_index]->uplink_frequency_offset,
                                             enb_properties.properties[enb_properties_index]->frame_type);
449

450 451
                  setting_mme_addresses = config_setting_get_member (setting_enb, ENB_CONFIG_STRING_MME_IP_ADDRESS);
                  num_mme_address     = config_setting_length(setting_mme_addresses);
452
                  enb_properties.properties[enb_properties_index]->nb_mme = 0;
453 454 455 456 457 458 459 460 461
                  for (j = 0; j < num_mme_address; j++) {
                      setting_mme_address = config_setting_get_elem(setting_mme_addresses, j);
                      if(  !(
                              config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IPV4_ADDRESS, (const char **)&ipv4)
                              && config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IPV6_ADDRESS, (const char **)&ipv6)
                              && config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IP_ADDRESS_ACTIVE, (const char **)&active)
                              && config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IP_ADDRESS_PREFERENCE, (const char **)&preference)
                            )
                        ) {
462
                          AssertError (0, parse_errors ++,
463
                                  "Failed to parse eNB configuration file %s, %u th enb %u th mme address !\n",
464 465
                                  lib_config_file_name_pP, i, j);
                      }
466
                      enb_properties.properties[enb_properties_index]->nb_mme += 1;
467

468 469
                      enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4_address = strdup(ipv4);
                      enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6_address = strdup(ipv6);
470
                      if (strcmp(active, "yes") == 0) {
471
                          enb_properties.properties[enb_properties_index]->mme_ip_address[j].active = 1;
winckel's avatar
winckel committed
472 473 474
#if defined(ENABLE_USE_MME)
                          EPC_MODE_ENABLED = 1;
#endif
475 476 477
                      } // else { (calloc)

                      if (strcmp(preference, "ipv4") == 0) {
478
                          enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4 = 1;
479
                      } else if (strcmp(preference, "ipv6") == 0) {
480
                          enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6 = 1;
481
                      } else if (strcmp(preference, "no") == 0) {
482 483
                          enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4 = 1;
                          enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6 = 1;
484 485
                      }
                  }
gauthier's avatar
gauthier committed
486 487 488
                  subsetting = config_setting_get_member (setting_enb, ENB_CONFIG_STRING_NETWORK_INTERFACES_CONFIG);
                  if(subsetting != NULL) {
                      if(  (
489
                              config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1_MME,
gauthier's avatar
gauthier committed
490
                                      (const char **)&enb_interface_name_for_S1_MME)
491
                           && config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_IPV4_ADDRESS_FOR_S1_MME,
gauthier's avatar
gauthier committed
492
                                   (const char **)&enb_ipv4_address_for_S1_MME)
493
                           && config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1U,
gauthier's avatar
gauthier committed
494
                                   (const char **)&enb_interface_name_for_S1U)
495
                           && config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_IPV4_ADDR_FOR_S1U,
gauthier's avatar
gauthier committed
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513
                                   (const char **)&enb_ipv4_address_for_S1U)
                         )
                     ){
                          enb_properties.properties[enb_properties_index]->enb_interface_name_for_S1U = strdup(enb_interface_name_for_S1U);
                          cidr = enb_ipv4_address_for_S1U;
                          address = strtok(cidr, "/");
                          if (address) {
                              IPV4_STR_ADDR_TO_INT_NWBO ( address, enb_properties.properties[enb_properties_index]->enb_ipv4_address_for_S1U, "BAD IP ADDRESS FORMAT FOR eNB S1_U !\n" );
                          }

                          enb_properties.properties[enb_properties_index]->enb_interface_name_for_S1_MME = strdup(enb_interface_name_for_S1_MME);
                          cidr = enb_ipv4_address_for_S1_MME;
                          address = strtok(cidr, "/");
                          if (address) {
                              IPV4_STR_ADDR_TO_INT_NWBO ( address, enb_properties.properties[enb_properties_index]->enb_ipv4_address_for_S1_MME, "BAD IP ADDRESS FORMAT FOR eNB S1_MME !\n" );
                          }
                      }
                  }
514 515 516 517 518 519
                  enb_properties_index += 1;
                  break;
              }
          }
      }
  }
520 521
  enb_properties.number = num_enb_properties;

522
  AssertError (enb_properties_index == num_enb_properties, parse_errors ++,
523
          "Failed to parse eNB configuration file %s, mismatch between %u active eNBs and %u corresponding defined eNBs !\n",
524
          lib_config_file_name_pP, num_enb_properties, enb_properties_index);
525

526
  AssertFatal (parse_errors == 0,
527
               "Failed to parse eNB configuration file %s, found %d error%s !\n",
528
               lib_config_file_name_pP, parse_errors, parse_errors > 1 ? "s" : "");
529
  enb_config_display();
530
  return &enb_properties;
gauthier's avatar
gauthier committed
531

532 533 534 535
}

const Enb_properties_array_t *enb_config_get(void) {
    return &enb_properties;
536
}
537