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