← Back to branch summary

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

« back to all changes in this revision

Viewing changes to wpa_gui-qt4/networkconfig.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/networkconfig.cpp
 
1
/*
 
2
 * wpa_gui - NetworkConfig 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
#include <QMessageBox>
 
16
 
 
17
#include "networkconfig.h"
 
18
#include "wpagui.h"
 
19
 
 
20
enum {
 
21
    AUTH_NONE = 0,
 
22
    AUTH_IEEE8021X = 1,
 
23
    AUTH_WPA_PSK = 2,
 
24
    AUTH_WPA_EAP = 3,
 
25
    AUTH_WPA2_PSK = 4,
 
26
    AUTH_WPA2_EAP = 5
 
27
};
 
28
 
 
29
 
 
30
NetworkConfig::NetworkConfig(QWidget *parent, const char *, bool, Qt::WFlags)
 
31
        : QDialog(parent)
 
32
{
 
33
        setupUi(this);
 
34
 
 
35
        connect(authSelect, SIGNAL(activated(int)), this,
 
36
                SLOT(authChanged(int)));
 
37
        connect(cancelButton, SIGNAL(clicked()), this, SLOT(close()));
 
38
        connect(addButton, SIGNAL(clicked()), this, SLOT(addNetwork()));
 
39
        connect(encrSelect, SIGNAL(activated(const QString &)), this,
 
40
                SLOT(encrChanged(const QString &)));
 
41
        connect(removeButton, SIGNAL(clicked()), this, SLOT(removeNetwork()));
 
42
 
 
43
        wpagui = NULL;
 
44
        new_network = false;
 
45
}
 
46
 
 
47
 
 
48
NetworkConfig::~NetworkConfig()
 
49
{
 
50
}
 
51
 
 
52
 
 
53
void NetworkConfig::languageChange()
 
54
{
 
55
        retranslateUi(this);
 
56
}
 
57
 
 
58
 
 
59
void NetworkConfig::paramsFromScanResults(Q3ListViewItem *sel)
 
60
{
 
61
        new_network = true;
 
62
 
 
63
        /* SSID BSSID frequency signal flags */
 
64
        setCaption(sel->text(0));
 
65
        ssidEdit->setText(sel->text(0));
 
66
 
 
67
        QString flags = sel->text(4);
 
68
        int auth, encr = 0;
 
69
        if (flags.find("[WPA2-EAP") >= 0)
 
70
                auth = AUTH_WPA2_EAP;
 
71
        else if (flags.find("[WPA-EAP") >= 0)
 
72
                auth = AUTH_WPA_EAP;
 
73
        else if (flags.find("[WPA2-PSK") >= 0)
 
74
                auth = AUTH_WPA2_PSK;
 
75
        else if (flags.find("[WPA-PSK") >= 0)
 
76
                auth = AUTH_WPA_PSK;
 
77
        else
 
78
                auth = AUTH_NONE;
 
79
 
 
80
        if (flags.find("-CCMP") >= 0)
 
81
                encr = 1;
 
82
        else if (flags.find("-TKIP") >= 0)
 
83
                encr = 0;
 
84
        else if (flags.find("WEP") >= 0)
 
85
                encr = 1;
 
86
        else
 
87
                encr = 0;
 
88
 
 
89
        authSelect->setCurrentItem(auth);
 
90
        authChanged(auth);
 
91
        encrSelect->setCurrentItem(encr);
 
92
 
 
93
        getEapCapa();
 
94
}
 
95
 
 
96
 
 
97
void NetworkConfig::authChanged(int sel)
 
98
{
 
99
        pskEdit->setEnabled(sel == AUTH_WPA_PSK || sel == AUTH_WPA2_PSK);
 
100
        bool eap = sel == AUTH_IEEE8021X || sel == AUTH_WPA_EAP ||
 
101
                sel == AUTH_WPA2_EAP;
 
102
        eapSelect->setEnabled(eap);
 
103
        identityEdit->setEnabled(eap);
 
104
        passwordEdit->setEnabled(eap);
 
105
        cacertEdit->setEnabled(eap);
 
106
 
 
107
        while (encrSelect->count())
 
108
                encrSelect->removeItem(0);
 
109
 
 
110
        if (sel == AUTH_NONE || sel == AUTH_IEEE8021X) {
 
111
                encrSelect->insertItem("None");
 
112
                encrSelect->insertItem("WEP");
 
113
                encrSelect->setCurrentItem(sel == AUTH_NONE ? 0 : 1);
 
114
        } else {
 
115
                encrSelect->insertItem("TKIP");
 
116
                encrSelect->insertItem("CCMP");
 
117
                encrSelect->setCurrentItem((sel == AUTH_WPA2_PSK ||
 
118
                                            sel == AUTH_WPA2_EAP) ? 1 : 0);
 
119
        }
 
120
 
 
121
        wepEnabled(sel == AUTH_IEEE8021X);
 
122
}
 
123
 
 
124
 
 
125
void NetworkConfig::addNetwork()
 
126
{
 
127
        char reply[10], cmd[256];
 
128
        size_t reply_len;
 
129
        int id;
 
130
        int psklen = pskEdit->text().length();
 
131
        int auth = authSelect->currentItem();
 
132
 
 
133
        if (auth == AUTH_WPA_PSK || auth == AUTH_WPA2_PSK) {
 
134
                if (psklen < 8 || psklen > 64) {
 
135
                        QMessageBox::warning(this, "wpa_gui",
 
136
                                             "WPA-PSK requires a passphrase "
 
137
                                             "of 8 to 63 characters\n"
 
138
                                             "or 64 hex digit PSK");
 
139
                        return;
 
140
                }
 
141
        }
 
142
 
 
143
        if (wpagui == NULL)
 
144
                return;
 
145
 
 
146
        memset(reply, 0, sizeof(reply));
 
147
        reply_len = sizeof(reply) - 1;
 
148
 
 
149
        if (new_network) {
 
150
                wpagui->ctrlRequest("ADD_NETWORK", reply, &reply_len);
 
151
                if (reply[0] == 'F') {
 
152
                        QMessageBox::warning(this, "wpa_gui", "Failed to add "
 
153
                                             "network to wpa_supplicant\n"
 
154
                                             "configuration.");
 
155
                        return;
 
156
                }
 
157
                id = atoi(reply);
 
158
        } else
 
159
                id = edit_network_id;
 
160
 
 
161
        setNetworkParam(id, "ssid", ssidEdit->text().ascii(), true);
 
162
 
 
163
        char *key_mgmt = NULL, *proto = NULL, *pairwise = NULL;
 
164
        switch (auth) {
 
165
        case AUTH_NONE:
 
166
                key_mgmt = "NONE";
 
167
                break;
 
168
        case AUTH_IEEE8021X:
 
169
                key_mgmt = "IEEE8021X";
 
170
                break;
 
171
        case AUTH_WPA_PSK:
 
172
                key_mgmt = "WPA-PSK";
 
173
                proto = "WPA";
 
174
                break;
 
175
        case AUTH_WPA_EAP:
 
176
                key_mgmt = "WPA-EAP";
 
177
                proto = "WPA";
 
178
                break;
 
179
        case AUTH_WPA2_PSK:
 
180
                key_mgmt = "WPA-PSK";
 
181
                proto = "WPA2";
 
182
                break;
 
183
        case AUTH_WPA2_EAP:
 
184
                key_mgmt = "WPA-EAP";
 
185
                proto = "WPA2";
 
186
                break;
 
187
        }
 
188
 
 
189
        if (auth == AUTH_WPA_PSK || auth == AUTH_WPA_EAP ||
 
190
            auth == AUTH_WPA2_PSK || auth == AUTH_WPA2_EAP) {
 
191
                int encr = encrSelect->currentItem();
 
192
                if (encr == 0)
 
193
                        pairwise = "TKIP";
 
194
                else
 
195
                        pairwise = "CCMP";
 
196
        }
 
197
 
 
198
        if (proto)
 
199
                setNetworkParam(id, "proto", proto, false);
 
200
        if (key_mgmt)
 
201
                setNetworkParam(id, "key_mgmt", key_mgmt, false);
 
202
        if (pairwise) {
 
203
                setNetworkParam(id, "pairwise", pairwise, false);
 
204
                setNetworkParam(id, "group", "TKIP CCMP WEP104 WEP40", false);
 
205
        }
 
206
        if (pskEdit->isEnabled())
 
207
                setNetworkParam(id, "psk", pskEdit->text().ascii(),
 
208
                                psklen != 64);
 
209
        if (eapSelect->isEnabled())
 
210
                setNetworkParam(id, "eap", eapSelect->currentText().ascii(),
 
211
                                false);
 
212
        if (identityEdit->isEnabled())
 
213
                setNetworkParam(id, "identity", identityEdit->text().ascii(),
 
214
                                true);
 
215
        if (passwordEdit->isEnabled())
 
216
                setNetworkParam(id, "password", passwordEdit->text().ascii(),
 
217
                                true);
 
218
        if (cacertEdit->isEnabled())
 
219
                setNetworkParam(id, "ca_cert", cacertEdit->text().ascii(),
 
220
                                true);
 
221
        writeWepKey(id, wep0Edit, 0);
 
222
        writeWepKey(id, wep1Edit, 1);
 
223
        writeWepKey(id, wep2Edit, 2);
 
224
        writeWepKey(id, wep3Edit, 3);
 
225
 
 
226
        if (wep0Radio->isEnabled() && wep0Radio->isChecked())
 
227
                setNetworkParam(id, "wep_tx_keyidx", "0", false);
 
228
        else if (wep1Radio->isEnabled() && wep1Radio->isChecked())
 
229
                setNetworkParam(id, "wep_tx_keyidx", "1", false);
 
230
        else if (wep2Radio->isEnabled() && wep2Radio->isChecked())
 
231
                setNetworkParam(id, "wep_tx_keyidx", "2", false);
 
232
        else if (wep3Radio->isEnabled() && wep3Radio->isChecked())
 
233
                setNetworkParam(id, "wep_tx_keyidx", "3", false);
 
234
 
 
235
        snprintf(cmd, sizeof(cmd), "ENABLE_NETWORK %d", id);
 
236
        reply_len = sizeof(reply);
 
237
        wpagui->ctrlRequest(cmd, reply, &reply_len);
 
238
        if (strncmp(reply, "OK", 2) != 0) {
 
239
                QMessageBox::warning(this, "wpa_gui", "Failed to enable "
 
240
                                     "network in wpa_supplicant\n"
 
241
                                     "configuration.");
 
242
                /* Network was added, so continue anyway */
 
243
        }
 
244
        wpagui->triggerUpdate();
 
245
        wpagui->ctrlRequest("SAVE_CONFIG", reply, &reply_len);
 
246
 
 
247
        close();
 
248
}
 
249
 
 
250
 
 
251
void NetworkConfig::setWpaGui(WpaGui *_wpagui)
 
252
{
 
253
        wpagui = _wpagui;
 
254
}
 
255
 
 
256
 
 
257
int NetworkConfig::setNetworkParam(int id, const char *field,
 
258
                                   const char *value, bool quote)
 
259
{
 
260
        char reply[10], cmd[256];
 
261
        size_t reply_len;
 
262
        snprintf(cmd, sizeof(cmd), "SET_NETWORK %d %s %s%s%s",
 
263
                 id, field, quote ? "\"" : "", value, quote ? "\"" : "");
 
264
        reply_len = sizeof(reply);
 
265
        wpagui->ctrlRequest(cmd, reply, &reply_len);
 
266
        return strncmp(reply, "OK", 2) == 0 ? 0 : -1;
 
267
}
 
268
 
 
269
 
 
270
void NetworkConfig::encrChanged(const QString &sel)
 
271
{
 
272
        wepEnabled(sel.find("WEP") == 0);
 
273
}
 
274
 
 
275
 
 
276
void NetworkConfig::wepEnabled(bool enabled)
 
277
{
 
278
        wep0Edit->setEnabled(enabled);
 
279
        wep1Edit->setEnabled(enabled);
 
280
        wep2Edit->setEnabled(enabled);
 
281
        wep3Edit->setEnabled(enabled);
 
282
        wep0Radio->setEnabled(enabled);
 
283
        wep1Radio->setEnabled(enabled);
 
284
        wep2Radio->setEnabled(enabled);
 
285
        wep3Radio->setEnabled(enabled);
 
286
}
 
287
 
 
288
 
 
289
void NetworkConfig::writeWepKey(int network_id, QLineEdit *edit, int id)
 
290
{
 
291
        char buf[10];
 
292
        bool hex;
 
293
        const char *txt, *pos;
 
294
        size_t len;
 
295
 
 
296
        if (!edit->isEnabled() || edit->text().isEmpty())
 
297
                return;
 
298
 
 
299
        /*
 
300
         * Assume hex key if only hex characters are present and length matches
 
301
         * with 40, 104, or 128-bit key
 
302
         */
 
303
        txt = edit->text().ascii();
 
304
        len = strlen(txt);
 
305
        if (len == 0)
 
306
                return;
 
307
        pos = txt;
 
308
        hex = true;
 
309
        while (*pos) {
 
310
                if (!((*pos >= '0' && *pos <= '9') ||
 
311
                      (*pos >= 'a' && *pos <= 'f') ||
 
312
                      (*pos >= 'A' && *pos <= 'F'))) {
 
313
                        hex = false;
 
314
                        break;
 
315
                }
 
316
                pos++;
 
317
        }
 
318
        if (hex && len != 10 && len != 26 && len != 32)
 
319
                hex = false;
 
320
        snprintf(buf, sizeof(buf), "wep_key%d", id);
 
321
        setNetworkParam(network_id, buf, txt, !hex);
 
322
}
 
323
 
 
324
 
 
325
void NetworkConfig::paramsFromConfig(int network_id)
 
326
{
 
327
        int i;
 
328
 
 
329
        edit_network_id = network_id;
 
330
        getEapCapa();
 
331
 
 
332
        char reply[1024], cmd[256], *pos;
 
333
        size_t reply_len;
 
334
 
 
335
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d ssid", network_id);
 
336
        reply_len = sizeof(reply);
 
337
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0 &&
 
338
            reply_len >= 2 && reply[0] == '"') {
 
339
                reply[reply_len] = '\0';
 
340
                pos = strchr(reply + 1, '"');
 
341
                if (pos)
 
342
                        *pos = '\0';
 
343
                ssidEdit->setText(reply + 1);
 
344
        }
 
345
 
 
346
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d proto", network_id);
 
347
        reply_len = sizeof(reply);
 
348
        int wpa = 0;
 
349
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0) {
 
350
                reply[reply_len] = '\0';
 
351
                if (strstr(reply, "RSN") || strstr(reply, "WPA2"))
 
352
                        wpa = 2;
 
353
                else if (strstr(reply, "WPA"))
 
354
                        wpa = 1;
 
355
        }
 
356
 
 
357
        int auth = AUTH_NONE, encr = 0;
 
358
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d key_mgmt", network_id);
 
359
        reply_len = sizeof(reply);
 
360
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0) {
 
361
                reply[reply_len] = '\0';
 
362
                if (strstr(reply, "WPA-EAP"))
 
363
                        auth = wpa & 2 ? AUTH_WPA2_EAP : AUTH_WPA_EAP;
 
364
                else if (strstr(reply, "WPA-PSK"))
 
365
                        auth = wpa & 2 ? AUTH_WPA2_PSK : AUTH_WPA_PSK;
 
366
                else if (strstr(reply, "IEEE8021X")) {
 
367
                        auth = AUTH_IEEE8021X;
 
368
                        encr = 1;
 
369
                }
 
370
        }
 
371
 
 
372
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d pairwise", network_id);
 
373
        reply_len = sizeof(reply);
 
374
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0) {
 
375
                reply[reply_len] = '\0';
 
376
                if (strstr(reply, "CCMP"))
 
377
                        encr = 1;
 
378
                else if (strstr(reply, "TKIP"))
 
379
                        encr = 0;
 
380
                else if (strstr(reply, "WEP"))
 
381
                        encr = 1;
 
382
                else
 
383
                        encr = 0;
 
384
        }
 
385
 
 
386
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d psk", network_id);
 
387
        reply_len = sizeof(reply);
 
388
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0 &&
 
389
            reply_len >= 2 && reply[0] == '"') {
 
390
                reply[reply_len] = '\0';
 
391
                pos = strchr(reply + 1, '"');
 
392
                if (pos)
 
393
                        *pos = '\0';
 
394
                pskEdit->setText(reply + 1);
 
395
        }
 
396
 
 
397
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d identity", network_id);
 
398
        reply_len = sizeof(reply);
 
399
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0 &&
 
400
            reply_len >= 2 && reply[0] == '"') {
 
401
                reply[reply_len] = '\0';
 
402
                pos = strchr(reply + 1, '"');
 
403
                if (pos)
 
404
                        *pos = '\0';
 
405
                identityEdit->setText(reply + 1);
 
406
        }
 
407
 
 
408
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d password", network_id);
 
409
        reply_len = sizeof(reply);
 
410
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0 &&
 
411
            reply_len >= 2 && reply[0] == '"') {
 
412
                reply[reply_len] = '\0';
 
413
                pos = strchr(reply + 1, '"');
 
414
                if (pos)
 
415
                        *pos = '\0';
 
416
                passwordEdit->setText(reply + 1);
 
417
        }
 
418
 
 
419
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d ca_cert", network_id);
 
420
        reply_len = sizeof(reply);
 
421
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0 &&
 
422
            reply_len >= 2 && reply[0] == '"') {
 
423
                reply[reply_len] = '\0';
 
424
                pos = strchr(reply + 1, '"');
 
425
                if (pos)
 
426
                        *pos = '\0';
 
427
                cacertEdit->setText(reply + 1);
 
428
        }
 
429
 
 
430
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d eap", network_id);
 
431
        reply_len = sizeof(reply);
 
432
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0 &&
 
433
            reply_len >= 1) {
 
434
                reply[reply_len] = '\0';
 
435
                for (i = 0; i < eapSelect->count(); i++) {
 
436
                        if (eapSelect->text(i).compare(reply) == 0) {
 
437
                                eapSelect->setCurrentItem(i);
 
438
                                break;
 
439
                        }
 
440
                }
 
441
        }
 
442
 
 
443
        for (i = 0; i < 4; i++) {
 
444
                snprintf(cmd, sizeof(cmd), "GET_NETWORK %d wep_key%d",
 
445
                         network_id, i);
 
446
                reply_len = sizeof(reply);
 
447
                if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0 &&
 
448
                    reply_len >= 2 && reply[0] == '"') {
 
449
                        reply[reply_len] = '\0';
 
450
                        pos = strchr(reply + 1, '"');
 
451
                        if (pos)
 
452
                                *pos = '\0';
 
453
                        if (auth == AUTH_NONE || auth == AUTH_IEEE8021X)
 
454
                                encr = 1;
 
455
 
 
456
                        switch (i) {
 
457
                        case 0:
 
458
                                wep0Edit->setText(reply + 1);
 
459
                                break;
 
460
                        case 1:
 
461
                                wep1Edit->setText(reply + 1);
 
462
                                break;
 
463
                        case 2:
 
464
                                wep2Edit->setText(reply + 1);
 
465
                                break;
 
466
                        case 3:
 
467
                                wep3Edit->setText(reply + 1);
 
468
                                break;
 
469
                        }
 
470
                }
 
471
        }
 
472
 
 
473
        snprintf(cmd, sizeof(cmd), "GET_NETWORK %d wep_tx_keyidx", network_id);
 
474
        reply_len = sizeof(reply);
 
475
        if (wpagui->ctrlRequest(cmd, reply, &reply_len) >= 0 && reply_len >= 1)
 
476
        {
 
477
                reply[reply_len] = '\0';
 
478
                switch (atoi(reply)) {
 
479
                case 0:
 
480
                        wep0Radio->setChecked(true);
 
481
                        break;
 
482
                case 1:
 
483
                        wep1Radio->setChecked(true);
 
484
                        break;
 
485
                case 2:
 
486
                        wep2Radio->setChecked(true);
 
487
                        break;
 
488
                case 3:
 
489
                        wep3Radio->setChecked(true);
 
490
                        break;
 
491
                }
 
492
        }
 
493
 
 
494
        authSelect->setCurrentItem(auth);
 
495
        authChanged(auth);
 
496
        encrSelect->setCurrentItem(encr);
 
497
        if (auth == AUTH_NONE || auth == AUTH_IEEE8021X)
 
498
                wepEnabled(encr == 1);
 
499
 
 
500
        removeButton->setEnabled(true);
 
501
        addButton->setText("Save");
 
502
}
 
503
 
 
504
 
 
505
void NetworkConfig::removeNetwork()
 
506
{
 
507
        char reply[10], cmd[256];
 
508
        size_t reply_len;
 
509
 
 
510
        if (QMessageBox::information(this, "wpa_gui",
 
511
                                     "This will permanently remove the "
 
512
                                     "network\n"
 
513
                                     "from the configuration. Do you really "
 
514
                                     "want\n"
 
515
                                     "to remove this network?", "Yes", "No")
 
516
            != 0)
 
517
                return;
 
518
 
 
519
        snprintf(cmd, sizeof(cmd), "REMOVE_NETWORK %d", edit_network_id);
 
520
        reply_len = sizeof(reply);
 
521
        wpagui->ctrlRequest(cmd, reply, &reply_len);
 
522
        if (strncmp(reply, "OK", 2) != 0) {
 
523
                QMessageBox::warning(this, "wpa_gui",
 
524
                                     "Failed to remove network from "
 
525
                                     "wpa_supplicant\n"
 
526
                                     "configuration.");
 
527
        } else {
 
528
                wpagui->triggerUpdate();
 
529
                wpagui->ctrlRequest("SAVE_CONFIG", reply, &reply_len);
 
530
        }
 
531
 
 
532
        close();
 
533
}
 
534
 
 
535
 
 
536
void NetworkConfig::newNetwork()
 
537
{
 
538
        new_network = true;
 
539
        getEapCapa();
 
540
}
 
541
 
 
542
 
 
543
void NetworkConfig::getEapCapa()
 
544
{
 
545
        char reply[256];
 
546
        size_t reply_len;
 
547
 
 
548
        if (wpagui == NULL)
 
549
                return;
 
550
 
 
551
        reply_len = sizeof(reply) - 1;
 
552
        if (wpagui->ctrlRequest("GET_CAPABILITY eap", reply, &reply_len) < 0)
 
553
                return;
 
554
        reply[reply_len] = '\0';
 
555
 
 
556
        QString res(reply);
 
557
        QStringList types = QStringList::split(QChar(' '), res);
 
558
        eapSelect->insertStringList(types);
 
559
}