← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/wpasupplicant/gutsy

« back to all changes in this revision

Viewing changes to wpa_supplicant/wpa_gui/networkconfig.ui.h

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler, Alexander Sack
  • Date: 2007-08-26 16:06:57 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20070826160657-2m8pxoweuxe8f93t
Tags: 0.6.0+0.5.8-0ubuntu1
https://launchpad.net/bugs/140763
https://launchpad.net/bugs/141233
* New upstream release
* remove patch 11_erroneous_manpage_ref, applied upstream
* remove patch 25_wpas_dbus_unregister_iface_fix, applied upstream

[ Alexander Sack ]
* bumping upstream version to replace development version 0.6.0 with
  this package from stable release branch.
* attempt to fix wierd timeout and high latency issues by going
  back to stable upstream version (0.5.9) (LP: #140763,
  LP: #141233).

Show diffs side-by-side

added added

removed removed

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