mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-22 01:59:26 +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
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;

10
bin/lwresd/process_gabn.c
View File

@ -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;
}

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_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;

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;
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);

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.
*/
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));

8
bin/named/server.c
View File

@ -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);

18
bin/named/update.c
View File

@ -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);

14
bin/named/xfrout.c
View File

@ -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 <config.h>
@ -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) {

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 = 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);

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_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);

2
bin/tests/byname_test.c
View File

@ -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);

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)
{
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;

6
bin/tests/dispatch_test.c
View File

@ -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;

9
bin/tests/lwresconf_test.c
View File

@ -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

2
bin/tests/omapi_test.c
View File

@ -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);

2
bin/tests/ratelimiter_test.c
View File

@ -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);
}

9
bin/tests/sdig.c
View File

@ -36,6 +36,8 @@ extern int h_errno;
#include <isc/socket.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/types.h>
#include <dns/message.h>
#include <dns/name.h>
@ -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);
}

12
bin/tests/shutdown_test.c
View File

@ -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);

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
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, &region, task, my_send, event->arg);
isc_socket_send(sock, &region, 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, &region, task, my_http_get, event->arg);
isc_socket_send(sock, &region, 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, &region, 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);
}

6
bin/tests/task_test.c
View File

@ -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);

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++)
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);

14
bin/tests/timer_test.c
View File

@ -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";

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);
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;
}

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;
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");

66
lib/dns/adb.c
View File

@ -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));

12
lib/dns/byaddr.c
View File

@ -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

19
lib/dns/cache.c
View File

@ -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 <config.h>
@ -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--;

36
lib/dns/dispatch.c
View File

@ -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);

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

@ -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:
*

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.
*/
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);
}

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_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;

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;
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);
/*

8
lib/dns/view.c
View File

@ -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);

35
lib/dns/xfrin.c
View File

@ -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 <config.h>
@ -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". */

14
lib/dns/zone.c
View File

@ -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 <config.h>
@ -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;

8
lib/isc/event.c
View File

@ -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;
}

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

@ -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)
/*

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

@ -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;

10
lib/isc/ondestroy.c
View File

@ -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);

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);
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);

40
lib/isc/task.c
View File

@ -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++;

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;
}
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);
}

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
(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(&current_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(&current_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",

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

@ -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 *

14
lib/omapi/connection.c
View File

@ -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;

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;
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