switch.c File Reference

#include <poll.h>
#include <switch.h>
#include "private/switch_apr_pvt.h"
#include "private/switch_core_pvt.h"

Include dependency graph for switch.c:

Go to the source code of this file.

Macros
#define	_XOPEN_SOURCE   600
#define	PIDFILE   "freeswitch.pid"

Functions
static void	handle_SIGILL (int sig)
static void	handle_SIGTERM (int sig)
static int	freeswitch_kill_background (void)
static int	check_fd (int fd, int ms)
static void	daemonize (int *fds)
static void	reincarnate_handle_sigterm (int sig)
static void	reincarnate_protect (char **argv)
static switch_bool_t	is_option (const char *p)
int	main (int argc, char *argv[])

Variables
static char *	pfile = PIDFILE
static int	system_ready = 0
static pid_t	reincarnate_child = 0
static const char	usage []

Macro Definition Documentation

_XOPEN_SOURCE

#define _XOPEN_SOURCE   600

Definition at line 37 of file switch.c.

PIDFILE

#define PIDFILE   "freeswitch.pid"

Definition at line 56 of file switch.c.

Function Documentation

check_fd()

static int check_fd ( int  fd, int  ms  )

static

Definition at line 230 of file switch.c.

Referenced by daemonize().

{
        struct pollfd pfds[2] = { { 0 } };
        int s, r = 0;

        pfds[0].fd = fd;
        pfds[0].events = POLLIN | POLLERR;
        s = poll(pfds, 1, ms);

        if (s == 0 || s == -1) {
                r = s;
        } else {
                r = -1;

                if ((pfds[0].revents & POLLIN)) {
                        if (read(fd, &r, sizeof(r)) > -1) {
                                (void)write(fd, &r, sizeof(r));
                        }
                }
        }

        return r;
}

daemonize()

static void daemonize ( int *  fds )

static

Definition at line 254 of file switch.c.

References check_fd(), switch_assert, switch_fork(), and system_ready.

Referenced by main().

{
        int fd;
        pid_t pid;
        unsigned int sanity = 60;

        if (!fds) {
                switch (fork()) {
                case 0:         /* child process */
                        break;
                case -1:
                        fprintf(stderr, "Error Backgrounding (fork)! %d - %s\n", errno, strerror(errno));
                        exit(EXIT_SUCCESS);
                        break;
                default:        /* parent process */
                        exit(EXIT_SUCCESS);
                }

                if (setsid() < 0) {
                        fprintf(stderr, "Error Backgrounding (setsid)! %d - %s\n", errno, strerror(errno));
                        exit(EXIT_SUCCESS);
                }
        }

        pid = switch_fork();

        switch (pid) {
        case 0:         /* child process */
                if (fds) {
                        close(fds[0]);
                }
                break;
        case -1:
                fprintf(stderr, "Error Backgrounding (fork2)! %d - %s\n", errno, strerror(errno));
                exit(EXIT_SUCCESS);
                break;
        default:        /* parent process */
                fprintf(stderr, "%d Backgrounding.\n", (int) pid);

                if (fds) {
                        char *o;

                        close(fds[1]);

                        if ((o = getenv("FREESWITCH_BG_TIMEOUT"))) {
                                int tmp = atoi(o);
                                if (tmp > 0) {
                                        sanity = tmp;
                                }
                        }

                        do {
                                system_ready = check_fd(fds[0], 2000);

                                if (system_ready == 0) {
                                        printf("FreeSWITCH[%d] Waiting for background process pid:%d to be ready.....\n", (int)getpid(), (int) pid);
                                }

                        } while (--sanity && system_ready == 0);

                        shutdown(fds[0], 2);
                        close(fds[0]);
                        fds[0] = -1;


                        if (system_ready < 0) {
                                printf("FreeSWITCH[%d] Error starting system! pid:%d\n", (int)getpid(), (int) pid);
                                kill(pid, 9);
                                exit(EXIT_FAILURE);
                        }

                        printf("FreeSWITCH[%d] System Ready pid:%d\n", (int) getpid(), (int) pid);
                }

                exit(EXIT_SUCCESS);
        }

        if (fds) {
                setsid();
        }
        /* redirect std* to null */
        fd = open("/dev/null", O_RDONLY);
        switch_assert( fd >= 0 );
        if (fd != 0) {
                dup2(fd, 0);
                close(fd);
        }

        fd = open("/dev/null", O_WRONLY);
        switch_assert( fd >= 0 );
        if (fd != 1) {
                dup2(fd, 1);
                close(fd);
        }

        fd = open("/dev/null", O_WRONLY);
        switch_assert( fd >= 0 );
        if (fd != 2) {
                dup2(fd, 2);
                close(fd);
        }
        return;
}

freeswitch_kill_background()

static int freeswitch_kill_background ( void  )

static

Definition at line 104 of file switch.c.

References FALSE, memset(), path, pfile, switch_directories::run_dir, SCF_CALIBRATE_CLOCK, SCF_NONE, SCF_USE_AUTO_NAT, SCF_USE_CLOCK_RT, SCF_USE_NAT_MAPPING, SCF_USE_SQL, SWITCH_CHANNEL_LOG, switch_core_destroy(), switch_core_init_and_modload(), switch_core_set_globals(), SWITCH_FALSE, SWITCH_GLOBAL_dirs, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PATH_SEPARATOR, switch_snprintf(), and SWITCH_STATUS_SUCCESS.

Referenced by main().

{
        FILE *f;                                        /* FILE handle to open the pid file */
        char path[PATH_MAX] = "";               /* full path of the PID file */
        pid_t pid = 0;                          /* pid from the pid file */

        /* set the globals so we can use the global paths. */
        switch_core_set_globals();

        /* get the full path of the pid file. */
        switch_snprintf(path, sizeof(path), "%s%s%s", SWITCH_GLOBAL_dirs.run_dir, SWITCH_PATH_SEPARATOR, pfile);

        /* open the pid file */
        if ((f = fopen(path, "r")) == 0) {
                /* pid file does not exist */
                fprintf(stderr, "Cannot open pid file %s.\n", path);
                return 255;
        }

        /* pull the pid from the file */
        if (fscanf(f, "%d", (int *) (intptr_t) & pid) != 1) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to get the pid!\n");
        }

        /* if we have a valid pid */
        if (pid > 0) {

                /* kill the freeswitch running at the pid we found */
                fprintf(stderr, "Killing: %d\n", (int) pid);
#ifdef WIN32
                /* for windows we need the event to signal for shutting down a background FreeSWITCH */
                snprintf(path, sizeof(path), "Global\\Freeswitch.%d", pid);

                /* open the event so we can signal it */
                shutdown_event = OpenEvent(EVENT_MODIFY_STATE, FALSE, path);

                /* did we successfully open the event */
                if (!shutdown_event) {
                        /* we can't get the event, so we can't signal the process to shutdown */
                        fprintf(stderr, "ERROR: Can't Shutdown: %d\n", (int) pid);
                } else {
                        /* signal the event to shutdown */
                        SetEvent(shutdown_event);
                        /* cleanup */
                        CloseHandle(shutdown_event);
                }
#else
                /* for unix, send the signal to kill. */
                kill(pid, SIGTERM);
#endif
        }

        /* be nice and close the file handle to the pid file */
        fclose(f);

        return 0;
}

handle_SIGILL()

static void handle_SIGILL ( int  sig )

static

Definition at line 85 of file switch.c.

References SCSC_SHUTDOWN, and switch_core_session_ctl().

Referenced by main().

{
        int32_t arg = 0;
        if (sig) {}
        /* send shutdown signal to the freeswitch core */
        switch_core_session_ctl(SCSC_SHUTDOWN, &arg);
        return;
}

handle_SIGTERM()

static void handle_SIGTERM ( int  sig )

static

Definition at line 94 of file switch.c.

References SCSC_SHUTDOWN_ELEGANT, and switch_core_session_ctl().

Referenced by main().

{
        int32_t arg = 0;
        if (sig) {}
        /* send shutdown signal to the freeswitch core */
        switch_core_session_ctl(SCSC_SHUTDOWN_ELEGANT, &arg);
        return;
}

is_option()

static switch_bool_t is_option ( const char *  p )

static

Check if value string starts with "-"

Definition at line 481 of file switch.c.

Referenced by fct_clp__parse(), and main().

{
        /* skip whitespaces */
        while ((*p == 13) || (*p == 10) || (*p == 9) || (*p == 32) || (*p == 11)) p++;
        return (p[0] == '-');
}

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 490 of file switch.c.

References switch_directories::base_dir, buf, switch_directories::cache_dir, switch_directories::certs_dir, change_user_group(), switch_directories::conf_dir, switch_filenames::conf_name, daemonize(), switch_directories::db_dir, freeswitch_kill_background(), switch_directories::grammar_dir, handle_SIGILL(), handle_SIGTERM(), switch_directories::htdocs_dir, is_option(), switch_directories::log_dir, memset(), switch_directories::mod_dir, pfile, pool, switch_directories::recordings_dir, reincarnate_protect(), switch_directories::run_dir, SCF_CALIBRATE_CLOCK, SCF_USE_AUTO_NAT, SCF_USE_CLOCK_RT, SCF_USE_HEAVY_TIMING, SCF_USE_NAT_MAPPING, SCF_USE_SQL, SCF_USE_WIN32_MONOTONIC, SCF_VG, switch_directories::script_dir, set_auto_priority(), set_low_priority(), set_normal_priority(), set_realtime_priority(), switch_directories::sounds_dir, switch_directories::storage_dir, switch_copy_string(), switch_core_destroy(), switch_core_init_and_modload(), switch_core_runtime_loop(), switch_core_set_globals(), switch_core_set_process_privileges(), switch_core_setrlimits(), SWITCH_DEFAULT_DIR_PERMS, switch_dir_make_recursive(), SWITCH_FALSE, switch_file_close(), switch_file_lock(), switch_file_open(), switch_file_read(), switch_file_write(), SWITCH_FLOCK_EXCLUSIVE, SWITCH_FLOCK_NONBLOCK, SWITCH_FOPEN_CREATE, SWITCH_FOPEN_READ, SWITCH_FOPEN_TRUNCATE, SWITCH_FOPEN_WRITE, SWITCH_FPROT_UREAD, SWITCH_FPROT_UWRITE, SWITCH_GLOBAL_dirs, SWITCH_GLOBAL_filenames, SWITCH_PATH_SEPARATOR, switch_separate_string(), switch_sleep(), switch_snprintf(), SWITCH_STATUS_RESTART, SWITCH_STATUS_SUCCESS, switch_strlen_zero, SWITCH_SYSTEM_THREAD_STACKSIZE, SWITCH_THREAD_STACKSIZE, SWITCH_TRUE, switch_version_full(), switch_version_revision_human(), switch_directories::temp_dir, and usage.

{
        char pid_path[PATH_MAX] = "";   /* full path to the pid file */
        char pid_buffer[32] = "";       /* pid string */
        char old_pid_buffer[32] = { 0 };        /* pid string */
        switch_size_t pid_len, old_pid_len;
        const char *err = NULL;         /* error value for return from freeswitch initialization */
#ifndef WIN32
        switch_bool_t nf = SWITCH_FALSE;                                /* TRUE if we are running in nofork mode */
        switch_bool_t do_wait = SWITCH_FALSE;
        char *runas_user = NULL;
        char *runas_group = NULL;
        switch_bool_t reincarnate = SWITCH_FALSE, reincarnate_reexec = SWITCH_FALSE;
        int fds[2] = { 0, 0 };
#else
        const switch_bool_t nf = SWITCH_TRUE;                /* On Windows, force nf to true*/
        switch_bool_t win32_service = SWITCH_FALSE;
#endif
        switch_bool_t nc = SWITCH_FALSE;                                /* TRUE if we are running in noconsole mode */
        switch_bool_t elegant_term = SWITCH_FALSE;
        pid_t pid = 0;
        int i, x;
        char *opts;
        char opts_str[1024] = "";
        char *local_argv[1024] = { 0 };
        int local_argc = argc;
        char *arg_argv[128] = { 0 };
        int alt_dirs = 0, alt_base = 0, log_set = 0, run_set = 0, do_kill = 0;
        int priority = 0;
#if (defined(__SVR4) && defined(__sun))
        switch_core_flag_t flags = SCF_USE_SQL | SCF_CALIBRATE_CLOCK | SCF_USE_CLOCK_RT;
#else
        switch_core_flag_t flags = SCF_USE_SQL | SCF_USE_AUTO_NAT | SCF_USE_NAT_MAPPING | SCF_CALIBRATE_CLOCK | SCF_USE_CLOCK_RT;
#endif
        int ret = 0;
        switch_status_t destroy_status;
        switch_file_t *fd;
        switch_memory_pool_t *pool = NULL;
#ifdef HAVE_SETRLIMIT
#ifndef FS_64BIT
        switch_bool_t waste = SWITCH_FALSE;
#endif
#endif

        for (x = 0; x < argc; x++) {
                local_argv[x] = argv[x];
        }

        if ((opts = getenv("FREESWITCH_OPTS"))) {
                strncpy(opts_str, opts, sizeof(opts_str) - 1);
                i = switch_separate_string(opts_str, ' ', arg_argv, (sizeof(arg_argv) / sizeof(arg_argv[0])));
                for (x = 0; x < i; x++) {
                        local_argv[local_argc++] = arg_argv[x];
                }
        }

        if (local_argv[0] && strstr(local_argv[0], "freeswitchd")) {
                nc = SWITCH_TRUE;
        }

        // disable auto nat, use -nat to enable it
        flags &= ~SCF_USE_AUTO_NAT;

        for (x = 1; x < local_argc; x++) {

                if (switch_strlen_zero(local_argv[x]))
                        continue;

                if (!strcmp(local_argv[x], "-help") || !strcmp(local_argv[x], "-h") || !strcmp(local_argv[x], "-?")) {
                        printf("%s\n", usage);
                        exit(EXIT_SUCCESS);
                }
#ifdef WIN32
                if (x == 1 && !strcmp(local_argv[x], "-service")) {
                        /* New installs will always have the service name specified, but keep a default for compat */
                        x++;
                        if (!switch_strlen_zero(local_argv[x])) {
                                switch_copy_string(service_name, local_argv[x], SERVICENAME_MAXLEN);
                        } else {
                                switch_copy_string(service_name, SERVICENAME_DEFAULT, SERVICENAME_MAXLEN);
                        }

                        win32_service = SWITCH_TRUE;
                        continue;
                }

                else if (x == 1 && !strcmp(local_argv[x], "-install")) {
                        char servicePath[PATH_MAX];
                        char exePath[PATH_MAX];
                        SC_HANDLE hService;
                        SC_HANDLE hSCManager;
                        SERVICE_DESCRIPTION desc;
                        desc.lpDescription = "The FreeSWITCH service.";

                        x++;
                        if (!switch_strlen_zero(local_argv[x])) {
                                switch_copy_string(service_name, local_argv[x], SERVICENAME_MAXLEN);
                        } else {
                                switch_copy_string(service_name, SERVICENAME_DEFAULT, SERVICENAME_MAXLEN);
                        }

                        GetModuleFileName(NULL, exePath, sizeof(exePath));
                        snprintf(servicePath, sizeof(servicePath), "%s -service %s", exePath, service_name);

                        /* Perform service installation */

                        hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
                        if (!hSCManager) {
                                fprintf(stderr, "Could not open service manager (%u).\n", GetLastError());
                                exit(EXIT_FAILURE);
                        }

                        hService = CreateService(hSCManager, service_name, service_name, GENERIC_READ | GENERIC_EXECUTE | SERVICE_CHANGE_CONFIG, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_IGNORE,
                                                 servicePath, NULL, NULL, NULL, NULL, /* Service start name */ NULL);
                        if (!hService) {
                                fprintf(stderr, "Error creating freeswitch service (%u).\n", GetLastError());
                                CloseServiceHandle(hSCManager);
                                exit(EXIT_FAILURE);
                        }

                        /* Set desc, and don't care if it succeeds */
                        if (!ChangeServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, &desc)) {
                                fprintf(stderr, "FreeSWITCH installed, but could not set the service description (%u).\n", GetLastError());
                        }

                        CloseServiceHandle(hService);
                        CloseServiceHandle(hSCManager);
                        exit(EXIT_SUCCESS);
                }

                else if (x == 1 && !strcmp(local_argv[x], "-uninstall")) {
                        SC_HANDLE hService;
                        SC_HANDLE hSCManager;
                        BOOL deleted;

                        x++;
                        if (!switch_strlen_zero(local_argv[x])) {
                                switch_copy_string(service_name, local_argv[x], SERVICENAME_MAXLEN);
                        } else {
                                switch_copy_string(service_name, SERVICENAME_DEFAULT, SERVICENAME_MAXLEN);
                        }

                        /* Do the uninstallation */
                        hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
                        if (!hSCManager) {
                                fprintf(stderr, "Could not open service manager (%u).\n", GetLastError());
                                exit(EXIT_FAILURE);
                        }

                        hService = OpenService(hSCManager, service_name, DELETE);
                        if (!hService) {
                                fprintf(stderr, "Error opening service (%u).\n", GetLastError());
                                CloseServiceHandle(hSCManager);
                                exit(EXIT_FAILURE);
                        }

                        /* remove the service! */
                        deleted = DeleteService(hService);
                        if (!deleted) {
                                fprintf(stderr, "Error deleting service (%u).\n", GetLastError());
                        }

                        CloseServiceHandle(hService);
                        CloseServiceHandle(hSCManager);
                        exit(deleted ? EXIT_SUCCESS : EXIT_FAILURE);
                }

                else if (!strcmp(local_argv[x], "-monotonic-clock")) {
                        flags |= SCF_USE_WIN32_MONOTONIC;
                }
#else
                else if (!strcmp(local_argv[x], "-u")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "Option '%s' requires an argument!\n", local_argv[x - 1]);
                                exit(EXIT_FAILURE);
                        }
                        runas_user = local_argv[x];
                }

                else if (!strcmp(local_argv[x], "-g")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "Option '%s' requires an argument!\n", local_argv[x - 1]);
                                exit(EXIT_FAILURE);
                        }
                        runas_group = local_argv[x];
                }

                else if (!strcmp(local_argv[x], "-nf")) {
                        nf = SWITCH_TRUE;
                }

                else if (!strcmp(local_argv[x], "-elegant-term")) {
                        elegant_term = SWITCH_TRUE;
                }

                else if (!strcmp(local_argv[x], "-reincarnate")) {
                        reincarnate = SWITCH_TRUE;
                }
                else if (!strcmp(local_argv[x], "-reincarnate-reexec")) {
                        reincarnate = SWITCH_TRUE;
                        reincarnate_reexec = SWITCH_TRUE;
                }
#endif
#ifdef HAVE_SETRLIMIT
                else if (!strcmp(local_argv[x], "-core")) {
                        struct rlimit rlp;
                        memset(&rlp, 0, sizeof(rlp));
                        rlp.rlim_cur = RLIM_INFINITY;
                        rlp.rlim_max = RLIM_INFINITY;
                        setrlimit(RLIMIT_CORE, &rlp);
                }

                else if (!strcmp(local_argv[x], "-waste")) {
#ifndef FS_64BIT
                        fprintf(stderr, "WARNING: Wasting up to 8 megs of memory per thread.\n");
                        sleep(2);
                        waste = SWITCH_TRUE;
#endif
                }

                else if (!strcmp(local_argv[x], "-no-auto-stack")) {
#ifndef FS_64BIT
                        waste = SWITCH_TRUE;
#endif
                }
#endif
                else if (!strcmp(local_argv[x], "-version")) {
                        fprintf(stdout, "FreeSWITCH version: %s (%s)\n", switch_version_full(), switch_version_revision_human());
                        exit(EXIT_SUCCESS);
                }

                else if (!strcmp(local_argv[x], "-hp") || !strcmp(local_argv[x], "-rp")) {
                        priority = 2;
                }

                else if (!strcmp(local_argv[x], "-lp")) {
                        priority = -1;
                }

                else if (!strcmp(local_argv[x], "-np")) {
                        priority = 1;
                }

                else if (!strcmp(local_argv[x], "-nosql")) {
                        flags &= ~SCF_USE_SQL;
                }

                else if (!strcmp(local_argv[x], "-nonat")) {
                        flags &= ~SCF_USE_AUTO_NAT;
                }

                else if (!strcmp(local_argv[x], "-nat")) {
                        flags |= SCF_USE_AUTO_NAT;
                }

                else if (!strcmp(local_argv[x], "-nonatmap")) {
                        flags &= ~SCF_USE_NAT_MAPPING;
                }

                else if (!strcmp(local_argv[x], "-heavy-timer")) {
                        flags |= SCF_USE_HEAVY_TIMING;
                }

                else if (!strcmp(local_argv[x], "-nort")) {
                        flags &= ~SCF_USE_CLOCK_RT;
                }

                else if (!strcmp(local_argv[x], "-nocal")) {
                        flags &= ~SCF_CALIBRATE_CLOCK;
                }

                else if (!strcmp(local_argv[x], "-vg")) {
                        flags |= SCF_VG;
                }

                else if (!strcmp(local_argv[x], "-stop")) {
                        do_kill = SWITCH_TRUE;
                }

                else if (!strcmp(local_argv[x], "-nc")) {
                        nc = SWITCH_TRUE;
                }
#ifndef WIN32
                else if (!strcmp(local_argv[x], "-ncwait")) {
                        nc = SWITCH_TRUE;
                        do_wait = SWITCH_TRUE;
                }
#endif
                else if (!strcmp(local_argv[x], "-c")) {
                        nc = SWITCH_FALSE;
                }

                else if (!strcmp(local_argv[x], "-conf")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -conf you must specify a config directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.conf_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.conf_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.conf_dir, local_argv[x]);
                        alt_dirs++;
                }

                else if (!strcmp(local_argv[x], "-mod")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -mod you must specify a module directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.mod_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.mod_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.mod_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-log")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -log you must specify a log directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.log_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.log_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.log_dir, local_argv[x]);
                        alt_dirs++;
                        log_set = SWITCH_TRUE;
                }

                else if (!strcmp(local_argv[x], "-run")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -run you must specify a pid directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.run_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.run_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.run_dir, local_argv[x]);
                        run_set = SWITCH_TRUE;
                }

                else if (!strcmp(local_argv[x], "-db")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -db you must specify a db directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.db_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.db_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.db_dir, local_argv[x]);
                        alt_dirs++;
                }

                else if (!strcmp(local_argv[x], "-scripts")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -scripts you must specify a scripts directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.script_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.script_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.script_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-htdocs")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -htdocs you must specify a htdocs directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.htdocs_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.htdocs_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.htdocs_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-base")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -base you must specify a base directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.base_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.base_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.base_dir, local_argv[x]);
                        alt_base = 1;
                }

                else if (!strcmp(local_argv[x], "-temp")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -temp you must specify a temp directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.temp_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.temp_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.temp_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-storage")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -storage you must specify a storage directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.storage_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.storage_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.storage_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-cache")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -cache you must specify a cache directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.cache_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.cache_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.cache_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-recordings")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -recordings you must specify a recording directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.recordings_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.recordings_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.recordings_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-grammar")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -grammar you must specify a grammar directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.grammar_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.grammar_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.grammar_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-certs")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -certs you must specify a certificates directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.certs_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.certs_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.certs_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-sounds")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -sounds you must specify a sounds directory\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_dirs.sounds_dir = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_dirs.sounds_dir) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_dirs.sounds_dir, local_argv[x]);
                }

                else if (!strcmp(local_argv[x], "-cfgname")) {
                        x++;
                        if (switch_strlen_zero(local_argv[x]) || is_option(local_argv[x])) {
                                fprintf(stderr, "When using -cfgname you must specify a filename\n");
                                return 255;
                        }

                        SWITCH_GLOBAL_filenames.conf_name = (char *) malloc(strlen(local_argv[x]) + 1);
                        if (!SWITCH_GLOBAL_filenames.conf_name) {
                                fprintf(stderr, "Allocation error\n");
                                return 255;
                        }
                        strcpy(SWITCH_GLOBAL_filenames.conf_name, local_argv[x]);
                }

                /* Unknown option (always last!) */
                else {
                        fprintf(stderr, "Unknown option '%s', see '%s -help' for a list of valid options\n",
                                local_argv[x], local_argv[0]);
                        exit(EXIT_FAILURE);
                }
        }

        if (log_set && !run_set) {
                SWITCH_GLOBAL_dirs.run_dir = (char *) malloc(strlen(SWITCH_GLOBAL_dirs.log_dir) + 1);
                if (!SWITCH_GLOBAL_dirs.run_dir) {
                        fprintf(stderr, "Allocation error\n");
                        return 255;
                }
                strcpy(SWITCH_GLOBAL_dirs.run_dir, SWITCH_GLOBAL_dirs.log_dir);
        }

        if (do_kill) {
                return freeswitch_kill_background();
        }

        if (fspr_initialize() != SWITCH_STATUS_SUCCESS) {
                fprintf(stderr, "FATAL ERROR! Could not initialize APR\n");
                return 255;
        }

        if (alt_dirs && alt_dirs != 3 && !alt_base) {
                fprintf(stderr, "You must specify all or none of -conf, -log, and -db\n");
                return 255;
        }

#ifndef FS_64BIT
#if defined(HAVE_SETRLIMIT) && !defined(__sun)
        if (!waste && !(flags & SCF_VG)) {
                struct rlimit rlp;

                memset(&rlp, 0, sizeof(rlp));
                getrlimit(RLIMIT_STACK, &rlp);

                if (rlp.rlim_cur != SWITCH_THREAD_STACKSIZE) {
                        char buf[1024] = "";
                        int i = 0;

                        memset(&rlp, 0, sizeof(rlp));
                        rlp.rlim_cur = SWITCH_THREAD_STACKSIZE;
                        rlp.rlim_max = SWITCH_SYSTEM_THREAD_STACKSIZE;
                        setrlimit(RLIMIT_STACK, &rlp);

                        fspr_terminate();
                        if (argv) ret = (int) execv(argv[0], argv);

                        for (i = 0; i < argc; i++) {
                                switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%s ", argv[i]);
                        }

                        return system(buf);
                }
        }
#endif
#endif
        signal(SIGILL, handle_SIGILL);
        if (elegant_term) {
                signal(SIGTERM, handle_SIGTERM);
        } else {
                signal(SIGTERM, handle_SIGILL);
        }

#ifndef WIN32
        if (do_wait) {
                if (pipe(fds)) {
                        fprintf(stderr, "System Error!\n");
                        exit(-1);
                }
        }
#endif

        if (nc) {
#ifdef WIN32
                FreeConsole();
#else
                if (!nf) {
                        daemonize(do_wait ? fds : NULL);
                }
#endif
        }
#ifndef WIN32
        if (reincarnate)
                reincarnate_protect(reincarnate_reexec ? argv : NULL);
#endif

        if (switch_core_set_process_privileges() < 0) {
                return 255;
        }

        switch (priority) {
        case 2:
                set_realtime_priority();
                break;
        case 1:
                set_normal_priority();
                break;
        case -1:
                set_low_priority();
                break;
        default:
                set_auto_priority();
                break;
        }

        switch_core_setrlimits();


#ifndef WIN32
        if (runas_user || runas_group) {
                if (change_user_group(runas_user, runas_group) < 0) {
                        fprintf(stderr, "Failed to switch user [%s] / group [%s]\n",
                                switch_strlen_zero(runas_user)  ? "-" : runas_user,
                                switch_strlen_zero(runas_group) ? "-" : runas_group);
                        return 255;
                }
        }
#else
        if (win32_service) {
                /* Attempt to start service */
                SERVICE_TABLE_ENTRY dispatchTable[] = {
                        {service_name, &service_main}
                        ,
                        {NULL, NULL}
                };
                service_flags = flags; /* copy parsed flags for service startup */

                if (StartServiceCtrlDispatcher(dispatchTable) == 0) {
                        /* Not loaded as a service */
                        fprintf(stderr, "Error Freeswitch loaded as a console app with -service option\n");
                        fprintf(stderr, "To install the service load freeswitch with -install\n");
                }
                exit(EXIT_SUCCESS);
        }
#endif

        switch_core_set_globals();

        pid = getpid();

        memset(pid_buffer, 0, sizeof(pid_buffer));
        switch_snprintf(pid_path, sizeof(pid_path), "%s%s%s", SWITCH_GLOBAL_dirs.run_dir, SWITCH_PATH_SEPARATOR, pfile);
        switch_snprintf(pid_buffer, sizeof(pid_buffer), "%d", pid);
        pid_len = strlen(pid_buffer);

        fspr_pool_create(&pool, NULL);

        switch_dir_make_recursive(SWITCH_GLOBAL_dirs.run_dir, SWITCH_DEFAULT_DIR_PERMS, pool);

        if (switch_file_open(&fd, pid_path, SWITCH_FOPEN_READ, SWITCH_FPROT_UREAD | SWITCH_FPROT_UWRITE, pool) == SWITCH_STATUS_SUCCESS) {

                old_pid_len = sizeof(old_pid_buffer) -1;
                switch_file_read(fd, old_pid_buffer, &old_pid_len);
                switch_file_close(fd);
        }

        if (switch_file_open(&fd,
                                                 pid_path,
                                                 SWITCH_FOPEN_WRITE | SWITCH_FOPEN_CREATE | SWITCH_FOPEN_TRUNCATE,
                                                 SWITCH_FPROT_UREAD | SWITCH_FPROT_UWRITE, pool) != SWITCH_STATUS_SUCCESS) {
                fprintf(stderr, "Cannot open pid file %s.\n", pid_path);
                return 255;
        }

        if (switch_file_lock(fd, SWITCH_FLOCK_EXCLUSIVE | SWITCH_FLOCK_NONBLOCK) != SWITCH_STATUS_SUCCESS) {
                fprintf(stderr, "Cannot lock pid file %s.\n", pid_path);
                old_pid_len = strlen(old_pid_buffer);
                if (strlen(old_pid_buffer)) {
                        switch_file_write(fd, old_pid_buffer, &old_pid_len);
                }
                return 255;
        }

        switch_file_write(fd, pid_buffer, &pid_len);

        if (switch_core_init_and_modload(flags, nc ? SWITCH_FALSE : SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                fprintf(stderr, "Cannot Initialize [%s]\n", err);
                return 255;
        }

#ifndef WIN32
        if (do_wait) {
                if (fds[1] > -1) {
                        int v = 1;

                        if (write(fds[1], &v, sizeof(v)) < 0) {
                                fprintf(stderr, "System Error [%s]\n", strerror(errno));
                        } else {
                                (void)read(fds[1], &v, sizeof(v));
                        }

                        shutdown(fds[1], 2);
                        close(fds[1]);
                        fds[1] = -1;
                }
        }
#endif

        if (nc && nf) {
                signal(SIGINT, handle_SIGILL);
        }

        switch_core_runtime_loop(nc);

        destroy_status = switch_core_destroy();

        switch_file_close(fd);
        fspr_pool_destroy(pool);

        if (unlink(pid_path) != 0) {
                fprintf(stderr, "Failed to delete pid file [%s]\n", pid_path);
        }

        if (destroy_status == SWITCH_STATUS_RESTART) {
                char buf[1024] = { 0 };
                int j = 0;

                switch_sleep(1000000);
                if (!argv || !argv[0] || execv(argv[0], argv) == -1) {
                        fprintf(stderr, "Restart Failed [%s] resorting to plan b\n", strerror(errno));
                        for (j = 0; j < argc; j++) {
                                switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%s ", argv[j]);
                        }
                        ret = system(buf);
                }
        }

        return ret;
}

reincarnate_handle_sigterm()

static void reincarnate_handle_sigterm ( int  sig )

static

Definition at line 359 of file switch.c.

References reincarnate_child.

Referenced by reincarnate_protect().

                                                 {
        if (!sig) return;
        if (reincarnate_child) kill(reincarnate_child, sig);
        return;
}

reincarnate_protect()

static void reincarnate_protect ( char **  argv )

static

Definition at line 365 of file switch.c.

References buf, memset(), reincarnate_child, reincarnate_handle_sigterm(), and switch_strerror_r().

Referenced by main().

                                             {
        int i; struct sigaction sa, sa_dfl, sa4_prev, sa15_prev, sa17_prev;
        memset(&sa, 0, sizeof(sa)); memset(&sa_dfl, 0, sizeof(sa_dfl));
        sa.sa_handler = reincarnate_handle_sigterm;
        sa_dfl.sa_handler = SIG_DFL;
 refork:
        if ((i=fork())) { /* parent */
                int s; pid_t r;
                reincarnate_child = i;
                sigaction(SIGILL, &sa, &sa4_prev);
                sigaction(SIGTERM, &sa, &sa15_prev);
                sigaction(SIGCHLD, &sa_dfl, &sa17_prev);
        rewait:
                r = waitpid(i, &s, 0);
                if (r == (pid_t)-1) {
                        if (errno == EINTR) goto rewait;
                        exit(EXIT_FAILURE);
                }
                if (r != i) goto rewait;
                if (WIFEXITED(s)
                        && (WEXITSTATUS(s) == EXIT_SUCCESS
                                || WEXITSTATUS(s) == EXIT_FAILURE)) {
                        exit(WEXITSTATUS(s));
                }
                if (WIFEXITED(s) || WIFSIGNALED(s)) {
                        sigaction(SIGILL, &sa4_prev, NULL);
                        sigaction(SIGTERM, &sa15_prev, NULL);
                        sigaction(SIGCHLD, &sa17_prev, NULL);
                        if (argv) {
                                if (argv[0] && execv(argv[0], argv) == -1) {
                                        char buf[256];
                                        fprintf(stderr, "Reincarnate execv() failed: %d %s\n", errno,
                                                        switch_strerror_r(errno, buf, sizeof(buf)));
                                }
                                fprintf(stderr, "Trying reincarnate-reexec plan B...\n");
                                if (argv[0] && execvp(argv[0], argv) == -1) {
                                        char buf[256];
                                        fprintf(stderr, "Reincarnate execvp() failed: %d %s\n", errno,
                                                        switch_strerror_r(errno, buf, sizeof(buf)));
                                }
                                fprintf(stderr, "Falling back to normal reincarnate behavior...\n");
                                goto refork;
                        } else goto refork;
                }
                goto rewait;
        } else { /* child */
#ifdef __linux__
                prctl(PR_SET_PDEATHSIG, SIGTERM);
#endif
        }
}

Variable Documentation

pfile

char* pfile = PIDFILE

static

Definition at line 57 of file switch.c.

Referenced by freeswitch_kill_background(), and main().

reincarnate_child

pid_t reincarnate_child = 0

static

Definition at line 358 of file switch.c.

Referenced by reincarnate_handle_sigterm(), and reincarnate_protect().

system_ready

int system_ready = 0

static

Definition at line 58 of file switch.c.

Referenced by daemonize().

usage

const char usage[]

static

Definition at line 419 of file switch.c.

Referenced by main(), and switch_limit_usage().