void dhcp_restart(dhcp_smach_t *dsmp) { if (dsmp->dsm_state == INFORM_SENT || dsmp->dsm_state == INFORMATION) return; /* * As we're returning to INIT state, we need to discard any leases we * may have, and (for v4) canonize the LIF. There's a bit of tension * between keeping around a possibly still working address, and obeying * the RFCs. A more elaborate design would be to mark the addresses as * DEPRECATED, and then start a removal timer. Such a design would * probably compromise testing. */ deprecate_leases(dsmp); if (!set_start_timer(dsmp)) { dhcpmsg(MSG_ERROR, "dhcp_restart: cannot schedule dhcp_start, " "reverting to INIT state on %s", dsmp->dsm_name); (void) set_smach_state(dsmp, INIT); dsmp->dsm_dflags |= DHCP_IF_FAILED; ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY); } else { dhcpmsg(MSG_DEBUG, "dhcp_restart: restarting DHCP on %s", dsmp->dsm_name); } }
void dhcp_init_reboot(dhcp_smach_t *dsmp) { dhcpmsg(MSG_VERBOSE, "%s has cached configuration - entering " "INIT_REBOOT", dsmp->dsm_name); if (!set_smach_state(dsmp, INIT_REBOOT)) { dhcpmsg(MSG_ERROR, "dhcp_init_reboot: cannot register to " "collect ACK/NAK packets, reverting to INIT on %s", dsmp->dsm_name); dsmp->dsm_dflags |= DHCP_IF_FAILED; (void) set_smach_state(dsmp, INIT); ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY); return; } if (dsmp->dsm_isv6) dhcp_init_reboot_v6(dsmp); else dhcp_init_reboot_v4(dsmp); }
/* ARGSUSED */ static void ipc_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg) { dhcp_ipc_request_t *request; struct ifslist *ifsp, *primary_ifsp; int error, is_priv = (int)arg; PKT_LIST *plp[2]; dhcp_ipc_type_t cmd; (void) iu_unregister_event(eh, id, NULL); if (dhcp_ipc_recv_request(fd, &request, DHCP_IPC_REQUEST_WAIT) != 0) { dhcpmsg(MSG_ERROR, "ipc_event: dhcp_ipc_recv_request failed"); (void) dhcp_ipc_close(fd); return; } cmd = DHCP_IPC_CMD(request->message_type); if (cmd >= DHCP_NIPC) { send_error_reply(request, DHCP_IPC_E_CMD_UNKNOWN, &fd); return; } /* return EPERM for any of the privileged actions */ if (!is_priv) { switch (cmd) { case DHCP_STATUS: case DHCP_PING: case DHCP_GET_TAG: break; default: dhcpmsg(MSG_WARNING, "ipc_event: privileged ipc " "command (%i) attempted on %s", cmd, request->ifname); send_error_reply(request, DHCP_IPC_E_PERM, &fd); return; } } /* * try to locate the ifs associated with this command. if the * command is DHCP_START or DHCP_INFORM, then if there isn't * an ifs already, make one (there may already be one from a * previous failed attempt to START or INFORM). otherwise, * verify the interface is still valid. */ ifsp = lookup_ifs(request->ifname); switch (cmd) { case DHCP_START: /* FALLTHRU */ case DHCP_INFORM: /* * it's possible that the interface already exists, but * has been abandoned. usually in those cases we should * return DHCP_IPC_E_UNKIF, but that makes little sense * in the case of "start" or "inform", so just ignore * the abandoned interface and start over anew. */ if (ifsp != NULL && verify_ifs(ifsp) == 0) ifsp = NULL; /* * as part of initializing the ifs, insert_ifs() * creates a DLPI stream at ifsp->if_dlpi_fd. */ if (ifsp == NULL) { ifsp = insert_ifs(request->ifname, B_FALSE, &error); if (ifsp == NULL) { send_error_reply(request, error, &fd); return; } } break; default: if (ifsp == NULL) { if (request->ifname[0] == '\0') error = DHCP_IPC_E_NOPRIMARY; else error = DHCP_IPC_E_UNKIF; send_error_reply(request, error, &fd); return; } break; } if (verify_ifs(ifsp) == 0) { send_error_reply(request, DHCP_IPC_E_UNKIF, &fd); return; } if (ifsp->if_dflags & DHCP_IF_BOOTP) { switch (cmd) { case DHCP_EXTEND: case DHCP_RELEASE: case DHCP_INFORM: send_error_reply(request, DHCP_IPC_E_BOOTP, &fd); return; default: break; } } /* * verify that the interface 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 (!ipc_cmd_allowed[ifsp->if_state][cmd]) { send_error_reply(request, DHCP_IPC_E_OUTSTATE, &fd); return; } if ((request->message_type & DHCP_PRIMARY) && is_priv) { if ((primary_ifsp = lookup_ifs("")) != NULL) primary_ifsp->if_dflags &= ~DHCP_IF_PRIMARY; ifsp->if_dflags |= DHCP_IF_PRIMARY; } /* * current design dictates that there can be only one * outstanding transaction per interface -- this simplifies * the code considerably and also fits well with RFC2131. * it is worth classifying the different DHCP commands into * synchronous (those which we will handle now and be done * with) and asynchronous (those which require transactions * and will be completed at an indeterminate time in the * future): * * DROP: removes the agent's management of an interface. * asynchronous as the script program may be invoked. * * PING: checks to see if the agent controls an interface. * synchronous, since no packets need to be sent * to the DHCP server. * * STATUS: returns information about the an interface. * synchronous, since no packets need to be sent * to the DHCP server. * * RELEASE: releases the agent's management of an interface * and brings the interface 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 an interface. asynchronous since * the agent needs to wait for OFFERs, ACKs, etc. * * INFORM: obtains configuration parameters for an 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 * interface. the current asynchronous command is managed by * the async_* api: async_start(), async_finish(), * async_timeout(), async_cancel(), and async_pending(). * async_start() starts management of a new asynchronous * command on an interface, which should only be done after * async_pending() is called to check that there are no * pending asynchronous commands on that interface. when the * command is completed, async_finish() should be called. all * asynchronous commands have an associated timer, which calls * async_timeout() when it times out. if async_timeout() * decides that the asynchronous command should be cancelled * (see below), it calls async_cancel() to attempt * cancellation. * * 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 interface): * * o when an asynchronous command is requested, then * async_pending() is called to see if there is already * an asynchronous event. if so, the command does not * proceed, and if there is an associated ipc_action, * 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 interface 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. * * o if async_timeout() fires before command completion, * then if the command was internal to the agent, it * is cancelled. otherwise, if it was a user command, * then if the user is still waiting for the command * to complete, the command continues and async_timeout() * is rescheduled. */ switch (cmd) { case DHCP_DROP: /* FALLTHRU */ case DHCP_RELEASE: /* FALLTHRU */ case DHCP_EXTEND: /* FALLTHRU */ case DHCP_INFORM: /* FALLTHRU */ case DHCP_START: /* * if shutdown request has been received, send back an error. */ if (shutdown_started) { send_error_reply(request, DHCP_IPC_E_OUTSTATE, &fd); return; } if (async_pending(ifsp)) { send_error_reply(request, DHCP_IPC_E_PEND, &fd); return; } if (ipc_action_start(ifsp, request, fd) == 0) { dhcpmsg(MSG_WARNING, "ipc_event: ipc_action_start " "failed for %s", ifsp->if_name); send_error_reply(request, DHCP_IPC_E_MEMORY, &fd); return; } if (async_start(ifsp, cmd, B_TRUE) == 0) { ipc_action_finish(ifsp, DHCP_IPC_E_MEMORY); return; } break; default: break; } switch (cmd) { case DHCP_DROP: (void) script_start(ifsp, EVENT_DROP, dhcp_drop, NULL, NULL); return; case DHCP_EXTEND: (void) dhcp_extending(ifsp); break; case DHCP_GET_TAG: { dhcp_optnum_t optnum; DHCP_OPT *opt = NULL; boolean_t did_alloc = B_FALSE; PKT_LIST *ack = ifsp->if_ack; /* * verify the request makes sense. */ if (request->data_type != DHCP_TYPE_OPTNUM || request->data_length != sizeof (dhcp_optnum_t)) { send_error_reply(request, DHCP_IPC_E_PROTO, &fd); return; } (void) memcpy(&optnum, request->buffer, sizeof (dhcp_optnum_t)); load_option: switch (optnum.category) { case DSYM_SITE: /* FALLTHRU */ case DSYM_STANDARD: if (optnum.code <= DHCP_LAST_OPT) opt = ack->opts[optnum.code]; break; case DSYM_VENDOR: /* * 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 (optnum.code + optnum.size > sizeof (PKT)) break; /* + 2 to account for option code and length byte */ opt = malloc(optnum.size + 2); if (opt == NULL) { send_error_reply(request, DHCP_IPC_E_MEMORY, &fd); return; } did_alloc = B_TRUE; opt->len = optnum.size; opt->code = optnum.code; (void) memcpy(&opt->value, (caddr_t)ack->pkt + opt->code, opt->len); break; default: send_error_reply(request, DHCP_IPC_E_PROTO, &fd); return; } /* * return the option payload, if there was one. the "+ 2" * accounts for the option code number and length byte. */ if (opt != NULL) { send_data_reply(request, &fd, 0, DHCP_TYPE_OPTION, opt, opt->len + 2); if (did_alloc) free(opt); return; } else if (ack != ifsp->if_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 = ifsp->if_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(request, &fd); return; } case DHCP_INFORM: dhcp_inform(ifsp); /* next destination: dhcp_acknak() */ return; case DHCP_PING: if (ifsp->if_dflags & DHCP_IF_FAILED) send_error_reply(request, DHCP_IPC_E_FAILEDIF, &fd); else send_ok_reply(request, &fd); return; case DHCP_RELEASE: (void) script_start(ifsp, EVENT_RELEASE, dhcp_release, "Finished with lease.", NULL); return; case DHCP_START: (void) canonize_ifs(ifsp); /* * 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(ifsp->if_name, plp, 2); if (error != -1) { ifsp->if_orig_ack = ifsp->if_ack = plp[0]; if (error > 1) { /* * Return indicated we had more than one packet * second one is the original ack. Older * versions of the agent wrote only one ack * to the file, we now keep both the first * ack as well as the last one. */ ifsp->if_orig_ack = plp[1]; } dhcp_init_reboot(ifsp); /* next destination: dhcp_acknak() */ return; } /* * if not debugging, wait for a few seconds before * going into SELECTING. */ if (debug_level == 0) { if (iu_schedule_timer_ms(tq, lrand48() % DHCP_SELECT_WAIT, dhcp_start, ifsp) != -1) { hold_ifs(ifsp); /* next destination: dhcp_start() */ return; } } dhcp_selecting(ifsp); /* next destination: dhcp_requesting() */ return; case DHCP_STATUS: { dhcp_status_t status; status.if_began = monosec_to_time(ifsp->if_curstart_monosec); if (ifsp->if_lease == DHCP_PERM) { status.if_t1 = DHCP_PERM; status.if_t2 = DHCP_PERM; status.if_lease = DHCP_PERM; } else { status.if_t1 = status.if_began + ifsp->if_t1; status.if_t2 = status.if_began + ifsp->if_t2; status.if_lease = status.if_began + ifsp->if_lease; } status.version = DHCP_STATUS_VER; status.if_state = ifsp->if_state; status.if_dflags = ifsp->if_dflags; status.if_sent = ifsp->if_sent; status.if_recv = ifsp->if_received; status.if_bad_offers = ifsp->if_bad_offers; (void) strlcpy(status.if_name, ifsp->if_name, IFNAMSIZ); send_data_reply(request, &fd, 0, DHCP_TYPE_STATUS, &status, sizeof (dhcp_status_t)); return; } default: return; } }
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); }
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); }
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); }
/* 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; } } }
int dhcp_extending(struct ifslist *ifsp) { dhcp_pkt_t *dpkt; if (ifsp->if_state == BOUND) { ifsp->if_neg_monosec = monosec(); ifsp->if_state = RENEWING; ifsp->if_bad_offers = 0; ifsp->if_sent = 0; ifsp->if_received = 0; } dhcpmsg(MSG_DEBUG, "dhcp_extending: registering dhcp_acknak on %s", ifsp->if_name); if (register_acknak(ifsp) == 0) { ipc_action_finish(ifsp, DHCP_IPC_E_MEMORY); async_finish(ifsp); dhcpmsg(MSG_WARNING, "dhcp_extending: cannot register " "dhcp_acknak for %s, not sending renew request", ifsp->if_name); return (0); } /* * assemble DHCPREQUEST message. The max dhcp message size * option is set to the interface max, minus the size of the udp and * ip headers. */ dpkt = init_pkt(ifsp, REQUEST); dpkt->pkt->ciaddr.s_addr = ifsp->if_addr.s_addr; add_pkt_opt16(dpkt, CD_MAX_DHCP_SIZE, htons(ifsp->if_max - sizeof (struct udpiphdr))); add_pkt_opt32(dpkt, CD_LEASE_TIME, htonl(DHCP_PERM)); add_pkt_opt(dpkt, CD_CLASS_ID, class_id, class_id_len); add_pkt_opt(dpkt, CD_REQUEST_LIST, ifsp->if_prl, ifsp->if_prllen); /* * if_reqhost was set for this interface in dhcp_selecting() * if the REQUEST_HOSTNAME option was set and a host name was * found. */ if (ifsp->if_reqhost != NULL) { add_pkt_opt(dpkt, CD_HOSTNAME, ifsp->if_reqhost, strlen(ifsp->if_reqhost)); } add_pkt_opt(dpkt, CD_END, NULL, 0); /* * if we can't send the packet, leave the event handler registered * anyway, since we're not expecting to get any other types of * packets in other than ACKs/NAKs anyway. */ return (send_pkt(ifsp, dpkt, ifsp->if_server.s_addr, NULL)); }