merge: sync upstream profanity-im/profanity

Sync with upstream profanity-im/profanity.

Major upstream changes incorporated:

Memory management
  - Replace malloc+memset with g_new0 throughout codebase
  - Adopt auto_gchar / auto_gcharv / auto_gerror / auto_jid cleanup macros
  - Replace free() with g_free() for GAlloc'd memory

Editor rewrite
  - Remove pthread-based async editor; use GChildWatch callback API
  - New launch_editor(initial_content, callback, user_data) interface
  - Proper signal handling (SIGINT, SIGTSTP, SIGPIPE reset in child)
  - ui_suspend()/ui_resume() integration for TTY management

OMEMO improvements
  - Dual backend support: libsignal-protocol-c and libomemo-c
  - Proper pre-key removal after use (XEP-0384 compliance)
  - Automatic pre-key regeneration when store drops below threshold
  - New functions: omemo_is_device_active(), omemo_is_jid_trusted()
  - omemo_get_jid_untrusted_fingerprints() for better error messages
  - Fingerprint notifications on new device identity discovery
  - Deterministic pre-key ID generation tracking max_pre_key_id
  - omemo_trust_changed() UI updates on trust state changes

JID validation
  - RFC 6122-compliant validation in jid_is_valid()
  - Character-level checks (RFC 6122 forbidden chars: & ' / : < > @)
  - Length limits: 1023 per component, 3071 total
  - New jid_is_valid_user_jid() for user vs. service JID distinction

Database
  - Schema migration v3: UNIQUE constraint on archive_id for deduplication
  - Triggers for corrected message tracking (replaces_db_id / replaced_by_db_id)
  - db_history_result_t return type, _truncate_datetime_suffix()

UI / console
  - win_warn_needed() / win_warn_sent() warning deduplication hash table
  - PAD_MIN_HEIGHT dynamic pad sizing with PAD_THRESHOLD auto-cleanup
  - Spellcheck integration in input field with Unicode word detection
  - cons_spellcheck_setting() for /settings ui output
  - /[command]? shortcut for command help

Account config
  - Account name sanitization for GKeyFile special chars ([ ] = # \n \r)
  - Replace popen() with g_spawn_sync() for eval_password
  - TLS policy: add "direct" option alongside legacy

Connection
  - Port validation with g_assert (0–65535)
  - SHA-256 certificate fingerprint support (XMPP_CERT_PUBKEY_FINGERPRINT_SHA256)
  - "direct" TLS policy alias for legacy SSL

Common utilities
  - str_xml_sanitize() for XML 1.0 illegal character removal
  - string_matches_one_of() with formatted error messages
  - valid_tls_policy_option() helper
  - prof_date_time_format_iso8601() utility
  - Improved strip_arg_quotes() with backslash unescaping
  - prof_occurrences() uses g_slist_prepend + reverse for performance

PGP / OX
  - Proper GPGME resource cleanup with goto-cleanup pattern
  - g_string_free(xmppuri) leak fix in _ox_key_lookup

CSV export
  - Use GString + g_file_set_contents instead of raw write() syscalls

Tests
  - Restructured into subdirectories: command/, config/, xmpp/, ui/, omemo/, otr/, pgp/
  - New test_cmd_ac.c for autocompleter unit tests
  - Updated stubs for new UI suspend/resume functions

License headers
  - Migrate to SPDX-3.0 identifiers (GPL-3.0-or-later WITH OpenSSL-exception)

────────────────────────────────────────────────────
cproof-specific preservations:

  - XEP-0308 LMC: replace_id ?: id logic in message/stanza/omemo
  - Force encryption: cmd_force_encryption, test_forced_encryption
  - CWE-134: format string protection (cons_show("%s", ...))
  - y_start_pos-based paging in window.c
  - db_history_result_t return type, _truncate_datetime_suffix()

Merge-time fixes:

  - common.c: format-security (-Werror) — cons_show(errmsg) → cons_show("%s", errmsg)
  - database.c: null-deref guard — !msg->timestamp → msg && !msg->timestamp
  - console.c: implicit size_t → int cast — (int)(maxlen + 1)
  - tlscerts.c: %d for size_t — %zu

Build system:
  - Kept autotools (Makefile.am, configure.ac); upstream uses Meson
  - Restored deleted files: bootstrap.sh, autogen.sh, ax_valgrind_check.m4, configure-debug
  - Updated Makefile.am test paths for subdirectory structure
  - Added test_cmd_ac, test_forced_encryption to test sources

Functional tests:
  - Use cproof version; upstream requires stbbr_for_xmlns from updated stabber
  - Not yet available in devs/stabber fork

Closes #64

Merge author: jabber.developer2
Commits authors:
 Michael Vetter <jubalh@iodoru.org>
& Steffen Jaeckel <s@jaeckel.eu>

src/pgp/ox.c

@@ -3,35 +3,9 @@
  * vim: expandtab:ts=4:sts=4:sw=4
  *
  * Copyright (C) 2020 Stefan Kropp <stefan@debxwoody.de>
- * 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.
+ * Copyright (C) 2020 - 2026 Michael Vetter <jubalh@iodoru.org>
  *
+ * SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
  */
 
 #include "config.h"
@@ -85,6 +59,7 @@ ox_gpg_public_keys(void)
         if (error != GPG_ERR_EOF && error != GPG_ERR_NO_ERROR) {
             log_error("OX: gpgme_op_keylist_next %s %s", gpgme_strsource(error), gpgme_strerror(error));
             g_hash_table_destroy(result);
+            gpgme_release(ctx);
             return NULL;
         }
         while (!error) {
@@ -145,10 +120,16 @@ ox_gpg_public_keys(void)
 char*
 p_ox_gpg_signcrypt(const char* const sender_barejid, const char* const recipient_barejid, const char* const message)
 {
+    char* result = NULL;
+    gpgme_ctx_t ctx = NULL;
+    gpgme_key_t recp[3] = { NULL, NULL, NULL };
+    gpgme_data_t plain = NULL;
+    gpgme_data_t cipher = NULL;
+    char* cipher_str = NULL;
+
     setlocale(LC_ALL, "");
     gpgme_check_version(NULL);
     gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
-    gpgme_ctx_t ctx;
 
     gpgme_error_t error = gpgme_new(&ctx);
     if (GPG_ERR_NO_ERROR != error) {
@@ -165,13 +146,6 @@ p_ox_gpg_signcrypt(const char* const sender_barejid, const char* const recipient
     gpgme_set_textmode(ctx, 0);
     gpgme_set_offline(ctx, 1);
     gpgme_set_keylist_mode(ctx, GPGME_KEYLIST_MODE_LOCAL);
-    if (error != 0) {
-        log_error("OX: Signcrypt error: %s", gpgme_strerror(error));
-    }
-
-    gpgme_key_t recp[3];
-    recp[0] = NULL,
-    recp[1] = NULL;
 
     char* xmpp_jid_me = alloca((strlen(sender_barejid) + 6) * sizeof(char));
     char* xmpp_jid_recipient = alloca((strlen(recipient_barejid) + 6) * sizeof(char));
@@ -185,64 +159,73 @@ p_ox_gpg_signcrypt(const char* const sender_barejid, const char* const recipient
 
     // lookup own key
     recp[0] = _ox_key_lookup(sender_barejid, TRUE);
-    if (error != 0) {
+    if (recp[0] == NULL) {
         cons_show_error("Can't find OX key for %s", xmpp_jid_me);
-        log_error("OX: Key not found for %s. Error: %s", xmpp_jid_me, gpgme_strerror(error));
-        return NULL;
+        log_error("OX: Key not found for %s.", xmpp_jid_me);
+        goto cleanup;
     }
 
     error = gpgme_signers_add(ctx, recp[0]);
     if (error != 0) {
         log_error("OX: gpgme_signers_add %s. Error: %s", xmpp_jid_me, gpgme_strerror(error));
-        return NULL;
+        goto cleanup;
     }
 
     // lookup key of recipient
     recp[1] = _ox_key_lookup(recipient_barejid, FALSE);
-    if (error != 0) {
+    if (recp[1] == NULL) {
         cons_show_error("Can't find OX key for %s", xmpp_jid_recipient);
-        log_error("OX: Key not found for %s. Error: %s", xmpp_jid_recipient, gpgme_strerror(error));
-        return NULL;
+        log_error("OX: Key not found for %s.", xmpp_jid_recipient);
+        goto cleanup;
     }
 
     recp[2] = NULL;
-    log_debug("OX: %s <%s>", recp[0]->uids->name, recp[0]->uids->email);
-    log_debug("OX: %s <%s>", recp[1]->uids->name, recp[1]->uids->email);
+    if (recp[0]->uids) {
+        log_debug("OX: %s <%s>", recp[0]->uids->name, recp[0]->uids->email);
+    }
+    if (recp[1]->uids) {
+        log_debug("OX: %s <%s>", recp[1]->uids->name, recp[1]->uids->email);
+    }
 
     gpgme_encrypt_flags_t flags = 0;
 
-    gpgme_data_t plain;
-    gpgme_data_t cipher;
-
-    error = gpgme_data_new(&plain);
-    if (error != 0) {
-        log_error("OX: %s", gpgme_strerror(error));
-        return NULL;
-    }
-
     error = gpgme_data_new_from_mem(&plain, message, strlen(message), 0);
     if (error != 0) {
         log_error("OX: %s", gpgme_strerror(error));
-        return NULL;
+        goto cleanup;
     }
+
     error = gpgme_data_new(&cipher);
     if (error != 0) {
         log_error("OX: %s", gpgme_strerror(error));
-        return NULL;
+        goto cleanup;
     }
 
     error = gpgme_op_encrypt_sign(ctx, recp, flags, plain, cipher);
     if (error != 0) {
         log_error("OX: %s", gpgme_strerror(error));
-        return NULL;
+        goto cleanup;
     }
 
     size_t len;
-    char* cipher_str = gpgme_data_release_and_get_mem(cipher, &len);
-    char* result = g_base64_encode((unsigned char*)cipher_str, len);
-    gpgme_key_release(recp[0]);
-    gpgme_key_release(recp[1]);
-    gpgme_release(ctx);
+    cipher_str = gpgme_data_release_and_get_mem(cipher, &len);
+    cipher = NULL; // Already released by gpgme_data_release_and_get_mem
+    result = g_base64_encode((unsigned char*)cipher_str, len);
+
+cleanup:
+    if (cipher_str)
+        gpgme_free(cipher_str);
+    if (plain)
+        gpgme_data_release(plain);
+    if (cipher)
+        gpgme_data_release(cipher);
+    if (recp[0])
+        gpgme_key_release(recp[0]);
+    if (recp[1])
+        gpgme_key_release(recp[1]);
+    if (ctx)
+        gpgme_release(ctx);
+
     return result;
 }
 
@@ -313,6 +296,7 @@ _ox_key_lookup(const char* const barejid, gboolean secret_only)
                 if (uid->name && strlen(uid->name) >= 10) {
                     if (g_strcmp0(uid->name, xmppuri->str) == 0) {
                         gpgme_release(ctx);
+                        g_string_free(xmppuri, TRUE);
                         return key;
                     }
                 }
@@ -321,6 +305,7 @@ _ox_key_lookup(const char* const barejid, gboolean secret_only)
             gpgme_key_unref(key);
             error = gpgme_op_keylist_next(ctx, &key);
         }
+        g_string_free(xmppuri, TRUE);
     }
     gpgme_release(ctx);
 
@@ -362,6 +347,13 @@ _ox_key_is_usable(gpgme_key_t key, const char* const barejid, gboolean secret)
 char*
 p_ox_gpg_decrypt(char* base64)
 {
+    char* result = NULL;
+    gpgme_ctx_t ctx = NULL;
+    gpgme_data_t plain = NULL;
+    gpgme_data_t cipher = NULL;
+    guchar* encrypted = NULL;
+    char* plain_str = NULL;
+
     // if there is no private key avaibale,
     // we don't try do decrypt
     if (!ox_is_private_key_available(connection_get_barejid())) {
@@ -370,7 +362,6 @@ p_ox_gpg_decrypt(char* base64)
     setlocale(LC_ALL, "");
     gpgme_check_version(NULL);
     gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
-    gpgme_ctx_t ctx;
     gpgme_error_t error = gpgme_new(&ctx);
 
     if (GPG_ERR_NO_ERROR != error) {
@@ -387,25 +378,19 @@ p_ox_gpg_decrypt(char* base64)
     gpgme_set_textmode(ctx, 0);
     gpgme_set_offline(ctx, 1);
     gpgme_set_keylist_mode(ctx, GPGME_KEYLIST_MODE_LOCAL);
-    if (error != 0) {
-        log_error("OX: %s", gpgme_strerror(error));
-    }
-
-    gpgme_data_t plain = NULL;
-    gpgme_data_t cipher = NULL;
 
     gsize s;
-    guchar* encrypted = g_base64_decode(base64, &s);
+    encrypted = g_base64_decode(base64, &s);
     error = gpgme_data_new_from_mem(&cipher, (char*)encrypted, s, 0);
     if (error != 0) {
         log_error("OX: gpgme_data_new_from_mem: %s", gpgme_strerror(error));
-        return NULL;
+        goto cleanup;
     }
 
     error = gpgme_data_new(&plain);
     if (error != 0) {
         log_error("OX: %s", gpgme_strerror(error));
-        return NULL;
+        goto cleanup;
     }
 
     error = gpgme_op_decrypt_verify(ctx, cipher, plain);
@@ -413,18 +398,29 @@ p_ox_gpg_decrypt(char* base64)
         log_error("OX: gpgme_op_decrypt: %s", gpgme_strerror(error));
         error = gpgme_op_decrypt(ctx, cipher, plain);
         if (error != 0) {
-            return NULL;
+            goto cleanup;
         }
     }
 
     size_t len;
-    char* plain_str = gpgme_data_release_and_get_mem(plain, &len);
-    char* result = NULL;
+    plain_str = gpgme_data_release_and_get_mem(plain, &len);
+    plain = NULL; // Already released by gpgme_data_release_and_get_mem
     if (plain_str) {
         result = strndup(plain_str, len);
-        gpgme_free(plain_str);
     }
 
+cleanup:
+    if (encrypted)
+        g_free(encrypted);
+    if (plain_str)
+        gpgme_free(plain_str);
+    if (plain)
+        gpgme_data_release(plain);
+    if (cipher)
+        gpgme_data_release(cipher);
+    if (ctx)
+        gpgme_release(ctx);
+
     return result;
 }
 
@@ -455,30 +451,33 @@ p_ox_gpg_readkey(const char* const filename, char** key, char** fp)
 {
     log_info("PX: Read OpenPGP Key from file %s", filename);
 
-    GError* error = NULL;
+    GError* gerr = NULL;
     gchar* data = NULL;
     gsize size = -1;
+    gpgme_ctx_t ctx = NULL;
+    gpgme_data_t gpgme_data = NULL;
+    gpgme_key_t gkey = NULL;
+    gpgme_key_t end = NULL;
 
     gboolean success = g_file_get_contents(filename,
                                            &data,
                                            &size,
-                                           &error);
+                                           &gerr);
     if (success) {
         setlocale(LC_ALL, "");
         gpgme_check_version(NULL);
         gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
-        gpgme_ctx_t ctx;
         gpgme_error_t error = gpgme_new(&ctx);
 
         if (GPG_ERR_NO_ERROR != error) {
             log_error("OX: Read OpenPGP key from file: gpgme_new failed: %s", gpgme_strerror(error));
-            return;
+            goto cleanup;
         }
 
         error = gpgme_set_protocol(ctx, GPGME_PROTOCOL_OPENPGP);
         if (error != GPG_ERR_NO_ERROR) {
             log_error("OX: Read OpenPGP key from file: set GPGME_PROTOCOL_OPENPGP:  %s", gpgme_strerror(error));
-            return;
+            goto cleanup;
         }
 
         gpgme_set_armor(ctx, 0);
@@ -486,49 +485,54 @@ p_ox_gpg_readkey(const char* const filename, char** key, char** fp)
         gpgme_set_offline(ctx, 1);
         gpgme_set_keylist_mode(ctx, GPGME_KEYLIST_MODE_LOCAL);
 
-        gpgme_data_t gpgme_data = NULL;
-        error = gpgme_data_new(&gpgme_data);
-        if (error != GPG_ERR_NO_ERROR) {
-            log_error("OX: Read OpenPGP key from file: gpgme_data_new %s", gpgme_strerror(error));
-            return;
-        }
-
         error = gpgme_data_new_from_mem(&gpgme_data, (char*)data, size, 0);
         if (error != GPG_ERR_NO_ERROR) {
             log_error("OX: Read OpenPGP key from file: gpgme_data_new_from_mem %s", gpgme_strerror(error));
-            return;
+            goto cleanup;
         }
         error = gpgme_op_keylist_from_data_start(ctx, gpgme_data, 0);
         if (error != GPG_ERR_NO_ERROR) {
             log_error("OX: Read OpenPGP key from file: gpgme_op_keylist_from_data_start %s", gpgme_strerror(error));
-            return;
+            goto cleanup;
         }
-        gpgme_key_t gkey;
         error = gpgme_op_keylist_next(ctx, &gkey);
         if (error != GPG_ERR_NO_ERROR) {
             log_error("OX: Read OpenPGP key from file: gpgme_op_keylist_next %s", gpgme_strerror(error));
-            return;
+            goto cleanup;
         }
 
-        gpgme_key_t end;
         error = gpgme_op_keylist_next(ctx, &end);
         if (error == GPG_ERR_NO_ERROR) {
             log_error("OX: Read OpenPGP key from file: ambiguous key");
-            return;
+            goto cleanup;
         }
 
         if (gkey->revoked || gkey->expired || gkey->disabled || gkey->invalid || gkey->secret) {
             log_error("OX: Read OpenPGP key from file: Key is not valid");
-            return;
+            goto cleanup;
         }
 
         gchar* keybase64 = g_base64_encode((const guchar*)data, size);
 
         *key = strdup(keybase64);
         *fp = strdup(gkey->fpr);
+        g_free(keybase64);
     } else {
-        log_error("OX: Read OpenPGP key from file: Unable to read file: %s", error->message);
+        log_error("OX: Read OpenPGP key from file: Unable to read file: %s", gerr->message);
+        g_error_free(gerr);
     }
+
+cleanup:
+    if (data)
+        g_free(data);
+    if (gpgme_data)
+        gpgme_data_release(gpgme_data);
+    if (gkey)
+        gpgme_key_unref(gkey);
+    if (end)
+        gpgme_key_unref(end);
+    if (ctx)
+        gpgme_release(ctx);
 }
 
 gboolean
@@ -536,22 +540,26 @@ p_ox_gpg_import(char* base64_public_key)
 {
     gsize size = -1;
     guchar* key = g_base64_decode(base64_public_key, &size);
+    gboolean result = TRUE;
 
     setlocale(LC_ALL, "");
     gpgme_check_version(NULL);
     gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
-    gpgme_ctx_t ctx;
+    gpgme_ctx_t ctx = NULL;
+    gpgme_data_t gpgme_data = NULL;
     gpgme_error_t error = gpgme_new(&ctx);
 
     if (GPG_ERR_NO_ERROR != error) {
         log_error("OX: Read OpenPGP key from file: gpgme_new failed: %s", gpgme_strerror(error));
-        return FALSE;
+        result = FALSE;
+        goto cleanup;
     }
 
     error = gpgme_set_protocol(ctx, GPGME_PROTOCOL_OPENPGP);
     if (error != GPG_ERR_NO_ERROR) {
         log_error("OX: Read OpenPGP key from file: set GPGME_PROTOCOL_OPENPGP:  %s", gpgme_strerror(error));
-        return FALSE;
+        result = FALSE;
+        goto cleanup;
     }
 
     gpgme_set_armor(ctx, 0);
@@ -559,18 +567,26 @@ p_ox_gpg_import(char* base64_public_key)
     gpgme_set_offline(ctx, 1);
     gpgme_set_keylist_mode(ctx, GPGME_KEYLIST_MODE_LOCAL);
 
-    gpgme_data_t gpgme_data = NULL;
-    error = gpgme_data_new(&gpgme_data);
+    error = gpgme_data_new_from_mem(&gpgme_data, (gchar*)key, size, 0);
     if (error != GPG_ERR_NO_ERROR) {
-        log_error("OX: Read OpenPGP key from file: gpgme_data_new %s", gpgme_strerror(error));
-        return FALSE;
+        log_error("OX: Read OpenPGP key from file: gpgme_data_new_from_mem %s", gpgme_strerror(error));
+        result = FALSE;
+        goto cleanup;
     }
 
-    gpgme_data_new_from_mem(&gpgme_data, (gchar*)key, size, 0);
     error = gpgme_op_import(ctx, gpgme_data);
     if (error != GPG_ERR_NO_ERROR) {
         log_error("OX: Failed to import key");
+        result = FALSE;
     }
 
-    return TRUE;
+cleanup:
+    if (key)
+        g_free(key);
+    if (gpgme_data)
+        gpgme_data_release(gpgme_data);
+    if (ctx)
+        gpgme_release(ctx);
+
+    return result;
 }