diff --git a/bin/lwresd/client.c b/bin/lwresd/client.c index 3214655cd5..762d999eec 100644 --- a/bin/lwresd/client.c +++ b/bin/lwresd/client.c @@ -145,7 +145,7 @@ process_request(client_t *client) void 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; isc_socketevent_t *dev = (isc_socketevent_t *)ev; @@ -242,10 +242,10 @@ client_start_recv(clientmgr_t *cm) void 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(ev->type == LWRD_SHUTDOWN); + REQUIRE(ev->ev_type == LWRD_SHUTDOWN); REQUIRE((cm->flags & CLIENTMGR_FLAG_SHUTTINGDOWN) == 0); DP(50, "Got shutdown event, task %p", task); @@ -295,7 +295,7 @@ client_state_idle(client_t *client) void 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; isc_socketevent_t *dev = (isc_socketevent_t *)ev; diff --git a/bin/lwresd/process_gabn.c b/bin/lwresd/process_gabn.c index 5781e9f663..9996b0fa69 100644 --- a/bin/lwresd/process_gabn.c +++ b/bin/lwresd/process_gabn.c @@ -278,13 +278,13 @@ store_realname(client_t *client) static void process_gabn_finddone(isc_task_t *task, isc_event_t *ev) { - client_t *client = ev->arg; - isc_eventtype_t result; + client_t *client = ev->ev_arg; + isc_eventtype_t evtype; isc_boolean_t claimed; DP(50, "Find done for task %p, client %p", task, client); - result = ev->type; + evtype = ev->ev_type; 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. */ claimed = ISC_FALSE; - if (result == DNS_EVENT_ADBNOMOREADDRESSES) { + if (evtype == DNS_EVENT_ADBNOMOREADDRESSES) { if (NEED_V4(client)) { client->v4find = client->find; 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 * it. */ - if (result == DNS_EVENT_ADBMOREADDRESSES) { + if (evtype == DNS_EVENT_ADBMOREADDRESSES) { start_find(client); return; } diff --git a/bin/lwresd/process_gnba.c b/bin/lwresd/process_gnba.c index 5c86fb04a8..d6bff7d4db 100644 --- a/bin/lwresd/process_gnba.c +++ b/bin/lwresd/process_gnba.c @@ -57,12 +57,12 @@ byaddr_done(isc_task_t *task, isc_event_t *event) isc_uint16_t naliases; isc_stdtime_t now; - (void)task; + UNUSED(task); lwb.base = NULL; - client = event->arg; + client = event->ev_arg; cm = client->clientmgr; - INSIST(client->byaddr == event->sender); + INSIST(client->byaddr == event->ev_sender); bevent = (dns_byaddrevent_t *)event; gnba = &client->gnba; diff --git a/bin/named/client.c b/bin/named/client.c index 6b134ab937..44ef39145e 100644 --- a/bin/named/client.c +++ b/bin/named/client.c @@ -460,8 +460,8 @@ client_shutdown(isc_task_t *task, isc_event_t *event) { ns_client_t *client; REQUIRE(event != NULL); - REQUIRE(event->type == ISC_TASKEVENT_SHUTDOWN); - client = event->arg; + REQUIRE(event->ev_type == ISC_TASKEVENT_SHUTDOWN); + client = event->ev_arg; REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(task == client->task); @@ -476,7 +476,7 @@ client_shutdown(isc_task_t *task, isc_event_t *event) { } 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; REQUIRE(sevent != NULL); - REQUIRE(sevent->type == ISC_SOCKEVENT_SENDDONE); - client = sevent->arg; + REQUIRE(sevent->ev_type == ISC_SOCKEVENT_SENDDONE); + client = sevent->ev_arg; REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(task == client->task); @@ -812,7 +812,7 @@ client_request(isc_task_t *task, isc_event_t *event) { isc_boolean_t ra; /* Recursion available. */ REQUIRE(event != NULL); - client = event->arg; + client = event->ev_arg; REQUIRE(NS_CLIENT_VALID(client)); 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); 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)); devent = (dns_dispatchevent_t *)event; REQUIRE(client->dispentry != NULL); @@ -835,7 +835,7 @@ client_request(isc_task_t *task, isc_event_t *event) { result = devent->result; client->peeraddr = devent->addr; 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->pktinfo = devent->pktinfo; } else { @@ -843,8 +843,8 @@ client_request(isc_task_t *task, isc_event_t *event) { } } else { INSIST(TCP_CLIENT(client)); - REQUIRE(event->type == DNS_EVENT_TCPMSG); - REQUIRE(event->sender == &client->tcpmsg); + REQUIRE(event->ev_type == DNS_EVENT_TCPMSG); + REQUIRE(event->ev_sender == &client->tcpmsg); buffer = &client->tcpmsg.buffer; result = client->tcpmsg.result; INSIST(client->nreads == 1); @@ -1069,9 +1069,9 @@ client_timeout(isc_task_t *task, isc_event_t *event) { ns_client_t *client; REQUIRE(event != NULL); - REQUIRE(event->type == ISC_TIMEREVENT_LIFE || - event->type == ISC_TIMEREVENT_IDLE); - client = event->arg; + REQUIRE(event->ev_type == ISC_TIMEREVENT_LIFE || + event->ev_type == ISC_TIMEREVENT_IDLE); + client = event->ev_arg; REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(task == client->task); REQUIRE(client->timer != NULL); @@ -1233,11 +1233,11 @@ client_read(ns_client_t *client) { static void 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_result_t result; - REQUIRE(event->type == ISC_SOCKEVENT_NEWCONN); + REQUIRE(event->ev_type == ISC_SOCKEVENT_NEWCONN); REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(client->task == task); diff --git a/bin/named/query.c b/bin/named/query.c index c227184ede..31cab15819 100644 --- a/bin/named/query.c +++ b/bin/named/query.c @@ -1653,8 +1653,8 @@ query_resume(isc_task_t *task, isc_event_t *event) { * Resume a query after recursion. */ - REQUIRE(event->type == DNS_EVENT_FETCHDONE); - client = devent->arg; + REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE); + client = devent->ev_arg; REQUIRE(NS_CLIENT_VALID(client)); REQUIRE(task == client->task); REQUIRE(RECURSING(client)); diff --git a/bin/named/server.c b/bin/named/server.c index 86a4788d77..a64c540f4f 100644 --- a/bin/named/server.c +++ b/bin/named/server.c @@ -1076,7 +1076,7 @@ scan_interfaces(ns_server_t *server) { */ static void 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); isc_event_free(&event); RWLOCK(&server->conflock, isc_rwlocktype_write); @@ -1390,7 +1390,7 @@ load_zones(ns_server_t *server, isc_boolean_t stop) { static void run_server(isc_task_t *task, isc_event_t *event) { 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); @@ -1424,7 +1424,7 @@ run_server(isc_task_t *task, isc_event_t *event) { static void shutdown_server(isc_task_t *task, isc_event_t *event) { 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); @@ -1580,7 +1580,7 @@ fatal(char *msg, isc_result_t result) { static void ns_server_reload(isc_task_t *task, isc_event_t *event) { 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); result = load_configuration(ns_g_conffile, server, ISC_FALSE); diff --git a/bin/named/update.c b/bin/named/update.c index 976d5b60ae..abc08bd241 100644 --- a/bin/named/update.c +++ b/bin/named/update.c @@ -1753,14 +1753,14 @@ send_update_event(ns_client_t *client, dns_zone_t *zone) { evclient = NULL; ns_client_attach(client, &evclient); - event->arg = evclient; + event->ev_arg = evclient; dns_zone_gettask(zone, &zonetask); - isc_task_send(zonetask, (isc_event_t **) &event); + isc_task_send(zonetask, (isc_event_t **)&event); failure: if (event != NULL) - isc_event_free((isc_event_t **) &event); + isc_event_free((isc_event_t **)&event); return (result); } @@ -1855,7 +1855,7 @@ update_action(isc_task_t *task, isc_event_t *event) { update_event_t *uev = (update_event_t *) event; 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; dns_db_t *db = NULL; @@ -1871,7 +1871,7 @@ update_action(isc_task_t *task, isc_event_t *event) dns_name_t *zonename; 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, &temp); @@ -2294,8 +2294,8 @@ update_action(isc_task_t *task, isc_event_t *event) isc_task_detach(&task); uev->result = result; - uev->type = DNS_EVENT_UPDATEDONE; - uev->action = updatedone_action; + uev->ev_type = DNS_EVENT_UPDATEDONE; + uev->ev_action = updatedone_action; isc_task_send(client->task, &event); INSIST(event == NULL); } @@ -2304,9 +2304,9 @@ static void updatedone_action(isc_task_t *task, isc_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); respond(client, uev->result); diff --git a/bin/named/xfrout.c b/bin/named/xfrout.c index d4cb8b158e..89e61579b2 100644 --- a/bin/named/xfrout.c +++ b/bin/named/xfrout.c @@ -15,7 +15,7 @@ * 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 @@ -1431,15 +1431,19 @@ xfrout_ctx_destroy(xfrout_ctx_t **xfrp) { static void xfrout_senddone(isc_task_t *task, isc_event_t *event) { - isc_socketevent_t *sev = (isc_socketevent_t *) event; - xfrout_ctx_t *xfr = (xfrout_ctx_t *) event->arg; + isc_socketevent_t *sev = (isc_socketevent_t *)event; + xfrout_ctx_t *xfr = (xfrout_ctx_t *)event->ev_arg; isc_result_t evresult = sev->result; + UNUSED(task); - INSIST(event->type == ISC_SOCKEVENT_SENDDONE); + + INSIST(event->ev_type == ISC_SOCKEVENT_SENDDONE); + isc_event_free(&event); xfr->sends--; INSIST(xfr->sends == 0); - (void) isc_timer_touch(xfr->client->timer); + + (void)isc_timer_touch(xfr->client->timer); if (xfr->shuttingdown == ISC_TRUE) { xfrout_maybe_destroy(xfr); } else if (evresult != ISC_R_SUCCESS) { diff --git a/bin/tests/adb_test.c b/bin/tests/adb_test.c index 5fdcd69055..51a59f9c21 100644 --- a/bin/tests/adb_test.c +++ b/bin/tests/adb_test.c @@ -138,11 +138,11 @@ lookup_callback(isc_task_t *task, isc_event_t *ev) { client_t *client; - client = ev->arg; - INSIST(client->find == ev->sender); + client = ev->ev_arg; + INSIST(client->find == ev->ev_sender); 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); diff --git a/bin/tests/byaddr_test.c b/bin/tests/byaddr_test.c index 1fb496291d..3bbd0fc497 100644 --- a/bin/tests/byaddr_test.c +++ b/bin/tests/byaddr_test.c @@ -60,7 +60,7 @@ done(isc_task_t *task, isc_event_t *event) { isc_result_t result; isc_region_t r; - REQUIRE(event->type == DNS_EVENT_BYADDRDONE); + REQUIRE(event->ev_type == DNS_EVENT_BYADDRDONE); bevent = (dns_byaddrevent_t *)event; (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); isc_event_free(&event); diff --git a/bin/tests/byname_test.c b/bin/tests/byname_test.c index 43d727a614..2c5308824f 100644 --- a/bin/tests/byname_test.c +++ b/bin/tests/byname_test.c @@ -200,7 +200,7 @@ do_find(isc_boolean_t want_event) { static void adb_callback(isc_task_t *etask, isc_event_t *event) { - unsigned int type = event->type; + unsigned int type = event->ev_type; REQUIRE(etask == task); diff --git a/bin/tests/dispatch_tcp_test.c b/bin/tests/dispatch_tcp_test.c index e45ea94f6b..928968aae7 100644 --- a/bin/tests/dispatch_tcp_test.c +++ b/bin/tests/dispatch_tcp_test.c @@ -124,7 +124,7 @@ void send_done(isc_task_t *task, isc_event_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; @@ -252,7 +252,7 @@ void got_response(isc_task_t *task, isc_event_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; isc_result_t result; @@ -283,7 +283,7 @@ void got_request(isc_task_t *task, isc_event_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; dns_message_t *msg; isc_result_t result; diff --git a/bin/tests/dispatch_test.c b/bin/tests/dispatch_test.c index b9886905dd..73081c43e6 100644 --- a/bin/tests/dispatch_test.c +++ b/bin/tests/dispatch_test.c @@ -103,7 +103,7 @@ void send_done(isc_task_t *task, isc_event_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; @@ -231,7 +231,7 @@ void got_response(isc_task_t *task, isc_event_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; isc_result_t result; unsigned int cnt; @@ -286,7 +286,7 @@ void got_request(isc_task_t *task, isc_event_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; isc_result_t result; unsigned int cnt; diff --git a/bin/tests/lwresconf_test.c b/bin/tests/lwresconf_test.c index 772f5ae153..07f264381f 100644 --- a/bin/tests/lwresconf_test.c +++ b/bin/tests/lwresconf_test.c @@ -65,7 +65,6 @@ int main(int argc, char *argv[]) { lwres_context_t *ctx; - lwres_conf_t conf; const char *file = "/etc/resolv.conf"; int ret; #ifdef USE_ISC_MEM @@ -91,14 +90,14 @@ main(int argc, char *argv[]) #endif CHECK(ret, "lwres_context_create"); - lwres_conf_init(&conf); - if (lwres_conf_parse(ctx, file, &conf) == 0) { - lwres_conf_print(stderr, &conf); + lwres_conf_init(ctx); + if (lwres_conf_parse(ctx, file) == 0) { + lwres_conf_print(ctx, stderr); } else { perror("lwres_conf_parse"); } - lwres_conf_clear(ctx, &conf); + lwres_conf_clear(ctx); lwres_context_destroy(&ctx); #ifdef USE_ISC_MEM diff --git a/bin/tests/omapi_test.c b/bin/tests/omapi_test.c index 9128be1f08..09c5e2849f 100644 --- a/bin/tests/omapi_test.c +++ b/bin/tests/omapi_test.c @@ -531,7 +531,7 @@ do_connect(const char *host, int port) { static void 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); diff --git a/bin/tests/ratelimiter_test.c b/bin/tests/ratelimiter_test.c index 851a6a421c..0649c886b3 100644 --- a/bin/tests/ratelimiter_test.c +++ b/bin/tests/ratelimiter_test.c @@ -45,7 +45,7 @@ utick(isc_task_t *task, isc_event_t *event) { (void) task; printf("utick\n"); - event->action = ltick; + event->ev_action = ltick; isc_ratelimiter_enqueue(rlim, &event); } diff --git a/bin/tests/sdig.c b/bin/tests/sdig.c index 64cff0c0da..63bd58a64a 100644 --- a/bin/tests/sdig.c +++ b/bin/tests/sdig.c @@ -36,6 +36,8 @@ extern int h_errno; #include #include +#include + #include #include #include @@ -187,10 +189,10 @@ recv_done(isc_task_t *task, isc_event_t *event) { isc_buffer_t *b; isc_result_t result; - REQUIRE(event->type == ISC_SOCKEVENT_RECVDONE); + REQUIRE(event->ev_type == ISC_SOCKEVENT_RECVDONE); sevent = (isc_socketevent_t *)event; - (void)task; + UNUSED(task); /* * 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 send_done(isc_task_t *task, isc_event_t *event) { - (void)task; + UNUSED(task); + isc_event_free(&event); } diff --git a/bin/tests/shutdown_test.c b/bin/tests/shutdown_test.c index 7760717c0b..ea5c280545 100644 --- a/bin/tests/shutdown_test.c +++ b/bin/tests/shutdown_test.c @@ -57,7 +57,7 @@ static isc_timermgr_t * timer_manager; static void 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); isc_task_detach(&info->task); @@ -66,7 +66,7 @@ t1_shutdown(isc_task_t *task, isc_event_t *event) { static void 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); info->exiting = ISC_TRUE; @@ -75,10 +75,10 @@ t2_shutdown(isc_task_t *task, isc_event_t *event) { static void 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; - INSIST(event->type == ISC_TASKEVENT_SHUTDOWN); + INSIST(event->ev_type == ISC_TASKEVENT_SHUTDOWN); printf("task %s (%p) shutdown\n", info->name, task); if (strcmp(info->name, "0") == 0) { @@ -102,10 +102,10 @@ foo_event(isc_task_t *task, isc_event_t *event) { static void tick(isc_task_t *task, isc_event_t *event) { - t_info *info = event->arg; + t_info *info = event->ev_arg; 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); diff --git a/bin/tests/sock_test.c b/bin/tests/sock_test.c index 2c5d418f3d..b4e8239c2a 100644 --- a/bin/tests/sock_test.c +++ b/bin/tests/sock_test.c @@ -41,7 +41,7 @@ static void my_recv(isc_task_t *task, isc_event_t *event); static void 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); fflush(stdout); @@ -57,11 +57,11 @@ my_recv(isc_task_t *task, isc_event_t *event) char buf[1024]; char host[256]; - sock = event->sender; + sock = event->ev_sender; dev = (isc_socketevent_t *)event; 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->n, dev->result); 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 */ - if (strcmp(event->arg, "so2") != 0) { + if (strcmp(event->ev_arg, "so2") != 0) { region = dev->region; sprintf(buf, "\r\nReceived: %.*s\r\n\r\n", (int)dev->n, (char *)region.base); region.base = isc_mem_get(mctx, strlen(buf) + 1); region.length = strlen(buf) + 1; strcpy((char *)region.base, buf); /* strcpy is safe */ - isc_socket_send(sock, ®ion, task, my_send, event->arg); + isc_socket_send(sock, ®ion, task, my_send, event->ev_arg); } else { region = dev->region; printf("\r\nReceived: %.*s\r\n\r\n", (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); } @@ -115,11 +115,11 @@ my_send(isc_task_t *task, isc_event_t *event) isc_socket_t *sock; isc_socketevent_t *dev; - sock = event->sender; + sock = event->ev_sender; dev = (isc_socketevent_t *)event; 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->n, dev->result); @@ -139,11 +139,11 @@ my_http_get(isc_task_t *task, isc_event_t *event) isc_socket_t *sock; isc_socketevent_t *dev; - sock = event->sender; + sock = event->ev_sender; 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", - (char *)(event->arg), task, sock, + (char *)(event->ev_arg), task, sock, dev->region.base, dev->region.length, dev->n, dev->result); @@ -154,7 +154,7 @@ my_http_get(isc_task_t *task, isc_event_t *event) 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); } @@ -167,10 +167,10 @@ my_connect(isc_task_t *task, isc_event_t *event) isc_region_t region; char buf[1024]; - sock = event->sender; + sock = event->ev_sender; 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); 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; strcpy((char *)region.base, buf); /* strcpy is safe */ - isc_socket_send(sock, ®ion, task, my_http_get, event->arg); + isc_socket_send(sock, ®ion, task, my_http_get, event->ev_arg); isc_event_free(&event); } @@ -197,7 +197,7 @@ my_connect(isc_task_t *task, isc_event_t *event) static void 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_region_t region; isc_socket_t *oldsock; @@ -206,14 +206,14 @@ my_listen(isc_task_t *task, isc_event_t *event) dev = (isc_socket_newconnev_t *)event; 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); if (dev->result == ISC_R_SUCCESS) { /* * 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.length = 20; @@ -226,11 +226,11 @@ my_listen(isc_task_t *task, isc_event_t *event) RUNTIME_CHECK(isc_task_create(manager, 0, &newtask) == ISC_R_SUCCESS); isc_socket_recv(dev->newsocket, ®ion, 1, - newtask, my_recv, event->arg); + newtask, my_recv, event->ev_arg); isc_task_detach(&newtask); } else { - printf("detaching from socket %p\n", event->sender); - oldsock = event->sender; + printf("detaching from socket %p\n", event->ev_sender); + oldsock = event->ev_sender; isc_socket_detach(&oldsock); @@ -245,12 +245,12 @@ my_listen(isc_task_t *task, isc_event_t *event) static void 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); 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); } diff --git a/bin/tests/task_test.c b/bin/tests/task_test.c index c2fa4d77dc..2a9d855f76 100644 --- a/bin/tests/task_test.c +++ b/bin/tests/task_test.c @@ -35,7 +35,7 @@ static void my_callback(isc_task_t *task, isc_event_t *event) { int i, j; - char *name = event->arg; + char *name = event->ev_arg; j = 0; for (i = 0; i < 1000000; i++) @@ -46,7 +46,7 @@ my_callback(isc_task_t *task, isc_event_t *event) static void 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); isc_event_free(&event); @@ -55,7 +55,7 @@ my_shutdown(isc_task_t *task, isc_event_t *event) { static void 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); isc_event_free(&event); diff --git a/bin/tests/tasks/t_tasks.c b/bin/tests/tasks/t_tasks.c index 1ebae31765..cfcd93980f 100644 --- a/bin/tests/tasks/t_tasks.c +++ b/bin/tests/tasks/t_tasks.c @@ -66,7 +66,7 @@ t1_callback(isc_task_t *task, isc_event_t *event) for (i = 0; i < 1000000; i++) j += 100; - t_info("task %s\n", event->arg); + t_info("task %s\n", event->ev_arg); isc_event_free(&event); } @@ -74,7 +74,7 @@ static void t1_shutdown(isc_task_t *task, isc_event_t *event) { task = task; - t_info("shutdown %s\n", event->arg); + t_info("shutdown %s\n", event->ev_arg); isc_event_free(&event); } @@ -82,7 +82,7 @@ static void my_tick(isc_task_t *task, isc_event_t *event) { task = task; - t_info("%s\n", event->arg); + t_info("%s\n", event->ev_arg); isc_event_free(&event); } @@ -404,8 +404,8 @@ t2_shutdown(isc_task_t *task, isc_event_t *event) { task = task; /* notused */ - if (event->arg != NULL) { - isc_task_destroy((isc_task_t**) &event->arg); + if (event->ev_arg != NULL) { + isc_task_destroy((isc_task_t**) &event->ev_arg); } else { 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); } - 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 */ newtask = NULL; @@ -1315,41 +1315,41 @@ t10_event2(isc_task_t *task, isc_event_t *event) { if (T_debug) { t_info("Event %p,%d,%d,%s\n", - event->sender, - (int) event->type, - event->tag, - event->attributes & ISC_EVENTATTR_NOPURGE ? "NP" : "P"); + event->ev_sender, + (int) event->ev_type, + event->ev_tag, + event->ev_attributes & ISC_EVENTATTR_NOPURGE ? "NP" : "P"); } if ((T10_purge_sender == 0) || - (T10_purge_sender == event->sender)) { + (T10_purge_sender == event->ev_sender)) { sender_match = 1; } if (T10_testrange == 0) { - if (T10_purge_type_first == event->type) { + if (T10_purge_type_first == event->ev_type) { type_match = 1; } } else { - if ((T10_purge_type_first <= event->type) && - (event->type <= T10_purge_type_last)) { + if ((T10_purge_type_first <= event->ev_type) && + (event->ev_type <= T10_purge_type_last)) { type_match = 1; } } if ((T10_purge_tag == NULL) || - (T10_purge_tag == event->tag)) { + (T10_purge_tag == event->ev_tag)) { tag_match = 1; } 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", - event->sender, (int) event->type, event->tag); + event->ev_sender, (int) event->ev_type, event->ev_tag); ++T10_eventcnt; } else { 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 { @@ -1522,11 +1522,11 @@ t_taskpurge_x( int sender, int type, int tag, NULL, 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 */ 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; } } @@ -1886,9 +1886,9 @@ t_tasks11(int purgable) { sizeof(*event2)); event2_clone = event2; if (purgable) - event2->attributes &= ~ISC_EVENTATTR_NOPURGE; + event2->ev_attributes &= ~ISC_EVENTATTR_NOPURGE; else - event2->attributes |= ISC_EVENTATTR_NOPURGE; + event2->ev_attributes |= ISC_EVENTATTR_NOPURGE; isc_task_send(task, &event2); diff --git a/bin/tests/timer_test.c b/bin/tests/timer_test.c index 3e8f3bdd7f..bd76323590 100644 --- a/bin/tests/timer_test.c +++ b/bin/tests/timer_test.c @@ -37,7 +37,7 @@ int tick_count = 0; static void 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); isc_event_free(&event); @@ -46,9 +46,9 @@ shutdown_task(isc_task_t *task, isc_event_t *event) { static void 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); @@ -75,13 +75,13 @@ tick(isc_task_t *task, isc_event_t *event) static void timeout(isc_task_t *task, isc_event_t *event) { - char *name = event->arg; + char *name = event->ev_arg; char *type; - INSIST(event->type == ISC_TIMEREVENT_IDLE || - event->type == ISC_TIMEREVENT_LIFE); + INSIST(event->ev_type == ISC_TIMEREVENT_IDLE || + event->ev_type == ISC_TIMEREVENT_LIFE); - if (event->type == ISC_TIMEREVENT_IDLE) + if (event->ev_type == ISC_TIMEREVENT_IDLE) type = "idle"; else type = "life"; diff --git a/bin/tests/timers/t_timers.c b/bin/tests/timers/t_timers.c index d37670cfd9..cb31311953 100644 --- a/bin/tests/timers/t_timers.c +++ b/bin/tests/timers/t_timers.c @@ -104,12 +104,12 @@ tx_te(isc_task_t *task, isc_event_t *event) { t_info("tick %d\n", Tx_eventcnt); 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; - if (event->type != expected_event_type) { + if (event->ev_type != expected_event_type) { t_info("expected event type %d, got %d\n", - expected_event_type, (int) event->type); + expected_event_type, (int) event->ev_type); ++Tx_nfails; } @@ -444,9 +444,9 @@ t3_te(isc_task_t *task, isc_event_t *event) { ++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", - event->type, ISC_TIMEREVENT_IDLE); + event->ev_type, ISC_TIMEREVENT_IDLE); ++Tx_nfails; } @@ -545,9 +545,9 @@ t4_te(isc_task_t *task, isc_event_t *event) { } 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", - event->type, ISC_TIMEREVENT_IDLE); + event->ev_type, ISC_TIMEREVENT_IDLE); ++Tx_nfails; } if (Tx_eventcnt == 2) { @@ -571,9 +571,9 @@ t4_te(isc_task_t *task, isc_event_t *event) { } } else { - if (event->type != ISC_TIMEREVENT_LIFE) { + if (event->ev_type != ISC_TIMEREVENT_LIFE) { t_info("received event type %d, expected type %d\n", - event->type, ISC_TIMEREVENT_IDLE); + event->ev_type, ISC_TIMEREVENT_IDLE); ++Tx_nfails; } diff --git a/bin/tests/tkey_test.c b/bin/tests/tkey_test.c index de4ac3ea38..17393b5fd8 100644 --- a/bin/tests/tkey_test.c +++ b/bin/tests/tkey_test.c @@ -87,7 +87,7 @@ senddone(isc_task_t *task, isc_event_t *event) { isc_socketevent_t *sevent = (isc_socketevent_t *)event; REQUIRE(sevent != NULL); - REQUIRE(sevent->type == ISC_SOCKEVENT_SENDDONE); + REQUIRE(sevent->ev_type == ISC_SOCKEVENT_SENDDONE); REQUIRE(task == task1); printf("senddone\n"); @@ -102,7 +102,7 @@ recvdone(isc_task_t *task, isc_event_t *event) { isc_result_t result; REQUIRE(sevent != NULL); - REQUIRE(sevent->type == ISC_SOCKEVENT_RECVDONE); + REQUIRE(sevent->ev_type == ISC_SOCKEVENT_RECVDONE); REQUIRE(task == task1); printf("recvdone\n"); @@ -135,7 +135,7 @@ senddone2(isc_task_t *task, isc_event_t *event) { isc_socketevent_t *sevent = (isc_socketevent_t *)event; REQUIRE(sevent != NULL); - REQUIRE(sevent->type == ISC_SOCKEVENT_SENDDONE); + REQUIRE(sevent->ev_type == ISC_SOCKEVENT_SENDDONE); REQUIRE(task == task2); printf("senddone2\n"); @@ -150,7 +150,7 @@ recvdone2(isc_task_t *task, isc_event_t *event) { isc_result_t result; REQUIRE(sevent != NULL); - REQUIRE(sevent->type == ISC_SOCKEVENT_RECVDONE); + REQUIRE(sevent->ev_type == ISC_SOCKEVENT_RECVDONE); REQUIRE(task == task2); printf("recvdone2\n"); diff --git a/lib/dns/adb.c b/lib/dns/adb.c index 5df059e3e5..d035681df2 100644 --- a/lib/dns/adb.c +++ b/lib/dns/adb.c @@ -1038,12 +1038,12 @@ event_free(isc_event_t *event) dns_adbfind_t *find; INSIST(event != NULL); - find = event->destroy_arg; + find = event->ev_destroy_arg; INSIST(DNS_ADBFIND_VALID(find)); LOCK(&find->lock); find->flags |= FIND_EVENT_FREED; - event->destroy_arg = NULL; + event->ev_destroy_arg = NULL; UNLOCK(&find->lock); } @@ -1110,11 +1110,11 @@ clean_finds_at_name(dns_adbname_t *name, isc_eventtype_t evtype, INSIST(!FIND_EVENTSENT(find)); ev = &find->event; - task = ev->sender; - ev->sender = find; - ev->type = evtype; - ev->destroy = event_free; - ev->destroy_arg = find; + task = ev->ev_sender; + ev->ev_sender = find; + ev->ev_type = evtype; + ev->ev_destroy = event_free; + ev->ev_destroy_arg = find; DP(DEF_LEVEL, "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 check_exit(dns_adb_t *adb) { - isc_event_t *event, *next_event; + isc_event_t *event; isc_task_t *etask; isc_boolean_t zeroirefcnt; @@ -1155,15 +1155,15 @@ check_exit(dns_adb_t *adb) /* * We're now shutdown. Send any whenshutdown events. */ - for (event = ISC_LIST_HEAD(adb->whenshutdown); - event != NULL; - event = next_event) { - next_event = ISC_LIST_NEXT(event, link); - ISC_LIST_UNLINK(adb->whenshutdown, event, link); - etask = event->sender; - event->sender = adb; + event = ISC_LIST_HEAD(adb->whenshutdown); + while (event != NULL) { + ISC_LIST_UNLINK(adb->whenshutdown, event, ev_link); + etask = event->ev_sender; + event->ev_sender = adb; isc_task_sendanddetach(&etask, &event); + event = ISC_LIST_HEAD(adb->whenshutdown); } + /* * If there aren't any external references either, we're * 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 */ - adb = ev->arg; + adb = ev->ev_arg; INSIST(DNS_ADB_VALID(adb)); /* @@ -2095,7 +2095,7 @@ timer_cleanup(isc_task_t *task, isc_event_t *ev) UNUSED(task); - adb = ev->arg; + adb = ev->ev_arg; INSIST(DNS_ADB_VALID(adb)); 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. */ - event->sender = adb; + event->ev_sender = adb; isc_task_send(task, &event); } else { clone = NULL; isc_task_attach(task, &clone); - event->sender = clone; - ISC_LIST_APPEND(adb->whenshutdown, event, link); + event->ev_sender = clone; + ISC_LIST_APPEND(adb->whenshutdown, event, ev_link); } 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); taskp = NULL; isc_task_attach(task, &taskp); - find->event.sender = taskp; - find->event.action = action; - find->event.arg = arg; + find->event.ev_sender = taskp; + find->event.ev_action = action; + find->event.ev_arg = arg; } } @@ -2832,11 +2832,11 @@ dns_adb_cancelfind(dns_adbfind_t *find) if (!FIND_EVENTSENT(find)) { ev = &find->event; - task = ev->sender; - ev->sender = find; - ev->type = DNS_EVENT_ADBCANCELED; - ev->destroy = event_free; - ev->destroy_arg = find; + task = ev->ev_sender; + ev->ev_sender = find; + ev->ev_type = DNS_EVENT_ADBCANCELED; + ev->ev_destroy = event_free; + ev->ev_destroy_arg = find; DP(DEF_LEVEL, "Sending event %p to task %p for find %p", ev, task, find); @@ -3004,7 +3004,7 @@ dns_adb_dumpfind(dns_adbfind_t *find, FILE *f) find->query_pending, find->partial_result, find->options, find->flags); 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); if (ai != NULL) @@ -3324,9 +3324,9 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) (void)task; - INSIST(ev->type == DNS_EVENT_FETCHDONE); + INSIST(ev->ev_type == DNS_EVENT_FETCHDONE); dev = (dns_fetchevent_t *)ev; - name = ev->arg; + name = ev->ev_arg; INSIST(DNS_ADBNAME_VALID(name)); adb = name->adb; INSIST(DNS_ADB_VALID(adb)); @@ -3482,9 +3482,9 @@ fetch_callback_a6(isc_task_t *task, isc_event_t *ev) (void)task; - INSIST(ev->type == DNS_EVENT_FETCHDONE); + INSIST(ev->ev_type == DNS_EVENT_FETCHDONE); dev = (dns_fetchevent_t *)ev; - name = ev->arg; + name = ev->ev_arg; INSIST(DNS_ADBNAME_VALID(name)); adb = name->adb; INSIST(DNS_ADB_VALID(adb)); diff --git a/lib/dns/byaddr.c b/lib/dns/byaddr.c index 6002713827..1432e31769 100644 --- a/lib/dns/byaddr.c +++ b/lib/dns/byaddr.c @@ -173,10 +173,10 @@ copy_ptr_targets(dns_byaddr_t *byaddr) { static void 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; - REQUIRE(event->type == DNS_EVENT_FETCHDONE); + REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE); REQUIRE(VALID_BYADDR(byaddr)); REQUIRE(byaddr->task == task); fevent = (dns_fetchevent_t *)event; @@ -351,7 +351,7 @@ byaddr_find(dns_byaddr_t *byaddr, dns_fetchevent_t *event) { if (send_event) { byaddr->event->result = result; - byaddr->event->sender = byaddr; + byaddr->event->ev_sender = byaddr; ievent = (isc_event_t *)byaddr->event; byaddr->event = NULL; isc_task_sendanddetach(&byaddr->task, &ievent); @@ -367,8 +367,8 @@ bevent_destroy(isc_event_t *event) { dns_name_t *name, *next_name; isc_mem_t *mctx; - REQUIRE(event->type == DNS_EVENT_BYADDRDONE); - mctx = event->destroy_arg; + REQUIRE(event->ev_type == DNS_EVENT_BYADDRDONE); + mctx = event->ev_destroy_arg; bevent = (dns_byaddrevent_t *)event; for (name = ISC_LIST_HEAD(bevent->names); @@ -378,7 +378,7 @@ bevent_destroy(isc_event_t *event) { dns_name_free(name, mctx); 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 diff --git a/lib/dns/cache.c b/lib/dns/cache.c index 1bce3514f5..abb237c7bd 100644 --- a/lib/dns/cache.c +++ b/lib/dns/cache.c @@ -15,7 +15,7 @@ * 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 @@ -450,9 +450,10 @@ end_cleaning(cache_cleaner_t *cleaner, isc_event_t *event) { */ static void 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(event->type == ISC_TIMEREVENT_TICK); + INSIST(event->ev_type == ISC_TIMEREVENT_TICK); + if (cleaner->state == cleaner_s_idle) { begin_cleaning(cleaner); } else { @@ -471,11 +472,13 @@ cleaning_timer_action(isc_task_t *task, isc_event_t *event) { static void incremental_cleaning_action(isc_task_t *task, isc_event_t *event) { isc_result_t result; - cache_cleaner_t *cleaner = event->arg; + cache_cleaner_t *cleaner = event->ev_arg; isc_stdtime_t now; int n_names; - INSIST(event->type == DNS_EVENT_CACHECLEAN); + + INSIST(event->ev_type == DNS_EVENT_CACHECLEAN); INSIST(CLEANER_BUSY(cleaner)); + n_names = cleaner->increment; isc_stdtime_get(&now); @@ -590,12 +593,14 @@ dns_cache_clean(dns_cache_t *cache, isc_stdtime_t now) { */ static void 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; + UNUSED(task); + LOCK(&cache->lock); - INSIST(event->type == ISC_TASKEVENT_SHUTDOWN); + INSIST(event->ev_type == ISC_TASKEVENT_SHUTDOWN); isc_event_free(&event); cache->live_tasks--; diff --git a/lib/dns/dispatch.c b/lib/dns/dispatch.c index 3fa14ea5b7..6fb7e88354 100644 --- a/lib/dns/dispatch.c +++ b/lib/dns/dispatch.c @@ -230,7 +230,7 @@ destroy(dns_dispatch_t *disp) */ ev = ISC_LIST_HEAD(disp->rq_events); 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_event(disp, ev); ev = ISC_LIST_HEAD(disp->rq_events); @@ -383,7 +383,7 @@ static void udp_recv(isc_task_t *task, isc_event_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; isc_result_t dres; 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 queue_request; isc_boolean_t queue_response; - unsigned int attributes; - (void)task; /* shut up compiler */ + UNUSED(task); 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->id = id; rev->addr = ev->address; - attributes = 0; - if ((ev->attributes & ISC_SOCKEVENTATTR_PKTINFO) != 0) { - rev->pktinfo = ev->pktinfo; - attributes |= DNS_DISPATCHATTR_PKTINFO; - } else { - attributes &= ~DNS_DISPATCHATTR_PKTINFO; - } + rev->pktinfo = ev->pktinfo; + rev->attributes = ev->attributes; if (queue_request) { - ISC_LIST_APPEND(disp->rq_events, rev, link); + ISC_LIST_APPEND(disp->rq_events, rev, ev_link); } else if (queue_response) { - ISC_LIST_APPEND(resp->items, rev, link); + ISC_LIST_APPEND(resp->items, rev, ev_link); } else { - ISC_EVENT_INIT(rev, sizeof(*rev), attributes, NULL, + ISC_EVENT_INIT(rev, sizeof(*rev), 0, NULL, DNS_EVENT_DISPATCH, resp->action, resp->arg, resp, NULL, NULL); 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 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_messageid_t id; 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_response; - (void)task; /* shut up compiler */ + UNUSED(task); REQUIRE(VALID_DISPATCH(disp)); @@ -718,9 +712,9 @@ tcp_recv(isc_task_t *task, isc_event_t *ev_in) rev->id = id; rev->addr = tcpmsg->address; if (queue_request) { - ISC_LIST_APPEND(disp->rq_events, rev, link); + ISC_LIST_APPEND(disp->rq_events, rev, ev_link); } else if (queue_response) { - ISC_LIST_APPEND(resp->items, rev, link); + ISC_LIST_APPEND(resp->items, rev, ev_link); } else { ISC_EVENT_INIT(rev, sizeof(*rev), 0, NULL, DNS_EVENT_DISPATCH, 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); while (ev != NULL) { - ISC_LIST_UNLINK(res->items, ev, link); + ISC_LIST_UNLINK(res->items, ev, ev_link); if (ev->buffer.base != NULL) free_buffer(disp, ev->buffer.base, ev->buffer.length); free_event(disp, ev); @@ -1409,7 +1403,7 @@ do_next_response(dns_dispatch_t *disp, dns_dispentry_t *resp) 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, resp->action, resp->arg, resp, NULL, NULL); @@ -1433,7 +1427,7 @@ do_next_request(dns_dispatch_t *disp, dns_dispentry_t *resp) 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, resp->action, resp->arg, resp, NULL, NULL); diff --git a/lib/dns/include/dns/dispatch.h b/lib/dns/include/dns/dispatch.h index 10600644c2..e91f69fec4 100644 --- a/lib/dns/include/dns/dispatch.h +++ b/lib/dns/include/dns/dispatch.h @@ -86,13 +86,9 @@ struct dns_dispatchevent { isc_sockaddr_t addr; /* address recv'd from */ struct in6_pktinfo pktinfo; /* reply info for v6 */ isc_buffer_t buffer; /* data buffer */ + isc_uint32_t attributes; /* mirrored from socket.h */ }; -/* - * event attributes - */ -#define DNS_DISPATCHATTR_PKTINFO 0x00100000U - /* * Functions to: * diff --git a/lib/dns/request.c b/lib/dns/request.c index eccce53cdb..0132b76363 100644 --- a/lib/dns/request.c +++ b/lib/dns/request.c @@ -195,13 +195,13 @@ dns_requestmgr_whenshutdown(dns_requestmgr_t *requestmgr, isc_task_t *task, /* * We're already shutdown. Send the event. */ - event->sender = requestmgr; + event->ev_sender = requestmgr; isc_task_send(task, &event); } else { clone = NULL; isc_task_attach(task, &clone); - event->sender = clone; - ISC_LIST_APPEND(requestmgr->whenshutdown, event, link); + event->ev_sender = clone; + ISC_LIST_APPEND(requestmgr->whenshutdown, event, ev_link); } UNLOCK(&requestmgr->lock); } @@ -286,10 +286,10 @@ send_shutdown_events(dns_requestmgr_t *requestmgr) { for (event = ISC_LIST_HEAD(requestmgr->whenshutdown); event != NULL; event = next_event) { - next_event = ISC_LIST_NEXT(event, link); - ISC_LIST_UNLINK(requestmgr->whenshutdown, event, link); - etask = event->sender; - event->sender = requestmgr; + next_event = ISC_LIST_NEXT(event, ev_link); + ISC_LIST_UNLINK(requestmgr->whenshutdown, event, ev_link); + etask = event->ev_sender; + event->ev_sender = requestmgr; isc_task_sendanddetach(&etask, &event); } } @@ -394,7 +394,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message, goto cleanup; } isc_task_attach(task, &tclone); - request->event->sender = task; + request->event->ev_sender = task; request->event->request = request; request->event->result = ISC_R_FAILURE; @@ -628,9 +628,9 @@ static void req_connected(isc_task_t *task, isc_event_t *event) { isc_socketevent_t *sevent = (isc_socketevent_t *)event; 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)); TRACE("req_connected\n"); @@ -653,9 +653,9 @@ req_connected(isc_task_t *task, isc_event_t *event) { static void req_senddone(isc_task_t *task, isc_event_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"); (void)task; @@ -669,12 +669,12 @@ req_senddone(isc_task_t *task, isc_event_t *event) { static void req_response(isc_task_t *task, isc_event_t *event) { 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; isc_region_t r; REQUIRE(VALID_REQUEST(request)); - REQUIRE(event->type == DNS_EVENT_DISPATCH); + REQUIRE(event->ev_type == DNS_EVENT_DISPATCH); UNUSED(task); @@ -712,7 +712,7 @@ req_response(isc_task_t *task, isc_event_t *event) { static void 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"); UNUSED(task); @@ -730,8 +730,8 @@ req_sendevent(dns_request_t *request, isc_result_t result) { /* * Lock held by caller. */ - task = request->event->sender; - request->event->sender = request; + task = request->event->ev_sender; + request->event->ev_sender = request; request->event->result = result; isc_task_sendanddetach(&task, (isc_event_t **)&request->event); } diff --git a/lib/dns/tcpmsg.c b/lib/dns/tcpmsg.c index e033ab527c..438573e59f 100644 --- a/lib/dns/tcpmsg.c +++ b/lib/dns/tcpmsg.c @@ -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_event_t *dev; - dns_tcpmsg_t *tcpmsg = ev_in->arg; + dns_tcpmsg_t *tcpmsg = ev_in->ev_arg; isc_region_t region; 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_event_t *dev; - dns_tcpmsg_t *tcpmsg = ev_in->arg; + dns_tcpmsg_t *tcpmsg = ev_in->ev_arg; (void)task; diff --git a/lib/dns/validator.c b/lib/dns/validator.c index 04a0dbfe9e..967a19ed9d 100644 --- a/lib/dns/validator.c +++ b/lib/dns/validator.c @@ -131,11 +131,11 @@ validator_done(dns_validator_t *val, isc_result_t result) { */ val->event->result = result; - task = val->event->sender; - val->event->sender = val; - val->event->type = DNS_EVENT_VALIDATORDONE; - val->event->action = val->action; - val->event->arg = val->arg; + task = val->event->ev_sender; + val->event->ev_sender = val; + val->event->ev_type = DNS_EVENT_VALIDATORDONE; + val->event->ev_action = val->action; + val->event->ev_arg = val->arg; if ((val->attributes & VALATTR_NEGATIVE) != 0) { val->event->rdataset = NULL; val->event->sigrdataset = NULL; @@ -154,9 +154,9 @@ fetch_callback_validator(isc_task_t *task, isc_event_t *event) { isc_result_t result; UNUSED(task); - INSIST(event->type == DNS_EVENT_FETCHDONE); + INSIST(event->ev_type == DNS_EVENT_FETCHDONE); devent = (dns_fetchevent_t *)event; - val = devent->arg; + val = devent->ev_arg; rdataset = devent->rdataset; 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; UNUSED(task); - INSIST(event->type == DNS_EVENT_VALIDATORDONE); + INSIST(event->ev_type == DNS_EVENT_VALIDATORDONE); devent = (dns_validatorevent_t *)event; rdataset = devent->rdataset; - val = devent->arg; + val = devent->ev_arg; validator_log(val, ISC_LOG_DEBUG(3), "in keyvalidated"); if (devent->result == ISC_R_SUCCESS) { @@ -467,7 +467,7 @@ get_key(dns_validator_t *val, dns_siginfo_t *siginfo) { &siginfo->signer, dns_rdatatype_key, NULL, NULL, NULL, 0, - val->event->sender, + val->event->ev_sender, fetch_callback_validator, val, frdataset, @@ -699,7 +699,7 @@ validator_start(isc_task_t *task, isc_event_t *event) { isc_result_t result; UNUSED(task); - REQUIRE(event->type == DNS_EVENT_VALIDATORSTART); + REQUIRE(event->ev_type == DNS_EVENT_VALIDATORSTART); vevent = (dns_validatorevent_t *) event; val = vevent->validator; @@ -809,8 +809,8 @@ dns_validator_cancel(dns_validator_t *validator) { LOCK(&validator->lock); if (validator->event != NULL) { validator->event->result = ISC_R_CANCELED; - task = validator->event->sender; - validator->event->sender = validator; + task = validator->event->ev_sender; + validator->event->ev_sender = validator; isc_task_sendanddetach(&task, (isc_event_t **)&validator->event); /* diff --git a/lib/dns/view.c b/lib/dns/view.c index e2e76f1bca..f0d651cf62 100644 --- a/lib/dns/view.c +++ b/lib/dns/view.c @@ -293,10 +293,10 @@ dns_view_detach(dns_view_t **viewp) { static void 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; - REQUIRE(event->type == DNS_EVENT_VIEWRESSHUTDOWN); + REQUIRE(event->ev_type == DNS_EVENT_VIEWRESSHUTDOWN); REQUIRE(DNS_VIEW_VALID(view)); REQUIRE(view->task == task); @@ -315,10 +315,10 @@ resolver_shutdown(isc_task_t *task, isc_event_t *event) { static void 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; - REQUIRE(event->type == DNS_EVENT_VIEWADBSHUTDOWN); + REQUIRE(event->ev_type == DNS_EVENT_VIEWADBSHUTDOWN); REQUIRE(DNS_VIEW_VALID(view)); REQUIRE(view->task == task); diff --git a/lib/dns/xfrin.c b/lib/dns/xfrin.c index 93d4e5ccf0..671a6f7cde 100644 --- a/lib/dns/xfrin.c +++ b/lib/dns/xfrin.c @@ -15,7 +15,7 @@ * 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 @@ -855,14 +855,15 @@ render(dns_message_t *msg, isc_buffer_t *buf) { static void xfrin_connect_done(isc_task_t *task, isc_event_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 result; REQUIRE(VALID_XFRIN(xfr)); - task = task; /* Unused */ - INSIST(event->type == ISC_SOCKEVENT_CONNECT); + UNUSED(task); + + INSIST(event->ev_type == ISC_SOCKEVENT_CONNECT); isc_event_free(&event); xfr->connects--; @@ -1007,15 +1008,16 @@ static void xfrin_sendlen_done(isc_task_t *task, isc_event_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 result; isc_region_t region; REQUIRE(VALID_XFRIN(xfr)); - task = task; /* Unused */ - INSIST(event->type == ISC_SOCKEVENT_SENDDONE); + UNUSED(task); + + INSIST(event->ev_type == ISC_SOCKEVENT_SENDDONE); isc_event_free(&event); xfr->sends--; @@ -1041,13 +1043,14 @@ static void xfrin_send_done(isc_task_t *task, isc_event_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; REQUIRE(VALID_XFRIN(xfr)); - task = task; /* Unused */ - INSIST(event->type == ISC_SOCKEVENT_SENDDONE); + UNUSED(task); + + INSIST(event->ev_type == ISC_SOCKEVENT_SENDDONE); xfr->sends--; 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 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; dns_message_t *msg = NULL; dns_name_t *name; @@ -1073,10 +1076,10 @@ xfrin_recv_done(isc_task_t *task, isc_event_t *ev) { REQUIRE(VALID_XFRIN(xfr)); - task = task; /* Unused */ + UNUSED(task); - INSIST(ev->type == DNS_EVENT_TCPMSG); - tcpmsg = ev->sender; + INSIST(ev->ev_type == DNS_EVENT_TCPMSG); + tcpmsg = ev->ev_sender; isc_event_free(&ev); xfr->recvs--; @@ -1229,11 +1232,11 @@ xfrin_recv_done(isc_task_t *task, isc_event_t *ev) { static void 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)); - task = task; /* Unused */ + UNUSED(task); isc_event_free(&event); /* This will log "giving up: timeout". */ diff --git a/lib/dns/zone.c b/lib/dns/zone.c index 5442d60d5e..67b29ce040 100644 --- a/lib/dns/zone.c +++ b/lib/dns/zone.c @@ -15,7 +15,7 @@ * 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 @@ -928,7 +928,7 @@ static void checkservers_callback(isc_task_t *task, isc_event_t *event) { const char me[] = "checkservers_callback"; 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_t *zone; dns_name_t *name; @@ -945,7 +945,7 @@ checkservers_callback(isc_task_t *task, isc_event_t *event) { mctx = checkservers->mctx; res = checkservers->res; - task = task; /* unused */ + UNUSED(task); if (devent->result != ISC_R_SUCCESS) { /* timeout */ @@ -2068,7 +2068,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) { isc_result_t result; isc_uint32_t serial; - zone = devent->arg; + zone = devent->ev_arg; INSIST(DNS_ZONE_VALID(zone)); /* @@ -2241,10 +2241,10 @@ soa_query(dns_zone_t *zone, isc_taskaction_t callback) { */ static void 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); REQUIRE(DNS_ZONE_VALID(zone)); - INSIST(event->type == DNS_EVENT_ZONECONTROL); + INSIST(event->ev_type == DNS_EVENT_ZONECONTROL); INSIST(zone->erefs == 0); zone_log(zone, "zone_shutdown", ISC_LOG_DEBUG(3), "shutting down"); zone->shuttingdown = ISC_TRUE; @@ -2256,7 +2256,7 @@ zone_shutdown(isc_task_t *task, isc_event_t *event) { static void zone_timer(isc_task_t *task, isc_event_t *event) { 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); DNS_ENTER; diff --git a/lib/isc/event.c b/lib/isc/event.c index 12f754012a..93d9f873b1 100644 --- a/lib/isc/event.c +++ b/lib/isc/event.c @@ -31,9 +31,9 @@ static void 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 * @@ -64,8 +64,8 @@ isc_event_free(isc_event_t **eventp) { event = *eventp; REQUIRE(event != NULL); - if (event->destroy != NULL) - (event->destroy)(event); + if (event->ev_destroy != NULL) + (event->ev_destroy)(event); *eventp = NULL; } diff --git a/lib/isc/include/isc/event.h b/lib/isc/include/isc/event.h index 3f06e1ebd4..dc1891643b 100644 --- a/lib/isc/include/isc/event.h +++ b/lib/isc/include/isc/event.h @@ -41,16 +41,16 @@ typedef void (*isc_eventdestructor_t)(isc_event_t *); * really an issue. */ #define ISC_EVENT_COMMON(ltype) \ - size_t size; \ - unsigned int attributes; \ - void * tag; \ - isc_eventtype_t type; \ - isc_taskaction_t action; \ - void * arg; \ - void * sender; \ - isc_eventdestructor_t destroy; \ - void * destroy_arg; \ - ISC_LINK(ltype) link + size_t ev_size; \ + unsigned int ev_attributes; \ + void * ev_tag; \ + isc_eventtype_t ev_type; \ + isc_taskaction_t ev_action; \ + void * ev_arg; \ + void * ev_sender; \ + isc_eventdestructor_t ev_destroy; \ + void * ev_destroy_arg; \ + ISC_LINK(ltype) ev_link /* * 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) \ do { \ - (event)->size = (sz); \ - (event)->attributes = (at); \ - (event)->tag = (ta); \ - (event)->type = (ty); \ - (event)->action = (ac); \ - (event)->arg = (ar); \ - (event)->sender = (sn); \ - (event)->destroy = (df); \ - (event)->destroy_arg = (da); \ - ISC_LINK_INIT((event), link); \ + (event)->ev_size = (sz); \ + (event)->ev_attributes = (at); \ + (event)->ev_tag = (ta); \ + (event)->ev_type = (ty); \ + (event)->ev_action = (ac); \ + (event)->ev_arg = (ar); \ + (event)->ev_sender = (sn); \ + (event)->ev_destroy = (df); \ + (event)->ev_destroy_arg = (da); \ + ISC_LINK_INIT((event), ev_link); \ } while (0) /* diff --git a/lib/isc/include/isc/socket.h b/lib/isc/include/isc/socket.h index d68d5cb16d..7210ce9fcf 100644 --- a/lib/isc/include/isc/socket.h +++ b/lib/isc/include/isc/socket.h @@ -100,6 +100,7 @@ struct isc_socketevent { isc_sockaddr_t address; /* source address */ isc_time_t timestamp; /* timestamp of packet recv */ struct in6_pktinfo pktinfo; /* ipv6 pktinfo */ + isc_uint32_t attributes; /* see below */ }; typedef struct isc_socket_newconnev isc_socket_newconnev_t; diff --git a/lib/isc/ondestroy.c b/lib/isc/ondestroy.c index fd8afae55b..2a50b45615 100644 --- a/lib/isc/ondestroy.c +++ b/lib/isc/ondestroy.c @@ -50,9 +50,9 @@ isc_ondestroy_register(isc_ondestroy_t *ondest, 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); } @@ -69,10 +69,10 @@ isc_ondestroy_notify(isc_ondestroy_t *ondest, void *sender) eventp = ISC_LIST_HEAD(ondest->events); while (eventp != NULL) { - ISC_LIST_UNLINK(ondest->events, eventp, link); + ISC_LIST_UNLINK(ondest->events, eventp, ev_link); - task = eventp->sender; - eventp->sender = sender; + task = eventp->ev_sender; + eventp->ev_sender = sender; isc_task_sendanddetach(&task, &eventp); diff --git a/lib/isc/ratelimiter.c b/lib/isc/ratelimiter.c index a9f0555484..a499145c6c 100644 --- a/lib/isc/ratelimiter.c +++ b/lib/isc/ratelimiter.c @@ -98,7 +98,7 @@ isc_ratelimiter_enqueue(isc_ratelimiter_t *rl, isc_event_t **eventp) LOCK(&rl->lock); if (rl->state == isc_ratelimiter_ratelimited) { isc_event_t *ev = *eventp; - ISC_LIST_APPEND(rl->pending, ev, link); + ISC_LIST_APPEND(rl->pending, ev, ev_link); *eventp = NULL; } else { 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) { 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; (void) task; /* Unused */ 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. */ - ISC_LIST_UNLINK(rl->pending, p, link); + ISC_LIST_UNLINK(rl->pending, p, ev_link); } else { /* * 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); isc_timer_detach(&rl->timer); 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_mutex_destroy(&rl->lock); diff --git a/lib/isc/task.c b/lib/isc/task.c index 438be43ce3..2b19eb08b1 100644 --- a/lib/isc/task.c +++ b/lib/isc/task.c @@ -250,9 +250,9 @@ task_shutdown(isc_task_t *task) { for (event = TAIL(task->on_shutdown); event != NULL; event = prev) { - prev = PREV(event, link); - DEQUEUE(task->on_shutdown, event, link); - ENQUEUE(task->events, event, link); + prev = PREV(event, ev_link); + DEQUEUE(task->on_shutdown, event, ev_link); + ENQUEUE(task->events, event, ev_link); } } @@ -342,8 +342,8 @@ task_send(isc_task_t *task, isc_event_t **eventp) { REQUIRE(eventp != NULL); event = *eventp; REQUIRE(event != NULL); - REQUIRE(event->sender != NULL); - REQUIRE(event->type > 0); + REQUIRE(event->ev_sender != NULL); + REQUIRE(event->ev_type > 0); REQUIRE(task->state != task_state_done); XTRACE("task_send"); @@ -355,7 +355,7 @@ task_send(isc_task_t *task, isc_event_t **eventp) { } INSIST(task->state == task_state_ready || task->state == task_state_running); - ENQUEUE(task->events, event, link); + ENQUEUE(task->events, event, ev_link); *eventp = NULL; return (was_idle); @@ -436,7 +436,7 @@ isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) { *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 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); for (event = HEAD(task->events); event != NULL; event = next_event) { - next_event = NEXT(event, link); - if (event->type >= first && event->type <= last && - (sender == NULL || event->sender == sender) && - (tag == NULL || event->tag == tag) && + next_event = NEXT(event, ev_link); + if (event->ev_type >= first && event->ev_type <= last && + (sender == NULL || event->ev_sender == sender) && + (tag == NULL || event->ev_tag == tag) && (!purging || PURGE_OK(event))) { - DEQUEUE(task->events, event, link); - ENQUEUE(*events, event, link); + DEQUEUE(task->events, event, ev_link); + ENQUEUE(*events, event, ev_link); count++; } } @@ -498,7 +498,7 @@ isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first, ISC_TRUE); for (event = HEAD(events); event != NULL; event = next_event) { - next_event = NEXT(event, link); + next_event = NEXT(event, ev_link); 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); curr_event != NULL; curr_event = next_event) { - next_event = NEXT(curr_event, link); + next_event = NEXT(curr_event, ev_link); if (curr_event == event && PURGE_OK(event)) { - DEQUEUE(task->events, curr_event, link); + DEQUEUE(task->events, curr_event, ev_link); break; } } @@ -621,7 +621,7 @@ isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg) { disallowed = ISC_TRUE; result = ISC_R_SHUTTINGDOWN; } else - ENQUEUE(task->on_shutdown, event, link); + ENQUEUE(task->on_shutdown, event, ev_link); UNLOCK(&task->lock); if (disallowed) @@ -790,15 +790,15 @@ run(void *uap) { do { if (!EMPTY(task->events)) { event = HEAD(task->events); - DEQUEUE(task->events, event, link); + DEQUEUE(task->events, event, ev_link); /* * Execute the event action. */ XTRACE("execute action"); - if (event->action != NULL) { + if (event->ev_action != NULL) { UNLOCK(&task->lock); - (event->action)(task, event); + (event->ev_action)(task,event); LOCK(&task->lock); } dispatch_count++; diff --git a/lib/isc/unix/app.c b/lib/isc/unix/app.c index 5ce4e0f039..1c38c34395 100644 --- a/lib/isc/unix/app.c +++ b/lib/isc/unix/app.c @@ -210,7 +210,7 @@ isc_app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action, goto unlock; } - ISC_LIST_APPEND(on_run, event, link); + ISC_LIST_APPEND(on_run, event, ev_link); result = ISC_R_SUCCESS; @@ -249,10 +249,10 @@ isc_app_run(void) { for (event = ISC_LIST_HEAD(on_run); event != NULL; event = next_event) { - next_event = ISC_LIST_NEXT(event, link); - ISC_LIST_UNLINK(on_run, event, link); - task = event->sender; - event->sender = (void *)&running; + next_event = ISC_LIST_NEXT(event, ev_link); + ISC_LIST_UNLINK(on_run, event, ev_link); + task = event->ev_sender; + event->ev_sender = (void *)&running; isc_task_sendanddetach(&task, &event); } diff --git a/lib/isc/unix/socket.c b/lib/isc/unix/socket.c index ed6bb36153..f3d6604274 100644 --- a/lib/isc/unix/socket.c +++ b/lib/isc/unix/socket.c @@ -321,7 +321,7 @@ process_cmsg(isc_socket_t *sock, struct msghdr *msg, isc_socketevent_t *dev) #endif #endif - (void)sock; + UNUSED(sock); #ifdef ISC_NET_BSD44MSGHDR #ifdef MSG_TRUNC @@ -642,11 +642,12 @@ allocate_socketevent(isc_socket_t *sock, isc_eventtype_t eventtype, return (NULL); ev->result = ISC_R_UNEXPECTED; - ISC_LINK_INIT(ev, link); + ISC_LINK_INIT(ev, ev_link); ISC_LIST_INIT(ev->bufferlist); ev->region.base = NULL; ev->n = 0; ev->offset = 0; + ev->attributes = 0; return (ev); } @@ -811,6 +812,7 @@ doio_send(isc_socket_t *sock, isc_socketevent_t *dev) size_t write_count; struct msghdr msghdr; + /* XXXMLG Should verify that we didn't overflow MAXSCATTERGATHER? */ build_msghdr_send(sock, dev, &msghdr, iov, MAXSCATTERGATHER_SEND, &write_count); @@ -1228,14 +1230,14 @@ dispatch_read(isc_socket_t *sock) iev = &sock->readable_ev; XTRACE(TRACE_WATCHER, ("dispatch_read: posted event %p to task %p\n", - ev, ev->sender)); + ev, ev->ev_sender)); sock->references++; - iev->sender = sock; - iev->action = internal_recv; - iev->arg = sock; + iev->ev_sender = sock; + iev->ev_action = internal_recv; + 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 @@ -1254,14 +1256,14 @@ dispatch_write(isc_socket_t *sock) iev = &sock->writable_ev; XTRACE(TRACE_WATCHER, ("dispatch_send: posted event %p to task %p\n", - ev, ev->sender)); + ev, ev->ev_sender)); sock->references++; - iev->sender = sock; - iev->action = internal_send; - iev->arg = sock; + iev->ev_sender = sock; + iev->ev_action = internal_send; + 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; sock->references++; /* keep socket around for this internal event */ - iev->sender = sock; - iev->action = internal_accept; - iev->arg = sock; + iev->ev_sender = sock; + iev->ev_action = internal_accept; + 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 @@ -1308,11 +1310,11 @@ dispatch_connect(isc_socket_t *sock) INSIST(sock->connecting); sock->references++; /* keep socket around for this internal event */ - iev->sender = sock; - iev->action = internal_connect; - iev->arg = sock; + iev->ev_sender = sock; + iev->ev_action = internal_connect; + 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; - task = (*dev)->sender; + task = (*dev)->ev_sender; (*dev)->result = resultcode; - (*dev)->sender = sock; + (*dev)->ev_sender = sock; - if (ISC_LINK_LINKED(*dev, link)) - ISC_LIST_DEQUEUE(sock->recv_list, *dev, link); + if (ISC_LINK_LINKED(*dev, ev_link)) + ISC_LIST_DEQUEUE(sock->recv_list, *dev, ev_link); if (sock->recv_result != ISC_R_SUCCESS) (*dev)->attributes |= ISC_SOCKEVENTATTR_FATALERROR; @@ -1360,13 +1362,14 @@ send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev, { isc_task_t *task; - task = (*dev)->sender; + INSIST(dev != NULL && *dev != NULL); + task = (*dev)->ev_sender; (*dev)->result = resultcode; - (*dev)->sender = sock; + (*dev)->ev_sender = sock; - if (ISC_LINK_LINKED(*dev, link)) - ISC_LIST_DEQUEUE(sock->send_list, *dev, link); + if (ISC_LINK_LINKED(*dev, ev_link)) + ISC_LIST_DEQUEUE(sock->send_list, *dev, ev_link); if (sock->send_result != ISC_R_SUCCESS) (*dev)->attributes |= ISC_SOCKEVENTATTR_FATALERROR; @@ -1400,9 +1403,9 @@ internal_accept(isc_task_t *me, isc_event_t *ev) int fd; isc_result_t result = ISC_R_SUCCESS; - (void)me; + UNUSED(me); - sock = ev->sender; + sock = ev->ev_sender; INSIST(VALID_SOCKET(sock)); LOCK(&sock->lock); @@ -1468,7 +1471,7 @@ internal_accept(isc_task_t *me, isc_event_t *ev) /* * 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. @@ -1517,8 +1520,8 @@ internal_accept(isc_task_t *me, isc_event_t *ev) * Fill in the done event details and send it off. */ dev->result = result; - task = dev->sender; - dev->sender = sock; + task = dev->ev_sender; + dev->ev_sender = sock; 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_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)); LOCK(&sock->lock); @@ -1561,13 +1564,13 @@ internal_recv(isc_task_t *me, isc_event_t *ev) */ dev = ISC_LIST_HEAD(sock->recv_list); while (dev != NULL) { - task = dev->sender; + task = dev->ev_sender; /* * If this is a marker event, post its completion and * continue the loop. */ - if (dev->type == ISC_SOCKEVENT_RECVMARK) { + if (dev->ev_type == ISC_SOCKEVENT_RECVMARK) { send_recvdone_event(sock, &dev, sock->recv_result); goto next; } @@ -1621,14 +1624,14 @@ internal_send(isc_task_t *me, isc_event_t *ev) isc_socket_t *sock; 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. */ - sock = (isc_socket_t *)ev->sender; + sock = (isc_socket_t *)ev->ev_sender; INSIST(VALID_SOCKET(sock)); LOCK(&sock->lock); @@ -1655,13 +1658,13 @@ internal_send(isc_task_t *me, isc_event_t *ev) */ dev = ISC_LIST_HEAD(sock->send_list); while (dev != NULL) { - task = dev->sender; + task = dev->ev_sender; /* * If this is a marker event, post its completion and * continue the loop. */ - if (dev->type == ISC_SOCKEVENT_SENDMARK) { + if (dev->ev_type == ISC_SOCKEVENT_SENDMARK) { send_senddone_event(sock, &dev, sock->send_result); goto next; } @@ -2138,7 +2141,7 @@ isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist, dev->minimum = minimum; } - dev->sender = task; + dev->ev_sender = task; /* * 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 * 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) 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->n = 0; dev->region = *region; - dev->sender = task; + dev->ev_sender = task; 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 * 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) 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->sender = task; + dev->ev_sender = task; set_dev_address(address, sock, dev); 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 * 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) 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. ***/ - dev->sender = task; + dev->ev_sender = task; set_dev_address(address, sock, dev); 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 * 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) 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 * 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 *) isc_event_allocate(manager->mctx, task, ISC_SOCKEVENT_NEWCONN, @@ -2613,7 +2616,7 @@ isc_socket_accept(isc_socket_t *sock, UNLOCK(&sock->lock); return (ISC_R_NOMEMORY); } - ISC_LINK_INIT(dev, link); + ISC_LINK_INIT(dev, ev_link); ret = allocate_socket(manager, sock->type, &nsock); if (ret != ISC_R_SUCCESS) { @@ -2628,7 +2631,7 @@ isc_socket_accept(isc_socket_t *sock, isc_task_attach(task, &ntask); nsock->references++; - dev->sender = ntask; + dev->ev_sender = ntask; dev->newsocket = nsock; /* @@ -2639,7 +2642,7 @@ isc_socket_accept(isc_socket_t *sock, if (EMPTY(sock->accept_list)) 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); return (ISC_R_SUCCESS); @@ -2677,7 +2680,7 @@ isc_socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr, UNLOCK(&sock->lock); 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 @@ -2737,7 +2740,7 @@ isc_socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr, sock->connecting = 1; - dev->sender = ntask; + dev->ev_sender = ntask; /* * 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; ISC_SOCKADDR_LEN_T optlen; - (void)me; - INSIST(ev->type == ISC_SOCKEVENT_INTW); + UNUSED(me); + INSIST(ev->ev_type == ISC_SOCKEVENT_INTW); - sock = ev->sender; + sock = ev->ev_sender; INSIST(VALID_SOCKET(sock)); LOCK(&sock->lock); @@ -2849,8 +2852,8 @@ internal_connect(isc_task_t *me, isc_event_t *ev) UNLOCK(&sock->lock); - task = dev->sender; - dev->sender = sock; + task = dev->ev_sender; + dev->ev_sender = sock; 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); while (dev != NULL) { - current_task = dev->sender; - next = ISC_LIST_NEXT(dev, link); + current_task = dev->ev_sender; + next = ISC_LIST_NEXT(dev, ev_link); if ((task == NULL) || (task == current_task)) 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); while (dev != NULL) { - current_task = dev->sender; - next = ISC_LIST_NEXT(dev, link); + current_task = dev->ev_sender; + next = ISC_LIST_NEXT(dev, ev_link); if ((task == NULL) || (task == current_task)) 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); while (dev != NULL) { - current_task = dev->sender; - next = ISC_LIST_NEXT(dev, link); + current_task = dev->ev_sender; + next = ISC_LIST_NEXT(dev, ev_link); 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--; free_socket(&dev->newsocket); dev->result = ISC_R_CANCELED; - dev->sender = sock; + dev->ev_sender = sock; isc_task_sendanddetach(¤t_task, (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; dev = sock->connect_ev; - current_task = dev->sender; + current_task = dev->ev_sender; if ((task == NULL) || (task == current_task)) { sock->connect_ev = NULL; dev->result = ISC_R_CANCELED; - dev->sender = sock; + dev->ev_sender = sock; isc_task_sendanddetach(¤t_task, (isc_event_t **)&dev); } @@ -3064,9 +3068,9 @@ isc_socket_recvmark(isc_socket_t *sock, */ 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, ("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); - 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, ("isc_socket_sendmark: queued event dev %p, task %p\n", diff --git a/lib/lwres/include/lwres/lwres.h b/lib/lwres/include/lwres/lwres.h index e95fc78baa..e8d3df2cec 100644 --- a/lib/lwres/include/lwres/lwres.h +++ b/lib/lwres/include/lwres/lwres.h @@ -430,8 +430,7 @@ void lwres_conf_clear(lwres_context_t *ctx); /* * frees all internally allocated memory in confdata. Uses the memory - * routines supplies by ctx (so that should probably be the same value as - * given to lwres_conf_parse()). + * routines supplied by ctx. */ lwres_conf_t * diff --git a/lib/omapi/connection.c b/lib/omapi/connection.c index 29eeb75f31..e86ea200e6 100644 --- a/lib/omapi/connection.c +++ b/lib/omapi/connection.c @@ -15,7 +15,7 @@ * 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 */ @@ -249,8 +249,8 @@ connect_done(isc_task_t *task, isc_event_t *event) { isc_socket_t *socket; omapi_connection_t *connection; - socket = event->sender; - connection = event->arg; + socket = event->ev_sender; + connection = event->ev_arg; result = ((isc_socket_connev_t *)event)->result; isc_event_free(&event); @@ -308,8 +308,8 @@ recv_done(isc_task_t *task, isc_event_t *event) { omapi_connection_t *connection; unsigned int bytes_read; - socket = event->sender; - connection = event->arg; + socket = event->ev_sender; + connection = event->ev_arg; socketevent = (isc_socketevent_t *)event; bufferlist = socketevent->bufferlist; bytes_read = socketevent->n; @@ -394,8 +394,8 @@ send_done(isc_task_t *task, isc_event_t *event) { omapi_connection_t *connection; unsigned int sent_bytes; - socket = event->sender; - connection = event->arg; + socket = event->ev_sender; + connection = event->ev_arg; socketevent = (isc_socketevent_t *)event; sent_bytes = socketevent->n; bufferlist = socketevent->bufferlist; diff --git a/lib/omapi/listener.c b/lib/omapi/listener.c index a720b723bf..e54165167c 100644 --- a/lib/omapi/listener.c +++ b/lib/omapi/listener.c @@ -81,7 +81,7 @@ listener_accept(isc_task_t *task, isc_event_t *event) { result = ((isc_socket_newconnev_t *)event)->result; 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