/*
* Things that need to happen immediately after connection initiation should go here.
*/
void
check_connection_established_dowork (struct context *c)
{
if (event_timeout_trigger (&c->c2.wait_for_connect, &c->c2.timeval, ETT_DEFAULT))
{
if (CONNECTION_ESTABLISHED (c))
{
#if P2MP
/* if --pull was specified, send a push request to server */
if (c->c2.tls_multi && c->options.pull)
{
#ifdef ENABLE_MANAGEMENT
if (management)
{
management_set_state (management,
OPENVPN_STATE_GET_CONFIG,
NULL,
0,
0);
}
#endif
/* send push request in 1 sec */
event_timeout_init (&c->c2.push_request_interval, 1, now);
reset_coarse_timers (c);
}
else
#endif
{
do_up (c, false, 0);
}
event_timeout_clear (&c->c2.wait_for_connect);
}
}
}
void
check_add_routes_dowork (struct context *c)
{
if (test_routes (c->c1.route_list, c->c1.tuntap))
{
check_add_routes_action (c, false);
}
else if (event_timeout_trigger (&c->c2.route_wakeup_expire, &c->c2.timeval, ETT_DEFAULT))
{
check_add_routes_action (c, true);
}
else
{
msg (D_ROUTE, "Route: Waiting for TUN/TAP interface to come up...");
if (c->c1.tuntap)
{
if (!tun_standby (c->c1.tuntap))
{
register_signal (c, SIGHUP, "ip-fail");
c->persist.restart_sleep_seconds = 10;
#ifdef WIN32
show_routes (M_INFO|M_NOPREFIX);
show_adapters (M_INFO|M_NOPREFIX);
#endif
}
}
update_time ();
if (c->c2.route_wakeup.n != 1)
event_timeout_init (&c->c2.route_wakeup, 1, now);
event_timeout_reset (&c->c2.ping_rec_interval);
}
}
int main(void)
{
puts("[START] event test application.\n");
event_queue_t queue = { .waiter = (thread_t *)sched_active_thread };
printf("posting 0x%08x\n", (unsigned)&event);
event_post(&queue, &event);
printf("posting 0x%08x\n", (unsigned)&event2);
event_post(&queue, &event2);
printf("canceling 0x%08x\n", (unsigned)&event2);
event_cancel(&queue, &event2);
printf("posting custom event\n");
event_post(&queue, (event_t *)&custom_event);
event_timeout_t event_timeout;
printf("posting timed callback with timeout 1sec\n");
event_timeout_init(&event_timeout, &queue, (event_t *)&event_callback);
before = xtimer_now_usec();
event_timeout_set(&event_timeout, 100000LU);
printf("launching event queue\n");
event_loop(&queue);
return 0;
}
/*
* Schedule a signal n_seconds from now.
*/
void
schedule_exit (struct context *c, const int n_seconds, const int signal)
{
tls_set_single_session (c->c2.tls_multi);
update_time ();
reset_coarse_timers (c);
event_timeout_init (&c->c2.scheduled_exit, n_seconds, now);
c->c2.scheduled_exit_signal = signal;
msg (D_SCHED_EXIT, "Delayed exit in %d seconds", n_seconds);
}
static void
process_explicit_exit_notification_init(struct context *c)
{
msg(M_INFO, "SIGTERM received, sending exit notification to peer");
event_timeout_init(&c->c2.explicit_exit_notification_interval, 1, 0);
reset_coarse_timers(c);
signal_reset(c->sig);
halt_non_edge_triggered_signals();
c->c2.explicit_exit_notification_time_wait = now;
}
void
pf_check_reload(struct context *c)
{
const int slow_wakeup = 15;
const int fast_wakeup = 1;
const int wakeup_transition = 60;
bool reloaded = false;
if (c->c2.pf.enabled
&& c->c2.pf.filename
&& event_timeout_trigger(&c->c2.pf.reload, &c->c2.timeval, ETT_DEFAULT))
{
platform_stat_t s;
if (!platform_stat(c->c2.pf.filename, &s))
{
if (s.st_mtime > c->c2.pf.file_last_mod)
{
struct pf_set *pfs = pf_init_from_file(c->c2.pf.filename);
if (pfs)
{
if (c->c2.pf.pfs)
{
pf_destroy(c->c2.pf.pfs);
}
c->c2.pf.pfs = pfs;
reloaded = true;
if (pf_kill_test(pfs))
{
c->sig->signal_received = SIGTERM;
c->sig->signal_text = "pf-kill";
}
}
c->c2.pf.file_last_mod = s.st_mtime;
}
}
{
int wakeup = slow_wakeup;
if (!c->c2.pf.pfs && c->c2.pf.n_check_reload < wakeup_transition)
{
wakeup = fast_wakeup;
}
event_timeout_init(&c->c2.pf.reload, wakeup, now);
reset_coarse_timers(c);
c->c2.pf.n_check_reload++;
}
}
#ifdef ENABLE_DEBUG
if (reloaded && check_debug_level(D_PF_DEBUG))
{
pf_context_print(&c->c2.pf, "pf_check_reload", D_PF_DEBUG);
}
#endif
}
void
pf_init_context(struct context *c)
{
struct gc_arena gc = gc_new();
#ifdef PLUGIN_PF
if (plugin_defined(c->plugins, OPENVPN_PLUGIN_ENABLE_PF))
{
const char *pf_file = create_temp_file(c->options.tmp_dir, "pf", &gc);
if (pf_file)
{
setenv_str(c->c2.es, "pf_file", pf_file);
if (plugin_call(c->plugins, OPENVPN_PLUGIN_ENABLE_PF, NULL, NULL, c->c2.es) == OPENVPN_PLUGIN_FUNC_SUCCESS)
{
event_timeout_init(&c->c2.pf.reload, 1, now);
c->c2.pf.filename = string_alloc(pf_file, &c->c2.gc);
c->c2.pf.enabled = true;
#ifdef ENABLE_DEBUG
if (check_debug_level(D_PF_DEBUG))
{
pf_context_print(&c->c2.pf, "pf_init_context#1", D_PF_DEBUG);
}
#endif
}
else
{
msg(M_WARN, "WARNING: OPENVPN_PLUGIN_ENABLE_PF disabled");
}
}
}
#endif /* ifdef PLUGIN_PF */
#ifdef MANAGEMENT_PF
if (!c->c2.pf.enabled && management_enable_pf(management))
{
c->c2.pf.enabled = true;
#ifdef ENABLE_DEBUG
if (check_debug_level(D_PF_DEBUG))
{
pf_context_print(&c->c2.pf, "pf_init_context#2", D_PF_DEBUG);
}
#endif
}
#endif
gc_free(&gc);
}
struct status_output *
status_open(const char *filename,
const int refresh_freq,
const int msglevel,
const struct virtual_output *vout,
const unsigned int flags)
{
struct status_output *so = NULL;
if (filename || msglevel >= 0 || vout)
{
ALLOC_OBJ_CLEAR(so, struct status_output);
so->flags = flags;
so->msglevel = msglevel;
so->vout = vout;
so->fd = -1;
buf_reset(&so->read_buf);
event_timeout_clear(&so->et);
if (filename)
{
switch (so->flags)
{
case STATUS_OUTPUT_WRITE:
so->fd = platform_open(filename,
O_CREAT | O_TRUNC | O_WRONLY,
S_IRUSR | S_IWUSR);
break;
case STATUS_OUTPUT_READ:
so->fd = platform_open(filename,
O_RDONLY,
S_IRUSR | S_IWUSR);
break;
case STATUS_OUTPUT_READ|STATUS_OUTPUT_WRITE:
so->fd = platform_open(filename,
O_CREAT | O_RDWR,
S_IRUSR | S_IWUSR);
break;
default:
ASSERT(0);
}
if (so->fd >= 0)
{
so->filename = string_alloc(filename, NULL);
set_cloexec(so->fd);
/* allocate read buffer */
if (so->flags & STATUS_OUTPUT_READ)
{
so->read_buf = alloc_buf(512);
}
}
else
{
msg(M_WARN, "Note: cannot open %s for %s", filename, print_status_mode(so->flags));
so->errors = true;
}
}
else
{
so->flags = STATUS_OUTPUT_WRITE;
}
if ((so->flags & STATUS_OUTPUT_WRITE) && refresh_freq > 0)
{
event_timeout_init(&so->et, refresh_freq, 0);
}
}
return so;
}
