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

« back to all changes in this revision

Viewing changes to wpa_gui-qt4/wpagui.ui.h

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