Merge 5.12 into 5.12.9
Change-Id: I604e23045b115966e06d966f25724b3f72b313d8
This commit is contained in:
commit
b11508aa54
@ -1,203 +0,0 @@
|
||||
From 63566d1fff2665b777650594eec6eefd3587e177 Mon Sep 17 00:00:00 2001
|
||||
From: Andy Shaw <andy.shaw@qt.io>
|
||||
Date: Wed, 4 Mar 2020 07:44:22 +0100
|
||||
Subject: [PATCH] Fix CVE-2020-9327 in SQLite
|
||||
|
||||
This was taken from abc473fb8fb99900 in SQLite, ref:
|
||||
https://www.sqlite.org/cgi/src/info/abc473fb8fb99900
|
||||
|
||||
Fixes: QTBUG-82533
|
||||
Change-Id: I9840e29f19a0b861229987f5b59d8585ba2e55dc
|
||||
---
|
||||
.../0001-Fix-CVE-2020-9327-in-SQLite.patch | 96 +++++++++++++++++++
|
||||
src/3rdparty/sqlite/sqlite3.c | 31 ++++--
|
||||
2 files changed, 118 insertions(+), 9 deletions(-)
|
||||
create mode 100644 src/3rdparty/sqlite/patches/0001-Fix-CVE-2020-9327-in-SQLite.patch
|
||||
|
||||
diff --git a/src/3rdparty/sqlite/patches/0001-Fix-CVE-2020-9327-in-SQLite.patch b/src/3rdparty/sqlite/patches/0001-Fix-CVE-2020-9327-in-SQLite.patch
|
||||
new file mode 100644
|
||||
index 0000000000..e0e8206db5
|
||||
--- /dev/null
|
||||
+++ b/src/3rdparty/sqlite/patches/0001-Fix-CVE-2020-9327-in-SQLite.patch
|
||||
@@ -0,0 +1,96 @@
|
||||
+From f79860e0fe251e3267a3cd5558dce98f918e0caa Mon Sep 17 00:00:00 2001
|
||||
+From: Andy Shaw <andy.shaw@qt.io>
|
||||
+Date: Wed, 4 Mar 2020 07:44:22 +0100
|
||||
+Subject: [PATCH] Fix CVE-2020-9327 in SQLite
|
||||
+
|
||||
+Fixes: QTBUG-82533
|
||||
+Change-Id: I9840e29f19a0b861229987f5b59d8585ba2e55dc
|
||||
+---
|
||||
+ src/3rdparty/sqlite/sqlite3.c | 31 ++++++++++++++++++++++---------
|
||||
+ 1 file changed, 22 insertions(+), 9 deletions(-)
|
||||
+
|
||||
+diff --git a/src/3rdparty/sqlite/sqlite3.c b/src/3rdparty/sqlite/sqlite3.c
|
||||
+index 55dc686ee0..dfe5323a59 100644
|
||||
+--- a/src/3rdparty/sqlite/sqlite3.c
|
||||
++++ b/src/3rdparty/sqlite/sqlite3.c
|
||||
+@@ -17428,8 +17428,11 @@ struct Table {
|
||||
+ */
|
||||
+ #ifndef SQLITE_OMIT_VIRTUALTABLE
|
||||
+ # define IsVirtual(X) ((X)->nModuleArg)
|
||||
++# define ExprIsVtab(X) \
|
||||
++ ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->nModuleArg)
|
||||
+ #else
|
||||
+ # define IsVirtual(X) 0
|
||||
++# define ExprIsVtab(X) 0
|
||||
+ #endif
|
||||
+
|
||||
+ /*
|
||||
+@@ -104133,19 +104136,25 @@ static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
|
||||
+ case TK_LT:
|
||||
+ case TK_LE:
|
||||
+ case TK_GT:
|
||||
+- case TK_GE:
|
||||
++ case TK_GE: {
|
||||
++ Expr *pLeft = pExpr->pLeft;
|
||||
++ Expr *pRight = pExpr->pRight;
|
||||
+ testcase( pExpr->op==TK_EQ );
|
||||
+ testcase( pExpr->op==TK_NE );
|
||||
+ testcase( pExpr->op==TK_LT );
|
||||
+ testcase( pExpr->op==TK_LE );
|
||||
+ testcase( pExpr->op==TK_GT );
|
||||
+ testcase( pExpr->op==TK_GE );
|
||||
+- if( (pExpr->pLeft->op==TK_COLUMN && IsVirtual(pExpr->pLeft->y.pTab))
|
||||
+- || (pExpr->pRight->op==TK_COLUMN && IsVirtual(pExpr->pRight->y.pTab))
|
||||
++ /* The y.pTab=0 assignment in wherecode.c always happens after the
|
||||
++ ** impliesNotNullRow() test */
|
||||
++ if( (pLeft->op==TK_COLUMN && ALWAYS(pLeft->y.pTab!=0)
|
||||
++ && IsVirtual(pLeft->y.pTab))
|
||||
++ || (pRight->op==TK_COLUMN && ALWAYS(pRight->y.pTab!=0)
|
||||
++ && IsVirtual(pRight->y.pTab))
|
||||
+ ){
|
||||
+- return WRC_Prune;
|
||||
++ return WRC_Prune;
|
||||
+ }
|
||||
+-
|
||||
++ }
|
||||
+ default:
|
||||
+ return WRC_Continue;
|
||||
+ }
|
||||
+@@ -142591,7 +142600,8 @@ static int isAuxiliaryVtabOperator(
|
||||
+ ** MATCH(expression,vtab_column)
|
||||
+ */
|
||||
+ pCol = pList->a[1].pExpr;
|
||||
+- if( pCol->op==TK_COLUMN && IsVirtual(pCol->y.pTab) ){
|
||||
++ testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
|
||||
++ if( ExprIsVtab(pCol) ){
|
||||
+ for(i=0; i<ArraySize(aOp); i++){
|
||||
+ if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
|
||||
+ *peOp2 = aOp[i].eOp2;
|
||||
+@@ -142613,7 +142623,8 @@ static int isAuxiliaryVtabOperator(
|
||||
+ ** with function names in an arbitrary case.
|
||||
+ */
|
||||
+ pCol = pList->a[0].pExpr;
|
||||
+- if( pCol->op==TK_COLUMN && IsVirtual(pCol->y.pTab) ){
|
||||
++ testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
|
||||
++ if( ExprIsVtab(pCol) ){
|
||||
+ sqlite3_vtab *pVtab;
|
||||
+ sqlite3_module *pMod;
|
||||
+ void (*xNotUsed)(sqlite3_context*,int,sqlite3_value**);
|
||||
+@@ -142636,10 +142647,12 @@ static int isAuxiliaryVtabOperator(
|
||||
+ int res = 0;
|
||||
+ Expr *pLeft = pExpr->pLeft;
|
||||
+ Expr *pRight = pExpr->pRight;
|
||||
+- if( pLeft->op==TK_COLUMN && IsVirtual(pLeft->y.pTab) ){
|
||||
++ testcase( pLeft->op==TK_COLUMN && pLeft->y.pTab==0 );
|
||||
++ if( ExprIsVtab(pLeft) ){
|
||||
+ res++;
|
||||
+ }
|
||||
+- if( pRight && pRight->op==TK_COLUMN && IsVirtual(pRight->y.pTab) ){
|
||||
++ testcase( pRight && pRight->op==TK_COLUMN && pRight->y.pTab==0 );
|
||||
++ if( pRight && ExprIsVtab(pRight) ){
|
||||
+ res++;
|
||||
+ SWAP(Expr*, pLeft, pRight);
|
||||
+ }
|
||||
+--
|
||||
+2.21.0 (Apple Git-122.2)
|
||||
+
|
||||
diff --git a/src/3rdparty/sqlite/sqlite3.c b/src/3rdparty/sqlite/sqlite3.c
|
||||
index 55dc686ee0..dfe5323a59 100644
|
||||
--- a/src/3rdparty/sqlite/sqlite3.c
|
||||
+++ b/src/3rdparty/sqlite/sqlite3.c
|
||||
@@ -17428,8 +17428,11 @@ struct Table {
|
||||
*/
|
||||
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
||||
# define IsVirtual(X) ((X)->nModuleArg)
|
||||
+# define ExprIsVtab(X) \
|
||||
+ ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->nModuleArg)
|
||||
#else
|
||||
# define IsVirtual(X) 0
|
||||
+# define ExprIsVtab(X) 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
@@ -104133,19 +104136,25 @@ static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
|
||||
case TK_LT:
|
||||
case TK_LE:
|
||||
case TK_GT:
|
||||
- case TK_GE:
|
||||
+ case TK_GE: {
|
||||
+ Expr *pLeft = pExpr->pLeft;
|
||||
+ Expr *pRight = pExpr->pRight;
|
||||
testcase( pExpr->op==TK_EQ );
|
||||
testcase( pExpr->op==TK_NE );
|
||||
testcase( pExpr->op==TK_LT );
|
||||
testcase( pExpr->op==TK_LE );
|
||||
testcase( pExpr->op==TK_GT );
|
||||
testcase( pExpr->op==TK_GE );
|
||||
- if( (pExpr->pLeft->op==TK_COLUMN && IsVirtual(pExpr->pLeft->y.pTab))
|
||||
- || (pExpr->pRight->op==TK_COLUMN && IsVirtual(pExpr->pRight->y.pTab))
|
||||
+ /* The y.pTab=0 assignment in wherecode.c always happens after the
|
||||
+ ** impliesNotNullRow() test */
|
||||
+ if( (pLeft->op==TK_COLUMN && ALWAYS(pLeft->y.pTab!=0)
|
||||
+ && IsVirtual(pLeft->y.pTab))
|
||||
+ || (pRight->op==TK_COLUMN && ALWAYS(pRight->y.pTab!=0)
|
||||
+ && IsVirtual(pRight->y.pTab))
|
||||
){
|
||||
- return WRC_Prune;
|
||||
+ return WRC_Prune;
|
||||
}
|
||||
-
|
||||
+ }
|
||||
default:
|
||||
return WRC_Continue;
|
||||
}
|
||||
@@ -142591,7 +142600,8 @@ static int isAuxiliaryVtabOperator(
|
||||
** MATCH(expression,vtab_column)
|
||||
*/
|
||||
pCol = pList->a[1].pExpr;
|
||||
- if( pCol->op==TK_COLUMN && IsVirtual(pCol->y.pTab) ){
|
||||
+ testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
|
||||
+ if( ExprIsVtab(pCol) ){
|
||||
for(i=0; i<ArraySize(aOp); i++){
|
||||
if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
|
||||
*peOp2 = aOp[i].eOp2;
|
||||
@@ -142613,7 +142623,8 @@ static int isAuxiliaryVtabOperator(
|
||||
** with function names in an arbitrary case.
|
||||
*/
|
||||
pCol = pList->a[0].pExpr;
|
||||
- if( pCol->op==TK_COLUMN && IsVirtual(pCol->y.pTab) ){
|
||||
+ testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
|
||||
+ if( ExprIsVtab(pCol) ){
|
||||
sqlite3_vtab *pVtab;
|
||||
sqlite3_module *pMod;
|
||||
void (*xNotUsed)(sqlite3_context*,int,sqlite3_value**);
|
||||
@@ -142636,10 +142647,12 @@ static int isAuxiliaryVtabOperator(
|
||||
int res = 0;
|
||||
Expr *pLeft = pExpr->pLeft;
|
||||
Expr *pRight = pExpr->pRight;
|
||||
- if( pLeft->op==TK_COLUMN && IsVirtual(pLeft->y.pTab) ){
|
||||
+ testcase( pLeft->op==TK_COLUMN && pLeft->y.pTab==0 );
|
||||
+ if( ExprIsVtab(pLeft) ){
|
||||
res++;
|
||||
}
|
||||
- if( pRight && pRight->op==TK_COLUMN && IsVirtual(pRight->y.pTab) ){
|
||||
+ testcase( pRight && pRight->op==TK_COLUMN && pRight->y.pTab==0 );
|
||||
+ if( pRight && ExprIsVtab(pRight) ){
|
||||
res++;
|
||||
SWAP(Expr*, pLeft, pRight);
|
||||
}
|
||||
--
|
||||
2.21.0 (Apple Git-122.2)
|
||||
|
@ -1,30 +0,0 @@
|
||||
From fa3ea2350c0367aa7cfd796b31214e2dcf574360 Mon Sep 17 00:00:00 2001
|
||||
From: Andy Shaw <andy.shaw@qt.io>
|
||||
Date: Mon, 20 Apr 2020 10:43:29 +0200
|
||||
Subject: [PATCH] sqlite: Fix CVE-2020-11655
|
||||
|
||||
This was taken from 4a302b42c7bf5e11 in SQLite, ref:
|
||||
https://www3.sqlite.org/cgi/src/info/4a302b42c7bf5e11
|
||||
|
||||
[ChangeLog][QtSQL][sqlite] Fixed CVE-2020-11655
|
||||
|
||||
Change-Id: I5ead78d9ee63aa0f12f1c1014c79373728569f30
|
||||
---
|
||||
src/3rdparty/sqlite/sqlite3.c | 1 +
|
||||
1 file changed, 1 insertion(+)
|
||||
|
||||
diff --git a/src/3rdparty/sqlite/sqlite3.c b/src/3rdparty/sqlite/sqlite3.c
|
||||
index dfe5323a59..054be43d95 100644
|
||||
--- a/src/3rdparty/sqlite/sqlite3.c
|
||||
+++ b/src/3rdparty/sqlite/sqlite3.c
|
||||
@@ -133226,6 +133226,7 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
|
||||
struct AggInfo_func *pFunc;
|
||||
int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
|
||||
if( nReg==0 ) return;
|
||||
+ if( pParse->nErr ) return;
|
||||
#ifdef SQLITE_DEBUG
|
||||
/* Verify that all AggInfo registers are within the range specified by
|
||||
** AggInfo.mnReg..AggInfo.mxReg */
|
||||
--
|
||||
2.24.2 (Apple Git-127)
|
||||
|
@ -1,63 +0,0 @@
|
||||
From 99cdbed3bb5368ae2ec80d15635a2dd57961310c Mon Sep 17 00:00:00 2001
|
||||
From: Andy Shaw <andy.shaw@qt.io>
|
||||
Date: Mon, 20 Apr 2020 10:49:57 +0200
|
||||
Subject: [PATCH] sqlite: Fix CVE-2020-11656
|
||||
|
||||
This was taken from d09f8c3621d5f7f8 and b64674919f673602 in SQLite,
|
||||
ref: https://www3.sqlite.org/cgi/src/info/d09f8c3621d5f7f8
|
||||
https://www.sqlite.org/cgi/src/info/b64674919f673602
|
||||
|
||||
[ChangeLog][QtSQL][sqlite] Fixed CVE-2020-11656
|
||||
|
||||
Fixes: QTBUG-83652
|
||||
Change-Id: I99bd59dc10b753ff19822c902dff1fc339d330a8
|
||||
---
|
||||
src/3rdparty/sqlite/sqlite3.c | 18 +++++++++++++++++-
|
||||
1 file changed, 17 insertions(+), 1 deletion(-)
|
||||
|
||||
diff --git a/src/3rdparty/sqlite/sqlite3.c b/src/3rdparty/sqlite/sqlite3.c
|
||||
index 054be43d95..6ff9ba42aa 100644
|
||||
--- a/src/3rdparty/sqlite/sqlite3.c
|
||||
+++ b/src/3rdparty/sqlite/sqlite3.c
|
||||
@@ -97945,7 +97945,7 @@ static int resolveOrderByTermToExprList(
|
||||
nc.nErr = 0;
|
||||
db = pParse->db;
|
||||
savedSuppErr = db->suppressErr;
|
||||
- db->suppressErr = 1;
|
||||
+ if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1;
|
||||
rc = sqlite3ResolveExprNames(&nc, pE);
|
||||
db->suppressErr = savedSuppErr;
|
||||
if( rc ) return 0;
|
||||
@@ -105383,6 +105383,21 @@ static void renameWalkWith(Walker *pWalker, Select *pSelect){
|
||||
}
|
||||
}
|
||||
|
||||
+/*
|
||||
+** Unmap all tokens in the IdList object passed as the second argument.
|
||||
+*/
|
||||
+static void unmapColumnIdlistNames(
|
||||
+ Parse *pParse,
|
||||
+ IdList *pIdList
|
||||
+){
|
||||
+ if( pIdList ){
|
||||
+ int ii;
|
||||
+ for(ii=0; ii<pIdList->nId; ii++){
|
||||
+ sqlite3RenameTokenRemap(pParse, 0, (void*)pIdList->a[ii].zName);
|
||||
+ }
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
/*
|
||||
** Walker callback used by sqlite3RenameExprUnmap().
|
||||
*/
|
||||
@@ -105404,6 +105419,7 @@ static int renameUnmapSelectCb(Walker *pWalker, Select *p){
|
||||
for(i=0; i<pSrc->nSrc; i++){
|
||||
sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
|
||||
if( sqlite3WalkExpr(pWalker, pSrc->a[i].pOn) ) return WRC_Abort;
|
||||
+ unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing);
|
||||
}
|
||||
}
|
||||
|
||||
--
|
||||
2.24.2 (Apple Git-127)
|
||||
|
4663
src/3rdparty/sqlite/sqlite3.c
vendored
4663
src/3rdparty/sqlite/sqlite3.c
vendored
File diff suppressed because it is too large
Load Diff
242
src/3rdparty/sqlite/sqlite3.h
vendored
242
src/3rdparty/sqlite/sqlite3.h
vendored
@ -123,9 +123,9 @@ extern "C" {
|
||||
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
|
||||
** [sqlite_version()] and [sqlite_source_id()].
|
||||
*/
|
||||
#define SQLITE_VERSION "3.31.1"
|
||||
#define SQLITE_VERSION_NUMBER 3031001
|
||||
#define SQLITE_SOURCE_ID "2020-01-27 19:55:54 3bfa9cc97da10598521b342961df8f5f68c7388fa117345eeb516eaa837bb4d6"
|
||||
#define SQLITE_VERSION "3.32.1"
|
||||
#define SQLITE_VERSION_NUMBER 3032001
|
||||
#define SQLITE_SOURCE_ID "2020-05-25 16:19:56 0c1fcf4711a2e66c813aed38cf41cd3e2123ee8eb6db98118086764c4ba83350"
|
||||
|
||||
/*
|
||||
** CAPI3REF: Run-Time Library Version Numbers
|
||||
@ -299,26 +299,22 @@ typedef sqlite_uint64 sqlite3_uint64;
|
||||
** the [sqlite3] object is successfully destroyed and all associated
|
||||
** resources are deallocated.
|
||||
**
|
||||
** ^If the database connection is associated with unfinalized prepared
|
||||
** statements or unfinished sqlite3_backup objects then sqlite3_close()
|
||||
** will leave the database connection open and return [SQLITE_BUSY].
|
||||
** ^If sqlite3_close_v2() is called with unfinalized prepared statements
|
||||
** and/or unfinished sqlite3_backups, then the database connection becomes
|
||||
** an unusable "zombie" which will automatically be deallocated when the
|
||||
** last prepared statement is finalized or the last sqlite3_backup is
|
||||
** finished. The sqlite3_close_v2() interface is intended for use with
|
||||
** host languages that are garbage collected, and where the order in which
|
||||
** destructors are called is arbitrary.
|
||||
**
|
||||
** Applications should [sqlite3_finalize | finalize] all [prepared statements],
|
||||
** [sqlite3_blob_close | close] all [BLOB handles], and
|
||||
** Ideally, applications should [sqlite3_finalize | finalize] all
|
||||
** [prepared statements], [sqlite3_blob_close | close] all [BLOB handles], and
|
||||
** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated
|
||||
** with the [sqlite3] object prior to attempting to close the object. ^If
|
||||
** sqlite3_close_v2() is called on a [database connection] that still has
|
||||
** outstanding [prepared statements], [BLOB handles], and/or
|
||||
** [sqlite3_backup] objects then it returns [SQLITE_OK] and the deallocation
|
||||
** of resources is deferred until all [prepared statements], [BLOB handles],
|
||||
** and [sqlite3_backup] objects are also destroyed.
|
||||
** with the [sqlite3] object prior to attempting to close the object.
|
||||
** ^If the database connection is associated with unfinalized prepared
|
||||
** statements, BLOB handlers, and/or unfinished sqlite3_backup objects then
|
||||
** sqlite3_close() will leave the database connection open and return
|
||||
** [SQLITE_BUSY]. ^If sqlite3_close_v2() is called with unfinalized prepared
|
||||
** statements, unclosed BLOB handlers, and/or unfinished sqlite3_backups,
|
||||
** it returns [SQLITE_OK] regardless, but instead of deallocating the database
|
||||
** connection immediately, it marks the database connection as an unusable
|
||||
** "zombie" and makes arrangements to automatically deallocate the database
|
||||
** connection after all prepared statements are finalized, all BLOB handles
|
||||
** are closed, and all backups have finished. The sqlite3_close_v2() interface
|
||||
** is intended for use with host languages that are garbage collected, and
|
||||
** where the order in which destructors are called is arbitrary.
|
||||
**
|
||||
** ^If an [sqlite3] object is destroyed while a transaction is open,
|
||||
** the transaction is automatically rolled back.
|
||||
@ -507,10 +503,12 @@ SQLITE_API int sqlite3_exec(
|
||||
#define SQLITE_IOERR_BEGIN_ATOMIC (SQLITE_IOERR | (29<<8))
|
||||
#define SQLITE_IOERR_COMMIT_ATOMIC (SQLITE_IOERR | (30<<8))
|
||||
#define SQLITE_IOERR_ROLLBACK_ATOMIC (SQLITE_IOERR | (31<<8))
|
||||
#define SQLITE_IOERR_DATA (SQLITE_IOERR | (32<<8))
|
||||
#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))
|
||||
#define SQLITE_LOCKED_VTAB (SQLITE_LOCKED | (2<<8))
|
||||
#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))
|
||||
#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8))
|
||||
#define SQLITE_BUSY_TIMEOUT (SQLITE_BUSY | (3<<8))
|
||||
#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))
|
||||
#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8))
|
||||
#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8))
|
||||
@ -519,6 +517,7 @@ SQLITE_API int sqlite3_exec(
|
||||
#define SQLITE_CANTOPEN_SYMLINK (SQLITE_CANTOPEN | (6<<8))
|
||||
#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8))
|
||||
#define SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT | (2<<8))
|
||||
#define SQLITE_CORRUPT_INDEX (SQLITE_CORRUPT | (3<<8))
|
||||
#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))
|
||||
#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8))
|
||||
#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8))
|
||||
@ -1087,10 +1086,12 @@ struct sqlite3_io_methods {
|
||||
** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE].
|
||||
**
|
||||
** <li>[[SQLITE_FCNTL_LOCK_TIMEOUT]]
|
||||
** The [SQLITE_FCNTL_LOCK_TIMEOUT] opcode causes attempts to obtain
|
||||
** a file lock using the xLock or xShmLock methods of the VFS to wait
|
||||
** for up to M milliseconds before failing, where M is the single
|
||||
** unsigned integer parameter.
|
||||
** The [SQLITE_FCNTL_LOCK_TIMEOUT] opcode is used to configure a VFS
|
||||
** to block for up to M milliseconds before failing when attempting to
|
||||
** obtain a file lock using the xLock or xShmLock methods of the VFS.
|
||||
** The parameter is a pointer to a 32-bit signed integer that contains
|
||||
** the value that M is to be set to. Before returning, the 32-bit signed
|
||||
** integer is overwritten with the previous value of M.
|
||||
**
|
||||
** <li>[[SQLITE_FCNTL_DATA_VERSION]]
|
||||
** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to
|
||||
@ -1112,6 +1113,11 @@ struct sqlite3_io_methods {
|
||||
** happen either internally or externally and that are associated with
|
||||
** a particular attached database.
|
||||
**
|
||||
** <li>[[SQLITE_FCNTL_CKPT_START]]
|
||||
** The [SQLITE_FCNTL_CKPT_START] opcode is invoked from within a checkpoint
|
||||
** in wal mode before the client starts to copy pages from the wal
|
||||
** file to the database file.
|
||||
**
|
||||
** <li>[[SQLITE_FCNTL_CKPT_DONE]]
|
||||
** The [SQLITE_FCNTL_CKPT_DONE] opcode is invoked from within a checkpoint
|
||||
** in wal mode after the client has finished copying pages from the wal
|
||||
@ -1155,6 +1161,8 @@ struct sqlite3_io_methods {
|
||||
#define SQLITE_FCNTL_DATA_VERSION 35
|
||||
#define SQLITE_FCNTL_SIZE_LIMIT 36
|
||||
#define SQLITE_FCNTL_CKPT_DONE 37
|
||||
#define SQLITE_FCNTL_RESERVE_BYTES 38
|
||||
#define SQLITE_FCNTL_CKPT_START 39
|
||||
|
||||
/* deprecated names */
|
||||
#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE
|
||||
@ -3533,8 +3541,19 @@ SQLITE_API int sqlite3_open_v2(
|
||||
** that check if a database file was a URI that contained a specific query
|
||||
** parameter, and if so obtains the value of that query parameter.
|
||||
**
|
||||
** If F is the database filename pointer passed into the xOpen() method of
|
||||
** a VFS implementation or it is the return value of [sqlite3_db_filename()]
|
||||
** The first parameter to these interfaces (hereafter referred to
|
||||
** as F) must be one of:
|
||||
** <ul>
|
||||
** <li> A database filename pointer created by the SQLite core and
|
||||
** passed into the xOpen() method of a VFS implemention, or
|
||||
** <li> A filename obtained from [sqlite3_db_filename()], or
|
||||
** <li> A new filename constructed using [sqlite3_create_filename()].
|
||||
** </ul>
|
||||
** If the F parameter is not one of the above, then the behavior is
|
||||
** undefined and probably undesirable. Older versions of SQLite were
|
||||
** more tolerant of invalid F parameters than newer versions.
|
||||
**
|
||||
** If F is a suitable filename (as described in the previous paragraph)
|
||||
** and if P is the name of the query parameter, then
|
||||
** sqlite3_uri_parameter(F,P) returns the value of the P
|
||||
** parameter if it exists or a NULL pointer if P does not appear as a
|
||||
@ -3617,6 +3636,78 @@ SQLITE_API const char *sqlite3_filename_database(const char*);
|
||||
SQLITE_API const char *sqlite3_filename_journal(const char*);
|
||||
SQLITE_API const char *sqlite3_filename_wal(const char*);
|
||||
|
||||
/*
|
||||
** CAPI3REF: Database File Corresponding To A Journal
|
||||
**
|
||||
** ^If X is the name of a rollback or WAL-mode journal file that is
|
||||
** passed into the xOpen method of [sqlite3_vfs], then
|
||||
** sqlite3_database_file_object(X) returns a pointer to the [sqlite3_file]
|
||||
** object that represents the main database file.
|
||||
**
|
||||
** This routine is intended for use in custom [VFS] implementations
|
||||
** only. It is not a general-purpose interface.
|
||||
** The argument sqlite3_file_object(X) must be a filename pointer that
|
||||
** has been passed into [sqlite3_vfs].xOpen method where the
|
||||
** flags parameter to xOpen contains one of the bits
|
||||
** [SQLITE_OPEN_MAIN_JOURNAL] or [SQLITE_OPEN_WAL]. Any other use
|
||||
** of this routine results in undefined and probably undesirable
|
||||
** behavior.
|
||||
*/
|
||||
SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*);
|
||||
|
||||
/*
|
||||
** CAPI3REF: Create and Destroy VFS Filenames
|
||||
**
|
||||
** These interfces are provided for use by [VFS shim] implementations and
|
||||
** are not useful outside of that context.
|
||||
**
|
||||
** The sqlite3_create_filename(D,J,W,N,P) allocates memory to hold a version of
|
||||
** database filename D with corresponding journal file J and WAL file W and
|
||||
** with N URI parameters key/values pairs in the array P. The result from
|
||||
** sqlite3_create_filename(D,J,W,N,P) is a pointer to a database filename that
|
||||
** is safe to pass to routines like:
|
||||
** <ul>
|
||||
** <li> [sqlite3_uri_parameter()],
|
||||
** <li> [sqlite3_uri_boolean()],
|
||||
** <li> [sqlite3_uri_int64()],
|
||||
** <li> [sqlite3_uri_key()],
|
||||
** <li> [sqlite3_filename_database()],
|
||||
** <li> [sqlite3_filename_journal()], or
|
||||
** <li> [sqlite3_filename_wal()].
|
||||
** </ul>
|
||||
** If a memory allocation error occurs, sqlite3_create_filename() might
|
||||
** return a NULL pointer. The memory obtained from sqlite3_create_filename(X)
|
||||
** must be released by a corresponding call to sqlite3_free_filename(Y).
|
||||
**
|
||||
** The P parameter in sqlite3_create_filename(D,J,W,N,P) should be an array
|
||||
** of 2*N pointers to strings. Each pair of pointers in this array corresponds
|
||||
** to a key and value for a query parameter. The P parameter may be a NULL
|
||||
** pointer if N is zero. None of the 2*N pointers in the P array may be
|
||||
** NULL pointers and key pointers should not be empty strings.
|
||||
** None of the D, J, or W parameters to sqlite3_create_filename(D,J,W,N,P) may
|
||||
** be NULL pointers, though they can be empty strings.
|
||||
**
|
||||
** The sqlite3_free_filename(Y) routine releases a memory allocation
|
||||
** previously obtained from sqlite3_create_filename(). Invoking
|
||||
** sqlite3_free_filename(Y) where Y is a NULL pointer is a harmless no-op.
|
||||
**
|
||||
** If the Y parameter to sqlite3_free_filename(Y) is anything other
|
||||
** than a NULL pointer or a pointer previously acquired from
|
||||
** sqlite3_create_filename(), then bad things such as heap
|
||||
** corruption or segfaults may occur. The value Y should be
|
||||
** used again after sqlite3_free_filename(Y) has been called. This means
|
||||
** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y,
|
||||
** then the corresponding [sqlite3_module.xClose() method should also be
|
||||
** invoked prior to calling sqlite3_free_filename(Y).
|
||||
*/
|
||||
SQLITE_API char *sqlite3_create_filename(
|
||||
const char *zDatabase,
|
||||
const char *zJournal,
|
||||
const char *zWal,
|
||||
int nParam,
|
||||
const char **azParam
|
||||
);
|
||||
SQLITE_API void sqlite3_free_filename(char*);
|
||||
|
||||
/*
|
||||
** CAPI3REF: Error Codes And Messages
|
||||
@ -4199,12 +4290,30 @@ typedef struct sqlite3_context sqlite3_context;
|
||||
** [sqlite3_bind_parameter_index()] API if desired. ^The index
|
||||
** for "?NNN" parameters is the value of NNN.
|
||||
** ^The NNN value must be between 1 and the [sqlite3_limit()]
|
||||
** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999).
|
||||
** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 32766).
|
||||
**
|
||||
** ^The third argument is the value to bind to the parameter.
|
||||
** ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16()
|
||||
** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter
|
||||
** is ignored and the end result is the same as sqlite3_bind_null().
|
||||
** ^If the third parameter to sqlite3_bind_text() is not NULL, then
|
||||
** it should be a pointer to well-formed UTF8 text.
|
||||
** ^If the third parameter to sqlite3_bind_text16() is not NULL, then
|
||||
** it should be a pointer to well-formed UTF16 text.
|
||||
** ^If the third parameter to sqlite3_bind_text64() is not NULL, then
|
||||
** it should be a pointer to a well-formed unicode string that is
|
||||
** either UTF8 if the sixth parameter is SQLITE_UTF8, or UTF16
|
||||
** otherwise.
|
||||
**
|
||||
** [[byte-order determination rules]] ^The byte-order of
|
||||
** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF)
|
||||
** found in first character, which is removed, or in the absence of a BOM
|
||||
** the byte order is the native byte order of the host
|
||||
** machine for sqlite3_bind_text16() or the byte order specified in
|
||||
** the 6th parameter for sqlite3_bind_text64().)^
|
||||
** ^If UTF16 input text contains invalid unicode
|
||||
** characters, then SQLite might change those invalid characters
|
||||
** into the unicode replacement character: U+FFFD.
|
||||
**
|
||||
** ^(In those routines that have a fourth argument, its value is the
|
||||
** number of bytes in the parameter. To be clear: the value is the
|
||||
@ -4218,7 +4327,7 @@ typedef struct sqlite3_context sqlite3_context;
|
||||
** or sqlite3_bind_text16() or sqlite3_bind_text64() then
|
||||
** that parameter must be the byte offset
|
||||
** where the NUL terminator would occur assuming the string were NUL
|
||||
** terminated. If any NUL characters occur at byte offsets less than
|
||||
** terminated. If any NUL characters occurs at byte offsets less than
|
||||
** the value of the fourth parameter then the resulting string value will
|
||||
** contain embedded NULs. The result of expressions involving strings
|
||||
** with embedded NULs is undefined.
|
||||
@ -5386,7 +5495,7 @@ SQLITE_API void sqlite3_value_free(sqlite3_value*);
|
||||
**
|
||||
** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is
|
||||
** determined by the N parameter on first successful call. Changing the
|
||||
** value of N in any subsequents call to sqlite3_aggregate_context() within
|
||||
** value of N in any subsequent call to sqlite3_aggregate_context() within
|
||||
** the same aggregate function instance will not resize the memory
|
||||
** allocation.)^ Within the xFinal callback, it is customary to set
|
||||
** N=0 in calls to sqlite3_aggregate_context(C,N) so that no
|
||||
@ -5543,8 +5652,9 @@ typedef void (*sqlite3_destructor_type)(void*);
|
||||
** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16()
|
||||
** as the text of an error message. ^SQLite interprets the error
|
||||
** message string from sqlite3_result_error() as UTF-8. ^SQLite
|
||||
** interprets the string from sqlite3_result_error16() as UTF-16 in native
|
||||
** byte order. ^If the third parameter to sqlite3_result_error()
|
||||
** interprets the string from sqlite3_result_error16() as UTF-16 using
|
||||
** the same [byte-order determination rules] as [sqlite3_bind_text16()].
|
||||
** ^If the third parameter to sqlite3_result_error()
|
||||
** or sqlite3_result_error16() is negative then SQLite takes as the error
|
||||
** message all text up through the first zero character.
|
||||
** ^If the third parameter to sqlite3_result_error() or
|
||||
@ -5612,6 +5722,25 @@ typedef void (*sqlite3_destructor_type)(void*);
|
||||
** then SQLite makes a copy of the result into space obtained
|
||||
** from [sqlite3_malloc()] before it returns.
|
||||
**
|
||||
** ^For the sqlite3_result_text16(), sqlite3_result_text16le(), and
|
||||
** sqlite3_result_text16be() routines, and for sqlite3_result_text64()
|
||||
** when the encoding is not UTF8, if the input UTF16 begins with a
|
||||
** byte-order mark (BOM, U+FEFF) then the BOM is removed from the
|
||||
** string and the rest of the string is interpreted according to the
|
||||
** byte-order specified by the BOM. ^The byte-order specified by
|
||||
** the BOM at the beginning of the text overrides the byte-order
|
||||
** specified by the interface procedure. ^So, for example, if
|
||||
** sqlite3_result_text16le() is invoked with text that begins
|
||||
** with bytes 0xfe, 0xff (a big-endian byte-order mark) then the
|
||||
** first two bytes of input are skipped and the remaining input
|
||||
** is interpreted as UTF16BE text.
|
||||
**
|
||||
** ^For UTF16 input text to the sqlite3_result_text16(),
|
||||
** sqlite3_result_text16be(), sqlite3_result_text16le(), and
|
||||
** sqlite3_result_text64() routines, if the text contains invalid
|
||||
** UTF16 characters, the invalid characters might be converted
|
||||
** into the unicode replacement character, U+FFFD.
|
||||
**
|
||||
** ^The sqlite3_result_value() interface sets the result of
|
||||
** the application-defined function to be a copy of the
|
||||
** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The
|
||||
@ -5817,51 +5946,6 @@ SQLITE_API int sqlite3_collation_needed16(
|
||||
void(*)(void*,sqlite3*,int eTextRep,const void*)
|
||||
);
|
||||
|
||||
#ifdef SQLITE_HAS_CODEC
|
||||
/*
|
||||
** Specify the key for an encrypted database. This routine should be
|
||||
** called right after sqlite3_open().
|
||||
**
|
||||
** The code to implement this API is not available in the public release
|
||||
** of SQLite.
|
||||
*/
|
||||
SQLITE_API int sqlite3_key(
|
||||
sqlite3 *db, /* Database to be rekeyed */
|
||||
const void *pKey, int nKey /* The key */
|
||||
);
|
||||
SQLITE_API int sqlite3_key_v2(
|
||||
sqlite3 *db, /* Database to be rekeyed */
|
||||
const char *zDbName, /* Name of the database */
|
||||
const void *pKey, int nKey /* The key */
|
||||
);
|
||||
|
||||
/*
|
||||
** Change the key on an open database. If the current database is not
|
||||
** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
|
||||
** database is decrypted.
|
||||
**
|
||||
** The code to implement this API is not available in the public release
|
||||
** of SQLite.
|
||||
*/
|
||||
SQLITE_API int sqlite3_rekey(
|
||||
sqlite3 *db, /* Database to be rekeyed */
|
||||
const void *pKey, int nKey /* The new key */
|
||||
);
|
||||
SQLITE_API int sqlite3_rekey_v2(
|
||||
sqlite3 *db, /* Database to be rekeyed */
|
||||
const char *zDbName, /* Name of the database */
|
||||
const void *pKey, int nKey /* The new key */
|
||||
);
|
||||
|
||||
/*
|
||||
** Specify the activation key for a SEE database. Unless
|
||||
** activated, none of the SEE routines will work.
|
||||
*/
|
||||
SQLITE_API void sqlite3_activate_see(
|
||||
const char *zPassPhrase /* Activation phrase */
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifdef SQLITE_ENABLE_CEROD
|
||||
/*
|
||||
** Specify the activation key for a CEROD database. Unless
|
||||
@ -7604,7 +7688,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
|
||||
#define SQLITE_TESTCTRL_PENDING_BYTE 11
|
||||
#define SQLITE_TESTCTRL_ASSERT 12
|
||||
#define SQLITE_TESTCTRL_ALWAYS 13
|
||||
#define SQLITE_TESTCTRL_RESERVE 14
|
||||
#define SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */
|
||||
#define SQLITE_TESTCTRL_OPTIMIZATIONS 15
|
||||
#define SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */
|
||||
#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */
|
||||
|
@ -1245,6 +1245,9 @@ QString QIcon::fallbackThemeName()
|
||||
themeSearchPath() containing an index.theme
|
||||
file describing its contents.
|
||||
|
||||
\note This should be done before creating \l QGuiApplication, to ensure
|
||||
correct initialization.
|
||||
|
||||
\sa fallbackThemeName(), themeSearchPaths(), themeName()
|
||||
*/
|
||||
void QIcon::setFallbackThemeName(const QString &name)
|
||||
|
@ -112,10 +112,9 @@ extern QFactoryLoader *qt_iconEngineFactoryLoader(); // qicon.cpp
|
||||
void QIconLoader::ensureInitialized()
|
||||
{
|
||||
if (!m_initialized) {
|
||||
if (!QGuiApplicationPrivate::platformTheme())
|
||||
return; // it's too early: try again later (QTBUG-74252)
|
||||
m_initialized = true;
|
||||
|
||||
Q_ASSERT(qApp);
|
||||
|
||||
m_systemTheme = systemThemeName();
|
||||
|
||||
if (m_systemTheme.isEmpty())
|
||||
@ -125,6 +124,16 @@ void QIconLoader::ensureInitialized()
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
\internal
|
||||
Gets an instance.
|
||||
|
||||
\l QIcon::setFallbackThemeName() should be called before QGuiApplication is
|
||||
created, to avoid a race condition (QTBUG-74252). When this function is
|
||||
called from there, ensureInitialized() does not succeed because there
|
||||
is no QPlatformTheme yet, so systemThemeName() is empty, and we don't want
|
||||
m_systemTheme to get intialized to the fallback theme instead of the normal one.
|
||||
*/
|
||||
QIconLoader *QIconLoader::instance()
|
||||
{
|
||||
iconLoaderInstance()->ensureInitialized();
|
||||
|
@ -139,6 +139,9 @@ void QVncScreen::enableClientCursor(QVncClient *client)
|
||||
void QVncScreen::disableClientCursor(QVncClient *client)
|
||||
{
|
||||
#if QT_CONFIG(cursor)
|
||||
if (!clientCursor)
|
||||
return;
|
||||
|
||||
uint clientCount = clientCursor->removeClient(client);
|
||||
if (clientCount == 0) {
|
||||
delete clientCursor;
|
||||
|
Loading…
x
Reference in New Issue
Block a user