usr/src/cmd/cmd-inet/sbin/dhcpagent/select.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
  23  *
  24  * SELECTING state of the client state machine.
  25  */
  26
  27 #include <sys/types.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <strings.h>
  31 #include <time.h>
  32 #include <limits.h>
  33 #include <netinet/in.h>
  34 #include <net/route.h>
  35 #include <net/if.h>
  36 #include <netinet/dhcp.h>
  37 #include <netinet/udp.h>
  38 #include <netinet/ip_var.h>
  39 #include <netinet/udp_var.h>
  40 #include <dhcpmsg.h>
  41 #include <dhcp_hostconf.h>
  42
  43 #include "states.h"
  44 #include "agent.h"
  45 #include "util.h"
  46 #include "interface.h"
  47 #include "packet.h"
  48 #include "defaults.h"
  49
  50 static stop_func_t      stop_selecting;
  51
  52 /*
  53  * dhcp_start(): starts DHCP on a state machine
  54  *
  55  *   input: iu_tq_t *: unused
  56  *          void *: the state machine on which to start DHCP
  57  *  output: void
  58  */
  59
  60 /* ARGSUSED */
  61 static void
  62 dhcp_start(iu_tq_t *tqp, void *arg)
  63 {
  64         dhcp_smach_t    *dsmp = arg;
  65
  66         dsmp->dsm_start_timer = -1;
  67         (void) set_smach_state(dsmp, INIT);
  68         if (verify_smach(dsmp)) {
  69                 dhcpmsg(MSG_VERBOSE, "starting DHCP on %s", dsmp->dsm_name);
  70                 dhcp_selecting(dsmp);
  71         }
  72 }
  73
  74 /*
  75  * set_start_timer(): sets a random timer to start a DHCP state machine
  76  *
  77  *   input: dhcp_smach_t *: the state machine on which to start DHCP
  78  *  output: boolean_t: B_TRUE if a timer is now running
  79  */
  80
  81 boolean_t
  82 set_start_timer(dhcp_smach_t *dsmp)
  83 {
  84         if (dsmp->dsm_start_timer != -1)
  85                 return (B_TRUE);
  86
  87         dsmp->dsm_start_timer = iu_schedule_timer_ms(tq,
  88             lrand48() % DHCP_SELECT_WAIT, dhcp_start, dsmp);
  89         if (dsmp->dsm_start_timer == -1)
  90                 return (B_FALSE);
  91
  92         hold_smach(dsmp);
  93         return (B_TRUE);
  94 }
  95
  96 /*
  97  * dhcp_selecting(): sends a DISCOVER and sets up reception of OFFERs for
  98  *                   IPv4, or sends a Solicit and sets up reception of
  99  *                   Advertisements for DHCPv6.
 100  *
 101  *   input: dhcp_smach_t *: the state machine on which to send the DISCOVER
 102  *  output: void
 103  */
 104
 105 void
 106 dhcp_selecting(dhcp_smach_t *dsmp)
 107 {
 108         dhcp_pkt_t              *dpkt;
 109         const char              *reqhost;
 110         char                    hostfile[PATH_MAX + 1];
 111
 112         /*
 113          * We first set up to collect OFFER/Advertise packets as they arrive.
 114          * We then send out DISCOVER/Solicit probes.  Then we wait a
 115          * user-tunable number of seconds before seeing if OFFERs/
 116          * Advertisements have come in response to our DISCOVER/Solicit.  If
 117          * none have come in, we continue to wait, sending out our DISCOVER/
 118          * Solicit probes with exponential backoff.  If no OFFER/Advertisement
 119          * is ever received, we will wait forever (note that since we're
 120          * event-driven though, we're still able to service other state
 121          * machines).
 122          *
 123          * Note that we do an reset_smach() here because we may be landing in
 124          * dhcp_selecting() as a result of restarting DHCP, so the state
 125          * machine may not be fresh.
 126          */
 127
 128         reset_smach(dsmp);
 129         if (!set_smach_state(dsmp, SELECTING)) {
 130                 dhcpmsg(MSG_ERROR,
 131                     "dhcp_selecting: cannot switch to SELECTING state; "
 132                     "reverting to INIT on %s", dsmp->dsm_name);
 133                 goto failed;
 134
 135         }
 136
 137         /* Remove the stale hostconf file, if there is any */
 138         (void) remove_hostconf(dsmp->dsm_name, dsmp->dsm_isv6);
 139
 140         dsmp->dsm_offer_timer = iu_schedule_timer(tq,
 141             dsmp->dsm_offer_wait, dhcp_requesting, dsmp);
 142         if (dsmp->dsm_offer_timer == -1) {
 143                 dhcpmsg(MSG_ERROR, "dhcp_selecting: cannot schedule to read "
 144                     "%s packets", dsmp->dsm_isv6 ? "Advertise" : "OFFER");
 145                 goto failed;
 146         }
 147
 148         hold_smach(dsmp);
 149
 150         /*
 151          * Assemble and send the DHCPDISCOVER or Solicit message.
 152          *
 153          * If this fails, we'll wait for the select timer to go off
 154          * before trying again.
 155          */
 156         if (dsmp->dsm_isv6) {
 157                 dhcpv6_ia_na_t d6in;
 158
 159                 if ((dpkt = init_pkt(dsmp, DHCPV6_MSG_SOLICIT)) == NULL) {
 160                         dhcpmsg(MSG_ERROR, "dhcp_selecting: unable to set up "
 161                             "Solicit packet");
 162                         return;
 163                 }
 164
 165                 /* Add an IA_NA option for our controlling LIF */
 166                 d6in.d6in_iaid = htonl(dsmp->dsm_lif->lif_iaid);
 167                 d6in.d6in_t1 = htonl(0);
 168                 d6in.d6in_t2 = htonl(0);
 169                 (void) add_pkt_opt(dpkt, DHCPV6_OPT_IA_NA,
 170                     (dhcpv6_option_t *)&d6in + 1,
 171                     sizeof (d6in) - sizeof (dhcpv6_option_t));
 172
 173                 /* Option Request option for desired information */
 174                 (void) add_pkt_prl(dpkt, dsmp);
 175
 176                 /* Enable Rapid-Commit */
 177                 (void) add_pkt_opt(dpkt, DHCPV6_OPT_RAPID_COMMIT, NULL, 0);
 178
 179                 /* xxx add Reconfigure Accept */
 180
 181                 (void) send_pkt_v6(dsmp, dpkt, ipv6_all_dhcp_relay_and_servers,
 182                     stop_selecting, DHCPV6_SOL_TIMEOUT, DHCPV6_SOL_MAX_RT);
 183         } else {
 184                 if ((dpkt = init_pkt(dsmp, DISCOVER)) == NULL) {
 185                         dhcpmsg(MSG_ERROR, "dhcp_selecting: unable to set up "
 186                             "DISCOVER packet");
 187                         return;
 188                 }
 189
 190                 /*
 191                  * The max DHCP message size option is set to the interface
 192                  * MTU, minus the size of the UDP and IP headers.
 193                  */
 194                 (void) add_pkt_opt16(dpkt, CD_MAX_DHCP_SIZE,
 195                     htons(dsmp->dsm_lif->lif_max - sizeof (struct udpiphdr)));
 196                 (void) add_pkt_opt32(dpkt, CD_LEASE_TIME, htonl(DHCP_PERM));
 197
 198                 if (class_id_len != 0) {
 199                         (void) add_pkt_opt(dpkt, CD_CLASS_ID, class_id,
 200                             class_id_len);
 201                 }
 202                 (void) add_pkt_prl(dpkt, dsmp);
 203
 204                 if (df_get_bool(dsmp->dsm_name, dsmp->dsm_isv6,
 205                     DF_REQUEST_HOSTNAME)) {
 206                         dhcpmsg(MSG_DEBUG,
 207                             "dhcp_selecting: DF_REQUEST_HOSTNAME");
 208                         (void) snprintf(hostfile, sizeof (hostfile),
 209                             "/etc/hostname.%s", dsmp->dsm_name);
 210
 211                         if ((reqhost = iffile_to_hostname(hostfile)) != NULL) {
 212                                 dhcpmsg(MSG_DEBUG, "dhcp_selecting: host %s",
 213                                     reqhost);
 214                                 dsmp->dsm_reqhost = strdup(reqhost);
 215                                 if (dsmp->dsm_reqhost != NULL)
 216                                         (void) add_pkt_opt(dpkt, CD_HOSTNAME,
 217                                             dsmp->dsm_reqhost,
 218                                             strlen(dsmp->dsm_reqhost));
 219                                 else
 220                                         dhcpmsg(MSG_WARNING,
 221                                             "dhcp_selecting: cannot allocate "
 222                                             "memory for host name option");
 223                         }
 224                 }
 225                 (void) add_pkt_opt(dpkt, CD_END, NULL, 0);
 226
 227                 (void) send_pkt(dsmp, dpkt, htonl(INADDR_BROADCAST),
 228                     stop_selecting);
 229         }
 230         return;
 231
 232 failed:
 233         (void) set_smach_state(dsmp, INIT);
 234         dsmp->dsm_dflags |= DHCP_IF_FAILED;
 235         ipc_action_finish(dsmp, DHCP_IPC_E_MEMORY);
 236 }
 237
 238 /*
 239  * stop_selecting(): decides when to stop retransmitting DISCOVERs -- only when
 240  *                   abandoning the state machine.  For DHCPv6, this timer may
 241  *                   go off before the offer wait timer.  If so, then this is a
 242  *                   good time to check for valid Advertisements, so cancel the
 243  *                   timer and go check.
 244  *
 245  *   input: dhcp_smach_t *: the state machine DISCOVERs are being sent on
 246  *          unsigned int: the number of DISCOVERs sent so far
 247  *  output: boolean_t: B_TRUE if retransmissions should stop
 248  */
 249
 250 /* ARGSUSED1 */
 251 static boolean_t
 252 stop_selecting(dhcp_smach_t *dsmp, unsigned int n_discovers)
 253 {
 254         /*
 255          * If we're using v4 and the underlying LIF we're trying to configure
 256          * has been touched by the user, then bail out.
 257          */
 258         if (!dsmp->dsm_isv6 && !verify_lif(dsmp->dsm_lif)) {
 259                 finished_smach(dsmp, DHCP_IPC_E_UNKIF);
 260                 return (B_TRUE);
 261         }
 262
 263         if (dsmp->dsm_recv_pkt_list != NULL) {
 264                 dhcp_requesting(NULL, dsmp);
 265                 if (dsmp->dsm_state != SELECTING)
 266                         return (B_TRUE);
 267         }
 268         return (B_FALSE);
 269 }