/* ARGSUSED1 */
static boolean_t
stop_selecting(dhcp_smach_t *dsmp, unsigned int n_discovers)
{
/*
* If we're using v4 and the underlying LIF we're trying to configure
* has been touched by the user, then bail out.
*/
if (!dsmp->dsm_isv6 && !verify_lif(dsmp->dsm_lif)) {
finished_smach(dsmp, DHCP_IPC_E_UNKIF);
return (B_TRUE);
}
if (dsmp->dsm_recv_pkt_list != NULL) {
dhcp_requesting(NULL, dsmp);
if (dsmp->dsm_state != SELECTING)
return (B_TRUE);
}
return (B_FALSE);
}
static void
accept_v6_message(dhcp_smach_t *dsmp, PKT_LIST *plp, const char *pname,
uchar_t recv_type)
{
const dhcpv6_option_t *d6o;
uint_t olen;
const char *estr, *msg;
uint_t msglen;
int status;
/* Account for received and processed messages */
dsmp->dsm_received++;
/* We don't yet support Reconfigure at all. */
if (recv_type == DHCPV6_MSG_RECONFIGURE) {
dhcpmsg(MSG_VERBOSE, "accept_v6_message: ignored Reconfigure "
"on %s", dsmp->dsm_name);
free_pkt_entry(plp);
return;
}
/*
* All valid DHCPv6 messages must have our Client ID specified.
*/
d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_CLIENTID, &olen);
olen -= sizeof (*d6o);
if (d6o == NULL || olen != dsmp->dsm_cidlen ||
memcmp(d6o + 1, dsmp->dsm_cid, olen) != 0) {
dhcpmsg(MSG_VERBOSE,
"accept_v6_message: discarded %s on %s: %s Client ID",
pname, dsmp->dsm_name, d6o == NULL ? "no" : "wrong");
free_pkt_entry(plp);
return;
}
/*
* All valid DHCPv6 messages must have a Server ID specified.
*
* If this is a Reply and it's not in response to Solicit, Confirm,
* Rebind, or Information-Request, then it must also match the Server
* ID we're expecting.
*
* For Reply in the Solicit, Confirm, Rebind, and Information-Request
* cases, the Server ID needs to be saved. This is done inside of
* dhcp_bound().
*/
d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_SERVERID, &olen);
if (d6o == NULL) {
dhcpmsg(MSG_DEBUG,
"accept_v6_message: discarded %s on %s: no Server ID",
pname, dsmp->dsm_name);
free_pkt_entry(plp);
return;
}
if (recv_type == DHCPV6_MSG_REPLY && dsmp->dsm_state != SELECTING &&
dsmp->dsm_state != INIT_REBOOT && dsmp->dsm_state != REBINDING &&
dsmp->dsm_state != INFORM_SENT) {
olen -= sizeof (*d6o);
if (olen != dsmp->dsm_serveridlen ||
memcmp(d6o + 1, dsmp->dsm_serverid, olen) != 0) {
dhcpmsg(MSG_DEBUG, "accept_v6_message: discarded %s on "
"%s: wrong Server ID", pname, dsmp->dsm_name);
free_pkt_entry(plp);
return;
}
}
/*
* Break out of the switch if the input message needs to be discarded.
* Return from the function if the message has been enqueued or
* consumed.
*/
switch (dsmp->dsm_state) {
case SELECTING:
/* A Reply message signifies a Rapid-Commit. */
if (recv_type == DHCPV6_MSG_REPLY) {
if (dhcpv6_pkt_option(plp, NULL,
DHCPV6_OPT_RAPID_COMMIT, &olen) == NULL) {
dhcpmsg(MSG_DEBUG, "accept_v6_message: Reply "
"on %s lacks Rapid-Commit; ignoring",
dsmp->dsm_name);
break;
}
dhcpmsg(MSG_VERBOSE,
"accept_v6_message: rapid-commit Reply on %s",
dsmp->dsm_name);
cancel_offer_timer(dsmp);
goto rapid_commit;
}
/* Otherwise, we're looking for Advertisements. */
if (recv_type != DHCPV6_MSG_ADVERTISE)
break;
/*
* Special case: if this advertisement has preference 255, then
* we must stop right now and select this server.
*/
d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_PREFERENCE,
&olen);
if (d6o != NULL && olen == sizeof (*d6o) + 1 &&
*(const uchar_t *)(d6o + 1) == 255) {
pkt_smach_enqueue(dsmp, plp);
dhcpmsg(MSG_DEBUG, "accept_v6_message: preference 255;"
" immediate Request on %s", dsmp->dsm_name);
dhcp_requesting(NULL, dsmp);
} else {
pkt_smach_enqueue(dsmp, plp);
}
return;
case PRE_BOUND:
case BOUND:
/*
* Not looking for anything in these states. (If we
* implemented reconfigure, that might go here.)
*/
break;
case REQUESTING:
case INIT_REBOOT:
case RENEWING:
case REBINDING:
case INFORM_SENT:
/*
* We're looking for Reply messages.
*/
if (recv_type != DHCPV6_MSG_REPLY)
break;
dhcpmsg(MSG_VERBOSE,
"accept_v6_message: received Reply message on %s",
dsmp->dsm_name);
rapid_commit:
/*
* Extract the status code option. If one is present and the
* request failed, then try to go to another advertisement in
* the list or restart the selection machinery.
*/
d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_STATUS_CODE,
&olen);
status = dhcpv6_status_code(d6o, olen, &estr, &msg, &msglen);
/*
* Check for the UseMulticast status code. If this is present,
* and if we were actually using unicast, then drop back and
* try again. If we weren't using unicast, then just pretend
* we never saw this message -- the peer is confused. (TAHI
* does this.)
*/
if (status == DHCPV6_STAT_USEMCAST) {
if (IN6_IS_ADDR_MULTICAST(
&dsmp->dsm_send_dest.v6.sin6_addr)) {
break;
} else {
free_pkt_entry(plp);
dsmp->dsm_send_dest.v6.sin6_addr =
ipv6_all_dhcp_relay_and_servers;
retransmit_now(dsmp);
return;
}
}
print_server_msg(dsmp, msg, msglen);
/*
* We treat NoBinding at the top level as "success." Granted,
* this doesn't make much sense, but the TAHI test suite does
* this. NoBinding really only makes sense in the context of a
* specific IA, as it refers to the GUID:IAID binding, so
* ignoring it at the top level is safe.
*/
if (status == DHCPV6_STAT_SUCCESS ||
status == DHCPV6_STAT_NOBINDING) {
if (dhcp_bound(dsmp, plp)) {
/*
* dhcp_bound will stop retransmission on
* success, if that's called for.
*/
server_unicast_option(dsmp, plp);
} else {
stop_pkt_retransmission(dsmp);
dhcpmsg(MSG_WARNING, "accept_v6_message: "
"dhcp_bound failed for %s", dsmp->dsm_name);
(void) remove_hostconf(dsmp->dsm_name,
dsmp->dsm_isv6);
dhcp_restart(dsmp);
}
} else {
dhcpmsg(MSG_WARNING, "accept_v6_message: Reply: %s",
estr);
stop_pkt_retransmission(dsmp);
free_pkt_entry(plp);
if (dsmp->dsm_state == INFORM_SENT) {
(void) set_smach_state(dsmp, INIT);
ipc_action_finish(dsmp, DHCP_IPC_E_SRVFAILED);
} else {
(void) remove_hostconf(dsmp->dsm_name,
dsmp->dsm_isv6);
request_failed(dsmp);
}
}
return;
case DECLINING:
/*
* We're looking for Reply messages.
*/
if (recv_type != DHCPV6_MSG_REPLY)
break;
stop_pkt_retransmission(dsmp);
/*
* Extract the status code option. Note that it's not a
* failure if the server reports an error.
*/
d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_STATUS_CODE,
&olen);
if (dhcpv6_status_code(d6o, olen, &estr, &msg,
&msglen) == DHCPV6_STAT_SUCCESS) {
print_server_msg(dsmp, msg, msglen);
} else {
dhcpmsg(MSG_WARNING, "accept_v6_message: Reply: %s",
estr);
}
free_pkt_entry(plp);
if (dsmp->dsm_leases == NULL) {
dhcpmsg(MSG_VERBOSE, "accept_v6_message: %s has no "
"leases left", dsmp->dsm_name);
dhcp_restart(dsmp);
} else if (dsmp->dsm_lif_wait == 0) {
(void) set_smach_state(dsmp, BOUND);
} else {
(void) set_smach_state(dsmp, PRE_BOUND);
}
return;
case RELEASING:
/*
* We're looking for Reply messages.
*/
if (recv_type != DHCPV6_MSG_REPLY)
break;
stop_pkt_retransmission(dsmp);
/*
* Extract the status code option.
*/
d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_STATUS_CODE,
&olen);
if (dhcpv6_status_code(d6o, olen, &estr, &msg,
&msglen) == DHCPV6_STAT_SUCCESS) {
print_server_msg(dsmp, msg, msglen);
} else {
dhcpmsg(MSG_WARNING, "accept_v6_message: Reply: %s",
estr);
}
free_pkt_entry(plp);
finished_smach(dsmp, DHCP_IPC_SUCCESS);
return;
}
/*
* Break from above switch means that the message must be discarded.
*/
dhcpmsg(MSG_VERBOSE,
"accept_v6_message: discarded v6 %s on %s; state %s",
pname, dsmp->dsm_name, dhcp_state_to_string(dsmp->dsm_state));
free_pkt_entry(plp);
}
/* ARGSUSED */
static void
rtsock_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg)
{
dhcp_smach_t *dsmp, *dsmnext;
union {
struct ifa_msghdr ifam;
struct if_msghdr ifm;
char buf[1024];
} msg;
uint16_t ifindex;
int msglen;
boolean_t isv6;
if ((msglen = read(fd, &msg, sizeof (msg))) <= 0)
return;
/* Note that the routing socket interface index is just 16 bits */
if (msg.ifm.ifm_type == RTM_IFINFO) {
ifindex = msg.ifm.ifm_index;
isv6 = (msg.ifm.ifm_flags & IFF_IPV6) ? B_TRUE : B_FALSE;
} else if (msg.ifam.ifam_type == RTM_DELADDR ||
msg.ifam.ifam_type == RTM_NEWADDR) {
ifindex = msg.ifam.ifam_index;
isv6 = is_rtm_v6(&msg.ifam, msglen);
} else {
return;
}
for (dsmp = lookup_smach_by_uindex(ifindex, NULL, isv6);
dsmp != NULL; dsmp = dsmnext) {
DHCPSTATE oldstate;
boolean_t lif_finished;
boolean_t lease_removed;
dhcp_lease_t *dlp, *dlnext;
/*
* Note that script_start can call dhcp_drop directly, and
* that will do release_smach.
*/
dsmnext = lookup_smach_by_uindex(ifindex, dsmp, isv6);
oldstate = dsmp->dsm_state;
/*
* Ignore state machines that are currently processing drop or
* release; there is nothing more we can do for them.
*/
if (dsmp->dsm_droprelease)
continue;
/*
* Look for link up/down notifications. These occur on a
* physical interface basis.
*/
if (msg.ifm.ifm_type == RTM_IFINFO) {
process_link_up_down(dsmp->dsm_lif->lif_pif, &msg.ifm);
continue;
}
/*
* Since we cannot trust the flags reported by the routing
* socket (they're just 32 bits -- and thus never include
* IFF_DUPLICATE), and we can't trust the ifindex (it's only 16
* bits and also doesn't reflect the alias in use), we get
* flags on all matching interfaces, and go by that.
*/
lif_finished = B_FALSE;
lease_removed = B_FALSE;
for (dlp = dsmp->dsm_leases; dlp != NULL; dlp = dlnext) {
dhcp_lif_t *lif, *lifnext;
uint_t nlifs = dlp->dl_nlifs;
dlnext = dlp->dl_next;
for (lif = dlp->dl_lifs; lif != NULL && nlifs > 0;
lif = lifnext, nlifs--) {
lifnext = lif->lif_next;
if (check_lif(lif, &msg.ifam, msglen)) {
dsmp->dsm_lif_wait--;
lif_finished = B_TRUE;
}
}
if (dlp->dl_nlifs == 0) {
remove_lease(dlp);
lease_removed = B_TRUE;
}
}
if ((isv6 && !check_main_lif(dsmp, &msg.ifam, msglen)) ||
(!isv6 && !verify_lif(dsmp->dsm_lif))) {
finished_smach(dsmp, DHCP_IPC_E_INVIF);
continue;
}
/*
* Ignore this state machine if nothing interesting has
* happened.
*/
if (!lif_finished && dsmp->dsm_lif_down == 0 &&
(dsmp->dsm_leases != NULL || !lease_removed))
continue;
/*
* If we're still waiting for DAD to complete on some of the
* configured LIFs, then don't send a response.
*/
if (dsmp->dsm_lif_wait != 0) {
dhcpmsg(MSG_VERBOSE, "rtsock_event: %s still has %d "
"LIFs waiting on DAD", dsmp->dsm_name,
dsmp->dsm_lif_wait);
continue;
}
/*
* If we have some failed LIFs, then handle them now. We'll
* remove them from the list. Any leases that become empty are
* also removed as part of the decline-generation process.
*/
if (dsmp->dsm_lif_down != 0)
send_declines(dsmp);
if (dsmp->dsm_leases == NULL) {
dsmp->dsm_bad_offers++;
/*
* For DHCPv6, we'll process the restart once we're
* done sending Decline messages, because these are
* supposed to be acknowledged. With DHCPv4, there's
* no acknowledgment for a DECLINE, so after sending
* it, we just restart right away.
*/
if (!dsmp->dsm_isv6) {
dhcpmsg(MSG_VERBOSE, "rtsock_event: %s has no "
"LIFs left", dsmp->dsm_name);
dhcp_restart(dsmp);
}
} else {
/*
* If we're now up on at least some of the leases and
* we were waiting for that, then kick off the rest of
* configuration. Lease validation and DAD are done.
*/
dhcpmsg(MSG_VERBOSE, "rtsock_event: all LIFs verified "
"on %s in %s state", dsmp->dsm_name,
dhcp_state_to_string(oldstate));
if (oldstate == PRE_BOUND ||
oldstate == ADOPTING)
dhcp_bound_complete(dsmp);
if (oldstate == ADOPTING)
dhcp_adopt_complete(dsmp);
}
}
}