void workerLoop(struct worker* worker) {
event_base_priority_init(worker->event_base, 2);
//Seed event for each fd
int i;
for( i = 0; i < worker->nConnections; i++) {
struct event* ev = event_new(worker->event_base, worker->connections[i]->sock, EV_WRITE|EV_PERSIST, sendCallback, worker);
event_priority_set(ev, 1);
event_add(ev, NULL);
ev = event_new(worker->event_base, worker->connections[i]->sock, EV_READ|EV_PERSIST, receiveCallback, worker);
event_priority_set(ev, 2);
event_add(ev, NULL);
}//End for i
gettimeofday(&(worker->last_write_time), NULL);
printf("starting receive base loop\n");
int error = event_base_loop(worker->event_base, 0);
if(error == -1) {
printf("Error starting libevent\n");
} else if(error == 1) {
printf("No events registered with libevent\n");
}
printf("base loop done\n");
}//End workerLoop()
static int
primwatch_event_initialize(
primwatch_t *primwatch)
{
if ((primwatch->event_base = event_init()) == NULL) {
fprintf(stderr, "can not create event cntext\n");
return 1;
}
if (event_base_priority_init(primwatch->event_base, DEFAULT_EVENT_PRIORITY)) {
fprintf(stderr, "can not initialize event priority\n");
return 1;
}
if (watcher_create(
&primwatch->watcher,
primwatch->event_base,
primwatch->config_manager)) {
fprintf(stderr, "can not create wathcer instance\n");
return 1;
}
if (controller_create(
&primwatch->controller,
primwatch->event_base,
primwatch->watcher)) {
fprintf(stderr, "can not create controller instance\n");
return 1;
}
return 0;
}
static int init_base_ev(pingtun_t *handle) {
handle->base_ev = event_base_new();
if (NULL == handle->base_ev) {
ERR("initializing event base failed");
return -1;
}
if (0 != event_base_priority_init(handle->base_ev, PINGTUN_PRIO_MAX)) {
ERR("failed to set base priority");
return -1;
}
return 0;
}
int
main(int argc, char **argv)
{
struct event ev;
struct event *t1;
event_enable_debug_mode();
fprintf(stderr, "Libevent %s\n", event_get_version());
fflush(stderr);
if (!(base = event_base_new()))
die("event_base_new");
if (event_base_priority_init(base, 8) < 0)
die("event_base_priority_init");
if (event_assign(&ev, base, SIGTERM, EV_SIGNAL|EV_PERSIST, cbfunc, NULL)<0)
die("event_assign");
if (event_priority_set(&ev, SIGPRI) < 0)
die("event_priority_set");
if (event_add(&ev, NULL) < 0)
die("event_add");
fprintf(stderr, "SIGNAL EVENT DEFINED\n");
fflush(stderr);
t1 = (struct event*)malloc(sizeof(struct event));
if (event_assign(t1, base, -1, EV_WRITE, t1func, t1) < 0) {
die("event_assign_term");
}
if (event_priority_set(t1, TERMPRI) < 0) {
die("event_priority_set_term");
}
event_active(t1, EV_WRITE, 1);
fprintf(stderr, "FIRST TERMINATION EVENT DEFINED\n");
fflush(stderr);
/* event_dispatch(base); */
while (run) {
event_base_loop(base, EVLOOP_ONCE);
}
fprintf(stderr, "EXITED LOOP - FREEING BASE\n");
fflush(stderr);
event_base_free(base);
return 0;
}
int event_priority_init (int npri)
{
return event_base_priority_init (ev_x_cur, npri);
}
int API
main (int argc, char *argv[], char *envp[])
{
initalize_syslog ();
struct state state;
/* TODO(wad) EVENT_BASE_FLAG_PRECISE_TIMER | EVENT_BASE_FLAG_PRECISE_TIMER */
struct event_base *base = event_base_new();
if (!base)
{
fatal ("could not allocated new event base");
}
/* Add three priority levels:
* 0 - time saving. Must be done before any other events are handled.
* 1 - network synchronization events
* 2 - any other events (wake, platform, etc)
*/
event_base_priority_init (base, MAX_EVENT_PRIORITIES);
memset (&state, 0, sizeof (state));
set_conf_defaults (&state.opts);
parse_argv (&state.opts, argc, argv);
check_conf (&state);
load_conf (&state.opts);
check_conf (&state);
if (!state.opts.sources)
add_source_to_conf (&state.opts, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_PROXY);
state.base = base;
state.envp = envp;
state.backoff = state.opts.wait_between_tries;
/* TODO(wad) move this into setup_time_setter */
/* grab a handle to /dev/rtc for time-setter. */
if (state.opts.should_sync_hwclock &&
platform->rtc_open(&state.hwclock))
{
pinfo ("can't open hwclock fd");
state.opts.should_sync_hwclock = 0;
}
/* install the SIGCHLD handler for the setter and tlsdate */
if (setup_sigchld_event (&state, 1))
{
error ("Failed to setup SIGCHLD event");
goto out;
}
/* fork off the privileged helper */
info ("spawning time setting helper . . .");
if (setup_time_setter (&state))
{
error ("could not fork privileged coprocess");
goto out;
}
/* release the hwclock now that the time-setter is running. */
if (state.opts.should_sync_hwclock)
{
platform->rtc_close (&state.hwclock);
}
/* drop privileges before touching any untrusted data */
drop_privs_to (state.opts.user, state.opts.group);
/* register a signal handler to save time at shutdown */
if (state.opts.should_save_disk)
{
struct event *event = event_new (base, SIGTERM, EV_SIGNAL|EV_PERSIST,
action_sigterm, &state);
if (!event)
fatal ("Failed to create SIGTERM event");
event_priority_set (event, PRI_SAVE);
event_add (event, NULL);
}
if (state.opts.should_dbus && init_dbus (&state))
{
error ("Failed to initialize DBus");
goto out;
}
/* Register the tlsdate event before any listeners could show up. */
state.events[E_TLSDATE] = event_new (base, -1, EV_TIMEOUT,
action_run_tlsdate, &state);
if (!state.events[E_TLSDATE])
{
error ("Failed to create tlsdate event");
goto out;
}
event_priority_set (state.events[E_TLSDATE], PRI_NET);
/* The timeout and fd will be filled in per-call. */
if (setup_tlsdate_status (&state))
{
error ("Failed to create tlsdate status event");
goto out;
}
/* TODO(wad) Could use a timeout on this to catch setter death? */
/* EV_READ is for truncation/EPIPE notification */
state.events[E_SAVE] = event_new (base, state.setter_save_fd,
EV_READ|EV_WRITE, action_sync_and_save,
&state);
if (!state.events[E_SAVE])
{
error ("Failed to create sync & save event");
goto out;
}
event_priority_set (state.events[E_SAVE], PRI_SAVE);
/* Start by grabbing the system time. */
state.last_sync_type = SYNC_TYPE_RTC;
state.last_time = time (NULL);
/* If possible, grab disk time and check the two. */
if (state.opts.should_load_disk)
{
time_t disk_time = state.last_time;
if (!load_disk_timestamp (state.timestamp_path, &disk_time))
{
info ("disk timestamp available: yes");
if (!is_sane_time (state.last_time) ||
state.last_time < disk_time)
{
state.last_sync_type = SYNC_TYPE_DISK;
state.last_time = disk_time;
}
}
else
{
info ("disk timestamp available: no");
}
}
if (!is_sane_time (state.last_time))
{
state.last_sync_type = SYNC_TYPE_BUILD;
state.last_time = RECENT_COMPILE_DATE + 1;
}
/* Save and announce the initial time source. */
trigger_event (&state, E_SAVE, -1);
info ("initial time sync type: %s", sync_type_str (state.last_sync_type));
/* Initialize platform specific loop behavior */
if (platform_init_cros (&state))
{
error ("Failed to initialize platform code");
goto out;
}
if (setup_event_route_up (&state))
{
error ("Failed to setup route up monitoring");
goto out;
}
if (setup_event_timer_sync (&state))
{
error ("Failed to setup a timer event");
goto out;
}
if (setup_event_timer_continuity (&state))
{
error ("Failed to setup continuity timer");
goto out;
}
/* Add a forced sync event to the event list. */
action_kickoff_time_sync (-1, EV_TIMEOUT, &state);
info ("Entering dispatch . . .");
event_base_dispatch (base);
info ("tlsdated terminating gracefully");
out:
return cleanup_main (&state);
}
verto_ctx *
verto_convert_libevent(struct event_base* base)
{
event_base_priority_init(base, 3);
return verto_convert(libevent, base);
}
int
main(int argc, char **argv)
{
struct event_base *base;
struct evconnlistener *listener;
struct sockaddr_in sin;
struct stat stat = {.pps = 0, .ts = 0};
int port = 9876;
if (argc > 1) {
port = atoi(argv[1]);
}
if (port<=0 || port>65535) {
puts("Invalid port");
return 1;
}
base = event_base_new();
if (!base) {
puts("Couldn't open event base");
return 1;
}
/* Clear the sockaddr before using it, in case there are extra
* platform-specific fields that can mess us up. */
memset(&sin, 0, sizeof(sin));
/* This is an INET address */
sin.sin_family = AF_INET;
/* Listen on 0.0.0.0 */
sin.sin_addr.s_addr = htonl(0);
/* Listen on the given port. */
sin.sin_port = htons(port);
listener = evconnlistener_new_bind(base, accept_conn_cb, &stat,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr*)&sin, sizeof(sin));
if (!listener) {
perror("Couldn't create listener");
return 1;
}
evconnlistener_set_error_cb(listener, accept_error_cb);
event_base_priority_init(base, 4);
struct timeval one_second = {1, 0};
struct event *stats_ev = event_new(base, -1, EV_TIMEOUT|EV_PERSIST, on_stats, &stat);
event_add(stats_ev, &one_second);
event_priority_set(stats_ev, 0);
struct event *sigterm_ev = evsignal_new(base, SIGTERM, handle_SIGTERM, base);
evsignal_add(sigterm_ev, NULL);
event_priority_set(sigterm_ev, 1);
struct event *sigint_ev = evsignal_new(base, SIGINT, handle_SIGINT, base);
evsignal_add(sigint_ev, NULL);
event_priority_set(sigint_ev, 1);
event_base_dispatch(base);
event_free(stats_ev);
event_free(sigterm_ev);
event_free(sigint_ev);
evconnlistener_free(listener);
event_base_free(base);
return 0;
}
