v2.19.2

Author: bernerdad

libs/wsnet/src/dnsresolver/dnsresolver_cares.cpp

@@ -11,7 +11,10 @@
     #include <netinet/in.h>
     #include <arpa/inet.h>
     #include <netdb.h>
-    #include <sys/select.h>
+    #include <poll.h>
+#elif defined(_WIN32) || defined(_WIN64)
+    #include <winsock2.h>
+    #define poll WSAPoll
 #endif
 
 #if defined(__APPLE__) && !defined(IS_MOBILE_PLATFORM)
@@ -129,7 +132,15 @@ void DnsResolver_cares::run()
     std::queue<QueueItem> localQueue;
     while (!finish_) {
 
-        {   // mutex lock section
+        // Check if c-ares still has active sockets
+        // If so, do not block so that the next batch can be processed immediately
+        ares_socket_t temp_sockets[ARES_GETSOCK_MAXNUM];
+        int temp_bitmask = ares_getsock(channel, temp_sockets, ARES_GETSOCK_MAXNUM);
+        bool has_active_sockets = (temp_bitmask != 0);
+
+        // Wait only if there are no active requests and no active sockets
+        if (!has_active_sockets) {
+            // mutex lock section
             std::unique_lock<std::mutex> locker(mutex_);
             condition_.wait(locker, [this]{ return !activeRequests_.empty() || finish_; });
             localQueue = queue_;
@@ -178,17 +189,56 @@ void DnsResolver_cares::run()
         }
 
         // process
-        fd_set readers, writers;
-        FD_ZERO(&readers);
-        FD_ZERO(&writers);
-        int nfds = ares_fds(channel, &readers, &writers);
-        if (nfds != 0) {
+        ares_socket_t sockets[ARES_GETSOCK_MAXNUM];
+        int bitmask = ares_getsock(channel, sockets, ARES_GETSOCK_MAXNUM);
+        
+        struct pollfd pfds[ARES_GETSOCK_MAXNUM];
+        int nfds = 0;
+        
+        for (int i = 0; i < ARES_GETSOCK_MAXNUM; i++) {
+            if (ARES_GETSOCK_READABLE(bitmask, i) || ARES_GETSOCK_WRITABLE(bitmask, i)) {
+                pfds[nfds].fd = sockets[i];
+                pfds[nfds].events = 0;
+                pfds[nfds].revents = 0;
+                
+                if (ARES_GETSOCK_READABLE(bitmask, i)) {
+                    pfds[nfds].events |= POLLIN;
+                }
+                if (ARES_GETSOCK_WRITABLE(bitmask, i)) {
+                    pfds[nfds].events |= POLLOUT;
+                }
+                nfds++;
+            }
+        }
+        
+        if (nfds > 0) {
             // do not block for longer than kTimeoutMs interval
-            timeval tvp;
-            tvp.tv_sec = 0;
-            tvp.tv_usec = kTimeoutMs * 1000;
-            select(nfds, &readers, &writers, NULL, &tvp);
-            ares_process(channel, &readers, &writers);
+            int timeout_ms = kTimeoutMs;
+            poll(pfds, nfds, timeout_ms);
+            
+            // Convert poll events to ares_fd_events_t for ares_process_fds
+            ares_fd_events_t events[ARES_GETSOCK_MAXNUM];
+            int nevents = 0;
+            
+            for (int i = 0; i < nfds; i++) {
+                events[nevents].fd = pfds[i].fd;
+                events[nevents].events = 0;
+                
+                if (pfds[i].revents & POLLIN) {
+                    events[nevents].events |= ARES_FD_EVENT_READ;
+                }
+                if (pfds[i].revents & POLLOUT) {
+                    events[nevents].events |= ARES_FD_EVENT_WRITE;
+                }
+                
+                // Include the fd even if no events (for timeout processing)
+                nevents++;
+            }
+            
+            ares_process_fds(channel, events, nevents, ARES_PROCESS_FLAG_NONE);
+        } else {
+            // No file descriptors to process, but still need to handle timeouts
+            ares_process_fds(channel, NULL, 0, ARES_PROCESS_FLAG_NONE);
         }
     }
 

src/client/base/backend/backend.cpp

@@ -112,11 +112,12 @@ void Backend::init()
     connect(engine_, &Engine::setRobertFilterFinished, this, &Backend::onEngineSetRobertFilterFinished);
     connect(engine_, &Engine::syncRobertFinished, this, &Backend::onEngineSyncRobertFinished);
     connect(engine_, &Engine::splitTunnelingStartFailed, this, &Backend::splitTunnelingStartFailed);
+    connect(engine_, &Engine::systemExtensionAvailabilityChanged, this, &Backend::systemExtensionAvailabilityChanged);
     connect(engine_, &Engine::autoEnableAntiCensorship, this, &Backend::onEngineAutoEnableAntiCensorship);
     connect(engine_, &Engine::connectionIdChanged, this, &Backend::connectionIdChanged);
     connect(engine_, &Engine::localDnsServerNotAvailable, this, &Backend::localDnsServerNotAvailable);
     connect(engine_, &Engine::bridgeApiAvailabilityChanged, this, &Backend::onEngineBridgeApiAvailabilityChanged);
-    connect(engine_, &Engine::ipRotateFailed, this, &Backend::ipRotateFailed);
+    connect(engine_, &Engine::ipRotateResult, this, &Backend::ipRotateResult);
     connect(engine_, &Engine::connectingHostnameChanged, this, &Backend::onEngineConnectingHostnameChanged);
     connect(engine_, &Engine::controldDevicesFetched, this, &Backend::controldDevicesFetched);
     threadEngine_->start(QThread::LowPriority);
@@ -135,6 +136,7 @@ void Backend::enableBFE_win()
 
 void Backend::login(const QString &username, const QString &password, const QString &code2fa)
 {
+    WS_ASSERT(loginState_ != LOGIN_STATE_LOGGING_IN);
     loginState_ = LOGIN_STATE_LOGGING_IN;
     bLastLoginWithAuthHash_ = false;
     lastUsername_ = username;
@@ -160,13 +162,15 @@ bool Backend::isSavedApiSettingsExists() const
 
 void Backend::loginWithAuthHash()
 {
+    WS_ASSERT(loginState_ != LOGIN_STATE_LOGGING_IN);
     loginState_ = LOGIN_STATE_LOGGING_IN;
     bLastLoginWithAuthHash_ = true;
     engine_->loginWithAuthHash();
 }
 
 void Backend::loginWithLastLoginSettings()
 {
+    WS_ASSERT(loginState_ != LOGIN_STATE_LOGGING_IN);
     loginState_ = LOGIN_STATE_LOGGING_IN;
     if (bLastLoginWithAuthHash_)
         loginWithAuthHash();
@@ -575,9 +579,9 @@ void Backend::onEngineSyncRobertFinished(bool success)
     emit syncRobertResult(success);
 }
 
-void Backend::onEngineProtocolStatusChanged(const QVector<types::ProtocolStatus> &status)
+void Backend::onEngineProtocolStatusChanged(const QVector<types::ProtocolStatus> &status, bool isAutomaticMode)
 {
-    emit protocolStatusChanged(status);
+    emit protocolStatusChanged(status, isAutomaticMode);
 }
 
 void Backend::onEngineEmergencyConnected()
@@ -889,10 +893,12 @@ void Backend::sendSplitTunneling(const types::SplitTunneling &st)
     QStringList ips;
     QStringList hosts;
     for (int i = 0; i < st.networkRoutes.size(); ++i) {
-        if (st.networkRoutes[i].type == SPLIT_TUNNELING_NETWORK_ROUTE_TYPE_IP) {
-            ips << st.networkRoutes[i].name;
-        } else if (st.networkRoutes[i].type == SPLIT_TUNNELING_NETWORK_ROUTE_TYPE_HOSTNAME) {
-            hosts << st.networkRoutes[i].name;
+        if (st.networkRoutes[i].active) {
+            if (st.networkRoutes[i].type == SPLIT_TUNNELING_NETWORK_ROUTE_TYPE_IP) {
+                ips << st.networkRoutes[i].name;
+            } else if (st.networkRoutes[i].type == SPLIT_TUNNELING_NETWORK_ROUTE_TYPE_HOSTNAME) {
+                hosts << st.networkRoutes[i].name;
+            }
         }
     }
 
@@ -1075,4 +1081,3 @@ void Backend::fetchControldDevices(const QString &apiKey)
 {
     engine_->fetchControldDevices(apiKey);
 }
-

src/client/base/backend/backend.h

@@ -148,7 +148,7 @@ private slots:
     void onEngineRobertFiltersUpdated(bool success, const QVector<api_responses::RobertFilter> &filters);
     void onEngineSetRobertFilterFinished(bool success);
     void onEngineSyncRobertFinished(bool success);
-    void onEngineProtocolStatusChanged(const QVector<types::ProtocolStatus> &status);
+    void onEngineProtocolStatusChanged(const QVector<types::ProtocolStatus> &status, bool isAutomaticMode);
 
     void onEngineEmergencyConnected();
     void onEngineEmergencyDisconnected();
@@ -215,6 +215,7 @@ private slots:
     void sessionStatusChanged(const api_responses::SessionStatus &sessionStatus);
     void checkUpdateChanged(const api_responses::CheckUpdate &checkUpdateInfo);
     void splitTunnelingStateChanged(bool isActive);
+    void systemExtensionAvailabilityChanged(bool available);
 
     void confirmEmailResult(bool bSuccess);
     void debugLogResult(bool bSuccess);
@@ -247,7 +248,7 @@ private slots:
 
     void wireGuardAtKeyLimit();
     void wireGuardKeyLimitUserResponse(bool deleteOldestKey);
-    void protocolStatusChanged(const QVector<types::ProtocolStatus> &status);
+    void protocolStatusChanged(const QVector<types::ProtocolStatus> &status, bool isAutomaticMode);
 
     void controldDevicesFetched(CONTROLD_FETCH_RESULT result, const QList<QPair<QString, QString>> &devices);
 
@@ -256,7 +257,7 @@ private slots:
     void localDnsServerNotAvailable();
 
     void bridgeApiAvailabilityChanged(bool isAvailable);
-    void ipRotateFailed();
+    void ipRotateResult(bool success);
 
 private:
     bool isSavedApiSettingsExists_;

src/client/base/backend/preferences/preferences.cpp

@@ -23,13 +23,6 @@ Preferences::Preferences(QObject *parent) : QObject(parent)
 
 Preferences::~Preferences()
 {
-    // make sure timers are cleaned up; don't call clearLastKnownGoodProtocols() here,
-    // because it will trigger a emit engineSettingsChanged();
-    for (auto network : timers_.keys()) {
-        timers_[network]->stop();
-        SAFE_DELETE(timers_[network]);
-    }
-    timers_.clear();
 }
 
 bool Preferences::isLaunchOnStartup() const
@@ -649,60 +642,6 @@ void Preferences::setCustomOvpnConfigsPath(const QString &path)
     }
 }
 
-types::Protocol Preferences::networkLastKnownGoodProtocol(const QString &network) const
-{
-    return engineSettings_.networkLastKnownGoodProtocol(network);
-}
-
-uint Preferences::networkLastKnownGoodPort(const QString &network) const
-{
-    return engineSettings_.networkLastKnownGoodPort(network);
-}
-
-void Preferences::setNetworkLastKnownGoodProtocolPort(const QString &network, const types::Protocol &protocol, uint port)
-{
-    if (engineSettings_.networkLastKnownGoodProtocol(network) != protocol ||
-        engineSettings_.networkLastKnownGoodPort(network) != port)
-    {
-        // if a timer doesn't exist for this netowrk, create it, otherwise use the existing one
-        if (!timers_.contains(network)) {
-            QTimer *timer = new QTimer(this);
-            timer->setSingleShot(true);
-            connect(timer, &QTimer::timeout, this, [this, network] () {
-                clearLastKnownGoodProtocols(network);
-            });
-            timers_[network] = timer;
-        }
-        // start or restart timer to clear this in 12 hours
-        timers_[network]->start(12*60*60*1000);
-
-        engineSettings_.setNetworkLastKnownGoodProtocolPort(network, protocol, port);
-        emitEngineSettingsChanged();
-        emit networkLastKnownGoodProtocolPortChanged(network, protocol, port);
-    }
-}
-
-void Preferences::clearLastKnownGoodProtocols(const QString &network)
-{
-    engineSettings_.clearLastKnownGoodProtocols(network);
-    emitEngineSettingsChanged();
-
-    if (!network.isEmpty()) {
-        if (timers_.contains(network)) {
-            timers_[network]->stop();
-            SAFE_DELETE(timers_[network]);
-            timers_.remove(network);
-        }
-        emit networkLastKnownGoodProtocolPortChanged(network, types::Protocol(types::Protocol::TYPE::UNINITIALIZED), 0);
-    } else {
-        for (auto network : timers_.keys()) {
-            timers_[network]->stop();
-            SAFE_DELETE(timers_[network]);
-        }
-        timers_.clear();
-    }
-}
-
 QJsonObject Preferences::toJson() const
 {
     QJsonObject json;

src/client/base/backend/preferences/preferences.h

@@ -160,11 +160,6 @@ class Preferences : public QObject
     bool isShowLocationLoad() const;
     void setShowLocationLoad(bool b);
 
-    types::Protocol networkLastKnownGoodProtocol(const QString &network) const;
-    uint networkLastKnownGoodPort(const QString &network) const;
-    void setNetworkLastKnownGoodProtocolPort(const QString &network, const types::Protocol &protocol, uint port);
-    void clearLastKnownGoodProtocols(const QString &network = "");
-
     QJsonObject toJson() const;
     void updateFromJson(const QJsonObject& ob);
 
@@ -217,7 +212,6 @@ class Preferences : public QObject
     void networkPreferredProtocolsChanged(QMap<QString, types::ConnectionSettings> p);
     void splitTunnelingChanged(types::SplitTunneling st);
     void keepAliveChanged(bool b);
-    void networkLastKnownGoodProtocolPortChanged(const QString &network, const types::Protocol &protocol, uint port);
 
     // emit if any of the engine options have changed
     // don't emit in setEngineSettings()
@@ -230,7 +224,6 @@ class Preferences : public QObject
     types::GuiSettings guiSettings_;
 
     bool isSettingEngineSettings_;
-    QMap<QString, QTimer *> timers_;
 
     void emitEngineSettingsChanged();
 

src/client/base/backend/preferences/preferenceshelper.cpp

@@ -5,8 +5,8 @@
 PreferencesHelper::PreferencesHelper(QObject *parent) : QObject(parent),
     isWifiSharingSupported_(true), isDockedToTray_(false), isExternalConfigMode_(false)
 {
-    availableLanguageCodes_ << "ar" << "cs" << "de" << "en" << "es" << "fa" << "fr" << "hi" << "id" << "it" << "ja" << "ko"
-        << "pl" << "pt" << "ru" << "tr" << "uk" << "vi" << "zh-CN" << "zh-TW";
+    availableLanguageCodes_ << "ar" << "cs" << "de" << "el" << "en" << "es" << "fa" << "fr" << "hi" << "id" << "it" << "ja" << "ko"
+        << "pl" << "pt" << "ru" << "sk" << "tr" << "uk" << "vi" << "zh-CN" << "zh-TW";
 }
 
 QString PreferencesHelper::buildVersion()

src/client/base/localipcserver/localipcserver.cpp

@@ -23,6 +23,7 @@ LocalIPCServer::LocalIPCServer(Backend *backend, QObject *parent) : QObject(pare
     connect(backend_, &Backend::updateVersionChanged, this, &LocalIPCServer::onBackendUpdateVersionChanged);
     connect(backend_, &Backend::connectionIdChanged, this, &LocalIPCServer::onBackendConnectionIdChanged);
     connect(backend_, &Backend::bridgeApiAvailabilityChanged, this, &LocalIPCServer::onBackendBridgeApiAvailabilityChanged);
+    connect(backend_, &Backend::ipRotateResult, this, &LocalIPCServer::onBackendIpRotateResult);
 
     connect(backend_->locationsModelManager(), &gui_locations::LocationsModelManager::deviceNameChanged, this, &LocalIPCServer::onLocationsModelManagerDeviceNameChanged);
 }
@@ -157,14 +158,32 @@ void LocalIPCServer::onConnectionCommandCallback(IPC::Command *command, IPC::Con
         IPC::CliCommands::SetKeyLimitBehavior *cmd = static_cast<IPC::CliCommands::SetKeyLimitBehavior *>(command);
         emit setKeyLimitBehavior(cmd->keyLimitDelete_);
     } else if (command->getStringId() == IPC::CliCommands::RotateIp::getCommandStringId()) {
-        if (!isBridgeApiAvailable_) {
+        if (awaitingIpRotateResult_) {
             IPC::CliCommands::Acknowledge cmd;
-            cmd.code_ = 1;
-            cmd.message_ = "Bridge API not available";
+            cmd.code_ = 2;
+            cmd.message_ = "IP rotate already in progress";
             sendCommand(cmd);
             return;
         }
-        backend_->rotateIp();
+        awaitingIpRotateResult_ = true;
+
+        qint64 msSinceLastResult = 0;
+        if (lastIpRotateResultTime_.isValid()) {
+            msSinceLastResult = lastIpRotateResultTime_.msecsTo(QDateTime::currentDateTime());
+        }
+
+        int delayMs = qMax(0LL, 2000 - msSinceLastResult);
+        QTimer::singleShot(delayMs, this, [this]() {
+            if (!isBridgeApiAvailable_) {
+                IPC::CliCommands::Acknowledge cmd;
+                cmd.code_ = 1;
+                cmd.message_ = "Bridge API not available";
+                sendCommand(cmd);
+                return;
+            }
+            backend_->rotateIp();
+        });
+        return;
     } else if (command->getStringId() == IPC::CliCommands::FavIp::getCommandStringId()) {
         if (!isBridgeApiAvailable_) {
             IPC::CliCommands::Acknowledge cmd;
@@ -285,6 +304,10 @@ void LocalIPCServer::onBackendConnectStateChanged(const types::ConnectState &sta
             invalidLocation_ = false;
         }
     }
+
+    if (awaitingIpRotateResult_ && connectState_.connectState != CONNECT_STATE_CONNECTED) {
+        onBackendIpRotateResult(false);
+    }
 }
 
 void LocalIPCServer::onBackendProtocolPortChanged(const types::Protocol &protocol, uint port)
@@ -340,3 +363,23 @@ void LocalIPCServer::onLocationsModelManagerDeviceNameChanged(const QString &dev
 {
     deviceName_ = deviceName;
 }
+
+void LocalIPCServer::onBackendIpRotateResult(bool success)
+{
+    if (!awaitingIpRotateResult_) {
+        return;
+    }
+
+    awaitingIpRotateResult_ = false;
+    lastIpRotateResultTime_ = QDateTime::currentDateTime();
+
+    IPC::CliCommands::Acknowledge cmd;
+    if (success) {
+        cmd.code_ = 0;
+        cmd.message_ = "IP rotated.";
+    } else {
+        cmd.code_ = 1;
+        cmd.message_ = "Could not rotate IP.";
+    }
+    sendCommand(cmd);
+}