master
1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1982, 1986, 1989, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * From: @(#)if.h 8.1 (Berkeley) 6/10/93
32 */
33
34#ifndef _NET_IF_VAR_H_
35#define _NET_IF_VAR_H_
36
37/*
38 * Structures defining a network interface, providing a packet
39 * transport mechanism (ala level 0 of the PUP protocols).
40 *
41 * Each interface accepts output datagrams of a specified maximum
42 * length, and provides higher level routines with input datagrams
43 * received from its medium.
44 *
45 * Output occurs when the routine if_output is called, with three parameters:
46 * (*ifp->if_output)(ifp, m, dst, ro)
47 * Here m is the mbuf chain to be sent and dst is the destination address.
48 * The output routine encapsulates the supplied datagram if necessary,
49 * and then transmits it on its medium.
50 *
51 * On input, each interface unwraps the data received by it, and either
52 * places it on the input queue of an internetwork datagram routine
53 * and posts the associated software interrupt, or passes the datagram to a raw
54 * packet input routine.
55 *
56 * Routines exist for locating interfaces by their addresses
57 * or for locating an interface on a certain network, as well as more general
58 * routing and gateway routines maintaining information used to locate
59 * interfaces. These routines live in the files if.c and route.c
60 */
61
62struct rtentry; /* ifa_rtrequest */
63struct socket;
64struct carp_if;
65struct carp_softc;
66struct ifvlantrunk;
67struct route; /* if_output */
68struct vnet;
69struct ifmedia;
70struct netmap_adapter;
71struct debugnet_methods;
72
73#ifdef _KERNEL
74#include <sys/_eventhandler.h>
75#include <sys/mbuf.h> /* ifqueue only? */
76#include <sys/buf_ring.h>
77#include <net/vnet.h>
78#endif /* _KERNEL */
79#include <sys/ck.h>
80#include <sys/counter.h>
81#include <sys/epoch.h>
82#include <sys/lock.h> /* XXX */
83#include <sys/mutex.h> /* struct ifqueue */
84#include <sys/rwlock.h> /* XXX */
85#include <sys/sx.h> /* XXX */
86#include <sys/_task.h> /* if_link_task */
87#define IF_DUNIT_NONE -1
88
89#include <net/altq/if_altq.h>
90
91CK_STAILQ_HEAD(ifnethead, ifnet); /* we use TAILQs so that the order of */
92CK_STAILQ_HEAD(ifaddrhead, ifaddr); /* instantiation is preserved in the list */
93CK_STAILQ_HEAD(ifmultihead, ifmultiaddr);
94CK_STAILQ_HEAD(ifgrouphead, ifg_group);
95
96#ifdef _KERNEL
97VNET_DECLARE(struct pfil_head *, link_pfil_head);
98#define V_link_pfil_head VNET(link_pfil_head)
99#define PFIL_ETHER_NAME "ethernet"
100
101#define HHOOK_IPSEC_INET 0
102#define HHOOK_IPSEC_INET6 1
103#define HHOOK_IPSEC_COUNT 2
104VNET_DECLARE(struct hhook_head *, ipsec_hhh_in[HHOOK_IPSEC_COUNT]);
105VNET_DECLARE(struct hhook_head *, ipsec_hhh_out[HHOOK_IPSEC_COUNT]);
106#define V_ipsec_hhh_in VNET(ipsec_hhh_in)
107#define V_ipsec_hhh_out VNET(ipsec_hhh_out)
108#endif /* _KERNEL */
109
110typedef enum {
111 IFCOUNTER_IPACKETS = 0,
112 IFCOUNTER_IERRORS,
113 IFCOUNTER_OPACKETS,
114 IFCOUNTER_OERRORS,
115 IFCOUNTER_COLLISIONS,
116 IFCOUNTER_IBYTES,
117 IFCOUNTER_OBYTES,
118 IFCOUNTER_IMCASTS,
119 IFCOUNTER_OMCASTS,
120 IFCOUNTER_IQDROPS,
121 IFCOUNTER_OQDROPS,
122 IFCOUNTER_NOPROTO,
123 IFCOUNTERS /* Array size. */
124} ift_counter;
125
126typedef void (*if_start_fn_t)(if_t);
127typedef int (*if_ioctl_fn_t)(if_t, u_long, caddr_t);
128typedef void (*if_init_fn_t)(void *);
129typedef void (*if_input_fn_t)(if_t, struct mbuf *);
130typedef int (*if_output_fn_t)(if_t, struct mbuf *, const struct sockaddr *,
131 struct route *);
132typedef void (*if_qflush_fn_t)(if_t);
133typedef int (*if_transmit_fn_t)(if_t, struct mbuf *);
134typedef uint64_t (*if_get_counter_t)(if_t, ift_counter);
135typedef void (*if_reassign_fn_t)(if_t, struct vnet *, char *);
136
137struct ifnet_hw_tsomax {
138 u_int tsomaxbytes; /* TSO total burst length limit in bytes */
139 u_int tsomaxsegcount; /* TSO maximum segment count */
140 u_int tsomaxsegsize; /* TSO maximum segment size in bytes */
141};
142
143/* Interface encap request types */
144typedef enum {
145 IFENCAP_LL = 1 /* pre-calculate link-layer header */
146} ife_type;
147
148/*
149 * The structure below allows to request various pre-calculated L2/L3 headers
150 * for different media. Requests varies by type (rtype field).
151 *
152 * IFENCAP_LL type: pre-calculates link header based on address family
153 * and destination lladdr.
154 *
155 * Input data fields:
156 * buf: pointer to destination buffer
157 * bufsize: buffer size
158 * flags: IFENCAP_FLAG_BROADCAST if destination is broadcast
159 * family: address family defined by AF_ constant.
160 * lladdr: pointer to link-layer address
161 * lladdr_len: length of link-layer address
162 * hdata: pointer to L3 header (optional, used for ARP requests).
163 * Output data fields:
164 * buf: encap data is stored here
165 * bufsize: resulting encap length is stored here
166 * lladdr_off: offset of link-layer address from encap hdr start
167 * hdata: L3 header may be altered if necessary
168 */
169
170struct if_encap_req {
171 u_char *buf; /* Destination buffer (w) */
172 size_t bufsize; /* size of provided buffer (r) */
173 ife_type rtype; /* request type (r) */
174 uint32_t flags; /* Request flags (r) */
175 int family; /* Address family AF_* (r) */
176 int lladdr_off; /* offset from header start (w) */
177 int lladdr_len; /* lladdr length (r) */
178 char *lladdr; /* link-level address pointer (r) */
179 char *hdata; /* Upper layer header data (rw) */
180};
181
182#define IFENCAP_FLAG_BROADCAST 0x02 /* Destination is broadcast */
183
184/*
185 * Network interface send tag support. The storage of "struct
186 * m_snd_tag" comes from the network driver and it is free to allocate
187 * as much additional space as it wants for its own use.
188 */
189struct ktls_session;
190struct m_snd_tag;
191
192#define IF_SND_TAG_TYPE_RATE_LIMIT 0
193#define IF_SND_TAG_TYPE_UNLIMITED 1
194#define IF_SND_TAG_TYPE_TLS 2
195#define IF_SND_TAG_TYPE_TLS_RATE_LIMIT 3
196#define IF_SND_TAG_TYPE_TLS_RX 4
197#define IF_SND_TAG_TYPE_MAX 5
198
199struct if_snd_tag_alloc_header {
200 uint32_t type; /* send tag type, see IF_SND_TAG_XXX */
201 uint32_t flowid; /* mbuf hash value */
202 uint32_t flowtype; /* mbuf hash type */
203 uint8_t numa_domain; /* numa domain of associated inp */
204};
205
206struct if_snd_tag_alloc_rate_limit {
207 struct if_snd_tag_alloc_header hdr;
208 uint64_t max_rate; /* in bytes/s */
209 uint32_t flags; /* M_NOWAIT or M_WAITOK */
210 uint32_t reserved; /* alignment */
211};
212
213struct if_snd_tag_alloc_tls {
214 struct if_snd_tag_alloc_header hdr;
215 struct inpcb *inp;
216 const struct ktls_session *tls;
217};
218
219struct if_snd_tag_alloc_tls_rx {
220 struct if_snd_tag_alloc_header hdr;
221 struct inpcb *inp;
222 const struct ktls_session *tls;
223 uint16_t vlan_id; /* valid if non-zero */
224};
225
226struct if_snd_tag_alloc_tls_rate_limit {
227 struct if_snd_tag_alloc_header hdr;
228 struct inpcb *inp;
229 const struct ktls_session *tls;
230 uint64_t max_rate; /* in bytes/s */
231};
232
233struct if_snd_tag_rate_limit_params {
234 uint64_t max_rate; /* in bytes/s */
235 uint32_t queue_level; /* 0 (empty) .. 65535 (full) */
236#define IF_SND_QUEUE_LEVEL_MIN 0
237#define IF_SND_QUEUE_LEVEL_MAX 65535
238 uint32_t flags; /* M_NOWAIT or M_WAITOK */
239};
240
241struct if_snd_tag_modify_tls_rx {
242 /* TCP sequence number of TLS header in host endian format */
243 uint32_t tls_hdr_tcp_sn;
244
245 /*
246 * TLS record length, including all headers, data and trailers.
247 * If the tls_rec_length is zero, it means HW encryption resumed.
248 */
249 uint32_t tls_rec_length;
250
251 /* TLS sequence number in host endian format */
252 uint64_t tls_seq_number;
253};
254
255union if_snd_tag_alloc_params {
256 struct if_snd_tag_alloc_header hdr;
257 struct if_snd_tag_alloc_rate_limit rate_limit;
258 struct if_snd_tag_alloc_rate_limit unlimited;
259 struct if_snd_tag_alloc_tls tls;
260 struct if_snd_tag_alloc_tls_rx tls_rx;
261 struct if_snd_tag_alloc_tls_rate_limit tls_rate_limit;
262};
263
264union if_snd_tag_modify_params {
265 struct if_snd_tag_rate_limit_params rate_limit;
266 struct if_snd_tag_rate_limit_params unlimited;
267 struct if_snd_tag_rate_limit_params tls_rate_limit;
268 struct if_snd_tag_modify_tls_rx tls_rx;
269};
270
271union if_snd_tag_query_params {
272 struct if_snd_tag_rate_limit_params rate_limit;
273 struct if_snd_tag_rate_limit_params unlimited;
274 struct if_snd_tag_rate_limit_params tls_rate_limit;
275};
276
277typedef int (if_snd_tag_alloc_t)(if_t, union if_snd_tag_alloc_params *,
278 struct m_snd_tag **);
279typedef int (if_snd_tag_modify_t)(struct m_snd_tag *, union if_snd_tag_modify_params *);
280typedef int (if_snd_tag_query_t)(struct m_snd_tag *, union if_snd_tag_query_params *);
281typedef void (if_snd_tag_free_t)(struct m_snd_tag *);
282typedef struct m_snd_tag *(if_next_send_tag_t)(struct m_snd_tag *);
283
284struct if_snd_tag_sw {
285 if_snd_tag_modify_t *snd_tag_modify;
286 if_snd_tag_query_t *snd_tag_query;
287 if_snd_tag_free_t *snd_tag_free;
288 if_next_send_tag_t *next_snd_tag;
289 u_int type; /* One of IF_SND_TAG_TYPE_*. */
290};
291
292/* Query return flags */
293#define RT_NOSUPPORT 0x00000000 /* Not supported */
294#define RT_IS_INDIRECT 0x00000001 /*
295 * Interface like a lagg, select
296 * the actual interface for
297 * capabilities.
298 */
299#define RT_IS_SELECTABLE 0x00000002 /*
300 * No rate table, you select
301 * rates and the first
302 * number_of_rates are created.
303 */
304#define RT_IS_FIXED_TABLE 0x00000004 /* A fixed table is attached */
305#define RT_IS_UNUSABLE 0x00000008 /* It is not usable for this */
306#define RT_IS_SETUP_REQ 0x00000010 /* The interface setup must be called before use */
307
308struct if_ratelimit_query_results {
309 const uint64_t *rate_table; /* Pointer to table if present */
310 uint32_t flags; /* Flags indicating results */
311 uint32_t max_flows; /* Max flows using, 0=unlimited */
312 uint32_t number_of_rates; /* How many unique rates can be created */
313 uint32_t min_segment_burst; /* The amount the adapter bursts at each send */
314};
315
316typedef void (if_ratelimit_query_t)(if_t,
317 struct if_ratelimit_query_results *);
318typedef int (if_ratelimit_setup_t)(if_t, uint64_t, uint32_t);
319#define IF_NODOM 255
320/*
321 * Locks for address lists on the network interface.
322 */
323#define IF_ADDR_LOCK_INIT(if) mtx_init(&(if)->if_addr_lock, "if_addr_lock", NULL, MTX_DEF)
324#define IF_ADDR_LOCK_DESTROY(if) mtx_destroy(&(if)->if_addr_lock)
325
326#define IF_ADDR_WLOCK(if) mtx_lock(&(if)->if_addr_lock)
327#define IF_ADDR_WUNLOCK(if) mtx_unlock(&(if)->if_addr_lock)
328#define IF_ADDR_LOCK_ASSERT(if) MPASS(in_epoch(net_epoch_preempt) || mtx_owned(&(if)->if_addr_lock))
329#define IF_ADDR_WLOCK_ASSERT(if) mtx_assert(&(if)->if_addr_lock, MA_OWNED)
330
331#ifdef _KERNEL
332/* interface link layer address change event */
333typedef void (*iflladdr_event_handler_t)(void *, if_t);
334EVENTHANDLER_DECLARE(iflladdr_event, iflladdr_event_handler_t);
335/* interface address change event */
336typedef void (*ifaddr_event_handler_t)(void *, if_t);
337EVENTHANDLER_DECLARE(ifaddr_event, ifaddr_event_handler_t);
338typedef void (*ifaddr_event_ext_handler_t)(void *, if_t, struct ifaddr *, int);
339EVENTHANDLER_DECLARE(ifaddr_event_ext, ifaddr_event_ext_handler_t);
340#define IFADDR_EVENT_ADD 0
341#define IFADDR_EVENT_DEL 1
342/* new interface arrival event */
343typedef void (*ifnet_arrival_event_handler_t)(void *, if_t);
344EVENTHANDLER_DECLARE(ifnet_arrival_event, ifnet_arrival_event_handler_t);
345/* interface departure event */
346typedef void (*ifnet_departure_event_handler_t)(void *, if_t);
347EVENTHANDLER_DECLARE(ifnet_departure_event, ifnet_departure_event_handler_t);
348/* Interface link state change event */
349typedef void (*ifnet_link_event_handler_t)(void *, if_t, int);
350EVENTHANDLER_DECLARE(ifnet_link_event, ifnet_link_event_handler_t);
351/* Interface up/down event */
352#define IFNET_EVENT_UP 0
353#define IFNET_EVENT_DOWN 1
354#define IFNET_EVENT_PCP 2 /* priority code point, PCP */
355#define IFNET_EVENT_UPDATE_BAUDRATE 3
356
357typedef void (*ifnet_event_fn)(void *, if_t ifp, int event);
358EVENTHANDLER_DECLARE(ifnet_event, ifnet_event_fn);
359
360/*
361 * interface groups
362 */
363struct ifg_group {
364 char ifg_group[IFNAMSIZ];
365 u_int ifg_refcnt;
366 void *ifg_pf_kif;
367 CK_STAILQ_HEAD(, ifg_member) ifg_members; /* (CK_) */
368 CK_STAILQ_ENTRY(ifg_group) ifg_next; /* (CK_) */
369};
370
371struct ifg_member {
372 CK_STAILQ_ENTRY(ifg_member) ifgm_next; /* (CK_) */
373 if_t ifgm_ifp;
374};
375
376struct ifg_list {
377 struct ifg_group *ifgl_group;
378 CK_STAILQ_ENTRY(ifg_list) ifgl_next; /* (CK_) */
379};
380
381#ifdef _SYS_EVENTHANDLER_H_
382/* group attach event */
383typedef void (*group_attach_event_handler_t)(void *, struct ifg_group *);
384EVENTHANDLER_DECLARE(group_attach_event, group_attach_event_handler_t);
385/* group detach event */
386typedef void (*group_detach_event_handler_t)(void *, struct ifg_group *);
387EVENTHANDLER_DECLARE(group_detach_event, group_detach_event_handler_t);
388/* group change event */
389typedef void (*group_change_event_handler_t)(void *, const char *);
390EVENTHANDLER_DECLARE(group_change_event, group_change_event_handler_t);
391#endif /* _SYS_EVENTHANDLER_H_ */
392
393/*
394 * 72 was chosen below because it is the size of a TCP/IP
395 * header (40) + the minimum mss (32).
396 */
397#define IF_MINMTU 72
398#define IF_MAXMTU 65535
399
400#define TOEDEV(ifp) if_getllsoftc(ifp)
401#define SETTOEDEV(ifp, sc) if_setllsoftc((ifp), (sc))
402
403/*
404 * The ifaddr structure contains information about one address
405 * of an interface. They are maintained by the different address families,
406 * are allocated and attached when an address is set, and are linked
407 * together so all addresses for an interface can be located.
408 *
409 * NOTE: a 'struct ifaddr' is always at the beginning of a larger
410 * chunk of malloc'ed memory, where we store the three addresses
411 * (ifa_addr, ifa_dstaddr and ifa_netmask) referenced here.
412 */
413struct ifaddr {
414 struct sockaddr *ifa_addr; /* address of interface */
415 struct sockaddr *ifa_dstaddr; /* other end of p-to-p link */
416#define ifa_broadaddr ifa_dstaddr /* broadcast address interface */
417 struct sockaddr *ifa_netmask; /* used to determine subnet */
418 if_t ifa_ifp; /* back-pointer to interface */
419 struct carp_softc *ifa_carp; /* pointer to CARP data */
420 CK_STAILQ_ENTRY(ifaddr) ifa_link; /* queue macro glue */
421 u_short ifa_flags; /* mostly rt_flags for cloning */
422#define IFA_ROUTE RTF_UP /* route installed */
423#define IFA_RTSELF RTF_HOST /* loopback route to self installed */
424 u_int ifa_refcnt; /* references to this structure */
425
426 counter_u64_t ifa_ipackets;
427 counter_u64_t ifa_opackets;
428 counter_u64_t ifa_ibytes;
429 counter_u64_t ifa_obytes;
430 struct epoch_context ifa_epoch_ctx;
431};
432
433struct ifaddr * ifa_alloc(size_t size, int flags);
434void ifa_free(struct ifaddr *ifa);
435void ifa_ref(struct ifaddr *ifa);
436int __result_use_check ifa_try_ref(struct ifaddr *ifa);
437
438/*
439 * Multicast address structure. This is analogous to the ifaddr
440 * structure except that it keeps track of multicast addresses.
441 */
442#define IFMA_F_ENQUEUED 0x1
443struct ifmultiaddr {
444 CK_STAILQ_ENTRY(ifmultiaddr) ifma_link; /* queue macro glue */
445 struct sockaddr *ifma_addr; /* address this membership is for */
446 struct sockaddr *ifma_lladdr; /* link-layer translation, if any */
447 if_t ifma_ifp; /* back-pointer to interface */
448 u_int ifma_refcount; /* reference count */
449 int ifma_flags;
450 void *ifma_protospec; /* protocol-specific state, if any */
451 struct ifmultiaddr *ifma_llifma; /* pointer to ifma for ifma_lladdr */
452 struct epoch_context ifma_epoch_ctx;
453};
454
455extern struct sx ifnet_sxlock;
456
457#define IFNET_WLOCK() sx_xlock(&ifnet_sxlock)
458#define IFNET_WUNLOCK() sx_xunlock(&ifnet_sxlock)
459#define IFNET_RLOCK_ASSERT() sx_assert(&ifnet_sxlock, SA_SLOCKED)
460#define IFNET_WLOCK_ASSERT() sx_assert(&ifnet_sxlock, SA_XLOCKED)
461#define IFNET_RLOCK() sx_slock(&ifnet_sxlock)
462#define IFNET_RUNLOCK() sx_sunlock(&ifnet_sxlock)
463
464/*
465 * Look up an ifnet given its index. The returned value protected from
466 * being freed by the network epoch. The _ref variant also acquires a
467 * reference that must be freed using if_rele().
468 */
469if_t ifnet_byindex(u_int);
470if_t ifnet_byindex_ref(u_int);
471
472/*
473 * ifnet_byindexgen() looks up ifnet by index and generation count,
474 * attempting to restore a weak pointer that had been stored across
475 * the epoch.
476 */
477if_t ifnet_byindexgen(uint16_t idx, uint16_t gen);
478
479VNET_DECLARE(struct ifnethead, ifnet);
480VNET_DECLARE(struct ifgrouphead, ifg_head);
481VNET_DECLARE(if_t, loif); /* first loopback interface */
482
483#define V_ifnet VNET(ifnet)
484#define V_ifg_head VNET(ifg_head)
485#define V_loif VNET(loif)
486
487#ifdef MCAST_VERBOSE
488#define MCDPRINTF printf
489#else
490#define MCDPRINTF(...)
491#endif
492
493int if_addgroup(if_t, const char *);
494int if_delgroup(if_t, const char *);
495int if_addmulti(if_t, struct sockaddr *, struct ifmultiaddr **);
496int if_allmulti(if_t, int);
497if_t if_alloc(u_char);
498if_t if_alloc_dev(u_char, device_t dev);
499void if_attach(if_t);
500void if_dead(if_t);
501int if_delmulti(if_t, struct sockaddr *);
502void if_delmulti_ifma(struct ifmultiaddr *);
503void if_delmulti_ifma_flags(struct ifmultiaddr *, int flags);
504void if_detach(if_t);
505void if_purgeaddrs(if_t);
506void if_delallmulti(if_t);
507void if_down(if_t);
508struct ifmultiaddr *
509 if_findmulti(if_t, const struct sockaddr *);
510void if_freemulti(struct ifmultiaddr *ifma);
511void if_free(if_t);
512void if_initname(if_t, const char *, int);
513void if_link_state_change(if_t, int);
514int if_printf(if_t, const char *, ...) __printflike(2, 3);
515int if_log(if_t, int, const char *, ...) __printflike(3, 4);
516void if_ref(if_t);
517void if_rele(if_t);
518bool __result_use_check if_try_ref(if_t);
519int if_setlladdr(if_t, const u_char *, int);
520int if_tunnel_check_nesting(if_t, struct mbuf *, uint32_t, int);
521void if_up(if_t);
522int ifioctl(struct socket *, u_long, caddr_t, struct thread *);
523int ifpromisc(if_t, int);
524if_t ifunit(const char *);
525if_t ifunit_ref(const char *);
526
527int ifa_add_loopback_route(struct ifaddr *, struct sockaddr *);
528int ifa_del_loopback_route(struct ifaddr *, struct sockaddr *);
529int ifa_switch_loopback_route(struct ifaddr *, struct sockaddr *);
530
531struct ifaddr *ifa_ifwithaddr(const struct sockaddr *);
532int ifa_ifwithaddr_check(const struct sockaddr *);
533struct ifaddr *ifa_ifwithbroadaddr(const struct sockaddr *, int);
534struct ifaddr *ifa_ifwithdstaddr(const struct sockaddr *, int);
535struct ifaddr *ifa_ifwithnet(const struct sockaddr *, int, int);
536struct ifaddr *ifa_ifwithroute(int, const struct sockaddr *,
537 const struct sockaddr *, u_int);
538struct ifaddr *ifaof_ifpforaddr(const struct sockaddr *, if_t);
539int ifa_preferred(struct ifaddr *, struct ifaddr *);
540
541int if_simloop(if_t ifp, struct mbuf *m, int af, int hlen);
542
543typedef void *if_com_alloc_t(u_char type, if_t ifp);
544typedef void if_com_free_t(void *com, u_char type);
545void if_register_com_alloc(u_char type, if_com_alloc_t *a, if_com_free_t *f);
546void if_deregister_com_alloc(u_char type);
547void if_data_copy(if_t, struct if_data *);
548uint64_t if_get_counter_default(if_t, ift_counter);
549void if_inc_counter(if_t, ift_counter, int64_t);
550
551uint64_t if_setbaudrate(if_t ifp, uint64_t baudrate);
552uint64_t if_getbaudrate(const if_t ifp);
553int if_setcapabilities(if_t ifp, int capabilities);
554int if_setcapabilitiesbit(if_t ifp, int setbit, int clearbit);
555int if_getcapabilities(const if_t ifp);
556int if_togglecapenable(if_t ifp, int togglecap);
557int if_setcapenable(if_t ifp, int capenable);
558int if_setcapenablebit(if_t ifp, int setcap, int clearcap);
559int if_getcapenable(const if_t ifp);
560int if_setcapabilities2(if_t ifp, int capabilities);
561int if_setcapabilities2bit(if_t ifp, int setbit, int clearbit);
562int if_getcapabilities2(const if_t ifp);
563int if_togglecapenable2(if_t ifp, int togglecap);
564int if_setcapenable2(if_t ifp, int capenable);
565int if_setcapenable2bit(if_t ifp, int setcap, int clearcap);
566int if_getcapenable2(const if_t ifp);
567int if_getdunit(const if_t ifp);
568int if_getindex(const if_t ifp);
569int if_getidxgen(const if_t ifp);
570const char *if_getdname(const if_t ifp);
571void if_setdname(if_t ifp, const char *name);
572const char *if_name(if_t ifp);
573int if_setname(if_t ifp, const char *name);
574int if_rename(if_t ifp, char *new_name);
575const char *if_getdescr(if_t ifp);
576void if_setdescr(if_t ifp, char *descrbuf);
577char *if_allocdescr(size_t sz, int malloc_flag);
578void if_freedescr(char *descrbuf);
579void if_setlastchange(if_t ifp);
580int if_getalloctype(const if_t ifp);
581int if_gettype(const if_t ifp);
582int if_setdev(if_t ifp, void *dev);
583int if_setdrvflagbits(if_t ifp, int if_setflags, int clear_flags);
584int if_getdrvflags(const if_t ifp);
585int if_setdrvflags(if_t ifp, int flags);
586int if_getlinkstate(if_t ifp);
587int if_clearhwassist(if_t ifp);
588int if_sethwassistbits(if_t ifp, int toset, int toclear);
589int if_sethwassist(if_t ifp, int hwassist_bit);
590int if_gethwassist(const if_t ifp);
591int if_togglehwassist(if_t ifp, int toggle_bits);
592int if_setsoftc(if_t ifp, void *softc);
593void *if_getsoftc(if_t ifp);
594int if_setflags(if_t ifp, int flags);
595void if_setllsoftc(if_t ifp, void *softc);
596void *if_getllsoftc(if_t ifp);
597u_int if_getfib(if_t ifp);
598uint8_t if_getaddrlen(if_t ifp);
599int if_gethwaddr(const if_t ifp, struct ifreq *);
600const uint8_t *if_getbroadcastaddr(const if_t ifp);
601void if_setbroadcastaddr(if_t ifp, const uint8_t *);
602int if_setmtu(if_t ifp, int mtu);
603int if_getmtu(const if_t ifp);
604int if_getmtu_family(const if_t ifp, int family);
605void if_notifymtu(if_t ifp);
606int if_setflagbits(if_t ifp, int set, int clear);
607int if_setflags(if_t ifp, int flags);
608int if_getflags(const if_t ifp);
609int if_getnumadomain(if_t ifp);
610int if_sendq_empty(if_t ifp);
611int if_setsendqready(if_t ifp);
612int if_setsendqlen(if_t ifp, int tx_desc_count);
613int if_sethwtsomax(if_t ifp, u_int if_hw_tsomax);
614int if_sethwtsomaxsegcount(if_t ifp, u_int if_hw_tsomaxsegcount);
615int if_sethwtsomaxsegsize(if_t ifp, u_int if_hw_tsomaxsegsize);
616u_int if_gethwtsomax(const if_t ifp);
617u_int if_gethwtsomaxsegcount(const if_t ifp);
618u_int if_gethwtsomaxsegsize(const if_t ifp);
619void if_setnetmapadapter(if_t ifp, struct netmap_adapter *na);
620struct netmap_adapter *if_getnetmapadapter(if_t ifp);
621void if_input(if_t ifp, struct mbuf* sendmp);
622int if_sendq_prepend(if_t ifp, struct mbuf *m);
623struct mbuf *if_dequeue(if_t ifp);
624int if_setifheaderlen(if_t ifp, int len);
625void if_setrcvif(struct mbuf *m, if_t ifp);
626void if_setvtag(struct mbuf *m, u_int16_t tag);
627u_int16_t if_getvtag(struct mbuf *m);
628int if_vlantrunkinuse(if_t ifp);
629caddr_t if_getlladdr(const if_t ifp);
630struct vnet *if_getvnet(const if_t ifp);
631void *if_gethandle(u_char);
632void if_bpfmtap(if_t ifp, struct mbuf *m);
633void if_etherbpfmtap(if_t ifp, struct mbuf *m);
634void if_vlancap(if_t ifp);
635int if_transmit(if_t ifp, struct mbuf *m);
636void if_init(if_t ifp, void *ctx);
637int if_ioctl(if_t ifp, u_long cmd, void *data);
638int if_resolvemulti(if_t ifp, struct sockaddr **, struct sockaddr *);
639uint64_t if_getcounter(if_t ifp, ift_counter counter);
640struct label *if_getmaclabel(if_t ifp);
641void if_setmaclabel(if_t ifp, struct label *label);
642struct bpf_if *if_getbpf(if_t ifp);
643uint8_t if_getpcp(if_t ifp);
644void *if_getl2com(if_t ifp);
645struct ifvlantrunk *if_getvlantrunk(if_t ifp);
646bool if_altq_is_enabled(if_t ifp);
647
648void *if_getafdata(if_t ifp, int);
649
650int if_snd_tag_alloc(if_t ifp, union if_snd_tag_alloc_params *params,
651 struct m_snd_tag **mstp);
652/*
653 * Traversing through interface address lists.
654 */
655struct sockaddr_dl;
656typedef u_int iflladdr_cb_t(void *, struct sockaddr_dl *, u_int);
657u_int if_foreach_lladdr(if_t, iflladdr_cb_t, void *);
658u_int if_foreach_llmaddr(if_t, iflladdr_cb_t, void *);
659u_int if_lladdr_count(if_t);
660u_int if_llmaddr_count(if_t);
661bool if_maddr_empty(if_t);
662
663struct ifaddr * if_getifaddr(const if_t ifp);
664typedef u_int if_addr_cb_t(void *, struct ifaddr *, u_int);
665u_int if_foreach_addr_type(if_t ifp, int type, if_addr_cb_t cb, void *cb_arg);
666
667typedef int (*if_foreach_cb_t)(if_t, void *);
668typedef bool (*if_foreach_match_t)(if_t, void *);
669int if_foreach(if_foreach_cb_t, void *);
670int if_foreach_sleep(if_foreach_match_t, void *, if_foreach_cb_t, void *);
671
672/* Opaque iterator structure for iterating over interfaces. */
673struct if_iter {
674 void *context[4];
675};
676
677if_t if_iter_start(struct if_iter *);
678if_t if_iter_next(struct if_iter *);
679void if_iter_finish(struct if_iter *);
680
681struct ifa_iter {
682 void *context[4];
683};
684
685struct ifaddr *ifa_iter_start(if_t ifp, struct ifa_iter *iter);
686struct ifaddr *ifa_iter_next(struct ifa_iter *iter);
687void ifa_iter_finish(struct ifa_iter *iter);
688
689/* Functions */
690void if_setinitfn(if_t ifp, if_init_fn_t);
691void if_setinputfn(if_t ifp, if_input_fn_t);
692if_input_fn_t if_getinputfn(if_t ifp);
693void if_setioctlfn(if_t ifp, if_ioctl_fn_t);
694void if_setoutputfn(if_t ifp, if_output_fn_t);
695void if_setstartfn(if_t ifp, if_start_fn_t);
696if_start_fn_t if_getstartfn(if_t ifp);
697void if_settransmitfn(if_t ifp, if_transmit_fn_t);
698if_transmit_fn_t if_gettransmitfn(if_t ifp);
699void if_setqflushfn(if_t ifp, if_qflush_fn_t);
700void if_setgetcounterfn(if_t ifp, if_get_counter_t);
701void if_setsndtagallocfn(if_t ifp, if_snd_tag_alloc_t);
702void if_setdebugnet_methods(if_t, struct debugnet_methods *);
703void if_setreassignfn(if_t ifp, if_reassign_fn_t);
704void if_setratelimitqueryfn(if_t ifp, if_ratelimit_query_t);
705
706/* TSO */
707void if_hw_tsomax_common(if_t ifp, struct ifnet_hw_tsomax *);
708int if_hw_tsomax_update(if_t ifp, struct ifnet_hw_tsomax *);
709
710/* accessors for struct ifreq */
711void *ifr_data_get_ptr(void *ifrp);
712void *ifr_buffer_get_buffer(void *data);
713size_t ifr_buffer_get_length(void *data);
714
715int ifhwioctl(u_long, if_t, caddr_t, struct thread *);
716
717#ifdef DEVICE_POLLING
718enum poll_cmd { POLL_ONLY, POLL_AND_CHECK_STATUS };
719
720typedef int poll_handler_t(if_t ifp, enum poll_cmd cmd, int count);
721int ether_poll_register(poll_handler_t *h, if_t ifp);
722int ether_poll_deregister(if_t ifp);
723#endif /* DEVICE_POLLING */
724
725#endif /* _KERNEL */
726
727#include <net/if_private.h> /* XXX: temporary until drivers converted. */
728#include <net/ifq.h> /* XXXAO: temporary unconditional include */
729
730#endif /* !_NET_IF_VAR_H_ */