isc_result_t
isc_taskpool_create(isc_taskmgr_t *tmgr, isc_mem_t *mctx,
unsigned int ntasks, unsigned int quantum,
isc_taskpool_t **poolp)
{
unsigned int i;
isc_taskpool_t *pool = NULL;
isc_result_t result;
INSIST(ntasks > 0);
/* Allocate the pool structure */
result = alloc_pool(tmgr, mctx, ntasks, quantum, &pool);
if (result != ISC_R_SUCCESS)
return (result);
/* Create the tasks */
for (i = 0; i < ntasks; i++) {
result = isc_task_create(tmgr, quantum, &pool->tasks[i]);
if (result != ISC_R_SUCCESS) {
isc_taskpool_destroy(&pool);
return (result);
}
isc_task_setname(pool->tasks[i], "taskpool", NULL);
}
*poolp = pool;
return (ISC_R_SUCCESS);
}
isc_result_t
isc_taskpool_expand(isc_taskpool_t **sourcep, unsigned int size,
isc_taskpool_t **targetp)
{
isc_result_t result;
isc_taskpool_t *pool;
REQUIRE(sourcep != NULL && *sourcep != NULL);
REQUIRE(targetp != NULL && *targetp == NULL);
pool = *sourcep;
if (size > pool->ntasks) {
isc_taskpool_t *newpool = NULL;
unsigned int i;
/* Allocate a new pool structure */
result = alloc_pool(pool->tmgr, pool->mctx, size,
pool->quantum, &newpool);
if (result != ISC_R_SUCCESS)
return (result);
/* Copy over the tasks from the old pool */
for (i = 0; i < pool->ntasks; i++) {
newpool->tasks[i] = pool->tasks[i];
pool->tasks[i] = NULL;
}
/* Create new tasks */
for (i = pool->ntasks; i < size; i++) {
result = isc_task_create(pool->tmgr, pool->quantum,
&newpool->tasks[i]);
if (result != ISC_R_SUCCESS) {
isc_taskpool_destroy(&newpool);
return (result);
}
isc_task_setname(newpool->tasks[i], "taskpool", NULL);
}
isc_taskpool_destroy(&pool);
pool = newpool;
}
*sourcep = NULL;
*targetp = pool;
return (ISC_R_SUCCESS);
}
int
main(int argc, char *argv[]) {
isc_mem_t *mctx;
isc_boolean_t verbose = ISC_FALSE;
unsigned int workers = 2;
isc_taskmgr_t *taskmgr;
isc_task_t *task;
isc_timermgr_t *timermgr;
dns_view_t *view;
int ch;
isc_socketmgr_t *socketmgr;
dns_dispatchmgr_t *dispatchmgr;
isc_netaddr_t na;
dns_byaddr_t *byaddr;
isc_result_t result;
unsigned int options = 0;
dns_cache_t *cache;
RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);
dns_result_register();
mctx = NULL;
RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
while ((ch = isc_commandline_parse(argc, argv, "nvw:")) != -1) {
switch (ch) {
case 'n':
/*
* We only try nibbles, so do nothing for this option.
*/
break;
case 'v':
verbose = ISC_TRUE;
break;
case 'w':
workers = (unsigned int)atoi(isc_commandline_argument);
break;
}
}
if (verbose) {
printf("%u workers\n", workers);
printf("IPv4: %s\n", isc_result_totext(isc_net_probeipv4()));
printf("IPv6: %s\n", isc_result_totext(isc_net_probeipv6()));
}
taskmgr = NULL;
RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &taskmgr)
== ISC_R_SUCCESS);
task = NULL;
RUNTIME_CHECK(isc_task_create(taskmgr, 0, &task)
== ISC_R_SUCCESS);
isc_task_setname(task, "byaddr", NULL);
dispatchmgr = NULL;
RUNTIME_CHECK(dns_dispatchmgr_create(mctx, NULL, &dispatchmgr)
== ISC_R_SUCCESS);
timermgr = NULL;
RUNTIME_CHECK(isc_timermgr_create(mctx, &timermgr) == ISC_R_SUCCESS);
socketmgr = NULL;
RUNTIME_CHECK(isc_socketmgr_create(mctx, &socketmgr) == ISC_R_SUCCESS);
cache = NULL;
RUNTIME_CHECK(dns_cache_create(mctx, taskmgr, timermgr,
dns_rdataclass_in, "rbt", 0, NULL,
&cache) == ISC_R_SUCCESS);
view = NULL;
RUNTIME_CHECK(dns_view_create(mctx, dns_rdataclass_in, "default",
&view) == ISC_R_SUCCESS);
{
unsigned int attrs;
dns_dispatch_t *disp4 = NULL;
dns_dispatch_t *disp6 = NULL;
if (isc_net_probeipv4() == ISC_R_SUCCESS) {
isc_sockaddr_t any4;
isc_sockaddr_any(&any4);
attrs = DNS_DISPATCHATTR_IPV4 | DNS_DISPATCHATTR_UDP;
RUNTIME_CHECK(dns_dispatch_getudp(dispatchmgr,
socketmgr,
taskmgr, &any4,
512, 6, 1024,
17, 19, attrs,
attrs, &disp4)
== ISC_R_SUCCESS);
INSIST(disp4 != NULL);
}
if (isc_net_probeipv6() == ISC_R_SUCCESS) {
isc_sockaddr_t any6;
isc_sockaddr_any6(&any6);
attrs = DNS_DISPATCHATTR_IPV6 | DNS_DISPATCHATTR_UDP;
RUNTIME_CHECK(dns_dispatch_getudp(dispatchmgr,
socketmgr,
taskmgr, &any6,
512, 6, 1024,
17, 19, attrs,
attrs, &disp6)
== ISC_R_SUCCESS);
INSIST(disp6 != NULL);
}
RUNTIME_CHECK(dns_view_createresolver(view, taskmgr, 10, 1,
socketmgr,
timermgr, 0,
dispatchmgr,
disp4, disp6) ==
ISC_R_SUCCESS);
if (disp4 != NULL)
dns_dispatch_detach(&disp4);
if (disp6 != NULL)
dns_dispatch_detach(&disp6);
}
{
struct in_addr ina;
isc_sockaddr_t sa;
isc_sockaddrlist_t sal;
ISC_LIST_INIT(sal);
ina.s_addr = inet_addr("127.0.0.1");
isc_sockaddr_fromin(&sa, &ina, 53);
ISC_LIST_APPEND(sal, &sa, link);
RUNTIME_CHECK(dns_fwdtable_add(view->fwdtable, dns_rootname,
&sal, dns_fwdpolicy_only)
== ISC_R_SUCCESS);
}
dns_view_setcache(view, cache);
dns_view_freeze(view);
dns_cache_detach(&cache);
printf("address = %s\n", argv[isc_commandline_index]);
na.family = AF_INET;
if (inet_pton(AF_INET, argv[isc_commandline_index],
(char *)&na.type.in) != 1) {
na.family = AF_INET6;
if (inet_pton(AF_INET6, argv[isc_commandline_index],
(char *)&na.type.in6) != 1) {
printf("unknown address format\n");
exit(1);
}
}
result = dns_byaddr_create(mctx, &na, view, options, task,
done, NULL, &byaddr);
if (result != ISC_R_SUCCESS) {
printf("dns_byaddr_create() returned %s\n",
isc_result_totext(result));
RUNTIME_CHECK(0);
}
(void)isc_app_run();
/*
* XXXRTH if we get a control-C before we get to isc_app_run(),
* we're in trouble (because we might try to destroy things before
* they've been created.
*/
dns_view_detach(&view);
isc_task_shutdown(task);
isc_task_detach(&task);
dns_dispatchmgr_destroy(&dispatchmgr);
isc_taskmgr_destroy(&taskmgr);
isc_socketmgr_destroy(&socketmgr);
isc_timermgr_destroy(&timermgr);
if (verbose)
isc_mem_stats(mctx, stdout);
isc_mem_destroy(&mctx);
isc_app_finish();
return (0);
}
int
main(int argc, char *argv[]) {
isc_boolean_t verbose = ISC_FALSE;
unsigned int workers = 2;
isc_timermgr_t *timermgr;
int ch;
isc_socketmgr_t *socketmgr;
dns_dispatchmgr_t *dispatchmgr;
dns_cache_t *cache;
isc_buffer_t b;
RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);
dns_result_register();
mctx = NULL;
RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_entropy_create(mctx, &ectx) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE)
== ISC_R_SUCCESS);
while ((ch = isc_commandline_parse(argc, argv, "d:vw:")) != -1) {
switch (ch) {
case 'd':
level = (unsigned int)atoi(isc_commandline_argument);
break;
case 'v':
verbose = ISC_TRUE;
break;
case 'w':
workers = (unsigned int)atoi(isc_commandline_argument);
break;
}
}
log_init();
if (verbose) {
printf("%u workers\n", workers);
printf("IPv4: %s\n", isc_result_totext(isc_net_probeipv4()));
printf("IPv6: %s\n", isc_result_totext(isc_net_probeipv6()));
}
taskmgr = NULL;
RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &taskmgr) ==
ISC_R_SUCCESS);
task = NULL;
RUNTIME_CHECK(isc_task_create(taskmgr, 0, &task) ==
ISC_R_SUCCESS);
isc_task_setname(task, "byname", NULL);
dispatchmgr = NULL;
RUNTIME_CHECK(dns_dispatchmgr_create(mctx, NULL, &dispatchmgr)
== ISC_R_SUCCESS);
timermgr = NULL;
RUNTIME_CHECK(isc_timermgr_create(mctx, &timermgr) == ISC_R_SUCCESS);
socketmgr = NULL;
RUNTIME_CHECK(isc_socketmgr_create(mctx, &socketmgr) == ISC_R_SUCCESS);
cache = NULL;
RUNTIME_CHECK(dns_cache_create(mctx, taskmgr, timermgr,
dns_rdataclass_in, "rbt", 0, NULL,
&cache) == ISC_R_SUCCESS);
view = NULL;
RUNTIME_CHECK(dns_view_create(mctx, dns_rdataclass_in, "default",
&view) == ISC_R_SUCCESS);
{
unsigned int attrs;
dns_dispatch_t *disp4 = NULL;
dns_dispatch_t *disp6 = NULL;
if (isc_net_probeipv4() == ISC_R_SUCCESS) {
isc_sockaddr_t any4;
isc_sockaddr_any(&any4);
attrs = DNS_DISPATCHATTR_IPV4 | DNS_DISPATCHATTR_UDP;
RUNTIME_CHECK(dns_dispatch_getudp(dispatchmgr,
socketmgr,
taskmgr, &any4,
512, 6, 1024,
17, 19, attrs,
attrs, &disp4)
== ISC_R_SUCCESS);
INSIST(disp4 != NULL);
}
if (isc_net_probeipv6() == ISC_R_SUCCESS) {
isc_sockaddr_t any6;
isc_sockaddr_any6(&any6);
attrs = DNS_DISPATCHATTR_IPV6 | DNS_DISPATCHATTR_UDP;
RUNTIME_CHECK(dns_dispatch_getudp(dispatchmgr,
socketmgr,
taskmgr, &any6,
512, 6, 1024,
17, 19, attrs,
attrs, &disp6)
== ISC_R_SUCCESS);
INSIST(disp6 != NULL);
}
RUNTIME_CHECK(dns_view_createresolver(view, taskmgr, 10, 1,
socketmgr,
timermgr, 0,
dispatchmgr,
disp4, disp6) ==
ISC_R_SUCCESS);
if (disp4 != NULL)
dns_dispatch_detach(&disp4);
if (disp6 != NULL)
dns_dispatch_detach(&disp6);
}
{
struct in_addr ina;
isc_sockaddr_t sa;
isc_sockaddrlist_t sal;
ISC_LIST_INIT(sal);
ina.s_addr = inet_addr("127.0.0.1");
isc_sockaddr_fromin(&sa, &ina, 53);
ISC_LIST_APPEND(sal, &sa, link);
RUNTIME_CHECK(dns_fwdtable_add(view->fwdtable, dns_rootname,
&sal, dns_fwdpolicy_only)
== ISC_R_SUCCESS);
}
dns_view_setcache(view, cache);
dns_view_freeze(view);
dns_cache_detach(&cache);
printf("name = %s\n", argv[isc_commandline_index]);
isc_buffer_init(&b, argv[isc_commandline_index],
strlen(argv[isc_commandline_index]));
isc_buffer_add(&b, strlen(argv[isc_commandline_index]));
dns_fixedname_init(&fixed);
dns_fixedname_init(&target);
RUNTIME_CHECK(dns_name_fromtext(dns_fixedname_name(&fixed), &b,
dns_rootname, 0, NULL) ==
ISC_R_SUCCESS);
RUNTIME_CHECK(isc_app_onrun(mctx, task, run, NULL) == ISC_R_SUCCESS);
(void)isc_app_run();
dns_view_detach(&view);
isc_task_shutdown(task);
isc_task_detach(&task);
dns_dispatchmgr_destroy(&dispatchmgr);
isc_taskmgr_destroy(&taskmgr);
isc_socketmgr_destroy(&socketmgr);
isc_timermgr_destroy(&timermgr);
isc_log_destroy(&lctx);
isc_hash_destroy();
isc_entropy_detach(&ectx);
if (verbose)
isc_mem_stats(mctx, stdout);
isc_mem_destroy(&mctx);
isc_app_finish();
return (0);
}
static isc_result_t
add_listener(ns_server_t *server, ns_statschannel_t **listenerp,
const cfg_obj_t *listen_params, const cfg_obj_t *config,
isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
const char *socktext)
{
isc_result_t result;
ns_statschannel_t *listener;
isc_task_t *task = NULL;
isc_socket_t *sock = NULL;
const cfg_obj_t *allow;
dns_acl_t *new_acl = NULL;
listener = isc_mem_get(server->mctx, sizeof(*listener));
if (listener == NULL)
return (ISC_R_NOMEMORY);
listener->httpdmgr = NULL;
listener->address = *addr;
listener->acl = NULL;
listener->mctx = NULL;
ISC_LINK_INIT(listener, link);
result = isc_mutex_init(&listener->lock);
if (result != ISC_R_SUCCESS) {
isc_mem_put(server->mctx, listener, sizeof(*listener));
return (ISC_R_FAILURE);
}
isc_mem_attach(server->mctx, &listener->mctx);
allow = cfg_tuple_get(listen_params, "allow");
if (allow != NULL && cfg_obj_islist(allow)) {
result = cfg_acl_fromconfig(allow, config, ns_g_lctx,
aclconfctx, listener->mctx, 0,
&new_acl);
} else
result = dns_acl_any(listener->mctx, &new_acl);
if (result != ISC_R_SUCCESS)
goto cleanup;
dns_acl_attach(new_acl, &listener->acl);
dns_acl_detach(&new_acl);
result = isc_task_create(ns_g_taskmgr, 0, &task);
if (result != ISC_R_SUCCESS)
goto cleanup;
isc_task_setname(task, "statchannel", NULL);
result = isc_socket_create(ns_g_socketmgr, isc_sockaddr_pf(addr),
isc_sockettype_tcp, &sock);
if (result != ISC_R_SUCCESS)
goto cleanup;
isc_socket_setname(sock, "statchannel", NULL);
#ifndef ISC_ALLOW_MAPPED
isc_socket_ipv6only(sock, ISC_TRUE);
#endif
result = isc_socket_bind(sock, addr, ISC_SOCKET_REUSEADDRESS);
if (result != ISC_R_SUCCESS)
goto cleanup;
result = isc_httpdmgr_create(server->mctx, sock, task, client_ok,
destroy_listener, listener, ns_g_timermgr,
&listener->httpdmgr);
if (result != ISC_R_SUCCESS)
goto cleanup;
#ifdef HAVE_LIBXML2
isc_httpdmgr_addurl(listener->httpdmgr, "/", render_index, server);
#endif
isc_httpdmgr_addurl(listener->httpdmgr, "/bind9.xsl", render_xsl,
server);
*listenerp = listener;
isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
NS_LOGMODULE_SERVER, ISC_LOG_NOTICE,
"statistics channel listening on %s", socktext);
cleanup:
if (result != ISC_R_SUCCESS) {
if (listener->acl != NULL)
dns_acl_detach(&listener->acl);
DESTROYLOCK(&listener->lock);
isc_mem_putanddetach(&listener->mctx, listener,
sizeof(*listener));
}
if (task != NULL)
isc_task_detach(&task);
if (sock != NULL)
isc_socket_detach(&sock);
return (result);
}
isc_result_t
ns_lwdclientmgr_create(ns_lwreslistener_t *listener, unsigned int nclients,
isc_taskmgr_t *taskmgr)
{
ns_lwresd_t *lwresd = listener->manager;
ns_lwdclientmgr_t *cm;
ns_lwdclient_t *client;
unsigned int i;
isc_result_t result;
cm = isc_mem_get(lwresd->mctx, sizeof(ns_lwdclientmgr_t));
if (cm == NULL)
return (ISC_R_NOMEMORY);
result = isc_mutex_init(&cm->lock);
if (result != ISC_R_SUCCESS)
goto freecm;
cm->listener = NULL;
ns_lwreslistener_attach(listener, &cm->listener);
cm->mctx = lwresd->mctx;
cm->sock = NULL;
isc_socket_attach(listener->sock, &cm->sock);
cm->view = lwresd->view;
cm->lwctx = NULL;
cm->task = NULL;
cm->flags = 0;
ISC_LINK_INIT(cm, link);
ISC_LIST_INIT(cm->idle);
ISC_LIST_INIT(cm->running);
result = lwres_context_create(&cm->lwctx, cm->mctx,
ns__lwresd_memalloc, ns__lwresd_memfree,
LWRES_CONTEXT_SERVERMODE);
if (result != ISC_R_SUCCESS)
goto errout;
for (i = 0; i < nclients; i++) {
client = isc_mem_get(lwresd->mctx, sizeof(ns_lwdclient_t));
if (client != NULL) {
ns_lwdclient_log(50, "created client %p, manager %p",
client, cm);
ns_lwdclient_initialize(client, cm);
}
}
/*
* If we could create no clients, clean up and return.
*/
if (ISC_LIST_EMPTY(cm->idle)) {
result = ISC_R_NOMEMORY;
goto errout;
}
result = isc_task_create(taskmgr, 0, &cm->task);
if (result != ISC_R_SUCCESS)
goto errout;
isc_task_setname(cm->task, "lwdclient", NULL);
/*
* This MUST be last, since there is no way to cancel an onshutdown...
*/
result = isc_task_onshutdown(cm->task, lwdclientmgr_shutdown_callback,
cm);
if (result != ISC_R_SUCCESS)
goto errout;
ns_lwreslistener_linkcm(listener, cm);
return (ISC_R_SUCCESS);
errout:
client = ISC_LIST_HEAD(cm->idle);
while (client != NULL) {
ISC_LIST_UNLINK(cm->idle, client, link);
isc_mem_put(lwresd->mctx, client, sizeof(*client));
client = ISC_LIST_HEAD(cm->idle);
}
if (cm->task != NULL)
isc_task_detach(&cm->task);
if (cm->lwctx != NULL)
lwres_context_destroy(&cm->lwctx);
DESTROYLOCK(&cm->lock);
freecm:
isc_mem_put(lwresd->mctx, cm, sizeof(*cm));
return (result);
}
ATF_TC_BODY(privilege_drop, tc) {
isc_result_t result;
isc_task_t *task1 = NULL, *task2 = NULL;
isc_event_t *event;
int a = -1, b = -1, c = -1, d = -1, e = -1; /* non valid states */
int i = 0;
UNUSED(tc);
counter = 1;
result = isc_mutex_init(&set_lock);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_test_begin(NULL, ISC_TRUE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
#ifdef ISC_PLATFORM_USETHREADS
/*
* Pause the task manager so we can fill up the work queue
* without things happening while we do it.
*/
isc__taskmgr_pause(taskmgr);
#endif
result = isc_task_create(taskmgr, 0, &task1);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_task_setname(task1, "privileged", NULL);
ATF_CHECK(!isc_task_privilege(task1));
isc_task_setprivilege(task1, ISC_TRUE);
ATF_CHECK(isc_task_privilege(task1));
result = isc_task_create(taskmgr, 0, &task2);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_task_setname(task2, "normal", NULL);
ATF_CHECK(!isc_task_privilege(task2));
/* First event: privileged */
event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST,
set_and_drop, &a, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(a, -1);
isc_task_send(task1, &event);
/* Second event: not privileged */
event = isc_event_allocate(mctx, task2, ISC_TASKEVENT_TEST,
set_and_drop, &b, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(b, -1);
isc_task_send(task2, &event);
/* Third event: privileged */
event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST,
set_and_drop, &c, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(c, -1);
isc_task_send(task1, &event);
/* Fourth event: privileged */
event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST,
set_and_drop, &d, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(d, -1);
isc_task_send(task1, &event);
/* Fifth event: not privileged */
event = isc_event_allocate(mctx, task2, ISC_TASKEVENT_TEST,
set_and_drop, &e, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(e, -1);
isc_task_send(task2, &event);
ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_normal);
isc_taskmgr_setmode(taskmgr, isc_taskmgrmode_privileged);
ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_privileged);
#ifdef ISC_PLATFORM_USETHREADS
isc__taskmgr_resume(taskmgr);
#endif
/* We're waiting for all variables to be set. */
while ((a == -1 || b == -1 || c == -1 || d == -1 || e == -1) &&
i++ < 5000) {
#ifndef ISC_PLATFORM_USETHREADS
while (isc__taskmgr_ready(taskmgr))
isc__taskmgr_dispatch(taskmgr);
#endif
isc_test_nap(1000);
}
/*
* We can't guarantee what order the events fire, but
* we do know *exactly one* of the privileged tasks will
* have run in privileged mode...
*/
ATF_CHECK(a == isc_taskmgrmode_privileged ||
c == isc_taskmgrmode_privileged ||
d == isc_taskmgrmode_privileged);
ATF_CHECK(a + c + d == isc_taskmgrmode_privileged);
/* ...and neither of the non-privileged tasks did... */
ATF_CHECK(b == isc_taskmgrmode_normal || e == isc_taskmgrmode_normal);
/* ...but all five of them did run. */
ATF_CHECK_EQ(counter, 6);
ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_normal);
isc_task_destroy(&task1);
ATF_REQUIRE_EQ(task1, NULL);
isc_task_destroy(&task2);
ATF_REQUIRE_EQ(task2, NULL);
isc_test_end();
}
ATF_TC_BODY(privileged_events, tc) {
isc_result_t result;
isc_task_t *task1 = NULL, *task2 = NULL;
isc_event_t *event;
int a = 0, b = 0, c = 0, d = 0, e = 0;
int i = 0;
UNUSED(tc);
counter = 1;
result = isc_mutex_init(&set_lock);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_test_begin(NULL, ISC_TRUE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
#ifdef ISC_PLATFORM_USETHREADS
/*
* Pause the task manager so we can fill up the work queue
* without things happening while we do it.
*/
isc__taskmgr_pause(taskmgr);
#endif
result = isc_task_create(taskmgr, 0, &task1);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_task_setname(task1, "privileged", NULL);
ATF_CHECK(!isc_task_privilege(task1));
isc_task_setprivilege(task1, ISC_TRUE);
ATF_CHECK(isc_task_privilege(task1));
result = isc_task_create(taskmgr, 0, &task2);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_task_setname(task2, "normal", NULL);
ATF_CHECK(!isc_task_privilege(task2));
/* First event: privileged */
event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST,
set, &a, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(a, 0);
isc_task_send(task1, &event);
/* Second event: not privileged */
event = isc_event_allocate(mctx, task2, ISC_TASKEVENT_TEST,
set, &b, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(b, 0);
isc_task_send(task2, &event);
/* Third event: privileged */
event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST,
set, &c, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(c, 0);
isc_task_send(task1, &event);
/* Fourth event: privileged */
event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST,
set, &d, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(d, 0);
isc_task_send(task1, &event);
/* Fifth event: not privileged */
event = isc_event_allocate(mctx, task2, ISC_TASKEVENT_TEST,
set, &e, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(e, 0);
isc_task_send(task2, &event);
ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_normal);
isc_taskmgr_setmode(taskmgr, isc_taskmgrmode_privileged);
ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_privileged);
#ifdef ISC_PLATFORM_USETHREADS
isc__taskmgr_resume(taskmgr);
#endif
/* We're waiting for *all* variables to be set */
while ((a == 0 || b == 0 || c == 0 || d == 0 || e == 0) && i++ < 5000) {
#ifndef ISC_PLATFORM_USETHREADS
while (isc__taskmgr_ready(taskmgr))
isc__taskmgr_dispatch(taskmgr);
#endif
isc_test_nap(1000);
}
/*
* We can't guarantee what order the events fire, but
* we do know the privileged tasks that set a, c, and d
* would have fired first.
*/
ATF_CHECK(a <= 3);
ATF_CHECK(c <= 3);
ATF_CHECK(d <= 3);
/* ...and the non-privileged tasks that set b and e, last */
ATF_CHECK(b >= 4);
ATF_CHECK(e >= 4);
ATF_CHECK_EQ(counter, 6);
isc_task_setprivilege(task1, ISC_FALSE);
ATF_CHECK(!isc_task_privilege(task1));
ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_normal);
isc_task_destroy(&task1);
ATF_REQUIRE_EQ(task1, NULL);
isc_task_destroy(&task2);
ATF_REQUIRE_EQ(task2, NULL);
isc_test_end();
}
