e241a3f4db
The reference counting and isc_timer_attach()/isc_timer_detach()
semantic are actually misleading because it cannot be used under normal
conditions. The usual conditions under which is timer used uses the
object where timer is used as argument to the "timer" itself. This
means that when the caller is using `isc_timer_detach()` it needs the
timer to stop and the isc_timer_detach() does that only if this would be
the last reference. Unfortunately, this also means that if the timer is
attached elsewhere and the timer is fired it will most likely be
use-after-free, because the object used in the timer no longer exists.
Remove the reference counting from the isc_timer unit, remove
isc_timer_attach() function and rename isc_timer_detach() to
isc_timer_destroy() to better reflect how the API needs to be used.
The only caveat is that the already executed event must be destroyed
before the isc_timer_destroy() is called because the timer is no longet
attached to .ev_destroy_arg.
(cherry picked from commit ae01ec2823)
143 lines
3.4 KiB
C
143 lines
3.4 KiB
C
/*
|
|
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
|
|
*
|
|
* SPDX-License-Identifier: MPL-2.0
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
|
|
*
|
|
* See the COPYRIGHT file distributed with this work for additional
|
|
* information regarding copyright ownership.
|
|
*/
|
|
|
|
#include <isc/app.h>
|
|
#include <isc/managers.h>
|
|
#include <isc/mem.h>
|
|
#include <isc/print.h>
|
|
#include <isc/ratelimiter.h>
|
|
#include <isc/task.h>
|
|
#include <isc/time.h>
|
|
#include <isc/timer.h>
|
|
#include <isc/util.h>
|
|
|
|
isc_ratelimiter_t *rlim = NULL;
|
|
isc_nm_t *netmgr = NULL;
|
|
isc_taskmgr_t *taskmgr = NULL;
|
|
isc_timermgr_t *timermgr = NULL;
|
|
isc_task_t *g_task = NULL;
|
|
isc_mem_t *mctx = NULL;
|
|
|
|
static void
|
|
utick(isc_task_t *task, isc_event_t *event);
|
|
static void
|
|
shutdown_rl(isc_task_t *task, isc_event_t *event);
|
|
static void
|
|
shutdown_all(isc_task_t *task, isc_event_t *event);
|
|
|
|
typedef struct {
|
|
int milliseconds;
|
|
void (*fun)(isc_task_t *, isc_event_t *);
|
|
} schedule_t;
|
|
|
|
schedule_t schedule[] = { { 100, utick }, { 200, utick },
|
|
{ 300, utick }, { 3000, utick },
|
|
{ 3100, utick }, { 3200, utick },
|
|
{ 3300, shutdown_rl }, { 5000, utick },
|
|
{ 6000, shutdown_all } };
|
|
|
|
#define NEVENTS (int)(sizeof(schedule) / sizeof(schedule[0]))
|
|
|
|
isc_timer_t *timers[NEVENTS];
|
|
|
|
static void
|
|
ltick(isc_task_t *task, isc_event_t *event) {
|
|
UNUSED(task);
|
|
printf("** ltick%s **\n",
|
|
(event->ev_attributes & ISC_EVENTATTR_CANCELED) != 0 ? " ("
|
|
"canceled"
|
|
")"
|
|
: "");
|
|
isc_event_free(&event);
|
|
}
|
|
|
|
static void
|
|
utick(isc_task_t *task, isc_event_t *event) {
|
|
isc_result_t result;
|
|
UNUSED(task);
|
|
event->ev_action = ltick;
|
|
event->ev_sender = NULL;
|
|
result = isc_ratelimiter_enqueue(rlim, g_task, &event);
|
|
printf("enqueue: %s\n", result == ISC_R_SUCCESS ? "ok" : "failed");
|
|
}
|
|
|
|
static void
|
|
shutdown_rl(isc_task_t *task, isc_event_t *event) {
|
|
UNUSED(task);
|
|
UNUSED(event);
|
|
printf("shutdown ratelimiter\n");
|
|
isc_ratelimiter_shutdown(rlim);
|
|
}
|
|
|
|
static void
|
|
shutdown_all(isc_task_t *task, isc_event_t *event) {
|
|
int i;
|
|
UNUSED(task);
|
|
UNUSED(event);
|
|
printf("shutdown all\n");
|
|
for (i = 0; i < NEVENTS; i++) {
|
|
isc_timer_destroy(&timers[i]);
|
|
}
|
|
|
|
isc_app_shutdown();
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[]) {
|
|
isc_interval_t linterval;
|
|
int i;
|
|
|
|
UNUSED(argc);
|
|
UNUSED(argv);
|
|
|
|
isc_app_start();
|
|
isc_interval_set(&linterval, 1, 0);
|
|
|
|
isc_mem_create(&mctx);
|
|
RUNTIME_CHECK(isc_managers_create(mctx, 3, 0, &netmgr, &taskmgr) ==
|
|
ISC_R_SUCCESS);
|
|
RUNTIME_CHECK(isc_timermgr_create(mctx, &timermgr) == ISC_R_SUCCESS);
|
|
RUNTIME_CHECK(isc_task_create(taskmgr, 0, &g_task) == ISC_R_SUCCESS);
|
|
|
|
RUNTIME_CHECK(isc_ratelimiter_create(mctx, timermgr, g_task, &rlim) ==
|
|
ISC_R_SUCCESS);
|
|
|
|
RUNTIME_CHECK(isc_ratelimiter_setinterval(rlim, &linterval) ==
|
|
ISC_R_SUCCESS);
|
|
|
|
for (i = 0; i < NEVENTS; i++) {
|
|
isc_interval_t uinterval;
|
|
int ms = schedule[i].milliseconds;
|
|
isc_interval_set(&uinterval, ms / 1000, (ms % 1000) * 1000000);
|
|
timers[i] = NULL;
|
|
RUNTIME_CHECK(isc_timer_create(timermgr, isc_timertype_once,
|
|
NULL, &uinterval, g_task,
|
|
schedule[i].fun, NULL,
|
|
&timers[i]) == ISC_R_SUCCESS);
|
|
}
|
|
|
|
isc_app_run();
|
|
|
|
isc_task_destroy(&g_task);
|
|
|
|
isc_ratelimiter_detach(&rlim);
|
|
|
|
isc_timermgr_destroy(&timermgr);
|
|
isc_managers_destroy(&netmgr, &taskmgr);
|
|
|
|
isc_mem_stats(mctx, stdout);
|
|
|
|
isc_app_finish();
|
|
return (0);
|
|
}
|