www.project-moonshot.org Git - mech_eap.orig/blob - libeap/wpa_supplicant/wpa_gui-qt4/peers.cpp

   1 /*
   2  * wpa_gui - Peers class
   3  * Copyright (c) 2009-2010, Atheros Communications
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include <cstdio>
  16 #include <QImageReader>
  17 #include <QMessageBox>
  18
  19 #include "common/wpa_ctrl.h"
  20 #include "wpagui.h"
  21 #include "stringquery.h"
  22 #include "peers.h"
  23
  24
  25 enum {
  26         peer_role_address = Qt::UserRole + 1,
  27         peer_role_type,
  28         peer_role_uuid,
  29         peer_role_details,
  30         peer_role_ifname,
  31         peer_role_pri_dev_type,
  32         peer_role_ssid,
  33         peer_role_config_methods,
  34         peer_role_dev_passwd_id,
  35         peer_role_bss_id,
  36         peer_role_selected_method,
  37         peer_role_selected_pin,
  38         peer_role_requested_method,
  39         peer_role_network_id
  40 };
  41
  42 enum selected_method {
  43         SEL_METHOD_NONE,
  44         SEL_METHOD_PIN_PEER_DISPLAY,
  45         SEL_METHOD_PIN_LOCAL_DISPLAY
  46 };
  47
  48 /*
  49  * TODO:
  50  * - add current AP info (e.g., from WPS) in station mode
  51  */
  52
  53 enum peer_type {
  54         PEER_TYPE_ASSOCIATED_STATION,
  55         PEER_TYPE_AP,
  56         PEER_TYPE_AP_WPS,
  57         PEER_TYPE_WPS_PIN_NEEDED,
  58         PEER_TYPE_P2P,
  59         PEER_TYPE_P2P_CLIENT,
  60         PEER_TYPE_P2P_GROUP,
  61         PEER_TYPE_P2P_PERSISTENT_GROUP_GO,
  62         PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT,
  63         PEER_TYPE_P2P_INVITATION,
  64         PEER_TYPE_WPS_ER_AP,
  65         PEER_TYPE_WPS_ER_AP_UNCONFIGURED,
  66         PEER_TYPE_WPS_ER_ENROLLEE,
  67         PEER_TYPE_WPS_ENROLLEE
  68 };
  69
  70
  71 Peers::Peers(QWidget *parent, const char *, bool, Qt::WFlags)
  72         : QDialog(parent)
  73 {
  74         setupUi(this);
  75
  76         if (QImageReader::supportedImageFormats().contains(QByteArray("svg")))
  77         {
  78                 default_icon = new QIcon(":/icons/wpa_gui.svg");
  79                 ap_icon = new QIcon(":/icons/ap.svg");
  80                 laptop_icon = new QIcon(":/icons/laptop.svg");
  81                 group_icon = new QIcon(":/icons/group.svg");
  82                 invitation_icon = new QIcon(":/icons/invitation.svg");
  83         } else {
  84                 default_icon = new QIcon(":/icons/wpa_gui.png");
  85                 ap_icon = new QIcon(":/icons/ap.png");
  86                 laptop_icon = new QIcon(":/icons/laptop.png");
  87                 group_icon = new QIcon(":/icons/group.png");
  88                 invitation_icon = new QIcon(":/icons/invitation.png");
  89         }
  90
  91         peers->setModel(&model);
  92         peers->setResizeMode(QListView::Adjust);
  93         peers->setDragEnabled(false);
  94         peers->setSelectionMode(QAbstractItemView::NoSelection);
  95
  96         peers->setContextMenuPolicy(Qt::CustomContextMenu);
  97         connect(peers, SIGNAL(customContextMenuRequested(const QPoint &)),
  98                 this, SLOT(context_menu(const QPoint &)));
  99
 100         wpagui = NULL;
 101         hide_ap = false;
 102 }
 103
 104
 105 void Peers::setWpaGui(WpaGui *_wpagui)
 106 {
 107         wpagui = _wpagui;
 108         update_peers();
 109 }
 110
 111
 112 Peers::~Peers()
 113 {
 114         delete default_icon;
 115         delete ap_icon;
 116         delete laptop_icon;
 117         delete group_icon;
 118         delete invitation_icon;
 119 }
 120
 121
 122 void Peers::languageChange()
 123 {
 124         retranslateUi(this);
 125 }
 126
 127
 128 QString Peers::ItemType(int type)
 129 {
 130         QString title;
 131         switch (type) {
 132         case PEER_TYPE_ASSOCIATED_STATION:
 133                 title = tr("Associated station");
 134                 break;
 135         case PEER_TYPE_AP:
 136                 title = tr("AP");
 137                 break;
 138         case PEER_TYPE_AP_WPS:
 139                 title = tr("WPS AP");
 140                 break;
 141         case PEER_TYPE_WPS_PIN_NEEDED:
 142                 title = tr("WPS PIN needed");
 143                 break;
 144         case PEER_TYPE_P2P:
 145                 title = tr("P2P Device");
 146                 break;
 147         case PEER_TYPE_P2P_CLIENT:
 148                 title = tr("P2P Device (group client)");
 149                 break;
 150         case PEER_TYPE_P2P_GROUP:
 151                 title = tr("P2P Group");
 152                 break;
 153         case PEER_TYPE_P2P_PERSISTENT_GROUP_GO:
 154                 title = tr("P2P Persistent Group (GO)");
 155                 break;
 156         case PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT:
 157                 title = tr("P2P Persistent Group (client)");
 158                 break;
 159         case PEER_TYPE_P2P_INVITATION:
 160                 title = tr("P2P Invitation");
 161                 break;
 162         case PEER_TYPE_WPS_ER_AP:
 163                 title = tr("ER: WPS AP");
 164                 break;
 165         case PEER_TYPE_WPS_ER_AP_UNCONFIGURED:
 166                 title = tr("ER: WPS AP (Unconfigured)");
 167                 break;
 168         case PEER_TYPE_WPS_ER_ENROLLEE:
 169                 title = tr("ER: WPS Enrollee");
 170                 break;
 171         case PEER_TYPE_WPS_ENROLLEE:
 172                 title = tr("WPS Enrollee");
 173                 break;
 174         }
 175         return title;
 176 }
 177
 178
 179 void Peers::context_menu(const QPoint &pos)
 180 {
 181         QMenu *menu = new QMenu;
 182         if (menu == NULL)
 183                 return;
 184
 185         QModelIndex idx = peers->indexAt(pos);
 186         if (idx.isValid()) {
 187                 ctx_item = model.itemFromIndex(idx);
 188                 int type = ctx_item->data(peer_role_type).toInt();
 189                 menu->addAction(Peers::ItemType(type))->setEnabled(false);
 190                 menu->addSeparator();
 191
 192                 int config_methods = -1;
 193                 QVariant var = ctx_item->data(peer_role_config_methods);
 194                 if (var.isValid())
 195                         config_methods = var.toInt();
 196
 197                 enum selected_method method = SEL_METHOD_NONE;
 198                 var = ctx_item->data(peer_role_selected_method);
 199                 if (var.isValid())
 200                         method = (enum selected_method) var.toInt();
 201
 202                 if ((type == PEER_TYPE_ASSOCIATED_STATION ||
 203                      type == PEER_TYPE_AP_WPS ||
 204                      type == PEER_TYPE_WPS_PIN_NEEDED ||
 205                      type == PEER_TYPE_WPS_ER_ENROLLEE ||
 206                      type == PEER_TYPE_WPS_ENROLLEE) &&
 207                     (config_methods == -1 || (config_methods & 0x010c))) {
 208                         menu->addAction(tr("Enter WPS PIN"), this,
 209                                         SLOT(enter_pin()));
 210                 }
 211
 212                 if (type == PEER_TYPE_P2P || type == PEER_TYPE_P2P_CLIENT) {
 213                         menu->addAction(tr("P2P Connect"), this,
 214                                         SLOT(ctx_p2p_connect()));
 215                         if (method == SEL_METHOD_NONE &&
 216                             config_methods > -1 &&
 217                             config_methods & 0x0080 /* PBC */ &&
 218                             config_methods != 0x0080)
 219                                 menu->addAction(tr("P2P Connect (PBC)"), this,
 220                                                 SLOT(connect_pbc()));
 221                         if (method == SEL_METHOD_NONE) {
 222                                 menu->addAction(tr("P2P Request PIN"), this,
 223                                                 SLOT(ctx_p2p_req_pin()));
 224                                 menu->addAction(tr("P2P Show PIN"), this,
 225                                                 SLOT(ctx_p2p_show_pin()));
 226                         }
 227
 228                         if (config_methods > -1 && (config_methods & 0x0100)) {
 229                                 /* Peer has Keypad */
 230                                 menu->addAction(tr("P2P Display PIN"), this,
 231                                                 SLOT(ctx_p2p_display_pin()));
 232                         }
 233
 234                         if (config_methods > -1 && (config_methods & 0x000c)) {
 235                                 /* Peer has Label or Display */
 236                                 menu->addAction(tr("P2P Enter PIN"), this,
 237                                                 SLOT(ctx_p2p_enter_pin()));
 238                         }
 239                 }
 240
 241                 if (type == PEER_TYPE_P2P_GROUP) {
 242                         menu->addAction(tr("Show passphrase"), this,
 243                                         SLOT(ctx_p2p_show_passphrase()));
 244                         menu->addAction(tr("Remove P2P Group"), this,
 245                                         SLOT(ctx_p2p_remove_group()));
 246                 }
 247
 248                 if (type == PEER_TYPE_P2P_PERSISTENT_GROUP_GO ||
 249                     type == PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT ||
 250                     type == PEER_TYPE_P2P_INVITATION) {
 251                         menu->addAction(tr("Start group"), this,
 252                                         SLOT(ctx_p2p_start_persistent()));
 253                 }
 254
 255                 if (type == PEER_TYPE_P2P_PERSISTENT_GROUP_GO ||
 256                     type == PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT) {
 257                         menu->addAction(tr("Invite"), this,
 258                                         SLOT(ctx_p2p_invite()));
 259                 }
 260
 261                 if (type == PEER_TYPE_P2P_INVITATION) {
 262                         menu->addAction(tr("Ignore"), this,
 263                                         SLOT(ctx_p2p_delete()));
 264                 }
 265
 266                 if (type == PEER_TYPE_AP_WPS) {
 267                         menu->addAction(tr("Connect (PBC)"), this,
 268                                         SLOT(connect_pbc()));
 269                 }
 270
 271                 if ((type == PEER_TYPE_ASSOCIATED_STATION ||
 272                      type == PEER_TYPE_WPS_ER_ENROLLEE ||
 273                      type == PEER_TYPE_WPS_ENROLLEE) &&
 274                     config_methods >= 0 && (config_methods & 0x0080)) {
 275                         menu->addAction(tr("Enroll (PBC)"), this,
 276                                         SLOT(connect_pbc()));
 277                 }
 278
 279                 if (type == PEER_TYPE_WPS_ER_AP) {
 280                         menu->addAction(tr("Learn Configuration"), this,
 281                                         SLOT(learn_ap_config()));
 282                 }
 283
 284                 menu->addAction(tr("Properties"), this, SLOT(properties()));
 285         } else {
 286                 ctx_item = NULL;
 287                 menu->addAction(QString(tr("Refresh")), this,
 288                                 SLOT(ctx_refresh()));
 289                 menu->addAction(tr("Start P2P discovery"), this,
 290                                 SLOT(ctx_p2p_start()));
 291                 menu->addAction(tr("Stop P2P discovery"), this,
 292                                 SLOT(ctx_p2p_stop()));
 293                 menu->addAction(tr("P2P listen only"), this,
 294                                 SLOT(ctx_p2p_listen()));
 295                 menu->addAction(tr("Start P2P group"), this,
 296                                 SLOT(ctx_p2p_start_group()));
 297                 if (hide_ap)
 298                         menu->addAction(tr("Show AP entries"), this,
 299                                         SLOT(ctx_show_ap()));
 300                 else
 301                         menu->addAction(tr("Hide AP entries"), this,
 302                                         SLOT(ctx_hide_ap()));
 303         }
 304
 305         menu->exec(peers->mapToGlobal(pos));
 306 }
 307
 308
 309 void Peers::enter_pin()
 310 {
 311         if (ctx_item == NULL)
 312                 return;
 313
 314         int peer_type = ctx_item->data(peer_role_type).toInt();
 315         QString uuid;
 316         QString addr;
 317         addr = ctx_item->data(peer_role_address).toString();
 318         if (peer_type == PEER_TYPE_WPS_ER_ENROLLEE)
 319                 uuid = ctx_item->data(peer_role_uuid).toString();
 320
 321         StringQuery input(tr("PIN:"));
 322         input.setWindowTitle(tr("PIN for ") + ctx_item->text());
 323         if (input.exec() != QDialog::Accepted)
 324                 return;
 325
 326         char cmd[100];
 327         char reply[100];
 328         size_t reply_len;
 329
 330         if (peer_type == PEER_TYPE_WPS_ER_ENROLLEE) {
 331                 snprintf(cmd, sizeof(cmd), "WPS_ER_PIN %s %s %s",
 332                          uuid.toAscii().constData(),
 333                          input.get_string().toAscii().constData(),
 334                          addr.toAscii().constData());
 335         } else {
 336                 snprintf(cmd, sizeof(cmd), "WPS_PIN %s %s",
 337                          addr.toAscii().constData(),
 338                          input.get_string().toAscii().constData());
 339         }
 340         reply_len = sizeof(reply) - 1;
 341         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
 342                 QMessageBox msg;
 343                 msg.setIcon(QMessageBox::Warning);
 344                 msg.setText(tr("Failed to set the WPS PIN."));
 345                 msg.exec();
 346         }
 347 }
 348
 349
 350 void Peers::ctx_refresh()
 351 {
 352         update_peers();
 353 }
 354
 355
 356 void Peers::ctx_p2p_start()
 357 {
 358         char reply[20];
 359         size_t reply_len;
 360         reply_len = sizeof(reply) - 1;
 361         if (wpagui->ctrlRequest("P2P_FIND", reply, &reply_len) < 0 ||
 362             memcmp(reply, "FAIL", 4) == 0) {
 363                 QMessageBox msg;
 364                 msg.setIcon(QMessageBox::Warning);
 365                 msg.setText("Failed to start P2P discovery.");
 366                 msg.exec();
 367         }
 368 }
 369
 370
 371 void Peers::ctx_p2p_stop()
 372 {
 373         char reply[20];
 374         size_t reply_len;
 375         reply_len = sizeof(reply) - 1;
 376         wpagui->ctrlRequest("P2P_STOP_FIND", reply, &reply_len);
 377 }
 378
 379
 380 void Peers::ctx_p2p_listen()
 381 {
 382         char reply[20];
 383         size_t reply_len;
 384         reply_len = sizeof(reply) - 1;
 385         if (wpagui->ctrlRequest("P2P_LISTEN 3600", reply, &reply_len) < 0 ||
 386             memcmp(reply, "FAIL", 4) == 0) {
 387                 QMessageBox msg;
 388                 msg.setIcon(QMessageBox::Warning);
 389                 msg.setText("Failed to start P2P listen.");
 390                 msg.exec();
 391         }
 392 }
 393
 394
 395 void Peers::ctx_p2p_start_group()
 396 {
 397         char reply[20];
 398         size_t reply_len;
 399         reply_len = sizeof(reply) - 1;
 400         if (wpagui->ctrlRequest("P2P_GROUP_ADD", reply, &reply_len) < 0 ||
 401             memcmp(reply, "FAIL", 4) == 0) {
 402                 QMessageBox msg;
 403                 msg.setIcon(QMessageBox::Warning);
 404                 msg.setText("Failed to start P2P group.");
 405                 msg.exec();
 406         }
 407 }
 408
 409
 410 void Peers::add_station(QString info)
 411 {
 412         QStringList lines = info.split(QRegExp("\\n"));
 413         QString name;
 414
 415         for (QStringList::Iterator it = lines.begin();
 416              it != lines.end(); it++) {
 417                 int pos = (*it).indexOf('=') + 1;
 418                 if (pos < 1)
 419                         continue;
 420
 421                 if ((*it).startsWith("wpsDeviceName="))
 422                         name = (*it).mid(pos);
 423                 else if ((*it).startsWith("p2p_device_name="))
 424                         name = (*it).mid(pos);
 425         }
 426
 427         if (name.isEmpty())
 428                 name = lines[0];
 429
 430         QStandardItem *item = new QStandardItem(*laptop_icon, name);
 431         if (item) {
 432                 /* Remove WPS enrollee entry if one is still pending */
 433                 if (model.rowCount() > 0) {
 434                         QModelIndexList lst = model.match(model.index(0, 0),
 435                                                           peer_role_address,
 436                                                           lines[0]);
 437                         for (int i = 0; i < lst.size(); i++) {
 438                                 QStandardItem *item;
 439                                 item = model.itemFromIndex(lst[i]);
 440                                 if (item == NULL)
 441                                         continue;
 442                                 int type = item->data(peer_role_type).toInt();
 443                                 if (type == PEER_TYPE_WPS_ENROLLEE) {
 444                                         model.removeRow(lst[i].row());
 445                                         break;
 446                                 }
 447                         }
 448                 }
 449
 450                 item->setData(lines[0], peer_role_address);
 451                 item->setData(PEER_TYPE_ASSOCIATED_STATION,
 452                               peer_role_type);
 453                 item->setData(info, peer_role_details);
 454                 item->setToolTip(ItemType(PEER_TYPE_ASSOCIATED_STATION));
 455                 model.appendRow(item);
 456         }
 457 }
 458
 459
 460 void Peers::add_stations()
 461 {
 462         char reply[2048];
 463         size_t reply_len;
 464         char cmd[30];
 465         int res;
 466
 467         reply_len = sizeof(reply) - 1;
 468         if (wpagui->ctrlRequest("STA-FIRST", reply, &reply_len) < 0)
 469                 return;
 470
 471         do {
 472                 reply[reply_len] = '\0';
 473                 QString info(reply);
 474                 char *txt = reply;
 475                 while (*txt != '\0' && *txt != '\n')
 476                         txt++;
 477                 *txt++ = '\0';
 478                 if (strncmp(reply, "FAIL", 4) == 0 ||
 479                     strncmp(reply, "UNKNOWN", 7) == 0)
 480                         break;
 481
 482                 add_station(info);
 483
 484                 reply_len = sizeof(reply) - 1;
 485                 snprintf(cmd, sizeof(cmd), "STA-NEXT %s", reply);
 486                 res = wpagui->ctrlRequest(cmd, reply, &reply_len);
 487         } while (res >= 0);
 488 }
 489
 490
 491 void Peers::add_single_station(const char *addr)
 492 {
 493         char reply[2048];
 494         size_t reply_len;
 495         char cmd[30];
 496
 497         reply_len = sizeof(reply) - 1;
 498         snprintf(cmd, sizeof(cmd), "STA %s", addr);
 499         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0)
 500                 return;
 501
 502         reply[reply_len] = '\0';
 503         QString info(reply);
 504         char *txt = reply;
 505         while (*txt != '\0' && *txt != '\n')
 506                 txt++;
 507         *txt++ = '\0';
 508         if (strncmp(reply, "FAIL", 4) == 0 ||
 509             strncmp(reply, "UNKNOWN", 7) == 0)
 510                 return;
 511
 512         add_station(info);
 513 }
 514
 515
 516 void Peers::add_p2p_group_client(QStandardItem * /*parent*/, QString params)
 517 {
 518         /*
 519          * dev=02:b5:64:63:30:63 iface=02:b5:64:63:30:63 dev_capab=0x0
 520          * dev_type=1-0050f204-1 dev_name='Wireless Client'
 521          * config_methods=0x8c
 522          */
 523
 524         QStringList items =
 525                 params.split(QRegExp(" (?=[^']*('[^']*'[^']*)*$)"));
 526         QString addr = "";
 527         QString name = "";
 528         int config_methods = 0;
 529         QString dev_type;
 530
 531         for (int i = 0; i < items.size(); i++) {
 532                 QString str = items.at(i);
 533                 int pos = str.indexOf('=') + 1;
 534                 if (str.startsWith("dev_name='"))
 535                         name = str.section('\'', 1, -2);
 536                 else if (str.startsWith("config_methods="))
 537                         config_methods =
 538                                 str.section('=', 1).toInt(0, 0);
 539                 else if (str.startsWith("dev="))
 540                         addr = str.mid(pos);
 541                 else if (str.startsWith("dev_type=") && dev_type.isEmpty())
 542                         dev_type = str.mid(pos);
 543         }
 544
 545         QStandardItem *item = find_addr(addr);
 546         if (item)
 547                 return;
 548
 549         item = new QStandardItem(*default_icon, name);
 550         if (item) {
 551                 /* TODO: indicate somehow the relationship to the group owner
 552                  * (parent) */
 553                 item->setData(addr, peer_role_address);
 554                 item->setData(config_methods, peer_role_config_methods);
 555                 item->setData(PEER_TYPE_P2P_CLIENT, peer_role_type);
 556                 if (!dev_type.isEmpty())
 557                         item->setData(dev_type, peer_role_pri_dev_type);
 558                 item->setData(items.join(QString("\n")), peer_role_details);
 559                 item->setToolTip(ItemType(PEER_TYPE_P2P_CLIENT));
 560                 model.appendRow(item);
 561         }
 562 }
 563
 564
 565 void Peers::remove_bss(int id)
 566 {
 567         if (model.rowCount() == 0)
 568                 return;
 569
 570         QModelIndexList lst = model.match(model.index(0, 0), peer_role_bss_id,
 571                                           id);
 572         if (lst.size() == 0)
 573                 return;
 574         model.removeRow(lst[0].row());
 575 }
 576
 577
 578 bool Peers::add_bss(const char *cmd)
 579 {
 580         char reply[2048];
 581         size_t reply_len;
 582
 583         if (hide_ap)
 584                 return false;
 585
 586         reply_len = sizeof(reply) - 1;
 587         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0)
 588                 return false;
 589         reply[reply_len] = '\0';
 590
 591         QString bss(reply);
 592         if (bss.isEmpty() || bss.startsWith("FAIL"))
 593                 return false;
 594
 595         QString ssid, bssid, flags, wps_name, pri_dev_type;
 596         int id = -1;
 597
 598         QStringList lines = bss.split(QRegExp("\\n"));
 599         for (QStringList::Iterator it = lines.begin();
 600              it != lines.end(); it++) {
 601                 int pos = (*it).indexOf('=') + 1;
 602                 if (pos < 1)
 603                         continue;
 604
 605                 if ((*it).startsWith("bssid="))
 606                         bssid = (*it).mid(pos);
 607                 else if ((*it).startsWith("id="))
 608                         id = (*it).mid(pos).toInt();
 609                 else if ((*it).startsWith("flags="))
 610                         flags = (*it).mid(pos);
 611                 else if ((*it).startsWith("ssid="))
 612                         ssid = (*it).mid(pos);
 613                 else if ((*it).startsWith("wps_device_name="))
 614                         wps_name = (*it).mid(pos);
 615                 else if ((*it).startsWith("wps_primary_device_type="))
 616                         pri_dev_type = (*it).mid(pos);
 617         }
 618
 619         QString name = wps_name;
 620         if (name.isEmpty())
 621                 name = ssid + "\n" + bssid;
 622
 623         QStandardItem *item = new QStandardItem(*ap_icon, name);
 624         if (item) {
 625                 item->setData(bssid, peer_role_address);
 626                 if (id >= 0)
 627                         item->setData(id, peer_role_bss_id);
 628                 int type;
 629                 if (flags.contains("[WPS"))
 630                         type = PEER_TYPE_AP_WPS;
 631                 else
 632                         type = PEER_TYPE_AP;
 633                 item->setData(type, peer_role_type);
 634
 635                 for (int i = 0; i < lines.size(); i++) {
 636                         if (lines[i].length() > 60) {
 637                                 lines[i].remove(60, lines[i].length());
 638                                 lines[i] += "..";
 639                         }
 640                 }
 641                 item->setToolTip(ItemType(type));
 642                 item->setData(lines.join("\n"), peer_role_details);
 643                 if (!pri_dev_type.isEmpty())
 644                         item->setData(pri_dev_type,
 645                                       peer_role_pri_dev_type);
 646                 if (!ssid.isEmpty())
 647                         item->setData(ssid, peer_role_ssid);
 648                 model.appendRow(item);
 649
 650                 lines = bss.split(QRegExp("\\n"));
 651                 for (QStringList::Iterator it = lines.begin();
 652                      it != lines.end(); it++) {
 653                         if ((*it).startsWith("p2p_group_client:"))
 654                                 add_p2p_group_client(item,
 655                                                      (*it).mid(18));
 656                 }
 657         }
 658
 659         return true;
 660 }
 661
 662
 663 void Peers::add_scan_results()
 664 {
 665         int index;
 666         char cmd[20];
 667
 668         index = 0;
 669         while (wpagui) {
 670                 snprintf(cmd, sizeof(cmd), "BSS %d", index++);
 671                 if (index > 1000)
 672                         break;
 673
 674                 if (!add_bss(cmd))
 675                         break;
 676         }
 677 }
 678
 679
 680 void Peers::add_persistent(int id, const char *ssid, const char *bssid)
 681 {
 682         char cmd[100];
 683         char reply[100];
 684         size_t reply_len;
 685         int mode;
 686
 687         snprintf(cmd, sizeof(cmd), "GET_NETWORK %d mode", id);
 688         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0)
 689                 return;
 690         reply[reply_len] = '\0';
 691         mode = atoi(reply);
 692
 693         QString name = ssid;
 694         name = '[' + name + ']';
 695
 696         QStandardItem *item = new QStandardItem(*group_icon, name);
 697         if (!item)
 698                 return;
 699
 700         int type;
 701         if (mode == 3)
 702                 type = PEER_TYPE_P2P_PERSISTENT_GROUP_GO;
 703         else
 704                 type = PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT;
 705         item->setData(type, peer_role_type);
 706         item->setToolTip(ItemType(type));
 707         item->setData(ssid, peer_role_ssid);
 708         if (bssid && strcmp(bssid, "any") == 0)
 709                 bssid = NULL;
 710         if (bssid)
 711                 item->setData(bssid, peer_role_address);
 712         item->setData(id, peer_role_network_id);
 713         item->setBackground(Qt::BDiagPattern);
 714
 715         model.appendRow(item);
 716 }
 717
 718
 719 void Peers::add_persistent_groups()
 720 {
 721         char buf[2048], *start, *end, *id, *ssid, *bssid, *flags;
 722         size_t len;
 723
 724         len = sizeof(buf) - 1;
 725         if (wpagui->ctrlRequest("LIST_NETWORKS", buf, &len) < 0)
 726                 return;
 727
 728         buf[len] = '\0';
 729         start = strchr(buf, '\n');
 730         if (start == NULL)
 731                 return;
 732         start++;
 733
 734         while (*start) {
 735                 bool last = false;
 736                 end = strchr(start, '\n');
 737                 if (end == NULL) {
 738                         last = true;
 739                         end = start;
 740                         while (end[0] && end[1])
 741                                 end++;
 742                 }
 743                 *end = '\0';
 744
 745                 id = start;
 746                 ssid = strchr(id, '\t');
 747                 if (ssid == NULL)
 748                         break;
 749                 *ssid++ = '\0';
 750                 bssid = strchr(ssid, '\t');
 751                 if (bssid == NULL)
 752                         break;
 753                 *bssid++ = '\0';
 754                 flags = strchr(bssid, '\t');
 755                 if (flags == NULL)
 756                         break;
 757                 *flags++ = '\0';
 758
 759                 if (strstr(flags, "[DISABLED][P2P-PERSISTENT]"))
 760                         add_persistent(atoi(id), ssid, bssid);
 761
 762                 if (last)
 763                         break;
 764                 start = end + 1;
 765         }
 766 }
 767
 768
 769 void Peers::update_peers()
 770 {
 771         model.clear();
 772         if (wpagui == NULL)
 773                 return;
 774
 775         char reply[20];
 776         size_t replylen = sizeof(reply) - 1;
 777         wpagui->ctrlRequest("WPS_ER_START", reply, &replylen);
 778
 779         add_stations();
 780         add_scan_results();
 781         add_persistent_groups();
 782 }
 783
 784
 785 QStandardItem * Peers::find_addr(QString addr)
 786 {
 787         if (model.rowCount() == 0)
 788                 return NULL;
 789
 790         QModelIndexList lst = model.match(model.index(0, 0), peer_role_address,
 791                                           addr);
 792         if (lst.size() == 0)
 793                 return NULL;
 794         return model.itemFromIndex(lst[0]);
 795 }
 796
 797
 798 QStandardItem * Peers::find_addr_type(QString addr, int type)
 799 {
 800         if (model.rowCount() == 0)
 801                 return NULL;
 802
 803         QModelIndexList lst = model.match(model.index(0, 0), peer_role_address,
 804                                           addr);
 805         for (int i = 0; i < lst.size(); i++) {
 806                 QStandardItem *item = model.itemFromIndex(lst[i]);
 807                 if (item->data(peer_role_type).toInt() == type)
 808                         return item;
 809         }
 810         return NULL;
 811 }
 812
 813
 814 QStandardItem * Peers::find_uuid(QString uuid)
 815 {
 816         if (model.rowCount() == 0)
 817                 return NULL;
 818
 819         QModelIndexList lst = model.match(model.index(0, 0), peer_role_uuid,
 820                                           uuid);
 821         if (lst.size() == 0)
 822                 return NULL;
 823         return model.itemFromIndex(lst[0]);
 824 }
 825
 826
 827 void Peers::event_notify(WpaMsg msg)
 828 {
 829         QString text = msg.getMsg();
 830
 831         if (text.startsWith(WPS_EVENT_PIN_NEEDED)) {
 832                 /*
 833                  * WPS-PIN-NEEDED 5a02a5fa-9199-5e7c-bc46-e183d3cb32f7
 834                  * 02:2a:c4:18:5b:f3
 835                  * [Wireless Client|Company|cmodel|123|12345|1-0050F204-1]
 836                  */
 837                 QStringList items = text.split(' ');
 838                 QString uuid = items[1];
 839                 QString addr = items[2];
 840                 QString name = "";
 841
 842                 QStandardItem *item = find_addr(addr);
 843                 if (item)
 844                         return;
 845
 846                 int pos = text.indexOf('[');
 847                 if (pos >= 0) {
 848                         int pos2 = text.lastIndexOf(']');
 849                         if (pos2 >= pos) {
 850                                 items = text.mid(pos + 1, pos2 - pos - 1).
 851                                         split('|');
 852                                 name = items[0];
 853                                 items.append(addr);
 854                         }
 855                 }
 856
 857                 item = new QStandardItem(*laptop_icon, name);
 858                 if (item) {
 859                         item->setData(addr, peer_role_address);
 860                         item->setData(PEER_TYPE_WPS_PIN_NEEDED,
 861                                       peer_role_type);
 862                         item->setToolTip(ItemType(PEER_TYPE_WPS_PIN_NEEDED));
 863                         item->setData(items.join("\n"), peer_role_details);
 864                         item->setData(items[5], peer_role_pri_dev_type);
 865                         model.appendRow(item);
 866                 }
 867                 return;
 868         }
 869
 870         if (text.startsWith(AP_STA_CONNECTED)) {
 871                 /* AP-STA-CONNECTED 02:2a:c4:18:5b:f3 */
 872                 QStringList items = text.split(' ');
 873                 QString addr = items[1];
 874                 QStandardItem *item = find_addr(addr);
 875                 if (item == NULL || item->data(peer_role_type).toInt() !=
 876                     PEER_TYPE_ASSOCIATED_STATION)
 877                         add_single_station(addr.toAscii().constData());
 878                 return;
 879         }
 880
 881         if (text.startsWith(AP_STA_DISCONNECTED)) {
 882                 /* AP-STA-DISCONNECTED 02:2a:c4:18:5b:f3 */
 883                 QStringList items = text.split(' ');
 884                 QString addr = items[1];
 885
 886                 if (model.rowCount() == 0)
 887                         return;
 888
 889                 QModelIndexList lst = model.match(model.index(0, 0),
 890                                                   peer_role_address, addr, -1);
 891                 for (int i = 0; i < lst.size(); i++) {
 892                         QStandardItem *item = model.itemFromIndex(lst[i]);
 893                         if (item && item->data(peer_role_type).toInt() ==
 894                             PEER_TYPE_ASSOCIATED_STATION) {
 895                                 model.removeRow(lst[i].row());
 896                                 break;
 897                         }
 898                 }
 899                 return;
 900         }
 901
 902         if (text.startsWith(P2P_EVENT_DEVICE_FOUND)) {
 903                 /*
 904                  * P2P-DEVICE-FOUND 02:b5:64:63:30:63
 905                  * p2p_dev_addr=02:b5:64:63:30:63 pri_dev_type=1-0050f204-1
 906                  * name='Wireless Client' config_methods=0x84 dev_capab=0x21
 907                  * group_capab=0x0
 908                  */
 909                 QStringList items =
 910                         text.split(QRegExp(" (?=[^']*('[^']*'[^']*)*$)"));
 911                 QString addr = items[1];
 912                 QString name = "";
 913                 QString pri_dev_type;
 914                 int config_methods = 0;
 915                 for (int i = 0; i < items.size(); i++) {
 916                         QString str = items.at(i);
 917                         if (str.startsWith("name='"))
 918                                 name = str.section('\'', 1, -2);
 919                         else if (str.startsWith("config_methods="))
 920                                 config_methods =
 921                                         str.section('=', 1).toInt(0, 0);
 922                         else if (str.startsWith("pri_dev_type="))
 923                                 pri_dev_type = str.section('=', 1);
 924                 }
 925
 926                 QStandardItem *item = find_addr(addr);
 927                 if (item) {
 928                         int type = item->data(peer_role_type).toInt();
 929                         if (type == PEER_TYPE_P2P)
 930                                 return;
 931                 }
 932
 933                 item = new QStandardItem(*default_icon, name);
 934                 if (item) {
 935                         item->setData(addr, peer_role_address);
 936                         item->setData(config_methods,
 937                                       peer_role_config_methods);
 938                         item->setData(PEER_TYPE_P2P, peer_role_type);
 939                         if (!pri_dev_type.isEmpty())
 940                                 item->setData(pri_dev_type,
 941                                               peer_role_pri_dev_type);
 942                         item->setData(items.join(QString("\n")),
 943                                       peer_role_details);
 944                         item->setToolTip(ItemType(PEER_TYPE_P2P));
 945                         model.appendRow(item);
 946                 }
 947
 948                 item = find_addr_type(addr,
 949                                       PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT);
 950                 if (item)
 951                         item->setBackground(Qt::NoBrush);
 952         }
 953
 954         if (text.startsWith(P2P_EVENT_GROUP_STARTED)) {
 955                 /* P2P-GROUP-STARTED wlan0-p2p-0 GO ssid="DIRECT-3F"
 956                  * passphrase="YOyTkxID" go_dev_addr=02:40:61:c2:f3:b7
 957                  * [PERSISTENT] */
 958                 QStringList items = text.split(' ');
 959                 if (items.size() < 4)
 960                         return;
 961
 962                 int pos = text.indexOf(" ssid=\"");
 963                 if (pos < 0)
 964                         return;
 965                 QString ssid = text.mid(pos + 7);
 966                 pos = ssid.indexOf(" passphrase=\"");
 967                 if (pos < 0)
 968                         pos = ssid.indexOf(" psk=");
 969                 if (pos >= 0)
 970                         ssid.truncate(pos);
 971                 pos = ssid.lastIndexOf('"');
 972                 if (pos >= 0)
 973                         ssid.truncate(pos);
 974
 975                 QStandardItem *item = new QStandardItem(*group_icon, ssid);
 976                 if (item) {
 977                         item->setData(PEER_TYPE_P2P_GROUP, peer_role_type);
 978                         item->setData(items[1], peer_role_ifname);
 979                         QString details;
 980                         if (items[2] == "GO") {
 981                                 details = tr("P2P GO for interface ") +
 982                                         items[1];
 983                         } else {
 984                                 details = tr("P2P client for interface ") +
 985                                         items[1];
 986                         }
 987                         if (text.contains(" [PERSISTENT]"))
 988                                 details += "\nPersistent group";
 989                         item->setData(details, peer_role_details);
 990                         item->setToolTip(ItemType(PEER_TYPE_P2P_GROUP));
 991                         model.appendRow(item);
 992                 }
 993         }
 994
 995         if (text.startsWith(P2P_EVENT_GROUP_REMOVED)) {
 996                 /* P2P-GROUP-REMOVED wlan0-p2p-0 GO */
 997                 QStringList items = text.split(' ');
 998                 if (items.size() < 2)
 999                         return;
1000
1001                 if (model.rowCount() == 0)
1002                         return;
1003
1004                 QModelIndexList lst = model.match(model.index(0, 0),
1005                                                   peer_role_ifname, items[1]);
1006                 for (int i = 0; i < lst.size(); i++)
1007                         model.removeRow(lst[i].row());
1008                 return;
1009         }
1010
1011         if (text.startsWith(P2P_EVENT_PROV_DISC_SHOW_PIN)) {
1012                 /* P2P-PROV-DISC-SHOW-PIN 02:40:61:c2:f3:b7 12345670 */
1013                 QStringList items = text.split(' ');
1014                 if (items.size() < 3)
1015                         return;
1016                 QString addr = items[1];
1017                 QString pin = items[2];
1018
1019                 QStandardItem *item = find_addr_type(addr, PEER_TYPE_P2P);
1020                 if (item == NULL)
1021                         return;
1022                 item->setData(SEL_METHOD_PIN_LOCAL_DISPLAY,
1023                               peer_role_selected_method);
1024                 item->setData(pin, peer_role_selected_pin);
1025                 QVariant var = item->data(peer_role_requested_method);
1026                 if (var.isValid() &&
1027                     var.toInt() == SEL_METHOD_PIN_LOCAL_DISPLAY) {
1028                         ctx_item = item;
1029                         ctx_p2p_display_pin_pd();
1030                 }
1031                 return;
1032         }
1033
1034         if (text.startsWith(P2P_EVENT_PROV_DISC_ENTER_PIN)) {
1035                 /* P2P-PROV-DISC-ENTER-PIN 02:40:61:c2:f3:b7 */
1036                 QStringList items = text.split(' ');
1037                 if (items.size() < 2)
1038                         return;
1039                 QString addr = items[1];
1040
1041                 QStandardItem *item = find_addr_type(addr, PEER_TYPE_P2P);
1042                 if (item == NULL)
1043                         return;
1044                 item->setData(SEL_METHOD_PIN_PEER_DISPLAY,
1045                               peer_role_selected_method);
1046                 QVariant var = item->data(peer_role_requested_method);
1047                 if (var.isValid() &&
1048                     var.toInt() == SEL_METHOD_PIN_PEER_DISPLAY) {
1049                         ctx_item = item;
1050                         ctx_p2p_connect();
1051                 }
1052                 return;
1053         }
1054
1055         if (text.startsWith(P2P_EVENT_INVITATION_RECEIVED)) {
1056                 /* P2P-INVITATION-RECEIVED sa=02:f0:bc:44:87:62 persistent=4 */
1057                 QStringList items = text.split(' ');
1058                 if (items.size() < 3)
1059                         return;
1060                 if (!items[1].startsWith("sa=") ||
1061                     !items[2].startsWith("persistent="))
1062                         return;
1063                 QString addr = items[1].mid(3);
1064                 int id = items[2].mid(11).toInt();
1065
1066                 char cmd[100];
1067                 char reply[100];
1068                 size_t reply_len;
1069
1070                 snprintf(cmd, sizeof(cmd), "GET_NETWORK %d ssid", id);
1071                 reply_len = sizeof(reply) - 1;
1072                 if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0)
1073                         return;
1074                 reply[reply_len] = '\0';
1075                 QString name;
1076                 char *pos = strrchr(reply, '"');
1077                 if (pos && reply[0] == '"') {
1078                         *pos = '\0';
1079                         name = reply + 1;
1080                 } else
1081                         name = reply;
1082
1083                 QStandardItem *item;
1084                 item = find_addr_type(addr, PEER_TYPE_P2P_INVITATION);
1085                 if (item)
1086                         model.removeRow(item->row());
1087
1088                 item = new QStandardItem(*invitation_icon, name);
1089                 if (!item)
1090                         return;
1091                 item->setData(PEER_TYPE_P2P_INVITATION, peer_role_type);
1092                 item->setToolTip(ItemType(PEER_TYPE_P2P_INVITATION));
1093                 item->setData(addr, peer_role_address);
1094                 item->setData(id, peer_role_network_id);
1095
1096                 model.appendRow(item);
1097
1098                 enable_persistent(id);
1099
1100                 return;
1101         }
1102
1103         if (text.startsWith(P2P_EVENT_INVITATION_RESULT)) {
1104                 /* P2P-INVITATION-RESULT status=1 */
1105                 /* TODO */
1106                 return;
1107         }
1108
1109         if (text.startsWith(WPS_EVENT_ER_AP_ADD)) {
1110                 /*
1111                  * WPS-ER-AP-ADD 87654321-9abc-def0-1234-56789abc0002
1112                  * 02:11:22:33:44:55 pri_dev_type=6-0050F204-1 wps_state=1
1113                  * |Very friendly name|Company|Long description of the model|
1114                  * WAP|http://w1.fi/|http://w1.fi/hostapd/
1115                  */
1116                 QStringList items = text.split(' ');
1117                 if (items.size() < 5)
1118                         return;
1119                 QString uuid = items[1];
1120                 QString addr = items[2];
1121                 QString pri_dev_type = items[3].mid(13);
1122                 int wps_state = items[4].mid(10).toInt();
1123
1124                 int pos = text.indexOf('|');
1125                 if (pos < 0)
1126                         return;
1127                 items = text.mid(pos + 1).split('|');
1128                 if (items.size() < 1)
1129                         return;
1130
1131                 QStandardItem *item = find_uuid(uuid);
1132                 if (item)
1133                         return;
1134
1135                 item = new QStandardItem(*ap_icon, items[0]);
1136                 if (item) {
1137                         item->setData(uuid, peer_role_uuid);
1138                         item->setData(addr, peer_role_address);
1139                         int type = wps_state == 2 ? PEER_TYPE_WPS_ER_AP:
1140                                 PEER_TYPE_WPS_ER_AP_UNCONFIGURED;
1141                         item->setData(type, peer_role_type);
1142                         item->setToolTip(ItemType(type));
1143                         item->setData(pri_dev_type, peer_role_pri_dev_type);
1144                         item->setData(items.join(QString("\n")),
1145                                       peer_role_details);
1146                         model.appendRow(item);
1147                 }
1148
1149                 return;
1150         }
1151
1152         if (text.startsWith(WPS_EVENT_ER_AP_REMOVE)) {
1153                 /* WPS-ER-AP-REMOVE 87654321-9abc-def0-1234-56789abc0002 */
1154                 QStringList items = text.split(' ');
1155                 if (items.size() < 2)
1156                         return;
1157                 if (model.rowCount() == 0)
1158                         return;
1159
1160                 QModelIndexList lst = model.match(model.index(0, 0),
1161                                                   peer_role_uuid, items[1]);
1162                 for (int i = 0; i < lst.size(); i++) {
1163                         QStandardItem *item = model.itemFromIndex(lst[i]);
1164                         if (item &&
1165                             (item->data(peer_role_type).toInt() ==
1166                              PEER_TYPE_WPS_ER_AP ||
1167                              item->data(peer_role_type).toInt() ==
1168                              PEER_TYPE_WPS_ER_AP_UNCONFIGURED))
1169                                 model.removeRow(lst[i].row());
1170                 }
1171                 return;
1172         }
1173
1174         if (text.startsWith(WPS_EVENT_ER_ENROLLEE_ADD)) {
1175                 /*
1176                  * WPS-ER-ENROLLEE-ADD 2b7093f1-d6fb-5108-adbb-bea66bb87333
1177                  * 02:66:a0:ee:17:27 M1=1 config_methods=0x14d dev_passwd_id=0
1178                  * pri_dev_type=1-0050F204-1
1179                  * |Wireless Client|Company|cmodel|123|12345|
1180                  */
1181                 QStringList items = text.split(' ');
1182                 if (items.size() < 3)
1183                         return;
1184                 QString uuid = items[1];
1185                 QString addr = items[2];
1186                 QString pri_dev_type = items[6].mid(13);
1187                 int config_methods = -1;
1188                 int dev_passwd_id = -1;
1189
1190                 for (int i = 3; i < items.size(); i++) {
1191                         int pos = items[i].indexOf('=') + 1;
1192                         if (pos < 1)
1193                                 continue;
1194                         QString val = items[i].mid(pos);
1195                         if (items[i].startsWith("config_methods=")) {
1196                                 config_methods = val.toInt(0, 0);
1197                         } else if (items[i].startsWith("dev_passwd_id=")) {
1198                                 dev_passwd_id = val.toInt();
1199                         }
1200                 }
1201
1202                 int pos = text.indexOf('|');
1203                 if (pos < 0)
1204                         return;
1205                 items = text.mid(pos + 1).split('|');
1206                 if (items.size() < 1)
1207                         return;
1208                 QString name = items[0];
1209                 if (name.length() == 0)
1210                         name = addr;
1211
1212                 remove_enrollee_uuid(uuid);
1213
1214                 QStandardItem *item;
1215                 item = new QStandardItem(*laptop_icon, name);
1216                 if (item) {
1217                         item->setData(uuid, peer_role_uuid);
1218                         item->setData(addr, peer_role_address);
1219                         item->setData(PEER_TYPE_WPS_ER_ENROLLEE,
1220                                       peer_role_type);
1221                         item->setToolTip(ItemType(PEER_TYPE_WPS_ER_ENROLLEE));
1222                         item->setData(items.join(QString("\n")),
1223                                       peer_role_details);
1224                         item->setData(pri_dev_type, peer_role_pri_dev_type);
1225                         if (config_methods >= 0)
1226                                 item->setData(config_methods,
1227                                               peer_role_config_methods);
1228                         if (dev_passwd_id >= 0)
1229                                 item->setData(dev_passwd_id,
1230                                               peer_role_dev_passwd_id);
1231                         model.appendRow(item);
1232                 }
1233
1234                 return;
1235         }
1236
1237         if (text.startsWith(WPS_EVENT_ER_ENROLLEE_REMOVE)) {
1238                 /*
1239                  * WPS-ER-ENROLLEE-REMOVE 2b7093f1-d6fb-5108-adbb-bea66bb87333
1240                  * 02:66:a0:ee:17:27
1241                  */
1242                 QStringList items = text.split(' ');
1243                 if (items.size() < 2)
1244                         return;
1245                 remove_enrollee_uuid(items[1]);
1246                 return;
1247         }
1248
1249         if (text.startsWith(WPS_EVENT_ENROLLEE_SEEN)) {
1250                 /* TODO: need to time out this somehow or remove on successful
1251                  * WPS run, etc. */
1252                 /*
1253                  * WPS-ENROLLEE-SEEN 02:00:00:00:01:00
1254                  * 572cf82f-c957-5653-9b16-b5cfb298abf1 1-0050F204-1 0x80 4 1
1255                  * [Wireless Client]
1256                  * (MAC addr, UUID-E, pri dev type, config methods,
1257                  * dev passwd id, request type, [dev name])
1258                  */
1259                 QStringList items = text.split(' ');
1260                 if (items.size() < 7)
1261                         return;
1262                 QString addr = items[1];
1263                 QString uuid = items[2];
1264                 QString pri_dev_type = items[3];
1265                 int config_methods = items[4].toInt(0, 0);
1266                 int dev_passwd_id = items[5].toInt();
1267                 QString name;
1268
1269                 QStandardItem *item = find_addr(addr);
1270                 if (item) {
1271                         int type = item->data(peer_role_type).toInt();
1272                         if (type == PEER_TYPE_ASSOCIATED_STATION)
1273                                 return; /* already associated */
1274                 }
1275
1276                 int pos = text.indexOf('[');
1277                 if (pos >= 0) {
1278                         int pos2 = text.lastIndexOf(']');
1279                         if (pos2 >= pos) {
1280                                 QStringList items2 =
1281                                         text.mid(pos + 1, pos2 - pos - 1).
1282                                         split('|');
1283                                 name = items2[0];
1284                         }
1285                 }
1286                 if (name.isEmpty())
1287                         name = addr;
1288
1289                 item = find_uuid(uuid);
1290                 if (item) {
1291                         QVariant var = item->data(peer_role_config_methods);
1292                         QVariant var2 = item->data(peer_role_dev_passwd_id);
1293                         if ((var.isValid() && config_methods != var.toInt()) ||
1294                             (var2.isValid() && dev_passwd_id != var2.toInt()))
1295                                 remove_enrollee_uuid(uuid);
1296                         else
1297                                 return;
1298                 }
1299
1300                 item = new QStandardItem(*laptop_icon, name);
1301                 if (item) {
1302                         item->setData(uuid, peer_role_uuid);
1303                         item->setData(addr, peer_role_address);
1304                         item->setData(PEER_TYPE_WPS_ENROLLEE,
1305                                       peer_role_type);
1306                         item->setToolTip(ItemType(PEER_TYPE_WPS_ENROLLEE));
1307                         item->setData(items.join(QString("\n")),
1308                                       peer_role_details);
1309                         item->setData(pri_dev_type, peer_role_pri_dev_type);
1310                         item->setData(config_methods,
1311                                       peer_role_config_methods);
1312                         item->setData(dev_passwd_id, peer_role_dev_passwd_id);
1313                         model.appendRow(item);
1314                 }
1315
1316                 return;
1317         }
1318
1319         if (text.startsWith(WPA_EVENT_BSS_ADDED)) {
1320                 /* CTRL-EVENT-BSS-ADDED 34 00:11:22:33:44:55 */
1321                 QStringList items = text.split(' ');
1322                 if (items.size() < 2)
1323                         return;
1324                 char cmd[20];
1325                 snprintf(cmd, sizeof(cmd), "BSS ID-%d", items[1].toInt());
1326                 add_bss(cmd);
1327                 return;
1328         }
1329
1330         if (text.startsWith(WPA_EVENT_BSS_REMOVED)) {
1331                 /* CTRL-EVENT-BSS-REMOVED 34 00:11:22:33:44:55 */
1332                 QStringList items = text.split(' ');
1333                 if (items.size() < 2)
1334                         return;
1335                 remove_bss(items[1].toInt());
1336                 return;
1337         }
1338 }
1339
1340
1341 void Peers::ctx_p2p_connect()
1342 {
1343         if (ctx_item == NULL)
1344                 return;
1345         QString addr = ctx_item->data(peer_role_address).toString();
1346         QString arg;
1347         int config_methods =
1348                 ctx_item->data(peer_role_config_methods).toInt();
1349         enum selected_method method = SEL_METHOD_NONE;
1350         QVariant var = ctx_item->data(peer_role_selected_method);
1351         if (var.isValid())
1352                 method = (enum selected_method) var.toInt();
1353         if (method == SEL_METHOD_PIN_LOCAL_DISPLAY) {
1354                 arg = ctx_item->data(peer_role_selected_pin).toString();
1355                 char cmd[100];
1356                 char reply[100];
1357                 size_t reply_len;
1358                 snprintf(cmd, sizeof(cmd), "P2P_CONNECT %s %s display",
1359                          addr.toAscii().constData(),
1360                          arg.toAscii().constData());
1361                 reply_len = sizeof(reply) - 1;
1362                 if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1363                         QMessageBox msg;
1364                         msg.setIcon(QMessageBox::Warning);
1365                         msg.setText("Failed to initiate P2P connect.");
1366                         msg.exec();
1367                         return;
1368                 }
1369                 QMessageBox::information(this,
1370                                          tr("PIN for ") + ctx_item->text(),
1371                                          tr("Enter the following PIN on the\n"
1372                                             "peer device: ") + arg);
1373         } else if (method == SEL_METHOD_PIN_PEER_DISPLAY) {
1374                 StringQuery input(tr("PIN from peer display:"));
1375                 input.setWindowTitle(tr("PIN for ") + ctx_item->text());
1376                 if (input.exec() != QDialog::Accepted)
1377                         return;
1378                 arg = input.get_string();
1379         } else if (config_methods == 0x0080 /* PBC */) {
1380                 arg = "pbc";
1381         } else {
1382                 StringQuery input(tr("PIN:"));
1383                 input.setWindowTitle(tr("PIN for ") + ctx_item->text());
1384                 if (input.exec() != QDialog::Accepted)
1385                         return;
1386                 arg = input.get_string();
1387         }
1388
1389         char cmd[100];
1390         char reply[100];
1391         size_t reply_len;
1392         snprintf(cmd, sizeof(cmd), "P2P_CONNECT %s %s",
1393                  addr.toAscii().constData(),
1394                  arg.toAscii().constData());
1395         reply_len = sizeof(reply) - 1;
1396         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1397                 QMessageBox msg;
1398                 msg.setIcon(QMessageBox::Warning);
1399                 msg.setText("Failed to initiate P2P connect.");
1400                 msg.exec();
1401         }
1402 }
1403
1404
1405 void Peers::ctx_p2p_req_pin()
1406 {
1407         if (ctx_item == NULL)
1408                 return;
1409         QString addr = ctx_item->data(peer_role_address).toString();
1410         ctx_item->setData(SEL_METHOD_PIN_PEER_DISPLAY,
1411                           peer_role_requested_method);
1412
1413         char cmd[100];
1414         char reply[100];
1415         size_t reply_len;
1416         snprintf(cmd, sizeof(cmd), "P2P_PROV_DISC %s display",
1417                  addr.toAscii().constData());
1418         reply_len = sizeof(reply) - 1;
1419         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1420                 QMessageBox msg;
1421                 msg.setIcon(QMessageBox::Warning);
1422                 msg.setText(tr("Failed to request PIN from peer."));
1423                 msg.exec();
1424         }
1425 }
1426
1427
1428 void Peers::ctx_p2p_show_pin()
1429 {
1430         if (ctx_item == NULL)
1431                 return;
1432         QString addr = ctx_item->data(peer_role_address).toString();
1433         ctx_item->setData(SEL_METHOD_PIN_LOCAL_DISPLAY,
1434                           peer_role_requested_method);
1435
1436         char cmd[100];
1437         char reply[100];
1438         size_t reply_len;
1439         snprintf(cmd, sizeof(cmd), "P2P_PROV_DISC %s keypad",
1440                  addr.toAscii().constData());
1441         reply_len = sizeof(reply) - 1;
1442         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1443                 QMessageBox msg;
1444                 msg.setIcon(QMessageBox::Warning);
1445                 msg.setText(tr("Failed to request peer to enter PIN."));
1446                 msg.exec();
1447         }
1448 }
1449
1450
1451 void Peers::ctx_p2p_display_pin()
1452 {
1453         if (ctx_item == NULL)
1454                 return;
1455         QString addr = ctx_item->data(peer_role_address).toString();
1456
1457         char cmd[100];
1458         char reply[100];
1459         size_t reply_len;
1460         snprintf(cmd, sizeof(cmd), "P2P_CONNECT %s pin",
1461                  addr.toAscii().constData());
1462         reply_len = sizeof(reply) - 1;
1463         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1464                 QMessageBox msg;
1465                 msg.setIcon(QMessageBox::Warning);
1466                 msg.setText("Failed to initiate P2P connect.");
1467                 msg.exec();
1468                 return;
1469         }
1470         reply[reply_len] = '\0';
1471         QMessageBox::information(this,
1472                                  tr("PIN for ") + ctx_item->text(),
1473                                  tr("Enter the following PIN on the\n"
1474                                     "peer device: ") + reply);
1475 }
1476
1477
1478 void Peers::ctx_p2p_display_pin_pd()
1479 {
1480         if (ctx_item == NULL)
1481                 return;
1482         QString addr = ctx_item->data(peer_role_address).toString();
1483         QString arg = ctx_item->data(peer_role_selected_pin).toString();
1484
1485         char cmd[100];
1486         char reply[100];
1487         size_t reply_len;
1488         snprintf(cmd, sizeof(cmd), "P2P_CONNECT %s %s display",
1489                  addr.toAscii().constData(),
1490                  arg.toAscii().constData());
1491         reply_len = sizeof(reply) - 1;
1492         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1493                 QMessageBox msg;
1494                 msg.setIcon(QMessageBox::Warning);
1495                 msg.setText("Failed to initiate P2P connect.");
1496                 msg.exec();
1497                 return;
1498         }
1499         reply[reply_len] = '\0';
1500         QMessageBox::information(this,
1501                                  tr("PIN for ") + ctx_item->text(),
1502                                  tr("Enter the following PIN on the\n"
1503                                     "peer device: ") + arg);
1504 }
1505
1506
1507 void Peers::ctx_p2p_enter_pin()
1508 {
1509         if (ctx_item == NULL)
1510                 return;
1511         QString addr = ctx_item->data(peer_role_address).toString();
1512         QString arg;
1513
1514         StringQuery input(tr("PIN from peer:"));
1515         input.setWindowTitle(tr("PIN for ") + ctx_item->text());
1516         if (input.exec() != QDialog::Accepted)
1517                 return;
1518         arg = input.get_string();
1519
1520         char cmd[100];
1521         char reply[100];
1522         size_t reply_len;
1523         snprintf(cmd, sizeof(cmd), "P2P_CONNECT %s %s keypad",
1524                  addr.toAscii().constData(),
1525                  arg.toAscii().constData());
1526         reply_len = sizeof(reply) - 1;
1527         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1528                 QMessageBox msg;
1529                 msg.setIcon(QMessageBox::Warning);
1530                 msg.setText("Failed to initiate P2P connect.");
1531                 msg.exec();
1532         }
1533 }
1534
1535
1536 void Peers::ctx_p2p_remove_group()
1537 {
1538         if (ctx_item == NULL)
1539                 return;
1540         char cmd[100];
1541         char reply[100];
1542         size_t reply_len;
1543         snprintf(cmd, sizeof(cmd), "P2P_GROUP_REMOVE %s",
1544                  ctx_item->data(peer_role_ifname).toString().toAscii().
1545                  constData());
1546         reply_len = sizeof(reply) - 1;
1547         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1548                 QMessageBox msg;
1549                 msg.setIcon(QMessageBox::Warning);
1550                 msg.setText("Failed to remove P2P Group.");
1551                 msg.exec();
1552         }
1553 }
1554
1555
1556 void Peers::closeEvent(QCloseEvent *)
1557 {
1558         if (wpagui) {
1559                 char reply[20];
1560                 size_t replylen = sizeof(reply) - 1;
1561                 wpagui->ctrlRequest("WPS_ER_STOP", reply, &replylen);
1562         }
1563 }
1564
1565
1566 void Peers::done(int r)
1567 {
1568         QDialog::done(r);
1569         close();
1570 }
1571
1572
1573 void Peers::remove_enrollee_uuid(QString uuid)
1574 {
1575         if (model.rowCount() == 0)
1576                 return;
1577
1578         QModelIndexList lst = model.match(model.index(0, 0),
1579                                           peer_role_uuid, uuid);
1580         for (int i = 0; i < lst.size(); i++) {
1581                 QStandardItem *item = model.itemFromIndex(lst[i]);
1582                 if (item == NULL)
1583                         continue;
1584                 int type = item->data(peer_role_type).toInt();
1585                 if (type == PEER_TYPE_WPS_ER_ENROLLEE ||
1586                     type == PEER_TYPE_WPS_ENROLLEE)
1587                         model.removeRow(lst[i].row());
1588         }
1589 }
1590
1591
1592 void Peers::properties()
1593 {
1594         if (ctx_item == NULL)
1595                 return;
1596
1597         QMessageBox msg(this);
1598         msg.setStandardButtons(QMessageBox::Ok);
1599         msg.setDefaultButton(QMessageBox::Ok);
1600         msg.setEscapeButton(QMessageBox::Ok);
1601         msg.setWindowTitle(tr("Peer Properties"));
1602
1603         int type = ctx_item->data(peer_role_type).toInt();
1604         QString title = Peers::ItemType(type);
1605
1606         msg.setText(title + QString("\n") + tr("Name: ") + ctx_item->text());
1607
1608         QVariant var;
1609         QString info;
1610
1611         var = ctx_item->data(peer_role_address);
1612         if (var.isValid())
1613                 info += tr("Address: ") + var.toString() + QString("\n");
1614
1615         var = ctx_item->data(peer_role_uuid);
1616         if (var.isValid())
1617                 info += tr("UUID: ") + var.toString() + QString("\n");
1618
1619         var = ctx_item->data(peer_role_pri_dev_type);
1620         if (var.isValid())
1621                 info += tr("Primary Device Type: ") + var.toString() +
1622                         QString("\n");
1623
1624         var = ctx_item->data(peer_role_ssid);
1625         if (var.isValid())
1626                 info += tr("SSID: ") + var.toString() + QString("\n");
1627
1628         var = ctx_item->data(peer_role_config_methods);
1629         if (var.isValid()) {
1630                 int methods = var.toInt();
1631                 info += tr("Configuration Methods: ");
1632                 if (methods & 0x0001)
1633                         info += tr("[USBA]");
1634                 if (methods & 0x0002)
1635                         info += tr("[Ethernet]");
1636                 if (methods & 0x0004)
1637                         info += tr("[Label]");
1638                 if (methods & 0x0008)
1639                         info += tr("[Display]");
1640                 if (methods & 0x0010)
1641                         info += tr("[Ext. NFC Token]");
1642                 if (methods & 0x0020)
1643                         info += tr("[Int. NFC Token]");
1644                 if (methods & 0x0040)
1645                         info += tr("[NFC Interface]");
1646                 if (methods & 0x0080)
1647                         info += tr("[Push Button]");
1648                 if (methods & 0x0100)
1649                         info += tr("[Keypad]");
1650                 info += "\n";
1651         }
1652
1653         var = ctx_item->data(peer_role_selected_method);
1654         if (var.isValid()) {
1655                 enum selected_method method =
1656                         (enum selected_method) var.toInt();
1657                 switch (method) {
1658                 case SEL_METHOD_NONE:
1659                         break;
1660                 case SEL_METHOD_PIN_PEER_DISPLAY:
1661                         info += tr("Selected Method: PIN on peer display\n");
1662                         break;
1663                 case SEL_METHOD_PIN_LOCAL_DISPLAY:
1664                         info += tr("Selected Method: PIN on local display\n");
1665                         break;
1666                 }
1667         }
1668
1669         var = ctx_item->data(peer_role_selected_pin);
1670         if (var.isValid()) {
1671                 info += tr("PIN to enter on peer: ") + var.toString() + "\n";
1672         }
1673
1674         var = ctx_item->data(peer_role_dev_passwd_id);
1675         if (var.isValid()) {
1676                 info += tr("Device Password ID: ") + var.toString();
1677                 switch (var.toInt()) {
1678                 case 0:
1679                         info += tr(" (Default PIN)");
1680                         break;
1681                 case 1:
1682                         info += tr(" (User-specified PIN)");
1683                         break;
1684                 case 2:
1685                         info += tr(" (Machine-specified PIN)");
1686                         break;
1687                 case 3:
1688                         info += tr(" (Rekey)");
1689                         break;
1690                 case 4:
1691                         info += tr(" (Push Button)");
1692                         break;
1693                 case 5:
1694                         info += tr(" (Registrar-specified)");
1695                         break;
1696                 }
1697                 info += "\n";
1698         }
1699
1700         msg.setInformativeText(info);
1701
1702         var = ctx_item->data(peer_role_details);
1703         if (var.isValid())
1704                 msg.setDetailedText(var.toString());
1705
1706         msg.exec();
1707 }
1708
1709
1710 void Peers::connect_pbc()
1711 {
1712         if (ctx_item == NULL)
1713                 return;
1714
1715         char cmd[100];
1716         char reply[100];
1717         size_t reply_len;
1718
1719         int peer_type = ctx_item->data(peer_role_type).toInt();
1720         if (peer_type == PEER_TYPE_WPS_ER_ENROLLEE) {
1721                 snprintf(cmd, sizeof(cmd), "WPS_ER_PBC %s",
1722                          ctx_item->data(peer_role_uuid).toString().toAscii().
1723                          constData());
1724         } else if (peer_type == PEER_TYPE_P2P ||
1725                    peer_type == PEER_TYPE_P2P_CLIENT) {
1726                 snprintf(cmd, sizeof(cmd), "P2P_CONNECT %s pbc",
1727                          ctx_item->data(peer_role_address).toString().
1728                          toAscii().constData());
1729         } else {
1730                 snprintf(cmd, sizeof(cmd), "WPS_PBC");
1731         }
1732         reply_len = sizeof(reply) - 1;
1733         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1734                 QMessageBox msg;
1735                 msg.setIcon(QMessageBox::Warning);
1736                 msg.setText(tr("Failed to start WPS PBC."));
1737                 msg.exec();
1738         }
1739 }
1740
1741
1742 void Peers::learn_ap_config()
1743 {
1744         if (ctx_item == NULL)
1745                 return;
1746
1747         QString uuid = ctx_item->data(peer_role_uuid).toString();
1748
1749         StringQuery input(tr("AP PIN:"));
1750         input.setWindowTitle(tr("AP PIN for ") + ctx_item->text());
1751         if (input.exec() != QDialog::Accepted)
1752                 return;
1753
1754         char cmd[100];
1755         char reply[100];
1756         size_t reply_len;
1757
1758         snprintf(cmd, sizeof(cmd), "WPS_ER_LEARN %s %s",
1759                  uuid.toAscii().constData(),
1760                  input.get_string().toAscii().constData());
1761         reply_len = sizeof(reply) - 1;
1762         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) {
1763                 QMessageBox msg;
1764                 msg.setIcon(QMessageBox::Warning);
1765                 msg.setText(tr("Failed to start learning AP configuration."));
1766                 msg.exec();
1767         }
1768 }
1769
1770
1771 void Peers::ctx_hide_ap()
1772 {
1773         hide_ap = true;
1774
1775         if (model.rowCount() == 0)
1776                 return;
1777
1778         do {
1779                 QModelIndexList lst;
1780                 lst = model.match(model.index(0, 0),
1781                                   peer_role_type, PEER_TYPE_AP);
1782                 if (lst.size() == 0) {
1783                         lst = model.match(model.index(0, 0),
1784                                           peer_role_type, PEER_TYPE_AP_WPS);
1785                         if (lst.size() == 0)
1786                                 break;
1787                 }
1788
1789                 model.removeRow(lst[0].row());
1790         } while (1);
1791 }
1792
1793
1794 void Peers::ctx_show_ap()
1795 {
1796         hide_ap = false;
1797         add_scan_results();
1798 }
1799
1800
1801 void Peers::ctx_p2p_show_passphrase()
1802 {
1803         char reply[64];
1804         size_t reply_len;
1805
1806         reply_len = sizeof(reply) - 1;
1807         if (wpagui->ctrlRequest("P2P_GET_PASSPHRASE", reply, &reply_len) < 0 ||
1808             memcmp(reply, "FAIL", 4) == 0) {
1809                 QMessageBox msg;
1810                 msg.setIcon(QMessageBox::Warning);
1811                 msg.setText("Failed to get P2P group passphrase.");
1812                 msg.exec();
1813         } else {
1814                 reply[reply_len] = '\0';
1815                 QMessageBox::information(this, tr("Passphrase"),
1816                                          tr("P2P group passphrase:\n") +
1817                                          reply);
1818         }
1819 }
1820
1821
1822 void Peers::ctx_p2p_start_persistent()
1823 {
1824         if (ctx_item == NULL)
1825                 return;
1826
1827         char cmd[100];
1828         char reply[100];
1829         size_t reply_len;
1830
1831         snprintf(cmd, sizeof(cmd), "P2P_GROUP_ADD persistent=%d",
1832                  ctx_item->data(peer_role_network_id).toInt());
1833         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0 ||
1834             memcmp(reply, "FAIL", 4) == 0) {
1835                 QMessageBox msg;
1836                 msg.setIcon(QMessageBox::Warning);
1837                 msg.setText(tr("Failed to start persistent P2P Group."));
1838                 msg.exec();
1839         } else if (ctx_item->data(peer_role_type).toInt() ==
1840                    PEER_TYPE_P2P_INVITATION)
1841                 model.removeRow(ctx_item->row());
1842 }
1843
1844
1845 void Peers::ctx_p2p_invite()
1846 {
1847         if (ctx_item == NULL)
1848                 return;
1849
1850         char cmd[100];
1851         char reply[100];
1852         size_t reply_len;
1853
1854         snprintf(cmd, sizeof(cmd), "P2P_INVITE persistent=%d",
1855                  ctx_item->data(peer_role_network_id).toInt());
1856         if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0 ||
1857             memcmp(reply, "FAIL", 4) == 0) {
1858                 QMessageBox msg;
1859                 msg.setIcon(QMessageBox::Warning);
1860                 msg.setText(tr("Failed to invite peer to start persistent "
1861                                "P2P Group."));
1862                 msg.exec();
1863         }
1864 }
1865
1866
1867 void Peers::ctx_p2p_delete()
1868 {
1869         if (ctx_item == NULL)
1870                 return;
1871         model.removeRow(ctx_item->row());
1872 }
1873
1874
1875 void Peers::enable_persistent(int id)
1876 {
1877         if (model.rowCount() == 0)
1878                 return;
1879
1880         QModelIndexList lst = model.match(model.index(0, 0),
1881                                           peer_role_network_id, id);
1882         for (int i = 0; i < lst.size(); i++) {
1883                 QStandardItem *item = model.itemFromIndex(lst[i]);
1884                 int type = item->data(peer_role_type).toInt();
1885                 if (type == PEER_TYPE_P2P_PERSISTENT_GROUP_GO ||
1886                     type == PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT)
1887                         item->setBackground(Qt::NoBrush);
1888         }
1889 }