void
server_unicast_option(dhcp_smach_t *dsmp, PKT_LIST *plp)
{
const dhcpv6_option_t *d6o;
uint_t olen;
d6o = dhcpv6_pkt_option(plp, NULL, DHCPV6_OPT_UNICAST, &olen);
olen -= sizeof (*d6o);
/* LINTED: no consequent */
if (d6o == NULL) {
/* No Server Unicast option specified */
} else if (olen != sizeof (dsmp->dsm_server)) {
dhcpmsg(MSG_WARNING, "server_unicast_option: %s has Server "
"Unicast option with bad length",
pkt_type_to_string(pkt_recv_type(plp), B_TRUE));
} else {
in6_addr_t addr;
(void) memcpy(&addr, d6o + 1, olen);
if (IN6_IS_ADDR_UNSPECIFIED(&addr)) {
dhcpmsg(MSG_WARNING, "server_unicast_option: unicast "
"to unspecified address ignored");
} else if (IN6_IS_ADDR_MULTICAST(&addr)) {
dhcpmsg(MSG_WARNING, "server_unicast_option: unicast "
"to multicast address ignored");
} else if (IN6_IS_ADDR_V4COMPAT(&addr) ||
IN6_IS_ADDR_V4MAPPED(&addr)) {
dhcpmsg(MSG_WARNING, "server_unicast_option: unicast "
"to invalid address ignored");
} else {
dsmp->dsm_server = addr;
}
}
}
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 int
compute_points_v6(const PKT_LIST *pkt, const dhcp_smach_t *dsmp)
{
char abuf[INET6_ADDRSTRLEN];
int points = 0;
const dhcpv6_option_t *d6o, *d6so;
uint_t olen, solen;
int i;
const char *estr, *msg;
uint_t msglen;
/*
* Look through the packet contents. Valid packets must have our
* client ID and a server ID, which has already been checked by
* dhcp_packet_lif. Bonus points for each option.
*/
/* One point for having a valid message. */
points++;
/*
* Per RFC 3315, if the Advertise message says, "yes, we have no
* bananas today," then ignore the entire message. (Why it's just
* _this_ error and no other is a bit of a mystery, but a standard is a
* standard.)
*/
d6o = dhcpv6_pkt_option(pkt, NULL, DHCPV6_OPT_STATUS_CODE, &olen);
if (dhcpv6_status_code(d6o, olen, &estr, &msg, &msglen) ==
DHCPV6_STAT_NOADDRS) {
dhcpmsg(MSG_INFO,
"discard advertisement from %s on %s: no address status",
inet_ntop(AF_INET6,
&((struct sockaddr_in6 *)&pkt->pktfrom)->sin6_addr,
abuf, sizeof (abuf)), dsmp->dsm_name);
return (-1);
}
/* Two points for each batch of offered IP addresses */
d6o = NULL;
while ((d6o = dhcpv6_pkt_option(pkt, d6o, DHCPV6_OPT_IA_NA,
&olen)) != NULL) {
/*
* Note that it's possible to have "no bananas" on an
* individual IA. We must look for that here.
*
* RFC 3315 section 17.1.3 does not refer to the status code
* embedded in the IA itself. However, the TAHI test suite
* checks for this specific case. Because it's extremely
* unlikely that any usable server is going to report that it
* has no addresses on a network using DHCP for address
* assignment, we allow such messages to be dropped.
*/
d6so = dhcpv6_find_option(
(const char *)d6o + sizeof (dhcpv6_ia_na_t),
olen - sizeof (dhcpv6_ia_na_t), NULL,
DHCPV6_OPT_STATUS_CODE, &solen);
if (dhcpv6_status_code(d6so, solen, &estr, &msg, &msglen) ==
DHCPV6_STAT_NOADDRS)
return (-1);
points += 2;
}
/*
* Note that we drive on in the case where there are no addresses. The
* hope here is that we'll at least get some useful configuration
* information.
*/
/* One point for each requested option */
for (i = 0; i < dsmp->dsm_prllen; i++) {
if (dhcpv6_pkt_option(pkt, NULL, dsmp->dsm_prl[i], NULL) !=
NULL)
points++;
}
/*
* Ten points for each point of "preference." Note: the value 255 is
* special. It means "stop right now and select this server."
*/
d6o = dhcpv6_pkt_option(pkt, NULL, DHCPV6_OPT_PREFERENCE, &olen);
if (d6o != NULL && olen == sizeof (*d6o) + 1) {
int pref = *(const uchar_t *)(d6o + 1);
if (pref == 255)
return (-2);
points += 10 * pref;
}
return (points);
}
void
dhcp_requesting(iu_tq_t *tqp, void *arg)
{
dhcp_smach_t *dsmp = arg;
dhcp_pkt_t *dpkt;
PKT_LIST *offer;
lease_t lease;
boolean_t isv6 = dsmp->dsm_isv6;
/*
* We assume here that if tqp is set, then this means we're being
* called back by the offer wait timer. If so, then drop our hold
* on the state machine. Otherwise, cancel the timer if it's running.
*/
if (tqp != NULL) {
dhcpmsg(MSG_VERBOSE,
"dhcp_requesting: offer wait timer on v%d %s",
isv6 ? 6 : 4, dsmp->dsm_name);
dsmp->dsm_offer_timer = -1;
if (!verify_smach(dsmp))
return;
} else {
cancel_offer_timer(dsmp);
}
/*
* select the best OFFER; all others pitched.
*/
offer = select_best(dsmp);
if (offer == NULL) {
dhcpmsg(MSG_VERBOSE,
"no OFFERs/Advertisements on %s, waiting...",
dsmp->dsm_name);
/*
* no acceptable OFFERs have come in. reschedule
* ourself for callback.
*/
if ((dsmp->dsm_offer_timer = iu_schedule_timer(tq,
dsmp->dsm_offer_wait, dhcp_requesting, dsmp)) == -1) {
/*
* ugh. the best we can do at this point is
* revert back to INIT and wait for a user to
* restart us.
*/
dhcpmsg(MSG_WARNING, "dhcp_requesting: cannot "
"reschedule callback, reverting to INIT state on "
"%s", dsmp->dsm_name);
stop_pkt_retransmission(dsmp);
(void) set_smach_state(dsmp, INIT);
dsmp->dsm_dflags |= DHCP_IF_FAILED;
ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY);
} else {
hold_smach(dsmp);
}
return;
}
/*
* With IPv4, the DHCPREQUEST packet we're about to transmit implicitly
* declines all other offers we've received. We can no longer use any
* cached offers, so we must discard them now. With DHCPv6, though,
* we're permitted to hang onto the advertisements (offers) and try
* them if the preferred one doesn't pan out.
*/
if (!isv6)
free_pkt_list(&dsmp->dsm_recv_pkt_list);
/* stop collecting packets. */
stop_pkt_retransmission(dsmp);
/*
* For IPv4, check to see whether we got an OFFER or a BOOTP packet.
* If we got a BOOTP packet, go to the BOUND state now.
*/
if (!isv6 && offer->opts[CD_DHCP_TYPE] == NULL) {
free_pkt_list(&dsmp->dsm_recv_pkt_list);
if (!set_smach_state(dsmp, REQUESTING)) {
dhcp_restart(dsmp);
return;
}
if (!dhcp_bound(dsmp, offer)) {
dhcpmsg(MSG_WARNING, "dhcp_requesting: dhcp_bound "
"failed for %s", dsmp->dsm_name);
dhcp_restart(dsmp);
return;
}
return;
}
if (isv6) {
const char *estr, *msg;
const dhcpv6_option_t *d6o;
uint_t olen, msglen;
/* If there's a Status Code option, print the message */
d6o = dhcpv6_pkt_option(offer, NULL, DHCPV6_OPT_STATUS_CODE,
&olen);
(void) dhcpv6_status_code(d6o, olen, &estr, &msg, &msglen);
print_server_msg(dsmp, msg, msglen);
/* Copy in the Server ID (guaranteed to be present now) */
if (!save_server_id(dsmp, offer))
goto failure;
/*
* Determine how to send this message. If the Advertisement
* (offer) has the unicast option, then use the address
* specified in the option. Otherwise, send via multicast.
*/
server_unicast_option(dsmp, offer);
send_v6_request(dsmp);
} else {
/* if we got a message from the server, display it. */
if (offer->opts[CD_MESSAGE] != NULL) {
print_server_msg(dsmp,
(char *)offer->opts[CD_MESSAGE]->value,
offer->opts[CD_MESSAGE]->len);
}
/*
* assemble a DHCPREQUEST, with the ciaddr field set to 0,
* since we got here from the INIT state.
*/
dpkt = init_pkt(dsmp, REQUEST);
/*
* Grab the lease out of the OFFER; we know it's valid because
* select_best() already checked. The max dhcp message size
* option is set to the interface max, minus the size of the
* udp and ip headers.
*/
(void) memcpy(&lease, offer->opts[CD_LEASE_TIME]->value,
sizeof (lease_t));
(void) add_pkt_opt32(dpkt, CD_LEASE_TIME, lease);
(void) add_pkt_opt16(dpkt, CD_MAX_DHCP_SIZE,
htons(dsmp->dsm_lif->lif_max - sizeof (struct udpiphdr)));
(void) add_pkt_opt32(dpkt, CD_REQUESTED_IP_ADDR,
offer->pkt->yiaddr.s_addr);
(void) add_pkt_opt(dpkt, CD_SERVER_ID,
offer->opts[CD_SERVER_ID]->value,
offer->opts[CD_SERVER_ID]->len);
if (class_id_len != 0) {
(void) add_pkt_opt(dpkt, CD_CLASS_ID, class_id,
class_id_len);
}
(void) add_pkt_prl(dpkt, dsmp);
/*
* dsm_reqhost was set for this state machine in
* dhcp_selecting() if the DF_REQUEST_HOSTNAME option set and a
* host name was found
*/
if (dsmp->dsm_reqhost != NULL) {
(void) add_pkt_opt(dpkt, CD_HOSTNAME, dsmp->dsm_reqhost,
strlen(dsmp->dsm_reqhost));
}
(void) add_pkt_opt(dpkt, CD_END, NULL, 0);
/*
* send out the REQUEST, trying retransmissions. either a NAK
* or too many REQUEST attempts will revert us to SELECTING.
*/
if (!set_smach_state(dsmp, REQUESTING)) {
dhcpmsg(MSG_ERROR, "dhcp_requesting: cannot switch to "
"REQUESTING state; reverting to INIT on %s",
dsmp->dsm_name);
goto failure;
}
(void) send_pkt(dsmp, dpkt, htonl(INADDR_BROADCAST),
stop_requesting);
}
/* all done with the offer */
free_pkt_entry(offer);
return;
failure:
dsmp->dsm_dflags |= DHCP_IF_FAILED;
(void) set_smach_state(dsmp, INIT);
ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY);
free_pkt_list(&dsmp->dsm_recv_pkt_list);
}
/* ARGSUSED */
static void
ipc_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg)
{
ipc_action_t ia, *iap;
dhcp_smach_t *dsmp;
int error, is_priv = (int)arg;
const char *ifname;
boolean_t isv6;
boolean_t dsm_created = B_FALSE;
ipc_action_init(&ia);
error = dhcp_ipc_recv_request(fd, &ia.ia_request,
DHCP_IPC_REQUEST_WAIT);
if (error != DHCP_IPC_SUCCESS) {
if (error != DHCP_IPC_E_EOF) {
dhcpmsg(MSG_ERROR,
"ipc_event: dhcp_ipc_recv_request failed: %s",
dhcp_ipc_strerror(error));
} else {
dhcpmsg(MSG_DEBUG, "ipc_event: connection closed");
}
if ((dsmp = lookup_smach_by_event(id)) != NULL) {
ipc_action_finish(dsmp, error);
} else {
(void) iu_unregister_event(eh, id, NULL);
(void) dhcp_ipc_close(fd);
}
return;
}
/* Fill in temporary ipc_action structure for utility functions */
ia.ia_cmd = DHCP_IPC_CMD(ia.ia_request->message_type);
ia.ia_fd = fd;
ia.ia_eid = id;
if (ia.ia_cmd >= DHCP_NIPC) {
dhcpmsg(MSG_ERROR,
"ipc_event: invalid command (%s) attempted on %s",
dhcp_ipc_type_to_string(ia.ia_cmd), ia.ia_request->ifname);
send_error_reply(&ia, DHCP_IPC_E_CMD_UNKNOWN);
return;
}
/* return EPERM for any of the privileged actions */
if (!is_priv && (ipc_cmd_flags[ia.ia_cmd] & CMD_ISPRIV)) {
dhcpmsg(MSG_WARNING,
"ipc_event: privileged ipc command (%s) attempted on %s",
dhcp_ipc_type_to_string(ia.ia_cmd), ia.ia_request->ifname);
send_error_reply(&ia, DHCP_IPC_E_PERM);
return;
}
/*
* Try to locate the state machine associated with this command. If
* the command is DHCP_START or DHCP_INFORM and there isn't a state
* machine already, make one (there may already be one from a previous
* failed attempt to START or INFORM). Otherwise, verify the reference
* is still valid.
*
* The interface name may be blank. In that case, we look up the
* primary interface, and the requested type (v4 or v6) doesn't matter.
*/
isv6 = (ia.ia_request->message_type & DHCP_V6) != 0;
ifname = ia.ia_request->ifname;
if (*ifname == '\0')
dsmp = primary_smach(isv6);
else
dsmp = lookup_smach(ifname, isv6);
if (dsmp != NULL) {
/* Note that verify_smach drops a reference */
hold_smach(dsmp);
if (!verify_smach(dsmp))
dsmp = NULL;
}
if (dsmp == NULL) {
/*
* If the user asked for the primary DHCP interface by giving
* an empty string and there is no primary, then check if we're
* handling dhcpinfo. If so, then simulate primary selection.
* Otherwise, report failure.
*/
if (ifname[0] == '\0') {
if (ia.ia_cmd == DHCP_GET_TAG)
dsmp = info_primary_smach(isv6);
if (dsmp == NULL)
error = DHCP_IPC_E_NOPRIMARY;
/*
* If there's no interface, and we're starting up, then create
* it now, along with a state machine for it. Note that if
* insert_smach fails, it discards the LIF reference.
*/
} else if (ipc_cmd_flags[ia.ia_cmd] & CMD_CREATE) {
dhcp_lif_t *lif;
lif = attach_lif(ifname, isv6, &error);
if (lif != NULL &&
(dsmp = insert_smach(lif, &error)) != NULL) {
/*
* Get client ID for logical interface. (V4
* only, because V6 plumbs its own interfaces.)
*/
error = get_smach_cid(dsmp);
if (error != DHCP_IPC_SUCCESS) {
remove_smach(dsmp);
dsmp = NULL;
}
dsm_created = (dsmp != NULL);
}
/*
* Otherwise, this is an operation on an unknown interface.
*/
} else {
error = DHCP_IPC_E_UNKIF;
}
if (dsmp == NULL) {
send_error_reply(&ia, error);
return;
}
}
/*
* If this is a request for DHCP to manage a lease on an address,
* ensure that IFF_DHCPRUNNING is set (we don't set this when the lif
* is created because the lif may have been created for INFORM).
*/
if (ia.ia_cmd == DHCP_START &&
(error = set_lif_dhcp(dsmp->dsm_lif)) != DHCP_IPC_SUCCESS) {
if (dsm_created)
remove_smach(dsmp);
send_error_reply(&ia, error);
return;
}
if ((dsmp->dsm_dflags & DHCP_IF_BOOTP) &&
!(ipc_cmd_flags[ia.ia_cmd] & CMD_BOOTP)) {
dhcpmsg(MSG_ERROR, "command %s not valid for BOOTP on %s",
dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name);
send_error_reply(&ia, DHCP_IPC_E_BOOTP);
return;
}
/*
* verify that the state machine is in a state which will allow the
* command. we do this up front so that we can return an error
* *before* needlessly cancelling an in-progress transaction.
*/
if (!check_cmd_allowed(dsmp->dsm_state, ia.ia_cmd)) {
dhcpmsg(MSG_DEBUG,
"in state %s; not allowing %s command on %s",
dhcp_state_to_string(dsmp->dsm_state),
dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name);
send_error_reply(&ia,
ia.ia_cmd == DHCP_START && dsmp->dsm_state != INIT ?
DHCP_IPC_E_RUNNING : DHCP_IPC_E_OUTSTATE);
return;
}
dhcpmsg(MSG_DEBUG, "in state %s; allowing %s command on %s",
dhcp_state_to_string(dsmp->dsm_state),
dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name);
if ((ia.ia_request->message_type & DHCP_PRIMARY) && is_priv)
make_primary(dsmp);
/*
* The current design dictates that there can be only one outstanding
* transaction per state machine -- this simplifies the code
* considerably and also fits well with RFCs 2131 and 3315. It is
* worth classifying the different DHCP commands into synchronous
* (those which we will handle now and reply to immediately) and
* asynchronous (those which require transactions and will be completed
* at an indeterminate time in the future):
*
* DROP: removes the agent's management of a state machine.
* asynchronous as the script program may be invoked.
*
* PING: checks to see if the agent has a named state machine.
* synchronous, since no packets need to be sent
* to the DHCP server.
*
* STATUS: returns information about a state machine.
* synchronous, since no packets need to be sent
* to the DHCP server.
*
* RELEASE: releases the agent's management of a state machine
* and brings the associated interfaces down. asynchronous
* as the script program may be invoked.
*
* EXTEND: renews a lease. asynchronous, since the agent
* needs to wait for an ACK, etc.
*
* START: starts DHCP on a named state machine. asynchronous since
* the agent needs to wait for OFFERs, ACKs, etc.
*
* INFORM: obtains configuration parameters for the system using
* externally configured interface. asynchronous, since the
* agent needs to wait for an ACK.
*
* Notice that EXTEND, INFORM, START, DROP and RELEASE are
* asynchronous. Notice also that asynchronous commands may occur from
* within the agent -- for instance, the agent will need to do implicit
* EXTENDs to extend the lease. In order to make the code simpler, the
* following rules apply for asynchronous commands:
*
* There can only be one asynchronous command at a time per state
* machine. The current asynchronous command is managed by the async_*
* api: async_start(), async_finish(), and async_cancel().
* async_start() starts management of a new asynchronous command on an
* state machine, which should only be done after async_cancel() to
* terminate a previous command. When the command is completed,
* async_finish() should be called.
*
* Asynchronous commands started by a user command have an associated
* ipc_action which provides the agent with information for how to get
* in touch with the user command when the action completes. These
* ipc_action records also have an associated timeout which may be
* infinite. ipc_action_start() should be called when starting an
* asynchronous command requested by a user, which sets up the timer
* and keeps track of the ipc information (file descriptor, request
* type). When the asynchronous command completes, ipc_action_finish()
* should be called to return a command status code to the user and
* close the ipc connection). If the command does not complete before
* the timer fires, ipc_action_timeout() is called which closes the ipc
* connection and returns DHCP_IPC_E_TIMEOUT to the user. Note that
* independent of ipc_action_timeout(), ipc_action_finish() should be
* called.
*
* on a case-by-case basis, here is what happens (per state machine):
*
* o When an asynchronous command is requested, then
* async_cancel() is called to terminate any non-user
* action in progress. If there's a user action running,
* the user command is sent DHCP_IPC_E_PEND.
*
* o otherwise, the the transaction is started with
* async_start(). if the transaction is on behalf
* of a user, ipc_action_start() is called to keep
* track of the ipc information and set up the
* ipc_action timer.
*
* o if the command completes normally and before a
* timeout fires, then async_finish() is called.
* if there was an associated ipc_action,
* ipc_action_finish() is called to complete it.
*
* o if the command fails before a timeout fires, then
* async_finish() is called, and the state machine is
* is returned to a known state based on the command.
* if there was an associated ipc_action,
* ipc_action_finish() is called to complete it.
*
* o if the ipc_action timer fires before command
* completion, then DHCP_IPC_E_TIMEOUT is returned to
* the user. however, the transaction continues to
* be carried out asynchronously.
*/
if (ipc_cmd_flags[ia.ia_cmd] & CMD_IMMED) {
/*
* Only immediate commands (ping, status, get_tag) need to
* worry about freeing ia through one of the reply functions
* before returning.
*/
iap = &ia;
} else {
/*
* if shutdown request has been received, send back an error.
*/
if (shutdown_started) {
send_error_reply(&ia, DHCP_IPC_E_OUTSTATE);
return;
}
if (dsmp->dsm_dflags & DHCP_IF_BUSY) {
send_error_reply(&ia, DHCP_IPC_E_PEND);
return;
}
if (!ipc_action_start(dsmp, &ia)) {
dhcpmsg(MSG_WARNING, "ipc_event: ipc_action_start "
"failed for %s", dsmp->dsm_name);
send_error_reply(&ia, DHCP_IPC_E_MEMORY);
return;
}
/* Action structure consumed by above function */
iap = &dsmp->dsm_ia;
}
switch (iap->ia_cmd) {
case DHCP_DROP:
if (dsmp->dsm_droprelease)
break;
dsmp->dsm_droprelease = B_TRUE;
/*
* Ensure that a timer associated with the existing state
* doesn't pop while we're waiting for the script to complete.
* (If so, chaos can result -- e.g., a timer causes us to end
* up in dhcp_selecting() would start acquiring a new lease on
* dsmp while our DHCP_DROP dismantling is ongoing.)
*/
cancel_smach_timers(dsmp);
(void) script_start(dsmp, isv6 ? EVENT_DROP6 : EVENT_DROP,
dhcp_drop, NULL, NULL);
break; /* not an immediate function */
case DHCP_EXTEND:
dhcp_smach_set_msg_reqhost(dsmp, iap);
(void) dhcp_extending(dsmp);
break;
case DHCP_GET_TAG: {
dhcp_optnum_t optnum;
void *opt = NULL;
uint_t optlen;
boolean_t did_alloc = B_FALSE;
PKT_LIST *ack = dsmp->dsm_ack;
int i;
/*
* verify the request makes sense.
*/
if (iap->ia_request->data_type != DHCP_TYPE_OPTNUM ||
iap->ia_request->data_length != sizeof (dhcp_optnum_t)) {
send_error_reply(iap, DHCP_IPC_E_PROTO);
break;
}
(void) memcpy(&optnum, iap->ia_request->buffer,
sizeof (dhcp_optnum_t));
load_option:
switch (optnum.category) {
case DSYM_SITE: /* FALLTHRU */
case DSYM_STANDARD:
for (i = 0; i < dsmp->dsm_pillen; i++) {
if (dsmp->dsm_pil[i] == optnum.code)
break;
}
if (i < dsmp->dsm_pillen)
break;
if (isv6) {
opt = dhcpv6_pkt_option(ack, NULL, optnum.code,
NULL);
} else {
opt = dhcp_get_ack_or_state(dsmp, ack,
optnum.code, &did_alloc);
}
break;
case DSYM_VENDOR:
if (isv6) {
dhcpv6_option_t *d6o;
uint32_t ent;
/*
* Look through vendor options to find our
* enterprise number.
*/
d6o = NULL;
for (;;) {
d6o = dhcpv6_pkt_option(ack, d6o,
DHCPV6_OPT_VENDOR_OPT, &optlen);
if (d6o == NULL)
break;
optlen -= sizeof (*d6o);
if (optlen < sizeof (ent))
continue;
(void) memcpy(&ent, d6o + 1,
sizeof (ent));
if (ntohl(ent) != DHCPV6_SUN_ENT)
continue;
break;
}
if (d6o != NULL) {
/*
* Now find the requested vendor option
* within the vendor options block.
*/
opt = dhcpv6_find_option(
(char *)(d6o + 1) + sizeof (ent),
optlen - sizeof (ent), NULL,
optnum.code, NULL);
}
} else {
/*
* the test against VS_OPTION_START is broken
* up into two tests to avoid compiler warnings
* under intel.
*/
if ((optnum.code > VS_OPTION_START ||
optnum.code == VS_OPTION_START) &&
optnum.code <= VS_OPTION_END)
opt = ack->vs[optnum.code];
}
break;
case DSYM_FIELD:
if (isv6) {
dhcpv6_message_t *d6m =
(dhcpv6_message_t *)ack->pkt;
dhcpv6_option_t *d6o;
/* Validate the packet field the user wants */
optlen = optnum.code + optnum.size;
if (d6m->d6m_msg_type ==
DHCPV6_MSG_RELAY_FORW ||
d6m->d6m_msg_type ==
DHCPV6_MSG_RELAY_REPL) {
if (optlen > sizeof (dhcpv6_relay_t))
break;
} else {
if (optlen > sizeof (*d6m))
break;
}
opt = malloc(sizeof (*d6o) + optnum.size);
if (opt != NULL) {
d6o = opt;
d6o->d6o_code = htons(optnum.code);
d6o->d6o_len = htons(optnum.size);
(void) memcpy(d6o + 1, (caddr_t)d6m +
optnum.code, optnum.size);
}
} else {
if (optnum.code + optnum.size > sizeof (PKT))
break;
opt = malloc(optnum.size + DHCP_OPT_META_LEN);
if (opt != NULL) {
DHCP_OPT *v4opt = opt;
v4opt->len = optnum.size;
v4opt->code = optnum.code;
(void) memcpy(v4opt->value,
(caddr_t)ack->pkt + optnum.code,
optnum.size);
}
}
if (opt == NULL) {
send_error_reply(iap, DHCP_IPC_E_MEMORY);
return;
}
did_alloc = B_TRUE;
break;
default:
send_error_reply(iap, DHCP_IPC_E_PROTO);
return;
}
/*
* return the option payload, if there was one.
*/
if (opt != NULL) {
if (isv6) {
dhcpv6_option_t d6ov;
(void) memcpy(&d6ov, opt, sizeof (d6ov));
optlen = ntohs(d6ov.d6o_len) + sizeof (d6ov);
} else {
optlen = ((DHCP_OPT *)opt)->len +
DHCP_OPT_META_LEN;
}
send_data_reply(iap, 0, DHCP_TYPE_OPTION, opt, optlen);
if (did_alloc)
free(opt);
break;
} else if (ack != dsmp->dsm_orig_ack) {
/*
* There wasn't any definition for the option in the
* current ack, so now retry with the original ack if
* the original ack is not the current ack.
*/
ack = dsmp->dsm_orig_ack;
goto load_option;
}
/*
* note that an "okay" response is returned either in
* the case of an unknown option or a known option
* with no payload. this is okay (for now) since
* dhcpinfo checks whether an option is valid before
* ever performing ipc with the agent.
*/
send_ok_reply(iap);
break;
}
case DHCP_INFORM:
dhcp_inform(dsmp);
/* next destination: dhcp_acknak() */
break; /* not an immediate function */
case DHCP_PING:
if (dsmp->dsm_dflags & DHCP_IF_FAILED)
send_error_reply(iap, DHCP_IPC_E_FAILEDIF);
else
send_ok_reply(iap);
break;
case DHCP_RELEASE:
if (dsmp->dsm_droprelease)
break;
dsmp->dsm_droprelease = B_TRUE;
cancel_smach_timers(dsmp); /* see comment in DHCP_DROP above */
(void) script_start(dsmp, isv6 ? EVENT_RELEASE6 :
EVENT_RELEASE, dhcp_release, "Finished with lease.", NULL);
break; /* not an immediate function */
case DHCP_START: {
PKT_LIST *ack, *oack;
PKT_LIST *plp[2];
deprecate_leases(dsmp);
dhcp_smach_set_msg_reqhost(dsmp, iap);
/*
* if we have a valid hostconf lying around, then jump
* into INIT_REBOOT. if it fails, we'll end up going
* through the whole selecting() procedure again.
*/
error = read_hostconf(dsmp->dsm_name, plp, 2, dsmp->dsm_isv6);
ack = error > 0 ? plp[0] : NULL;
oack = error > 1 ? plp[1] : NULL;
/*
* If the allocation of the old ack fails, that's fine;
* continue without it.
*/
if (oack == NULL)
oack = ack;
/*
* As long as we've allocated something, start using it.
*/
if (ack != NULL) {
dsmp->dsm_orig_ack = oack;
dsmp->dsm_ack = ack;
dhcp_init_reboot(dsmp);
/* next destination: dhcp_acknak() */
break;
}
/*
* if not debugging, wait for a few seconds before
* going into SELECTING.
*/
if (debug_level != 0 || !set_start_timer(dsmp)) {
dhcp_selecting(dsmp);
/* next destination: dhcp_requesting() */
}
/* else next destination: dhcp_start() */
}
break;
case DHCP_STATUS: {
dhcp_status_t status;
dhcp_lease_t *dlp;
status.if_began = monosec_to_time(dsmp->dsm_curstart_monosec);
/*
* We return information on just the first lease as being
* representative of the lot. A better status mechanism is
* needed.
*/
dlp = dsmp->dsm_leases;
if (dlp == NULL ||
dlp->dl_lifs->lif_expire.dt_start == DHCP_PERM) {
status.if_t1 = DHCP_PERM;
status.if_t2 = DHCP_PERM;
status.if_lease = DHCP_PERM;
} else {
status.if_t1 = status.if_began +
dlp->dl_t1.dt_start;
status.if_t2 = status.if_began +
dlp->dl_t2.dt_start;
status.if_lease = status.if_began +
dlp->dl_lifs->lif_expire.dt_start;
}
status.version = DHCP_STATUS_VER;
status.if_state = dsmp->dsm_state;
status.if_dflags = dsmp->dsm_dflags;
status.if_sent = dsmp->dsm_sent;
status.if_recv = dsmp->dsm_received;
status.if_bad_offers = dsmp->dsm_bad_offers;
(void) strlcpy(status.if_name, dsmp->dsm_name, LIFNAMSIZ);
send_data_reply(iap, 0, DHCP_TYPE_STATUS, &status,
sizeof (dhcp_status_t));
break;
}
}
}
static void
dhcp_init_reboot_v6(dhcp_smach_t *dsmp)
{
dhcp_pkt_t *dpkt;
dhcpv6_option_t *d6o, *d6so, *popt;
uint_t olen, solen;
dhcpv6_ia_na_t d6in;
dhcpv6_iaaddr_t d6ia;
char *obase;
/*
* Assemble a Confirm message based on the current ack.
*/
dpkt = init_pkt(dsmp, DHCPV6_MSG_CONFIRM);
/*
* Loop over and copy IA_NAs and IAADDRs we have in our last ack. This
* is what we'll be requesting.
*/
d6o = NULL;
while ((d6o = dhcpv6_pkt_option(dsmp->dsm_ack, d6o, DHCPV6_OPT_IA_NA,
&olen)) != NULL) {
/*
* Copy in IA_NA option from the ack. Note that we use zero
* for all timers in accordance with RFC 3315. (It would make
* some sense to say what we think the current timers are as
* a hint to the server, but the RFC doesn't agree.)
*/
if (olen < sizeof (dhcpv6_ia_na_t))
continue;
(void) memcpy(&d6in, d6o, sizeof (d6in));
d6in.d6in_t1 = 0;
d6in.d6in_t2 = 0;
popt = add_pkt_opt(dpkt, DHCPV6_OPT_IA_NA,
(char *)&d6in + sizeof (*d6o),
sizeof (d6in) - sizeof (*d6o));
if (popt == NULL)
goto failure;
/*
* Now loop over the IAADDR suboptions and add those.
*/
obase = (char *)d6o + sizeof (dhcpv6_ia_na_t);
olen -= sizeof (dhcpv6_ia_na_t);
d6so = NULL;
while ((d6so = dhcpv6_find_option(obase, olen, d6so,
DHCPV6_OPT_IAADDR, &solen)) != NULL) {
if (solen < sizeof (dhcpv6_iaaddr_t))
continue;
(void) memcpy(&d6ia, d6so, sizeof (d6ia));
d6ia.d6ia_preflife = 0;
d6ia.d6ia_vallife = 0;
if (add_pkt_subopt(dpkt, popt, DHCPV6_OPT_IAADDR,
(char *)&d6ia + sizeof (*d6so),
sizeof (d6ia) - sizeof (*d6so)) == NULL)
goto failure;
}
}
/* Add required Option Request option */
(void) add_pkt_prl(dpkt, dsmp);
(void) send_pkt_v6(dsmp, dpkt, ipv6_all_dhcp_relay_and_servers,
stop_init_reboot, DHCPV6_CNF_TIMEOUT, DHCPV6_CNF_MAX_RT);
return;
failure:
if (!set_start_timer(dsmp))
dhcp_selecting(dsmp);
}