static int
dhcp_finish_expire(dhcp_smach_t *dsmp, void *arg)
{
dhcp_lif_t *lif = arg;
dhcp_lease_t *dlp;
dhcpmsg(MSG_DEBUG, "lease expired on %s; removing", lif->lif_name);
dlp = lif->lif_lease;
unplumb_lif(lif);
if (dlp->dl_nlifs == 0)
remove_lease(dlp);
release_lif(lif);
/* If some valid leases remain, then drive on */
if (dsmp->dsm_leases != NULL) {
dhcpmsg(MSG_DEBUG,
"dhcp_finish_expire: some leases remain on %s",
dsmp->dsm_name);
return (1);
}
(void) remove_hostconf(dsmp->dsm_name, dsmp->dsm_isv6);
dhcpmsg(MSG_INFO, "last lease expired on %s -- restarting DHCP",
dsmp->dsm_name);
/*
* in the case where the lease is less than DHCP_REBIND_MIN
* seconds, we will never enter dhcp_renew() and thus the packet
* counters will not be reset. in that case, reset them here.
*/
if (dsmp->dsm_state == BOUND) {
dsmp->dsm_bad_offers = 0;
dsmp->dsm_sent = 0;
dsmp->dsm_received = 0;
}
deprecate_leases(dsmp);
/* reset_smach() in dhcp_selecting() will clean up any leftover state */
dhcp_selecting(dsmp);
return (1);
}
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);
}
static void
accept_v4_acknak(dhcp_smach_t *dsmp, PKT_LIST *plp)
{
/* Account for received and processed messages */
dsmp->dsm_received++;
if (*plp->opts[CD_DHCP_TYPE]->value == ACK) {
if (dsmp->dsm_state != INFORM_SENT &&
dsmp->dsm_state != INFORMATION &&
(plp->opts[CD_LEASE_TIME] == NULL ||
plp->opts[CD_LEASE_TIME]->len != sizeof (lease_t))) {
dhcpmsg(MSG_WARNING, "accept_v4_acknak: ACK packet on "
"%s missing mandatory lease option, ignored",
dsmp->dsm_name);
dsmp->dsm_bad_offers++;
free_pkt_entry(plp);
return;
}
if ((dsmp->dsm_state == RENEWING ||
dsmp->dsm_state == REBINDING) &&
dsmp->dsm_leases->dl_lifs->lif_addr !=
plp->pkt->yiaddr.s_addr) {
dhcpmsg(MSG_WARNING, "accept_v4_acknak: renewal ACK "
"packet has a different IP address (%s), ignored",
inet_ntoa(plp->pkt->yiaddr));
dsmp->dsm_bad_offers++;
free_pkt_entry(plp);
return;
}
}
/*
* looks good; cancel the retransmission timer and unregister
* the acknak handler. ACK to BOUND, NAK back to SELECTING.
*/
stop_pkt_retransmission(dsmp);
if (*plp->opts[CD_DHCP_TYPE]->value == NAK) {
char saddr[18];
saddr[0] = '\0';
if (plp->opts[CD_SERVER_ID] != NULL &&
plp->opts[CD_SERVER_ID]->len == sizeof (struct in_addr)) {
struct in_addr t_server;
bcopy(plp->opts[CD_SERVER_ID]->value, &t_server,
plp->opts[CD_SERVER_ID]->len);
(void) strlcpy(saddr, inet_ntoa(t_server),
sizeof (saddr));
}
dhcpmsg(MSG_WARNING, "accept_v4_acknak: NAK on interface %s "
"from %s %s",
dsmp->dsm_name,
inet_ntoa(plp->pktfrom.v4.sin_addr), saddr);
dsmp->dsm_bad_offers++;
free_pkt_entry(plp);
dhcp_restart(dsmp);
/*
* remove any bogus cached configuration we might have
* around (right now would only happen if we got here
* from INIT_REBOOT).
*/
(void) remove_hostconf(dsmp->dsm_name, dsmp->dsm_isv6);
return;
}
if (plp->opts[CD_SERVER_ID] == NULL ||
plp->opts[CD_SERVER_ID]->len != sizeof (ipaddr_t)) {
dhcpmsg(MSG_ERROR, "accept_v4_acknak: ACK with no valid "
"server id on %s", dsmp->dsm_name);
dsmp->dsm_bad_offers++;
free_pkt_entry(plp);
dhcp_restart(dsmp);
return;
}
if (plp->opts[CD_MESSAGE] != NULL) {
print_server_msg(dsmp, (char *)plp->opts[CD_MESSAGE]->value,
plp->opts[CD_MESSAGE]->len);
}
dhcpmsg(MSG_VERBOSE, "accept_v4_acknak: ACK on %s", dsmp->dsm_name);
if (!dhcp_bound(dsmp, plp)) {
dhcpmsg(MSG_WARNING, "accept_v4_acknak: dhcp_bound failed "
"for %s", dsmp->dsm_name);
dhcp_restart(dsmp);
}
}
void
dhcp_selecting(dhcp_smach_t *dsmp)
{
dhcp_pkt_t *dpkt;
/*
* We first set up to collect OFFER/Advertise packets as they arrive.
* We then send out DISCOVER/Solicit probes. Then we wait a
* user-tunable number of seconds before seeing if OFFERs/
* Advertisements have come in response to our DISCOVER/Solicit. If
* none have come in, we continue to wait, sending out our DISCOVER/
* Solicit probes with exponential backoff. If no OFFER/Advertisement
* is ever received, we will wait forever (note that since we're
* event-driven though, we're still able to service other state
* machines).
*
* Note that we do an reset_smach() here because we may be landing in
* dhcp_selecting() as a result of restarting DHCP, so the state
* machine may not be fresh.
*/
reset_smach(dsmp);
if (!set_smach_state(dsmp, SELECTING)) {
dhcpmsg(MSG_ERROR,
"dhcp_selecting: cannot switch to SELECTING state; "
"reverting to INIT on %s", dsmp->dsm_name);
goto failed;
}
/* Remove the stale hostconf file, if there is any */
(void) remove_hostconf(dsmp->dsm_name, dsmp->dsm_isv6);
dsmp->dsm_offer_timer = iu_schedule_timer(tq,
dsmp->dsm_offer_wait, dhcp_requesting, dsmp);
if (dsmp->dsm_offer_timer == -1) {
dhcpmsg(MSG_ERROR, "dhcp_selecting: cannot schedule to read "
"%s packets", dsmp->dsm_isv6 ? "Advertise" : "OFFER");
goto failed;
}
hold_smach(dsmp);
/*
* Assemble and send the DHCPDISCOVER or Solicit message.
*
* If this fails, we'll wait for the select timer to go off
* before trying again.
*/
if (dsmp->dsm_isv6) {
dhcpv6_ia_na_t d6in;
if ((dpkt = init_pkt(dsmp, DHCPV6_MSG_SOLICIT)) == NULL) {
dhcpmsg(MSG_ERROR, "dhcp_selecting: unable to set up "
"Solicit packet");
return;
}
/* Add an IA_NA option for our controlling LIF */
d6in.d6in_iaid = htonl(dsmp->dsm_lif->lif_iaid);
d6in.d6in_t1 = htonl(0);
d6in.d6in_t2 = htonl(0);
(void) add_pkt_opt(dpkt, DHCPV6_OPT_IA_NA,
(dhcpv6_option_t *)&d6in + 1,
sizeof (d6in) - sizeof (dhcpv6_option_t));
/* Option Request option for desired information */
(void) add_pkt_prl(dpkt, dsmp);
/* Enable Rapid-Commit */
(void) add_pkt_opt(dpkt, DHCPV6_OPT_RAPID_COMMIT, NULL, 0);
/* xxx add Reconfigure Accept */
(void) send_pkt_v6(dsmp, dpkt, ipv6_all_dhcp_relay_and_servers,
stop_selecting, DHCPV6_SOL_TIMEOUT, DHCPV6_SOL_MAX_RT);
} else {
if ((dpkt = init_pkt(dsmp, DISCOVER)) == NULL) {
dhcpmsg(MSG_ERROR, "dhcp_selecting: unable to set up "
"DISCOVER packet");
return;
}
/*
* The max DHCP message size option is set to the interface
* MTU, minus the size of the UDP and IP headers.
*/
(void) add_pkt_opt16(dpkt, CD_MAX_DHCP_SIZE,
htons(dsmp->dsm_lif->lif_max - sizeof (struct udpiphdr)));
(void) add_pkt_opt32(dpkt, CD_LEASE_TIME, htonl(DHCP_PERM));
if (class_id_len != 0) {
(void) add_pkt_opt(dpkt, CD_CLASS_ID, class_id,
class_id_len);
}
(void) add_pkt_prl(dpkt, dsmp);
if (!dhcp_add_fqdn_opt(dpkt, dsmp))
(void) dhcp_add_hostname_opt(dpkt, dsmp);
(void) add_pkt_opt(dpkt, CD_END, NULL, 0);
(void) send_pkt(dsmp, dpkt, htonl(INADDR_BROADCAST),
stop_selecting);
}
return;
failed:
(void) set_smach_state(dsmp, INIT);
dsmp->dsm_dflags |= DHCP_IF_FAILED;
ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY);
}
