fix: address PR #98 review feedback

- check-cwe134.sh: match gchar* in addition to char* in variadic pattern - rosterwin.c: merge duplicated if/else into single condition - omemo.c: remove unnecessary scope block and goto, use early return
Add low-impact warning flags, fix warnings found by new flags
2026-03-07 13:32:02 +03:00 · 2026-03-04 22:28:16 +03:00 · 2026-03-04 21:18:35 +03:00 · 2026-03-03 16:29:25 +03:00 · 2026-02-18 17:39:25 +01:00
44 changed files with 878 additions and 2923 deletions
--- a/13
+++ b/13
@@ -1,16 +1,3 @@
-0.16.0 (unreleased)
-===================
-
-Changes:
- Add flat-file database backend as alternative to SQLite for message history.
-  Stores messages as human-readable plain text files. Configure with `/privacy logging flatfile`.
-  Files are stored in ~/.local/share/profanity/flatlog/.
- Add `/history verify [<jid>]` command to check integrity of stored message
-  history (works with both SQLite and flat-file backends).
- Add vtable-based database backend abstraction allowing pluggable storage.
- Add `make check-functional-flatfile` target to run functional tests with
-  flat-file backend.
-
 0.15.0 (2025-03-27)
 ===================

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -123,20 +123,6 @@ Test your changes with the following tools to find mistakes.

 Run `make check` to run the unit tests with your current configuration or `./ci-build.sh` to check with different switches passed to configure.

-### flat-file backend tests
-
-To run functional tests with the flat-file database backend (instead of SQLite):
-
-```bash
-make check-functional-flatfile
-```
-
-Or manually for a single group:
-
-```bash
-PROF_FLATFILE=1 PROF_TEST_GROUP=1 ./tests/functionaltests/functionaltests 1
-```
-
 ### valgrind
 We provide a suppressions file `prof.supp`. It is a combination of the suppressions for shipped with glib2, python and custom rules.

--- a/Dockerfile.arch
+++ b/Dockerfile.arch
@@ -3,7 +3,6 @@ FROM archlinux:latest
 ENV TERM=xterm
 ENV CC="ccache gcc"

-RUN pacman-key --refresh-keys
 RUN pacman -Syyu --noconfirm

 # reflector is optional - if it fails due to network issues, continue with default mirrorlist
--- a/Makefile.am
+++ b/Makefile.am
@@ -3,8 +3,6 @@ core_sources = \
 	src/log.c src/common.c \
 	src/chatlog.c src/chatlog.h \
 	src/database.h src/database.c \
-	src/database_sqlite.c \
-	src/database_flatfile.c \
 	src/log.h src/profanity.c src/common.h \
 	src/profanity.h src/xmpp/chat_session.c \
 	src/xmpp/chat_session.h src/xmpp/muc.c src/xmpp/muc.h src/xmpp/jid.h src/xmpp/jid.c \
@@ -331,26 +329,6 @@ check-functional-parallel: tests/functionaltests/functionaltests
 	grep -E 'PASSED|FAILED|Running' $(builddir)/test-logs/group*.log || true; \
 	if [ $$failed -ne 0 ]; then echo "FUNCTIONAL TESTS FAILED"; exit 1; fi; \
 	echo "All functional test groups passed!"
-
-# Run functional tests with the flat-file database backend
-# Usage: make check-functional-flatfile
-check-functional-flatfile: tests/functionaltests/functionaltests
-	@echo "Running functional tests with flat-file backend ($(words $(FUNC_TEST_GROUPS)) groups)..."
-	@mkdir -p $(builddir)/test-logs $(builddir)/test-files
-	@pids=""; \
-	for g in $(FUNC_TEST_GROUPS); do \
-		PROF_FLATFILE=1 ./tests/functionaltests/functionaltests $$g > $(builddir)/test-logs/group$$g-flatfile.log 2>&1 & \
-		pids="$$pids $$!"; \
-	done; \
-	failed=0; i=1; \
-	for pid in $$pids; do \
-		wait $$pid || { echo "Group $$i FAILED (flatfile)"; cat $(builddir)/test-logs/group$$i-flatfile.log; failed=1; }; \
-		i=$$((i + 1)); \
-	done; \
-	echo "=== Flat-file Test Results Summary ==="; \
-	grep -E 'PASSED|FAILED|Running' $(builddir)/test-logs/group*-flatfile.log || true; \
-	if [ $$failed -ne 0 ]; then echo "FLAT-FILE FUNCTIONAL TESTS FAILED"; exit 1; fi; \
-	echo "All flat-file functional test groups passed!"
 endif
 endif

--- a/check-cwe134.sh
+++ b/check-cwe134.sh
@@ -1,8 +1,14 @@
 #!/bin/bash
-# check-cwe134.sh - Static analysis for CWE-134 format string vulnerabilities
+# check-cwe134.sh - Verify __attribute__((format)) on printf-like wrappers
 #
-# This script detects potentially unsafe usage of format string functions
-# where user-controlled data may be passed without "%s" wrapper.
+# CWE-134 format string vulnerabilities are caught at compile time by
+# -Wformat=2 (includes -Wformat-security + -Wformat-nonliteral), BUT only
+# for functions annotated with __attribute__((format(printf, N, M))) or
+# G_GNUC_PRINTF(N, M).
+#
+# This script ensures every variadic function whose last fixed parameter
+# looks like a format string has the annotation.  Without it, the compiler
+# silently ignores format misuse.
 #
 # Usage: ./check-cwe134.sh [directory]

@@ -10,59 +16,103 @@ set -e

 DIR="${1:-src}"

-echo "=== CWE-134 Format String Vulnerability Check ==="
+echo "=== CWE-134: format attribute audit ==="
 echo "Scanning: $DIR"
 echo ""

-# Functions that accept format strings
-FORMAT_FUNCS="cons_show|cons_debug|cons_show_error|log_info|log_error|log_warning|log_debug|win_println|win_print"
-
 ERRORS=0

-echo "Checking for unsafe format string usage..."
+# --------------------------------------------------------------------- #
+# Known printf-like wrappers that MUST have the attribute                #
+# --------------------------------------------------------------------- #
+REQUIRED_ATTRIBUTED=(
+    "cons_show"
+    "cons_debug"
+    "cons_show_error"
+    "cons_show_padded"
+    "log_debug"
+    "log_info"
+    "log_warning"
+    "log_error"
+    "win_print"
+    "win_println"
+    "win_println_indent"
+    "win_println_va"
+    "win_append"
+    "win_appendln"
+    "win_append_highlight"
+    "win_appendln_highlight"
+    "win_command_exec_error"
+)
+
+echo "Check 1: Known wrappers must have G_GNUC_PRINTF / __attribute__((format))"
 echo ""

-# Pattern 1: function call with single variable argument (no format string)
-# Example: cons_show(variable);  - BAD
-# Example: cons_show("%s", variable);  - OK
-# Matches: func(identifier) or func(identifier->member) or func(identifier[index])
-RESULTS=$(grep -rn --include="*.c" -P "($FORMAT_FUNCS)\s*\(\s*[a-zA-Z_][a-zA-Z0-9_]*(\s*->\s*\w+|\s*\[\s*\w+\s*\])?\s*\)\s*;" "$DIR" 2>/dev/null || true)
+for func in "${REQUIRED_ATTRIBUTED[@]}"; do
+    HAS_ATTR=$(grep -B1 --include="*.h" -rn "void ${func}\s*(" "$DIR" 2>/dev/null \
+        | grep -Ec "format\(printf|G_GNUC_PRINTF" || true)
+    if [ "$HAS_ATTR" -eq 0 ]; then
+        echo "  ❌ $func — missing format attribute"
+        ERRORS=$((ERRORS + 1))
+    fi
+done

-# Filter out function definitions, declarations, and safe api_* wrappers
-RESULTS=$(echo "$RESULTS" | grep -v "const char\|void \|^[^:]*:[0-9]*:[a-z_]*(\|api_cons_show\|api_log_" || true)
+if [ "$ERRORS" -eq 0 ]; then
+    echo "  ✅ All known wrappers annotated."
+fi

-if [ -n "$RESULTS" ]; then
-    echo "❌ POTENTIAL CWE-134 VULNERABILITIES FOUND:"
+# --------------------------------------------------------------------- #
+# Auto-detect new variadic functions that look like printf wrappers      #
+# but are NOT in the known list and NOT annotated.                       #
+# Heuristic: declaration has (... const char* ..., ...) and no attribute #
+# --------------------------------------------------------------------- #
+echo ""
+echo "Check 2: Detect unannotated printf-like variadic declarations in headers"
+echo ""
+
+KNOWN_RE=$(IFS="|"; echo "${REQUIRED_ATTRIBUTED[*]}")
+
+# Find variadic declarations with a const char* / gchar* parameter followed by ...)
+# that do NOT have a format attribute on the preceding line
+NEW_ISSUES=$(grep -B1 -rn --include="*.h" \
+    'const g\?char\s*\*.*,\s*\.\.\.)' "$DIR" 2>/dev/null \
+    | awk '
+        /format\(printf|G_GNUC_PRINTF/ { skip=1; next }
+        /const g?char.*,.*\.\.\.\)/ {
+            if (skip) { skip=0; next }
+            print
+        }
+        { skip=0 }
+    ' \
+    | grep -E "void\s+\w+\s*\(" \
+    | grep -Ev "($KNOWN_RE)" \
+    || true)
+
+if [ -n "$NEW_ISSUES" ]; then
+    echo "  ⚠️  Possibly unannotated new printf-like functions:"
    echo ""
-    echo "$RESULTS"
+    echo "$NEW_ISSUES"
    echo ""
-    ERRORS=$(echo "$RESULTS" | wc -l)
+    NEW_COUNT=$(echo "$NEW_ISSUES" | wc -l)
+    ERRORS=$((ERRORS + NEW_COUNT))
 else
-    echo "✅ No obvious CWE-134 issues found."
-fi
-
-# Additional check: GString->str passed directly (not as %s argument)
-echo ""
-echo "Checking for GString->str passed to format functions..."
-
-GSTRING_RESULTS=$(grep -rn --include="*.c" -P "($FORMAT_FUNCS)\s*\([^)]*->str\s*\)" "$DIR" 2>/dev/null | grep -v '"%s"' || true)
-
-if [ -n "$GSTRING_RESULTS" ]; then
-    echo "⚠️  GString->str passed without \"%s\" (review manually):"
-    echo ""
-    echo "$GSTRING_RESULTS"
-    echo ""
+    echo "  ✅ No unannotated variadic printf-like functions found."
 fi

+# --------------------------------------------------------------------- #
+# Summary                                                                #
+# --------------------------------------------------------------------- #
 echo ""
 echo "=== Summary ==="
-echo "Critical issues: $ERRORS"
+echo "Issues: $ERRORS"
+echo ""

 if [ "$ERRORS" -gt 0 ]; then
+    echo "Fix: add the attribute before the declaration in the .h file:"
+    echo "  G_GNUC_PRINTF(N, M)          // N = format arg, M = first vararg"
+    echo "  void my_func(ProfWin* w, const char* fmt, ...);"
    echo ""
-    echo "Fix by adding \"%s\" format specifier:"
-    echo "  BAD:  cons_show(variable);"
-    echo "  GOOD: cons_show(\"%s\", variable);"
+    echo "The compiler flag -Wformat=2 will then catch all misuse automatically."
    exit 1
 fi

--- a/configure.ac
+++ b/configure.ac
@@ -385,9 +385,41 @@ AC_CHECK_LIB([util], [forkpty], [AM_CONDITIONAL([HAVE_FORKPTY], [true]) FORKPTY_
 AC_SUBST([FORKPTY_LIB])

 ## Default parameters
-AM_CFLAGS="$AM_CFLAGS -Wall -Wno-deprecated-declarations -std=gnu99 -ggdb3"
+AM_CFLAGS="$AM_CFLAGS -Wall -Wextra -Wformat=2 -Wno-format-zero-length"
+AM_CFLAGS="$AM_CFLAGS -Wno-deprecated-declarations -Wno-unused-parameter -Wno-missing-field-initializers -Wno-sign-compare -Wno-cast-function-type"
+AM_CFLAGS="$AM_CFLAGS -Wnull-dereference -Wpointer-arith"
+AM_CFLAGS="$AM_CFLAGS -Wimplicit-function-declaration"
+AM_CFLAGS="$AM_CFLAGS -Wundef"
+AM_CFLAGS="$AM_CFLAGS -Wfloat-equal -Wredundant-decls"
+AM_CFLAGS="$AM_CFLAGS -fstack-protector-strong -fno-common"
+AM_CFLAGS="$AM_CFLAGS -D_FORTIFY_SOURCE=2"
+AM_CFLAGS="$AM_CFLAGS -std=gnu99 -ggdb3"
+
+# GCC-specific warnings (not supported by clang) — test each one
+saved_CFLAGS="$CFLAGS"
+for _flag in -Wlogical-op -Wduplicated-cond -Wduplicated-branches \
+             -Wstringop-overflow -Warray-bounds=2 -Walloc-zero; do
+    AC_MSG_CHECKING([whether $CC supports $_flag])
+    CFLAGS="$saved_CFLAGS $_flag -Werror"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
+        [AC_MSG_RESULT([yes]); AM_CFLAGS="$AM_CFLAGS $_flag"],
+        [AC_MSG_RESULT([no])])
+done
+CFLAGS="$saved_CFLAGS"
+
 AM_LDFLAGS="$AM_LDFLAGS -export-dynamic"

+# Linker hardening (RELRO + immediate binding)
+saved_LDFLAGS="$LDFLAGS"
+for _flag in -Wl,-z,relro -Wl,-z,now; do
+    AC_MSG_CHECKING([whether linker supports $_flag])
+    LDFLAGS="$saved_LDFLAGS $_flag"
+    AC_LINK_IFELSE([AC_LANG_PROGRAM()],
+        [AC_MSG_RESULT([yes]); AM_LDFLAGS="$AM_LDFLAGS $_flag"],
+        [AC_MSG_RESULT([no])])
+done
+LDFLAGS="$saved_LDFLAGS"
+
 AS_IF([test "x$enable_coverage" = xyes],
    [AM_CFLAGS="$AM_CFLAGS --coverage -O0"
     AM_LDFLAGS="$AM_LDFLAGS --coverage"
@@ -401,7 +433,7 @@ AS_IF([test "x$PLATFORM" = xosx],
 AM_CFLAGS="$AM_CFLAGS $PTHREAD_CFLAGS $glib_CFLAGS $gio_CFLAGS $curl_CFLAGS ${SQLITE_CFLAGS}"
 AM_CFLAGS="$AM_CFLAGS $libnotify_CFLAGS ${GTK_CFLAGS} $python_CFLAGS"
 AM_CFLAGS="$AM_CFLAGS -DTHEMES_PATH=\"\\\"$THEMES_PATH\\\"\" -DICONS_PATH=\"\\\"$ICONS_PATH\\\"\" -DGLOBAL_PYTHON_PLUGINS_PATH=\"\\\"$GLOBAL_PYTHON_PLUGINS_PATH\\\"\" -DGLOBAL_C_PLUGINS_PATH=\"\\\"$GLOBAL_C_PLUGINS_PATH\\\"\""
-AM_CFLAGS="$AM_CFLAGS $CFLAGS"
+
 LIBS="$glib_LIBS $gio_LIBS $PTHREAD_LIBS $curl_LIBS $libnotify_LIBS $python_LIBS ${GTK_LIBS} ${SQLITE_LIBS} $LIBS"

 AC_SUBST(AM_LDFLAGS)
--- a/docs/profanity.1
+++ b/docs/profanity.1
@@ -197,35 +197,8 @@ Configuration for
 .B Profanity
 is stored in
 .I $XDG_CONFIG_HOME/profanity/profrc
-, details on commands for configuring Profanity can be found at <https://profanity-im.github.io/reference.html> or the respective built\-in help or man pages..SS Message History Storage
-By default, message history is stored in an SQLite database. An alternative flat-file backend
-stores messages as human-readable plain text files that can be edited with any text editor.
-.PP
-To enable flat-file logging, set in
-.IR profrc :
-.PP
-.EX
-[logging]
-dblog=flatfile
-.EE
-.PP
-Or use the command:
-.B /privacy logging flatfile
-.PP
-Flat-file logs are stored under
-.IR $XDG_DATA_HOME/profanity/flatlog/ ,
-organized as
-.IR {account_jid}/{contact_jid}/{YYYY_MM_DD}.log .
-.PP
-Each line has the format:
-.br
-.EX
-{ISO8601} [{type}|{enc}|id:{id}|corrects:{id}] {sender}: {message}
-.EE
-.PP
-Use
-.B /history verify
-to check integrity of stored history (both SQLite and flat-file)..SH BUGS
+, details on commands for configuring Profanity can be found at <https://profanity-im.github.io/reference.html> or the respective built\-in help or man pages.
+.SH BUGS
 Bugs can either be reported by raising an issue at the Github issue tracker:
 .br
 .PP
--- a/profrc.example
+++ b/profrc.example
@@ -49,13 +49,6 @@ grlog=true
 maxsize=1048580
 rotate=true
 shared=true
-# Database backend for message history:
-#   on       - SQLite database (default)
-#   off      - no message logging
-#   redact   - store with redacted message content
-#   flatfile - plain text files, editable with any text editor
-#              stored in ~/.local/share/profanity/flatlog/
-dblog=on

 [otr]
 warn=true
--- a/src/chatlog.c
+++ b/src/chatlog.c
@@ -204,7 +204,7 @@ chat_log_omemo_msg_in(ProfMessage* message)
            if (message->type == PROF_MSG_TYPE_MUCPM) {
                _chat_log_chat(mybarejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
            } else {
-                _chat_log_chat(mybarejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
+                _chat_log_chat(mybarejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, NULL);
            }
        }
    }
--- a/src/command/cmd_defs.c
+++ b/src/command/cmd_defs.c
@@ -1875,21 +1875,18 @@ static const struct cmd_t command_defs[] = {
    },

    { CMD_PREAMBLE("/history",
-                   parse_args, 1, 2, &cons_history_setting)
+                   parse_args, 1, 1, &cons_history_setting)
      CMD_MAINFUNC(cmd_history)
      CMD_TAGS(
              CMD_TAG_UI,
              CMD_TAG_CHAT)
      CMD_SYN(
-              "/history on|off",
-              "/history verify [<jid>]")
+              "/history on|off")
      CMD_DESC(
              "Switch chat history on or off, /logging chat will automatically be enabled when this setting is on. "
-              "When history is enabled, previous messages are shown in chat windows. "
-              "Use 'verify' to check integrity of stored message history.")
+              "When history is enabled, previous messages are shown in chat windows.")
      CMD_ARGS(
-              { "on|off", "Enable or disable showing chat history." },
-              { "verify [<jid>]", "Verify integrity of message history. Optionally specify a JID to check only one contact." })
+              { "on|off", "Enable or disable showing chat history." })
    },

    { CMD_PREAMBLE("/log",
@@ -2721,7 +2718,7 @@ static const struct cmd_t command_defs[] = {
              CMD_TAG_CHAT,
              CMD_TAG_DISCOVERY)
      CMD_SYN(
-              "/privacy logging on|redact|off|flatfile",
+              "/privacy logging on|redact|off",
              "/privacy os on|off")
      CMD_DESC(
              "Configure privacy settings. "
@@ -2729,13 +2726,12 @@ static const struct cmd_t command_defs[] = {
              "clientid to set the client identification name "
              "session_alarm to configure an alarm when more clients log in.")
      CMD_ARGS(
-              { "logging on|redact|off|flatfile", "Switch chat logging. 'on' uses SQLite database (default). 'flatfile' stores messages as plain text files in ~/.local/share/profanity/flatlog/ that can be manually edited with any text editor. 'off' disables logging entirely. 'redact' stores messages with content replaced by '[redacted]'. Note: 'off' might have unintended consequences, such as not being able to decrypt OMEMO encrypted messages received later via MAM. The 'flatfile' setting takes effect on next connection." },
+              { "logging on|redact|off", "Switch chat logging. This will also disable logging in the internally used SQL database. Your messages will not be saved anywhere locally. This might have unintended consequences, such as not being able to decrypt OMEMO encrypted messages received later via MAM, and should be used with caution." },
              { "os on|off", "Choose whether to include the OS name if a user asks for software information (XEP-0092)." }
              )
      CMD_EXAMPLES(
              "/privacy",
              "/privacy logging off",
-              "/privacy logging flatfile",
              "/privacy os off")
    },

@@ -3071,7 +3067,7 @@ command_docgen(void)

    fclose(toc_fragment);
    fclose(main_fragment);
-    printf("\nProcessed %d commands.\n\n", g_list_length(cmds));
+    printf("\nProcessed %u commands.\n\n", g_list_length(cmds));
    g_list_free(cmds);
 }

@@ -3149,7 +3145,7 @@ command_mangen(void)
        curr = g_list_next(curr);
    }

-    printf("\nProcessed %d commands.\n\n", g_list_length(cmds));
+    printf("\nProcessed %u commands.\n\n", g_list_length(cmds));

    g_list_free(cmds);
 }
--- a/src/command/cmd_funcs.c
+++ b/src/command/cmd_funcs.c
@@ -2271,7 +2271,7 @@ cmd_group(ProfWin* window, const char* const command, gchar** args)
        if (curr) {
            cons_show("Groups:");
            while (curr) {
-                cons_show("  %s", curr->data);
+                cons_show("  %s", (char*)curr->data);
                curr = g_list_next(curr);
            }

@@ -3109,7 +3109,7 @@ cmd_blocked(ProfWin* window, const char* const command, gchar** args)
    if (curr) {
        cons_show("Blocked users:");
        while (curr) {
-            cons_show("  %s", curr->data);
+            cons_show("  %s", (char*)curr->data);
            curr = g_list_next(curr);
        }
    } else {
@@ -5190,7 +5190,7 @@ cmd_charset(ProfWin* window, const char* const command, gchar** args)
    if (codeset) {
        cons_show("  CODESET:    %s", codeset);
    }
-    cons_show("  MB_CUR_MAX: %d", MB_CUR_MAX);
+    cons_show("  MB_CUR_MAX: %zu", MB_CUR_MAX);
    cons_show("  MB_LEN_MAX: %d", MB_LEN_MAX);

    return TRUE;
@@ -5624,7 +5624,7 @@ cmd_notify(ProfWin* window, const char* const command, gchar** args)
                    cons_show("No room notification triggers");
                }
                while (curr) {
-                    cons_show("  %s", curr->data);
+                    cons_show("  %s", (char*)curr->data);
                    curr = g_list_next(curr);
                }
                g_list_free_full(triggers, free);
@@ -6299,7 +6299,7 @@ cmd_reconnect(ProfWin* window, const char* const command, gchar** args)
    } else if (strtoi_range(value, &intval, 0, INT_MAX, &err_msg)) {
        prefs_set_reconnect(intval);
        if (intval == 0) {
-            cons_show("Reconnect disabled.", intval);
+            cons_show("Reconnect disabled.");
        } else {
            cons_show("Reconnect interval set to %d seconds.", intval);
        }
@@ -6686,11 +6686,6 @@ cmd_privacy(ProfWin* window, const char* const command, gchar** args)
        } else if (g_strcmp0(arg, "redact") == 0) {
            cons_show("Messages are going to be redacted.");
            prefs_set_string(PREF_DBLOG, arg);
-        } else if (g_strcmp0(arg, "flatfile") == 0) {
-            cons_show("Using flat-file backend for message logging. Takes effect on next connection.");
-            prefs_set_string(PREF_DBLOG, arg);
-            prefs_set_boolean(PREF_CHLOG, TRUE);
-            prefs_set_boolean(PREF_HISTORY, TRUE);
        } else {
            cons_bad_cmd_usage(command);
            return TRUE;
@@ -6735,58 +6730,6 @@ cmd_history(ProfWin* window, const char* const command, gchar** args)
        return TRUE;
    }

-    if (g_strcmp0(args[0], "verify") == 0) {
-        const gchar* contact_jid = args[1]; // may be NULL (verify all)
-        cons_show("Verifying history integrity...");
-
-        GSList* issues = log_database_verify_integrity(contact_jid);
-
-        int errors = 0, warnings = 0, infos = 0;
-        for (GSList* l = issues; l; l = l->next) {
-            integrity_issue_t* issue = l->data;
-            const char* level_str;
-            switch (issue->level) {
-            case INTEGRITY_ERROR:
-                level_str = "ERROR";
-                errors++;
-                break;
-            case INTEGRITY_WARNING:
-                level_str = "WARN";
-                warnings++;
-                break;
-            case INTEGRITY_INFO:
-                level_str = "INFO";
-                infos++;
-                break;
-            default:
-                level_str = "???";
-                break;
-            }
-            if (issue->line > 0) {
-                if (issue->level == INTEGRITY_ERROR) {
-                    cons_show_error("[%s] %s:%d — %s", level_str, issue->file, issue->line, issue->message);
-                } else {
-                    cons_show("[%s] %s:%d — %s", level_str, issue->file, issue->line, issue->message);
-                }
-            } else {
-                if (issue->level == INTEGRITY_ERROR) {
-                    cons_show_error("[%s] %s — %s", level_str, issue->file, issue->message);
-                } else {
-                    cons_show("[%s] %s — %s", level_str, issue->file, issue->message);
-                }
-            }
-        }
-
-        if (!issues) {
-            cons_show("Verification complete: no issues found.");
-        } else {
-            cons_show("Verification complete: %d error(s), %d warning(s), %d info(s).",
-                      errors, warnings, infos);
-            g_slist_free_full(issues, (GDestroyNotify)integrity_issue_free);
-        }
-        return TRUE;
-    }
-
    _cmd_set_boolean_preference(args[0], "Chat history", PREF_HISTORY);

    // if set to on, set chlog (/logging chat on)
@@ -6915,7 +6858,7 @@ cmd_plugins_install(ProfWin* window, const char* const command, gchar** args)
                cons_show("");
                cons_show("Installed and loaded plugins (%u):", g_slist_length(curr));
                while (curr) {
-                    cons_show("  %s", curr->data);
+                    cons_show("  %s", (char*)curr->data);
                    curr = g_slist_next(curr);
                }
            }
@@ -6924,7 +6867,7 @@ cmd_plugins_install(ProfWin* window, const char* const command, gchar** args)
                cons_show("");
                cons_show("Failed installs (%u):", g_slist_length(curr));
                while (curr) {
-                    cons_show("  %s", curr->data);
+                    cons_show("  %s", (char*)curr->data);
                    curr = g_slist_next(curr);
                }
            }
@@ -7026,7 +6969,7 @@ cmd_plugins_load(ProfWin* window, const char* const command, gchar** args)
            cons_show("Loaded plugins:");
            GSList* curr = loaded;
            while (curr) {
-                cons_show("  %s", curr->data);
+                cons_show("  %s", (char*)curr->data);
                curr = g_slist_next(curr);
            }
            g_slist_free_full(loaded, g_free);
@@ -7158,7 +7101,7 @@ cmd_plugins(ProfWin* window, const char* const command, gchar** args)
        GSList* curr = unloaded_plugins;
        cons_show("The following plugins already installed and can be loaded:");
        while (curr) {
-            cons_show("  %s", curr->data);
+            cons_show("  %s", (char*)curr->data);
            curr = g_slist_next(curr);
        }
        g_slist_free_full(unloaded_plugins, g_free);
@@ -7168,7 +7111,7 @@ cmd_plugins(ProfWin* window, const char* const command, gchar** args)
        GList* curr = plugins;
        cons_show("Loaded plugins:");
        while (curr) {
-            cons_show("  %s", curr->data);
+            cons_show("  %s", (char*)curr->data);
            curr = g_list_next(curr);
        }
        g_list_free(plugins);
--- a/src/common.c
+++ b/src/common.c
@@ -383,7 +383,7 @@ utf8_display_len(const char* const str)
 char*
 release_get_latest(void)
 {
-    char* url = "https://profanity-im.github.io/profanity_version.txt";
+    const char* url = "https://profanity-im.github.io/profanity_version.txt";

    CURL* handle = curl_easy_init();
    struct curl_data_t output;
--- a/src/config/account.c
+++ b/src/config/account.c
@@ -189,7 +189,7 @@ account_eval_password(ProfAccount* account)

    int exit_status = pclose(stream);
    if (exit_status > 0) {
-        log_error("Command for `eval_password` returned error status (%s).",
+        log_error("Command for `eval_password` returned error status (%d).",
                  exit_status);
        return FALSE;
    } else if (exit_status < 0) {
--- a/src/config/files.c
+++ b/src/config/files.c
@@ -114,30 +114,26 @@ gchar*
 files_get_log_file(const char* const log_file)
 {
    auto_gchar gchar* xdg_data = _files_get_xdg_data_home();
-    GString* logfile;

    if (log_file) {
        auto_gchar gchar* log_path = g_path_get_dirname(log_file);
        if (!create_dir(log_path)) {
            log_error("Error while creating directory %s", log_path);
        }
-
-        logfile = g_string_new(log_file);
-    } else {
-        logfile = g_string_new(xdg_data);
-        g_string_append(logfile, "/profanity/logs/profanity");
-
-        if (!prefs_get_boolean(PREF_LOG_SHARED)) {
-            g_string_append_printf(logfile, "%d", getpid());
-        }
-
-        g_string_append(logfile, ".log");
+        return g_strdup(log_file);
    }

+    GString* logfile = g_string_new(xdg_data);
+    g_string_append(logfile, "/profanity/logs/profanity");
+
+    if (!prefs_get_boolean(PREF_LOG_SHARED)) {
+        g_string_append_printf(logfile, "%d", getpid());
+    }
+
+    g_string_append(logfile, ".log");
+
    gchar* result = g_strdup(logfile->str);
-
    g_string_free(logfile, TRUE);
-
    return result;
 }

--- a/src/config/files.h
+++ b/src/config/files.h
@@ -57,7 +57,6 @@
 #define DIR_OMEMO     "omemo"
 #define DIR_PLUGINS   "plugins"
 #define DIR_DATABASE  "database"
-#define DIR_FLATLOG   "flatlog"
 #define DIR_DOWNLOADS "downloads"
 #define DIR_EDITOR    "editor"
 #define DIR_CERTS     "certs"
--- a/src/database.c
+++ b/src/database.c
@@ -35,129 +35,703 @@

 #include "config.h"

+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sqlite3.h>
 #include <glib.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>

 #include "log.h"
 #include "common.h"
+#include "config/files.h"
 #include "database.h"
 #include "config/preferences.h"
 #include "ui/ui.h"
 #include "xmpp/xmpp.h"
 #include "xmpp/message.h"

-db_backend_t* active_db_backend = NULL;
+static sqlite3* g_chatlog_database;

-void
-integrity_issue_free(integrity_issue_t* issue)
+static void _add_to_db(ProfMessage* message, const char* type, const Jid* const from_jid, const Jid* const to_jid);
+static char* _get_db_filename(ProfAccount* account);
+static prof_msg_type_t _get_message_type_type(const char* const type);
+static prof_enc_t _get_message_enc_type(const char* const encstr);
+static int _get_db_version(void);
+static gboolean _migrate_to_v2(void);
+static gboolean _check_available_space_for_db_migration(char* path_to_db);
+
+static const int latest_version = 2;
+
+// Helper: close DB handle (if any), warn on busy, and shutdown SQLite
+static void
+_db_teardown(const char* ctx)
 {
-    if (issue) {
-        g_free(issue->file);
-        g_free(issue->message);
-        g_free(issue);
+    if (g_chatlog_database) {
+        int rc = sqlite3_close_v2(g_chatlog_database);
+        if (rc != SQLITE_OK) {
+            log_warning("sqlite3_close_v2 in %s returned %d; database may still have active statements.",
+                        ctx ? ctx : "db_teardown", rc);
+        }
+        g_chatlog_database = NULL;
    }
+    // Safe to call unconditionally; no-op if not initialized.
+    // See: https://www.sqlite.org/c3ref/initialize.html
+    sqlite3_shutdown();
+}
+
+// Helper: prepare a statement and log a contextual error on failure
+static gboolean
+_db_prepare_ctx(const char* query, sqlite3_stmt** stmt, const char* ctx)
+{
+    int rc = sqlite3_prepare_v2(g_chatlog_database, query, -1, stmt, NULL);
+    if (rc != SQLITE_OK) {
+        log_error("SQLite error in %s: (error code: %d) %s",
+                  ctx ? ctx : "sqlite3_prepare_v2",
+                  rc,
+                  sqlite3_errmsg(g_chatlog_database));
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static char*
+_db_strdup(const char* str)
+{
+    return str ? strdup(str) : NULL;
+}
+
+#define auto_sqlite __attribute__((__cleanup__(auto_free_sqlite)))
+
+static void
+auto_free_sqlite(gchar** str)
+{
+    if (str == NULL)
+        return;
+    sqlite3_free(*str);
+}
+
+static char*
+_get_db_filename(ProfAccount* account)
+{
+    return files_file_in_account_data_path(DIR_DATABASE, account->jid, "chatlog.db");
 }

 gboolean
 log_database_init(ProfAccount* account)
 {
-    auto_gchar gchar* pref_dblog = prefs_get_string(PREF_DBLOG);
-
-    // Select backend based on preference
-    if (g_strcmp0(pref_dblog, "flatfile") == 0) {
-        active_db_backend = db_backend_flatfile();
-        log_info("Using flat-file database backend");
-    } else {
-        active_db_backend = db_backend_sqlite();
-        log_info("Using SQLite database backend");
-    }
-
-    if (!active_db_backend) {
-        log_error("log_database_init: no backend available");
+    int ret = sqlite3_initialize();
+    if (ret != SQLITE_OK) {
+        log_error("Error initializing SQLite database: %d", ret);
        return FALSE;
    }

-    return active_db_backend->init(account);
+    auto_char char* filename = _get_db_filename(account);
+    if (!filename) {
+        sqlite3_shutdown();
+        return FALSE;
+    }
+
+    ret = sqlite3_open(filename, &g_chatlog_database);
+    if (ret != SQLITE_OK) {
+        const char* err_msg = g_chatlog_database ? sqlite3_errmsg(g_chatlog_database) : "(no handle)";
+        log_error("Error opening SQLite database: %s", err_msg);
+        _db_teardown("log_database_init(open)");
+        return FALSE;
+    }
+
+    char* err_msg = NULL;
+
+    int db_version = _get_db_version();
+    if (db_version == latest_version) {
+        return TRUE;
+    }
+
+    // ChatLogs Table
+    // Contains all chat messages
+    //
+    // id is primary key
+    // from_jid is the sender's jid
+    // to_jid is the receiver's jid
+    // from_resource is the sender's resource
+    // to_resource is the receiver's resource
+    // message is the message's text
+    // timestamp is the timestamp like "2020/03/24 11:12:14"
+    // type is there to distinguish: message (chat), MUC message (muc), muc pm (mucpm)
+    // stanza_id is the ID in <message>
+    // archive_id is the stanza-id from from XEP-0359: Unique and Stable Stanza IDs used for XEP-0313: Message Archive Management
+    // encryption is to distinguish: none, omemo, otr, pgp
+    // marked_read is 0/1 whether a message has been marked as read via XEP-0333: Chat Markers
+    // replace_id is the ID from XEP-0308: Last Message Correction
+    // replaces_db_id is ID (primary key) of the original message that LMC message corrects/replaces
+    // replaced_by_db_id is ID (primary key) of the last correcting (LMC) message for the original message
+    const char* query = "CREATE TABLE IF NOT EXISTS `ChatLogs` ("
+                        "`id` INTEGER PRIMARY KEY AUTOINCREMENT, "
+                        "`from_jid` TEXT NOT NULL, "
+                        "`to_jid` TEXT NOT NULL, "
+                        "`from_resource` TEXT, "
+                        "`to_resource` TEXT, "
+                        "`message` TEXT, "
+                        "`timestamp` TEXT, "
+                        "`type` TEXT, "
+                        "`stanza_id` TEXT, "
+                        "`archive_id` TEXT, "
+                        "`encryption` TEXT, "
+                        "`marked_read` INTEGER, "
+                        "`replace_id` TEXT, "
+                        "`replaces_db_id` INTEGER, "
+                        "`replaced_by_db_id` INTEGER)";
+    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
+        goto out;
+    }
+
+    query = "CREATE TRIGGER IF NOT EXISTS update_corrected_message "
+            "AFTER INSERT ON ChatLogs "
+            "FOR EACH ROW "
+            "WHEN NEW.replaces_db_id IS NOT NULL "
+            "BEGIN "
+            "UPDATE ChatLogs "
+            "SET replaced_by_db_id = NEW.id "
+            "WHERE id = NEW.replaces_db_id; "
+            "END;";
+    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
+        log_error("Unable to add `update_corrected_message` trigger.");
+        goto out;
+    }
+
+    query = "CREATE INDEX IF NOT EXISTS ChatLogs_timestamp_IDX ON `ChatLogs` (`timestamp`)";
+    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
+        log_error("Unable to create index for timestamp.");
+        goto out;
+    }
+    query = "CREATE INDEX IF NOT EXISTS ChatLogs_to_from_jid_IDX ON `ChatLogs` (`to_jid`, `from_jid`)";
+    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
+        log_error("Unable to create index for to_jid.");
+        goto out;
+    }
+
+    query = "CREATE TABLE IF NOT EXISTS `DbVersion` (`dv_id` INTEGER PRIMARY KEY, `version` INTEGER UNIQUE)";
+    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
+        goto out;
+    }
+
+    if (db_version == -1) {
+        query = "INSERT OR IGNORE INTO `DbVersion` (`version`) VALUES ('2')";
+        if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
+            goto out;
+        }
+        db_version = _get_db_version();
+    }
+
+    // Unlikely event, but we don't want to migrate if we are just unable to determine the DB version
+    if (db_version == -1) {
+        cons_show_error("DB Initialization Error: Unable to check DB version.");
+        goto out;
+    }
+
+    if (db_version < latest_version) {
+        cons_show("Migrating database schema. This operation may take a while...");
+        if (db_version < 2 && (!_check_available_space_for_db_migration(filename) || !_migrate_to_v2())) {
+            cons_show_error("Database Initialization Error: Unable to migrate database to version 2. Please, check error logs for details.");
+            goto out;
+        }
+        cons_show("Database schema migration was successful.");
+    }
+
+    log_debug("Initialized SQLite database: %s", filename);
+    return TRUE;
+
+out:
+    if (err_msg) {
+        log_error("SQLite error in log_database_init(): %s", err_msg);
+        sqlite3_free(err_msg);
+    } else {
+        log_error("Unknown SQLite error in log_database_init().");
+    }
+    _db_teardown("log_database_init(out)");
+    return FALSE;
 }

 void
 log_database_close(void)
 {
-    if (active_db_backend) {
-        active_db_backend->close();
-    }
-    active_db_backend = NULL;
+    log_debug("log_database_close() called");
+    _db_teardown("log_database_close");
 }

 void
 log_database_add_incoming(ProfMessage* message)
 {
-    if (active_db_backend && active_db_backend->add_incoming) {
-        active_db_backend->add_incoming(message);
+    if (message->to_jid) {
+        _add_to_db(message, NULL, message->from_jid, message->to_jid);
+    } else {
+        _add_to_db(message, NULL, message->from_jid, connection_get_jid());
    }
 }

+static void
+_log_database_add_outgoing(const char* type, const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
+{
+    ProfMessage* msg = message_init();
+
+    msg->id = _db_strdup(id);
+    msg->from_jid = jid_create(barejid);
+    msg->plain = _db_strdup(message);
+    msg->replace_id = _db_strdup(replace_id);
+    msg->timestamp = g_date_time_new_now_local(); // TODO: get from outside. best to have whole ProfMessage from outside
+    msg->enc = enc;
+
+    _add_to_db(msg, type, connection_get_jid(), msg->from_jid); // TODO: myjid now in profmessage
+
+    message_free(msg);
+}
+
 void
 log_database_add_outgoing_chat(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
 {
-    if (active_db_backend && active_db_backend->add_outgoing_chat) {
-        active_db_backend->add_outgoing_chat(id, barejid, message, replace_id, enc);
-    }
+    _log_database_add_outgoing("chat", id, barejid, message, replace_id, enc);
 }

 void
 log_database_add_outgoing_muc(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
 {
-    if (active_db_backend && active_db_backend->add_outgoing_muc) {
-        active_db_backend->add_outgoing_muc(id, barejid, message, replace_id, enc);
-    }
+    _log_database_add_outgoing("muc", id, barejid, message, replace_id, enc);
 }

 void
 log_database_add_outgoing_muc_pm(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
 {
-    if (active_db_backend && active_db_backend->add_outgoing_muc_pm) {
-        active_db_backend->add_outgoing_muc_pm(id, barejid, message, replace_id, enc);
-    }
-}
-
-db_history_result_t
-log_database_get_previous_chat(const gchar* const contact_barejid, const gchar* start_time, const gchar* end_time, gboolean from_start, gboolean flip, GSList** result)
-{
-    if (active_db_backend && active_db_backend->get_previous_chat) {
-        return active_db_backend->get_previous_chat(contact_barejid, start_time, end_time, from_start, flip, result);
-    }
-    return DB_RESPONSE_ERROR;
+    _log_database_add_outgoing("mucpm", id, barejid, message, replace_id, enc);
 }

+// Get info (timestamp and stanza_id) of the first or last message in db
 ProfMessage*
 log_database_get_limits_info(const gchar* const contact_barejid, gboolean is_last)
 {
-    if (active_db_backend && active_db_backend->get_limits_info) {
-        return active_db_backend->get_limits_info(contact_barejid, is_last);
-    }
-    // Fallback: return an empty message with sane defaults
+    sqlite3_stmt* stmt = NULL;
+    const Jid* myjid = connection_get_jid();
+    // Always return a valid ProfMessage to avoid NULL dereferences in callers
    ProfMessage* msg = message_init();
-    if (is_last) {
+    if (!myjid || !myjid->str) {
+        // If caller requested the last message and we have no context, fall back to now
+        if (is_last) {
+            msg->timestamp = g_date_time_new_now_utc();
+        }
+        return msg;
+    }
+
+    const char* order = is_last ? "DESC" : "ASC";
+    auto_sqlite char* query = sqlite3_mprintf("SELECT `archive_id`, `timestamp` FROM `ChatLogs` WHERE "
+                                              "(`from_jid` = %Q AND `to_jid` = %Q) OR "
+                                              "(`from_jid` = %Q AND `to_jid` = %Q) "
+                                              "ORDER BY `timestamp` %s LIMIT 1;",
+                                              contact_barejid, myjid->barejid, myjid->barejid, contact_barejid, order);
+
+    if (!query) {
+        log_error("Could not allocate memory for SQL query in log_database_get_limits_info()");
+        if (is_last) {
+            msg->timestamp = g_date_time_new_now_utc();
+        }
+        return msg;
+    }
+
+    if (!_db_prepare_ctx(query, &stmt, "log_database_get_limits_info()")) {
+        if (is_last) {
+            msg->timestamp = g_date_time_new_now_utc();
+        }
+        return msg;
+    }
+
+    if (sqlite3_step(stmt) == SQLITE_ROW) {
+        char* archive_id = (char*)sqlite3_column_text(stmt, 0);
+        char* date = (char*)sqlite3_column_text(stmt, 1);
+
+        msg->stanzaid = _db_strdup(archive_id);
+        msg->timestamp = g_date_time_new_from_iso8601(date, NULL);
+    }
+    sqlite3_finalize(stmt);
+
+    // If nothing was found and caller expects the last message, provide a sane default
+    if (!msg->timestamp && is_last) {
        msg->timestamp = g_date_time_new_now_utc();
    }
+
    return msg;
 }

-GSList*
-log_database_verify_integrity(const gchar* const contact_barejid)
+// Query previous chats, constraints start_time and end_time. If end_time is
+// null the current time is used. from_start gets first few messages if true
+// otherwise the last ones. Flip flips the order of the results
+db_history_result_t
+log_database_get_previous_chat(const gchar* const contact_barejid, const gchar* start_time, const gchar* end_time, gboolean from_start, gboolean flip, GSList** result)
 {
-    if (active_db_backend && active_db_backend->verify_integrity) {
-        return active_db_backend->verify_integrity(contact_barejid);
+    if (!g_chatlog_database) {
+        log_warning("log_database_get_previous_chat() called but db is not initialized");
+        return DB_RESPONSE_ERROR;
+    }
+    sqlite3_stmt* stmt = NULL;
+    const Jid* myjid = connection_get_jid();
+    if (!myjid->str) {
+        log_warning("log_database_get_previous_chat() called but no connection detected.");
+        return DB_RESPONSE_ERROR;
    }

-    GSList* issues = NULL;
-    integrity_issue_t* issue = g_malloc0(sizeof(integrity_issue_t));
-    issue->level = INTEGRITY_WARNING;
-    issue->file = g_strdup("N/A");
-    issue->line = 0;
-    issue->message = g_strdup("Active backend does not support integrity verification");
-    issues = g_slist_append(issues, issue);
-    return issues;
+    // Flip order when querying older pages
+    const gchar* sort1 = from_start ? "ASC" : "DESC";
+    const gchar* sort2 = !flip ? "ASC" : "DESC";
+    GDateTime* now = g_date_time_new_now_local();
+    auto_gchar gchar* end_date_fmt = end_time ? g_strdup(end_time) : g_date_time_format_iso8601(now);
+    auto_sqlite gchar* query = sqlite3_mprintf("SELECT * FROM ("
+                                               "SELECT COALESCE(B.`message`, A.`message`) AS message, "
+                                               "A.`timestamp`, A.`from_jid`, A.`from_resource`, A.`to_jid`, A.`to_resource`, A.`type`, A.`encryption`, A.`stanza_id` FROM `ChatLogs` AS A "
+                                               "LEFT JOIN `ChatLogs` AS B ON (A.`replaced_by_db_id` = B.`id` AND A.`from_jid` = B.`from_jid`) "
+                                               "WHERE (A.`replaces_db_id` IS NULL) "
+                                               "AND ((A.`from_jid` = %Q AND A.`to_jid` = %Q) OR (A.`from_jid` = %Q AND A.`to_jid` = %Q)) "
+                                               "AND A.`timestamp` < %Q "
+                                               "AND (%Q IS NULL OR A.`timestamp` > %Q) "
+                                               "ORDER BY A.`timestamp` %s LIMIT %d) "
+                                               "ORDER BY `timestamp` %s;",
+                                               contact_barejid, myjid->barejid, myjid->barejid, contact_barejid, end_date_fmt, start_time, start_time, sort1, MESSAGES_TO_RETRIEVE, sort2);
+
+    g_date_time_unref(now);
+
+    if (!query) {
+        log_error("Could not allocate memory.");
+        return DB_RESPONSE_ERROR;
+    }
+
+    if (!_db_prepare_ctx(query, &stmt, "log_database_get_previous_chat()")) {
+        return DB_RESPONSE_ERROR;
+    }
+
+    while (sqlite3_step(stmt) == SQLITE_ROW) {
+        char* message = (char*)sqlite3_column_text(stmt, 0);
+        char* date = (char*)sqlite3_column_text(stmt, 1);
+        char* from_jid = (char*)sqlite3_column_text(stmt, 2);
+        char* from_resource = (char*)sqlite3_column_text(stmt, 3);
+        char* to_jid = (char*)sqlite3_column_text(stmt, 4);
+        char* to_resource = (char*)sqlite3_column_text(stmt, 5);
+        char* type = (char*)sqlite3_column_text(stmt, 6);
+        char* encryption = (char*)sqlite3_column_text(stmt, 7);
+        char* id = (char*)sqlite3_column_text(stmt, 8);
+
+        ProfMessage* msg = message_init();
+        msg->id = id ? strdup(id) : NULL;
+        msg->from_jid = jid_create_from_bare_and_resource(from_jid, from_resource);
+        msg->to_jid = jid_create_from_bare_and_resource(to_jid, to_resource);
+        msg->plain = strdup(message ?: "");
+        msg->timestamp = g_date_time_new_from_iso8601(date, NULL);
+        msg->type = _get_message_type_type(type);
+        msg->enc = _get_message_enc_type(encryption);
+
+        *result = g_slist_append(*result, msg);
+    }
+    sqlite3_finalize(stmt);
+
+    return g_slist_length(*result) != 0 ? DB_RESPONSE_SUCCESS : DB_RESPONSE_EMPTY;
+}
+
+static const char*
+_get_message_type_str(prof_msg_type_t type)
+{
+    switch (type) {
+    case PROF_MSG_TYPE_CHAT:
+        return "chat";
+    case PROF_MSG_TYPE_MUC:
+        return "muc";
+    case PROF_MSG_TYPE_MUCPM:
+        return "mucpm";
+    case PROF_MSG_TYPE_UNINITIALIZED:
+        return NULL;
+    }
+    return NULL;
+}
+
+static prof_msg_type_t
+_get_message_type_type(const char* const type)
+{
+    if (g_strcmp0(type, "chat") == 0) {
+        return PROF_MSG_TYPE_CHAT;
+    } else if (g_strcmp0(type, "muc") == 0) {
+        return PROF_MSG_TYPE_MUC;
+    } else if (g_strcmp0(type, "mucpm") == 0) {
+        return PROF_MSG_TYPE_MUCPM;
+    } else {
+        return PROF_MSG_TYPE_UNINITIALIZED;
+    }
+}
+
+static const char*
+_get_message_enc_str(prof_enc_t enc)
+{
+    switch (enc) {
+    case PROF_MSG_ENC_OX:
+        return "ox";
+    case PROF_MSG_ENC_PGP:
+        return "pgp";
+    case PROF_MSG_ENC_OTR:
+        return "otr";
+    case PROF_MSG_ENC_OMEMO:
+        return "omemo";
+    case PROF_MSG_ENC_NONE:
+        return "none";
+    }
+
+    return "none";
+}
+
+static prof_enc_t
+_get_message_enc_type(const char* const encstr)
+{
+    if (g_strcmp0(encstr, "ox") == 0) {
+        return PROF_MSG_ENC_OX;
+    } else if (g_strcmp0(encstr, "pgp") == 0) {
+        return PROF_MSG_ENC_PGP;
+    } else if (g_strcmp0(encstr, "otr") == 0) {
+        return PROF_MSG_ENC_OTR;
+    } else if (g_strcmp0(encstr, "omemo") == 0) {
+        return PROF_MSG_ENC_OMEMO;
+    }
+
+    return PROF_MSG_ENC_NONE;
+}
+
+static void
+_add_to_db(ProfMessage* message, const char* type, const Jid* const from_jid, const Jid* const to_jid)
+{
+    auto_gchar gchar* pref_dblog = prefs_get_string(PREF_DBLOG);
+    sqlite_int64 original_message_id = -1;
+
+    if (g_strcmp0(pref_dblog, "off") == 0) {
+        return;
+    } else if (g_strcmp0(pref_dblog, "redact") == 0) {
+        if (message->plain) {
+            free(message->plain);
+        }
+        message->plain = strdup("[REDACTED]");
+    }
+
+    if (!g_chatlog_database) {
+        log_debug("log_database_add() called but db is not initialized");
+        return;
+    }
+
+    char* err_msg;
+    auto_gchar gchar* date_fmt = NULL;
+
+    if (message->timestamp) {
+        date_fmt = g_date_time_format_iso8601(message->timestamp);
+    } else {
+        GDateTime* dt = g_date_time_new_now_local();
+        date_fmt = g_date_time_format_iso8601(dt);
+        g_date_time_unref(dt);
+    }
+
+    const char* enc = _get_message_enc_str(message->enc);
+
+    if (!type) {
+        type = (char*)_get_message_type_str(message->type);
+    }
+
+    // Apply LMC and check its validity (XEP-0308)
+    if (message->replace_id) {
+        auto_sqlite char* replace_check_query = sqlite3_mprintf("SELECT `id`, `from_jid`, `replaces_db_id` FROM `ChatLogs` WHERE `stanza_id` = %Q ORDER BY `timestamp` DESC LIMIT 1",
+                                                                message->replace_id);
+
+        if (!replace_check_query) {
+            log_error("Could not allocate memory for SQL replace query in log_database_add()");
+            return;
+        }
+
+        sqlite3_stmt* lmc_stmt = NULL;
+        if (!_db_prepare_ctx(replace_check_query, &lmc_stmt, "_add_to_db(replace_check)")) {
+            return;
+        }
+
+        if (sqlite3_step(lmc_stmt) == SQLITE_ROW) {
+            original_message_id = sqlite3_column_int64(lmc_stmt, 0);
+            const char* from_jid_orig = (const char*)sqlite3_column_text(lmc_stmt, 1);
+
+            // Handle non-XEP-compliant replacement messages (edit->edit->original)
+            sqlite_int64 tmp = sqlite3_column_int64(lmc_stmt, 2);
+            original_message_id = tmp ? tmp : original_message_id;
+
+            if (g_strcmp0(from_jid_orig, from_jid->barejid) != 0) {
+                log_error("Mismatch in sender JIDs when trying to do LMC. Corrected message sender: %s. Original message sender: %s. Replace-ID: %s. Message: %s", from_jid->barejid, from_jid_orig, message->replace_id, message->plain);
+                cons_show_error("%s sent a message correction with mismatched sender. See log for details.", from_jid->barejid);
+                sqlite3_finalize(lmc_stmt);
+                return;
+            }
+        } else {
+            log_warning("Got LMC message that does not have original message counterpart in the database from %s", message->from_jid->fulljid);
+        }
+        sqlite3_finalize(lmc_stmt);
+    }
+
+    // stanza-id (XEP-0359) doesn't have to be present in the message.
+    // But if it's duplicated, it's a serious server-side problem, so we better track it.
+    // Unless it's MAM, in that case it's expected behaviour.
+    if (message->stanzaid && !message->is_mam) {
+        auto_sqlite char* duplicate_check_query = sqlite3_mprintf("SELECT 1 FROM `ChatLogs` WHERE (`archive_id` = %Q)",
+                                                                  message->stanzaid);
+
+        if (!duplicate_check_query) {
+            log_error("Could not allocate memory for SQL duplicate query in log_database_add()");
+            return;
+        }
+
+        sqlite3_stmt* stmt;
+        if (_db_prepare_ctx(duplicate_check_query, &stmt, "_add_to_db(duplicate_check)")) {
+            if (sqlite3_step(stmt) == SQLITE_ROW) {
+                log_error("Duplicate stanza-id found for the message. stanza_id: %s; archive_id: %s; sender: %s; content: %s", message->id, message->stanzaid, from_jid->barejid, message->plain);
+                cons_show_error("Got a message with duplicate (server-generated) stanza-id from %s.", from_jid->fulljid);
+            }
+            sqlite3_finalize(stmt);
+        }
+    }
+
+    auto_sqlite char* orig_message_id = original_message_id == -1 ? NULL : sqlite3_mprintf("%d", original_message_id);
+
+    auto_sqlite char* query = sqlite3_mprintf("INSERT INTO `ChatLogs` "
+                                              "(`from_jid`, `from_resource`, `to_jid`, `to_resource`, "
+                                              "`message`, `timestamp`, `stanza_id`, `archive_id`, "
+                                              "`replaces_db_id`, `replace_id`, `type`, `encryption`) "
+                                              "VALUES (%Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q)",
+                                              from_jid->barejid,
+                                              from_jid->resourcepart,
+                                              to_jid->barejid,
+                                              to_jid->resourcepart,
+                                              message->plain,
+                                              date_fmt,
+                                              message->id,
+                                              message->stanzaid,
+                                              orig_message_id,
+                                              message->replace_id,
+                                              type,
+                                              enc);
+    if (!query) {
+        log_error("Could not allocate memory for SQL insert query in log_database_add()");
+        return;
+    }
+
+    log_debug("Writing to DB. Query: %s", query);
+
+    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
+        if (err_msg) {
+            log_error("SQLite error in _add_to_db(): %s", err_msg);
+            sqlite3_free(err_msg);
+        } else {
+            log_error("Unknown SQLite error in _add_to_db().");
+        }
+    } else {
+        int inserted_rows_count = sqlite3_changes(g_chatlog_database);
+        if (inserted_rows_count < 1) {
+            log_error("SQLite did not insert message (rows: %d, id: %s, content: %s)", inserted_rows_count, message->id, message->plain);
+        }
+    }
+}
+
+static int
+_get_db_version(void)
+{
+    int current_version = -1;
+    const char* query = "SELECT `version` FROM `DbVersion` LIMIT 1";
+    sqlite3_stmt* statement;
+    if (_db_prepare_ctx(query, &statement, "_get_db_version()")) {
+        if (sqlite3_step(statement) == SQLITE_ROW) {
+            current_version = sqlite3_column_int(statement, 0);
+        }
+        sqlite3_finalize(statement);
+    }
+    return current_version;
+}
+
+/**
+ * Migration to version 2 introduces new columns. Returns TRUE on success.
+ *
+ * New columns:
+ * `replaces_db_id` database ID for correcting message of the original message
+ * `replaced_by_db_id` database ID for original message of the last correcting message
+ */
+static gboolean
+_migrate_to_v2(void)
+{
+    char* err_msg = NULL;
+
+    // from_resource, to_resource, message, timestamp, stanza_id, archive_id, replace_id, type, encryption
+    const char* sql_statements[] = {
+        "BEGIN TRANSACTION",
+        "ALTER TABLE `ChatLogs` ADD COLUMN `replaces_db_id` INTEGER;",
+        "ALTER TABLE `ChatLogs` ADD COLUMN `replaced_by_db_id` INTEGER;",
+        "UPDATE `ChatLogs` AS A "
+        "SET `replaces_db_id` = B.`id` "
+        "FROM `ChatLogs` AS B "
+        "WHERE A.`replace_id` IS NOT NULL AND A.`replace_id` != '' "
+        "AND A.`replace_id` = B.`stanza_id` "
+        "AND A.`from_jid` = B.`from_jid` AND A.`to_jid` = B.`to_jid`;",
+        "UPDATE `ChatLogs` AS A "
+        "SET `replaced_by_db_id` = B.`id` "
+        "FROM `ChatLogs` AS B "
+        "WHERE (A.`replace_id` IS NULL OR A.`replace_id` = '') "
+        "AND A.`id` = B.`replaces_db_id` "
+        "AND A.`from_jid` = B.`from_jid`;",
+        "UPDATE ChatLogs SET "
+        "from_resource = COALESCE(NULLIF(from_resource, ''), NULL), "
+        "to_resource = COALESCE(NULLIF(to_resource, ''), NULL), "
+        "message = COALESCE(NULLIF(message, ''), NULL), "
+        "timestamp = COALESCE(NULLIF(timestamp, ''), NULL), "
+        "stanza_id = COALESCE(NULLIF(stanza_id, ''), NULL), "
+        "archive_id = COALESCE(NULLIF(archive_id, ''), NULL), "
+        "replace_id = COALESCE(NULLIF(replace_id, ''), NULL), "
+        "type = COALESCE(NULLIF(type, ''), NULL), "
+        "encryption = COALESCE(NULLIF(encryption, ''), NULL);",
+        "UPDATE `DbVersion` SET `version` = 2;",
+        "END TRANSACTION"
+    };
+
+    int statements_count = sizeof(sql_statements) / sizeof(sql_statements[0]);
+
+    for (int i = 0; i < statements_count; i++) {
+        if (SQLITE_OK != sqlite3_exec(g_chatlog_database, sql_statements[i], NULL, 0, &err_msg)) {
+            log_error("SQLite error in _migrate_to_v2() on statement %d: %s", i, err_msg);
+            if (err_msg) {
+                sqlite3_free(err_msg);
+                err_msg = NULL;
+            }
+            goto cleanup;
+        }
+    }
+
+    return TRUE;
+
+cleanup:
+    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, "ROLLBACK;", NULL, 0, &err_msg)) {
+        log_error("[DB Migration] Unable to ROLLBACK: %s", err_msg);
+        if (err_msg) {
+            sqlite3_free(err_msg);
+        }
+    }
+
+    return FALSE;
+}
+
+// Checks if there is more system storage space available than current database takes + 40% (for indexing and other potential size increases)
+static gboolean
+_check_available_space_for_db_migration(char* path_to_db)
+{
+    struct stat file_stat;
+    struct statvfs fs_stat;
+
+    if (statvfs(path_to_db, &fs_stat) == 0 && stat(path_to_db, &file_stat) == 0) {
+        unsigned long long file_size = file_stat.st_size / 1024;
+        unsigned long long available_space_kb = fs_stat.f_frsize * fs_stat.f_bavail / 1024;
+        log_debug("_check_available_space_for_db_migration(): Available space on disk: %llu KB; DB size: %llu KB", available_space_kb, file_size);
+
+        return (available_space_kb >= (file_size + (file_size * 10 / 4)));
+    } else {
+        log_error("Error checking available space.");
+        return FALSE;
+    }
 }
--- a/src/database.h
+++ b/src/database.h
@@ -48,47 +48,6 @@ typedef enum {
    DB_RESPONSE_SUCCESS
 } db_history_result_t;

-// Integrity verification issue levels
-typedef enum {
-    INTEGRITY_ERROR,
-    INTEGRITY_WARNING,
-    INTEGRITY_INFO
-} integrity_level_t;
-
-// A single integrity issue found during verification
-typedef struct
-{
-    integrity_level_t level;
-    char* file;
-    int line;
-    char* message;
-} integrity_issue_t;
-
-void integrity_issue_free(integrity_issue_t* issue);
-
-// Backend vtable: pluggable storage backends implement this interface
-typedef struct db_backend_t
-{
-    const char* name;
-    gboolean (*init)(ProfAccount* account);
-    void (*close)(void);
-    void (*add_incoming)(ProfMessage* message);
-    void (*add_outgoing_chat)(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc);
-    void (*add_outgoing_muc)(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc);
-    void (*add_outgoing_muc_pm)(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc);
-    db_history_result_t (*get_previous_chat)(const gchar* const contact_barejid, const gchar* start_time, const gchar* end_time, gboolean from_start, gboolean flip, GSList** result);
-    ProfMessage* (*get_limits_info)(const gchar* const contact_barejid, gboolean is_last);
-    GSList* (*verify_integrity)(const gchar* const contact_barejid);
-} db_backend_t;
-
-// Active backend (set during init based on PREF_DBLOG)
-extern db_backend_t* active_db_backend;
-
-// Backend registry
-db_backend_t* db_backend_sqlite(void);
-db_backend_t* db_backend_flatfile(void);
-
-// Public API (dispatches to active_db_backend)
 gboolean log_database_init(ProfAccount* account);
 void log_database_add_incoming(ProfMessage* message);
 void log_database_add_outgoing_chat(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc);
@@ -97,6 +56,5 @@ void log_database_add_outgoing_muc_pm(const char* const id, const char* const ba
 db_history_result_t log_database_get_previous_chat(const gchar* const contact_barejid, const gchar* start_time, const gchar* end_time, gboolean from_start, gboolean flip, GSList** result);
 ProfMessage* log_database_get_limits_info(const gchar* const contact_barejid, gboolean is_last);
 void log_database_close(void);
-GSList* log_database_verify_integrity(const gchar* const contact_barejid);

 #endif // DATABASE_H
--- a/src/database_flatfile.c
+++ b/src/database_flatfile.c
--- a/src/database_sqlite.c
+++ b/src/database_sqlite.c
@@ -1,819 +0,0 @@
-/*
- * database_sqlite.c
- * vim: expandtab:ts=4:sts=4:sw=4
- *
- * Copyright (C) 2020 - 2025 Michael Vetter <jubalh@iodoru.org>
- *
- * This file is part of Profanity.
- *
- * Profanity is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Profanity is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Profanity.  If not, see <https://www.gnu.org/licenses/>.
- *
- * In addition, as a special exception, the copyright holders give permission to
- * link the code of portions of this program with the OpenSSL library under
- * certain conditions as described in each individual source file, and
- * distribute linked combinations including the two.
- *
- * You must obey the GNU General Public License in all respects for all of the
- * code used other than OpenSSL. If you modify file(s) with this exception, you
- * may extend this exception to your version of the file(s), but you are not
- * obligated to do so. If you do not wish to do so, delete this exception
- * statement from your version. If you delete this exception statement from all
- * source files in the program, then also delete it here.
- *
- */
-
-#include "config.h"
-
-#include <sys/stat.h>
-#include <sys/statvfs.h>
-#include <sqlite3.h>
-#include <glib.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-
-#include "log.h"
-#include "common.h"
-#include "config/files.h"
-#include "database.h"
-#include "config/preferences.h"
-#include "ui/ui.h"
-#include "xmpp/xmpp.h"
-#include "xmpp/message.h"
-
-static sqlite3* g_chatlog_database;
-
-static void _add_to_db(ProfMessage* message, char* type, const Jid* const from_jid, const Jid* const to_jid);
-static char* _get_db_filename(ProfAccount* account);
-static prof_msg_type_t _get_message_type_type(const char* const type);
-static prof_enc_t _get_message_enc_type(const char* const encstr);
-static int _get_db_version(void);
-static gboolean _migrate_to_v2(void);
-static gboolean _check_available_space_for_db_migration(char* path_to_db);
-
-static const int latest_version = 2;
-
-// Helper: close DB handle (if any), warn on busy, and shutdown SQLite
-static void
-_db_teardown(const char* ctx)
-{
-    if (g_chatlog_database) {
-        int rc = sqlite3_close_v2(g_chatlog_database);
-        if (rc != SQLITE_OK) {
-            log_warning("sqlite3_close_v2 in %s returned %d; database may still have active statements.",
-                        ctx ? ctx : "db_teardown", rc);
-        }
-        g_chatlog_database = NULL;
-    }
-    sqlite3_shutdown();
-}
-
-// Helper: prepare a statement and log a contextual error on failure
-static gboolean
-_db_prepare_ctx(const char* query, sqlite3_stmt** stmt, const char* ctx)
-{
-    int rc = sqlite3_prepare_v2(g_chatlog_database, query, -1, stmt, NULL);
-    if (rc != SQLITE_OK) {
-        log_error("SQLite error in %s: (error code: %d) %s",
-                  ctx ? ctx : "sqlite3_prepare_v2",
-                  rc,
-                  sqlite3_errmsg(g_chatlog_database));
-        return FALSE;
-    }
-    return TRUE;
-}
-
-static char*
-_db_strdup(const char* str)
-{
-    return str ? strdup(str) : NULL;
-}
-
-#define auto_sqlite __attribute__((__cleanup__(auto_free_sqlite)))
-
-static void
-auto_free_sqlite(gchar** str)
-{
-    if (str == NULL)
-        return;
-    sqlite3_free(*str);
-}
-
-static char*
-_get_db_filename(ProfAccount* account)
-{
-    return files_file_in_account_data_path(DIR_DATABASE, account->jid, "chatlog.db");
-}
-
-static gboolean
-_sqlite_init(ProfAccount* account)
-{
-    int ret = sqlite3_initialize();
-    if (ret != SQLITE_OK) {
-        log_error("Error initializing SQLite database: %d", ret);
-        return FALSE;
-    }
-
-    auto_char char* filename = _get_db_filename(account);
-    if (!filename) {
-        sqlite3_shutdown();
-        return FALSE;
-    }
-
-    ret = sqlite3_open(filename, &g_chatlog_database);
-    if (ret != SQLITE_OK) {
-        const char* err_msg = g_chatlog_database ? sqlite3_errmsg(g_chatlog_database) : "(no handle)";
-        log_error("Error opening SQLite database: %s", err_msg);
-        _db_teardown("_sqlite_init(open)");
-        return FALSE;
-    }
-
-    char* err_msg = NULL;
-
-    int db_version = _get_db_version();
-    if (db_version == latest_version) {
-        return TRUE;
-    }
-
-    char* query = "CREATE TABLE IF NOT EXISTS `ChatLogs` ("
-                  "`id` INTEGER PRIMARY KEY AUTOINCREMENT, "
-                  "`from_jid` TEXT NOT NULL, "
-                  "`to_jid` TEXT NOT NULL, "
-                  "`from_resource` TEXT, "
-                  "`to_resource` TEXT, "
-                  "`message` TEXT, "
-                  "`timestamp` TEXT, "
-                  "`type` TEXT, "
-                  "`stanza_id` TEXT, "
-                  "`archive_id` TEXT, "
-                  "`encryption` TEXT, "
-                  "`marked_read` INTEGER, "
-                  "`replace_id` TEXT, "
-                  "`replaces_db_id` INTEGER, "
-                  "`replaced_by_db_id` INTEGER)";
-    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
-        goto out;
-    }
-
-    query = "CREATE TRIGGER IF NOT EXISTS update_corrected_message "
-            "AFTER INSERT ON ChatLogs "
-            "FOR EACH ROW "
-            "WHEN NEW.replaces_db_id IS NOT NULL "
-            "BEGIN "
-            "UPDATE ChatLogs "
-            "SET replaced_by_db_id = NEW.id "
-            "WHERE id = NEW.replaces_db_id; "
-            "END;";
-    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
-        log_error("Unable to add `update_corrected_message` trigger.");
-        goto out;
-    }
-
-    query = "CREATE INDEX IF NOT EXISTS ChatLogs_timestamp_IDX ON `ChatLogs` (`timestamp`)";
-    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
-        log_error("Unable to create index for timestamp.");
-        goto out;
-    }
-    query = "CREATE INDEX IF NOT EXISTS ChatLogs_to_from_jid_IDX ON `ChatLogs` (`to_jid`, `from_jid`)";
-    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
-        log_error("Unable to create index for to_jid.");
-        goto out;
-    }
-
-    query = "CREATE TABLE IF NOT EXISTS `DbVersion` (`dv_id` INTEGER PRIMARY KEY, `version` INTEGER UNIQUE)";
-    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
-        goto out;
-    }
-
-    if (db_version == -1) {
-        query = "INSERT OR IGNORE INTO `DbVersion` (`version`) VALUES ('2')";
-        if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
-            goto out;
-        }
-        db_version = _get_db_version();
-    }
-
-    if (db_version == -1) {
-        cons_show_error("DB Initialization Error: Unable to check DB version.");
-        goto out;
-    }
-
-    if (db_version < latest_version) {
-        cons_show("Migrating database schema. This operation may take a while...");
-        if (db_version < 2 && (!_check_available_space_for_db_migration(filename) || !_migrate_to_v2())) {
-            cons_show_error("Database Initialization Error: Unable to migrate database to version 2. Please, check error logs for details.");
-            goto out;
-        }
-        cons_show("Database schema migration was successful.");
-    }
-
-    log_debug("Initialized SQLite database: %s", filename);
-    return TRUE;
-
-out:
-    if (err_msg) {
-        log_error("SQLite error in _sqlite_init(): %s", err_msg);
-        sqlite3_free(err_msg);
-    } else {
-        log_error("Unknown SQLite error in _sqlite_init().");
-    }
-    _db_teardown("_sqlite_init(out)");
-    return FALSE;
-}
-
-static void
-_sqlite_close(void)
-{
-    log_debug("_sqlite_close() called");
-    _db_teardown("_sqlite_close");
-}
-
-static void
-_sqlite_add_incoming(ProfMessage* message)
-{
-    if (message->to_jid) {
-        _add_to_db(message, NULL, message->from_jid, message->to_jid);
-    } else {
-        _add_to_db(message, NULL, message->from_jid, connection_get_jid());
-    }
-}
-
-static void
-_log_database_add_outgoing(char* type, const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
-{
-    ProfMessage* msg = message_init();
-
-    msg->id = _db_strdup(id);
-    msg->from_jid = jid_create(barejid);
-    msg->plain = _db_strdup(message);
-    msg->replace_id = _db_strdup(replace_id);
-    msg->timestamp = g_date_time_new_now_local();
-    msg->enc = enc;
-
-    _add_to_db(msg, type, connection_get_jid(), msg->from_jid);
-
-    message_free(msg);
-}
-
-static void
-_sqlite_add_outgoing_chat(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
-{
-    _log_database_add_outgoing("chat", id, barejid, message, replace_id, enc);
-}
-
-static void
-_sqlite_add_outgoing_muc(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
-{
-    _log_database_add_outgoing("muc", id, barejid, message, replace_id, enc);
-}
-
-static void
-_sqlite_add_outgoing_muc_pm(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
-{
-    _log_database_add_outgoing("mucpm", id, barejid, message, replace_id, enc);
-}
-
-static ProfMessage*
-_sqlite_get_limits_info(const gchar* const contact_barejid, gboolean is_last)
-{
-    sqlite3_stmt* stmt = NULL;
-    const Jid* myjid = connection_get_jid();
-    ProfMessage* msg = message_init();
-    if (!myjid || !myjid->str) {
-        if (is_last) {
-            msg->timestamp = g_date_time_new_now_utc();
-        }
-        return msg;
-    }
-
-    const char* order = is_last ? "DESC" : "ASC";
-    auto_sqlite char* query = sqlite3_mprintf("SELECT `archive_id`, `timestamp` FROM `ChatLogs` WHERE "
-                                              "(`from_jid` = %Q AND `to_jid` = %Q) OR "
-                                              "(`from_jid` = %Q AND `to_jid` = %Q) "
-                                              "ORDER BY `timestamp` %s LIMIT 1;",
-                                              contact_barejid, myjid->barejid, myjid->barejid, contact_barejid, order);
-
-    if (!query) {
-        log_error("Could not allocate memory for SQL query in _sqlite_get_limits_info()");
-        if (is_last) {
-            msg->timestamp = g_date_time_new_now_utc();
-        }
-        return msg;
-    }
-
-    if (!_db_prepare_ctx(query, &stmt, "_sqlite_get_limits_info()")) {
-        if (is_last) {
-            msg->timestamp = g_date_time_new_now_utc();
-        }
-        return msg;
-    }
-
-    if (sqlite3_step(stmt) == SQLITE_ROW) {
-        char* archive_id = (char*)sqlite3_column_text(stmt, 0);
-        char* date = (char*)sqlite3_column_text(stmt, 1);
-
-        msg->stanzaid = _db_strdup(archive_id);
-        msg->timestamp = g_date_time_new_from_iso8601(date, NULL);
-    }
-    sqlite3_finalize(stmt);
-
-    if (!msg->timestamp && is_last) {
-        msg->timestamp = g_date_time_new_now_utc();
-    }
-
-    return msg;
-}
-
-static db_history_result_t
-_sqlite_get_previous_chat(const gchar* const contact_barejid, const gchar* start_time, const gchar* end_time, gboolean from_start, gboolean flip, GSList** result)
-{
-    if (!g_chatlog_database) {
-        log_warning("_sqlite_get_previous_chat() called but db is not initialized");
-        return DB_RESPONSE_ERROR;
-    }
-    sqlite3_stmt* stmt = NULL;
-    const Jid* myjid = connection_get_jid();
-    if (!myjid->str) {
-        log_warning("_sqlite_get_previous_chat() called but no connection detected.");
-        return DB_RESPONSE_ERROR;
-    }
-
-    gchar* sort1 = from_start ? "ASC" : "DESC";
-    gchar* sort2 = !flip ? "ASC" : "DESC";
-    GDateTime* now = g_date_time_new_now_local();
-    auto_gchar gchar* end_date_fmt = end_time ? g_strdup(end_time) : g_date_time_format_iso8601(now);
-    auto_sqlite gchar* query = sqlite3_mprintf("SELECT * FROM ("
-                                               "SELECT COALESCE(B.`message`, A.`message`) AS message, "
-                                               "A.`timestamp`, A.`from_jid`, A.`from_resource`, A.`to_jid`, A.`to_resource`, A.`type`, A.`encryption`, A.`stanza_id` FROM `ChatLogs` AS A "
-                                               "LEFT JOIN `ChatLogs` AS B ON (A.`replaced_by_db_id` = B.`id` AND A.`from_jid` = B.`from_jid`) "
-                                               "WHERE (A.`replaces_db_id` IS NULL) "
-                                               "AND ((A.`from_jid` = %Q AND A.`to_jid` = %Q) OR (A.`from_jid` = %Q AND A.`to_jid` = %Q)) "
-                                               "AND A.`timestamp` < %Q "
-                                               "AND (%Q IS NULL OR A.`timestamp` > %Q) "
-                                               "ORDER BY A.`timestamp` %s LIMIT %d) "
-                                               "ORDER BY `timestamp` %s;",
-                                               contact_barejid, myjid->barejid, myjid->barejid, contact_barejid, end_date_fmt, start_time, start_time, sort1, MESSAGES_TO_RETRIEVE, sort2);
-
-    g_date_time_unref(now);
-
-    if (!query) {
-        log_error("Could not allocate memory.");
-        return DB_RESPONSE_ERROR;
-    }
-
-    if (!_db_prepare_ctx(query, &stmt, "_sqlite_get_previous_chat()")) {
-        return DB_RESPONSE_ERROR;
-    }
-
-    while (sqlite3_step(stmt) == SQLITE_ROW) {
-        char* message = (char*)sqlite3_column_text(stmt, 0);
-        char* date = (char*)sqlite3_column_text(stmt, 1);
-        char* from_jid = (char*)sqlite3_column_text(stmt, 2);
-        char* from_resource = (char*)sqlite3_column_text(stmt, 3);
-        char* to_jid = (char*)sqlite3_column_text(stmt, 4);
-        char* to_resource = (char*)sqlite3_column_text(stmt, 5);
-        char* type = (char*)sqlite3_column_text(stmt, 6);
-        char* encryption = (char*)sqlite3_column_text(stmt, 7);
-        char* id = (char*)sqlite3_column_text(stmt, 8);
-
-        ProfMessage* msg = message_init();
-        msg->id = id ? strdup(id) : NULL;
-        msg->from_jid = jid_create_from_bare_and_resource(from_jid, from_resource);
-        msg->to_jid = jid_create_from_bare_and_resource(to_jid, to_resource);
-        msg->plain = strdup(message ?: "");
-        msg->timestamp = g_date_time_new_from_iso8601(date, NULL);
-        msg->type = _get_message_type_type(type);
-        msg->enc = _get_message_enc_type(encryption);
-
-        *result = g_slist_append(*result, msg);
-    }
-    sqlite3_finalize(stmt);
-
-    return g_slist_length(*result) != 0 ? DB_RESPONSE_SUCCESS : DB_RESPONSE_EMPTY;
-}
-
-static GSList*
-_sqlite_verify_integrity(const gchar* const contact_barejid)
-{
-    GSList* issues = NULL;
-
-    if (!g_chatlog_database) {
-        integrity_issue_t* issue = g_malloc0(sizeof(integrity_issue_t));
-        issue->level = INTEGRITY_ERROR;
-        issue->file = g_strdup("chatlog.db");
-        issue->line = 0;
-        issue->message = g_strdup("Database not initialized");
-        issues = g_slist_append(issues, issue);
-        return issues;
-    }
-
-    // PRAGMA integrity_check
-    sqlite3_stmt* stmt = NULL;
-    if (_db_prepare_ctx("PRAGMA integrity_check", &stmt, "_sqlite_verify_integrity()")) {
-        while (sqlite3_step(stmt) == SQLITE_ROW) {
-            const char* result = (const char*)sqlite3_column_text(stmt, 0);
-            if (g_strcmp0(result, "ok") != 0) {
-                integrity_issue_t* issue = g_malloc0(sizeof(integrity_issue_t));
-                issue->level = INTEGRITY_ERROR;
-                issue->file = g_strdup("chatlog.db");
-                issue->line = 0;
-                issue->message = g_strdup_printf("SQLite integrity check: %s", result);
-                issues = g_slist_append(issues, issue);
-            }
-        }
-        sqlite3_finalize(stmt);
-    }
-
-    // Check timestamp ordering for a specific contact or all
-    const Jid* myjid = connection_get_jid();
-    if (myjid && myjid->barejid) {
-        auto_sqlite char* query = NULL;
-        if (contact_barejid) {
-            query = sqlite3_mprintf(
-                "SELECT A.`id`, A.`timestamp`, B.`id`, B.`timestamp` FROM `ChatLogs` A "
-                "JOIN `ChatLogs` B ON B.`id` = A.`id` + 1 "
-                "WHERE A.`timestamp` > B.`timestamp` "
-                "AND ((A.`from_jid` = %Q AND A.`to_jid` = %Q) OR (A.`from_jid` = %Q AND A.`to_jid` = %Q)) "
-                "LIMIT 50",
-                contact_barejid, myjid->barejid, myjid->barejid, contact_barejid);
-        } else {
-            query = sqlite3_mprintf(
-                "SELECT A.`id`, A.`timestamp`, B.`id`, B.`timestamp` FROM `ChatLogs` A "
-                "JOIN `ChatLogs` B ON B.`id` = A.`id` + 1 "
-                "WHERE A.`timestamp` > B.`timestamp` "
-                "LIMIT 50");
-        }
-
-        if (query && _db_prepare_ctx(query, &stmt, "_sqlite_verify_integrity(timestamp_order)")) {
-            while (sqlite3_step(stmt) == SQLITE_ROW) {
-                int id_a = sqlite3_column_int(stmt, 0);
-                const char* ts_a = (const char*)sqlite3_column_text(stmt, 1);
-                int id_b = sqlite3_column_int(stmt, 2);
-                const char* ts_b = (const char*)sqlite3_column_text(stmt, 3);
-
-                integrity_issue_t* issue = g_malloc0(sizeof(integrity_issue_t));
-                issue->level = INTEGRITY_WARNING;
-                issue->file = g_strdup("chatlog.db");
-                issue->line = id_a;
-                issue->message = g_strdup_printf("Timestamp out of order: row %d (%s) > row %d (%s)",
-                                                 id_a, ts_a ? ts_a : "NULL", id_b, ts_b ? ts_b : "NULL");
-                issues = g_slist_append(issues, issue);
-            }
-            sqlite3_finalize(stmt);
-        }
-
-        // Check broken LMC references
-        auto_sqlite char* lmc_query = sqlite3_mprintf(
-            "SELECT A.`id`, A.`replaces_db_id` FROM `ChatLogs` A "
-            "WHERE A.`replaces_db_id` IS NOT NULL "
-            "AND NOT EXISTS (SELECT 1 FROM `ChatLogs` B WHERE B.`id` = A.`replaces_db_id`) "
-            "LIMIT 50");
-
-        if (lmc_query && _db_prepare_ctx(lmc_query, &stmt, "_sqlite_verify_integrity(lmc_check)")) {
-            while (sqlite3_step(stmt) == SQLITE_ROW) {
-                int id = sqlite3_column_int(stmt, 0);
-                int replaces_id = sqlite3_column_int(stmt, 1);
-
-                integrity_issue_t* issue = g_malloc0(sizeof(integrity_issue_t));
-                issue->level = INTEGRITY_ERROR;
-                issue->file = g_strdup("chatlog.db");
-                issue->line = id;
-                issue->message = g_strdup_printf("Broken LMC reference: row %d references non-existent row %d",
-                                                 id, replaces_id);
-                issues = g_slist_append(issues, issue);
-            }
-            sqlite3_finalize(stmt);
-        }
-    }
-
-    return issues;
-}
-
-// --- Type conversion helpers ---
-
-static const char*
-_get_message_type_str(prof_msg_type_t type)
-{
-    switch (type) {
-    case PROF_MSG_TYPE_CHAT:
-        return "chat";
-    case PROF_MSG_TYPE_MUC:
-        return "muc";
-    case PROF_MSG_TYPE_MUCPM:
-        return "mucpm";
-    case PROF_MSG_TYPE_UNINITIALIZED:
-        return NULL;
-    }
-    return NULL;
-}
-
-static prof_msg_type_t
-_get_message_type_type(const char* const type)
-{
-    if (g_strcmp0(type, "chat") == 0) {
-        return PROF_MSG_TYPE_CHAT;
-    } else if (g_strcmp0(type, "muc") == 0) {
-        return PROF_MSG_TYPE_MUC;
-    } else if (g_strcmp0(type, "mucpm") == 0) {
-        return PROF_MSG_TYPE_MUCPM;
-    } else {
-        return PROF_MSG_TYPE_UNINITIALIZED;
-    }
-}
-
-static const char*
-_get_message_enc_str(prof_enc_t enc)
-{
-    switch (enc) {
-    case PROF_MSG_ENC_OX:
-        return "ox";
-    case PROF_MSG_ENC_PGP:
-        return "pgp";
-    case PROF_MSG_ENC_OTR:
-        return "otr";
-    case PROF_MSG_ENC_OMEMO:
-        return "omemo";
-    case PROF_MSG_ENC_NONE:
-        return "none";
-    }
-
-    return "none";
-}
-
-static prof_enc_t
-_get_message_enc_type(const char* const encstr)
-{
-    if (g_strcmp0(encstr, "ox") == 0) {
-        return PROF_MSG_ENC_OX;
-    } else if (g_strcmp0(encstr, "pgp") == 0) {
-        return PROF_MSG_ENC_PGP;
-    } else if (g_strcmp0(encstr, "otr") == 0) {
-        return PROF_MSG_ENC_OTR;
-    } else if (g_strcmp0(encstr, "omemo") == 0) {
-        return PROF_MSG_ENC_OMEMO;
-    }
-
-    return PROF_MSG_ENC_NONE;
-}
-
-// --- Core write logic ---
-
-static void
-_add_to_db(ProfMessage* message, char* type, const Jid* const from_jid, const Jid* const to_jid)
-{
-    auto_gchar gchar* pref_dblog = prefs_get_string(PREF_DBLOG);
-    sqlite_int64 original_message_id = -1;
-
-    if (g_strcmp0(pref_dblog, "off") == 0) {
-        return;
-    } else if (g_strcmp0(pref_dblog, "redact") == 0) {
-        if (message->plain) {
-            free(message->plain);
-        }
-        message->plain = strdup("[REDACTED]");
-    }
-
-    if (!g_chatlog_database) {
-        log_debug("_add_to_db() called but db is not initialized");
-        return;
-    }
-
-    char* err_msg;
-    auto_gchar gchar* date_fmt = NULL;
-
-    if (message->timestamp) {
-        date_fmt = g_date_time_format_iso8601(message->timestamp);
-    } else {
-        GDateTime* dt = g_date_time_new_now_local();
-        date_fmt = g_date_time_format_iso8601(dt);
-        g_date_time_unref(dt);
-    }
-
-    const char* enc = _get_message_enc_str(message->enc);
-
-    if (!type) {
-        type = (char*)_get_message_type_str(message->type);
-    }
-
-    // Apply LMC and check its validity (XEP-0308)
-    if (message->replace_id) {
-        auto_sqlite char* replace_check_query = sqlite3_mprintf("SELECT `id`, `from_jid`, `replaces_db_id` FROM `ChatLogs` WHERE `stanza_id` = %Q ORDER BY `timestamp` DESC LIMIT 1",
-                                                                message->replace_id);
-
-        if (!replace_check_query) {
-            log_error("Could not allocate memory for SQL replace query in _add_to_db()");
-            return;
-        }
-
-        sqlite3_stmt* lmc_stmt = NULL;
-        if (!_db_prepare_ctx(replace_check_query, &lmc_stmt, "_add_to_db(replace_check)")) {
-            return;
-        }
-
-        if (sqlite3_step(lmc_stmt) == SQLITE_ROW) {
-            original_message_id = sqlite3_column_int64(lmc_stmt, 0);
-            const char* from_jid_orig = (const char*)sqlite3_column_text(lmc_stmt, 1);
-
-            sqlite_int64 tmp = sqlite3_column_int64(lmc_stmt, 2);
-            original_message_id = tmp ? tmp : original_message_id;
-
-            if (g_strcmp0(from_jid_orig, from_jid->barejid) != 0) {
-                log_error("Mismatch in sender JIDs when trying to do LMC. Corrected message sender: %s. Original message sender: %s. Replace-ID: %s. Message: %s", from_jid->barejid, from_jid_orig, message->replace_id, message->plain);
-                cons_show_error("%s sent a message correction with mismatched sender. See log for details.", from_jid->barejid);
-                sqlite3_finalize(lmc_stmt);
-                return;
-            }
-        } else {
-            log_warning("Got LMC message that does not have original message counterpart in the database from %s", message->from_jid->fulljid);
-        }
-        sqlite3_finalize(lmc_stmt);
-    }
-
-    if (message->stanzaid && !message->is_mam) {
-        auto_sqlite char* duplicate_check_query = sqlite3_mprintf("SELECT 1 FROM `ChatLogs` WHERE (`archive_id` = %Q)",
-                                                                  message->stanzaid);
-
-        if (!duplicate_check_query) {
-            log_error("Could not allocate memory for SQL duplicate query in _add_to_db()");
-            return;
-        }
-
-        sqlite3_stmt* stmt;
-        if (_db_prepare_ctx(duplicate_check_query, &stmt, "_add_to_db(duplicate_check)")) {
-            if (sqlite3_step(stmt) == SQLITE_ROW) {
-                log_error("Duplicate stanza-id found for the message. stanza_id: %s; archive_id: %s; sender: %s; content: %s", message->id, message->stanzaid, from_jid->barejid, message->plain);
-                cons_show_error("Got a message with duplicate (server-generated) stanza-id from %s.", from_jid->fulljid);
-            }
-            sqlite3_finalize(stmt);
-        }
-    }
-
-    auto_sqlite char* orig_message_id = original_message_id == -1 ? NULL : sqlite3_mprintf("%d", original_message_id);
-
-    auto_sqlite char* query = sqlite3_mprintf("INSERT INTO `ChatLogs` "
-                                              "(`from_jid`, `from_resource`, `to_jid`, `to_resource`, "
-                                              "`message`, `timestamp`, `stanza_id`, `archive_id`, "
-                                              "`replaces_db_id`, `replace_id`, `type`, `encryption`) "
-                                              "VALUES (%Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q)",
-                                              from_jid->barejid,
-                                              from_jid->resourcepart,
-                                              to_jid->barejid,
-                                              to_jid->resourcepart,
-                                              message->plain,
-                                              date_fmt,
-                                              message->id,
-                                              message->stanzaid,
-                                              orig_message_id,
-                                              message->replace_id,
-                                              type,
-                                              enc);
-    if (!query) {
-        log_error("Could not allocate memory for SQL insert query in _add_to_db()");
-        return;
-    }
-
-    log_debug("Writing to DB. Query: %s", query);
-
-    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, query, NULL, 0, &err_msg)) {
-        if (err_msg) {
-            log_error("SQLite error in _add_to_db(): %s", err_msg);
-            sqlite3_free(err_msg);
-        } else {
-            log_error("Unknown SQLite error in _add_to_db().");
-        }
-    } else {
-        int inserted_rows_count = sqlite3_changes(g_chatlog_database);
-        if (inserted_rows_count < 1) {
-            log_error("SQLite did not insert message (rows: %d, id: %s, content: %s)", inserted_rows_count, message->id, message->plain);
-        }
-    }
-}
-
-// --- DB version and migration ---
-
-static int
-_get_db_version(void)
-{
-    int current_version = -1;
-    const char* query = "SELECT `version` FROM `DbVersion` LIMIT 1";
-    sqlite3_stmt* statement;
-    if (_db_prepare_ctx(query, &statement, "_get_db_version()")) {
-        if (sqlite3_step(statement) == SQLITE_ROW) {
-            current_version = sqlite3_column_int(statement, 0);
-        }
-        sqlite3_finalize(statement);
-    }
-    return current_version;
-}
-
-static gboolean
-_migrate_to_v2(void)
-{
-    char* err_msg = NULL;
-
-    const char* sql_statements[] = {
-        "BEGIN TRANSACTION",
-        "ALTER TABLE `ChatLogs` ADD COLUMN `replaces_db_id` INTEGER;",
-        "ALTER TABLE `ChatLogs` ADD COLUMN `replaced_by_db_id` INTEGER;",
-        "UPDATE `ChatLogs` AS A "
-        "SET `replaces_db_id` = B.`id` "
-        "FROM `ChatLogs` AS B "
-        "WHERE A.`replace_id` IS NOT NULL AND A.`replace_id` != '' "
-        "AND A.`replace_id` = B.`stanza_id` "
-        "AND A.`from_jid` = B.`from_jid` AND A.`to_jid` = B.`to_jid`;",
-        "UPDATE `ChatLogs` AS A "
-        "SET `replaced_by_db_id` = B.`id` "
-        "FROM `ChatLogs` AS B "
-        "WHERE (A.`replace_id` IS NULL OR A.`replace_id` = '') "
-        "AND A.`id` = B.`replaces_db_id` "
-        "AND A.`from_jid` = B.`from_jid`;",
-        "UPDATE ChatLogs SET "
-        "from_resource = COALESCE(NULLIF(from_resource, ''), NULL), "
-        "to_resource = COALESCE(NULLIF(to_resource, ''), NULL), "
-        "message = COALESCE(NULLIF(message, ''), NULL), "
-        "timestamp = COALESCE(NULLIF(timestamp, ''), NULL), "
-        "stanza_id = COALESCE(NULLIF(stanza_id, ''), NULL), "
-        "archive_id = COALESCE(NULLIF(archive_id, ''), NULL), "
-        "replace_id = COALESCE(NULLIF(replace_id, ''), NULL), "
-        "type = COALESCE(NULLIF(type, ''), NULL), "
-        "encryption = COALESCE(NULLIF(encryption, ''), NULL);",
-        "UPDATE `DbVersion` SET `version` = 2;",
-        "END TRANSACTION"
-    };
-
-    int statements_count = sizeof(sql_statements) / sizeof(sql_statements[0]);
-
-    for (int i = 0; i < statements_count; i++) {
-        if (SQLITE_OK != sqlite3_exec(g_chatlog_database, sql_statements[i], NULL, 0, &err_msg)) {
-            log_error("SQLite error in _migrate_to_v2() on statement %d: %s", i, err_msg);
-            if (err_msg) {
-                sqlite3_free(err_msg);
-                err_msg = NULL;
-            }
-            goto cleanup;
-        }
-    }
-
-    return TRUE;
-
-cleanup:
-    if (SQLITE_OK != sqlite3_exec(g_chatlog_database, "ROLLBACK;", NULL, 0, &err_msg)) {
-        log_error("[DB Migration] Unable to ROLLBACK: %s", err_msg);
-        if (err_msg) {
-            sqlite3_free(err_msg);
-        }
-    }
-
-    return FALSE;
-}
-
-static gboolean
-_check_available_space_for_db_migration(char* path_to_db)
-{
-    struct stat file_stat;
-    struct statvfs fs_stat;
-
-    if (statvfs(path_to_db, &fs_stat) == 0 && stat(path_to_db, &file_stat) == 0) {
-        unsigned long long file_size = file_stat.st_size / 1024;
-        unsigned long long available_space_kb = fs_stat.f_frsize * fs_stat.f_bavail / 1024;
-        log_debug("_check_available_space_for_db_migration(): Available space on disk: %llu KB; DB size: %llu KB", available_space_kb, file_size);
-
-        return (available_space_kb >= (file_size + (file_size * 10 / 4)));
-    } else {
-        log_error("Error checking available space.");
-        return FALSE;
-    }
-}
-
-// --- Backend vtable ---
-
-static db_backend_t sqlite_backend = {
-    .name = "sqlite",
-    .init = _sqlite_init,
-    .close = _sqlite_close,
-    .add_incoming = _sqlite_add_incoming,
-    .add_outgoing_chat = _sqlite_add_outgoing_chat,
-    .add_outgoing_muc = _sqlite_add_outgoing_muc,
-    .add_outgoing_muc_pm = _sqlite_add_outgoing_muc_pm,
-    .get_previous_chat = _sqlite_get_previous_chat,
-    .get_limits_info = _sqlite_get_limits_info,
-    .verify_integrity = _sqlite_verify_integrity,
-};
-
-db_backend_t*
-db_backend_sqlite(void)
-{
-    return &sqlite_backend;
-}
--- a/src/log.h
+++ b/src/log.h
@@ -54,9 +54,13 @@ void log_init(log_level_t filter, const char* const log_file);
 log_level_t log_get_filter(void);
 void log_close(void);
 const gchar* get_log_file_location(void);
+G_GNUC_PRINTF(1, 2)
 void log_debug(const char* const msg, ...);
+G_GNUC_PRINTF(1, 2)
 void log_info(const char* const msg, ...);
+G_GNUC_PRINTF(1, 2)
 void log_warning(const char* const msg, ...);
+G_GNUC_PRINTF(1, 2)
 void log_error(const char* const msg, ...);
 void log_msg(log_level_t level, const char* const area, const char* const msg);
 int log_level_from_string(char* log_level, log_level_t* level);
--- a/src/omemo/omemo.c
+++ b/src/omemo/omemo.c
@@ -537,7 +537,7 @@ omemo_set_device_list(const char* const from, GList* device_list)
                        g_hash_table_iter_init(&iter, known_identities);
                        while (g_hash_table_iter_next(&iter, &key, &value)) {
                            if (device_id->data == value) {
-                                cons_show("OMEMO: Adding firstusage trust for %s device %d - Fingerprint %s", jid->barejid, device_id->data, omemo_format_fingerprint(key));
+                                cons_show("OMEMO: Adding firstusage trust for %s device %d - Fingerprint %s", jid->barejid, GPOINTER_TO_INT(device_id->data), omemo_format_fingerprint(key));
                                omemo_trust(jid->barejid, omemo_format_fingerprint(key));
                            }
                        }
@@ -744,8 +744,8 @@ omemo_on_message_send(ProfWin* win, const char* const message, gboolean request_
        GList* recipient_device_id = NULL;
        recipient_device_id = g_hash_table_lookup(omemo_ctx.device_list, recipients_iter->data);
        if (!recipient_device_id) {
-            log_warning("[OMEMO][SEND] cannot find device ids for %s", recipients_iter->data);
-            win_println(win, THEME_ERROR, "!", "Can't find a OMEMO device id for %s.\n", recipients_iter->data);
+            log_warning("[OMEMO][SEND] cannot find device ids for %s", (char*)recipients_iter->data);
+            win_println(win, THEME_ERROR, "!", "Can't find a OMEMO device id for %s.\n", (char*)recipients_iter->data);
            continue;
        }

@@ -769,7 +769,7 @@ omemo_on_message_send(ProfWin* win, const char* const message, gboolean request_
                }
            }

-            log_debug("[OMEMO][SEND] recipients with device id %d for %s", GPOINTER_TO_INT(device_ids_iter->data), recipients_iter->data);
+            log_debug("[OMEMO][SEND] recipients with device id %d for %s", GPOINTER_TO_INT(device_ids_iter->data), (char*)recipients_iter->data);
            res = session_cipher_create(&cipher, omemo_ctx.store, &address, omemo_ctx.signal);
            if (res != SG_SUCCESS) {
                log_error("[OMEMO][SEND] cannot create cipher for %s device id %d - code: %d", address.name, address.device_id, res);
@@ -1304,7 +1304,7 @@ _handle_own_device_list(const char* const jid, GList* device_list)
 {
    // We didn't find the own device id -> publish
    if (!g_list_find(device_list, GINT_TO_POINTER(omemo_ctx.device_id))) {
-        cons_show("Could not find own OMEMO device ID. Going to publish own device ID: %d", GINT_TO_POINTER(omemo_ctx.device_id));
+        cons_show("Could not find own OMEMO device ID. Going to publish own device ID: %d", omemo_ctx.device_id);
        log_debug("[OMEMO] No device ID for our device. Publishing device list");
        device_list = g_list_copy(device_list);
        device_list = g_list_append(device_list, GINT_TO_POINTER(omemo_ctx.device_id));
@@ -1406,8 +1406,6 @@ omemo_automatic_start(const char* const recipient)
    case PROF_OMEMOPOLICY_AUTOMATIC:
        if (g_list_find_custom(account->omemo_enabled, recipient, (GCompareFunc)g_strcmp0)) {
            result = TRUE;
-        } else if (g_list_find_custom(account->omemo_disabled, recipient, (GCompareFunc)g_strcmp0)) {
-            result = FALSE;
        } else {
            result = FALSE;
        }
--- a/src/plugins/api.c
+++ b/src/plugins/api.c
@@ -532,7 +532,7 @@ api_encryption_reset(const char* const barejid)

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_encryption_reset failed, could not find chat window for %s", barejid);
+        log_warning("api_encryption_reset failed, could not find chat window for %s", barejid);
        return;
    }

@@ -566,7 +566,7 @@ api_chat_set_titlebar_enctext(const char* const barejid, const char* const encte

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_chat_set_titlebar_enctext failed, could not find chat window for %s", barejid);
+        log_warning("api_chat_set_titlebar_enctext failed, could not find chat window for %s", barejid);
        return 0;
    }

@@ -585,7 +585,7 @@ api_chat_unset_titlebar_enctext(const char* const barejid)

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_chat_unset_titlebar_enctext failed, could not find chat window for %s", barejid);
+        log_warning("api_chat_unset_titlebar_enctext failed, could not find chat window for %s", barejid);
        return 0;
    }

@@ -614,7 +614,7 @@ api_chat_set_incoming_char(const char* const barejid, const char* const ch)

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_chat_set_incoming_char failed, could not find chat window for %s", barejid);
+        log_warning("api_chat_set_incoming_char failed, could not find chat window for %s", barejid);
        return 0;
    }

@@ -633,7 +633,7 @@ api_chat_unset_incoming_char(const char* const barejid)

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_chat_unset_incoming_char failed, could not find chat window for %s", barejid);
+        log_warning("api_chat_unset_incoming_char failed, could not find chat window for %s", barejid);
        return 0;
    }

@@ -662,7 +662,7 @@ api_chat_set_outgoing_char(const char* const barejid, const char* const ch)

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_chat_set_outgoing_char failed, could not find chat window for %s", barejid);
+        log_warning("api_chat_set_outgoing_char failed, could not find chat window for %s", barejid);
        return 0;
    }

@@ -681,7 +681,7 @@ api_chat_unset_outgoing_char(const char* const barejid)

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_chat_unset_outgoing_char failed, could not find chat window for %s", barejid);
+        log_warning("api_chat_unset_outgoing_char failed, could not find chat window for %s", barejid);
        return 0;
    }

@@ -705,7 +705,7 @@ api_room_set_titlebar_enctext(const char* const roomjid, const char* const encte

    ProfMucWin* mucwin = wins_get_muc(roomjid);
    if (mucwin == NULL) {
-        log_warning("%s", "api_room_set_titlebar_enctext failed, could not find room window for %s", roomjid);
+        log_warning("api_room_set_titlebar_enctext failed, could not find room window for %s", roomjid);
        return 0;
    }

@@ -724,7 +724,7 @@ api_room_unset_titlebar_enctext(const char* const roomjid)

    ProfMucWin* mucwin = wins_get_muc(roomjid);
    if (mucwin == NULL) {
-        log_warning("%s", "api_room_unset_titlebar_enctext failed, could not find room window for %s", roomjid);
+        log_warning("api_room_unset_titlebar_enctext failed, could not find room window for %s", roomjid);
        return 0;
    }

@@ -753,7 +753,7 @@ api_room_set_message_char(const char* const roomjid, const char* const ch)

    ProfMucWin* mucwin = wins_get_muc(roomjid);
    if (mucwin == NULL) {
-        log_warning("%s", "api_room_set_message_char failed, could not find room window for %s", roomjid);
+        log_warning("api_room_set_message_char failed, could not find room window for %s", roomjid);
        return 0;
    }

@@ -772,7 +772,7 @@ api_room_unset_message_char(const char* const roomjid)

    ProfMucWin* mucwin = wins_get_muc(roomjid);
    if (mucwin == NULL) {
-        log_warning("%s", "api_room_unset_message_char failed, could not find room window for %s", roomjid);
+        log_warning("api_room_unset_message_char failed, could not find room window for %s", roomjid);
        return 0;
    }

@@ -796,7 +796,7 @@ api_chat_show(const char* const barejid, const char* message)

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_chat_show failed, could not find chat window for %s", barejid);
+        log_warning("api_chat_show failed, could not find chat window for %s", barejid);
        return 0;
    }

@@ -832,7 +832,7 @@ api_chat_show_themed(const char* const barejid, const char* const group, const c

    ProfChatWin* chatwin = wins_get_chat(barejid);
    if (chatwin == NULL) {
-        log_warning("%s", "api_chat_show_themed failed, could not find chat window for %s", barejid);
+        log_warning("api_chat_show_themed failed, could not find chat window for %s", barejid);
        return 0;
    }

@@ -859,7 +859,7 @@ api_room_show(const char* const roomjid, const char* message)

    ProfMucWin* mucwin = wins_get_muc(roomjid);
    if (mucwin == NULL) {
-        log_warning("%s", "api_room_show failed, could not find room window for %s", roomjid);
+        log_warning("api_room_show failed, could not find room window for %s", roomjid);
        return 0;
    }

@@ -895,7 +895,7 @@ api_room_show_themed(const char* const roomjid, const char* const group, const c

    ProfMucWin* mucwin = wins_get_muc(roomjid);
    if (mucwin == NULL) {
-        log_warning("%s", "api_room_show_themed failed, could not find room window for %s", roomjid);
+        log_warning("api_room_show_themed failed, could not find room window for %s", roomjid);
        return 0;
    }

--- a/src/tools/http_common.h
+++ b/src/tools/http_common.h
@@ -36,9 +36,12 @@
 #ifndef TOOLS_HTTP_COMMON_H
 #define TOOLS_HTTP_COMMON_H

+#include <glib.h>
 #include "ui/window.h"

+G_GNUC_PRINTF(3, 4)
 void http_print_transfer(ProfWin* window, char* id, const char* fmt, ...);
+G_GNUC_PRINTF(3, 4)
 void http_print_transfer_update(ProfWin* window, char* id, const char* fmt, ...);

 #endif
--- a/src/ui/chatwin.c
+++ b/src/ui/chatwin.c
@@ -303,7 +303,7 @@ chatwin_incoming_msg(ProfChatWin* chatwin, ProfMessage* message, gboolean win_cr
    assert(chatwin != NULL);

    if (message->plain == NULL) {
-        log_error("chatwin_incoming_msg: Message with no plain field from: %s", message->from_jid);
+        log_error("chatwin_incoming_msg: Message with no plain field from: %s", message->from_jid->fulljid);
        return;
    }

--- a/src/ui/console.c
+++ b/src/ui/console.c
@@ -470,10 +470,10 @@ cons_show_wins(gboolean unread)

    GSList* curr = window_strings;
    while (curr) {
-        if (g_strstr_len(curr->data, strlen(curr->data), " unread") > 0) {
-            win_println(console, THEME_CMD_WINS_UNREAD, "-", "%s", curr->data);
+        if (g_strstr_len((char*)curr->data, strlen((char*)curr->data), " unread") != NULL) {
+            win_println(console, THEME_CMD_WINS_UNREAD, "-", "%s", (char*)curr->data);
        } else {
-            win_println(console, THEME_DEFAULT, "-", "%s", curr->data);
+            win_println(console, THEME_DEFAULT, "-", "%s", (char*)curr->data);
        }
        curr = g_slist_next(curr);
    }
@@ -491,10 +491,10 @@ cons_show_wins_attention()

    GSList* curr = window_strings;
    while (curr) {
-        if (g_strstr_len(curr->data, strlen(curr->data), " unread") > 0) {
-            win_println(console, THEME_CMD_WINS_UNREAD, "-", "%s", curr->data);
+        if (g_strstr_len((char*)curr->data, strlen((char*)curr->data), " unread") != NULL) {
+            win_println(console, THEME_CMD_WINS_UNREAD, "-", "%s", (char*)curr->data);
        } else {
-            win_println(console, THEME_DEFAULT, "-", "%s", curr->data);
+            win_println(console, THEME_DEFAULT, "-", "%s", (char*)curr->data);
        }
        curr = g_slist_next(curr);
    }
@@ -512,7 +512,7 @@ cons_show_room_invites(GList* invites)
    } else {
        cons_show("Chat room invites, use /join or /decline commands:");
        while (invites) {
-            cons_show("  %s", invites->data);
+            cons_show("  %s", (char*)invites->data);
            invites = g_list_next(invites);
        }
    }
@@ -591,7 +591,7 @@ cons_show_caps(const char* const fulljid, resource_presence_t presence)
            win_println(console, THEME_DEFAULT, "-", "Features:");
            GSList* feature = caps->features;
            while (feature) {
-                win_println(console, THEME_DEFAULT, "-", " %s", feature->data);
+                win_println(console, THEME_DEFAULT, "-", " %s", (char*)feature->data);
                feature = g_slist_next(feature);
            }
        }
@@ -611,10 +611,10 @@ cons_show_received_subs(void)
    if (received == NULL) {
        cons_show("No outstanding subscription requests.");
    } else {
-        cons_show("Outstanding subscription requests from:",
+        cons_show("Outstanding subscription requests from (%d):",
                  g_list_length(received));
        while (received) {
-            cons_show("  %s", received->data);
+            cons_show("  %s", (char*)received->data);
            received = g_list_next(received);
        }
        g_list_free_full(received, g_free);
@@ -782,7 +782,7 @@ cons_show_disco_info(const char* jid, GSList* identities, GSList* features)
            cons_show("  Features:");
        }
        while (features) {
-            cons_show("    %s", features->data);
+            cons_show("    %s", (char*)features->data);
            features = g_slist_next(features);
        }

@@ -2297,7 +2297,7 @@ cons_show_themes(GSList* themes)
    } else {
        cons_show("Available themes:");
        while (themes) {
-            cons_show("%s", themes->data);
+            cons_show("%s", (char*)themes->data);
            themes = g_slist_next(themes);
        }
    }
@@ -2315,7 +2315,7 @@ cons_show_scripts(GSList* scripts)
    } else {
        cons_show("Scripts:");
        while (scripts) {
-            cons_show("%s", scripts->data);
+            cons_show("%s", (char*)scripts->data);
            scripts = g_slist_next(scripts);
        }
    }
@@ -2333,7 +2333,7 @@ cons_show_script(const char* const script, GSList* commands)
    } else {
        cons_show("%s:", script);
        while (commands) {
-            cons_show("  %s", commands->data);
+            cons_show("  %s", (char*)commands->data);
            commands = g_slist_next(commands);
        }
    }
--- a/src/ui/mucwin.c
+++ b/src/ui/mucwin.c
@@ -218,7 +218,7 @@ mucwin_room_disco_info(ProfMucWin* mucwin, GSList* identities, GSList* features)
            win_println(window, THEME_DEFAULT, "!", "Features:");
        }
        while (features) {
-            win_println(window, THEME_DEFAULT, "!", "  %s", features->data);
+            win_println(window, THEME_DEFAULT, "!", "  %s", (char*)features->data);
            features = g_slist_next(features);
        }
        win_println(window, THEME_DEFAULT, "-", "");
@@ -534,7 +534,7 @@ mucwin_incoming_msg(ProfMucWin* mucwin, const ProfMessage* const message, GSList
    int flags = 0;

    if (message->plain == NULL) {
-        log_error("mucwin_incoming_msg: Message with no plain field from: %s", message->from_jid);
+        log_error("mucwin_incoming_msg: Message with no plain field from: %s", message->from_jid->fulljid);
        return;
    }

--- a/src/ui/privwin.c
+++ b/src/ui/privwin.c
@@ -52,7 +52,7 @@ privwin_incoming_msg(ProfPrivateWin* privatewin, ProfMessage* message)
    assert(privatewin != NULL);

    if (message->plain == NULL) {
-        log_error("privwin_incoming_msg: Message with no plain field from: %s", message->from_jid);
+        log_error("privwin_incoming_msg: Message with no plain field from: %s", message->from_jid->fulljid);
        return;
    }

--- a/src/ui/rosterwin.c
+++ b/src/ui/rosterwin.c
@@ -981,9 +981,7 @@ _rosterwin_unsubscribed_header(ProfLayoutSplit* layout, GList* wins)
    auto_gchar gchar* countpref = prefs_get_string(PREF_ROSTER_COUNT);
    if (g_strcmp0(countpref, "items") == 0) {
        int itemcount = g_list_length(wins);
-        if (itemcount == 0 && prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
-            g_string_append_printf(header, " (%d)", itemcount);
-        } else {
+        if (itemcount != 0 || prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
            g_string_append_printf(header, " (%d)", itemcount);
        }
    } else if (g_strcmp0(countpref, "unread") == 0) {
@@ -994,9 +992,7 @@ _rosterwin_unsubscribed_header(ProfLayoutSplit* layout, GList* wins)
            unreadcount += chatwin->unread;
            curr = g_list_next(curr);
        }
-        if (unreadcount == 0 && prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
-            g_string_append_printf(header, " (%d)", unreadcount);
-        } else if (unreadcount > 0) {
+        if (unreadcount != 0 || prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
            g_string_append_printf(header, " (%d)", unreadcount);
        }
    }
@@ -1026,9 +1022,7 @@ _rosterwin_contacts_header(ProfLayoutSplit* layout, const char* const title, GSL
    auto_gchar gchar* countpref = prefs_get_string(PREF_ROSTER_COUNT);
    if (g_strcmp0(countpref, "items") == 0) {
        int itemcount = g_slist_length(contacts);
-        if (itemcount == 0 && prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
-            g_string_append_printf(header, " (%d)", itemcount);
-        } else {
+        if (itemcount != 0 || prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
            g_string_append_printf(header, " (%d)", itemcount);
        }
    } else if (g_strcmp0(countpref, "unread") == 0) {
@@ -1043,9 +1037,7 @@ _rosterwin_contacts_header(ProfLayoutSplit* layout, const char* const title, GSL
            }
            curr = g_slist_next(curr);
        }
-        if (unreadcount == 0 && prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
-            g_string_append_printf(header, " (%d)", unreadcount);
-        } else if (unreadcount > 0) {
+        if (unreadcount != 0 || prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
            g_string_append_printf(header, " (%d)", unreadcount);
        }
    }
@@ -1136,9 +1128,7 @@ _rosterwin_private_header(ProfLayoutSplit* layout, GList* privs)
    auto_gchar gchar* countpref = prefs_get_string(PREF_ROSTER_COUNT);
    if (g_strcmp0(countpref, "items") == 0) {
        int itemcount = g_list_length(privs);
-        if (itemcount == 0 && prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
-            g_string_append_printf(title_str, " (%d)", itemcount);
-        } else if (itemcount > 0) {
+        if (itemcount != 0 || prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
            g_string_append_printf(title_str, " (%d)", itemcount);
        }
    } else if (g_strcmp0(countpref, "unread") == 0) {
@@ -1149,9 +1139,7 @@ _rosterwin_private_header(ProfLayoutSplit* layout, GList* privs)
            unreadcount += privwin->unread;
            curr = g_list_next(curr);
        }
-        if (unreadcount == 0 && prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
-            g_string_append_printf(title_str, " (%d)", unreadcount);
-        } else if (unreadcount > 0) {
+        if (unreadcount != 0 || prefs_get_boolean(PREF_ROSTER_COUNT_ZERO)) {
            g_string_append_printf(title_str, " (%d)", unreadcount);
        }
    }
--- a/src/ui/ui.h
+++ b/src/ui/ui.h
@@ -244,7 +244,9 @@ char* inp_readline(void);
 void inp_nonblocking(gboolean reset);

 // Console window
+G_GNUC_PRINTF(1, 2)
 void cons_show(const char* const msg, ...);
+G_GNUC_PRINTF(2, 3)
 void cons_show_padded(int pad, const char* const msg, ...);
 void cons_about(void);
 void cons_help(void);
@@ -263,7 +265,9 @@ void cons_show_pgp_prefs(void);
 void cons_show_omemo_prefs(void);
 void cons_show_ox_prefs(void);
 void cons_show_account(ProfAccount* account);
+G_GNUC_PRINTF(1, 2)
 void cons_debug(const char* const msg, ...);
+G_GNUC_PRINTF(1, 2)
 void cons_show_error(const char* const cmd, ...);
 void cons_show_contacts(GSList* list);
 void cons_show_roster(GSList* list);
@@ -318,7 +322,6 @@ void cons_wrap_setting(void);
 void cons_time_setting(void);
 void cons_wintitle_setting(void);
 void cons_notify_setting(void);
-void cons_show_desktop_prefs(void);
 void cons_states_setting(void);
 void cons_outtype_setting(void);
 void cons_intype_setting(void);
@@ -393,16 +396,24 @@ void win_show_subwin(ProfWin* window);
 void win_refresh_without_subwin(ProfWin* window);
 void win_refresh_with_subwin(ProfWin* window);

+G_GNUC_PRINTF(4, 5)
 void win_print(ProfWin* window, theme_item_t theme_item, const char* show_char, const char* const message, ...);
+G_GNUC_PRINTF(4, 5)
 void win_println(ProfWin* window, theme_item_t theme_item, const char* show_char, const char* const message, ...);
+G_GNUC_PRINTF(3, 4)
 void win_println_indent(ProfWin* window, int pad, const char* const message, ...);

+G_GNUC_PRINTF(4, 0)
 void win_println_va(ProfWin* window, theme_item_t theme_item, const char* show_char, const char* const message, va_list arg);

+G_GNUC_PRINTF(3, 4)
 void win_append(ProfWin* window, theme_item_t theme_item, const char* const message, ...);
+G_GNUC_PRINTF(3, 4)
 void win_appendln(ProfWin* window, theme_item_t theme_item, const char* const message, ...);

+G_GNUC_PRINTF(3, 4)
 void win_append_highlight(ProfWin* window, theme_item_t theme_item, const char* const message, ...);
+G_GNUC_PRINTF(3, 4)
 void win_appendln_highlight(ProfWin* window, theme_item_t theme_item, const char* const message, ...);

 gchar* win_get_title(ProfWin* window);
@@ -416,6 +427,7 @@ void win_clear(ProfWin* window);
 char* win_get_tab_identifier(ProfWin* window);
 gchar* win_to_string(ProfWin* window);
 void win_command_list_error(ProfWin* window, const char* const error);
+G_GNUC_PRINTF(3, 4)
 void win_command_exec_error(ProfWin* window, const char* const command, const char* const error, ...);
 void win_handle_command_list(ProfWin* window, GSList* cmds);
 void win_handle_command_exec_status(ProfWin* window, const char* const type, const char* const value);
--- a/src/xmpp/connection.c
+++ b/src/xmpp/connection.c
@@ -239,7 +239,7 @@ _conn_apply_settings(const char* const jid, const char* const passwd, const char
    }

    if (xmpp_conn_set_flags(conn.xmpp_conn, flags)) {
-        log_error("libstrophe doesn't accept this combination of flags: 0x%x", flags);
+        log_error("libstrophe doesn't accept this combination of flags: 0x%lx", flags);
        conn.conn_status = JABBER_DISCONNECTED;
        return FALSE;
    }
--- a/src/xmpp/connection.h
+++ b/src/xmpp/connection.h
@@ -51,7 +51,6 @@ jabber_conn_status_t connection_register(const char* const altdomain, int port,
 void connection_set_disconnected(void);

 void connection_set_priority(const int priority);
-void connection_set_priority(int priority);
 void connection_set_disco_items(GSList* items);

 xmpp_conn_t* connection_get_conn(void);
--- a/src/xmpp/form.c
+++ b/src/xmpp/form.c
@@ -458,7 +458,7 @@ form_get_field_type(DataForm* form, const char* const tag)
 }

 void
-form_set_value(DataForm* form, const char* const tag, char* value)
+form_set_value(DataForm* form, const char* const tag, const char* value)
 {
    char* var = g_hash_table_lookup(form->tag_to_var, tag);
    if (var) {
--- a/src/xmpp/iq.c
+++ b/src/xmpp/iq.c
@@ -921,7 +921,7 @@ _caps_response_id_handler(xmpp_stanza_t* const stanza, void* const userdata)
    // handle error responses
    if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
        auto_char char* error_message = stanza_get_error_message(stanza);
-        log_warning("Error received for capabilities response from %s: ", from, error_message);
+        log_warning("Error received for capabilities response from %s: %s", from, error_message);
        return 0;
    }

@@ -996,7 +996,7 @@ _caps_response_for_jid_id_handler(xmpp_stanza_t* const stanza, void* const userd
    // handle error responses
    if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
        auto_char char* error_message = stanza_get_error_message(stanza);
-        log_warning("Error received for capabilities response from %s: ", from, error_message);
+        log_warning("Error received for capabilities response from %s: %s", from, error_message);
        return 0;
    }

@@ -1054,7 +1054,7 @@ _caps_response_legacy_id_handler(xmpp_stanza_t* const stanza, void* const userda
    // handle error responses
    if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
        auto_char char* error_message = stanza_get_error_message(stanza);
-        log_warning("Error received for capabilities response from %s: ", from, error_message);
+        log_warning("Error received for capabilities response from %s: %s", from, error_message);
        return 0;
    }

@@ -1254,7 +1254,7 @@ _command_exec_response_handler(xmpp_stanza_t* const stanza, void* const userdata
    if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
        auto_char char* error_message = stanza_get_error_message(stanza);
        log_debug("Error executing command %s for %s: %s", command, from, error_message);
-        win_command_exec_error(win, command, error_message);
+        win_command_exec_error(win, command, "%s", error_message);
        return 0;
    }

--- a/src/xmpp/muc.c
+++ b/src/xmpp/muc.c
@@ -427,7 +427,7 @@ muc_rooms(void)
 * Return current users nickname for the specified room
 * The nickname is owned by the chat room and should not be modified or freed
 */
-const char* const
+const char*
 muc_nick(const char* const room)
 {
    ChatRoom* chat_room = g_hash_table_lookup(rooms, room);
--- a/src/xmpp/muc.h
+++ b/src/xmpp/muc.h
@@ -93,7 +93,7 @@ GList* muc_rooms(void);

 void muc_set_features(const char* const room, GSList* features);

-const char* const muc_nick(const char* const room);
+const char* muc_nick(const char* const room);
 char* muc_password(const char* const room);

 void muc_nick_change_start(const char* const room, const char* const new_nick);
--- a/src/xmpp/omemo.c
+++ b/src/xmpp/omemo.c
@@ -353,6 +353,7 @@ omemo_receive_message(xmpp_stanza_t* const stanza, gboolean* trusted)
 {
    char* plaintext = NULL;
    const char* type = xmpp_stanza_get_type(stanza);
+    const char* from = xmpp_stanza_get_from(stanza);
    GList* keys = NULL;
    unsigned char* iv_raw = NULL;
    unsigned char* payload_raw = NULL;
@@ -434,8 +435,6 @@ omemo_receive_message(xmpp_stanza_t* const stanza, gboolean* trusted)
        keys = g_list_append(keys, key);
    }

-    const char* from = xmpp_stanza_get_from(stanza);
-
    plaintext = omemo_on_message_recv(from, sid, iv_raw, iv_len,
                                      keys, payload_raw, payload_len,
                                      g_strcmp0(type, STANZA_TYPE_GROUPCHAT) == 0, trusted);
@@ -471,7 +470,8 @@ _omemo_receive_devicelist(xmpp_stanza_t* const stanza, void* const userdata)

        const char* code = xmpp_stanza_get_attribute(error, "code");
        if (g_strcmp0(code, "404") == 0) {
-            goto out;
+            omemo_set_device_list(from, NULL);
+            return 1;
        }
    }

@@ -517,7 +517,8 @@ _omemo_receive_devicelist(xmpp_stanza_t* const stanza, void* const userdata)
        log_warning("[OMEMO] User %s has a non 'current' device item list: %s.", from, xmpp_stanza_get_id(first));
        item = first;
    } else {
-        goto out;
+        omemo_set_device_list(from, device_list);
+        return 1;
    }

    xmpp_stanza_t* list = xmpp_stanza_get_child_by_ns(item, STANZA_NS_OMEMO);
@@ -539,7 +540,6 @@ _omemo_receive_devicelist(xmpp_stanza_t* const stanza, void* const userdata)
        }
    }

-out:
    omemo_set_device_list(from, device_list);

    return 1;
--- a/src/xmpp/omemo.h
+++ b/src/xmpp/omemo.h
@@ -38,7 +38,6 @@
 #include "xmpp/iq.h"

 void omemo_devicelist_subscribe(void);
-void omemo_devicelist_configure_and_request(void);
 void omemo_devicelist_publish(GList* device_list);
 void omemo_devicelist_request(const char* const jid);
 void omemo_bundle_publish(gboolean first);
--- a/src/xmpp/presence.c
+++ b/src/xmpp/presence.c
@@ -501,7 +501,7 @@ _subscribe_handler(xmpp_stanza_t* const stanza)
 {
    const char* from = xmpp_stanza_get_from(stanza);
    if (!from) {
-        log_warning("Subscribe presence handler received with no from attribute", from);
+        log_warning("Subscribe presence handler received with no from attribute");
    }
    log_debug("Subscribe presence handler fired for %s", from);

--- a/src/xmpp/stanza.c
+++ b/src/xmpp/stanza.c
@@ -1948,7 +1948,7 @@ stanza_attach_priority(xmpp_ctx_t* const ctx, xmpp_stanza_t* const presence, con
        return;
    }

-    char pri_str[10];
+    char pri_str[12];
    snprintf(pri_str, sizeof(pri_str), "%d", pri);

    xmpp_stanza_t* priority = xmpp_stanza_new(ctx);
@@ -2007,7 +2007,7 @@ stanza_attach_last_activity(xmpp_ctx_t* const ctx,
    xmpp_stanza_t* query = xmpp_stanza_new(ctx);
    xmpp_stanza_set_name(query, STANZA_NAME_QUERY);
    xmpp_stanza_set_ns(query, STANZA_NS_LASTACTIVITY);
-    char idle_str[10];
+    char idle_str[12];
    snprintf(idle_str, sizeof(idle_str), "%d", idle);
    xmpp_stanza_set_attribute(query, STANZA_ATTR_SECONDS, idle_str);
    xmpp_stanza_add_child(presence, query);
--- a/src/xmpp/vcard.c
+++ b/src/xmpp/vcard.c
@@ -1300,7 +1300,7 @@ _vcard_photo_result(xmpp_stanza_t* const stanza, void* userdata)
        return 1;
    }

-    GString* filename;
+    GString* filename = NULL;

    if (!data->filename) {
        auto_gchar gchar* path = files_get_data_path(DIR_PHOTOS);
@@ -1340,6 +1340,11 @@ _vcard_photo_result(xmpp_stanza_t* const stanza, void* userdata)

    GError* err = NULL;

+    if (!filename) {
+        cons_show_error("Unable to determine filename for photo");
+        return 1;
+    }
+
    if (g_file_set_contents(filename->str, (gchar*)photo->data, photo->length, &err) == FALSE) {
        cons_show_error("Unable to save photo: %s", err->message);
        g_error_free(err);
--- a/src/xmpp/xmpp.h
+++ b/src/xmpp/xmpp.h
@@ -305,7 +305,7 @@ char* blocked_ac_find(const char* const search_str, gboolean previous, void* con
 void blocked_ac_reset(void);

 void form_destroy(DataForm* form);
-void form_set_value(DataForm* form, const char* const tag, char* value);
+void form_set_value(DataForm* form, const char* const tag, const char* value);
 gboolean form_add_unique_value(DataForm* form, const char* const tag, char* value);
 void form_add_value(DataForm* form, const char* const tag, char* value);
 gboolean form_remove_value(DataForm* form, const char* const tag, char* value);
--- a/tests/functionaltests/proftest.c
+++ b/tests/functionaltests/proftest.c
@@ -315,20 +315,6 @@ init_prof_test(void **state)
    _create_chatlogs_dir();
    _create_logs_dir();

-    /* If PROF_FLATFILE=1 is set, write a profrc that selects the flat-file backend */
-    const char *flatfile_env = getenv("PROF_FLATFILE");
-    if (flatfile_env && strcmp(flatfile_env, "1") == 0) {
-        char profrc_path[512];
-        snprintf(profrc_path, sizeof(profrc_path),
-                 "%s/profanity/profrc", xdg_config_home);
-        FILE *prc = fopen(profrc_path, "w");
-        if (prc) {
-            fprintf(prc, "[logging]\ndblog=flatfile\n");
-            fclose(prc);
-            printf("[PROF_TEST] Wrote profrc with dblog=flatfile: %s\n", profrc_path);
-        }
-    }
-
    prof_start();
    int prof_started = prof_output_regex("CProof\\. Type /help for help information\\.");
    assert_true(prof_started);
--- a/tests/unittests/database/stub_database.c
+++ b/tests/unittests/database/stub_database.c
@@ -25,8 +25,6 @@

 #include "database.h"

-db_backend_t* active_db_backend = NULL;
-
 gboolean
 log_database_init(ProfAccount* account)
 {
@@ -52,27 +50,3 @@ void
 log_database_close(void)
 {
 }
-GSList*
-log_database_verify_integrity(const gchar* const contact_barejid)
-{
-    return NULL;
-}
-void
-integrity_issue_free(integrity_issue_t* issue)
-{
-    if (issue) {
-        g_free(issue->file);
-        g_free(issue->message);
-        g_free(issue);
-    }
-}
-db_backend_t*
-db_backend_sqlite(void)
-{
-    return NULL;
-}
-db_backend_t*
-db_backend_flatfile(void)
-{
-    return NULL;
-}
--- a/tests/unittests/test_common.c
+++ b/tests/unittests/test_common.c
@@ -515,7 +515,7 @@ _lists_equal(GSList* a, GSList* b)
    GSList* curra = a;
    GSList* currb = b;

-    while (curra) {
+    while (curra && currb) {
        int aval = GPOINTER_TO_INT(curra->data);
        int bval = GPOINTER_TO_INT(currb->data);
Author	SHA1	Message	Date
jabber.developer2	d081993c90	fix: address PR #98 review feedback All checks were successful CI Code / Check spelling (pull_request) Successful in 23s Details CI Code / Check coding style (pull_request) Successful in 34s Details CI Code / Code Coverage (pull_request) Successful in 4m48s Details CI Code / Linux (ubuntu) (pull_request) Successful in 6m14s Details CI Code / Linux (debian) (pull_request) Successful in 6m15s Details CI Code / Linux (arch) (pull_request) Successful in 6m35s Details - check-cwe134.sh: match gchar* in addition to char* in variadic pattern - rosterwin.c: merge duplicated if/else into single condition - omemo.c: remove unnecessary scope block and goto, use early return	2026-03-07 13:32:02 +03:00
jabber.developer2	4ef3bc8e46	Add low-impact warning flags, fix warnings found by new flags All checks were successful CI Code / Check spelling (pull_request) Successful in 16s Details CI Code / Check coding style (pull_request) Successful in 33s Details CI Code / Code Coverage (pull_request) Successful in 4m48s Details CI Code / Linux (ubuntu) (pull_request) Successful in 6m20s Details CI Code / Linux (debian) (pull_request) Successful in 6m22s Details CI Code / Linux (arch) (pull_request) Successful in 11m47s Details Add compiler flags: -Wundef, -Wfloat-equal, -Wredundant-decls, -Walloc-zero. Fix -Wredundant-decls warnings: - Remove stale cons_show_desktop_prefs declaration (ui.h) - Remove duplicate connection_set_priority prototype (connection.h) - Remove stale omemo_devicelist_configure_and_request declaration (omemo.h) Fix potential buffer overflow in stanza.c: - Increase pri_str and idle_str buffers from 10 to 12 bytes (INT_MIN = -2147483648 needs 12 bytes including NUL)	2026-03-04 22:28:16 +03:00
jabber.developer2	bb6d29a060	Harden compiler flags, simplify CWE-134 script, fix bugs found by new warnings configure.ac: - Replace basic -Wformat/-Wformat-nonliteral with -Wformat=2 - Add -Wextra, -Wnull-dereference, -Wpointer-arith, -Wimplicit-function-declaration - Add -fstack-protector-strong, -fno-common, -D_FORTIFY_SOURCE=2 - Add GCC-specific flags via AC_COMPILE_IFELSE: -Wlogical-op, -Wduplicated-cond, -Wduplicated-branches, -Wstringop-overflow - Add linker hardening via AC_LINK_IFELSE: -Wl,-z,relro -Wl,-z,now - Suppress noisy -Wextra sub-warnings: -Wno-unused-parameter, -Wno-missing-field-initializers, -Wno-sign-compare, -Wno-cast-function-type - Remove AM_CFLAGS/CFLAGS duplication line check-cwe134.sh: - Reduce from 5 checks to 2 (checks 1-3 are now redundant with -Wformat=2) - Check 1: verify known wrappers have G_GNUC_PRINTF attribute - Check 2: auto-detect unannotated variadic printf-like functions Bug fixes found by -Wduplicated-branches: - chatlog.c: non-MUCPM redact path passed resourcepart instead of NULL - rosterwin.c: two instances of if/else with identical branches in roster count - omemo.c: redundant else-if branch in omemo_automatic_start Other fixes for new warnings: - console.c: pointer compared to integer 0 instead of NULL (2 instances) - vcard.c: NULL guard for filename before g_file_set_contents - files.c: refactor to early return, eliminating NULL logfile path - database.c: const-correctness for type, query, sort variables - form.c/xmpp.h: const-correctness for form_set_value parameter - muc.c/muc.h: remove meaningless top-level const on return type - common.c: const-correctness for URL string literal - xmpp/omemo.c: scope block for declarations after goto, move from decl before goto, replace goto with direct return - http_common.h: add G_GNUC_PRINTF attributes for http_print_transfer* - test_common.c: add currb NULL check to silence -Wnull-dereference	2026-03-04 21:18:35 +03:00
jabber.developer2	92953099e1	fix: CWE-134 format string vulnerability audit All checks were successful CI Code / Check spelling (pull_request) Successful in 21s Details CI Code / Check coding style (pull_request) Successful in 38s Details CI Code / Linux (ubuntu) (pull_request) Successful in 6m25s Details CI Code / Linux (debian) (pull_request) Successful in 9m11s Details CI Code / Code Coverage (pull_request) Successful in 9m13s Details CI Code / Linux (arch) (pull_request) Successful in 11m27s Details Security: - Fix CWE-134 in iq.c: user-controlled string passed as format arg Annotations: - Add G_GNUC_PRINTF to variadic functions in ui.h and log.h Compiler flags (configure.ac): - Add -Wformat -Wformat-nonliteral -Wno-format-zero-length Format mismatch fixes: - chatwin.c: Jid* instead of char* for %s - connection.c: %x -> %lx for long flags - cmd_funcs.c: %d -> %zu for MB_CUR_MAX/MB_LEN_MAX (size_t) - cmd_funcs.c: cast gpointer to (char) for %s - cmd_defs.c: %d -> %u for g_list_length() (guint) - iq.c: from_jid->barejid -> from_jid->fulljid - console.c, mucwin.c, privwin.c, account.c, omemo.c, presence.c: gpointer -> (char) casts for %s Bug fixes: - api.c: broken log_warning() calls with extra format arg - cmd_funcs.c: remove unused arg from cons_show() Tooling: - Expand check-cwe134.sh detection patterns	2026-03-03 16:29:25 +03:00
Jabber Developer	31538580fb	fix arch build All checks were successful CI Code / Check spelling (pull_request) Successful in 17s Details CI Code / Check coding style (pull_request) Successful in 28s Details CI Code / Linux (debian) (pull_request) Successful in 6m21s Details CI Code / Linux (ubuntu) (pull_request) Successful in 8m59s Details CI Code / Code Coverage (pull_request) Successful in 8m25s Details CI Code / Linux (arch) (pull_request) Successful in 10m31s Details CI Code / Check spelling (push) Successful in 17s Details CI Code / Check coding style (push) Successful in 31s Details CI Code / Linux (debian) (push) Successful in 6m29s Details CI Code / Linux (ubuntu) (push) Successful in 6m33s Details CI Code / Code Coverage (push) Successful in 9m3s Details CI Code / Linux (arch) (push) Successful in 10m31s Details	2026-02-18 17:39:25 +01:00