/*

 * Copyright (c) 2004-2006 Maxim Sobolev <sobomax@FreeBSD.org>

 * Copyright (c) 2006-2007 Sippy Software, Inc., http://www.sippysoft.com

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 */

#ifdef LINUX_XXX

/* Apparently needed for drand48(3) */

#define _SVID_SOURCE  1

/* Needed for the asprintf(3) */

#define _GNU_SOURCE 1

#endif

#include <sys/types.h>

#include <sys/resource.h>

#include <sys/socket.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <getopt.h>

#include <grp.h>

#include <limits.h>

#include <math.h>

#include <netdb.h>

#include <pthread.h>

#include <pwd.h>

#include <stdatomic.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <signal.h>

#include <string.h>

#include <syslog.h>

#include <unistd.h>

#include "config_pp.h"

#if !defined(NO_ERR_H)

#include <err.h>

#include "rtpp_util.h"

#else

#include "rtpp_util.h"

#endif

#ifdef HAVE_SYSTEMD_DAEMON

#include <systemd/sd-daemon.h>

#endif

#include <elperiodic.h>

#include "rtpp_types.h"

#include "rtpp_refcnt.h"

#include "rtpp_runcreds.h"

#include "rtpp_cfile.h"

#include "rtpp_log.h"

#include "rtpp_log_obj.h"

#include "rtpp_cfg.h"

#include "rtpp_defines.h"

#include "rtpp_command.h"

#include "rtpp_controlfd.h"

#include "rtpp_genuid_singlet.h"

#include "rtpp_hash_table.h"

#include "commands/rpcpv1_ver.h"

#include "rtpp_command_async.h"

#include "rtpp_command_ecodes.h"

#include "rtpp_port_table.h"

#include "rtpp_proc_async.h"

#include "rtpp_proc_servers.h"

#include "rtpp_proc_ttl.h"

#include "rtpp_bindaddrs.h"

#include "rtpp_network.h"

#include "rtpp_notify.h"

#include "rtpp_math.h"

#include "rtpp_mallocs.h"

#include "rtpp_list.h"

#if ENABLE_MODULE_IF

#include "rtpp_module_if.h"

#include "rtpp_modman.h"

#endif

#include "rtpp_stats.h"

#include "rtpp_sessinfo.h"

#include "rtpp_time.h"

#include "rtpp_timed.h"

#include "rtpp_timed_task.h"

#include "rtpp_tnotify_set.h"

#include "rtpp_weakref.h"

#include "rtpp_debug.h"

#include "rtpp_locking.h"

#include "rtpp_nofile.h"

#include "advanced/pproc_manager.h"

#ifdef RTPP_CHECK_LEAKS

#include "libexecinfo/stacktraverse.h"

#include "libexecinfo/execinfo.h"

#include "rtpp_memdeb_internal.h"

#endif

#include "rtpp_stacktrace.h"

#if defined(LIBRTPPROXY)

#include "librtpproxy.h"

#include "rtpp_module_if_static.h"

#endif

#ifndef RTPP_DEBUG

# define RTPP_DEBUG 0

#else

# define RTPP_DEBUG 1

#endif

#define PRIO_UNSET (PRIO_MIN - 1)

static void usage(void);

#ifdef RTPP_CHECK_LEAKS

RTPP_MEMDEB_APP_STATIC;

#endif

static void

usage(void)

{

    fprintf(stderr, "usage:\trtpproxy [-2fvFiPaRbD] [-l addr1[/addr2]] "

      "[-6 addr1[/addr2]] [-s path]\n\t  [-t tos] [-r rdir [-S sdir]] [-T ttl] "

      "[-L nfiles] [-m port_min]\n\t  [-M port_max] [-u uname[:gname]] [-w sock_mode] "

      "[-n timeout_socket]\n\t  [-d log_level[:log_facility]] [-p pid_file]\n"

      "\t  [-c fifo|rr] [-A addr1[/addr2] [-W setup_ttl]\n"

      "\trtpproxy -V\n");

    exit(1);

}

static struct rtpp_cfg *_sig_cf;

static void rtpp_exit(int, int) __attribute__ ((noreturn));

static void

rtpp_exit(int memdeb, int rval)

{

    int ecode;

    ecode = 0;

#ifdef RTPP_CHECK_LEAKS

    if (memdeb) {

        ecode = rtpp_memdeb_dumpstats(MEMDEB_SYM, 0) == 0 ? 0 : 1;

    }

#endif

    exit(rval == 0 ? ecode : rval);

}

static void

rtpp_glog_fin(void)

{

    RTPP_OBJ_DECREF(_sig_cf->glog);

#ifdef RTPP_CHECK_LEAKS

    RTPP_MEMDEB_FIN(rtpproxy);

#ifdef RTPP_MEMDEB_STDOUT

    fclose(stdout);

#endif

#endif

}

static void

fatsignal(int sig)

{

    RTPP_LOG(_sig_cf->glog, RTPP_LOG_INFO, "got signal %d", sig);

    if (_sig_cf->fastshutdown == 0) {

        _sig_cf->fastshutdown = 1;

        return;

    }

    /*

     * Got second signal while already in the fastshutdown mode, something

     * probably jammed, do quick exit right from sighandler.

     */

    rtpp_exit(1, 0);

}

static void

sighup(int sig)

{

    if (_sig_cf->slowshutdown == 0) {

        RTPP_LOG(_sig_cf->glog, RTPP_LOG_INFO,

          "got SIGHUP, initiating deorbiting-burn sequence");

    }

    _sig_cf->slowshutdown = 1;

}

static void

ehandler(void)

{

    RTPP_DBGCODE(catchtrace) {

        rtpp_stacktrace_print("Exiting from: ehandler()");

    }

    if (_sig_cf->ctrl_socks != NULL)

        rtpp_controlfd_cleanup(_sig_cf);

    unlink(_sig_cf->pid_file);

    RTPP_LOG(_sig_cf->glog, RTPP_LOG_INFO, "rtpproxy ended");

}

long long

rtpp_rlim_max(const struct rtpp_cfg *cfsp)

{

    return (long long)(cfsp->nofile->limit->rlim_max);

}

#define LOPT_DSO      256

#define LOPT_BRSYM    257

#define LOPT_NICE     258

#define LOPT_OVL_PROT 259

#define LOPT_CONFIG   260

#define LOPT_FORC_ASM 261

const static struct option longopts[] = {

    { "dso", required_argument, NULL, LOPT_DSO },

    { "bridge_symmetric", no_argument, NULL, LOPT_BRSYM },

    { "nice", required_argument, NULL, LOPT_NICE },

    { "overload_prot", optional_argument, NULL, LOPT_OVL_PROT },

    { "config", required_argument, NULL, LOPT_CONFIG },

    { "force_asymmetric", no_argument, NULL, LOPT_FORC_ASM },

    { NULL,  0,                 NULL, 0 }

};

static void

init_config_bail(struct rtpp_cfg *cfsp, int rval, const char *msg, int memdeb)

{

    struct rtpp_ctrl_sock *ctrl_sock, *ctrl_sock_next;

    if (msg != NULL) {

        RTPP_LOG(cfsp->glog, RTPP_LOG_ERR, "%s", msg);

    }

    CALL_METHOD(cfsp->bindaddrs_cf, dtor);

    free(cfsp->locks);

    CALL_METHOD(cfsp->rtpp_tnset_cf, dtor);

    CALL_METHOD(cfsp->nofile, dtor);

    RTPP_OBJ_DECREF(cfsp->sessions_wrt);

    for (ctrl_sock = RTPP_LIST_HEAD(cfsp->ctrl_socks);

      ctrl_sock != NULL; ctrl_sock = ctrl_sock_next) {

        ctrl_sock_next = RTPP_ITER_NEXT(ctrl_sock);

        free(ctrl_sock);

    }

    free(cfsp->ctrl_socks);

    free(cfsp->runcreds);

    RTPP_OBJ_DECREF(cfsp->modules_cf);

    rtpp_gen_uid_free();

    rtpp_exit(memdeb, rval);

}

static void

init_config(struct rtpp_cfg *cfsp, int argc, char **argv)

{

    int ch, i, umode, stdio_mode;

    char *bh[2], *bh6[2], *cp;

    const char *errmsg;

    struct passwd *pp;

    struct group *gp;

    struct rtpp_ctrl_sock *ctrl_sock;

    int option_index, brsym;

    const struct proto_cap *pcp;

    struct rtpp_module_if *mif;

    char mpath[PATH_MAX + 1];

    struct rtpp_module_conf *mcp;

    bh[0] = bh[1] = bh6[0] = bh6[1] = NULL;

    umode = stdio_mode = 0;

    cfsp->pid_file = PID_FILE;

    cfsp->port_min = PORT_MIN;

    cfsp->port_max = PORT_MAX;

    cfsp->port_ctl = 0;

    cfsp->advaddr[0] = NULL;

    cfsp->advaddr[1] = NULL;

    cfsp->max_ttl = SESSION_TIMEOUT;

    cfsp->tos = TOS;

    cfsp->rrtcp = 1;

    cfsp->runcreds->sock_mode = 0;

    cfsp->ttl_mode = TTL_UNIFIED;

    cfsp->log_level = -1;

    cfsp->log_facility = -1;

    cfsp->sched_hz = rtpp_get_sched_hz();

    cfsp->sched_policy = SCHED_OTHER;

    cfsp->sched_nice = PRIO_UNSET;

    cfsp->target_pfreq = MIN(POLL_RATE, cfsp->sched_hz);

    cfsp->slowshutdown = 0;

    cfsp->fastshutdown = 0;

    cfsp->rtpp_tnset_cf = rtpp_tnotify_set_ctor();

    if (cfsp->rtpp_tnset_cf == NULL) {

        err(1, "rtpp_tnotify_set_ctor");

    }

    cfsp->locks = malloc(sizeof(*cfsp->locks));

    if (cfsp->locks == NULL) {

        err(1, "malloc(rtpp_cfg->locks)");

    }

    if (pthread_mutex_init(&(cfsp->locks->glob), NULL) != 0) {

        errx(1, "pthread_mutex_init(rtpp_cfg->locks->glob)");

    }

    cfsp->bindaddrs_cf = rtpp_bindaddrs_ctor();

    if (cfsp->bindaddrs_cf == NULL) {

        err(1, "malloc(rtpp_cfg->bindaddrs_cf)");

    }

    cfsp->nofile = rtpp_nofile_ctor();

    if (cfsp->nofile == NULL)

        err(1, "malloc(rtpp_cfg->nofile)");

    cfsp->sessions_wrt = rtpp_weakref_ctor();

    if (cfsp->sessions_wrt == NULL) {

        err(1, "can't allocate memory for the sessions weakref table");

         /* NOTREACHED */

    }

    option_index = -1;

    brsym = 0;

    while ((ch = getopt_long(argc, argv, "vf2Rl:6:s:S:t:r:p:T:L:m:M:u:Fin:Pad:"

      "Vc:A:w:bW:DC", longopts, &option_index)) != -1) {

  switch (ch) {

        case LOPT_DSO:

            cp = NULL;

#if defined(LIBRTPPROXY)

            if (rtpp_static_modules_lookup(optarg) != NULL) {

                cp = optarg;

            }

#endif

            if (cp == NULL)

                cp = realpath(optarg, mpath);

            if (cp == NULL) {

                 err(1, "realpath: %s", optarg);

            }

            mif = rtpp_module_if_ctor(cp);

            if (mif == NULL) {

                err(1, "%s: dymanic module constructor has failed", cp);

            }

            if (CALL_METHOD(mif, load, cfsp, cfsp->glog) != 0) {

                errx(1, "%p: dymanic module load has failed", mif);

            }

            if (CALL_METHOD(mif, get_mconf, &mcp) != 0) {

                errx(1, "%p->get_mconf() method has failed: %s", mif, cp);

            }

            if (mcp != NULL) {

                 errx(1, "%s: dymanic module requires configuration, cannot be "

                   "loaded via --dso option", cp);

            }

            CALL_METHOD(cfsp->modules_cf, insert, mif);

            break;

        case LOPT_BRSYM:

            brsym = 1;

            break;

        case LOPT_NICE:

            switch (atoi_saferange(optarg, &cfsp->sched_nice, PRIO_MIN, PRIO_MAX)) {

            case ATOI_OK:

                break;

            case ATOI_OUTRANGE:

                errx(1, "%s: nice level is out of range %d..%d", optarg,

                  PRIO_MIN, PRIO_MAX);

            default:

                errx(1, "%s: nice level argument is invalid", optarg);

            }

            break;

        case LOPT_OVL_PROT:

            cfsp->overload_prot.low_trs = 0.85;

            cfsp->overload_prot.high_trs = 0.90;

            cfsp->overload_prot.ecode = ECODE_OVERLOAD;

            break;

        case LOPT_CONFIG:

            cfsp->cfile = optarg;

            break;

        case LOPT_FORC_ASM:

            cfsp->aforce = 1;

            break;

        case 'c':

            if (strcmp(optarg, "fifo") == 0) {

                 cfsp->sched_policy = SCHED_FIFO;

                 break;

            }

            if (strcmp(optarg, "rr") == 0) {

                 cfsp->sched_policy = SCHED_RR;

                 break;

            }

            errx(1, "%s: unknown scheduling policy", optarg);

            break;

  case 'f':

      cfsp->ropts.no_daemon = 1;

      break;

  case 'l':

      bh[0] = optarg;

      bh[1] = strchr(bh[0], '/');

      if (bh[1] != NULL) {

    *bh[1] = '\0';

    bh[1]++;

    cfsp->bmode = 1;

    /*

     * Historically, in bridge mode all clients are assumed to

     * be asymmetric

     */

    cfsp->aforce = 1;

      }

      break;

  case '6':

      bh6[0] = optarg;

      bh6[1] = strchr(bh6[0], '/');

      if (bh6[1] != NULL) {

    *bh6[1] = '\0';

    bh6[1]++;

    cfsp->bmode = 1;

    cfsp->aforce = 1;

      }

      break;

    case 'A':

        if (*optarg == '\0') {

            errx(1, "first advertised address is invalid");

        }

        cfsp->advaddr[0] = optarg;

        cp = strchr(optarg, '/');

        if (cp != NULL) {

            *cp = '\0';

            cp++;

            if (*cp == '\0') {

                errx(1, "second advertised address is invalid");

            }

        }

        cfsp->advaddr[1] = cp;

        break;

  case 's':

            ctrl_sock = rtpp_ctrl_sock_parse(optarg);

            if (ctrl_sock == NULL) {

                errx(1, "can't parse control socket argument");

            }

            rtpp_list_append(cfsp->ctrl_socks, ctrl_sock);

            if (RTPP_CTRL_ISDG(ctrl_sock)) {

                umode = 1;

            } else if (ctrl_sock->type == RTPC_STDIO) {

                stdio_mode = 1;

            }

      break;

  case 't':

            switch (atoi_saferange(optarg, &cfsp->tos, 0, 255)) {

            case ATOI_OK:

                break;

            case ATOI_OUTRANGE:

                errx(1, "%s: TOS is too small/large", optarg);

            default:

                errx(1, "%s: TOS argument is invalid", optarg);

      }

            break;

  case '2':

      cfsp->dmode = 1;

      break;

  case 'v':

      printf("Basic version: %d\n", CPROTOVER);

      for (pcp = iterate_proto_caps(NULL); pcp != NULL; pcp = iterate_proto_caps(pcp)) {

    printf("Extension %s: %s\n", pcp->pc_id, pcp->pc_description);

      }

      init_config_bail(cfsp, 0, NULL, 0);

      break;

  case 'r':

      cfsp->rdir = optarg;

      break;

  case 'S':

      cfsp->sdir = optarg;

      break;

  case 'R':

      cfsp->rrtcp = 0;

      break;

  case 'p':

      cfsp->pid_file = optarg;

      break;

  case 'T':

      if (atoi_saferange(optarg, &cfsp->max_ttl, 1, -1))

                errx(1, "%s: max TTL argument is invalid", optarg);

      break;

  case 'L': {

            int rlim_max_opt;

            if (atoi_saferange(optarg, &rlim_max_opt, 0, -1))

                errx(1, "%s: max file rlimit argument is invalid", optarg);

      cfsp->nofile->limit->rlim_cur = rlim_max_opt;

      cfsp->nofile->limit->rlim_max = rlim_max_opt;

      if (setrlimit(RLIMIT_NOFILE, cfsp->nofile->limit) != 0)

    err(1, "setrlimit");

      if (getrlimit(RLIMIT_NOFILE, cfsp->nofile->limit) != 0)

    err(1, "getrlimit");

      if (cfsp->nofile->limit->rlim_max < rlim_max_opt)

    warnx("limit allocated by setrlimit (%d) is less than "

      "requested (%d)", (int) cfsp->nofile->limit->rlim_max,

      rlim_max_opt);

      break;

            }

  case 'm':

      switch (atoi_saferange(optarg, &cfsp->port_min, 1, 65535)) {

            case ATOI_OK:

                break;

            case ATOI_OUTRANGE:

                errx(1, "invalid value of the port_min argument, "

                  "not in the range 1-65535");

            default:

                errx(1, "%s: min port argument is invalid", optarg);

            }

      break;

  case 'M':

      switch (atoi_saferange(optarg, &cfsp->port_max, 1, 65535)) {

            case ATOI_OK:

                break;

            case ATOI_OUTRANGE:

                errx(1, "invalid value of the port_max argument, "

                  "not in the range 1-65535");

            default:

                errx(1, "%s: max port argument is invalid", optarg);

            }

      break;

  case 'u':

      cfsp->runcreds->uname = optarg;

      cp = strchr(optarg, ':');

      if (cp != NULL) {

    if (cp == optarg)

        cfsp->runcreds->uname = NULL;

    cp[0] = '\0';

    cp++;

      }

      cfsp->runcreds->gname = cp;

      cfsp->runcreds->uid = -1;

      cfsp->runcreds->gid = -1;

      if (cfsp->runcreds->uname != NULL) {

    pp = getpwnam(cfsp->runcreds->uname);

    if (pp == NULL)

        errx(1, "can't find ID for the user: %s", cfsp->runcreds->uname);

    cfsp->runcreds->uid = pp->pw_uid;

    if (cfsp->runcreds->gname == NULL)

        cfsp->runcreds->gid = pp->pw_gid;

      }

      if (cfsp->runcreds->gname != NULL) {

    gp = getgrnam(cfsp->runcreds->gname);

    if (gp == NULL)

        errx(1, "can't find ID for the group: %s", cfsp->runcreds->gname);

    cfsp->runcreds->gid = gp->gr_gid;

                if (cfsp->runcreds->sock_mode == 0) {

                    cfsp->runcreds->sock_mode = 0755;

                }

      }

      break;

  case 'w': {

            int sock_mode;

      if (atoi_saferange(optarg, &sock_mode, 0, 4095))

                errx(1, "%s: socket mode argument is invalid", optarg);

            cfsp->runcreds->sock_mode = sock_mode;

      break;

            }

  case 'F':

      cfsp->no_check = 1;

      break;

  case 'i':

      cfsp->ttl_mode = TTL_INDEPENDENT;

      break;

  case 'n':

      if(strlen(optarg) == 0)

    errx(1, "timeout notification socket name too short");

            if (CALL_METHOD(cfsp->rtpp_tnset_cf, append, optarg,

              &errmsg) != 0) {

                errx(1, "error adding timeout notification: %s", errmsg);

            }

      break;

  case 'P':

      cfsp->record_pcap = 1;

      break;

  case 'a':

      cfsp->record_all = 1;

      break;

  case 'd':

      cp = strchr(optarg, ':');

      if (cp != NULL) {

    cfsp->log_facility = rtpp_log_str2fac(cp + 1);

    if (cfsp->log_facility == -1)

        errx(1, "%s: invalid log facility", cp + 1);

    *cp = '\0';

      }

      cfsp->log_level = rtpp_log_str2lvl(optarg);

      if (cfsp->log_level == -1)

    errx(1, "%s: invalid log level", optarg);

            CALL_METHOD(cfsp->glog, setlevel, cfsp->log_level);

      break;

  case 'V':

      printf("%s\n", RTPP_SW_VERSION);

      init_config_bail(cfsp, 0, NULL, 0);

      break;

        case 'W':

            if (atoi_saferange(optarg, &cfsp->max_setup_ttl, 1, -1))

                errx(1, "%s: max setup TTL argument is invalid", optarg);

            break;

        case 'b':

            cfsp->seq_ports = 1;

            break;

        case 'D':

      cfsp->ropts.no_chdir = 1;

      break;

        case 'C':

      printf("%s\n", get_mclock_name());

      init_config_bail(cfsp, 0, NULL, 0);

      break;

  case '?':

  default:

      usage();

  }

    }

    if (optind != argc) {

       warnx("%d extra unhandled argument%s at the end of the command line",

         argc - optind, (argc - optind) > 1 ? "s" : "");

       usage();

    }

    if (cfsp->cfile != NULL) {

        if (rtpp_cfile_process(cfsp) < 0) {

            init_config_bail(cfsp, 1, "rtpp_cfile_process() failed", 1);

        }

    }

    if (cfsp->bmode != 0 && brsym != 0) {

        cfsp->aforce = 0;

    }

    if (cfsp->max_setup_ttl == 0) {

        cfsp->max_setup_ttl = cfsp->max_ttl;

    }

    /* No control socket has been specified, add a default one */

    if (RTPP_LIST_IS_EMPTY(cfsp->ctrl_socks)) {

        ctrl_sock = rtpp_ctrl_sock_parse(CMD_SOCK);

        if (ctrl_sock == NULL) {

            errx(1, "can't parse control socket: \"%s\"", CMD_SOCK);

        }

        rtpp_list_append(cfsp->ctrl_socks, ctrl_sock);

    }

    if (cfsp->rdir == NULL && cfsp->sdir != NULL)

  errx(1, "-S switch requires -r switch");

    if (cfsp->ropts.no_daemon == 0 && stdio_mode != 0)

        errx(1, "stdio command mode requires -f switch");

    if (cfsp->no_check == 0 && getuid() == 0 && cfsp->runcreds->uname == NULL) {

  if (umode != 0) {

      errx(1, "running this program as superuser in a remote control "

        "mode is strongly not recommended, as it poses serious security "

        "threat to your system. Use -u option to run as an unprivileged "

        "user or -F is you want to run as a superuser anyway.");

  } else {

      warnx("WARNING!!! Running this program as superuser is strongly "

        "not recommended, as it may pose serious security threat to "

        "your system. Use -u option to run as an unprivileged user "

        "or -F to surpress this warning.");

  }

    }

    /* make sure that port_min and port_max are even */

    if ((cfsp->port_min % 2) != 0)

  cfsp->port_min++;

    if ((cfsp->port_max % 2) != 0) {

  cfsp->port_max--;

    } else {

  /*

   * If port_max is already even then there is no

   * "room" for the RTCP port, go back by two ports.

   */

  cfsp->port_max -= 2;

    }

    if (cfsp->port_min > cfsp->port_max)

  errx(1, "port_min should be less than port_max");

    if (bh[0] == NULL && bh[1] == NULL && bh6[0] == NULL && bh6[1] == NULL) {

  bh[0] = "*";

    }

    for (i = 0; i < 2; i++) {

  if (bh[i] != NULL && *bh[i] == '\0')

      bh[i] = NULL;

  if (bh6[i] != NULL && *bh6[i] == '\0')

      bh6[i] = NULL;

    }

    i = ((bh[0] == NULL) ? 0 : 1) + ((bh[1] == NULL) ? 0 : 1) +

      ((bh6[0] == NULL) ? 0 : 1) + ((bh6[1] == NULL) ? 0 : 1);

    if (cfsp->bmode != 0) {

  if (bh[0] != NULL && bh6[0] != NULL)

      errx(1, "either IPv4 or IPv6 should be configured for external "

        "interface in bridging mode, not both");

  if (bh[1] != NULL && bh6[1] != NULL)

      errx(1, "either IPv4 or IPv6 should be configured for internal "

        "interface in bridging mode, not both");

        if (cfsp->advaddr[0] != NULL && cfsp->advaddr[1] == NULL)

            errx(1, "two advertised addresses are required for internal "

              "and external interfaces in bridging mode");

  if (i != 2)

      errx(1, "incomplete configuration of the bridging mode - exactly "

        "2 listen addresses required, %d provided", i);

    } else if (i != 1) {

  errx(1, "exactly 1 listen addresses required, %d provided", i);

    }

    for (i = 0; i < 2; i++) {

  cfsp->bindaddr[i] = NULL;

  if (bh[i] != NULL) {

      cfsp->bindaddr[i] = CALL_METHOD(cfsp->bindaddrs_cf,

              host2, bh[i], AF_INET, AI_PASSIVE, &errmsg);

      if (cfsp->bindaddr[i] == NULL)

    errx(1, "host2bindaddr: %s", errmsg);

      continue;

  }

  if (bh6[i] != NULL) {

      cfsp->bindaddr[i] = CALL_METHOD(cfsp->bindaddrs_cf,

              host2, bh6[i], AF_INET6, AI_PASSIVE, &errmsg);

      if (cfsp->bindaddr[i] == NULL)

    errx(1, "host2bindaddr: %s", errmsg);

      continue;

  }

    }

    if (cfsp->bindaddr[0] == NULL) {

  cfsp->bindaddr[0] = cfsp->bindaddr[1];

  cfsp->bindaddr[1] = NULL;

    }

}

static enum rtpp_timed_cb_rvals

update_derived_stats(double dtime, void *argp)

{

    struct rtpp_stats *rtpp_stats;

    rtpp_stats = (struct rtpp_stats *)argp;

    CALL_SMETHOD(rtpp_stats, update_derived, dtime);

    return (CB_MORE);

}

#if !defined(LIBRTPPROXY)

static void

#else

void

#endif

rtpp_shutdown(struct rtpp_cfg *cfsp)

{

    struct rtpp_ctrl_sock *ctrl_sock, *ctrl_sock_next;

    CALL_METHOD(cfsp->rtpp_cmd_cf, dtor);

    CALL_SMETHOD(cfsp->sessions_wrt, purge);

    CALL_SMETHOD(cfsp->sessions_ht, purge);

    while ((CALL_SMETHOD(cfsp->rtp_streams_wrt, get_length) > 0) ||

      (CALL_SMETHOD(cfsp->rtcp_streams_wrt, get_length) > 0))

        continue;

    RTPP_OBJ_DECREF(cfsp->modules_cf);

    RTPP_OBJ_DECREF(cfsp->pproc_manager);

    free(cfsp->runcreds);

    RTPP_OBJ_DECREF(cfsp->rtpp_notify_cf);

    CALL_METHOD(cfsp->bindaddrs_cf, dtor);

    free(cfsp->locks);

    CALL_METHOD(cfsp->rtpp_tnset_cf, dtor);

    CALL_SMETHOD(cfsp->rtpp_timed_cf, shutdown);

    RTPP_OBJ_DECREF(cfsp->rtpp_timed_cf);

    CALL_METHOD(cfsp->rtpp_proc_ttl_cf, dtor);

    RTPP_OBJ_DECREF(cfsp->proc_servers);

    CALL_METHOD(cfsp->rtpp_proc_cf, dtor);

    RTPP_OBJ_DECREF(cfsp->sessinfo);

    RTPP_OBJ_DECREF(cfsp->rtpp_stats);

    for (int i = 0; i <= RTPP_PT_MAX; i++) {

        RTPP_OBJ_DECREF(cfsp->port_table[i]);

    }

    RTPP_OBJ_DECREF(cfsp->sessions_wrt);

    RTPP_OBJ_DECREF(cfsp->sessions_ht);

    RTPP_OBJ_DECREF(cfsp->rtp_streams_wrt);

    RTPP_OBJ_DECREF(cfsp->rtcp_streams_wrt);

    CALL_METHOD(cfsp->nofile, dtor);

    rtpp_controlfd_cleanup(cfsp);

    for (ctrl_sock = RTPP_LIST_HEAD(cfsp->ctrl_socks);

      ctrl_sock != NULL; ctrl_sock = ctrl_sock_next) {

        ctrl_sock_next = RTPP_ITER_NEXT(ctrl_sock);

        free(ctrl_sock);

    }

    free(cfsp->ctrl_socks);

    cfsp->ctrl_socks = NULL;

    rtpp_gen_uid_free();

}

#if !defined(LIBRTPPROXY)

int

main(int argc, char **argv)

#else

struct rtpp_cfg *

rtpp_main(int argc, char **argv)

#endif

{

    int i, len, pid_fd;

    static struct rtpp_cfg cfs;

    char buf[256];

    struct sched_param sparam;

    void *elp;

    struct rtpp_timed_task *tp;

    struct rtpp_daemon_rope drop;

    memset(&cfs, 0, sizeof(cfs));

#if defined(LIBRTPPROXY)

    cfs.ropts = (struct rtpp_run_options){

        .no_pid = 1, .no_chdir = 1, .no_daemon = 1, .no_sigtrap = 1

    };

#endif

#ifdef RTPP_CHECK_LEAKS

    RTPP_MEMDEB_APP_INIT();

#endif

    if (getdtime() == -1) {

        err(1, "timer self-test has failed: please check your build configuration");

        /* NOTREACHED */

    }

#ifdef RTPP_CHECK_LEAKS

    if (rtpp_memdeb_selftest(MEMDEB_SYM) != 0) {

        errx(1, "MEMDEB self-test has failed");

        /* NOTREACHED */

    }

#endif

    cfs.ctrl_socks = rtpp_zmalloc(sizeof(struct rtpp_list));

    if (cfs.ctrl_socks == NULL) {

         err(1, "can't allocate memory for the struct ctrl_socks");

         /* NOTREACHED */

    }

    cfs.modules_cf = rtpp_modman_ctor();

    if (cfs.modules_cf == NULL) {

         err(1, "can't allocate memory for the struct modules_cf");

         /* NOTREACHED */

    }

    cfs.runcreds = rtpp_zmalloc(sizeof(struct rtpp_runcreds));

    if (cfs.runcreds == NULL) {

         err(1, "can't allocate memory for the struct runcreds");

         /* NOTREACHED */

    }

    seedrandom();

    if (rtpp_gen_uid_init() != 0) {

        err(1, "rtpp_gen_uid_init() failed");

        /* NOTREACHED */

    }

    cfs.glog = rtpp_log_ctor("rtpproxy", NULL, LF_REOPEN);

    if (cfs.glog == NULL) {

        err(1, "can't initialize logging subsystem");

        /* NOTREACHED */

    }

 #ifdef RTPP_CHECK_LEAKS

    rtpp_memdeb_setlog(MEMDEB_SYM, cfs.glog);

    rtpp_memdeb_approve(MEMDEB_SYM, "_rtpp_log_open", 1, "Referenced by memdeb itself");

 #endif

    _sig_cf = &cfs;

    atexit(rtpp_glog_fin);

    init_config(&cfs, argc, argv);

    cfs.sessions_ht = rtpp_hash_table_ctor(rtpp_ht_key_str_t, 0);

    if (cfs.sessions_ht == NULL) {

        err(1, "can't allocate memory for the hash table");

         /* NOTREACHED */

    }

    cfs.rtp_streams_wrt = rtpp_weakref_ctor();

    if (cfs.rtp_streams_wrt == NULL) {

        err(1, "can't allocate memory for the RTP streams weakref table");

         /* NOTREACHED */

    }

    cfs.rtcp_streams_wrt = rtpp_weakref_ctor();

    if (cfs.rtcp_streams_wrt == NULL) {