roy.marples.name Git - dhcpcd-ui/blob - src/dhcpcd-qt/dhcpcd-qt.cpp

   1 /*
   2  * dhcpcd-qt
   3  * Copyright 2014-2017 Roy Marples <roy@marples.name>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <QCursor>
  28 #include <QDebug>
  29 #include <QList>
  30 #include <QSocketNotifier>
  31 #include <QtGui>
  32
  33 #include <cerrno>
  34
  35 #include "config.h"
  36 #include "dhcpcd-qt.h"
  37 #include "dhcpcd-about.h"
  38 #include "dhcpcd-preferences.h"
  39 #include "dhcpcd-wi.h"
  40 #include "dhcpcd-ifmenu.h"
  41 #include "dhcpcd-ssidmenu.h"
  42
  43 #ifdef NOTIFY
  44 #include <knotification.h>
  45 #endif
  46
  47 DhcpcdQt::DhcpcdQt()
  48 {
  49
  50         createActions();
  51         createTrayIcon();
  52
  53         onLine = carrier = false;
  54         lastStatus = DHC_UNKNOWN;
  55         aniTimer = new QTimer(this);
  56         connect(aniTimer, SIGNAL(timeout()), this, SLOT(animate()));
  57         notifier = NULL;
  58         retryOpenTimer = NULL;
  59
  60         about = NULL;
  61         preferences = NULL;
  62
  63         wis = new QList<DhcpcdWi *>();
  64         ssidMenu = NULL;
  65
  66         qDebug("%s", "Connecting ...");
  67         con = dhcpcd_new();
  68         if (con == NULL) {
  69                 qCritical("libdhcpcd: %s", strerror(errno));
  70                 exit(EXIT_FAILURE);
  71                 return;
  72         }
  73         dhcpcd_set_progname(con, "dhcpcd-qt");
  74         dhcpcd_set_status_callback(con, dhcpcd_status_cb, this);
  75         dhcpcd_set_if_callback(con, dhcpcd_if_cb, this);
  76         dhcpcd_wpa_set_scan_callback(con, dhcpcd_wpa_scan_cb, this);
  77         dhcpcd_wpa_set_status_callback(con, dhcpcd_wpa_status_cb, this);
  78         tryOpen();
  79 }
  80
  81 DhcpcdQt::~DhcpcdQt()
  82 {
  83
  84         if (ssidMenu) {
  85                 ssidMenu->setVisible(false);
  86                 ssidMenu->deleteLater();
  87         }
  88
  89         if (con != NULL) {
  90                 dhcpcd_close(con);
  91                 dhcpcd_free(con);
  92         }
  93
  94         for (auto &wi : *wis)
  95                 wi->deleteLater();
  96         delete wis;
  97 }
  98
  99 DHCPCD_CONNECTION *DhcpcdQt::getConnection()
 100 {
 101
 102         return con;
 103 }
 104
 105 QList<DhcpcdWi *> *DhcpcdQt::getWis()
 106 {
 107
 108         return wis;
 109 }
 110
 111 const char * DhcpcdQt::signalStrengthIcon(DHCPCD_WI_SCAN *scan)
 112 {
 113
 114         if (scan == NULL)
 115                 return "network-wireless-connected-00";
 116         if (scan->strength.value > 80)
 117                 return "network-wireless-connected-100";
 118         if (scan->strength.value > 55)
 119                 return "network-wireless-connected-75";
 120         if (scan->strength.value > 30)
 121                 return "network-wireless-connected-50";
 122         if (scan->strength.value > 5)
 123                 return "network-wireless-connected-25";
 124         return "network-wireless-connected-00";
 125 }
 126
 127 DHCPCD_WI_SCAN * DhcpcdQt::getStrongestSignal()
 128 {
 129         DHCPCD_WI_SCAN *scan, *scans, *s;
 130         DHCPCD_WPA *wpa;
 131         DHCPCD_IF *i;
 132
 133         scan = NULL;
 134         for (auto &wi : *wis) {
 135                 wpa = wi->getWpa();
 136                 i = dhcpcd_wpa_if(wpa);
 137                 scans = wi->getScans();
 138                 for (s = scans; s; s = s->next) {
 139                         if (dhcpcd_wi_associated(i, s) &&
 140                             (scan == NULL ||
 141                             s->strength.value > scan->strength.value))
 142                                 scan = s;
 143                 }
 144         }
 145         return scan;
 146 }
 147
 148 void DhcpcdQt::animate()
 149 {
 150         const char *icon;
 151         DHCPCD_WI_SCAN *scan;
 152
 153         scan = getStrongestSignal();
 154
 155         if (onLine) {
 156                 if (aniCounter++ > 6) {
 157                         aniTimer->stop();
 158                         aniCounter = 0;
 159                         return;
 160                 }
 161
 162                 if (aniCounter % 2 == 0)
 163                         icon = scan ? "network-wireless-connected-00" :
 164                             "network-idle";
 165                 else
 166                         icon = scan ? DhcpcdQt::signalStrengthIcon(scan) :
 167                             "network-transmit-receive";
 168         } else {
 169                 if (scan) {
 170                         switch(aniCounter++) {
 171                         case 0:
 172                                 icon = "network-wireless-connected-00";
 173                                 break;
 174                         case 1:
 175                                 icon = "network-wireless-connected-25";
 176                                 break;
 177                         case 2:
 178                                 icon = "network-wireless-connected-50";
 179                                 break;
 180                         case 3:
 181                                 icon = "network-wireless-connected-75";
 182                                 break;
 183                         default:
 184                                 icon = "network-wireless-connected-100";
 185                                 aniCounter = 0;
 186                         }
 187                 } else {
 188                         switch(aniCounter++) {
 189                         case 0:
 190                                 icon = "network-transmit";
 191                                 break;
 192                         case 1:
 193                                 icon = "network-receive";
 194                                 break;
 195                         default:
 196                                 icon = "network-idle";
 197                                 aniCounter = 0;
 198                         }
 199                 }
 200         }
 201
 202         setIcon("status", icon);
 203 }
 204
 205 void DhcpcdQt::updateOnline(bool showIf)
 206 {
 207         bool isOn, isCarrier;
 208         char *msg;
 209         DHCPCD_IF *ifs, *i;
 210         QString msgs;
 211
 212         isOn = isCarrier = false;
 213         ifs = dhcpcd_interfaces(con);
 214         for (i = ifs; i; i = i->next) {
 215                 if (i->type == DHT_LINK) {
 216                         if (i->up)
 217                                 isCarrier = true;
 218                 } else {
 219                         if (i->up)
 220                                 isOn = true;
 221                 }
 222                 msg = dhcpcd_if_message(i, NULL);
 223                 if (msg) {
 224                         if (showIf)
 225                                 qDebug("%s", msg);
 226                         if (msgs.isEmpty())
 227                                 msgs = QString::fromLatin1(msg);
 228                         else
 229                                 msgs += '\n' + QString::fromLatin1(msg);
 230                         free(msg);
 231                 } else if (showIf)
 232                         qDebug("%s: %s", i->ifname, i->reason);
 233         }
 234
 235         if (onLine != isOn || carrier != isCarrier) {
 236                 onLine = isOn;
 237                 carrier = isCarrier;
 238                 aniTimer->stop();
 239                 aniCounter = 0;
 240                 if (isOn) {
 241                         animate();
 242                         aniTimer->start(300);
 243                 } else if (isCarrier) {
 244                         animate();
 245                         aniTimer->start(500);
 246                 } else
 247                         setIcon("status", "network-offline");
 248         }
 249
 250         trayIcon->setToolTip(msgs);
 251 }
 252
 253 void DhcpcdQt::statusCallback(unsigned int status, const char *status_msg)
 254 {
 255
 256         qDebug("Status changed to %s", status_msg);
 257         if (status == DHC_DOWN) {
 258                 aniTimer->stop();
 259                 aniCounter = 0;
 260                 onLine = carrier = false;
 261                 setIcon("status", "network-offline");
 262                 trayIcon->setToolTip(tr("Not connected to dhcpcd"));
 263                 /* Close down everything */
 264                 if (notifier) {
 265                         notifier->setEnabled(false);
 266                         notifier->deleteLater();
 267                         notifier = NULL;
 268                 }
 269                 if (ssidMenu) {
 270                         ssidMenu->deleteLater();
 271                         ssidMenu = NULL;
 272                 }
 273                 preferencesAction->setEnabled(false);
 274                 if (preferences) {
 275                         preferences->deleteLater();
 276                         preferences = NULL;
 277                 }
 278         } else {
 279                 bool refresh;
 280
 281                 if (lastStatus == DHC_UNKNOWN || lastStatus == DHC_DOWN) {
 282                         qDebug("Connected to dhcpcd-%s", dhcpcd_version(con));
 283                         refresh = true;
 284                 } else
 285                         refresh = lastStatus == DHC_OPENED ? true : false;
 286                 updateOnline(refresh);
 287         }
 288
 289         lastStatus = status;
 290
 291         if (status == DHC_DOWN) {
 292                 if (retryOpenTimer == NULL) {
 293                         retryOpenTimer = new QTimer(this);
 294                         connect(retryOpenTimer, SIGNAL(timeout()),
 295                             this, SLOT(tryOpen()));
 296                         retryOpenTimer->start(DHCPCD_RETRYOPEN);
 297                 }
 298         }
 299 }
 300
 301 void DhcpcdQt::dhcpcd_status_cb(_unused DHCPCD_CONNECTION *con,
 302     unsigned int status, const char *status_msg, void *d)
 303 {
 304         DhcpcdQt *dhcpcdQt = (DhcpcdQt *)d;
 305
 306         dhcpcdQt->statusCallback(status, status_msg);
 307 }
 308
 309 void DhcpcdQt::ifCallback(DHCPCD_IF *i)
 310 {
 311         char *msg;
 312         bool new_msg;
 313
 314         if (i->state == DHS_RENEW ||
 315             i->state == DHS_STOP || i->state == DHS_STOPPED)
 316         {
 317                 msg = dhcpcd_if_message(i, &new_msg);
 318                 if (msg) {
 319                         qDebug("%s", msg);
 320                         if (new_msg) {
 321                                 QString t = tr("Network Event");
 322                                 QString m = msg;
 323                                 QString icon;
 324
 325                                 if (i->up)
 326                                         icon = "network-transmit-receive";
 327                                 //else
 328                                 //      icon = "network-transmit";
 329                                 if (!i->up)
 330                                         icon = "network-offline";
 331                                 notify(t, m, icon);
 332                         }
 333                         free(msg);
 334                 }
 335         }
 336
 337         updateOnline(false);
 338
 339         if (i->wireless) {
 340                 for (auto &wi : *wis) {
 341                         DHCPCD_WPA *wpa = wi->getWpa();
 342                         if (dhcpcd_wpa_if(wpa) == i) {
 343                                 DHCPCD_WI_SCAN *scans;
 344
 345                                 scans = dhcpcd_wi_scans(i);
 346                                 processScans(wi, scans);
 347                         }
 348                 }
 349         }
 350 }
 351
 352 void DhcpcdQt::dhcpcd_if_cb(DHCPCD_IF *i, void *d)
 353 {
 354         DhcpcdQt *dhcpcdQt = (DhcpcdQt *)d;
 355
 356         dhcpcdQt->ifCallback(i);
 357 }
 358
 359 DhcpcdWi *DhcpcdQt::findWi(DHCPCD_WPA *wpa)
 360 {
 361
 362         for (auto &wi : *wis) {
 363                 if (wi->getWpa() == wpa)
 364                         return wi;
 365         }
 366         return NULL;
 367 }
 368
 369 void DhcpcdQt::processScans(DhcpcdWi *wi, DHCPCD_WI_SCAN *scans)
 370 {
 371         DHCPCD_IF *i;
 372
 373         /* Don't spam the user if we're already connected. */
 374         i = dhcpcd_wpa_if(wi->getWpa());
 375
 376         if (!i->up) {
 377                 QString title = tr("New Access Point");
 378                 QString txt;
 379                 DHCPCD_WI_SCAN *s1, *s2;
 380
 381                 for (s1 = scans; s1; s1 = s1->next) {
 382                         for (s2 = wi->getScans(); s2; s2 = s2->next) {
 383                                 if (strcmp(s1->ssid, s2->ssid) == 0)
 384                                         break;
 385                         }
 386                         if (s2 == NULL) {
 387                                 if (!txt.isEmpty()) {
 388                                         title = tr("New Access Points");
 389                                         txt += '\n';
 390                                 }
 391                                 txt += s1->ssid;
 392                         }
 393                 }
 394                 if (!txt.isEmpty() &&
 395                     (ssidMenu == NULL || !ssidMenu->isVisible()))
 396                         notify(title, txt, "network-wireless");
 397         }
 398
 399         if (wi->setScans(scans) && ssidMenu && ssidMenu->isVisible())
 400                 ssidMenu->popup(ssidMenuPos);
 401 }
 402
 403 void DhcpcdQt::scanCallback(DHCPCD_WPA *wpa)
 404 {
 405         DHCPCD_WI_SCAN *scans;
 406         int fd = dhcpcd_wpa_get_fd(wpa);
 407         DhcpcdWi *wi;
 408
 409         wi = findWi(wpa);
 410         if (fd == -1) {
 411                 qCritical("No fd for WPA");
 412                 if (wi) {
 413                         wis->removeOne(wi);
 414                         wi->close();
 415                         wi->deleteLater();
 416                 }
 417                 return;
 418         }
 419
 420         DHCPCD_IF *i = dhcpcd_wpa_if(wpa);
 421         if (i == NULL) {
 422                 qCritical("No interface for WPA");
 423                 if (wi) {
 424                         wis->removeOne(wi);
 425                         wi->close();
 426                         wi->deleteLater();
 427                 }
 428                 return;
 429         }
 430
 431         qDebug("%s: Received scan results", i->ifname);
 432         scans = dhcpcd_wi_scans(i);
 433         if (wi == NULL) {
 434                 wi = new DhcpcdWi(this, wpa);
 435                 if (wi->open()) {
 436                         wis->append(wi);
 437                         wi->setScans(scans);
 438                 } else {
 439                         wi->close();
 440                         wi->deleteLater();
 441                 }
 442         } else
 443                 processScans(wi, scans);
 444
 445         if (!aniTimer->isActive()) {
 446                 DHCPCD_WI_SCAN *scan;
 447                 const char *icon;
 448
 449                 scan = getStrongestSignal();
 450                 if (scan)
 451                         icon = DhcpcdQt::signalStrengthIcon(scan);
 452                 else if (onLine)
 453                         icon = "network-transmit-receive";
 454                 else
 455                         icon = "network-offline";
 456
 457                 setIcon("status", icon);
 458         }
 459 }
 460
 461 void DhcpcdQt::dhcpcd_wpa_scan_cb(DHCPCD_WPA *wpa, void *d)
 462 {
 463         DhcpcdQt *dhcpcdQt = (DhcpcdQt *)d;
 464
 465         dhcpcdQt->scanCallback(wpa);
 466 }
 467
 468 void DhcpcdQt::wpaStatusCallback(DHCPCD_WPA *wpa,
 469     unsigned int status, const char *status_msg)
 470 {
 471         DHCPCD_IF *i;
 472
 473         i = dhcpcd_wpa_if(wpa);
 474         qDebug("%s: WPA status %s", i->ifname, status_msg);
 475         if (status == DHC_DOWN) {
 476                 DhcpcdWi *wi = findWi(wpa);
 477                 if (wi) {
 478                         wis->removeOne(wi);
 479                         wi->close();
 480                         wi->deleteLater();
 481                 }
 482         }
 483 }
 484
 485 void DhcpcdQt::dhcpcd_wpa_status_cb(DHCPCD_WPA *wpa,
 486     unsigned int status, const char *status_msg, void *d)
 487 {
 488         DhcpcdQt *dhcpcdQt = (DhcpcdQt *)d;
 489
 490         dhcpcdQt->wpaStatusCallback(wpa, status, status_msg);
 491 }
 492
 493 void DhcpcdQt::tryOpen() {
 494         int fd = dhcpcd_open(con, true);
 495         static int last_error;
 496
 497         if (fd == -1) {
 498                 if (errno == EACCES || errno == EPERM) {
 499                         if ((fd = dhcpcd_open(con, false)) != -1)
 500                                 goto unprived;
 501                 }
 502                 if (errno != last_error) {
 503                         last_error = errno;
 504                         const char *errt = strerror(errno);
 505                         qCritical("dhcpcd_open: %s", errt);
 506                         trayIcon->setToolTip(
 507                             tr("Error connecting to dhcpcd: %1").arg(errt));
 508                 }
 509                 if (retryOpenTimer == NULL) {
 510                         retryOpenTimer = new QTimer(this);
 511                         connect(retryOpenTimer, SIGNAL(timeout()),
 512                             this, SLOT(tryOpen()));
 513                         retryOpenTimer->start(DHCPCD_RETRYOPEN);
 514                 }
 515                 return;
 516         }
 517
 518 unprived:
 519         /* Start listening to WPA events */
 520         dhcpcd_wpa_start(con);
 521
 522         if (retryOpenTimer) {
 523                 retryOpenTimer->stop();
 524                 retryOpenTimer->deleteLater();
 525                 retryOpenTimer = NULL;
 526         }
 527
 528         notifier = new QSocketNotifier(fd, QSocketNotifier::Read);
 529         connect(notifier, SIGNAL(activated(int)), this, SLOT(dispatch()));
 530
 531         preferencesAction->setEnabled(dhcpcd_privileged(con));
 532 }
 533
 534 void DhcpcdQt::dispatch()
 535 {
 536
 537         dhcpcd_dispatch(con);
 538 }
 539
 540 void DhcpcdQt::notify(const QString &title, const QString &msg,
 541     const QString &icon)
 542 {
 543
 544 #ifdef NOTIFY
 545         KNotification *n = new KNotification("event", this);
 546         n->setTitle(title);
 547         n->setText(msg);
 548         n->sendEvent();
 549 #else
 550 #if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0)
 551         const QIcon i = getIcon("status", icon);
 552 #else
 553         QSystemTrayIcon::MessageIcon i = QSystemTrayIcon::Information;
 554
 555         if (icon.compare("network-offline") == 0)
 556                 i = QSystemTrayIcon::Warning;
 557 #endif
 558         trayIcon->showMessage(title, msg, i);
 559 #endif
 560 }
 561
 562 void DhcpcdQt::closeEvent(QCloseEvent *event)
 563 {
 564
 565         if (trayIcon->isVisible()) {
 566                 hide();
 567                 event->ignore();
 568         }
 569 }
 570
 571 QIcon DhcpcdQt::getIcon(QString category, QString name)
 572 {
 573         QIcon icon;
 574
 575         if (QIcon::hasThemeIcon(name))
 576                 icon = QIcon::fromTheme(name);
 577         else
 578                 icon = QIcon(ICONDIR "/hicolor/scalable/" + category + "/" + name + ".svg");
 579
 580         return icon;
 581 }
 582
 583 void DhcpcdQt::setIcon(QString category, QString name)
 584 {
 585         QIcon icon = getIcon(category, name);
 586
 587         trayIcon->setIcon(icon);
 588 }
 589
 590 QIcon DhcpcdQt::icon()
 591 {
 592
 593         return getIcon("status", "network-transmit-receive");
 594 }
 595
 596 void DhcpcdQt::menuDeleted(QMenu *menu)
 597 {
 598
 599         if (ssidMenu == menu)
 600                 ssidMenu = NULL;
 601 }
 602
 603 void DhcpcdQt::createSsidMenu()
 604 {
 605
 606         if (ssidMenu) {
 607                 ssidMenu->deleteLater();
 608                 ssidMenu = NULL;
 609         }
 610         if (wis->size() == 0)
 611                 return;
 612
 613         ssidMenu = new QMenu(this);
 614         if (wis->size() == 1)
 615                 wis->first()->createMenu(ssidMenu);
 616         else {
 617                 for (auto &wi : *wis)
 618                         ssidMenu->addMenu(wi->createIfMenu(ssidMenu));
 619         }
 620         ssidMenuPos = QCursor::pos();
 621         ssidMenu->popup(ssidMenuPos);
 622 }
 623
 624 void DhcpcdQt::iconActivated(QSystemTrayIcon::ActivationReason reason)
 625 {
 626
 627         if (reason == QSystemTrayIcon::Trigger)
 628                 createSsidMenu();
 629 }
 630
 631 void DhcpcdQt::dialogClosed(QDialog *dialog)
 632 {
 633
 634         if (dialog == about)
 635                 about = NULL;
 636         else if (dialog == preferences)
 637                 preferences = NULL;
 638 }
 639
 640 void DhcpcdQt::showPreferences()
 641 {
 642
 643         if (preferences == NULL) {
 644                 preferences = new DhcpcdPreferences(this);
 645                 preferences->show();
 646         } else
 647                 preferences->activateWindow();
 648 }
 649
 650 void DhcpcdQt::showAbout()
 651 {
 652
 653         if (about == NULL) {
 654                 about = new DhcpcdAbout(this);
 655                 about->show();
 656         } else
 657                 about->activateWindow();
 658 }
 659
 660 void DhcpcdQt::createActions()
 661 {
 662
 663         preferencesAction = new QAction(tr("&Preferences"), this);
 664         preferencesAction->setIcon(QIcon::fromTheme("preferences-system-network"));
 665         preferencesAction->setEnabled(false);
 666         connect(preferencesAction, SIGNAL(triggered()),
 667             this, SLOT(showPreferences()));
 668
 669         aboutAction = new QAction(tr("&About"), this);
 670         aboutAction->setIcon(QIcon::fromTheme("help-about"));
 671         connect(aboutAction, SIGNAL(triggered()), this, SLOT(showAbout()));
 672
 673         quitAction = new QAction(tr("&Quit"), this);
 674         quitAction->setIcon(QIcon::fromTheme("application-exit"));
 675         connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
 676
 677 }
 678
 679 void DhcpcdQt::createTrayIcon()
 680 {
 681
 682         trayIconMenu = new QMenu(this);
 683         trayIconMenu->addAction(preferencesAction);
 684         trayIconMenu->addSeparator();
 685         trayIconMenu->addAction(aboutAction);
 686         trayIconMenu->addAction(quitAction);
 687
 688         trayIcon = new QSystemTrayIcon(this);
 689         setIcon("status", "network-offline");
 690         trayIcon->setContextMenu(trayIconMenu);
 691
 692         connect(trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
 693             this, SLOT(iconActivated(QSystemTrayIcon::ActivationReason)));
 694
 695         trayIcon->show();
 696 }