src/vcl/vcl_cfg.c

   1 /*
   2  * Copyright (c) 2018-2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vcl/vcl_private.h>
  17
  18 /* NOTE: _vppcom_main is only used until the heap is allocated.
  19  *       Do not access it directly -- use vcm which will point to
  20  *       the heap allocated copy after init.
  21  */
  22 vppcom_main_t _vppcom_main = {
  23   .debug = VPPCOM_DEBUG_INIT,
  24   .is_init = 0,
  25   .app_index = ~0,
  26 };
  27
  28 vppcom_main_t *vcm = &_vppcom_main;
  29
  30 void
  31 vppcom_cfg_init (vppcom_cfg_t * vcl_cfg)
  32 {
  33   ASSERT (vcl_cfg);
  34
  35   vcl_cfg->heapsize = (256ULL << 20);
  36   vcl_cfg->max_workers = 16;
  37   vcl_cfg->segment_size = (256 << 20);
  38   vcl_cfg->add_segment_size = (128 << 20);
  39   vcl_cfg->preallocated_fifo_pairs = 8;
  40   vcl_cfg->rx_fifo_size = (1 << 20);
  41   vcl_cfg->tx_fifo_size = (1 << 20);
  42   vcl_cfg->event_queue_size = 2048;
  43   vcl_cfg->app_timeout = 10 * 60.0;
  44   vcl_cfg->session_timeout = 10 * 60.0;
  45   vcl_cfg->event_log_path = "/dev/shm";
  46 }
  47
  48 #define VCFG_DBG(_lvl, _fmt, _args...)                  \
  49 {                                                       \
  50   if (vcm->debug > _lvl)                                \
  51     fprintf (stderr, _fmt "\n", ##_args);               \
  52 }
  53 void
  54 vppcom_cfg_heapsize (char *conf_fname)
  55 {
  56   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
  57   FILE *fp;
  58   char inbuf[4096];
  59   int argc = 1;
  60   char **argv = NULL;
  61   char *arg = NULL;
  62   char *p;
  63   int i;
  64   u8 *sizep;
  65   u32 size;
  66   void *vcl_mem;
  67   void *heap;
  68
  69   fp = fopen (conf_fname, "r");
  70   if (fp == NULL)
  71     {
  72       VCFG_DBG (0, "VCL<%d>: using default heapsize %lu (0x%lx)",
  73                 getpid (), (unsigned long) vcl_cfg->heapsize,
  74                 (unsigned long) vcl_cfg->heapsize);
  75       goto defaulted;
  76     }
  77
  78   argv = calloc (1, sizeof (char *));
  79   if (argv == NULL)
  80     {
  81       VCFG_DBG (0, "VCL<%d>: calloc failed, using default heapsize %lu"
  82                 " (0x%lx)", getpid (), (unsigned long) vcl_cfg->heapsize,
  83                 (unsigned long) vcl_cfg->heapsize);
  84       goto defaulted;
  85     }
  86
  87   while (1)
  88     {
  89       if (fgets (inbuf, 4096, fp) == 0)
  90         break;
  91       p = strtok (inbuf, " \t\n");
  92       while (p != NULL)
  93         {
  94           if (*p == '#')
  95             break;
  96           argc++;
  97           char **tmp = realloc (argv, argc * sizeof (char *));
  98           if (tmp == NULL)
  99             {
 100               VCFG_DBG (0, "VCL<%d>: realloc failed, using default "
 101                         "heapsize %lu (0x%lx)", getpid (),
 102                         (unsigned long) vcl_cfg->heapsize,
 103                         (unsigned long) vcl_cfg->heapsize);
 104               goto defaulted;
 105             }
 106           argv = tmp;
 107           arg = strndup (p, 1024);
 108           if (arg == NULL)
 109             {
 110               VCFG_DBG (0, "VCL<%d>: strndup failed, using default "
 111                         "heapsize %lu (0x%lx)", getpid (),
 112                         (unsigned long) vcl_cfg->heapsize,
 113                         (unsigned long) vcl_cfg->heapsize);
 114               goto defaulted;
 115             }
 116           argv[argc - 1] = arg;
 117           p = strtok (NULL, " \t\n");
 118         }
 119     }
 120
 121   fclose (fp);
 122   fp = NULL;
 123
 124   char **tmp = realloc (argv, (argc + 1) * sizeof (char *));
 125   if (tmp == NULL)
 126     {
 127       VCFG_DBG (0, "VCL<%d>: realloc failed, using default heapsize %lu "
 128                 "(0x%lx)", getpid (), (unsigned long) vcl_cfg->heapsize,
 129                 (unsigned long) vcl_cfg->heapsize);
 130       goto defaulted;
 131     }
 132   argv = tmp;
 133   argv[argc] = NULL;
 134
 135   /*
 136    * Look for and parse the "heapsize" config parameter.
 137    * Manual since none of the clib infra has been bootstrapped yet.
 138    *
 139    * Format: heapsize <nn>[mM][gG]
 140    */
 141
 142   for (i = 1; i < (argc - 1); i++)
 143     {
 144       if (!strncmp (argv[i], "heapsize", 8))
 145         {
 146           sizep = (u8 *) argv[i + 1];
 147           size = 0;
 148           while (*sizep >= '0' && *sizep <= '9')
 149             {
 150               size *= 10;
 151               size += *sizep++ - '0';
 152             }
 153           if (size == 0)
 154             {
 155               VCFG_DBG (0, "VCL<%d>: parse error '%s %s', using default "
 156                         "heapsize %lu (0x%lx)", getpid (), argv[i],
 157                         argv[i + 1], (unsigned long) vcl_cfg->heapsize,
 158                         (unsigned long) vcl_cfg->heapsize);
 159               goto defaulted;
 160             }
 161
 162           if (*sizep == 'g' || *sizep == 'G')
 163             vcl_cfg->heapsize = size << 30;
 164           else if (*sizep == 'm' || *sizep == 'M')
 165             vcl_cfg->heapsize = size << 20;
 166           else
 167             {
 168               VCFG_DBG (0, "VCL<%d>: parse error '%s %s', using default "
 169                         "heapsize %lu (0x%lx)", getpid (), argv[i],
 170                         argv[i + 1], (unsigned long) vcl_cfg->heapsize,
 171                         (unsigned long) vcl_cfg->heapsize);
 172               goto defaulted;
 173             }
 174         }
 175       free (argv[i]);
 176     }
 177
 178 defaulted:
 179   if (fp != NULL)
 180     fclose (fp);
 181   if (argv != NULL)
 182     free (argv);
 183
 184   vcl_mem = mmap (0, vcl_cfg->heapsize, PROT_READ | PROT_WRITE,
 185                   MAP_SHARED | MAP_ANONYMOUS, -1, 0);
 186   if (vcl_mem == MAP_FAILED)
 187     {
 188       VCFG_DBG (0, "VCL<%d>: ERROR: mmap(0, %lu == 0x%lx, "
 189                 "PROT_READ | PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS, "
 190                 "-1, 0) failed!", getpid (),
 191                 (unsigned long) vcl_cfg->heapsize,
 192                 (unsigned long) vcl_cfg->heapsize);
 193       ASSERT (vcl_mem != MAP_FAILED);
 194       return;
 195     }
 196   heap = clib_mem_init_thread_safe (vcl_mem, vcl_cfg->heapsize);
 197   if (!heap)
 198     {
 199       fprintf (stderr, "VCL<%d>: ERROR: clib_mem_init() failed!", getpid ());
 200       ASSERT (heap);
 201       return;
 202     }
 203   vcl_mem = clib_mem_alloc (sizeof (_vppcom_main));
 204   if (!vcl_mem)
 205     {
 206       clib_warning ("VCL<%d>: ERROR: clib_mem_alloc() failed!", getpid ());
 207       ASSERT (vcl_mem);
 208       return;
 209     }
 210
 211   clib_memcpy (vcl_mem, &_vppcom_main, sizeof (_vppcom_main));
 212   vcm = vcl_mem;
 213
 214   VCFG_DBG (0, "VCL<%d>: allocated VCL heap = %p, size %lu (0x%lx)",
 215             getpid (), heap, (unsigned long) vcl_cfg->heapsize,
 216             (unsigned long) vcl_cfg->heapsize);
 217 }
 218
 219 void
 220 vppcom_cfg_read_file (char *conf_fname)
 221 {
 222   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
 223   int fd;
 224   unformat_input_t _input, *input = &_input;
 225   unformat_input_t _line_input, *line_input = &_line_input;
 226   u8 vc_cfg_input = 0;
 227   struct stat s;
 228   u32 uid, gid;
 229
 230   fd = open (conf_fname, O_RDONLY);
 231   if (fd < 0)
 232     {
 233       VCFG_DBG (0, "VCL<%d>: using default configuration.", getpid ());
 234       goto file_done;
 235     }
 236
 237   if (fstat (fd, &s) < 0)
 238     {
 239       VCFG_DBG (0, "VCL<%d>: failed to stat `%s' using default configuration",
 240                 getpid (), conf_fname);
 241       goto file_done;
 242     }
 243
 244   if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
 245     {
 246       VCFG_DBG (0, "VCL<%d>: not a regular file `%s', using default "
 247                 "configuration", getpid (), conf_fname);
 248       goto file_done;
 249     }
 250
 251   unformat_init_clib_file (input, fd);
 252
 253   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 254     {
 255       /* skip empty newlines as they confuse unformat_line_input */
 256       unformat_skip_white_space (input);
 257       (void) unformat_user (input, unformat_line_input, line_input);
 258       unformat_skip_white_space (line_input);
 259
 260       if (unformat (line_input, "vcl {"))
 261         {
 262           vc_cfg_input = 1;
 263           unformat_free (line_input);
 264           continue;
 265         }
 266
 267       if (vc_cfg_input)
 268         {
 269           if (unformat (line_input, "heapsize %U", unformat_memory_size,
 270                         &vcl_cfg->heapsize))
 271             {
 272               VCFG_DBG (0, "VCL<%d>: configured heapsize %lu", getpid (),
 273                         (unsigned long) vcl_cfg->heapsize);
 274             }
 275           else
 276             if (unformat
 277                 (line_input, "max-workers %u", &vcl_cfg->max_workers))
 278             {
 279               VCFG_DBG (0, "VCL<%d>: configured max-workers %u", getpid (),
 280                         vcl_cfg->max_workers);
 281             }
 282           else if (unformat (line_input, "api-socket-name %s",
 283                              &vcl_cfg->vpp_bapi_socket_name))
 284             {
 285               vec_terminate_c_string (vcl_cfg->vpp_bapi_socket_name);
 286               VCFG_DBG (0, "VCL<%d>: configured api-socket-name (%s)",
 287                         getpid (), vcl_cfg->vpp_bapi_socket_name);
 288             }
 289           else if (unformat (line_input, "app-socket-api %s",
 290                              &vcl_cfg->vpp_app_socket_api))
 291             {
 292               vec_terminate_c_string (vcl_cfg->vpp_app_socket_api);
 293               VCFG_DBG (0, "VCL<%d>: configured app-socket-api (%s)",
 294                         getpid (), vcl_cfg->vpp_app_socket_api);
 295             }
 296           else if (unformat (line_input, "uid %d", &uid))
 297             {
 298               vl_set_memory_uid (uid);
 299               VCFG_DBG (0, "VCL<%d>: configured uid %d", getpid (), uid);
 300             }
 301           else if (unformat (line_input, "gid %d", &gid))
 302             {
 303               vl_set_memory_gid (gid);
 304               VCFG_DBG (0, "VCL<%d>: configured gid %d", getpid (), gid);
 305             }
 306           else if (unformat (line_input, "segment-size 0x%lx",
 307                              &vcl_cfg->segment_size))
 308             {
 309               VCFG_DBG (0, "VCL<%d>: configured segment_size 0x%lx (%lu)",
 310                         getpid (), vcl_cfg->segment_size,
 311                         vcl_cfg->segment_size);
 312             }
 313           else if (unformat (line_input, "segment-size %lu",
 314                              &vcl_cfg->segment_size))
 315             {
 316               VCFG_DBG (0, "VCL<%d>: configured segment_size %lu (0x%lx)",
 317                         getpid (), vcl_cfg->segment_size,
 318                         vcl_cfg->segment_size);
 319             }
 320           else if (unformat (line_input, "add-segment-size 0x%lx",
 321                              &vcl_cfg->add_segment_size))
 322             {
 323               VCFG_DBG (0, "VCL<%d>: configured add_segment_size 0x%lx (%lu)",
 324                         getpid (), vcl_cfg->add_segment_size,
 325                         vcl_cfg->add_segment_size);
 326             }
 327           else if (unformat (line_input, "add-segment-size %lu",
 328                              &vcl_cfg->add_segment_size))
 329             {
 330               VCFG_DBG (0, "VCL<%d>: configured add_segment_size %lu (0x%lx)",
 331                         getpid (), vcl_cfg->add_segment_size,
 332                         vcl_cfg->add_segment_size);
 333             }
 334           else if (unformat (line_input, "preallocated-fifo-pairs %u",
 335                              &vcl_cfg->preallocated_fifo_pairs))
 336             {
 337               VCFG_DBG (0, "VCL<%d>: configured preallocated_fifo_pairs %u "
 338                         "(0x%x)", getpid (), vcl_cfg->preallocated_fifo_pairs,
 339                         vcl_cfg->preallocated_fifo_pairs);
 340             }
 341           else if (unformat (line_input, "rx-fifo-size 0x%x",
 342                              &vcl_cfg->rx_fifo_size))
 343             {
 344               VCFG_DBG (0, "VCL<%d>: configured rx_fifo_size 0x%x (%u)",
 345                         getpid (), vcl_cfg->rx_fifo_size,
 346                         vcl_cfg->rx_fifo_size);
 347             }
 348           else if (unformat (line_input, "rx-fifo-size %u",
 349                              &vcl_cfg->rx_fifo_size))
 350             {
 351               VCFG_DBG (0, "VCL<%d>: configured rx_fifo_size %u (0x%x)",
 352                         getpid (), vcl_cfg->rx_fifo_size,
 353                         vcl_cfg->rx_fifo_size);
 354             }
 355           else if (unformat (line_input, "tx-fifo-size 0x%x",
 356                              &vcl_cfg->tx_fifo_size))
 357             {
 358               VCFG_DBG (0, "VCL<%d>: configured tx_fifo_size 0x%x (%u)",
 359                         getpid (), vcl_cfg->tx_fifo_size,
 360                         vcl_cfg->tx_fifo_size);
 361             }
 362           else if (unformat (line_input, "tx-fifo-size %u",
 363                              &vcl_cfg->tx_fifo_size))
 364             {
 365               VCFG_DBG (0, "VCL<%d>: configured tx_fifo_size %u (0x%x)",
 366                         getpid (), vcl_cfg->tx_fifo_size,
 367                         vcl_cfg->tx_fifo_size);
 368             }
 369           else if (unformat (line_input, "event-queue-size 0x%x",
 370                              &vcl_cfg->event_queue_size))
 371             {
 372               VCFG_DBG (0, "VCL<%d>: configured event_queue_size 0x%x (%u)",
 373                         getpid (), vcl_cfg->event_queue_size,
 374                         vcl_cfg->event_queue_size);
 375             }
 376           else if (unformat (line_input, "event-queue-size %u",
 377                              &vcl_cfg->event_queue_size))
 378             {
 379               VCFG_DBG (0, "VCL<%d>: configured event_queue_size %u (0x%x)",
 380                         getpid (), vcl_cfg->event_queue_size,
 381                         vcl_cfg->event_queue_size);
 382             }
 383           else if (unformat (line_input, "app-timeout %f",
 384                              &vcl_cfg->app_timeout))
 385             {
 386               VCFG_DBG (0, "VCL<%d>: configured app_timeout %f",
 387                         getpid (), vcl_cfg->app_timeout);
 388             }
 389           else if (unformat (line_input, "session-timeout %f",
 390                              &vcl_cfg->session_timeout))
 391             {
 392               VCFG_DBG (0, "VCL<%d>: configured session_timeout %f",
 393                         getpid (), vcl_cfg->session_timeout);
 394             }
 395           else if (unformat (line_input, "app-proxy-transport-tcp"))
 396             {
 397               vcl_cfg->app_proxy_transport_tcp = 1;
 398               VCFG_DBG (0, "VCL<%d>: configured app_proxy_transport_tcp (%d)",
 399                         getpid (), vcl_cfg->app_proxy_transport_tcp);
 400             }
 401           else if (unformat (line_input, "app-proxy-transport-udp"))
 402             {
 403               vcl_cfg->app_proxy_transport_udp = 1;
 404               VCFG_DBG (0, "VCL<%d>: configured app_proxy_transport_udp (%d)",
 405                         getpid (), vcl_cfg->app_proxy_transport_udp);
 406             }
 407           else if (unformat (line_input, "app-scope-local"))
 408             {
 409               vcl_cfg->app_scope_local = 1;
 410               VCFG_DBG (0, "VCL<%d>: configured app_scope_local (%d)",
 411                         getpid (), vcl_cfg->app_scope_local);
 412             }
 413           else if (unformat (line_input, "app-scope-global"))
 414             {
 415               vcl_cfg->app_scope_global = 1;
 416               VCFG_DBG (0, "VCL<%d>: configured app_scope_global (%d)",
 417                         getpid (), vcl_cfg->app_scope_global);
 418             }
 419           else if (unformat (line_input, "namespace-secret %lu",
 420                              &vcl_cfg->namespace_secret))
 421             {
 422               VCFG_DBG (0, "VCL<%d>: configured namespace_secret %llu "
 423                         "(0x%llx)", getpid (),
 424                         (unsigned long long) vcl_cfg->namespace_secret,
 425                         (unsigned long long) vcl_cfg->namespace_secret);
 426             }
 427           else if (unformat (line_input, "namespace-id %v",
 428                              &vcl_cfg->namespace_id))
 429             {
 430               u32 max_nsid_vec_len = vcl_bapi_max_nsid_len ();
 431               u32 nsid_vec_len = vec_len (vcl_cfg->namespace_id);
 432               if (nsid_vec_len > max_nsid_vec_len)
 433                 {
 434                   _vec_len (vcl_cfg->namespace_id) = max_nsid_vec_len;
 435                   VCFG_DBG (0, "VCL<%d>: configured namespace_id is too long,"
 436                             " truncated to %d characters!",
 437                             getpid (), max_nsid_vec_len);
 438                 }
 439
 440               VCFG_DBG (0, "VCL<%d>: configured namespace_id %s",
 441                         getpid (), (char *) vcl_cfg->namespace_id);
 442             }
 443           else if (unformat (line_input, "use-mq-eventfd"))
 444             {
 445               vcl_cfg->use_mq_eventfd = 1;
 446               VCFG_DBG (0, "VCL<%d>: configured with mq with eventfd",
 447                         getpid ());
 448             }
 449           else if (unformat (line_input, "tls-engine %u",
 450                              &vcl_cfg->tls_engine))
 451             {
 452               VCFG_DBG (0, "VCL<%d>: configured tls-engine %u (0x%x)",
 453                         getpid (), vcl_cfg->tls_engine, vcl_cfg->tls_engine);
 454             }
 455           else if (unformat (line_input, "multi-thread-workers"))
 456             {
 457               vcl_cfg->mt_wrk_supported = 1;
 458               VCFG_DBG (0, "VCL<%d>: configured with multithread workers",
 459                         getpid ());
 460             }
 461           else if (unformat (line_input, "}"))
 462             {
 463               vc_cfg_input = 0;
 464               VCFG_DBG (0, "VCL<%d>: completed parsing vppcom config!",
 465                         getpid ());
 466               unformat_free (line_input);
 467               goto input_done;
 468             }
 469           else
 470             {
 471               if (line_input->buffer[line_input->index] != '#')
 472                 {
 473                   clib_warning ("VCL<%d>: Unknown vppcom config option: '%s'",
 474                                 getpid (), (char *)
 475                                 &line_input->buffer[line_input->index]);
 476                 }
 477             }
 478           unformat_free (line_input);
 479         }
 480     }
 481
 482 input_done:
 483   unformat_free (input);
 484
 485 file_done:
 486   if (fd >= 0)
 487     close (fd);
 488 }
 489
 490 void
 491 vppcom_cfg (vppcom_cfg_t * vcl_cfg)
 492 {
 493   char *conf_fname, *env_var_str;
 494
 495   vppcom_cfg_init (vcl_cfg);
 496   env_var_str = getenv (VPPCOM_ENV_DEBUG);
 497   if (env_var_str)
 498     {
 499       u32 tmp;
 500       if (sscanf (env_var_str, "%u", &tmp) != 1)
 501         {
 502           VCFG_DBG (0, "VCL<%d>: WARNING: Invalid debug level specified "
 503                     "in the environment variable " VPPCOM_ENV_DEBUG
 504                     " (%s)!\n", getpid (), env_var_str);
 505         }
 506       else
 507         {
 508           vcm->debug = tmp;
 509           VCFG_DBG (0, "VCL<%d>: configured VCL debug level (%u) from "
 510                     VPPCOM_ENV_DEBUG "!", getpid (), vcm->debug);
 511         }
 512     }
 513   conf_fname = getenv (VPPCOM_ENV_CONF);
 514   if (!conf_fname)
 515     conf_fname = VPPCOM_CONF_DEFAULT;
 516   vppcom_cfg_heapsize (conf_fname);
 517   vppcom_cfg_read_file (conf_fname);
 518
 519   /* Regrab cfg after heap initialization */
 520   vcl_cfg = &vcm->cfg;
 521   env_var_str = getenv (VPPCOM_ENV_APP_NAMESPACE_ID);
 522   if (env_var_str)
 523     {
 524       u32 ns_id_vec_len = strlen (env_var_str);
 525
 526       vec_reset_length (vcm->cfg.namespace_id);
 527       vec_validate (vcm->cfg.namespace_id, ns_id_vec_len - 1);
 528       clib_memcpy (vcm->cfg.namespace_id, env_var_str, ns_id_vec_len);
 529
 530       VCFG_DBG (0, "VCL<%d>: configured namespace_id (%s) from "
 531                 VPPCOM_ENV_APP_NAMESPACE_ID "!", getpid (), env_var_str);
 532     }
 533   env_var_str = getenv (VPPCOM_ENV_APP_NAMESPACE_SECRET);
 534   if (env_var_str)
 535     {
 536       u64 tmp;
 537       if (sscanf (env_var_str, "%llu", (unsigned long long *) &tmp) != 1)
 538         {
 539           VCFG_DBG (0, "VCL<%d>: WARNING: Invalid namespace secret specified"
 540                     " in the environment variable "
 541                     VPPCOM_ENV_APP_NAMESPACE_SECRET " (%s)!\n", getpid (),
 542                     env_var_str);
 543         }
 544       else
 545         {
 546           vcm->cfg.namespace_secret = tmp;
 547           VCFG_DBG (0, "VCL<%d>: configured namespace secret (%llu) from "
 548                     VPPCOM_ENV_APP_NAMESPACE_SECRET "!", getpid (),
 549                     (unsigned long long) vcm->cfg.namespace_secret);
 550         }
 551     }
 552   if (getenv (VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP))
 553     {
 554       vcm->cfg.app_proxy_transport_tcp = 1;
 555       VCFG_DBG (0, "VCL<%d>: configured app_proxy_transport_tcp (%u) from "
 556                 VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP "!", getpid (),
 557                 vcm->cfg.app_proxy_transport_tcp);
 558     }
 559   if (getenv (VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP))
 560     {
 561       vcm->cfg.app_proxy_transport_udp = 1;
 562       VCFG_DBG (0, "VCL<%d>: configured app_proxy_transport_udp (%u) from "
 563                 VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP "!", getpid (),
 564                 vcm->cfg.app_proxy_transport_udp);
 565     }
 566   if (getenv (VPPCOM_ENV_APP_SCOPE_LOCAL))
 567     {
 568       vcm->cfg.app_scope_local = 1;
 569       VCFG_DBG (0, "VCL<%d>: configured app_scope_local (%u) from "
 570                 VPPCOM_ENV_APP_SCOPE_LOCAL "!", getpid (),
 571                 vcm->cfg.app_scope_local);
 572     }
 573   if (getenv (VPPCOM_ENV_APP_SCOPE_GLOBAL))
 574     {
 575       vcm->cfg.app_scope_global = 1;
 576       VCFG_DBG (0, "VCL<%d>: configured app_scope_global (%u) from "
 577                 VPPCOM_ENV_APP_SCOPE_GLOBAL "!", getpid (),
 578                 vcm->cfg.app_scope_global);
 579     }
 580   env_var_str = getenv (VPPCOM_ENV_VPP_API_SOCKET);
 581   if (env_var_str)
 582     {
 583       vcm->cfg.vpp_bapi_socket_name = format (0, "%s%c", env_var_str, 0);
 584       VCFG_DBG (0, "VCL<%d>: configured api-socket-name (%s)", getpid (),
 585                 vcl_cfg->vpp_bapi_socket_name);
 586     }
 587   env_var_str = getenv (VPPCOM_ENV_VPP_SAPI_SOCKET);
 588   if (env_var_str)
 589     {
 590       vcm->cfg.vpp_app_socket_api = format (0, "%s%c", env_var_str, 0);
 591       VCFG_DBG (0, "VCL<%d>: configured app-socket-api (%s)", getpid (),
 592                 vcl_cfg->vpp_app_socket_api);
 593     }
 594 }
 595
 596 /*
 597  * fd.io coding-style-patch-verification: ON
 598  *
 599  * Local Variables:
 600  * eval: (c-set-style "gnu")
 601  * End:
 602  */