1 /*
2 * This file implement the Wireless Extensions spy API.
3 *
4 * Authors : Jean Tourrilhes - HPL - <jt@hpl.hp.com>
5 * Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved.
6 *
7 * (As all part of the Linux kernel, this file is GPL)
8 */
9
10 #include <linux/wireless.h>
11 #include <linux/netdevice.h>
12 #include <linux/etherdevice.h>
13 #include <linux/export.h>
14 #include <net/iw_handler.h>
15 #include <net/arp.h>
16 #include <net/wext.h>
17
18 static inline struct iw_spy_data *get_spydata(struct net_device *dev)
19 {
20 /* This is the new way */
21 if (dev->wireless_data)
22 return dev->wireless_data->spy_data;
23 return NULL;
24 }
25
26 int iw_handler_set_spy(struct net_device * dev,
27 struct iw_request_info * info,
28 union iwreq_data * wrqu,
29 char * extra)
30 {
31 struct iw_spy_data * spydata = get_spydata(dev);
32 struct sockaddr * address = (struct sockaddr *) extra;
33
34 /* Make sure driver is not buggy or using the old API */
35 if (!spydata)
36 return -EOPNOTSUPP;
37
38 /* Disable spy collection while we copy the addresses.
39 * While we copy addresses, any call to wireless_spy_update()
40 * will NOP. This is OK, as anyway the addresses are changing. */
41 spydata->spy_number = 0;
42
43 /* We want to operate without locking, because wireless_spy_update()
44 * most likely will happen in the interrupt handler, and therefore
45 * have its own locking constraints and needs performance.
46 * The rtnl_lock() make sure we don't race with the other iw_handlers.
47 * This make sure wireless_spy_update() "see" that the spy list
48 * is temporarily disabled. */
49 smp_wmb();
50
51 /* Are there are addresses to copy? */
52 if (wrqu->data.length > 0) {
53 int i;
54
55 /* Copy addresses */
56 for (i = 0; i < wrqu->data.length; i++)
57 memcpy(spydata->spy_address[i], address[i].sa_data,
58 ETH_ALEN);
59 /* Reset stats */
60 memset(spydata->spy_stat, 0,
61 sizeof(struct iw_quality) * IW_MAX_SPY);
62 }
63
64 /* Make sure above is updated before re-enabling */
65 smp_wmb();
66
67 /* Enable addresses */
68 spydata->spy_number = wrqu->data.length;
69
70 return 0;
71 }
72 EXPORT_SYMBOL(iw_handler_set_spy);
73
74 int iw_handler_get_spy(struct net_device * dev,
75 struct iw_request_info * info,
76 union iwreq_data * wrqu,
77 char * extra)
78 {
79 struct iw_spy_data * spydata = get_spydata(dev);
80 struct sockaddr * address = (struct sockaddr *) extra;
81 int i;
82
83 /* Make sure driver is not buggy or using the old API */
84 if (!spydata)
85 return -EOPNOTSUPP;
86
87 wrqu->data.length = spydata->spy_number;
88
89 /* Copy addresses. */
90 for (i = 0; i < spydata->spy_number; i++) {
91 memcpy(address[i].sa_data, spydata->spy_address[i], ETH_ALEN);
92 address[i].sa_family = AF_UNIX;
93 }
94 /* Copy stats to the user buffer (just after). */
95 if (spydata->spy_number > 0)
96 memcpy(extra + (sizeof(struct sockaddr) *spydata->spy_number),
97 spydata->spy_stat,
98 sizeof(struct iw_quality) * spydata->spy_number);
99 /* Reset updated flags. */
100 for (i = 0; i < spydata->spy_number; i++)
101 spydata->spy_stat[i].updated &= ~IW_QUAL_ALL_UPDATED;
102 return 0;
103 }
104 EXPORT_SYMBOL(iw_handler_get_spy);
105
106 /*------------------------------------------------------------------*/
107 /*
108 * Standard Wireless Handler : set spy threshold
109 */
110 int iw_handler_set_thrspy(struct net_device * dev,
111 struct iw_request_info *info,
112 union iwreq_data * wrqu,
113 char * extra)
114 {
115 struct iw_spy_data * spydata = get_spydata(dev);
116 struct iw_thrspy * threshold = (struct iw_thrspy *) extra;
117
118 /* Make sure driver is not buggy or using the old API */
119 if (!spydata)
120 return -EOPNOTSUPP;
121
122 /* Just do it */
123 memcpy(&(spydata->spy_thr_low), &(threshold->low),
124 2 * sizeof(struct iw_quality));
125
126 /* Clear flag */
127 memset(spydata->spy_thr_under, '\0', sizeof(spydata->spy_thr_under));
128
129 return 0;
130 }
131 EXPORT_SYMBOL(iw_handler_set_thrspy);
132
133 /*------------------------------------------------------------------*/
134 /*
135 * Standard Wireless Handler : get spy threshold
136 */
137 int iw_handler_get_thrspy(struct net_device * dev,
138 struct iw_request_info *info,
139 union iwreq_data * wrqu,
140 char * extra)
141 {
142 struct iw_spy_data * spydata = get_spydata(dev);
143 struct iw_thrspy * threshold = (struct iw_thrspy *) extra;
144
145 /* Make sure driver is not buggy or using the old API */
146 if (!spydata)
147 return -EOPNOTSUPP;
148
149 /* Just do it */
150 memcpy(&(threshold->low), &(spydata->spy_thr_low),
151 2 * sizeof(struct iw_quality));
152
153 return 0;
154 }
155 EXPORT_SYMBOL(iw_handler_get_thrspy);
156
157 /*------------------------------------------------------------------*/
158 /*
159 * Prepare and send a Spy Threshold event
160 */
161 static void iw_send_thrspy_event(struct net_device * dev,
162 struct iw_spy_data * spydata,
163 unsigned char * address,
164 struct iw_quality * wstats)
165 {
166 union iwreq_data wrqu;
167 struct iw_thrspy threshold;
168
169 /* Init */
170 wrqu.data.length = 1;
171 wrqu.data.flags = 0;
172 /* Copy address */
173 memcpy(threshold.addr.sa_data, address, ETH_ALEN);
174 threshold.addr.sa_family = ARPHRD_ETHER;
175 /* Copy stats */
176 memcpy(&(threshold.qual), wstats, sizeof(struct iw_quality));
177 /* Copy also thresholds */
178 memcpy(&(threshold.low), &(spydata->spy_thr_low),
179 2 * sizeof(struct iw_quality));
180
181 /* Send event to user space */
182 wireless_send_event(dev, SIOCGIWTHRSPY, &wrqu, (char *) &threshold);
183 }
184
185 /* ---------------------------------------------------------------- */
186 /*
187 * Call for the driver to update the spy data.
188 * For now, the spy data is a simple array. As the size of the array is
189 * small, this is good enough. If we wanted to support larger number of
190 * spy addresses, we should use something more efficient...
191 */
192 void wireless_spy_update(struct net_device * dev,
193 unsigned char * address,
194 struct iw_quality * wstats)
195 {
196 struct iw_spy_data * spydata = get_spydata(dev);
197 int i;
198 int match = -1;
199
200 /* Make sure driver is not buggy or using the old API */
201 if (!spydata)
202 return;
203
204 /* Update all records that match */
205 for (i = 0; i < spydata->spy_number; i++)
206 if (ether_addr_equal(address, spydata->spy_address[i])) {
207 memcpy(&(spydata->spy_stat[i]), wstats,
208 sizeof(struct iw_quality));
209 match = i;
210 }
211
212 /* Generate an event if we cross the spy threshold.
213 * To avoid event storms, we have a simple hysteresis : we generate
214 * event only when we go under the low threshold or above the
215 * high threshold. */
216 if (match >= 0) {
217 if (spydata->spy_thr_under[match]) {
218 if (wstats->level > spydata->spy_thr_high.level) {
219 spydata->spy_thr_under[match] = 0;
220 iw_send_thrspy_event(dev, spydata,
221 address, wstats);
222 }
223 } else {
224 if (wstats->level < spydata->spy_thr_low.level) {
225 spydata->spy_thr_under[match] = 1;
226 iw_send_thrspy_event(dev, spydata,
227 address, wstats);
228 }
229 }
230 }
231 }
232 EXPORT_SYMBOL(wireless_spy_update);