/* * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application * Copyright (C) 2005/2006, Anthony Minessale II * * Version: MPL 1.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application * * The Initial Developer of the Original Code is * Anthony Minessale II * Portions created by the Initial Developer are Copyright (C) * the Initial Developer. All Rights Reserved. * * Contributor(s): * * Anthony Minessale II * Michael Jerris * * * switch.c -- Main * */ #include //pid filename: Stores the process id of the freeswitch process #define PIDFILE "freeswitch.pid" static char *pfile = PIDFILE; //log filename: Filename of the freeswitch log file to be used if we are in background mode #define LOGFILE "freeswitch.log" static char *lfile = LOGFILE; //If we are a windows service, what should we be called #define SERVICENAME "Freeswitch" //Picky compiler #ifdef __ICC #pragma warning (disable:167) #endif #ifdef WIN32 #include #include //event to signal shutdown (for you unix people, this is like a pthread_cond) static HANDLE shutdown_event; #endif //signal handler for when freeswitch is running in background mode. //signal triggers the shutdown of freeswitch static void handle_SIGHUP(int sig) { uint32_t arg = 0; if(sig); //send shutdown signal to the freeswitch core switch_core_session_ctl(SCSC_SHUTDOWN, &arg); return; } //kill a freeswitch process running in background mode static int freeswitch_kill_background() { FILE *f; //FILE handle to open the pid file char path[256] = ""; //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. snprintf(path, sizeof(path), "%s%s%s", SWITCH_GLOBAL_dirs.log_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 fscanf(f, "%d", &pid); //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 freewitc 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 sucessfully 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; } #ifdef WIN32 //we need these vars to handle the service SERVICE_STATUS_HANDLE hStatus; SERVICE_STATUS status; //Handler function for service start/stop from the service void WINAPI ServiceCtrlHandler( DWORD control ) { switch( control ) { case SERVICE_CONTROL_SHUTDOWN: case SERVICE_CONTROL_STOP: //Shutdown freeswitch switch_core_destroy(0); //set service status valuse status.dwCurrentState = SERVICE_STOPPED; status.dwWin32ExitCode = 0; status.dwCheckPoint = 0; status.dwWaitHint = 0; break; case SERVICE_CONTROL_INTERROGATE: // we already set the service status every time it changes. // if there are other times we change it and don't update, we should do so here break; } SetServiceStatus( hStatus, &status ); } //the main service entry point void WINAPI service_main( DWORD numArgs, char **args ) { const char *err = NULL; //error value for return from freeswitch initialization // we have to initialize the service-specific stuff memset( &status, 0, sizeof(SERVICE_STATUS) ); status.dwServiceType = SERVICE_WIN32; status.dwCurrentState = SERVICE_START_PENDING; status.dwControlsAccepted = SERVICE_ACCEPT_STOP; //register our handler for service control messages hStatus = RegisterServiceCtrlHandler( SERVICENAME, &ServiceCtrlHandler ); //update the service status SetServiceStatus( hStatus, &status ); //run freeswitch with elevated priority set_high_priority(); //attempt to initialize freeswitch and load modules if (switch_core_init_and_modload(lfile, &err) != SWITCH_STATUS_SUCCESS) { //freeswitch did not start sucessfully status.dwCurrentState = SERVICE_STOPPED; } else { //freeswitch started status.dwCurrentState = SERVICE_RUNNING; } //update the service status SetServiceStatus( hStatus, &status ); } #endif //the main application entry point int main(int argc, char *argv[]) { char pid_path[256] = ""; // full path to the pid file const char *err = NULL; // error value for return from freeswitch initialization int bg = 0; // TRUE if we are running in background mode int vg = 0; // TRUE if we are running in vg mode FILE *f; // file handle to the pid file pid_t pid = 0; // int x; // int die = 0; // #ifdef WIN32 SERVICE_TABLE_ENTRY dispatchTable[] = { { SERVICENAME, &service_main }, { NULL, NULL } }; #endif for (x = 1; x < argc; x++) { #ifdef WIN32 if (x == 1) { if (argv[x] && !strcmp(argv[x], "-service")) { 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(0); } if (argv[x] && !strcmp(argv[x], "-install")) { char exePath[1024]; char servicePath[1024]; SC_HANDLE handle = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); GetModuleFileName( NULL, exePath, 1024 ); snprintf(servicePath, sizeof(servicePath), "%s -service", exePath); CreateService( handle, SERVICENAME, SERVICENAME, GENERIC_READ | GENERIC_EXECUTE, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_IGNORE, servicePath, NULL, NULL, NULL, NULL, NULL ); exit(0); } if (argv[x] && !strcmp(argv[x], "-uninstall")) { SC_HANDLE handle = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS ); SC_HANDLE service = OpenService( handle, SERVICENAME, DELETE ); if( service != NULL ) { // remove the service! DeleteService( service ); } exit(0); } } #endif if (argv[x] && !strcmp(argv[x], "-hp")) { set_high_priority(); } if (argv[x] && !strcmp(argv[x], "-stop")) { die++; } if (argv[x] && !strcmp(argv[x], "-nc")) { bg++; } if (argv[x] && !strcmp(argv[x], "-vg")) { vg++; } } if (die) { return freeswitch_kill_background(); } if (bg) { signal(SIGHUP, handle_SIGHUP); signal(SIGTERM, handle_SIGHUP); #ifdef WIN32 FreeConsole(); #else if ((pid = fork())) { fprintf(stderr, "%d Backgrounding.\n", (int)pid); exit(0); } #endif } if (switch_core_init_and_modload(bg ? lfile : NULL, &err) != SWITCH_STATUS_SUCCESS) { fprintf(stderr, "Cannot Initilize [%s]\n", err); return 255; } snprintf(pid_path, sizeof(pid_path), "%s%s%s", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, pfile); if ((f = fopen(pid_path, "w")) == 0) { fprintf(stderr, "Cannot open pid file %s.\n", pid_path); return 255; } fprintf(f, "%d", pid = getpid()); fclose(f); switch_core_runtime_loop(bg); return switch_core_destroy(vg); }