int master_exit(int retval) { cleanup_memory(); #ifdef WIN32 if ( NT_ServiceFlag == TRUE ) { terminate(retval); } #endif #if defined(WANT_CONTRIB) && defined(WITH_MANAGEMENT) #if defined(HAVE_DLOPEN) || defined(WIN32) MasterPluginManager::Shutdown(); #endif #endif // If we're positive that we are going to shut down, // we should clean out the shared port directory if // we created it. std::string dirname; if ( SharedPortEndpoint::CreatedSharedPortDirectory() && SharedPortEndpoint::GetDaemonSocketDir(dirname) ) { TemporaryPrivSentry tps(PRIV_CONDOR); Directory d(dirname.c_str()); d.Remove_Entire_Directory(); if (-1 == rmdir(dirname.c_str())) { dprintf(D_ALWAYS, "ERROR: failed to remove shared port temporary directory: %s (errno=%d).\n", strerror(errno), errno); } } DC_Exit(retval, shutdown_program ); return 1; // just to satisfy vc++ }
/* use for successful exit */ void cleanup(void) { /* No longer write settings here, because we only */ /* want to save settings from certain types of games. */ //write_user_config_file(); cleanup_memory(); // exit(0); }
/* * LAG alarm! -Thoric */ static void caught_alarm( int signum ) { echo_to_all( "&[immortal]Alas, the hideous malevalent entity known only as 'Lag' rises once more!", ECHOTAR_ALL ); bug( "&RALARM CLOCK! In section %s", alarm_section ); if( newdesc ) { FD_CLR( newdesc, &in_set ); FD_CLR( newdesc, &out_set ); FD_CLR( newdesc, &exc_set ); log_string( "clearing newdesc" ); } if( fBootDb ) { log_string( "Terminating program. Infinite loop detected during bootup." ); shutdown_mud( "Infinite loop detected during bootup." ); abort( ); } log_string( "&RPossible infinite loop detected during game operation. Restarting game_loop()." ); signal( SIGALRM, caught_alarm ); // Have to reset the signal handler or the next hit will deadlock game_loop( ); /* * Clean up the loose ends. */ close_mud( ); /* * That's all, folks. */ log_string( "Normal termination of game." ); log_string( "Cleaning up Memory.&d" ); cleanup_memory( ); exit( 0 ); }
static void SegVio( int signum ) { bug( "%s", "}RSEGMENTATION FAULT: Invalid Memory Access&D" ); log_string( lastplayercmd ); if( !pclist.empty( ) ) { list < char_data * >::iterator ich; for( ich = pclist.begin( ); ich != pclist.end( ); ++ich ) { char_data *ch = *ich; if( ch && ch->name && ch->in_room ) log_printf( "%-20s in room: %d", ch->name, ch->in_room->vnum ); } } if( sigsegv == true ) abort( ); else sigsegv = true; ++crash_count; signal( SIGSEGV, SegVio ); // Have to reset the signal handler or the next one raised will crash game_loop( ); // Clean up the loose ends... hey wait... why is this here? Because: When game_loop returns now, it will come here instead of main() close_mud( ); // That's all, folks. log_string( "Normal termination of game." ); log_string( "Cleaning up Memory.&d" ); cleanup_memory( ); exit( 0 ); }
int main(void) { Simulation_Run_Ptr simulation_run; Simulation_Run_Data_Ptr data; /* * Declare and initialize our random number generator seeds defined in * simparameters.h */ unsigned RANDOM_SEEDS[] = {RANDOM_SEED_LIST, 0}; unsigned random_seed; int j=0; /* * Loop for each random number generator seed, doing a separate * simulation_run run for each. */ while ((random_seed = RANDOM_SEEDS[j++]) != 0) { simulation_run = simulation_run_new(); /* Create a new simulation run. */ /* * Create a Simulation_Run_Data object. This will hold all of our user * defined data (declared in main.h). Set the simulation_run data pointer * to our new object. */ data = (Simulation_Run_Data_Ptr) xmalloc(sizeof(Simulation_Run_Data)); simulation_run_set_data(simulation_run, (void*) data); /* * Initialize the simulation_run data variables, declared in main.h. */ data->blip_counter = 0; data->arrival_count = 0; data->number_of_packets_processed = 0; data->accumulated_delay = 0.0; data->random_seed = random_seed; /* * Create the packet buffer and transmission link, declared in main.h. */ data->buffer = fifoqueue_new(); data->link = server_new(); /* * Set the random number generator seed for this run. */ random_generator_initialize(random_seed); /* * Schedule the initial packet arrival for the current clock time (= 0). */ schedule_packet_arrival_event(simulation_run, simulation_run_get_time(simulation_run)); /* * Execute events until we are finished. */ while(data->number_of_packets_processed < RUNLENGTH) { simulation_run_execute_event(simulation_run); } /* * Output results and clean up after ourselves. */ output_results(simulation_run); cleanup_memory(simulation_run); } getchar(); /* Pause before finishing. */ return 0; }
/* use for fail exit */ void cleanup_on_error(void) { cleanup_memory(); exit(1); }
int main( int argc, char **argv ) #endif { struct timeval now_time; int temp = -1, temp2 = -1; bool fCopyOver = false; #if !defined(WIN32) moron_check( ); // Debatable weather or not this is true in WIN32 anyway :) #endif DONT_UPPER = false; num_descriptors = 0; num_logins = 0; dlist.clear( ); mudstrlcpy( lastplayercmd, "No commands issued yet", MIL * 2 ); // Init time. tzset( ); gettimeofday( &now_time, NULL ); current_time = now_time.tv_sec; mudstrlcpy( str_boot_time, c_time( current_time, -1 ), MIL ); /* Records when the mud was last rebooted */ new_pfile_time_t = current_time + 86400; mud_start_time = current_time; // Get the port number. mud_port = 9500; if( argc > 1 ) { if( !is_number( argv[1] ) ) { fprintf( stderr, "Usage: %s [port #]\n", argv[0] ); exit( 1 ); } else if( ( mud_port = atoi( argv[1] ) ) <= 1024 ) { fprintf( stderr, "%s", "Port number must be above 1024.\n" ); exit( 1 ); } if( argv[2] && argv[2][0] ) { fCopyOver = true; control = atoi( argv[3] ); #ifdef IMC temp2 = atoi( argv[4] ); #endif } else fCopyOver = false; } #if defined(WIN32) { /* * Initialise Windows sockets library */ unsigned short wVersionRequested = MAKEWORD( 1, 1 ); WSADATA wsadata; int err; /* * Need to include library: wsock32.lib for Windows Sockets */ err = WSAStartup( wVersionRequested, &wsadata ); if( err ) { fprintf( stderr, "Error %i on WSAStartup\n", err ); exit( 1 ); } /* * standard termination signals */ signal( SIGINT, bailout ); signal( SIGTERM, bailout ); } #endif /* WIN32 */ // Initialize all startup functions of the mud. init_mud( fCopyOver, mud_port, temp, temp2 ); #if !defined(WIN32) /* * Set various signal traps, waiting until after completing all bootup operations * before doing so because crashes during bootup should not be intercepted. Samson 3-11-04 */ signal( SIGTERM, SigTerm ); /* Catch kill signals */ signal( SIGPIPE, SIG_IGN ); signal( SIGALRM, caught_alarm ); signal( SIGUSR1, SigUser1 ); /* Catch user defined signals */ signal( SIGUSR2, SigUser2 ); #endif #ifdef MULTIPORT signal( SIGCHLD, SigChld ); #endif /* * If this setting is active, intercept SIGSEGV and keep the mud running. * Doing so sets a flag variable which if true will cause SegVio to abort() * If game_loop is restarted and makes it through once without crashing again, * then the flag is unset and SIGSEGV will continue to be intercepted. Samson 3-11-04 */ if( sysdata->crashhandler == true ) set_chandler( ); log_string( "No people online yet. Suspending autonomous update handlers." ); // Sick isn't it? The whole game being run inside of one little statement..... :P game_loop( ); // Clean up the loose ends. close_mud( ); // That's all, folks. log_string( "Normal termination of game." ); log_string( "Cleaning up Memory.&d" ); cleanup_memory( ); exit( 0 ); }