config_userapi.c 15.3 KB
Newer Older
1 2 3 4 5
/*
 * 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
6
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
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
 * 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 common/config/config_userapi.c
 * \brief configuration module, api implementation to access configuration parameters
 * \author Francois TABURET
 * \date 2017
 * \version 0.1
 * \company NOKIA BellLabs France
 * \email: francois.taburet@nokia-bell-labs.com
 * \note
 * \warning
 */
32 33 34

#define _GNU_SOURCE

35 36 37 38 39 40
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <dlfcn.h>
41
#include <arpa/inet.h>
42
#include <platform_types.h>
43
#include "config_userapi.h"
44
#include "../utils/LOG/log.h"
45

46 47
configmodule_interface_t *config_get_if(void) {
  if (cfgptr == NULL) {
48
    CONFIG_PRINTF_ERROR("[CONFIG] %s %d config module not initialized\n",__FILE__,__LINE__);
49 50 51
  }

  return cfgptr;
52 53
}

54 55 56 57 58 59 60 61 62 63 64 65 66
char *config_check_valptr(paramdef_t *cfgoptions, char **ptr, int length) {
  if (ptr == NULL ) {
    ptr = malloc(sizeof(char *));

    if (ptr != NULL) {
      *ptr=NULL;
      cfgoptions->strptr=ptr;

      if ( (cfgoptions->paramflags & PARAMFLAG_NOFREE) == 0) {
        config_get_if()->ptrs[config_get_if()->numptrs] = (char *)ptr;
        config_get_if()->numptrs++;
      }
    } else {
67 68
      CONFIG_PRINTF_ERROR("[CONFIG] %s %d option %s, cannot allocate pointer: %s \n",
                          __FILE__, __LINE__, cfgoptions->optname, strerror(errno));
69 70 71 72 73 74 75 76 77
    }
  }

  printf_ptrs("[CONFIG] %s ptr: 0x%08lx requested size: %i\n",cfgoptions->optname,(uintptr_t)(ptr),length);

  if(cfgoptions->numelt > 0 && PARAM_ISSCALAR(cfgoptions)  ) { /* already allocated */
    if (*ptr != NULL) {
      return *ptr;
    } else {
78 79
      CONFIG_PRINTF_ERROR("[CONFIG] %s %d option %s, definition error: value pointer is NULL, declared as %i bytes allocated\n",
                          __FILE__, __LINE__,cfgoptions->optname, cfgoptions->numelt);
80 81 82 83
    }
  }

  if (*ptr == NULL) {
laurent's avatar
laurent committed
84
    *ptr = malloc(length>40?length:40); // LTS: dummy fix, waiting Francois full fix in 4G branch
85 86 87 88 89 90 91 92 93

    if ( *ptr != NULL) {
      memset(*ptr,0,length);

      if ( (cfgoptions->paramflags & PARAMFLAG_NOFREE) == 0) {
        config_get_if()->ptrs[config_get_if()->numptrs] = *ptr;
        config_get_if()->numptrs++;
      }
    } else {
94
      CONFIG_PRINTF_ERROR("[CONFIG] %s %d malloc error\n",__FILE__, __LINE__);
95 96 97 98
    }
  }

  return *ptr;
99 100
}

101 102 103
void config_assign_int(paramdef_t *cfgoptions, char *fullname, int val) {
  int tmpval=val;

104
  if ( ((cfgoptions->paramflags &PARAMFLAG_BOOL) != 0) && tmpval >0) {
105
    tmpval =1;
106
  }
107

108
  switch (cfgoptions->type) {
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 142 143 144 145 146
    case TYPE_UINT8:
      *(cfgoptions->u8ptr) = (uint8_t)tmpval;
      printf_params("[CONFIG] %s: %u\n", fullname, (uint8_t)tmpval);
      break;

    case TYPE_INT8:
      *(cfgoptions->i8ptr) = (int8_t)tmpval;
      printf_params("[CONFIG] %s: %i\n", fullname, (int8_t)tmpval);
      break;

    case TYPE_UINT16:
      *(cfgoptions->u16ptr) = (uint16_t)tmpval;
      printf_params("[CONFIG] %s: %hu\n", fullname, (uint16_t)tmpval);
      break;

    case TYPE_INT16:
      *(cfgoptions->i16ptr) = (int16_t)tmpval;
      printf_params("[CONFIG] %s: %hi\n", fullname, (int16_t)tmpval);
      break;

    case TYPE_UINT32:
      *(cfgoptions->uptr) = (uint32_t)tmpval;
      printf_params("[CONFIG] %s: %u\n", fullname, (uint32_t)tmpval);
      break;

    case TYPE_MASK:
      *(cfgoptions->uptr) = *(cfgoptions->uptr) | (uint32_t)tmpval;
      printf_params("[CONFIG] %s: 0x%08x\n", fullname, (uint32_t)tmpval);
      break;

    case TYPE_INT32:
      *(cfgoptions->iptr) = (int32_t)tmpval;
      printf_params("[CONFIG] %s: %i\n", fullname, (int32_t)tmpval);
      break;

    default:
      fprintf (stderr,"[CONFIG] %s %i type %i non integer parameter %s not assigned\n",__FILE__, __LINE__,cfgoptions->type,fullname);
      break;
147 148
  }
}
149
void config_assign_processedint(paramdef_t *cfgoption, int val) {
150 151 152 153 154
  cfgoption->processedvalue = malloc(sizeof(int));

  if (  cfgoption->processedvalue != NULL) {
    *(cfgoption->processedvalue) = val;
  } else {
155
    CONFIG_PRINTF_ERROR("[CONFIG] %s %d malloc error\n",__FILE__, __LINE__);
156
  }
157
}
158

159
int config_get_processedint(paramdef_t *cfgoption) {
160 161 162 163 164 165 166 167 168 169 170 171 172
  int ret;

  if (  cfgoption->processedvalue != NULL) {
    ret=*(cfgoption->processedvalue);
    free( cfgoption->processedvalue);
    cfgoption->processedvalue=NULL;
    printf_params("[CONFIG] %s:  set from %s to %i\n",cfgoption->optname, *(cfgoption->strptr), ret);
  } else {
    fprintf (stderr,"[CONFIG] %s %d %s has no processed integer availablle\n",__FILE__, __LINE__, cfgoption->optname);
    ret=0;
  }

  return ret;
173
}
174
void config_printhelp(paramdef_t *params,int numparams, char *prefix) {
175
  printf("\n-----Help for section %-26s: %03i entries------\n",(prefix==NULL)?"(root section)":prefix,numparams);
176

177
  for (int i=0 ; i<numparams ; i++) {
178 179 180
    printf("    %s%s: %s",
           (strlen(params[i].optname) <= 1) ? "-" : "--",
           params[i].optname,
181
           (params[i].helpstr != NULL)?params[i].helpstr:"Help string not specified\n");
182 183 184
  }   /* for on params entries */

  printf("--------------------------------------------------------------------\n\n");
185 186
}

187
int config_execcheck(paramdef_t *params, int numparams, char *prefix) {
188 189 190 191 192 193 194 195 196 197 198 199 200
  int st=0;

  for (int i=0 ; i<numparams ; i++) {
    if ( params[i].chkPptr == NULL) {
      continue;
    }

    if (params[i].chkPptr->s4.f4 != NULL) {
      st += params[i].chkPptr->s4.f4(&(params[i]));
    }
  }

  if (st != 0) {
201
    CONFIG_PRINTF_ERROR("[CONFIG] config_execcheck: section %s %i parameters with wrong value\n", prefix, -st);
202 203 204
  }

  return st;
205 206
}

yilmazt's avatar
yilmazt committed
207
int config_paramidx_fromname(paramdef_t *params, int numparams, char *name) {
208 209 210 211 212 213 214 215 216
  for (int i=0; i<numparams ; i++) {
    if (strcmp(name,params[i].optname) == 0)
      return i;
  }

  fprintf(stderr,"[CONFIG]config_paramidx_fromname , %s is not a valid parameter name\n",name);
  return -1;
}

217
int config_get(paramdef_t *params, int numparams, char *prefix) {
218
  int ret= -1;
219

220
  if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
221
    fprintf(stderr,"[CONFIG] config_get, section %s skipped, config module not properly initialized\n",prefix);
222
    return ret;
223
  }
224

225
  configmodule_interface_t *cfgif = config_get_if();
226

227
  if (cfgif != NULL) {
228
    ret = config_get_if()->get(params, numparams, prefix);
229

230
    if (ret >= 0) {
231 232
      config_process_cmdline(params, numparams, prefix);
      config_execcheck(params, numparams, prefix);
233
    }
234

235
    return ret;
236
  }
237

238
  return ret;
239
}
240

241
int config_getlist(paramlist_def_t *ParamList, paramdef_t *params, int numparams, char *prefix) {
242 243 244 245
  if (CONFIG_ISFLAGSET(CONFIG_ABORT)) {
    fprintf(stderr,"[CONFIG] config_get skipped, config module not properly initialized\n");
    return -1;
  }
246

247 248 249 250
  if (!config_get_if())
    return -1;

  const int ret = config_get_if()->getlist(ParamList, params, numparams, prefix);
251

252 253
  if (ret >= 0 && params) {
    char *newprefix;
254

255 256
    if (prefix) {
      int rc = asprintf(&newprefix, "%s.%s", prefix, ParamList->listname);
257

258 259
      if (rc < 0) newprefix = NULL;
    } else {
260
      newprefix = ParamList->listname;
261
    }
262

263
    char cfgpath[MAX_OPTNAME_SIZE*2 + 6]; /* prefix.listname.[listindex] */
264

265 266 267
    for (int i = 0; i < ParamList->numelt; ++i) {
      // TODO config_process_cmdline?
      sprintf(cfgpath, "%s.[%i]", newprefix, i);
268
      config_process_cmdline(ParamList->paramarray[i],numparams,cfgpath);
269 270
      config_execcheck(ParamList->paramarray[i], numparams, cfgpath);
    }
271

272 273 274
    if (prefix)
      free(newprefix);
  }
275

276 277 278
  return ret;
}

279
int config_isparamset(paramdef_t *params,int paramidx) {
280
  if ((params[paramidx].paramflags & PARAMFLAG_PARAMSET) != 0) {
281
    return 1;
282
  } else {
283
    return 0;
284
  }
285
}
286

287
void print_intvalueerror(paramdef_t *param, char *fname, int *okval, int numokval) {
288 289 290 291 292 293 294 295
  fprintf(stderr,"[CONFIG] %s: %s: %i invalid value, authorized values:\n       ",
          fname,param->optname, (int)*(param->uptr));

  for ( int i=0; i<numokval ; i++) {
    fprintf(stderr, " %i",okval[i]);
  }

  fprintf(stderr, " \n");
296
}
297 298 299 300

int config_check_intval(paramdef_t *param) {
  if ( param == NULL ) {
    fprintf(stderr,"[CONFIG] config_check_intval: NULL param argument\n");
301
    return -1;
302 303 304 305 306 307 308 309 310 311
  }

  for ( int i=0; i<param->chkPptr->s1.num_okintval ; i++) {
    if( *(param->uptr) == param->chkPptr->s1.okintval[i] ) {
      return 0;
    }
  }

  print_intvalueerror(param,"config_check_intval", param->chkPptr->s1.okintval,param->chkPptr->s1.num_okintval);
  return -1;
312 313
}

314 315 316 317 318 319 320 321 322 323 324
int config_check_modify_integer(paramdef_t *param) {
  for (int i=0; i < param->chkPptr->s1a.num_okintval ; i++) {
    if (*(param->uptr) == param->chkPptr->s1a.okintval[i] ) {
      printf_params("[CONFIG] %s:  read value %i, set to %i\n",param->optname,*(param->uptr),param->chkPptr->s1a.setintval [i]);
      *(param->uptr) = param->chkPptr->s1a.setintval [i];
      return 0;
    }
  }

  print_intvalueerror(param,"config_check_modify_integer", param->chkPptr->s1a.okintval,param->chkPptr->s1a.num_okintval);
  return -1;
325 326
}

327 328 329 330 331 332 333 334
int config_check_intrange(paramdef_t *param) {
  if( *(param->iptr) >= param->chkPptr->s2.okintrange[0]  && *(param->iptr) <= param->chkPptr->s2.okintrange[1]  ) {
    return 0;
  }

  fprintf(stderr,"[CONFIG] config_check_intrange: %s: %i invalid value, authorized range: %i %i\n",
          param->optname, (int)*(param->uptr), param->chkPptr->s2.okintrange[0], param->chkPptr->s2.okintrange[1]);
  return -1;
335 336 337
}

void print_strvalueerror(paramdef_t *param, char *fname, char **okval, int numokval) {
338 339 340 341 342 343 344 345
  fprintf(stderr,"[CONFIG] %s: %s: %s invalid value, authorized values:\n       ",
          fname,param->optname, *(param->strptr));

  for ( int i=0; i<numokval ; i++) {
    fprintf(stderr, " %s",okval[i]);
  }

  fprintf(stderr, " \n");
346
}
347 348 349 350

int config_check_strval(paramdef_t *param) {
  if ( param == NULL ) {
    fprintf(stderr,"[CONFIG] config_check_strval: NULL param argument\n");
351
    return -1;
352
  }
353

354 355 356 357 358
  for ( int i=0; i<param->chkPptr->s3.num_okstrval ; i++) {
    if( strcasecmp(*(param->strptr),param->chkPptr->s3.okstrval[i] ) == 0) {
      return 0;
    }
  }
359

360 361 362
  print_strvalueerror(param, "config_check_strval", param->chkPptr->s3.okstrval, param->chkPptr->s3.num_okstrval);
  return -1;
}
363

364 365 366 367 368 369 370
int config_checkstr_assign_integer(paramdef_t *param) {
  for (int i=0; i < param->chkPptr->s3a.num_okstrval ; i++) {
    if (strcasecmp(*(param->strptr),param->chkPptr->s3a.okstrval[i]  ) == 0) {
      config_assign_processedint(param, param->chkPptr->s3a.setintval[i]);
      return 0;
    }
  }
371

372 373
  print_strvalueerror(param, "config_check_strval", param->chkPptr->s3a.okstrval, param->chkPptr->s3a.num_okstrval);
  return -1;
374
}
375

376 377 378 379 380 381
void config_set_checkfunctions(paramdef_t *params, checkedparam_t *checkfunctions, int numparams) {
  for (int i=0; i< numparams ; i++ ) {
    params[i].chkPptr = &(checkfunctions[i]);
  }
}

382
int config_setdefault_string(paramdef_t *cfgoptions, char *prefix) {
383
  int status = 0;
384

385
  if( cfgoptions->defstrval != NULL) {
386 387 388 389 390 391 392
    status=1;

    if (cfgoptions->numelt == 0 ) {
      config_check_valptr(cfgoptions, cfgoptions->strptr, strlen(cfgoptions->defstrval)+1);
      sprintf(*(cfgoptions->strptr), "%s",cfgoptions->defstrval);
      printf_params("[CONFIG] %s.%s set to default value \"%s\"\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname, *(cfgoptions->strptr));
    } else {
393 394
      sprintf((char *)(cfgoptions->strptr), "%s",cfgoptions->defstrval);
      printf_params("[CONFIG] %s.%s set to default value \"%s\"\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname, (char *)(cfgoptions->strptr));
395
    }
396
  }
397

398 399 400
  return status;
}

401
int config_setdefault_stringlist(paramdef_t *cfgoptions, char *prefix) {
402
  int status = 0;
403

404
  if( cfgoptions->defstrlistval != NULL) {
405 406 407 408 409
    cfgoptions->strlistptr=cfgoptions->defstrlistval;
    status=1;

    for(int j=0; j<cfgoptions->numelt; j++)
      printf_params("[CONFIG] %s.%s[%i] set to default value %s\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname,j, cfgoptions->strlistptr[j]);
410
  }
411

412 413 414
  return status;
}

415
int config_setdefault_int(paramdef_t *cfgoptions, char *prefix) {
416 417
  int status = 0;
  config_check_valptr(cfgoptions, (char **)(&(cfgoptions->iptr)),sizeof(int32_t));
418

419
  if( ((cfgoptions->paramflags & PARAMFLAG_MANDATORY) == 0)) {
420 421 422
    config_assign_int(cfgoptions,cfgoptions->optname,cfgoptions->defintval);
    status=1;
    printf_params("[CONFIG] %s.%s set to default value\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname);
423
  }
424

425
  return status;
426
}
427

428
int config_setdefault_int64(paramdef_t *cfgoptions, char *prefix) {
429 430
  int status = 0;
  config_check_valptr(cfgoptions, (char **)&(cfgoptions->i64ptr),sizeof(long long));
431

432
  if( ((cfgoptions->paramflags & PARAMFLAG_MANDATORY) == 0)) {
433 434 435
    *(cfgoptions->u64ptr)=cfgoptions->defuintval;
    status=1;
    printf_params("[CONFIG] %s.%s set to default value %llu\n", ((prefix == NULL) ? "" : prefix), cfgoptions->optname, (long long unsigned)(*(cfgoptions->u64ptr)));
436
  }
437

438 439 440
  return status;
}

441 442 443
int config_setdefault_intlist(paramdef_t *cfgoptions, char *prefix) {
  int status = 0;

444
  if( cfgoptions->defintarrayval != NULL) {
445
    config_check_valptr(cfgoptions,(char **)&(cfgoptions->iptr), sizeof(int32_t *));
446 447
    cfgoptions->iptr=cfgoptions->defintarrayval;
    status=1;
448

449
    for (int j=0; j<cfgoptions->numelt ; j++) {
450
      printf_params("[CONFIG] %s[%i] set to default value %i\n",cfgoptions->optname,j,(int)cfgoptions->iptr[j]);
451 452
    }
  }
453

454 455 456
  return status;
}

457
int config_setdefault_double(paramdef_t *cfgoptions, char *prefix) {
458 459
  int status = 0;
  config_check_valptr(cfgoptions, (char **)&(cfgoptions->dblptr),sizeof(double));
460

461
  if( ((cfgoptions->paramflags & PARAMFLAG_MANDATORY) == 0)) {
462
    *(cfgoptions->dblptr)=cfgoptions->defdblval;
463
    status=1;
464
    printf_params("[CONFIG] %s set to default value %lf\n",cfgoptions->optname, *(cfgoptions->dblptr));
465
  }
466

467
  return status;
468
}
469

470
int config_assign_ipv4addr(paramdef_t *cfgoptions, char *ipv4addr) {
471
  config_check_valptr(cfgoptions,(char **)&(cfgoptions->uptr), sizeof(int));
472
  int rst=inet_pton(AF_INET, ipv4addr,cfgoptions->uptr );
473

474
  if (rst == 1 && *(cfgoptions->uptr) > 0) {
475 476
    printf_params("[CONFIG] %s: %s\n",cfgoptions->optname, ipv4addr);
    return 1;
477
  } else {
478 479 480 481 482 483 484 485
    if ( strncmp(ipv4addr,ANY_IPV4ADDR_STRING,sizeof(ANY_IPV4ADDR_STRING)) == 0) {
      printf_params("[CONFIG] %s:%s (INADDR_ANY) \n",cfgoptions->optname,ipv4addr);
      *cfgoptions->uptr=INADDR_ANY;
      return 1;
    } else {
      fprintf(stderr,"[CONFIG] %s not valid for %s \n", ipv4addr, cfgoptions->optname);
      return -1;
    }
486
  }
487

488 489 490 491
  return 0;
}


492
int config_setdefault_ipv4addr(paramdef_t *cfgoptions,  char *prefix) {
493
  int status = 0;
494

495
  if (cfgoptions->defstrval != NULL) {
496
    status = config_assign_ipv4addr(cfgoptions, cfgoptions->defstrval);
497
  }
498

499
  return status;
500
}