libeap/wpa_supplicant/wpa_gui-qt4/peers.cpp

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