util.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0
/*
 * Wireless utility functions
 *
 * Copyright 2007-2009	Johannes Berg <[email protected]>
 * Copyright 2013-2014  Intel Mobile Communications GmbH
 * Copyright 2017	Intel Deutschland GmbH
 * Copyright (C) 2018-2023 Intel Corporation
 */
#include <linux/export.h>
#include <linux/bitops.h>
#include <linux/etherdevice.h>
#include <linux/slab.h>
#include <linux/ieee80211.h>
#include <net/cfg80211.h>
#include <net/ip.h>
#include <net/dsfield.h>
#include <linux/if_vlan.h>
#include <linux/mpls.h>
#include <linux/gcd.h>
#include <linux/bitfield.h>
#include <linux/nospec.h>
#include "core.h"
#include "rdev-ops.h"


const struct ieee80211_rate *
ieee80211_get_response_rate(struct ieee80211_supported_band *sband,
			    u32 basic_rates, int bitrate)
{ … }
EXPORT_SYMBOL(…);

u32 ieee80211_mandatory_rates(struct ieee80211_supported_band *sband)
{ … }
EXPORT_SYMBOL(…);

u32 ieee80211_channel_to_freq_khz(int chan, enum nl80211_band band)
{ … }
EXPORT_SYMBOL(…);

enum nl80211_chan_width
ieee80211_s1g_channel_width(const struct ieee80211_channel *chan)
{ … }
EXPORT_SYMBOL(…);

int ieee80211_freq_khz_to_channel(u32 freq)
{ … }
EXPORT_SYMBOL(…);

struct ieee80211_channel *ieee80211_get_channel_khz(struct wiphy *wiphy,
						    u32 freq)
{ … }
EXPORT_SYMBOL(…);

static void set_mandatory_flags_band(struct ieee80211_supported_band *sband)
{ … }

void ieee80211_set_bitrate_flags(struct wiphy *wiphy)
{ … }

bool cfg80211_supported_cipher_suite(struct wiphy *wiphy, u32 cipher)
{ … }

static bool
cfg80211_igtk_cipher_supported(struct cfg80211_registered_device *rdev)
{ … }

bool cfg80211_valid_key_idx(struct cfg80211_registered_device *rdev,
			    int key_idx, bool pairwise)
{ … }

int cfg80211_validate_key_settings(struct cfg80211_registered_device *rdev,
				   struct key_params *params, int key_idx,
				   bool pairwise, const u8 *mac_addr)
{ … }

unsigned int __attribute_const__ ieee80211_hdrlen(__le16 fc)
{ … }
EXPORT_SYMBOL(…);

unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb)
{ … }
EXPORT_SYMBOL(…);

static unsigned int __ieee80211_get_mesh_hdrlen(u8 flags)
{ … }

unsigned int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr)
{ … }
EXPORT_SYMBOL(…);

bool ieee80211_get_8023_tunnel_proto(const void *hdr, __be16 *proto)
{ … }
EXPORT_SYMBOL(…);

int ieee80211_strip_8023_mesh_hdr(struct sk_buff *skb)
{ … }
EXPORT_SYMBOL(…);

int ieee80211_data_to_8023_exthdr(struct sk_buff *skb, struct ethhdr *ehdr,
				  const u8 *addr, enum nl80211_iftype iftype,
				  u8 data_offset, bool is_amsdu)
{ … }
EXPORT_SYMBOL(…);

static void
__frame_add_frag(struct sk_buff *skb, struct page *page,
		 void *ptr, int len, int size)
{ … }

static void
__ieee80211_amsdu_copy_frag(struct sk_buff *skb, struct sk_buff *frame,
			    int offset, int len)
{ … }

static struct sk_buff *
__ieee80211_amsdu_copy(struct sk_buff *skb, unsigned int hlen,
		       int offset, int len, bool reuse_frag,
		       int min_len)
{ … }

static u16
ieee80211_amsdu_subframe_length(void *field, u8 mesh_flags, u8 hdr_type)
{ … }

bool ieee80211_is_valid_amsdu(struct sk_buff *skb, u8 mesh_hdr)
{ … }
EXPORT_SYMBOL(…);

void ieee80211_amsdu_to_8023s(struct sk_buff *skb, struct sk_buff_head *list,
			      const u8 *addr, enum nl80211_iftype iftype,
			      const unsigned int extra_headroom,
			      const u8 *check_da, const u8 *check_sa,
			      u8 mesh_control)
{ … }
EXPORT_SYMBOL(…);

/* Given a data frame determine the 802.1p/1d tag to use. */
unsigned int cfg80211_classify8021d(struct sk_buff *skb,
				    struct cfg80211_qos_map *qos_map)
{ … }
EXPORT_SYMBOL(…);

const struct element *ieee80211_bss_get_elem(struct cfg80211_bss *bss, u8 id)
{ … }
EXPORT_SYMBOL(…);

void cfg80211_upload_connect_keys(struct wireless_dev *wdev)
{ … }

void cfg80211_process_wdev_events(struct wireless_dev *wdev)
{ … }

void cfg80211_process_rdev_events(struct cfg80211_registered_device *rdev)
{ … }

int cfg80211_change_iface(struct cfg80211_registered_device *rdev,
			  struct net_device *dev, enum nl80211_iftype ntype,
			  struct vif_params *params)
{ … }

static u32 cfg80211_calculate_bitrate_ht(struct rate_info *rate)
{ … }

static u32 cfg80211_calculate_bitrate_dmg(struct rate_info *rate)
{ … }

static u32 cfg80211_calculate_bitrate_extended_sc_dmg(struct rate_info *rate)
{ … }

static u32 cfg80211_calculate_bitrate_edmg(struct rate_info *rate)
{ … }

static u32 cfg80211_calculate_bitrate_vht(struct rate_info *rate)
{ … }

static u32 cfg80211_calculate_bitrate_he(struct rate_info *rate)
{ … }

static u32 cfg80211_calculate_bitrate_eht(struct rate_info *rate)
{ … }

static u32 cfg80211_calculate_bitrate_s1g(struct rate_info *rate)
{ … }

u32 cfg80211_calculate_bitrate(struct rate_info *rate)
{ … }
EXPORT_SYMBOL(…);

int cfg80211_get_p2p_attr(const u8 *ies, unsigned int len,
			  enum ieee80211_p2p_attr_id attr,
			  u8 *buf, unsigned int bufsize)
{ … }
EXPORT_SYMBOL(…);

static bool ieee80211_id_in_list(const u8 *ids, int n_ids, u8 id, bool id_ext)
{ … }

static size_t skip_ie(const u8 *ies, size_t ielen, size_t pos)
{ … }

size_t ieee80211_ie_split_ric(const u8 *ies, size_t ielen,
			      const u8 *ids, int n_ids,
			      const u8 *after_ric, int n_after_ric,
			      size_t offset)
{ … }
EXPORT_SYMBOL(…);

void ieee80211_fragment_element(struct sk_buff *skb, u8 *len_pos, u8 frag_id)
{ … }
EXPORT_SYMBOL(…);

bool ieee80211_operating_class_to_band(u8 operating_class,
				       enum nl80211_band *band)
{ … }
EXPORT_SYMBOL(…);

bool ieee80211_operating_class_to_chandef(u8 operating_class,
					  struct ieee80211_channel *chan,
					  struct cfg80211_chan_def *chandef)
{ … }
EXPORT_SYMBOL(…);

bool ieee80211_chandef_to_operating_class(struct cfg80211_chan_def *chandef,
					  u8 *op_class)
{ … }
EXPORT_SYMBOL(…);

static int cfg80211_wdev_bi(struct wireless_dev *wdev)
{ … }

static void cfg80211_calculate_bi_data(struct wiphy *wiphy, u32 new_beacon_int,
				       u32 *beacon_int_gcd,
				       bool *beacon_int_different,
				       int radio_idx)
{ … }

int cfg80211_validate_beacon_int(struct cfg80211_registered_device *rdev,
				 enum nl80211_iftype iftype, u32 beacon_int)
{ … }

int cfg80211_iter_combinations(struct wiphy *wiphy,
			       struct iface_combination_params *params,
			       void (*iter)(const struct ieee80211_iface_combination *c,
					    void *data),
			       void *data)
{ … }
EXPORT_SYMBOL(…);

static void
cfg80211_iter_sum_ifcombs(const struct ieee80211_iface_combination *c,
			  void *data)
{ … }

int cfg80211_check_combinations(struct wiphy *wiphy,
				struct iface_combination_params *params)
{ … }
EXPORT_SYMBOL(…);

int ieee80211_get_ratemask(struct ieee80211_supported_band *sband,
			   const u8 *rates, unsigned int n_rates,
			   u32 *mask)
{ … }

unsigned int ieee80211_get_num_supported_channels(struct wiphy *wiphy)
{ … }
EXPORT_SYMBOL(…);

int cfg80211_get_station(struct net_device *dev, const u8 *mac_addr,
			 struct station_info *sinfo)
{ … }
EXPORT_SYMBOL(…);

void cfg80211_free_nan_func(struct cfg80211_nan_func *f)
{ … }
EXPORT_SYMBOL(…);

bool cfg80211_does_bw_fit_range(const struct ieee80211_freq_range *freq_range,
				u32 center_freq_khz, u32 bw_khz)
{ … }

int cfg80211_sinfo_alloc_tid_stats(struct station_info *sinfo, gfp_t gfp)
{ … }
EXPORT_SYMBOL(…);

/* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
/* Ethernet-II snap header (RFC1042 for most EtherTypes) */
const unsigned char rfc1042_header[] __aligned(2) = …;
EXPORT_SYMBOL(…);

/* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
const unsigned char bridge_tunnel_header[] __aligned(2) = …;
EXPORT_SYMBOL(…);

/* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
struct iapp_layer2_update { … } __packed;

void cfg80211_send_layer2_update(struct net_device *dev, const u8 *addr)
{ … }
EXPORT_SYMBOL(…);

int ieee80211_get_vht_max_nss(struct ieee80211_vht_cap *cap,
			      enum ieee80211_vht_chanwidth bw,
			      int mcs, bool ext_nss_bw_capable,
			      unsigned int max_vht_nss)
{ … }
EXPORT_SYMBOL(…);

bool cfg80211_iftype_allowed(struct wiphy *wiphy, enum nl80211_iftype iftype,
			     bool is_4addr, u8 check_swif)

{ … }
EXPORT_SYMBOL(…);

void cfg80211_remove_link(struct wireless_dev *wdev, unsigned int link_id)
{ … }

void cfg80211_remove_links(struct wireless_dev *wdev)
{ … }

int cfg80211_remove_virtual_intf(struct cfg80211_registered_device *rdev,
				 struct wireless_dev *wdev)
{ … }

const struct wiphy_iftype_ext_capab *
cfg80211_get_iftype_ext_capa(struct wiphy *wiphy, enum nl80211_iftype type)
{ … }
EXPORT_SYMBOL(…);

static bool
ieee80211_radio_freq_range_valid(const struct wiphy_radio *radio,
				 u32 freq, u32 width)
{ … }

bool cfg80211_radio_chandef_valid(const struct wiphy_radio *radio,
				  const struct cfg80211_chan_def *chandef)
{ … }
EXPORT_SYMBOL(…);
linux/net/wireless/util.c
