← Back to branch summary

~ubuntu-branches/ubuntu/lucid/wpasupplicant/lucid-updates

« back to all changes in this revision

Viewing changes to wpa_gui-qt4/wpagui.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Kel Modderman
  • Date: 2006-10-05 08:04:01 UTC
  • mfrom: (1.1.5 upstream) (3 etch)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20061005080401-r8lqlix4390yos7b
Tags: 0.5.5-2
http://bugs.debian.org/388316
* Update madwifi headers to latest SVN. (Closes: #388316)
* Remove failed attempt at action locking. [debian/functions.sh,
  debian/wpa_action.sh]
* Add hysteresis checking functions, to avoid "event loops" while
  using wpa-roam. [debian/functions.sh, debian/wpa_action.sh]
* Change of co-maintainer email address.
* Add ishex() function to functions.sh to determine wpa-psk value type in
  plaintext or hex. This effectively eliminates the need for the bogus and
  somewhat confusing wpa-passphrase contruct specific to our scripts and
  allows wpa-psk to work with either a 8 to 63 character long plaintext
  string or 64 character long hex string.
* Adjust README.modes to not refer to the redundant wpa-passphrase stuff.
* Add big fat NOTE about acceptable wpa-psk's to top of example gallery.
* Strip surrounding quotes from wpa-ssid if present, instead of just whining
  about them.
* Update email address in copyright blurb of functions.sh, ifupdown.sh and
  wpa_action.sh.  

Show diffs side-by-side

added added

removed removed

Lines of Context:
wpa_gui-qt4/wpagui.cpp
 
1
/*
 
2
 * wpa_gui - WpaGui class
 
3
 * Copyright (c) 2005-2006, Jouni Malinen <jkmaline@cc.hut.fi>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License version 2 as
 
7
 * published by the Free Software Foundation.
 
8
 *
 
9
 * Alternatively, this software may be distributed under the terms of BSD
 
10
 * license.
 
11
 *
 
12
 * See README and COPYING for more details.
 
13
 */
 
14
 
 
15
#ifdef __MINGW32__
 
16
/* Need to get getopt() */
 
17
#include <unistd.h>
 
18
#endif
 
19
 
 
20
#include <QMessageBox>
 
21
 
 
22
#include "wpagui.h"
 
23
#include "dirent.h"
 
24
#include "wpa_ctrl.h"
 
25
#include "userdatarequest.h"
 
26
#include "networkconfig.h"
 
27
 
 
28
WpaGui::WpaGui(QWidget *parent, const char *, Qt::WFlags)
 
29
        : QMainWindow(parent)
 
30
{
 
31
        setupUi(this);
 
32
 
 
33
        (void) statusBar();
 
34
 
 
35
        connect(helpIndexAction, SIGNAL(activated()), this, SLOT(helpIndex()));
 
36
        connect(helpContentsAction, SIGNAL(activated()), this,
 
37
                SLOT(helpContents()));
 
38
        connect(helpAboutAction, SIGNAL(activated()), this, SLOT(helpAbout()));
 
39
        connect(fileExitAction, SIGNAL(activated()), this, SLOT(close()));
 
40
        connect(disconnectButton, SIGNAL(clicked()), this, SLOT(disconnect()));
 
41
        connect(scanButton, SIGNAL(clicked()), this, SLOT(scan()));
 
42
        connect(connectButton, SIGNAL(clicked()), this, SLOT(connectB()));
 
43
        connect(fileEventHistoryAction, SIGNAL(activated()), this,
 
44
                SLOT(eventHistory()));
 
45
        connect(networkSelect, SIGNAL(activated(const QString&)), this,
 
46
                SLOT(selectNetwork(const QString&)));
 
47
        connect(fileEdit_networkAction, SIGNAL(activated()), this,
 
48
                SLOT(editNetwork()));
 
49
        connect(fileAdd_NetworkAction, SIGNAL(activated()), this,
 
50
                SLOT(addNetwork()));
 
51
        connect(adapterSelect, SIGNAL(activated(const QString&)), this,
 
52
                SLOT(selectAdapter(const QString&)));
 
53
 
 
54
        eh = NULL;
 
55
        scanres = NULL;
 
56
        udr = NULL;
 
57
        ctrl_iface = NULL;
 
58
        ctrl_conn = NULL;
 
59
        monitor_conn = NULL;
 
60
        msgNotifier = NULL;
 
61
        ctrl_iface_dir = strdup("/var/run/wpa_supplicant");
 
62
 
 
63
        parse_argv();
 
64
 
 
65
        textStatus->setText("connecting to wpa_supplicant");
 
66
        timer = new QTimer(this);
 
67
        connect(timer, SIGNAL(timeout()), SLOT(ping()));
 
68
        timer->start(1000, FALSE);
 
69
 
 
70
        if (openCtrlConnection(ctrl_iface) < 0) {
 
71
                printf("Failed to open control connection to "
 
72
                       "wpa_supplicant.\n");
 
73
        }
 
74
 
 
75
        updateStatus();
 
76
        networkMayHaveChanged = true;
 
77
        updateNetworks();
 
78
}
 
79
 
 
80
 
 
81
WpaGui::~WpaGui()
 
82
{
 
83
        delete msgNotifier;
 
84
 
 
85
        if (monitor_conn) {
 
86
                wpa_ctrl_detach(monitor_conn);
 
87
                wpa_ctrl_close(monitor_conn);
 
88
                monitor_conn = NULL;
 
89
        }
 
90
        if (ctrl_conn) {
 
91
                wpa_ctrl_close(ctrl_conn);
 
92
                ctrl_conn = NULL;
 
93
        }
 
94
 
 
95
        if (eh) {
 
96
                eh->close();
 
97
                delete eh;
 
98
                eh = NULL;
 
99
        }
 
100
 
 
101
        if (scanres) {
 
102
                scanres->close();
 
103
                delete scanres;
 
104
                scanres = NULL;
 
105
        }
 
106
 
 
107
        if (udr) {
 
108
                udr->close();
 
109
                delete udr;
 
110
                udr = NULL;
 
111
        }
 
112
 
 
113
        free(ctrl_iface);
 
114
        ctrl_iface = NULL;
 
115
 
 
116
        free(ctrl_iface_dir);
 
117
        ctrl_iface_dir = NULL;
 
118
}
 
119
 
 
120
 
 
121
void WpaGui::languageChange()
 
122
{
 
123
        retranslateUi(this);
 
124
}
 
125
 
 
126
 
 
127
void WpaGui::parse_argv()
 
128
{
 
129
        int c;
 
130
        for (;;) {
 
131
                c = getopt(qApp->argc(), qApp->argv(), "i:p:");
 
132
                if (c < 0)
 
133
                        break;
 
134
                switch (c) {
 
135
                case 'i':
 
136
                        free(ctrl_iface);
 
137
                        ctrl_iface = strdup(optarg);
 
138
                        break;
 
139
                case 'p':
 
140
                        free(ctrl_iface_dir);
 
141
                        ctrl_iface_dir = strdup(optarg);
 
142
                        break;
 
143
                }
 
144
        }
 
145
}
 
146
 
 
147
 
 
148
int WpaGui::openCtrlConnection(const char *ifname)
 
149
{
 
150
        char *cfile;
 
151
        int flen;
 
152
        char buf[2048], *pos, *pos2;
 
153
        size_t len;
 
154
 
 
155
        if (ifname) {
 
156
                if (ifname != ctrl_iface) {
 
157
                        free(ctrl_iface);
 
158
                        ctrl_iface = strdup(ifname);
 
159
                }
 
160
        } else {
 
161
#ifdef CONFIG_CTRL_IFACE_UDP
 
162
                free(ctrl_iface);
 
163
                ctrl_iface = strdup("udp");
 
164
#endif /* CONFIG_CTRL_IFACE_UDP */
 
165
#ifdef CONFIG_CTRL_IFACE_UNIX
 
166
                struct dirent *dent;
 
167
                DIR *dir = opendir(ctrl_iface_dir);
 
168
                free(ctrl_iface);
 
169
                ctrl_iface = NULL;
 
170
                if (dir) {
 
171
                        while ((dent = readdir(dir))) {
 
172
#ifdef _DIRENT_HAVE_D_TYPE
 
173
                                /* Skip the file if it is not a socket.
 
174
                                 * Also accept DT_UNKNOWN (0) in case
 
175
                                 * the C library or underlying file
 
176
                                 * system does not support d_type. */
 
177
                                if (dent->d_type != DT_SOCK &&
 
178
                                    dent->d_type != DT_UNKNOWN)
 
179
                                        continue;
 
180
#endif /* _DIRENT_HAVE_D_TYPE */
 
181
 
 
182
                                if (strcmp(dent->d_name, ".") == 0 ||
 
183
                                    strcmp(dent->d_name, "..") == 0)
 
184
                                        continue;
 
185
                                printf("Selected interface '%s'\n",
 
186
                                       dent->d_name);
 
187
                                ctrl_iface = strdup(dent->d_name);
 
188
                                break;
 
189
                        }
 
190
                        closedir(dir);
 
191
                }
 
192
#endif /* CONFIG_CTRL_IFACE_UNIX */
 
193
#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
 
194
                struct wpa_ctrl *ctrl;
 
195
                int ret;
 
196
 
 
197
                free(ctrl_iface);
 
198
                ctrl_iface = NULL;
 
199
 
 
200
                ctrl = wpa_ctrl_open(NULL);
 
201
                if (ctrl) {
 
202
                        len = sizeof(buf) - 1;
 
203
                        ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf,
 
204
                                               &len, NULL);
 
205
                        if (ret >= 0) {
 
206
                                buf[len] = '\0';
 
207
                                pos = strchr(buf, '\n');
 
208
                                if (pos)
 
209
                                        *pos = '\0';
 
210
                                ctrl_iface = strdup(buf);
 
211
                        }
 
212
                        wpa_ctrl_close(ctrl);
 
213
                }
 
214
#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
 
215
        }
 
216
 
 
217
        if (ctrl_iface == NULL)
 
218
                return -1;
 
219
 
 
220
#ifdef CONFIG_CTRL_IFACE_UNIX
 
221
        flen = strlen(ctrl_iface_dir) + strlen(ctrl_iface) + 2;
 
222
        cfile = (char *) malloc(flen);
 
223
        if (cfile == NULL)
 
224
                return -1;
 
225
        snprintf(cfile, flen, "%s/%s", ctrl_iface_dir, ctrl_iface);
 
226
#else /* CONFIG_CTRL_IFACE_UNIX */
 
227
        flen = strlen(ctrl_iface) + 1;
 
228
        cfile = (char *) malloc(flen);
 
229
        if (cfile == NULL)
 
230
                return -1;
 
231
        snprintf(cfile, flen, "%s", ctrl_iface);
 
232
#endif /* CONFIG_CTRL_IFACE_UNIX */
 
233
 
 
234
        if (ctrl_conn) {
 
235
                wpa_ctrl_close(ctrl_conn);
 
236
                ctrl_conn = NULL;
 
237
        }
 
238
 
 
239
        if (monitor_conn) {
 
240
                delete msgNotifier;
 
241
                msgNotifier = NULL;
 
242
                wpa_ctrl_detach(monitor_conn);
 
243
                wpa_ctrl_close(monitor_conn);
 
244
                monitor_conn = NULL;
 
245
        }
 
246
 
 
247
        printf("Trying to connect to '%s'\n", cfile);
 
248
        ctrl_conn = wpa_ctrl_open(cfile);
 
249
        if (ctrl_conn == NULL) {
 
250
                free(cfile);
 
251
                return -1;
 
252
        }
 
253
        monitor_conn = wpa_ctrl_open(cfile);
 
254
        free(cfile);
 
255
        if (monitor_conn == NULL) {
 
256
                wpa_ctrl_close(ctrl_conn);
 
257
                return -1;
 
258
        }
 
259
        if (wpa_ctrl_attach(monitor_conn)) {
 
260
                printf("Failed to attach to wpa_supplicant\n");
 
261
                wpa_ctrl_close(monitor_conn);
 
262
                monitor_conn = NULL;
 
263
                wpa_ctrl_close(ctrl_conn);
 
264
                ctrl_conn = NULL;
 
265
                return -1;
 
266
        }
 
267
 
 
268
#if defined(CONFIG_CTRL_IFACE_UNIX) || defined(CONFIG_CTRL_IFACE_UDP)
 
269
        msgNotifier = new QSocketNotifier(wpa_ctrl_get_fd(monitor_conn),
 
270
                                          QSocketNotifier::Read, this);
 
271
        connect(msgNotifier, SIGNAL(activated(int)), SLOT(receiveMsgs()));
 
272
#endif
 
273
 
 
274
        adapterSelect->clear();
 
275
        adapterSelect->insertItem(ctrl_iface);
 
276
        adapterSelect->setCurrentItem(0);
 
277
 
 
278
        len = sizeof(buf) - 1;
 
279
        if (wpa_ctrl_request(ctrl_conn, "INTERFACES", 10, buf, &len, NULL) >=
 
280
            0) {
 
281
                buf[len] = '\0';
 
282
                pos = buf;
 
283
                while (*pos) {
 
284
                        pos2 = strchr(pos, '\n');
 
285
                        if (pos2)
 
286
                                *pos2 = '\0';
 
287
                        if (strcmp(pos, ctrl_iface) != 0)
 
288
                                adapterSelect->insertItem(pos);
 
289
                        if (pos2)
 
290
                                pos = pos2 + 1;
 
291
                        else
 
292
                                break;
 
293
                }
 
294
        }
 
295
 
 
296
        return 0;
 
297
}
 
298
 
 
299
 
 
300
static void wpa_gui_msg_cb(char *msg, size_t)
 
301
{
 
302
        /* This should not happen anymore since two control connections are
 
303
         * used. */
 
304
        printf("missed message: %s\n", msg);
 
305
}
 
306
 
 
307
 
 
308
int WpaGui::ctrlRequest(const char *cmd, char *buf, size_t *buflen)
 
309
{
 
310
        int ret;
 
311
 
 
312
        if (ctrl_conn == NULL)
 
313
                return -3;
 
314
        ret = wpa_ctrl_request(ctrl_conn, cmd, strlen(cmd), buf, buflen,
 
315
                               wpa_gui_msg_cb);
 
316
        if (ret == -2)
 
317
                printf("'%s' command timed out.\n", cmd);
 
318
        else if (ret < 0)
 
319
                printf("'%s' command failed.\n", cmd);
 
320
 
 
321
        return ret;
 
322
}
 
323
 
 
324
 
 
325
void WpaGui::updateStatus()
 
326
{
 
327
        char buf[2048], *start, *end, *pos;
 
328
        size_t len;
 
329
 
 
330
        pingsToStatusUpdate = 10;
 
331
 
 
332
        len = sizeof(buf) - 1;
 
333
        if (ctrl_conn == NULL || ctrlRequest("STATUS", buf, &len) < 0) {
 
334
                textStatus->setText("Could not get status from "
 
335
                                    "wpa_supplicant");
 
336
                textAuthentication->clear();
 
337
                textEncryption->clear();
 
338
                textSsid->clear();
 
339
                textBssid->clear();
 
340
                textIpAddress->clear();
 
341
                return;
 
342
        }
 
343
 
 
344
        buf[len] = '\0';
 
345
 
 
346
        bool auth_updated = false, ssid_updated = false;
 
347
        bool bssid_updated = false, ipaddr_updated = false;
 
348
        bool status_updated = false;
 
349
        char *pairwise_cipher = NULL, *group_cipher = NULL;
 
350
 
 
351
        start = buf;
 
352
        while (*start) {
 
353
                bool last = false;
 
354
                end = strchr(start, '\n');
 
355
                if (end == NULL) {
 
356
                        last = true;
 
357
                        end = start;
 
358
                        while (end[0] && end[1])
 
359
                                end++;
 
360
                }
 
361
                *end = '\0';
 
362
 
 
363
                pos = strchr(start, '=');
 
364
                if (pos) {
 
365
                        *pos++ = '\0';
 
366
                        if (strcmp(start, "bssid") == 0) {
 
367
                                bssid_updated = true;
 
368
                                textBssid->setText(pos);
 
369
                        } else if (strcmp(start, "ssid") == 0) {
 
370
                                ssid_updated = true;
 
371
                                textSsid->setText(pos);
 
372
                        } else if (strcmp(start, "ip_address") == 0) {
 
373
                                ipaddr_updated = true;
 
374
                                textIpAddress->setText(pos);
 
375
                        } else if (strcmp(start, "wpa_state") == 0) {
 
376
                                status_updated = true;
 
377
                                textStatus->setText(pos);
 
378
                        } else if (strcmp(start, "key_mgmt") == 0) {
 
379
                                auth_updated = true;
 
380
                                textAuthentication->setText(pos);
 
381
                                /* TODO: could add EAP status to this */
 
382
                        } else if (strcmp(start, "pairwise_cipher") == 0) {
 
383
                                pairwise_cipher = pos;
 
384
                        } else if (strcmp(start, "group_cipher") == 0) {
 
385
                                group_cipher = pos;
 
386
                        }
 
387
                }
 
388
 
 
389
                if (last)
 
390
                        break;
 
391
                start = end + 1;
 
392
        }
 
393
 
 
394
        if (pairwise_cipher || group_cipher) {
 
395
                QString encr;
 
396
                if (pairwise_cipher && group_cipher &&
 
397
                    strcmp(pairwise_cipher, group_cipher) != 0) {
 
398
                        encr.append(pairwise_cipher);
 
399
                        encr.append(" + ");
 
400
                        encr.append(group_cipher);
 
401
                } else if (pairwise_cipher) {
 
402
                        encr.append(pairwise_cipher);
 
403
                } else if (group_cipher) {
 
404
                        encr.append(group_cipher);
 
405
                        encr.append(" [group key only]");
 
406
                } else {
 
407
                        encr.append("?");
 
408
                }
 
409
                textEncryption->setText(encr);
 
410
        } else
 
411
                textEncryption->clear();
 
412
 
 
413
        if (!status_updated)
 
414
                textStatus->clear();
 
415
        if (!auth_updated)
 
416
                textAuthentication->clear();
 
417
        if (!ssid_updated)
 
418
                textSsid->clear();
 
419
        if (!bssid_updated)
 
420
                textBssid->clear();
 
421
        if (!ipaddr_updated)
 
422
                textIpAddress->clear();
 
423
}
 
424
 
 
425
 
 
426
void WpaGui::updateNetworks()
 
427
{
 
428
        char buf[2048], *start, *end, *id, *ssid, *bssid, *flags;
 
429
        size_t len;
 
430
        int first_active = -1;
 
431
        bool selected = false;
 
432
 
 
433
        if (!networkMayHaveChanged)
 
434
                return;
 
435
 
 
436
        networkSelect->clear();
 
437
 
 
438
        if (ctrl_conn == NULL)
 
439
                return;
 
440
 
 
441
        len = sizeof(buf) - 1;
 
442
        if (ctrlRequest("LIST_NETWORKS", buf, &len) < 0)
 
443
                return;
 
444
 
 
445
        buf[len] = '\0';
 
446
        start = strchr(buf, '\n');
 
447
        if (start == NULL)
 
448
                return;
 
449
        start++;
 
450
 
 
451
        while (*start) {
 
452
                bool last = false;
 
453
                end = strchr(start, '\n');
 
454
                if (end == NULL) {
 
455
                        last = true;
 
456
                        end = start;
 
457
                        while (end[0] && end[1])
 
458
                                end++;
 
459
                }
 
460
                *end = '\0';
 
461
 
 
462
                id = start;
 
463
                ssid = strchr(id, '\t');
 
464
                if (ssid == NULL)
 
465
                        break;
 
466
                *ssid++ = '\0';
 
467
                bssid = strchr(ssid, '\t');
 
468
                if (bssid == NULL)
 
469
                        break;
 
470
                *bssid++ = '\0';
 
471
                flags = strchr(bssid, '\t');
 
472
                if (flags == NULL)
 
473
                        break;
 
474
                *flags++ = '\0';
 
475
 
 
476
                QString network(id);
 
477
                network.append(": ");
 
478
                network.append(ssid);
 
479
                networkSelect->insertItem(network);
 
480
 
 
481
                if (strstr(flags, "[CURRENT]")) {
 
482
                        networkSelect->setCurrentItem(networkSelect->count() -
 
483
                                                      1);
 
484
                        selected = true;
 
485
                } else if (first_active < 0 &&
 
486
                           strstr(flags, "[DISABLED]") == NULL)
 
487
                        first_active = networkSelect->count() - 1;
 
488
 
 
489
                if (last)
 
490
                        break;
 
491
                start = end + 1;
 
492
        }
 
493
 
 
494
        if (!selected && first_active >= 0)
 
495
                networkSelect->setCurrentItem(first_active);
 
496
 
 
497
        networkMayHaveChanged = false;
 
498
}
 
499
 
 
500
 
 
501
void WpaGui::helpIndex()
 
502
{
 
503
        printf("helpIndex\n");
 
504
}
 
505
 
 
506
 
 
507
void WpaGui::helpContents()
 
508
{
 
509
        printf("helpContents\n");
 
510
}
 
511
 
 
512
 
 
513
void WpaGui::helpAbout()
 
514
{
 
515
        QMessageBox::about(this, "wpa_gui for wpa_supplicant",
 
516
                           "Copyright (c) 2003-2006,\n"
 
517
                           "Jouni Malinen <jkmaline@cc.hut.fi>\n"
 
518
                           "and contributors.\n"
 
519
                           "\n"
 
520
                           "This program is free software. You can\n"
 
521
                           "distribute it and/or modify it under the terms "
 
522
                           "of\n"
 
523
                           "the GNU General Public License version 2.\n"
 
524
                           "\n"
 
525
                           "Alternatively, this software may be distributed\n"
 
526
                           "under the terms of the BSD license.\n"
 
527
                           "\n"
 
528
                           "This product includes software developed\n"
 
529
                           "by the OpenSSL Project for use in the\n"
 
530
                           "OpenSSL Toolkit (http://www.openssl.org/)\n");
 
531
}
 
532
 
 
533
 
 
534
void WpaGui::disconnect()
 
535
{
 
536
        char reply[10];
 
537
        size_t reply_len = sizeof(reply);
 
538
        ctrlRequest("DISCONNECT", reply, &reply_len);
 
539
}
 
540
 
 
541
 
 
542
void WpaGui::scan()
 
543
{
 
544
        if (scanres) {
 
545
                scanres->close();
 
546
                delete scanres;
 
547
        }
 
548
 
 
549
        scanres = new ScanResults();
 
550
        if (scanres == NULL)
 
551
                return;
 
552
        scanres->setWpaGui(this);
 
553
        scanres->show();
 
554
        scanres->exec();
 
555
}
 
556
 
 
557
 
 
558
void WpaGui::eventHistory()
 
559
{
 
560
        if (eh) {
 
561
                eh->close();
 
562
                delete eh;
 
563
        }
 
564
 
 
565
        eh = new EventHistory();
 
566
        if (eh == NULL)
 
567
                return;
 
568
        eh->addEvents(msgs);
 
569
        eh->show();
 
570
        eh->exec();
 
571
}
 
572
 
 
573
 
 
574
void WpaGui::ping()
 
575
{
 
576
        char buf[10];
 
577
        size_t len;
 
578
 
 
579
#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
 
580
        /*
 
581
         * QSocketNotifier cannot be used with Windows named pipes, so use a
 
582
         * timer to check for received messages for now. This could be
 
583
         * optimized be doing something specific to named pipes or Windows
 
584
         * events, but it is not clear what would be the best way of doing that
 
585
         * in Qt.
 
586
         */
 
587
        receiveMsgs();
 
588
#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
 
589
 
 
590
        if (scanres && !scanres->isVisible()) {
 
591
                delete scanres;
 
592
                scanres = NULL;
 
593
        }
 
594
 
 
595
        if (eh && !eh->isVisible()) {
 
596
                delete eh;
 
597
                eh = NULL;
 
598
        }
 
599
 
 
600
        if (udr && !udr->isVisible()) {
 
601
                delete udr;
 
602
                udr = NULL;
 
603
        }
 
604
 
 
605
        len = sizeof(buf) - 1;
 
606
        if (ctrlRequest("PING", buf, &len) < 0) {
 
607
                printf("PING failed - trying to reconnect\n");
 
608
                if (openCtrlConnection(ctrl_iface) >= 0) {
 
609
                        printf("Reconnected successfully\n");
 
610
                        pingsToStatusUpdate = 0;
 
611
                }
 
612
        }
 
613
 
 
614
        pingsToStatusUpdate--;
 
615
        if (pingsToStatusUpdate <= 0) {
 
616
                updateStatus();
 
617
                updateNetworks();
 
618
        }
 
619
}
 
620
 
 
621
 
 
622
static int str_match(const char *a, const char *b)
 
623
{
 
624
        return strncmp(a, b, strlen(b)) == 0;
 
625
}
 
626
 
 
627
 
 
628
void WpaGui::processMsg(char *msg)
 
629
{
 
630
        char *pos = msg, *pos2;
 
631
        int priority = 2;
 
632
 
 
633
        if (*pos == '<') {
 
634
                /* skip priority */
 
635
                pos++;
 
636
                priority = atoi(pos);
 
637
                pos = strchr(pos, '>');
 
638
                if (pos)
 
639
                        pos++;
 
640
                else
 
641
                        pos = msg;
 
642
        }
 
643
 
 
644
        WpaMsg wm(pos, priority);
 
645
        if (eh)
 
646
                eh->addEvent(wm);
 
647
        msgs.append(wm);
 
648
        while (msgs.count() > 100)
 
649
                msgs.pop_front();
 
650
 
 
651
        /* Update last message with truncated version of the event */
 
652
        if (strncmp(pos, "CTRL-", 5) == 0) {
 
653
                pos2 = strchr(pos, str_match(pos, WPA_CTRL_REQ) ? ':' : ' ');
 
654
                if (pos2)
 
655
                        pos2++;
 
656
                else
 
657
                        pos2 = pos;
 
658
        } else
 
659
                pos2 = pos;
 
660
        QString lastmsg = pos2;
 
661
        lastmsg.truncate(40);
 
662
        textLastMessage->setText(lastmsg);
 
663
 
 
664
        pingsToStatusUpdate = 0;
 
665
        networkMayHaveChanged = true;
 
666
 
 
667
        if (str_match(pos, WPA_CTRL_REQ))
 
668
                processCtrlReq(pos + strlen(WPA_CTRL_REQ));
 
669
}
 
670
 
 
671
 
 
672
void WpaGui::processCtrlReq(const char *req)
 
673
{
 
674
        if (udr) {
 
675
                udr->close();
 
676
                delete udr;
 
677
        }
 
678
        udr = new UserDataRequest();
 
679
        if (udr == NULL)
 
680
                return;
 
681
        if (udr->setParams(this, req) < 0) {
 
682
                delete udr;
 
683
                udr = NULL;
 
684
                return;
 
685
        }
 
686
        udr->show();
 
687
        udr->exec();
 
688
}
 
689
 
 
690
 
 
691
void WpaGui::receiveMsgs()
 
692
{
 
693
        char buf[256];
 
694
        size_t len;
 
695
 
 
696
        while (monitor_conn && wpa_ctrl_pending(monitor_conn) > 0) {
 
697
                len = sizeof(buf) - 1;
 
698
                if (wpa_ctrl_recv(monitor_conn, buf, &len) == 0) {
 
699
                        buf[len] = '\0';
 
700
                        processMsg(buf);
 
701
                }
 
702
        }
 
703
}
 
704
 
 
705
 
 
706
void WpaGui::connectB()
 
707
{
 
708
        char reply[10];
 
709
        size_t reply_len = sizeof(reply);
 
710
        ctrlRequest("REASSOCIATE", reply, &reply_len);
 
711
}
 
712
 
 
713
 
 
714
void WpaGui::selectNetwork( const QString &sel )
 
715
{
 
716
        QString cmd(sel);
 
717
        char reply[10];
 
718
        size_t reply_len = sizeof(reply);
 
719
 
 
720
        int pos = cmd.find(':');
 
721
        if (pos < 0) {
 
722
                printf("Invalid selectNetwork '%s'\n", cmd.ascii());
 
723
                return;
 
724
        }
 
725
        cmd.truncate(pos);
 
726
        cmd.prepend("SELECT_NETWORK ");
 
727
        ctrlRequest(cmd.ascii(), reply, &reply_len);
 
728
}
 
729
 
 
730
 
 
731
void WpaGui::editNetwork()
 
732
{
 
733
        QString sel(networkSelect->currentText());
 
734
        int pos = sel.find(':');
 
735
        if (pos < 0) {
 
736
                printf("Invalid selectNetwork '%s'\n", sel.ascii());
 
737
                return;
 
738
        }
 
739
        sel.truncate(pos);
 
740
 
 
741
        NetworkConfig *nc = new NetworkConfig();
 
742
        if (nc == NULL)
 
743
                return;
 
744
        nc->setWpaGui(this);
 
745
 
 
746
        nc->paramsFromConfig(sel.toInt());
 
747
        nc->show();
 
748
        nc->exec();
 
749
}
 
750
 
 
751
 
 
752
void WpaGui::triggerUpdate()
 
753
{
 
754
        updateStatus();
 
755
        networkMayHaveChanged = true;
 
756
        updateNetworks();
 
757
}
 
758
 
 
759
 
 
760
void WpaGui::addNetwork()
 
761
{
 
762
        NetworkConfig *nc = new NetworkConfig();
 
763
        if (nc == NULL)
 
764
                return;
 
765
        nc->setWpaGui(this);
 
766
        nc->newNetwork();
 
767
        nc->show();
 
768
        nc->exec();
 
769
}
 
770
 
 
771
 
 
772
void WpaGui::selectAdapter( const QString & sel )
 
773
{
 
774
        if (openCtrlConnection(sel.ascii()) < 0)
 
775
                printf("Failed to open control connection to "
 
776
                       "wpa_supplicant.\n");
 
777
        updateStatus();
 
778
        updateNetworks();
 
779
}