← Back to branch summary

~ubuntu-branches/ubuntu/vivid/wpasupplicant/vivid

« back to all changes in this revision

Viewing changes to wpa_gui-qt4/wpagui.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Kel Modderman
  • Date: 2008-03-12 20:03:04 UTC
  • mfrom: (1.1.10 upstream)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20080312200304-4331y9wj46pdd34z
Tags: 0.6.3-1
http://bugs.debian.org/466910
* New upstream release.
* Drop patches applied upstream:
  - debian/patches/30_wpa_gui_qt4_eventhistoryui_rework.patch
  - debian/patches/31_wpa_gui_qt4_eventhistory_always_scrollbar.patch
  - debian/patches/32_wpa_gui_qt4_eventhistory_scroll_with_events.patch
  - debian/patches/40_dbus_ssid_data.patch
* Tidy up the clean target of debian/rules. Now that the madwifi headers are
  handled differently we no longer need to do any cleanup.
* Fix formatting error in debian/ifupdown/wpa_action.8 to make lintian
  quieter.
* Add patch to fix formatting errors in manpages build from sgml source. Use
  <emphasis> tags to hightlight keywords instead of surrounding them in
  strong quotes.
  - debian/patches/41_manpage_format_fixes.patch
* wpasupplicant binary package no longer suggests pcscd, guessnet, iproute
  or wireless-tools, nor does it recommend dhcp3-client. These are not
  needed.
* Add debian/patches/10_silence_siocsiwauth_icotl_failure.patch to disable
  ioctl failure messages that occur under normal conditions.
* Cherry pick two upstream git commits concerning the dbus interface:
  - debian/patches/11_avoid_dbus_version_namespace.patch
  - debian/patches/12_fix_potential_use_after_free.patch
* Add debian/patches/42_manpage_explain_available_drivers.patch to explain
  that not all of the driver backends are available in the provided
  wpa_supplicant binary, and that the canonical list of supported driver
  backends can be retrieved from the wpa_supplicant -h (help) output.
  (Closes: #466910)
* Add debian/patches/20_wpa_gui_qt4_disable_link_prl.patch to remove
  link_prl CONFIG compile flag added by qmake-qt4 >= 4.3.4-2 to avoid excess
  linking.

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 <j@w1.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 <j@w1.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
 
}