2 * This is the new netlink-based wireless configuration interface.
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/list.h>
12 #include <linux/if_ether.h>
13 #include <linux/ieee80211.h>
14 #include <linux/nl80211.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/netlink.h>
17 #include <linux/etherdevice.h>
18 #include <net/net_namespace.h>
19 #include <net/genetlink.h>
20 #include <net/cfg80211.h>
26 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type
);
27 static int nl80211_crypto_settings(struct cfg80211_registered_device
*rdev
,
28 struct genl_info
*info
,
29 struct cfg80211_crypto_settings
*settings
,
32 static int nl80211_pre_doit(struct genl_ops
*ops
, struct sk_buff
*skb
,
33 struct genl_info
*info
);
34 static void nl80211_post_doit(struct genl_ops
*ops
, struct sk_buff
*skb
,
35 struct genl_info
*info
);
37 /* the netlink family */
38 static struct genl_family nl80211_fam
= {
39 .id
= GENL_ID_GENERATE
, /* don't bother with a hardcoded ID */
40 .name
= "nl80211", /* have users key off the name instead */
41 .hdrsize
= 0, /* no private header */
42 .version
= 1, /* no particular meaning now */
43 .maxattr
= NL80211_ATTR_MAX
,
45 .pre_doit
= nl80211_pre_doit
,
46 .post_doit
= nl80211_post_doit
,
49 /* internal helper: get rdev and dev */
50 static int get_rdev_dev_by_ifindex(struct net
*netns
, struct nlattr
**attrs
,
51 struct cfg80211_registered_device
**rdev
,
52 struct net_device
**dev
)
56 if (!attrs
[NL80211_ATTR_IFINDEX
])
59 ifindex
= nla_get_u32(attrs
[NL80211_ATTR_IFINDEX
]);
60 *dev
= dev_get_by_index(netns
, ifindex
);
64 *rdev
= cfg80211_get_dev_from_ifindex(netns
, ifindex
);
67 return PTR_ERR(*rdev
);
73 /* policy for the attributes */
74 static const struct nla_policy nl80211_policy
[NL80211_ATTR_MAX
+1] = {
75 [NL80211_ATTR_WIPHY
] = { .type
= NLA_U32
},
76 [NL80211_ATTR_WIPHY_NAME
] = { .type
= NLA_NUL_STRING
,
78 [NL80211_ATTR_WIPHY_TXQ_PARAMS
] = { .type
= NLA_NESTED
},
79 [NL80211_ATTR_WIPHY_FREQ
] = { .type
= NLA_U32
},
80 [NL80211_ATTR_WIPHY_CHANNEL_TYPE
] = { .type
= NLA_U32
},
81 [NL80211_ATTR_WIPHY_RETRY_SHORT
] = { .type
= NLA_U8
},
82 [NL80211_ATTR_WIPHY_RETRY_LONG
] = { .type
= NLA_U8
},
83 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD
] = { .type
= NLA_U32
},
84 [NL80211_ATTR_WIPHY_RTS_THRESHOLD
] = { .type
= NLA_U32
},
85 [NL80211_ATTR_WIPHY_COVERAGE_CLASS
] = { .type
= NLA_U8
},
87 [NL80211_ATTR_IFTYPE
] = { .type
= NLA_U32
},
88 [NL80211_ATTR_IFINDEX
] = { .type
= NLA_U32
},
89 [NL80211_ATTR_IFNAME
] = { .type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
-1 },
91 [NL80211_ATTR_MAC
] = { .len
= ETH_ALEN
},
92 [NL80211_ATTR_PREV_BSSID
] = { .len
= ETH_ALEN
},
94 [NL80211_ATTR_KEY
] = { .type
= NLA_NESTED
, },
95 [NL80211_ATTR_KEY_DATA
] = { .type
= NLA_BINARY
,
96 .len
= WLAN_MAX_KEY_LEN
},
97 [NL80211_ATTR_KEY_IDX
] = { .type
= NLA_U8
},
98 [NL80211_ATTR_KEY_CIPHER
] = { .type
= NLA_U32
},
99 [NL80211_ATTR_KEY_DEFAULT
] = { .type
= NLA_FLAG
},
100 [NL80211_ATTR_KEY_SEQ
] = { .type
= NLA_BINARY
, .len
= 16 },
101 [NL80211_ATTR_KEY_TYPE
] = { .type
= NLA_U32
},
103 [NL80211_ATTR_BEACON_INTERVAL
] = { .type
= NLA_U32
},
104 [NL80211_ATTR_DTIM_PERIOD
] = { .type
= NLA_U32
},
105 [NL80211_ATTR_BEACON_HEAD
] = { .type
= NLA_BINARY
,
106 .len
= IEEE80211_MAX_DATA_LEN
},
107 [NL80211_ATTR_BEACON_TAIL
] = { .type
= NLA_BINARY
,
108 .len
= IEEE80211_MAX_DATA_LEN
},
109 [NL80211_ATTR_STA_AID
] = { .type
= NLA_U16
},
110 [NL80211_ATTR_STA_FLAGS
] = { .type
= NLA_NESTED
},
111 [NL80211_ATTR_STA_LISTEN_INTERVAL
] = { .type
= NLA_U16
},
112 [NL80211_ATTR_STA_SUPPORTED_RATES
] = { .type
= NLA_BINARY
,
113 .len
= NL80211_MAX_SUPP_RATES
},
114 [NL80211_ATTR_STA_PLINK_ACTION
] = { .type
= NLA_U8
},
115 [NL80211_ATTR_STA_VLAN
] = { .type
= NLA_U32
},
116 [NL80211_ATTR_MNTR_FLAGS
] = { /* NLA_NESTED can't be empty */ },
117 [NL80211_ATTR_MESH_ID
] = { .type
= NLA_BINARY
,
118 .len
= IEEE80211_MAX_MESH_ID_LEN
},
119 [NL80211_ATTR_MPATH_NEXT_HOP
] = { .type
= NLA_U32
},
121 [NL80211_ATTR_REG_ALPHA2
] = { .type
= NLA_STRING
, .len
= 2 },
122 [NL80211_ATTR_REG_RULES
] = { .type
= NLA_NESTED
},
124 [NL80211_ATTR_BSS_CTS_PROT
] = { .type
= NLA_U8
},
125 [NL80211_ATTR_BSS_SHORT_PREAMBLE
] = { .type
= NLA_U8
},
126 [NL80211_ATTR_BSS_SHORT_SLOT_TIME
] = { .type
= NLA_U8
},
127 [NL80211_ATTR_BSS_BASIC_RATES
] = { .type
= NLA_BINARY
,
128 .len
= NL80211_MAX_SUPP_RATES
},
129 [NL80211_ATTR_BSS_HT_OPMODE
] = { .type
= NLA_U16
},
131 [NL80211_ATTR_MESH_CONFIG
] = { .type
= NLA_NESTED
},
132 [NL80211_ATTR_SUPPORT_MESH_AUTH
] = { .type
= NLA_FLAG
},
134 [NL80211_ATTR_HT_CAPABILITY
] = { .len
= NL80211_HT_CAPABILITY_LEN
},
136 [NL80211_ATTR_MGMT_SUBTYPE
] = { .type
= NLA_U8
},
137 [NL80211_ATTR_IE
] = { .type
= NLA_BINARY
,
138 .len
= IEEE80211_MAX_DATA_LEN
},
139 [NL80211_ATTR_SCAN_FREQUENCIES
] = { .type
= NLA_NESTED
},
140 [NL80211_ATTR_SCAN_SSIDS
] = { .type
= NLA_NESTED
},
142 [NL80211_ATTR_SSID
] = { .type
= NLA_BINARY
,
143 .len
= IEEE80211_MAX_SSID_LEN
},
144 [NL80211_ATTR_AUTH_TYPE
] = { .type
= NLA_U32
},
145 [NL80211_ATTR_REASON_CODE
] = { .type
= NLA_U16
},
146 [NL80211_ATTR_FREQ_FIXED
] = { .type
= NLA_FLAG
},
147 [NL80211_ATTR_TIMED_OUT
] = { .type
= NLA_FLAG
},
148 [NL80211_ATTR_USE_MFP
] = { .type
= NLA_U32
},
149 [NL80211_ATTR_STA_FLAGS2
] = {
150 .len
= sizeof(struct nl80211_sta_flag_update
),
152 [NL80211_ATTR_CONTROL_PORT
] = { .type
= NLA_FLAG
},
153 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE
] = { .type
= NLA_U16
},
154 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
] = { .type
= NLA_FLAG
},
155 [NL80211_ATTR_PRIVACY
] = { .type
= NLA_FLAG
},
156 [NL80211_ATTR_CIPHER_SUITE_GROUP
] = { .type
= NLA_U32
},
157 [NL80211_ATTR_WPA_VERSIONS
] = { .type
= NLA_U32
},
158 [NL80211_ATTR_PID
] = { .type
= NLA_U32
},
159 [NL80211_ATTR_4ADDR
] = { .type
= NLA_U8
},
160 [NL80211_ATTR_PMKID
] = { .type
= NLA_BINARY
,
161 .len
= WLAN_PMKID_LEN
},
162 [NL80211_ATTR_DURATION
] = { .type
= NLA_U32
},
163 [NL80211_ATTR_COOKIE
] = { .type
= NLA_U64
},
164 [NL80211_ATTR_TX_RATES
] = { .type
= NLA_NESTED
},
165 [NL80211_ATTR_FRAME
] = { .type
= NLA_BINARY
,
166 .len
= IEEE80211_MAX_DATA_LEN
},
167 [NL80211_ATTR_FRAME_MATCH
] = { .type
= NLA_BINARY
, },
168 [NL80211_ATTR_PS_STATE
] = { .type
= NLA_U32
},
169 [NL80211_ATTR_CQM
] = { .type
= NLA_NESTED
, },
170 [NL80211_ATTR_LOCAL_STATE_CHANGE
] = { .type
= NLA_FLAG
},
171 [NL80211_ATTR_AP_ISOLATE
] = { .type
= NLA_U8
},
172 [NL80211_ATTR_WIPHY_TX_POWER_SETTING
] = { .type
= NLA_U32
},
173 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL
] = { .type
= NLA_U32
},
174 [NL80211_ATTR_FRAME_TYPE
] = { .type
= NLA_U16
},
175 [NL80211_ATTR_WIPHY_ANTENNA_TX
] = { .type
= NLA_U32
},
176 [NL80211_ATTR_WIPHY_ANTENNA_RX
] = { .type
= NLA_U32
},
177 [NL80211_ATTR_MCAST_RATE
] = { .type
= NLA_U32
},
178 [NL80211_ATTR_OFFCHANNEL_TX_OK
] = { .type
= NLA_FLAG
},
179 [NL80211_ATTR_KEY_DEFAULT_TYPES
] = { .type
= NLA_NESTED
},
180 [NL80211_ATTR_WOWLAN_TRIGGERS
] = { .type
= NLA_NESTED
},
181 [NL80211_ATTR_STA_PLINK_STATE
] = { .type
= NLA_U8
},
182 [NL80211_ATTR_SCHED_SCAN_INTERVAL
] = { .type
= NLA_U32
},
183 [NL80211_ATTR_REKEY_DATA
] = { .type
= NLA_NESTED
},
184 [NL80211_ATTR_SCAN_SUPP_RATES
] = { .type
= NLA_NESTED
},
185 [NL80211_ATTR_HIDDEN_SSID
] = { .type
= NLA_U32
},
186 [NL80211_ATTR_IE_PROBE_RESP
] = { .type
= NLA_BINARY
,
187 .len
= IEEE80211_MAX_DATA_LEN
},
188 [NL80211_ATTR_IE_ASSOC_RESP
] = { .type
= NLA_BINARY
,
189 .len
= IEEE80211_MAX_DATA_LEN
},
190 [NL80211_ATTR_ROAM_SUPPORT
] = { .type
= NLA_FLAG
},
191 [NL80211_ATTR_SCHED_SCAN_MATCH
] = { .type
= NLA_NESTED
},
192 [NL80211_ATTR_TX_NO_CCK_RATE
] = { .type
= NLA_FLAG
},
193 [NL80211_ATTR_TDLS_ACTION
] = { .type
= NLA_U8
},
194 [NL80211_ATTR_TDLS_DIALOG_TOKEN
] = { .type
= NLA_U8
},
195 [NL80211_ATTR_TDLS_OPERATION
] = { .type
= NLA_U8
},
196 [NL80211_ATTR_TDLS_SUPPORT
] = { .type
= NLA_FLAG
},
197 [NL80211_ATTR_TDLS_EXTERNAL_SETUP
] = { .type
= NLA_FLAG
},
198 [NL80211_ATTR_DONT_WAIT_FOR_ACK
] = { .type
= NLA_FLAG
},
199 [NL80211_ATTR_PROBE_RESP
] = { .type
= NLA_BINARY
,
200 .len
= IEEE80211_MAX_DATA_LEN
},
201 [NL80211_ATTR_DFS_REGION
] = { .type
= NLA_U8
},
202 [NL80211_ATTR_DISABLE_HT
] = { .type
= NLA_FLAG
},
203 [NL80211_ATTR_HT_CAPABILITY_MASK
] = {
204 .len
= NL80211_HT_CAPABILITY_LEN
206 [NL80211_ATTR_NOACK_MAP
] = { .type
= NLA_U16
},
207 [NL80211_ATTR_INACTIVITY_TIMEOUT
] = { .type
= NLA_U16
},
208 [NL80211_ATTR_BG_SCAN_PERIOD
] = { .type
= NLA_U16
},
211 /* policy for the key attributes */
212 static const struct nla_policy nl80211_key_policy
[NL80211_KEY_MAX
+ 1] = {
213 [NL80211_KEY_DATA
] = { .type
= NLA_BINARY
, .len
= WLAN_MAX_KEY_LEN
},
214 [NL80211_KEY_IDX
] = { .type
= NLA_U8
},
215 [NL80211_KEY_CIPHER
] = { .type
= NLA_U32
},
216 [NL80211_KEY_SEQ
] = { .type
= NLA_BINARY
, .len
= 16 },
217 [NL80211_KEY_DEFAULT
] = { .type
= NLA_FLAG
},
218 [NL80211_KEY_DEFAULT_MGMT
] = { .type
= NLA_FLAG
},
219 [NL80211_KEY_TYPE
] = { .type
= NLA_U32
},
220 [NL80211_KEY_DEFAULT_TYPES
] = { .type
= NLA_NESTED
},
223 /* policy for the key default flags */
224 static const struct nla_policy
225 nl80211_key_default_policy
[NUM_NL80211_KEY_DEFAULT_TYPES
] = {
226 [NL80211_KEY_DEFAULT_TYPE_UNICAST
] = { .type
= NLA_FLAG
},
227 [NL80211_KEY_DEFAULT_TYPE_MULTICAST
] = { .type
= NLA_FLAG
},
230 /* policy for WoWLAN attributes */
231 static const struct nla_policy
232 nl80211_wowlan_policy
[NUM_NL80211_WOWLAN_TRIG
] = {
233 [NL80211_WOWLAN_TRIG_ANY
] = { .type
= NLA_FLAG
},
234 [NL80211_WOWLAN_TRIG_DISCONNECT
] = { .type
= NLA_FLAG
},
235 [NL80211_WOWLAN_TRIG_MAGIC_PKT
] = { .type
= NLA_FLAG
},
236 [NL80211_WOWLAN_TRIG_PKT_PATTERN
] = { .type
= NLA_NESTED
},
237 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
] = { .type
= NLA_FLAG
},
238 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
] = { .type
= NLA_FLAG
},
239 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
] = { .type
= NLA_FLAG
},
240 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE
] = { .type
= NLA_FLAG
},
243 /* policy for GTK rekey offload attributes */
244 static const struct nla_policy
245 nl80211_rekey_policy
[NUM_NL80211_REKEY_DATA
] = {
246 [NL80211_REKEY_DATA_KEK
] = { .len
= NL80211_KEK_LEN
},
247 [NL80211_REKEY_DATA_KCK
] = { .len
= NL80211_KCK_LEN
},
248 [NL80211_REKEY_DATA_REPLAY_CTR
] = { .len
= NL80211_REPLAY_CTR_LEN
},
251 static const struct nla_policy
252 nl80211_match_policy
[NL80211_SCHED_SCAN_MATCH_ATTR_MAX
+ 1] = {
253 [NL80211_ATTR_SCHED_SCAN_MATCH_SSID
] = { .type
= NLA_BINARY
,
254 .len
= IEEE80211_MAX_SSID_LEN
},
257 /* ifidx get helper */
258 static int nl80211_get_ifidx(struct netlink_callback
*cb
)
262 res
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
263 nl80211_fam
.attrbuf
, nl80211_fam
.maxattr
,
268 if (!nl80211_fam
.attrbuf
[NL80211_ATTR_IFINDEX
])
271 res
= nla_get_u32(nl80211_fam
.attrbuf
[NL80211_ATTR_IFINDEX
]);
277 static int nl80211_prepare_netdev_dump(struct sk_buff
*skb
,
278 struct netlink_callback
*cb
,
279 struct cfg80211_registered_device
**rdev
,
280 struct net_device
**dev
)
282 int ifidx
= cb
->args
[0];
286 ifidx
= nl80211_get_ifidx(cb
);
294 *dev
= __dev_get_by_index(sock_net(skb
->sk
), ifidx
);
300 *rdev
= cfg80211_get_dev_from_ifindex(sock_net(skb
->sk
), ifidx
);
302 err
= PTR_ERR(*rdev
);
312 static void nl80211_finish_netdev_dump(struct cfg80211_registered_device
*rdev
)
314 cfg80211_unlock_rdev(rdev
);
319 static bool is_valid_ie_attr(const struct nlattr
*attr
)
327 pos
= nla_data(attr
);
348 /* message building helper */
349 static inline void *nl80211hdr_put(struct sk_buff
*skb
, u32 pid
, u32 seq
,
352 /* since there is no private header just add the generic one */
353 return genlmsg_put(skb
, pid
, seq
, &nl80211_fam
, flags
, cmd
);
356 static int nl80211_msg_put_channel(struct sk_buff
*msg
,
357 struct ieee80211_channel
*chan
)
359 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_FREQ
,
361 goto nla_put_failure
;
363 if ((chan
->flags
& IEEE80211_CHAN_DISABLED
) &&
364 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_DISABLED
))
365 goto nla_put_failure
;
366 if ((chan
->flags
& IEEE80211_CHAN_PASSIVE_SCAN
) &&
367 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN
))
368 goto nla_put_failure
;
369 if ((chan
->flags
& IEEE80211_CHAN_NO_IBSS
) &&
370 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_IBSS
))
371 goto nla_put_failure
;
372 if ((chan
->flags
& IEEE80211_CHAN_RADAR
) &&
373 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_RADAR
))
374 goto nla_put_failure
;
376 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_MAX_TX_POWER
,
377 DBM_TO_MBM(chan
->max_power
)))
378 goto nla_put_failure
;
386 /* netlink command implementations */
393 bool def_uni
, def_multi
;
396 static int nl80211_parse_key_new(struct nlattr
*key
, struct key_parse
*k
)
398 struct nlattr
*tb
[NL80211_KEY_MAX
+ 1];
399 int err
= nla_parse_nested(tb
, NL80211_KEY_MAX
, key
,
404 k
->def
= !!tb
[NL80211_KEY_DEFAULT
];
405 k
->defmgmt
= !!tb
[NL80211_KEY_DEFAULT_MGMT
];
414 if (tb
[NL80211_KEY_IDX
])
415 k
->idx
= nla_get_u8(tb
[NL80211_KEY_IDX
]);
417 if (tb
[NL80211_KEY_DATA
]) {
418 k
->p
.key
= nla_data(tb
[NL80211_KEY_DATA
]);
419 k
->p
.key_len
= nla_len(tb
[NL80211_KEY_DATA
]);
422 if (tb
[NL80211_KEY_SEQ
]) {
423 k
->p
.seq
= nla_data(tb
[NL80211_KEY_SEQ
]);
424 k
->p
.seq_len
= nla_len(tb
[NL80211_KEY_SEQ
]);
427 if (tb
[NL80211_KEY_CIPHER
])
428 k
->p
.cipher
= nla_get_u32(tb
[NL80211_KEY_CIPHER
]);
430 if (tb
[NL80211_KEY_TYPE
]) {
431 k
->type
= nla_get_u32(tb
[NL80211_KEY_TYPE
]);
432 if (k
->type
< 0 || k
->type
>= NUM_NL80211_KEYTYPES
)
436 if (tb
[NL80211_KEY_DEFAULT_TYPES
]) {
437 struct nlattr
*kdt
[NUM_NL80211_KEY_DEFAULT_TYPES
];
438 err
= nla_parse_nested(kdt
, NUM_NL80211_KEY_DEFAULT_TYPES
- 1,
439 tb
[NL80211_KEY_DEFAULT_TYPES
],
440 nl80211_key_default_policy
);
444 k
->def_uni
= kdt
[NL80211_KEY_DEFAULT_TYPE_UNICAST
];
445 k
->def_multi
= kdt
[NL80211_KEY_DEFAULT_TYPE_MULTICAST
];
451 static int nl80211_parse_key_old(struct genl_info
*info
, struct key_parse
*k
)
453 if (info
->attrs
[NL80211_ATTR_KEY_DATA
]) {
454 k
->p
.key
= nla_data(info
->attrs
[NL80211_ATTR_KEY_DATA
]);
455 k
->p
.key_len
= nla_len(info
->attrs
[NL80211_ATTR_KEY_DATA
]);
458 if (info
->attrs
[NL80211_ATTR_KEY_SEQ
]) {
459 k
->p
.seq
= nla_data(info
->attrs
[NL80211_ATTR_KEY_SEQ
]);
460 k
->p
.seq_len
= nla_len(info
->attrs
[NL80211_ATTR_KEY_SEQ
]);
463 if (info
->attrs
[NL80211_ATTR_KEY_IDX
])
464 k
->idx
= nla_get_u8(info
->attrs
[NL80211_ATTR_KEY_IDX
]);
466 if (info
->attrs
[NL80211_ATTR_KEY_CIPHER
])
467 k
->p
.cipher
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_CIPHER
]);
469 k
->def
= !!info
->attrs
[NL80211_ATTR_KEY_DEFAULT
];
470 k
->defmgmt
= !!info
->attrs
[NL80211_ATTR_KEY_DEFAULT_MGMT
];
479 if (info
->attrs
[NL80211_ATTR_KEY_TYPE
]) {
480 k
->type
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_TYPE
]);
481 if (k
->type
< 0 || k
->type
>= NUM_NL80211_KEYTYPES
)
485 if (info
->attrs
[NL80211_ATTR_KEY_DEFAULT_TYPES
]) {
486 struct nlattr
*kdt
[NUM_NL80211_KEY_DEFAULT_TYPES
];
487 int err
= nla_parse_nested(
488 kdt
, NUM_NL80211_KEY_DEFAULT_TYPES
- 1,
489 info
->attrs
[NL80211_ATTR_KEY_DEFAULT_TYPES
],
490 nl80211_key_default_policy
);
494 k
->def_uni
= kdt
[NL80211_KEY_DEFAULT_TYPE_UNICAST
];
495 k
->def_multi
= kdt
[NL80211_KEY_DEFAULT_TYPE_MULTICAST
];
501 static int nl80211_parse_key(struct genl_info
*info
, struct key_parse
*k
)
505 memset(k
, 0, sizeof(*k
));
509 if (info
->attrs
[NL80211_ATTR_KEY
])
510 err
= nl80211_parse_key_new(info
->attrs
[NL80211_ATTR_KEY
], k
);
512 err
= nl80211_parse_key_old(info
, k
);
517 if (k
->def
&& k
->defmgmt
)
521 if (k
->def_uni
|| !k
->def_multi
)
527 if (k
->idx
< 4 || k
->idx
> 5)
530 if (k
->idx
< 0 || k
->idx
> 3)
533 if (k
->idx
< 0 || k
->idx
> 5)
541 static struct cfg80211_cached_keys
*
542 nl80211_parse_connkeys(struct cfg80211_registered_device
*rdev
,
545 struct key_parse parse
;
547 struct cfg80211_cached_keys
*result
;
548 int rem
, err
, def
= 0;
550 result
= kzalloc(sizeof(*result
), GFP_KERNEL
);
552 return ERR_PTR(-ENOMEM
);
555 result
->defmgmt
= -1;
557 nla_for_each_nested(key
, keys
, rem
) {
558 memset(&parse
, 0, sizeof(parse
));
561 err
= nl80211_parse_key_new(key
, &parse
);
567 if (parse
.idx
< 0 || parse
.idx
> 4)
573 result
->def
= parse
.idx
;
574 if (!parse
.def_uni
|| !parse
.def_multi
)
576 } else if (parse
.defmgmt
)
578 err
= cfg80211_validate_key_settings(rdev
, &parse
.p
,
579 parse
.idx
, false, NULL
);
582 result
->params
[parse
.idx
].cipher
= parse
.p
.cipher
;
583 result
->params
[parse
.idx
].key_len
= parse
.p
.key_len
;
584 result
->params
[parse
.idx
].key
= result
->data
[parse
.idx
];
585 memcpy(result
->data
[parse
.idx
], parse
.p
.key
, parse
.p
.key_len
);
594 static int nl80211_key_allowed(struct wireless_dev
*wdev
)
596 ASSERT_WDEV_LOCK(wdev
);
598 switch (wdev
->iftype
) {
599 case NL80211_IFTYPE_AP
:
600 case NL80211_IFTYPE_AP_VLAN
:
601 case NL80211_IFTYPE_P2P_GO
:
602 case NL80211_IFTYPE_MESH_POINT
:
604 case NL80211_IFTYPE_ADHOC
:
605 if (!wdev
->current_bss
)
608 case NL80211_IFTYPE_STATION
:
609 case NL80211_IFTYPE_P2P_CLIENT
:
610 if (wdev
->sme_state
!= CFG80211_SME_CONNECTED
)
620 static int nl80211_put_iftypes(struct sk_buff
*msg
, u32 attr
, u16 ifmodes
)
622 struct nlattr
*nl_modes
= nla_nest_start(msg
, attr
);
626 goto nla_put_failure
;
630 if ((ifmodes
& 1) && nla_put_flag(msg
, i
))
631 goto nla_put_failure
;
636 nla_nest_end(msg
, nl_modes
);
643 static int nl80211_put_iface_combinations(struct wiphy
*wiphy
,
646 struct nlattr
*nl_combis
;
649 nl_combis
= nla_nest_start(msg
,
650 NL80211_ATTR_INTERFACE_COMBINATIONS
);
652 goto nla_put_failure
;
654 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
655 const struct ieee80211_iface_combination
*c
;
656 struct nlattr
*nl_combi
, *nl_limits
;
658 c
= &wiphy
->iface_combinations
[i
];
660 nl_combi
= nla_nest_start(msg
, i
+ 1);
662 goto nla_put_failure
;
664 nl_limits
= nla_nest_start(msg
, NL80211_IFACE_COMB_LIMITS
);
666 goto nla_put_failure
;
668 for (j
= 0; j
< c
->n_limits
; j
++) {
669 struct nlattr
*nl_limit
;
671 nl_limit
= nla_nest_start(msg
, j
+ 1);
673 goto nla_put_failure
;
674 if (nla_put_u32(msg
, NL80211_IFACE_LIMIT_MAX
,
676 goto nla_put_failure
;
677 if (nl80211_put_iftypes(msg
, NL80211_IFACE_LIMIT_TYPES
,
679 goto nla_put_failure
;
680 nla_nest_end(msg
, nl_limit
);
683 nla_nest_end(msg
, nl_limits
);
685 if (c
->beacon_int_infra_match
&&
686 nla_put_flag(msg
, NL80211_IFACE_COMB_STA_AP_BI_MATCH
))
687 goto nla_put_failure
;
688 if (nla_put_u32(msg
, NL80211_IFACE_COMB_NUM_CHANNELS
,
689 c
->num_different_channels
) ||
690 nla_put_u32(msg
, NL80211_IFACE_COMB_MAXNUM
,
692 goto nla_put_failure
;
694 nla_nest_end(msg
, nl_combi
);
697 nla_nest_end(msg
, nl_combis
);
704 static int nl80211_send_wiphy(struct sk_buff
*msg
, u32 pid
, u32 seq
, int flags
,
705 struct cfg80211_registered_device
*dev
)
708 struct nlattr
*nl_bands
, *nl_band
;
709 struct nlattr
*nl_freqs
, *nl_freq
;
710 struct nlattr
*nl_rates
, *nl_rate
;
711 struct nlattr
*nl_cmds
;
712 enum ieee80211_band band
;
713 struct ieee80211_channel
*chan
;
714 struct ieee80211_rate
*rate
;
716 const struct ieee80211_txrx_stypes
*mgmt_stypes
=
717 dev
->wiphy
.mgmt_stypes
;
719 hdr
= nl80211hdr_put(msg
, pid
, seq
, flags
, NL80211_CMD_NEW_WIPHY
);
723 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, dev
->wiphy_idx
) ||
724 nla_put_string(msg
, NL80211_ATTR_WIPHY_NAME
, wiphy_name(&dev
->wiphy
)) ||
725 nla_put_u32(msg
, NL80211_ATTR_GENERATION
,
726 cfg80211_rdev_list_generation
) ||
727 nla_put_u8(msg
, NL80211_ATTR_WIPHY_RETRY_SHORT
,
728 dev
->wiphy
.retry_short
) ||
729 nla_put_u8(msg
, NL80211_ATTR_WIPHY_RETRY_LONG
,
730 dev
->wiphy
.retry_long
) ||
731 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FRAG_THRESHOLD
,
732 dev
->wiphy
.frag_threshold
) ||
733 nla_put_u32(msg
, NL80211_ATTR_WIPHY_RTS_THRESHOLD
,
734 dev
->wiphy
.rts_threshold
) ||
735 nla_put_u8(msg
, NL80211_ATTR_WIPHY_COVERAGE_CLASS
,
736 dev
->wiphy
.coverage_class
) ||
737 nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_SCAN_SSIDS
,
738 dev
->wiphy
.max_scan_ssids
) ||
739 nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS
,
740 dev
->wiphy
.max_sched_scan_ssids
) ||
741 nla_put_u16(msg
, NL80211_ATTR_MAX_SCAN_IE_LEN
,
742 dev
->wiphy
.max_scan_ie_len
) ||
743 nla_put_u16(msg
, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN
,
744 dev
->wiphy
.max_sched_scan_ie_len
) ||
745 nla_put_u8(msg
, NL80211_ATTR_MAX_MATCH_SETS
,
746 dev
->wiphy
.max_match_sets
))
747 goto nla_put_failure
;
749 if ((dev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
) &&
750 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_IBSS_RSN
))
751 goto nla_put_failure
;
752 if ((dev
->wiphy
.flags
& WIPHY_FLAG_MESH_AUTH
) &&
753 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_MESH_AUTH
))
754 goto nla_put_failure
;
755 if ((dev
->wiphy
.flags
& WIPHY_FLAG_AP_UAPSD
) &&
756 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_AP_UAPSD
))
757 goto nla_put_failure
;
758 if ((dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_FW_ROAM
) &&
759 nla_put_flag(msg
, NL80211_ATTR_ROAM_SUPPORT
))
760 goto nla_put_failure
;
761 if ((dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) &&
762 nla_put_flag(msg
, NL80211_ATTR_TDLS_SUPPORT
))
763 goto nla_put_failure
;
764 if ((dev
->wiphy
.flags
& WIPHY_FLAG_TDLS_EXTERNAL_SETUP
) &&
765 nla_put_flag(msg
, NL80211_ATTR_TDLS_EXTERNAL_SETUP
))
766 goto nla_put_failure
;
768 if (nla_put(msg
, NL80211_ATTR_CIPHER_SUITES
,
769 sizeof(u32
) * dev
->wiphy
.n_cipher_suites
,
770 dev
->wiphy
.cipher_suites
))
771 goto nla_put_failure
;
773 if (nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_PMKIDS
,
774 dev
->wiphy
.max_num_pmkids
))
775 goto nla_put_failure
;
777 if ((dev
->wiphy
.flags
& WIPHY_FLAG_CONTROL_PORT_PROTOCOL
) &&
778 nla_put_flag(msg
, NL80211_ATTR_CONTROL_PORT_ETHERTYPE
))
779 goto nla_put_failure
;
781 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX
,
782 dev
->wiphy
.available_antennas_tx
) ||
783 nla_put_u32(msg
, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX
,
784 dev
->wiphy
.available_antennas_rx
))
785 goto nla_put_failure
;
787 if ((dev
->wiphy
.flags
& WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD
) &&
788 nla_put_u32(msg
, NL80211_ATTR_PROBE_RESP_OFFLOAD
,
789 dev
->wiphy
.probe_resp_offload
))
790 goto nla_put_failure
;
792 if ((dev
->wiphy
.available_antennas_tx
||
793 dev
->wiphy
.available_antennas_rx
) && dev
->ops
->get_antenna
) {
794 u32 tx_ant
= 0, rx_ant
= 0;
796 res
= dev
->ops
->get_antenna(&dev
->wiphy
, &tx_ant
, &rx_ant
);
798 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_ANTENNA_TX
,
800 nla_put_u32(msg
, NL80211_ATTR_WIPHY_ANTENNA_RX
,
802 goto nla_put_failure
;
806 if (nl80211_put_iftypes(msg
, NL80211_ATTR_SUPPORTED_IFTYPES
,
807 dev
->wiphy
.interface_modes
))
808 goto nla_put_failure
;
810 nl_bands
= nla_nest_start(msg
, NL80211_ATTR_WIPHY_BANDS
);
812 goto nla_put_failure
;
814 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
815 if (!dev
->wiphy
.bands
[band
])
818 nl_band
= nla_nest_start(msg
, band
);
820 goto nla_put_failure
;
823 if (dev
->wiphy
.bands
[band
]->ht_cap
.ht_supported
&&
824 (nla_put(msg
, NL80211_BAND_ATTR_HT_MCS_SET
,
825 sizeof(dev
->wiphy
.bands
[band
]->ht_cap
.mcs
),
826 &dev
->wiphy
.bands
[band
]->ht_cap
.mcs
) ||
827 nla_put_u16(msg
, NL80211_BAND_ATTR_HT_CAPA
,
828 dev
->wiphy
.bands
[band
]->ht_cap
.cap
) ||
829 nla_put_u8(msg
, NL80211_BAND_ATTR_HT_AMPDU_FACTOR
,
830 dev
->wiphy
.bands
[band
]->ht_cap
.ampdu_factor
) ||
831 nla_put_u8(msg
, NL80211_BAND_ATTR_HT_AMPDU_DENSITY
,
832 dev
->wiphy
.bands
[band
]->ht_cap
.ampdu_density
)))
833 goto nla_put_failure
;
835 /* add frequencies */
836 nl_freqs
= nla_nest_start(msg
, NL80211_BAND_ATTR_FREQS
);
838 goto nla_put_failure
;
840 for (i
= 0; i
< dev
->wiphy
.bands
[band
]->n_channels
; i
++) {
841 nl_freq
= nla_nest_start(msg
, i
);
843 goto nla_put_failure
;
845 chan
= &dev
->wiphy
.bands
[band
]->channels
[i
];
847 if (nl80211_msg_put_channel(msg
, chan
))
848 goto nla_put_failure
;
850 nla_nest_end(msg
, nl_freq
);
853 nla_nest_end(msg
, nl_freqs
);
856 nl_rates
= nla_nest_start(msg
, NL80211_BAND_ATTR_RATES
);
858 goto nla_put_failure
;
860 for (i
= 0; i
< dev
->wiphy
.bands
[band
]->n_bitrates
; i
++) {
861 nl_rate
= nla_nest_start(msg
, i
);
863 goto nla_put_failure
;
865 rate
= &dev
->wiphy
.bands
[band
]->bitrates
[i
];
866 if (nla_put_u32(msg
, NL80211_BITRATE_ATTR_RATE
,
868 goto nla_put_failure
;
869 if ((rate
->flags
& IEEE80211_RATE_SHORT_PREAMBLE
) &&
871 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE
))
872 goto nla_put_failure
;
874 nla_nest_end(msg
, nl_rate
);
877 nla_nest_end(msg
, nl_rates
);
879 nla_nest_end(msg
, nl_band
);
881 nla_nest_end(msg
, nl_bands
);
883 nl_cmds
= nla_nest_start(msg
, NL80211_ATTR_SUPPORTED_COMMANDS
);
885 goto nla_put_failure
;
890 if (dev->ops->op) { \
892 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
893 goto nla_put_failure; \
897 CMD(add_virtual_intf
, NEW_INTERFACE
);
898 CMD(change_virtual_intf
, SET_INTERFACE
);
899 CMD(add_key
, NEW_KEY
);
900 CMD(start_ap
, START_AP
);
901 CMD(add_station
, NEW_STATION
);
902 CMD(add_mpath
, NEW_MPATH
);
903 CMD(update_mesh_config
, SET_MESH_CONFIG
);
904 CMD(change_bss
, SET_BSS
);
905 CMD(auth
, AUTHENTICATE
);
906 CMD(assoc
, ASSOCIATE
);
907 CMD(deauth
, DEAUTHENTICATE
);
908 CMD(disassoc
, DISASSOCIATE
);
909 CMD(join_ibss
, JOIN_IBSS
);
910 CMD(join_mesh
, JOIN_MESH
);
911 CMD(set_pmksa
, SET_PMKSA
);
912 CMD(del_pmksa
, DEL_PMKSA
);
913 CMD(flush_pmksa
, FLUSH_PMKSA
);
914 if (dev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
)
915 CMD(remain_on_channel
, REMAIN_ON_CHANNEL
);
916 CMD(set_bitrate_mask
, SET_TX_BITRATE_MASK
);
918 CMD(mgmt_tx_cancel_wait
, FRAME_WAIT_CANCEL
);
919 if (dev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
) {
921 if (nla_put_u32(msg
, i
, NL80211_CMD_SET_WIPHY_NETNS
))
922 goto nla_put_failure
;
924 CMD(set_channel
, SET_CHANNEL
);
925 CMD(set_wds_peer
, SET_WDS_PEER
);
926 if (dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) {
927 CMD(tdls_mgmt
, TDLS_MGMT
);
928 CMD(tdls_oper
, TDLS_OPER
);
930 if (dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_SCHED_SCAN
)
931 CMD(sched_scan_start
, START_SCHED_SCAN
);
932 CMD(probe_client
, PROBE_CLIENT
);
933 CMD(set_noack_map
, SET_NOACK_MAP
);
934 if (dev
->wiphy
.flags
& WIPHY_FLAG_REPORTS_OBSS
) {
936 if (nla_put_u32(msg
, i
, NL80211_CMD_REGISTER_BEACONS
))
937 goto nla_put_failure
;
940 #ifdef CONFIG_NL80211_TESTMODE
941 CMD(testmode_cmd
, TESTMODE
);
946 if (dev
->ops
->connect
|| dev
->ops
->auth
) {
948 if (nla_put_u32(msg
, i
, NL80211_CMD_CONNECT
))
949 goto nla_put_failure
;
952 if (dev
->ops
->disconnect
|| dev
->ops
->deauth
) {
954 if (nla_put_u32(msg
, i
, NL80211_CMD_DISCONNECT
))
955 goto nla_put_failure
;
958 nla_nest_end(msg
, nl_cmds
);
960 if (dev
->ops
->remain_on_channel
&&
961 (dev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
) &&
962 nla_put_u32(msg
, NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION
,
963 dev
->wiphy
.max_remain_on_channel_duration
))
964 goto nla_put_failure
;
966 if ((dev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
) &&
967 nla_put_flag(msg
, NL80211_ATTR_OFFCHANNEL_TX_OK
))
968 goto nla_put_failure
;
972 struct nlattr
*nl_ftypes
, *nl_ifs
;
973 enum nl80211_iftype ift
;
975 nl_ifs
= nla_nest_start(msg
, NL80211_ATTR_TX_FRAME_TYPES
);
977 goto nla_put_failure
;
979 for (ift
= 0; ift
< NUM_NL80211_IFTYPES
; ift
++) {
980 nl_ftypes
= nla_nest_start(msg
, ift
);
982 goto nla_put_failure
;
984 stypes
= mgmt_stypes
[ift
].tx
;
987 nla_put_u16(msg
, NL80211_ATTR_FRAME_TYPE
,
988 (i
<< 4) | IEEE80211_FTYPE_MGMT
))
989 goto nla_put_failure
;
993 nla_nest_end(msg
, nl_ftypes
);
996 nla_nest_end(msg
, nl_ifs
);
998 nl_ifs
= nla_nest_start(msg
, NL80211_ATTR_RX_FRAME_TYPES
);
1000 goto nla_put_failure
;
1002 for (ift
= 0; ift
< NUM_NL80211_IFTYPES
; ift
++) {
1003 nl_ftypes
= nla_nest_start(msg
, ift
);
1005 goto nla_put_failure
;
1007 stypes
= mgmt_stypes
[ift
].rx
;
1010 nla_put_u16(msg
, NL80211_ATTR_FRAME_TYPE
,
1011 (i
<< 4) | IEEE80211_FTYPE_MGMT
))
1012 goto nla_put_failure
;
1016 nla_nest_end(msg
, nl_ftypes
);
1018 nla_nest_end(msg
, nl_ifs
);
1021 if (dev
->wiphy
.wowlan
.flags
|| dev
->wiphy
.wowlan
.n_patterns
) {
1022 struct nlattr
*nl_wowlan
;
1024 nl_wowlan
= nla_nest_start(msg
,
1025 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED
);
1027 goto nla_put_failure
;
1029 if (((dev
->wiphy
.wowlan
.flags
& WIPHY_WOWLAN_ANY
) &&
1030 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_ANY
)) ||
1031 ((dev
->wiphy
.wowlan
.flags
& WIPHY_WOWLAN_DISCONNECT
) &&
1032 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_DISCONNECT
)) ||
1033 ((dev
->wiphy
.wowlan
.flags
& WIPHY_WOWLAN_MAGIC_PKT
) &&
1034 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_MAGIC_PKT
)) ||
1035 ((dev
->wiphy
.wowlan
.flags
& WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
) &&
1036 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED
)) ||
1037 ((dev
->wiphy
.wowlan
.flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
) &&
1038 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
)) ||
1039 ((dev
->wiphy
.wowlan
.flags
& WIPHY_WOWLAN_EAP_IDENTITY_REQ
) &&
1040 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
)) ||
1041 ((dev
->wiphy
.wowlan
.flags
& WIPHY_WOWLAN_4WAY_HANDSHAKE
) &&
1042 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
)) ||
1043 ((dev
->wiphy
.wowlan
.flags
& WIPHY_WOWLAN_RFKILL_RELEASE
) &&
1044 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_RFKILL_RELEASE
)))
1045 goto nla_put_failure
;
1046 if (dev
->wiphy
.wowlan
.n_patterns
) {
1047 struct nl80211_wowlan_pattern_support pat
= {
1048 .max_patterns
= dev
->wiphy
.wowlan
.n_patterns
,
1050 dev
->wiphy
.wowlan
.pattern_min_len
,
1052 dev
->wiphy
.wowlan
.pattern_max_len
,
1054 if (nla_put(msg
, NL80211_WOWLAN_TRIG_PKT_PATTERN
,
1056 goto nla_put_failure
;
1059 nla_nest_end(msg
, nl_wowlan
);
1062 if (nl80211_put_iftypes(msg
, NL80211_ATTR_SOFTWARE_IFTYPES
,
1063 dev
->wiphy
.software_iftypes
))
1064 goto nla_put_failure
;
1066 if (nl80211_put_iface_combinations(&dev
->wiphy
, msg
))
1067 goto nla_put_failure
;
1069 if ((dev
->wiphy
.flags
& WIPHY_FLAG_HAVE_AP_SME
) &&
1070 nla_put_u32(msg
, NL80211_ATTR_DEVICE_AP_SME
,
1071 dev
->wiphy
.ap_sme_capa
))
1072 goto nla_put_failure
;
1074 if (nla_put_u32(msg
, NL80211_ATTR_FEATURE_FLAGS
,
1075 dev
->wiphy
.features
))
1076 goto nla_put_failure
;
1078 if (dev
->wiphy
.ht_capa_mod_mask
&&
1079 nla_put(msg
, NL80211_ATTR_HT_CAPABILITY_MASK
,
1080 sizeof(*dev
->wiphy
.ht_capa_mod_mask
),
1081 dev
->wiphy
.ht_capa_mod_mask
))
1082 goto nla_put_failure
;
1084 return genlmsg_end(msg
, hdr
);
1087 genlmsg_cancel(msg
, hdr
);
1091 static int nl80211_dump_wiphy(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1094 int start
= cb
->args
[0];
1095 struct cfg80211_registered_device
*dev
;
1097 mutex_lock(&cfg80211_mutex
);
1098 list_for_each_entry(dev
, &cfg80211_rdev_list
, list
) {
1099 if (!net_eq(wiphy_net(&dev
->wiphy
), sock_net(skb
->sk
)))
1103 if (nl80211_send_wiphy(skb
, NETLINK_CB(cb
->skb
).pid
,
1104 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
1110 mutex_unlock(&cfg80211_mutex
);
1117 static int nl80211_get_wiphy(struct sk_buff
*skb
, struct genl_info
*info
)
1119 struct sk_buff
*msg
;
1120 struct cfg80211_registered_device
*dev
= info
->user_ptr
[0];
1122 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1126 if (nl80211_send_wiphy(msg
, info
->snd_pid
, info
->snd_seq
, 0, dev
) < 0) {
1131 return genlmsg_reply(msg
, info
);
1134 static const struct nla_policy txq_params_policy
[NL80211_TXQ_ATTR_MAX
+ 1] = {
1135 [NL80211_TXQ_ATTR_QUEUE
] = { .type
= NLA_U8
},
1136 [NL80211_TXQ_ATTR_TXOP
] = { .type
= NLA_U16
},
1137 [NL80211_TXQ_ATTR_CWMIN
] = { .type
= NLA_U16
},
1138 [NL80211_TXQ_ATTR_CWMAX
] = { .type
= NLA_U16
},
1139 [NL80211_TXQ_ATTR_AIFS
] = { .type
= NLA_U8
},
1142 static int parse_txq_params(struct nlattr
*tb
[],
1143 struct ieee80211_txq_params
*txq_params
)
1145 if (!tb
[NL80211_TXQ_ATTR_AC
] || !tb
[NL80211_TXQ_ATTR_TXOP
] ||
1146 !tb
[NL80211_TXQ_ATTR_CWMIN
] || !tb
[NL80211_TXQ_ATTR_CWMAX
] ||
1147 !tb
[NL80211_TXQ_ATTR_AIFS
])
1150 txq_params
->ac
= nla_get_u8(tb
[NL80211_TXQ_ATTR_AC
]);
1151 txq_params
->txop
= nla_get_u16(tb
[NL80211_TXQ_ATTR_TXOP
]);
1152 txq_params
->cwmin
= nla_get_u16(tb
[NL80211_TXQ_ATTR_CWMIN
]);
1153 txq_params
->cwmax
= nla_get_u16(tb
[NL80211_TXQ_ATTR_CWMAX
]);
1154 txq_params
->aifs
= nla_get_u8(tb
[NL80211_TXQ_ATTR_AIFS
]);
1156 if (txq_params
->ac
>= NL80211_NUM_ACS
)
1162 static bool nl80211_can_set_dev_channel(struct wireless_dev
*wdev
)
1165 * You can only set the channel explicitly for AP, mesh
1166 * and WDS type interfaces; all others have their channel
1167 * managed via their respective "establish a connection"
1168 * command (connect, join, ...)
1170 * Monitors are special as they are normally slaved to
1171 * whatever else is going on, so they behave as though
1172 * you tried setting the wiphy channel itself.
1175 wdev
->iftype
== NL80211_IFTYPE_AP
||
1176 wdev
->iftype
== NL80211_IFTYPE_WDS
||
1177 wdev
->iftype
== NL80211_IFTYPE_MESH_POINT
||
1178 wdev
->iftype
== NL80211_IFTYPE_MONITOR
||
1179 wdev
->iftype
== NL80211_IFTYPE_P2P_GO
;
1182 static int __nl80211_set_channel(struct cfg80211_registered_device
*rdev
,
1183 struct wireless_dev
*wdev
,
1184 struct genl_info
*info
)
1186 enum nl80211_channel_type channel_type
= NL80211_CHAN_NO_HT
;
1190 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
1193 if (!nl80211_can_set_dev_channel(wdev
))
1196 if (info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]) {
1197 channel_type
= nla_get_u32(info
->attrs
[
1198 NL80211_ATTR_WIPHY_CHANNEL_TYPE
]);
1199 if (channel_type
!= NL80211_CHAN_NO_HT
&&
1200 channel_type
!= NL80211_CHAN_HT20
&&
1201 channel_type
!= NL80211_CHAN_HT40PLUS
&&
1202 channel_type
!= NL80211_CHAN_HT40MINUS
)
1206 freq
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]);
1208 mutex_lock(&rdev
->devlist_mtx
);
1211 result
= cfg80211_set_freq(rdev
, wdev
, freq
, channel_type
);
1214 result
= cfg80211_set_freq(rdev
, NULL
, freq
, channel_type
);
1216 mutex_unlock(&rdev
->devlist_mtx
);
1221 static int nl80211_set_channel(struct sk_buff
*skb
, struct genl_info
*info
)
1223 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1224 struct net_device
*netdev
= info
->user_ptr
[1];
1226 return __nl80211_set_channel(rdev
, netdev
->ieee80211_ptr
, info
);
1229 static int nl80211_set_wds_peer(struct sk_buff
*skb
, struct genl_info
*info
)
1231 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1232 struct net_device
*dev
= info
->user_ptr
[1];
1233 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1236 if (!info
->attrs
[NL80211_ATTR_MAC
])
1239 if (netif_running(dev
))
1242 if (!rdev
->ops
->set_wds_peer
)
1245 if (wdev
->iftype
!= NL80211_IFTYPE_WDS
)
1248 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
1249 return rdev
->ops
->set_wds_peer(wdev
->wiphy
, dev
, bssid
);
1253 static int nl80211_set_wiphy(struct sk_buff
*skb
, struct genl_info
*info
)
1255 struct cfg80211_registered_device
*rdev
;
1256 struct net_device
*netdev
= NULL
;
1257 struct wireless_dev
*wdev
;
1258 int result
= 0, rem_txq_params
= 0;
1259 struct nlattr
*nl_txq_params
;
1261 u8 retry_short
= 0, retry_long
= 0;
1262 u32 frag_threshold
= 0, rts_threshold
= 0;
1263 u8 coverage_class
= 0;
1266 * Try to find the wiphy and netdev. Normally this
1267 * function shouldn't need the netdev, but this is
1268 * done for backward compatibility -- previously
1269 * setting the channel was done per wiphy, but now
1270 * it is per netdev. Previous userland like hostapd
1271 * also passed a netdev to set_wiphy, so that it is
1272 * possible to let that go to the right netdev!
1274 mutex_lock(&cfg80211_mutex
);
1276 if (info
->attrs
[NL80211_ATTR_IFINDEX
]) {
1277 int ifindex
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFINDEX
]);
1279 netdev
= dev_get_by_index(genl_info_net(info
), ifindex
);
1280 if (netdev
&& netdev
->ieee80211_ptr
) {
1281 rdev
= wiphy_to_dev(netdev
->ieee80211_ptr
->wiphy
);
1282 mutex_lock(&rdev
->mtx
);
1288 rdev
= __cfg80211_rdev_from_info(info
);
1290 mutex_unlock(&cfg80211_mutex
);
1291 return PTR_ERR(rdev
);
1297 mutex_lock(&rdev
->mtx
);
1298 } else if (netif_running(netdev
) &&
1299 nl80211_can_set_dev_channel(netdev
->ieee80211_ptr
))
1300 wdev
= netdev
->ieee80211_ptr
;
1305 * end workaround code, by now the rdev is available
1306 * and locked, and wdev may or may not be NULL.
1309 if (info
->attrs
[NL80211_ATTR_WIPHY_NAME
])
1310 result
= cfg80211_dev_rename(
1311 rdev
, nla_data(info
->attrs
[NL80211_ATTR_WIPHY_NAME
]));
1313 mutex_unlock(&cfg80211_mutex
);
1318 if (info
->attrs
[NL80211_ATTR_WIPHY_TXQ_PARAMS
]) {
1319 struct ieee80211_txq_params txq_params
;
1320 struct nlattr
*tb
[NL80211_TXQ_ATTR_MAX
+ 1];
1322 if (!rdev
->ops
->set_txq_params
) {
1323 result
= -EOPNOTSUPP
;
1332 if (netdev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
1333 netdev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
) {
1338 if (!netif_running(netdev
)) {
1343 nla_for_each_nested(nl_txq_params
,
1344 info
->attrs
[NL80211_ATTR_WIPHY_TXQ_PARAMS
],
1346 nla_parse(tb
, NL80211_TXQ_ATTR_MAX
,
1347 nla_data(nl_txq_params
),
1348 nla_len(nl_txq_params
),
1350 result
= parse_txq_params(tb
, &txq_params
);
1354 result
= rdev
->ops
->set_txq_params(&rdev
->wiphy
,
1362 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
1363 result
= __nl80211_set_channel(rdev
, wdev
, info
);
1368 if (info
->attrs
[NL80211_ATTR_WIPHY_TX_POWER_SETTING
]) {
1369 enum nl80211_tx_power_setting type
;
1372 if (!rdev
->ops
->set_tx_power
) {
1373 result
= -EOPNOTSUPP
;
1377 idx
= NL80211_ATTR_WIPHY_TX_POWER_SETTING
;
1378 type
= nla_get_u32(info
->attrs
[idx
]);
1380 if (!info
->attrs
[NL80211_ATTR_WIPHY_TX_POWER_LEVEL
] &&
1381 (type
!= NL80211_TX_POWER_AUTOMATIC
)) {
1386 if (type
!= NL80211_TX_POWER_AUTOMATIC
) {
1387 idx
= NL80211_ATTR_WIPHY_TX_POWER_LEVEL
;
1388 mbm
= nla_get_u32(info
->attrs
[idx
]);
1391 result
= rdev
->ops
->set_tx_power(&rdev
->wiphy
, type
, mbm
);
1396 if (info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_TX
] &&
1397 info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_RX
]) {
1399 if ((!rdev
->wiphy
.available_antennas_tx
&&
1400 !rdev
->wiphy
.available_antennas_rx
) ||
1401 !rdev
->ops
->set_antenna
) {
1402 result
= -EOPNOTSUPP
;
1406 tx_ant
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_TX
]);
1407 rx_ant
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_RX
]);
1409 /* reject antenna configurations which don't match the
1410 * available antenna masks, except for the "all" mask */
1411 if ((~tx_ant
&& (tx_ant
& ~rdev
->wiphy
.available_antennas_tx
)) ||
1412 (~rx_ant
&& (rx_ant
& ~rdev
->wiphy
.available_antennas_rx
))) {
1417 tx_ant
= tx_ant
& rdev
->wiphy
.available_antennas_tx
;
1418 rx_ant
= rx_ant
& rdev
->wiphy
.available_antennas_rx
;
1420 result
= rdev
->ops
->set_antenna(&rdev
->wiphy
, tx_ant
, rx_ant
);
1427 if (info
->attrs
[NL80211_ATTR_WIPHY_RETRY_SHORT
]) {
1428 retry_short
= nla_get_u8(
1429 info
->attrs
[NL80211_ATTR_WIPHY_RETRY_SHORT
]);
1430 if (retry_short
== 0) {
1434 changed
|= WIPHY_PARAM_RETRY_SHORT
;
1437 if (info
->attrs
[NL80211_ATTR_WIPHY_RETRY_LONG
]) {
1438 retry_long
= nla_get_u8(
1439 info
->attrs
[NL80211_ATTR_WIPHY_RETRY_LONG
]);
1440 if (retry_long
== 0) {
1444 changed
|= WIPHY_PARAM_RETRY_LONG
;
1447 if (info
->attrs
[NL80211_ATTR_WIPHY_FRAG_THRESHOLD
]) {
1448 frag_threshold
= nla_get_u32(
1449 info
->attrs
[NL80211_ATTR_WIPHY_FRAG_THRESHOLD
]);
1450 if (frag_threshold
< 256) {
1454 if (frag_threshold
!= (u32
) -1) {
1456 * Fragments (apart from the last one) are required to
1457 * have even length. Make the fragmentation code
1458 * simpler by stripping LSB should someone try to use
1459 * odd threshold value.
1461 frag_threshold
&= ~0x1;
1463 changed
|= WIPHY_PARAM_FRAG_THRESHOLD
;
1466 if (info
->attrs
[NL80211_ATTR_WIPHY_RTS_THRESHOLD
]) {
1467 rts_threshold
= nla_get_u32(
1468 info
->attrs
[NL80211_ATTR_WIPHY_RTS_THRESHOLD
]);
1469 changed
|= WIPHY_PARAM_RTS_THRESHOLD
;
1472 if (info
->attrs
[NL80211_ATTR_WIPHY_COVERAGE_CLASS
]) {
1473 coverage_class
= nla_get_u8(
1474 info
->attrs
[NL80211_ATTR_WIPHY_COVERAGE_CLASS
]);
1475 changed
|= WIPHY_PARAM_COVERAGE_CLASS
;
1479 u8 old_retry_short
, old_retry_long
;
1480 u32 old_frag_threshold
, old_rts_threshold
;
1481 u8 old_coverage_class
;
1483 if (!rdev
->ops
->set_wiphy_params
) {
1484 result
= -EOPNOTSUPP
;
1488 old_retry_short
= rdev
->wiphy
.retry_short
;
1489 old_retry_long
= rdev
->wiphy
.retry_long
;
1490 old_frag_threshold
= rdev
->wiphy
.frag_threshold
;
1491 old_rts_threshold
= rdev
->wiphy
.rts_threshold
;
1492 old_coverage_class
= rdev
->wiphy
.coverage_class
;
1494 if (changed
& WIPHY_PARAM_RETRY_SHORT
)
1495 rdev
->wiphy
.retry_short
= retry_short
;
1496 if (changed
& WIPHY_PARAM_RETRY_LONG
)
1497 rdev
->wiphy
.retry_long
= retry_long
;
1498 if (changed
& WIPHY_PARAM_FRAG_THRESHOLD
)
1499 rdev
->wiphy
.frag_threshold
= frag_threshold
;
1500 if (changed
& WIPHY_PARAM_RTS_THRESHOLD
)
1501 rdev
->wiphy
.rts_threshold
= rts_threshold
;
1502 if (changed
& WIPHY_PARAM_COVERAGE_CLASS
)
1503 rdev
->wiphy
.coverage_class
= coverage_class
;
1505 result
= rdev
->ops
->set_wiphy_params(&rdev
->wiphy
, changed
);
1507 rdev
->wiphy
.retry_short
= old_retry_short
;
1508 rdev
->wiphy
.retry_long
= old_retry_long
;
1509 rdev
->wiphy
.frag_threshold
= old_frag_threshold
;
1510 rdev
->wiphy
.rts_threshold
= old_rts_threshold
;
1511 rdev
->wiphy
.coverage_class
= old_coverage_class
;
1516 mutex_unlock(&rdev
->mtx
);
1523 static int nl80211_send_iface(struct sk_buff
*msg
, u32 pid
, u32 seq
, int flags
,
1524 struct cfg80211_registered_device
*rdev
,
1525 struct net_device
*dev
)
1529 hdr
= nl80211hdr_put(msg
, pid
, seq
, flags
, NL80211_CMD_NEW_INTERFACE
);
1533 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
1534 nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
1535 nla_put_string(msg
, NL80211_ATTR_IFNAME
, dev
->name
) ||
1536 nla_put_u32(msg
, NL80211_ATTR_IFTYPE
,
1537 dev
->ieee80211_ptr
->iftype
) ||
1538 nla_put_u32(msg
, NL80211_ATTR_GENERATION
,
1539 rdev
->devlist_generation
^
1540 (cfg80211_rdev_list_generation
<< 2)))
1541 goto nla_put_failure
;
1543 if (rdev
->ops
->get_channel
) {
1544 struct ieee80211_channel
*chan
;
1545 enum nl80211_channel_type channel_type
;
1547 chan
= rdev
->ops
->get_channel(&rdev
->wiphy
, &channel_type
);
1549 (nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
,
1550 chan
->center_freq
) ||
1551 nla_put_u32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
1553 goto nla_put_failure
;
1556 return genlmsg_end(msg
, hdr
);
1559 genlmsg_cancel(msg
, hdr
);
1563 static int nl80211_dump_interface(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1567 int wp_start
= cb
->args
[0];
1568 int if_start
= cb
->args
[1];
1569 struct cfg80211_registered_device
*rdev
;
1570 struct wireless_dev
*wdev
;
1572 mutex_lock(&cfg80211_mutex
);
1573 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
1574 if (!net_eq(wiphy_net(&rdev
->wiphy
), sock_net(skb
->sk
)))
1576 if (wp_idx
< wp_start
) {
1582 mutex_lock(&rdev
->devlist_mtx
);
1583 list_for_each_entry(wdev
, &rdev
->netdev_list
, list
) {
1584 if (if_idx
< if_start
) {
1588 if (nl80211_send_iface(skb
, NETLINK_CB(cb
->skb
).pid
,
1589 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
1590 rdev
, wdev
->netdev
) < 0) {
1591 mutex_unlock(&rdev
->devlist_mtx
);
1596 mutex_unlock(&rdev
->devlist_mtx
);
1601 mutex_unlock(&cfg80211_mutex
);
1603 cb
->args
[0] = wp_idx
;
1604 cb
->args
[1] = if_idx
;
1609 static int nl80211_get_interface(struct sk_buff
*skb
, struct genl_info
*info
)
1611 struct sk_buff
*msg
;
1612 struct cfg80211_registered_device
*dev
= info
->user_ptr
[0];
1613 struct net_device
*netdev
= info
->user_ptr
[1];
1615 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1619 if (nl80211_send_iface(msg
, info
->snd_pid
, info
->snd_seq
, 0,
1625 return genlmsg_reply(msg
, info
);
1628 static const struct nla_policy mntr_flags_policy
[NL80211_MNTR_FLAG_MAX
+ 1] = {
1629 [NL80211_MNTR_FLAG_FCSFAIL
] = { .type
= NLA_FLAG
},
1630 [NL80211_MNTR_FLAG_PLCPFAIL
] = { .type
= NLA_FLAG
},
1631 [NL80211_MNTR_FLAG_CONTROL
] = { .type
= NLA_FLAG
},
1632 [NL80211_MNTR_FLAG_OTHER_BSS
] = { .type
= NLA_FLAG
},
1633 [NL80211_MNTR_FLAG_COOK_FRAMES
] = { .type
= NLA_FLAG
},
1636 static int parse_monitor_flags(struct nlattr
*nla
, u32
*mntrflags
)
1638 struct nlattr
*flags
[NL80211_MNTR_FLAG_MAX
+ 1];
1646 if (nla_parse_nested(flags
, NL80211_MNTR_FLAG_MAX
,
1647 nla
, mntr_flags_policy
))
1650 for (flag
= 1; flag
<= NL80211_MNTR_FLAG_MAX
; flag
++)
1652 *mntrflags
|= (1<<flag
);
1657 static int nl80211_valid_4addr(struct cfg80211_registered_device
*rdev
,
1658 struct net_device
*netdev
, u8 use_4addr
,
1659 enum nl80211_iftype iftype
)
1662 if (netdev
&& (netdev
->priv_flags
& IFF_BRIDGE_PORT
))
1668 case NL80211_IFTYPE_AP_VLAN
:
1669 if (rdev
->wiphy
.flags
& WIPHY_FLAG_4ADDR_AP
)
1672 case NL80211_IFTYPE_STATION
:
1673 if (rdev
->wiphy
.flags
& WIPHY_FLAG_4ADDR_STATION
)
1683 static int nl80211_set_interface(struct sk_buff
*skb
, struct genl_info
*info
)
1685 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1686 struct vif_params params
;
1688 enum nl80211_iftype otype
, ntype
;
1689 struct net_device
*dev
= info
->user_ptr
[1];
1690 u32 _flags
, *flags
= NULL
;
1691 bool change
= false;
1693 memset(¶ms
, 0, sizeof(params
));
1695 otype
= ntype
= dev
->ieee80211_ptr
->iftype
;
1697 if (info
->attrs
[NL80211_ATTR_IFTYPE
]) {
1698 ntype
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFTYPE
]);
1701 if (ntype
> NL80211_IFTYPE_MAX
)
1705 if (info
->attrs
[NL80211_ATTR_MESH_ID
]) {
1706 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1708 if (ntype
!= NL80211_IFTYPE_MESH_POINT
)
1710 if (netif_running(dev
))
1714 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN
!=
1715 IEEE80211_MAX_MESH_ID_LEN
);
1716 wdev
->mesh_id_up_len
=
1717 nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
1718 memcpy(wdev
->ssid
, nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]),
1719 wdev
->mesh_id_up_len
);
1723 if (info
->attrs
[NL80211_ATTR_4ADDR
]) {
1724 params
.use_4addr
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_4ADDR
]);
1726 err
= nl80211_valid_4addr(rdev
, dev
, params
.use_4addr
, ntype
);
1730 params
.use_4addr
= -1;
1733 if (info
->attrs
[NL80211_ATTR_MNTR_FLAGS
]) {
1734 if (ntype
!= NL80211_IFTYPE_MONITOR
)
1736 err
= parse_monitor_flags(info
->attrs
[NL80211_ATTR_MNTR_FLAGS
],
1746 err
= cfg80211_change_iface(rdev
, dev
, ntype
, flags
, ¶ms
);
1750 if (!err
&& params
.use_4addr
!= -1)
1751 dev
->ieee80211_ptr
->use_4addr
= params
.use_4addr
;
1756 static int nl80211_new_interface(struct sk_buff
*skb
, struct genl_info
*info
)
1758 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1759 struct vif_params params
;
1760 struct net_device
*dev
;
1762 enum nl80211_iftype type
= NL80211_IFTYPE_UNSPECIFIED
;
1765 memset(¶ms
, 0, sizeof(params
));
1767 if (!info
->attrs
[NL80211_ATTR_IFNAME
])
1770 if (info
->attrs
[NL80211_ATTR_IFTYPE
]) {
1771 type
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFTYPE
]);
1772 if (type
> NL80211_IFTYPE_MAX
)
1776 if (!rdev
->ops
->add_virtual_intf
||
1777 !(rdev
->wiphy
.interface_modes
& (1 << type
)))
1780 if (info
->attrs
[NL80211_ATTR_4ADDR
]) {
1781 params
.use_4addr
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_4ADDR
]);
1782 err
= nl80211_valid_4addr(rdev
, NULL
, params
.use_4addr
, type
);
1787 err
= parse_monitor_flags(type
== NL80211_IFTYPE_MONITOR
?
1788 info
->attrs
[NL80211_ATTR_MNTR_FLAGS
] : NULL
,
1790 dev
= rdev
->ops
->add_virtual_intf(&rdev
->wiphy
,
1791 nla_data(info
->attrs
[NL80211_ATTR_IFNAME
]),
1792 type
, err
? NULL
: &flags
, ¶ms
);
1794 return PTR_ERR(dev
);
1796 if (type
== NL80211_IFTYPE_MESH_POINT
&&
1797 info
->attrs
[NL80211_ATTR_MESH_ID
]) {
1798 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1801 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN
!=
1802 IEEE80211_MAX_MESH_ID_LEN
);
1803 wdev
->mesh_id_up_len
=
1804 nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
1805 memcpy(wdev
->ssid
, nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]),
1806 wdev
->mesh_id_up_len
);
1813 static int nl80211_del_interface(struct sk_buff
*skb
, struct genl_info
*info
)
1815 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1816 struct net_device
*dev
= info
->user_ptr
[1];
1818 if (!rdev
->ops
->del_virtual_intf
)
1821 return rdev
->ops
->del_virtual_intf(&rdev
->wiphy
, dev
);
1824 static int nl80211_set_noack_map(struct sk_buff
*skb
, struct genl_info
*info
)
1826 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1827 struct net_device
*dev
= info
->user_ptr
[1];
1830 if (!info
->attrs
[NL80211_ATTR_NOACK_MAP
])
1833 if (!rdev
->ops
->set_noack_map
)
1836 noack_map
= nla_get_u16(info
->attrs
[NL80211_ATTR_NOACK_MAP
]);
1838 return rdev
->ops
->set_noack_map(&rdev
->wiphy
, dev
, noack_map
);
1841 struct get_key_cookie
{
1842 struct sk_buff
*msg
;
1847 static void get_key_callback(void *c
, struct key_params
*params
)
1850 struct get_key_cookie
*cookie
= c
;
1853 nla_put(cookie
->msg
, NL80211_ATTR_KEY_DATA
,
1854 params
->key_len
, params
->key
)) ||
1856 nla_put(cookie
->msg
, NL80211_ATTR_KEY_SEQ
,
1857 params
->seq_len
, params
->seq
)) ||
1859 nla_put_u32(cookie
->msg
, NL80211_ATTR_KEY_CIPHER
,
1861 goto nla_put_failure
;
1863 key
= nla_nest_start(cookie
->msg
, NL80211_ATTR_KEY
);
1865 goto nla_put_failure
;
1868 nla_put(cookie
->msg
, NL80211_KEY_DATA
,
1869 params
->key_len
, params
->key
)) ||
1871 nla_put(cookie
->msg
, NL80211_KEY_SEQ
,
1872 params
->seq_len
, params
->seq
)) ||
1874 nla_put_u32(cookie
->msg
, NL80211_KEY_CIPHER
,
1876 goto nla_put_failure
;
1878 if (nla_put_u8(cookie
->msg
, NL80211_ATTR_KEY_IDX
, cookie
->idx
))
1879 goto nla_put_failure
;
1881 nla_nest_end(cookie
->msg
, key
);
1888 static int nl80211_get_key(struct sk_buff
*skb
, struct genl_info
*info
)
1890 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1892 struct net_device
*dev
= info
->user_ptr
[1];
1894 const u8
*mac_addr
= NULL
;
1896 struct get_key_cookie cookie
= {
1900 struct sk_buff
*msg
;
1902 if (info
->attrs
[NL80211_ATTR_KEY_IDX
])
1903 key_idx
= nla_get_u8(info
->attrs
[NL80211_ATTR_KEY_IDX
]);
1908 if (info
->attrs
[NL80211_ATTR_MAC
])
1909 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
1911 pairwise
= !!mac_addr
;
1912 if (info
->attrs
[NL80211_ATTR_KEY_TYPE
]) {
1913 u32 kt
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_TYPE
]);
1914 if (kt
>= NUM_NL80211_KEYTYPES
)
1916 if (kt
!= NL80211_KEYTYPE_GROUP
&&
1917 kt
!= NL80211_KEYTYPE_PAIRWISE
)
1919 pairwise
= kt
== NL80211_KEYTYPE_PAIRWISE
;
1922 if (!rdev
->ops
->get_key
)
1925 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1929 hdr
= nl80211hdr_put(msg
, info
->snd_pid
, info
->snd_seq
, 0,
1930 NL80211_CMD_NEW_KEY
);
1932 return PTR_ERR(hdr
);
1935 cookie
.idx
= key_idx
;
1937 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
1938 nla_put_u8(msg
, NL80211_ATTR_KEY_IDX
, key_idx
))
1939 goto nla_put_failure
;
1941 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
))
1942 goto nla_put_failure
;
1944 if (pairwise
&& mac_addr
&&
1945 !(rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
))
1948 err
= rdev
->ops
->get_key(&rdev
->wiphy
, dev
, key_idx
, pairwise
,
1949 mac_addr
, &cookie
, get_key_callback
);
1955 goto nla_put_failure
;
1957 genlmsg_end(msg
, hdr
);
1958 return genlmsg_reply(msg
, info
);
1967 static int nl80211_set_key(struct sk_buff
*skb
, struct genl_info
*info
)
1969 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1970 struct key_parse key
;
1972 struct net_device
*dev
= info
->user_ptr
[1];
1974 err
= nl80211_parse_key(info
, &key
);
1981 /* only support setting default key */
1982 if (!key
.def
&& !key
.defmgmt
)
1985 wdev_lock(dev
->ieee80211_ptr
);
1988 if (!rdev
->ops
->set_default_key
) {
1993 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
1997 err
= rdev
->ops
->set_default_key(&rdev
->wiphy
, dev
, key
.idx
,
1998 key
.def_uni
, key
.def_multi
);
2003 #ifdef CONFIG_CFG80211_WEXT
2004 dev
->ieee80211_ptr
->wext
.default_key
= key
.idx
;
2007 if (key
.def_uni
|| !key
.def_multi
) {
2012 if (!rdev
->ops
->set_default_mgmt_key
) {
2017 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
2021 err
= rdev
->ops
->set_default_mgmt_key(&rdev
->wiphy
,
2026 #ifdef CONFIG_CFG80211_WEXT
2027 dev
->ieee80211_ptr
->wext
.default_mgmt_key
= key
.idx
;
2032 wdev_unlock(dev
->ieee80211_ptr
);
2037 static int nl80211_new_key(struct sk_buff
*skb
, struct genl_info
*info
)
2039 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2041 struct net_device
*dev
= info
->user_ptr
[1];
2042 struct key_parse key
;
2043 const u8
*mac_addr
= NULL
;
2045 err
= nl80211_parse_key(info
, &key
);
2052 if (info
->attrs
[NL80211_ATTR_MAC
])
2053 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2055 if (key
.type
== -1) {
2057 key
.type
= NL80211_KEYTYPE_PAIRWISE
;
2059 key
.type
= NL80211_KEYTYPE_GROUP
;
2063 if (key
.type
!= NL80211_KEYTYPE_PAIRWISE
&&
2064 key
.type
!= NL80211_KEYTYPE_GROUP
)
2067 if (!rdev
->ops
->add_key
)
2070 if (cfg80211_validate_key_settings(rdev
, &key
.p
, key
.idx
,
2071 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
2075 wdev_lock(dev
->ieee80211_ptr
);
2076 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
2078 err
= rdev
->ops
->add_key(&rdev
->wiphy
, dev
, key
.idx
,
2079 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
2081 wdev_unlock(dev
->ieee80211_ptr
);
2086 static int nl80211_del_key(struct sk_buff
*skb
, struct genl_info
*info
)
2088 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2090 struct net_device
*dev
= info
->user_ptr
[1];
2091 u8
*mac_addr
= NULL
;
2092 struct key_parse key
;
2094 err
= nl80211_parse_key(info
, &key
);
2098 if (info
->attrs
[NL80211_ATTR_MAC
])
2099 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2101 if (key
.type
== -1) {
2103 key
.type
= NL80211_KEYTYPE_PAIRWISE
;
2105 key
.type
= NL80211_KEYTYPE_GROUP
;
2109 if (key
.type
!= NL80211_KEYTYPE_PAIRWISE
&&
2110 key
.type
!= NL80211_KEYTYPE_GROUP
)
2113 if (!rdev
->ops
->del_key
)
2116 wdev_lock(dev
->ieee80211_ptr
);
2117 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
2119 if (key
.type
== NL80211_KEYTYPE_PAIRWISE
&& mac_addr
&&
2120 !(rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
))
2124 err
= rdev
->ops
->del_key(&rdev
->wiphy
, dev
, key
.idx
,
2125 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
2128 #ifdef CONFIG_CFG80211_WEXT
2130 if (key
.idx
== dev
->ieee80211_ptr
->wext
.default_key
)
2131 dev
->ieee80211_ptr
->wext
.default_key
= -1;
2132 else if (key
.idx
== dev
->ieee80211_ptr
->wext
.default_mgmt_key
)
2133 dev
->ieee80211_ptr
->wext
.default_mgmt_key
= -1;
2136 wdev_unlock(dev
->ieee80211_ptr
);
2141 static int nl80211_parse_beacon(struct genl_info
*info
,
2142 struct cfg80211_beacon_data
*bcn
)
2144 bool haveinfo
= false;
2146 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_BEACON_TAIL
]) ||
2147 !is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]) ||
2148 !is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE_PROBE_RESP
]) ||
2149 !is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE_ASSOC_RESP
]))
2152 memset(bcn
, 0, sizeof(*bcn
));
2154 if (info
->attrs
[NL80211_ATTR_BEACON_HEAD
]) {
2155 bcn
->head
= nla_data(info
->attrs
[NL80211_ATTR_BEACON_HEAD
]);
2156 bcn
->head_len
= nla_len(info
->attrs
[NL80211_ATTR_BEACON_HEAD
]);
2162 if (info
->attrs
[NL80211_ATTR_BEACON_TAIL
]) {
2163 bcn
->tail
= nla_data(info
->attrs
[NL80211_ATTR_BEACON_TAIL
]);
2165 nla_len(info
->attrs
[NL80211_ATTR_BEACON_TAIL
]);
2172 if (info
->attrs
[NL80211_ATTR_IE
]) {
2173 bcn
->beacon_ies
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
2174 bcn
->beacon_ies_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
2177 if (info
->attrs
[NL80211_ATTR_IE_PROBE_RESP
]) {
2178 bcn
->proberesp_ies
=
2179 nla_data(info
->attrs
[NL80211_ATTR_IE_PROBE_RESP
]);
2180 bcn
->proberesp_ies_len
=
2181 nla_len(info
->attrs
[NL80211_ATTR_IE_PROBE_RESP
]);
2184 if (info
->attrs
[NL80211_ATTR_IE_ASSOC_RESP
]) {
2185 bcn
->assocresp_ies
=
2186 nla_data(info
->attrs
[NL80211_ATTR_IE_ASSOC_RESP
]);
2187 bcn
->assocresp_ies_len
=
2188 nla_len(info
->attrs
[NL80211_ATTR_IE_ASSOC_RESP
]);
2191 if (info
->attrs
[NL80211_ATTR_PROBE_RESP
]) {
2193 nla_data(info
->attrs
[NL80211_ATTR_PROBE_RESP
]);
2194 bcn
->probe_resp_len
=
2195 nla_len(info
->attrs
[NL80211_ATTR_PROBE_RESP
]);
2201 static int nl80211_start_ap(struct sk_buff
*skb
, struct genl_info
*info
)
2203 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2204 struct net_device
*dev
= info
->user_ptr
[1];
2205 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
2206 struct cfg80211_ap_settings params
;
2209 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
2210 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
2213 if (!rdev
->ops
->start_ap
)
2216 if (wdev
->beacon_interval
)
2219 memset(¶ms
, 0, sizeof(params
));
2221 /* these are required for START_AP */
2222 if (!info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
] ||
2223 !info
->attrs
[NL80211_ATTR_DTIM_PERIOD
] ||
2224 !info
->attrs
[NL80211_ATTR_BEACON_HEAD
])
2227 err
= nl80211_parse_beacon(info
, ¶ms
.beacon
);
2231 params
.beacon_interval
=
2232 nla_get_u32(info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]);
2233 params
.dtim_period
=
2234 nla_get_u32(info
->attrs
[NL80211_ATTR_DTIM_PERIOD
]);
2236 err
= cfg80211_validate_beacon_int(rdev
, params
.beacon_interval
);
2241 * In theory, some of these attributes should be required here
2242 * but since they were not used when the command was originally
2243 * added, keep them optional for old user space programs to let
2244 * them continue to work with drivers that do not need the
2245 * additional information -- drivers must check!
2247 if (info
->attrs
[NL80211_ATTR_SSID
]) {
2248 params
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
2250 nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
2251 if (params
.ssid_len
== 0 ||
2252 params
.ssid_len
> IEEE80211_MAX_SSID_LEN
)
2256 if (info
->attrs
[NL80211_ATTR_HIDDEN_SSID
]) {
2257 params
.hidden_ssid
= nla_get_u32(
2258 info
->attrs
[NL80211_ATTR_HIDDEN_SSID
]);
2259 if (params
.hidden_ssid
!= NL80211_HIDDEN_SSID_NOT_IN_USE
&&
2260 params
.hidden_ssid
!= NL80211_HIDDEN_SSID_ZERO_LEN
&&
2261 params
.hidden_ssid
!= NL80211_HIDDEN_SSID_ZERO_CONTENTS
)
2265 params
.privacy
= !!info
->attrs
[NL80211_ATTR_PRIVACY
];
2267 if (info
->attrs
[NL80211_ATTR_AUTH_TYPE
]) {
2268 params
.auth_type
= nla_get_u32(
2269 info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
2270 if (!nl80211_valid_auth_type(params
.auth_type
))
2273 params
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
2275 err
= nl80211_crypto_settings(rdev
, info
, ¶ms
.crypto
,
2276 NL80211_MAX_NR_CIPHER_SUITES
);
2280 if (info
->attrs
[NL80211_ATTR_INACTIVITY_TIMEOUT
]) {
2281 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_INACTIVITY_TIMER
))
2283 params
.inactivity_timeout
= nla_get_u16(
2284 info
->attrs
[NL80211_ATTR_INACTIVITY_TIMEOUT
]);
2287 err
= rdev
->ops
->start_ap(&rdev
->wiphy
, dev
, ¶ms
);
2289 wdev
->beacon_interval
= params
.beacon_interval
;
2293 static int nl80211_set_beacon(struct sk_buff
*skb
, struct genl_info
*info
)
2295 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2296 struct net_device
*dev
= info
->user_ptr
[1];
2297 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
2298 struct cfg80211_beacon_data params
;
2301 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
2302 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
2305 if (!rdev
->ops
->change_beacon
)
2308 if (!wdev
->beacon_interval
)
2311 err
= nl80211_parse_beacon(info
, ¶ms
);
2315 return rdev
->ops
->change_beacon(&rdev
->wiphy
, dev
, ¶ms
);
2318 static int nl80211_stop_ap(struct sk_buff
*skb
, struct genl_info
*info
)
2320 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2321 struct net_device
*dev
= info
->user_ptr
[1];
2322 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
2325 if (!rdev
->ops
->stop_ap
)
2328 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
2329 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
2332 if (!wdev
->beacon_interval
)
2335 err
= rdev
->ops
->stop_ap(&rdev
->wiphy
, dev
);
2337 wdev
->beacon_interval
= 0;
2341 static const struct nla_policy sta_flags_policy
[NL80211_STA_FLAG_MAX
+ 1] = {
2342 [NL80211_STA_FLAG_AUTHORIZED
] = { .type
= NLA_FLAG
},
2343 [NL80211_STA_FLAG_SHORT_PREAMBLE
] = { .type
= NLA_FLAG
},
2344 [NL80211_STA_FLAG_WME
] = { .type
= NLA_FLAG
},
2345 [NL80211_STA_FLAG_MFP
] = { .type
= NLA_FLAG
},
2346 [NL80211_STA_FLAG_AUTHENTICATED
] = { .type
= NLA_FLAG
},
2347 [NL80211_STA_FLAG_TDLS_PEER
] = { .type
= NLA_FLAG
},
2350 static int parse_station_flags(struct genl_info
*info
,
2351 enum nl80211_iftype iftype
,
2352 struct station_parameters
*params
)
2354 struct nlattr
*flags
[NL80211_STA_FLAG_MAX
+ 1];
2359 * Try parsing the new attribute first so userspace
2360 * can specify both for older kernels.
2362 nla
= info
->attrs
[NL80211_ATTR_STA_FLAGS2
];
2364 struct nl80211_sta_flag_update
*sta_flags
;
2366 sta_flags
= nla_data(nla
);
2367 params
->sta_flags_mask
= sta_flags
->mask
;
2368 params
->sta_flags_set
= sta_flags
->set
;
2369 if ((params
->sta_flags_mask
|
2370 params
->sta_flags_set
) & BIT(__NL80211_STA_FLAG_INVALID
))
2375 /* if present, parse the old attribute */
2377 nla
= info
->attrs
[NL80211_ATTR_STA_FLAGS
];
2381 if (nla_parse_nested(flags
, NL80211_STA_FLAG_MAX
,
2382 nla
, sta_flags_policy
))
2386 * Only allow certain flags for interface types so that
2387 * other attributes are silently ignored. Remember that
2388 * this is backward compatibility code with old userspace
2389 * and shouldn't be hit in other cases anyway.
2392 case NL80211_IFTYPE_AP
:
2393 case NL80211_IFTYPE_AP_VLAN
:
2394 case NL80211_IFTYPE_P2P_GO
:
2395 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHORIZED
) |
2396 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE
) |
2397 BIT(NL80211_STA_FLAG_WME
) |
2398 BIT(NL80211_STA_FLAG_MFP
);
2400 case NL80211_IFTYPE_P2P_CLIENT
:
2401 case NL80211_IFTYPE_STATION
:
2402 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHORIZED
) |
2403 BIT(NL80211_STA_FLAG_TDLS_PEER
);
2405 case NL80211_IFTYPE_MESH_POINT
:
2406 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
2407 BIT(NL80211_STA_FLAG_MFP
) |
2408 BIT(NL80211_STA_FLAG_AUTHORIZED
);
2413 for (flag
= 1; flag
<= NL80211_STA_FLAG_MAX
; flag
++)
2415 params
->sta_flags_set
|= (1<<flag
);
2420 static bool nl80211_put_sta_rate(struct sk_buff
*msg
, struct rate_info
*info
,
2423 struct nlattr
*rate
;
2426 rate
= nla_nest_start(msg
, attr
);
2428 goto nla_put_failure
;
2430 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
2431 bitrate
= cfg80211_calculate_bitrate(info
);
2433 nla_put_u16(msg
, NL80211_RATE_INFO_BITRATE
, bitrate
)) ||
2434 ((info
->flags
& RATE_INFO_FLAGS_MCS
) &&
2435 nla_put_u8(msg
, NL80211_RATE_INFO_MCS
, info
->mcs
)) ||
2436 ((info
->flags
& RATE_INFO_FLAGS_40_MHZ_WIDTH
) &&
2437 nla_put_flag(msg
, NL80211_RATE_INFO_40_MHZ_WIDTH
)) ||
2438 ((info
->flags
& RATE_INFO_FLAGS_SHORT_GI
) &&
2439 nla_put_flag(msg
, NL80211_RATE_INFO_SHORT_GI
)))
2440 goto nla_put_failure
;
2442 nla_nest_end(msg
, rate
);
2449 static int nl80211_send_station(struct sk_buff
*msg
, u32 pid
, u32 seq
,
2451 struct cfg80211_registered_device
*rdev
,
2452 struct net_device
*dev
,
2453 const u8
*mac_addr
, struct station_info
*sinfo
)
2456 struct nlattr
*sinfoattr
, *bss_param
;
2458 hdr
= nl80211hdr_put(msg
, pid
, seq
, flags
, NL80211_CMD_NEW_STATION
);
2462 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
2463 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
) ||
2464 nla_put_u32(msg
, NL80211_ATTR_GENERATION
, sinfo
->generation
))
2465 goto nla_put_failure
;
2467 sinfoattr
= nla_nest_start(msg
, NL80211_ATTR_STA_INFO
);
2469 goto nla_put_failure
;
2470 if ((sinfo
->filled
& STATION_INFO_CONNECTED_TIME
) &&
2471 nla_put_u32(msg
, NL80211_STA_INFO_CONNECTED_TIME
,
2472 sinfo
->connected_time
))
2473 goto nla_put_failure
;
2474 if ((sinfo
->filled
& STATION_INFO_INACTIVE_TIME
) &&
2475 nla_put_u32(msg
, NL80211_STA_INFO_INACTIVE_TIME
,
2476 sinfo
->inactive_time
))
2477 goto nla_put_failure
;
2478 if ((sinfo
->filled
& STATION_INFO_RX_BYTES
) &&
2479 nla_put_u32(msg
, NL80211_STA_INFO_RX_BYTES
,
2481 goto nla_put_failure
;
2482 if ((sinfo
->filled
& STATION_INFO_TX_BYTES
) &&
2483 nla_put_u32(msg
, NL80211_STA_INFO_TX_BYTES
,
2485 goto nla_put_failure
;
2486 if ((sinfo
->filled
& STATION_INFO_LLID
) &&
2487 nla_put_u16(msg
, NL80211_STA_INFO_LLID
, sinfo
->llid
))
2488 goto nla_put_failure
;
2489 if ((sinfo
->filled
& STATION_INFO_PLID
) &&
2490 nla_put_u16(msg
, NL80211_STA_INFO_PLID
, sinfo
->plid
))
2491 goto nla_put_failure
;
2492 if ((sinfo
->filled
& STATION_INFO_PLINK_STATE
) &&
2493 nla_put_u8(msg
, NL80211_STA_INFO_PLINK_STATE
,
2494 sinfo
->plink_state
))
2495 goto nla_put_failure
;
2496 switch (rdev
->wiphy
.signal_type
) {
2497 case CFG80211_SIGNAL_TYPE_MBM
:
2498 if ((sinfo
->filled
& STATION_INFO_SIGNAL
) &&
2499 nla_put_u8(msg
, NL80211_STA_INFO_SIGNAL
,
2501 goto nla_put_failure
;
2502 if ((sinfo
->filled
& STATION_INFO_SIGNAL_AVG
) &&
2503 nla_put_u8(msg
, NL80211_STA_INFO_SIGNAL_AVG
,
2505 goto nla_put_failure
;
2510 if (sinfo
->filled
& STATION_INFO_TX_BITRATE
) {
2511 if (!nl80211_put_sta_rate(msg
, &sinfo
->txrate
,
2512 NL80211_STA_INFO_TX_BITRATE
))
2513 goto nla_put_failure
;
2515 if (sinfo
->filled
& STATION_INFO_RX_BITRATE
) {
2516 if (!nl80211_put_sta_rate(msg
, &sinfo
->rxrate
,
2517 NL80211_STA_INFO_RX_BITRATE
))
2518 goto nla_put_failure
;
2520 if ((sinfo
->filled
& STATION_INFO_RX_PACKETS
) &&
2521 nla_put_u32(msg
, NL80211_STA_INFO_RX_PACKETS
,
2523 goto nla_put_failure
;
2524 if ((sinfo
->filled
& STATION_INFO_TX_PACKETS
) &&
2525 nla_put_u32(msg
, NL80211_STA_INFO_TX_PACKETS
,
2527 goto nla_put_failure
;
2528 if ((sinfo
->filled
& STATION_INFO_TX_RETRIES
) &&
2529 nla_put_u32(msg
, NL80211_STA_INFO_TX_RETRIES
,
2531 goto nla_put_failure
;
2532 if ((sinfo
->filled
& STATION_INFO_TX_FAILED
) &&
2533 nla_put_u32(msg
, NL80211_STA_INFO_TX_FAILED
,
2535 goto nla_put_failure
;
2536 if ((sinfo
->filled
& STATION_INFO_BEACON_LOSS_COUNT
) &&
2537 nla_put_u32(msg
, NL80211_STA_INFO_BEACON_LOSS
,
2538 sinfo
->beacon_loss_count
))
2539 goto nla_put_failure
;
2540 if (sinfo
->filled
& STATION_INFO_BSS_PARAM
) {
2541 bss_param
= nla_nest_start(msg
, NL80211_STA_INFO_BSS_PARAM
);
2543 goto nla_put_failure
;
2545 if (((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_CTS_PROT
) &&
2546 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_CTS_PROT
)) ||
2547 ((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_SHORT_PREAMBLE
) &&
2548 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE
)) ||
2549 ((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_SHORT_SLOT_TIME
) &&
2550 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME
)) ||
2551 nla_put_u8(msg
, NL80211_STA_BSS_PARAM_DTIM_PERIOD
,
2552 sinfo
->bss_param
.dtim_period
) ||
2553 nla_put_u16(msg
, NL80211_STA_BSS_PARAM_BEACON_INTERVAL
,
2554 sinfo
->bss_param
.beacon_interval
))
2555 goto nla_put_failure
;
2557 nla_nest_end(msg
, bss_param
);
2559 if ((sinfo
->filled
& STATION_INFO_STA_FLAGS
) &&
2560 nla_put(msg
, NL80211_STA_INFO_STA_FLAGS
,
2561 sizeof(struct nl80211_sta_flag_update
),
2563 goto nla_put_failure
;
2564 if ((sinfo
->filled
& STATION_INFO_T_OFFSET
) &&
2565 nla_put_u64(msg
, NL80211_STA_INFO_T_OFFSET
,
2567 goto nla_put_failure
;
2568 nla_nest_end(msg
, sinfoattr
);
2570 if ((sinfo
->filled
& STATION_INFO_ASSOC_REQ_IES
) &&
2571 nla_put(msg
, NL80211_ATTR_IE
, sinfo
->assoc_req_ies_len
,
2572 sinfo
->assoc_req_ies
))
2573 goto nla_put_failure
;
2575 return genlmsg_end(msg
, hdr
);
2578 genlmsg_cancel(msg
, hdr
);
2582 static int nl80211_dump_station(struct sk_buff
*skb
,
2583 struct netlink_callback
*cb
)
2585 struct station_info sinfo
;
2586 struct cfg80211_registered_device
*dev
;
2587 struct net_device
*netdev
;
2588 u8 mac_addr
[ETH_ALEN
];
2589 int sta_idx
= cb
->args
[1];
2592 err
= nl80211_prepare_netdev_dump(skb
, cb
, &dev
, &netdev
);
2596 if (!dev
->ops
->dump_station
) {
2602 memset(&sinfo
, 0, sizeof(sinfo
));
2603 err
= dev
->ops
->dump_station(&dev
->wiphy
, netdev
, sta_idx
,
2610 if (nl80211_send_station(skb
,
2611 NETLINK_CB(cb
->skb
).pid
,
2612 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
2613 dev
, netdev
, mac_addr
,
2622 cb
->args
[1] = sta_idx
;
2625 nl80211_finish_netdev_dump(dev
);
2630 static int nl80211_get_station(struct sk_buff
*skb
, struct genl_info
*info
)
2632 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2633 struct net_device
*dev
= info
->user_ptr
[1];
2634 struct station_info sinfo
;
2635 struct sk_buff
*msg
;
2636 u8
*mac_addr
= NULL
;
2639 memset(&sinfo
, 0, sizeof(sinfo
));
2641 if (!info
->attrs
[NL80211_ATTR_MAC
])
2644 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2646 if (!rdev
->ops
->get_station
)
2649 err
= rdev
->ops
->get_station(&rdev
->wiphy
, dev
, mac_addr
, &sinfo
);
2653 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2657 if (nl80211_send_station(msg
, info
->snd_pid
, info
->snd_seq
, 0,
2658 rdev
, dev
, mac_addr
, &sinfo
) < 0) {
2663 return genlmsg_reply(msg
, info
);
2667 * Get vlan interface making sure it is running and on the right wiphy.
2669 static struct net_device
*get_vlan(struct genl_info
*info
,
2670 struct cfg80211_registered_device
*rdev
)
2672 struct nlattr
*vlanattr
= info
->attrs
[NL80211_ATTR_STA_VLAN
];
2673 struct net_device
*v
;
2679 v
= dev_get_by_index(genl_info_net(info
), nla_get_u32(vlanattr
));
2681 return ERR_PTR(-ENODEV
);
2683 if (!v
->ieee80211_ptr
|| v
->ieee80211_ptr
->wiphy
!= &rdev
->wiphy
) {
2688 if (!netif_running(v
)) {
2696 return ERR_PTR(ret
);
2699 static int nl80211_set_station(struct sk_buff
*skb
, struct genl_info
*info
)
2701 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2703 struct net_device
*dev
= info
->user_ptr
[1];
2704 struct station_parameters params
;
2705 u8
*mac_addr
= NULL
;
2707 memset(¶ms
, 0, sizeof(params
));
2709 params
.listen_interval
= -1;
2710 params
.plink_state
= -1;
2712 if (info
->attrs
[NL80211_ATTR_STA_AID
])
2715 if (!info
->attrs
[NL80211_ATTR_MAC
])
2718 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2720 if (info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]) {
2721 params
.supported_rates
=
2722 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
2723 params
.supported_rates_len
=
2724 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
2727 if (info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
])
2728 params
.listen_interval
=
2729 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
]);
2731 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
])
2733 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]);
2735 if (!rdev
->ops
->change_station
)
2738 if (parse_station_flags(info
, dev
->ieee80211_ptr
->iftype
, ¶ms
))
2741 if (info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
])
2742 params
.plink_action
=
2743 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
]);
2745 if (info
->attrs
[NL80211_ATTR_STA_PLINK_STATE
])
2746 params
.plink_state
=
2747 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_STATE
]);
2749 switch (dev
->ieee80211_ptr
->iftype
) {
2750 case NL80211_IFTYPE_AP
:
2751 case NL80211_IFTYPE_AP_VLAN
:
2752 case NL80211_IFTYPE_P2P_GO
:
2753 /* disallow mesh-specific things */
2754 if (params
.plink_action
)
2757 /* TDLS can't be set, ... */
2758 if (params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
))
2761 * ... but don't bother the driver with it. This works around
2762 * a hostapd/wpa_supplicant issue -- it always includes the
2763 * TLDS_PEER flag in the mask even for AP mode.
2765 params
.sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
2767 /* accept only the listed bits */
2768 if (params
.sta_flags_mask
&
2769 ~(BIT(NL80211_STA_FLAG_AUTHORIZED
) |
2770 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE
) |
2771 BIT(NL80211_STA_FLAG_WME
) |
2772 BIT(NL80211_STA_FLAG_MFP
)))
2775 /* must be last in here for error handling */
2776 params
.vlan
= get_vlan(info
, rdev
);
2777 if (IS_ERR(params
.vlan
))
2778 return PTR_ERR(params
.vlan
);
2780 case NL80211_IFTYPE_P2P_CLIENT
:
2781 case NL80211_IFTYPE_STATION
:
2783 * Don't allow userspace to change the TDLS_PEER flag,
2784 * but silently ignore attempts to change it since we
2785 * don't have state here to verify that it doesn't try
2786 * to change the flag.
2788 params
.sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
2790 case NL80211_IFTYPE_ADHOC
:
2791 /* disallow things sta doesn't support */
2792 if (params
.plink_action
)
2796 if (params
.listen_interval
>= 0)
2798 /* reject any changes other than AUTHORIZED */
2799 if (params
.sta_flags_mask
& ~BIT(NL80211_STA_FLAG_AUTHORIZED
))
2802 case NL80211_IFTYPE_MESH_POINT
:
2803 /* disallow things mesh doesn't support */
2808 if (params
.listen_interval
>= 0)
2811 * No special handling for TDLS here -- the userspace
2812 * mesh code doesn't have this bug.
2814 if (params
.sta_flags_mask
&
2815 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
2816 BIT(NL80211_STA_FLAG_MFP
) |
2817 BIT(NL80211_STA_FLAG_AUTHORIZED
)))
2824 /* be aware of params.vlan when changing code here */
2826 err
= rdev
->ops
->change_station(&rdev
->wiphy
, dev
, mac_addr
, ¶ms
);
2829 dev_put(params
.vlan
);
2834 static struct nla_policy
2835 nl80211_sta_wme_policy
[NL80211_STA_WME_MAX
+ 1] __read_mostly
= {
2836 [NL80211_STA_WME_UAPSD_QUEUES
] = { .type
= NLA_U8
},
2837 [NL80211_STA_WME_MAX_SP
] = { .type
= NLA_U8
},
2840 static int nl80211_new_station(struct sk_buff
*skb
, struct genl_info
*info
)
2842 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2844 struct net_device
*dev
= info
->user_ptr
[1];
2845 struct station_parameters params
;
2846 u8
*mac_addr
= NULL
;
2848 memset(¶ms
, 0, sizeof(params
));
2850 if (!info
->attrs
[NL80211_ATTR_MAC
])
2853 if (!info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
])
2856 if (!info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
])
2859 if (!info
->attrs
[NL80211_ATTR_STA_AID
])
2862 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2863 params
.supported_rates
=
2864 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
2865 params
.supported_rates_len
=
2866 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
2867 params
.listen_interval
=
2868 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
]);
2870 params
.aid
= nla_get_u16(info
->attrs
[NL80211_ATTR_STA_AID
]);
2871 if (!params
.aid
|| params
.aid
> IEEE80211_MAX_AID
)
2874 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
])
2876 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]);
2878 if (info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
])
2879 params
.plink_action
=
2880 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
]);
2882 if (!rdev
->ops
->add_station
)
2885 if (parse_station_flags(info
, dev
->ieee80211_ptr
->iftype
, ¶ms
))
2888 switch (dev
->ieee80211_ptr
->iftype
) {
2889 case NL80211_IFTYPE_AP
:
2890 case NL80211_IFTYPE_AP_VLAN
:
2891 case NL80211_IFTYPE_P2P_GO
:
2892 /* parse WME attributes if sta is WME capable */
2893 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_AP_UAPSD
) &&
2894 (params
.sta_flags_set
& BIT(NL80211_STA_FLAG_WME
)) &&
2895 info
->attrs
[NL80211_ATTR_STA_WME
]) {
2896 struct nlattr
*tb
[NL80211_STA_WME_MAX
+ 1];
2899 nla
= info
->attrs
[NL80211_ATTR_STA_WME
];
2900 err
= nla_parse_nested(tb
, NL80211_STA_WME_MAX
, nla
,
2901 nl80211_sta_wme_policy
);
2905 if (tb
[NL80211_STA_WME_UAPSD_QUEUES
])
2906 params
.uapsd_queues
=
2907 nla_get_u8(tb
[NL80211_STA_WME_UAPSD_QUEUES
]);
2908 if (params
.uapsd_queues
&
2909 ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK
)
2912 if (tb
[NL80211_STA_WME_MAX_SP
])
2914 nla_get_u8(tb
[NL80211_STA_WME_MAX_SP
]);
2917 ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK
)
2920 params
.sta_modify_mask
|= STATION_PARAM_APPLY_UAPSD
;
2922 /* TDLS peers cannot be added */
2923 if (params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
))
2925 /* but don't bother the driver with it */
2926 params
.sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
2928 /* must be last in here for error handling */
2929 params
.vlan
= get_vlan(info
, rdev
);
2930 if (IS_ERR(params
.vlan
))
2931 return PTR_ERR(params
.vlan
);
2933 case NL80211_IFTYPE_MESH_POINT
:
2934 /* TDLS peers cannot be added */
2935 if (params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
))
2938 case NL80211_IFTYPE_STATION
:
2939 /* Only TDLS peers can be added */
2940 if (!(params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)))
2942 /* Can only add if TDLS ... */
2943 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
))
2945 /* ... with external setup is supported */
2946 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_TDLS_EXTERNAL_SETUP
))
2953 /* be aware of params.vlan when changing code here */
2955 err
= rdev
->ops
->add_station(&rdev
->wiphy
, dev
, mac_addr
, ¶ms
);
2958 dev_put(params
.vlan
);
2962 static int nl80211_del_station(struct sk_buff
*skb
, struct genl_info
*info
)
2964 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2965 struct net_device
*dev
= info
->user_ptr
[1];
2966 u8
*mac_addr
= NULL
;
2968 if (info
->attrs
[NL80211_ATTR_MAC
])
2969 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2971 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
2972 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP_VLAN
&&
2973 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
&&
2974 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
2977 if (!rdev
->ops
->del_station
)
2980 return rdev
->ops
->del_station(&rdev
->wiphy
, dev
, mac_addr
);
2983 static int nl80211_send_mpath(struct sk_buff
*msg
, u32 pid
, u32 seq
,
2984 int flags
, struct net_device
*dev
,
2985 u8
*dst
, u8
*next_hop
,
2986 struct mpath_info
*pinfo
)
2989 struct nlattr
*pinfoattr
;
2991 hdr
= nl80211hdr_put(msg
, pid
, seq
, flags
, NL80211_CMD_NEW_STATION
);
2995 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
2996 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, dst
) ||
2997 nla_put(msg
, NL80211_ATTR_MPATH_NEXT_HOP
, ETH_ALEN
, next_hop
) ||
2998 nla_put_u32(msg
, NL80211_ATTR_GENERATION
, pinfo
->generation
))
2999 goto nla_put_failure
;
3001 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_MPATH_INFO
);
3003 goto nla_put_failure
;
3004 if ((pinfo
->filled
& MPATH_INFO_FRAME_QLEN
) &&
3005 nla_put_u32(msg
, NL80211_MPATH_INFO_FRAME_QLEN
,
3007 goto nla_put_failure
;
3008 if (((pinfo
->filled
& MPATH_INFO_SN
) &&
3009 nla_put_u32(msg
, NL80211_MPATH_INFO_SN
, pinfo
->sn
)) ||
3010 ((pinfo
->filled
& MPATH_INFO_METRIC
) &&
3011 nla_put_u32(msg
, NL80211_MPATH_INFO_METRIC
,
3013 ((pinfo
->filled
& MPATH_INFO_EXPTIME
) &&
3014 nla_put_u32(msg
, NL80211_MPATH_INFO_EXPTIME
,
3016 ((pinfo
->filled
& MPATH_INFO_FLAGS
) &&
3017 nla_put_u8(msg
, NL80211_MPATH_INFO_FLAGS
,
3019 ((pinfo
->filled
& MPATH_INFO_DISCOVERY_TIMEOUT
) &&
3020 nla_put_u32(msg
, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT
,
3021 pinfo
->discovery_timeout
)) ||
3022 ((pinfo
->filled
& MPATH_INFO_DISCOVERY_RETRIES
) &&
3023 nla_put_u8(msg
, NL80211_MPATH_INFO_DISCOVERY_RETRIES
,
3024 pinfo
->discovery_retries
)))
3025 goto nla_put_failure
;
3027 nla_nest_end(msg
, pinfoattr
);
3029 return genlmsg_end(msg
, hdr
);
3032 genlmsg_cancel(msg
, hdr
);
3036 static int nl80211_dump_mpath(struct sk_buff
*skb
,
3037 struct netlink_callback
*cb
)
3039 struct mpath_info pinfo
;
3040 struct cfg80211_registered_device
*dev
;
3041 struct net_device
*netdev
;
3043 u8 next_hop
[ETH_ALEN
];
3044 int path_idx
= cb
->args
[1];
3047 err
= nl80211_prepare_netdev_dump(skb
, cb
, &dev
, &netdev
);
3051 if (!dev
->ops
->dump_mpath
) {
3056 if (netdev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
) {
3062 err
= dev
->ops
->dump_mpath(&dev
->wiphy
, netdev
, path_idx
,
3063 dst
, next_hop
, &pinfo
);
3069 if (nl80211_send_mpath(skb
, NETLINK_CB(cb
->skb
).pid
,
3070 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
3071 netdev
, dst
, next_hop
,
3080 cb
->args
[1] = path_idx
;
3083 nl80211_finish_netdev_dump(dev
);
3087 static int nl80211_get_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
3089 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3091 struct net_device
*dev
= info
->user_ptr
[1];
3092 struct mpath_info pinfo
;
3093 struct sk_buff
*msg
;
3095 u8 next_hop
[ETH_ALEN
];
3097 memset(&pinfo
, 0, sizeof(pinfo
));
3099 if (!info
->attrs
[NL80211_ATTR_MAC
])
3102 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
3104 if (!rdev
->ops
->get_mpath
)
3107 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
3110 err
= rdev
->ops
->get_mpath(&rdev
->wiphy
, dev
, dst
, next_hop
, &pinfo
);
3114 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3118 if (nl80211_send_mpath(msg
, info
->snd_pid
, info
->snd_seq
, 0,
3119 dev
, dst
, next_hop
, &pinfo
) < 0) {
3124 return genlmsg_reply(msg
, info
);
3127 static int nl80211_set_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
3129 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3130 struct net_device
*dev
= info
->user_ptr
[1];
3132 u8
*next_hop
= NULL
;
3134 if (!info
->attrs
[NL80211_ATTR_MAC
])
3137 if (!info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
])
3140 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
3141 next_hop
= nla_data(info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
]);
3143 if (!rdev
->ops
->change_mpath
)
3146 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
3149 return rdev
->ops
->change_mpath(&rdev
->wiphy
, dev
, dst
, next_hop
);
3152 static int nl80211_new_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
3154 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3155 struct net_device
*dev
= info
->user_ptr
[1];
3157 u8
*next_hop
= NULL
;
3159 if (!info
->attrs
[NL80211_ATTR_MAC
])
3162 if (!info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
])
3165 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
3166 next_hop
= nla_data(info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
]);
3168 if (!rdev
->ops
->add_mpath
)
3171 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
3174 return rdev
->ops
->add_mpath(&rdev
->wiphy
, dev
, dst
, next_hop
);
3177 static int nl80211_del_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
3179 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3180 struct net_device
*dev
= info
->user_ptr
[1];
3183 if (info
->attrs
[NL80211_ATTR_MAC
])
3184 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
3186 if (!rdev
->ops
->del_mpath
)
3189 return rdev
->ops
->del_mpath(&rdev
->wiphy
, dev
, dst
);
3192 static int nl80211_set_bss(struct sk_buff
*skb
, struct genl_info
*info
)
3194 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3195 struct net_device
*dev
= info
->user_ptr
[1];
3196 struct bss_parameters params
;
3198 memset(¶ms
, 0, sizeof(params
));
3199 /* default to not changing parameters */
3200 params
.use_cts_prot
= -1;
3201 params
.use_short_preamble
= -1;
3202 params
.use_short_slot_time
= -1;
3203 params
.ap_isolate
= -1;
3204 params
.ht_opmode
= -1;
3206 if (info
->attrs
[NL80211_ATTR_BSS_CTS_PROT
])
3207 params
.use_cts_prot
=
3208 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_CTS_PROT
]);
3209 if (info
->attrs
[NL80211_ATTR_BSS_SHORT_PREAMBLE
])
3210 params
.use_short_preamble
=
3211 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_SHORT_PREAMBLE
]);
3212 if (info
->attrs
[NL80211_ATTR_BSS_SHORT_SLOT_TIME
])
3213 params
.use_short_slot_time
=
3214 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_SHORT_SLOT_TIME
]);
3215 if (info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]) {
3216 params
.basic_rates
=
3217 nla_data(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
3218 params
.basic_rates_len
=
3219 nla_len(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
3221 if (info
->attrs
[NL80211_ATTR_AP_ISOLATE
])
3222 params
.ap_isolate
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_AP_ISOLATE
]);
3223 if (info
->attrs
[NL80211_ATTR_BSS_HT_OPMODE
])
3225 nla_get_u16(info
->attrs
[NL80211_ATTR_BSS_HT_OPMODE
]);
3227 if (!rdev
->ops
->change_bss
)
3230 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
3231 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
3234 return rdev
->ops
->change_bss(&rdev
->wiphy
, dev
, ¶ms
);
3237 static const struct nla_policy reg_rule_policy
[NL80211_REG_RULE_ATTR_MAX
+ 1] = {
3238 [NL80211_ATTR_REG_RULE_FLAGS
] = { .type
= NLA_U32
},
3239 [NL80211_ATTR_FREQ_RANGE_START
] = { .type
= NLA_U32
},
3240 [NL80211_ATTR_FREQ_RANGE_END
] = { .type
= NLA_U32
},
3241 [NL80211_ATTR_FREQ_RANGE_MAX_BW
] = { .type
= NLA_U32
},
3242 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
] = { .type
= NLA_U32
},
3243 [NL80211_ATTR_POWER_RULE_MAX_EIRP
] = { .type
= NLA_U32
},
3246 static int parse_reg_rule(struct nlattr
*tb
[],
3247 struct ieee80211_reg_rule
*reg_rule
)
3249 struct ieee80211_freq_range
*freq_range
= ®_rule
->freq_range
;
3250 struct ieee80211_power_rule
*power_rule
= ®_rule
->power_rule
;
3252 if (!tb
[NL80211_ATTR_REG_RULE_FLAGS
])
3254 if (!tb
[NL80211_ATTR_FREQ_RANGE_START
])
3256 if (!tb
[NL80211_ATTR_FREQ_RANGE_END
])
3258 if (!tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
])
3260 if (!tb
[NL80211_ATTR_POWER_RULE_MAX_EIRP
])
3263 reg_rule
->flags
= nla_get_u32(tb
[NL80211_ATTR_REG_RULE_FLAGS
]);
3265 freq_range
->start_freq_khz
=
3266 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_START
]);
3267 freq_range
->end_freq_khz
=
3268 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_END
]);
3269 freq_range
->max_bandwidth_khz
=
3270 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
]);
3272 power_rule
->max_eirp
=
3273 nla_get_u32(tb
[NL80211_ATTR_POWER_RULE_MAX_EIRP
]);
3275 if (tb
[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
])
3276 power_rule
->max_antenna_gain
=
3277 nla_get_u32(tb
[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
]);
3282 static int nl80211_req_set_reg(struct sk_buff
*skb
, struct genl_info
*info
)
3288 * You should only get this when cfg80211 hasn't yet initialized
3289 * completely when built-in to the kernel right between the time
3290 * window between nl80211_init() and regulatory_init(), if that is
3293 mutex_lock(&cfg80211_mutex
);
3294 if (unlikely(!cfg80211_regdomain
)) {
3295 mutex_unlock(&cfg80211_mutex
);
3296 return -EINPROGRESS
;
3298 mutex_unlock(&cfg80211_mutex
);
3300 if (!info
->attrs
[NL80211_ATTR_REG_ALPHA2
])
3303 data
= nla_data(info
->attrs
[NL80211_ATTR_REG_ALPHA2
]);
3305 r
= regulatory_hint_user(data
);
3310 static int nl80211_get_mesh_config(struct sk_buff
*skb
,
3311 struct genl_info
*info
)
3313 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3314 struct net_device
*dev
= info
->user_ptr
[1];
3315 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
3316 struct mesh_config cur_params
;
3319 struct nlattr
*pinfoattr
;
3320 struct sk_buff
*msg
;
3322 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
3325 if (!rdev
->ops
->get_mesh_config
)
3329 /* If not connected, get default parameters */
3330 if (!wdev
->mesh_id_len
)
3331 memcpy(&cur_params
, &default_mesh_config
, sizeof(cur_params
));
3333 err
= rdev
->ops
->get_mesh_config(&rdev
->wiphy
, dev
,
3340 /* Draw up a netlink message to send back */
3341 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3344 hdr
= nl80211hdr_put(msg
, info
->snd_pid
, info
->snd_seq
, 0,
3345 NL80211_CMD_GET_MESH_CONFIG
);
3348 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_MESH_CONFIG
);
3350 goto nla_put_failure
;
3351 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
3352 nla_put_u16(msg
, NL80211_MESHCONF_RETRY_TIMEOUT
,
3353 cur_params
.dot11MeshRetryTimeout
) ||
3354 nla_put_u16(msg
, NL80211_MESHCONF_CONFIRM_TIMEOUT
,
3355 cur_params
.dot11MeshConfirmTimeout
) ||
3356 nla_put_u16(msg
, NL80211_MESHCONF_HOLDING_TIMEOUT
,
3357 cur_params
.dot11MeshHoldingTimeout
) ||
3358 nla_put_u16(msg
, NL80211_MESHCONF_MAX_PEER_LINKS
,
3359 cur_params
.dot11MeshMaxPeerLinks
) ||
3360 nla_put_u8(msg
, NL80211_MESHCONF_MAX_RETRIES
,
3361 cur_params
.dot11MeshMaxRetries
) ||
3362 nla_put_u8(msg
, NL80211_MESHCONF_TTL
,
3363 cur_params
.dot11MeshTTL
) ||
3364 nla_put_u8(msg
, NL80211_MESHCONF_ELEMENT_TTL
,
3365 cur_params
.element_ttl
) ||
3366 nla_put_u8(msg
, NL80211_MESHCONF_AUTO_OPEN_PLINKS
,
3367 cur_params
.auto_open_plinks
) ||
3368 nla_put_u32(msg
, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
,
3369 cur_params
.dot11MeshNbrOffsetMaxNeighbor
) ||
3370 nla_put_u8(msg
, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
,
3371 cur_params
.dot11MeshHWMPmaxPREQretries
) ||
3372 nla_put_u32(msg
, NL80211_MESHCONF_PATH_REFRESH_TIME
,
3373 cur_params
.path_refresh_time
) ||
3374 nla_put_u16(msg
, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
,
3375 cur_params
.min_discovery_timeout
) ||
3376 nla_put_u32(msg
, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
,
3377 cur_params
.dot11MeshHWMPactivePathTimeout
) ||
3378 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
,
3379 cur_params
.dot11MeshHWMPpreqMinInterval
) ||
3380 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
,
3381 cur_params
.dot11MeshHWMPperrMinInterval
) ||
3382 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
,
3383 cur_params
.dot11MeshHWMPnetDiameterTraversalTime
) ||
3384 nla_put_u8(msg
, NL80211_MESHCONF_HWMP_ROOTMODE
,
3385 cur_params
.dot11MeshHWMPRootMode
) ||
3386 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_RANN_INTERVAL
,
3387 cur_params
.dot11MeshHWMPRannInterval
) ||
3388 nla_put_u8(msg
, NL80211_MESHCONF_GATE_ANNOUNCEMENTS
,
3389 cur_params
.dot11MeshGateAnnouncementProtocol
) ||
3390 nla_put_u8(msg
, NL80211_MESHCONF_FORWARDING
,
3391 cur_params
.dot11MeshForwarding
) ||
3392 nla_put_u32(msg
, NL80211_MESHCONF_RSSI_THRESHOLD
,
3393 cur_params
.rssi_threshold
) ||
3394 nla_put_u32(msg
, NL80211_MESHCONF_HT_OPMODE
,
3395 cur_params
.ht_opmode
))
3396 goto nla_put_failure
;
3397 nla_nest_end(msg
, pinfoattr
);
3398 genlmsg_end(msg
, hdr
);
3399 return genlmsg_reply(msg
, info
);
3402 genlmsg_cancel(msg
, hdr
);
3408 static const struct nla_policy nl80211_meshconf_params_policy
[NL80211_MESHCONF_ATTR_MAX
+1] = {
3409 [NL80211_MESHCONF_RETRY_TIMEOUT
] = { .type
= NLA_U16
},
3410 [NL80211_MESHCONF_CONFIRM_TIMEOUT
] = { .type
= NLA_U16
},
3411 [NL80211_MESHCONF_HOLDING_TIMEOUT
] = { .type
= NLA_U16
},
3412 [NL80211_MESHCONF_MAX_PEER_LINKS
] = { .type
= NLA_U16
},
3413 [NL80211_MESHCONF_MAX_RETRIES
] = { .type
= NLA_U8
},
3414 [NL80211_MESHCONF_TTL
] = { .type
= NLA_U8
},
3415 [NL80211_MESHCONF_ELEMENT_TTL
] = { .type
= NLA_U8
},
3416 [NL80211_MESHCONF_AUTO_OPEN_PLINKS
] = { .type
= NLA_U8
},
3417 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
] = { .type
= NLA_U32
},
3419 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
] = { .type
= NLA_U8
},
3420 [NL80211_MESHCONF_PATH_REFRESH_TIME
] = { .type
= NLA_U32
},
3421 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
] = { .type
= NLA_U16
},
3422 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
] = { .type
= NLA_U32
},
3423 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
] = { .type
= NLA_U16
},
3424 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
] = { .type
= NLA_U16
},
3425 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
] = { .type
= NLA_U16
},
3426 [NL80211_MESHCONF_HWMP_ROOTMODE
] = { .type
= NLA_U8
},
3427 [NL80211_MESHCONF_HWMP_RANN_INTERVAL
] = { .type
= NLA_U16
},
3428 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS
] = { .type
= NLA_U8
},
3429 [NL80211_MESHCONF_FORWARDING
] = { .type
= NLA_U8
},
3430 [NL80211_MESHCONF_RSSI_THRESHOLD
] = { .type
= NLA_U32
},
3431 [NL80211_MESHCONF_HT_OPMODE
] = { .type
= NLA_U16
},
3434 static const struct nla_policy
3435 nl80211_mesh_setup_params_policy
[NL80211_MESH_SETUP_ATTR_MAX
+1] = {
3436 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
] = { .type
= NLA_U8
},
3437 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
] = { .type
= NLA_U8
},
3438 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
] = { .type
= NLA_U8
},
3439 [NL80211_MESH_SETUP_USERSPACE_AUTH
] = { .type
= NLA_FLAG
},
3440 [NL80211_MESH_SETUP_IE
] = { .type
= NLA_BINARY
,
3441 .len
= IEEE80211_MAX_DATA_LEN
},
3442 [NL80211_MESH_SETUP_USERSPACE_AMPE
] = { .type
= NLA_FLAG
},
3445 static int nl80211_parse_mesh_config(struct genl_info
*info
,
3446 struct mesh_config
*cfg
,
3449 struct nlattr
*tb
[NL80211_MESHCONF_ATTR_MAX
+ 1];
3452 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
3454 if (table[attr_num]) {\
3455 cfg->param = nla_fn(table[attr_num]); \
3456 mask |= (1 << (attr_num - 1)); \
3461 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
3463 if (nla_parse_nested(tb
, NL80211_MESHCONF_ATTR_MAX
,
3464 info
->attrs
[NL80211_ATTR_MESH_CONFIG
],
3465 nl80211_meshconf_params_policy
))
3468 /* This makes sure that there aren't more than 32 mesh config
3469 * parameters (otherwise our bitfield scheme would not work.) */
3470 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX
> 32);
3472 /* Fill in the params struct */
3473 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshRetryTimeout
,
3474 mask
, NL80211_MESHCONF_RETRY_TIMEOUT
, nla_get_u16
);
3475 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshConfirmTimeout
,
3476 mask
, NL80211_MESHCONF_CONFIRM_TIMEOUT
, nla_get_u16
);
3477 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHoldingTimeout
,
3478 mask
, NL80211_MESHCONF_HOLDING_TIMEOUT
, nla_get_u16
);
3479 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshMaxPeerLinks
,
3480 mask
, NL80211_MESHCONF_MAX_PEER_LINKS
, nla_get_u16
);
3481 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshMaxRetries
,
3482 mask
, NL80211_MESHCONF_MAX_RETRIES
, nla_get_u8
);
3483 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshTTL
,
3484 mask
, NL80211_MESHCONF_TTL
, nla_get_u8
);
3485 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, element_ttl
,
3486 mask
, NL80211_MESHCONF_ELEMENT_TTL
, nla_get_u8
);
3487 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, auto_open_plinks
,
3488 mask
, NL80211_MESHCONF_AUTO_OPEN_PLINKS
, nla_get_u8
);
3489 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshNbrOffsetMaxNeighbor
,
3490 mask
, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
,
3492 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPmaxPREQretries
,
3493 mask
, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
,
3495 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, path_refresh_time
,
3496 mask
, NL80211_MESHCONF_PATH_REFRESH_TIME
, nla_get_u32
);
3497 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, min_discovery_timeout
,
3498 mask
, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
,
3500 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPactivePathTimeout
,
3501 mask
, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
,
3503 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPpreqMinInterval
,
3504 mask
, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
,
3506 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPperrMinInterval
,
3507 mask
, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
,
3509 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
3510 dot11MeshHWMPnetDiameterTraversalTime
,
3511 mask
, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
,
3513 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
3514 dot11MeshHWMPRootMode
, mask
,
3515 NL80211_MESHCONF_HWMP_ROOTMODE
,
3517 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
3518 dot11MeshHWMPRannInterval
, mask
,
3519 NL80211_MESHCONF_HWMP_RANN_INTERVAL
,
3521 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
3522 dot11MeshGateAnnouncementProtocol
, mask
,
3523 NL80211_MESHCONF_GATE_ANNOUNCEMENTS
,
3525 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshForwarding
,
3526 mask
, NL80211_MESHCONF_FORWARDING
, nla_get_u8
);
3527 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, rssi_threshold
,
3528 mask
, NL80211_MESHCONF_RSSI_THRESHOLD
, nla_get_u32
);
3529 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, ht_opmode
,
3530 mask
, NL80211_MESHCONF_HT_OPMODE
, nla_get_u16
);
3536 #undef FILL_IN_MESH_PARAM_IF_SET
3539 static int nl80211_parse_mesh_setup(struct genl_info
*info
,
3540 struct mesh_setup
*setup
)
3542 struct nlattr
*tb
[NL80211_MESH_SETUP_ATTR_MAX
+ 1];
3544 if (!info
->attrs
[NL80211_ATTR_MESH_SETUP
])
3546 if (nla_parse_nested(tb
, NL80211_MESH_SETUP_ATTR_MAX
,
3547 info
->attrs
[NL80211_ATTR_MESH_SETUP
],
3548 nl80211_mesh_setup_params_policy
))
3551 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
])
3552 setup
->sync_method
=
3553 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
])) ?
3554 IEEE80211_SYNC_METHOD_VENDOR
:
3555 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET
;
3557 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
])
3558 setup
->path_sel_proto
=
3559 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
])) ?
3560 IEEE80211_PATH_PROTOCOL_VENDOR
:
3561 IEEE80211_PATH_PROTOCOL_HWMP
;
3563 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
])
3564 setup
->path_metric
=
3565 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
])) ?
3566 IEEE80211_PATH_METRIC_VENDOR
:
3567 IEEE80211_PATH_METRIC_AIRTIME
;
3570 if (tb
[NL80211_MESH_SETUP_IE
]) {
3571 struct nlattr
*ieattr
=
3572 tb
[NL80211_MESH_SETUP_IE
];
3573 if (!is_valid_ie_attr(ieattr
))
3575 setup
->ie
= nla_data(ieattr
);
3576 setup
->ie_len
= nla_len(ieattr
);
3578 setup
->is_authenticated
= nla_get_flag(tb
[NL80211_MESH_SETUP_USERSPACE_AUTH
]);
3579 setup
->is_secure
= nla_get_flag(tb
[NL80211_MESH_SETUP_USERSPACE_AMPE
]);
3584 static int nl80211_update_mesh_config(struct sk_buff
*skb
,
3585 struct genl_info
*info
)
3587 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3588 struct net_device
*dev
= info
->user_ptr
[1];
3589 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
3590 struct mesh_config cfg
;
3594 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
3597 if (!rdev
->ops
->update_mesh_config
)
3600 err
= nl80211_parse_mesh_config(info
, &cfg
, &mask
);
3605 if (!wdev
->mesh_id_len
)
3609 err
= rdev
->ops
->update_mesh_config(&rdev
->wiphy
, dev
,
3617 static int nl80211_get_reg(struct sk_buff
*skb
, struct genl_info
*info
)
3619 struct sk_buff
*msg
;
3621 struct nlattr
*nl_reg_rules
;
3625 mutex_lock(&cfg80211_mutex
);
3627 if (!cfg80211_regdomain
)
3630 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3636 hdr
= nl80211hdr_put(msg
, info
->snd_pid
, info
->snd_seq
, 0,
3637 NL80211_CMD_GET_REG
);
3641 if (nla_put_string(msg
, NL80211_ATTR_REG_ALPHA2
,
3642 cfg80211_regdomain
->alpha2
) ||
3643 (cfg80211_regdomain
->dfs_region
&&
3644 nla_put_u8(msg
, NL80211_ATTR_DFS_REGION
,
3645 cfg80211_regdomain
->dfs_region
)))
3646 goto nla_put_failure
;
3648 nl_reg_rules
= nla_nest_start(msg
, NL80211_ATTR_REG_RULES
);
3650 goto nla_put_failure
;
3652 for (i
= 0; i
< cfg80211_regdomain
->n_reg_rules
; i
++) {
3653 struct nlattr
*nl_reg_rule
;
3654 const struct ieee80211_reg_rule
*reg_rule
;
3655 const struct ieee80211_freq_range
*freq_range
;
3656 const struct ieee80211_power_rule
*power_rule
;
3658 reg_rule
= &cfg80211_regdomain
->reg_rules
[i
];
3659 freq_range
= ®_rule
->freq_range
;
3660 power_rule
= ®_rule
->power_rule
;
3662 nl_reg_rule
= nla_nest_start(msg
, i
);
3664 goto nla_put_failure
;
3666 if (nla_put_u32(msg
, NL80211_ATTR_REG_RULE_FLAGS
,
3668 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_START
,
3669 freq_range
->start_freq_khz
) ||
3670 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_END
,
3671 freq_range
->end_freq_khz
) ||
3672 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_MAX_BW
,
3673 freq_range
->max_bandwidth_khz
) ||
3674 nla_put_u32(msg
, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
,
3675 power_rule
->max_antenna_gain
) ||
3676 nla_put_u32(msg
, NL80211_ATTR_POWER_RULE_MAX_EIRP
,
3677 power_rule
->max_eirp
))
3678 goto nla_put_failure
;
3680 nla_nest_end(msg
, nl_reg_rule
);
3683 nla_nest_end(msg
, nl_reg_rules
);
3685 genlmsg_end(msg
, hdr
);
3686 err
= genlmsg_reply(msg
, info
);
3690 genlmsg_cancel(msg
, hdr
);
3695 mutex_unlock(&cfg80211_mutex
);
3699 static int nl80211_set_reg(struct sk_buff
*skb
, struct genl_info
*info
)
3701 struct nlattr
*tb
[NL80211_REG_RULE_ATTR_MAX
+ 1];
3702 struct nlattr
*nl_reg_rule
;
3703 char *alpha2
= NULL
;
3704 int rem_reg_rules
= 0, r
= 0;
3705 u32 num_rules
= 0, rule_idx
= 0, size_of_regd
;
3707 struct ieee80211_regdomain
*rd
= NULL
;
3709 if (!info
->attrs
[NL80211_ATTR_REG_ALPHA2
])
3712 if (!info
->attrs
[NL80211_ATTR_REG_RULES
])
3715 alpha2
= nla_data(info
->attrs
[NL80211_ATTR_REG_ALPHA2
]);
3717 if (info
->attrs
[NL80211_ATTR_DFS_REGION
])
3718 dfs_region
= nla_get_u8(info
->attrs
[NL80211_ATTR_DFS_REGION
]);
3720 nla_for_each_nested(nl_reg_rule
, info
->attrs
[NL80211_ATTR_REG_RULES
],
3723 if (num_rules
> NL80211_MAX_SUPP_REG_RULES
)
3727 mutex_lock(&cfg80211_mutex
);
3729 if (!reg_is_valid_request(alpha2
)) {
3734 size_of_regd
= sizeof(struct ieee80211_regdomain
) +
3735 (num_rules
* sizeof(struct ieee80211_reg_rule
));
3737 rd
= kzalloc(size_of_regd
, GFP_KERNEL
);
3743 rd
->n_reg_rules
= num_rules
;
3744 rd
->alpha2
[0] = alpha2
[0];
3745 rd
->alpha2
[1] = alpha2
[1];
3748 * Disable DFS master mode if the DFS region was
3749 * not supported or known on this kernel.
3751 if (reg_supported_dfs_region(dfs_region
))
3752 rd
->dfs_region
= dfs_region
;
3754 nla_for_each_nested(nl_reg_rule
, info
->attrs
[NL80211_ATTR_REG_RULES
],
3756 nla_parse(tb
, NL80211_REG_RULE_ATTR_MAX
,
3757 nla_data(nl_reg_rule
), nla_len(nl_reg_rule
),
3759 r
= parse_reg_rule(tb
, &rd
->reg_rules
[rule_idx
]);
3765 if (rule_idx
> NL80211_MAX_SUPP_REG_RULES
) {
3771 BUG_ON(rule_idx
!= num_rules
);
3775 mutex_unlock(&cfg80211_mutex
);
3780 mutex_unlock(&cfg80211_mutex
);
3785 static int validate_scan_freqs(struct nlattr
*freqs
)
3787 struct nlattr
*attr1
, *attr2
;
3788 int n_channels
= 0, tmp1
, tmp2
;
3790 nla_for_each_nested(attr1
, freqs
, tmp1
) {
3793 * Some hardware has a limited channel list for
3794 * scanning, and it is pretty much nonsensical
3795 * to scan for a channel twice, so disallow that
3796 * and don't require drivers to check that the
3797 * channel list they get isn't longer than what
3798 * they can scan, as long as they can scan all
3799 * the channels they registered at once.
3801 nla_for_each_nested(attr2
, freqs
, tmp2
)
3802 if (attr1
!= attr2
&&
3803 nla_get_u32(attr1
) == nla_get_u32(attr2
))
3810 static int nl80211_trigger_scan(struct sk_buff
*skb
, struct genl_info
*info
)
3812 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3813 struct net_device
*dev
= info
->user_ptr
[1];
3814 struct cfg80211_scan_request
*request
;
3815 struct nlattr
*attr
;
3816 struct wiphy
*wiphy
;
3817 int err
, tmp
, n_ssids
= 0, n_channels
, i
;
3820 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
3823 wiphy
= &rdev
->wiphy
;
3825 if (!rdev
->ops
->scan
)
3831 if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
3832 n_channels
= validate_scan_freqs(
3833 info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]);
3837 enum ieee80211_band band
;
3840 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++)
3841 if (wiphy
->bands
[band
])
3842 n_channels
+= wiphy
->bands
[band
]->n_channels
;
3845 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
])
3846 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
], tmp
)
3849 if (n_ssids
> wiphy
->max_scan_ssids
)
3852 if (info
->attrs
[NL80211_ATTR_IE
])
3853 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
3857 if (ie_len
> wiphy
->max_scan_ie_len
)
3860 request
= kzalloc(sizeof(*request
)
3861 + sizeof(*request
->ssids
) * n_ssids
3862 + sizeof(*request
->channels
) * n_channels
3863 + ie_len
, GFP_KERNEL
);
3868 request
->ssids
= (void *)&request
->channels
[n_channels
];
3869 request
->n_ssids
= n_ssids
;
3872 request
->ie
= (void *)(request
->ssids
+ n_ssids
);
3874 request
->ie
= (void *)(request
->channels
+ n_channels
);
3878 if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
3879 /* user specified, bail out if channel not found */
3880 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
], tmp
) {
3881 struct ieee80211_channel
*chan
;
3883 chan
= ieee80211_get_channel(wiphy
, nla_get_u32(attr
));
3890 /* ignore disabled channels */
3891 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
3894 request
->channels
[i
] = chan
;
3898 enum ieee80211_band band
;
3901 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
3903 if (!wiphy
->bands
[band
])
3905 for (j
= 0; j
< wiphy
->bands
[band
]->n_channels
; j
++) {
3906 struct ieee80211_channel
*chan
;
3908 chan
= &wiphy
->bands
[band
]->channels
[j
];
3910 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
3913 request
->channels
[i
] = chan
;
3924 request
->n_channels
= i
;
3927 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
]) {
3928 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
], tmp
) {
3929 if (nla_len(attr
) > IEEE80211_MAX_SSID_LEN
) {
3933 request
->ssids
[i
].ssid_len
= nla_len(attr
);
3934 memcpy(request
->ssids
[i
].ssid
, nla_data(attr
), nla_len(attr
));
3939 if (info
->attrs
[NL80211_ATTR_IE
]) {
3940 request
->ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
3941 memcpy((void *)request
->ie
,
3942 nla_data(info
->attrs
[NL80211_ATTR_IE
]),
3946 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++)
3947 if (wiphy
->bands
[i
])
3949 (1 << wiphy
->bands
[i
]->n_bitrates
) - 1;
3951 if (info
->attrs
[NL80211_ATTR_SCAN_SUPP_RATES
]) {
3952 nla_for_each_nested(attr
,
3953 info
->attrs
[NL80211_ATTR_SCAN_SUPP_RATES
],
3955 enum ieee80211_band band
= nla_type(attr
);
3957 if (band
< 0 || band
>= IEEE80211_NUM_BANDS
) {
3961 err
= ieee80211_get_ratemask(wiphy
->bands
[band
],
3964 &request
->rates
[band
]);
3971 nla_get_flag(info
->attrs
[NL80211_ATTR_TX_NO_CCK_RATE
]);
3974 request
->wiphy
= &rdev
->wiphy
;
3976 rdev
->scan_req
= request
;
3977 err
= rdev
->ops
->scan(&rdev
->wiphy
, dev
, request
);
3980 nl80211_send_scan_start(rdev
, dev
);
3984 rdev
->scan_req
= NULL
;
3991 static int nl80211_start_sched_scan(struct sk_buff
*skb
,
3992 struct genl_info
*info
)
3994 struct cfg80211_sched_scan_request
*request
;
3995 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3996 struct net_device
*dev
= info
->user_ptr
[1];
3997 struct nlattr
*attr
;
3998 struct wiphy
*wiphy
;
3999 int err
, tmp
, n_ssids
= 0, n_match_sets
= 0, n_channels
, i
;
4001 enum ieee80211_band band
;
4003 struct nlattr
*tb
[NL80211_SCHED_SCAN_MATCH_ATTR_MAX
+ 1];
4005 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_SCHED_SCAN
) ||
4006 !rdev
->ops
->sched_scan_start
)
4009 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
4012 if (!info
->attrs
[NL80211_ATTR_SCHED_SCAN_INTERVAL
])
4015 interval
= nla_get_u32(info
->attrs
[NL80211_ATTR_SCHED_SCAN_INTERVAL
]);
4019 wiphy
= &rdev
->wiphy
;
4021 if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
4022 n_channels
= validate_scan_freqs(
4023 info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]);
4029 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++)
4030 if (wiphy
->bands
[band
])
4031 n_channels
+= wiphy
->bands
[band
]->n_channels
;
4034 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
])
4035 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
],
4039 if (n_ssids
> wiphy
->max_sched_scan_ssids
)
4042 if (info
->attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
])
4043 nla_for_each_nested(attr
,
4044 info
->attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
],
4048 if (n_match_sets
> wiphy
->max_match_sets
)
4051 if (info
->attrs
[NL80211_ATTR_IE
])
4052 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
4056 if (ie_len
> wiphy
->max_sched_scan_ie_len
)
4059 mutex_lock(&rdev
->sched_scan_mtx
);
4061 if (rdev
->sched_scan_req
) {
4066 request
= kzalloc(sizeof(*request
)
4067 + sizeof(*request
->ssids
) * n_ssids
4068 + sizeof(*request
->match_sets
) * n_match_sets
4069 + sizeof(*request
->channels
) * n_channels
4070 + ie_len
, GFP_KERNEL
);
4077 request
->ssids
= (void *)&request
->channels
[n_channels
];
4078 request
->n_ssids
= n_ssids
;
4081 request
->ie
= (void *)(request
->ssids
+ n_ssids
);
4083 request
->ie
= (void *)(request
->channels
+ n_channels
);
4088 request
->match_sets
= (void *)(request
->ie
+ ie_len
);
4089 else if (request
->ssids
)
4090 request
->match_sets
=
4091 (void *)(request
->ssids
+ n_ssids
);
4093 request
->match_sets
=
4094 (void *)(request
->channels
+ n_channels
);
4096 request
->n_match_sets
= n_match_sets
;
4099 if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
4100 /* user specified, bail out if channel not found */
4101 nla_for_each_nested(attr
,
4102 info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
],
4104 struct ieee80211_channel
*chan
;
4106 chan
= ieee80211_get_channel(wiphy
, nla_get_u32(attr
));
4113 /* ignore disabled channels */
4114 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
4117 request
->channels
[i
] = chan
;
4122 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
4124 if (!wiphy
->bands
[band
])
4126 for (j
= 0; j
< wiphy
->bands
[band
]->n_channels
; j
++) {
4127 struct ieee80211_channel
*chan
;
4129 chan
= &wiphy
->bands
[band
]->channels
[j
];
4131 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
4134 request
->channels
[i
] = chan
;
4145 request
->n_channels
= i
;
4148 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
]) {
4149 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
],
4151 if (nla_len(attr
) > IEEE80211_MAX_SSID_LEN
) {
4155 request
->ssids
[i
].ssid_len
= nla_len(attr
);
4156 memcpy(request
->ssids
[i
].ssid
, nla_data(attr
),
4163 if (info
->attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
]) {
4164 nla_for_each_nested(attr
,
4165 info
->attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
],
4167 struct nlattr
*ssid
;
4169 nla_parse(tb
, NL80211_SCHED_SCAN_MATCH_ATTR_MAX
,
4170 nla_data(attr
), nla_len(attr
),
4171 nl80211_match_policy
);
4172 ssid
= tb
[NL80211_ATTR_SCHED_SCAN_MATCH_SSID
];
4174 if (nla_len(ssid
) > IEEE80211_MAX_SSID_LEN
) {
4178 memcpy(request
->match_sets
[i
].ssid
.ssid
,
4179 nla_data(ssid
), nla_len(ssid
));
4180 request
->match_sets
[i
].ssid
.ssid_len
=
4187 if (info
->attrs
[NL80211_ATTR_IE
]) {
4188 request
->ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
4189 memcpy((void *)request
->ie
,
4190 nla_data(info
->attrs
[NL80211_ATTR_IE
]),
4195 request
->wiphy
= &rdev
->wiphy
;
4196 request
->interval
= interval
;
4198 err
= rdev
->ops
->sched_scan_start(&rdev
->wiphy
, dev
, request
);
4200 rdev
->sched_scan_req
= request
;
4201 nl80211_send_sched_scan(rdev
, dev
,
4202 NL80211_CMD_START_SCHED_SCAN
);
4209 mutex_unlock(&rdev
->sched_scan_mtx
);
4213 static int nl80211_stop_sched_scan(struct sk_buff
*skb
,
4214 struct genl_info
*info
)
4216 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4219 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_SCHED_SCAN
) ||
4220 !rdev
->ops
->sched_scan_stop
)
4223 mutex_lock(&rdev
->sched_scan_mtx
);
4224 err
= __cfg80211_stop_sched_scan(rdev
, false);
4225 mutex_unlock(&rdev
->sched_scan_mtx
);
4230 static int nl80211_send_bss(struct sk_buff
*msg
, struct netlink_callback
*cb
,
4232 struct cfg80211_registered_device
*rdev
,
4233 struct wireless_dev
*wdev
,
4234 struct cfg80211_internal_bss
*intbss
)
4236 struct cfg80211_bss
*res
= &intbss
->pub
;
4240 ASSERT_WDEV_LOCK(wdev
);
4242 hdr
= nl80211hdr_put(msg
, NETLINK_CB(cb
->skb
).pid
, seq
, flags
,
4243 NL80211_CMD_NEW_SCAN_RESULTS
);
4247 genl_dump_check_consistent(cb
, hdr
, &nl80211_fam
);
4249 if (nla_put_u32(msg
, NL80211_ATTR_GENERATION
, rdev
->bss_generation
) ||
4250 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, wdev
->netdev
->ifindex
))
4251 goto nla_put_failure
;
4253 bss
= nla_nest_start(msg
, NL80211_ATTR_BSS
);
4255 goto nla_put_failure
;
4256 if ((!is_zero_ether_addr(res
->bssid
) &&
4257 nla_put(msg
, NL80211_BSS_BSSID
, ETH_ALEN
, res
->bssid
)) ||
4258 (res
->information_elements
&& res
->len_information_elements
&&
4259 nla_put(msg
, NL80211_BSS_INFORMATION_ELEMENTS
,
4260 res
->len_information_elements
,
4261 res
->information_elements
)) ||
4262 (res
->beacon_ies
&& res
->len_beacon_ies
&&
4263 res
->beacon_ies
!= res
->information_elements
&&
4264 nla_put(msg
, NL80211_BSS_BEACON_IES
,
4265 res
->len_beacon_ies
, res
->beacon_ies
)))
4266 goto nla_put_failure
;
4268 nla_put_u64(msg
, NL80211_BSS_TSF
, res
->tsf
))
4269 goto nla_put_failure
;
4270 if (res
->beacon_interval
&&
4271 nla_put_u16(msg
, NL80211_BSS_BEACON_INTERVAL
, res
->beacon_interval
))
4272 goto nla_put_failure
;
4273 if (nla_put_u16(msg
, NL80211_BSS_CAPABILITY
, res
->capability
) ||
4274 nla_put_u32(msg
, NL80211_BSS_FREQUENCY
, res
->channel
->center_freq
) ||
4275 nla_put_u32(msg
, NL80211_BSS_SEEN_MS_AGO
,
4276 jiffies_to_msecs(jiffies
- intbss
->ts
)))
4277 goto nla_put_failure
;
4279 switch (rdev
->wiphy
.signal_type
) {
4280 case CFG80211_SIGNAL_TYPE_MBM
:
4281 if (nla_put_u32(msg
, NL80211_BSS_SIGNAL_MBM
, res
->signal
))
4282 goto nla_put_failure
;
4284 case CFG80211_SIGNAL_TYPE_UNSPEC
:
4285 if (nla_put_u8(msg
, NL80211_BSS_SIGNAL_UNSPEC
, res
->signal
))
4286 goto nla_put_failure
;
4292 switch (wdev
->iftype
) {
4293 case NL80211_IFTYPE_P2P_CLIENT
:
4294 case NL80211_IFTYPE_STATION
:
4295 if (intbss
== wdev
->current_bss
&&
4296 nla_put_u32(msg
, NL80211_BSS_STATUS
,
4297 NL80211_BSS_STATUS_ASSOCIATED
))
4298 goto nla_put_failure
;
4300 case NL80211_IFTYPE_ADHOC
:
4301 if (intbss
== wdev
->current_bss
&&
4302 nla_put_u32(msg
, NL80211_BSS_STATUS
,
4303 NL80211_BSS_STATUS_IBSS_JOINED
))
4304 goto nla_put_failure
;
4310 nla_nest_end(msg
, bss
);
4312 return genlmsg_end(msg
, hdr
);
4315 genlmsg_cancel(msg
, hdr
);
4319 static int nl80211_dump_scan(struct sk_buff
*skb
,
4320 struct netlink_callback
*cb
)
4322 struct cfg80211_registered_device
*rdev
;
4323 struct net_device
*dev
;
4324 struct cfg80211_internal_bss
*scan
;
4325 struct wireless_dev
*wdev
;
4326 int start
= cb
->args
[1], idx
= 0;
4329 err
= nl80211_prepare_netdev_dump(skb
, cb
, &rdev
, &dev
);
4333 wdev
= dev
->ieee80211_ptr
;
4336 spin_lock_bh(&rdev
->bss_lock
);
4337 cfg80211_bss_expire(rdev
);
4339 cb
->seq
= rdev
->bss_generation
;
4341 list_for_each_entry(scan
, &rdev
->bss_list
, list
) {
4344 if (nl80211_send_bss(skb
, cb
,
4345 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
4346 rdev
, wdev
, scan
) < 0) {
4352 spin_unlock_bh(&rdev
->bss_lock
);
4356 nl80211_finish_netdev_dump(rdev
);
4361 static int nl80211_send_survey(struct sk_buff
*msg
, u32 pid
, u32 seq
,
4362 int flags
, struct net_device
*dev
,
4363 struct survey_info
*survey
)
4366 struct nlattr
*infoattr
;
4368 hdr
= nl80211hdr_put(msg
, pid
, seq
, flags
,
4369 NL80211_CMD_NEW_SURVEY_RESULTS
);
4373 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
))
4374 goto nla_put_failure
;
4376 infoattr
= nla_nest_start(msg
, NL80211_ATTR_SURVEY_INFO
);
4378 goto nla_put_failure
;
4380 if (nla_put_u32(msg
, NL80211_SURVEY_INFO_FREQUENCY
,
4381 survey
->channel
->center_freq
))
4382 goto nla_put_failure
;
4384 if ((survey
->filled
& SURVEY_INFO_NOISE_DBM
) &&
4385 nla_put_u8(msg
, NL80211_SURVEY_INFO_NOISE
, survey
->noise
))
4386 goto nla_put_failure
;
4387 if ((survey
->filled
& SURVEY_INFO_IN_USE
) &&
4388 nla_put_flag(msg
, NL80211_SURVEY_INFO_IN_USE
))
4389 goto nla_put_failure
;
4390 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME
) &&
4391 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME
,
4392 survey
->channel_time
))
4393 goto nla_put_failure
;
4394 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME_BUSY
) &&
4395 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY
,
4396 survey
->channel_time_busy
))
4397 goto nla_put_failure
;
4398 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME_EXT_BUSY
) &&
4399 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY
,
4400 survey
->channel_time_ext_busy
))
4401 goto nla_put_failure
;
4402 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME_RX
) &&
4403 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME_RX
,
4404 survey
->channel_time_rx
))
4405 goto nla_put_failure
;
4406 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME_TX
) &&
4407 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME_TX
,
4408 survey
->channel_time_tx
))
4409 goto nla_put_failure
;
4411 nla_nest_end(msg
, infoattr
);
4413 return genlmsg_end(msg
, hdr
);
4416 genlmsg_cancel(msg
, hdr
);
4420 static int nl80211_dump_survey(struct sk_buff
*skb
,
4421 struct netlink_callback
*cb
)
4423 struct survey_info survey
;
4424 struct cfg80211_registered_device
*dev
;
4425 struct net_device
*netdev
;
4426 int survey_idx
= cb
->args
[1];
4429 res
= nl80211_prepare_netdev_dump(skb
, cb
, &dev
, &netdev
);
4433 if (!dev
->ops
->dump_survey
) {
4439 struct ieee80211_channel
*chan
;
4441 res
= dev
->ops
->dump_survey(&dev
->wiphy
, netdev
, survey_idx
,
4448 /* Survey without a channel doesn't make sense */
4449 if (!survey
.channel
) {
4454 chan
= ieee80211_get_channel(&dev
->wiphy
,
4455 survey
.channel
->center_freq
);
4456 if (!chan
|| chan
->flags
& IEEE80211_CHAN_DISABLED
) {
4461 if (nl80211_send_survey(skb
,
4462 NETLINK_CB(cb
->skb
).pid
,
4463 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
4471 cb
->args
[1] = survey_idx
;
4474 nl80211_finish_netdev_dump(dev
);
4478 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type
)
4480 return auth_type
<= NL80211_AUTHTYPE_MAX
;
4483 static bool nl80211_valid_wpa_versions(u32 wpa_versions
)
4485 return !(wpa_versions
& ~(NL80211_WPA_VERSION_1
|
4486 NL80211_WPA_VERSION_2
));
4489 static int nl80211_authenticate(struct sk_buff
*skb
, struct genl_info
*info
)
4491 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4492 struct net_device
*dev
= info
->user_ptr
[1];
4493 struct ieee80211_channel
*chan
;
4494 const u8
*bssid
, *ssid
, *ie
= NULL
;
4495 int err
, ssid_len
, ie_len
= 0;
4496 enum nl80211_auth_type auth_type
;
4497 struct key_parse key
;
4498 bool local_state_change
;
4500 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
4503 if (!info
->attrs
[NL80211_ATTR_MAC
])
4506 if (!info
->attrs
[NL80211_ATTR_AUTH_TYPE
])
4509 if (!info
->attrs
[NL80211_ATTR_SSID
])
4512 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
4515 err
= nl80211_parse_key(info
, &key
);
4520 if (key
.type
!= -1 && key
.type
!= NL80211_KEYTYPE_GROUP
)
4522 if (!key
.p
.key
|| !key
.p
.key_len
)
4524 if ((key
.p
.cipher
!= WLAN_CIPHER_SUITE_WEP40
||
4525 key
.p
.key_len
!= WLAN_KEY_LEN_WEP40
) &&
4526 (key
.p
.cipher
!= WLAN_CIPHER_SUITE_WEP104
||
4527 key
.p
.key_len
!= WLAN_KEY_LEN_WEP104
))
4539 for (i
= 0; i
< rdev
->wiphy
.n_cipher_suites
; i
++) {
4540 if (key
.p
.cipher
== rdev
->wiphy
.cipher_suites
[i
]) {
4549 if (!rdev
->ops
->auth
)
4552 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
4553 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
4556 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4557 chan
= ieee80211_get_channel(&rdev
->wiphy
,
4558 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
4559 if (!chan
|| (chan
->flags
& IEEE80211_CHAN_DISABLED
))
4562 ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
4563 ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
4565 if (info
->attrs
[NL80211_ATTR_IE
]) {
4566 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
4567 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
4570 auth_type
= nla_get_u32(info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
4571 if (!nl80211_valid_auth_type(auth_type
))
4574 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
4577 * Since we no longer track auth state, ignore
4578 * requests to only change local state.
4580 if (local_state_change
)
4583 return cfg80211_mlme_auth(rdev
, dev
, chan
, auth_type
, bssid
,
4584 ssid
, ssid_len
, ie
, ie_len
,
4585 key
.p
.key
, key
.p
.key_len
, key
.idx
);
4588 static int nl80211_crypto_settings(struct cfg80211_registered_device
*rdev
,
4589 struct genl_info
*info
,
4590 struct cfg80211_crypto_settings
*settings
,
4593 memset(settings
, 0, sizeof(*settings
));
4595 settings
->control_port
= info
->attrs
[NL80211_ATTR_CONTROL_PORT
];
4597 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_ETHERTYPE
]) {
4599 proto
= nla_get_u16(
4600 info
->attrs
[NL80211_ATTR_CONTROL_PORT_ETHERTYPE
]);
4601 settings
->control_port_ethertype
= cpu_to_be16(proto
);
4602 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_CONTROL_PORT_PROTOCOL
) &&
4605 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
])
4606 settings
->control_port_no_encrypt
= true;
4608 settings
->control_port_ethertype
= cpu_to_be16(ETH_P_PAE
);
4610 if (info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]) {
4614 data
= nla_data(info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]);
4615 len
= nla_len(info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]);
4616 settings
->n_ciphers_pairwise
= len
/ sizeof(u32
);
4618 if (len
% sizeof(u32
))
4621 if (settings
->n_ciphers_pairwise
> cipher_limit
)
4624 memcpy(settings
->ciphers_pairwise
, data
, len
);
4626 for (i
= 0; i
< settings
->n_ciphers_pairwise
; i
++)
4627 if (!cfg80211_supported_cipher_suite(
4629 settings
->ciphers_pairwise
[i
]))
4633 if (info
->attrs
[NL80211_ATTR_CIPHER_SUITE_GROUP
]) {
4634 settings
->cipher_group
=
4635 nla_get_u32(info
->attrs
[NL80211_ATTR_CIPHER_SUITE_GROUP
]);
4636 if (!cfg80211_supported_cipher_suite(&rdev
->wiphy
,
4637 settings
->cipher_group
))
4641 if (info
->attrs
[NL80211_ATTR_WPA_VERSIONS
]) {
4642 settings
->wpa_versions
=
4643 nla_get_u32(info
->attrs
[NL80211_ATTR_WPA_VERSIONS
]);
4644 if (!nl80211_valid_wpa_versions(settings
->wpa_versions
))
4648 if (info
->attrs
[NL80211_ATTR_AKM_SUITES
]) {
4652 data
= nla_data(info
->attrs
[NL80211_ATTR_AKM_SUITES
]);
4653 len
= nla_len(info
->attrs
[NL80211_ATTR_AKM_SUITES
]);
4654 settings
->n_akm_suites
= len
/ sizeof(u32
);
4656 if (len
% sizeof(u32
))
4659 if (settings
->n_akm_suites
> NL80211_MAX_NR_AKM_SUITES
)
4662 memcpy(settings
->akm_suites
, data
, len
);
4668 static int nl80211_associate(struct sk_buff
*skb
, struct genl_info
*info
)
4670 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4671 struct net_device
*dev
= info
->user_ptr
[1];
4672 struct cfg80211_crypto_settings crypto
;
4673 struct ieee80211_channel
*chan
;
4674 const u8
*bssid
, *ssid
, *ie
= NULL
, *prev_bssid
= NULL
;
4675 int err
, ssid_len
, ie_len
= 0;
4676 bool use_mfp
= false;
4678 struct ieee80211_ht_cap
*ht_capa
= NULL
;
4679 struct ieee80211_ht_cap
*ht_capa_mask
= NULL
;
4681 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
4684 if (!info
->attrs
[NL80211_ATTR_MAC
] ||
4685 !info
->attrs
[NL80211_ATTR_SSID
] ||
4686 !info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
4689 if (!rdev
->ops
->assoc
)
4692 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
4693 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
4696 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4698 chan
= ieee80211_get_channel(&rdev
->wiphy
,
4699 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
4700 if (!chan
|| (chan
->flags
& IEEE80211_CHAN_DISABLED
))
4703 ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
4704 ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
4706 if (info
->attrs
[NL80211_ATTR_IE
]) {
4707 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
4708 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
4711 if (info
->attrs
[NL80211_ATTR_USE_MFP
]) {
4712 enum nl80211_mfp mfp
=
4713 nla_get_u32(info
->attrs
[NL80211_ATTR_USE_MFP
]);
4714 if (mfp
== NL80211_MFP_REQUIRED
)
4716 else if (mfp
!= NL80211_MFP_NO
)
4720 if (info
->attrs
[NL80211_ATTR_PREV_BSSID
])
4721 prev_bssid
= nla_data(info
->attrs
[NL80211_ATTR_PREV_BSSID
]);
4723 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_HT
]))
4724 flags
|= ASSOC_REQ_DISABLE_HT
;
4726 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
4728 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]);
4730 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]) {
4733 ht_capa
= nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]);
4736 err
= nl80211_crypto_settings(rdev
, info
, &crypto
, 1);
4738 err
= cfg80211_mlme_assoc(rdev
, dev
, chan
, bssid
, prev_bssid
,
4739 ssid
, ssid_len
, ie
, ie_len
, use_mfp
,
4740 &crypto
, flags
, ht_capa
,
4746 static int nl80211_deauthenticate(struct sk_buff
*skb
, struct genl_info
*info
)
4748 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4749 struct net_device
*dev
= info
->user_ptr
[1];
4750 const u8
*ie
= NULL
, *bssid
;
4753 bool local_state_change
;
4755 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
4758 if (!info
->attrs
[NL80211_ATTR_MAC
])
4761 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
4764 if (!rdev
->ops
->deauth
)
4767 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
4768 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
4771 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4773 reason_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
4774 if (reason_code
== 0) {
4775 /* Reason Code 0 is reserved */
4779 if (info
->attrs
[NL80211_ATTR_IE
]) {
4780 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
4781 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
4784 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
4786 return cfg80211_mlme_deauth(rdev
, dev
, bssid
, ie
, ie_len
, reason_code
,
4787 local_state_change
);
4790 static int nl80211_disassociate(struct sk_buff
*skb
, struct genl_info
*info
)
4792 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4793 struct net_device
*dev
= info
->user_ptr
[1];
4794 const u8
*ie
= NULL
, *bssid
;
4797 bool local_state_change
;
4799 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
4802 if (!info
->attrs
[NL80211_ATTR_MAC
])
4805 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
4808 if (!rdev
->ops
->disassoc
)
4811 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
4812 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
4815 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4817 reason_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
4818 if (reason_code
== 0) {
4819 /* Reason Code 0 is reserved */
4823 if (info
->attrs
[NL80211_ATTR_IE
]) {
4824 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
4825 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
4828 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
4830 return cfg80211_mlme_disassoc(rdev
, dev
, bssid
, ie
, ie_len
, reason_code
,
4831 local_state_change
);
4835 nl80211_parse_mcast_rate(struct cfg80211_registered_device
*rdev
,
4836 int mcast_rate
[IEEE80211_NUM_BANDS
],
4839 struct wiphy
*wiphy
= &rdev
->wiphy
;
4843 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
4844 struct ieee80211_supported_band
*sband
;
4846 sband
= wiphy
->bands
[band
];
4850 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
4851 if (sband
->bitrates
[i
].bitrate
== rateval
) {
4852 mcast_rate
[band
] = i
+ 1;
4862 static int nl80211_join_ibss(struct sk_buff
*skb
, struct genl_info
*info
)
4864 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4865 struct net_device
*dev
= info
->user_ptr
[1];
4866 struct cfg80211_ibss_params ibss
;
4867 struct wiphy
*wiphy
;
4868 struct cfg80211_cached_keys
*connkeys
= NULL
;
4871 memset(&ibss
, 0, sizeof(ibss
));
4873 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
4876 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
] ||
4877 !info
->attrs
[NL80211_ATTR_SSID
] ||
4878 !nla_len(info
->attrs
[NL80211_ATTR_SSID
]))
4881 ibss
.beacon_interval
= 100;
4883 if (info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]) {
4884 ibss
.beacon_interval
=
4885 nla_get_u32(info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]);
4886 if (ibss
.beacon_interval
< 1 || ibss
.beacon_interval
> 10000)
4890 if (!rdev
->ops
->join_ibss
)
4893 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
)
4896 wiphy
= &rdev
->wiphy
;
4898 if (info
->attrs
[NL80211_ATTR_MAC
]) {
4899 ibss
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4901 if (!is_valid_ether_addr(ibss
.bssid
))
4904 ibss
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
4905 ibss
.ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
4907 if (info
->attrs
[NL80211_ATTR_IE
]) {
4908 ibss
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
4909 ibss
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
4912 if (info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]) {
4913 enum nl80211_channel_type channel_type
;
4915 channel_type
= nla_get_u32(
4916 info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]);
4917 if (channel_type
!= NL80211_CHAN_NO_HT
&&
4918 channel_type
!= NL80211_CHAN_HT20
&&
4919 channel_type
!= NL80211_CHAN_HT40MINUS
&&
4920 channel_type
!= NL80211_CHAN_HT40PLUS
)
4923 if (channel_type
!= NL80211_CHAN_NO_HT
&&
4924 !(wiphy
->features
& NL80211_FEATURE_HT_IBSS
))
4927 ibss
.channel_type
= channel_type
;
4929 ibss
.channel_type
= NL80211_CHAN_NO_HT
;
4932 ibss
.channel
= rdev_freq_to_chan(rdev
,
4933 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]),
4935 if (!ibss
.channel
||
4936 ibss
.channel
->flags
& IEEE80211_CHAN_NO_IBSS
||
4937 ibss
.channel
->flags
& IEEE80211_CHAN_DISABLED
)
4940 /* Both channels should be able to initiate communication */
4941 if ((ibss
.channel_type
== NL80211_CHAN_HT40PLUS
||
4942 ibss
.channel_type
== NL80211_CHAN_HT40MINUS
) &&
4943 !cfg80211_can_beacon_sec_chan(&rdev
->wiphy
, ibss
.channel
,
4947 ibss
.channel_fixed
= !!info
->attrs
[NL80211_ATTR_FREQ_FIXED
];
4948 ibss
.privacy
= !!info
->attrs
[NL80211_ATTR_PRIVACY
];
4950 if (info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]) {
4952 nla_data(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
4954 nla_len(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
4955 struct ieee80211_supported_band
*sband
=
4956 wiphy
->bands
[ibss
.channel
->band
];
4958 err
= ieee80211_get_ratemask(sband
, rates
, n_rates
,
4964 if (info
->attrs
[NL80211_ATTR_MCAST_RATE
] &&
4965 !nl80211_parse_mcast_rate(rdev
, ibss
.mcast_rate
,
4966 nla_get_u32(info
->attrs
[NL80211_ATTR_MCAST_RATE
])))
4969 if (ibss
.privacy
&& info
->attrs
[NL80211_ATTR_KEYS
]) {
4970 connkeys
= nl80211_parse_connkeys(rdev
,
4971 info
->attrs
[NL80211_ATTR_KEYS
]);
4972 if (IS_ERR(connkeys
))
4973 return PTR_ERR(connkeys
);
4977 nla_get_flag(info
->attrs
[NL80211_ATTR_CONTROL_PORT
]);
4979 err
= cfg80211_join_ibss(rdev
, dev
, &ibss
, connkeys
);
4985 static int nl80211_leave_ibss(struct sk_buff
*skb
, struct genl_info
*info
)
4987 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4988 struct net_device
*dev
= info
->user_ptr
[1];
4990 if (!rdev
->ops
->leave_ibss
)
4993 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
)
4996 return cfg80211_leave_ibss(rdev
, dev
, false);
4999 #ifdef CONFIG_NL80211_TESTMODE
5000 static struct genl_multicast_group nl80211_testmode_mcgrp
= {
5004 static int nl80211_testmode_do(struct sk_buff
*skb
, struct genl_info
*info
)
5006 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5009 if (!info
->attrs
[NL80211_ATTR_TESTDATA
])
5013 if (rdev
->ops
->testmode_cmd
) {
5014 rdev
->testmode_info
= info
;
5015 err
= rdev
->ops
->testmode_cmd(&rdev
->wiphy
,
5016 nla_data(info
->attrs
[NL80211_ATTR_TESTDATA
]),
5017 nla_len(info
->attrs
[NL80211_ATTR_TESTDATA
]));
5018 rdev
->testmode_info
= NULL
;
5024 static int nl80211_testmode_dump(struct sk_buff
*skb
,
5025 struct netlink_callback
*cb
)
5027 struct cfg80211_registered_device
*rdev
;
5035 * 0 is a valid index, but not valid for args[0],
5036 * so we need to offset by 1.
5038 phy_idx
= cb
->args
[0] - 1;
5040 err
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
5041 nl80211_fam
.attrbuf
, nl80211_fam
.maxattr
,
5045 if (nl80211_fam
.attrbuf
[NL80211_ATTR_WIPHY
]) {
5046 phy_idx
= nla_get_u32(
5047 nl80211_fam
.attrbuf
[NL80211_ATTR_WIPHY
]);
5049 struct net_device
*netdev
;
5051 err
= get_rdev_dev_by_ifindex(sock_net(skb
->sk
),
5052 nl80211_fam
.attrbuf
,
5057 phy_idx
= rdev
->wiphy_idx
;
5058 cfg80211_unlock_rdev(rdev
);
5060 if (nl80211_fam
.attrbuf
[NL80211_ATTR_TESTDATA
])
5062 (long)nl80211_fam
.attrbuf
[NL80211_ATTR_TESTDATA
];
5066 data
= nla_data((void *)cb
->args
[1]);
5067 data_len
= nla_len((void *)cb
->args
[1]);
5070 mutex_lock(&cfg80211_mutex
);
5071 rdev
= cfg80211_rdev_by_wiphy_idx(phy_idx
);
5073 mutex_unlock(&cfg80211_mutex
);
5076 cfg80211_lock_rdev(rdev
);
5077 mutex_unlock(&cfg80211_mutex
);
5079 if (!rdev
->ops
->testmode_dump
) {
5085 void *hdr
= nl80211hdr_put(skb
, NETLINK_CB(cb
->skb
).pid
,
5086 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
5087 NL80211_CMD_TESTMODE
);
5088 struct nlattr
*tmdata
;
5090 if (nla_put_u32(skb
, NL80211_ATTR_WIPHY
, phy_idx
)) {
5091 genlmsg_cancel(skb
, hdr
);
5095 tmdata
= nla_nest_start(skb
, NL80211_ATTR_TESTDATA
);
5097 genlmsg_cancel(skb
, hdr
);
5100 err
= rdev
->ops
->testmode_dump(&rdev
->wiphy
, skb
, cb
,
5102 nla_nest_end(skb
, tmdata
);
5104 if (err
== -ENOBUFS
|| err
== -ENOENT
) {
5105 genlmsg_cancel(skb
, hdr
);
5108 genlmsg_cancel(skb
, hdr
);
5112 genlmsg_end(skb
, hdr
);
5117 cb
->args
[0] = phy_idx
+ 1;
5119 cfg80211_unlock_rdev(rdev
);
5123 static struct sk_buff
*
5124 __cfg80211_testmode_alloc_skb(struct cfg80211_registered_device
*rdev
,
5125 int approxlen
, u32 pid
, u32 seq
, gfp_t gfp
)
5127 struct sk_buff
*skb
;
5129 struct nlattr
*data
;
5131 skb
= nlmsg_new(approxlen
+ 100, gfp
);
5135 hdr
= nl80211hdr_put(skb
, pid
, seq
, 0, NL80211_CMD_TESTMODE
);
5141 if (nla_put_u32(skb
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
))
5142 goto nla_put_failure
;
5143 data
= nla_nest_start(skb
, NL80211_ATTR_TESTDATA
);
5145 ((void **)skb
->cb
)[0] = rdev
;
5146 ((void **)skb
->cb
)[1] = hdr
;
5147 ((void **)skb
->cb
)[2] = data
;
5156 struct sk_buff
*cfg80211_testmode_alloc_reply_skb(struct wiphy
*wiphy
,
5159 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
5161 if (WARN_ON(!rdev
->testmode_info
))
5164 return __cfg80211_testmode_alloc_skb(rdev
, approxlen
,
5165 rdev
->testmode_info
->snd_pid
,
5166 rdev
->testmode_info
->snd_seq
,
5169 EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb
);
5171 int cfg80211_testmode_reply(struct sk_buff
*skb
)
5173 struct cfg80211_registered_device
*rdev
= ((void **)skb
->cb
)[0];
5174 void *hdr
= ((void **)skb
->cb
)[1];
5175 struct nlattr
*data
= ((void **)skb
->cb
)[2];
5177 if (WARN_ON(!rdev
->testmode_info
)) {
5182 nla_nest_end(skb
, data
);
5183 genlmsg_end(skb
, hdr
);
5184 return genlmsg_reply(skb
, rdev
->testmode_info
);
5186 EXPORT_SYMBOL(cfg80211_testmode_reply
);
5188 struct sk_buff
*cfg80211_testmode_alloc_event_skb(struct wiphy
*wiphy
,
5189 int approxlen
, gfp_t gfp
)
5191 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
5193 return __cfg80211_testmode_alloc_skb(rdev
, approxlen
, 0, 0, gfp
);
5195 EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb
);
5197 void cfg80211_testmode_event(struct sk_buff
*skb
, gfp_t gfp
)
5199 void *hdr
= ((void **)skb
->cb
)[1];
5200 struct nlattr
*data
= ((void **)skb
->cb
)[2];
5202 nla_nest_end(skb
, data
);
5203 genlmsg_end(skb
, hdr
);
5204 genlmsg_multicast(skb
, 0, nl80211_testmode_mcgrp
.id
, gfp
);
5206 EXPORT_SYMBOL(cfg80211_testmode_event
);
5209 static int nl80211_connect(struct sk_buff
*skb
, struct genl_info
*info
)
5211 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5212 struct net_device
*dev
= info
->user_ptr
[1];
5213 struct cfg80211_connect_params connect
;
5214 struct wiphy
*wiphy
;
5215 struct cfg80211_cached_keys
*connkeys
= NULL
;
5218 memset(&connect
, 0, sizeof(connect
));
5220 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
5223 if (!info
->attrs
[NL80211_ATTR_SSID
] ||
5224 !nla_len(info
->attrs
[NL80211_ATTR_SSID
]))
5227 if (info
->attrs
[NL80211_ATTR_AUTH_TYPE
]) {
5229 nla_get_u32(info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
5230 if (!nl80211_valid_auth_type(connect
.auth_type
))
5233 connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
5235 connect
.privacy
= info
->attrs
[NL80211_ATTR_PRIVACY
];
5237 err
= nl80211_crypto_settings(rdev
, info
, &connect
.crypto
,
5238 NL80211_MAX_NR_CIPHER_SUITES
);
5242 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
5243 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
5246 wiphy
= &rdev
->wiphy
;
5248 connect
.bg_scan_period
= -1;
5249 if (info
->attrs
[NL80211_ATTR_BG_SCAN_PERIOD
] &&
5250 (wiphy
->flags
& WIPHY_FLAG_SUPPORTS_FW_ROAM
)) {
5251 connect
.bg_scan_period
=
5252 nla_get_u16(info
->attrs
[NL80211_ATTR_BG_SCAN_PERIOD
]);
5255 if (info
->attrs
[NL80211_ATTR_MAC
])
5256 connect
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
5257 connect
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
5258 connect
.ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
5260 if (info
->attrs
[NL80211_ATTR_IE
]) {
5261 connect
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
5262 connect
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
5265 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
5267 ieee80211_get_channel(wiphy
,
5268 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
5269 if (!connect
.channel
||
5270 connect
.channel
->flags
& IEEE80211_CHAN_DISABLED
)
5274 if (connect
.privacy
&& info
->attrs
[NL80211_ATTR_KEYS
]) {
5275 connkeys
= nl80211_parse_connkeys(rdev
,
5276 info
->attrs
[NL80211_ATTR_KEYS
]);
5277 if (IS_ERR(connkeys
))
5278 return PTR_ERR(connkeys
);
5281 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_HT
]))
5282 connect
.flags
|= ASSOC_REQ_DISABLE_HT
;
5284 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
5285 memcpy(&connect
.ht_capa_mask
,
5286 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]),
5287 sizeof(connect
.ht_capa_mask
));
5289 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]) {
5290 if (!info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
5292 memcpy(&connect
.ht_capa
,
5293 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]),
5294 sizeof(connect
.ht_capa
));
5297 err
= cfg80211_connect(rdev
, dev
, &connect
, connkeys
);
5303 static int nl80211_disconnect(struct sk_buff
*skb
, struct genl_info
*info
)
5305 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5306 struct net_device
*dev
= info
->user_ptr
[1];
5309 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
5310 reason
= WLAN_REASON_DEAUTH_LEAVING
;
5312 reason
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
5317 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
5318 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
5321 return cfg80211_disconnect(rdev
, dev
, reason
, true);
5324 static int nl80211_wiphy_netns(struct sk_buff
*skb
, struct genl_info
*info
)
5326 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5331 if (!info
->attrs
[NL80211_ATTR_PID
])
5334 pid
= nla_get_u32(info
->attrs
[NL80211_ATTR_PID
]);
5336 net
= get_net_ns_by_pid(pid
);
5338 return PTR_ERR(net
);
5342 /* check if anything to do */
5343 if (!net_eq(wiphy_net(&rdev
->wiphy
), net
))
5344 err
= cfg80211_switch_netns(rdev
, net
);
5350 static int nl80211_setdel_pmksa(struct sk_buff
*skb
, struct genl_info
*info
)
5352 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5353 int (*rdev_ops
)(struct wiphy
*wiphy
, struct net_device
*dev
,
5354 struct cfg80211_pmksa
*pmksa
) = NULL
;
5355 struct net_device
*dev
= info
->user_ptr
[1];
5356 struct cfg80211_pmksa pmksa
;
5358 memset(&pmksa
, 0, sizeof(struct cfg80211_pmksa
));
5360 if (!info
->attrs
[NL80211_ATTR_MAC
])
5363 if (!info
->attrs
[NL80211_ATTR_PMKID
])
5366 pmksa
.pmkid
= nla_data(info
->attrs
[NL80211_ATTR_PMKID
]);
5367 pmksa
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
5369 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
5370 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
5373 switch (info
->genlhdr
->cmd
) {
5374 case NL80211_CMD_SET_PMKSA
:
5375 rdev_ops
= rdev
->ops
->set_pmksa
;
5377 case NL80211_CMD_DEL_PMKSA
:
5378 rdev_ops
= rdev
->ops
->del_pmksa
;
5388 return rdev_ops(&rdev
->wiphy
, dev
, &pmksa
);
5391 static int nl80211_flush_pmksa(struct sk_buff
*skb
, struct genl_info
*info
)
5393 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5394 struct net_device
*dev
= info
->user_ptr
[1];
5396 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
5397 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
5400 if (!rdev
->ops
->flush_pmksa
)
5403 return rdev
->ops
->flush_pmksa(&rdev
->wiphy
, dev
);
5406 static int nl80211_tdls_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
5408 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5409 struct net_device
*dev
= info
->user_ptr
[1];
5410 u8 action_code
, dialog_token
;
5414 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) ||
5415 !rdev
->ops
->tdls_mgmt
)
5418 if (!info
->attrs
[NL80211_ATTR_TDLS_ACTION
] ||
5419 !info
->attrs
[NL80211_ATTR_STATUS_CODE
] ||
5420 !info
->attrs
[NL80211_ATTR_TDLS_DIALOG_TOKEN
] ||
5421 !info
->attrs
[NL80211_ATTR_IE
] ||
5422 !info
->attrs
[NL80211_ATTR_MAC
])
5425 peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
5426 action_code
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_ACTION
]);
5427 status_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_STATUS_CODE
]);
5428 dialog_token
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_DIALOG_TOKEN
]);
5430 return rdev
->ops
->tdls_mgmt(&rdev
->wiphy
, dev
, peer
, action_code
,
5431 dialog_token
, status_code
,
5432 nla_data(info
->attrs
[NL80211_ATTR_IE
]),
5433 nla_len(info
->attrs
[NL80211_ATTR_IE
]));
5436 static int nl80211_tdls_oper(struct sk_buff
*skb
, struct genl_info
*info
)
5438 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5439 struct net_device
*dev
= info
->user_ptr
[1];
5440 enum nl80211_tdls_operation operation
;
5443 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) ||
5444 !rdev
->ops
->tdls_oper
)
5447 if (!info
->attrs
[NL80211_ATTR_TDLS_OPERATION
] ||
5448 !info
->attrs
[NL80211_ATTR_MAC
])
5451 operation
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_OPERATION
]);
5452 peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
5454 return rdev
->ops
->tdls_oper(&rdev
->wiphy
, dev
, peer
, operation
);
5457 static int nl80211_remain_on_channel(struct sk_buff
*skb
,
5458 struct genl_info
*info
)
5460 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5461 struct net_device
*dev
= info
->user_ptr
[1];
5462 struct ieee80211_channel
*chan
;
5463 struct sk_buff
*msg
;
5466 enum nl80211_channel_type channel_type
= NL80211_CHAN_NO_HT
;
5470 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
] ||
5471 !info
->attrs
[NL80211_ATTR_DURATION
])
5474 duration
= nla_get_u32(info
->attrs
[NL80211_ATTR_DURATION
]);
5477 * We should be on that channel for at least one jiffie,
5478 * and more than 5 seconds seems excessive.
5480 if (!duration
|| !msecs_to_jiffies(duration
) ||
5481 duration
> rdev
->wiphy
.max_remain_on_channel_duration
)
5484 if (!rdev
->ops
->remain_on_channel
||
5485 !(rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
))
5488 if (info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]) {
5489 channel_type
= nla_get_u32(
5490 info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]);
5491 if (channel_type
!= NL80211_CHAN_NO_HT
&&
5492 channel_type
!= NL80211_CHAN_HT20
&&
5493 channel_type
!= NL80211_CHAN_HT40PLUS
&&
5494 channel_type
!= NL80211_CHAN_HT40MINUS
)
5498 freq
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]);
5499 chan
= rdev_freq_to_chan(rdev
, freq
, channel_type
);
5503 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
5507 hdr
= nl80211hdr_put(msg
, info
->snd_pid
, info
->snd_seq
, 0,
5508 NL80211_CMD_REMAIN_ON_CHANNEL
);
5515 err
= rdev
->ops
->remain_on_channel(&rdev
->wiphy
, dev
, chan
,
5516 channel_type
, duration
, &cookie
);
5521 if (nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
))
5522 goto nla_put_failure
;
5524 genlmsg_end(msg
, hdr
);
5526 return genlmsg_reply(msg
, info
);
5535 static int nl80211_cancel_remain_on_channel(struct sk_buff
*skb
,
5536 struct genl_info
*info
)
5538 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5539 struct net_device
*dev
= info
->user_ptr
[1];
5542 if (!info
->attrs
[NL80211_ATTR_COOKIE
])
5545 if (!rdev
->ops
->cancel_remain_on_channel
)
5548 cookie
= nla_get_u64(info
->attrs
[NL80211_ATTR_COOKIE
]);
5550 return rdev
->ops
->cancel_remain_on_channel(&rdev
->wiphy
, dev
, cookie
);
5553 static u32
rateset_to_mask(struct ieee80211_supported_band
*sband
,
5554 u8
*rates
, u8 rates_len
)
5559 for (i
= 0; i
< rates_len
; i
++) {
5560 int rate
= (rates
[i
] & 0x7f) * 5;
5562 for (ridx
= 0; ridx
< sband
->n_bitrates
; ridx
++) {
5563 struct ieee80211_rate
*srate
=
5564 &sband
->bitrates
[ridx
];
5565 if (rate
== srate
->bitrate
) {
5570 if (ridx
== sband
->n_bitrates
)
5571 return 0; /* rate not found */
5577 static bool ht_rateset_to_mask(struct ieee80211_supported_band
*sband
,
5578 u8
*rates
, u8 rates_len
,
5579 u8 mcs
[IEEE80211_HT_MCS_MASK_LEN
])
5583 memset(mcs
, 0, IEEE80211_HT_MCS_MASK_LEN
);
5585 for (i
= 0; i
< rates_len
; i
++) {
5588 ridx
= rates
[i
] / 8;
5589 rbit
= BIT(rates
[i
] % 8);
5591 /* check validity */
5592 if ((ridx
< 0) || (ridx
>= IEEE80211_HT_MCS_MASK_LEN
))
5595 /* check availability */
5596 if (sband
->ht_cap
.mcs
.rx_mask
[ridx
] & rbit
)
5605 static const struct nla_policy nl80211_txattr_policy
[NL80211_TXRATE_MAX
+ 1] = {
5606 [NL80211_TXRATE_LEGACY
] = { .type
= NLA_BINARY
,
5607 .len
= NL80211_MAX_SUPP_RATES
},
5608 [NL80211_TXRATE_MCS
] = { .type
= NLA_BINARY
,
5609 .len
= NL80211_MAX_SUPP_HT_RATES
},
5612 static int nl80211_set_tx_bitrate_mask(struct sk_buff
*skb
,
5613 struct genl_info
*info
)
5615 struct nlattr
*tb
[NL80211_TXRATE_MAX
+ 1];
5616 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5617 struct cfg80211_bitrate_mask mask
;
5619 struct net_device
*dev
= info
->user_ptr
[1];
5620 struct nlattr
*tx_rates
;
5621 struct ieee80211_supported_band
*sband
;
5623 if (info
->attrs
[NL80211_ATTR_TX_RATES
] == NULL
)
5626 if (!rdev
->ops
->set_bitrate_mask
)
5629 memset(&mask
, 0, sizeof(mask
));
5630 /* Default to all rates enabled */
5631 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
5632 sband
= rdev
->wiphy
.bands
[i
];
5633 mask
.control
[i
].legacy
=
5634 sband
? (1 << sband
->n_bitrates
) - 1 : 0;
5636 memcpy(mask
.control
[i
].mcs
,
5637 sband
->ht_cap
.mcs
.rx_mask
,
5638 sizeof(mask
.control
[i
].mcs
));
5640 memset(mask
.control
[i
].mcs
, 0,
5641 sizeof(mask
.control
[i
].mcs
));
5645 * The nested attribute uses enum nl80211_band as the index. This maps
5646 * directly to the enum ieee80211_band values used in cfg80211.
5648 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES
> IEEE80211_HT_MCS_MASK_LEN
* 8);
5649 nla_for_each_nested(tx_rates
, info
->attrs
[NL80211_ATTR_TX_RATES
], rem
)
5651 enum ieee80211_band band
= nla_type(tx_rates
);
5652 if (band
< 0 || band
>= IEEE80211_NUM_BANDS
)
5654 sband
= rdev
->wiphy
.bands
[band
];
5657 nla_parse(tb
, NL80211_TXRATE_MAX
, nla_data(tx_rates
),
5658 nla_len(tx_rates
), nl80211_txattr_policy
);
5659 if (tb
[NL80211_TXRATE_LEGACY
]) {
5660 mask
.control
[band
].legacy
= rateset_to_mask(
5662 nla_data(tb
[NL80211_TXRATE_LEGACY
]),
5663 nla_len(tb
[NL80211_TXRATE_LEGACY
]));
5664 if ((mask
.control
[band
].legacy
== 0) &&
5665 nla_len(tb
[NL80211_TXRATE_LEGACY
]))
5668 if (tb
[NL80211_TXRATE_MCS
]) {
5669 if (!ht_rateset_to_mask(
5671 nla_data(tb
[NL80211_TXRATE_MCS
]),
5672 nla_len(tb
[NL80211_TXRATE_MCS
]),
5673 mask
.control
[band
].mcs
))
5677 if (mask
.control
[band
].legacy
== 0) {
5678 /* don't allow empty legacy rates if HT
5679 * is not even supported. */
5680 if (!rdev
->wiphy
.bands
[band
]->ht_cap
.ht_supported
)
5683 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++)
5684 if (mask
.control
[band
].mcs
[i
])
5687 /* legacy and mcs rates may not be both empty */
5688 if (i
== IEEE80211_HT_MCS_MASK_LEN
)
5693 return rdev
->ops
->set_bitrate_mask(&rdev
->wiphy
, dev
, NULL
, &mask
);
5696 static int nl80211_register_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
5698 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5699 struct net_device
*dev
= info
->user_ptr
[1];
5700 u16 frame_type
= IEEE80211_FTYPE_MGMT
| IEEE80211_STYPE_ACTION
;
5702 if (!info
->attrs
[NL80211_ATTR_FRAME_MATCH
])
5705 if (info
->attrs
[NL80211_ATTR_FRAME_TYPE
])
5706 frame_type
= nla_get_u16(info
->attrs
[NL80211_ATTR_FRAME_TYPE
]);
5708 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
5709 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
&&
5710 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
&&
5711 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
5712 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP_VLAN
&&
5713 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
&&
5714 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
5717 /* not much point in registering if we can't reply */
5718 if (!rdev
->ops
->mgmt_tx
)
5721 return cfg80211_mlme_register_mgmt(dev
->ieee80211_ptr
, info
->snd_pid
,
5723 nla_data(info
->attrs
[NL80211_ATTR_FRAME_MATCH
]),
5724 nla_len(info
->attrs
[NL80211_ATTR_FRAME_MATCH
]));
5727 static int nl80211_tx_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
5729 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5730 struct net_device
*dev
= info
->user_ptr
[1];
5731 struct ieee80211_channel
*chan
;
5732 enum nl80211_channel_type channel_type
= NL80211_CHAN_NO_HT
;
5733 bool channel_type_valid
= false;
5738 struct sk_buff
*msg
= NULL
;
5739 unsigned int wait
= 0;
5740 bool offchan
, no_cck
, dont_wait_for_ack
;
5742 dont_wait_for_ack
= info
->attrs
[NL80211_ATTR_DONT_WAIT_FOR_ACK
];
5744 if (!info
->attrs
[NL80211_ATTR_FRAME
] ||
5745 !info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
5748 if (!rdev
->ops
->mgmt_tx
)
5751 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
5752 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
&&
5753 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
&&
5754 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
5755 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP_VLAN
&&
5756 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
&&
5757 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
5760 if (info
->attrs
[NL80211_ATTR_DURATION
]) {
5761 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
))
5763 wait
= nla_get_u32(info
->attrs
[NL80211_ATTR_DURATION
]);
5766 if (info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]) {
5767 channel_type
= nla_get_u32(
5768 info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]);
5769 if (channel_type
!= NL80211_CHAN_NO_HT
&&
5770 channel_type
!= NL80211_CHAN_HT20
&&
5771 channel_type
!= NL80211_CHAN_HT40PLUS
&&
5772 channel_type
!= NL80211_CHAN_HT40MINUS
)
5774 channel_type_valid
= true;
5777 offchan
= info
->attrs
[NL80211_ATTR_OFFCHANNEL_TX_OK
];
5779 if (offchan
&& !(rdev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
))
5782 no_cck
= nla_get_flag(info
->attrs
[NL80211_ATTR_TX_NO_CCK_RATE
]);
5784 freq
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]);
5785 chan
= rdev_freq_to_chan(rdev
, freq
, channel_type
);
5789 if (!dont_wait_for_ack
) {
5790 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
5794 hdr
= nl80211hdr_put(msg
, info
->snd_pid
, info
->snd_seq
, 0,
5803 err
= cfg80211_mlme_mgmt_tx(rdev
, dev
, chan
, offchan
, channel_type
,
5804 channel_type_valid
, wait
,
5805 nla_data(info
->attrs
[NL80211_ATTR_FRAME
]),
5806 nla_len(info
->attrs
[NL80211_ATTR_FRAME
]),
5807 no_cck
, dont_wait_for_ack
, &cookie
);
5812 if (nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
))
5813 goto nla_put_failure
;
5815 genlmsg_end(msg
, hdr
);
5816 return genlmsg_reply(msg
, info
);
5828 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff
*skb
, struct genl_info
*info
)
5830 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5831 struct net_device
*dev
= info
->user_ptr
[1];
5834 if (!info
->attrs
[NL80211_ATTR_COOKIE
])
5837 if (!rdev
->ops
->mgmt_tx_cancel_wait
)
5840 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
5841 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
&&
5842 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
&&
5843 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
5844 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP_VLAN
&&
5845 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
5848 cookie
= nla_get_u64(info
->attrs
[NL80211_ATTR_COOKIE
]);
5850 return rdev
->ops
->mgmt_tx_cancel_wait(&rdev
->wiphy
, dev
, cookie
);
5853 static int nl80211_set_power_save(struct sk_buff
*skb
, struct genl_info
*info
)
5855 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5856 struct wireless_dev
*wdev
;
5857 struct net_device
*dev
= info
->user_ptr
[1];
5862 if (!info
->attrs
[NL80211_ATTR_PS_STATE
])
5865 ps_state
= nla_get_u32(info
->attrs
[NL80211_ATTR_PS_STATE
]);
5867 if (ps_state
!= NL80211_PS_DISABLED
&& ps_state
!= NL80211_PS_ENABLED
)
5870 wdev
= dev
->ieee80211_ptr
;
5872 if (!rdev
->ops
->set_power_mgmt
)
5875 state
= (ps_state
== NL80211_PS_ENABLED
) ? true : false;
5877 if (state
== wdev
->ps
)
5880 err
= rdev
->ops
->set_power_mgmt(wdev
->wiphy
, dev
, state
,
5887 static int nl80211_get_power_save(struct sk_buff
*skb
, struct genl_info
*info
)
5889 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5890 enum nl80211_ps_state ps_state
;
5891 struct wireless_dev
*wdev
;
5892 struct net_device
*dev
= info
->user_ptr
[1];
5893 struct sk_buff
*msg
;
5897 wdev
= dev
->ieee80211_ptr
;
5899 if (!rdev
->ops
->set_power_mgmt
)
5902 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
5906 hdr
= nl80211hdr_put(msg
, info
->snd_pid
, info
->snd_seq
, 0,
5907 NL80211_CMD_GET_POWER_SAVE
);
5914 ps_state
= NL80211_PS_ENABLED
;
5916 ps_state
= NL80211_PS_DISABLED
;
5918 if (nla_put_u32(msg
, NL80211_ATTR_PS_STATE
, ps_state
))
5919 goto nla_put_failure
;
5921 genlmsg_end(msg
, hdr
);
5922 return genlmsg_reply(msg
, info
);
5931 static struct nla_policy
5932 nl80211_attr_cqm_policy
[NL80211_ATTR_CQM_MAX
+ 1] __read_mostly
= {
5933 [NL80211_ATTR_CQM_RSSI_THOLD
] = { .type
= NLA_U32
},
5934 [NL80211_ATTR_CQM_RSSI_HYST
] = { .type
= NLA_U32
},
5935 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
] = { .type
= NLA_U32
},
5938 static int nl80211_set_cqm_rssi(struct genl_info
*info
,
5939 s32 threshold
, u32 hysteresis
)
5941 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5942 struct wireless_dev
*wdev
;
5943 struct net_device
*dev
= info
->user_ptr
[1];
5948 wdev
= dev
->ieee80211_ptr
;
5950 if (!rdev
->ops
->set_cqm_rssi_config
)
5953 if (wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
5954 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
5957 return rdev
->ops
->set_cqm_rssi_config(wdev
->wiphy
, dev
,
5958 threshold
, hysteresis
);
5961 static int nl80211_set_cqm(struct sk_buff
*skb
, struct genl_info
*info
)
5963 struct nlattr
*attrs
[NL80211_ATTR_CQM_MAX
+ 1];
5967 cqm
= info
->attrs
[NL80211_ATTR_CQM
];
5973 err
= nla_parse_nested(attrs
, NL80211_ATTR_CQM_MAX
, cqm
,
5974 nl80211_attr_cqm_policy
);
5978 if (attrs
[NL80211_ATTR_CQM_RSSI_THOLD
] &&
5979 attrs
[NL80211_ATTR_CQM_RSSI_HYST
]) {
5982 threshold
= nla_get_u32(attrs
[NL80211_ATTR_CQM_RSSI_THOLD
]);
5983 hysteresis
= nla_get_u32(attrs
[NL80211_ATTR_CQM_RSSI_HYST
]);
5984 err
= nl80211_set_cqm_rssi(info
, threshold
, hysteresis
);
5992 static int nl80211_join_mesh(struct sk_buff
*skb
, struct genl_info
*info
)
5994 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5995 struct net_device
*dev
= info
->user_ptr
[1];
5996 struct mesh_config cfg
;
5997 struct mesh_setup setup
;
6000 /* start with default */
6001 memcpy(&cfg
, &default_mesh_config
, sizeof(cfg
));
6002 memcpy(&setup
, &default_mesh_setup
, sizeof(setup
));
6004 if (info
->attrs
[NL80211_ATTR_MESH_CONFIG
]) {
6005 /* and parse parameters if given */
6006 err
= nl80211_parse_mesh_config(info
, &cfg
, NULL
);
6011 if (!info
->attrs
[NL80211_ATTR_MESH_ID
] ||
6012 !nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]))
6015 setup
.mesh_id
= nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]);
6016 setup
.mesh_id_len
= nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
6018 if (info
->attrs
[NL80211_ATTR_MCAST_RATE
] &&
6019 !nl80211_parse_mcast_rate(rdev
, setup
.mcast_rate
,
6020 nla_get_u32(info
->attrs
[NL80211_ATTR_MCAST_RATE
])))
6023 if (info
->attrs
[NL80211_ATTR_MESH_SETUP
]) {
6024 /* parse additional setup parameters if given */
6025 err
= nl80211_parse_mesh_setup(info
, &setup
);
6030 return cfg80211_join_mesh(rdev
, dev
, &setup
, &cfg
);
6033 static int nl80211_leave_mesh(struct sk_buff
*skb
, struct genl_info
*info
)
6035 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6036 struct net_device
*dev
= info
->user_ptr
[1];
6038 return cfg80211_leave_mesh(rdev
, dev
);
6041 static int nl80211_get_wowlan(struct sk_buff
*skb
, struct genl_info
*info
)
6043 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6044 struct sk_buff
*msg
;
6047 if (!rdev
->wiphy
.wowlan
.flags
&& !rdev
->wiphy
.wowlan
.n_patterns
)
6050 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
6054 hdr
= nl80211hdr_put(msg
, info
->snd_pid
, info
->snd_seq
, 0,
6055 NL80211_CMD_GET_WOWLAN
);
6057 goto nla_put_failure
;
6060 struct nlattr
*nl_wowlan
;
6062 nl_wowlan
= nla_nest_start(msg
, NL80211_ATTR_WOWLAN_TRIGGERS
);
6064 goto nla_put_failure
;
6066 if ((rdev
->wowlan
->any
&&
6067 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_ANY
)) ||
6068 (rdev
->wowlan
->disconnect
&&
6069 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_DISCONNECT
)) ||
6070 (rdev
->wowlan
->magic_pkt
&&
6071 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_MAGIC_PKT
)) ||
6072 (rdev
->wowlan
->gtk_rekey_failure
&&
6073 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
)) ||
6074 (rdev
->wowlan
->eap_identity_req
&&
6075 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
)) ||
6076 (rdev
->wowlan
->four_way_handshake
&&
6077 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
)) ||
6078 (rdev
->wowlan
->rfkill_release
&&
6079 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_RFKILL_RELEASE
)))
6080 goto nla_put_failure
;
6081 if (rdev
->wowlan
->n_patterns
) {
6082 struct nlattr
*nl_pats
, *nl_pat
;
6085 nl_pats
= nla_nest_start(msg
,
6086 NL80211_WOWLAN_TRIG_PKT_PATTERN
);
6088 goto nla_put_failure
;
6090 for (i
= 0; i
< rdev
->wowlan
->n_patterns
; i
++) {
6091 nl_pat
= nla_nest_start(msg
, i
+ 1);
6093 goto nla_put_failure
;
6094 pat_len
= rdev
->wowlan
->patterns
[i
].pattern_len
;
6095 if (nla_put(msg
, NL80211_WOWLAN_PKTPAT_MASK
,
6096 DIV_ROUND_UP(pat_len
, 8),
6097 rdev
->wowlan
->patterns
[i
].mask
) ||
6098 nla_put(msg
, NL80211_WOWLAN_PKTPAT_PATTERN
,
6100 rdev
->wowlan
->patterns
[i
].pattern
))
6101 goto nla_put_failure
;
6102 nla_nest_end(msg
, nl_pat
);
6104 nla_nest_end(msg
, nl_pats
);
6107 nla_nest_end(msg
, nl_wowlan
);
6110 genlmsg_end(msg
, hdr
);
6111 return genlmsg_reply(msg
, info
);
6118 static int nl80211_set_wowlan(struct sk_buff
*skb
, struct genl_info
*info
)
6120 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6121 struct nlattr
*tb
[NUM_NL80211_WOWLAN_TRIG
];
6122 struct cfg80211_wowlan no_triggers
= {};
6123 struct cfg80211_wowlan new_triggers
= {};
6124 struct wiphy_wowlan_support
*wowlan
= &rdev
->wiphy
.wowlan
;
6126 bool prev_enabled
= rdev
->wowlan
;
6128 if (!rdev
->wiphy
.wowlan
.flags
&& !rdev
->wiphy
.wowlan
.n_patterns
)
6131 if (!info
->attrs
[NL80211_ATTR_WOWLAN_TRIGGERS
])
6134 err
= nla_parse(tb
, MAX_NL80211_WOWLAN_TRIG
,
6135 nla_data(info
->attrs
[NL80211_ATTR_WOWLAN_TRIGGERS
]),
6136 nla_len(info
->attrs
[NL80211_ATTR_WOWLAN_TRIGGERS
]),
6137 nl80211_wowlan_policy
);
6141 if (tb
[NL80211_WOWLAN_TRIG_ANY
]) {
6142 if (!(wowlan
->flags
& WIPHY_WOWLAN_ANY
))
6144 new_triggers
.any
= true;
6147 if (tb
[NL80211_WOWLAN_TRIG_DISCONNECT
]) {
6148 if (!(wowlan
->flags
& WIPHY_WOWLAN_DISCONNECT
))
6150 new_triggers
.disconnect
= true;
6153 if (tb
[NL80211_WOWLAN_TRIG_MAGIC_PKT
]) {
6154 if (!(wowlan
->flags
& WIPHY_WOWLAN_MAGIC_PKT
))
6156 new_triggers
.magic_pkt
= true;
6159 if (tb
[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED
])
6162 if (tb
[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
]) {
6163 if (!(wowlan
->flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
))
6165 new_triggers
.gtk_rekey_failure
= true;
6168 if (tb
[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
]) {
6169 if (!(wowlan
->flags
& WIPHY_WOWLAN_EAP_IDENTITY_REQ
))
6171 new_triggers
.eap_identity_req
= true;
6174 if (tb
[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
]) {
6175 if (!(wowlan
->flags
& WIPHY_WOWLAN_4WAY_HANDSHAKE
))
6177 new_triggers
.four_way_handshake
= true;
6180 if (tb
[NL80211_WOWLAN_TRIG_RFKILL_RELEASE
]) {
6181 if (!(wowlan
->flags
& WIPHY_WOWLAN_RFKILL_RELEASE
))
6183 new_triggers
.rfkill_release
= true;
6186 if (tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
]) {
6189 int rem
, pat_len
, mask_len
;
6190 struct nlattr
*pat_tb
[NUM_NL80211_WOWLAN_PKTPAT
];
6192 nla_for_each_nested(pat
, tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
],
6195 if (n_patterns
> wowlan
->n_patterns
)
6198 new_triggers
.patterns
= kcalloc(n_patterns
,
6199 sizeof(new_triggers
.patterns
[0]),
6201 if (!new_triggers
.patterns
)
6204 new_triggers
.n_patterns
= n_patterns
;
6207 nla_for_each_nested(pat
, tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
],
6209 nla_parse(pat_tb
, MAX_NL80211_WOWLAN_PKTPAT
,
6210 nla_data(pat
), nla_len(pat
), NULL
);
6212 if (!pat_tb
[NL80211_WOWLAN_PKTPAT_MASK
] ||
6213 !pat_tb
[NL80211_WOWLAN_PKTPAT_PATTERN
])
6215 pat_len
= nla_len(pat_tb
[NL80211_WOWLAN_PKTPAT_PATTERN
]);
6216 mask_len
= DIV_ROUND_UP(pat_len
, 8);
6217 if (nla_len(pat_tb
[NL80211_WOWLAN_PKTPAT_MASK
]) !=
6220 if (pat_len
> wowlan
->pattern_max_len
||
6221 pat_len
< wowlan
->pattern_min_len
)
6224 new_triggers
.patterns
[i
].mask
=
6225 kmalloc(mask_len
+ pat_len
, GFP_KERNEL
);
6226 if (!new_triggers
.patterns
[i
].mask
) {
6230 new_triggers
.patterns
[i
].pattern
=
6231 new_triggers
.patterns
[i
].mask
+ mask_len
;
6232 memcpy(new_triggers
.patterns
[i
].mask
,
6233 nla_data(pat_tb
[NL80211_WOWLAN_PKTPAT_MASK
]),
6235 new_triggers
.patterns
[i
].pattern_len
= pat_len
;
6236 memcpy(new_triggers
.patterns
[i
].pattern
,
6237 nla_data(pat_tb
[NL80211_WOWLAN_PKTPAT_PATTERN
]),
6243 if (memcmp(&new_triggers
, &no_triggers
, sizeof(new_triggers
))) {
6244 struct cfg80211_wowlan
*ntrig
;
6245 ntrig
= kmemdup(&new_triggers
, sizeof(new_triggers
),
6251 cfg80211_rdev_free_wowlan(rdev
);
6252 rdev
->wowlan
= ntrig
;
6255 cfg80211_rdev_free_wowlan(rdev
);
6256 rdev
->wowlan
= NULL
;
6259 if (rdev
->ops
->set_wakeup
&& prev_enabled
!= !!rdev
->wowlan
)
6260 rdev
->ops
->set_wakeup(&rdev
->wiphy
, rdev
->wowlan
);
6264 for (i
= 0; i
< new_triggers
.n_patterns
; i
++)
6265 kfree(new_triggers
.patterns
[i
].mask
);
6266 kfree(new_triggers
.patterns
);
6270 static int nl80211_set_rekey_data(struct sk_buff
*skb
, struct genl_info
*info
)
6272 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6273 struct net_device
*dev
= info
->user_ptr
[1];
6274 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
6275 struct nlattr
*tb
[NUM_NL80211_REKEY_DATA
];
6276 struct cfg80211_gtk_rekey_data rekey_data
;
6279 if (!info
->attrs
[NL80211_ATTR_REKEY_DATA
])
6282 err
= nla_parse(tb
, MAX_NL80211_REKEY_DATA
,
6283 nla_data(info
->attrs
[NL80211_ATTR_REKEY_DATA
]),
6284 nla_len(info
->attrs
[NL80211_ATTR_REKEY_DATA
]),
6285 nl80211_rekey_policy
);
6289 if (nla_len(tb
[NL80211_REKEY_DATA_REPLAY_CTR
]) != NL80211_REPLAY_CTR_LEN
)
6291 if (nla_len(tb
[NL80211_REKEY_DATA_KEK
]) != NL80211_KEK_LEN
)
6293 if (nla_len(tb
[NL80211_REKEY_DATA_KCK
]) != NL80211_KCK_LEN
)
6296 memcpy(rekey_data
.kek
, nla_data(tb
[NL80211_REKEY_DATA_KEK
]),
6298 memcpy(rekey_data
.kck
, nla_data(tb
[NL80211_REKEY_DATA_KCK
]),
6300 memcpy(rekey_data
.replay_ctr
,
6301 nla_data(tb
[NL80211_REKEY_DATA_REPLAY_CTR
]),
6302 NL80211_REPLAY_CTR_LEN
);
6305 if (!wdev
->current_bss
) {
6310 if (!rdev
->ops
->set_rekey_data
) {
6315 err
= rdev
->ops
->set_rekey_data(&rdev
->wiphy
, dev
, &rekey_data
);
6321 static int nl80211_register_unexpected_frame(struct sk_buff
*skb
,
6322 struct genl_info
*info
)
6324 struct net_device
*dev
= info
->user_ptr
[1];
6325 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
6327 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
6328 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
6331 if (wdev
->ap_unexpected_nlpid
)
6334 wdev
->ap_unexpected_nlpid
= info
->snd_pid
;
6338 static int nl80211_probe_client(struct sk_buff
*skb
,
6339 struct genl_info
*info
)
6341 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6342 struct net_device
*dev
= info
->user_ptr
[1];
6343 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
6344 struct sk_buff
*msg
;
6350 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
6351 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
6354 if (!info
->attrs
[NL80211_ATTR_MAC
])
6357 if (!rdev
->ops
->probe_client
)
6360 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
6364 hdr
= nl80211hdr_put(msg
, info
->snd_pid
, info
->snd_seq
, 0,
6365 NL80211_CMD_PROBE_CLIENT
);
6372 addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6374 err
= rdev
->ops
->probe_client(&rdev
->wiphy
, dev
, addr
, &cookie
);
6378 if (nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
))
6379 goto nla_put_failure
;
6381 genlmsg_end(msg
, hdr
);
6383 return genlmsg_reply(msg
, info
);
6392 static int nl80211_register_beacons(struct sk_buff
*skb
, struct genl_info
*info
)
6394 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6396 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_REPORTS_OBSS
))
6399 if (rdev
->ap_beacons_nlpid
)
6402 rdev
->ap_beacons_nlpid
= info
->snd_pid
;
6407 #define NL80211_FLAG_NEED_WIPHY 0x01
6408 #define NL80211_FLAG_NEED_NETDEV 0x02
6409 #define NL80211_FLAG_NEED_RTNL 0x04
6410 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
6411 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
6412 NL80211_FLAG_CHECK_NETDEV_UP)
6414 static int nl80211_pre_doit(struct genl_ops
*ops
, struct sk_buff
*skb
,
6415 struct genl_info
*info
)
6417 struct cfg80211_registered_device
*rdev
;
6418 struct net_device
*dev
;
6420 bool rtnl
= ops
->internal_flags
& NL80211_FLAG_NEED_RTNL
;
6425 if (ops
->internal_flags
& NL80211_FLAG_NEED_WIPHY
) {
6426 rdev
= cfg80211_get_dev_from_info(info
);
6430 return PTR_ERR(rdev
);
6432 info
->user_ptr
[0] = rdev
;
6433 } else if (ops
->internal_flags
& NL80211_FLAG_NEED_NETDEV
) {
6434 err
= get_rdev_dev_by_ifindex(genl_info_net(info
), info
->attrs
,
6441 if (ops
->internal_flags
& NL80211_FLAG_CHECK_NETDEV_UP
&&
6442 !netif_running(dev
)) {
6443 cfg80211_unlock_rdev(rdev
);
6449 info
->user_ptr
[0] = rdev
;
6450 info
->user_ptr
[1] = dev
;
6456 static void nl80211_post_doit(struct genl_ops
*ops
, struct sk_buff
*skb
,
6457 struct genl_info
*info
)
6459 if (info
->user_ptr
[0])
6460 cfg80211_unlock_rdev(info
->user_ptr
[0]);
6461 if (info
->user_ptr
[1])
6462 dev_put(info
->user_ptr
[1]);
6463 if (ops
->internal_flags
& NL80211_FLAG_NEED_RTNL
)
6467 static struct genl_ops nl80211_ops
[] = {
6469 .cmd
= NL80211_CMD_GET_WIPHY
,
6470 .doit
= nl80211_get_wiphy
,
6471 .dumpit
= nl80211_dump_wiphy
,
6472 .policy
= nl80211_policy
,
6473 /* can be retrieved by unprivileged users */
6474 .internal_flags
= NL80211_FLAG_NEED_WIPHY
,
6477 .cmd
= NL80211_CMD_SET_WIPHY
,
6478 .doit
= nl80211_set_wiphy
,
6479 .policy
= nl80211_policy
,
6480 .flags
= GENL_ADMIN_PERM
,
6481 .internal_flags
= NL80211_FLAG_NEED_RTNL
,
6484 .cmd
= NL80211_CMD_GET_INTERFACE
,
6485 .doit
= nl80211_get_interface
,
6486 .dumpit
= nl80211_dump_interface
,
6487 .policy
= nl80211_policy
,
6488 /* can be retrieved by unprivileged users */
6489 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
6492 .cmd
= NL80211_CMD_SET_INTERFACE
,
6493 .doit
= nl80211_set_interface
,
6494 .policy
= nl80211_policy
,
6495 .flags
= GENL_ADMIN_PERM
,
6496 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6497 NL80211_FLAG_NEED_RTNL
,
6500 .cmd
= NL80211_CMD_NEW_INTERFACE
,
6501 .doit
= nl80211_new_interface
,
6502 .policy
= nl80211_policy
,
6503 .flags
= GENL_ADMIN_PERM
,
6504 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
6505 NL80211_FLAG_NEED_RTNL
,
6508 .cmd
= NL80211_CMD_DEL_INTERFACE
,
6509 .doit
= nl80211_del_interface
,
6510 .policy
= nl80211_policy
,
6511 .flags
= GENL_ADMIN_PERM
,
6512 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6513 NL80211_FLAG_NEED_RTNL
,
6516 .cmd
= NL80211_CMD_GET_KEY
,
6517 .doit
= nl80211_get_key
,
6518 .policy
= nl80211_policy
,
6519 .flags
= GENL_ADMIN_PERM
,
6520 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6521 NL80211_FLAG_NEED_RTNL
,
6524 .cmd
= NL80211_CMD_SET_KEY
,
6525 .doit
= nl80211_set_key
,
6526 .policy
= nl80211_policy
,
6527 .flags
= GENL_ADMIN_PERM
,
6528 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6529 NL80211_FLAG_NEED_RTNL
,
6532 .cmd
= NL80211_CMD_NEW_KEY
,
6533 .doit
= nl80211_new_key
,
6534 .policy
= nl80211_policy
,
6535 .flags
= GENL_ADMIN_PERM
,
6536 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6537 NL80211_FLAG_NEED_RTNL
,
6540 .cmd
= NL80211_CMD_DEL_KEY
,
6541 .doit
= nl80211_del_key
,
6542 .policy
= nl80211_policy
,
6543 .flags
= GENL_ADMIN_PERM
,
6544 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6545 NL80211_FLAG_NEED_RTNL
,
6548 .cmd
= NL80211_CMD_SET_BEACON
,
6549 .policy
= nl80211_policy
,
6550 .flags
= GENL_ADMIN_PERM
,
6551 .doit
= nl80211_set_beacon
,
6552 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6553 NL80211_FLAG_NEED_RTNL
,
6556 .cmd
= NL80211_CMD_START_AP
,
6557 .policy
= nl80211_policy
,
6558 .flags
= GENL_ADMIN_PERM
,
6559 .doit
= nl80211_start_ap
,
6560 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6561 NL80211_FLAG_NEED_RTNL
,
6564 .cmd
= NL80211_CMD_STOP_AP
,
6565 .policy
= nl80211_policy
,
6566 .flags
= GENL_ADMIN_PERM
,
6567 .doit
= nl80211_stop_ap
,
6568 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6569 NL80211_FLAG_NEED_RTNL
,
6572 .cmd
= NL80211_CMD_GET_STATION
,
6573 .doit
= nl80211_get_station
,
6574 .dumpit
= nl80211_dump_station
,
6575 .policy
= nl80211_policy
,
6576 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6577 NL80211_FLAG_NEED_RTNL
,
6580 .cmd
= NL80211_CMD_SET_STATION
,
6581 .doit
= nl80211_set_station
,
6582 .policy
= nl80211_policy
,
6583 .flags
= GENL_ADMIN_PERM
,
6584 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6585 NL80211_FLAG_NEED_RTNL
,
6588 .cmd
= NL80211_CMD_NEW_STATION
,
6589 .doit
= nl80211_new_station
,
6590 .policy
= nl80211_policy
,
6591 .flags
= GENL_ADMIN_PERM
,
6592 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6593 NL80211_FLAG_NEED_RTNL
,
6596 .cmd
= NL80211_CMD_DEL_STATION
,
6597 .doit
= nl80211_del_station
,
6598 .policy
= nl80211_policy
,
6599 .flags
= GENL_ADMIN_PERM
,
6600 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6601 NL80211_FLAG_NEED_RTNL
,
6604 .cmd
= NL80211_CMD_GET_MPATH
,
6605 .doit
= nl80211_get_mpath
,
6606 .dumpit
= nl80211_dump_mpath
,
6607 .policy
= nl80211_policy
,
6608 .flags
= GENL_ADMIN_PERM
,
6609 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6610 NL80211_FLAG_NEED_RTNL
,
6613 .cmd
= NL80211_CMD_SET_MPATH
,
6614 .doit
= nl80211_set_mpath
,
6615 .policy
= nl80211_policy
,
6616 .flags
= GENL_ADMIN_PERM
,
6617 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6618 NL80211_FLAG_NEED_RTNL
,
6621 .cmd
= NL80211_CMD_NEW_MPATH
,
6622 .doit
= nl80211_new_mpath
,
6623 .policy
= nl80211_policy
,
6624 .flags
= GENL_ADMIN_PERM
,
6625 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6626 NL80211_FLAG_NEED_RTNL
,
6629 .cmd
= NL80211_CMD_DEL_MPATH
,
6630 .doit
= nl80211_del_mpath
,
6631 .policy
= nl80211_policy
,
6632 .flags
= GENL_ADMIN_PERM
,
6633 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6634 NL80211_FLAG_NEED_RTNL
,
6637 .cmd
= NL80211_CMD_SET_BSS
,
6638 .doit
= nl80211_set_bss
,
6639 .policy
= nl80211_policy
,
6640 .flags
= GENL_ADMIN_PERM
,
6641 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6642 NL80211_FLAG_NEED_RTNL
,
6645 .cmd
= NL80211_CMD_GET_REG
,
6646 .doit
= nl80211_get_reg
,
6647 .policy
= nl80211_policy
,
6648 /* can be retrieved by unprivileged users */
6651 .cmd
= NL80211_CMD_SET_REG
,
6652 .doit
= nl80211_set_reg
,
6653 .policy
= nl80211_policy
,
6654 .flags
= GENL_ADMIN_PERM
,
6657 .cmd
= NL80211_CMD_REQ_SET_REG
,
6658 .doit
= nl80211_req_set_reg
,
6659 .policy
= nl80211_policy
,
6660 .flags
= GENL_ADMIN_PERM
,
6663 .cmd
= NL80211_CMD_GET_MESH_CONFIG
,
6664 .doit
= nl80211_get_mesh_config
,
6665 .policy
= nl80211_policy
,
6666 /* can be retrieved by unprivileged users */
6667 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6668 NL80211_FLAG_NEED_RTNL
,
6671 .cmd
= NL80211_CMD_SET_MESH_CONFIG
,
6672 .doit
= nl80211_update_mesh_config
,
6673 .policy
= nl80211_policy
,
6674 .flags
= GENL_ADMIN_PERM
,
6675 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6676 NL80211_FLAG_NEED_RTNL
,
6679 .cmd
= NL80211_CMD_TRIGGER_SCAN
,
6680 .doit
= nl80211_trigger_scan
,
6681 .policy
= nl80211_policy
,
6682 .flags
= GENL_ADMIN_PERM
,
6683 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6684 NL80211_FLAG_NEED_RTNL
,
6687 .cmd
= NL80211_CMD_GET_SCAN
,
6688 .policy
= nl80211_policy
,
6689 .dumpit
= nl80211_dump_scan
,
6692 .cmd
= NL80211_CMD_START_SCHED_SCAN
,
6693 .doit
= nl80211_start_sched_scan
,
6694 .policy
= nl80211_policy
,
6695 .flags
= GENL_ADMIN_PERM
,
6696 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6697 NL80211_FLAG_NEED_RTNL
,
6700 .cmd
= NL80211_CMD_STOP_SCHED_SCAN
,
6701 .doit
= nl80211_stop_sched_scan
,
6702 .policy
= nl80211_policy
,
6703 .flags
= GENL_ADMIN_PERM
,
6704 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6705 NL80211_FLAG_NEED_RTNL
,
6708 .cmd
= NL80211_CMD_AUTHENTICATE
,
6709 .doit
= nl80211_authenticate
,
6710 .policy
= nl80211_policy
,
6711 .flags
= GENL_ADMIN_PERM
,
6712 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6713 NL80211_FLAG_NEED_RTNL
,
6716 .cmd
= NL80211_CMD_ASSOCIATE
,
6717 .doit
= nl80211_associate
,
6718 .policy
= nl80211_policy
,
6719 .flags
= GENL_ADMIN_PERM
,
6720 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6721 NL80211_FLAG_NEED_RTNL
,
6724 .cmd
= NL80211_CMD_DEAUTHENTICATE
,
6725 .doit
= nl80211_deauthenticate
,
6726 .policy
= nl80211_policy
,
6727 .flags
= GENL_ADMIN_PERM
,
6728 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6729 NL80211_FLAG_NEED_RTNL
,
6732 .cmd
= NL80211_CMD_DISASSOCIATE
,
6733 .doit
= nl80211_disassociate
,
6734 .policy
= nl80211_policy
,
6735 .flags
= GENL_ADMIN_PERM
,
6736 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6737 NL80211_FLAG_NEED_RTNL
,
6740 .cmd
= NL80211_CMD_JOIN_IBSS
,
6741 .doit
= nl80211_join_ibss
,
6742 .policy
= nl80211_policy
,
6743 .flags
= GENL_ADMIN_PERM
,
6744 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6745 NL80211_FLAG_NEED_RTNL
,
6748 .cmd
= NL80211_CMD_LEAVE_IBSS
,
6749 .doit
= nl80211_leave_ibss
,
6750 .policy
= nl80211_policy
,
6751 .flags
= GENL_ADMIN_PERM
,
6752 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6753 NL80211_FLAG_NEED_RTNL
,
6755 #ifdef CONFIG_NL80211_TESTMODE
6757 .cmd
= NL80211_CMD_TESTMODE
,
6758 .doit
= nl80211_testmode_do
,
6759 .dumpit
= nl80211_testmode_dump
,
6760 .policy
= nl80211_policy
,
6761 .flags
= GENL_ADMIN_PERM
,
6762 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
6763 NL80211_FLAG_NEED_RTNL
,
6767 .cmd
= NL80211_CMD_CONNECT
,
6768 .doit
= nl80211_connect
,
6769 .policy
= nl80211_policy
,
6770 .flags
= GENL_ADMIN_PERM
,
6771 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6772 NL80211_FLAG_NEED_RTNL
,
6775 .cmd
= NL80211_CMD_DISCONNECT
,
6776 .doit
= nl80211_disconnect
,
6777 .policy
= nl80211_policy
,
6778 .flags
= GENL_ADMIN_PERM
,
6779 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6780 NL80211_FLAG_NEED_RTNL
,
6783 .cmd
= NL80211_CMD_SET_WIPHY_NETNS
,
6784 .doit
= nl80211_wiphy_netns
,
6785 .policy
= nl80211_policy
,
6786 .flags
= GENL_ADMIN_PERM
,
6787 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
6788 NL80211_FLAG_NEED_RTNL
,
6791 .cmd
= NL80211_CMD_GET_SURVEY
,
6792 .policy
= nl80211_policy
,
6793 .dumpit
= nl80211_dump_survey
,
6796 .cmd
= NL80211_CMD_SET_PMKSA
,
6797 .doit
= nl80211_setdel_pmksa
,
6798 .policy
= nl80211_policy
,
6799 .flags
= GENL_ADMIN_PERM
,
6800 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6801 NL80211_FLAG_NEED_RTNL
,
6804 .cmd
= NL80211_CMD_DEL_PMKSA
,
6805 .doit
= nl80211_setdel_pmksa
,
6806 .policy
= nl80211_policy
,
6807 .flags
= GENL_ADMIN_PERM
,
6808 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6809 NL80211_FLAG_NEED_RTNL
,
6812 .cmd
= NL80211_CMD_FLUSH_PMKSA
,
6813 .doit
= nl80211_flush_pmksa
,
6814 .policy
= nl80211_policy
,
6815 .flags
= GENL_ADMIN_PERM
,
6816 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6817 NL80211_FLAG_NEED_RTNL
,
6820 .cmd
= NL80211_CMD_REMAIN_ON_CHANNEL
,
6821 .doit
= nl80211_remain_on_channel
,
6822 .policy
= nl80211_policy
,
6823 .flags
= GENL_ADMIN_PERM
,
6824 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6825 NL80211_FLAG_NEED_RTNL
,
6828 .cmd
= NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
,
6829 .doit
= nl80211_cancel_remain_on_channel
,
6830 .policy
= nl80211_policy
,
6831 .flags
= GENL_ADMIN_PERM
,
6832 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6833 NL80211_FLAG_NEED_RTNL
,
6836 .cmd
= NL80211_CMD_SET_TX_BITRATE_MASK
,
6837 .doit
= nl80211_set_tx_bitrate_mask
,
6838 .policy
= nl80211_policy
,
6839 .flags
= GENL_ADMIN_PERM
,
6840 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6841 NL80211_FLAG_NEED_RTNL
,
6844 .cmd
= NL80211_CMD_REGISTER_FRAME
,
6845 .doit
= nl80211_register_mgmt
,
6846 .policy
= nl80211_policy
,
6847 .flags
= GENL_ADMIN_PERM
,
6848 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6849 NL80211_FLAG_NEED_RTNL
,
6852 .cmd
= NL80211_CMD_FRAME
,
6853 .doit
= nl80211_tx_mgmt
,
6854 .policy
= nl80211_policy
,
6855 .flags
= GENL_ADMIN_PERM
,
6856 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6857 NL80211_FLAG_NEED_RTNL
,
6860 .cmd
= NL80211_CMD_FRAME_WAIT_CANCEL
,
6861 .doit
= nl80211_tx_mgmt_cancel_wait
,
6862 .policy
= nl80211_policy
,
6863 .flags
= GENL_ADMIN_PERM
,
6864 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6865 NL80211_FLAG_NEED_RTNL
,
6868 .cmd
= NL80211_CMD_SET_POWER_SAVE
,
6869 .doit
= nl80211_set_power_save
,
6870 .policy
= nl80211_policy
,
6871 .flags
= GENL_ADMIN_PERM
,
6872 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6873 NL80211_FLAG_NEED_RTNL
,
6876 .cmd
= NL80211_CMD_GET_POWER_SAVE
,
6877 .doit
= nl80211_get_power_save
,
6878 .policy
= nl80211_policy
,
6879 /* can be retrieved by unprivileged users */
6880 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6881 NL80211_FLAG_NEED_RTNL
,
6884 .cmd
= NL80211_CMD_SET_CQM
,
6885 .doit
= nl80211_set_cqm
,
6886 .policy
= nl80211_policy
,
6887 .flags
= GENL_ADMIN_PERM
,
6888 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6889 NL80211_FLAG_NEED_RTNL
,
6892 .cmd
= NL80211_CMD_SET_CHANNEL
,
6893 .doit
= nl80211_set_channel
,
6894 .policy
= nl80211_policy
,
6895 .flags
= GENL_ADMIN_PERM
,
6896 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6897 NL80211_FLAG_NEED_RTNL
,
6900 .cmd
= NL80211_CMD_SET_WDS_PEER
,
6901 .doit
= nl80211_set_wds_peer
,
6902 .policy
= nl80211_policy
,
6903 .flags
= GENL_ADMIN_PERM
,
6904 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6905 NL80211_FLAG_NEED_RTNL
,
6908 .cmd
= NL80211_CMD_JOIN_MESH
,
6909 .doit
= nl80211_join_mesh
,
6910 .policy
= nl80211_policy
,
6911 .flags
= GENL_ADMIN_PERM
,
6912 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6913 NL80211_FLAG_NEED_RTNL
,
6916 .cmd
= NL80211_CMD_LEAVE_MESH
,
6917 .doit
= nl80211_leave_mesh
,
6918 .policy
= nl80211_policy
,
6919 .flags
= GENL_ADMIN_PERM
,
6920 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6921 NL80211_FLAG_NEED_RTNL
,
6924 .cmd
= NL80211_CMD_GET_WOWLAN
,
6925 .doit
= nl80211_get_wowlan
,
6926 .policy
= nl80211_policy
,
6927 /* can be retrieved by unprivileged users */
6928 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
6929 NL80211_FLAG_NEED_RTNL
,
6932 .cmd
= NL80211_CMD_SET_WOWLAN
,
6933 .doit
= nl80211_set_wowlan
,
6934 .policy
= nl80211_policy
,
6935 .flags
= GENL_ADMIN_PERM
,
6936 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
6937 NL80211_FLAG_NEED_RTNL
,
6940 .cmd
= NL80211_CMD_SET_REKEY_OFFLOAD
,
6941 .doit
= nl80211_set_rekey_data
,
6942 .policy
= nl80211_policy
,
6943 .flags
= GENL_ADMIN_PERM
,
6944 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6945 NL80211_FLAG_NEED_RTNL
,
6948 .cmd
= NL80211_CMD_TDLS_MGMT
,
6949 .doit
= nl80211_tdls_mgmt
,
6950 .policy
= nl80211_policy
,
6951 .flags
= GENL_ADMIN_PERM
,
6952 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6953 NL80211_FLAG_NEED_RTNL
,
6956 .cmd
= NL80211_CMD_TDLS_OPER
,
6957 .doit
= nl80211_tdls_oper
,
6958 .policy
= nl80211_policy
,
6959 .flags
= GENL_ADMIN_PERM
,
6960 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6961 NL80211_FLAG_NEED_RTNL
,
6964 .cmd
= NL80211_CMD_UNEXPECTED_FRAME
,
6965 .doit
= nl80211_register_unexpected_frame
,
6966 .policy
= nl80211_policy
,
6967 .flags
= GENL_ADMIN_PERM
,
6968 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6969 NL80211_FLAG_NEED_RTNL
,
6972 .cmd
= NL80211_CMD_PROBE_CLIENT
,
6973 .doit
= nl80211_probe_client
,
6974 .policy
= nl80211_policy
,
6975 .flags
= GENL_ADMIN_PERM
,
6976 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
6977 NL80211_FLAG_NEED_RTNL
,
6980 .cmd
= NL80211_CMD_REGISTER_BEACONS
,
6981 .doit
= nl80211_register_beacons
,
6982 .policy
= nl80211_policy
,
6983 .flags
= GENL_ADMIN_PERM
,
6984 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
6985 NL80211_FLAG_NEED_RTNL
,
6988 .cmd
= NL80211_CMD_SET_NOACK_MAP
,
6989 .doit
= nl80211_set_noack_map
,
6990 .policy
= nl80211_policy
,
6991 .flags
= GENL_ADMIN_PERM
,
6992 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
6993 NL80211_FLAG_NEED_RTNL
,
6998 static struct genl_multicast_group nl80211_mlme_mcgrp
= {
7002 /* multicast groups */
7003 static struct genl_multicast_group nl80211_config_mcgrp
= {
7006 static struct genl_multicast_group nl80211_scan_mcgrp
= {
7009 static struct genl_multicast_group nl80211_regulatory_mcgrp
= {
7010 .name
= "regulatory",
7013 /* notification functions */
7015 void nl80211_notify_dev_rename(struct cfg80211_registered_device
*rdev
)
7017 struct sk_buff
*msg
;
7019 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7023 if (nl80211_send_wiphy(msg
, 0, 0, 0, rdev
) < 0) {
7028 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7029 nl80211_config_mcgrp
.id
, GFP_KERNEL
);
7032 static int nl80211_add_scan_req(struct sk_buff
*msg
,
7033 struct cfg80211_registered_device
*rdev
)
7035 struct cfg80211_scan_request
*req
= rdev
->scan_req
;
7036 struct nlattr
*nest
;
7039 ASSERT_RDEV_LOCK(rdev
);
7044 nest
= nla_nest_start(msg
, NL80211_ATTR_SCAN_SSIDS
);
7046 goto nla_put_failure
;
7047 for (i
= 0; i
< req
->n_ssids
; i
++) {
7048 if (nla_put(msg
, i
, req
->ssids
[i
].ssid_len
, req
->ssids
[i
].ssid
))
7049 goto nla_put_failure
;
7051 nla_nest_end(msg
, nest
);
7053 nest
= nla_nest_start(msg
, NL80211_ATTR_SCAN_FREQUENCIES
);
7055 goto nla_put_failure
;
7056 for (i
= 0; i
< req
->n_channels
; i
++) {
7057 if (nla_put_u32(msg
, i
, req
->channels
[i
]->center_freq
))
7058 goto nla_put_failure
;
7060 nla_nest_end(msg
, nest
);
7063 nla_put(msg
, NL80211_ATTR_IE
, req
->ie_len
, req
->ie
))
7064 goto nla_put_failure
;
7071 static int nl80211_send_scan_msg(struct sk_buff
*msg
,
7072 struct cfg80211_registered_device
*rdev
,
7073 struct net_device
*netdev
,
7074 u32 pid
, u32 seq
, int flags
,
7079 hdr
= nl80211hdr_put(msg
, pid
, seq
, flags
, cmd
);
7083 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7084 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
7085 goto nla_put_failure
;
7087 /* ignore errors and send incomplete event anyway */
7088 nl80211_add_scan_req(msg
, rdev
);
7090 return genlmsg_end(msg
, hdr
);
7093 genlmsg_cancel(msg
, hdr
);
7098 nl80211_send_sched_scan_msg(struct sk_buff
*msg
,
7099 struct cfg80211_registered_device
*rdev
,
7100 struct net_device
*netdev
,
7101 u32 pid
, u32 seq
, int flags
, u32 cmd
)
7105 hdr
= nl80211hdr_put(msg
, pid
, seq
, flags
, cmd
);
7109 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7110 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
7111 goto nla_put_failure
;
7113 return genlmsg_end(msg
, hdr
);
7116 genlmsg_cancel(msg
, hdr
);
7120 void nl80211_send_scan_start(struct cfg80211_registered_device
*rdev
,
7121 struct net_device
*netdev
)
7123 struct sk_buff
*msg
;
7125 msg
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
7129 if (nl80211_send_scan_msg(msg
, rdev
, netdev
, 0, 0, 0,
7130 NL80211_CMD_TRIGGER_SCAN
) < 0) {
7135 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7136 nl80211_scan_mcgrp
.id
, GFP_KERNEL
);
7139 void nl80211_send_scan_done(struct cfg80211_registered_device
*rdev
,
7140 struct net_device
*netdev
)
7142 struct sk_buff
*msg
;
7144 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7148 if (nl80211_send_scan_msg(msg
, rdev
, netdev
, 0, 0, 0,
7149 NL80211_CMD_NEW_SCAN_RESULTS
) < 0) {
7154 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7155 nl80211_scan_mcgrp
.id
, GFP_KERNEL
);
7158 void nl80211_send_scan_aborted(struct cfg80211_registered_device
*rdev
,
7159 struct net_device
*netdev
)
7161 struct sk_buff
*msg
;
7163 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7167 if (nl80211_send_scan_msg(msg
, rdev
, netdev
, 0, 0, 0,
7168 NL80211_CMD_SCAN_ABORTED
) < 0) {
7173 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7174 nl80211_scan_mcgrp
.id
, GFP_KERNEL
);
7177 void nl80211_send_sched_scan_results(struct cfg80211_registered_device
*rdev
,
7178 struct net_device
*netdev
)
7180 struct sk_buff
*msg
;
7182 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7186 if (nl80211_send_sched_scan_msg(msg
, rdev
, netdev
, 0, 0, 0,
7187 NL80211_CMD_SCHED_SCAN_RESULTS
) < 0) {
7192 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7193 nl80211_scan_mcgrp
.id
, GFP_KERNEL
);
7196 void nl80211_send_sched_scan(struct cfg80211_registered_device
*rdev
,
7197 struct net_device
*netdev
, u32 cmd
)
7199 struct sk_buff
*msg
;
7201 msg
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
7205 if (nl80211_send_sched_scan_msg(msg
, rdev
, netdev
, 0, 0, 0, cmd
) < 0) {
7210 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7211 nl80211_scan_mcgrp
.id
, GFP_KERNEL
);
7215 * This can happen on global regulatory changes or device specific settings
7216 * based on custom world regulatory domains.
7218 void nl80211_send_reg_change_event(struct regulatory_request
*request
)
7220 struct sk_buff
*msg
;
7223 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7227 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_REG_CHANGE
);
7233 /* Userspace can always count this one always being set */
7234 if (nla_put_u8(msg
, NL80211_ATTR_REG_INITIATOR
, request
->initiator
))
7235 goto nla_put_failure
;
7237 if (request
->alpha2
[0] == '0' && request
->alpha2
[1] == '0') {
7238 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
7239 NL80211_REGDOM_TYPE_WORLD
))
7240 goto nla_put_failure
;
7241 } else if (request
->alpha2
[0] == '9' && request
->alpha2
[1] == '9') {
7242 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
7243 NL80211_REGDOM_TYPE_CUSTOM_WORLD
))
7244 goto nla_put_failure
;
7245 } else if ((request
->alpha2
[0] == '9' && request
->alpha2
[1] == '8') ||
7246 request
->intersect
) {
7247 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
7248 NL80211_REGDOM_TYPE_INTERSECTION
))
7249 goto nla_put_failure
;
7251 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
7252 NL80211_REGDOM_TYPE_COUNTRY
) ||
7253 nla_put_string(msg
, NL80211_ATTR_REG_ALPHA2
,
7255 goto nla_put_failure
;
7258 if (wiphy_idx_valid(request
->wiphy_idx
) &&
7259 nla_put_u32(msg
, NL80211_ATTR_WIPHY
, request
->wiphy_idx
))
7260 goto nla_put_failure
;
7262 genlmsg_end(msg
, hdr
);
7265 genlmsg_multicast_allns(msg
, 0, nl80211_regulatory_mcgrp
.id
,
7272 genlmsg_cancel(msg
, hdr
);
7276 static void nl80211_send_mlme_event(struct cfg80211_registered_device
*rdev
,
7277 struct net_device
*netdev
,
7278 const u8
*buf
, size_t len
,
7279 enum nl80211_commands cmd
, gfp_t gfp
)
7281 struct sk_buff
*msg
;
7284 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
7288 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
7294 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7295 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7296 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
))
7297 goto nla_put_failure
;
7299 genlmsg_end(msg
, hdr
);
7301 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7302 nl80211_mlme_mcgrp
.id
, gfp
);
7306 genlmsg_cancel(msg
, hdr
);
7310 void nl80211_send_rx_auth(struct cfg80211_registered_device
*rdev
,
7311 struct net_device
*netdev
, const u8
*buf
,
7312 size_t len
, gfp_t gfp
)
7314 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
7315 NL80211_CMD_AUTHENTICATE
, gfp
);
7318 void nl80211_send_rx_assoc(struct cfg80211_registered_device
*rdev
,
7319 struct net_device
*netdev
, const u8
*buf
,
7320 size_t len
, gfp_t gfp
)
7322 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
7323 NL80211_CMD_ASSOCIATE
, gfp
);
7326 void nl80211_send_deauth(struct cfg80211_registered_device
*rdev
,
7327 struct net_device
*netdev
, const u8
*buf
,
7328 size_t len
, gfp_t gfp
)
7330 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
7331 NL80211_CMD_DEAUTHENTICATE
, gfp
);
7334 void nl80211_send_disassoc(struct cfg80211_registered_device
*rdev
,
7335 struct net_device
*netdev
, const u8
*buf
,
7336 size_t len
, gfp_t gfp
)
7338 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
7339 NL80211_CMD_DISASSOCIATE
, gfp
);
7342 void nl80211_send_unprot_deauth(struct cfg80211_registered_device
*rdev
,
7343 struct net_device
*netdev
, const u8
*buf
,
7344 size_t len
, gfp_t gfp
)
7346 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
7347 NL80211_CMD_UNPROT_DEAUTHENTICATE
, gfp
);
7350 void nl80211_send_unprot_disassoc(struct cfg80211_registered_device
*rdev
,
7351 struct net_device
*netdev
, const u8
*buf
,
7352 size_t len
, gfp_t gfp
)
7354 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
7355 NL80211_CMD_UNPROT_DISASSOCIATE
, gfp
);
7358 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device
*rdev
,
7359 struct net_device
*netdev
, int cmd
,
7360 const u8
*addr
, gfp_t gfp
)
7362 struct sk_buff
*msg
;
7365 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
7369 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
7375 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7376 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7377 nla_put_flag(msg
, NL80211_ATTR_TIMED_OUT
) ||
7378 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
))
7379 goto nla_put_failure
;
7381 genlmsg_end(msg
, hdr
);
7383 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7384 nl80211_mlme_mcgrp
.id
, gfp
);
7388 genlmsg_cancel(msg
, hdr
);
7392 void nl80211_send_auth_timeout(struct cfg80211_registered_device
*rdev
,
7393 struct net_device
*netdev
, const u8
*addr
,
7396 nl80211_send_mlme_timeout(rdev
, netdev
, NL80211_CMD_AUTHENTICATE
,
7400 void nl80211_send_assoc_timeout(struct cfg80211_registered_device
*rdev
,
7401 struct net_device
*netdev
, const u8
*addr
,
7404 nl80211_send_mlme_timeout(rdev
, netdev
, NL80211_CMD_ASSOCIATE
,
7408 void nl80211_send_connect_result(struct cfg80211_registered_device
*rdev
,
7409 struct net_device
*netdev
, const u8
*bssid
,
7410 const u8
*req_ie
, size_t req_ie_len
,
7411 const u8
*resp_ie
, size_t resp_ie_len
,
7412 u16 status
, gfp_t gfp
)
7414 struct sk_buff
*msg
;
7417 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
7421 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CONNECT
);
7427 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7428 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7429 (bssid
&& nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
)) ||
7430 nla_put_u16(msg
, NL80211_ATTR_STATUS_CODE
, status
) ||
7432 nla_put(msg
, NL80211_ATTR_REQ_IE
, req_ie_len
, req_ie
)) ||
7434 nla_put(msg
, NL80211_ATTR_RESP_IE
, resp_ie_len
, resp_ie
)))
7435 goto nla_put_failure
;
7437 genlmsg_end(msg
, hdr
);
7439 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7440 nl80211_mlme_mcgrp
.id
, gfp
);
7444 genlmsg_cancel(msg
, hdr
);
7449 void nl80211_send_roamed(struct cfg80211_registered_device
*rdev
,
7450 struct net_device
*netdev
, const u8
*bssid
,
7451 const u8
*req_ie
, size_t req_ie_len
,
7452 const u8
*resp_ie
, size_t resp_ie_len
, gfp_t gfp
)
7454 struct sk_buff
*msg
;
7457 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
7461 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_ROAM
);
7467 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7468 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7469 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
) ||
7471 nla_put(msg
, NL80211_ATTR_REQ_IE
, req_ie_len
, req_ie
)) ||
7473 nla_put(msg
, NL80211_ATTR_RESP_IE
, resp_ie_len
, resp_ie
)))
7474 goto nla_put_failure
;
7476 genlmsg_end(msg
, hdr
);
7478 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7479 nl80211_mlme_mcgrp
.id
, gfp
);
7483 genlmsg_cancel(msg
, hdr
);
7488 void nl80211_send_disconnected(struct cfg80211_registered_device
*rdev
,
7489 struct net_device
*netdev
, u16 reason
,
7490 const u8
*ie
, size_t ie_len
, bool from_ap
)
7492 struct sk_buff
*msg
;
7495 msg
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
7499 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_DISCONNECT
);
7505 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7506 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7507 (from_ap
&& reason
&&
7508 nla_put_u16(msg
, NL80211_ATTR_REASON_CODE
, reason
)) ||
7510 nla_put_flag(msg
, NL80211_ATTR_DISCONNECTED_BY_AP
)) ||
7511 (ie
&& nla_put(msg
, NL80211_ATTR_IE
, ie_len
, ie
)))
7512 goto nla_put_failure
;
7514 genlmsg_end(msg
, hdr
);
7516 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7517 nl80211_mlme_mcgrp
.id
, GFP_KERNEL
);
7521 genlmsg_cancel(msg
, hdr
);
7526 void nl80211_send_ibss_bssid(struct cfg80211_registered_device
*rdev
,
7527 struct net_device
*netdev
, const u8
*bssid
,
7530 struct sk_buff
*msg
;
7533 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
7537 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_JOIN_IBSS
);
7543 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7544 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7545 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
))
7546 goto nla_put_failure
;
7548 genlmsg_end(msg
, hdr
);
7550 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7551 nl80211_mlme_mcgrp
.id
, gfp
);
7555 genlmsg_cancel(msg
, hdr
);
7559 void nl80211_send_new_peer_candidate(struct cfg80211_registered_device
*rdev
,
7560 struct net_device
*netdev
,
7561 const u8
*macaddr
, const u8
* ie
, u8 ie_len
,
7564 struct sk_buff
*msg
;
7567 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
7571 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE
);
7577 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7578 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7579 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, macaddr
) ||
7581 nla_put(msg
, NL80211_ATTR_IE
, ie_len
, ie
)))
7582 goto nla_put_failure
;
7584 genlmsg_end(msg
, hdr
);
7586 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7587 nl80211_mlme_mcgrp
.id
, gfp
);
7591 genlmsg_cancel(msg
, hdr
);
7595 void nl80211_michael_mic_failure(struct cfg80211_registered_device
*rdev
,
7596 struct net_device
*netdev
, const u8
*addr
,
7597 enum nl80211_key_type key_type
, int key_id
,
7598 const u8
*tsc
, gfp_t gfp
)
7600 struct sk_buff
*msg
;
7603 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
7607 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE
);
7613 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7614 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7615 (addr
&& nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
)) ||
7616 nla_put_u32(msg
, NL80211_ATTR_KEY_TYPE
, key_type
) ||
7618 nla_put_u8(msg
, NL80211_ATTR_KEY_IDX
, key_id
)) ||
7619 (tsc
&& nla_put(msg
, NL80211_ATTR_KEY_SEQ
, 6, tsc
)))
7620 goto nla_put_failure
;
7622 genlmsg_end(msg
, hdr
);
7624 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7625 nl80211_mlme_mcgrp
.id
, gfp
);
7629 genlmsg_cancel(msg
, hdr
);
7633 void nl80211_send_beacon_hint_event(struct wiphy
*wiphy
,
7634 struct ieee80211_channel
*channel_before
,
7635 struct ieee80211_channel
*channel_after
)
7637 struct sk_buff
*msg
;
7639 struct nlattr
*nl_freq
;
7641 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
7645 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT
);
7652 * Since we are applying the beacon hint to a wiphy we know its
7653 * wiphy_idx is valid
7655 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, get_wiphy_idx(wiphy
)))
7656 goto nla_put_failure
;
7659 nl_freq
= nla_nest_start(msg
, NL80211_ATTR_FREQ_BEFORE
);
7661 goto nla_put_failure
;
7662 if (nl80211_msg_put_channel(msg
, channel_before
))
7663 goto nla_put_failure
;
7664 nla_nest_end(msg
, nl_freq
);
7667 nl_freq
= nla_nest_start(msg
, NL80211_ATTR_FREQ_AFTER
);
7669 goto nla_put_failure
;
7670 if (nl80211_msg_put_channel(msg
, channel_after
))
7671 goto nla_put_failure
;
7672 nla_nest_end(msg
, nl_freq
);
7674 genlmsg_end(msg
, hdr
);
7677 genlmsg_multicast_allns(msg
, 0, nl80211_regulatory_mcgrp
.id
,
7684 genlmsg_cancel(msg
, hdr
);
7688 static void nl80211_send_remain_on_chan_event(
7689 int cmd
, struct cfg80211_registered_device
*rdev
,
7690 struct net_device
*netdev
, u64 cookie
,
7691 struct ieee80211_channel
*chan
,
7692 enum nl80211_channel_type channel_type
,
7693 unsigned int duration
, gfp_t gfp
)
7695 struct sk_buff
*msg
;
7698 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
7702 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
7708 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7709 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7710 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, chan
->center_freq
) ||
7711 nla_put_u32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
, channel_type
) ||
7712 nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
))
7713 goto nla_put_failure
;
7715 if (cmd
== NL80211_CMD_REMAIN_ON_CHANNEL
&&
7716 nla_put_u32(msg
, NL80211_ATTR_DURATION
, duration
))
7717 goto nla_put_failure
;
7719 genlmsg_end(msg
, hdr
);
7721 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7722 nl80211_mlme_mcgrp
.id
, gfp
);
7726 genlmsg_cancel(msg
, hdr
);
7730 void nl80211_send_remain_on_channel(struct cfg80211_registered_device
*rdev
,
7731 struct net_device
*netdev
, u64 cookie
,
7732 struct ieee80211_channel
*chan
,
7733 enum nl80211_channel_type channel_type
,
7734 unsigned int duration
, gfp_t gfp
)
7736 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL
,
7737 rdev
, netdev
, cookie
, chan
,
7738 channel_type
, duration
, gfp
);
7741 void nl80211_send_remain_on_channel_cancel(
7742 struct cfg80211_registered_device
*rdev
, struct net_device
*netdev
,
7743 u64 cookie
, struct ieee80211_channel
*chan
,
7744 enum nl80211_channel_type channel_type
, gfp_t gfp
)
7746 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
,
7747 rdev
, netdev
, cookie
, chan
,
7748 channel_type
, 0, gfp
);
7751 void nl80211_send_sta_event(struct cfg80211_registered_device
*rdev
,
7752 struct net_device
*dev
, const u8
*mac_addr
,
7753 struct station_info
*sinfo
, gfp_t gfp
)
7755 struct sk_buff
*msg
;
7757 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
7761 if (nl80211_send_station(msg
, 0, 0, 0,
7762 rdev
, dev
, mac_addr
, sinfo
) < 0) {
7767 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7768 nl80211_mlme_mcgrp
.id
, gfp
);
7771 void nl80211_send_sta_del_event(struct cfg80211_registered_device
*rdev
,
7772 struct net_device
*dev
, const u8
*mac_addr
,
7775 struct sk_buff
*msg
;
7778 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
7782 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_DEL_STATION
);
7788 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
7789 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
))
7790 goto nla_put_failure
;
7792 genlmsg_end(msg
, hdr
);
7794 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7795 nl80211_mlme_mcgrp
.id
, gfp
);
7799 genlmsg_cancel(msg
, hdr
);
7803 static bool __nl80211_unexpected_frame(struct net_device
*dev
, u8 cmd
,
7804 const u8
*addr
, gfp_t gfp
)
7806 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
7807 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
7808 struct sk_buff
*msg
;
7811 u32 nlpid
= ACCESS_ONCE(wdev
->ap_unexpected_nlpid
);
7816 msg
= nlmsg_new(100, gfp
);
7820 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
7826 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7827 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
7828 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
))
7829 goto nla_put_failure
;
7831 err
= genlmsg_end(msg
, hdr
);
7837 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlpid
);
7841 genlmsg_cancel(msg
, hdr
);
7846 bool nl80211_unexpected_frame(struct net_device
*dev
, const u8
*addr
, gfp_t gfp
)
7848 return __nl80211_unexpected_frame(dev
, NL80211_CMD_UNEXPECTED_FRAME
,
7852 bool nl80211_unexpected_4addr_frame(struct net_device
*dev
,
7853 const u8
*addr
, gfp_t gfp
)
7855 return __nl80211_unexpected_frame(dev
,
7856 NL80211_CMD_UNEXPECTED_4ADDR_FRAME
,
7860 int nl80211_send_mgmt(struct cfg80211_registered_device
*rdev
,
7861 struct net_device
*netdev
, u32 nlpid
,
7862 int freq
, int sig_dbm
,
7863 const u8
*buf
, size_t len
, gfp_t gfp
)
7865 struct sk_buff
*msg
;
7868 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
7872 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FRAME
);
7878 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7879 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7880 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
) ||
7882 nla_put_u32(msg
, NL80211_ATTR_RX_SIGNAL_DBM
, sig_dbm
)) ||
7883 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
))
7884 goto nla_put_failure
;
7886 genlmsg_end(msg
, hdr
);
7888 return genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlpid
);
7891 genlmsg_cancel(msg
, hdr
);
7896 void nl80211_send_mgmt_tx_status(struct cfg80211_registered_device
*rdev
,
7897 struct net_device
*netdev
, u64 cookie
,
7898 const u8
*buf
, size_t len
, bool ack
,
7901 struct sk_buff
*msg
;
7904 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
7908 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS
);
7914 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7915 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7916 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
) ||
7917 nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
) ||
7918 (ack
&& nla_put_flag(msg
, NL80211_ATTR_ACK
)))
7919 goto nla_put_failure
;
7921 genlmsg_end(msg
, hdr
);
7923 genlmsg_multicast(msg
, 0, nl80211_mlme_mcgrp
.id
, gfp
);
7927 genlmsg_cancel(msg
, hdr
);
7932 nl80211_send_cqm_rssi_notify(struct cfg80211_registered_device
*rdev
,
7933 struct net_device
*netdev
,
7934 enum nl80211_cqm_rssi_threshold_event rssi_event
,
7937 struct sk_buff
*msg
;
7938 struct nlattr
*pinfoattr
;
7941 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
7945 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NOTIFY_CQM
);
7951 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7952 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
7953 goto nla_put_failure
;
7955 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_CQM
);
7957 goto nla_put_failure
;
7959 if (nla_put_u32(msg
, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
,
7961 goto nla_put_failure
;
7963 nla_nest_end(msg
, pinfoattr
);
7965 genlmsg_end(msg
, hdr
);
7967 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
7968 nl80211_mlme_mcgrp
.id
, gfp
);
7972 genlmsg_cancel(msg
, hdr
);
7976 void nl80211_gtk_rekey_notify(struct cfg80211_registered_device
*rdev
,
7977 struct net_device
*netdev
, const u8
*bssid
,
7978 const u8
*replay_ctr
, gfp_t gfp
)
7980 struct sk_buff
*msg
;
7981 struct nlattr
*rekey_attr
;
7984 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
7988 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD
);
7994 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
7995 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
7996 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
))
7997 goto nla_put_failure
;
7999 rekey_attr
= nla_nest_start(msg
, NL80211_ATTR_REKEY_DATA
);
8001 goto nla_put_failure
;
8003 if (nla_put(msg
, NL80211_REKEY_DATA_REPLAY_CTR
,
8004 NL80211_REPLAY_CTR_LEN
, replay_ctr
))
8005 goto nla_put_failure
;
8007 nla_nest_end(msg
, rekey_attr
);
8009 genlmsg_end(msg
, hdr
);
8011 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
8012 nl80211_mlme_mcgrp
.id
, gfp
);
8016 genlmsg_cancel(msg
, hdr
);
8020 void nl80211_pmksa_candidate_notify(struct cfg80211_registered_device
*rdev
,
8021 struct net_device
*netdev
, int index
,
8022 const u8
*bssid
, bool preauth
, gfp_t gfp
)
8024 struct sk_buff
*msg
;
8025 struct nlattr
*attr
;
8028 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
8032 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE
);
8038 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
8039 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
8040 goto nla_put_failure
;
8042 attr
= nla_nest_start(msg
, NL80211_ATTR_PMKSA_CANDIDATE
);
8044 goto nla_put_failure
;
8046 if (nla_put_u32(msg
, NL80211_PMKSA_CANDIDATE_INDEX
, index
) ||
8047 nla_put(msg
, NL80211_PMKSA_CANDIDATE_BSSID
, ETH_ALEN
, bssid
) ||
8049 nla_put_flag(msg
, NL80211_PMKSA_CANDIDATE_PREAUTH
)))
8050 goto nla_put_failure
;
8052 nla_nest_end(msg
, attr
);
8054 genlmsg_end(msg
, hdr
);
8056 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
8057 nl80211_mlme_mcgrp
.id
, gfp
);
8061 genlmsg_cancel(msg
, hdr
);
8065 void nl80211_ch_switch_notify(struct cfg80211_registered_device
*rdev
,
8066 struct net_device
*netdev
, int freq
,
8067 enum nl80211_channel_type type
, gfp_t gfp
)
8069 struct sk_buff
*msg
;
8072 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
8076 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CH_SWITCH_NOTIFY
);
8082 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
8083 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
) ||
8084 nla_put_u32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
, type
))
8085 goto nla_put_failure
;
8087 genlmsg_end(msg
, hdr
);
8089 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
8090 nl80211_mlme_mcgrp
.id
, gfp
);
8094 genlmsg_cancel(msg
, hdr
);
8099 nl80211_send_cqm_pktloss_notify(struct cfg80211_registered_device
*rdev
,
8100 struct net_device
*netdev
, const u8
*peer
,
8101 u32 num_packets
, gfp_t gfp
)
8103 struct sk_buff
*msg
;
8104 struct nlattr
*pinfoattr
;
8107 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
8111 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NOTIFY_CQM
);
8117 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
8118 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
8119 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, peer
))
8120 goto nla_put_failure
;
8122 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_CQM
);
8124 goto nla_put_failure
;
8126 if (nla_put_u32(msg
, NL80211_ATTR_CQM_PKT_LOSS_EVENT
, num_packets
))
8127 goto nla_put_failure
;
8129 nla_nest_end(msg
, pinfoattr
);
8131 genlmsg_end(msg
, hdr
);
8133 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
8134 nl80211_mlme_mcgrp
.id
, gfp
);
8138 genlmsg_cancel(msg
, hdr
);
8142 void cfg80211_probe_status(struct net_device
*dev
, const u8
*addr
,
8143 u64 cookie
, bool acked
, gfp_t gfp
)
8145 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
8146 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
8147 struct sk_buff
*msg
;
8151 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
8155 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_PROBE_CLIENT
);
8161 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
8162 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
8163 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
) ||
8164 nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
) ||
8165 (acked
&& nla_put_flag(msg
, NL80211_ATTR_ACK
)))
8166 goto nla_put_failure
;
8168 err
= genlmsg_end(msg
, hdr
);
8174 genlmsg_multicast_netns(wiphy_net(&rdev
->wiphy
), msg
, 0,
8175 nl80211_mlme_mcgrp
.id
, gfp
);
8179 genlmsg_cancel(msg
, hdr
);
8182 EXPORT_SYMBOL(cfg80211_probe_status
);
8184 void cfg80211_report_obss_beacon(struct wiphy
*wiphy
,
8185 const u8
*frame
, size_t len
,
8186 int freq
, int sig_dbm
, gfp_t gfp
)
8188 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
8189 struct sk_buff
*msg
;
8191 u32 nlpid
= ACCESS_ONCE(rdev
->ap_beacons_nlpid
);
8196 msg
= nlmsg_new(len
+ 100, gfp
);
8200 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FRAME
);
8206 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
8208 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
)) ||
8210 nla_put_u32(msg
, NL80211_ATTR_RX_SIGNAL_DBM
, sig_dbm
)) ||
8211 nla_put(msg
, NL80211_ATTR_FRAME
, len
, frame
))
8212 goto nla_put_failure
;
8214 genlmsg_end(msg
, hdr
);
8216 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlpid
);
8220 genlmsg_cancel(msg
, hdr
);
8223 EXPORT_SYMBOL(cfg80211_report_obss_beacon
);
8225 static int nl80211_netlink_notify(struct notifier_block
* nb
,
8226 unsigned long state
,
8229 struct netlink_notify
*notify
= _notify
;
8230 struct cfg80211_registered_device
*rdev
;
8231 struct wireless_dev
*wdev
;
8233 if (state
!= NETLINK_URELEASE
)
8238 list_for_each_entry_rcu(rdev
, &cfg80211_rdev_list
, list
) {
8239 list_for_each_entry_rcu(wdev
, &rdev
->netdev_list
, list
)
8240 cfg80211_mlme_unregister_socket(wdev
, notify
->pid
);
8241 if (rdev
->ap_beacons_nlpid
== notify
->pid
)
8242 rdev
->ap_beacons_nlpid
= 0;
8250 static struct notifier_block nl80211_netlink_notifier
= {
8251 .notifier_call
= nl80211_netlink_notify
,
8254 /* initialisation/exit functions */
8256 int nl80211_init(void)
8260 err
= genl_register_family_with_ops(&nl80211_fam
,
8261 nl80211_ops
, ARRAY_SIZE(nl80211_ops
));
8265 err
= genl_register_mc_group(&nl80211_fam
, &nl80211_config_mcgrp
);
8269 err
= genl_register_mc_group(&nl80211_fam
, &nl80211_scan_mcgrp
);
8273 err
= genl_register_mc_group(&nl80211_fam
, &nl80211_regulatory_mcgrp
);
8277 err
= genl_register_mc_group(&nl80211_fam
, &nl80211_mlme_mcgrp
);
8281 #ifdef CONFIG_NL80211_TESTMODE
8282 err
= genl_register_mc_group(&nl80211_fam
, &nl80211_testmode_mcgrp
);
8287 err
= netlink_register_notifier(&nl80211_netlink_notifier
);
8293 genl_unregister_family(&nl80211_fam
);
8297 void nl80211_exit(void)
8299 netlink_unregister_notifier(&nl80211_netlink_notifier
);
8300 genl_unregister_family(&nl80211_fam
);