rdns_proposal
zeroslot(struct rdns_proposal *tab)
findslot(struct rdns_proposal *tab)
struct rdns_proposal learning[nitems(learned)];
int findslot(struct rdns_proposal *);
void zeroslot(struct rdns_proposal *);
const struct rdns_proposal *rpa = a, *rpb = b;
struct rdns_proposal learned[ASR_MAXNS];
LIST_FOREACH (rdns_proposal, &iface->rdns_proposals,
rdns_proposal_state_transition(rdns_proposal,
void rdns_proposal_state_transition(struct rdns_proposal *rdns_proposal,
enum proposal_state old_state = rdns_proposal->state;
rdns_proposal->state = new_state;
if ((iface = get_slaacd_iface_by_id(rdns_proposal->if_index)) == NULL)
switch (rdns_proposal->state) {
withdraw_rdns(rdns_proposal);
rdns_proposal->timo.tv_sec = -1;
rdns_proposal->timo.tv_sec =
real_lifetime(&rdns_proposal->uptime,
rdns_proposal->rdns_lifetime);
lifetime = real_lifetime(&rdns_proposal->uptime,
rdns_proposal->rdns_lifetime);
rdns_proposal->timo.tv_sec = lifetime -
rdns_proposal->timo.tv_sec = RTR_SOLICITATION_INTERVAL;
lifetime = real_lifetime(&rdns_proposal->uptime,
rdns_proposal->rdns_lifetime);
rdns_proposal->timo.tv_sec = lifetime -
rdns_proposal->timo.tv_sec = RTR_SOLICITATION_INTERVAL;
withdraw_rdns(rdns_proposal);
rdns_proposal->timo.tv_sec = MAX_RTR_SOLICITATIONS *
rdns_proposal->timo.tv_sec = 0; /* remove immediately */
if_name = if_indextoname(rdns_proposal->if_index, ifnamebuf);
proposal_state_name(new_state), rdns_proposal->timo.tv_sec);
if (rdns_proposal->timo.tv_sec == -1) {
if (evtimer_pending(&rdns_proposal->timer, NULL))
evtimer_del(&rdns_proposal->timer);
evtimer_add(&rdns_proposal->timer, &rdns_proposal->timo);
LIST_ENTRY(rdns_proposal) entries;
struct rdns_proposal *rdns_proposal;
rdns_proposal = find_rdns_proposal_by_gw(iface, &ra->from);
if (!rdns_proposal) {
if (rdns_proposal->rdns_count == MAX_RDNS_COUNT)
free_rdns_proposal(rdns_proposal);
if (rdns_proposal->rdns_count != rdns_count ||
memcmp(&rdns_proposal->rdns, &rdns, sizeof(rdns)) != 0) {
memcpy(&rdns_proposal->rdns, &rdns, sizeof(rdns));
rdns_proposal->rdns_count = rdns_count;
rdns_proposal->state = PROPOSAL_NOT_CONFIGURED;
rdns_proposal->when = ra->when;
rdns_proposal->uptime = ra->uptime;
rdns_proposal->rdns_lifetime = ra->rdns_lifetime;
proposal_state_name(rdns_proposal->state),
real_lifetime(&rdns_proposal->uptime,
rdns_proposal->rdns_lifetime));
switch (rdns_proposal->state) {
rdns_proposal_state_transition(rdns_proposal,
rdns_proposal_state_transition(rdns_proposal,
compose_rdns_proposal(rdns_proposal->if_index,
rdns_proposal->rdomain);
sin6_to_str(&rdns_proposal->from));
LIST_HEAD(, rdns_proposal) rdns_proposals;
struct rdns_proposal *rdns_proposal;
if ((rdns_proposal = calloc(1, sizeof(*rdns_proposal))) == NULL)
rdns_proposal->id = ++proposal_id;
evtimer_set(&rdns_proposal->timer, rdns_proposal_timeout,
rdns_proposal);
rdns_proposal->timo.tv_sec = 1;
rdns_proposal->timo.tv_usec = arc4random_uniform(1000000);
rdns_proposal->state = PROPOSAL_NOT_CONFIGURED;
rdns_proposal->when = ra->when;
rdns_proposal->uptime = ra->uptime;
rdns_proposal->if_index = iface->if_index;
rdns_proposal->rdomain = iface->rdomain;
memcpy(&rdns_proposal->from, &ra->from,
sizeof(rdns_proposal->from));
rdns_proposal->rdns_lifetime = ra->rdns_lifetime;
memcpy(&rdns_proposal->rdns[rdns_proposal->rdns_count++],
if (rdns_proposal->rdns_count == MAX_RDNS_COUNT)
LIST_INSERT_HEAD(&iface->rdns_proposals, rdns_proposal, entries);
hbuf = sin6_to_str(&rdns_proposal->from);
struct rdns_proposal *rdns_proposal;
LIST_FOREACH(rdns_proposal, &iface->rdns_proposals, entries) {
if (rdns_proposal->state == PROPOSAL_WITHDRAWN ||
rdns_proposal->state == PROPOSAL_STALE)
rdns_proposal_state_transition(rdns_proposal,
for (i = 0; i < rdns_proposal->rdns_count &&
rdns_proposal->rdns[i];
free_rdns_proposal(struct rdns_proposal *rdns_proposal)
if (rdns_proposal == NULL)
LIST_REMOVE(rdns_proposal, entries);
evtimer_del(&rdns_proposal->timer);
switch (rdns_proposal->state) {
withdraw_rdns(rdns_proposal);
free(rdns_proposal);
withdraw_rdns(struct rdns_proposal *rdns_proposal)
log_debug("%s: %d", __func__, rdns_proposal->if_index);
rdns_proposal->state = PROPOSAL_WITHDRAWN;
compose_rdns_proposal(rdns_proposal->if_index, rdns_proposal->rdomain);
struct rdns_proposal *rdns_proposal;
rdns_proposal = (struct rdns_proposal *)arg;
hbuf = sin6_to_str(&rdns_proposal->from);
log_debug("%s: iface %d: %s [%s]", __func__, rdns_proposal->if_index,
hbuf, proposal_state_name(rdns_proposal->state));
switch (rdns_proposal->state) {
rdns_proposal_state_transition(rdns_proposal, PROPOSAL_STALE);
rdns_proposal_state_transition(rdns_proposal,
if (real_lifetime(&rdns_proposal->uptime,
rdns_proposal->rdns_lifetime) > 0)
rdns_proposal_state_transition(rdns_proposal,
rdns_proposal_state_transition(rdns_proposal,
free_rdns_proposal(rdns_proposal);
rdns_proposal = NULL;
free_rdns_proposal(rdns_proposal);
rdns_proposal = NULL;
void rdns_proposal_state_transition(struct rdns_proposal *,
proposal_state_name(rdns_proposal->state));
struct rdns_proposal*
struct rdns_proposal *rdns_proposal;
LIST_FOREACH (rdns_proposal, &iface->rdns_proposals, entries) {
if (memcmp(&rdns_proposal->from, from, sizeof(*from)) == 0)
return (rdns_proposal);
void free_rdns_proposal(struct rdns_proposal *);
void withdraw_rdns(struct rdns_proposal *);
struct rdns_proposal *find_rdns_proposal_by_gw(struct slaacd_iface *,
struct rdns_proposal *rdns_proposal;
LIST_FOREACH(rdns_proposal, &iface->rdns_proposals, entries) {
cei_rdns_proposal.id = rdns_proposal->id;
proposal_state_name(rdns_proposal->state),
cei_rdns_proposal.next_timeout = rdns_proposal->timo.tv_sec;
cei_rdns_proposal.when = rdns_proposal->when;
cei_rdns_proposal.uptime = rdns_proposal->uptime;
memcpy(&cei_rdns_proposal.from, &rdns_proposal->from, sizeof(
cei_rdns_proposal.rdns_count = rdns_proposal->rdns_count;
&rdns_proposal->rdns, sizeof(cei_rdns_proposal.rdns));
rdns_proposal->rdns_lifetime;
struct rdns_proposal *rdns_proposal;
rdns_proposal = LIST_FIRST(&iface->rdns_proposals);
free_rdns_proposal(rdns_proposal);
struct rdns_proposal *rdns_proposal;
LIST_FOREACH (rdns_proposal, &iface->rdns_proposals,
rdns_proposal_state_transition(rdns_proposal,
struct imsg_rdns_proposal rdns_proposal;
rdns_proposal.if_index = ifan->ifan_index;
rdns_proposal.src = 0;
rdns_proposal.rtdns.sr_family = AF_INET;
rdns_proposal.rtdns.sr_len = offsetof(struct sockaddr_rtdns,
&rdns_proposal, sizeof(rdns_proposal));
rdns_proposal.if_index = rtm->rtm_index;
rdns_proposal.src = rtm->rtm_priority;
memcpy(&rdns_proposal.rtdns, rtdns, sizeof(rdns_proposal.rtdns));
&rdns_proposal, sizeof(rdns_proposal));
replace_autoconf_forwarders(struct imsg_rdns_proposal *rdns_proposal)
af = rdns_proposal->rtdns.sr_family;
src = rdns_proposal->rtdns.sr_dns;
if ((rdns_proposal->rtdns.sr_len - 2) % addrsz != 0) {
rdns_count = (rdns_proposal->rtdns.sr_len -
sin6->sin6_scope_id = rdns_proposal->if_index;
uw_forwarder->if_index = rdns_proposal->if_index;
uw_forwarder->src = rdns_proposal->src;
if ((rdns_proposal->src == 0 || rdns_proposal->src ==
tmp->src) && (rdns_proposal->if_index == 0 ||
rdns_proposal->if_index == tmp->if_index))