openwrt · Lankaster · Mar 2, 2022
diff --git a/frameworks/qt5base/Makefile b/frameworks/qt5base/Makefile
@@ -12,13 +12,13 @@
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=qt5base
-PKG_VERSION:=5.15.0
+PKG_VERSION:=5.15.2
 PKG_RELEASE:=1
-PKG_HASH:=bc9a21e9f6fff9629019fdf9f989f064751d5073c3a28dc596def92f4d4275c6
+PKG_HASH:=909fad2591ee367993a75d7e2ea50ad4db332f05e1c38dd7a5a274e156a4e0f8
 
 PKG_SYS_NAME:=qtbase-everywhere-src-$(PKG_VERSION)
 PKG_SOURCE:=$(PKG_SYS_NAME).tar.xz
-PKG_SOURCE_URL:=https://download.qt.io/official_releases/qt/$(basename $(PKG_VERSION))/$(PKG_VERSION)/submodules
+PKG_SOURCE_URL:=https://download.qt.io/archive/qt/$(basename $(PKG_VERSION))/$(PKG_VERSION)/submodules
 
 PKG_BUILD_DIR=$(BUILD_DIR)/$(PKG_SYS_NAME)
 HOST_BUILD_DIR=$(BUILD_DIR)/host/$(PKG_SYS_NAME)
@@ -377,7 +377,7 @@ define Build/Configure
 			--opengles3=no \
 			--egl=no \
 			--xcb-xlib=no \
-			--qpa=$(if $(CONFIG_PACKAGE_qt5base-plugin-platforms-linuxfb),linuxfb,) \
+			--qpa=$(if $(CONFIG_PACKAGE_qt5base-plugin-platforms-linuxfb),linuxfb,no) \
 			--directfb=no \
 			--eglfs=no \
 			--gbm=no \

diff --git a/frameworks/qt5base/patches/100-xcb_screens_uaf.patch b/frameworks/qt5base/patches/100-xcb_screens_uaf.patch
@@ -0,0 +1,26 @@
+Description: Avoid use-after-free in QXcbConnection::initializeScreens()
+Origin: upstream, https://code.qt.io/cgit/qt/qtbase.git/commit/?id=86b8c5c3f32c2457
+Last-Update: 2020-11-23
+
+--- a/src/plugins/platforms/xcb/qxcbconnection_screens.cpp
++++ b/src/plugins/platforms/xcb/qxcbconnection_screens.cpp
+@@ -290,6 +290,8 @@ void QXcbConnection::initializeScreens()
+             // RRGetScreenResources in this case.
+             auto resources_current = Q_XCB_REPLY(xcb_randr_get_screen_resources_current,
+                                                  xcb_connection(), xcbScreen->root);
++            decltype(Q_XCB_REPLY(xcb_randr_get_screen_resources,
++                                 xcb_connection(), xcbScreen->root)) resources;
+             if (!resources_current) {
+                 qWarning("failed to get the current screen resources");
+             } else {
+@@ -300,8 +302,8 @@ void QXcbConnection::initializeScreens()
+                     timestamp = resources_current->config_timestamp;
+                     outputs = xcb_randr_get_screen_resources_current_outputs(resources_current.get());
+                 } else {
+-                    auto resources = Q_XCB_REPLY(xcb_randr_get_screen_resources,
+-                                                 xcb_connection(), xcbScreen->root);
++                    resources = Q_XCB_REPLY(xcb_randr_get_screen_resources,
++                                            xcb_connection(), xcbScreen->root);
+                     if (!resources) {
+                         qWarning("failed to get the screen resources");
+                     } else {
diff --git a/frameworks/qt5base/patches/101-qnam_connect_memory_leak.patch b/frameworks/qt5base/patches/101-qnam_connect_memory_leak.patch
@@ -0,0 +1,25 @@
+Description: QNAM: work around QObject finicky orphan cleanup details
+Origin: upstream, https://code.qt.io/cgit/qt/qtbase.git/commit/?id=0807f16eb407eaf8
+Last-Update: 2021-01-26
+
+--- a/src/network/access/qnetworkreplyhttpimpl.cpp
++++ b/src/network/access/qnetworkreplyhttpimpl.cpp
+@@ -808,7 +808,17 @@ void QNetworkReplyHttpImplPrivate::postR
+
+     // For the synchronous HTTP, this is the normal way the delegate gets deleted
+     // For the asynchronous HTTP this is a safety measure, the delegate deletes itself when HTTP is finished
+-    QObject::connect(thread, SIGNAL(finished()), delegate, SLOT(deleteLater()));
++    QMetaObject::Connection threadFinishedConnection =
++            QObject::connect(thread, SIGNAL(finished()), delegate, SLOT(deleteLater()));
++
++    // QTBUG-88063: When 'delegate' is deleted the connection will be added to 'thread''s orphaned
++    // connections list. This orphaned list will be cleaned up next time 'thread' emits a signal,
++    // unfortunately that's the finished signal. It leads to a soft-leak so we do this to disconnect
++    // it on deletion so that it cleans up the orphan immediately.
++    QObject::connect(delegate, &QObject::destroyed, delegate, [threadFinishedConnection]() {
++        if (bool(threadFinishedConnection))
++            QObject::disconnect(threadFinishedConnection);
++    });
+
+     // Set the properties it needs
+     delegate->httpRequest = httpRequest;
diff --git a/frameworks/qt5base/patches/102-gcc_11_limits.patch b/frameworks/qt5base/patches/102-gcc_11_limits.patch
@@ -0,0 +1,38 @@
+Description: include <limits> to fix some GCC 11 build issues
+Origin: upstream, commits:
+ https://code.qt.io/cgit/qt/qtbase.git/commit/?id=813a928c7c3cf986
+ https://code.qt.io/cgit/qt/qtbase.git/commit/?id=9c56d4da2ff631a8
+Last-Update: 2021-01-26
+
+--- a/src/corelib/global/qendian.h
++++ b/src/corelib/global/qendian.h
+@@ -44,6 +44,8 @@
+ #include <QtCore/qfloat16.h>
+ #include <QtCore/qglobal.h>
+
++#include <limits>
++
+ // include stdlib.h and hope that it defines __GLIBC__ for glibc-based systems
+ #include <stdlib.h>
+ #include <string.h>
+--- a/src/corelib/global/qfloat16.h
++++ b/src/corelib/global/qfloat16.h
+@@ -43,6 +43,7 @@
+
+ #include <QtCore/qglobal.h>
+ #include <QtCore/qmetatype.h>
++#include <limits>
+ #include <string.h>
+
+ #if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__AVX2__) && !defined(__F16C__)
+--- a/src/corelib/text/qbytearraymatcher.h
++++ b/src/corelib/text/qbytearraymatcher.h
+@@ -42,6 +42,8 @@
+
+ #include <QtCore/qbytearray.h>
+
++#include <limits>
++
+ QT_BEGIN_NAMESPACE
+
+
diff --git a/frameworks/qt5base/patches/103-qiodevice_readline_memory.patch b/frameworks/qt5base/patches/103-qiodevice_readline_memory.patch
@@ -0,0 +1,21 @@
+Description: fix allocated memory of QByteArray returned by QIODevice::readLine
+Origin: upstream, https://code.qt.io/cgit/qt/qtbase.git/commit/?id=6485b6d45ad165cf
+Last-Update: 2021-02-20
+
+--- a/src/corelib/io/qiodevice.cpp
++++ b/src/corelib/io/qiodevice.cpp
+@@ -1480,10 +1480,12 @@ QByteArray QIODevice::readLine(qint64 ma
+     } else
+         readBytes = readLine(result.data(), result.size());
+
+-    if (readBytes <= 0)
++    if (readBytes <= 0) {
+         result.clear();
+-    else
++    } else {
+         result.resize(readBytes);
++        result.squeeze();
++    }
+
+     return result;
+ }
diff --git a/frameworks/qt5base/patches/104-mime_globs.patch b/frameworks/qt5base/patches/104-mime_globs.patch
@@ -0,0 +1,51 @@
+Description: adjust QMimeDatabase implementation
+ When multiple globs match, and the result from magic sniffing is
+ unrelated to any of those globs, globs have priority and one of them
+ should be picked up.
+Origin: upstream, https://code.qt.io/cgit/qt/qtbase.git/commit/?id=0cbbba2aa5b47224
+Last-Update: 2021-06-12
+
+--- a/src/corelib/mimetypes/qmimedatabase.cpp
++++ b/src/corelib/mimetypes/qmimedatabase.cpp
+@@ -389,20 +389,23 @@ QMimeType QMimeDatabasePrivate::mimeType
+         // Disambiguate conflicting extensions (if magic matching found something)
+         if (candidateByData.isValid() && magicAccuracy > 0) {
+             const QString sniffedMime = candidateByData.name();
+-            // If the sniffedMime matches a glob match, use it
++            // If the sniffedMime matches a highest-weight glob match, use it
+             if (candidatesByName.m_matchingMimeTypes.contains(sniffedMime)) {
+                 *accuracyPtr = 100;
+                 return candidateByData;
+             }
+-            for (const QString &m : qAsConst(candidatesByName.m_matchingMimeTypes)) {
++            for (const QString &m : qAsConst(candidatesByName.m_allMatchingMimeTypes)) {
+                 if (inherits(m, sniffedMime)) {
+                     // We have magic + pattern pointing to this, so it's a pretty good match
+                     *accuracyPtr = 100;
+                     return mimeTypeForName(m);
+                 }
+             }
+-            *accuracyPtr = magicAccuracy;
+-            return candidateByData;
++            if (candidatesByName.m_allMatchingMimeTypes.isEmpty()) {
++                // No glob, use magic
++                *accuracyPtr = magicAccuracy;
++                return candidateByData;
++            }
+         }
+     }
+
+--- a/src/corelib/mimetypes/qmimeglobpattern.cpp
++++ b/src/corelib/mimetypes/qmimeglobpattern.cpp
+@@ -83,7 +83,10 @@ void QMimeGlobMatchResult::addMatch(cons
+     }
+     if (!m_matchingMimeTypes.contains(mimeType)) {
+         m_matchingMimeTypes.append(mimeType);
+-        m_allMatchingMimeTypes.append(mimeType);
++        if (replace)
++            m_allMatchingMimeTypes.prepend(mimeType); // highest-weight first
++        else
++            m_allMatchingMimeTypes.append(mimeType);
+         m_knownSuffixLength = knownSuffixLength;
+     }
+ }
diff --git a/frameworks/qt5base/patches/105-fix-invalid-pointer-return-with-QGridLayout.patch b/frameworks/qt5base/patches/105-fix-invalid-pointer-return-with-QGridLayout.patch
@@ -0,0 +1,113 @@
+From c47bb4478a4c3a29c0505d7d89755f40601b326f Mon Sep 17 00:00:00 2001
+From: Zhang Yu <zhangyub@uniontech.com>
+Date: Mon, 22 Feb 2021 09:25:01 +0800
+Subject: [PATCH] Fix invalid pointer return with QGridLayout::itemAt(-1)
+
+QGridLayout::takeAt() and QLayoutItem *itemAt() only check the upper bound.
+If the index < 0, these function will return invalid pointer.
+
+Fixes: QTBUG-91261
+Pick-to: 5.15 6.0 6.1
+Change-Id: Idfb9fb6228b9707f817353b04974da16205a835c
+Reviewed-by: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
+---
+
+diff --git a/src/widgets/kernel/qgridlayout.cpp b/src/widgets/kernel/qgridlayout.cpp
+index 121bae0..336a68c 100644
+--- a/src/widgets/kernel/qgridlayout.cpp
++++ b/src/widgets/kernel/qgridlayout.cpp
+@@ -149,14 +149,14 @@
+     QRect cellRect(int row, int col) const;
+
+     inline QLayoutItem *itemAt(int index) const {
+-        if (index < things.count())
++        if (index >= 0 && index < things.count())
+             return things.at(index)->item();
+         else
+             return nullptr;
+     }
+     inline QLayoutItem *takeAt(int index) {
+         Q_Q(QGridLayout);
+-        if (index < things.count()) {
++        if (index >= 0 && index < things.count()) {
+             if (QGridBox *b = things.takeAt(index)) {
+                 QLayoutItem *item = b->takeItem();
+                 if (QLayout *l = item->layout()) {
+@@ -184,7 +184,7 @@
+     }
+
+     void getItemPosition(int index, int *row, int *column, int *rowSpan, int *columnSpan) const {
+-        if (index < things.count()) {
++        if (index >= 0 && index < things.count()) {
+             const QGridBox *b =  things.at(index);
+             int toRow = b->toRow(rr);
+             int toCol = b->toCol(cc);
+diff --git a/tests/auto/widgets/kernel/qgridlayout/tst_qgridlayout.cpp b/tests/auto/widgets/kernel/qgridlayout/tst_qgridlayout.cpp
+index e3bd1d1..2cf2462 100644
+--- a/tests/auto/widgets/kernel/qgridlayout/tst_qgridlayout.cpp
++++ b/tests/auto/widgets/kernel/qgridlayout/tst_qgridlayout.cpp
+@@ -75,6 +75,7 @@
+     void taskQTBUG_40609_addingWidgetToItsOwnLayout();
+     void taskQTBUG_40609_addingLayoutToItself();
+     void taskQTBUG_52357_spacingWhenItemIsHidden();
++    void taskQTBUG_91261_itemIndexRange();
+     void replaceWidget();
+     void dontCrashWhenExtendsToEnd();
+ };
+@@ -1666,6 +1667,56 @@
+     QTRY_COMPARE_WITH_TIMEOUT(tempWidth, button1.width() + button3.width() + layout.spacing(), 1000);
+ }
+
++void tst_QGridLayout::taskQTBUG_91261_itemIndexRange()
++{
++    QWidget widget;
++    QGridLayout lay(&widget);
++    QPushButton *btn = new QPushButton(&widget);
++    lay.addWidget(btn, 0, 0);
++
++    {
++        auto ptr = lay.itemAt(-1);
++        QCOMPARE(ptr, nullptr);
++
++        ptr = lay.itemAt(0);
++        QCOMPARE(ptr->widget(), btn);
++
++        ptr = lay.itemAt(1);
++        QCOMPARE(ptr, nullptr);
++    }
++
++    {
++        int row = -1;
++        int column = -1;
++        int rowSpan;
++        int columnSpan;
++
++        lay.getItemPosition(-1, &row, &column, &rowSpan, &columnSpan);
++        QCOMPARE(row, -1);
++        QCOMPARE(column, -1);
++
++        lay.getItemPosition(1, &row, &column, &rowSpan, &columnSpan);
++        QCOMPARE(row, -1);
++        QCOMPARE(column, -1);
++
++        lay.getItemPosition(0, &row, &column, &rowSpan, &columnSpan);
++        QCOMPARE(row, 0);
++        QCOMPARE(column, 0);
++    }
++
++    {
++        auto ptr = lay.takeAt(-1);
++        QCOMPARE(ptr, nullptr);
++
++        ptr = lay.takeAt(1);
++        QCOMPARE(ptr, nullptr);
++
++        ptr = lay.takeAt(0);
++        QCOMPARE(ptr->widget(), btn);
++        delete ptr;
++    }
++}
++
+ void tst_QGridLayout::replaceWidget()
+ {
+     QWidget wdg;
diff --git a/frameworks/qt5base/patches/106-fix-misplacement-of-placeholder-text-in-QLineEdit.patch b/frameworks/qt5base/patches/106-fix-misplacement-of-placeholder-text-in-QLineEdit.patch
@@ -0,0 +1,53 @@
+Description: fix misplacement of placeholder text in QLineEdit with RTL content
+ The placeholder text was rendered in the wrong position after clicking
+ on the clear button in a QLineEdit with right-to-left content. The
+ button was still taking up space while it was fading out, so the first
+ paintEvent rendered the placeholder with space reserved for the clear
+ button. Once the button gets hidden, no new update was issued, so
+ garbage was left behind.
+ .
+ Fix this by not giving a fading-out clear button any margin space. The
+ result of this is that the placeholder text is visible underneath the
+ fading-out clear button. This is preferable to the placeholder text
+ being first rendered next to the fading-out clear button, and then
+ popping to the edge when the clear button is hidden (which would have
+ been the result of issuing a complete update for the line edit at the
+ end of the fade-out animation).
+Origin: upstream, https://code.qt.io/cgit/qt/qtbase.git/commit/?id=dc794f7622bc00f7
+Last-Update: 2021-06-16
+
+--- a/src/widgets/widgets/qlineedit_p.cpp
++++ b/src/widgets/widgets/qlineedit_p.cpp
+@@ -664,10 +664,18 @@ static int effectiveTextMargin(int defau
+     if (widgets.empty())
+         return defaultMargin;
+
+-    return defaultMargin + (parameters.margin + parameters.widgetWidth) *
+-           int(std::count_if(widgets.begin(), widgets.end(),
++    const auto visibleSideWidgetCount = std::count_if(widgets.begin(), widgets.end(),
+                              [](const QLineEditPrivate::SideWidgetEntry &e) {
+-                                 return e.widget->isVisibleTo(e.widget->parentWidget()); }));
++#if QT_CONFIG(animation)
++        // a button that's fading out doesn't get any space
++        if (auto* iconButton = qobject_cast<QLineEditIconButton*>(e.widget))
++            return iconButton->needsSpace();
++
++#endif
++        return e.widget->isVisibleTo(e.widget->parentWidget());
++    });
++
++    return defaultMargin + (parameters.margin + parameters.widgetWidth) * visibleSideWidgetCount;
+ }
+
+ QMargins QLineEditPrivate::effectiveTextMargins() const
+--- a/src/widgets/widgets/qlineedit_p.h
++++ b/src/widgets/widgets/qlineedit_p.h
+@@ -95,6 +95,8 @@ public:
+
+     bool shouldHideWithText() const;
+     void setHideWithText(bool hide);
++    // m_wasHidden is true unless the button is fading out
++    bool needsSpace() const { return m_wasHidden; }
+ #endif
+
+ protected:
diff --git a/frameworks/qt5base/patches/107-fusion_checkable_qpushbutton.patch b/frameworks/qt5base/patches/107-fusion_checkable_qpushbutton.patch
@@ -0,0 +1,27 @@
+Description: QPushButton/fusion style: don't ignore QIcon::On icon
+ The fusion style did ignore the QIcon::On icon because it reset
+ State_On to avoid the visual shift of a pressed button.
+ But it's not needed to reset this flag - the shift does not happen
+ because the fusion style does return 0 as offset for
+ PM_ButtonShiftHorizontal/PM_ButtonShiftVertical so no shifting will
+ happen.
+Origin: upstream, https://code.qt.io/cgit/qt/qtbase.git/commit/?id=e9ccdf4d84157173
+Last-Update: 2021-08-10
+
+--- a/src/widgets/styles/qfusionstyle.cpp
++++ b/src/widgets/styles/qfusionstyle.cpp
+@@ -1771,14 +1771,6 @@ void QFusionStyle::drawControl(ControlEl
+             proxy()->drawControl(CE_PushButtonLabel, &subopt, painter, widget);
+         }
+         break;
+-    case CE_PushButtonLabel:
+-        if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {
+-            QStyleOptionButton b(*button);
+-            // no PM_ButtonShiftHorizontal and PM_ButtonShiftVertical for fusion style
+-            b.state &= ~(State_On | State_Sunken);
+-            QCommonStyle::drawControl(element, &b, painter, widget);
+-        }
+-        break;
+     case CE_MenuBarEmptyArea:
+         painter->save();
+     {