usr/src/cmd/cmd-inet/sbin/dhcpagent/interface.h

   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 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #ifndef INTERFACE_H
  27 #define INTERFACE_H
  28
  29 /*
  30  * Interface.[ch] encapsulate all of the agent's knowledge of network
  31  * interfaces from the DHCP agent's perspective.  See interface.c for
  32  * documentation on how to use the exported functions.  Note that there are not
  33  * functional interfaces for manipulating all of the fields in a PIF or LIF --
  34  * please read the comments in the structure definitions below for the rules on
  35  * accessing various fields.
  36  */
  37
  38 #ifdef  __cplusplus
  39 extern "C" {
  40 #endif
  41
  42 #include <netinet/in.h>
  43 #include <net/if.h>                     /* IFNAMSIZ */
  44 #include <sys/types.h>
  45 #include <netinet/dhcp.h>
  46 #include <dhcpagent_ipc.h>
  47 #include <libinetutil.h>
  48
  49 #include "common.h"
  50 #include "util.h"
  51
  52 #define V4_PART_OF_V6(v6)       v6._S6_un._S6_u32[3]
  53
  54 struct dhcp_pif_s {
  55         dhcp_pif_t      *pif_next;      /* Note: must be first */
  56         dhcp_pif_t      *pif_prev;
  57         dhcp_lif_t      *pif_lifs;      /* pointer to logical interface list */
  58         uint32_t        pif_index;      /* interface index */
  59         uint16_t        pif_max;        /* largest DHCP packet on this if */
  60         uchar_t         *pif_hwaddr;    /* our link-layer address */
  61         uchar_t         pif_hwlen;      /* our link-layer address len */
  62         uchar_t         pif_hwtype;     /* type of link-layer */
  63         boolean_t       pif_isv6;
  64         boolean_t       pif_running;    /* interface is running */
  65         uint_t          pif_hold_count; /* reference count */
  66         char            pif_name[LIFNAMSIZ];
  67         char            pif_grifname[LIFNAMSIZ];
  68         uint32_t        pif_grindex;    /* interface index for pif_grifname */
  69         boolean_t       pif_under_ipmp; /* is an ipmp underlying interface */
  70 };
  71
  72 struct dhcp_lif_s {
  73         dhcp_lif_t      *lif_next;      /* Note: must be first */
  74         dhcp_lif_t      *lif_prev;
  75         dhcp_pif_t      *lif_pif;       /* backpointer to parent physical if */
  76         dhcp_smach_t    *lif_smachs;    /* pointer to list of state machines */
  77         dhcp_lease_t    *lif_lease;     /* backpointer to lease holding LIF */
  78         uint64_t        lif_flags;      /* Interface flags (IFF_*) */
  79         int             lif_sock_ip_fd; /* Bound to addr.BOOTPC for src addr */
  80         iu_event_id_t   lif_packet_id;  /* event packet id */
  81         uint_t          lif_max;        /* maximum IP message size */
  82         uint_t          lif_hold_count; /* reference count */
  83         boolean_t       lif_dad_wait;   /* waiting for DAD resolution */
  84         boolean_t       lif_removed;    /* removed from list */
  85         boolean_t       lif_plumbed;    /* interface plumbed by dhcpagent */
  86         boolean_t       lif_expired;    /* lease has evaporated */
  87         const char      *lif_declined;  /* reason to refuse this address */
  88         uint32_t        lif_iaid;       /* unique and stable identifier */
  89         iu_event_id_t   lif_iaid_id;    /* for delayed writes to /etc */
  90
  91         /*
  92          * While in any states except ADOPTING, INIT, INFORMATION and
  93          * INFORM_SENT, the following three fields are equal to what we believe
  94          * the current address, netmask, and broadcast address on the interface
  95          * to be.  This is so we can detect if the user changes them and
  96          * abandon the interface.
  97          */
  98
  99         in6_addr_t      lif_v6addr;     /* our IP address */
 100         in6_addr_t      lif_v6mask;     /* our netmask */
 101         in6_addr_t      lif_v6peer;     /* our broadcast or peer address */
 102
 103         dhcp_timer_t    lif_preferred;  /* lease preferred timer (v6 only) */
 104         dhcp_timer_t    lif_expire;     /* lease expire timer */
 105
 106         char            lif_name[LIFNAMSIZ];
 107 };
 108 #define lif_addr        V4_PART_OF_V6(lif_v6addr)
 109 #define lif_netmask     V4_PART_OF_V6(lif_v6mask)
 110 #define lif_peer        V4_PART_OF_V6(lif_v6peer)
 111 #define lif_broadcast   V4_PART_OF_V6(lif_v6peer)
 112
 113 /* used by expired_lif_state to express state of DHCP interfaces */
 114 typedef enum dhcp_expire_e {
 115         DHCP_EXP_NOLIFS,
 116         DHCP_EXP_NOEXP,
 117         DHCP_EXP_ALLEXP,
 118         DHCP_EXP_SOMEEXP
 119 } dhcp_expire_t;
 120
 121 /*
 122  * A word on memory management and LIFs and PIFs:
 123  *
 124  * Since LIFs are often passed as context to callback functions, they cannot be
 125  * freed when the interface they represent is dropped or released (or when
 126  * those callbacks finally go off, they will be hosed).  To handle this
 127  * situation, the structures are reference counted.  Here are the rules for
 128  * managing these counts:
 129  *
 130  * A PIF is created through insert_pif().  Along with initializing the PIF,
 131  * this puts a hold on the PIF.  A LIF is created through insert_lif().  This
 132  * also initializes the LIF and places a hold on it.  The caller's hold on the
 133  * underlying PIF is transferred to the LIF.
 134  *
 135  * Whenever a lease is released or dropped (implicitly or explicitly),
 136  * remove_lif() is called, which sets the lif_removed flag and removes the
 137  * interface from the internal list of managed interfaces.  Lastly,
 138  * remove_lif() calls release_lif() to remove the hold acquired in
 139  * insert_lif().  If this decrements the hold count on the interface to zero,
 140  * then free() is called and the hold on the PIF is dropped.  If there are
 141  * holds other than the hold acquired in insert_lif(), the hold count will
 142  * still be > 0, and the interface will remain allocated (though dormant).
 143  *
 144  * Whenever a callback is scheduled against a LIF, another hold must be put on
 145  * the ifslist through hold_lif().
 146  *
 147  * Whenever a callback is called back against a LIF, release_lif() must be
 148  * called to decrement the hold count, which may end up freeing the LIF if the
 149  * hold count becomes zero.
 150  *
 151  * Since some callbacks may take a long time to get called back (such as
 152  * timeout callbacks for lease expiration, etc), it is sometimes more
 153  * appropriate to cancel the callbacks and call release_lif() if the
 154  * cancellation succeeds.  This is done in remove_lif() for the lease preferred
 155  * and expire callbacks.
 156  *
 157  * In general, a callback may also call verify_lif() when it gets called back
 158  * in addition to release_lif(), to make sure that the interface is still in
 159  * fact under the dhcpagent's control.  To make coding simpler, there is a
 160  * third function, verify_smach(), which performs both the release_lif() and
 161  * the verify_lif() on all LIFs controlled by a state machine.
 162  */
 163
 164 extern dhcp_pif_t *v4root;
 165 extern dhcp_pif_t *v6root;
 166
 167 dhcp_pif_t      *insert_pif(const char *, boolean_t, int *);
 168 void            hold_pif(dhcp_pif_t *);
 169 void            release_pif(dhcp_pif_t *);
 170 dhcp_pif_t      *lookup_pif_by_uindex(uint16_t, dhcp_pif_t *, boolean_t);
 171 dhcp_pif_t      *lookup_pif_by_name(const char *, boolean_t);
 172 void            pif_status(dhcp_pif_t *, boolean_t);
 173
 174 dhcp_lif_t      *insert_lif(dhcp_pif_t *, const char *, int *);
 175 void            hold_lif(dhcp_lif_t *);
 176 void            release_lif(dhcp_lif_t *);
 177 void            remove_lif(dhcp_lif_t *);
 178 dhcp_lif_t      *lookup_lif_by_name(const char *, const dhcp_pif_t *);
 179 boolean_t       verify_lif(const dhcp_lif_t *);
 180 dhcp_lif_t      *plumb_lif(dhcp_pif_t *, const in6_addr_t *);
 181 void            unplumb_lif(dhcp_lif_t *);
 182 dhcp_lif_t      *attach_lif(const char *, boolean_t, int *);
 183 int             set_lif_dhcp(dhcp_lif_t *);
 184 void            set_lif_deprecated(dhcp_lif_t *);
 185 boolean_t       clear_lif_deprecated(dhcp_lif_t *);
 186 boolean_t       open_ip_lif(dhcp_lif_t *, in_addr_t, boolean_t);
 187 void            close_ip_lif(dhcp_lif_t *);
 188 void            lif_mark_decline(dhcp_lif_t *, const char *);
 189 boolean_t       schedule_lif_timer(dhcp_lif_t *, dhcp_timer_t *,
 190                     iu_tq_callback_t *);
 191 void            cancel_lif_timers(dhcp_lif_t *);
 192 dhcp_expire_t   expired_lif_state(dhcp_smach_t *);
 193 dhcp_lif_t      *find_expired_lif(dhcp_smach_t *);
 194
 195 uint_t          get_max_mtu(boolean_t);
 196 void            remove_v6_strays(void);
 197
 198 #ifdef  __cplusplus
 199 }
 200 #endif
 201
 202 #endif  /* INTERFACE_H */