mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-28 13:08:06 +00:00
Code Issues Releases Wiki Activity

convert sender, arg, action, etc. to ev_sender, ev_arg, ev_action, etc.

Browse Source
This commit is contained in:
Michael Graff 2000-04-17 19:22:44 +00:00
parent 0d89e0d55c
commit e44487bfc2
46 changed files with 426 additions and 418 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
bin/lwresd/client.c
View File

@ -145,7 +145,7 @@ process_request(client_t *client)
void void
client_recv(isc_task_t *task, isc_event_t *ev) client_recv(isc_task_t *task, isc_event_t *ev)
{ {
client_t *client = ev->arg; client_t *client = ev->ev_arg;
clientmgr_t *cm = client->clientmgr; clientmgr_t *cm = client->clientmgr;
isc_socketevent_t *dev = (isc_socketevent_t *)ev; isc_socketevent_t *dev = (isc_socketevent_t *)ev;
@ -242,10 +242,10 @@ client_start_recv(clientmgr_t *cm)
void void
client_shutdown(isc_task_t *task, isc_event_t *ev) client_shutdown(isc_task_t *task, isc_event_t *ev)
{ {
clientmgr_t *cm = ev->arg; clientmgr_t *cm = ev->ev_arg;
REQUIRE(task == cm->task); REQUIRE(task == cm->task);
REQUIRE(ev->type == LWRD_SHUTDOWN); REQUIRE(ev->ev_type == LWRD_SHUTDOWN);
REQUIRE((cm->flags & CLIENTMGR_FLAG_SHUTTINGDOWN) == 0); REQUIRE((cm->flags & CLIENTMGR_FLAG_SHUTTINGDOWN) == 0);
DP(50, "Got shutdown event, task %p", task); DP(50, "Got shutdown event, task %p", task);
@ -295,7 +295,7 @@ client_state_idle(client_t *client)
void void
client_send(isc_task_t *task, isc_event_t *ev) client_send(isc_task_t *task, isc_event_t *ev)
{ {
client_t *client = ev->arg; client_t *client = ev->ev_arg;
clientmgr_t *cm = client->clientmgr; clientmgr_t *cm = client->clientmgr;
isc_socketevent_t *dev = (isc_socketevent_t *)ev; isc_socketevent_t *dev = (isc_socketevent_t *)ev;

10
bin/lwresd/process_gabn.c
View File

@ -278,13 +278,13 @@ store_realname(client_t *client)
static void static void
process_gabn_finddone(isc_task_t *task, isc_event_t *ev) process_gabn_finddone(isc_task_t *task, isc_event_t *ev)
{ {
client_t *client = ev->arg; client_t *client = ev->ev_arg;
isc_eventtype_t result; isc_eventtype_t evtype;
isc_boolean_t claimed; isc_boolean_t claimed;
DP(50, "Find done for task %p, client %p", task, client); DP(50, "Find done for task %p, client %p", task, client);
result = ev->type; evtype = ev->ev_type;
isc_event_free(&ev); isc_event_free(&ev);
/* /*
@ -292,7 +292,7 @@ process_gabn_finddone(isc_task_t *task, isc_event_t *ev)
* right now, so we can render things. * right now, so we can render things.
*/ */
claimed = ISC_FALSE; claimed = ISC_FALSE;
if (result == DNS_EVENT_ADBNOMOREADDRESSES) { if (evtype == DNS_EVENT_ADBNOMOREADDRESSES) {
if (NEED_V4(client)) { if (NEED_V4(client)) {
client->v4find = client->find; client->v4find = client->find;
claimed = ISC_TRUE; claimed = ISC_TRUE;
@ -328,7 +328,7 @@ process_gabn_finddone(isc_task_t *task, isc_event_t *ev)
* We have some new information we can gather. Run off and fetch * We have some new information we can gather. Run off and fetch
* it. * it.
*/ */
if (result == DNS_EVENT_ADBMOREADDRESSES) { if (evtype == DNS_EVENT_ADBMOREADDRESSES) {
start_find(client); start_find(client);
return; return;
} }

6
bin/lwresd/process_gnba.c
View File

@ -57,12 +57,12 @@ byaddr_done(isc_task_t *task, isc_event_t *event)
isc_uint16_t naliases; isc_uint16_t naliases;
isc_stdtime_t now; isc_stdtime_t now;
(void)task; UNUSED(task);
lwb.base = NULL; lwb.base = NULL;
client = event->arg; client = event->ev_arg;
cm = client->clientmgr; cm = client->clientmgr;
INSIST(client->byaddr == event->sender); INSIST(client->byaddr == event->ev_sender);
bevent = (dns_byaddrevent_t *)event; bevent = (dns_byaddrevent_t *)event;
gnba = &client->gnba; gnba = &client->gnba;

30
bin/named/client.c
View File

@ -460,8 +460,8 @@ client_shutdown(isc_task_t *task, isc_event_t *event) {
ns_client_t *client; ns_client_t *client;
REQUIRE(event != NULL); REQUIRE(event != NULL);
REQUIRE(event->type == ISC_TASKEVENT_SHUTDOWN); REQUIRE(event->ev_type == ISC_TASKEVENT_SHUTDOWN);
client = event->arg; client = event->ev_arg;
REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(NS_CLIENT_VALID(client));
REQUIRE(task == client->task); REQUIRE(task == client->task);
@ -476,7 +476,7 @@ client_shutdown(isc_task_t *task, isc_event_t *event) {
} }
client->newstate = NS_CLIENTSTATE_FREED; client->newstate = NS_CLIENTSTATE_FREED;
(void) exit_check(client); (void)exit_check(client);
} }
@ -579,8 +579,8 @@ client_senddone(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *) event; isc_socketevent_t *sevent = (isc_socketevent_t *) event;
REQUIRE(sevent != NULL); REQUIRE(sevent != NULL);
REQUIRE(sevent->type == ISC_SOCKEVENT_SENDDONE); REQUIRE(sevent->ev_type == ISC_SOCKEVENT_SENDDONE);
client = sevent->arg; client = sevent->ev_arg;
REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(NS_CLIENT_VALID(client));
REQUIRE(task == client->task); REQUIRE(task == client->task);
@ -812,7 +812,7 @@ client_request(isc_task_t *task, isc_event_t *event) {
isc_boolean_t ra; /* Recursion available. */ isc_boolean_t ra; /* Recursion available. */
REQUIRE(event != NULL); REQUIRE(event != NULL);
client = event->arg; client = event->ev_arg;
REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(NS_CLIENT_VALID(client));
REQUIRE(task == client->task); REQUIRE(task == client->task);
@ -826,7 +826,7 @@ client_request(isc_task_t *task, isc_event_t *event) {
RWLOCK(&ns_g_server->conflock, isc_rwlocktype_read); RWLOCK(&ns_g_server->conflock, isc_rwlocktype_read);
dns_zonemgr_lockconf(ns_g_server->zonemgr, isc_rwlocktype_read); dns_zonemgr_lockconf(ns_g_server->zonemgr, isc_rwlocktype_read);
if (event->type == DNS_EVENT_DISPATCH) { if (event->ev_type == DNS_EVENT_DISPATCH) {
INSIST(!TCP_CLIENT(client)); INSIST(!TCP_CLIENT(client));
devent = (dns_dispatchevent_t *)event; devent = (dns_dispatchevent_t *)event;
REQUIRE(client->dispentry != NULL); REQUIRE(client->dispentry != NULL);
@ -835,7 +835,7 @@ client_request(isc_task_t *task, isc_event_t *event) {
result = devent->result; result = devent->result;
client->peeraddr = devent->addr; client->peeraddr = devent->addr;
client->peeraddr_valid = ISC_TRUE; client->peeraddr_valid = ISC_TRUE;
if ((devent->attributes & DNS_DISPATCHATTR_PKTINFO) != 0) { if ((devent->attributes & ISC_SOCKEVENTATTR_PKTINFO) != 0) {
client->attributes |= NS_CLIENTATTR_PKTINFO; client->attributes |= NS_CLIENTATTR_PKTINFO;
client->pktinfo = devent->pktinfo; client->pktinfo = devent->pktinfo;
} else { } else {
@ -843,8 +843,8 @@ client_request(isc_task_t *task, isc_event_t *event) {
} }
} else { } else {
INSIST(TCP_CLIENT(client)); INSIST(TCP_CLIENT(client));
REQUIRE(event->type == DNS_EVENT_TCPMSG); REQUIRE(event->ev_type == DNS_EVENT_TCPMSG);
REQUIRE(event->sender == &client->tcpmsg); REQUIRE(event->ev_sender == &client->tcpmsg);
buffer = &client->tcpmsg.buffer; buffer = &client->tcpmsg.buffer;
result = client->tcpmsg.result; result = client->tcpmsg.result;
INSIST(client->nreads == 1); INSIST(client->nreads == 1);
@ -1069,9 +1069,9 @@ client_timeout(isc_task_t *task, isc_event_t *event) {
ns_client_t *client; ns_client_t *client;
REQUIRE(event != NULL); REQUIRE(event != NULL);
REQUIRE(event->type == ISC_TIMEREVENT_LIFE || REQUIRE(event->ev_type == ISC_TIMEREVENT_LIFE ||
event->type == ISC_TIMEREVENT_IDLE); event->ev_type == ISC_TIMEREVENT_IDLE);
client = event->arg; client = event->ev_arg;
REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(NS_CLIENT_VALID(client));
REQUIRE(task == client->task); REQUIRE(task == client->task);
REQUIRE(client->timer != NULL); REQUIRE(client->timer != NULL);
@ -1233,11 +1233,11 @@ client_read(ns_client_t *client) {
static void static void
client_newconn(isc_task_t *task, isc_event_t *event) { client_newconn(isc_task_t *task, isc_event_t *event) {
ns_client_t *client = event->arg; ns_client_t *client = event->ev_arg;
isc_socket_newconnev_t *nevent = (isc_socket_newconnev_t *)event; isc_socket_newconnev_t *nevent = (isc_socket_newconnev_t *)event;
isc_result_t result; isc_result_t result;
REQUIRE(event->type == ISC_SOCKEVENT_NEWCONN); REQUIRE(event->ev_type == ISC_SOCKEVENT_NEWCONN);
REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(NS_CLIENT_VALID(client));
REQUIRE(client->task == task); REQUIRE(client->task == task);

4
bin/named/query.c
View File

@ -1653,8 +1653,8 @@ query_resume(isc_task_t *task, isc_event_t *event) {
* Resume a query after recursion. * Resume a query after recursion.
*/ */
REQUIRE(event->type == DNS_EVENT_FETCHDONE); REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE);
client = devent->arg; client = devent->ev_arg;
REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(NS_CLIENT_VALID(client));
REQUIRE(task == client->task); REQUIRE(task == client->task);
REQUIRE(RECURSING(client)); REQUIRE(RECURSING(client));

8
bin/named/server.c
View File

@ -1076,7 +1076,7 @@ scan_interfaces(ns_server_t *server) {
*/ */
static void static void
interface_timer_tick(isc_task_t *task, isc_event_t *event) { interface_timer_tick(isc_task_t *task, isc_event_t *event) {
ns_server_t *server = (ns_server_t *) event->arg; ns_server_t *server = (ns_server_t *) event->ev_arg;
UNUSED(task); UNUSED(task);
isc_event_free(&event); isc_event_free(&event);
RWLOCK(&server->conflock, isc_rwlocktype_write); RWLOCK(&server->conflock, isc_rwlocktype_write);
@ -1390,7 +1390,7 @@ load_zones(ns_server_t *server, isc_boolean_t stop) {
static void static void
run_server(isc_task_t *task, isc_event_t *event) { run_server(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
ns_server_t *server = (ns_server_t *) event->arg; ns_server_t *server = (ns_server_t *)event->ev_arg;
UNUSED(task); UNUSED(task);
@ -1424,7 +1424,7 @@ run_server(isc_task_t *task, isc_event_t *event) {
static void static void
shutdown_server(isc_task_t *task, isc_event_t *event) { shutdown_server(isc_task_t *task, isc_event_t *event) {
dns_view_t *view, *view_next; dns_view_t *view, *view_next;
ns_server_t *server = (ns_server_t *) event->arg; ns_server_t *server = (ns_server_t *)event->ev_arg;
UNUSED(task); UNUSED(task);
@ -1580,7 +1580,7 @@ fatal(char *msg, isc_result_t result) {
static void static void
ns_server_reload(isc_task_t *task, isc_event_t *event) { ns_server_reload(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
ns_server_t *server = (ns_server_t *)event->arg; ns_server_t *server = (ns_server_t *)event->ev_arg;
UNUSED(task); UNUSED(task);
result = load_configuration(ns_g_conffile, server, ISC_FALSE); result = load_configuration(ns_g_conffile, server, ISC_FALSE);

18
bin/named/update.c
View File

@ -1753,14 +1753,14 @@ send_update_event(ns_client_t *client, dns_zone_t *zone) {
evclient = NULL; evclient = NULL;
ns_client_attach(client, &evclient); ns_client_attach(client, &evclient);
event->arg = evclient; event->ev_arg = evclient;
dns_zone_gettask(zone, &zonetask); dns_zone_gettask(zone, &zonetask);
isc_task_send(zonetask, (isc_event_t **) &event); isc_task_send(zonetask, (isc_event_t **)&event);
failure: failure:
if (event != NULL) if (event != NULL)
isc_event_free((isc_event_t **) &event); isc_event_free((isc_event_t **)&event);
return (result); return (result);
} }
@ -1855,7 +1855,7 @@ update_action(isc_task_t *task, isc_event_t *event)
{ {
update_event_t *uev = (update_event_t *) event; update_event_t *uev = (update_event_t *) event;
dns_zone_t *zone = uev->zone; dns_zone_t *zone = uev->zone;
ns_client_t *client = (ns_client_t *) event->arg; ns_client_t *client = (ns_client_t *)event->ev_arg;
isc_result_t result; isc_result_t result;
dns_db_t *db = NULL; dns_db_t *db = NULL;
@ -1871,7 +1871,7 @@ update_action(isc_task_t *task, isc_event_t *event)
dns_name_t *zonename; dns_name_t *zonename;
dns_ssutable_t *ssutable = NULL; dns_ssutable_t *ssutable = NULL;
INSIST(event->type == DNS_EVENT_UPDATE); INSIST(event->ev_type == DNS_EVENT_UPDATE);
dns_diff_init(mctx, &diff); dns_diff_init(mctx, &diff);
dns_diff_init(mctx, &temp); dns_diff_init(mctx, &temp);
@ -2294,8 +2294,8 @@ update_action(isc_task_t *task, isc_event_t *event)
isc_task_detach(&task); isc_task_detach(&task);
uev->result = result; uev->result = result;
uev->type = DNS_EVENT_UPDATEDONE; uev->ev_type = DNS_EVENT_UPDATEDONE;
uev->action = updatedone_action; uev->ev_action = updatedone_action;
isc_task_send(client->task, &event); isc_task_send(client->task, &event);
INSIST(event == NULL); INSIST(event == NULL);
} }
@ -2304,9 +2304,9 @@ static void
updatedone_action(isc_task_t *task, isc_event_t *event) updatedone_action(isc_task_t *task, isc_event_t *event)
{ {
update_event_t *uev = (update_event_t *) event; update_event_t *uev = (update_event_t *) event;
ns_client_t *client = (ns_client_t *) event->arg; ns_client_t *client = (ns_client_t *) event->ev_arg;
INSIST(event->type == DNS_EVENT_UPDATEDONE); INSIST(event->ev_type == DNS_EVENT_UPDATEDONE);
INSIST(task == client->task); INSIST(task == client->task);
respond(client, uev->result); respond(client, uev->result);

14
bin/named/xfrout.c
View File

@ -15,7 +15,7 @@
* SOFTWARE. * SOFTWARE.
*/ */
/* $Id: xfrout.c,v 1.56 2000/04/11 19:08:32 gson Exp $ */ /* $Id: xfrout.c,v 1.57 2000/04/17 19:22:00 explorer Exp $ */
#include <config.h> #include <config.h>
@ -1431,15 +1431,19 @@ xfrout_ctx_destroy(xfrout_ctx_t **xfrp) {
static void static void
xfrout_senddone(isc_task_t *task, isc_event_t *event) { xfrout_senddone(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sev = (isc_socketevent_t *) event; isc_socketevent_t *sev = (isc_socketevent_t *)event;
xfrout_ctx_t *xfr = (xfrout_ctx_t *) event->arg; xfrout_ctx_t *xfr = (xfrout_ctx_t *)event->ev_arg;
isc_result_t evresult = sev->result; isc_result_t evresult = sev->result;
UNUSED(task); UNUSED(task);
INSIST(event->type == ISC_SOCKEVENT_SENDDONE);
INSIST(event->ev_type == ISC_SOCKEVENT_SENDDONE);
isc_event_free(&event); isc_event_free(&event);
xfr->sends--; xfr->sends--;
INSIST(xfr->sends == 0); INSIST(xfr->sends == 0);
(void) isc_timer_touch(xfr->client->timer);
(void)isc_timer_touch(xfr->client->timer);
if (xfr->shuttingdown == ISC_TRUE) { if (xfr->shuttingdown == ISC_TRUE) {
xfrout_maybe_destroy(xfr); xfrout_maybe_destroy(xfr);
} else if (evresult != ISC_R_SUCCESS) { } else if (evresult != ISC_R_SUCCESS) {

6
bin/tests/adb_test.c
View File

@ -138,11 +138,11 @@ lookup_callback(isc_task_t *task, isc_event_t *ev)
{ {
client_t *client; client_t *client;
client = ev->arg; client = ev->ev_arg;
INSIST(client->find == ev->sender); INSIST(client->find == ev->ev_sender);
printf("Task %p got event %p type %08x from %p, client %p\n", printf("Task %p got event %p type %08x from %p, client %p\n",
task, ev, ev->type, client->find, client); task, ev, ev->ev_type, client->find, client);
isc_event_free(&ev); isc_event_free(&ev);

4
bin/tests/byaddr_test.c
View File

@ -60,7 +60,7 @@ done(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
isc_region_t r; isc_region_t r;
REQUIRE(event->type == DNS_EVENT_BYADDRDONE); REQUIRE(event->ev_type == DNS_EVENT_BYADDRDONE);
bevent = (dns_byaddrevent_t *)event; bevent = (dns_byaddrevent_t *)event;
(void)task; (void)task;
@ -86,7 +86,7 @@ done(isc_task_t *task, isc_event_t *event) {
} }
} }
byaddr = event->sender; byaddr = event->ev_sender;
dns_byaddr_destroy(&byaddr); dns_byaddr_destroy(&byaddr);
isc_event_free(&event); isc_event_free(&event);

2
bin/tests/byname_test.c
View File

@ -200,7 +200,7 @@ do_find(isc_boolean_t want_event) {
static void static void
adb_callback(isc_task_t *etask, isc_event_t *event) { adb_callback(isc_task_t *etask, isc_event_t *event) {
unsigned int type = event->type; unsigned int type = event->ev_type;
REQUIRE(etask == task); REQUIRE(etask == task);

6
bin/tests/dispatch_tcp_test.c
View File

@ -124,7 +124,7 @@ void
send_done(isc_task_t *task, isc_event_t *ev_in) send_done(isc_task_t *task, isc_event_t *ev_in)
{ {
isc_socketevent_t *ev = (isc_socketevent_t *)ev_in; isc_socketevent_t *ev = (isc_socketevent_t *)ev_in;
dns_dispentry_t *resp = (dns_dispentry_t *)ev_in->arg; dns_dispentry_t *resp = (dns_dispentry_t *)ev_in->ev_arg;
(void)task; (void)task;
@ -252,7 +252,7 @@ void
got_response(isc_task_t *task, isc_event_t *ev_in) got_response(isc_task_t *task, isc_event_t *ev_in)
{ {
dns_dispatchevent_t *ev = (dns_dispatchevent_t *)ev_in; dns_dispatchevent_t *ev = (dns_dispatchevent_t *)ev_in;
dns_dispentry_t *resp = ev->sender; dns_dispentry_t *resp = ev->ev_sender;
dns_message_t *msg; dns_message_t *msg;
isc_result_t result; isc_result_t result;
@ -283,7 +283,7 @@ void
got_request(isc_task_t *task, isc_event_t *ev_in) got_request(isc_task_t *task, isc_event_t *ev_in)
{ {
dns_dispatchevent_t *ev = (dns_dispatchevent_t *)ev_in; dns_dispatchevent_t *ev = (dns_dispatchevent_t *)ev_in;
dns_dispentry_t *resp = ev->sender; dns_dispentry_t *resp = ev->ev_sender;
static int cnt = 0; static int cnt = 0;
dns_message_t *msg; dns_message_t *msg;
isc_result_t result; isc_result_t result;

6
bin/tests/dispatch_test.c
View File

@ -103,7 +103,7 @@ void
send_done(isc_task_t *task, isc_event_t *ev_in) send_done(isc_task_t *task, isc_event_t *ev_in)
{ {
isc_socketevent_t *ev = (isc_socketevent_t *)ev_in; isc_socketevent_t *ev = (isc_socketevent_t *)ev_in;
clictx_t *cli = (clictx_t *)ev_in->arg; clictx_t *cli = (clictx_t *)ev_in->ev_arg;
(void)task; (void)task;
@ -231,7 +231,7 @@ void
got_response(isc_task_t *task, isc_event_t *ev_in) got_response(isc_task_t *task, isc_event_t *ev_in)
{ {
dns_dispatchevent_t *ev = (dns_dispatchevent_t *)ev_in; dns_dispatchevent_t *ev = (dns_dispatchevent_t *)ev_in;
dns_dispentry_t *resp = ev->sender; dns_dispentry_t *resp = ev->ev_sender;
dns_message_t *msg; dns_message_t *msg;
isc_result_t result; isc_result_t result;
unsigned int cnt; unsigned int cnt;
@ -286,7 +286,7 @@ void
got_request(isc_task_t *task, isc_event_t *ev_in) got_request(isc_task_t *task, isc_event_t *ev_in)
{ {
dns_dispatchevent_t *ev = (dns_dispatchevent_t *)ev_in; dns_dispatchevent_t *ev = (dns_dispatchevent_t *)ev_in;
clictx_t *cli = (clictx_t *)ev_in->arg; clictx_t *cli = (clictx_t *)ev_in->ev_arg;
dns_message_t *msg; dns_message_t *msg;
isc_result_t result; isc_result_t result;
unsigned int cnt; unsigned int cnt;

9
bin/tests/lwresconf_test.c
View File

@ -65,7 +65,6 @@ int
main(int argc, char *argv[]) main(int argc, char *argv[])
{ {
lwres_context_t *ctx; lwres_context_t *ctx;
lwres_conf_t conf;
const char *file = "/etc/resolv.conf"; const char *file = "/etc/resolv.conf";
int ret; int ret;
#ifdef USE_ISC_MEM #ifdef USE_ISC_MEM
@ -91,14 +90,14 @@ main(int argc, char *argv[])
#endif #endif
CHECK(ret, "lwres_context_create"); CHECK(ret, "lwres_context_create");
lwres_conf_init(&conf); lwres_conf_init(ctx);
if (lwres_conf_parse(ctx, file, &conf) == 0) { if (lwres_conf_parse(ctx, file) == 0) {
lwres_conf_print(stderr, &conf); lwres_conf_print(ctx, stderr);
} else { } else {
perror("lwres_conf_parse"); perror("lwres_conf_parse");
} }
lwres_conf_clear(ctx, &conf); lwres_conf_clear(ctx);
lwres_context_destroy(&ctx); lwres_context_destroy(&ctx);
#ifdef USE_ISC_MEM #ifdef USE_ISC_MEM

2
bin/tests/omapi_test.c
View File

@ -531,7 +531,7 @@ do_connect(const char *host, int port) {
static void static void
listen_done(isc_task_t *task, isc_event_t *event) { listen_done(isc_task_t *task, isc_event_t *event) {
omapi_object_t *listener = event->arg; omapi_object_t *listener = event->ev_arg;
UNUSED(task); UNUSED(task);

2
bin/tests/ratelimiter_test.c
View File

@ -45,7 +45,7 @@ utick(isc_task_t *task, isc_event_t *event)
{ {
(void) task; (void) task;
printf("utick\n"); printf("utick\n");
event->action = ltick; event->ev_action = ltick;
isc_ratelimiter_enqueue(rlim, &event); isc_ratelimiter_enqueue(rlim, &event);
} }

9
bin/tests/sdig.c
View File

@ -36,6 +36,8 @@ extern int h_errno;
#include <isc/socket.h> #include <isc/socket.h>
#include <isc/task.h> #include <isc/task.h>
#include <isc/util.h>
#include <dns/types.h> #include <dns/types.h>
#include <dns/message.h> #include <dns/message.h>
#include <dns/name.h> #include <dns/name.h>
@ -187,10 +189,10 @@ recv_done(isc_task_t *task, isc_event_t *event) {
isc_buffer_t *b; isc_buffer_t *b;
isc_result_t result; isc_result_t result;
REQUIRE(event->type == ISC_SOCKEVENT_RECVDONE); REQUIRE(event->ev_type == ISC_SOCKEVENT_RECVDONE);
sevent = (isc_socketevent_t *)event; sevent = (isc_socketevent_t *)event;
(void)task; UNUSED(task);
/* /*
* There will be one buffer (since that is what we put on the list) * There will be one buffer (since that is what we put on the list)
@ -215,7 +217,8 @@ recv_done(isc_task_t *task, isc_event_t *event) {
static void static void
send_done(isc_task_t *task, isc_event_t *event) { send_done(isc_task_t *task, isc_event_t *event) {
(void)task; UNUSED(task);
isc_event_free(&event); isc_event_free(&event);
} }

12
bin/tests/shutdown_test.c
View File

@ -57,7 +57,7 @@ static isc_timermgr_t * timer_manager;
static void static void
t1_shutdown(isc_task_t *task, isc_event_t *event) { t1_shutdown(isc_task_t *task, isc_event_t *event) {
t_info *info = event->arg; t_info *info = event->ev_arg;
printf("task %s (%p) t1_shutdown\n", info->name, task); printf("task %s (%p) t1_shutdown\n", info->name, task);
isc_task_detach(&info->task); isc_task_detach(&info->task);
@ -66,7 +66,7 @@ t1_shutdown(isc_task_t *task, isc_event_t *event) {
static void static void
t2_shutdown(isc_task_t *task, isc_event_t *event) { t2_shutdown(isc_task_t *task, isc_event_t *event) {
t_info *info = event->arg; t_info *info = event->ev_arg;
printf("task %s (%p) t2_shutdown\n", info->name, task); printf("task %s (%p) t2_shutdown\n", info->name, task);
info->exiting = ISC_TRUE; info->exiting = ISC_TRUE;
@ -75,10 +75,10 @@ t2_shutdown(isc_task_t *task, isc_event_t *event) {
static void static void
shutdown_action(isc_task_t *task, isc_event_t *event) { shutdown_action(isc_task_t *task, isc_event_t *event) {
t_info *info = event->arg; t_info *info = event->ev_arg;
isc_event_t *nevent; isc_event_t *nevent;
INSIST(event->type == ISC_TASKEVENT_SHUTDOWN); INSIST(event->ev_type == ISC_TASKEVENT_SHUTDOWN);
printf("task %s (%p) shutdown\n", info->name, task); printf("task %s (%p) shutdown\n", info->name, task);
if (strcmp(info->name, "0") == 0) { if (strcmp(info->name, "0") == 0) {
@ -102,10 +102,10 @@ foo_event(isc_task_t *task, isc_event_t *event) {
static void static void
tick(isc_task_t *task, isc_event_t *event) tick(isc_task_t *task, isc_event_t *event)
{ {
t_info *info = event->arg; t_info *info = event->ev_arg;
isc_event_t *nevent; isc_event_t *nevent;
INSIST(event->type == ISC_TIMEREVENT_TICK); INSIST(event->ev_type == ISC_TIMEREVENT_TICK);
printf("task %s (%p) tick\n", info->name, task); printf("task %s (%p) tick\n", info->name, task);

44
bin/tests/sock_test.c
View File

@ -41,7 +41,7 @@ static void my_recv(isc_task_t *task, isc_event_t *event);
static void static void
my_shutdown(isc_task_t *task, isc_event_t *event) my_shutdown(isc_task_t *task, isc_event_t *event)
{ {
char *name = event->arg; char *name = event->ev_arg;
printf("shutdown %s (%p)\n", name, task); printf("shutdown %s (%p)\n", name, task);
fflush(stdout); fflush(stdout);
@ -57,11 +57,11 @@ my_recv(isc_task_t *task, isc_event_t *event)
char buf[1024]; char buf[1024];
char host[256]; char host[256];
sock = event->sender; sock = event->ev_sender;
dev = (isc_socketevent_t *)event; dev = (isc_socketevent_t *)event;
printf("Socket %s (sock %p, base %p, length %d, n %d, result %d)\n", printf("Socket %s (sock %p, base %p, length %d, n %d, result %d)\n",
(char *)(event->arg), sock, (char *)(event->ev_arg), sock,
dev->region.base, dev->region.length, dev->region.base, dev->region.length,
dev->n, dev->result); dev->n, dev->result);
if (dev->address.type.sa.sa_family == AF_INET6) { if (dev->address.type.sa.sa_family == AF_INET6) {
@ -90,21 +90,21 @@ my_recv(isc_task_t *task, isc_event_t *event)
/* /*
* Echo the data back * Echo the data back
*/ */
if (strcmp(event->arg, "so2") != 0) { if (strcmp(event->ev_arg, "so2") != 0) {
region = dev->region; region = dev->region;
sprintf(buf, "\r\nReceived: %.*s\r\n\r\n", sprintf(buf, "\r\nReceived: %.*s\r\n\r\n",
(int)dev->n, (char *)region.base); (int)dev->n, (char *)region.base);
region.base = isc_mem_get(mctx, strlen(buf) + 1); region.base = isc_mem_get(mctx, strlen(buf) + 1);
region.length = strlen(buf) + 1; region.length = strlen(buf) + 1;
strcpy((char *)region.base, buf); /* strcpy is safe */ strcpy((char *)region.base, buf); /* strcpy is safe */
isc_socket_send(sock, &region, task, my_send, event->arg); isc_socket_send(sock, &region, task, my_send, event->ev_arg);
} else { } else {
region = dev->region; region = dev->region;
printf("\r\nReceived: %.*s\r\n\r\n", printf("\r\nReceived: %.*s\r\n\r\n",
(int)dev->n, (char *)region.base); (int)dev->n, (char *)region.base);
} }
isc_socket_recv(sock, &dev->region, 1, task, my_recv, event->arg); isc_socket_recv(sock, &dev->region, 1, task, my_recv, event->ev_arg);
isc_event_free(&event); isc_event_free(&event);
} }
@ -115,11 +115,11 @@ my_send(isc_task_t *task, isc_event_t *event)
isc_socket_t *sock; isc_socket_t *sock;
isc_socketevent_t *dev; isc_socketevent_t *dev;
sock = event->sender; sock = event->ev_sender;
dev = (isc_socketevent_t *)event; dev = (isc_socketevent_t *)event;
printf("my_send: %s task %p\n\t(sock %p, base %p, length %d, n %d, result %d)\n", printf("my_send: %s task %p\n\t(sock %p, base %p, length %d, n %d, result %d)\n",
(char *)(event->arg), task, sock, (char *)(event->ev_arg), task, sock,
dev->region.base, dev->region.length, dev->region.base, dev->region.length,
dev->n, dev->result); dev->n, dev->result);
@ -139,11 +139,11 @@ my_http_get(isc_task_t *task, isc_event_t *event)
isc_socket_t *sock; isc_socket_t *sock;
isc_socketevent_t *dev; isc_socketevent_t *dev;
sock = event->sender; sock = event->ev_sender;
dev = (isc_socketevent_t *)event; dev = (isc_socketevent_t *)event;
printf("my_http_get: %s task %p\n\t(sock %p, base %p, length %d, n %d, result %d)\n", printf("my_http_get: %s task %p\n\t(sock %p, base %p, length %d, n %d, result %d)\n",
(char *)(event->arg), task, sock, (char *)(event->ev_arg), task, sock,
dev->region.base, dev->region.length, dev->region.base, dev->region.length,
dev->n, dev->result); dev->n, dev->result);
@ -154,7 +154,7 @@ my_http_get(isc_task_t *task, isc_event_t *event)
return; return;
} }
isc_socket_recv(sock, &dev->region, 1, task, my_recv, event->arg); isc_socket_recv(sock, &dev->region, 1, task, my_recv, event->ev_arg);
isc_event_free(&event); isc_event_free(&event);
} }
@ -167,10 +167,10 @@ my_connect(isc_task_t *task, isc_event_t *event)
isc_region_t region; isc_region_t region;
char buf[1024]; char buf[1024];
sock = event->sender; sock = event->ev_sender;
dev = (isc_socket_connev_t *)event; dev = (isc_socket_connev_t *)event;
printf("%s: Connection result: %d\n", (char *)(event->arg), printf("%s: Connection result: %d\n", (char *)(event->ev_arg),
dev->result); dev->result);
if (dev->result != ISC_R_SUCCESS) { if (dev->result != ISC_R_SUCCESS) {
@ -189,7 +189,7 @@ my_connect(isc_task_t *task, isc_event_t *event)
region.length = strlen(buf) + 1; region.length = strlen(buf) + 1;
strcpy((char *)region.base, buf); /* strcpy is safe */ strcpy((char *)region.base, buf); /* strcpy is safe */
isc_socket_send(sock, &region, task, my_http_get, event->arg); isc_socket_send(sock, &region, task, my_http_get, event->ev_arg);
isc_event_free(&event); isc_event_free(&event);
} }
@ -197,7 +197,7 @@ my_connect(isc_task_t *task, isc_event_t *event)
static void static void
my_listen(isc_task_t *task, isc_event_t *event) my_listen(isc_task_t *task, isc_event_t *event)
{ {
char *name = event->arg; char *name = event->ev_arg;
isc_socket_newconnev_t *dev; isc_socket_newconnev_t *dev;
isc_region_t region; isc_region_t region;
isc_socket_t *oldsock; isc_socket_t *oldsock;
@ -206,14 +206,14 @@ my_listen(isc_task_t *task, isc_event_t *event)
dev = (isc_socket_newconnev_t *)event; dev = (isc_socket_newconnev_t *)event;
printf("newcon %s (task %p, oldsock %p, newsock %p, result %d)\n", printf("newcon %s (task %p, oldsock %p, newsock %p, result %d)\n",
name, task, event->sender, dev->newsocket, dev->result); name, task, event->ev_sender, dev->newsocket, dev->result);
fflush(stdout); fflush(stdout);
if (dev->result == ISC_R_SUCCESS) { if (dev->result == ISC_R_SUCCESS) {
/* /*
* queue another listen on this socket * queue another listen on this socket
*/ */
isc_socket_accept(event->sender, task, my_listen, event->arg); isc_socket_accept(event->ev_sender, task, my_listen, event->ev_arg);
region.base = isc_mem_get(mctx, 20); region.base = isc_mem_get(mctx, 20);
region.length = 20; region.length = 20;
@ -226,11 +226,11 @@ my_listen(isc_task_t *task, isc_event_t *event)
RUNTIME_CHECK(isc_task_create(manager, 0, &newtask) RUNTIME_CHECK(isc_task_create(manager, 0, &newtask)
== ISC_R_SUCCESS); == ISC_R_SUCCESS);
isc_socket_recv(dev->newsocket, &region, 1, isc_socket_recv(dev->newsocket, &region, 1,
newtask, my_recv, event->arg); newtask, my_recv, event->ev_arg);
isc_task_detach(&newtask); isc_task_detach(&newtask);
} else { } else {
printf("detaching from socket %p\n", event->sender); printf("detaching from socket %p\n", event->ev_sender);
oldsock = event->sender; oldsock = event->ev_sender;
isc_socket_detach(&oldsock); isc_socket_detach(&oldsock);
@ -245,12 +245,12 @@ my_listen(isc_task_t *task, isc_event_t *event)
static void static void
timeout(isc_task_t *task, isc_event_t *event) timeout(isc_task_t *task, isc_event_t *event)
{ {
isc_socket_t *sock = event->arg; isc_socket_t *sock = event->ev_arg;
printf("Timeout, canceling IO on socket %p (task %p)\n", sock, task); printf("Timeout, canceling IO on socket %p (task %p)\n", sock, task);
isc_socket_cancel(sock, NULL, ISC_SOCKCANCEL_ALL); isc_socket_cancel(sock, NULL, ISC_SOCKCANCEL_ALL);
isc_timer_detach((isc_timer_t **)&event->sender); isc_timer_detach((isc_timer_t **)&event->ev_sender);
isc_event_free(&event); isc_event_free(&event);
} }

6
bin/tests/task_test.c
View File

@ -35,7 +35,7 @@ static void
my_callback(isc_task_t *task, isc_event_t *event) my_callback(isc_task_t *task, isc_event_t *event)
{ {
int i, j; int i, j;
char *name = event->arg; char *name = event->ev_arg;
j = 0; j = 0;
for (i = 0; i < 1000000; i++) for (i = 0; i < 1000000; i++)
@ -46,7 +46,7 @@ my_callback(isc_task_t *task, isc_event_t *event)
static void static void
my_shutdown(isc_task_t *task, isc_event_t *event) { my_shutdown(isc_task_t *task, isc_event_t *event) {
char *name = event->arg; char *name = event->ev_arg;
printf("shutdown %s (%p)\n", name, task); printf("shutdown %s (%p)\n", name, task);
isc_event_free(&event); isc_event_free(&event);
@ -55,7 +55,7 @@ my_shutdown(isc_task_t *task, isc_event_t *event) {
static void static void
my_tick(isc_task_t *task, isc_event_t *event) my_tick(isc_task_t *task, isc_event_t *event)
{ {
char *name = event->arg; char *name = event->ev_arg;
printf("task %p tick %s\n", task, name); printf("task %p tick %s\n", task, name);
isc_event_free(&event); isc_event_free(&event);

46
bin/tests/tasks/t_tasks.c
View File

@ -66,7 +66,7 @@ t1_callback(isc_task_t *task, isc_event_t *event)
for (i = 0; i < 1000000; i++) for (i = 0; i < 1000000; i++)
j += 100; j += 100;
t_info("task %s\n", event->arg); t_info("task %s\n", event->ev_arg);
isc_event_free(&event); isc_event_free(&event);
} }
@ -74,7 +74,7 @@ static void
t1_shutdown(isc_task_t *task, isc_event_t *event) { t1_shutdown(isc_task_t *task, isc_event_t *event) {
task = task; task = task;
t_info("shutdown %s\n", event->arg); t_info("shutdown %s\n", event->ev_arg);
isc_event_free(&event); isc_event_free(&event);
} }
@ -82,7 +82,7 @@ static void
my_tick(isc_task_t *task, isc_event_t *event) my_tick(isc_task_t *task, isc_event_t *event)
{ {
task = task; task = task;
t_info("%s\n", event->arg); t_info("%s\n", event->ev_arg);
isc_event_free(&event); isc_event_free(&event);
} }
@ -404,8 +404,8 @@ t2_shutdown(isc_task_t *task, isc_event_t *event) {
task = task; /* notused */ task = task; /* notused */
if (event->arg != NULL) { if (event->ev_arg != NULL) {
isc_task_destroy((isc_task_t**) &event->arg); isc_task_destroy((isc_task_t**) &event->ev_arg);
} }
else { else {
isc_result = isc_mutex_lock(&T2_mx); isc_result = isc_mutex_lock(&T2_mx);
@ -446,9 +446,9 @@ t2_callback(isc_task_t *task, isc_event_t *event)
t_info("T2_ntasks %d\n", T2_ntasks); t_info("T2_ntasks %d\n", T2_ntasks);
} }
if (event->arg) { if (event->ev_arg) {
event->arg = (void* ) (((int) event->arg) - 1); event->ev_arg = (void* ) (((int) event->ev_arg) - 1);
/* create a new task and forward the message */ /* create a new task and forward the message */
newtask = NULL; newtask = NULL;
@ -1315,41 +1315,41 @@ t10_event2(isc_task_t *task, isc_event_t *event) {
if (T_debug) { if (T_debug) {
t_info("Event %p,%d,%d,%s\n", t_info("Event %p,%d,%d,%s\n",
event->sender, event->ev_sender,
(int) event->type, (int) event->ev_type,
event->tag, event->ev_tag,
event->attributes & ISC_EVENTATTR_NOPURGE ? "NP" : "P"); event->ev_attributes & ISC_EVENTATTR_NOPURGE ? "NP" : "P");
} }
if ((T10_purge_sender == 0) || if ((T10_purge_sender == 0) ||
(T10_purge_sender == event->sender)) { (T10_purge_sender == event->ev_sender)) {
sender_match = 1; sender_match = 1;
} }
if (T10_testrange == 0) { if (T10_testrange == 0) {
if (T10_purge_type_first == event->type) { if (T10_purge_type_first == event->ev_type) {
type_match = 1; type_match = 1;
} }
} }
else { else {
if ((T10_purge_type_first <= event->type) && if ((T10_purge_type_first <= event->ev_type) &&
(event->type <= T10_purge_type_last)) { (event->ev_type <= T10_purge_type_last)) {
type_match = 1; type_match = 1;
} }
} }
if ((T10_purge_tag == NULL) || if ((T10_purge_tag == NULL) ||
(T10_purge_tag == event->tag)) { (T10_purge_tag == event->ev_tag)) {
tag_match = 1; tag_match = 1;
} }
if (sender_match && type_match && tag_match) { if (sender_match && type_match && tag_match) {
if (event->attributes & ISC_EVENTATTR_NOPURGE) { if (event->ev_attributes & ISC_EVENTATTR_NOPURGE) {
t_info("event %p,%d,%d matched but was not purgable\n", t_info("event %p,%d,%d matched but was not purgable\n",
event->sender, (int) event->type, event->tag); event->ev_sender, (int) event->ev_type, event->ev_tag);
++T10_eventcnt; ++T10_eventcnt;
} }
else { else {
t_info("*** event %p,%d,%d not purged\n", t_info("*** event %p,%d,%d not purged\n",
event->sender, (int) event->type, event->tag); event->ev_sender, (int) event->ev_type, event->ev_tag);
} }
} }
else { else {
@ -1522,11 +1522,11 @@ t_taskpurge_x( int sender, int type, int tag,
NULL, NULL,
sizeof(*event)); sizeof(*event));
eventtab[event_cnt]->tag = (void *)((int)tag + tag_cnt); eventtab[event_cnt]->ev_tag = (void *)((int)tag + tag_cnt);
/* make all odd message non-purgable */ /* make all odd message non-purgable */
if ((sender_cnt % 2) && (type_cnt %2) && (tag_cnt %2)) if ((sender_cnt % 2) && (type_cnt %2) && (tag_cnt %2))
eventtab[event_cnt]->attributes |= ISC_EVENTATTR_NOPURGE; eventtab[event_cnt]->ev_attributes |= ISC_EVENTATTR_NOPURGE;
++event_cnt; ++event_cnt;
} }
} }
@ -1886,9 +1886,9 @@ t_tasks11(int purgable) {
sizeof(*event2)); sizeof(*event2));
event2_clone = event2; event2_clone = event2;
if (purgable) if (purgable)
event2->attributes &= ~ISC_EVENTATTR_NOPURGE; event2->ev_attributes &= ~ISC_EVENTATTR_NOPURGE;
else else
event2->attributes |= ISC_EVENTATTR_NOPURGE; event2->ev_attributes |= ISC_EVENTATTR_NOPURGE;
isc_task_send(task, &event2); isc_task_send(task, &event2);

14
bin/tests/timer_test.c
View File

@ -37,7 +37,7 @@ int tick_count = 0;
static void static void
shutdown_task(isc_task_t *task, isc_event_t *event) { shutdown_task(isc_task_t *task, isc_event_t *event) {
char *name = event->arg; char *name = event->ev_arg;
printf("task %p shutdown %s\n", task, name); printf("task %p shutdown %s\n", task, name);
isc_event_free(&event); isc_event_free(&event);
@ -46,9 +46,9 @@ shutdown_task(isc_task_t *task, isc_event_t *event) {
static void static void
tick(isc_task_t *task, isc_event_t *event) tick(isc_task_t *task, isc_event_t *event)
{ {
char *name = event->arg; char *name = event->ev_arg;
INSIST(event->type == ISC_TIMEREVENT_TICK); INSIST(event->ev_type == ISC_TIMEREVENT_TICK);
printf("task %s (%p) tick\n", name, task); printf("task %s (%p) tick\n", name, task);
@ -75,13 +75,13 @@ tick(isc_task_t *task, isc_event_t *event)
static void static void
timeout(isc_task_t *task, isc_event_t *event) timeout(isc_task_t *task, isc_event_t *event)
{ {
char *name = event->arg; char *name = event->ev_arg;
char *type; char *type;
INSIST(event->type == ISC_TIMEREVENT_IDLE || INSIST(event->ev_type == ISC_TIMEREVENT_IDLE ||
event->type == ISC_TIMEREVENT_LIFE); event->ev_type == ISC_TIMEREVENT_LIFE);
if (event->type == ISC_TIMEREVENT_IDLE) if (event->ev_type == ISC_TIMEREVENT_IDLE)
type = "idle"; type = "idle";
else else
type = "life"; type = "life";

18
bin/tests/timers/t_timers.c
View File

@ -104,12 +104,12 @@ tx_te(isc_task_t *task, isc_event_t *event) {
t_info("tick %d\n", Tx_eventcnt); t_info("tick %d\n", Tx_eventcnt);
expected_event_type = ISC_TIMEREVENT_LIFE; expected_event_type = ISC_TIMEREVENT_LIFE;
if ((isc_timertype_t) event->arg == isc_timertype_ticker) if ((isc_timertype_t) event->ev_arg == isc_timertype_ticker)
expected_event_type = ISC_TIMEREVENT_TICK; expected_event_type = ISC_TIMEREVENT_TICK;
if (event->type != expected_event_type) { if (event->ev_type != expected_event_type) {
t_info("expected event type %d, got %d\n", t_info("expected event type %d, got %d\n",
expected_event_type, (int) event->type); expected_event_type, (int) event->ev_type);
++Tx_nfails; ++Tx_nfails;
} }
@ -444,9 +444,9 @@ t3_te(isc_task_t *task, isc_event_t *event) {
++Tx_nprobs; ++Tx_nprobs;
} }
if (event->type != ISC_TIMEREVENT_IDLE) { if (event->ev_type != ISC_TIMEREVENT_IDLE) {
t_info("received event type %d, expected type %d\n", t_info("received event type %d, expected type %d\n",
event->type, ISC_TIMEREVENT_IDLE); event->ev_type, ISC_TIMEREVENT_IDLE);
++Tx_nfails; ++Tx_nfails;
} }
@ -545,9 +545,9 @@ t4_te(isc_task_t *task, isc_event_t *event) {
} }
if (Tx_eventcnt < 3) { if (Tx_eventcnt < 3) {
if (event->type != ISC_TIMEREVENT_TICK) { if (event->ev_type != ISC_TIMEREVENT_TICK) {
t_info("received event type %d, expected type %d\n", t_info("received event type %d, expected type %d\n",
event->type, ISC_TIMEREVENT_IDLE); event->ev_type, ISC_TIMEREVENT_IDLE);
++Tx_nfails; ++Tx_nfails;
} }
if (Tx_eventcnt == 2) { if (Tx_eventcnt == 2) {
@ -571,9 +571,9 @@ t4_te(isc_task_t *task, isc_event_t *event) {
} }
} }
else { else {
if (event->type != ISC_TIMEREVENT_LIFE) { if (event->ev_type != ISC_TIMEREVENT_LIFE) {
t_info("received event type %d, expected type %d\n", t_info("received event type %d, expected type %d\n",
event->type, ISC_TIMEREVENT_IDLE); event->ev_type, ISC_TIMEREVENT_IDLE);
++Tx_nfails; ++Tx_nfails;
} }

8
bin/tests/tkey_test.c
View File

@ -87,7 +87,7 @@ senddone(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *)event; isc_socketevent_t *sevent = (isc_socketevent_t *)event;
REQUIRE(sevent != NULL); REQUIRE(sevent != NULL);
REQUIRE(sevent->type == ISC_SOCKEVENT_SENDDONE); REQUIRE(sevent->ev_type == ISC_SOCKEVENT_SENDDONE);
REQUIRE(task == task1); REQUIRE(task == task1);
printf("senddone\n"); printf("senddone\n");
@ -102,7 +102,7 @@ recvdone(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
REQUIRE(sevent != NULL); REQUIRE(sevent != NULL);
REQUIRE(sevent->type == ISC_SOCKEVENT_RECVDONE); REQUIRE(sevent->ev_type == ISC_SOCKEVENT_RECVDONE);
REQUIRE(task == task1); REQUIRE(task == task1);
printf("recvdone\n"); printf("recvdone\n");
@ -135,7 +135,7 @@ senddone2(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *)event; isc_socketevent_t *sevent = (isc_socketevent_t *)event;
REQUIRE(sevent != NULL); REQUIRE(sevent != NULL);
REQUIRE(sevent->type == ISC_SOCKEVENT_SENDDONE); REQUIRE(sevent->ev_type == ISC_SOCKEVENT_SENDDONE);
REQUIRE(task == task2); REQUIRE(task == task2);
printf("senddone2\n"); printf("senddone2\n");
@ -150,7 +150,7 @@ recvdone2(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
REQUIRE(sevent != NULL); REQUIRE(sevent != NULL);
REQUIRE(sevent->type == ISC_SOCKEVENT_RECVDONE); REQUIRE(sevent->ev_type == ISC_SOCKEVENT_RECVDONE);
REQUIRE(task == task2); REQUIRE(task == task2);
printf("recvdone2\n"); printf("recvdone2\n");

66
lib/dns/adb.c
View File

@ -1038,12 +1038,12 @@ event_free(isc_event_t *event)
dns_adbfind_t *find; dns_adbfind_t *find;
INSIST(event != NULL); INSIST(event != NULL);
find = event->destroy_arg; find = event->ev_destroy_arg;
INSIST(DNS_ADBFIND_VALID(find)); INSIST(DNS_ADBFIND_VALID(find));
LOCK(&find->lock); LOCK(&find->lock);
find->flags |= FIND_EVENT_FREED; find->flags |= FIND_EVENT_FREED;
event->destroy_arg = NULL; event->ev_destroy_arg = NULL;
UNLOCK(&find->lock); UNLOCK(&find->lock);
} }
@ -1110,11 +1110,11 @@ clean_finds_at_name(dns_adbname_t *name, isc_eventtype_t evtype,
INSIST(!FIND_EVENTSENT(find)); INSIST(!FIND_EVENTSENT(find));
ev = &find->event; ev = &find->event;
task = ev->sender; task = ev->ev_sender;
ev->sender = find; ev->ev_sender = find;
ev->type = evtype; ev->ev_type = evtype;
ev->destroy = event_free; ev->ev_destroy = event_free;
ev->destroy_arg = find; ev->ev_destroy_arg = find;
DP(DEF_LEVEL, DP(DEF_LEVEL,
"Sending event %p to task %p for find %p", "Sending event %p to task %p for find %p",
@ -1135,7 +1135,7 @@ clean_finds_at_name(dns_adbname_t *name, isc_eventtype_t evtype,
static inline void static inline void
check_exit(dns_adb_t *adb) check_exit(dns_adb_t *adb)
{ {
isc_event_t *event, *next_event; isc_event_t *event;
isc_task_t *etask; isc_task_t *etask;
isc_boolean_t zeroirefcnt; isc_boolean_t zeroirefcnt;
@ -1155,15 +1155,15 @@ check_exit(dns_adb_t *adb)
/* /*
* We're now shutdown. Send any whenshutdown events. * We're now shutdown. Send any whenshutdown events.
*/ */
for (event = ISC_LIST_HEAD(adb->whenshutdown); event = ISC_LIST_HEAD(adb->whenshutdown);
event != NULL; while (event != NULL) {
event = next_event) { ISC_LIST_UNLINK(adb->whenshutdown, event, ev_link);
next_event = ISC_LIST_NEXT(event, link); etask = event->ev_sender;
ISC_LIST_UNLINK(adb->whenshutdown, event, link); event->ev_sender = adb;
etask = event->sender;
event->sender = adb;
isc_task_sendanddetach(&etask, &event); isc_task_sendanddetach(&etask, &event);
event = ISC_LIST_HEAD(adb->whenshutdown);
} }
/* /*
* If there aren't any external references either, we're * If there aren't any external references either, we're
* done. Send the control event to initiate shutdown. * done. Send the control event to initiate shutdown.
@ -1946,7 +1946,7 @@ shutdown_task(isc_task_t *task, isc_event_t *ev)
(void)task; /* not used */ (void)task; /* not used */
adb = ev->arg; adb = ev->ev_arg;
INSIST(DNS_ADB_VALID(adb)); INSIST(DNS_ADB_VALID(adb));
/* /*
@ -2095,7 +2095,7 @@ timer_cleanup(isc_task_t *task, isc_event_t *ev)
UNUSED(task); UNUSED(task);
adb = ev->arg; adb = ev->ev_arg;
INSIST(DNS_ADB_VALID(adb)); INSIST(DNS_ADB_VALID(adb));
LOCK(&adb->lock); LOCK(&adb->lock);
@ -2399,13 +2399,13 @@ dns_adb_whenshutdown(dns_adb_t *adb, isc_task_t *task, isc_event_t **eventp)
/* /*
* We're already shutdown. Send the event. * We're already shutdown. Send the event.
*/ */
event->sender = adb; event->ev_sender = adb;
isc_task_send(task, &event); isc_task_send(task, &event);
} else { } else {
clone = NULL; clone = NULL;
isc_task_attach(task, &clone); isc_task_attach(task, &clone);
event->sender = clone; event->ev_sender = clone;
ISC_LIST_APPEND(adb->whenshutdown, event, link); ISC_LIST_APPEND(adb->whenshutdown, event, ev_link);
} }
UNLOCK(&adb->lock); UNLOCK(&adb->lock);
@ -2722,9 +2722,9 @@ dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
INSIST((find->flags & DNS_ADBFIND_ADDRESSMASK) != 0); INSIST((find->flags & DNS_ADBFIND_ADDRESSMASK) != 0);
taskp = NULL; taskp = NULL;
isc_task_attach(task, &taskp); isc_task_attach(task, &taskp);
find->event.sender = taskp; find->event.ev_sender = taskp;
find->event.action = action; find->event.ev_action = action;
find->event.arg = arg; find->event.ev_arg = arg;
} }
} }
@ -2832,11 +2832,11 @@ dns_adb_cancelfind(dns_adbfind_t *find)
if (!FIND_EVENTSENT(find)) { if (!FIND_EVENTSENT(find)) {
ev = &find->event; ev = &find->event;
task = ev->sender; task = ev->ev_sender;
ev->sender = find; ev->ev_sender = find;
ev->type = DNS_EVENT_ADBCANCELED; ev->ev_type = DNS_EVENT_ADBCANCELED;
ev->destroy = event_free; ev->ev_destroy = event_free;
ev->destroy_arg = find; ev->ev_destroy_arg = find;
DP(DEF_LEVEL, "Sending event %p to task %p for find %p", DP(DEF_LEVEL, "Sending event %p to task %p for find %p",
ev, task, find); ev, task, find);
@ -3004,7 +3004,7 @@ dns_adb_dumpfind(dns_adbfind_t *find, FILE *f)
find->query_pending, find->partial_result, find->query_pending, find->partial_result,
find->options, find->flags); find->options, find->flags);
fprintf(f, "\tname_bucket %d, name %p, event sender %p\n", fprintf(f, "\tname_bucket %d, name %p, event sender %p\n",
find->name_bucket, find->adbname, find->event.sender); find->name_bucket, find->adbname, find->event.ev_sender);
ai = ISC_LIST_HEAD(find->list); ai = ISC_LIST_HEAD(find->list);
if (ai != NULL) if (ai != NULL)
@ -3324,9 +3324,9 @@ fetch_callback(isc_task_t *task, isc_event_t *ev)
(void)task; (void)task;
INSIST(ev->type == DNS_EVENT_FETCHDONE); INSIST(ev->ev_type == DNS_EVENT_FETCHDONE);
dev = (dns_fetchevent_t *)ev; dev = (dns_fetchevent_t *)ev;
name = ev->arg; name = ev->ev_arg;
INSIST(DNS_ADBNAME_VALID(name)); INSIST(DNS_ADBNAME_VALID(name));
adb = name->adb; adb = name->adb;
INSIST(DNS_ADB_VALID(adb)); INSIST(DNS_ADB_VALID(adb));
@ -3482,9 +3482,9 @@ fetch_callback_a6(isc_task_t *task, isc_event_t *ev)
(void)task; (void)task;
INSIST(ev->type == DNS_EVENT_FETCHDONE); INSIST(ev->ev_type == DNS_EVENT_FETCHDONE);
dev = (dns_fetchevent_t *)ev; dev = (dns_fetchevent_t *)ev;
name = ev->arg; name = ev->ev_arg;
INSIST(DNS_ADBNAME_VALID(name)); INSIST(DNS_ADBNAME_VALID(name));
adb = name->adb; adb = name->adb;
INSIST(DNS_ADB_VALID(adb)); INSIST(DNS_ADB_VALID(adb));

12
lib/dns/byaddr.c
View File

@ -173,10 +173,10 @@ copy_ptr_targets(dns_byaddr_t *byaddr) {
static void static void
fetch_done(isc_task_t *task, isc_event_t *event) { fetch_done(isc_task_t *task, isc_event_t *event) {
dns_byaddr_t *byaddr = event->arg; dns_byaddr_t *byaddr = event->ev_arg;
dns_fetchevent_t *fevent; dns_fetchevent_t *fevent;
REQUIRE(event->type == DNS_EVENT_FETCHDONE); REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE);
REQUIRE(VALID_BYADDR(byaddr)); REQUIRE(VALID_BYADDR(byaddr));
REQUIRE(byaddr->task == task); REQUIRE(byaddr->task == task);
fevent = (dns_fetchevent_t *)event; fevent = (dns_fetchevent_t *)event;
@ -351,7 +351,7 @@ byaddr_find(dns_byaddr_t *byaddr, dns_fetchevent_t *event) {
if (send_event) { if (send_event) {
byaddr->event->result = result; byaddr->event->result = result;
byaddr->event->sender = byaddr; byaddr->event->ev_sender = byaddr;
ievent = (isc_event_t *)byaddr->event; ievent = (isc_event_t *)byaddr->event;
byaddr->event = NULL; byaddr->event = NULL;
isc_task_sendanddetach(&byaddr->task, &ievent); isc_task_sendanddetach(&byaddr->task, &ievent);
@ -367,8 +367,8 @@ bevent_destroy(isc_event_t *event) {
dns_name_t *name, *next_name; dns_name_t *name, *next_name;
isc_mem_t *mctx; isc_mem_t *mctx;
REQUIRE(event->type == DNS_EVENT_BYADDRDONE); REQUIRE(event->ev_type == DNS_EVENT_BYADDRDONE);
mctx = event->destroy_arg; mctx = event->ev_destroy_arg;
bevent = (dns_byaddrevent_t *)event; bevent = (dns_byaddrevent_t *)event;
for (name = ISC_LIST_HEAD(bevent->names); for (name = ISC_LIST_HEAD(bevent->names);
@ -378,7 +378,7 @@ bevent_destroy(isc_event_t *event) {
dns_name_free(name, mctx); dns_name_free(name, mctx);
isc_mem_put(mctx, name, sizeof *name); isc_mem_put(mctx, name, sizeof *name);
} }
isc_mem_put(mctx, event, event->size); isc_mem_put(mctx, event, event->ev_size);
} }
isc_result_t isc_result_t

19
lib/dns/cache.c
View File

@ -15,7 +15,7 @@
* SOFTWARE. * SOFTWARE.
*/ */
/* $Id: cache.c,v 1.16 2000/04/12 01:37:41 halley Exp $ */ /* $Id: cache.c,v 1.17 2000/04/17 19:22:22 explorer Exp $ */
#include <config.h> #include <config.h>
@ -450,9 +450,10 @@ end_cleaning(cache_cleaner_t *cleaner, isc_event_t *event) {
*/ */
static void static void
cleaning_timer_action(isc_task_t *task, isc_event_t *event) { cleaning_timer_action(isc_task_t *task, isc_event_t *event) {
cache_cleaner_t *cleaner = event->arg; cache_cleaner_t *cleaner = event->ev_arg;
INSIST(task == cleaner->task); INSIST(task == cleaner->task);
INSIST(event->type == ISC_TIMEREVENT_TICK); INSIST(event->ev_type == ISC_TIMEREVENT_TICK);
if (cleaner->state == cleaner_s_idle) { if (cleaner->state == cleaner_s_idle) {
begin_cleaning(cleaner); begin_cleaning(cleaner);
} else { } else {
@ -471,11 +472,13 @@ cleaning_timer_action(isc_task_t *task, isc_event_t *event) {
static void static void
incremental_cleaning_action(isc_task_t *task, isc_event_t *event) { incremental_cleaning_action(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
cache_cleaner_t *cleaner = event->arg; cache_cleaner_t *cleaner = event->ev_arg;
isc_stdtime_t now; isc_stdtime_t now;
int n_names; int n_names;
INSIST(event->type == DNS_EVENT_CACHECLEAN);
INSIST(event->ev_type == DNS_EVENT_CACHECLEAN);
INSIST(CLEANER_BUSY(cleaner)); INSIST(CLEANER_BUSY(cleaner));
n_names = cleaner->increment; n_names = cleaner->increment;
isc_stdtime_get(&now); isc_stdtime_get(&now);
@ -590,12 +593,14 @@ dns_cache_clean(dns_cache_t *cache, isc_stdtime_t now) {
*/ */
static void static void
cleaner_shutdown_action(isc_task_t *task, isc_event_t *event) { cleaner_shutdown_action(isc_task_t *task, isc_event_t *event) {
dns_cache_t *cache = event->arg; dns_cache_t *cache = event->ev_arg;
isc_boolean_t should_free = ISC_FALSE; isc_boolean_t should_free = ISC_FALSE;
UNUSED(task); UNUSED(task);
LOCK(&cache->lock); LOCK(&cache->lock);
INSIST(event->type == ISC_TASKEVENT_SHUTDOWN); INSIST(event->ev_type == ISC_TASKEVENT_SHUTDOWN);
isc_event_free(&event); isc_event_free(&event);
cache->live_tasks--; cache->live_tasks--;

36
lib/dns/dispatch.c
View File

@ -230,7 +230,7 @@ destroy(dns_dispatch_t *disp)
*/ */
ev = ISC_LIST_HEAD(disp->rq_events); ev = ISC_LIST_HEAD(disp->rq_events);
while (ev != NULL) { while (ev != NULL) {
ISC_LIST_UNLINK(disp->rq_events, ev, link); ISC_LIST_UNLINK(disp->rq_events, ev, ev_link);
free_buffer(disp, ev->buffer.base, ev->buffer.length); free_buffer(disp, ev->buffer.base, ev->buffer.length);
free_event(disp, ev); free_event(disp, ev);
ev = ISC_LIST_HEAD(disp->rq_events); ev = ISC_LIST_HEAD(disp->rq_events);
@ -383,7 +383,7 @@ static void
udp_recv(isc_task_t *task, isc_event_t *ev_in) udp_recv(isc_task_t *task, isc_event_t *ev_in)
{ {
isc_socketevent_t *ev = (isc_socketevent_t *)ev_in; isc_socketevent_t *ev = (isc_socketevent_t *)ev_in;
dns_dispatch_t *disp = ev_in->arg; dns_dispatch_t *disp = ev_in->ev_arg;
dns_messageid_t id; dns_messageid_t id;
isc_result_t dres; isc_result_t dres;
isc_buffer_t source; isc_buffer_t source;
@ -394,9 +394,8 @@ udp_recv(isc_task_t *task, isc_event_t *ev_in)
isc_boolean_t killit; isc_boolean_t killit;
isc_boolean_t queue_request; isc_boolean_t queue_request;
isc_boolean_t queue_response; isc_boolean_t queue_response;
unsigned int attributes;
(void)task; /* shut up compiler */ UNUSED(task);
XDEBUG(("Got packet!\n")); XDEBUG(("Got packet!\n"));
@ -521,19 +520,14 @@ udp_recv(isc_task_t *task, isc_event_t *ev_in)
rev->result = ISC_R_SUCCESS; rev->result = ISC_R_SUCCESS;
rev->id = id; rev->id = id;
rev->addr = ev->address; rev->addr = ev->address;
attributes = 0; rev->pktinfo = ev->pktinfo;
if ((ev->attributes & ISC_SOCKEVENTATTR_PKTINFO) != 0) { rev->attributes = ev->attributes;
rev->pktinfo = ev->pktinfo;
attributes |= DNS_DISPATCHATTR_PKTINFO;
} else {
attributes &= ~DNS_DISPATCHATTR_PKTINFO;
}
if (queue_request) { if (queue_request) {
ISC_LIST_APPEND(disp->rq_events, rev, link); ISC_LIST_APPEND(disp->rq_events, rev, ev_link);
} else if (queue_response) { } else if (queue_response) {
ISC_LIST_APPEND(resp->items, rev, link); ISC_LIST_APPEND(resp->items, rev, ev_link);
} else { } else {
ISC_EVENT_INIT(rev, sizeof(*rev), attributes, NULL, ISC_EVENT_INIT(rev, sizeof(*rev), 0, NULL,
DNS_EVENT_DISPATCH, DNS_EVENT_DISPATCH,
resp->action, resp->arg, resp, NULL, NULL); resp->action, resp->arg, resp, NULL, NULL);
XDEBUG(("Sent event %p buffer %p len %d to task %p, resp %p\n", XDEBUG(("Sent event %p buffer %p len %d to task %p, resp %p\n",
@ -580,7 +574,7 @@ udp_recv(isc_task_t *task, isc_event_t *ev_in)
static void static void
tcp_recv(isc_task_t *task, isc_event_t *ev_in) tcp_recv(isc_task_t *task, isc_event_t *ev_in)
{ {
dns_dispatch_t *disp = ev_in->arg; dns_dispatch_t *disp = ev_in->ev_arg;
dns_tcpmsg_t *tcpmsg = &disp->tcpmsg; dns_tcpmsg_t *tcpmsg = &disp->tcpmsg;
dns_messageid_t id; dns_messageid_t id;
isc_result_t dres; isc_result_t dres;
@ -592,7 +586,7 @@ tcp_recv(isc_task_t *task, isc_event_t *ev_in)
isc_boolean_t queue_request; isc_boolean_t queue_request;
isc_boolean_t queue_response; isc_boolean_t queue_response;
(void)task; /* shut up compiler */ UNUSED(task);
REQUIRE(VALID_DISPATCH(disp)); REQUIRE(VALID_DISPATCH(disp));
@ -718,9 +712,9 @@ tcp_recv(isc_task_t *task, isc_event_t *ev_in)
rev->id = id; rev->id = id;
rev->addr = tcpmsg->address; rev->addr = tcpmsg->address;
if (queue_request) { if (queue_request) {
ISC_LIST_APPEND(disp->rq_events, rev, link); ISC_LIST_APPEND(disp->rq_events, rev, ev_link);
} else if (queue_response) { } else if (queue_response) {
ISC_LIST_APPEND(resp->items, rev, link); ISC_LIST_APPEND(resp->items, rev, ev_link);
} else { } else {
ISC_EVENT_INIT(rev, sizeof(*rev), 0, NULL, DNS_EVENT_DISPATCH, ISC_EVENT_INIT(rev, sizeof(*rev), 0, NULL, DNS_EVENT_DISPATCH,
resp->action, resp->arg, resp, NULL, NULL); resp->action, resp->arg, resp, NULL, NULL);
@ -1193,7 +1187,7 @@ dns_dispatch_removeresponse(dns_dispatch_t *disp, dns_dispentry_t **resp,
*/ */
ev = ISC_LIST_HEAD(res->items); ev = ISC_LIST_HEAD(res->items);
while (ev != NULL) { while (ev != NULL) {
ISC_LIST_UNLINK(res->items, ev, link); ISC_LIST_UNLINK(res->items, ev, ev_link);
if (ev->buffer.base != NULL) if (ev->buffer.base != NULL)
free_buffer(disp, ev->buffer.base, ev->buffer.length); free_buffer(disp, ev->buffer.base, ev->buffer.length);
free_event(disp, ev); free_event(disp, ev);
@ -1409,7 +1403,7 @@ do_next_response(dns_dispatch_t *disp, dns_dispentry_t *resp)
return; return;
} }
ISC_LIST_UNLINK(disp->rq_events, ev, link); ISC_LIST_UNLINK(disp->rq_events, ev, ev_link);
ISC_EVENT_INIT(ev, sizeof(*ev), 0, NULL, DNS_EVENT_DISPATCH, ISC_EVENT_INIT(ev, sizeof(*ev), 0, NULL, DNS_EVENT_DISPATCH,
resp->action, resp->arg, resp, NULL, NULL); resp->action, resp->arg, resp, NULL, NULL);
@ -1433,7 +1427,7 @@ do_next_request(dns_dispatch_t *disp, dns_dispentry_t *resp)
return; return;
} }
ISC_LIST_UNLINK(disp->rq_events, ev, link); ISC_LIST_UNLINK(disp->rq_events, ev, ev_link);
ISC_EVENT_INIT(ev, sizeof(*ev), 0, NULL, DNS_EVENT_DISPATCH, ISC_EVENT_INIT(ev, sizeof(*ev), 0, NULL, DNS_EVENT_DISPATCH,
resp->action, resp->arg, resp, NULL, NULL); resp->action, resp->arg, resp, NULL, NULL);

6
lib/dns/include/dns/dispatch.h
View File

@ -86,13 +86,9 @@ struct dns_dispatchevent {
isc_sockaddr_t addr; /* address recv'd from */ isc_sockaddr_t addr; /* address recv'd from */
struct in6_pktinfo pktinfo; /* reply info for v6 */ struct in6_pktinfo pktinfo; /* reply info for v6 */
isc_buffer_t buffer; /* data buffer */ isc_buffer_t buffer; /* data buffer */
isc_uint32_t attributes; /* mirrored from socket.h */
}; };
/*
* event attributes
*/
#define DNS_DISPATCHATTR_PKTINFO 0x00100000U
/* /*
* Functions to: * Functions to:
* *

34
lib/dns/request.c
View File

@ -195,13 +195,13 @@ dns_requestmgr_whenshutdown(dns_requestmgr_t *requestmgr, isc_task_t *task,
/* /*
* We're already shutdown. Send the event. * We're already shutdown. Send the event.
*/ */
event->sender = requestmgr; event->ev_sender = requestmgr;
isc_task_send(task, &event); isc_task_send(task, &event);
} else { } else {
clone = NULL; clone = NULL;
isc_task_attach(task, &clone); isc_task_attach(task, &clone);
event->sender = clone; event->ev_sender = clone;
ISC_LIST_APPEND(requestmgr->whenshutdown, event, link); ISC_LIST_APPEND(requestmgr->whenshutdown, event, ev_link);
} }
UNLOCK(&requestmgr->lock); UNLOCK(&requestmgr->lock);
} }
@ -286,10 +286,10 @@ send_shutdown_events(dns_requestmgr_t *requestmgr) {
for (event = ISC_LIST_HEAD(requestmgr->whenshutdown); for (event = ISC_LIST_HEAD(requestmgr->whenshutdown);
event != NULL; event != NULL;
event = next_event) { event = next_event) {
next_event = ISC_LIST_NEXT(event, link); next_event = ISC_LIST_NEXT(event, ev_link);
ISC_LIST_UNLINK(requestmgr->whenshutdown, event, link); ISC_LIST_UNLINK(requestmgr->whenshutdown, event, ev_link);
etask = event->sender; etask = event->ev_sender;
event->sender = requestmgr; event->ev_sender = requestmgr;
isc_task_sendanddetach(&etask, &event); isc_task_sendanddetach(&etask, &event);
} }
} }
@ -394,7 +394,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
goto cleanup; goto cleanup;
} }
isc_task_attach(task, &tclone); isc_task_attach(task, &tclone);
request->event->sender = task; request->event->ev_sender = task;
request->event->request = request; request->event->request = request;
request->event->result = ISC_R_FAILURE; request->event->result = ISC_R_FAILURE;
@ -628,9 +628,9 @@ static void
req_connected(isc_task_t *task, isc_event_t *event) { req_connected(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *)event; isc_socketevent_t *sevent = (isc_socketevent_t *)event;
isc_result_t result; isc_result_t result;
dns_request_t *request = event->arg; dns_request_t *request = event->ev_arg;
REQUIRE(event->type == ISC_SOCKEVENT_SENDDONE); REQUIRE(event->ev_type == ISC_SOCKEVENT_SENDDONE);
REQUIRE(DNS_REQUEST_CONNECTING(request)); REQUIRE(DNS_REQUEST_CONNECTING(request));
TRACE("req_connected\n"); TRACE("req_connected\n");
@ -653,9 +653,9 @@ req_connected(isc_task_t *task, isc_event_t *event) {
static void static void
req_senddone(isc_task_t *task, isc_event_t *event) { req_senddone(isc_task_t *task, isc_event_t *event) {
isc_socketevent_t *sevent = (isc_socketevent_t *)event; isc_socketevent_t *sevent = (isc_socketevent_t *)event;
dns_request_t *request = event->arg; dns_request_t *request = event->ev_arg;
REQUIRE(event->type == ISC_SOCKEVENT_SENDDONE); REQUIRE(event->ev_type == ISC_SOCKEVENT_SENDDONE);
TRACE("req_senddone\n"); TRACE("req_senddone\n");
(void)task; (void)task;
@ -669,12 +669,12 @@ req_senddone(isc_task_t *task, isc_event_t *event) {
static void static void
req_response(isc_task_t *task, isc_event_t *event) { req_response(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
dns_request_t *request = event->arg; dns_request_t *request = event->ev_arg;
dns_dispatchevent_t *devent = (dns_dispatchevent_t *)event; dns_dispatchevent_t *devent = (dns_dispatchevent_t *)event;
isc_region_t r; isc_region_t r;
REQUIRE(VALID_REQUEST(request)); REQUIRE(VALID_REQUEST(request));
REQUIRE(event->type == DNS_EVENT_DISPATCH); REQUIRE(event->ev_type == DNS_EVENT_DISPATCH);
UNUSED(task); UNUSED(task);
@ -712,7 +712,7 @@ req_response(isc_task_t *task, isc_event_t *event) {
static void static void
req_timeout(isc_task_t *task, isc_event_t *event) { req_timeout(isc_task_t *task, isc_event_t *event) {
dns_request_t *request = event->arg; dns_request_t *request = event->ev_arg;
TRACE("req_timeout\n"); TRACE("req_timeout\n");
UNUSED(task); UNUSED(task);
@ -730,8 +730,8 @@ req_sendevent(dns_request_t *request, isc_result_t result) {
/* /*
* Lock held by caller. * Lock held by caller.
*/ */
task = request->event->sender; task = request->event->ev_sender;
request->event->sender = request; request->event->ev_sender = request;
request->event->result = result; request->event->result = result;
isc_task_sendanddetach(&task, (isc_event_t **)&request->event); isc_task_sendanddetach(&task, (isc_event_t **)&request->event);
} }

4
lib/dns/tcpmsg.c
View File

@ -53,7 +53,7 @@ recv_length(isc_task_t *task, isc_event_t *ev_in)
{ {
isc_socketevent_t *ev = (isc_socketevent_t *)ev_in; isc_socketevent_t *ev = (isc_socketevent_t *)ev_in;
isc_event_t *dev; isc_event_t *dev;
dns_tcpmsg_t *tcpmsg = ev_in->arg; dns_tcpmsg_t *tcpmsg = ev_in->ev_arg;
isc_region_t region; isc_region_t region;
isc_result_t result; isc_result_t result;
@ -111,7 +111,7 @@ recv_message(isc_task_t *task, isc_event_t *ev_in)
{ {
isc_socketevent_t *ev = (isc_socketevent_t *)ev_in; isc_socketevent_t *ev = (isc_socketevent_t *)ev_in;
isc_event_t *dev; isc_event_t *dev;
dns_tcpmsg_t *tcpmsg = ev_in->arg; dns_tcpmsg_t *tcpmsg = ev_in->ev_arg;
(void)task; (void)task;

26
lib/dns/validator.c
View File

@ -131,11 +131,11 @@ validator_done(dns_validator_t *val, isc_result_t result) {
*/ */
val->event->result = result; val->event->result = result;
task = val->event->sender; task = val->event->ev_sender;
val->event->sender = val; val->event->ev_sender = val;
val->event->type = DNS_EVENT_VALIDATORDONE; val->event->ev_type = DNS_EVENT_VALIDATORDONE;
val->event->action = val->action; val->event->ev_action = val->action;
val->event->arg = val->arg; val->event->ev_arg = val->arg;
if ((val->attributes & VALATTR_NEGATIVE) != 0) { if ((val->attributes & VALATTR_NEGATIVE) != 0) {
val->event->rdataset = NULL; val->event->rdataset = NULL;
val->event->sigrdataset = NULL; val->event->sigrdataset = NULL;
@ -154,9 +154,9 @@ fetch_callback_validator(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
UNUSED(task); UNUSED(task);
INSIST(event->type == DNS_EVENT_FETCHDONE); INSIST(event->ev_type == DNS_EVENT_FETCHDONE);
devent = (dns_fetchevent_t *)event; devent = (dns_fetchevent_t *)event;
val = devent->arg; val = devent->ev_arg;
rdataset = devent->rdataset; rdataset = devent->rdataset;
validator_log(val, ISC_LOG_DEBUG(3), "in fetch_callback_validator"); validator_log(val, ISC_LOG_DEBUG(3), "in fetch_callback_validator");
@ -202,10 +202,10 @@ keyvalidated(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
UNUSED(task); UNUSED(task);
INSIST(event->type == DNS_EVENT_VALIDATORDONE); INSIST(event->ev_type == DNS_EVENT_VALIDATORDONE);
devent = (dns_validatorevent_t *)event; devent = (dns_validatorevent_t *)event;
rdataset = devent->rdataset; rdataset = devent->rdataset;
val = devent->arg; val = devent->ev_arg;
validator_log(val, ISC_LOG_DEBUG(3), "in keyvalidated"); validator_log(val, ISC_LOG_DEBUG(3), "in keyvalidated");
if (devent->result == ISC_R_SUCCESS) { if (devent->result == ISC_R_SUCCESS) {
@ -467,7 +467,7 @@ get_key(dns_validator_t *val, dns_siginfo_t *siginfo) {
&siginfo->signer, &siginfo->signer,
dns_rdatatype_key, dns_rdatatype_key,
NULL, NULL, NULL, 0, NULL, NULL, NULL, 0,
val->event->sender, val->event->ev_sender,
fetch_callback_validator, fetch_callback_validator,
val, val,
frdataset, frdataset,
@ -699,7 +699,7 @@ validator_start(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
UNUSED(task); UNUSED(task);
REQUIRE(event->type == DNS_EVENT_VALIDATORSTART); REQUIRE(event->ev_type == DNS_EVENT_VALIDATORSTART);
vevent = (dns_validatorevent_t *) event; vevent = (dns_validatorevent_t *) event;
val = vevent->validator; val = vevent->validator;
@ -809,8 +809,8 @@ dns_validator_cancel(dns_validator_t *validator) {
LOCK(&validator->lock); LOCK(&validator->lock);
if (validator->event != NULL) { if (validator->event != NULL) {
validator->event->result = ISC_R_CANCELED; validator->event->result = ISC_R_CANCELED;
task = validator->event->sender; task = validator->event->ev_sender;
validator->event->sender = validator; validator->event->ev_sender = validator;
isc_task_sendanddetach(&task, isc_task_sendanddetach(&task,
(isc_event_t **)&validator->event); (isc_event_t **)&validator->event);
/* /*

8
lib/dns/view.c
View File

@ -293,10 +293,10 @@ dns_view_detach(dns_view_t **viewp) {
static void static void
resolver_shutdown(isc_task_t *task, isc_event_t *event) { resolver_shutdown(isc_task_t *task, isc_event_t *event) {
dns_view_t *view = event->arg; dns_view_t *view = event->ev_arg;
isc_boolean_t done; isc_boolean_t done;
REQUIRE(event->type == DNS_EVENT_VIEWRESSHUTDOWN); REQUIRE(event->ev_type == DNS_EVENT_VIEWRESSHUTDOWN);
REQUIRE(DNS_VIEW_VALID(view)); REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(view->task == task); REQUIRE(view->task == task);
@ -315,10 +315,10 @@ resolver_shutdown(isc_task_t *task, isc_event_t *event) {
static void static void
adb_shutdown(isc_task_t *task, isc_event_t *event) { adb_shutdown(isc_task_t *task, isc_event_t *event) {
dns_view_t *view = event->arg; dns_view_t *view = event->ev_arg;
isc_boolean_t done; isc_boolean_t done;
REQUIRE(event->type == DNS_EVENT_VIEWADBSHUTDOWN); REQUIRE(event->ev_type == DNS_EVENT_VIEWADBSHUTDOWN);
REQUIRE(DNS_VIEW_VALID(view)); REQUIRE(DNS_VIEW_VALID(view));
REQUIRE(view->task == task); REQUIRE(view->task == task);

35
lib/dns/xfrin.c
View File

@ -15,7 +15,7 @@
* SOFTWARE. * SOFTWARE.
*/ */
/* $Id: xfrin.c,v 1.63 2000/04/11 19:08:11 gson Exp $ */ /* $Id: xfrin.c,v 1.64 2000/04/17 19:22:29 explorer Exp $ */
#include <config.h> #include <config.h>
@ -855,14 +855,15 @@ render(dns_message_t *msg, isc_buffer_t *buf) {
static void static void
xfrin_connect_done(isc_task_t *task, isc_event_t *event) { xfrin_connect_done(isc_task_t *task, isc_event_t *event) {
isc_socket_connev_t *cev = (isc_socket_connev_t *) event; isc_socket_connev_t *cev = (isc_socket_connev_t *) event;
dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->arg; dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->ev_arg;
isc_result_t evresult = cev->result; isc_result_t evresult = cev->result;
isc_result_t result; isc_result_t result;
REQUIRE(VALID_XFRIN(xfr)); REQUIRE(VALID_XFRIN(xfr));
task = task; /* Unused */ UNUSED(task);
INSIST(event->type == ISC_SOCKEVENT_CONNECT);
INSIST(event->ev_type == ISC_SOCKEVENT_CONNECT);
isc_event_free(&event); isc_event_free(&event);
xfr->connects--; xfr->connects--;
@ -1007,15 +1008,16 @@ static void
xfrin_sendlen_done(isc_task_t *task, isc_event_t *event) xfrin_sendlen_done(isc_task_t *task, isc_event_t *event)
{ {
isc_socketevent_t *sev = (isc_socketevent_t *) event; isc_socketevent_t *sev = (isc_socketevent_t *) event;
dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->arg; dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->ev_arg;
isc_result_t evresult = sev->result; isc_result_t evresult = sev->result;
isc_result_t result; isc_result_t result;
isc_region_t region; isc_region_t region;
REQUIRE(VALID_XFRIN(xfr)); REQUIRE(VALID_XFRIN(xfr));
task = task; /* Unused */ UNUSED(task);
INSIST(event->type == ISC_SOCKEVENT_SENDDONE);
INSIST(event->ev_type == ISC_SOCKEVENT_SENDDONE);
isc_event_free(&event); isc_event_free(&event);
xfr->sends--; xfr->sends--;
@ -1041,13 +1043,14 @@ static void
xfrin_send_done(isc_task_t *task, isc_event_t *event) xfrin_send_done(isc_task_t *task, isc_event_t *event)
{ {
isc_socketevent_t *sev = (isc_socketevent_t *) event; isc_socketevent_t *sev = (isc_socketevent_t *) event;
dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->arg; dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->ev_arg;
isc_result_t result; isc_result_t result;
REQUIRE(VALID_XFRIN(xfr)); REQUIRE(VALID_XFRIN(xfr));
task = task; /* Unused */ UNUSED(task);
INSIST(event->type == ISC_SOCKEVENT_SENDDONE);
INSIST(event->ev_type == ISC_SOCKEVENT_SENDDONE);
xfr->sends--; xfr->sends--;
xfrin_log(xfr, ISC_LOG_DEBUG(3), "sent request data"); xfrin_log(xfr, ISC_LOG_DEBUG(3), "sent request data");
@ -1065,7 +1068,7 @@ xfrin_send_done(isc_task_t *task, isc_event_t *event)
static void static void
xfrin_recv_done(isc_task_t *task, isc_event_t *ev) { xfrin_recv_done(isc_task_t *task, isc_event_t *ev) {
dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) ev->arg; dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) ev->ev_arg;
isc_result_t result; isc_result_t result;
dns_message_t *msg = NULL; dns_message_t *msg = NULL;
dns_name_t *name; dns_name_t *name;
@ -1073,10 +1076,10 @@ xfrin_recv_done(isc_task_t *task, isc_event_t *ev) {
REQUIRE(VALID_XFRIN(xfr)); REQUIRE(VALID_XFRIN(xfr));
task = task; /* Unused */ UNUSED(task);
INSIST(ev->type == DNS_EVENT_TCPMSG); INSIST(ev->ev_type == DNS_EVENT_TCPMSG);
tcpmsg = ev->sender; tcpmsg = ev->ev_sender;
isc_event_free(&ev); isc_event_free(&ev);
xfr->recvs--; xfr->recvs--;
@ -1229,11 +1232,11 @@ xfrin_recv_done(isc_task_t *task, isc_event_t *ev) {
static void static void
xfrin_timeout(isc_task_t *task, isc_event_t *event) { xfrin_timeout(isc_task_t *task, isc_event_t *event) {
dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->arg; dns_xfrin_ctx_t *xfr = (dns_xfrin_ctx_t *) event->ev_arg;
REQUIRE(VALID_XFRIN(xfr)); REQUIRE(VALID_XFRIN(xfr));
task = task; /* Unused */ UNUSED(task);
isc_event_free(&event); isc_event_free(&event);
/* This will log "giving up: timeout". */ /* This will log "giving up: timeout". */

14
lib/dns/zone.c
View File

@ -15,7 +15,7 @@
* SOFTWARE. * SOFTWARE.
*/ */
/* $Id: zone.c,v 1.92 2000/04/12 01:36:22 halley Exp $ */ /* $Id: zone.c,v 1.93 2000/04/17 19:22:30 explorer Exp $ */
#include <config.h> #include <config.h>
@ -928,7 +928,7 @@ static void
checkservers_callback(isc_task_t *task, isc_event_t *event) { checkservers_callback(isc_task_t *task, isc_event_t *event) {
const char me[] = "checkservers_callback"; const char me[] = "checkservers_callback";
dns_fetchdoneevent_t *devent = (dns_fetchdoneevent_t *)event; dns_fetchdoneevent_t *devent = (dns_fetchdoneevent_t *)event;
dns_zone_checkservers_t *checkservers = event->arg; dns_zone_checkservers_t *checkservers = event->ev_arg;
dns_zone_state_t state; dns_zone_state_t state;
dns_zone_t *zone; dns_zone_t *zone;
dns_name_t *name; dns_name_t *name;
@ -945,7 +945,7 @@ checkservers_callback(isc_task_t *task, isc_event_t *event) {
mctx = checkservers->mctx; mctx = checkservers->mctx;
res = checkservers->res; res = checkservers->res;
task = task; /* unused */ UNUSED(task);
if (devent->result != ISC_R_SUCCESS) { if (devent->result != ISC_R_SUCCESS) {
/* timeout */ /* timeout */
@ -2068,7 +2068,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
isc_uint32_t serial; isc_uint32_t serial;
zone = devent->arg; zone = devent->ev_arg;
INSIST(DNS_ZONE_VALID(zone)); INSIST(DNS_ZONE_VALID(zone));
/* /*
@ -2241,10 +2241,10 @@ soa_query(dns_zone_t *zone, isc_taskaction_t callback) {
*/ */
static void static void
zone_shutdown(isc_task_t *task, isc_event_t *event) { zone_shutdown(isc_task_t *task, isc_event_t *event) {
dns_zone_t *zone = (dns_zone_t *) event->arg; dns_zone_t *zone = (dns_zone_t *) event->ev_arg;
UNUSED(task); UNUSED(task);
REQUIRE(DNS_ZONE_VALID(zone)); REQUIRE(DNS_ZONE_VALID(zone));
INSIST(event->type == DNS_EVENT_ZONECONTROL); INSIST(event->ev_type == DNS_EVENT_ZONECONTROL);
INSIST(zone->erefs == 0); INSIST(zone->erefs == 0);
zone_log(zone, "zone_shutdown", ISC_LOG_DEBUG(3), "shutting down"); zone_log(zone, "zone_shutdown", ISC_LOG_DEBUG(3), "shutting down");
zone->shuttingdown = ISC_TRUE; zone->shuttingdown = ISC_TRUE;
@ -2256,7 +2256,7 @@ zone_shutdown(isc_task_t *task, isc_event_t *event) {
static void static void
zone_timer(isc_task_t *task, isc_event_t *event) { zone_timer(isc_task_t *task, isc_event_t *event) {
const char me[] = "zone_timer"; const char me[] = "zone_timer";
dns_zone_t *zone = (dns_zone_t *)event->arg; dns_zone_t *zone = (dns_zone_t *)event->ev_arg;
UNUSED(task); UNUSED(task);
DNS_ENTER; DNS_ENTER;

8
lib/isc/event.c
View File

@ -31,9 +31,9 @@
static void static void
destroy(isc_event_t *event) { destroy(isc_event_t *event) {
isc_mem_t *mctx = event->destroy_arg; isc_mem_t *mctx = event->ev_destroy_arg;
isc_mem_put(mctx, event, event->size); isc_mem_put(mctx, event, event->ev_size);
} }
isc_event_t * isc_event_t *
@ -64,8 +64,8 @@ isc_event_free(isc_event_t **eventp) {
event = *eventp; event = *eventp;
REQUIRE(event != NULL); REQUIRE(event != NULL);
if (event->destroy != NULL) if (event->ev_destroy != NULL)
(event->destroy)(event); (event->ev_destroy)(event);
*eventp = NULL; *eventp = NULL;
} }

40
lib/isc/include/isc/event.h
View File

@ -41,16 +41,16 @@ typedef void (*isc_eventdestructor_t)(isc_event_t *);
* really an issue. * really an issue.
*/ */
#define ISC_EVENT_COMMON(ltype) \ #define ISC_EVENT_COMMON(ltype) \
size_t size; \ size_t ev_size; \
unsigned int attributes; \ unsigned int ev_attributes; \
void * tag; \ void * ev_tag; \
isc_eventtype_t type; \ isc_eventtype_t ev_type; \
isc_taskaction_t action; \ isc_taskaction_t ev_action; \
void * arg; \ void * ev_arg; \
void * sender; \ void * ev_sender; \
isc_eventdestructor_t destroy; \ isc_eventdestructor_t ev_destroy; \
void * destroy_arg; \ void * ev_destroy_arg; \
ISC_LINK(ltype) link ISC_LINK(ltype) ev_link
/* /*
* Attributes matching a mask of 0x000000ff are reserved for the task library's * Attributes matching a mask of 0x000000ff are reserved for the task library's
@ -61,16 +61,16 @@ typedef void (*isc_eventdestructor_t)(isc_event_t *);
#define ISC_EVENT_INIT(event, sz, at, ta, ty, ac, ar, sn, df, da) \ #define ISC_EVENT_INIT(event, sz, at, ta, ty, ac, ar, sn, df, da) \
do { \ do { \
(event)->size = (sz); \ (event)->ev_size = (sz); \
(event)->attributes = (at); \ (event)->ev_attributes = (at); \
(event)->tag = (ta); \ (event)->ev_tag = (ta); \
(event)->type = (ty); \ (event)->ev_type = (ty); \
(event)->action = (ac); \ (event)->ev_action = (ac); \
(event)->arg = (ar); \ (event)->ev_arg = (ar); \
(event)->sender = (sn); \ (event)->ev_sender = (sn); \
(event)->destroy = (df); \ (event)->ev_destroy = (df); \
(event)->destroy_arg = (da); \ (event)->ev_destroy_arg = (da); \
ISC_LINK_INIT((event), link); \ ISC_LINK_INIT((event), ev_link); \
} while (0) } while (0)
/* /*

1
lib/isc/include/isc/socket.h
View File

@ -100,6 +100,7 @@ struct isc_socketevent {
isc_sockaddr_t address; /* source address */ isc_sockaddr_t address; /* source address */
isc_time_t timestamp; /* timestamp of packet recv */ isc_time_t timestamp; /* timestamp of packet recv */
struct in6_pktinfo pktinfo; /* ipv6 pktinfo */ struct in6_pktinfo pktinfo; /* ipv6 pktinfo */
isc_uint32_t attributes; /* see below */
}; };
typedef struct isc_socket_newconnev isc_socket_newconnev_t; typedef struct isc_socket_newconnev isc_socket_newconnev_t;

10
lib/isc/ondestroy.c
View File

@ -50,9 +50,9 @@ isc_ondestroy_register(isc_ondestroy_t *ondest,
isc_task_attach(task, &thetask); isc_task_attach(task, &thetask);
theevent->sender = thetask; theevent->ev_sender = thetask;
ISC_LIST_APPEND(ondest->events, theevent, link); ISC_LIST_APPEND(ondest->events, theevent, ev_link);
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
} }
@ -69,10 +69,10 @@ isc_ondestroy_notify(isc_ondestroy_t *ondest, void *sender)
eventp = ISC_LIST_HEAD(ondest->events); eventp = ISC_LIST_HEAD(ondest->events);
while (eventp != NULL) { while (eventp != NULL) {
ISC_LIST_UNLINK(ondest->events, eventp, link); ISC_LIST_UNLINK(ondest->events, eventp, ev_link);
task = eventp->sender; task = eventp->ev_sender;
eventp->sender = sender; eventp->ev_sender = sender;
isc_task_sendanddetach(&task, &eventp); isc_task_sendanddetach(&task, &eventp);

8
lib/isc/ratelimiter.c
View File

@ -98,7 +98,7 @@ isc_ratelimiter_enqueue(isc_ratelimiter_t *rl, isc_event_t **eventp)
LOCK(&rl->lock); LOCK(&rl->lock);
if (rl->state == isc_ratelimiter_ratelimited) { if (rl->state == isc_ratelimiter_ratelimited) {
isc_event_t *ev = *eventp; isc_event_t *ev = *eventp;
ISC_LIST_APPEND(rl->pending, ev, link); ISC_LIST_APPEND(rl->pending, ev, ev_link);
*eventp = NULL; *eventp = NULL;
} else { } else {
result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL, result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
@ -117,7 +117,7 @@ static void
ratelimiter_tick(isc_task_t *task, isc_event_t *event) ratelimiter_tick(isc_task_t *task, isc_event_t *event)
{ {
isc_result_t result = ISC_R_SUCCESS; isc_result_t result = ISC_R_SUCCESS;
isc_ratelimiter_t *rl = (isc_ratelimiter_t *) event->arg; isc_ratelimiter_t *rl = (isc_ratelimiter_t *)event->ev_arg;
isc_event_t *p; isc_event_t *p;
(void) task; /* Unused */ (void) task; /* Unused */
LOCK(&rl->lock); LOCK(&rl->lock);
@ -126,7 +126,7 @@ ratelimiter_tick(isc_task_t *task, isc_event_t *event)
/* /*
* There is work to do. Let's do it after unlocking. * There is work to do. Let's do it after unlocking.
*/ */
ISC_LIST_UNLINK(rl->pending, p, link); ISC_LIST_UNLINK(rl->pending, p, ev_link);
} else { } else {
/* /*
* No work left to do. Stop the timer so that we don't * No work left to do. Stop the timer so that we don't
@ -158,7 +158,7 @@ isc_ratelimiter_destroy(isc_ratelimiter_t **ratelimiterp)
NULL, NULL, ISC_FALSE); NULL, NULL, ISC_FALSE);
isc_timer_detach(&rl->timer); isc_timer_detach(&rl->timer);
while ((p = ISC_LIST_HEAD(rl->pending)) != NULL) { while ((p = ISC_LIST_HEAD(rl->pending)) != NULL) {
ISC_LIST_UNLINK(rl->pending, p, link); ISC_LIST_UNLINK(rl->pending, p, ev_link);
isc_event_free(&p); isc_event_free(&p);
} }
isc_mutex_destroy(&rl->lock); isc_mutex_destroy(&rl->lock);

40
lib/isc/task.c
View File

@ -250,9 +250,9 @@ task_shutdown(isc_task_t *task) {
for (event = TAIL(task->on_shutdown); for (event = TAIL(task->on_shutdown);
event != NULL; event != NULL;
event = prev) { event = prev) {
prev = PREV(event, link); prev = PREV(event, ev_link);
DEQUEUE(task->on_shutdown, event, link); DEQUEUE(task->on_shutdown, event, ev_link);
ENQUEUE(task->events, event, link); ENQUEUE(task->events, event, ev_link);
} }
} }
@ -342,8 +342,8 @@ task_send(isc_task_t *task, isc_event_t **eventp) {
REQUIRE(eventp != NULL); REQUIRE(eventp != NULL);
event = *eventp; event = *eventp;
REQUIRE(event != NULL); REQUIRE(event != NULL);
REQUIRE(event->sender != NULL); REQUIRE(event->ev_sender != NULL);
REQUIRE(event->type > 0); REQUIRE(event->ev_type > 0);
REQUIRE(task->state != task_state_done); REQUIRE(task->state != task_state_done);
XTRACE("task_send"); XTRACE("task_send");
@ -355,7 +355,7 @@ task_send(isc_task_t *task, isc_event_t **eventp) {
} }
INSIST(task->state == task_state_ready || INSIST(task->state == task_state_ready ||
task->state == task_state_running); task->state == task_state_running);
ENQUEUE(task->events, event, link); ENQUEUE(task->events, event, ev_link);
*eventp = NULL; *eventp = NULL;
return (was_idle); return (was_idle);
@ -436,7 +436,7 @@ isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
*taskp = NULL; *taskp = NULL;
} }
#define PURGE_OK(event) (((event)->attributes & ISC_EVENTATTR_NOPURGE) == 0) #define PURGE_OK(event) (((event)->ev_attributes & ISC_EVENTATTR_NOPURGE) == 0)
static unsigned int static unsigned int
dequeue_events(isc_task_t *task, void *sender, isc_eventtype_t first, dequeue_events(isc_task_t *task, void *sender, isc_eventtype_t first,
@ -462,13 +462,13 @@ dequeue_events(isc_task_t *task, void *sender, isc_eventtype_t first,
LOCK(&task->lock); LOCK(&task->lock);
for (event = HEAD(task->events); event != NULL; event = next_event) { for (event = HEAD(task->events); event != NULL; event = next_event) {
next_event = NEXT(event, link); next_event = NEXT(event, ev_link);
if (event->type >= first && event->type <= last && if (event->ev_type >= first && event->ev_type <= last &&
(sender == NULL || event->sender == sender) && (sender == NULL || event->ev_sender == sender) &&
(tag == NULL || event->tag == tag) && (tag == NULL || event->ev_tag == tag) &&
(!purging || PURGE_OK(event))) { (!purging || PURGE_OK(event))) {
DEQUEUE(task->events, event, link); DEQUEUE(task->events, event, ev_link);
ENQUEUE(*events, event, link); ENQUEUE(*events, event, ev_link);
count++; count++;
} }
} }
@ -498,7 +498,7 @@ isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first,
ISC_TRUE); ISC_TRUE);
for (event = HEAD(events); event != NULL; event = next_event) { for (event = HEAD(events); event != NULL; event = next_event) {
next_event = NEXT(event, link); next_event = NEXT(event, ev_link);
isc_event_free(&event); isc_event_free(&event);
} }
@ -548,9 +548,9 @@ isc_task_purgeevent(isc_task_t *task, isc_event_t *event) {
for (curr_event = HEAD(task->events); for (curr_event = HEAD(task->events);
curr_event != NULL; curr_event != NULL;
curr_event = next_event) { curr_event = next_event) {
next_event = NEXT(curr_event, link); next_event = NEXT(curr_event, ev_link);
if (curr_event == event && PURGE_OK(event)) { if (curr_event == event && PURGE_OK(event)) {
DEQUEUE(task->events, curr_event, link); DEQUEUE(task->events, curr_event, ev_link);
break; break;
} }
} }
@ -621,7 +621,7 @@ isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg) {
disallowed = ISC_TRUE; disallowed = ISC_TRUE;
result = ISC_R_SHUTTINGDOWN; result = ISC_R_SHUTTINGDOWN;
} else } else
ENQUEUE(task->on_shutdown, event, link); ENQUEUE(task->on_shutdown, event, ev_link);
UNLOCK(&task->lock); UNLOCK(&task->lock);
if (disallowed) if (disallowed)
@ -790,15 +790,15 @@ run(void *uap) {
do { do {
if (!EMPTY(task->events)) { if (!EMPTY(task->events)) {
event = HEAD(task->events); event = HEAD(task->events);
DEQUEUE(task->events, event, link); DEQUEUE(task->events, event, ev_link);
/* /*
* Execute the event action. * Execute the event action.
*/ */
XTRACE("execute action"); XTRACE("execute action");
if (event->action != NULL) { if (event->ev_action != NULL) {
UNLOCK(&task->lock); UNLOCK(&task->lock);
(event->action)(task, event); (event->ev_action)(task,event);
LOCK(&task->lock); LOCK(&task->lock);
} }
dispatch_count++; dispatch_count++;

10
lib/isc/unix/app.c
View File

@ -210,7 +210,7 @@ isc_app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
goto unlock; goto unlock;
} }
ISC_LIST_APPEND(on_run, event, link); ISC_LIST_APPEND(on_run, event, ev_link);
result = ISC_R_SUCCESS; result = ISC_R_SUCCESS;
@ -249,10 +249,10 @@ isc_app_run(void) {
for (event = ISC_LIST_HEAD(on_run); for (event = ISC_LIST_HEAD(on_run);
event != NULL; event != NULL;
event = next_event) { event = next_event) {
next_event = ISC_LIST_NEXT(event, link); next_event = ISC_LIST_NEXT(event, ev_link);
ISC_LIST_UNLINK(on_run, event, link); ISC_LIST_UNLINK(on_run, event, ev_link);
task = event->sender; task = event->ev_sender;
event->sender = (void *)&running; event->ev_sender = (void *)&running;
isc_task_sendanddetach(&task, &event); isc_task_sendanddetach(&task, &event);
} }

156
lib/isc/unix/socket.c
View File

@ -321,7 +321,7 @@ process_cmsg(isc_socket_t *sock, struct msghdr *msg, isc_socketevent_t *dev)
#endif #endif
#endif #endif
(void)sock; UNUSED(sock);
#ifdef ISC_NET_BSD44MSGHDR #ifdef ISC_NET_BSD44MSGHDR
#ifdef MSG_TRUNC #ifdef MSG_TRUNC
@ -642,11 +642,12 @@ allocate_socketevent(isc_socket_t *sock, isc_eventtype_t eventtype,
return (NULL); return (NULL);
ev->result = ISC_R_UNEXPECTED; ev->result = ISC_R_UNEXPECTED;
ISC_LINK_INIT(ev, link); ISC_LINK_INIT(ev, ev_link);
ISC_LIST_INIT(ev->bufferlist); ISC_LIST_INIT(ev->bufferlist);
ev->region.base = NULL; ev->region.base = NULL;
ev->n = 0; ev->n = 0;
ev->offset = 0; ev->offset = 0;
ev->attributes = 0;
return (ev); return (ev);
} }
@ -811,6 +812,7 @@ doio_send(isc_socket_t *sock, isc_socketevent_t *dev)
size_t write_count; size_t write_count;
struct msghdr msghdr; struct msghdr msghdr;
/* XXXMLG Should verify that we didn't overflow MAXSCATTERGATHER? */
build_msghdr_send(sock, dev, &msghdr, iov, build_msghdr_send(sock, dev, &msghdr, iov,
MAXSCATTERGATHER_SEND, &write_count); MAXSCATTERGATHER_SEND, &write_count);
@ -1228,14 +1230,14 @@ dispatch_read(isc_socket_t *sock)
iev = &sock->readable_ev; iev = &sock->readable_ev;
XTRACE(TRACE_WATCHER, ("dispatch_read: posted event %p to task %p\n", XTRACE(TRACE_WATCHER, ("dispatch_read: posted event %p to task %p\n",
ev, ev->sender)); ev, ev->ev_sender));
sock->references++; sock->references++;
iev->sender = sock; iev->ev_sender = sock;
iev->action = internal_recv; iev->ev_action = internal_recv;
iev->arg = sock; iev->ev_arg = sock;
isc_task_send(ev->sender, (isc_event_t **)&iev); isc_task_send(ev->ev_sender, (isc_event_t **)&iev);
} }
static void static void
@ -1254,14 +1256,14 @@ dispatch_write(isc_socket_t *sock)
iev = &sock->writable_ev; iev = &sock->writable_ev;
XTRACE(TRACE_WATCHER, ("dispatch_send: posted event %p to task %p\n", XTRACE(TRACE_WATCHER, ("dispatch_send: posted event %p to task %p\n",
ev, ev->sender)); ev, ev->ev_sender));
sock->references++; sock->references++;
iev->sender = sock; iev->ev_sender = sock;
iev->action = internal_send; iev->ev_action = internal_send;
iev->arg = sock; iev->ev_arg = sock;
isc_task_send(ev->sender, (isc_event_t **)&iev); isc_task_send(ev->ev_sender, (isc_event_t **)&iev);
} }
/* /*
@ -1287,11 +1289,11 @@ dispatch_accept(isc_socket_t *sock)
iev = &sock->readable_ev; iev = &sock->readable_ev;
sock->references++; /* keep socket around for this internal event */ sock->references++; /* keep socket around for this internal event */
iev->sender = sock; iev->ev_sender = sock;
iev->action = internal_accept; iev->ev_action = internal_accept;
iev->arg = sock; iev->ev_arg = sock;
isc_task_send(ev->sender, (isc_event_t **)&iev); isc_task_send(ev->ev_sender, (isc_event_t **)&iev);
} }
static void static void
@ -1308,11 +1310,11 @@ dispatch_connect(isc_socket_t *sock)
INSIST(sock->connecting); INSIST(sock->connecting);
sock->references++; /* keep socket around for this internal event */ sock->references++; /* keep socket around for this internal event */
iev->sender = sock; iev->ev_sender = sock;
iev->action = internal_connect; iev->ev_action = internal_connect;
iev->arg = sock; iev->ev_arg = sock;
isc_task_send(ev->sender, (isc_event_t **)&iev); isc_task_send(ev->ev_sender, (isc_event_t **)&iev);
} }
/* /*
@ -1331,13 +1333,13 @@ send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev,
{ {
isc_task_t *task; isc_task_t *task;
task = (*dev)->sender; task = (*dev)->ev_sender;
(*dev)->result = resultcode; (*dev)->result = resultcode;
(*dev)->sender = sock; (*dev)->ev_sender = sock;
if (ISC_LINK_LINKED(*dev, link)) if (ISC_LINK_LINKED(*dev, ev_link))
ISC_LIST_DEQUEUE(sock->recv_list, *dev, link); ISC_LIST_DEQUEUE(sock->recv_list, *dev, ev_link);
if (sock->recv_result != ISC_R_SUCCESS) if (sock->recv_result != ISC_R_SUCCESS)
(*dev)->attributes |= ISC_SOCKEVENTATTR_FATALERROR; (*dev)->attributes |= ISC_SOCKEVENTATTR_FATALERROR;
@ -1360,13 +1362,14 @@ send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev,
{ {
isc_task_t *task; isc_task_t *task;
task = (*dev)->sender; INSIST(dev != NULL && *dev != NULL);
task = (*dev)->ev_sender;
(*dev)->result = resultcode; (*dev)->result = resultcode;
(*dev)->sender = sock; (*dev)->ev_sender = sock;
if (ISC_LINK_LINKED(*dev, link)) if (ISC_LINK_LINKED(*dev, ev_link))
ISC_LIST_DEQUEUE(sock->send_list, *dev, link); ISC_LIST_DEQUEUE(sock->send_list, *dev, ev_link);
if (sock->send_result != ISC_R_SUCCESS) if (sock->send_result != ISC_R_SUCCESS)
(*dev)->attributes |= ISC_SOCKEVENTATTR_FATALERROR; (*dev)->attributes |= ISC_SOCKEVENTATTR_FATALERROR;
@ -1400,9 +1403,9 @@ internal_accept(isc_task_t *me, isc_event_t *ev)
int fd; int fd;
isc_result_t result = ISC_R_SUCCESS; isc_result_t result = ISC_R_SUCCESS;
(void)me; UNUSED(me);
sock = ev->sender; sock = ev->ev_sender;
INSIST(VALID_SOCKET(sock)); INSIST(VALID_SOCKET(sock));
LOCK(&sock->lock); LOCK(&sock->lock);
@ -1468,7 +1471,7 @@ internal_accept(isc_task_t *me, isc_event_t *ev)
/* /*
* Pull off the done event. * Pull off the done event.
*/ */
ISC_LIST_UNLINK(sock->accept_list, dev, link); ISC_LIST_UNLINK(sock->accept_list, dev, ev_link);
/* /*
* Poke watcher if there are more pending accepts. * Poke watcher if there are more pending accepts.
@ -1517,8 +1520,8 @@ internal_accept(isc_task_t *me, isc_event_t *ev)
* Fill in the done event details and send it off. * Fill in the done event details and send it off.
*/ */
dev->result = result; dev->result = result;
task = dev->sender; task = dev->ev_sender;
dev->sender = sock; dev->ev_sender = sock;
isc_task_sendanddetach(&task, (isc_event_t **)&dev); isc_task_sendanddetach(&task, (isc_event_t **)&dev);
} }
@ -1530,11 +1533,11 @@ internal_recv(isc_task_t *me, isc_event_t *ev)
isc_socket_t *sock; isc_socket_t *sock;
isc_task_t *task; isc_task_t *task;
(void)me; UNUSED(me);
INSIST(ev->type == ISC_SOCKEVENT_INTR); INSIST(ev->ev_type == ISC_SOCKEVENT_INTR);
sock = ev->sender; sock = ev->ev_sender;
INSIST(VALID_SOCKET(sock)); INSIST(VALID_SOCKET(sock));
LOCK(&sock->lock); LOCK(&sock->lock);
@ -1561,13 +1564,13 @@ internal_recv(isc_task_t *me, isc_event_t *ev)
*/ */
dev = ISC_LIST_HEAD(sock->recv_list); dev = ISC_LIST_HEAD(sock->recv_list);
while (dev != NULL) { while (dev != NULL) {
task = dev->sender; task = dev->ev_sender;
/* /*
* If this is a marker event, post its completion and * If this is a marker event, post its completion and
* continue the loop. * continue the loop.
*/ */
if (dev->type == ISC_SOCKEVENT_RECVMARK) { if (dev->ev_type == ISC_SOCKEVENT_RECVMARK) {
send_recvdone_event(sock, &dev, sock->recv_result); send_recvdone_event(sock, &dev, sock->recv_result);
goto next; goto next;
} }
@ -1621,14 +1624,14 @@ internal_send(isc_task_t *me, isc_event_t *ev)
isc_socket_t *sock; isc_socket_t *sock;
isc_task_t *task; isc_task_t *task;
(void)me; UNUSED(me);
INSIST(ev->type == ISC_SOCKEVENT_INTW); INSIST(ev->ev_type == ISC_SOCKEVENT_INTW);
/* /*
* Find out what socket this is and lock it. * Find out what socket this is and lock it.
*/ */
sock = (isc_socket_t *)ev->sender; sock = (isc_socket_t *)ev->ev_sender;
INSIST(VALID_SOCKET(sock)); INSIST(VALID_SOCKET(sock));
LOCK(&sock->lock); LOCK(&sock->lock);
@ -1655,13 +1658,13 @@ internal_send(isc_task_t *me, isc_event_t *ev)
*/ */
dev = ISC_LIST_HEAD(sock->send_list); dev = ISC_LIST_HEAD(sock->send_list);
while (dev != NULL) { while (dev != NULL) {
task = dev->sender; task = dev->ev_sender;
/* /*
* If this is a marker event, post its completion and * If this is a marker event, post its completion and
* continue the loop. * continue the loop.
*/ */
if (dev->type == ISC_SOCKEVENT_SENDMARK) { if (dev->ev_type == ISC_SOCKEVENT_SENDMARK) {
send_senddone_event(sock, &dev, sock->send_result); send_senddone_event(sock, &dev, sock->send_result);
goto next; goto next;
} }
@ -2138,7 +2141,7 @@ isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
dev->minimum = minimum; dev->minimum = minimum;
} }
dev->sender = task; dev->ev_sender = task;
/* /*
* Move each buffer from the passed in list to our internal one. * Move each buffer from the passed in list to our internal one.
@ -2193,7 +2196,7 @@ isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
* Enqueue the request. If the socket was previously not being * Enqueue the request. If the socket was previously not being
* watched, poke the watcher to start paying attention to it. * watched, poke the watcher to start paying attention to it.
*/ */
ISC_LIST_ENQUEUE(sock->recv_list, dev, link); ISC_LIST_ENQUEUE(sock->recv_list, dev, ev_link);
if (was_empty) if (was_empty)
select_poke(sock->manager, sock->fd); select_poke(sock->manager, sock->fd);
@ -2245,7 +2248,7 @@ isc_socket_recv(isc_socket_t *sock, isc_region_t *region, unsigned int minimum,
dev->result = ISC_R_SUCCESS; dev->result = ISC_R_SUCCESS;
dev->n = 0; dev->n = 0;
dev->region = *region; dev->region = *region;
dev->sender = task; dev->ev_sender = task;
was_empty = ISC_LIST_EMPTY(sock->recv_list); was_empty = ISC_LIST_EMPTY(sock->recv_list);
@ -2291,7 +2294,7 @@ isc_socket_recv(isc_socket_t *sock, isc_region_t *region, unsigned int minimum,
* Enqueue the request. If the socket was previously not being * Enqueue the request. If the socket was previously not being
* watched, poke the watcher to start paying attention to it. * watched, poke the watcher to start paying attention to it.
*/ */
ISC_LIST_ENQUEUE(sock->recv_list, dev, link); ISC_LIST_ENQUEUE(sock->recv_list, dev, ev_link);
if (was_empty) if (was_empty)
select_poke(sock->manager, sock->fd); select_poke(sock->manager, sock->fd);
@ -2340,7 +2343,7 @@ isc_socket_sendto(isc_socket_t *sock, isc_region_t *region,
} }
dev->region = *region; dev->region = *region;
dev->sender = task; dev->ev_sender = task;
set_dev_address(address, sock, dev); set_dev_address(address, sock, dev);
if (pktinfo != NULL) { if (pktinfo != NULL) {
@ -2384,7 +2387,7 @@ isc_socket_sendto(isc_socket_t *sock, isc_region_t *region,
* Enqueue the request. If the socket was previously not being * Enqueue the request. If the socket was previously not being
* watched, poke the watcher to start paying attention to it. * watched, poke the watcher to start paying attention to it.
*/ */
ISC_LIST_ENQUEUE(sock->send_list, dev, link); ISC_LIST_ENQUEUE(sock->send_list, dev, ev_link);
if (was_empty) if (was_empty)
select_poke(sock->manager, sock->fd); select_poke(sock->manager, sock->fd);
@ -2441,7 +2444,7 @@ isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
*** to the task rather than this function failing. *** to the task rather than this function failing.
***/ ***/
dev->sender = task; dev->ev_sender = task;
set_dev_address(address, sock, dev); set_dev_address(address, sock, dev);
if (pktinfo != NULL) { if (pktinfo != NULL) {
@ -2495,7 +2498,7 @@ isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
* Enqueue the request. If the socket was previously not being * Enqueue the request. If the socket was previously not being
* watched, poke the watcher to start paying attention to it. * watched, poke the watcher to start paying attention to it.
*/ */
ISC_LIST_ENQUEUE(sock->send_list, dev, link); ISC_LIST_ENQUEUE(sock->send_list, dev, ev_link);
if (was_empty) if (was_empty)
select_poke(sock->manager, sock->fd); select_poke(sock->manager, sock->fd);
@ -2604,7 +2607,7 @@ isc_socket_accept(isc_socket_t *sock,
/* /*
* Sender field is overloaded here with the task we will be sending * Sender field is overloaded here with the task we will be sending
* this event to. Just before the actual event is delivered the * this event to. Just before the actual event is delivered the
* actual sender will be touched up to be the socket. * actual ev_sender will be touched up to be the socket.
*/ */
dev = (isc_socket_newconnev_t *) dev = (isc_socket_newconnev_t *)
isc_event_allocate(manager->mctx, task, ISC_SOCKEVENT_NEWCONN, isc_event_allocate(manager->mctx, task, ISC_SOCKEVENT_NEWCONN,
@ -2613,7 +2616,7 @@ isc_socket_accept(isc_socket_t *sock,
UNLOCK(&sock->lock); UNLOCK(&sock->lock);
return (ISC_R_NOMEMORY); return (ISC_R_NOMEMORY);
} }
ISC_LINK_INIT(dev, link); ISC_LINK_INIT(dev, ev_link);
ret = allocate_socket(manager, sock->type, &nsock); ret = allocate_socket(manager, sock->type, &nsock);
if (ret != ISC_R_SUCCESS) { if (ret != ISC_R_SUCCESS) {
@ -2628,7 +2631,7 @@ isc_socket_accept(isc_socket_t *sock,
isc_task_attach(task, &ntask); isc_task_attach(task, &ntask);
nsock->references++; nsock->references++;
dev->sender = ntask; dev->ev_sender = ntask;
dev->newsocket = nsock; dev->newsocket = nsock;
/* /*
@ -2639,7 +2642,7 @@ isc_socket_accept(isc_socket_t *sock,
if (EMPTY(sock->accept_list)) if (EMPTY(sock->accept_list))
select_poke(manager, sock->fd); select_poke(manager, sock->fd);
ISC_LIST_ENQUEUE(sock->accept_list, dev, link); ISC_LIST_ENQUEUE(sock->accept_list, dev, ev_link);
UNLOCK(&sock->lock); UNLOCK(&sock->lock);
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
@ -2677,7 +2680,7 @@ isc_socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr,
UNLOCK(&sock->lock); UNLOCK(&sock->lock);
return (ISC_R_NOMEMORY); return (ISC_R_NOMEMORY);
} }
ISC_LINK_INIT(dev, link); ISC_LINK_INIT(dev, ev_link);
/* /*
* Try to do the connect right away, as there can be only one * Try to do the connect right away, as there can be only one
@ -2737,7 +2740,7 @@ isc_socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr,
sock->connecting = 1; sock->connecting = 1;
dev->sender = ntask; dev->ev_sender = ntask;
/* /*
* poke watcher here. We still have the socket locked, so there * poke watcher here. We still have the socket locked, so there
@ -2765,10 +2768,10 @@ internal_connect(isc_task_t *me, isc_event_t *ev)
int cc; int cc;
ISC_SOCKADDR_LEN_T optlen; ISC_SOCKADDR_LEN_T optlen;
(void)me; UNUSED(me);
INSIST(ev->type == ISC_SOCKEVENT_INTW); INSIST(ev->ev_type == ISC_SOCKEVENT_INTW);
sock = ev->sender; sock = ev->ev_sender;
INSIST(VALID_SOCKET(sock)); INSIST(VALID_SOCKET(sock));
LOCK(&sock->lock); LOCK(&sock->lock);
@ -2849,8 +2852,8 @@ internal_connect(isc_task_t *me, isc_event_t *ev)
UNLOCK(&sock->lock); UNLOCK(&sock->lock);
task = dev->sender; task = dev->ev_sender;
dev->sender = sock; dev->ev_sender = sock;
isc_task_sendanddetach(&task, (isc_event_t **)&dev); isc_task_sendanddetach(&task, (isc_event_t **)&dev);
} }
@ -2933,8 +2936,8 @@ isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how)
dev = ISC_LIST_HEAD(sock->recv_list); dev = ISC_LIST_HEAD(sock->recv_list);
while (dev != NULL) { while (dev != NULL) {
current_task = dev->sender; current_task = dev->ev_sender;
next = ISC_LIST_NEXT(dev, link); next = ISC_LIST_NEXT(dev, ev_link);
if ((task == NULL) || (task == current_task)) if ((task == NULL) || (task == current_task))
send_recvdone_event(sock, &dev, send_recvdone_event(sock, &dev,
@ -2952,8 +2955,8 @@ isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how)
dev = ISC_LIST_HEAD(sock->send_list); dev = ISC_LIST_HEAD(sock->send_list);
while (dev != NULL) { while (dev != NULL) {
current_task = dev->sender; current_task = dev->ev_sender;
next = ISC_LIST_NEXT(dev, link); next = ISC_LIST_NEXT(dev, ev_link);
if ((task == NULL) || (task == current_task)) if ((task == NULL) || (task == current_task))
send_senddone_event(sock, &dev, send_senddone_event(sock, &dev,
@ -2970,18 +2973,19 @@ isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how)
dev = ISC_LIST_HEAD(sock->accept_list); dev = ISC_LIST_HEAD(sock->accept_list);
while (dev != NULL) { while (dev != NULL) {
current_task = dev->sender; current_task = dev->ev_sender;
next = ISC_LIST_NEXT(dev, link); next = ISC_LIST_NEXT(dev, ev_link);
if ((task == NULL) || (task == current_task)) { if ((task == NULL) || (task == current_task)) {
ISC_LIST_UNLINK(sock->accept_list, dev, link); ISC_LIST_UNLINK(sock->accept_list, dev,
ev_link);
dev->newsocket->references--; dev->newsocket->references--;
free_socket(&dev->newsocket); free_socket(&dev->newsocket);
dev->result = ISC_R_CANCELED; dev->result = ISC_R_CANCELED;
dev->sender = sock; dev->ev_sender = sock;
isc_task_sendanddetach(&current_task, isc_task_sendanddetach(&current_task,
(isc_event_t **)&dev); (isc_event_t **)&dev);
} }
@ -3002,13 +3006,13 @@ isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how)
sock->connecting = 0; sock->connecting = 0;
dev = sock->connect_ev; dev = sock->connect_ev;
current_task = dev->sender; current_task = dev->ev_sender;
if ((task == NULL) || (task == current_task)) { if ((task == NULL) || (task == current_task)) {
sock->connect_ev = NULL; sock->connect_ev = NULL;
dev->result = ISC_R_CANCELED; dev->result = ISC_R_CANCELED;
dev->sender = sock; dev->ev_sender = sock;
isc_task_sendanddetach(&current_task, isc_task_sendanddetach(&current_task,
(isc_event_t **)&dev); (isc_event_t **)&dev);
} }
@ -3064,9 +3068,9 @@ isc_socket_recvmark(isc_socket_t *sock,
*/ */
isc_task_attach(task, &ntask); isc_task_attach(task, &ntask);
dev->sender = ntask; dev->ev_sender = ntask;
ISC_LIST_ENQUEUE(sock->recv_list, dev, link); ISC_LIST_ENQUEUE(sock->recv_list, dev, ev_link);
XTRACE(TRACE_RECV, XTRACE(TRACE_RECV,
("isc_socket_recvmark: queued event dev %p, task %p\n", ("isc_socket_recvmark: queued event dev %p, task %p\n",
@ -3118,9 +3122,9 @@ isc_socket_sendmark(isc_socket_t *sock,
*/ */
isc_task_attach(task, &ntask); isc_task_attach(task, &ntask);
dev->sender = ntask; dev->ev_sender = ntask;
ISC_LIST_ENQUEUE(sock->send_list, dev, link); ISC_LIST_ENQUEUE(sock->send_list, dev, ev_link);
XTRACE(TRACE_SEND, XTRACE(TRACE_SEND,
("isc_socket_sendmark: queued event dev %p, task %p\n", ("isc_socket_sendmark: queued event dev %p, task %p\n",

3
lib/lwres/include/lwres/lwres.h
View File

@ -430,8 +430,7 @@ void
lwres_conf_clear(lwres_context_t *ctx); lwres_conf_clear(lwres_context_t *ctx);
/* /*
* frees all internally allocated memory in confdata. Uses the memory * frees all internally allocated memory in confdata. Uses the memory
* routines supplies by ctx (so that should probably be the same value as * routines supplied by ctx.
* given to lwres_conf_parse()).
*/ */
lwres_conf_t * lwres_conf_t *

14
lib/omapi/connection.c
View File

@ -15,7 +15,7 @@
* SOFTWARE. * SOFTWARE.
*/ */
/* $Id: connection.c,v 1.18 2000/04/12 01:40:58 halley Exp $ */ /* $Id: connection.c,v 1.19 2000/04/17 19:22:43 explorer Exp $ */
/* Principal Author: DCL */ /* Principal Author: DCL */
@ -249,8 +249,8 @@ connect_done(isc_task_t *task, isc_event_t *event) {
isc_socket_t *socket; isc_socket_t *socket;
omapi_connection_t *connection; omapi_connection_t *connection;
socket = event->sender; socket = event->ev_sender;
connection = event->arg; connection = event->ev_arg;
result = ((isc_socket_connev_t *)event)->result; result = ((isc_socket_connev_t *)event)->result;
isc_event_free(&event); isc_event_free(&event);
@ -308,8 +308,8 @@ recv_done(isc_task_t *task, isc_event_t *event) {
omapi_connection_t *connection; omapi_connection_t *connection;
unsigned int bytes_read; unsigned int bytes_read;
socket = event->sender; socket = event->ev_sender;
connection = event->arg; connection = event->ev_arg;
socketevent = (isc_socketevent_t *)event; socketevent = (isc_socketevent_t *)event;
bufferlist = socketevent->bufferlist; bufferlist = socketevent->bufferlist;
bytes_read = socketevent->n; bytes_read = socketevent->n;
@ -394,8 +394,8 @@ send_done(isc_task_t *task, isc_event_t *event) {
omapi_connection_t *connection; omapi_connection_t *connection;
unsigned int sent_bytes; unsigned int sent_bytes;
socket = event->sender; socket = event->ev_sender;
connection = event->arg; connection = event->ev_arg;
socketevent = (isc_socketevent_t *)event; socketevent = (isc_socketevent_t *)event;
sent_bytes = socketevent->n; sent_bytes = socketevent->n;
bufferlist = socketevent->bufferlist; bufferlist = socketevent->bufferlist;

2
lib/omapi/listener.c
View File

@ -81,7 +81,7 @@ listener_accept(isc_task_t *task, isc_event_t *event) {
result = ((isc_socket_newconnev_t *)event)->result; result = ((isc_socket_newconnev_t *)event)->result;
socket = ((isc_socket_newconnev_t *)event)->newsocket; socket = ((isc_socket_newconnev_t *)event)->newsocket;
listener = (omapi_listener_t *)event->arg; listener = (omapi_listener_t *)event->ev_arg;
/* /*
* No more need for the event, once all the desired data has been * No more need for the event, once all the desired data has been