From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 176FA158170 for ; Fri, 19 Jul 2024 03:40:33 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 19F27E29E3; Fri, 19 Jul 2024 03:40:32 +0000 (UTC) Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id E8960E29E3 for ; Fri, 19 Jul 2024 03:40:31 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id C7254342F9D for ; Fri, 19 Jul 2024 03:40:30 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 003A81E28 for ; Fri, 19 Jul 2024 03:40:29 +0000 (UTC) From: "orbea" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "orbea" Message-ID: <1721357267.8d7093b3245de3d6c206cd2a5d4c7cdb293c8ab1.orbea@gentoo> Subject: [gentoo-commits] repo/proj/libressl:master commit in: dev-qt/qtbase/files/, dev-qt/qtbase/ X-VCS-Repository: repo/proj/libressl X-VCS-Files: dev-qt/qtbase/Manifest dev-qt/qtbase/files/qtbase-6.6.3-pkgconf-deps.patch dev-qt/qtbase/files/qtbase-6.7.1-qeventlooplocker.patch dev-qt/qtbase/files/qtbase-6.7.2-CVE-2024-39936.patch dev-qt/qtbase/qtbase-6.7.1.ebuild dev-qt/qtbase/qtbase-6.7.2-r1.ebuild X-VCS-Directories: dev-qt/qtbase/ dev-qt/qtbase/files/ X-VCS-Committer: orbea X-VCS-Committer-Name: orbea X-VCS-Revision: 8d7093b3245de3d6c206cd2a5d4c7cdb293c8ab1 X-VCS-Branch: master Date: Fri, 19 Jul 2024 03:40:29 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 0c5fb640-7d56-40c4-a038-d758fb963a8b X-Archives-Hash: 7481a3cb000f73cf201e519a2ca2461e commit: 8d7093b3245de3d6c206cd2a5d4c7cdb293c8ab1 Author: orbea riseup net> AuthorDate: Fri Jul 19 02:47:47 2024 +0000 Commit: orbea riseup net> CommitDate: Fri Jul 19 02:47:47 2024 +0000 URL: https://gitweb.gentoo.org/repo/proj/libressl.git/commit/?id=8d7093b3 dev-qt/qtbase: add 6.7.2-r1, drop 6.7.1 Signed-off-by: orbea riseup.net> dev-qt/qtbase/Manifest | 1 - .../qtbase/files/qtbase-6.6.3-pkgconf-deps.patch | 35 ---- .../files/qtbase-6.7.1-qeventlooplocker.patch | 159 ---------------- .../qtbase/files/qtbase-6.7.2-CVE-2024-39936.patch | 200 +++++++++++++++++++++ ...{qtbase-6.7.1.ebuild => qtbase-6.7.2-r1.ebuild} | 5 +- 5 files changed, 202 insertions(+), 198 deletions(-) diff --git a/dev-qt/qtbase/Manifest b/dev-qt/qtbase/Manifest index a8aaf26..24deb29 100644 --- a/dev-qt/qtbase/Manifest +++ b/dev-qt/qtbase/Manifest @@ -1,2 +1 @@ -DIST qtbase-everywhere-src-6.7.1.tar.xz 49324536 BLAKE2B 5e5a5801c29c1ac541812931cd56709a934a500ce4d5a38e7d3776620cb46db0d25408c22cbf33a7bcc657098c571e501fde14f523a77acba1827edd977d2bc5 SHA512 864bebfc3659907e52b8dc3f62a65d431573ef2bf406a9f71c688229083a2128c5474f75823275d11948be3d031de1d6427acf373f977df9ee9e73a27ef56efb DIST qtbase-everywhere-src-6.7.2.tar.xz 49364504 BLAKE2B b48b8a8decafe3262d459b9446c25561851fef88b3316107c2909f5964e8122a558b5501a3e59667bdf4776d36ea5ba0d9f227538c45c1f8e94fbc8fff4244a6 SHA512 eb4b2f1fb02ab0ed5508d32449e140778278ff1a619cfcae14920b276b5c46e01a566d73fb8f84cf2cfc81e19cb11e53ab500df6b27d12ab875aa8c07bd15d6b diff --git a/dev-qt/qtbase/files/qtbase-6.6.3-pkgconf-deps.patch b/dev-qt/qtbase/files/qtbase-6.6.3-pkgconf-deps.patch deleted file mode 100644 index 965dade..0000000 --- a/dev-qt/qtbase/files/qtbase-6.6.3-pkgconf-deps.patch +++ /dev/null @@ -1,35 +0,0 @@ -https://bugs.gentoo.org/928299 -https://bugreports.qt.io/browse/QTBUG-124135 -https://codereview.qt-project.org/c/qt/qtbase/+/553372 -From: Alexey Edelev -Date: Fri, 05 Apr 2024 14:50:37 +0200 -Subject: [PATCH] Prefer the versioned targets over the namespaceless one when collecting deps - -Change the way we collect dependencies in __qt_internal_walk_libs. -Prefer the versioned Qt targets over the namespaceless. This fixes the -generating of the pkg-config configs. - -Pick-to: 6.5 6.6 6.7 -Task-number: QTBUG-124135 -Change-Id: I660376e122a99b5bc0874f2bc6ccd4d80c9ad453 ---- a/cmake/QtPublicWalkLibsHelpers.cmake -+++ b/cmake/QtPublicWalkLibsHelpers.cmake -@@ -184,13 +184,13 @@ - if(lib_target MATCHES "^::@") - continue() - elseif(TARGET ${lib_target}) -- if ("${lib_target}" MATCHES "^Qt::(.*)") -- # If both, Qt::Foo and Foo targets exist, prefer the target name without -+ if(NOT "${lib_target}" MATCHES "^(Qt|${QT_CMAKE_EXPORT_NAMESPACE})::.+") -+ # If both, Qt::Foo and Foo targets exist, prefer the target name with versioned - # namespace. Which one is preferred doesn't really matter. This code exists to - # avoid ending up with both, Qt::Foo and Foo in our dependencies. -- set(namespaceless_lib_target "${CMAKE_MATCH_1}") -- if(TARGET "${namespaceless_lib_target}") -- set(lib_target ${namespaceless_lib_target}) -+ set(versioned_qt_target "${QT_CMAKE_EXPORT_NAMESPACE}::${lib_target}") -+ if(TARGET "${versioned_qt_target}") -+ set(lib_target ${versioned_qt_target}) - endif() - endif() - get_target_property(lib_target_type ${lib_target} TYPE) diff --git a/dev-qt/qtbase/files/qtbase-6.7.1-qeventlooplocker.patch b/dev-qt/qtbase/files/qtbase-6.7.1-qeventlooplocker.patch deleted file mode 100644 index ff2bf19..0000000 --- a/dev-qt/qtbase/files/qtbase-6.7.1-qeventlooplocker.patch +++ /dev/null @@ -1,159 +0,0 @@ -https://bugs.kde.org/show_bug.cgi?id=484405 -https://bugreports.qt.io/browse/QTBUG-124386 -https://codereview.qt-project.org/c/qt/qtbase/+/556573 -https://github.com/qt/qtbase/commit/a8ef8ea55014546e0e835cd0eacf694919702a11 -From: =?UTF-8?q?Tor=20Arne=20Vestb=C3=B8?= -Date: Wed, 24 Apr 2024 22:33:42 +0200 -Subject: [PATCH] Don't quit automatically via QEventLoopLocker if there are - open windows - -As part of df359bcb703db5a8adbf14e88ba4ae0d54f0cfcd the semantics and -interaction between QEventLoopLocker and QGuiApplication was changed, -based on the assumption that these two mechanisms were independent -and should not affect each other. - -This had a surprising regression where the use of QEventLoopLocker in -combination with the QCoreApplication::isQuitLockEnabled() automatic -quit would end up quitting the app, even if it had open windows, for -example when the last job of some internal job queue finished. - -It could be argued that if the app has open windows that should not -be closed, they should ignore the Close event, and that an application -with running QEventLoopLocker jobs should maintain an active window -showing the progress of those jobs, but still, this is regression -that we want to fix. - -We now bail out if !lastWindowClosed() in QGuiApplication's -canQuitAutomatically, which is triggered from QEventLoopLocker's -isQuitLockEnabled() behavior. And we do so regardless of whether -quitOnLastWindowClosed is set or not, as the latter property -determines the behavior when closing a window, not the behavior -when a QEventLoopLocker goes out of scope. - -Similarly, we now block quitting of the application when triggered -by quitOnLastWindowClosed() if a QEventLoop is active, regardless of -the isQuitLockEnabled(), as the latter property is determining -whether we should trigger a quit, not whether we should block them. - -[ChangeLog][Important behavior changes] Fixed a regression where -the last QEventLoopLocker going out of scope would quit the app, -even if there were open windows, if quitOnLastWindowClosed was -false. - -[ChangeLog][Important behavior changes] Fixed a regression where -closing the last window would quit the app, even if there were -active QEventLoopLockers, if isQuitLockEnabled was false. ---- a/src/corelib/kernel/qcoreapplication.cpp -+++ b/src/corelib/kernel/qcoreapplication.cpp -@@ -1081,2 +1081,10 @@ - -+ When this property is \c true the release of the last remaining -+ QEventLoopLocker operating on the application will attempt to -+ quit the application. -+ -+ Note that attempting a quit may not necessarily result in the -+ application quitting, for example if there still are open windows, -+ or the QEvent::Quit event is ignored. -+ - The default is \c true. -@@ -2083,3 +2091,9 @@ - -- if (quitLockEnabled && quitLockRef.loadRelaxed()) -+ // The automatic quit functionality is triggered by -+ // both QEventLoopLocker and maybeLastWindowClosed. -+ // In either case, we don't want to quit if there -+ // are active QEventLoopLockers, even if quitLockEnabled -+ // is not enabled, as the property signals whether to -+ // trigger the automatic quit, not whether to block it. -+ if (quitLockRef.loadRelaxed()) - return false; ---- a/src/corelib/kernel/qeventloop.cpp -+++ b/src/corelib/kernel/qeventloop.cpp -@@ -339,3 +339,7 @@ - -- The application will quit when there are no more QEventLoopLockers operating on it. -+ The application will attempt to quit when there are no more QEventLoopLockers -+ operating on it, as long as QCoreApplication::isQuitLockEnabled() is \c true. -+ -+ Note that attempting a quit may not necessarily result in the application quitting, -+ if there for example are open windows, or the QEvent::Quit event is ignored. - ---- a/src/gui/kernel/qguiapplication.cpp -+++ b/src/gui/kernel/qguiapplication.cpp -@@ -3677,5 +3677,9 @@ - -- If this property is \c true, the applications quits when the last visible -- \l{Primary and Secondary Windows}{primary window} (i.e. top level window -- with no transient parent) is closed. -+ If this property is \c true, the application will attempt to -+ quit when the last visible \l{Primary and Secondary Windows}{primary window} -+ (i.e. top level window with no transient parent) is closed. -+ -+ Note that attempting a quit may not necessarily result in the -+ application quitting, for example if there still are active -+ QEventLoopLocker instances, or the QEvent::Quit event is ignored. - -@@ -3735,3 +3739,9 @@ - { -- if (quitOnLastWindowClosed && !lastWindowClosed()) -+ // The automatic quit functionality is triggered by -+ // both QEventLoopLocker and maybeLastWindowClosed. -+ // Although the former is a QCoreApplication feature -+ // we don't want to quit the application when there -+ // are open windows, regardless of whether the app -+ // also quits automatically on maybeLastWindowClosed. -+ if (!lastWindowClosed()) - return false; ---- a/tests/auto/gui/kernel/qguiapplication/tst_qguiapplication.cpp -+++ b/tests/auto/gui/kernel/qguiapplication/tst_qguiapplication.cpp -@@ -1010,4 +1010,4 @@ - { -- // Disabling QEventLoopLocker support should not affect -- // quitting when last window is closed. -+ // Disabling QEventLoopLocker automatic quit should not affect -+ // quitting when last window is closed if there are no lockers. - app.setQuitLockEnabled(false); -@@ -1025,4 +1025,36 @@ - { -- // Disabling quitOnLastWindowClosed support should not affect -- // quitting when last QEventLoopLocker goes out of scope. -+ // Disabling QEventLoopLocker automatic quit should still block -+ // quitting when last window is closed if there is a locker alive. -+ app.setQuitLockEnabled(false); -+ -+ QScopedPointer locker(new QEventLoopLocker); -+ -+ QuitSpy quitSpy; -+ QWindow window; -+ window.show(); -+ QVERIFY(QTest::qWaitForWindowExposed(&window)); -+ QTimer::singleShot(0, &window, &QWindow::close); -+ QTimer::singleShot(200, &app, []{ QCoreApplication::exit(0); }); -+ app.exec(); -+ QCOMPARE(quitSpy.quits, 0); -+ } -+ -+ { -+ // Disabling quitOnLastWindowClosed automatic quit should not affect -+ // quitting when last QEventLoopLocker goes out of scope if -+ // there are no windows. -+ app.setQuitLockEnabled(true); -+ app.setQuitOnLastWindowClosed(false); -+ -+ QuitSpy quitSpy; -+ QScopedPointer locker(new QEventLoopLocker); -+ QTimer::singleShot(0, [&]{ locker.reset(nullptr); }); -+ QTimer::singleShot(200, &app, []{ QCoreApplication::exit(0); }); -+ app.exec(); -+ QCOMPARE(quitSpy.quits, 1); -+ } -+ -+ { -+ // Disabling quitOnLastWindowClosed automatic quit should still block -+ // quitting via QEventLoopLocker if there's a window alive. - app.setQuitLockEnabled(true); -@@ -1038,3 +1070,3 @@ - app.exec(); -- QCOMPARE(quitSpy.quits, 1); -+ QCOMPARE(quitSpy.quits, 0); - } diff --git a/dev-qt/qtbase/files/qtbase-6.7.2-CVE-2024-39936.patch b/dev-qt/qtbase/files/qtbase-6.7.2-CVE-2024-39936.patch new file mode 100644 index 0000000..cc6238a --- /dev/null +++ b/dev-qt/qtbase/files/qtbase-6.7.2-CVE-2024-39936.patch @@ -0,0 +1,200 @@ +https://bugs.gentoo.org/935869 +https://github.com/qt/qtbase/commit/2b1e36e183ce75c224305c7a94457b92f7a5cf58 +From: =?UTF-8?q?M=C3=A5rten=20Nordheim?= +Date: Tue, 25 Jun 2024 17:09:35 +0200 +Subject: [PATCH] HTTP2: Delay any communication until encrypted() can be + responded to + +We have the encrypted() signal that lets users do extra checks on the +established connection. It is emitted as BlockingQueued, so the HTTP +thread stalls until it is done emitting. Users can potentially call +abort() on the QNetworkReply at that point, which is passed as a Queued +call back to the HTTP thread. That means that any currently queued +signal emission will be processed before the abort() call is processed. + +In the case of HTTP2 it is a little special since it is multiplexed and +the code is built to start requests as they are available. This means +that, while the code worked fine for HTTP1, since one connection only +has one request, it is not working for HTTP2, since we try to send more +requests in-between the encrypted() signal and the abort() call. + +This patch changes the code to delay any communication until the +encrypted() signal has been emitted and processed, for HTTP2 only. +It's done by adding a few booleans, both to know that we have to return +early and so we can keep track of what events arose and what we need to +resume once enough time has passed that any abort() call must have been +processed. + +Fixes: QTBUG-126610 +--- a/src/network/access/qhttp2protocolhandler.cpp ++++ b/src/network/access/qhttp2protocolhandler.cpp +@@ -304,10 +304,10 @@ + } + +- if (!prefaceSent && !sendClientPreface()) +- return false; +- + if (!requests.size()) + return true; + ++ if (!prefaceSent && !sendClientPreface()) ++ return false; ++ + m_channel->state = QHttpNetworkConnectionChannel::WritingState; + // Check what was promised/pushed, maybe we do not have to send a request +--- a/src/network/access/qhttpnetworkconnectionchannel.cpp ++++ b/src/network/access/qhttpnetworkconnectionchannel.cpp +@@ -210,4 +210,8 @@ + { + Q_ASSERT(protocolHandler); ++ if (waitingForPotentialAbort) { ++ needInvokeSendRequest = true; ++ return false; // this return value is unused ++ } + return protocolHandler->sendRequest(); + } +@@ -222,7 +226,6 @@ + { + QMetaObject::invokeMethod(this, [this] { +- Q_ASSERT(protocolHandler); + if (reply) +- protocolHandler->sendRequest(); ++ sendRequest(); + }, Qt::ConnectionType::QueuedConnection); + } +@@ -231,4 +234,8 @@ + { + Q_ASSERT(protocolHandler); ++ if (waitingForPotentialAbort) { ++ needInvokeReceiveReply = true; ++ return; ++ } + protocolHandler->_q_receiveReply(); + } +@@ -237,4 +244,8 @@ + { + Q_ASSERT(protocolHandler); ++ if (waitingForPotentialAbort) { ++ needInvokeReadyRead = true; ++ return; ++ } + protocolHandler->_q_readyRead(); + } +@@ -1240,5 +1251,16 @@ + // Similar to HTTP/1.1 counterpart below: + const auto &pair = std::as_const(h2RequestsToSend).first(); ++ waitingForPotentialAbort = true; + emit pair.second->encrypted(); ++ ++ // We don't send or handle any received data until any effects from ++ // emitting encrypted() have been processed. This is necessary ++ // because the user may have called abort(). We may also abort the ++ // whole connection if the request has been aborted and there is ++ // no more requests to send. ++ QMetaObject::invokeMethod(this, ++ &QHttpNetworkConnectionChannel::checkAndResumeCommunication, ++ Qt::QueuedConnection); ++ + // In case our peer has sent us its settings (window size, max concurrent streams etc.) + // let's give _q_receiveReply a chance to read them first ('invokeMethod', QueuedConnection). +@@ -1258,4 +1280,26 @@ + } + ++ ++void QHttpNetworkConnectionChannel::checkAndResumeCommunication() ++{ ++ Q_ASSERT(connection->connectionType() == QHttpNetworkConnection::ConnectionTypeHTTP2 ++ || connection->connectionType() == QHttpNetworkConnection::ConnectionTypeHTTP2Direct); ++ ++ // Because HTTP/2 requires that we send a SETTINGS frame as the first thing we do, and respond ++ // to a SETTINGS frame with an ACK, we need to delay any handling until we can ensure that any ++ // effects from emitting encrypted() have been processed. ++ // This function is called after encrypted() was emitted, so check for changes. ++ ++ if (!reply && h2RequestsToSend.isEmpty()) ++ abort(); ++ waitingForPotentialAbort = false; ++ if (needInvokeReadyRead) ++ _q_readyRead(); ++ if (needInvokeReceiveReply) ++ _q_receiveReply(); ++ if (needInvokeSendRequest) ++ sendRequest(); ++} ++ + void QHttpNetworkConnectionChannel::requeueHttp2Requests() + { +--- a/src/network/access/qhttpnetworkconnectionchannel_p.h ++++ b/src/network/access/qhttpnetworkconnectionchannel_p.h +@@ -75,4 +75,8 @@ + bool ssl; + bool isInitialized; ++ bool waitingForPotentialAbort = false; ++ bool needInvokeReceiveReply = false; ++ bool needInvokeReadyRead = false; ++ bool needInvokeSendRequest = false; + ChannelState state; + QHttpNetworkRequest request; // current request, only used for HTTP +@@ -147,4 +151,6 @@ + void resendCurrentRequest(); + ++ void checkAndResumeCommunication(); ++ + bool isSocketBusy() const; + bool isSocketWriting() const; +--- a/tests/auto/network/access/http2/tst_http2.cpp ++++ b/tests/auto/network/access/http2/tst_http2.cpp +@@ -107,4 +107,6 @@ + void duplicateRequestsWithAborts(); + ++ void abortOnEncrypted(); ++ + protected slots: + // Slots to listen to our in-process server: +@@ -1480,4 +1482,46 @@ + } + ++void tst_Http2::abortOnEncrypted() ++{ ++#if !QT_CONFIG(ssl) ++ QSKIP("TLS support is needed for this test"); ++#else ++ clearHTTP2State(); ++ serverPort = 0; ++ ++ ServerPtr targetServer(newServer(defaultServerSettings, H2Type::h2Direct)); ++ ++ QMetaObject::invokeMethod(targetServer.data(), "startServer", Qt::QueuedConnection); ++ runEventLoop(); ++ ++ nRequests = 1; ++ nSentRequests = 0; ++ ++ const auto url = requestUrl(H2Type::h2Direct); ++ QNetworkRequest request(url); ++ request.setAttribute(QNetworkRequest::Http2DirectAttribute, true); ++ ++ std::unique_ptr reply{manager->get(request)}; ++ reply->ignoreSslErrors(); ++ connect(reply.get(), &QNetworkReply::encrypted, reply.get(), [reply = reply.get()](){ ++ reply->abort(); ++ }); ++ connect(reply.get(), &QNetworkReply::errorOccurred, this, &tst_Http2::replyFinishedWithError); ++ ++ runEventLoop(); ++ STOP_ON_FAILURE ++ ++ QCOMPARE(nRequests, 0); ++ QCOMPARE(reply->error(), QNetworkReply::OperationCanceledError); ++ ++ const bool res = QTest::qWaitFor( ++ [this, server = targetServer.get()]() { ++ return serverGotSettingsACK || prefaceOK || nSentRequests > 0; ++ }, ++ 500); ++ QVERIFY(!res); ++#endif // QT_CONFIG(ssl) ++} ++ + void tst_Http2::serverStarted(quint16 port) + { diff --git a/dev-qt/qtbase/qtbase-6.7.1.ebuild b/dev-qt/qtbase/qtbase-6.7.2-r1.ebuild similarity index 98% rename from dev-qt/qtbase/qtbase-6.7.1.ebuild rename to dev-qt/qtbase/qtbase-6.7.2-r1.ebuild index cf41a45..cc80ee8 100644 --- a/dev-qt/qtbase/qtbase-6.7.1.ebuild +++ b/dev-qt/qtbase/qtbase-6.7.2-r1.ebuild @@ -8,7 +8,7 @@ inherit qt6-build toolchain-funcs DESCRIPTION="Cross-platform application development framework" if [[ ${QT6_BUILD_TYPE} == release ]]; then - KEYWORDS="amd64 arm arm64 ~hppa ~loong ~ppc ppc64 ~riscv ~sparc x86" + KEYWORDS="~amd64 ~arm ~arm64 ~hppa ~loong ~ppc ~ppc64 ~riscv ~sparc ~x86" fi declare -A QT6_IUSE=( @@ -140,8 +140,7 @@ PATCHES=( "${FILESDIR}"/${PN}-6.5.2-no-symlink-check.patch "${FILESDIR}"/${PN}-6.6.1-forkfd-childstack-size.patch "${FILESDIR}"/${PN}-6.6.3-gcc14-avx512fp16.patch - "${FILESDIR}"/${PN}-6.6.3-pkgconf-deps.patch - "${FILESDIR}"/${PN}-6.7.1-qeventlooplocker.patch + "${FILESDIR}"/${PN}-6.7.2-CVE-2024-39936.patch ) src_prepare() {