← Back to branch summary

~siretart/lcd4linux/debian

« back to all changes in this revision

Viewing changes to plugin_wireless.c

  • Committer: Reinhard Tartler
  • Date: 2011-04-27 17:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 750.
  • Revision ID: siretart@tauware.de-20110427172415-6n4aptmvmz0eztvm
Tags: upstream-0.11.0~svn1143
Import upstream version 0.11.0~svn1143

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin_wireless.c
 
1
/* $Id: plugin_wireless.c 1136 2010-11-28 16:07:16Z mzuther $
 
2
 * $URL: https://ssl.bulix.org/svn/lcd4linux/trunk/plugin_wireless.c $
 
3
 *
 
4
 * Wireless Extension plugin
 
5
 *
 
6
 * Copyright (C) 2004 Xavier Vello <xavier66@free.fr>
 
7
 * Copyright (C) 2004 Martin Hejl <martin@hejl.de> 
 
8
 * Copyright (C) 2004 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net> 
 
9
 *
 
10
 * Losts of code borrowed from Wireless Tools, which is
 
11
 *         Copyright (C) 1997-2002 Jean Tourrilhes <jt@hpl.hp.com>
 
12
 * (avaible at http://web.hpl.hp.com/personal/Jean_Tourrilhes/Linux/)
 
13
 *
 
14
 * This file is part of LCD4Linux.
 
15
 *
 
16
 * LCD4Linux is free software; you can redistribute it and/or modify
 
17
 * it under the terms of the GNU General Public License as published by
 
18
 * the Free Software Foundation; either version 2, or (at your option)
 
19
 * any later version.
 
20
 *
 
21
 * LCD4Linux is distributed in the hope that it will be useful,
 
22
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
23
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
24
 * GNU General Public License for more details.
 
25
 *
 
26
 * You should have received a copy of the GNU General Public License
 
27
 * along with this program; if not, write to the Free Software
 
28
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
29
 *
 
30
 */
 
31
 
 
32
 /*
 
33
  * Exported functions:
 
34
 
 
35
  wifi_level
 
36
  wifi_noise
 
37
  wifi_quality
 
38
  wifi_protocol
 
39
  wifi_frequency
 
40
  wifi_bitrate
 
41
  wifi_essid
 
42
  wifi_op_mode
 
43
  wifi_sensitivity
 
44
  wifi_sec_mode
 
45
 
 
46
  All Functions take one parameter 
 
47
  (the name of the device, like "wlan0", "ath0" and so on)  
 
48
 
 
49
  */
 
50
 
 
51
#include "config.h"
 
52
 
 
53
#include <stdlib.h>
 
54
#include <string.h>
 
55
#include <stdio.h>
 
56
#include <unistd.h>
 
57
#include <errno.h>
 
58
#include <math.h>
 
59
 
 
60
#include <sys/ioctl.h>
 
61
#include <net/if_arp.h>
 
62
#include <linux/if.h>
 
63
#include <linux/wireless.h>
 
64
 
 
65
#include "debug.h"
 
66
#include "plugin.h"
 
67
#include "cfg.h"
 
68
#include "hash.h"
 
69
#include "qprintf.h"
 
70
 
 
71
 
 
72
#ifdef WITH_DMALLOC
 
73
#include <dmalloc.h>
 
74
#endif
 
75
 
 
76
#define HASH_TTL 100
 
77
 
 
78
   /*#define KILO  1e3 */
 
79
   /*#define MEGA  1e6 */
 
80
   /*#define GIGA  1e9 */
 
81
 
 
82
 
 
83
#define KEY_LEVEL "level"
 
84
#define KEY_QUALITY "quality"
 
85
#define KEY_NOISE "noise"
 
86
#define KEY_PROTO "proto"
 
87
#define KEY_FREQUENCY "frequency"
 
88
#define KEY_BIT_RATE "bit_rate"
 
89
#define KEY_ESSID "essid"
 
90
#define KEY_OP_MODE "op_mode"
 
91
#define KEY_SENS "sens"
 
92
#define KEY_SEC_MODE "sec_mode"
 
93
 
 
94
#define FREQ2FLOAT(m,e) (((double) m) * pow(10,e))
 
95
#define MWATT2DBM(in) ((int) (ceil(10.0 * log10((double) in))))
 
96
 
 
97
 
 
98
static HASH wireless;
 
99
static int sock = -2;
 
100
 
 
101
static char *operation_mode[] = {
 
102
    "Auto",
 
103
    "Ad-Hoc",
 
104
    "Managed",
 
105
    "Master",
 
106
    "Repeater",
 
107
    "Secondary",
 
108
    "Monitor",
 
109
    "n/a"
 
110
};
 
111
 
 
112
 
 
113
static void ioctl_error(const int line)
 
114
{
 
115
    error("IOCTL call to wireless extensions in line %d returned error", line);
 
116
}
 
117
 
 
118
int do_ioctl(const int sock,    /* Socket to the kernel */
 
119
             const char *ifname,        /* Device name */
 
120
             const int request, /* WE ID */
 
121
             struct iwreq *pwrq)
 
122
{                               /* Fixed part of the request */
 
123
    int ret;
 
124
 
 
125
    /* Set device name */
 
126
    strncpy(pwrq->ifr_name, ifname, IFNAMSIZ);
 
127
 
 
128
    /* Do the request */
 
129
    ret = ioctl(sock, request, pwrq);
 
130
    if (ret < 0) {
 
131
        debug("ioctl(0x%04x) failed: %d '%s'", request, errno, strerror(errno));
 
132
    }
 
133
 
 
134
    return ret;
 
135
 
 
136
}
 
137
 
 
138
int get_range_info(const int sock, const char *ifname, struct iw_range *range)
 
139
{
 
140
    struct iwreq req;
 
141
    char buffer[sizeof(struct iw_range) * 2];   /* Large enough */
 
142
 
 
143
    if (sock <= 0) {
 
144
        return (-1);
 
145
    }
 
146
 
 
147
    /* Cleanup */
 
148
    memset(buffer, 0, sizeof(buffer));
 
149
 
 
150
    req.u.data.pointer = (caddr_t) buffer;
 
151
    req.u.data.length = sizeof(buffer);
 
152
    req.u.data.flags = 0;
 
153
    if (do_ioctl(sock, ifname, SIOCGIWRANGE, &req) < 0)
 
154
        return (-1);
 
155
 
 
156
    /* Copy stuff at the right place, ignore extra */
 
157
    memcpy((char *) range, buffer, sizeof(struct iw_range));
 
158
 
 
159
    return (0);
 
160
}
 
161
 
 
162
 
 
163
 
 
164
static int get_ifname(struct iwreq *preq, const char *dev)
 
165
{
 
166
    /* do not cache this call !!! */
 
167
    struct iwreq req;
 
168
    char key_buffer[32];
 
169
 
 
170
    if (sock <= 0) {
 
171
        return (-1);
 
172
    }
 
173
 
 
174
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_PROTO);
 
175
 
 
176
    if (!preq)
 
177
        preq = &req;
 
178
 
 
179
    if (do_ioctl(sock, dev, SIOCGIWNAME, preq)) {
 
180
        debug("%s isn't a wirelesss interface !", dev);
 
181
        return -1;
 
182
    }
 
183
 
 
184
    hash_put(&wireless, key_buffer, preq->u.name);
 
185
    return (0);
 
186
 
 
187
}
 
188
 
 
189
static int get_frequency(const char *dev, const char *key)
 
190
{
 
191
    /* Get frequency / channel */
 
192
    struct iwreq req;
 
193
    char qprintf_buffer[1024];
 
194
    char key_buffer[32];
 
195
    double freq;
 
196
    int age;
 
197
 
 
198
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
 
199
    age = hash_age(&wireless, key);
 
200
 
 
201
    /* reread every HASH_TTL msec only */
 
202
    if (age > 0 && age <= HASH_TTL) {
 
203
        return (0);
 
204
    }
 
205
 
 
206
    if (get_ifname(&req, dev) != 0) {
 
207
        return (-1);
 
208
    }
 
209
 
 
210
    req.u.data.length = 0;
 
211
    req.u.data.flags = 1;       /* Clear updated flag */
 
212
 
 
213
    if (do_ioctl(sock, dev, SIOCGIWFREQ, &req) < 0) {
 
214
        ioctl_error(__LINE__);
 
215
        return -1;
 
216
    }
 
217
 
 
218
    freq = FREQ2FLOAT(req.u.freq.m, req.u.freq.e);
 
219
 
 
220
    /*if( freq>= GIGA)
 
221
       snprintf(qprintf_buffer,sizeof(qprintf_buffer), "%g GHz", freq / GIGA);
 
222
       else
 
223
       if(freq>= MEGA)
 
224
       snprintf(qprintf_buffer,sizeof(qprintf_buffer), "%g MHz", freq / MEGA);
 
225
       else
 
226
       snprintf(qprintf_buffer,sizeof(qprintf_buffer), "%g kHz", freq / KILO);
 
227
     */
 
228
    snprintf(qprintf_buffer, sizeof(qprintf_buffer), "%g", freq);
 
229
 
 
230
    hash_put(&wireless, key_buffer, qprintf_buffer);
 
231
    return (0);
 
232
 
 
233
}
 
234
 
 
235
static int get_essid(const char *dev, const char *key)
 
236
{
 
237
    /* Get ESSID */
 
238
    struct iwreq req;
 
239
    char key_buffer[32];
 
240
    char essid_buffer[IW_ESSID_MAX_SIZE + 1];
 
241
    int age;
 
242
 
 
243
 
 
244
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
 
245
    age = hash_age(&wireless, key);
 
246
 
 
247
    /* reread every HASH_TTL msec only */
 
248
    if (age > 0 && age <= HASH_TTL) {
 
249
        return (0);
 
250
    }
 
251
 
 
252
    if (get_ifname(&req, dev) != 0) {
 
253
        return (-1);
 
254
    }
 
255
 
 
256
    memset(essid_buffer, 0, sizeof(essid_buffer));
 
257
    req.u.essid.pointer = (caddr_t) essid_buffer;
 
258
    req.u.essid.length = IW_ESSID_MAX_SIZE + 1;
 
259
    req.u.essid.flags = 0;
 
260
 
 
261
    if (do_ioctl(sock, dev, SIOCGIWESSID, &req) < 0) {
 
262
        ioctl_error(__LINE__);
 
263
        return -1;
 
264
    }
 
265
 
 
266
    hash_put(&wireless, key_buffer, essid_buffer);
 
267
    return (0);
 
268
 
 
269
}
 
270
 
 
271
static int get_op_mode(const char *dev, const char *key)
 
272
{
 
273
    /* Get operation mode */
 
274
    struct iwreq req;
 
275
    char key_buffer[32];
 
276
    int age;
 
277
 
 
278
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
 
279
    age = hash_age(&wireless, key);
 
280
 
 
281
    /* reread every HASH_TTL msec only */
 
282
    if (age > 0 && age <= HASH_TTL) {
 
283
        return (0);
 
284
    }
 
285
 
 
286
    if (get_ifname(&req, dev) != 0) {
 
287
        return (-1);
 
288
    }
 
289
 
 
290
    if (do_ioctl(sock, dev, SIOCGIWMODE, &req) < 0) {
 
291
        ioctl_error(__LINE__);
 
292
        return -1;
 
293
    }
 
294
 
 
295
    /* Fixme: req.u.mode is unsigned and therefore never < 0 */
 
296
    /* if((req.u.mode > 6) || (req.u.mode < 0)) { */
 
297
 
 
298
    if (req.u.mode > 6) {
 
299
        req.u.mode = 7;         /* mode not available */
 
300
    }
 
301
 
 
302
    hash_put(&wireless, key_buffer, operation_mode[req.u.mode]);
 
303
    return (0);
 
304
 
 
305
}
 
306
 
 
307
static int get_bitrate(const char *dev, const char *key)
 
308
{
 
309
    /* Get bit rate */
 
310
    struct iwreq req;
 
311
    char key_buffer[32];
 
312
    char bitrate_buffer[64];
 
313
    int age;
 
314
    double bitrate = 0;
 
315
 
 
316
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
 
317
    age = hash_age(&wireless, key);
 
318
 
 
319
    /* reread every HASH_TTL msec only */
 
320
    if (age > 0 && age <= HASH_TTL) {
 
321
        return (0);
 
322
    }
 
323
 
 
324
    if (get_ifname(&req, dev) != 0) {
 
325
        return (-1);
 
326
    }
 
327
 
 
328
    if (do_ioctl(sock, dev, SIOCGIWRATE, &req) < 0) {
 
329
        ioctl_error(__LINE__);
 
330
        return -1;
 
331
    }
 
332
 
 
333
    bitrate_buffer[0] = '\0';
 
334
    bitrate = (double) (req.u.bitrate.value);
 
335
/*  if( bitrate>= GIGA)
 
336
    snprintf(bitrate_buffer,sizeof(bitrate_buffer), "%gGb/s", bitrate / GIGA);
 
337
  else
 
338
    if(bitrate >= MEGA)
 
339
      snprintf(bitrate_buffer,sizeof(bitrate_buffer), "%gMb/s", bitrate / MEGA);
 
340
    else
 
341
      snprintf(bitrate_buffer,sizeof(bitrate_buffer), "%gkb/s", bitrate / KILO);
 
342
*/
 
343
    snprintf(bitrate_buffer, sizeof(bitrate_buffer), "%g", bitrate);
 
344
 
 
345
    hash_put(&wireless, key_buffer, bitrate_buffer);
 
346
 
 
347
    return (0);
 
348
}
 
349
 
 
350
static int get_sens(const char *dev, const char *key)
 
351
{
 
352
    /* Get sensitivity */
 
353
    struct iwreq req;
 
354
    struct iw_range range;
 
355
    char key_buffer[32];
 
356
    char buffer[64];
 
357
    int age;
 
358
    int has_sens = 0;
 
359
    int has_range = 0;
 
360
 
 
361
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
 
362
    age = hash_age(&wireless, key);
 
363
 
 
364
    /* reread every HASH_TTL msec only */
 
365
    if (age > 0 && age <= HASH_TTL) {
 
366
        return (0);
 
367
    }
 
368
 
 
369
    if (get_ifname(&req, dev) != 0) {
 
370
        return (-1);
 
371
    }
 
372
 
 
373
    if (do_ioctl(sock, dev, SIOCGIWSENS, &req) >= 0) {
 
374
        has_sens = 1;
 
375
    }
 
376
 
 
377
    if (get_range_info(sock, dev, &range) < 0) {
 
378
        memset(&range, 0, sizeof(range));
 
379
    } else {
 
380
        has_range = 1;
 
381
    }
 
382
 
 
383
    if (has_range) {
 
384
        if (req.u.sens.value < 0) {
 
385
            qprintf(buffer, sizeof(buffer), "%d dBm", req.u.sens.value);
 
386
        } else {
 
387
            qprintf(buffer, sizeof(buffer), "%d/%d", req.u.sens.value, range.sensitivity);
 
388
        }
 
389
    } else {
 
390
        qprintf(buffer, sizeof(buffer), "%d", req.u.sens.value);
 
391
    }
 
392
 
 
393
    hash_put(&wireless, key_buffer, buffer);
 
394
    return (0);
 
395
}
 
396
 
 
397
 
 
398
static int get_sec_mode(const char *dev, const char *key)
 
399
{
 
400
    /* Get encryption information  */
 
401
    struct iwreq req;
 
402
    char key_buffer[32];
 
403
    char encrypt_key[IW_ENCODING_TOKEN_MAX + 1];
 
404
    int age;
 
405
    int has_key = 0;
 
406
    int key_flags = 0;
 
407
    int key_size = 0;
 
408
 
 
409
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
 
410
    age = hash_age(&wireless, key);
 
411
 
 
412
    /* reread every HASH_TTL msec only */
 
413
    if (age > 0 && age <= HASH_TTL) {
 
414
        return (0);
 
415
    }
 
416
 
 
417
    if (get_ifname(&req, dev) != 0) {
 
418
        return (-1);
 
419
    }
 
420
 
 
421
    req.u.data.pointer = (caddr_t) & encrypt_key;
 
422
    req.u.data.length = IW_ENCODING_TOKEN_MAX;
 
423
    req.u.data.flags = 0;
 
424
 
 
425
    if (do_ioctl(sock, dev, SIOCGIWENCODE, &req) >= 0) {
 
426
        has_key = 1;
 
427
        key_flags = req.u.data.flags;
 
428
        key_size = req.u.data.length;
 
429
    } else {
 
430
        return (-1);
 
431
    }
 
432
 
 
433
    /* Display encryption information  */
 
434
    /*if(has_key && (key_flags & IW_ENCODE_INDEX) > 1) */
 
435
    /*  printf(" [%d]", info->key_flags & IW_ENCODE_INDEX); */
 
436
 
 
437
    if (has_key && (key_flags & IW_ENCODE_RESTRICTED))
 
438
        hash_put(&wireless, key_buffer, "restricted");
 
439
    else if (has_key && (key_flags & IW_ENCODE_OPEN))
 
440
        hash_put(&wireless, key_buffer, "open");
 
441
 
 
442
    return (0);
 
443
}
 
444
 
 
445
static int get_stats(const char *dev, const char *key)
 
446
{
 
447
    struct iw_statistics stats;
 
448
    struct iwreq req;
 
449
    char qprintf_buffer[1024];
 
450
    char key_buffer[32];
 
451
    int age;
 
452
    struct iw_range range;
 
453
 
 
454
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
 
455
    age = hash_age(&wireless, key);
 
456
 
 
457
    /* reread every HASH_TTL msec only */
 
458
    if (age > 0 && age <= HASH_TTL) {
 
459
        return (0);
 
460
    }
 
461
 
 
462
    if (get_ifname(&req, dev) != 0) {
 
463
        return (-1);
 
464
    }
 
465
 
 
466
    req.u.data.pointer = (caddr_t) & stats;
 
467
    req.u.data.length = sizeof(stats);
 
468
    req.u.data.flags = 1;       /* Clear updated flag */
 
469
 
 
470
    if (do_ioctl(sock, dev, SIOCGIWSTATS, &req) < 0) {
 
471
        ioctl_error(__LINE__);
 
472
        return -1;
 
473
    }
 
474
 
 
475
    if (get_range_info(sock, dev, &range) < 0)
 
476
        memset(&range, 0, sizeof(range));
 
477
 
 
478
    if (stats.qual.level > range.max_qual.level) {
 
479
        qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d", stats.qual.level - 0x100);
 
480
        qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
 
481
        hash_put(&wireless, key_buffer, qprintf_buffer);
 
482
 
 
483
        qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d", stats.qual.noise - 0x100);
 
484
        qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_NOISE);
 
485
        hash_put(&wireless, key_buffer, qprintf_buffer);
 
486
 
 
487
        qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.qual, range.max_qual.qual);
 
488
        qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_QUALITY);
 
489
        hash_put(&wireless, key_buffer, qprintf_buffer);
 
490
    } else {
 
491
 
 
492
        qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.level, range.max_qual.level);
 
493
        qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
 
494
        hash_put(&wireless, key_buffer, qprintf_buffer);
 
495
 
 
496
        qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.noise, range.max_qual.noise);
 
497
        qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_NOISE);
 
498
        hash_put(&wireless, key_buffer, qprintf_buffer);
 
499
 
 
500
        qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.qual, range.max_qual.qual);
 
501
        qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_QUALITY);
 
502
        hash_put(&wireless, key_buffer, qprintf_buffer);
 
503
    }
 
504
 
 
505
    return 0;
 
506
}
 
507
 
 
508
static int check_socket()
 
509
{
 
510
 
 
511
    /* already handled in a previous run */
 
512
    if (sock == -3)
 
513
        return (-1);
 
514
 
 
515
    /* socket not initialized */
 
516
    if (sock == -2)
 
517
        sock = socket(AF_INET, SOCK_DGRAM, 0);
 
518
 
 
519
    /* error initilalizing socket */
 
520
    if (sock <= 0) {
 
521
        error("Error opening socket for reading wireless stats");
 
522
        sock = -3;
 
523
        return (-1);
 
524
    }
 
525
 
 
526
    return (0);
 
527
 
 
528
}
 
529
 
 
530
static void save_result(RESULT * result, const char *dev, const char *key, const int res)
 
531
{
 
532
    char key_buffer[64];
 
533
    char *val = NULL;
 
534
    qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
 
535
 
 
536
    if (res < 0) {
 
537
        SetResult(&result, R_STRING, "");
 
538
        return;
 
539
    }
 
540
 
 
541
    val = hash_get(&wireless, key_buffer, NULL);
 
542
 
 
543
    if (val) {
 
544
        SetResult(&result, R_STRING, val);
 
545
    } else {
 
546
        SetResult(&result, R_STRING, "");
 
547
    }
 
548
 
 
549
 
 
550
}
 
551
 
 
552
/* 
 
553
 *functions exported to the evaluator 
 
554
*/
 
555
 
 
556
static void wireless_quality(RESULT * result, RESULT * arg1)
 
557
{
 
558
    char *dev = R2S(arg1);
 
559
    if (check_socket() != 0)
 
560
        return;
 
561
 
 
562
    save_result(result, dev, KEY_QUALITY, get_stats(dev, KEY_QUALITY));
 
563
}
 
564
 
 
565
static void wireless_level(RESULT * result, RESULT * arg1)
 
566
{
 
567
    char *dev = R2S(arg1);
 
568
    if (check_socket() != 0)
 
569
        return;
 
570
 
 
571
    save_result(result, dev, KEY_LEVEL, get_stats(dev, KEY_LEVEL));
 
572
}
 
573
 
 
574
 
 
575
static void wireless_noise(RESULT * result, RESULT * arg1)
 
576
{
 
577
    char *dev = R2S(arg1);
 
578
    if (check_socket() != 0)
 
579
        return;
 
580
 
 
581
    save_result(result, dev, KEY_NOISE, get_stats(dev, KEY_NOISE));
 
582
}
 
583
 
 
584
 
 
585
static void wireless_protocol(RESULT * result, RESULT * arg1)
 
586
{
 
587
    char *dev = R2S(arg1);
 
588
    if (check_socket() != 0)
 
589
        return;
 
590
 
 
591
    save_result(result, dev, KEY_PROTO, get_ifname(NULL, dev));
 
592
}
 
593
 
 
594
static void wireless_frequency(RESULT * result, RESULT * arg1)
 
595
{
 
596
    char *dev = R2S(arg1);
 
597
    if (check_socket() != 0)
 
598
        return;
 
599
 
 
600
    save_result(result, dev, KEY_FREQUENCY, get_frequency(dev, KEY_FREQUENCY));
 
601
}
 
602
 
 
603
static void wireless_bitrate(RESULT * result, RESULT * arg1)
 
604
{
 
605
    char *dev = R2S(arg1);
 
606
    if (check_socket() != 0)
 
607
        return;
 
608
 
 
609
    save_result(result, dev, KEY_BIT_RATE, get_bitrate(dev, KEY_BIT_RATE));
 
610
}
 
611
 
 
612
static void wireless_essid(RESULT * result, RESULT * arg1)
 
613
{
 
614
    char *dev = R2S(arg1);
 
615
    if (check_socket() != 0)
 
616
        return;
 
617
 
 
618
    save_result(result, dev, KEY_ESSID, get_essid(dev, KEY_ESSID));
 
619
}
 
620
 
 
621
static void wireless_op_mode(RESULT * result, RESULT * arg1)
 
622
{
 
623
    char *dev = R2S(arg1);
 
624
    if (check_socket() != 0)
 
625
        return;
 
626
 
 
627
    save_result(result, dev, KEY_OP_MODE, get_op_mode(dev, KEY_OP_MODE));
 
628
}
 
629
 
 
630
static void wireless_sensitivity(RESULT * result, RESULT * arg1)
 
631
{
 
632
    char *dev = R2S(arg1);
 
633
    if (check_socket() != 0)
 
634
        return;
 
635
 
 
636
    save_result(result, dev, KEY_SENS, get_sens(dev, KEY_SENS));
 
637
}
 
638
 
 
639
static void wireless_sec_mode(RESULT * result, RESULT * arg1)
 
640
{
 
641
    char *dev = R2S(arg1);
 
642
    if (check_socket() != 0)
 
643
        return;
 
644
 
 
645
    save_result(result, dev, KEY_SEC_MODE, get_sec_mode(dev, KEY_SEC_MODE));
 
646
}
 
647
 
 
648
/*
 
649
init and cleanup
 
650
*/
 
651
 
 
652
int plugin_init_wireless(void)
 
653
{
 
654
    hash_create(&wireless);
 
655
 
 
656
    AddFunction("wifi::level", 1, wireless_level);
 
657
    AddFunction("wifi::noise", 1, wireless_noise);
 
658
    AddFunction("wifi::quality", 1, wireless_quality);
 
659
    AddFunction("wifi::protocol", 1, wireless_protocol);
 
660
    AddFunction("wifi::frequency", 1, wireless_frequency);
 
661
    AddFunction("wifi::bitrate", 1, wireless_bitrate);
 
662
    AddFunction("wifi::essid", 1, wireless_essid);
 
663
    AddFunction("wifi::op_mode", 1, wireless_op_mode);
 
664
    AddFunction("wifi::sensitivity", 1, wireless_sensitivity);
 
665
    AddFunction("wifi::sec_mode", 1, wireless_sec_mode);
 
666
 
 
667
    return 0;
 
668
}
 
669
 
 
670
void plugin_exit_wireless(void)
 
671
{
 
672
    if (sock > 0)
 
673
        close(sock);
 
674
    hash_destroy(&wireless);
 
675
}