/*	$OpenBSD: if_var.h,v 1.148 2026/03/22 23:14:00 bluhm Exp $	*/
/*	$NetBSD: if.h,v 1.23 1996/05/07 02:40:27 thorpej Exp $	*/

/*
 * Copyright (c) 2012-2013 Henning Brauer <henning@openbsd.org>
 * Copyright (c) 1982, 1986, 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)if.h	8.1 (Berkeley) 6/10/93
 */

#ifndef _NET_IF_VAR_H_
#define _NET_IF_VAR_H_

#ifdef _KERNEL

#include <sys/queue.h>
#include <sys/mbuf.h>
#include <sys/smr.h>
#include <sys/refcnt.h>
#include <sys/task.h>
#include <sys/timeout.h>

#include <net/ifq.h>
#include <net/route.h>

/*
 * Structures defining a network interface, providing a packet
 * transport mechanism (ala level 0 of the PUP protocols).
 *
 * Each interface accepts output datagrams of a specified maximum
 * length, and provides higher level routines with input datagrams
 * received from its medium.
 *
 * Output occurs when the routine if_output is called, with four parameters:
 *	(*ifp->if_output)(ifp, m, dst, rt)
 * Here m is the mbuf chain to be sent and dst is the destination address.
 * The output routine encapsulates the supplied datagram if necessary,
 * and then transmits it on its medium.
 *
 * On input, each interface unwraps the data received by it, and either
 * places it on the input queue of an internetwork datagram routine
 * and posts the associated software interrupt, or passes the datagram to a raw
 * packet input routine.
 *
 * Routines exist for locating interfaces by their addresses
 * or for locating an interface on a certain network, as well as more general
 * routing and gateway routines maintaining information used to locate
 * interfaces.  These routines live in the files if.c and route.c
 */

/*
 *  Locks used to protect struct members in this file:
 *	I	immutable after creation
 *	d	protection left to the driver
 *	c	only used in ioctl or routing socket contexts (kernel lock)
 *	K	kernel lock
 *	N	net lock
 *	T	if_tmplist_lock
 *	m	interface multicast rwlock if_maddrlock
 *
 *  For SRP related structures that allow lock-free reads, the write lock
 *  is indicated below.
 */

struct rtentry;
struct ifnet;
struct task;
struct cpumem;

struct netstack {
	struct mbuf_list	 ns_input;
	struct mbuf_list	 ns_proto;

	struct route		 ns_route;
	struct mbuf_list	 ns_tcp_ml;
	struct mbuf_list	 ns_tcp6_ml;
};

/*
 * Structure describing a `cloning' interface.
 */
struct if_clone {
	LIST_ENTRY(if_clone)	 ifc_list;	/* [I] on list of cloners */
	const char		*ifc_name;	/* name of device, e.g. `gif' */
	size_t			 ifc_namelen;	/* length of name */

	int			(*ifc_create)(struct if_clone *, int);
	int			(*ifc_destroy)(struct ifnet *);
};

#define	IF_CLONE_INITIALIZER(name, create, destroy)			\
{									\
  .ifc_list	= { NULL, NULL },					\
  .ifc_name	= name,							\
  .ifc_namelen	= sizeof(name) - 1,					\
  .ifc_create	= create,						\
  .ifc_destroy	= destroy,						\
}

enum if_counters {
	ifc_ipackets,		/* packets received on interface */
	ifc_ierrors,		/* input errors on interface */
	ifc_opackets,		/* packets sent on interface */
	ifc_oerrors,		/* output errors on interface */
	ifc_collisions,		/* collisions on csma interfaces */
	ifc_ibytes,		/* total number of octets received */
	ifc_obytes,		/* total number of octets sent */
	ifc_imcasts,		/* packets received via multicast */
	ifc_omcasts,		/* packets sent via multicast */
	ifc_iqdrops,		/* dropped on input, this interface */
	ifc_oqdrops,		/* dropped on output, this interface */
	ifc_noproto,		/* destined for unsupported protocol */

	ifc_ncounters
};

/*
 * Structure defining a queue for a network interface.
 *
 * (Would like to call this struct ``if'', but C isn't PL/1.)
 */
TAILQ_HEAD(ifnet_head, ifnet);		/* the actual queue head */
struct carp_softc;
SMR_LIST_HEAD(carp_iflist, carp_softc);

struct ifnet {				/* and the entries */
	void	*if_softc;		/* [I] lower-level data for this if */
	struct	refcnt if_refcnt;
	TAILQ_ENTRY(ifnet) if_list;	/* [NK] all struct ifnets are chained */
	TAILQ_ENTRY(ifnet) if_tmplist;	/* [T] temporary list */
	TAILQ_HEAD(, ifaddr) if_addrlist; /* [N] list of addresses per if */
	TAILQ_HEAD(, ifmaddr) if_maddrlist; /* [m] list of multicast records */
	TAILQ_HEAD(, ifg_list) if_groups; /* [N] list of groups per if */
	struct rwlock if_maddrlock;
	struct task_list if_addrhooks;	/* [I] address change callbacks */
	struct task_list if_linkstatehooks; /* [I] link change callbacks*/
	struct task_list if_detachhooks; /* [I] detach callbacks */
				/* [I] check or clean routes (+ or -)'d */
	void	(*if_rtrequest)(struct ifnet *, int, struct rtentry *);
	char	if_xname[IFNAMSIZ];	/* [I] external name (name + unit) */
	int	if_pcount;		/* [N] # of promiscuous listeners */
	unsigned int if_bridgeidx;	/* [K] used by bridge ports */
	caddr_t	if_bpf;			/* packet filter structure */
	caddr_t if_mcast;		/* used by multicast code */
	caddr_t if_mcast6;		/* used by IPv6 multicast code */
	caddr_t	if_pf_kif;		/* pf interface abstraction */
	union {
		/* carp if list (used by IFT_ETHER) */
		struct carp_iflist carp_s;

		/* index of carpdev (used by IFT_CARP) */
		unsigned int carp_idx;
	} if_carp_ptr;
#define if_carp		if_carp_ptr.carp_s
#define if_carpdevidx	if_carp_ptr.carp_idx
	unsigned int if_index;		/* [I] unique index for this if */
	short	if_timer;		/* time 'til if_watchdog called */
	unsigned short if_flags;	/* [N] up/down, broadcast, etc. */
	int	if_xflags;		/* [N] extra softnet flags */

	/* Stats and other data about if. Should be in sync with if_data. */
	u_char if_type;
	u_char if_addrlen;
	u_char if_hdrlen;
	u_char if_link_state;
	uint32_t if_mtu;
	uint32_t if_metric;
	uint64_t if_baudrate;
	uint32_t if_capabilities;
	uint32_t if_rdomain;
	struct  timeval if_lastchange;	/* [c] last op. state change */
	uint64_t if_data_counters[ifc_ncounters];

	struct	cpumem *if_counters;	/* per cpu stats */
	uint32_t if_hardmtu;		/* [d] maximum MTU device supports */
	char	if_description[IFDESCRSIZE]; /* [c] interface description */
	u_short	if_rtlabelid;		/* [c] next route label */
	uint8_t if_priority;		/* [c] route priority offset */
	uint8_t if_llprio;		/* [N] link layer priority */
	struct	timeout if_slowtimo;	/* [I] watchdog timeout */
	struct	task if_watchdogtask;	/* [I] watchdog task */
	struct	task if_linkstatetask;	/* [I] task to do route updates */

	/* procedure handles */
	void	(*if_input)(struct ifnet *, struct mbuf *, struct netstack *);
	int	(*if_bpf_mtap)(caddr_t, const struct mbuf *, u_int);
	int	(*if_output)(struct ifnet *, struct mbuf *, struct sockaddr *,
		     struct rtentry *);	/* output routine (enqueue) */
					/* link level output function */
	int	(*if_ll_output)(struct ifnet *, struct mbuf *,
		    struct sockaddr *, struct rtentry *);
	int	(*if_enqueue)(struct ifnet *, struct mbuf *);
	void	(*if_start)(struct ifnet *);	/* initiate output */
	int	(*if_ioctl)(struct ifnet *, u_long, caddr_t); /* ioctl hook */
	void	(*if_watchdog)(struct ifnet *);	/* timer routine */
	int	(*if_wol)(struct ifnet *, int);	/* WoL routine **/

	/* queues */
	struct	ifqueue if_snd;		/* transmit queue */
	struct	ifqueue **if_ifqs;	/* [I] pointer to an array of sndqs */
	void	(*if_qstart)(struct ifqueue *);
	unsigned int if_nifqs;		/* [I] number of output queues */
	unsigned int if_txmit;		/* [c] txmitigation amount */

	struct	ifiqueue if_rcv;	/* rx/input queue */
	struct	ifiqueue **if_iqs;	/* [I] pointer to the array of iqs */
	unsigned int if_niqs;		/* [I] number of input queues */

	struct sockaddr_dl *if_sadl;	/* [N] pointer to our sockaddr_dl */

	struct	nd_ifinfo *if_nd;	/* [I] IPv6 Neighbor Discovery info */
};

#define if_ipackets	if_data_counters[ifc_ipackets]
#define if_ierrors	if_data_counters[ifc_ierrors]
#define if_opackets	if_data_counters[ifc_opackets]
#define if_oerrors	if_data_counters[ifc_oerrors]
#define if_collisions	if_data_counters[ifc_collisions]
#define if_ibytes	if_data_counters[ifc_ibytes]
#define if_obytes	if_data_counters[ifc_obytes]
#define if_imcasts	if_data_counters[ifc_imcasts]
#define if_omcasts	if_data_counters[ifc_omcasts]
#define if_iqdrops	if_data_counters[ifc_iqdrops]
#define if_oqdrops	if_data_counters[ifc_oqdrops]
#define if_noproto	if_data_counters[ifc_noproto]

/*
 * The ifaddr structure contains information about one address
 * of an interface.  They are maintained by the different address families,
 * are allocated and attached when an address is set, and are linked
 * together so all addresses for an interface can be located.
 */
struct ifaddr {
	struct	sockaddr *ifa_addr;	/* address of interface */
	struct	sockaddr *ifa_dstaddr;	/* other end of p-to-p link */
#define	ifa_broadaddr	ifa_dstaddr	/* broadcast address interface */
	struct	sockaddr *ifa_netmask;	/* used to determine subnet */
	struct	ifnet *ifa_ifp;		/* back-pointer to interface */
	TAILQ_ENTRY(ifaddr) ifa_list;	/* [N] list of addresses for
					    interface */
	TAILQ_ENTRY(ifaddr) ifa_tmplist;/* [T] temporary list */
	u_int	ifa_flags;		/* interface flags, see below */
	struct	refcnt ifa_refcnt;	/* number of `rt_ifa` references */
	int	ifa_metric;		/* cost of going out this interface */
};

#define	IFA_ROUTE		0x01	/* Auto-magically installed route */

/*
 * Interface multicast address.
 */
struct ifmaddr {
	TAILQ_ENTRY(ifmaddr)	 ifma_list;	/* [m] Per-interface list */
	struct sockaddr		*ifma_addr;	/* [I] Protocol address */
	struct refcnt		 ifma_refcnt;	/* Count of references */
	unsigned int		 ifma_ifidx;	/* [I] Index of the interface */
};

/*
 * interface groups
 */

struct ifg_group {
	char			 ifg_group[IFNAMSIZ]; /* [I] group name */
	u_int			 ifg_refcnt;  /* [N] group reference count */
	caddr_t			 ifg_pf_kif;  /* [I] pf interface group */
	int			 ifg_carp_demoted; /* [K] carp demotion counter */
	TAILQ_HEAD(, ifg_member) ifg_members; /* [N] list of members per group */
	TAILQ_ENTRY(ifg_group)	 ifg_next;    /* [N] all groups are chained */

	struct refcnt		 ifg_tmprefcnt;
	TAILQ_ENTRY(ifg_group)	 ifg_tmplist;   /* [T] temporary list */
};

struct ifg_member {
	TAILQ_ENTRY(ifg_member)	 ifgm_next; /* [N] all members are chained */
	struct ifnet		*ifgm_ifp;  /* [I] member interface */
};

struct ifg_list {
	struct ifg_group	*ifgl_group; /* [I] interface group */
	TAILQ_ENTRY(ifg_list)	 ifgl_next;  /* [N] all groups are chained */
};

#define	IFNET_SLOWTIMO	1		/* granularity is 1 second */

#define IF_TXMIT_MIN			1
#define IF_TXMIT_DEFAULT		16

/* default interface priorities */
#define IF_WIRED_DEFAULT_PRIORITY	0
#define IF_WIRELESS_DEFAULT_PRIORITY	4
#define IF_WWAN_DEFAULT_PRIORITY	6
#define IF_CARP_DEFAULT_PRIORITY	15

/*
 * Network stack input queues.
 */
struct	niqueue {
	struct mbuf_queue	ni_q;
	u_int			ni_isr;
};

#define NIQUEUE_INITIALIZER(_len, _isr) \
    { MBUF_QUEUE_INITIALIZER((_len), IPL_NET), (_isr) }

int		niq_enqueue(struct niqueue *, struct mbuf *);

#define niq_dequeue(_q)			mq_dequeue(&(_q)->ni_q)
#define niq_delist(_q, _ml)		mq_delist(&(_q)->ni_q, (_ml))
#define niq_len(_q)			mq_len(&(_q)->ni_q)
#define niq_drops(_q)			mq_drops(&(_q)->ni_q)
#define sysctl_niq(_n, _l, _op, _olp, _np, _nl, _niq) \
    sysctl_mq((_n), (_l), (_op), (_olp), (_np), (_nl), &(_niq)->ni_q)

extern struct rwlock if_tmplist_lock;
extern struct ifnet_head ifnetlist;

void	if_start(struct ifnet *);
int	if_enqueue(struct ifnet *, struct mbuf *);
int	if_enqueue_ifq(struct ifnet *, struct mbuf *);
void	if_input(struct ifnet *, struct mbuf_list *);
void	if_vinput(struct ifnet *, struct mbuf *, struct netstack *);
void	if_input_process(struct ifnet *, struct mbuf_list *, unsigned int);
void	if_input_proto(struct ifnet *, struct mbuf *,
	    void (*)(struct ifnet *, struct mbuf *, struct netstack *),
	    struct netstack *);
int	if_input_local(struct ifnet *, struct mbuf *, sa_family_t,
	    struct netstack *);
int	if_output_ml(struct ifnet *, struct mbuf_list *,
	    struct sockaddr *, struct rtentry *);
int	if_output_mq(struct ifnet *, struct mbuf_queue *, unsigned int *,
	    struct sockaddr *, struct rtentry *);
int	if_output_tso(struct ifnet *, struct mbuf **, struct sockaddr *,
	    struct rtentry *, u_int);
int	if_output_local(struct ifnet *, struct mbuf *, sa_family_t);
void	if_rtrequest_dummy(struct ifnet *, int, struct rtentry *);
void	p2p_rtrequest(struct ifnet *, int, struct rtentry *);
void	p2p_input(struct ifnet *, struct mbuf *, struct netstack *);
int	p2p_bpf_mtap(caddr_t, const struct mbuf *, u_int);

/* this is a helper for if_input_process and similar functions */
static inline void
if_input_process_proto(struct ifnet *ifp, struct mbuf *m, struct netstack *ns)
{
	void (*input)(struct ifnet *, struct mbuf *, struct netstack *);
	input = m->m_pkthdr.ph_cookie;
	(*input)(ifp, m, ns);
}

struct	ifaddr *ifa_ifwithaddr(const struct sockaddr *, u_int);
struct	ifaddr *ifa_ifwithdstaddr(const struct sockaddr *, u_int);
struct	ifaddr *ifaof_ifpforaddr(const struct sockaddr *, struct ifnet *);
struct	ifaddr *ifaref(struct ifaddr *);
void	ifafree(struct ifaddr *);

int	if_isconnected(const struct ifnet *, unsigned int);

void	if_clone_attach(struct if_clone *);

int	if_clone_create(const char *, int);
int	if_clone_destroy(const char *);

struct if_clone *
	if_clone_lookup(const char *, int *);

void	ifa_add(struct ifnet *, struct ifaddr *);
void	ifa_del(struct ifnet *, struct ifaddr *);
void	ifa_update_broadaddr(struct ifnet *, struct ifaddr *,
	    struct sockaddr *);

void	if_addrhook_add(struct ifnet *, struct task *);
void	if_addrhook_del(struct ifnet *, struct task *);
void	if_addrhooks_run(struct ifnet *);
void	if_linkstatehook_add(struct ifnet *, struct task *);
void	if_linkstatehook_del(struct ifnet *, struct task *);
void	if_detachhook_add(struct ifnet *, struct task *);
void	if_detachhook_del(struct ifnet *, struct task *);

void	if_rxr_livelocked(struct if_rxring *);
void	if_rxr_init(struct if_rxring *, u_int, u_int);
u_int	if_rxr_get(struct if_rxring *, u_int);

#define if_rxr_put(_r, _c)	do { (_r)->rxr_alive -= (_c); } while (0)
#define if_rxr_needrefill(_r)	((_r)->rxr_alive < (_r)->rxr_lwm)
#define if_rxr_inuse(_r)	((_r)->rxr_alive)
#define if_rxr_cwm(_r)		((_r)->rxr_cwm)

int	if_rxr_info_ioctl(struct if_rxrinfo *, u_int, struct if_rxring_info *);
int	if_rxr_ioctl(struct if_rxrinfo *, const char *, u_int,
	    struct if_rxring *);

void	if_counters_alloc(struct ifnet *);
void	if_counters_free(struct ifnet *);

int	if_txhprio_l2_check(int);
int	if_txhprio_l3_check(int);
int	if_rxhprio_l2_check(int);
int	if_rxhprio_l3_check(int);

#endif /* _KERNEL */

#endif /* _NET_IF_VAR_H_ */