Esempio n. 1
0
bool timer (struct message *m) {
  if (m != NULL) {
    if (verbose_flag)
      printf("timer   receives %d\n", m->type);
    if (m->type == INIT_MESSAGE_TYPE) {
      struct timer_init *init = (struct timer_init*) m->data;
      delay = init->delay;
      verbose_flag = init->verbose_flag;
      int i;
      for (i = 0; i < N_TIMER; i++) {
        back[i] = -1;
      }
    } else if (m->type == ALARM_MESSAGE_TYPE) {
      struct alarm *alrm = (struct alarm *) m->data;
      timer_timeout[alrm->id] = alrm->timeout;
      inbox[alrm->id] = alrm->inbox;
      push_heap(alrm->id);
      check_timers();
    } else {
      assert(m->type == STOP_MESSAGE_TYPE);
    }
  } else {
    if (verbose_flag)
      printf("timer   receives NULL\n");
    // the minimum time that can be asked is MIN(delay, 3*delay) = delay
    int time_to_sleep = delay;
    if (n > 0) {
      time_to_sleep = MIN(time_to_sleep, timer_timeout[top_heap()]);
    }
    int err = usleep(time_to_sleep);
    if (err != 0) {
      myperror("usleep");
    } else {
      check_timers();
    }
  }
  return n == 0;
}
Esempio n. 2
0
int main(void)
{
	unsigned int i;

	init_rand();
	for (i = 0; i < NUM_TIMERS; i++) {
		init_timer(&timers[i], expiry, NULL);
		schedule_timer(&timers[i], random() >> rand_shift);
	}
	count = NUM_TIMERS;
	while(count) {
		check_timers(false);
		stamp++;
	}
	return 0;
}
Esempio n. 3
0
static PyObject*
PyEvents_WaitForEvent(PyObject* unused, PyObject* args)
{
    int nfds;
    fd_set readfds;
    fd_set writefds;
    fd_set errorfds;
    struct timeval timeout;
    unsigned long waittime;
    long milliseconds;
    long result = 0;
    if (!PyArg_ParseTuple(args, "k", &milliseconds)) return NULL;
    waittime = check_timers();
    if (waittime > 0) {
        if (waittime < milliseconds) milliseconds = waittime;
        timeout.tv_sec = milliseconds / 1000;
        timeout.tv_usec = 1000 * (milliseconds % 1000);
        nfds = set_fds(&readfds, &writefds, &errorfds);
        if (select(nfds, &readfds, &writefds, &errorfds, &timeout)==-1)
            return PyErr_SetFromErrno(PyExc_RuntimeError);
    }
    return PyInt_FromLong(result);
}
Esempio n. 4
0
/* Called once a minute. */
static void core_minutely()
{
  check_tcl_time(&nowtm);
  check_timers(&timer);
  flush_and_check_logs(LOGS_MINUTELY);
}
Esempio n. 5
0
/* Called once a second. */
static void core_secondly()
{
  static int cnt = 0;
  int miltime;

  check_timers(&utimer); /* Secondly timers */

  cnt++;
  if (cnt >= 10) { /* Every 10 seconds */
    cnt = 0;
    check_expired_dcc();
    if (con_chan && !backgrd) {
      dprintf(DP_STDOUT, "\033[2J\033[1;1H");
      tell_verbose_status(DP_STDOUT);
      do_module_report(DP_STDOUT, 0, "server");
      do_module_report(DP_STDOUT, 0, "channels");
      tell_mem_status(DP_STDOUT);
    }
  }

  egg_memcpy(&nowtm, localtime(&now), sizeof(struct tm));
  if (nowtm.tm_min != lastmin) {
    int i = 0;

    /* Once a minute */
    lastmin = (lastmin + 1) % 60;
    call_hook(HOOK_MINUTELY);
    check_expired_ignores();
    autolink_cycle(NULL); /* Attempt autolinks. */

    /* In case for some reason more than 1 min has passed: */
    while (nowtm.tm_min != lastmin) {
      /* Timer drift, dammit */
      debug2("timer: drift (lastmin=%d, now=%d)", lastmin, nowtm.tm_min);
      i++;
      lastmin = (lastmin + 1) % 60;
      call_hook(HOOK_MINUTELY);
    }
    if (i > 1)
      putlog(LOG_MISC, "*", "(!) timer drift -- spun %d minutes", i);

    miltime = (nowtm.tm_hour * 100) + nowtm.tm_min;
    if (((int) (nowtm.tm_min / 5) * 5) == nowtm.tm_min) {
      /* 5-minutely. */
      call_hook(HOOK_5MINUTELY);
      check_botnet_pings();
      flush_and_check_logs(LOGS_FIVEMINUTELY);

      /* Is it midnight? */
      if (miltime == MILTIME_MIDNIGHT) {
        char s[25];

        strncpyz(s, ctime(&now), sizeof s);
        putlog(LOG_ALL, "*", "--- %.11s%s", s, s + 20);
        call_hook(HOOK_BACKUP);
        close_logs_at_midnight();
      }
    }

    if (nowtm.tm_min == notify_users_at)
      call_hook(HOOK_HOURLY);

    if (miltime == switch_logfiles_at) {
      call_hook(HOOK_DAILY);
      switch_logs();
    }
  }
}
Esempio n. 6
0
int main(int argc, char *argv[])
{
    mrp_mainloop_t *ml;

    mrp_clear(&cfg);
    parse_cmdline(&cfg, argc, argv);

    mrp_log_set_mask(cfg.log_mask);
    mrp_log_set_target(cfg.log_target);

    ml = mainloop_create(&cfg);

    if (ml == NULL)
        fatal("failed to create main loop.");

    dbus_test.ml = ml;
    setup_dbus_tests(ml);
    ml = dbus_test.ml;

    setup_timers(ml);
    setup_io(ml);
    setup_signals(ml);
    MRP_UNUSED(setup_deferred);   /* XXX TODO: add deferred tests... */

#ifdef GLIB_ENABLED
    if (cfg.mainloop_type != MAINLOOP_GLIB && cfg.mainloop_type != MAINLOOP_QT) {
        if (cfg.ngio > 0 || cfg.ngtimer > 0)
            glib_pump_setup(ml);
    }

    setup_glib_io();
    setup_glib_timers();
#endif

    if (mrp_add_timer(ml, 1000, check_quit, NULL) == NULL)
        fatal("failed to create quit-check timer");

    setup_wakeup(ml);

    mainloop_run(&cfg);

    check_io();
    check_timers();
    check_signals();

#ifdef GLIB_ENABLED
    check_glib_io();
    check_glib_timers();
#endif

    if (dbus_test.client != 0)
        close(dbus_test.pipe[1]);   /* let the client continue */

    check_dbus();

#ifdef GLIB_ENABLED
    if (cfg.mainloop_type != MAINLOOP_GLIB) {
        if (cfg.ngio > 0 || cfg.ngtimer > 0)
            glib_pump_cleanup();
    }
#endif

    cleanup_wakeup();

    mainloop_cleanup(&cfg);
}
Esempio n. 7
0
int start_rendering()
{
	static int done = 0;
	static void * network_thread_data[2] = { NULL, NULL };
	static Uint32 last_frame_and_command_update = 0;

	SDL_Thread *network_thread;
	queue_t *message_queue;

#ifndef WINDOWS
	SDL_EventState(SDL_SYSWMEVENT,SDL_ENABLE);
#endif
	queue_initialise(&message_queue);
	network_thread_data[0] = message_queue;
	network_thread_data[1] = &done;
	network_thread = SDL_CreateThread(get_message_from_server, network_thread_data);

	/* Loop until done. */
	while( !done )
		{
			SDL_Event event;

			// handle SDL events
			in_main_event_loop = 1;
			while( SDL_PollEvent( &event ) )
				{
					done = HandleEvent(&event);
				}
			in_main_event_loop = 0;

			//advance the clock
			cur_time = SDL_GetTicks();

			//check for network data
			if(!queue_isempty(message_queue)) {
				message_t *message;

				while((message = queue_pop(message_queue)) != NULL)
				{
					process_message_from_server(message->data, message->length);
					free(message->data);
					free(message);
				}
			}
#ifdef	OLC
			olc_process();
#endif	//OLC
			my_tcp_flush(my_socket);    // make sure the tcp output buffer is set
			
			if (have_a_map && cur_time > last_frame_and_command_update + 60) {
				LOCK_ACTORS_LISTS();
				next_command();
				UNLOCK_ACTORS_LISTS();
				move_to_next_frame();
				last_frame_and_command_update = cur_time;
			}

			while (cur_time > next_second_time && real_game_second < 59)
			{
				real_game_second += 1;
				new_second();
				next_second_time += 1000;
			}

#ifdef NEW_SOUND
			weather_sound_control();
#endif	//NEW_SOUND

			if(!limit_fps || (cur_time-last_time && 1000/(cur_time-last_time) <= limit_fps))
			{
				weather_update();

                animate_actors();
				//draw everything
				draw_scene();
				last_time=cur_time;
			}
			else {
				SDL_Delay(1);//give up timeslice for anyone else
			}

#ifdef TIMER_CHECK
			//Check the timers to make sure that they are all still alive...
			check_timers();
#endif

			//cache handling
			if(cache_system)cache_system_maint();
			//see if we need to exit
			if(exit_now) {
				done = 1;
				break;
			}
		}
	if(!done) {
		done = 1;
	}
	LOG_INFO("Client closed");
	SDL_WaitThread(network_thread,&done);
	queue_destroy(message_queue);
	if(pm_log.ppl)free_pm_log();

	//save all local data
	save_local_data(NULL, 0);

#ifdef PAWN
	cleanup_pawn ();
#endif

#ifdef NEW_SOUND
	destroy_sound();		// Cleans up physical elements of the sound system and the streams thread
	clear_sound_data();		// Cleans up the config data
#endif // NEW_SOUND
	ec_destroy_all_effects();
	if (have_a_map)
	{
		destroy_map();
		free_buffers();
	}
	unload_questlog();
	save_item_lists();
	free_emotes();
	free_actor_defs();
	free_books();
	free_vars();
	cleanup_rules();
	save_exploration_map();
	cleanup_counters();
	cleanup_chan_names();
	cleanup_hud();
	SDL_RemoveTimer(draw_scene_timer);
	SDL_RemoveTimer(misc_timer);
	end_particles ();
	free_bbox_tree(main_bbox_tree);
	main_bbox_tree = NULL;
	free_astro_buffer();
	free_translations();
	free_skybox();
	/* Destroy our GL context, etc. */
	SDL_QuitSubSystem(SDL_INIT_AUDIO);
	SDL_QuitSubSystem(SDL_INIT_TIMER);
/*#ifdef WINDOWS
	// attempt to restart if requested
	if(restart_required > 0){
		LOG_INFO("Restarting %s", win_command_line);
		SDL_CreateThread(system, win_command_line);
	}
#endif  //WINDOWS
*/
#ifdef NEW_SOUND
	final_sound_exit();
#endif
#ifdef	CUSTOM_UPDATE
	stopp_custom_update();
#endif	/* CUSTOM_UPDATE */
	clear_zip_archives();

	destroy_tcp_out_mutex();

	if (use_frame_buffer) free_reflection_framebuffer();

	printf("doing SDL_Quit\n");
	fflush(stderr);
	SDL_Quit( );
	printf("done SDL_Quit\n");
	fflush(stderr);
	cleanup_mem();
	xmlCleanupParser();
	FreeXML();

	exit_logging();

	return(0);
}
Esempio n. 8
0
//
//
//	Main procedure
//
//
int main(int argc, char **argv) {
    int shutdown = 0;					// Shutdown flag
    struct timer_list timers;				// Timers
    int payload_len;					// length of payload returned
    struct payload_pkt app_data;			// App payload data
    char node_name[HOSTNAME_LEN];			// Node name
    parse_options(argc, argv);				// Parse command line parameters
    debug(DEBUG_ESSENTIAL, "Mesh starting in mode: %d\n", operating_mode);

    initialise_network(sizeof(struct payload_pkt),notify_link_up, notify_link_down);	// Initialise the network details with callbacks
    initialise_timers(&timers);				// and set all timers

    switch (operating_mode) {
    case OPMODE_MASTER:					// Only Master nodes are responsible for broadcasting
	add_timer(TIMER_BROADCAST, 5);			// Set to refresh network in y seconds
	break;

    case OPMODE_SLAVE:
//	add_timer(TIMER_APPLICATION, 15);		// Set to refresh network in y seconds
//	now done when link comes up
	break;
    }
    add_timer(TIMER_STATS, timeto1hour());		// Report Network Efficiency stats hourly

    while (!shutdown) {					// While NOT shutdown
	wait_on_network_timers(&timers); 		// Wait for message or timer expiory

	if (check_network_msg()) {			// If a message is available
	    handle_network_msg(&node_name[0], (char *)&app_data, &payload_len);	// handle the network message
	    handle_app_msg(&app_data, payload_len);			// handle application specific messages
	}
	switch (check_timers(&timers)) {		// check which timer has expired
	case TIMER_BROADCAST:				// On Broadcast timer
	    broadcast_network();			// send out broadcast message to contact other nodes
	    add_timer(TIMER_BROADCAST, 20);		// and set to broadcast again in y seconds
	    break;

	case TIMER_PING:
	    if (check_live_nodes()) {			// On Ping check the network
		add_timer(TIMER_REPLY, 2);		// Expire replies if not received within x secoonds
		add_timer(TIMER_PING, 20);		// and set to Ping again in y seconds
	    }
	    break;

	case TIMER_REPLY:
	    expire_live_nodes();			//  Expire other nodes where reply has timed out
	    break;

	case TIMER_STATS:
	    report_network_stats();			// Report network efficiency stats hourly
	    add_timer(TIMER_STATS, timeto1hour());	// Set to refresh network in 1 hour
	    break;

	case TIMER_PAYLOAD_ACK:
	    timeout_payload();
	    break;

	case TIMER_APPLICATION:
	    handle_app_timer();				// Handle the timer for the App
	    break;

	default:
	    break;
	}
	DEBUG_FUNCTION( DEBUG_DETAIL, display_live_network());
	DEBUG_FUNCTION( DEBUG_DETAIL, display_timers(&timers));
    }
    debug(DEBUG_ESSENTIAL, "Mesh node shut down\n");
    return 0;
}