Merge pull request #1486 from pi-hole/development

FTL v5.19.2
2024-10-26 16:52:18 +02:00 · 2022-11-17 12:52:14 +00:00
parent b48b3e1fb2 f4c9460f21
commit 844c8b9fda
8 changed files with 7606 additions and 2859 deletions
@@ -11,6 +11,6 @@
 cmake_minimum_required(VERSION 2.8.12)
 project(PIHOLE_FTL C)

-set(DNSMASQ_VERSION pi-hole-v2.88test3)
+set(DNSMASQ_VERSION pi-hole-v2.88rc1)

 add_subdirectory(src)
@@ -150,7 +150,7 @@ bool flush_message_table(void)
 	return true;
 }

-static bool add_message(const enum message_type type, const bool unique,
+static bool add_message(const enum message_type type,
                        const char *message, const int count,...)
 {
 	bool okay = false;
@@ -166,55 +166,52 @@ static bool add_message(const enum message_type type, const bool unique,
 		return false;
 	}

-	// Ensure there are no duplicates when adding host name or rate-limiting messages
-	if(unique)
-	{
-		sqlite3_stmt* stmt = NULL;
-		const char *querystr = "DELETE FROM message WHERE type = ?1 AND message = ?2";
-		int rc = sqlite3_prepare_v2(db, querystr, -1, &stmt, NULL);
-		if( rc != SQLITE_OK ){
-			logg("add_message(type=%u, message=%s) - SQL error prepare DELETE: %s",
-			     type, message, sqlite3_errstr(rc));
-			goto end_of_add_message;
-		}
-
-		// Bind type to prepared statement
-		if((rc = sqlite3_bind_text(stmt, 1, message_types[type], -1, SQLITE_STATIC)) != SQLITE_OK)
-		{
-			logg("add_message(type=%u, message=%s) - Failed to bind type DELETE: %s",
-			     type, message, sqlite3_errstr(rc));
-			sqlite3_reset(stmt);
-			sqlite3_finalize(stmt);
-			goto end_of_add_message;
-		}
-
-		// Bind message to prepared statement
-		if((rc = sqlite3_bind_text(stmt, 2, message, -1, SQLITE_STATIC)) != SQLITE_OK)
-		{
-			logg("add_message(type=%u, message=%s) - Failed to bind message DELETE: %s",
-			     type, message, sqlite3_errstr(rc));
-			sqlite3_reset(stmt);
-			sqlite3_finalize(stmt);
-			goto end_of_add_message;
-		}
-
-		// Execute and finalize
-		if((rc = sqlite3_step(stmt)) != SQLITE_OK && rc != SQLITE_DONE)
-		{
-			logg("add_message(type=%u, message=%s) - SQL error step DELETE: %s",
-			     type, message, sqlite3_errstr(rc));
-			goto end_of_add_message;
-		}
-		sqlite3_clear_bindings(stmt);
-		sqlite3_reset(stmt);
-		sqlite3_finalize(stmt);
+	// Ensure there are no duplicates when adding messages
+	sqlite3_stmt* stmt = NULL;
+	const char *querystr = "DELETE FROM message WHERE type = ?1 AND message = ?2";
+	int rc = sqlite3_prepare_v2(db, querystr, -1, &stmt, NULL);
+	if( rc != SQLITE_OK ){
+		logg("add_message(type=%u, message=%s) - SQL error prepare DELETE: %s",
+			type, message, sqlite3_errstr(rc));
+		goto end_of_add_message;
 	}

+	// Bind type to prepared statement
+	if((rc = sqlite3_bind_text(stmt, 1, message_types[type], -1, SQLITE_STATIC)) != SQLITE_OK)
+	{
+		logg("add_message(type=%u, message=%s) - Failed to bind type DELETE: %s",
+			type, message, sqlite3_errstr(rc));
+		sqlite3_reset(stmt);
+		sqlite3_finalize(stmt);
+		goto end_of_add_message;
+	}
+
+	// Bind message to prepared statement
+	if((rc = sqlite3_bind_text(stmt, 2, message, -1, SQLITE_STATIC)) != SQLITE_OK)
+	{
+		logg("add_message(type=%u, message=%s) - Failed to bind message DELETE: %s",
+			type, message, sqlite3_errstr(rc));
+		sqlite3_reset(stmt);
+		sqlite3_finalize(stmt);
+		goto end_of_add_message;
+	}
+
+	// Execute and finalize
+	if((rc = sqlite3_step(stmt)) != SQLITE_OK && rc != SQLITE_DONE)
+	{
+		logg("add_message(type=%u, message=%s) - SQL error step DELETE: %s",
+			type, message, sqlite3_errstr(rc));
+		goto end_of_add_message;
+	}
+	sqlite3_clear_bindings(stmt);
+	sqlite3_reset(stmt);
+	sqlite3_finalize(stmt);
+	stmt = NULL;
+
 	// Prepare SQLite statement
-	sqlite3_stmt* stmt = NULL;
-	const char *querystr = "INSERT INTO message (timestamp,type,message,blob1,blob2,blob3,blob4,blob5) "
-	                       "VALUES ((cast(strftime('%s', 'now') as int)),?,?,?,?,?,?,?);";
-	int rc = sqlite3_prepare_v2(db, querystr, -1, &stmt, NULL);
+	querystr = "INSERT INTO message (timestamp,type,message,blob1,blob2,blob3,blob4,blob5) "
+	           "VALUES ((cast(strftime('%s', 'now') as int)),?,?,?,?,?,?,?);";
+	rc = sqlite3_prepare_v2(db, querystr, -1, &stmt, NULL);
 	if( rc != SQLITE_OK )
 	{
 		logg("add_message(type=%u, message=%s) - SQL error prepare: %s",
@@ -317,7 +314,7 @@ void logg_regex_warning(const char *type, const char *warning, const int dbindex

 	// Log to database only if not in CLI mode
 	if(!cli_mode)
-		add_message(REGEX_MESSAGE, false, warning, 3, type, regex, dbindex);
+		add_message(REGEX_MESSAGE, warning, 3, type, regex, dbindex);
 }

 void logg_subnet_warning(const char *ip, const int matching_count, const char *matching_ids,
@@ -332,7 +329,7 @@ void logg_subnet_warning(const char *ip, const int matching_count, const char *m

 	// Log to database
 	char *names = get_client_names_from_ids(matching_ids);
-	add_message(SUBNET_MESSAGE, false, ip, 5, matching_count, names, matching_ids, chosen_match_text, chosen_match_id);
+	add_message(SUBNET_MESSAGE, ip, 5, matching_count, names, matching_ids, chosen_match_text, chosen_match_id);
 	free(names);
 }

@@ -343,7 +340,7 @@ void logg_hostname_warning(const char *ip, const char *name, const unsigned int
 	     ip, name, pos);

 	// Log to database
-	add_message(HOSTNAME_MESSAGE, true, ip, 2, name, (const int)pos);
+	add_message(HOSTNAME_MESSAGE, ip, 2, name, (const int)pos);
 }

 void logg_fatal_dnsmasq_message(const char *message)
@@ -352,7 +349,7 @@ void logg_fatal_dnsmasq_message(const char *message)
 	logg("FATAL ERROR in dnsmasq core: %s", message);

 	// Log to database
-	add_message(DNSMASQ_CONFIG_MESSAGE, false, message, 0);
+	add_message(DNSMASQ_CONFIG_MESSAGE, message, 0);

 	// FTL will dies after this point, so we should make sure to clean up
 	// behind ourselves
@@ -368,7 +365,7 @@ void logg_rate_limit_message(const char *clientIP, const unsigned int rate_limit
 	     clientIP, turnaround, turnaround == 1 ? "" : "s");

 	// Log to database
-	add_message(RATE_LIMIT_MESSAGE, true, clientIP, 2, config.rate_limit.count, config.rate_limit.interval);
+	add_message(RATE_LIMIT_MESSAGE, clientIP, 2, config.rate_limit.count, config.rate_limit.interval);
 }

 void logg_warn_dnsmasq_message(char *message)
@@ -377,7 +374,7 @@ void logg_warn_dnsmasq_message(char *message)
 	logg("WARNING in dnsmasq core: %s", message);

 	// Log to database
-	add_message(DNSMASQ_WARN_MESSAGE, false, message, 0);
+	add_message(DNSMASQ_WARN_MESSAGE, message, 0);
 }

 void log_resource_shortage(const double load, const int nprocs, const int shmem, const int disk, const char *path, const char *msg)
@@ -385,25 +382,25 @@ void log_resource_shortage(const double load, const int nprocs, const int shmem,
 	if(load > 0.0)
 	{
 		logg("WARNING: Long-term load (15min avg) larger than number of processors: %.1f > %d", load, nprocs);
-		add_message(LOAD_MESSAGE, true, "excessive load", 2, load, nprocs);
+		add_message(LOAD_MESSAGE, "excessive load", 2, load, nprocs);
 	}
 	else if(shmem > -1)
 	{
 		logg("WARNING: RAM shortage (%s) ahead: %d%% is used (%s)", path, shmem, msg);
-		add_message(SHMEM_MESSAGE, true, path, 2, shmem, msg);
+		add_message(SHMEM_MESSAGE, path, 2, shmem, msg);
 	}
 	else if(disk > -1)
 	{
 		logg("WARNING: Disk shortage (%s) ahead: %d%% is used (%s)", path, disk, msg);
-		add_message(DISK_MESSAGE, true, path, 2, disk, msg);
+		add_message(DISK_MESSAGE, path, 2, disk, msg);
 	}
 }

 void logg_inaccessible_adlist(const int dbindex, const char *address)
 {
 	// Log to FTL.log
-	logg("Adlist warning: Adlist with ID %d (%s) was inaccessible during last gravity run", dbindex, address);
+	logg("ADLIST WARNING: Adlist with ID %d (%s) was inaccessible during last gravity run", dbindex, address);

 	// Log to database
-	add_message(INACCESSIBLE_ADLIST_MESSAGE, false, address, 1, dbindex);
+	add_message(INACCESSIBLE_ADLIST_MESSAGE, address, 1, dbindex);
 }
@@ -146,9 +146,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.39.2"
-#define SQLITE_VERSION_NUMBER 3039002
-#define SQLITE_SOURCE_ID      "2022-07-21 15:24:47 698edb77537b67c41adc68f9b892db56bcf9a55e00371a61420f3ddd668e6603"
+#define SQLITE_VERSION        "3.40.0"
+#define SQLITE_VERSION_NUMBER 3040000
+#define SQLITE_SOURCE_ID      "2022-11-16 12:10:08 89c459e766ea7e9165d0beeb124708b955a4950d0f4792f457465d71b158d318"

 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -670,13 +670,17 @@ SQLITE_API int sqlite3_exec(
 **
 ** SQLite uses one of these integer values as the second
 ** argument to calls it makes to the xLock() and xUnlock() methods
-** of an [sqlite3_io_methods] object.
+** of an [sqlite3_io_methods] object.  These values are ordered from
+** lest restrictive to most restrictive.
+**
+** The argument to xLock() is always SHARED or higher.  The argument to
+** xUnlock is either SHARED or NONE.
 */
-#define SQLITE_LOCK_NONE          0
-#define SQLITE_LOCK_SHARED        1
-#define SQLITE_LOCK_RESERVED      2
-#define SQLITE_LOCK_PENDING       3
-#define SQLITE_LOCK_EXCLUSIVE     4
+#define SQLITE_LOCK_NONE          0       /* xUnlock() only */
+#define SQLITE_LOCK_SHARED        1       /* xLock() or xUnlock() */
+#define SQLITE_LOCK_RESERVED      2       /* xLock() only */
+#define SQLITE_LOCK_PENDING       3       /* xLock() only */
+#define SQLITE_LOCK_EXCLUSIVE     4       /* xLock() only */

 /*
 ** CAPI3REF: Synchronization Type Flags
@@ -754,7 +758,14 @@ struct sqlite3_file {
 ** <li> [SQLITE_LOCK_PENDING], or
 ** <li> [SQLITE_LOCK_EXCLUSIVE].
 ** </ul>
-** xLock() increases the lock. xUnlock() decreases the lock.
+** xLock() upgrades the database file lock.  In other words, xLock() moves the
+** database file lock in the direction NONE toward EXCLUSIVE. The argument to
+** xLock() is always on of SHARED, RESERVED, PENDING, or EXCLUSIVE, never
+** SQLITE_LOCK_NONE.  If the database file lock is already at or above the
+** requested lock, then the call to xLock() is a no-op.
+** xUnlock() downgrades the database file lock to either SHARED or NONE.
+*  If the lock is already at or below the requested lock state, then the call
+** to xUnlock() is a no-op.
 ** The xCheckReservedLock() method checks whether any database connection,
 ** either in this process or in some other process, is holding a RESERVED,
 ** PENDING, or EXCLUSIVE lock on the file.  It returns true
@@ -859,9 +870,8 @@ struct sqlite3_io_methods {
 ** opcode causes the xFileControl method to write the current state of
 ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
 ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
-** into an integer that the pArg argument points to. This capability
-** is used during testing and is only available when the SQLITE_TEST
-** compile-time option is used.
+** into an integer that the pArg argument points to.
+** This capability is only available if SQLite is compiled with [SQLITE_DEBUG].
 **
 ** <li>[[SQLITE_FCNTL_SIZE_HINT]]
 ** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
@@ -1253,6 +1263,26 @@ typedef struct sqlite3_mutex sqlite3_mutex;
 */
 typedef struct sqlite3_api_routines sqlite3_api_routines;

+/*
+** CAPI3REF: File Name
+**
+** Type [sqlite3_filename] is used by SQLite to pass filenames to the
+** xOpen method of a [VFS]. It may be cast to (const char*) and treated
+** as a normal, nul-terminated, UTF-8 buffer containing the filename, but
+** may also be passed to special APIs such as:
+**
+** <ul>
+** <li>  sqlite3_filename_database()
+** <li>  sqlite3_filename_journal()
+** <li>  sqlite3_filename_wal()
+** <li>  sqlite3_uri_parameter()
+** <li>  sqlite3_uri_boolean()
+** <li>  sqlite3_uri_int64()
+** <li>  sqlite3_uri_key()
+** </ul>
+*/
+typedef const char *sqlite3_filename;
+
 /*
 ** CAPI3REF: OS Interface Object
 **
@@ -1431,7 +1461,7 @@ struct sqlite3_vfs {
  sqlite3_vfs *pNext;      /* Next registered VFS */
  const char *zName;       /* Name of this virtual file system */
  void *pAppData;          /* Pointer to application-specific data */
-  int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
+  int (*xOpen)(sqlite3_vfs*, sqlite3_filename zName, sqlite3_file*,
               int flags, int *pOutFlags);
  int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
  int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
@@ -2309,6 +2339,7 @@ struct sqlite3_mem_methods {
 ** <ul>
 ** <li> The [PRAGMA writable_schema=ON] statement.
 ** <li> The [PRAGMA journal_mode=OFF] statement.
+** <li> The [PRAGMA schema_version=N] statement.
 ** <li> Writes to the [sqlite_dbpage] virtual table.
 ** <li> Direct writes to [shadow tables].
 ** </ul>
@@ -3424,6 +3455,9 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 ** <dd>The database is opened [shared cache] enabled, overriding
 ** the default shared cache setting provided by
 ** [sqlite3_enable_shared_cache()].)^
+** The [use of shared cache mode is discouraged] and hence shared cache
+** capabilities may be omitted from many builds of SQLite.  In such cases,
+** this option is a no-op.
 **
 ** ^(<dt>[SQLITE_OPEN_PRIVATECACHE]</dt>
 ** <dd>The database is opened [shared cache] disabled, overriding
@@ -3439,7 +3473,7 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 ** to return an extended result code.</dd>
 **
 ** [[OPEN_NOFOLLOW]] ^(<dt>[SQLITE_OPEN_NOFOLLOW]</dt>
-** <dd>The database filename is not allowed to be a symbolic link</dd>
+** <dd>The database filename is not allowed to contain a symbolic link</dd>
 ** </dl>)^
 **
 ** If the 3rd parameter to sqlite3_open_v2() is not one of the
@@ -3698,10 +3732,10 @@ SQLITE_API int sqlite3_open_v2(
 **
 ** See the [URI filename] documentation for additional information.
 */
-SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
-SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
-SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
-SQLITE_API const char *sqlite3_uri_key(const char *zFilename, int N);
+SQLITE_API const char *sqlite3_uri_parameter(sqlite3_filename z, const char *zParam);
+SQLITE_API int sqlite3_uri_boolean(sqlite3_filename z, const char *zParam, int bDefault);
+SQLITE_API sqlite3_int64 sqlite3_uri_int64(sqlite3_filename, const char*, sqlite3_int64);
+SQLITE_API const char *sqlite3_uri_key(sqlite3_filename z, int N);

 /*
 ** CAPI3REF:  Translate filenames
@@ -3730,9 +3764,9 @@ SQLITE_API const char *sqlite3_uri_key(const char *zFilename, int N);
 ** return value from [sqlite3_db_filename()], then the result is
 ** undefined and is likely a memory access violation.
 */
-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*);
+SQLITE_API const char *sqlite3_filename_database(sqlite3_filename);
+SQLITE_API const char *sqlite3_filename_journal(sqlite3_filename);
+SQLITE_API const char *sqlite3_filename_wal(sqlite3_filename);

 /*
 ** CAPI3REF:  Database File Corresponding To A Journal
@@ -3798,14 +3832,14 @@ SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*);
 ** then the corresponding [sqlite3_module.xClose() method should also be
 ** invoked prior to calling sqlite3_free_filename(Y).
 */
-SQLITE_API char *sqlite3_create_filename(
+SQLITE_API sqlite3_filename sqlite3_create_filename(
  const char *zDatabase,
  const char *zJournal,
  const char *zWal,
  int nParam,
  const char **azParam
 );
-SQLITE_API void sqlite3_free_filename(char*);
+SQLITE_API void sqlite3_free_filename(sqlite3_filename);

 /*
 ** CAPI3REF: Error Codes And Messages
@@ -5508,6 +5542,16 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 ** then the conversion is performed.  Otherwise no conversion occurs.
 ** The [SQLITE_INTEGER | datatype] after conversion is returned.)^
 **
+** ^(The sqlite3_value_encoding(X) interface returns one of [SQLITE_UTF8],
+** [SQLITE_UTF16BE], or [SQLITE_UTF16LE] according to the current encoding
+** of the value X, assuming that X has type TEXT.)^  If sqlite3_value_type(X)
+** returns something other than SQLITE_TEXT, then the return value from
+** sqlite3_value_encoding(X) is meaningless.  ^Calls to
+** sqlite3_value_text(X), sqlite3_value_text16(X), sqlite3_value_text16be(X),
+** sqlite3_value_text16le(X), sqlite3_value_bytes(X), or
+** sqlite3_value_bytes16(X) might change the encoding of the value X and
+** thus change the return from subsequent calls to sqlite3_value_encoding(X).
+**
 ** ^Within the [xUpdate] method of a [virtual table], the
 ** sqlite3_value_nochange(X) interface returns true if and only if
 ** the column corresponding to X is unchanged by the UPDATE operation
@@ -5572,6 +5616,7 @@ SQLITE_API int sqlite3_value_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_nochange(sqlite3_value*);
 SQLITE_API int sqlite3_value_frombind(sqlite3_value*);
+SQLITE_API int sqlite3_value_encoding(sqlite3_value*);

 /*
 ** CAPI3REF: Finding The Subtype Of SQL Values
@@ -5625,7 +5670,7 @@ SQLITE_API void sqlite3_value_free(sqlite3_value*);
 **
 ** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer
 ** when first called if N is less than or equal to zero or if a memory
-** allocate error occurs.
+** allocation error occurs.
 **
 ** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is
 ** determined by the N parameter on first successful call.  Changing the
@@ -5830,9 +5875,10 @@ typedef void (*sqlite3_destructor_type)(void*);
 ** of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE].
 ** ^SQLite takes the text result from the application from
 ** the 2nd parameter of the sqlite3_result_text* interfaces.
-** ^If the 3rd parameter to the sqlite3_result_text* interfaces
-** is negative, then SQLite takes result text from the 2nd parameter
-** through the first zero character.
+** ^If the 3rd parameter to any of the sqlite3_result_text* interfaces
+** other than sqlite3_result_text64() is negative, then SQLite computes
+** the string length itself by searching the 2nd parameter for the first
+** zero character.
 ** ^If the 3rd parameter to the sqlite3_result_text* interfaces
 ** is non-negative, then as many bytes (not characters) of the text
 ** pointed to by the 2nd parameter are taken as the application-defined
@@ -6328,7 +6374,7 @@ SQLITE_API const char *sqlite3_db_name(sqlite3 *db, int N);
 ** <li> [sqlite3_filename_wal()]
 ** </ul>
 */
-SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);
+SQLITE_API sqlite3_filename sqlite3_db_filename(sqlite3 *db, const char *zDbName);

 /*
 ** CAPI3REF: Determine if a database is read-only
@@ -6465,7 +6511,7 @@ SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
 ** function C that is invoked prior to each autovacuum of the database
 ** file.  ^The callback is passed a copy of the generic data pointer (P),
 ** the schema-name of the attached database that is being autovacuumed,
-** the the size of the database file in pages, the number of free pages,
+** the size of the database file in pages, the number of free pages,
 ** and the number of bytes per page, respectively.  The callback should
 ** return the number of free pages that should be removed by the
 ** autovacuum.  ^If the callback returns zero, then no autovacuum happens.
@@ -6586,6 +6632,11 @@ SQLITE_API void *sqlite3_update_hook(
 ** to the same database. Sharing is enabled if the argument is true
 ** and disabled if the argument is false.)^
 **
+** This interface is omitted if SQLite is compiled with
+** [-DSQLITE_OMIT_SHARED_CACHE].  The [-DSQLITE_OMIT_SHARED_CACHE]
+** compile-time option is recommended because the
+** [use of shared cache mode is discouraged].
+**
 ** ^Cache sharing is enabled and disabled for an entire process.
 ** This is a change as of SQLite [version 3.5.0] ([dateof:3.5.0]).
 ** In prior versions of SQLite,
@@ -6684,7 +6735,7 @@ SQLITE_API int sqlite3_db_release_memory(sqlite3*);
 ** ^The soft heap limit may not be greater than the hard heap limit.
 ** ^If the hard heap limit is enabled and if sqlite3_soft_heap_limit(N)
 ** is invoked with a value of N that is greater than the hard heap limit,
-** the the soft heap limit is set to the value of the hard heap limit.
+** the soft heap limit is set to the value of the hard heap limit.
 ** ^The soft heap limit is automatically enabled whenever the hard heap
 ** limit is enabled. ^When sqlite3_hard_heap_limit64(N) is invoked and
 ** the soft heap limit is outside the range of 1..N, then the soft heap
@@ -8979,7 +9030,7 @@ typedef struct sqlite3_backup sqlite3_backup;
 ** if the application incorrectly accesses the destination [database connection]
 ** and so no error code is reported, but the operations may malfunction
 ** nevertheless.  Use of the destination database connection while a
-** backup is in progress might also also cause a mutex deadlock.
+** backup is in progress might also cause a mutex deadlock.
 **
 ** If running in [shared cache mode], the application must
 ** guarantee that the shared cache used by the destination database
@@ -9407,7 +9458,7 @@ SQLITE_API int sqlite3_wal_checkpoint_v2(
 */
 #define SQLITE_CHECKPOINT_PASSIVE  0  /* Do as much as possible w/o blocking */
 #define SQLITE_CHECKPOINT_FULL     1  /* Wait for writers, then checkpoint */
-#define SQLITE_CHECKPOINT_RESTART  2  /* Like FULL but wait for for readers */
+#define SQLITE_CHECKPOINT_RESTART  2  /* Like FULL but wait for readers */
 #define SQLITE_CHECKPOINT_TRUNCATE 3  /* Like RESTART but also truncate WAL */

 /*
@@ -12833,4 +12884,4 @@ struct fts5_api {

 #endif /* _FTS5_H */

-/******** End of fts5.h *********/
+/******** End of fts5.h *********/
@@ -309,14 +309,14 @@ static int dnsmasq_gostdsa_verify(struct blockdata *key_data, unsigned int key_l
      mpz_init(y);
    }
    
-  mpz_import(x, 32 , 1, 1, 0, 0, p);
-  mpz_import(y, 32 , 1, 1, 0, 0, p + 32);
+  mpz_import(x, 32, -1, 1, 0, 0, p);
+  mpz_import(y, 32, -1, 1, 0, 0, p + 32);

  if (!ecc_point_set(gost_key, x, y))
-    return 0;
+    return 0; 
  
-  mpz_import(sig_struct->r, 32, 1, 1, 0, 0, sig);
-  mpz_import(sig_struct->s, 32, 1, 1, 0, 0, sig + 32);
+  mpz_import(sig_struct->s, 32, 1, 1, 0, 0, sig);
+  mpz_import(sig_struct->r, 32, 1, 1, 0, 0, sig + 32);
  
  return nettle_gostdsa_verify(gost_key, digest_len, digest, sig_struct);
 }
@@ -390,7 +390,12 @@ static int (*verify_func(int algo))(struct blockdata *key_data, unsigned int key
      return dnsmasq_ecdsa_verify;
      
 #if MIN_VERSION(3, 1)
-    case 15: case 16:
+    case 15:
+      return dnsmasq_eddsa_verify;
+#endif
+
+#if MIN_VERSION(3, 6)
+    case 16:
      return dnsmasq_eddsa_verify;
 #endif
    }
@@ -425,7 +430,9 @@ char *ds_digest_name(int digest)
    {
    case 1: return "sha1";
    case 2: return "sha256";
-    case 3: return "gosthash94";
+#if MIN_VERSION(3, 6)
+    case 3: return "gosthash94cp";
+#endif
    case 4: return "sha384";
    default: return NULL;
    }
@@ -444,11 +451,17 @@ char *algo_digest_name(int algo)
    case 7: return "sha1";        /* RSASHA1-NSEC3-SHA1 */
    case 8: return "sha256";      /* RSA/SHA-256 */
    case 10: return "sha512";     /* RSA/SHA-512 */
-    case 12: return "gosthash94"; /* ECC-GOST */
+#if MIN_VERSION(3, 6)
+    case 12: return "gosthash94cp"; /* ECC-GOST */ 
+#endif
    case 13: return "sha256";     /* ECDSAP256SHA256 */
    case 14: return "sha384";     /* ECDSAP384SHA384 */ 	
+#if MIN_VERSION(3, 1)
    case 15: return "null_hash";  /* ED25519 */
+#  if MIN_VERSION(3, 6)
    case 16: return "null_hash";  /* ED448 */
+#  endif
+#endif
    default: return NULL;
    }
 }
@@ -979,10 +979,13 @@ int dnssec_validate_by_ds(time_t now, struct dns_header *header, size_t plen, ch
 }

 /* The DNS packet is expected to contain the answer to a DS query
-   Put all DSs in the answer which are valid into the cache.
+   Put all DSs in the answer which are valid and have hash and signature algos
+   we support into the cache.
   Also handles replies which prove that there's no DS at this location, 
   either because the zone is unsigned or this isn't a zone cut. These are
   cached too.
+   If none of the DS's are for supported algos, treat the answer as if 
+   it's a proof of no DS at this location. RFC4035 para 5.2.
   return codes:
   STAT_OK          At least one valid DS found and in cache.
   STAT_BOGUS       no DS in reply or not signed, fails validation, bad packet.
@@ -993,8 +996,8 @@ int dnssec_validate_by_ds(time_t now, struct dns_header *header, size_t plen, ch
 int dnssec_validate_ds(time_t now, struct dns_header *header, size_t plen, char *name, char *keyname, int class)
 {
  unsigned char *p = (unsigned char *)(header+1);
-  int qtype, qclass, rc, i, neganswer, nons, neg_ttl = 0;
-  int aclass, atype, rdlen;
+  int qtype, qclass, rc, i, neganswer, nons, neg_ttl = 0, found_supported = 0;
+  int aclass, atype, rdlen, flags;
  unsigned long ttl;
  union all_addr a;

@@ -1065,14 +1068,22 @@ int dnssec_validate_ds(time_t now, struct dns_header *header, size_t plen, char
 	      algo = *p++;
 	      digest = *p++;
 	      
-	      if ((key = blockdata_alloc((char*)p, rdlen - 4)))
+	      if (!ds_digest_name(digest) || !ds_digest_name(digest))
+		{
+		  a.log.keytag = keytag;
+		  a.log.algo = algo;
+		  a.log.digest = digest;
+		  log_query(F_NOEXTRA | F_KEYTAG | F_UPSTREAM, name, &a, "DS keytag %hu, algo %hu, digest %hu (not supported)", 0);
+		  neg_ttl = ttl;
+		} 
+	      else if ((key = blockdata_alloc((char*)p, rdlen - 4)))
 		{
 		  a.ds.digest = digest;
 		  a.ds.keydata = key;
 		  a.ds.algo = algo;
 		  a.ds.keytag = keytag;
 		  a.ds.keylen = rdlen - 4;
-
+		  
 		  if (!cache_insert(name, &a, class, now, ttl, F_FORWARD | F_DS | F_DNSSECOK))
 		    {
 		      blockdata_free(key);
@@ -1083,26 +1094,29 @@ int dnssec_validate_ds(time_t now, struct dns_header *header, size_t plen, char
 		      a.log.keytag = keytag;
 		      a.log.algo = algo;
 		      a.log.digest = digest;
-		      if (ds_digest_name(digest) && algo_digest_name(algo))
-			log_query(F_NOEXTRA | F_KEYTAG | F_UPSTREAM, name, &a, "DS keytag %hu, algo %hu, digest %hu", 0);
-		      else
-			log_query(F_NOEXTRA | F_KEYTAG | F_UPSTREAM, name, &a, "DS keytag %hu, algo %hu, digest %hu (not supported)", 0);
+		      log_query(F_NOEXTRA | F_KEYTAG | F_UPSTREAM, name, &a, "DS keytag %hu, algo %hu, digest %hu", 0);
+		      found_supported = 1;
 		    } 
 		}
 	      
 	      p = psave;
 	    }
+
 	  if (!ADD_RDLEN(header, p, plen, rdlen))
 	    return STAT_BOGUS; /* bad packet */
 	}

      cache_end_insert();

+      /* Fall through if no supported algo DS found. */
+      if (found_supported)
+	return STAT_OK;
    }
-  else
+  
+  flags = F_FORWARD | F_DS | F_NEG | F_DNSSECOK;
+  
+  if (neganswer)
    {
-      int flags = F_FORWARD | F_DS | F_NEG | F_DNSSECOK;
-            
      if (RCODE(header) == NXDOMAIN)
 	flags |= F_NXDOMAIN;
      
@@ -1110,17 +1124,18 @@ int dnssec_validate_ds(time_t now, struct dns_header *header, size_t plen, char
 	 to store presence/absence of NS. */
      if (nons)
 	flags &= ~F_DNSSECOK;
-      
-      cache_start_insert();
-	  
-      /* Use TTL from NSEC for negative cache entries */
-      if (!cache_insert(name, NULL, class, now, neg_ttl, flags))
-	return STAT_BOGUS;
-      
-      cache_end_insert();  
-      
-      log_query(F_NOEXTRA | F_UPSTREAM, name, NULL, nons ? "no DS/cut" : "no DS", 0);
    }
+  
+  cache_start_insert();
+  
+  /* Use TTL from NSEC for negative cache entries */
+  if (!cache_insert(name, NULL, class, now, neg_ttl, flags))
+    return STAT_BOGUS;
+  
+  cache_end_insert();  
+  
+  if (neganswer)
+    log_query(F_NOEXTRA | F_UPSTREAM, name, NULL, nons ? "no DS/cut" : "no DS", 0);
      
  return STAT_OK;
 }
@@ -135,47 +135,32 @@ static int get_dev_shm_usage(char buffer[64])
 // (while we initialized the shared memory objects)
 static void verify_shmem_pid(void)
 {
-	const int fd = shm_open(SHARED_SETTINGS_NAME, O_RDWR, S_IRUSR | S_IWUSR);
-	if(fd == -1)
+	// Open shared memory settings object
+	const int settingsfd = shm_open(SHARED_SETTINGS_NAME, O_RDONLY, S_IRUSR | S_IWUSR);
+	if(settingsfd == -1)
 	{
 		logg("FATAL: verify_shmem_pid(): Failed to open shared memory object \"%s\": %s",
-		     SHARED_SETTINGS_NAME, strerror(errno));
+			SHARED_SETTINGS_NAME, strerror(errno));
 		exit(EXIT_FAILURE);
 	}

-	// Get new pointer
-	void *shm = mmap(NULL, shm_settings.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-
-	// Check for `mmap` error
-	if(shm == MAP_FAILED)
+	ShmSettings shms = { 0 };
+	if(read(settingsfd, &shms, sizeof(shms)) != sizeof(shms))
 	{
-		logg("FATAL: verify_shmem_pid(): Failed to map shared memory object \"%s\" (%i): %s",
-		     SHARED_SETTINGS_NAME, fd, strerror(errno));
+		logg("FATAL: verify_shmem_pid(): Failed to read %zu bytes from shared memory object \"%s\": %s",
+			sizeof(shms), SHARED_SETTINGS_NAME, strerror(errno));
 		exit(EXIT_FAILURE);
 	}

-	// Close file descriptor after call to mmap
-	close(fd);
-
-	// Unmap old memory region
-	if(munmap(shm_settings.ptr, shm_settings.size) < 0)
-	{
-		logg("FATAL: verify_shmem_pid(): Failed to unmap shared memory object \"%s\" (%i): %s",
-		     SHARED_SETTINGS_NAME, fd, strerror(errno));
-		exit(EXIT_FAILURE);
-	}
-
-	// Update pointer
-	shmSettings = shm_settings.ptr = shm;
+	close(settingsfd);

 	// Compare the SHM's PID to the one we had when creating the SHM objects
-	if(shmSettings->pid == shmem_pid)
+	if(shms.pid == shmem_pid)
 		return;

 	// If we reach here, we are in serious trouble. Terminating with error
 	// code is the most sensible thing we can do at this point
-	logg("FATAL: Shared memory is owned by a different process (PID %d)",
-	     shmSettings->pid);
+	logg("FATAL: Shared memory is owned by a different process (PID %d)", shms.pid);
 	check_running_FTL();
 	logg("Exiting now!");
 	exit(EXIT_FAILURE);
@@ -782,6 +767,9 @@ static bool realloc_shm(SharedMemory *sharedMemory, const size_t size1, const si
 	// TCP requests.
 	if(resize)
 	{
+		// Verify shared memory ownership
+		verify_shmem_pid();
+
 		// Open shared memory object
 		const int fd = shm_open(sharedMemory->name, O_RDWR, S_IRUSR | S_IWUSR);
 		if(fd == -1)
@@ -921,9 +909,6 @@ static size_t get_optimal_object_size(const size_t objsize, const size_t minsize
 // Enlarge shared memory to be able to hold at least one new record
 void shm_ensure_size(void)
 {
-	// Verify shared memory ownership
-	verify_shmem_pid();
-
 	if(counters->queries >= counters->queries_MAX-1)
 	{
 		// Have to reallocate shared memory