← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ctrl_iface.c

  • 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:
ctrl_iface.c
29
29
#include "eap.h"
30
30
 
31
31
 
 
32
static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
 
33
                                                  char *buf, int len);
 
34
 
 
35
 
32
36
static int wpa_supplicant_ctrl_iface_set(struct wpa_supplicant *wpa_s,
33
37
                                         char *cmd)
34
38
{
219
223
                                            char *buf, size_t buflen)
220
224
{
221
225
        char *pos, *end, tmp[30];
222
 
        int res, verbose;
 
226
        int res, verbose, ret;
223
227
 
224
228
        verbose = strcmp(params, "-VERBOSE") == 0;
225
229
        pos = buf;
226
230
        end = buf + buflen;
227
231
        if (wpa_s->wpa_state >= WPA_ASSOCIATED) {
228
232
                struct wpa_ssid *ssid = wpa_s->current_ssid;
229
 
                pos += snprintf(pos, end - pos, "bssid=" MACSTR "\n",
230
 
                                MAC2STR(wpa_s->bssid));
 
233
                ret = snprintf(pos, end - pos, "bssid=" MACSTR "\n",
 
234
                               MAC2STR(wpa_s->bssid));
 
235
                if (ret < 0 || ret >= end - pos)
 
236
                        return pos - buf;
 
237
                pos += ret;
231
238
                if (ssid) {
232
 
                        pos += snprintf(pos, end - pos,
233
 
                                        "ssid=%s\nid=%d\n",
234
 
                                        wpa_ssid_txt(ssid->ssid,
235
 
                                                     ssid->ssid_len),
236
 
                                        ssid->id);
237
 
                        if (ssid->id_str)
238
 
                                pos += snprintf(pos, end - pos, "id_str=%s\n",
239
 
                                                ssid->id_str);
 
239
                        u8 *_ssid = ssid->ssid;
 
240
                        size_t ssid_len = ssid->ssid_len;
 
241
                        u8 ssid_buf[MAX_SSID_LEN];
 
242
                        if (ssid_len == 0) {
 
243
                                int res = wpa_drv_get_ssid(wpa_s, ssid_buf);
 
244
                                if (res < 0)
 
245
                                        ssid_len = 0;
 
246
                                else
 
247
                                        ssid_len = res;
 
248
                                _ssid = ssid_buf;
 
249
                        }
 
250
                        ret = snprintf(pos, end - pos, "ssid=%s\nid=%d\n",
 
251
                                       wpa_ssid_txt(_ssid, ssid_len),
 
252
                                       ssid->id);
 
253
                        if (ret < 0 || ret >= end - pos)
 
254
                                return pos - buf;
 
255
                        pos += ret;
 
256
 
 
257
                        if (ssid->id_str) {
 
258
                                ret = snprintf(pos, end - pos, "id_str=%s\n",
 
259
                                               ssid->id_str);
 
260
                                if (ret < 0 || ret >= end - pos)
 
261
                                        return pos - buf;
 
262
                                pos += ret;
 
263
                        }
240
264
                }
241
265
 
242
266
                pos += wpa_sm_get_status(wpa_s->wpa, pos, end - pos, verbose);
243
267
        }
244
 
        pos += snprintf(pos, end - pos, "wpa_state=%s\n",
245
 
                        wpa_supplicant_state_txt(wpa_s->wpa_state));
 
268
        ret = snprintf(pos, end - pos, "wpa_state=%s\n",
 
269
                       wpa_supplicant_state_txt(wpa_s->wpa_state));
 
270
        if (ret < 0 || ret >= end - pos)
 
271
                return pos - buf;
 
272
        pos += ret;
246
273
 
247
274
        if (wpa_s->l2 &&
248
 
            l2_packet_get_ip_addr(wpa_s->l2, tmp, sizeof(tmp)) >= 0)
249
 
                pos += snprintf(pos, end - pos, "ip_address=%s\n", tmp);
 
275
            l2_packet_get_ip_addr(wpa_s->l2, tmp, sizeof(tmp)) >= 0) {
 
276
                ret = snprintf(pos, end - pos, "ip_address=%s\n", tmp);
 
277
                if (ret < 0 || ret >= end - pos)
 
278
                        return pos - buf;
 
279
                pos += ret;
 
280
        }
250
281
 
251
282
        if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
252
283
            wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
305
336
{
306
337
        char *pos, *end;
307
338
        struct wpa_ssid *ssid;
 
339
        int ret;
308
340
 
309
341
        pos = buf;
310
342
        end = buf + buflen;
311
 
        pos += snprintf(pos, end - pos, "network id / ssid / bssid / flags\n");
 
343
        ret = snprintf(pos, end - pos, "network id / ssid / bssid / flags\n");
 
344
        if (ret < 0 || ret >= end - pos)
 
345
                return pos - buf;
 
346
        pos += ret;
312
347
 
313
348
        ssid = wpa_s->conf->ssid;
314
349
        while (ssid) {
315
 
                pos += snprintf(pos, end - pos, "%d\t%s",
316
 
                                ssid->id,
317
 
                                wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
 
350
                ret = snprintf(pos, end - pos, "%d\t%s",
 
351
                               ssid->id,
 
352
                               wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
 
353
                if (ret < 0 || ret >= end - pos)
 
354
                        return pos - buf;
 
355
                pos += ret;
318
356
                if (ssid->bssid_set) {
319
 
                        pos += snprintf(pos, end - pos, "\t" MACSTR,
320
 
                                        MAC2STR(ssid->bssid));
 
357
                        ret = snprintf(pos, end - pos, "\t" MACSTR,
 
358
                                       MAC2STR(ssid->bssid));
321
359
                } else {
322
 
                        pos += snprintf(pos, end - pos, "\tany");
 
360
                        ret = snprintf(pos, end - pos, "\tany");
323
361
                }
324
 
                pos += snprintf(pos, end - pos, "\t%s%s",
325
 
                                ssid == wpa_s->current_ssid ? "[CURRENT]" : "",
326
 
                                ssid->disabled ? "[DISABLED]" : "");
327
 
                pos += snprintf(pos, end - pos, "\n");
 
362
                if (ret < 0 || ret >= end - pos)
 
363
                        return pos - buf;
 
364
                pos += ret;
 
365
                ret = snprintf(pos, end - pos, "\t%s%s",
 
366
                               ssid == wpa_s->current_ssid ? "[CURRENT]" : "",
 
367
                               ssid->disabled ? "[DISABLED]" : "");
 
368
                if (ret < 0 || ret >= end - pos)
 
369
                        return pos - buf;
 
370
                pos += ret;
 
371
                ret = snprintf(pos, end - pos, "\n");
 
372
                if (ret < 0 || ret >= end - pos)
 
373
                        return pos - buf;
 
374
                pos += ret;
328
375
 
329
376
                ssid = ssid->next;
330
377
        }
335
382
 
336
383
static char * wpa_supplicant_cipher_txt(char *pos, char *end, int cipher)
337
384
{
338
 
        int first = 1;
339
 
        pos += snprintf(pos, end - pos, "-");
 
385
        int first = 1, ret;
 
386
        ret = snprintf(pos, end - pos, "-");
 
387
        if (ret < 0 || ret >= end - pos)
 
388
                return pos;
 
389
        pos += ret;
340
390
        if (cipher & WPA_CIPHER_NONE) {
341
 
                pos += snprintf(pos, end - pos, "%sNONE", first ? "" : "+");
 
391
                ret = snprintf(pos, end - pos, "%sNONE", first ? "" : "+");
 
392
                if (ret < 0 || ret >= end - pos)
 
393
                        return pos;
 
394
                pos += ret;
342
395
                first = 0;
343
396
        }
344
397
        if (cipher & WPA_CIPHER_WEP40) {
345
 
                pos += snprintf(pos, end - pos, "%sWEP40", first ? "" : "+");
 
398
                ret = snprintf(pos, end - pos, "%sWEP40", first ? "" : "+");
 
399
                if (ret < 0 || ret >= end - pos)
 
400
                        return pos;
 
401
                pos += ret;
346
402
                first = 0;
347
403
        }
348
404
        if (cipher & WPA_CIPHER_WEP104) {
349
 
                pos += snprintf(pos, end - pos, "%sWEP104", first ? "" : "+");
 
405
                ret = snprintf(pos, end - pos, "%sWEP104", first ? "" : "+");
 
406
                if (ret < 0 || ret >= end - pos)
 
407
                        return pos;
 
408
                pos += ret;
350
409
                first = 0;
351
410
        }
352
411
        if (cipher & WPA_CIPHER_TKIP) {
353
 
                pos += snprintf(pos, end - pos, "%sTKIP", first ? "" : "+");
 
412
                ret = snprintf(pos, end - pos, "%sTKIP", first ? "" : "+");
 
413
                if (ret < 0 || ret >= end - pos)
 
414
                        return pos;
 
415
                pos += ret;
354
416
                first = 0;
355
417
        }
356
418
        if (cipher & WPA_CIPHER_CCMP) {
357
 
                pos += snprintf(pos, end - pos, "%sCCMP", first ? "" : "+");
 
419
                ret = snprintf(pos, end - pos, "%sCCMP", first ? "" : "+");
 
420
                if (ret < 0 || ret >= end - pos)
 
421
                        return pos;
 
422
                pos += ret;
358
423
                first = 0;
359
424
        }
360
425
        return pos;
365
430
                                    const u8 *ie, size_t ie_len)
366
431
{
367
432
        struct wpa_ie_data data;
368
 
        int first;
 
433
        int first, ret;
369
434
 
370
 
        pos += snprintf(pos, end - pos, "[%s-", proto);
 
435
        ret = snprintf(pos, end - pos, "[%s-", proto);
 
436
        if (ret < 0 || ret >= end - pos)
 
437
                return pos;
 
438
        pos += ret;
371
439
 
372
440
        if (wpa_parse_wpa_ie(ie, ie_len, &data) < 0) {
373
 
                pos += snprintf(pos, end - pos, "?]");
 
441
                ret = snprintf(pos, end - pos, "?]");
 
442
                if (ret < 0 || ret >= end - pos)
 
443
                        return pos;
 
444
                pos += ret;
374
445
                return pos;
375
446
        }
376
447
 
377
448
        first = 1;
378
449
        if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
379
 
                pos += snprintf(pos, end - pos, "%sEAP", first ? "" : "+");
 
450
                ret = snprintf(pos, end - pos, "%sEAP", first ? "" : "+");
 
451
                if (ret < 0 || ret >= end - pos)
 
452
                        return pos;
 
453
                pos += ret;
380
454
                first = 0;
381
455
        }
382
456
        if (data.key_mgmt & WPA_KEY_MGMT_PSK) {
383
 
                pos += snprintf(pos, end - pos, "%sPSK", first ? "" : "+");
 
457
                ret = snprintf(pos, end - pos, "%sPSK", first ? "" : "+");
 
458
                if (ret < 0 || ret >= end - pos)
 
459
                        return pos;
 
460
                pos += ret;
384
461
                first = 0;
385
462
        }
386
463
        if (data.key_mgmt & WPA_KEY_MGMT_WPA_NONE) {
387
 
                pos += snprintf(pos, end - pos, "%sNone", first ? "" : "+");
 
464
                ret = snprintf(pos, end - pos, "%sNone", first ? "" : "+");
 
465
                if (ret < 0 || ret >= end - pos)
 
466
                        return pos;
 
467
                pos += ret;
388
468
                first = 0;
389
469
        }
390
470
 
391
471
        pos = wpa_supplicant_cipher_txt(pos, end, data.pairwise_cipher);
392
472
 
393
 
        if (data.capabilities & WPA_CAPABILITY_PREAUTH)
394
 
                pos += snprintf(pos, end - pos, "-preauth");
 
473
        if (data.capabilities & WPA_CAPABILITY_PREAUTH) {
 
474
                ret = snprintf(pos, end - pos, "-preauth");
 
475
                if (ret < 0 || ret >= end - pos)
 
476
                        return pos;
 
477
                pos += ret;
 
478
        }
395
479
 
396
 
        pos += snprintf(pos, end - pos, "]");
 
480
        ret = snprintf(pos, end - pos, "]");
 
481
        if (ret < 0 || ret >= end - pos)
 
482
                return pos;
 
483
        pos += ret;
397
484
 
398
485
        return pos;
399
486
}
404
491
{
405
492
        char *pos, *end;
406
493
        struct wpa_scan_result *res;
407
 
        int i;
 
494
        int i, ret;
408
495
 
409
496
        if (wpa_s->scan_results == NULL &&
410
497
            wpa_supplicant_get_scan_results(wpa_s) < 0)
412
499
 
413
500
        pos = buf;
414
501
        end = buf + buflen;
415
 
        pos += snprintf(pos, end - pos, "bssid / frequency / signal level / "
416
 
                        "flags / ssid\n");
 
502
        ret = snprintf(pos, end - pos, "bssid / frequency / signal level / "
 
503
                       "flags / ssid\n");
 
504
        if (ret < 0 || ret >= end - pos)
 
505
                return pos - buf;
 
506
        pos += ret;
417
507
 
418
508
        for (i = 0; i < wpa_s->num_scan_results; i++) {
419
509
                res = &wpa_s->scan_results[i];
420
 
                pos += snprintf(pos, end - pos, MACSTR "\t%d\t%d\t",
421
 
                                MAC2STR(res->bssid), res->freq, res->level);
 
510
                ret = snprintf(pos, end - pos, MACSTR "\t%d\t%d\t",
 
511
                               MAC2STR(res->bssid), res->freq, res->level);
 
512
                if (ret < 0 || ret >= end - pos)
 
513
                        return pos - buf;
 
514
                pos += ret;
422
515
                if (res->wpa_ie_len) {
423
516
                        pos = wpa_supplicant_ie_txt(pos, end, "WPA",
424
517
                                                    res->wpa_ie,
430
523
                                                    res->rsn_ie_len);
431
524
                }
432
525
                if (!res->wpa_ie_len && !res->rsn_ie_len &&
433
 
                    res->caps & IEEE80211_CAP_PRIVACY)
434
 
                        pos += snprintf(pos, end - pos, "[WEP]");
435
 
                if (res->caps & IEEE80211_CAP_IBSS)
436
 
                        pos += snprintf(pos, end - pos, "[IBSS]");
437
 
 
438
 
                pos += snprintf(pos, end - pos, "\t%s",
439
 
                                wpa_ssid_txt(res->ssid, res->ssid_len));
440
 
 
441
 
                pos += snprintf(pos, end - pos, "\n");
 
526
                    res->caps & IEEE80211_CAP_PRIVACY) {
 
527
                        ret = snprintf(pos, end - pos, "[WEP]");
 
528
                        if (ret < 0 || ret >= end - pos)
 
529
                                return pos - buf;
 
530
                        pos += ret;
 
531
                }
 
532
                if (res->caps & IEEE80211_CAP_IBSS) {
 
533
                        ret = snprintf(pos, end - pos, "[IBSS]");
 
534
                        if (ret < 0 || ret >= end - pos)
 
535
                                return pos - buf;
 
536
                        pos += ret;
 
537
                }
 
538
 
 
539
                ret = snprintf(pos, end - pos, "\t%s",
 
540
                               wpa_ssid_txt(res->ssid, res->ssid_len));
 
541
                if (ret < 0 || ret >= end - pos)
 
542
                        return pos - buf;
 
543
                pos += ret;
 
544
 
 
545
                ret = snprintf(pos, end - pos, "\n");
 
546
                if (ret < 0 || ret >= end - pos)
 
547
                        return pos - buf;
 
548
                pos += ret;
442
549
        }
443
550
 
444
551
        return pos - buf;
549
656
        struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
550
657
{
551
658
        struct wpa_ssid *ssid;
 
659
        int ret;
552
660
 
553
661
        wpa_printf(MSG_DEBUG, "CTRL_IFACE: ADD_NETWORK");
554
662
 
558
666
        ssid->disabled = 1;
559
667
        wpa_config_set_network_defaults(ssid);
560
668
 
561
 
        return snprintf(buf, buflen, "%d\n", ssid->id);
 
669
        ret = snprintf(buf, buflen, "%d\n", ssid->id);
 
670
        if (ret < 0 || (size_t) ret >= buflen)
 
671
                return -1;
 
672
        return ret;
562
673
}
563
674
 
564
675
 
641
752
 
642
753
        /* cmd: "<network id> <variable name>" */
643
754
        name = strchr(cmd, ' ');
644
 
        if (name == NULL)
 
755
        if (name == NULL || buflen == 0)
645
756
                return -1;
646
757
        *name++ = '\0';
647
758
 
664
775
        }
665
776
 
666
777
        snprintf(buf, buflen, "%s", value);
 
778
        buf[buflen - 1] = '\0';
667
779
 
668
780
        free(value);
669
781
 
695
807
 
696
808
 
697
809
static int wpa_supplicant_ctrl_iface_get_capability(
698
 
        struct wpa_supplicant *wpa_s, const char *field, char *buf,
 
810
        struct wpa_supplicant *wpa_s, const char *_field, char *buf,
699
811
        size_t buflen)
700
812
{
701
813
        struct wpa_driver_capa capa;
702
 
        int res, first = 1;
703
 
        char *pos, *end;
704
 
 
705
 
        wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_CAPABILITY '%s'", field);
 
814
        int res, first = 1, ret;
 
815
        char *pos, *end, *strict;
 
816
        char field[30];
 
817
 
 
818
        /* Determine whether or not strict checking was requested */
 
819
        snprintf(field, sizeof(field), "%s", _field);
 
820
        field[sizeof(field) - 1] = '\0';
 
821
        strict = strchr(field, ' ');
 
822
        if (strict != NULL) {
 
823
                *strict++ = '\0';
 
824
                if (strcmp(strict, "strict") != 0) {
 
825
                        free(field);
 
826
                        return -1;
 
827
                }
 
828
        }
 
829
 
 
830
        wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_CAPABILITY '%s' %s",
 
831
                field, strict ? strict : "");
706
832
 
707
833
        if (strcmp(field, "eap") == 0) {
708
834
                return eap_get_names(buf, buflen);
714
840
        end = pos + buflen;
715
841
 
716
842
        if (strcmp(field, "pairwise") == 0) {
717
 
                if (res < 0)
718
 
                        return snprintf(buf, buflen, "CCMP TKIP NONE");
 
843
                if (res < 0) {
 
844
                        if (strict)
 
845
                                return 0;
 
846
                        ret = snprintf(buf, buflen, "CCMP TKIP NONE");
 
847
                        if (ret < 0 || (size_t) ret >= buflen)
 
848
                                return -1;
 
849
                        return ret;
 
850
                }
719
851
 
720
852
                if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
721
 
                        pos += snprintf(pos, end - pos, "%sCCMP",
722
 
                                        first ? "" : " ");
 
853
                        ret = snprintf(pos, end - pos, "%sCCMP",
 
854
                                       first ? "" : " ");
 
855
                        if (ret < 0 || ret >= end - pos)
 
856
                                return pos - buf;
 
857
                        pos += ret;
723
858
                        first = 0;
724
859
                }
725
860
 
726
861
                if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
727
 
                        pos += snprintf(pos, end - pos, "%sTKIP",
728
 
                                        first ? "" : " ");
 
862
                        ret = snprintf(pos, end - pos, "%sTKIP",
 
863
                                       first ? "" : " ");
 
864
                        if (ret < 0 || ret >= end - pos)
 
865
                                return pos - buf;
 
866
                        pos += ret;
729
867
                        first = 0;
730
868
                }
731
869
 
732
870
                if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
733
 
                        pos += snprintf(pos, end - pos, "%sNONE",
734
 
                                        first ? "" : " ");
 
871
                        ret = snprintf(pos, end - pos, "%sNONE",
 
872
                                       first ? "" : " ");
 
873
                        if (ret < 0 || ret >= end - pos)
 
874
                                return pos - buf;
 
875
                        pos += ret;
735
876
                        first = 0;
736
877
                }
737
878
 
739
880
        }
740
881
 
741
882
        if (strcmp(field, "group") == 0) {
742
 
                if (res < 0)
743
 
                        return snprintf(buf, buflen, "CCMP TKIP WEP104 WEP40");
 
883
                if (res < 0) {
 
884
                        if (strict)
 
885
                                return 0;
 
886
                        ret = snprintf(buf, buflen, "CCMP TKIP WEP104 WEP40");
 
887
                        if (ret < 0 || (size_t) ret >= buflen)
 
888
                                return -1;
 
889
                        return ret;
 
890
                }
744
891
 
745
892
                if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
746
 
                        pos += snprintf(pos, end - pos, "%sCCMP",
747
 
                                        first ? "" : " ");
 
893
                        ret = snprintf(pos, end - pos, "%sCCMP",
 
894
                                       first ? "" : " ");
 
895
                        if (ret < 0 || ret >= end - pos)
 
896
                                return pos - buf;
 
897
                        pos += ret;
748
898
                        first = 0;
749
899
                }
750
900
 
751
901
                if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
752
 
                        pos += snprintf(pos, end - pos, "%sTKIP",
753
 
                                        first ? "" : " ");
 
902
                        ret = snprintf(pos, end - pos, "%sTKIP",
 
903
                                       first ? "" : " ");
 
904
                        if (ret < 0 || ret >= end - pos)
 
905
                                return pos - buf;
 
906
                        pos += ret;
754
907
                        first = 0;
755
908
                }
756
909
 
757
910
                if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP104) {
758
 
                        pos += snprintf(pos, end - pos, "%sWEP104",
759
 
                                        first ? "" : " ");
 
911
                        ret = snprintf(pos, end - pos, "%sWEP104",
 
912
                                       first ? "" : " ");
 
913
                        if (ret < 0 || ret >= end - pos)
 
914
                                return pos - buf;
 
915
                        pos += ret;
760
916
                        first = 0;
761
917
                }
762
918
 
763
919
                if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP40) {
764
 
                        pos += snprintf(pos, end - pos, "%sWEP40",
765
 
                                        first ? "" : " ");
 
920
                        ret = snprintf(pos, end - pos, "%sWEP40",
 
921
                                       first ? "" : " ");
 
922
                        if (ret < 0 || ret >= end - pos)
 
923
                                return pos - buf;
 
924
                        pos += ret;
766
925
                        first = 0;
767
926
                }
768
927
 
771
930
 
772
931
        if (strcmp(field, "key_mgmt") == 0) {
773
932
                if (res < 0) {
774
 
                        return snprintf(buf, buflen, "WPA-PSK WPA-EAP "
775
 
                                        "IEEE8021X WPA-NONE NONE");
 
933
                        if (strict)
 
934
                                return 0;
 
935
                        ret = snprintf(buf, buflen, "WPA-PSK WPA-EAP "
 
936
                                       "IEEE8021X WPA-NONE NONE");
 
937
                        if (ret < 0 || (size_t) ret >= buflen)
 
938
                                return -1;
 
939
                        return ret;
776
940
                }
777
941
 
778
 
                pos += snprintf(pos, end - pos, "NONE IEEE8021X");
 
942
                ret = snprintf(pos, end - pos, "NONE IEEE8021X");
 
943
                if (ret < 0 || ret >= end - pos)
 
944
                        return pos - buf;
 
945
                pos += ret;
779
946
 
780
947
                if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
781
 
                                     WPA_DRIVER_CAPA_KEY_MGMT_WPA2))
782
 
                        pos += snprintf(pos, end - pos, " WPA-EAP");
 
948
                                     WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) {
 
949
                        ret = snprintf(pos, end - pos, " WPA-EAP");
 
950
                        if (ret < 0 || ret >= end - pos)
 
951
                                return pos - buf;
 
952
                        pos += ret;
 
953
                }
783
954
 
784
955
                if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
785
 
                                     WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK))
786
 
                        pos += snprintf(pos, end - pos, " WPA-PSK");
 
956
                                     WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
 
957
                        ret = snprintf(pos, end - pos, " WPA-PSK");
 
958
                        if (ret < 0 || ret >= end - pos)
 
959
                                return pos - buf;
 
960
                        pos += ret;
 
961
                }
787
962
 
788
 
                if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE)
789
 
                        pos += snprintf(pos, end - pos, " WPA-NONE");
 
963
                if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
 
964
                        ret = snprintf(pos, end - pos, " WPA-NONE");
 
965
                        if (ret < 0 || ret >= end - pos)
 
966
                                return pos - buf;
 
967
                        pos += ret;
 
968
                }
790
969
 
791
970
                return pos - buf;
792
971
        }
793
972
 
794
973
        if (strcmp(field, "proto") == 0) {
795
 
                if (res < 0)
796
 
                        return snprintf(buf, buflen, "RSN WPA");
 
974
                if (res < 0) {
 
975
                        if (strict)
 
976
                                return 0;
 
977
                        ret = snprintf(buf, buflen, "RSN WPA");
 
978
                        if (ret < 0 || (size_t) ret >= buflen)
 
979
                                return -1;
 
980
                        return ret;
 
981
                }
797
982
 
798
983
                if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
799
984
                                     WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
800
 
                        pos += snprintf(pos, end - pos, "%sRSN",
801
 
                                        first ? "" : " ");
 
985
                        ret = snprintf(pos, end - pos, "%sRSN",
 
986
                                       first ? "" : " ");
 
987
                        if (ret < 0 || ret >= end - pos)
 
988
                                return pos - buf;
 
989
                        pos += ret;
802
990
                        first = 0;
803
991
                }
804
992
 
805
993
                if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
806
994
                                     WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
807
 
                        pos += snprintf(pos, end - pos, "%sWPA",
808
 
                                        first ? "" : " ");
 
995
                        ret = snprintf(pos, end - pos, "%sWPA",
 
996
                                       first ? "" : " ");
 
997
                        if (ret < 0 || ret >= end - pos)
 
998
                                return pos - buf;
 
999
                        pos += ret;
809
1000
                        first = 0;
810
1001
                }
811
1002
 
813
1004
        }
814
1005
 
815
1006
        if (strcmp(field, "auth_alg") == 0) {
816
 
                if (res < 0)
817
 
                        return snprintf(buf, buflen, "OPEN SHARED LEAP");
 
1007
                if (res < 0) {
 
1008
                        if (strict)
 
1009
                                return 0;
 
1010
                        ret = snprintf(buf, buflen, "OPEN SHARED LEAP");
 
1011
                        if (ret < 0 || (size_t) ret >= buflen)
 
1012
                                return -1;
 
1013
                        return ret;
 
1014
                }
818
1015
 
819
1016
                if (capa.auth & (WPA_DRIVER_AUTH_OPEN)) {
820
 
                        pos += snprintf(pos, end - pos, "%sOPEN",
821
 
                                        first ? "" : " ");
 
1017
                        ret = snprintf(pos, end - pos, "%sOPEN",
 
1018
                                       first ? "" : " ");
 
1019
                        if (ret < 0 || ret >= end - pos)
 
1020
                                return pos - buf;
 
1021
                        pos += ret;
822
1022
                        first = 0;
823
1023
                }
824
1024
 
825
1025
                if (capa.auth & (WPA_DRIVER_AUTH_SHARED)) {
826
 
                        pos += snprintf(pos, end - pos, "%sSHARED",
827
 
                                        first ? "" : " ");
 
1026
                        ret = snprintf(pos, end - pos, "%sSHARED",
 
1027
                                       first ? "" : " ");
 
1028
                        if (ret < 0 || ret >= end - pos)
 
1029
                                return pos - buf;
 
1030
                        pos += ret;
828
1031
                        first = 0;
829
1032
                }
830
1033
 
831
1034
                if (capa.auth & (WPA_DRIVER_AUTH_LEAP)) {
832
 
                        pos += snprintf(pos, end - pos, "%sLEAP",
833
 
                                        first ? "" : " ");
 
1035
                        ret = snprintf(pos, end - pos, "%sLEAP",
 
1036
                                       first ? "" : " ");
 
1037
                        if (ret < 0 || ret >= end - pos)
 
1038
                                return pos - buf;
 
1039
                        pos += ret;
834
1040
                        first = 0;
835
1041
                }
836
1042
 
981
1187
        } else if (strncmp(buf, "AP_SCAN ", 8) == 0) {
982
1188
                if (wpa_supplicant_ctrl_iface_ap_scan(wpa_s, buf + 8))
983
1189
                        reply_len = -1;
 
1190
        } else if (strcmp(buf, "INTERFACES") == 0) {
 
1191
                reply_len = wpa_supplicant_global_iface_interfaces(
 
1192
                        wpa_s->global, reply, reply_size);
984
1193
        } else {
985
1194
                memcpy(reply, "UNKNOWN COMMAND\n", 16);
986
1195
                reply_len = 16;
1090
1299
}
1091
1300
 
1092
1301
 
 
1302
static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
 
1303
                                                  char *buf, int len)
 
1304
{
 
1305
        int res;
 
1306
        char *pos, *end;
 
1307
        struct wpa_supplicant *wpa_s;
 
1308
 
 
1309
        wpa_s = global->ifaces;
 
1310
        pos = buf;
 
1311
        end = buf + len;
 
1312
 
 
1313
        while (wpa_s) {
 
1314
                res = snprintf(pos, end - pos, "%s\n", wpa_s->ifname);
 
1315
                if (res < 0 || res >= end - pos) {
 
1316
                        *pos = '\0';
 
1317
                        break;
 
1318
                }
 
1319
                pos += res;
 
1320
                wpa_s = wpa_s->next;
 
1321
        }
 
1322
        return pos - buf;
 
1323
}
 
1324
 
 
1325
 
1093
1326
char * wpa_supplicant_global_ctrl_iface_process(struct wpa_global *global,
1094
1327
                                                char *buf, size_t *resp_len)
1095
1328
{
1118
1351
        } else if (strncmp(buf, "INTERFACE_REMOVE ", 17) == 0) {
1119
1352
                if (wpa_supplicant_global_iface_remove(global, buf + 17))
1120
1353
                        reply_len = -1;
 
1354
        } else if (strcmp(buf, "INTERFACES") == 0) {
 
1355
                reply_len = wpa_supplicant_global_iface_interfaces(
 
1356
                        global, reply, reply_size);
1121
1357
        } else {
1122
1358
                memcpy(reply, "UNKNOWN COMMAND\n", 16);
1123
1359
                reply_len = 16;