libs: remove cbi folder
[project/luci.git] / libs / iwinfo / src / iwinfo_wext.c
1 /*
2  * iwinfo - Wireless Information Library - Linux Wireless Extension Backend
3  *
4  *   Copyright (C) 2009 Jo-Philipp Wich <xm@subsignal.org>
5  *
6  * The iwinfo library is free software: you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License version 2
8  * as published by the Free Software Foundation.
9  *
10  * The iwinfo library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13  * See the GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with the iwinfo library. If not, see http://www.gnu.org/licenses/.
17  *
18  * Parts of this code are derived from the Linux wireless tools, iwlib.c,
19  * iwlist.c and iwconfig.c in particular.
20  */
21
22 #include "iwinfo.h"
23 #include "iwinfo_wext.h"
24
25 #define LOG10_MAGIC     1.25892541179
26
27 static int ioctl_socket = -1;
28
29 static double wext_freq2float(const struct iw_freq *in)
30 {
31         int             i;
32         double  res = (double) in->m;
33         for(i = 0; i < in->e; i++) res *= 10;
34         return res;
35 }
36
37 static int wext_freq2mhz(const struct iw_freq *in)
38 {
39         int i, mhz;
40
41         if( in->e == 6 )
42         {
43                 return in->m;
44         }
45         else
46         {
47                 mhz = in->m;
48                 for(i = 0; i < in->e; i++)
49                         mhz *= 10;
50
51                 return (int)(mhz / 100000);
52         }
53 }
54
55 static int wext_dbm2mw(int in)
56 {
57         double res = 1.0;
58         int ip = in / 10;
59         int fp = in % 10;
60         int k;
61
62         for(k = 0; k < ip; k++) res *= 10;
63         for(k = 0; k < fp; k++) res *= LOG10_MAGIC;
64
65         return (int)res;
66 }
67
68 static int wext_mw2dbm(int in)
69 {
70         double fin = (double) in;
71         int res = 0;
72
73         while(fin > 10.0)
74         {
75                 res += 10;
76                 fin /= 10.0;
77         }
78
79         while(fin > 1.000001)
80         {
81                 res += 1;
82                 fin /= LOG10_MAGIC;
83         }
84
85         return res;
86 }
87
88 static int wext_ioctl(const char *ifname, int cmd, struct iwreq *wrq)
89 {
90         /* prepare socket */
91         if( ioctl_socket == -1 )
92                 ioctl_socket = socket(AF_INET, SOCK_DGRAM, 0);
93
94         strncpy(wrq->ifr_name, ifname, IFNAMSIZ);
95         return ioctl(ioctl_socket, cmd, wrq);
96 }
97
98
99 int wext_probe(const char *ifname)
100 {
101         struct iwreq wrq;
102
103         if(wext_ioctl(ifname, SIOCGIWNAME, &wrq) >= 0)
104                 return 1;
105
106         return 0;
107 }
108
109 int wext_get_mode(const char *ifname, char *buf)
110 {
111         struct iwreq wrq;
112
113         if(wext_ioctl(ifname, SIOCGIWMODE, &wrq) >= 0)
114         {
115                 switch(wrq.u.mode)
116                 {
117                         case 0:
118                                 sprintf(buf, "Auto");
119                                 break;
120
121                         case 1:
122                                 sprintf(buf, "Ad-Hoc");
123                                 break;
124
125                         case 2:
126                                 sprintf(buf, "Client");
127                                 break;
128
129                         case 3:
130                                 sprintf(buf, "Master");
131                                 break;
132
133                         case 4:
134                                 sprintf(buf, "Repeater");
135                                 break;
136
137                         case 5:
138                                 sprintf(buf, "Secondary");
139                                 break;
140
141                         case 6:
142                                 sprintf(buf, "Monitor");
143                                 break;
144
145                         default:
146                                 sprintf(buf, "Unknown");
147                 }
148
149                 return 0;
150         }
151
152         return -1;
153 }
154
155 int wext_get_ssid(const char *ifname, char *buf)
156 {
157         struct iwreq wrq;
158
159         wrq.u.essid.pointer = (caddr_t) buf;
160         wrq.u.essid.length  = IW_ESSID_MAX_SIZE + 1;
161         wrq.u.essid.flags   = 0;
162
163         if(wext_ioctl(ifname, SIOCGIWESSID, &wrq) >= 0)
164                 return 0;
165
166         return -1;
167 }
168
169 int wext_get_bssid(const char *ifname, char *buf)
170 {
171         struct iwreq wrq;
172
173         if(wext_ioctl(ifname, SIOCGIWAP, &wrq) >= 0)
174         {
175                 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
176                         (uint8_t)wrq.u.ap_addr.sa_data[0], (uint8_t)wrq.u.ap_addr.sa_data[1],
177                         (uint8_t)wrq.u.ap_addr.sa_data[2], (uint8_t)wrq.u.ap_addr.sa_data[3],
178                         (uint8_t)wrq.u.ap_addr.sa_data[4], (uint8_t)wrq.u.ap_addr.sa_data[5]);
179
180                 return 0;
181         }
182
183         return -1;      
184 }
185
186 int wext_get_bitrate(const char *ifname, int *buf)
187 {
188         struct iwreq wrq;
189
190         if(wext_ioctl(ifname, SIOCGIWRATE, &wrq) >= 0)
191         {
192                 *buf = (wrq.u.bitrate.value / 1000);
193                 return 0;
194         }
195
196         return -1;      
197 }
198
199 int wext_get_channel(const char *ifname, int *buf)
200 {
201         struct iwreq wrq;
202         struct iw_range range;
203         double freq;
204         int i;
205
206         if(wext_ioctl(ifname, SIOCGIWFREQ, &wrq) >= 0)
207         {
208                 if( wrq.u.freq.m >= 1000 )
209                 {
210                         freq = wext_freq2float(&wrq.u.freq);
211                         wrq.u.data.pointer = (caddr_t) &range;
212                         wrq.u.data.length  = sizeof(struct iw_range);
213                         wrq.u.data.flags   = 0;
214
215                         if(wext_ioctl(ifname, SIOCGIWRANGE, &wrq) >= 0)
216                         {
217                                 for(i = 0; i < range.num_frequency; i++)
218                                 {
219                                         if( wext_freq2float(&range.freq[i]) == freq )
220                                         {
221                                                 *buf = range.freq[i].i;
222                                                 return 0;
223                                         }
224                                 }
225                         }
226                 }
227                 else
228                 {
229                         *buf = wrq.u.freq.m;
230                         return 0;
231                 }
232         }
233
234         return -1;      
235 }
236
237 int wext_get_frequency(const char *ifname, int *buf)
238 {
239         struct iwreq wrq;
240         struct iw_range range;
241         int i, channel;
242
243         if(wext_ioctl(ifname, SIOCGIWFREQ, &wrq) >= 0)
244         {
245                 /* We got a channel number instead ... */
246                 if( wrq.u.freq.m < 1000 )
247                 {
248                         channel = wrq.u.freq.m;
249                         wrq.u.data.pointer = (caddr_t) &range;
250                         wrq.u.data.length  = sizeof(struct iw_range);
251                         wrq.u.data.flags   = 0;
252
253                         if(wext_ioctl(ifname, SIOCGIWRANGE, &wrq) >= 0)
254                         {
255                                 for(i = 0; i < range.num_frequency; i++)
256                                 {
257                                         if( range.freq[i].i == channel )
258                                         {
259                                                 *buf = wext_freq2mhz(&range.freq[i]);
260                                                 return 0;
261                                         }
262                                 }
263                         }
264                 }
265                 else
266                 {
267                         *buf = wext_freq2mhz(&wrq.u.freq);
268                         return 0;
269                 }
270         }
271
272         return -1;      
273 }
274
275 int wext_get_signal(const char *ifname, int *buf)
276 {
277         struct iwreq wrq;
278         struct iw_statistics stats;
279
280         wrq.u.data.pointer = (caddr_t) &stats;
281         wrq.u.data.length  = sizeof(struct iw_statistics);
282         wrq.u.data.flags   = 1;
283
284         if(wext_ioctl(ifname, SIOCGIWSTATS, &wrq) >= 0)
285         {
286                 *buf = (stats.qual.level - 0x100);
287                 return 0;
288         }
289
290         return -1;
291 }
292
293 int wext_get_noise(const char *ifname, int *buf)
294 {
295         struct iwreq wrq;
296         struct iw_statistics stats;
297
298         wrq.u.data.pointer = (caddr_t) &stats;
299         wrq.u.data.length  = sizeof(struct iw_statistics);
300         wrq.u.data.flags   = 1;
301
302         if(wext_ioctl(ifname, SIOCGIWSTATS, &wrq) >= 0)
303         {
304                 *buf = (stats.qual.noise - 0x100);
305                 return 0;
306         }
307
308         return -1;
309 }
310
311 int wext_get_quality(const char *ifname, int *buf)
312 {
313         struct iwreq wrq;
314         struct iw_statistics stats;
315
316         wrq.u.data.pointer = (caddr_t) &stats;
317         wrq.u.data.length  = sizeof(struct iw_statistics);
318         wrq.u.data.flags   = 1;
319
320         if(wext_ioctl(ifname, SIOCGIWSTATS, &wrq) >= 0)
321         {
322                 *buf = stats.qual.qual;
323                 return 0;
324         }
325
326         return -1;
327 }
328
329 int wext_get_quality_max(const char *ifname, int *buf)
330 {
331         struct iwreq wrq;
332         struct iw_range range;
333
334         wrq.u.data.pointer = (caddr_t) &range;
335         wrq.u.data.length  = sizeof(struct iw_range);
336         wrq.u.data.flags   = 0;
337
338         if(wext_ioctl(ifname, SIOCGIWRANGE, &wrq) >= 0)
339         {
340                 *buf = range.max_qual.qual;
341                 return 0;
342         }
343
344         return -1;
345 }
346
347 int wext_get_enctype(const char *ifname, char *buf)
348 {
349         /* Stub */
350         return -1;
351 }
352
353 int wext_get_assoclist(const char *ifname, char *buf, int *len)
354 {
355         /* Stub */
356         return -1;
357 }
358
359 int wext_get_txpwrlist(const char *ifname, char *buf, int *len)
360 {
361         struct iwreq wrq;
362         struct iw_range range;
363         struct iwinfo_txpwrlist_entry entry;
364         int i;
365
366         wrq.u.data.pointer = (caddr_t) &range;
367         wrq.u.data.length  = sizeof(struct iw_range);
368         wrq.u.data.flags   = 0;
369
370         if( (wext_ioctl(ifname, SIOCGIWRANGE, &wrq) >= 0) &&
371             (range.num_txpower > 0) && (range.num_txpower <= IW_MAX_TXPOWER) &&
372             !(range.txpower_capa & IW_TXPOW_RELATIVE)
373         ) {
374                 for( i = 0; i < range.num_txpower; i++ )
375                 {
376                         if( range.txpower_capa & IW_TXPOW_DBM )
377                         {
378                                 entry.dbm = range.txpower[i];
379                                 entry.mw  = wext_dbm2mw(range.txpower[i]);
380                         }
381
382                         else if( range.txpower_capa & IW_TXPOW_MWATT )
383                         {
384                                 entry.dbm = wext_mw2dbm(range.txpower[i]);
385                                 entry.mw  = range.txpower[i];
386                         }
387
388                         memcpy(&buf[i*sizeof(entry)], &entry, sizeof(entry));
389                 }
390
391                 *len = i * sizeof(entry);
392                 return 0;
393         }
394
395         return -1;      
396 }
397
398 int wext_get_freqlist(const char *ifname, char *buf, int *len)
399 {
400         struct iwreq wrq;
401         struct iw_range range;
402         struct iwinfo_freqlist_entry entry;
403         int i, bl;
404
405         wrq.u.data.pointer = (caddr_t) &range;
406         wrq.u.data.length  = sizeof(struct iw_range);
407         wrq.u.data.flags   = 0;
408
409         if(wext_ioctl(ifname, SIOCGIWRANGE, &wrq) >= 0)
410         {
411                 bl = 0;
412
413                 for(i = 0; i < range.num_frequency; i++)
414                 {
415                         entry.mhz     = wext_freq2mhz(&range.freq[i]);
416                         entry.channel = range.freq[i].i;
417
418                         memcpy(&buf[bl], &entry, sizeof(struct iwinfo_freqlist_entry));
419                         bl += sizeof(struct iwinfo_freqlist_entry);
420                 }
421
422                 *len = bl;
423                 return 0;
424         }
425
426         return -1;
427 }
428
429 int wext_get_mbssid_support(const char *ifname, int *buf)
430 {
431         /* No multi bssid support atm */
432         return -1;
433 }
434