← Back to branch summary

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

« back to all changes in this revision

Viewing changes to wpa_cli.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:
wpa_cli.c
16
16
 
17
17
#ifdef CONFIG_CTRL_IFACE
18
18
 
19
 
#ifndef CONFIG_CTRL_IFACE_UDP
 
19
#ifdef CONFIG_CTRL_IFACE_UNIX
20
20
#include <dirent.h>
21
 
#endif /* CONFIG_CTRL_IFACE_UDP */
 
21
#endif /* CONFIG_CTRL_IFACE_UNIX */
22
22
#ifdef CONFIG_READLINE
23
23
#include <readline/readline.h>
24
24
#include <readline/history.h>
163
163
 
164
164
static struct wpa_ctrl * wpa_cli_open_connection(const char *ifname)
165
165
{
166
 
#ifdef CONFIG_CTRL_IFACE_UDP
167
 
        ctrl_conn = wpa_ctrl_open("");
 
166
#if defined(CONFIG_CTRL_IFACE_UDP) || defined(CONFIG_CTRL_IFACE_NAMED_PIPE)
 
167
        ctrl_conn = wpa_ctrl_open(ifname);
168
168
        return ctrl_conn;
169
 
#else /* CONFIG_CTRL_IFACE_UDP */
 
169
#else /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
170
170
        char *cfile;
171
171
        int flen;
172
172
 
182
182
        ctrl_conn = wpa_ctrl_open(cfile);
183
183
        free(cfile);
184
184
        return ctrl_conn;
185
 
#endif /* CONFIG_CTRL_IFACE_UDP */
 
185
#endif /* CONFIG_CTRL_IFACE_UDP || CONFIG_CTRL_IFACE_NAMED_PIPE */
186
186
}
187
187
 
188
188
 
395
395
static int wpa_cli_cmd_ap_scan(struct wpa_ctrl *ctrl, int argc, char *argv[])
396
396
{
397
397
        char cmd[256];
 
398
        int res;
 
399
 
398
400
        if (argc != 1) {
399
401
                printf("Invalid AP_SCAN command: needs one argument (ap_scan "
400
402
                       "value)\n");
401
403
                return 0;
402
404
        }
403
 
        snprintf(cmd, sizeof(cmd), "AP_SCAN %s", argv[0]);
 
405
        res = snprintf(cmd, sizeof(cmd), "AP_SCAN %s", argv[0]);
 
406
        if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
 
407
                printf("Too long AP_SCAN command.\n");
 
408
                return 0;
 
409
        }
404
410
        return wpa_ctrl_command(ctrl, cmd);
405
411
}
406
412
 
429
435
static int wpa_cli_cmd_level(struct wpa_ctrl *ctrl, int argc, char *argv[])
430
436
{
431
437
        char cmd[256];
 
438
        int res;
 
439
 
432
440
        if (argc != 1) {
433
441
                printf("Invalid LEVEL command: needs one argument (debug "
434
442
                       "level)\n");
435
443
                return 0;
436
444
        }
437
 
        snprintf(cmd, sizeof(cmd), "LEVEL %s", argv[0]);
 
445
        res = snprintf(cmd, sizeof(cmd), "LEVEL %s", argv[0]);
 
446
        if (res < 0 || (size_t) res >= sizeof(cmd) - 1) {
 
447
                printf("Too long LEVEL command.\n");
 
448
                return 0;
 
449
        }
438
450
        return wpa_ctrl_command(ctrl, cmd);
439
451
}
440
452
 
442
454
static int wpa_cli_cmd_identity(struct wpa_ctrl *ctrl, int argc, char *argv[])
443
455
{
444
456
        char cmd[256], *pos, *end;
445
 
        int i;
 
457
        int i, ret;
446
458
 
447
459
        if (argc < 2) {
448
460
                printf("Invalid IDENTITY command: needs two arguments "
452
464
 
453
465
        end = cmd + sizeof(cmd);
454
466
        pos = cmd;
455
 
        pos += snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
 
467
        ret = snprintf(pos, end - pos, WPA_CTRL_RSP "IDENTITY-%s:%s",
456
468
                       argv[0], argv[1]);
457
 
        for (i = 2; i < argc; i++)
458
 
                pos += snprintf(pos, end - pos, " %s", argv[i]);
 
469
        if (ret < 0 || ret >= end - pos) {
 
470
                printf("Too long IDENTITY command.\n");
 
471
                return 0;
 
472
        }
 
473
        pos += ret;
 
474
        for (i = 2; i < argc; i++) {
 
475
                ret = snprintf(pos, end - pos, " %s", argv[i]);
 
476
                if (ret < 0 || ret >= end - pos) {
 
477
                        printf("Too long IDENTITY command.\n");
 
478
                        return 0;
 
479
                }
 
480
                pos += ret;
 
481
        }
459
482
 
460
483
        return wpa_ctrl_command(ctrl, cmd);
461
484
}
464
487
static int wpa_cli_cmd_password(struct wpa_ctrl *ctrl, int argc, char *argv[])
465
488
{
466
489
        char cmd[256], *pos, *end;
467
 
        int i;
 
490
        int i, ret;
468
491
 
469
492
        if (argc < 2) {
470
493
                printf("Invalid PASSWORD command: needs two arguments "
474
497
 
475
498
        end = cmd + sizeof(cmd);
476
499
        pos = cmd;
477
 
        pos += snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
 
500
        ret = snprintf(pos, end - pos, WPA_CTRL_RSP "PASSWORD-%s:%s",
478
501
                       argv[0], argv[1]);
479
 
        for (i = 2; i < argc; i++)
480
 
                pos += snprintf(pos, end - pos, " %s", argv[i]);
 
502
        if (ret < 0 || ret >= end - pos) {
 
503
                printf("Too long PASSWORD command.\n");
 
504
                return 0;
 
505
        }
 
506
        pos += ret;
 
507
        for (i = 2; i < argc; i++) {
 
508
                ret = snprintf(pos, end - pos, " %s", argv[i]);
 
509
                if (ret < 0 || ret >= end - pos) {
 
510
                        printf("Too long PASSWORD command.\n");
 
511
                        return 0;
 
512
                }
 
513
                pos += ret;
 
514
        }
481
515
 
482
516
        return wpa_ctrl_command(ctrl, cmd);
483
517
}
487
521
                                    char *argv[])
488
522
{
489
523
        char cmd[256], *pos, *end;
490
 
        int i;
 
524
        int i, ret;
491
525
 
492
526
        if (argc < 2) {
493
527
                printf("Invalid NEW_PASSWORD command: needs two arguments "
497
531
 
498
532
        end = cmd + sizeof(cmd);
499
533
        pos = cmd;
500
 
        pos += snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
 
534
        ret = snprintf(pos, end - pos, WPA_CTRL_RSP "NEW_PASSWORD-%s:%s",
501
535
                       argv[0], argv[1]);
502
 
        for (i = 2; i < argc; i++)
503
 
                pos += snprintf(pos, end - pos, " %s", argv[i]);
 
536
        if (ret < 0 || ret >= end - pos) {
 
537
                printf("Too long NEW_PASSWORD command.\n");
 
538
                return 0;
 
539
        }
 
540
        pos += ret;
 
541
        for (i = 2; i < argc; i++) {
 
542
                ret = snprintf(pos, end - pos, " %s", argv[i]);
 
543
                if (ret < 0 || ret >= end - pos) {
 
544
                        printf("Too long NEW_PASSWORD command.\n");
 
545
                        return 0;
 
546
                }
 
547
                pos += ret;
 
548
        }
504
549
 
505
550
        return wpa_ctrl_command(ctrl, cmd);
506
551
}
509
554
static int wpa_cli_cmd_pin(struct wpa_ctrl *ctrl, int argc, char *argv[])
510
555
{
511
556
        char cmd[256], *pos, *end;
512
 
        int i;
 
557
        int i, ret;
513
558
 
514
559
        if (argc < 2) {
515
560
                printf("Invalid PIN command: needs two arguments "
519
564
 
520
565
        end = cmd + sizeof(cmd);
521
566
        pos = cmd;
522
 
        pos += snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
523
 
                        argv[0], argv[1]);
524
 
        for (i = 2; i < argc; i++)
525
 
                pos += snprintf(pos, end - pos, " %s", argv[i]);
526
 
 
 
567
        ret = snprintf(pos, end - pos, WPA_CTRL_RSP "PIN-%s:%s",
 
568
                       argv[0], argv[1]);
 
569
        if (ret < 0 || ret >= end - pos) {
 
570
                printf("Too long PIN command.\n");
 
571
                return 0;
 
572
        }
 
573
        pos += ret;
 
574
        for (i = 2; i < argc; i++) {
 
575
                ret = snprintf(pos, end - pos, " %s", argv[i]);
 
576
                if (ret < 0 || ret >= end - pos) {
 
577
                        printf("Too long PIN command.\n");
 
578
                        return 0;
 
579
                }
 
580
                pos += ret;
 
581
        }
527
582
        return wpa_ctrl_command(ctrl, cmd);
528
583
}
529
584
 
531
586
static int wpa_cli_cmd_otp(struct wpa_ctrl *ctrl, int argc, char *argv[])
532
587
{
533
588
        char cmd[256], *pos, *end;
534
 
        int i;
 
589
        int i, ret;
535
590
 
536
591
        if (argc < 2) {
537
592
                printf("Invalid OTP command: needs two arguments (network "
541
596
 
542
597
        end = cmd + sizeof(cmd);
543
598
        pos = cmd;
544
 
        pos += snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
 
599
        ret = snprintf(pos, end - pos, WPA_CTRL_RSP "OTP-%s:%s",
545
600
                       argv[0], argv[1]);
546
 
        for (i = 2; i < argc; i++)
547
 
                pos += snprintf(pos, end - pos, " %s", argv[i]);
 
601
        if (ret < 0 || ret >= end - pos) {
 
602
                printf("Too long OTP command.\n");
 
603
                return 0;
 
604
        }
 
605
        pos += ret;
 
606
        for (i = 2; i < argc; i++) {
 
607
                ret = snprintf(pos, end - pos, " %s", argv[i]);
 
608
                if (ret < 0 || ret >= end - pos) {
 
609
                        printf("Too long OTP command.\n");
 
610
                        return 0;
 
611
                }
 
612
                pos += ret;
 
613
        }
548
614
 
549
615
        return wpa_ctrl_command(ctrl, cmd);
550
616
}
554
620
                                  char *argv[])
555
621
{
556
622
        char cmd[256], *pos, *end;
557
 
        int i;
 
623
        int i, ret;
558
624
 
559
625
        if (argc < 2) {
560
626
                printf("Invalid PASSPHRASE command: needs two arguments "
564
630
 
565
631
        end = cmd + sizeof(cmd);
566
632
        pos = cmd;
567
 
        pos += snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
 
633
        ret = snprintf(pos, end - pos, WPA_CTRL_RSP "PASSPHRASE-%s:%s",
568
634
                       argv[0], argv[1]);
569
 
        for (i = 2; i < argc; i++)
570
 
                pos += snprintf(pos, end - pos, " %s", argv[i]);
 
635
        if (ret < 0 || ret >= end - pos) {
 
636
                printf("Too long PASSPHRASE command.\n");
 
637
                return 0;
 
638
        }
 
639
        pos += ret;
 
640
        for (i = 2; i < argc; i++) {
 
641
                ret = snprintf(pos, end - pos, " %s", argv[i]);
 
642
                if (ret < 0 || ret >= end - pos) {
 
643
                        printf("Too long PASSPHRASE command.\n");
 
644
                        return 0;
 
645
                }
 
646
                pos += ret;
 
647
        }
571
648
 
572
649
        return wpa_ctrl_command(ctrl, cmd);
573
650
}
576
653
static int wpa_cli_cmd_bssid(struct wpa_ctrl *ctrl, int argc, char *argv[])
577
654
{
578
655
        char cmd[256], *pos, *end;
579
 
        int i;
 
656
        int i, ret;
580
657
 
581
658
        if (argc < 2) {
582
659
                printf("Invalid BSSID command: needs two arguments (network "
586
663
 
587
664
        end = cmd + sizeof(cmd);
588
665
        pos = cmd;
589
 
        pos += snprintf(pos, end - pos, "BSSID");
590
 
        for (i = 0; i < argc; i++)
591
 
                pos += snprintf(pos, end - pos, " %s", argv[i]);
 
666
        ret = snprintf(pos, end - pos, "BSSID");
 
667
        if (ret < 0 || ret >= end - pos) {
 
668
                printf("Too long BSSID command.\n");
 
669
                return 0;
 
670
        }
 
671
        pos += ret;
 
672
        for (i = 0; i < argc; i++) {
 
673
                ret = snprintf(pos, end - pos, " %s", argv[i]);
 
674
                if (ret < 0 || ret >= end - pos) {
 
675
                        printf("Too long BSSID command.\n");
 
676
                        return 0;
 
677
                }
 
678
                pos += ret;
 
679
        }
592
680
 
593
681
        return wpa_ctrl_command(ctrl, cmd);
594
682
}
613
701
        }
614
702
 
615
703
        snprintf(cmd, sizeof(cmd), "SELECT_NETWORK %s", argv[0]);
 
704
        cmd[sizeof(cmd) - 1] = '\0';
616
705
 
617
706
        return wpa_ctrl_command(ctrl, cmd);
618
707
}
630
719
        }
631
720
 
632
721
        snprintf(cmd, sizeof(cmd), "ENABLE_NETWORK %s", argv[0]);
 
722
        cmd[sizeof(cmd) - 1] = '\0';
633
723
 
634
724
        return wpa_ctrl_command(ctrl, cmd);
635
725
}
647
737
        }
648
738
 
649
739
        snprintf(cmd, sizeof(cmd), "DISABLE_NETWORK %s", argv[0]);
 
740
        cmd[sizeof(cmd) - 1] = '\0';
650
741
 
651
742
        return wpa_ctrl_command(ctrl, cmd);
652
743
}
671
762
        }
672
763
 
673
764
        snprintf(cmd, sizeof(cmd), "REMOVE_NETWORK %s", argv[0]);
 
765
        cmd[sizeof(cmd) - 1] = '\0';
674
766
 
675
767
        return wpa_ctrl_command(ctrl, cmd);
676
768
}
783
875
{
784
876
        char cmd[64];
785
877
 
786
 
        if (argc != 1) {
787
 
                printf("Invalid GET_CAPABILITY command: needs one argument\n");
788
 
                return 0;
789
 
        }
790
 
 
791
 
        snprintf(cmd, sizeof(cmd), "GET_CAPABILITY %s", argv[0]);
 
878
        if (argc < 1 || argc > 2) {
 
879
                printf("Invalid GET_CAPABILITY command: need either one or "
 
880
                       "two arguments\n");
 
881
                return 0;
 
882
        }
 
883
 
 
884
        if ((argc == 2) && strcmp(argv[1], "strict") != 0) {
 
885
                printf("Invalid GET_CAPABILITY command: second argument, "
 
886
                       "if any, must be 'strict'\n");
 
887
                return 0;
 
888
        }
 
889
 
 
890
        snprintf(cmd, sizeof(cmd), "GET_CAPABILITY %s%s", argv[0],
 
891
                 (argc == 2) ? " strict" : "");
 
892
        cmd[sizeof(cmd) - 1] = '\0';
792
893
 
793
894
        return wpa_ctrl_command(ctrl, cmd);
794
895
}
795
896
 
796
897
 
797
 
static void wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
 
898
static int wpa_cli_list_interfaces(struct wpa_ctrl *ctrl)
798
899
{
799
 
#ifndef CONFIG_CTRL_IFACE_UDP
800
 
        struct dirent *dent;
801
 
        DIR *dir;
802
 
 
803
 
        dir = opendir(ctrl_iface_dir);
804
 
        if (dir == NULL) {
805
 
                printf("Control interface directory '%s' could not be "
806
 
                       "openned.\n", ctrl_iface_dir);
807
 
                return;
808
 
        }
809
 
 
810
900
        printf("Available interfaces:\n");
811
 
        while ((dent = readdir(dir))) {
812
 
                if (strcmp(dent->d_name, ".") == 0 ||
813
 
                    strcmp(dent->d_name, "..") == 0)
814
 
                        continue;
815
 
                printf("%s\n", dent->d_name);
816
 
        }
817
 
        closedir(dir);
818
 
#endif /* CONFIG_CTRL_IFACE_UDP */
 
901
        return wpa_ctrl_command(ctrl, "INTERFACES");
819
902
}
820
903
 
821
904
 
882
965
                 argc > 1 ? argv[1] : "", argc > 2 ? argv[2] : "",
883
966
                 argc > 3 ? argv[3] : "", argc > 4 ? argv[4] : "",
884
967
                 argc > 5 ? argv[5] : "");
 
968
        cmd[sizeof(cmd) - 1] = '\0';
885
969
        return wpa_ctrl_command(ctrl, cmd);
886
970
}
887
971
 
898
982
        }
899
983
 
900
984
        snprintf(cmd, sizeof(cmd), "INTERFACE_REMOVE %s", argv[0]);
 
985
        cmd[sizeof(cmd) - 1] = '\0';
901
986
        return wpa_ctrl_command(ctrl, cmd);
902
987
}
903
988
 
1009
1094
        if (cmd == NULL)
1010
1095
                return -1;
1011
1096
        snprintf(cmd, len, "%s %s %s", program, arg1, arg2);
 
1097
        cmd[len - 1] = '\0';
1012
1098
#ifndef _WIN32_WCE
1013
1099
        system(cmd);
1014
1100
#endif /* _WIN32_WCE */
1089
1175
#endif /* CONFIG_ANSI_C_EXTRA */
1090
1176
 
1091
1177
 
 
1178
static void wpa_cli_reconnect(void)
 
1179
{
 
1180
        wpa_cli_close_connection();
 
1181
        ctrl_conn = wpa_cli_open_connection(ctrl_ifname);
 
1182
        if (ctrl_conn) {
 
1183
                printf("Connection to wpa_supplicant re-established\n");
 
1184
                if (wpa_ctrl_attach(ctrl_conn) == 0) {
 
1185
                        wpa_cli_attached = 1;
 
1186
                } else {
 
1187
                        printf("Warning: Failed to attach to "
 
1188
                               "wpa_supplicant.\n");
 
1189
                }
 
1190
        }
 
1191
}
 
1192
 
 
1193
 
1092
1194
static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read,
1093
1195
                                 int action_monitor)
1094
1196
{
1095
1197
        int first = 1;
1096
 
        if (ctrl_conn == NULL)
 
1198
        if (ctrl_conn == NULL) {
 
1199
                wpa_cli_reconnect();
1097
1200
                return;
1098
 
        while (wpa_ctrl_pending(ctrl)) {
 
1201
        }
 
1202
        while (wpa_ctrl_pending(ctrl) > 0) {
1099
1203
                char buf[256];
1100
1204
                size_t len = sizeof(buf) - 1;
1101
1205
                if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
1113
1217
                        break;
1114
1218
                }
1115
1219
        }
 
1220
 
 
1221
        if (wpa_ctrl_pending(ctrl) < 0) {
 
1222
                printf("Connection to wpa_supplicant lost - trying to "
 
1223
                       "reconnect\n");
 
1224
                wpa_cli_reconnect();
 
1225
        }
1116
1226
}
1117
1227
 
1118
1228
 
1171
1281
                hfile = malloc(hfile_len);
1172
1282
                if (hfile) {
1173
1283
                        snprintf(hfile, hfile_len, "%s/%s", home, fname);
 
1284
                        hfile[hfile_len - 1] = '\0';
1174
1285
                        read_history(hfile);
1175
1286
                        stifle_history(100);
1176
1287
                }
1337
1448
                       "reconnect\n");
1338
1449
                wpa_cli_close_connection();
1339
1450
        }
1340
 
        if (!ctrl_conn) {
1341
 
                ctrl_conn = wpa_cli_open_connection(ctrl_ifname);
1342
 
                if (ctrl_conn) {
1343
 
                        printf("Connection to wpa_supplicant "
1344
 
                               "re-established\n");
1345
 
                        if (wpa_ctrl_attach(ctrl_conn) == 0) {
1346
 
                                wpa_cli_attached = 1;
1347
 
                        } else {
1348
 
                                printf("Warning: Failed to attach to "
1349
 
                                       "wpa_supplicant.\n");
1350
 
                        }
1351
 
                }
1352
 
        }
 
1451
        if (!ctrl_conn)
 
1452
                wpa_cli_reconnect();
1353
1453
        if (ctrl_conn)
1354
1454
                wpa_cli_recv_pending(ctrl_conn, 1, 0);
1355
1455
        alarm(1);
1357
1457
#endif /* CONFIG_NATIVE_WINDOWS */
1358
1458
 
1359
1459
 
 
1460
static char * wpa_cli_get_default_ifname(void)
 
1461
{
 
1462
        char *ifname = NULL;
 
1463
 
 
1464
#ifdef CONFIG_CTRL_IFACE_UNIX
 
1465
        struct dirent *dent;
 
1466
        DIR *dir = opendir(ctrl_iface_dir);
 
1467
        if (!dir)
 
1468
                return NULL;
 
1469
        while ((dent = readdir(dir))) {
 
1470
#ifdef _DIRENT_HAVE_D_TYPE
 
1471
                /*
 
1472
                 * Skip the file if it is not a socket. Also accept
 
1473
                 * DT_UNKNOWN (0) in case the C library or underlying
 
1474
                 * file system does not support d_type.
 
1475
                 */
 
1476
                if (dent->d_type != DT_SOCK && dent->d_type != DT_UNKNOWN)
 
1477
                        continue;
 
1478
#endif /* _DIRENT_HAVE_D_TYPE */
 
1479
                if (strcmp(dent->d_name, ".") == 0 ||
 
1480
                    strcmp(dent->d_name, "..") == 0)
 
1481
                        continue;
 
1482
                printf("Selected interface '%s'\n", dent->d_name);
 
1483
                ifname = strdup(dent->d_name);
 
1484
                break;
 
1485
        }
 
1486
        closedir(dir);
 
1487
#endif /* CONFIG_CTRL_IFACE_UNIX */
 
1488
 
 
1489
#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
 
1490
        char buf[2048], *pos;
 
1491
        size_t len;
 
1492
        struct wpa_ctrl *ctrl;
 
1493
        int ret;
 
1494
 
 
1495
        ctrl = wpa_ctrl_open(NULL);
 
1496
        if (ctrl == NULL)
 
1497
                return NULL;
 
1498
 
 
1499
        len = sizeof(buf) - 1;
 
1500
        ret = wpa_ctrl_request(ctrl, "INTERFACES", 10, buf, &len, NULL);
 
1501
        if (ret >= 0) {
 
1502
                buf[len] = '\0';
 
1503
                pos = strchr(buf, '\n');
 
1504
                if (pos)
 
1505
                        *pos = '\0';
 
1506
                ifname = strdup(buf);
 
1507
        }
 
1508
        wpa_ctrl_close(ctrl);
 
1509
#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
 
1510
 
 
1511
        return ifname;
 
1512
}
 
1513
 
 
1514
 
1360
1515
int main(int argc, char *argv[])
1361
1516
{
1362
1517
        int interactive;
1409
1564
                printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);
1410
1565
 
1411
1566
        if (global) {
 
1567
#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
 
1568
                ctrl_conn = wpa_ctrl_open(NULL);
 
1569
#else /* CONFIG_CTRL_IFACE_NAMED_PIPE */
1412
1570
                ctrl_conn = wpa_ctrl_open(global);
 
1571
#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
1413
1572
                if (ctrl_conn == NULL) {
1414
1573
                        perror("Failed to connect to wpa_supplicant - "
1415
1574
                               "wpa_ctrl_open");
1418
1577
        }
1419
1578
 
1420
1579
        for (; !global;) {
1421
 
#ifndef CONFIG_CTRL_IFACE_UDP
1422
 
                if (ctrl_ifname == NULL) {
1423
 
                        struct dirent *dent;
1424
 
                        DIR *dir = opendir(ctrl_iface_dir);
1425
 
                        if (dir) {
1426
 
                                while ((dent = readdir(dir))) {
1427
 
#ifdef _DIRENT_HAVE_D_TYPE
1428
 
                                        /* Skip the file if it is not a socket.
1429
 
                                         * Also accept DT_UNKNOWN (0) in case
1430
 
                                         * the C library or underlying file
1431
 
                                         * system does not support d_type. */
1432
 
                                        if (dent->d_type != DT_SOCK &&
1433
 
                                            dent->d_type != DT_UNKNOWN)
1434
 
                                                continue;
1435
 
#endif /* _DIRENT_HAVE_D_TYPE */
1436
 
                                        if (strcmp(dent->d_name, ".") == 0 ||
1437
 
                                            strcmp(dent->d_name, "..") == 0)
1438
 
                                                continue;
1439
 
                                        printf("Selected interface '%s'\n",
1440
 
                                               dent->d_name);
1441
 
                                        ctrl_ifname = strdup(dent->d_name);
1442
 
                                        break;
1443
 
                                }
1444
 
                                closedir(dir);
1445
 
                        }
1446
 
                }
1447
 
#endif /* CONFIG_CTRL_IFACE_UDP */
 
1580
                if (ctrl_ifname == NULL)
 
1581
                        ctrl_ifname = wpa_cli_get_default_ifname();
1448
1582
                ctrl_conn = wpa_cli_open_connection(ctrl_ifname);
1449
1583
                if (ctrl_conn) {
1450
1584
                        if (warning_displayed)