/src/opensips/cfg_pp.c

Source (jump to first uncovered line)
/*
 * OpenSIPS configuration file pre-processing
 *
 * Copyright (C) 2019 OpenSIPS Solutions
 *
 * This file is part of opensips, a free SIP server.
 *
 * opensips is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * opensips is distributed in the hope that 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 Street, Fifth Floor, Boston, MA 02110-1301,USA
 */

#define _WITH_GETLINE

#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <libgen.h>
#include <sys/stat.h>

#include "config.h"
#include "globals.h"
#include "cfg_pp.h"
#include "ut.h"

extern char *finame;
extern int startline;
extern int column;

extern FILE *yyin;
extern int yyparse();
extern int yyrestart(FILE*);
#ifdef DEBUG_PARSER
extern int yydebug;
#endif

str include_v1 = str_init("include_file");
str include_v2 = str_init("import_file");

str cfgtok_line = str_init("__OSSPP_LINE__");
str cfgtok_filebegin = str_init("__OSSPP_FILEBEGIN__");
str cfgtok_fileend = str_init("__OSSPP_FILEEND__");

static int flatten_opensips_cfg(FILE *cfg, const char *cfg_path, str *out);
static int exec_preprocessor(FILE *flat_cfg, const char *preproc_cmdline,
                             str *out);

static struct cfg_context *cfg_context_new_file(const char *path);
static void cfg_context_reset_all(void);
static void cfg_context_append_line(struct cfg_context *con,
                                    char *line, int len);

int parse_opensips_cfg(const char *cfg_file, const char *preproc_cmdline,
                              str *ret_buffer)
{
  FILE *cfg_stream;
  str cfg_buf, pp_buf;

  /* fill missing arguments with the default values*/
  if (!cfg_file)
    cfg_file = CFG_FILE;

  if (strlen(cfg_file) == 1 && cfg_file[0] == '-') {
    cfg_stream = stdin;
  } else {
    /* load config file or die */
    cfg_stream = fopen(cfg_file, "r");
    if (!cfg_stream) {
      LM_ERR("loading config file %s: %s\n", cfg_file,
             strerror(errno));
      return -1;
    }
  }

  cfg_context_reset_all();

  if (flatten_opensips_cfg(cfg_stream,
        cfg_stream == stdin ? "stdin" : cfg_file, &cfg_buf) < 0) {
    LM_ERR("failed to resolve file imports for %s\n", cfg_file);
    return -1;
  }

  cfg_stream = fmemopen(cfg_buf.s, cfg_buf.len, "r");
  if (!cfg_stream) {
    LM_ERR("failed to open file for flattened cfg buffer\n");
    goto out_free;
  }

  if (preproc_cmdline) {
    if (exec_preprocessor(cfg_stream, preproc_cmdline, &pp_buf) < 0) {
      LM_ERR("failed to exec preprocessor cmd: '%s'\n", preproc_cmdline);
      goto out_free;
    }
    free(cfg_buf.s);
    cfg_buf = pp_buf;

    cfg_stream = fmemopen(cfg_buf.s, cfg_buf.len, "r");
    if (!cfg_stream) {
      LM_ERR("failed to open file for processed cfg buffer\n");
      goto out_free;
    }
  }

#ifdef DEBUG_PARSER
  /* used for parser debugging */
  yydebug = 1;
#endif

  /* parse the config file, prior to this only default values
     e.g. for debugging settings will be used */
  yyin = cfg_stream;
  yyrestart(yyin);
  cfg_errors = 0;
  if (yyparse() != 0 || cfg_errors) {
    LM_ERR("bad config file (%d errors)\n", cfg_errors);
    fclose(cfg_stream);
    goto out_free;
  }

  fclose(cfg_stream);

  /* do we have to return the cfg buffer? */
  if (ret_buffer)
    *ret_buffer = cfg_buf;
  else
    free(cfg_buf.s);

  return 0;

out_free:
  free(cfg_buf.s);
  return -1;
}

static int extend_cfg_buf(char **buf, int *sz, int *bytes_left, int needed)
{
  if (needed < 4096)
    needed = 4096;

  *buf = realloc(*buf, *sz + needed);
  if (!*buf) {
    LM_ERR("failed to extend cfg buf to %d\n", *sz + needed);
    return -1;
  }

  *sz += needed;
  *bytes_left += needed;
  return 0;
}

/* search for '(include|import)_file "filepath"' patterns */
int mk_included_file_path(char *line, int line_len, const char *current_dir,
                          char **out_path)
{
  #define MAX_INCLUDE_FNAME   256
  static char full_path[MAX_INCLUDE_FNAME];
  struct stat _;
  char *p = NULL, enclose = 0;
  int len1, len2, fplen;

  while (line_len > 0 && is_ws(*line)) {
    line_len--;
    line++;
  }

  if (line_len > include_v1.len &&
          !memcmp(line, include_v1.s, include_v1.len)) {
    p = line + include_v1.len;
    line_len -= include_v1.len;
  } else if (line_len > include_v2.len &&
          !memcmp(line, include_v2.s, include_v2.len)) {
    p = line + include_v2.len;
    line_len -= include_v2.len;
  }

  if (!p)
    return 1;

  while (line_len > 0 && isspace(*p)) {
    line_len--;
    p++;
  }

  if (line_len < 3) // "f"
    return -1;

  if (*p != '"' && *p != '\'')
    return -1;

  enclose = *p++;
  line_len--;

  *out_path = p;

  while (line_len > 0 && *p != enclose) {
    line_len--;
    p++;
  }

  if (line_len == 0 || p - *out_path < 2) // ""_
    return -1;

  *p = '\0';

  /* is it a relative-path import? */
  if (**out_path != '/' && stat(*out_path, &_) < 0) {
    LM_DBG("%s not found (%d, %s), assuming it's relative to source cfg\n",
           *out_path, errno, strerror(errno));

    /* this relative path is not inside the startup dir,
     * so maybe it's relative to the importing file */
    len1 = strlen(current_dir);
    len2 = strlen(*out_path);

    if (len1 + 1 + len2 + 1 > MAX_INCLUDE_FNAME) {
      LM_ERR("file path too long (max %d): '%s' + '%s'\n",
             MAX_INCLUDE_FNAME, current_dir, *out_path);
      return -1;
    }

    memcpy(full_path, current_dir, len1);
    fplen = len1;

    /* this test can only fail when opensips runs from '/' */
    if (current_dir[len1 - 1] != '/')
      full_path[fplen++] = '/';

    memcpy(full_path + fplen, *out_path, len2);
    fplen += len2;

    full_path[fplen] = '\0';
    *out_path = full_path;
  }

  LM_DBG("preparing to include %s\n", *out_path);
  return 0;
}

static struct cfg_context {
  const char *path;
  const char *dirname; /* useful for relative path includes */
  int loc;
  char **lines;
  int bufsz;
  struct cfg_context *next;
} *__ccon;

static void cfg_context_reset_all(void)
{
  struct cfg_context *pos = NULL, *it = __ccon;

  while ( it && (it != __ccon || !pos) ) {
    pos = it;
    it = it->next;
    free((char*)pos->path);
    free((char*)pos->dirname);
    free(pos->lines);
    free(pos);
  };
  __ccon = NULL;
}

static struct cfg_context *cfg_context_new_file(const char *path)
{
  struct cfg_context *con, *it;
  char *cpy;

  for (it = __ccon; it; it = it->next)
    if (!strcmp(it->path, path))
      return it;

  con = malloc(sizeof *con);
  memset(con, 0, sizeof *con);

  con->path = strdup(path);

  cpy = strdup(path);
  con->dirname = strdup(dirname(cpy));
  free(cpy);

  con->lines = malloc(32 * sizeof *con->lines);
  con->bufsz = 32;

  add_last(con, __ccon);
  return con;
}

static void cfg_context_append_line(struct cfg_context *con,
                                    char *line, int len)
{
  if (con->loc == con->bufsz) {
    con->bufsz *= 2;
    con->lines = realloc(con->lines, con->bufsz * sizeof *con->lines);
    if (!con->lines)
      return;
  }

  con->lines[con->loc] = malloc(len + 1);
  memcpy(con->lines[con->loc], line, len);
  con->lines[con->loc][len] = '\0';

  con->loc++;
}

static int __flatten_opensips_cfg(FILE *cfg, const char *cfg_path,
                        char **flattened, int *sz, int *bytes_left, int reclev)
{
  FILE *included_cfg;
  ssize_t line_len;
  char *line = NULL, *included_cfg_path;
  unsigned long line_buf_sz = 0;
  int cfg_path_len = strlen(cfg_path);
  int line_counter = 1, needed, printed;
  struct cfg_context *con = NULL;

  if (reclev > 50) {
    LM_ERR("Maximum import depth reached (50) or "
           "you have an infinite include_file loop!\n");
    goto out_err;
  }

  if (cfg_path_len >= 2048) {
    LM_ERR("file path too large: %.*s...\n", 2048, cfg_path);
    goto out_err;
  }

  con = cfg_context_new_file(cfg_path);
  needed = cfgtok_filebegin.len + 1 + 1+cfg_path_len+1 + 1 + 1;
  if (*bytes_left < needed) {
    if (extend_cfg_buf(flattened, sz, bytes_left, needed) < 0) {
      LM_ERR("oom\n");
      goto out_err;
    }
  }

  /* print "start of file" adnotation */
  printed = snprintf(*flattened + *sz - *bytes_left, *bytes_left, "%.*s \"%.*s\"\n",
          cfgtok_filebegin.len, cfgtok_filebegin.s, cfg_path_len, cfg_path);
  *bytes_left -= printed;

  for (;;) {
    line_len = getline(&line, (size_t*)&line_buf_sz, cfg);
    if (line_len == -1) {
      if (ferror(cfg)) {
        if (errno == EINTR) {
          continue;
        } else {
          LM_ERR("failed to read from cfg file %.*s: %d (%s)\n",
                 cfg_path_len, cfg_path, errno, strerror(errno));
          goto out_err;
        }
      }

      if (!feof(cfg)) {
        LM_ERR("unhandled read error in cfg file %.*s: %d (%s)\n",
               cfg_path_len, cfg_path, errno, strerror(errno));
        goto out_err;
      }

      line_len = 0;
      break;

    } else if (line_len == 0) {
      continue;
    }

    /* fix ending lines with a missing '\n' character ;) */
    if (feof(cfg)) {
      if (line[line_len - 1] != '\n') {
        if (line_buf_sz < line_len + 1) {
          line = realloc(line, line_len + 1);
          line_buf_sz = line_len + 1;
        }

        line[line_len] = '\n';
        line_len += 1;
      }
    }

    /* finally... we have a line! print "line number" adnotation */
    needed = cfgtok_line.len + 1 + 10 + 1 + 1;
    if (*bytes_left < needed) {
      if (extend_cfg_buf(flattened, sz, bytes_left, needed) < 0) {
        LM_ERR("oom\n");
        goto out_err;
      }
    }

    printed = snprintf(*flattened + *sz - *bytes_left, *bytes_left,
                "%.*s %d\n", cfgtok_line.len, cfgtok_line.s, line_counter);
    line_counter++;
    *bytes_left -= printed;

    if (con)
      cfg_context_append_line(con, line, line_len);

    /* if it's an include, skip printing the line, but do print the file */
    if (mk_included_file_path(line, line_len, con->dirname, &included_cfg_path) == 0) {
      included_cfg = fopen(included_cfg_path, "r");
      if (!included_cfg) {
        LM_ERR("failed to open %s: %d (%s)\n", included_cfg_path,
               errno, strerror(errno));
        goto out_err;
      }

      included_cfg_path = strdup(included_cfg_path);
      if (__flatten_opensips_cfg(included_cfg, included_cfg_path,
                                 flattened, sz, bytes_left, reclev + 1)) {
        free(included_cfg_path);
        LM_ERR("failed to flatten cfg file %s\n", cfg_path);
        goto out_err;
      }
      free(included_cfg_path);
    } else {
      needed = line_len + 1;
      if (*bytes_left < needed) {
        if (extend_cfg_buf(flattened, sz, bytes_left, needed) < 0) {
          LM_ERR("oom\n");
          goto out_err;
        }
      }

      printed = snprintf(*flattened + *sz - *bytes_left, *bytes_left,
              "%.*s", (int)line_len, line);
      *bytes_left -= printed;
    }
  }

  free(line);
  line = NULL;

  needed = cfgtok_fileend.len + 1 + 1;
  if (*bytes_left < needed) {
    if (extend_cfg_buf(flattened, sz, bytes_left, needed) < 0) {
      LM_ERR("oom\n");
      goto out_err;
    }
  }

  /* print "end of file" adnotation */
  printed = snprintf(*flattened + *sz - *bytes_left, *bytes_left, "%.*s\n",
          cfgtok_fileend.len, cfgtok_fileend.s);
  *bytes_left -= printed;

  fclose(cfg);
  return 0;

out_err:
  if (line)
    free(line);
  fclose(cfg);
  return -1;
}

/*
 * - flatten any recursive includes into one big resulting file
 * - adnotate each line of the final file
 * - close given FILE * and return a buffer corresponding to the new file
 */
static int flatten_opensips_cfg(FILE *cfg, const char *cfg_path, str *out)
{
  int sz = 0, bytes_left = 0;
  char *flattened = NULL;

  if (__flatten_opensips_cfg(cfg, cfg_path, &flattened, &sz, &bytes_left, 0)) {
    LM_ERR("failed to flatten cfg file %s\n", cfg_path);
    return -1;
  }

  out->s = flattened;
  out->len = sz - bytes_left;

  if (strlen(out->s) != out->len) {
    LM_BUG("preprocessed buffer check failed (%lu vs. %d)",
           (unsigned long)strlen(out->s), out->len);
    LM_ERR("either this is a bug or your script contains '\\0' chars, "
            "which are obviously NOT allowed!\n");
    return -1;
  }

  return 0;
}

static char *cfg_include_stack[CFG_MAX_INCLUDE_DEPTH];
static char **cfg_include_stackp;
int cfg_push(const str *cfg_file)
{
  if (!cfg_include_stackp) {
    cfg_include_stackp = cfg_include_stack;
  } else if (cfg_include_stackp - cfg_include_stack + 1 >=
             CFG_MAX_INCLUDE_DEPTH) {
    LM_ERR("max nested cfg files reached! (%d)\n", CFG_MAX_INCLUDE_DEPTH);
    return -1;
  } else {
    cfg_include_stackp++;
  }

  *cfg_include_stackp = malloc(cfg_file->len + 1);
  if (!*cfg_include_stackp) {
    LM_ERR("oom\n");
    return -1;
  }
  memcpy(*cfg_include_stackp, cfg_file->s, cfg_file->len);
  (*cfg_include_stackp)[cfg_file->len] = '\0';

  finame = *cfg_include_stackp;
  startline = 1;
  column = 1;
  return 0;
}

int cfg_pop(void)
{
  if (!cfg_include_stackp) {
    LM_ERR("no more files to pop!\n");
    return -1;
  }

  /* the file path MUST NOT be freed, as the lexer and parser work in tandem,
   * so by this point, there are plenty of structures referencing it */

  if (cfg_include_stackp == cfg_include_stack) {
    cfg_include_stackp = NULL;
  } else {
    cfg_include_stackp--;
    finame = *cfg_include_stackp;
    column = 1;
  }

  return 0;
}

void _cfg_dump_context(const char *file, int line, int colstart, int colend,
                       int run_once)
{
  static int called_before;
  struct cfg_context *con;
  int i, iter = 1, len;
  char *p, *end, *wsbuf, *wb, *hiline;

  if (!file)
    return;

  for (con = __ccon; con; con = con->next)
    if (!strcmp(con->path, file))
      break;

  if (!con || !con->lines[0] || (run_once && called_before))
    return;

  called_before = 1;

  /* 2 lines above */
  if (line >= 3) {
    startline = line - 2;
    iter += 2;
  } else {
    startline = 1;
    iter += line - 1;
  }

  for (i = startline - 1; iter > 0; i++, iter--)
    LM_GEN1(L_CRIT, "%s", con->lines[i]);

  /* error indicator line */
  len = strlen(con->lines[i-1]);
  wsbuf = malloc(len + 1);
  if (!wsbuf) {
    LM_ERR("oom\n");
    return;
  }

  wb = wsbuf;
  for (p = con->lines[i-1], end = p + len; p < end && is_ws(*p); p++)
    *wb++ = *p;
  *wb = '\0';

  if (colend < colstart) {
    hiline = NULL;
  } else {
    hiline = malloc(colend - colstart);
    if (!hiline) {
      LM_ERR("oom\n");
      free(wsbuf);
      return;
    }
    memset(hiline, '~', colend - colstart);
  }

  LM_GEN1(L_CRIT, "%s^%.*s\n", wsbuf,
          colend >= colstart ? colend - colstart : 0, hiline);
  free(hiline);
  free(wsbuf);

  /* 2 lines below */
  if (line <= con->loc - 2)
    iter = 2;
  else
    iter = line <= con->loc ? con->loc - line : 0;

  for (; iter > 0; i++, iter--)
    LM_GEN1(L_CRIT, "%s", con->lines[i]);
}

void cfg_dump_backtrace(void)
{
  static int called_before;
  char **it;
  int frame = 0;

  if (called_before || !cfg_include_stackp)
    return;

  called_before = 1;
  LM_GEN1(L_CRIT, "Traceback (last included file at the bottom):\n");
  for (it = cfg_include_stack; it <= cfg_include_stackp; it++)
    LM_GEN1(L_CRIT, "%2d. %s\n", frame++, *it);
}

static int exec_preprocessor(FILE *flat_cfg, const char *preproc_cmdline,
                             str *out)
{
  int parent_w[2], parent_r[2], cfgsz = 0, cfgbufsz = 0;
  char chunk[1024], *cfgbuf = NULL;
  ssize_t written, bytes;
  size_t bytes2write;
  char *p, *tok, *cmd, **argv = NULL, *pp_binary = NULL;
  int argv_len = 0, flags, have_input = 0, done_writing = 0;

  if (strlen(preproc_cmdline) == 0) {
    LM_ERR("preprocessor command (-p) is an empty string!\n");
    goto out_err;
  }

  if (pipe(parent_w) != 0 || pipe(parent_r) != 0) {
    LM_ERR("failed to create pipe: %d (%s)\n", errno, strerror(errno));
    goto out_err;
  }

  /* fork a data-hungry preprocessor beast! (a.k.a. some tiny sed) */
  if (fork() == 0) {
    close(parent_w[1]);
    if (dup2(parent_w[0], STDIN_FILENO) < 0) {
      LM_ERR("dup2 failed with: %d (%s)\n", errno, strerror(errno));
      exit(-1);
    }
    close(parent_w[0]);

    close(parent_r[0]);
    if (dup2(parent_r[1], STDOUT_FILENO) < 0) {
      LM_ERR("dup2 failed with: %d (%s)\n", errno, strerror(errno));
      exit(-1);
    }
    close(parent_w[1]);

    for (cmd = strdup(preproc_cmdline); ; cmd = NULL) {
      tok = strtok(cmd, " \t\r\n");
      if (!tok)
        break;

      if (!pp_binary)
        pp_binary = tok;

      argv = realloc(argv, (argv_len + 1) * sizeof *argv);
      argv[argv_len++] = tok;
    }

    argv = realloc(argv, (argv_len + 1) * sizeof *argv);
    argv[argv_len++] = NULL;

    if (pp_binary) {
      execvp(pp_binary, argv);
      LM_ERR("failed to exec preprocessor '%s': %d (%s)\n",
           preproc_cmdline, errno, strerror(errno));
    } else
      LM_ERR("no binary to run: '%s'\n", preproc_cmdline);

    exit(-1);
  }

  close(parent_w[0]);
  close(parent_r[1]);

  flags = fcntl(parent_w[1], F_GETFL);
  if (flags == -1) {
    LM_ERR("fcntl GET 1 failed: %d - %s\n", errno, strerror(errno));
    goto out_err_pipes;
  }

  if (fcntl(parent_w[1], F_SETFL, flags | O_NONBLOCK) == -1) {
    LM_ERR("fcntl SET 1 failed: %d - %s\n", errno, strerror(errno));
    goto out_err_pipes;
  }

  flags = fcntl(parent_r[0], F_GETFL);
  if (flags == -1) {
    LM_ERR("fcntl GET 2 failed: %d - %s\n", errno, strerror(errno));
    goto out_err_pipes;
  }

  if (fcntl(parent_r[0], F_SETFL, flags | O_NONBLOCK) == -1) {
    LM_ERR("fcntl SET 2 failed: %d - %s\n", errno, strerror(errno));
    goto out_err_pipes;
  }

  /* communicate with the preprocessor using alternating,
   * non-blocking writes and reads */
  while (!done_writing) {
    /* fetch bytes to write */
    bytes2write = fread(chunk, 1, 1024, flat_cfg);
    if (ferror(flat_cfg)) {
      LM_ERR("failed to read from flat cfg: %d (%s)\n",
             errno, strerror(errno));
      goto out_err_pipes;
    }

    if (bytes2write == 0) {
      done_writing = 1;
      close(parent_w[1]); /* signal EOF to the outside process! */
    } else {
      have_input = 1;
    }

    p = chunk;

send_bytes:
    /* write phase */
    while (bytes2write > 0) {
      written = write(parent_w[1], p, bytes2write);
      if (written < 0) {
        if (errno == EAGAIN || errno == EWOULDBLOCK)
          break;
        else if (errno == EINTR)
          continue;
        else
          goto out_err_pipes;
      }

      bytes2write -= written;
      p += written;
    }

    /* read phase */
    for (;;) {
      if (cfgsz + 1024 > cfgbufsz) {
        if (cfgbufsz == 0)
          cfgbufsz = 4096;
        else
          cfgbufsz *= 2;

        cfgbuf = realloc(cfgbuf, cfgbufsz);
        if (!cfgbuf) {
          LM_ERR("oom, failed to build config buffer\n");
          goto out_err;
        }
      }

      bytes = read(parent_r[0], cfgbuf + cfgsz, 1024);
      if (bytes < 0) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
          if (done_writing) {
            usleep(10);
            continue;
          } else {
            break;
          }
        } else if (errno == EINTR) {
          continue;
        } else {
          goto out_err_pipes;
        }
      } else if (bytes == 0) {
        bytes2write = 0;
        done_writing = 1;
        break;
      }

      cfgsz += bytes;
    }

    if (bytes2write > 0)
      goto send_bytes;
  }

  if (have_input && cfgsz == 0)
    LM_WARN("no output from the preprocessor! "
        "Does it print to standard output?\n");

  fclose(flat_cfg);
  close(parent_r[0]);

  out->s = cfgbuf;
  out->len = cfgsz;
  return 0;

out_err_pipes:
  close(parent_w[1]);
  close(parent_r[0]);
out_err:
  fclose(flat_cfg);
  free(cfgbuf);
  return -1;
}

int eatback_pp_tok(struct str_buf *buf)
{
  char *p;
  str last_line;

  if (!buf->s)
    return 0;

  for (p = buf->crt - 1; p >= buf->s; p--)
    if (*p == '\n') {
      p++;
      goto match_pp_tok;
    }

  return 0;

match_pp_tok:
  last_line.s = p;
  last_line.len = buf->crt - p;

  if (last_line.len < 0) {
    LM_BUG("negative line len");
    return 0;
  }

  if (last_line.len >= cfgtok_line.len &&
    !memcmp(last_line.s, cfgtok_line.s, cfgtok_line.len))
    goto clear_last_line;

  if (last_line.len >= cfgtok_filebegin.len &&
    !memcmp(last_line.s, cfgtok_filebegin.s, cfgtok_filebegin.len))
    goto clear_last_line;

  if (last_line.len >= cfgtok_fileend.len &&
    !memcmp(last_line.s, cfgtok_fileend.s, cfgtok_fileend.len))
    goto clear_last_line;

  /* don't touch anything, this is an actual script line! */
  return 0;

clear_last_line:
  LM_DBG("clearing pp token line: '%.*s'\n", (int)(buf->crt - p), p);
  buf->left += buf->crt - p;
  *p = '\0';
  buf->crt = p;
  return 1;
}

Coverage Report

Created: 2025-07-09 06:29