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