int main(int UNUSED(argc), char * UNUSED(argv[])) { if ((botinfo = malloc(sizeof(struct botstruct))) == NULL) { fprintf(stderr, "main: Malloc error!\n"); acid_shutdown(-1); } time(&currtime); time(&botinfo->starttime); startup(); if(botinfo->ver == NULL) { botinfo->ver = malloc(50) ; snprintf(botinfo->ver, 50, "Acidblood %s\n",VERSION) ; } /* load user data */ if ((read_user_data()) < 0) { fprintf(stderr, "Error reading in user file.\n"); acid_shutdown(-1); } background() ; while (1) { time(&currtime); CheckConfServers() ; check_connections(); CheckTimers() ; ReapUserList(); } }
/* zeppelin loops here when it is in operational state. The check * against reset variable is probably not needed since select() will * return < 0 when a signal interrupts it. */ static void main_loop(void) { fd_set rfds, cfds; int retval, ret1, ret2, ret3; while(!reset) { retval = ret1 = ret2 = ret3 = 0; FD_ZERO(&rfds); conn_get_fds(&rfds); FD_ZERO(&cfds); conn_get_connecting_fds(&cfds); retval = select(FD_SETSIZE, &rfds, &cfds, NULL, NULL); diag(COMPONENT, DIAG_DEBUG, "main_loop: select returned %d", retval); if (retval < 0) { diag(COMPONENT, DIAG_ERROR, "main_loop: select: %s", strerror(errno)); break; /* leave main_loop */ } if (retval == 0) { /* Timeout, funny, since we have no timers */ continue; } if (FD_ISSET(lec_params.kernel->fd, &rfds)) { ret1 = msg_from_kernel(); FD_CLR(lec_params.kernel->fd, &rfds); } ret2 = complete_connections(&cfds); ret3 = check_connections(&rfds); if (ret1 < 0 || ret2 < 0 || ret3 < 0) break; /* leave main_loop */ } diag(COMPONENT, DIAG_DEBUG, "exiting main_loop"); return; }
int main(int argc, char *argv[]) { #if !defined(NOALARM) struct itimerval new_timer, old_timer; #endif /* !NOALARM */ struct rlimit rlp; #if defined(USE_SIGACTION) struct sigaction sigact; #endif struct sockaddr_in sadd; getrlimit(RLIMIT_NOFILE, &rlp); rlp.rlim_cur = rlp.rlim_max; setrlimit(RLIMIT_NOFILE, &rlp); /* First things first, let the client know we're alive */ write(1, SERVER_CONNECT_MSG, strlen(SERVER_CONNECT_MSG)); /* Need this to keep in sync with the client side * * <start><ident_id><local_port><sin_family><s_addr><sin_port> */ req_size = sizeof(char) + sizeof(ident_identifier) + sizeof(short int) + sizeof(sadd.sin_family) + sizeof(sadd.sin_addr.s_addr) + sizeof(sadd.sin_port); /* Set up signal handling */ #if defined( USE_SIGACTION ) #if defined( USE_SIGEMPTYSET ) sigemptyset(&(sigact.sa_mask)); #if !defined( FREEBSD ) && !defined( GLIBC ) sigact.sa_sigaction = 0; #endif #else sigact.sa_mask = 0; #if defined ( LINUX ) sigact.sa_restorer = (void *) 0; #endif #endif /* USE_SIGEMPTYSET */ sigact.sa_handler = catch_sigterm; sigaction(SIGTERM, &sigact, (struct sigaction *) 0); #if !defined ( NOALARM ) sigact.sa_handler = catch_sigalrm; sigaction(SIGALRM, &sigact, (struct sigaction *) 0); #endif /* !NOALARM */ sigact.sa_handler = SIG_IGN; sigaction(SIGPIPE, &sigact, (struct sigaction *) 0); #else /* !USE_SIGACTION */ signal(SIGTERM, catch_sigterm); #if !defined(NOALARM) signal(SIGALRM, catch_sigalrm); #endif /* !NOALARM */ signal(SIGPIPE, SIG_IGN); #endif /* USE_SIGACTION */ #if !defined(NOALARM) beats_per_second = 5; /* Set up a timer to wake us up now and again */ new_timer.it_interval.tv_sec = 0; new_timer.it_interval.tv_usec = 1000000 / beats_per_second; new_timer.it_value.tv_sec = 0; new_timer.it_value.tv_usec = new_timer.it_interval.tv_usec; if (0 > setitimer(ITIMER_REAL, &new_timer, &old_timer)) { perror("ident"); } #endif /* !NOALARM */ #if defined(HAVE_BZERO) #ifdef SUNOS bzero((char *)&idents_in_progress[0], MAX_IDENTS_IN_PROGRESS * sizeof(ident_request)); #elif OSF bzero((void *)&idents_in_progress[0], MAX_IDENTS_IN_PROGRESS * sizeof(ident_request)); #else bzero(&idents_in_progress[0], MAX_IDENTS_IN_PROGRESS * sizeof(ident_request)); #endif #else /* !HAVE_BZERO */ memset(&idents_in_progress[0], 0, MAX_IDENTS_IN_PROGRESS * sizeof(ident_request)); #endif /* HAVE_BZERO */ /* Now enter the main loop */ status = STATUS_RUNNING; while (status != STATUS_SHUTDOWN) { if (1 == getppid()) { /* If our parent is now PID 1 (init) the talker must have died without * killing us, so we have no business still being here * * time to die... */ exit(0); } check_requests(); check_connections(); #if !defined(NOALARM) sigpause(0); #endif /* !NOALARM */ } return 0; }
// MAIN - you can check out any time you like, but you can never leave int main(int argc, char **argv) { struct timeval time; time_t time_slept=0; time_t processing_time=0, total_processing_time=0; long hotreboot = 0; if( argc > 1 ) { if( !is_number(argv[1]) ) { mudlog("Invalid port number!"); exit(1); } else if( (port = atoi(argv[1])) <= 1024 ) { mudlog("Port must be above 1024!"); exit(1); } if(argc > 2 && !strcmp(argv[2], "hotreboot")) hotreboot = 1; } // test stuff { } get_time(&time); current_time = time.tv_sec; if(!hotreboot) create_host(port); init_mud(hotreboot); while(!mud_shutdown) { // we want the mud to loop no more than (LOOPS) times a second.. but not to loop // (LOOPS) times in 1/10th of a second and then wait for 9/10ths... try to make it even if( tick % LOOPS_PER_SECOND == 0 ) { if( time_slept > 1000000 ) { mudlog("time_slept is over a second (%li) and total processing_time this tick (%li)", time_slept, total_processing_time); // exit(1); } else mudsleep(1000000 - time_slept); time_slept = 0; total_processing_time = 0; } get_time( &time ); processing_time = time.tv_usec; // do all the mud stuff here.... check_connections(); mud_update(); // end mud stuff get_time( &time ); if(time.tv_usec > processing_time) processing_time = time.tv_usec - processing_time; else processing_time = processing_time - time.tv_usec; total_processing_time += processing_time; current_time = time.tv_sec; time_slept += (1000000 / LOOPS_PER_SECOND)-(processing_time); tick++; mudsleep((1000000 / LOOPS_PER_SECOND)-(processing_time)); } close(host); free_mud(); mudlog("Mud terminated normally."); return 1; }