Compare commits

..

59 Commits

Author SHA1 Message Date
43d557f2dc fix(ai): keep in-memory defaults seeded when prefs is unavailable
Some checks failed
CI Code / Check spelling (pull_request) Successful in 17s
CI Code / Check coding style (pull_request) Successful in 32s
CI Code / Code Coverage (pull_request) Successful in 2m34s
CI Code / Linux (debian) (pull_request) Failing after 3m35s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m45s
CI Code / Linux (arch) (pull_request) Failing after 4m27s
The defaults_initialized sentinel only makes sense when prefs is loaded.
Three unit tests use ai_client_setup, which calls ai_client_init without
loading prefs — prefs_ai_get_providers was bailing on the seeding branch
because of the prefs NULL check, leaving ai_client with zero providers
and breaking tests that expect at least one default.

Decouple the two concerns:
- Always seed openai/perplexity into the in-memory result list when the
  configured set is empty and we haven't already seeded.
- Only persist the seeded providers and write the defaults_initialized
  flag when prefs is actually available.

In production this is identical to the previous behaviour; in tests
without prefs the old "always-return-defaults" semantics is preserved
without a persistence side effect.

Also reflow ai_client.c JSON escape switch and HTTP-error ternary to
satisfy clang-format 18 (CI checks).
2026-05-14 17:34:54 +03:00
0847394d34 Merge branch 'test/ai-coverage-unit-only' into fix/ai-followups
Some checks failed
CI Code / Code Coverage (pull_request) Has been cancelled
CI Code / Check spelling (pull_request) Has been cancelled
CI Code / Linux (arch) (pull_request) Has been cancelled
CI Code / Linux (debian) (pull_request) Has been cancelled
CI Code / Linux (ubuntu) (pull_request) Has been cancelled
CI Code / Check coding style (pull_request) Has been cancelled
Pull in the defaults-agnostic unit and functional test coverage so this
branch carries both the source fixes and the tests that exercise them.

# Conflicts:
#	src/ai/ai_client.c
2026-05-14 17:24:16 +03:00
5104de40d3 refactor(ai): consolidate per-provider prefs into [ai/<name>] sections
Per-provider state used to live as flat keys in [ai] with naming
conventions to avoid collisions: <name>_url, <name>_models,
<name>_default_model, and the bare <name> for the API token. Custom
settings (/ai set custom) never made it to disk at all — they only
lived in the runtime AIProvider.settings hash table and were lost on
restart.

Move every per-provider field into a [ai/<name>] subsection of the
keyfile with stable key names:

  [ai/openai]
  url=https://api.openai.com/
  key=sk-...
  default_model=gpt-4
  models=gpt-4;gpt-3.5-turbo
  setting.tools=enabled

[ai] now keeps only the global "defaults_initialized" sentinel.

Migration runs once in _prefs_load: collect provider names from the
old <name>_url keys, then move url/models/default_model/token of each
provider into its subsection and drop the flat keys. Idempotent on
subsequent loads.

prefs_ai_* API surface kept compatible; storage backend changes only.
Adds:
  prefs_ai_remove_section()    — wipe whole subsection in one call
  prefs_ai_{set,get,remove,list}_setting() — persist custom settings

ai_client wiring:
- ai_set_provider_setting now writes to prefs as well as the runtime
  hash table; ai_client_init loads them back on startup.
- ai_remove_provider replaces four prefs_ai_remove_* calls with a
  single prefs_ai_remove_section.
2026-05-14 17:10:59 +03:00
659b9d77df refactor(ai): unify response and error JSON parsing
Both the chat response parser and the error envelope parser were doing
their own ad-hoc strstr scans and inline unescape loops, with different
sets of supported escape sequences (chat: \" \n; error: \" \n \\ \t).
Models endpoint errors didn't try to extract error.message at all and
surfaced raw response bodies to the user — inconsistent with the chat
path which already did parse them.

Consolidate around two helpers:

  _json_unescape_substring: decode \" \\ \/ \n \t \r \b \f into a fresh
    buffer; pass \uXXXX through verbatim (out of scope here).

  _extract_json_string: locate "field":"..." via _find_json_field
    (already handles JSON whitespace around the colon) and return the
    unescaped value, treating any \X inside the string body as opaque
    so embedded \" is never misread as the closing quote.

_parse_ai_response and _parse_error_response now each collapse to a
small wrapper around these helpers. Wire _parse_error_response into the
shared _curl_exec_and_handle 4xx branch so models requests also surface
the provider's error.message instead of the raw body.
2026-05-14 15:10:19 +03:00
de2d21a0ac fix(ai): persistence and command-output fixes
- Persist per-provider default model in [ai] prefs (set/get/remove
  helpers, load on init, clear with provider removal). Previously
  /ai set default-model only updated runtime state.

- Stop re-seeding openai/perplexity into [ai] every time the configured
  provider list is empty. The defaults are now seeded once, guarded by
  a "defaults_initialized" sentinel, so removing every provider does
  not silently restore them.

- /ai providers (no arg) now lists the configured providers with key
  status, instead of the hardcoded openai/perplexity blurb.

- /ai models <provider> (fresh fetch) prints the model names it cached,
  not just a count. Previously the user had to follow up with --cached
  to actually see them.

- /ai remove provider now also clears the persisted default model,
  token, and cached model list, leaving no orphan keys in [ai].

- Drop dead ai_models_find declaration from ai_client.h (no
  implementation in this tree).
2026-05-14 15:06:06 +03:00
65c6012677 test(ai): refactor coverage to be defaults-agnostic post feat/ai merge
Self-setup providers in tests instead of relying on hardcoded openai/perplexity
defaults. Multi-provider tests now use distinct URLs per provider; functional
tests check for http/https URL presence rather than specific provider names.

Drop ai_models_find tests (function removed upstream in feat/ai). Replace with
reset-hook + persistence coverage: providers_reset_ac restart cycle, provider
add/remove round-trip across init, model cache round-trip across init.

Keep three autocomplete prefix-change tests red in-suite (documented as latent
API-hygiene gap, unreachable from UI today). NULL-search test body retained
but registration commented out — currently SIGSEGVs the cmocka runner.

Add stub_xmpp connection_create_stanza_id to satisfy new cmd_funcs.c call site.
2026-05-14 11:59:44 +03:00
befdd0ba10 test(ai): autocomplete tests — 5 expected failures documenting real bugs
Adds 10 tests for ai_models_find and additional edge cases on
ai_providers_find. 5 pass as sanity; 5 fail intentionally, documenting
two distinct bugs in the autocomplete integration:

BUG A — ai_models_find cycling is broken
  src/ai/ai_client.c ai_models_find() allocates a fresh Autocomplete on
  every call and frees it before returning. The Autocomplete's last_found
  cursor is therefore never persisted, so repeated calls with the same
  prefix always return the first match. Tab+Tab+Tab cannot reach models
  2, 3, ...
  Caught by:
    - test_ai_models_find_cycles_through_matches
    - test_ai_models_find_null_search_cycles_all

BUG B — providers_ac is never reset between user input cycles
  src/ai/ai_client.c keeps the static providers_ac AC, but
  src/command/cmd_ac.c's all_acs[] (which cmd_ac_reset() iterates) does
  not include &providers_ac. So when the input loop fires the global
  reset, providers_ac retains its last_found cursor from the previous
  prefix.
  Result: tab-completing a new prefix continues from the old cursor
  position instead of restarting at the head of the new prefix's matches.
  A provider added mid-session may also be missed depending on cursor
  position.
  Caught by:
    - test_ai_providers_find_state_resets_on_prefix_change
    - test_ai_providers_find_empty_then_prefix
    - test_ai_providers_find_after_add_includes_new

Sanity (5 passing):
  - test_ai_models_find_no_models_returns_null
  - test_ai_models_find_returns_match_for_prefix
  - test_ai_models_find_no_match_returns_null
  - test_ai_models_find_previous_direction
  - test_ai_providers_find_after_remove_skips_removed

The failing tests are checked in as-is — they go green when the bugs
are fixed. See PR description for suggested fixes.
2026-05-14 08:47:24 +00:00
d676f3b087 test(ai): expand unit and functional coverage for /ai feature
Unit tests (tests/unittests/test_ai_client.c): +50 cases on top of the
existing 50 — total 100. Covers:
  - chat response parser (ai_parse_response): OpenAI content + Perplexity
    text formats, escape decoding, empty/null/missing inputs, format-string
    safety, multiline content
  - error envelope parser (ai_parse_error_message): standard envelope,
    nested escapes, missing fields, null/empty
  - extended JSON escape: \b, \f, \r, all-specials, UTF-8 pass-through
  - provider autocomplete cycling with >=2 matches and wrap-around
  - session edge cases: NULL args, 100-message order preservation,
    set_model(NULL), ref/unref(NULL)
  - provider edge cases: get/remove with NULL, double-remove, survival
    via session ref after ai_remove_provider
  - settings: multi-key independence, missing key, cross-provider
    isolation
  - model parsing edges: data not array, empty data, "id" outside data,
    multiple models
  - prefs round-trip: set token -> shutdown -> init -> token reloaded
    from disk (uses load_preferences fixture)

Functional tests:
  - Console only (test_ai.c): 15 cases for the /ai command surface that
    don't need HTTP. Covers /ai help, providers list, set provider/token,
    start with/without key/unknown provider, clear, remove, default
    provider/model, switch without window, bad subcommand.

Infrastructure:
  - TEST_GROUPS bumped to 5 in proftest.c; AI tests live in their own
    Group 5 because mixing them with stabber-driven tests in Group 4
    poisoned stbbr_stop() teardown.
  - PROF_FUNC_TEST_AI macro in functionaltests.c registers AI tests
    with ai_init_test() which wraps init_prof_test with a prof_connect()
    so stabber sees a graceful disconnect at teardown.

Source-level changes to enable testing:
  - src/ai/ai_client.{c,h}: dropped 'static' from _parse_ai_response
    (renamed ai_parse_response) and _parse_error_response (renamed
    ai_parse_error_message); declared under a "Parsing helpers (exposed
    for testing)" section. Same approach as ai_parse_models_from_json.

Results in Docker (cproof-debian image):
  - 595/595 unit tests pass
  - 15/15 AI functional tests pass (Group 5)
2026-05-14 08:47:24 +00:00
30ad6e2a6e fix(ac): use g_strdup instead of strdup for NULL-safety
Some checks failed
CI Code / Check spelling (pull_request) Successful in 19s
CI Code / Check coding style (pull_request) Successful in 34s
CI Code / Code Coverage (pull_request) Failing after 1m9s
CI Code / Linux (debian) (pull_request) Failing after 2m55s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m7s
CI Code / Linux (arch) (pull_request) Failing after 3m47s
2026-05-14 03:57:08 +00:00
7cf82c99f0 fix(ai): destroy mutex and remove locking in unref
Some checks failed
CI Code / Check spelling (pull_request) Successful in 20s
CI Code / Check coding style (pull_request) Successful in 35s
CI Code / Code Coverage (pull_request) Failing after 1m9s
CI Code / Linux (debian) (pull_request) Failing after 2m48s
CI Code / Linux (ubuntu) (pull_request) Failing after 2m56s
CI Code / Linux (arch) (pull_request) Failing after 3m35s
2026-05-14 03:54:30 +00:00
f93f7cdf2c fix(ai): unlock mutex before early return in error callback
Some checks failed
CI Code / Check coding style (pull_request) Successful in 36s
CI Code / Check spelling (pull_request) Successful in 20s
CI Code / Code Coverage (pull_request) Failing after 1m9s
CI Code / Linux (debian) (pull_request) Failing after 2m45s
CI Code / Linux (arch) (pull_request) Failing after 3m32s
CI Code / Linux (ubuntu) (pull_request) Failing after 2m53s
The mutex was not released when the aiwin pointer was invalid, leading to a potential deadlock in the AI thread.
2026-05-14 03:52:20 +00:00
a9f0153c0f fix(ai): prevent duplicate user message in AI JSON payload
Some checks failed
CI Code / Check spelling (pull_request) Successful in 17s
CI Code / Check coding style (pull_request) Successful in 32s
CI Code / Code Coverage (pull_request) Failing after 1m9s
CI Code / Linux (debian) (pull_request) Failing after 2m53s
CI Code / Linux (ubuntu) (pull_request) Failing after 2m59s
CI Code / Linux (arch) (pull_request) Failing after 3m39s
The user message was being added to session->history before calling
_build_json_payload_from_list(), which independently appends the prompt
to the JSON payload. This caused the same message to appear twice in
the API request.

Fix: Build JSON payload first, then add user message to history under
the same lock to maintain atomicity.
2026-05-14 03:50:12 +00:00
5a074b280d refactor(ai): remove hardcoded gpt-4o fallback model
Some checks failed
CI Code / Check coding style (pull_request) Successful in 38s
CI Code / Check spelling (pull_request) Successful in 18s
CI Code / Linux (arch) (pull_request) Failing after 3m33s
CI Code / Code Coverage (pull_request) Failing after 1m9s
CI Code / Linux (debian) (pull_request) Failing after 2m46s
CI Code / Linux (ubuntu) (pull_request) Failing after 2m53s
Remove the hardcoded "gpt-4o" fallback in cmd_ai_start to ensure
model selection relies exclusively on provider configuration defaults.
2026-05-14 03:37:59 +00:00
fba6a040ee refactor(cmd_ac): DRY AI autocomplete and fix trailing space API
Some checks failed
CI Code / Check spelling (pull_request) Successful in 18s
CI Code / Check coding style (pull_request) Successful in 32s
CI Code / Code Coverage (pull_request) Failing after 1m9s
CI Code / Linux (debian) (pull_request) Failing after 2m53s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m0s
CI Code / Linux (arch) (pull_request) Failing after 3m40s
- Replace _ai_model_autocomplete() with new _ai_provider_and_model_autocomplete()
  that handles both provider and model autocomplete in one function
- Add /ai set default-model model autocomplete support
- Remove trailing space requirement from cmd_prefix parameter (use \"/ai start\"
  instead of \"/ai start \")
- Fix const correctness in autocomplete_param_with_func() signature
- Remove unused space_at_end variable
2026-05-14 03:34:48 +00:00
89a224b017 feat(ai): allow /ai models command from console
Remove window type check from cmd_ai_models() so fetching models works
from console. Response is shown via cons_show() when called from console,
or in the AI window when called from there.
2026-05-13 22:02:02 +00:00
b28b719d11 feat(ai): persist default providers to config on first use
Some checks failed
CI Code / Check spelling (pull_request) Successful in 23s
CI Code / Check coding style (pull_request) Successful in 38s
CI Code / Code Coverage (pull_request) Failing after 1m9s
CI Code / Linux (ubuntu) (pull_request) Failing after 2h57m20s
CI Code / Linux (debian) (pull_request) Failing after 2h57m22s
CI Code / Linux (arch) (pull_request) Failing after 2h57m25s
Fix /ai set provider <name> <url> not persisting across restarts, and
default providers (openai, perplexity) disappearing when user adds a
custom provider.

- Add prefs_ai_set_provider(), prefs_ai_remove_provider(),
  prefs_ai_get_provider_url(), prefs_ai_list_providers(),
  prefs_free_ai_providers() for provider persistence.

- Implement prefs_ai_get_providers() in preferences.c: if no providers
  are configured, write default providers to config and return them.
  This ensures defaults are persisted so users can modify them directly.

- Move default provider URL definitions from ai_client.c to
  preferences.c. ai_client.c no longer knows about specific provider
  names.

- Simplify ai_client_init() to call prefs_ai_get_providers() and
  initialize with whatever it receives.

- ai_add_provider() persists to config; ai_remove_provider() removes
  from config.

Behavior: On first run, default providers are written to config. User
can then modify, remove, or add providers freely and they persist.
2026-05-13 21:44:02 +00:00
b21d537e80 feat(ai): persist custom providers to config and move defaults to preferences
Some checks failed
CI Code / Check spelling (pull_request) Successful in 22s
CI Code / Code Coverage (pull_request) Failing after 1m12s
CI Code / Linux (debian) (pull_request) Failing after 3m13s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m21s
CI Code / Linux (arch) (pull_request) Failing after 4m1s
CI Code / Check coding style (pull_request) Failing after 13m40s
Fix /ai set provider <name> <url> not persisting across restarts.

- Add prefs_ai_set_provider(), prefs_ai_remove_provider(),
  prefs_ai_get_provider_url(), prefs_ai_list_providers(),
  prefs_free_ai_providers(), and prefs_ai_get_default_provider_url()
  to preferences.h/c for provider persistence.

- Move default provider URL definitions (openai, perplexity) from
  ai_client.c to preferences.c, following the established pattern
  where defaults are returned as fallbacks when no config value exists.

- Modify ai_add_provider() to persist new/updated providers to config.

- Modify ai_remove_provider() to remove provider from config.

- Add internal _ai_add_provider_nopersist() helper for adding default
  providers and loading from config without double-persisting.

- Update ai_client_init() to load custom providers from config on
  startup, allowing users to override defaults or add new ones.

Users now have full control: default providers remain as fallbacks,
user-added providers persist to config, and users can override or
remove defaults freely.
2026-05-13 18:28:35 +00:00
2f1637ca8e fix(ai): add reset for models_ac and streamline model autocomplete handling
Some checks failed
CI Code / Check spelling (pull_request) Successful in 22s
CI Code / Check coding style (pull_request) Successful in 36s
CI Code / Code Coverage (pull_request) Failing after 1m11s
CI Code / Linux (debian) (pull_request) Failing after 3m10s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m20s
CI Code / Linux (arch) (pull_request) Failing after 4m3s
Replace the custom ai_models_find function with a dedicated
ai_models_ac autocomplete list. Update the /ai switch trigger to
include a trailing space for consistent parsing.
2026-05-13 12:59:29 +00:00
277c82fb5d refactor(ai): remove default command and enforce strict window context
Some checks failed
CI Code / Check spelling (pull_request) Successful in 23s
CI Code / Check coding style (pull_request) Successful in 37s
CI Code / Code Coverage (pull_request) Failing after 1m8s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m5s
CI Code / Linux (arch) (pull_request) Failing after 3m51s
CI Code / Linux (debian) (pull_request) Failing after 5m58s
- Remove `/ai set default-provider` command and related autocomplete logic
- Remove global `wins_get_ai()` window accessor function
- Enforce strict requirement that `/ai model`, `/ai switch`, `/ai models`, and `/ai clear` commands must be executed from within an active AI chat window
- Update `/ai start` to require `<provider>` argument

BREAKING CHANGE: `/ai model`, `/ai switch`, `/ai models`, and `/ai clear` commands now require an active AI window context. The `/ai set default-provider` command has been removed.
2026-05-13 12:41:20 +00:00
1ecaceb59f fix(ai): reset provider autocomplete state on search string change
Some checks failed
CI Code / Code Coverage (pull_request) Failing after 12m29s
CI Code / Check spelling (pull_request) Failing after 13m4s
CI Code / Check coding style (pull_request) Failing after 13m36s
CI Code / Linux (ubuntu) (pull_request) Failing after 14m13s
CI Code / Linux (debian) (pull_request) Failing after 14m48s
CI Code / Linux (arch) (pull_request) Failing after 15m25s
When typing /ai start <prefix><tab>, the autocomplete was not properly
handling search string changes. For example, typing "/ai start o<tab>"
would return "openai", but then typing "/ai start p<tab>" would still
return "openai" because the autocomplete state was not reset.

This commit:
- Adds ai_providers_reset_ac() function to reset provider autocomplete
  state, following the same pattern as accounts_reset_all_search()
- Integrates ai_providers_reset_ac() into cmd_ac_reset() for proper
  state cleanup when user presses Ctrl+C or switches contexts
2026-05-13 09:40:52 +00:00
18fb7fa733 fix(ai): pass stanza ID to AI message send function
Some checks failed
CI Code / Code Coverage (pull_request) Failing after 12m1s
CI Code / Check spelling (pull_request) Failing after 12m26s
CI Code / Check coding style (pull_request) Failing after 13m0s
CI Code / Linux (ubuntu) (pull_request) Failing after 13m34s
CI Code / Linux (debian) (pull_request) Failing after 14m1s
CI Code / Linux (arch) (pull_request) Failing after 14m23s
2026-05-12 17:08:30 +00:00
a75a06b4a2 Fix(ai): protect AI session state from concurrent access races
Some checks failed
CI Code / Check spelling (pull_request) Successful in 20s
CI Code / Check coding style (pull_request) Successful in 35s
CI Code / Linux (debian) (pull_request) Failing after 3m47s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m54s
CI Code / Code Coverage (pull_request) Successful in 6m41s
CI Code / Linux (arch) (pull_request) Failing after 9m31s
cmd_ai_switch() and cmd_ai_clear() mutated session fields (provider_name,
provider, model, api_key, history) on the main thread without coordination,
while _ai_request_thread() read the same fields concurrently in the worker
thread. This caused use-after-free when:

- g_free(session->model) was called between worker's read and g_strdup()
- ai_provider_unref(session->provider) freed the provider struct while
  worker accessed session->provider->api_url
- ai_session_clear_history() freed the history list while worker walked it

Fix:
1. Add pthread_mutex_t lock to AISession struct to protect all session
   fields from concurrent access.

2. Introduce ai_session_switch() public API that atomically switches
   provider, model, and API key under the session lock. This encapsulates
   all session mutations within ai_client.c so cmd_funcs.c never touches
   session fields directly.

3. Have _ai_request_thread() snapshot all session state under the session
   lock before making requests, using local copies for the duration of
   the curl request.

4. Add ai_provider_ref()/ai_provider_unref() around _ai_generic_request_thread()
   to prevent provider UAF during model-fetch requests.

5. Protect ai_session_add_message(), ai_session_clear_history(), and
   ai_session_set_model() with the session lock.

No pthread.h needed in cmd_funcs.c — all locking is encapsulated within
ai_client.c via the public API. No deadlock risk from nested locks.

Files changed:
- src/ai/ai_client.h: Add lock field, ai_session_switch() declaration
- src/ai/ai_client.c: Mutex init/destroy, session mutation protection,
  worker thread snapshot, provider ref management
- src/command/cmd_funcs.c: Use ai_session_switch() API, remove pthread.h
2026-05-11 23:42:24 +00:00
9f4621883a fix(ai): add mutex to AISession for thread safety
Some checks failed
CI Code / Linux (debian) (pull_request) Failing after 3m27s
CI Code / Linux (arch) (pull_request) Failing after 5m14s
CI Code / Code Coverage (pull_request) Failing after 10m52s
CI Code / Check spelling (pull_request) Failing after 10m57s
CI Code / Check coding style (pull_request) Failing after 11m2s
CI Code / Linux (ubuntu) (pull_request) Failing after 11m8s
Introduce a pthread mutex to protect all AISession fields from
concurrent access between the main thread and background request
worker.

- Initialize and destroy mutex during session lifecycle
- Lock session state when modifying or reading history, model, and
  provider fields
- Snapshot session state under lock in the request worker thread to
  prevent UAF races during API calls
- Refactor _build_json_payload to accept direct parameters for safe
  usage under lock
- Update command handlers to safely switch provider/model under lock
2026-05-11 23:26:14 +00:00
6fe8c370df ref(ai): remove org_id from provider configuration
Some checks failed
CI Code / Code Coverage (pull_request) Failing after 10m47s
CI Code / Check spelling (pull_request) Failing after 10m58s
CI Code / Check coding style (pull_request) Failing after 11m10s
CI Code / Linux (ubuntu) (pull_request) Failing after 11m30s
CI Code / Linux (debian) (pull_request) Failing after 11m42s
CI Code / Linux (arch) (pull_request) Failing after 11m54s
The org_id field was removed from AIProvider as it was no longer
populated through the command surface. The /ai set org command was
previously removed, leaving org_id as dead code.

This change removes org_id from:
- AIProvider struct definition
- ai_provider_new() and ai_provider_unref()
- ai_add_provider() API signature
- _build_curl_headers() (OpenAI-Organization header)
- cmd_ai_set() and cmd_ai_providers()
- All unit tests
2026-05-11 22:58:39 +00:00
b1dbe714e8 fix(ai): use atomic ai_provider_ref() in cmd_ai_switch
Some checks failed
CI Code / Linux (arch) (pull_request) Failing after 10m9s
CI Code / Code Coverage (pull_request) Failing after 14m6s
CI Code / Check spelling (pull_request) Failing after 14m27s
CI Code / Check coding style (pull_request) Failing after 14m44s
CI Code / Linux (ubuntu) (pull_request) Failing after 15m9s
CI Code / Linux (debian) (pull_request) Failing after 15m43s
src/command/cmd_funcs:11118 used a plain non-atomic ref_count++ on
ai_provider, which is a data race against concurrent
ai_provider_unref() calls using g_atomic_int_dec_and_test.

- Expose ai_provider_ref() in ai_client.h (was static)
- Replace non-atomic ref_count++ with ai_provider_ref() in cmd_ai_switch"
2026-05-11 21:15:10 +00:00
107f7778e2 fix(ai): collapse validate and dispatch into single critical section
Some checks failed
CI Code / Check spelling (pull_request) Successful in 31s
CI Code / Check coding style (pull_request) Successful in 43s
CI Code / Code Coverage (pull_request) Successful in 2m28s
CI Code / Linux (debian) (pull_request) Failing after 3m40s
CI Code / Linux (arch) (pull_request) Failing after 4m32s
CI Code / Linux (ubuntu) (pull_request) Failing after 6m18s
_aiwin_validate() no longer acquires the mutex. Callers now hold the
lock across both the existence check and the display dispatch,
eliminating the TOCTOU window where the window could be freed.
2026-05-11 20:54:42 +00:00
b634eed5af refactor(ai): remove cmd_ai_correct function
Some checks failed
CI Code / Check spelling (pull_request) Successful in 21s
CI Code / Check coding style (pull_request) Successful in 34s
CI Code / Code Coverage (pull_request) Successful in 2m28s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m43s
CI Code / Linux (arch) (pull_request) Failing after 4m43s
CI Code / Linux (debian) (pull_request) Failing after 6m15s
The /ai correct command implementation has been removed.
2026-05-11 20:34:06 +00:00
010b2062a4 fix(ai): reset paged flag to display user message
Some checks failed
CI Code / Linux (arch) (pull_request) Failing after 5m11s
CI Code / Code Coverage (pull_request) Failing after 11m1s
CI Code / Check spelling (pull_request) Failing after 11m4s
CI Code / Check coding style (pull_request) Failing after 11m11s
CI Code / Linux (ubuntu) (pull_request) Failing after 11m16s
CI Code / Linux (debian) (pull_request) Failing after 11m18s
When the user scrolls up to view history, the paged flag is set to 1.
This suppresses new messages in _win_printf(). Reset paged and
unread_msg flags before printing to ensure visibility.
2026-05-10 10:35:57 +00:00
ecb07fd00c fix(ai): improve API error parsing and fallback
Some checks failed
CI Code / Check spelling (pull_request) Successful in 20s
CI Code / Check coding style (pull_request) Successful in 35s
CI Code / Code Coverage (pull_request) Successful in 2m32s
CI Code / Linux (debian) (pull_request) Failing after 3m37s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m48s
CI Code / Linux (arch) (pull_request) Failing after 4m40s
Add early return for empty responses and fallback to console output
when the AI window is closed or invalid. Implement JSON error
parsing to extract readable messages from API failures, improving
debugging and user feedback.
2026-05-09 21:06:09 +00:00
a898cb212d feat(ai): implement robust JSON model parsing
Some checks failed
CI Code / Check coding style (pull_request) Successful in 46s
CI Code / Linux (arch) (pull_request) Failing after 9m46s
CI Code / Code Coverage (pull_request) Failing after 14m8s
CI Code / Check spelling (pull_request) Failing after 14m16s
CI Code / Linux (ubuntu) (pull_request) Failing after 14m24s
CI Code / Linux (debian) (pull_request) Failing after 14m33s
Rewrote internal JSON parsing to correctly handle whitespace, escaped
quotes, and strict field context extraction. This prevents incorrect
field names or provider names from being added to the model list.

Added `ai_parse_models_from_json` public API to facilitate testing.

Changed `/ai models` default behavior to always fetch fresh models.
Replaced `--refresh` flag with `--cached` to display local cache.

Added comprehensive unit tests covering OpenAI and Perplexity formats,
array format, empty/null JSON, escaped quotes, and whitespace handling.
2026-05-09 13:56:59 +00:00
07d267b5bc fix(ai): protect window validation with mutex
Some checks failed
CI Code / Check coding style (pull_request) Successful in 53s
CI Code / Check spelling (pull_request) Successful in 19s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m49s
CI Code / Linux (arch) (pull_request) Failing after 4m31s
CI Code / Code Coverage (pull_request) Successful in 2m23s
CI Code / Linux (debian) (pull_request) Failing after 5m58s
The existence check accesses shared state without synchronization,
which can cause race conditions when called from background threads.
Explicitly locking the mutex ensures safe access during validation.
2026-05-09 13:20:48 +00:00
acae543057 feat(ai): add model caching, settings, and commands
Some checks failed
CI Code / Check spelling (pull_request) Successful in 23s
CI Code / Check coding style (pull_request) Successful in 35s
CI Code / Code Coverage (pull_request) Successful in 2m28s
CI Code / Linux (debian) (pull_request) Failing after 6m18s
CI Code / Linux (arch) (pull_request) Failing after 8m46s
CI Code / Linux (ubuntu) (pull_request) Failing after 11m4s
- Introduce model caching with persistence to preferences
- Add provider default model and custom settings management
- Implement `/ai switch`, `/ai models`, and improve `/ai start`
- Add model name autocomplete for chat commands
- Update command definitions and help text
- Add unit tests for new functionality
2026-05-09 13:15:58 +00:00
731b55fa19 Merge branch 'master' into feat/ai
Some checks failed
CI Code / Check spelling (pull_request) Successful in 18s
CI Code / Check coding style (pull_request) Successful in 33s
CI Code / Code Coverage (pull_request) Successful in 2m29s
CI Code / Linux (debian) (pull_request) Failing after 3m35s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m46s
CI Code / Linux (arch) (pull_request) Failing after 4m32s
2026-05-06 13:57:13 +00:00
e229ed1281 fix(ai): return CURL_WRITEFUNC_ERROR on oversized response
Some checks failed
CI Code / Check coding style (pull_request) Successful in 1m4s
CI Code / Check spelling (pull_request) Successful in 1m10s
CI Code / Code Coverage (pull_request) Successful in 2m51s
CI Code / Linux (arch) (pull_request) Failing after 3m39s
CI Code / Linux (debian) (pull_request) Failing after 5m13s
CI Code / Linux (ubuntu) (pull_request) Failing after 5m21s
Return CURL_WRITEFUNC_ERROR instead of realsize when the response
exceeds 10MB. This causes curl to abort the transfer immediately
instead of continuing to stream data.
2026-05-01 19:15:46 +00:00
f4221e27ac fix(ai): fix leak from ai_get_provider_key
Some checks failed
CI Code / Check spelling (pull_request) Successful in 1m7s
CI Code / Check coding style (pull_request) Successful in 1m54s
CI Code / Linux (debian) (pull_request) Failing after 3m0s
CI Code / Linux (arch) (pull_request) Failing after 3m7s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m8s
CI Code / Code Coverage (pull_request) Successful in 2m53s
2026-05-01 18:50:21 +00:00
cdcc45b7c6 ref(pref): add newline at the end of the file 2026-05-01 18:47:46 +00:00
f133d81a05 fix(ai): use atomic operations for refcounting
Some checks failed
CI Code / Check coding style (pull_request) Successful in 1m8s
CI Code / Check spelling (pull_request) Successful in 1m7s
CI Code / Linux (debian) (pull_request) Failing after 2m58s
CI Code / Linux (arch) (pull_request) Failing after 3m7s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m8s
CI Code / Code Coverage (pull_request) Successful in 2m54s
Replace plain ref_count++/-- with g_atomic_int_inc and
g_atomic_int_dec_and_test for both AIProvider and AISession refcounts.
Prevents data races when ref/unref is called from worker threads.
2026-05-01 18:24:57 +00:00
a16237d16b fix(ai): convert \n escape sequences to actual newlines in LLM responses
Some checks failed
CI Code / Check spelling (pull_request) Successful in 51s
CI Code / Check coding style (pull_request) Successful in 1m7s
CI Code / Linux (debian) (pull_request) Failing after 2m56s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m5s
CI Code / Linux (arch) (pull_request) Failing after 3m5s
CI Code / Code Coverage (pull_request) Successful in 2m59s
2026-05-01 18:21:47 +00:00
cfe6ea46e2 feat(ai): disable request storage via store:false parameter
Some checks failed
CI Code / Check coding style (pull_request) Successful in 1m22s
CI Code / Linux (arch) (pull_request) Failing after 3m12s
CI Code / Check spelling (pull_request) Successful in 1m50s
CI Code / Linux (debian) (pull_request) Failing after 2m52s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m4s
CI Code / Code Coverage (pull_request) Successful in 2m49s
Add store:false to AI API requests to prevent OpenAI, Perplexity, and
other providers from storing conversation data or using it for training.

Both the OpenAI Responses API and Perplexity API support the store
parameter to control whether requests are persisted. Setting it to false
ensures conversations remain private and are not retained by the provider.

Privacy:
- Requests are not stored by AI providers
- Conversations are not used for model training
- Aligns with CProof's privacy-first design
2026-05-01 17:05:44 +00:00
2fc7f3d672 fix(ai): validate aiwin pointer to prevent UAF when window closed
Some checks failed
CI Code / Check spelling (pull_request) Successful in 53s
CI Code / Check coding style (pull_request) Successful in 1m11s
CI Code / Linux (debian) (pull_request) Failing after 2m58s
CI Code / Linux (arch) (pull_request) Failing after 3m11s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m10s
CI Code / Code Coverage (pull_request) Successful in 2m46s
Prevent use-after-free in the AI request worker thread when the user
closes the AI window during the 60-second HTTP request timeout. Without
this fix, the worker may dereference a dangling pointer and crash or
exhibit undefined behavior.

The _ai_request_thread function in ai_client.c previously cast user_data
to ProfAiWin* and used it directly without verifying the window was still
alive. Added wins_ai_exists() to iterate through all AI windows and check
if the pointer is still valid before use.

Safety:
- wins_ai_exists() iterates all AI windows (handles multiple AI windows)
- Worker skips UI update if window was freed, just cleans up
- Logs warning when dangling pointer is detected
2026-05-01 17:03:47 +00:00
fe0a46da58 refactor(ai): add UI display helpers
Some checks failed
CI Code / Check spelling (pull_request) Successful in 54s
CI Code / Check coding style (pull_request) Successful in 2m4s
CI Code / Linux (debian) (pull_request) Failing after 2m56s
CI Code / Linux (arch) (pull_request) Failing after 3m10s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m9s
CI Code / Code Coverage (pull_request) Successful in 2m55s
Add static _aiwin_display_error() and
_aiwin_display_response() helpers to reduce mutex repetition and
log warnings when aiwin is NULL or invalid.
2026-05-01 16:36:07 +00:00
cead417e78 refactor(ai): remove redundant callback layer from AI client
Some checks failed
CI Code / Check spelling (pull_request) Successful in 53s
CI Code / Check coding style (pull_request) Successful in 1m8s
CI Code / Linux (debian) (pull_request) Failing after 2m55s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m4s
CI Code / Linux (arch) (pull_request) Failing after 3m7s
CI Code / Code Coverage (pull_request) Successful in 2m42s
The ai_response_cb and ai_error_cb parameters were always passed the
same functions (aiwin_display_response and aiwin_display_error),
making the callback indirection redundant and complicating the call
chain.

Remove ai_callback_data_t, _ai_callback_invoke(), and
_ai_invoke_callback(). Simplify _ai_request_thread and ai_send_prompt
to directly call aiwin_display_error() and aiwin_display_response()
when user_data is a valid ProfAiWin*.
2026-05-01 13:34:00 +00:00
00f11eb704 fix(ai): guard NULL search_str and update tests for new cycling behavior
Some checks failed
CI Code / Check spelling (pull_request) Successful in 21s
CI Code / Check coding style (pull_request) Successful in 37s
CI Code / Linux (debian) (pull_request) Failing after 2m56s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m7s
CI Code / Code Coverage (pull_request) Successful in 2m55s
CI Code / Linux (arch) (pull_request) Failing after 3m45s
Update ai_providers_find() to handle NULL search_str safely by treating it
as an empty string, preventing a segfault in strdup() within autocomplete_complete().

Rename test_ai_providers_find_case_sensitive to test_ai_providers_find_case_insensitive
to reflect the new case-insensitive matching contract. Update all affected tests to
expect cycling behavior (NULL/empty returns first provider) and use auto_gchar for
automatic memory management.

Use `gchar` instead of `char` in ai_providers_find for consistency
2026-05-01 13:08:28 +00:00
4913a3d5a4 ref(ai): remove inaccurate logging 2026-05-01 12:56:57 +00:00
634fb7d7eb fix(ai): standardize lock handling in _ai_invoke_callback
Some checks failed
CI Code / Check spelling (pull_request) Successful in 20s
CI Code / Check coding style (pull_request) Successful in 34s
CI Code / Code Coverage (pull_request) Failing after 1m6s
CI Code / Linux (debian) (pull_request) Failing after 2m59s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m11s
CI Code / Linux (arch) (pull_request) Failing after 3m19s
Take the global lock mutex before invoking all callbacks (success
and error) to ensure thread-safety. Previously some paths took the
lock and others did not, creating asymmetric behavior that could
lead to data races when callbacks access UI state.
2026-05-01 11:35:09 +00:00
461c0c32dd refactor(ai): use stateful autocomplete for provider name matching
Some checks failed
CI Code / Check spelling (pull_request) Successful in 57s
CI Code / Check coding style (pull_request) Successful in 1m4s
CI Code / Code Coverage (pull_request) Failing after 1m7s
CI Code / Linux (debian) (pull_request) Failing after 2m58s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m9s
CI Code / Linux (arch) (pull_request) Failing after 3m47s
Replace the manual GHashTable iteration in ai_providers_find() with the
existing stateful autocomplete system. Provider names are now kept in
sync via autocomplete_add/remove during ai_add_provider/ai_remove_provider,
and ai_providers_find delegates to autocomplete_complete() for deterministic
tab-completion cycling through sorted results.

This eliminates manual GList allocation, iteration, and cleanup, while
providing consistent forward/backward cycling behavior shared by all
autocomplete callers.
2026-04-30 23:16:12 +00:00
002a6ed15b refactor(ai): flatten autocomplete into sequential prefix-matching chain
Some checks failed
CI Code / Check spelling (pull_request) Successful in 1m5s
CI Code / Check coding style (pull_request) Successful in 2m7s
CI Code / Linux (arch) (pull_request) Failing after 3m9s
CI Code / Code Coverage (pull_request) Successful in 2m54s
CI Code / Linux (debian) (pull_request) Successful in 4m28s
CI Code / Linux (ubuntu) (pull_request) Successful in 4m41s
Replace the deeply nested conditional tree in _ai_autocomplete() with a
flat sequential chain of autocomplete_param_with_*() calls. Each call
tries a specific command prefix (e.g., "/ai set provider", "/ai start")
and returns immediately on match — a common, reliable pattern for
command-line tab completion.

The previous design nested provider-name autocomplete inside
g_strv_length() and g_strcmp0() checks, meaning /ai<tab> and /ai <tab>
would never reach the subcommand matcher. The new flat structure ensures
every prefix is tried in order, with the most specific prefixes first
and the generic /ai subcommand fallback last.

This pattern — sequential prefix matching with early return — is the
standard approach for autocomplete dispatch: each handler owns its
prefix, no shared state or argument parsing is needed, and adding a
new subcommand is a single append to the chain.
2026-04-30 23:10:14 +00:00
dc75f16221 fix(ai): move generic subcommand autocomplete outside nested conditionals
Some checks failed
CI Code / Check spelling (pull_request) Successful in 22s
CI Code / Check coding style (pull_request) Successful in 1m8s
CI Code / Linux (arch) (pull_request) Failing after 3m7s
CI Code / Code Coverage (pull_request) Successful in 2m58s
CI Code / Linux (debian) (pull_request) Successful in 4m22s
CI Code / Linux (ubuntu) (pull_request) Successful in 4m35s
The generic `/ai <subcommand>` tab-completion was nested inside conditional
blocks that prevented it from firing in common cases — for example,
`/ai<tab>` or `/ai <tab>` would never match subcommands because the
`autocomplete_param_with_ac()` call was guarded by argument count checks
and nested inside the explicit handler branches.

Move the fallback subcommand autocomplete to execute unconditionally after
all explicit handler branches, ensuring `/ai <tab>` always lists available
subcommands regardless of argument count or which subcommand was typed.

Also move the `/ai set` subcommand fallback outside the inner else-block
so it runs whenever args[0] is "set", not only when num_args >= 2.
2026-04-30 22:51:07 +00:00
da0bf43d73 fix(ai): join multi-word arguments in cmd_ai_correct
Some checks failed
CI Code / Check spelling (pull_request) Successful in 24s
CI Code / Check coding style (pull_request) Successful in 37s
CI Code / Linux (arch) (pull_request) Failing after 3m7s
CI Code / Code Coverage (pull_request) Successful in 2m57s
CI Code / Linux (debian) (pull_request) Successful in 4m24s
CI Code / Linux (ubuntu) (pull_request) Successful in 4m37s
Use g_strjoinv to join all arguments from args[1] onwards into a
single prompt string. Previously only args[1] was used, truncating
multi-word prompts like '/ai correct hello world' to just 'hello'
2026-04-30 19:24:39 +00:00
9e1f9b666e fix(ai): fix provider_name leak and const-cast in cmd_ai_start
Some checks failed
CI Code / Check spelling (pull_request) Successful in 55s
CI Code / Linux (arch) (pull_request) Failing after 3m25s
CI Code / Check coding style (pull_request) Successful in 1m38s
CI Code / Linux (debian) (pull_request) Successful in 4m42s
CI Code / Code Coverage (pull_request) Successful in 2m50s
CI Code / Linux (ubuntu) (pull_request) Successful in 8m12s
Use auto_gchar temporary for g_strndup result in cmd_ai_start to
prevent memory leak. Fix const-cast warning by using a proper
non-const temporary variable.
2026-04-30 19:14:49 +00:00
93ad7379e2 fix(ai): align ai_list_providers with documented contract
All checks were successful
CI Code / Check coding style (pull_request) Successful in 48s
CI Code / Check spelling (pull_request) Successful in 33s
CI Code / Linux (debian) (pull_request) Successful in 4m47s
CI Code / Linux (arch) (pull_request) Successful in 5m29s
CI Code / Code Coverage (pull_request) Successful in 2m45s
CI Code / Linux (ubuntu) (pull_request) Successful in 4m29s
Remove ai_provider_ref() from ai_list_providers() so the returned
providers do not need to be unref'd by the caller. This matches the
header docstring which states "caller must not free the list or
providers". Also update all callers (cmd_ai_providers, tests) to
remove redundant ai_provider_unref() calls.
2026-04-30 19:09:46 +00:00
caa0b3ccba fix(ai): remove redundant g_strdup on api_key assignment
Some checks failed
CI Code / Check coding style (pull_request) Successful in 37s
CI Code / Check spelling (pull_request) Successful in 21s
CI Code / Linux (arch) (pull_request) Failing after 3m12s
CI Code / Code Coverage (pull_request) Successful in 2m47s
CI Code / Linux (debian) (pull_request) Successful in 4m21s
CI Code / Linux (ubuntu) (pull_request) Successful in 4m53s
ai_get_provider_key() already returns a freshly g_strdup'd copy of
the API key. The outer g_strdup in ai_session_create() created an
unnecessary second copy, leaking the original pointer.
2026-04-30 19:06:49 +00:00
c9a5239117 fix(ai): remove API key from debug log
Some checks failed
CI Code / Check spelling (pull_request) Successful in 22s
CI Code / Check coding style (pull_request) Successful in 37s
CI Code / Linux (debian) (pull_request) Failing after 2m59s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m10s
CI Code / Code Coverage (pull_request) Successful in 2m58s
CI Code / Linux (arch) (pull_request) Failing after 3m59s
Remove the log_debug line in ai_client.c that leaked the first 10
characters of the API key into logs. This is also contained a memory leak (g_strndup
return value was never freed).
2026-04-30 19:05:33 +00:00
25e0459979 fix(ai): persist API keys to disk after set/remove operations
API keys set via /ai set token were only stored in memory and lost
on client restart. prefs_ai_set_token() and prefs_ai_remove_token()
mutated the in-memory prefs but never called _save_prefs(), unlike
other preference setters in the same file.

Both functions now call _save_prefs() after mutating the keyfile,
ensuring API keys persist across client restarts as advertised.
2026-04-30 19:01:10 +00:00
bccd3ecded fix(ai): remove duplicate assistant response in the message history
Some checks failed
CI Code / Check coding style (pull_request) Successful in 44s
CI Code / Linux (debian) (pull_request) Failing after 2m59s
CI Code / Linux (arch) (pull_request) Failing after 3m7s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m7s
CI Code / Check spelling (pull_request) Successful in 17s
CI Code / Code Coverage (pull_request) Successful in 2m46s
2026-04-30 18:05:51 +00:00
cff05ca802 ref(ai): move unfitting functions out of window.c; create aiwin.c
Some checks failed
CI Code / Check coding style (pull_request) Failing after 34s
CI Code / Check spelling (pull_request) Successful in 22s
CI Code / Linux (arch) (pull_request) Failing after 2m57s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m16s
CI Code / Linux (debian) (pull_request) Failing after 6m16s
CI Code / Code Coverage (pull_request) Successful in 7m12s
2026-04-30 18:01:24 +00:00
9c8ad57b59 ref(ai): add stub, fix includes, move aiwin_send_message location
Some checks failed
CI Code / Check spelling (pull_request) Successful in 22s
CI Code / Check coding style (pull_request) Successful in 34s
CI Code / Linux (debian) (pull_request) Failing after 2m57s
CI Code / Linux (ubuntu) (pull_request) Failing after 3m9s
CI Code / Linux (arch) (pull_request) Failing after 3m13s
CI Code / Code Coverage (pull_request) Successful in 2m54s
2026-04-30 17:41:36 +00:00
1f1770bd58 fix(ai): set correct links in tests, fix headers 2026-04-30 17:02:54 +00:00
e43e8378b0 feat(ai): add AI client with multi-provider support and UI
Some checks failed
CI Code / Check coding style (pull_request) Successful in 47s
CI Code / Check spelling (pull_request) Successful in 59s
CI Code / Code Coverage (pull_request) Failing after 1m8s
CI Code / Linux (debian) (pull_request) Failing after 2m28s
CI Code / Linux (ubuntu) (pull_request) Failing after 2m41s
CI Code / Linux (arch) (pull_request) Failing after 3m15s
Add an AI client module that integrates with OpenAI-compatible API
providers (OpenAI, Perplexity, and custom providers) to provide
AI-assisted responses within the profanity client.

The implementation includes:

- src/ai/ai_client.c/h: Core AI client with provider management,
  session handling, and async HTTP request handling via libcurl.
  Supports per-provider API keys stored in preferences, reference-
  counted sessions, and conversation history tracking.

- src/ui/window.c/window_list.c: New AI window type (ProfAiWin) for
  displaying AI conversations, with response streaming and error
  display capabilities.

- Command integration: New `/ai` command (cmd_defs.c, cmd_funcs.c)
  for creating sessions, sending prompts, and managing providers.
  Provider autocomplete support in cmd_ac.c.

- Preferences integration: API keys for providers are persisted in
  the preferences system (config/preferences.c).

- Unit tests: 472 lines of comprehensive tests covering provider
  management, session lifecycle, JSON escaping, and autocomplete
  (tests/unittests/test_ai_client.c).

Architecture decisions:
- Asynchronous design: HTTP requests run on a separate thread to
  avoid blocking the main UI loop. Callbacks are invoked on the main
  thread via direct function call (profanity uses ncurses, not GLib
  main loop).
- Reference counting: Both AIProvider and AISession use ref counting
  for safe shared ownership.
- Response size limit: 10MB cap on HTTP responses to prevent OOM.
2026-04-29 19:23:33 +00:00
319 changed files with 10514 additions and 11806 deletions

49
.builds/openbsd.yml Normal file
View File

@@ -0,0 +1,49 @@
image: openbsd/7.0
packages:
- gcc-11.2.0p0
- cmake
- gmake
- cmocka
- libtool
- automake-1.16.3
- pkgconf
- readline
- python-3.8.12
- autoconf-2.69p3
- autoconf-archive
- curl
- gpgme
- glib2
- gtk+2
- libotr
- libassuan
- libgpg-error
- libgcrypt
- libsignal-protocol-c
- sqlite3
sources:
- https://github.com/strophe/libstrophe.git#0.11.0
- https://github.com/profanity-im/profanity
environment:
LANG: en_US.UTF-8
tasks:
- symlink: |
doas ln -sf /usr/local/bin/python3 /usr/local/bin/python
doas ln -sf /usr/local/bin/python3-config /usr/local/bin/python-config
doas ln -sf /usr/local/bin/pydoc3 /usr/local/bin/pydoc
- build: |
export AUTOCONF_VERSION=2.69
export AUTOMAKE_VERSION=1.16
cd ~/libstrophe
./bootstrap.sh
./configure
make
doas make install
cd ~/profanity
./ci-build.sh

View File

@@ -1,23 +0,0 @@
{
"extends": ["@commitlint/config-conventional"],
"rules": {
"type-enum": [
2,
"always",
[
"feat",
"fix",
"docs",
"style",
"refactor",
"perf",
"tests",
"build",
"ci",
"chore",
"cleanup"
]
],
"subject-case": [0]
}
}

11
.gitattributes vendored
View File

@@ -1,11 +0,0 @@
# Pattern Attribute
.clang-format export-ignore
.codespellrc export-ignore
.commitlintrc.json export-ignore
.git-blame-ignore-revs export-ignore
.github/ export-ignore
CONTRIBUTING.md export-ignore
RELEASE_GUIDE.md export-ignore
ci/ export-ignore
prof.supp export-ignore
scripts/ export-ignore

44
.github/ISSUE_TEMPLATE/bug_report.md vendored Normal file
View File

@@ -0,0 +1,44 @@
---
name: Bug report
about: Create a report
title: ''
labels: bug
assignees: ''
---
<!--- Provide a general summary of the issue in the Title above -->
<!--- More than 50 issues open? Please don't file any new feature requests -->
<!--- Help us reduce the work first :-) -->
## Expected Behavior
<!--- If you're describing a bug, tell us what should happen -->
<!--- If you're suggesting a change/improvement, tell us how it should work -->
## Current Behavior
<!--- If describing a bug, tell us what happens instead of the expected behavior -->
<!--- If suggesting a change/improvement, explain the difference from current behavior -->
## Possible Solution
<!--- Not obligatory, but suggest a fix/reason for the bug, -->
<!--- or ideas how to implement the addition or change -->
## Steps to Reproduce (for bugs)
<!--- Describe, in detail, what needs to happen to reproduce this bug -->
<!--- Give us a screenshot (if it's helpful for this particular bug) -->
1.
2.
3.
4.
## Context
<!--- How has this issue affected you? What are you trying to accomplish? -->
## Environment
* Give us the version and build information output generated by `profanity -v`
* If you could not yet build profanity, mention the revision you try to build from
* Operating System/Distribution
* glib version
* libstrophe version
* Some bugs might be due to specific implementation in the server. `/serversoftware example.domain` can be helpful

View File

@@ -1,20 +0,0 @@
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: feature
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.

View File

@@ -1,12 +1,3 @@
---
name: Bug report
about: Create a report
title: ''
labels: bug
assignees: ''
---
<!--- Provide a general summary of the issue in the Title above -->
<!--- More than 50 issues open? Please don't file any new feature requests -->
@@ -40,3 +31,4 @@ assignees: ''
* glib version
* libstrophe version
* Some bugs might be due to specific implementation in the server. `/serversoftware example.domain` can be helpful

View File

@@ -30,7 +30,7 @@ jobs:
steps:
- uses: actions/checkout@v4
- name: Build
run: docker build -f ci/Dockerfile.${{ matrix.flavor }} -t profanity .
run: docker build -f Dockerfile.${{ matrix.flavor }} -t profanity .
- name: Run tests
run: docker run profanity ./ci-build.sh
@@ -45,10 +45,10 @@ jobs:
# if this check fails, you have to update the number of auto types known and the list of auto types in the check below
- name: Check auto types are up-to-date
run: |
[[ "$(find src -type f -name '*.[ch]' -exec awk '/^#define auto_[\W]*/ {print $2}' '{}' \; | sort -u | wc -l)" == "9" ]] || exit -1
[[ "$(find src -type f -name '*.[ch]' -exec awk '/^#define auto_[\W]*/ {print $2}' '{}' \; | sort -u | wc -l)" == "8" ]] || exit -1
- name: Check auto types are initialized
run: |
grep -P 'auto_(char|gchar|gcharv|guchar|gerror|jid|sqlite|gfd|FILE)[\w *]*;$' -r src && exit -1 || true
grep -P 'auto_(char|gchar|gcharv|guchar|jid|sqlite|gfd|FILE)[\w *]*;$' -r src && exit -1 || true
- name: Check CWE-134 format string vulnerabilities
run: ./check-cwe134.sh
@@ -108,6 +108,6 @@ jobs:
steps:
- uses: actions/checkout@v4
- name: Build
run: docker build -f ci/Dockerfile.arch -t profanity-cov .
run: docker build -f Dockerfile.arch -t profanity-cov .
- name: Run coverage
run: docker run profanity-cov ./ci-build.sh --coverage-only

2
.gitignore vendored
View File

@@ -17,8 +17,6 @@ compile_commands.json
.project
.settings/
.vscode/
.kilo/
.roo/
*.plist/
# autotools

22
Brewfile Normal file
View File

@@ -0,0 +1,22 @@
brew 'autoconf'
brew 'autoconf-archive'
brew 'automake'
brew 'check'
brew 'cmocka'
brew 'curl'
brew 'expat'
brew 'glib'
brew 'gnutls'
brew 'gpgme'
brew 'gtk+'
brew 'libffi'
brew 'libotr'
brew 'libsignal-protocol-c'
brew 'libstrophe'
brew 'libtool'
brew 'ncurses'
brew 'openssl'
brew 'ossp-uuid'
brew 'pkg-config'
brew 'readline'
brew 'sqlite'

269
CHANGELOG
View File

@@ -1,5 +1,5 @@
cproof fork (unreleased)
========================
0.16.0 (unreleased)
===================
Changes:
- Add flat-file database backend as alternative to SQLite for message history.
@@ -10,271 +10,6 @@ Changes:
- Add vtable-based database backend abstraction allowing pluggable storage.
- Add `make check-functional-flatfile` target to run functional tests with
flat-file backend.
- Add AI client with multi-provider chat support (OpenAI, local, etc.).
- Consolidate logging controls; show database backend in the statusbar.
0.17.0 (2026-03-26)
===================
Special thanks to our sponsor Matthew Fennell!
3 people contributed to this release: @botantony, @sjaeckel and @jubalh.
The last release (0.16.0) was the first that could be compiled with the Meson build system.
It provided a tarball for autotools and a separate one for meson. The autotools tarball was done
so that distributions don't need dependencies on automake, autoconf and libtool.
Several distributions are dropping vendor tarballs and use git checkouts or autogenerated tarballs nowadays.
Meaning they need to run the above mentioned tools in the case of the autotools build anyways.
So this release will only be shipped with tarballs generated with meson. Profanity can still be compiled with both autotools or meson for easier adjustments. Autotols users just need to generate configure first. The next release will only use Meson. So we encourage everybody to build with Meson arleady and report any bugs they encounter.
We finally re-enabled functional tests (along with our existing unit tests) again!
It would be appreciated if we could find people who want to help us expand the unit and functional tests so we are less likely to introduce regressions when we rewrite existing code.
Features:
- Add OMEMO trust status indicators to the titlebar (#2104)
- Add command autocompletion for /stamp (#2126)
- Add jid_is_valid_user_jid() to check for valid user JIDs (#2102)
- Add unified quality-check script and git hook support (#2099)
- Display incoming reports (XEP-0377) (#2117)
- Handle and allow JIDs with trailing slashes (#2102)
- Implement color coded status messages for file transfers (#2131)
- Implement dynamic pad resizing (#2122)
- Improve XEP-0377 support with report-origin and third-party elements (#2117)
- Improve feedback during OMEMO session Initiation (#2104)
- Improve validation of JIDs (#2102)
- Notify users when new OMEMO devices or fingerprints are discovered (#2104)
- Only request receipts when supported (#2101)
- Provide descriptive fallback messages for OMEMO decryption failures (#2104)
- Provide detailed encryption failure messages for OMEMO (#2104)
- Sanitize illegal XML characters from outgoing messages (#2116)
- Show active and trust status in /omemo fingerprint (#2104)
- Support UTF-8 characters in autocompletion (#2115)
- Suppress "new device" alerts for already known devices (#2113)
- Suppress redundant `session already exists` messages (#2113)
- Suppress repetitive missing device ID warnings (#2113)
- Introduce `prof_date_time_format_iso8601()`. (#2112)
- Optimize random data generation. (#2109)
Bug Fixes:
- Allow adding own JID to roster (#2127)
- Check for necessary pointers in omemo_receive_message
- Correct handling of create_fulljid without resource (#2102)
- Database return NULL if no history limits are found (#2102)
- Define `prefs_changes_print` outside of `prefs_changes` (#2090)
- Dont OMEMO trust check so often (#2108)
- Fix -Wanalyzer-deref-before-check warning in cmd_ac_complete (#2095)
- Fix Floating Point Exception in OMEMO session building (#2096)
- Fix NULL dereference and memory leak in _mam_rsm_id_handler (#2094)
- Fix NULL dereference and memory leaks in OX logic (#2094)
- Fix api_get_current_occupants() memory problems (#2094)
- Fix custom outgoing stamp and fix stamp command help (#2126)
- Fix file autocompletion bugs and restore cycling (#2100)
- Fix memory leak and potential crash in iq_id_handler_add (#2094)
- Fix not saving first created account (#2107)
- Fix rare memleak (#2123)
- Fix redundant error reporting in http download (#2094)
- Fix usage error in /time command (#2101)
- Handle potential NULL from malloc in OMEMO fingerprint decoding (#2094)
- Ignore self-presence for untracked MUC rooms (#2097)
- Improve status reporting and filename handling for /url save (#2131)
- Incorrect omemo decryption error for Key Transport Messages (#2130)
- Increase max arguments for /connect to 9 (#2101)
- Initialize OMEMO pointers and add NULL checks (#2094)
- Missing plugins_post_chat_message_display calls (#2118)
- Only allow /msg with valid JIDs (#2102)
- Sanitize account names (#2105)
- Segfault when using /command help (#2094)
- Use <body> tag for spam reporting (XEP-0377) (#2117)
- Fix -Wanalyzer-deref-before-check warning in get_message_from_editor (#2095)
- Fix potential double free. (#2112)
- Fix potential segfault. (#2109)
- Flush OMEMO store only after encrypting for all recipients. (#2109)
- Check connection state before accepting command. (#2124)
Documentation:
- Add Conventional Commit Structure
- Add a section explaining how to write functional tests (#2101)
- Add information about footers in git commit messages
- Add note about sanitizers overhead (#2101)
- Add section explaining how to run functional tests (#2101)
- Expand the build section in CONTRIBUTING.md (#2099)
- Explain how to turn clang-format of for some blocks of code (#2099)
- Explain how to write unit tests (#2099)
- Improve help for /blocked (#2117)
- Mention generated html pages in release guide
- Sort entries in theme_template
- Update implemented XEPs
- Update theme_template with missing options
Cleanup:
- Adapt loop counter to proper type (#2089)
- Adapt type and cast to get ride of warnings (#2089)
- Add a defensive check in cmd_process_input() (#2094)
- Be a bit more defensive in (#2094)
- Be a bit more defensive in server_events.c (#2094)
- Cast device ids in omemo.c (#2089)
- Cast g_hash_table_lookup return to function pointer (#2089)
- Cast to get rid of warnings (#2089)
- Check for strdup() success in stanza_create_http_upload_request() (#2094)
- Cleanup log module (#2094)
- Cleanup types (#2104)
- Correct comparison in cons_show_wins() (#2089)
- Fix cast function type warnings in pgp.c (#2089)
- Fix potential NULL dereference and leaks in cmd_sendfile (#2094)
- Fix potential NULL dereference in cmd_omemo_(un)trust (#2094)
- Fix potential null pointer dereference (#2094)
- Fix uninitialized field in color_distance() (#2089)
- Initialize GOptionEntry entries correctly (#2089)
- Initialize optional fields in profModule (#2089)
- Initialize waittime to 0 (#2094)
- Make _connection_handler() safer (#2094)
- Make muc_nick() return const char* (#2089)
- Map test files according to structure in src (#2099)
- Move loop var from int to size_t in cmd_funcs.c (#2089)
- Move loop var from int to size_t in omemo.c (#2089)
- Move more functions from int to guint in statusbar.c (#2089)
- Move some variables from int to guint in statusbar.c (#2089)
- Refactor account_eval_password to use glib (#2094)
- Use auto_FILE and handle fopen failure in command_docgen (#2094)
- Use g_malloc and auto_gchar in _win_print_wrapped (#2094)
- Use g_new() instead of malloc in prof_add_shutdown_routine() (#2094)
- Use g_new0 and g_strdup for alias allocation (#2094)
- Use g_new0 instead of malloc in buffer_get_entry_by_id() (#2094)
- Wrap release handler in iq.c (#2089)
- The buffer API should use `unsigned` types. (#2112)
Tests:
- Add prof_send_raw (#2115)
- Add test for get_expanded_path() (#2093)
- Add test for get_mentions() (#2093)
- Add test for release_is_new() (#2093)
- Add test for string_to_verbosity() (#2093)
- Add test for tab autocompletion of /msg (#2115)
- Add test for valid_tls_policy_option() (#2093)
- Add tests for string_matches_one_of() (#2093)
- Add tests for strtoi_range() (#2093)
- Apply coding style to unit tests (#2099)
- Check for binary before starting functional tests
- Don't build functional test with analyzer and increase timeouts (#2101)
- Fix functional presence tests (#2101)
- Fix functional test connect_shows_presence_updates (#2101)
- Fix functional test message_receive_chatwin (#2101)
- Fix functional test message_send (#2101)
- Fix functional test ping_jid (#2101)
- Fix functional test ping_responds_to_server_request (#2101)
- Fix functional test receive_carbon (#2101)
- Fix functional test resets_to_barejid_after_presence_received (#2101)
- Fix functional test rooms_query (#2101)
- Fix functional test send_receipt_on_request (#2101)
- Fix functional test sends_room_join (#2101)
- Fix functional test test_ping (#2101)
- Fix passing of special characters to prof_expect() (#2101)
- Improve autocomplete unit tests (#2093)
- Re-enable functional tests (#2101)
- Remove apparently unused code (#2101)
- Standardize naming convention (#2099)
- Try two places for profanity binary (#2101)
- Update unit tests (#2094)
Build System:
- Add --enable-functional-tests switch (#2123)
- Add -Wpointer-arith flag (#2095)
- Add -fstack-protector-strong compiler flag (#2094)
- Add .gitattributes to exclude development files from exports (#2123)
- Add support for libomemo-c as OMEMO backend (#2120)
- Enable -fanalyzer for static analysis (#2094)
- Enable _FORTIFY_SOURCE and -Og optimization (#2094)
- Enable more warnings in debug mode (#2089)
- Set -Qunused-arguments depending on compiler not os
Refactorings:
- Centralize validation within jid_is_valid (#2102)
- Change vcard_print() checks (#2094)
- Fix clang-format expansion of table (#2099)
- Improve key transport message handling and deduplicate errors (#2130)
- Make Jid use glib functions (#2094)
- Make Resource use glib functions (#2094)
- Make _writecsv safer and with better performance (#2094)
- Modernize cmd_ac_complete_filepath and simplify path handling (#2094)
- Move pgp module to gchar (#2094)
- Optimize prof_occurrences() (#2093)
- Partly move plugins to glib (#2094)
- Refactor OMEMO error handling and add non-null attributes (#2104)
- Refactor form_set_value to use glib list management (#2095)
- Replace calloc with g_new0 for struct allocations (#2094)
- Replace malloc with g_new0 in many occasions (#2094)
- Roster export uses GString and g_file_set_contents now (#2094)
- Start to standardize on gchar (#2094)
- Use g_malloc0 instead of calloc in get_random_string() (#2094)
- Use g_new in message_pubsub_event_handler_add() (#2094)
- Use p_contact_new instead of malloc in p_contact_new() (#2094)
Chores:
- Add 0.16.0 to release in doap file
- Add README explaining the purpose and usage of helper scripts (#2128)
- Add XEP comparison script
- Add changelog-helper script (#2128)
- Add copyright header to C files who had none
- Add linter file to be ignored upon export
- Make meson doublecheck only available if the script exists
- Move to SPDX license header
- Require DCO from now on (#2123)
- Unify build configuration script into one (#2128)
- Update clang-format action to 4.16.0
- Update valgrind suppression file (#2123)
- Use more descriptive names for helper scripts (#2128)
0.16.0 (2026-02-23)
===================
5 people contributed to this release: @balejk, @mcalierno, @ritesh006, @sjaeckel and @jubalh.
Thanks a lot to our sponsors: Matthew Fennell, Martin Dosch and one anonymous sponsor.
If you want to support us too: https://profanity-im.github.io/donate.html
This release depends on libstrophe >= 0.12.3.
Changes:
- Add new command /changes (#2080)
With that command one can see the modifications of the runtime
configuration vs. the saved configuration.
- Explain the different kinds of messages in the manpage (#2063)
- Fix OTR detection (#1957, #2072)
- Fix OMEMO startup (79ff9ba)
- Fix overwriting new accounts when running multiple instances (#2080)
- Fix reconnect when no account has been set up yet (#2080)
- Don't publish keys if the server doesn't support pubsub (#2078, #2080)
- Fix compilation on Apple silicon macs (#2075)
- Handle SIGTERM and SIGHUP (#2082)
- Cleanup (#2067, #2080)
- Add cygwin CI (#2066)
- Replace ACX_PTHREAD with AX_PTHREAD (#2062)
- Add meson build system (#2086)
Mainly for testing purposes. Details will be announced in a later release.
0.15.1 (2025-08-22)
===================
5 people contributed to this release: @andreasstieger, @killerdevildog, @mdosch,
@sjaeckel and @jubalh.
Thanks a lot to our sponsors: Matthew Fennell, Martin Dosch and one anonymous sponsor.
If you want to support us too: https://profanity-im.github.io/donate.html
This release depends on libstrophe >= 0.12.3.
Changes:
- Add `iso8601` as valid time format
`/time all set iso8601` instead of manual specification
- Fix ignoring of roster pushes (#2035)
- Print location of decrypted files (#2041)
- Fix GPGME >= 2.0.0 compatibility issue (#2048)
- Fix tests with gcc15 and uintptr_t (#2055)
- Reduce noise in log files (#1911, #2060)
- Cleanup, code improvement and memory fixes (#2033, #2041, #2053)
- Improve documentation (#2040, 18f157b, #2058)
0.15.0 (2025-03-27)
===================

View File

@@ -2,9 +2,6 @@ FROM archlinux:latest
ENV TERM=xterm
ENV CC="ccache gcc"
# Arch ships a stripped ld-linux; Valgrind needs glibc debug symbols to
# redirect memcmp/memcpy/strlen. debuginfod fetches them on demand.
ENV DEBUGINFOD_URLS=https://debuginfod.archlinux.org
RUN pacman -Syyu --noconfirm

View File

@@ -152,32 +152,31 @@ unittest_sources = \
tests/unittests/tools/stub_aesgcm_download.c \
tests/unittests/tools/stub_plugin_download.c \
tests/unittests/helpers.c tests/unittests/helpers.h \
tests/unittests/xmpp/test_form.c tests/unittests/xmpp/test_form.h \
tests/unittests/test_form.c tests/unittests/test_form.h \
tests/unittests/test_common.c tests/unittests/test_common.h \
tests/unittests/tools/test_autocomplete.c tests/unittests/tools/test_autocomplete.h \
tests/unittests/xmpp/test_jid.c tests/unittests/xmpp/test_jid.h \
tests/unittests/tools/test_parser.c tests/unittests/tools/test_parser.h \
tests/unittests/xmpp/test_roster_list.c tests/unittests/xmpp/test_roster_list.h \
tests/unittests/xmpp/test_chat_session.c tests/unittests/xmpp/test_chat_session.h \
tests/unittests/xmpp/test_contact.c tests/unittests/xmpp/test_contact.h \
tests/unittests/config/test_preferences.c tests/unittests/config/test_preferences.h \
tests/unittests/event/test_server_events.c tests/unittests/event/test_server_events.h \
tests/unittests/xmpp/test_muc.c tests/unittests/xmpp/test_muc.h \
tests/unittests/command/test_cmd_presence.c tests/unittests/command/test_cmd_presence.h \
tests/unittests/command/test_cmd_alias.c tests/unittests/command/test_cmd_alias.h \
tests/unittests/command/test_cmd_connect.c tests/unittests/command/test_cmd_connect.h \
tests/unittests/command/test_cmd_rooms.c tests/unittests/command/test_cmd_rooms.h \
tests/unittests/command/test_cmd_account.c tests/unittests/command/test_cmd_account.h \
tests/unittests/command/test_cmd_sub.c tests/unittests/command/test_cmd_sub.h \
tests/unittests/command/test_cmd_bookmark.c tests/unittests/command/test_cmd_bookmark.h \
tests/unittests/command/test_cmd_otr.c tests/unittests/command/test_cmd_otr.h \
tests/unittests/command/test_cmd_pgp.c tests/unittests/command/test_cmd_pgp.h \
tests/unittests/command/test_cmd_join.c tests/unittests/command/test_cmd_join.h \
tests/unittests/command/test_cmd_roster.c tests/unittests/command/test_cmd_roster.h \
tests/unittests/command/test_cmd_disconnect.c tests/unittests/command/test_cmd_disconnect.h \
tests/unittests/command/test_cmd_ac.c tests/unittests/command/test_cmd_ac.h \
tests/unittests/plugins/test_callbacks.c tests/unittests/plugins/test_callbacks.h \
tests/unittests/plugins/test_plugins_disco.c tests/unittests/plugins/test_plugins_disco.h \
tests/unittests/test_autocomplete.c tests/unittests/test_autocomplete.h \
tests/unittests/test_jid.c tests/unittests/test_jid.h \
tests/unittests/test_parser.c tests/unittests/test_parser.h \
tests/unittests/test_roster_list.c tests/unittests/test_roster_list.h \
tests/unittests/test_chat_session.c tests/unittests/test_chat_session.h \
tests/unittests/test_contact.c tests/unittests/test_contact.h \
tests/unittests/test_preferences.c tests/unittests/test_preferences.h \
tests/unittests/test_server_events.c tests/unittests/test_server_events.h \
tests/unittests/test_muc.c tests/unittests/test_muc.h \
tests/unittests/test_cmd_presence.c tests/unittests/test_cmd_presence.h \
tests/unittests/test_cmd_alias.c tests/unittests/test_cmd_alias.h \
tests/unittests/test_cmd_connect.c tests/unittests/test_cmd_connect.h \
tests/unittests/test_cmd_rooms.c tests/unittests/test_cmd_rooms.h \
tests/unittests/test_cmd_account.c tests/unittests/test_cmd_account.h \
tests/unittests/test_cmd_sub.c tests/unittests/test_cmd_sub.h \
tests/unittests/test_cmd_bookmark.c tests/unittests/test_cmd_bookmark.h \
tests/unittests/test_cmd_otr.c tests/unittests/test_cmd_otr.h \
tests/unittests/test_cmd_pgp.c tests/unittests/test_cmd_pgp.h \
tests/unittests/test_cmd_join.c tests/unittests/test_cmd_join.h \
tests/unittests/test_cmd_roster.c tests/unittests/test_cmd_roster.h \
tests/unittests/test_cmd_disconnect.c tests/unittests/test_cmd_disconnect.h \
tests/unittests/test_callbacks.c tests/unittests/test_callbacks.h \
tests/unittests/test_plugins_disco.c tests/unittests/test_plugins_disco.h \
tests/unittests/test_forced_encryption.c tests/unittests/test_forced_encryption.h \
tests/unittests/test_ai_client.c tests/unittests/test_ai_client.h \
tests/unittests/test_database_export.c tests/unittests/test_database_export.h \
@@ -312,7 +311,7 @@ endif
TESTS = tests/unittests/unittests
check_PROGRAMS = tests/unittests/unittests
tests_unittests_unittests_CPPFLAGS = -I$(srcdir)/tests -I$(srcdir)/tests/unittests
tests_unittests_unittests_CPPFLAGS = -I$(srcdir)/tests
tests_unittests_unittests_SOURCES = $(unittest_sources)
tests_unittests_unittests_LDADD = -lcmocka

View File

@@ -2,40 +2,67 @@
* Release libstrophe if required
* Set the correct release version in meson.build
* Run Unit tests: `meson setup build_test -Dtests=true && meson test -C build_test`
* Run Functional tests: same as above but needs stabber installed
* Run Unit tests: `make check-unit`
* Run Functional tests - Currently disabled
* Run manual valgrind tests for new features
* Build and simple tests in Virtual machines ideally all dists including OSX and Windows (Cygwin)
* Update Inline command help (./src/command/cmd_defs.c)
* Check copyright dates in all files
* Create clean build folder:
`meson setup build_deb --buildtype=debug -Dnotifications=enabled -Dicons-and-clipboard=enabled -Dotr=enabled -Dpgp=enabled -Domemo=enabled -Dc-plugins=enabled -Dpython-plugins=enabled -Dxscreensaver=enabled -Domemo-qrcode=enabled -Dgdk-pixbuf=enabled`
* Build profanity: `meson compile -C build_deb`
* Generate HTML docs (the docgen argument only works when package status is development)
`./build_deb/profanity docgen`
* Generate manpages (the mangen argument only works when package status is development)
`./build_deb/profanity mangen`
`./profanity docgen`
* Determine if `libprofanity`'s version needs to be [increased](https://github.com/profanity-im/profanity/issues/973)
* Update plugin API docs (./apidocs/c and ./apidocs/python) need to run the `gen.sh` and commit the results to the website git repo
* Update CHANGELOG (Use scripts/changelog-helper.py)
* Update CHANGELOG
* Update profrc.example
* Update profanity.doap (new XEPs and latest version). Look for `DEV` which marks what is done on the development branch.
* Add new release to profanity.doap
* Set the package status to release: `meson setup build_rel --buildtype=release`
## Creating artefacts
* Set the correct release version in configure.ac:
```
AC_INIT([profanity], [0.6.0], [boothj5web@gmail.com])
```
* Set the package status in configure.ac:
```
PACKAGE_STATUS="release"
```
* Update date and version in man pages (profanity.1, profanity-ox-setup.1)
* Generate manpages for profanity commands (the mangen argument only works when package status is development)
`./profanity mangen`
These files should be added to the docs subfolder and added to git whenever a command changes.
* Add generated command manpages: `git add docs/profanity-*.1`
* Commit (Release 0.1.2)
* Commit
* Tag (0.1.2)
* Push
* Generate tarballs: `meson dist -C build_rel --formats xztar,zip`
* Configure to generate fresh Makefile:
```
./bootstrap.sh && ./configure
```
* Generate tarballs:
```
make dist
make dist-bzip2
make dist-xz
make dist-zip
```
* Set the package status back to dev:
```
PACKAGE_STATUS="development"
```
* Remove generated command manpages:
`git rm docs/profanity-*.1`
@@ -44,3 +71,13 @@
* Commit `Start new cycle`
* Push
## Updating website
* Make changes to the git repo including uploading the new artefacts at:
https://github.com/profanity-im/profanity-im.github.io
* Add .xz and .zip tarballs to `tarballs` directory
* Copy `guide/latest` to `guide/newversion`
* Update tarball location and name in index.html
* Update checksums in index.html
* Update profanity_version.txt
* Take results from profanity.doap and put them into xeps.html

View File

@@ -71,10 +71,6 @@ AC_ARG_ENABLE([omemo-qrcode],
[AS_HELP_STRING([--enable-omemo-qrcode], [enable ability to display omemo qr code])])
AC_ARG_ENABLE([coverage],
[AS_HELP_STRING([--enable-coverage], [enable code coverage analysis])])
AC_ARG_ENABLE([sanitizers],
[AS_HELP_STRING([--enable-sanitizers], [enable AddressSanitizer + UndefinedBehaviorSanitizer + unsigned-integer-overflow])])
AC_ARG_ENABLE([hardening],
[AS_HELP_STRING([--enable-hardening], [enable extra hardening warnings (e.g. -Wnull-dereference) that may produce false positives under -O2])])
m4_include([m4/ax_valgrind_check.m4])
AX_VALGRIND_DFLT([drd], [off])
@@ -399,7 +395,7 @@ AC_SUBST([FORKPTY_LIB])
## Default parameters
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-cast-function-type"
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 -Wpointer-arith"
AM_CFLAGS="$AM_CFLAGS -Wimplicit-function-declaration"
AM_CFLAGS="$AM_CFLAGS -Wundef"
@@ -410,8 +406,7 @@ 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 \
-Wsign-compare; do
-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()],
@@ -438,46 +433,11 @@ AS_IF([test "x$enable_coverage" = xyes],
AM_LDFLAGS="$AM_LDFLAGS --coverage"
AC_MSG_NOTICE([Code coverage analysis enabled])])
AS_IF([test "x$enable_sanitizers" = xyes],
[SAN_FLAGS="-fsanitize=address,undefined"
saved_CFLAGS="$CFLAGS"
CFLAGS="$saved_CFLAGS -fsanitize=unsigned-integer-overflow -Werror"
AC_MSG_CHECKING([whether $CC supports -fsanitize=unsigned-integer-overflow])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
[AC_MSG_RESULT([yes]); SAN_FLAGS="$SAN_FLAGS,unsigned-integer-overflow"],
[AC_MSG_RESULT([no])])
CFLAGS="$saved_CFLAGS"
AM_CFLAGS="$AM_CFLAGS $SAN_FLAGS -fno-sanitize-recover=all -fno-omit-frame-pointer"
AM_LDFLAGS="$AM_LDFLAGS -fsanitize=address,undefined"
AC_MSG_NOTICE([Sanitizers enabled: $SAN_FLAGS])])
AS_IF([test "x$enable_hardening" = xyes],
[saved_CFLAGS="$CFLAGS"
for _flag in -Wnull-dereference; 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"
AC_MSG_NOTICE([Extra hardening warnings enabled])])
# Skip _FORTIFY_SOURCE=2 if env already set one (Pikaur/makepkg) or under coverage -O0 (FORTIFY needs -O>0).
AS_IF([test "x$enable_coverage" != xyes],
[AS_CASE([" ${CPPFLAGS} ${CFLAGS} "],
[*_FORTIFY_SOURCE=*], [AC_MSG_NOTICE([_FORTIFY_SOURCE preset from environment, leaving as-is])],
[AM_CFLAGS="$AM_CFLAGS -D_FORTIFY_SOURCE=2"])])
AS_IF([test "x$PACKAGE_STATUS" = xdevelopment],
[AM_CFLAGS="$AM_CFLAGS -Wunused -Werror"])
AS_IF([test "x$PLATFORM" = xosx],
[AM_CFLAGS="$AM_CFLAGS -Qunused-arguments"])
# Treat glib/gio headers as system to keep their macros out of our -W* set.
glib_CFLAGS=$(echo "$glib_CFLAGS" | sed 's/-I/-isystem /g')
gio_CFLAGS=$(echo "$gio_CFLAGS" | sed 's/-I/-isystem /g')
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\\\"\""

View File

@@ -1,4 +1,4 @@
.TH man 1 "2026-03-26" "0.17.0" "Profanity XMPP client"
.TH man 1 "2023-08-03" "0.14.0" "Profanity XMPP client"
.SH NAME
Profanity \- a simple console based XMPP chat client.
.SH DESCRIPTION

View File

@@ -1,4 +1,4 @@
.TH man 1 "2026-03-23" "0.17.0" "Profanity XMPP client"
.TH man 1 "2025-03-27" "0.15.0" "Profanity XMPP client"
.SH NAME
Profanity \- a simple console based XMPP chat client.
.SH SYNOPSIS
@@ -181,15 +181,7 @@ Stands for Mutli-User Chats (XEP-0045) and are also called, groups, group chats,
The roster is your contact list. By default displayed at the right side on the console window. See RFC6121.
.TP
.BR XEP
XMPP is an extendable protocol. There are core features and optional features described in XMPP Extension Protocols, short XEPs.
.PP
There are various kind of messages.
.TP
1:1 messages are regular messages from one party to another party, from one JID to the other JID. Often you have the other party added to your roster.
.TP
MUC messages are messages from one party to a group chat.
.TP
MUC PM (MUC private message) are messages from one party to another party which are in the same group chat. You might not have the JID of this person in your roster or don't know their JID at all. Communication is done over the MUC via the nick. Only the two parties can see the message. In the Android client Conversations this is displayed as "whispering". If a user leaves a MUC another user can join the MUC with the same nick unless the nick is registered. Which often isn't the case.
XMPP is aa extendable protocol. There are core features and optional features described in XMPP Extension Protocols, short XEPs.
.SH SEE ALSO
.B Profanity
itself has a lot of built\-in help. Check the
@@ -261,7 +253,7 @@ or to the mailing list at:
.br
.SH LICENSE
Copyright (C) 2012 \- 2019 James Booth <boothj5web@gmail.com>.
Copyright (C) 2019 \- 2026 Michael Vetter <jubalh@iodoru.org>.
Copyright (C) 2019 \- 2025 Michael Vetter <jubalh@iodoru.org>.
License GPLv3+: GNU GPL version 3 or later <https://www.gnu.org/licenses/gpl.html>
This is free software; you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

View File

@@ -1,793 +0,0 @@
project('profanity', 'c',
version: '0.17.0',
license: 'GPL-3.0-or-later',
meson_version: '>= 0.56.0',
default_options: [
'c_std=gnu99',
'warning_level=2',
'wrap_mode=nofallback',
]
)
# Determine platform
host_system = host_machine.system()
platform_map = {
'freebsd': 'freebsd',
'netbsd': 'netbsd',
'openbsd': 'openbsd',
'darwin': 'osx',
'cygwin': 'cygwin',
}
platform = platform_map.get(host_system, 'nix')
# Configuration data
conf_data = configuration_data()
conf_data.set_quoted('PACKAGE_NAME', meson.project_name())
conf_data.set_quoted('PACKAGE_VERSION', meson.project_version())
conf_data.set_quoted('PACKAGE_BUGREPORT', 'jubalh@iodoru.org')
conf_data.set_quoted('PACKAGE_URL', 'https://profanity-im.github.io/')
# Possible options from meson:
# debug, debugoptimized, release, plain
# Build type configuration
is_release = get_option('buildtype') == 'release'
is_debug = get_option('buildtype') in ['debug', 'debugoptimized']
conf_data.set_quoted('PACKAGE_STATUS', is_release ? 'release' : 'development')
if platform == 'cygwin'
conf_data.set('PLATFORM_CYGWIN', 1)
endif
if platform == 'osx'
conf_data.set('PLATFORM_OSX', 1)
endif
# Get git version if in development
if is_debug
git = find_program('git', required: false)
if git.found()
conf_data.set('HAVE_GIT_VERSION', 1)
endif
endif
# Compiler setup
cc = meson.get_compiler('c')
# Common compiler flags
add_project_arguments([
'-Wno-deprecated-declarations',
'-Wno-unused-parameter',
], language: 'c')
analyzer_args = []
if is_debug
add_project_arguments([
'-ggdb3',
'-Wunused',
'-Wall',
'-Wextra',
'-fstack-protector-strong',
'-D_FORTIFY_SOURCE=2',
'-Og',
'-Wpointer-arith'
], language: 'c')
if cc.get_id() == 'gcc'
analyzer_args += '-fanalyzer'
endif
endif
if cc.get_id() == 'clang'
add_project_arguments('-Qunused-arguments', language: 'c')
endif
if platform == 'osx'
# Check for homebrew paths on Apple Silicon
if run_command('test', '-d', '/opt/homebrew/include', check: false).returncode() == 0
add_project_arguments('-I/opt/homebrew/include', language: 'c')
add_project_link_arguments('-L/opt/homebrew/lib', language: 'c')
endif
endif
# Required dependencies
glib_dep = dependency('glib-2.0', version: '>= 2.62.0')
gio_dep = dependency('gio-2.0')
curl_dep = dependency('libcurl', version: '>= 7.62.0')
sqlite_dep = dependency('sqlite3', version: '>= 3.35.0')
thread_dep = dependency('threads')
math_dep = cc.find_library('m')
libstrophe_dep = dependency('libstrophe', version: '>= 0.12.3')
# Check for XMPP_CERT_PUBKEY_FINGERPRINT_SHA256 support
if libstrophe_dep.type_name() != 'internal'
if cc.links('''
#include <strophe.h>
int main() {
xmpp_tlscert_get_string(NULL, XMPP_CERT_PUBKEY_FINGERPRINT_SHA256);
return 1;
}
''', dependencies: libstrophe_dep)
conf_data.set('HAVE_XMPP_CERT_PUBKEY_FINGERPRINT_SHA256', 1)
endif
else
conf_data.set('HAVE_XMPP_CERT_PUBKEY_FINGERPRINT_SHA256', 1)
endif
# ncurses
curses_dep = dependency('ncursesw', required: false)
if not curses_dep.found()
curses_dep = dependency('ncurses', required: false)
endif
if not curses_dep.found()
curses_dep = cc.find_library('ncursesw', required: false)
endif
if not curses_dep.found()
curses_dep = cc.find_library('ncurses', required: true)
endif
# Check for ncursesw/ncurses.h, Arch Linux uses ncurses.h for ncursesw
if cc.has_header('ncursesw/ncurses.h')
conf_data.set('HAVE_NCURSESW_NCURSES_H', 1)
elif cc.has_header('ncurses.h')
conf_data.set('HAVE_NCURSES_H', 1)
endif
# Readline
readline_dep = dependency('readline', required: false)
if not readline_dep.found() and platform == 'osx'
brew = find_program('brew', required: false)
if brew.found()
prefix = run_command(brew, '--prefix', 'readline', check: false).stdout().strip()
readline_dep = cc.find_library('readline', dirs: [prefix / 'lib'], required: true)
add_project_arguments('-I' + prefix / 'include', language: 'c')
endif
endif
if not readline_dep.found() and platform == 'openbsd'
readline_dep = cc.find_library('ereadline', dirs: ['/usr/local/lib'], required: false)
endif
if not readline_dep.found()
readline_dep = cc.find_library('readline', required: true)
endif
# Optional dependencies
have_osxnotify = false
libnotify_dep = disabler()
gtk_dep = disabler()
xscrnsaver_dep = []
python_dep = disabler()
dl_dep = disabler()
gpgme_dep = disabler()
libotr_dep = disabler()
gdk_pixbuf_dep = disabler()
omemo_dep = disabler()
gcrypt_dep = disabler()
qrencode_dep = disabler()
enchant_dep = disabler()
# Dependencies for functional tests
stabber_dep = cc.find_library('stabber', required: false)
util_dep = cc.find_library('util', required: false)
# Build flags
build_python_api = false
build_c_api = false
build_pgp = false
build_otr = false
build_omemo = false
# Notifications
if get_option('notifications').enabled()
if platform == 'osx'
terminal_notifier = find_program('terminal-notifier', required: true)
have_osxnotify = true
conf_data.set('HAVE_OSXNOTIFY', 1)
elif platform in ['nix', 'freebsd']
libnotify_dep = dependency('libnotify', required: true)
conf_data.set('HAVE_LIBNOTIFY', 1)
else
error('Notifications not supported on this platform')
endif
endif
# GTK (for icons and clipboard)
x11_extra_dep = []
if get_option('icons-and-clipboard').enabled()
gtk_dep = dependency('gtk+-3.0', version: '>= 3.24.0', required: true)
conf_data.set('HAVE_GTK', 1)
x11_dep = dependency('x11', required: false)
if x11_dep.found()
if cc.has_function('XSetIOErrorExitHandler', dependencies: x11_dep)
conf_data.set('HAVE_XEXITHANDLER', 1)
x11_extra_dep = [x11_dep]
endif
endif
endif
# XScreenSaver
if get_option('xscreensaver').enabled()
xscrnsaver_dep = [
dependency('xscrnsaver', required: true),
dependency('x11', required: true)
]
conf_data.set('HAVE_LIBXSS', 1)
endif
# Python plugins
if get_option('python-plugins').enabled()
python_dep = dependency('python3-embed', required: false)
if not python_dep.found()
python_dep = dependency('python-embed', required: true)
else
conf_data.set('PY_IS_PYTHON3', 1)
endif
build_python_api = true
conf_data.set('HAVE_PYTHON', 1)
endif
# C plugins
if get_option('c-plugins').enabled()
if platform == 'cygwin'
error('C plugins are not supported on Cygwin')
endif
if platform not in ['openbsd', 'freebsd', 'netbsd']
dl_dep = cc.find_library('dl', required: true)
endif
build_c_api = true
conf_data.set('HAVE_C', 1)
endif
# PGP support
if get_option('pgp').enabled()
gpgme_dep = dependency('gpgme', required: false)
build_pgp = true
conf_data.set('HAVE_LIBGPGME', 1)
endif
# OTR support
if get_option('otr').enabled()
libotr_dep = dependency('libotr', version: '>= 4.0', required: true)
build_otr = true
conf_data.set('HAVE_LIBOTR', 1)
endif
# GDK Pixbuf (for avatar scaling)
if get_option('gdk-pixbuf').enabled()
gdk_pixbuf_dep = dependency('gdk-pixbuf-2.0', version: '>= 2.4', required: true)
conf_data.set('HAVE_PIXBUF', 1)
endif
# OMEMO support
if get_option('omemo').enabled()
omemo_backend = get_option('omemo-backend')
if omemo_backend == 'libsignal'
omemo_dep = dependency('libsignal-protocol-c', version: '>= 2.3.2', required: true)
elif omemo_backend == 'libomemo-c'
omemo_dep = dependency('libomemo-c', version: '>= 0.5.1', required: true)
conf_data.set('HAVE_LIBOMEMO_C', 1)
endif
gcrypt_dep = dependency('libgcrypt', version: '>= 1.7.0', required: true)
build_omemo = true
conf_data.set('HAVE_OMEMO', 1)
endif
# QR code support (for OMEMO)
if get_option('omemo-qrcode').enabled()
qrencode_dep = dependency('libqrencode', required: true)
conf_data.set('HAVE_QRENCODE', 1)
endif
# Spellcheck support
if get_option('spellcheck').enabled()
enchant_dep = dependency('enchant-2', required: true)
conf_data.set('HAVE_SPELLCHECK', 1)
endif
# Set installation paths
themes_path = get_option('themes_path')
if themes_path == ''
themes_path = get_option('datadir') / meson.project_name() / 'themes'
endif
icons_path = get_option('datadir') / meson.project_name() / 'icons'
global_python_plugins_path = get_option('datadir') / meson.project_name() / 'plugins'
global_c_plugins_path = get_option('libdir') / meson.project_name() / 'plugins'
conf_data.set_quoted('THEMES_PATH', get_option('prefix') / themes_path)
conf_data.set_quoted('ICONS_PATH', get_option('prefix') / icons_path)
conf_data.set_quoted('GLOBAL_PYTHON_PLUGINS_PATH', get_option('prefix') / global_python_plugins_path)
conf_data.set_quoted('GLOBAL_C_PLUGINS_PATH', get_option('prefix') / global_c_plugins_path)
# Check for required functions
foreach func : ['atexit', 'memset', 'strdup', 'strstr']
if cc.has_function(func)
conf_data.set('HAVE_' + func.to_upper(), 1)
endif
endforeach
# Generate config.h
config_h = configure_file(
output: 'config.h',
configuration: conf_data,
)
# Build dependencies list
profanity_deps = [
glib_dep,
gio_dep,
curl_dep,
sqlite_dep,
thread_dep,
math_dep,
libstrophe_dep,
curses_dep,
readline_dep,
]
# Add optional dependencies only if found
if libnotify_dep.found()
profanity_deps += libnotify_dep
endif
if gtk_dep.found()
profanity_deps += gtk_dep
endif
if xscrnsaver_dep.length() > 0
profanity_deps += xscrnsaver_dep
endif
if x11_extra_dep.length() > 0
profanity_deps += x11_extra_dep
endif
if python_dep.found()
profanity_deps += python_dep
endif
if dl_dep.found()
profanity_deps += dl_dep
endif
if gpgme_dep.found()
profanity_deps += gpgme_dep
endif
if libotr_dep.found()
profanity_deps += libotr_dep
endif
if gdk_pixbuf_dep.found()
profanity_deps += gdk_pixbuf_dep
endif
if omemo_dep.found()
profanity_deps += omemo_dep
endif
if gcrypt_dep.found()
profanity_deps += gcrypt_dep
endif
if qrencode_dep.found()
profanity_deps += qrencode_dep
endif
if enchant_dep.found()
profanity_deps += enchant_dep
endif
# Include directories
inc = include_directories('.', 'src')
# Core source files
core_sources = files(
'src/xmpp/contact.c',
'src/log.c',
'src/common.c',
'src/chatlog.c',
'src/database.c',
'src/profanity.c',
'src/xmpp/chat_session.c',
'src/xmpp/muc.c',
'src/xmpp/jid.c',
'src/xmpp/chat_state.c',
'src/xmpp/resource.c',
'src/xmpp/roster_list.c',
'src/xmpp/capabilities.c',
'src/xmpp/session.c',
'src/xmpp/connection.c',
'src/xmpp/iq.c',
'src/xmpp/message.c',
'src/xmpp/presence.c',
'src/xmpp/stanza.c',
'src/xmpp/roster.c',
'src/xmpp/bookmark.c',
'src/xmpp/blocking.c',
'src/xmpp/form.c',
'src/xmpp/avatar.c',
'src/xmpp/ox.c',
'src/xmpp/vcard.c',
'src/event/common.c',
'src/event/server_events.c',
'src/event/client_events.c',
'src/ui/window.c',
'src/ui/core.c',
'src/ui/titlebar.c',
'src/ui/statusbar.c',
'src/ui/inputwin.c',
'src/ui/screen.c',
'src/ui/console.c',
'src/ui/notifier.c',
'src/ui/window_list.c',
'src/ui/rosterwin.c',
'src/ui/occupantswin.c',
'src/ui/buffer.c',
'src/ui/chatwin.c',
'src/ui/mucwin.c',
'src/ui/privwin.c',
'src/ui/confwin.c',
'src/ui/xmlwin.c',
'src/ui/vcardwin.c',
'src/command/cmd_defs.c',
'src/command/cmd_funcs.c',
'src/command/cmd_ac.c',
'src/tools/parser.c',
'src/tools/http_common.c',
'src/tools/http_upload.c',
'src/tools/http_download.c',
'src/tools/plugin_download.c',
'src/tools/bookmark_ignore.c',
'src/tools/autocomplete.c',
'src/tools/clipboard.c',
'src/tools/editor.c',
'src/tools/spellcheck.c',
'src/config/files.c',
'src/config/conflists.c',
'src/config/accounts.c',
'src/config/tlscerts.c',
'src/config/account.c',
'src/config/preferences.c',
'src/config/theme.c',
'src/config/color.c',
'src/config/scripts.c',
'src/config/cafile.c',
'src/plugins/plugins.c',
'src/plugins/api.c',
'src/plugins/callbacks.c',
'src/plugins/autocompleters.c',
'src/plugins/themes.c',
'src/plugins/settings.c',
'src/plugins/disco.c',
)
# Build the final source list
profanity_sources = core_sources
# Add conditional sources
if gtk_dep.found()
profanity_sources += files('src/ui/tray.c')
endif
if build_python_api
profanity_sources += files(
'src/plugins/python_plugins.c',
'src/plugins/python_api.c',
)
endif
if build_c_api
profanity_sources += files(
'src/plugins/c_plugins.c',
'src/plugins/c_api.c',
)
endif
if build_pgp
profanity_sources += files(
'src/pgp/gpg.c',
'src/pgp/ox.c',
)
endif
if build_otr
profanity_sources += files(
'src/otr/otrlibv4.c',
'src/otr/otr.c',
)
endif
if build_omemo
profanity_sources += files(
'src/omemo/omemo.c',
'src/omemo/crypto.c',
'src/omemo/store.c',
'src/xmpp/omemo.c',
'src/tools/aesgcm_download.c',
)
endif
# Generate git version header if in development
if is_debug
git_branch = run_command('git', 'rev-parse', '--symbolic-full-name', '--abbrev-ref', 'HEAD',
check: false).stdout().strip()
git_revision = run_command('git', 'log', '--pretty=format:%h', '-n', '1',
check: false).stdout().strip()
git_version_conf = configuration_data()
git_version_conf.set('PROF_GIT_BRANCH', '"' + git_branch + '"')
git_version_conf.set('PROF_GIT_REVISION', '"' + git_revision + '"')
configure_file(
input: 'src/gitversion.h.in',
output: 'gitversion.h',
configuration: git_version_conf,
)
endif
# Build the executable
profanity_exe = executable(
'profanity',
profanity_sources,
files('src/main.c'),
config_h,
c_args: analyzer_args,
dependencies: profanity_deps,
include_directories: inc,
install: true,
export_dynamic: true,
)
# Build libprofanity shared library for C plugins
if build_c_api
libprofanity = shared_library(
'profanity',
'src/plugins/profapi.c',
dependencies: profanity_deps,
include_directories: inc,
install: true,
version: '0.0.0',
)
install_headers('src/plugins/profapi.h')
endif
# Install themes if enabled
if get_option('install_themes')
install_subdir('themes',
install_dir: get_option('datadir') / meson.project_name(),
strip_directory: false,
)
endif
# Install icons
install_subdir('icons',
install_dir: get_option('datadir') / meson.project_name(),
strip_directory: false,
)
# Install man pages
man_pages = run_command('find', 'docs', '-name', 'profanity*.1', '-type', 'f',
check: true).stdout().strip().split('\n')
if man_pages.length() > 0 and man_pages[0] != ''
install_man(man_pages)
endif
# Install example config and theme template
install_data(
'profrc.example',
'theme_template',
install_dir: get_option('datadir') / 'doc' / meson.project_name(),
)
# Tests
build_unittests = false
build_functionaltests = false
if get_option('tests')
cmocka_dep = dependency('cmocka', required: false)
if cmocka_dep.found()
build_unittests = true
unittest_sources = files(
'src/xmpp/contact.c',
'src/common.c',
'src/profanity.c',
'src/xmpp/chat_session.c',
'src/xmpp/muc.c',
'src/xmpp/jid.c',
'src/xmpp/resource.c',
'src/xmpp/chat_state.c',
'src/xmpp/roster_list.c',
'src/xmpp/form.c',
'src/command/cmd_defs.c',
'src/command/cmd_funcs.c',
'src/command/cmd_ac.c',
'src/tools/parser.c',
'src/tools/autocomplete.c',
'src/tools/clipboard.c',
'src/tools/editor.c',
'src/tools/spellcheck.c',
'src/tools/bookmark_ignore.c',
'src/config/account.c',
'src/config/files.c',
'src/config/tlscerts.c',
'src/config/preferences.c',
'src/config/theme.c',
'src/config/color.c',
'src/config/scripts.c',
'src/config/conflists.c',
'src/plugins/plugins.c',
'src/plugins/api.c',
'src/plugins/callbacks.c',
'src/plugins/autocompleters.c',
'src/plugins/themes.c',
'src/plugins/settings.c',
'src/plugins/disco.c',
'src/ui/window_list.c',
'src/event/common.c',
'src/event/server_events.c',
'src/event/client_events.c',
'src/ui/tray.c',
'tests/unittests/xmpp/stub_vcard.c',
'tests/unittests/xmpp/stub_avatar.c',
'tests/unittests/xmpp/stub_ox.c',
'tests/unittests/xmpp/stub_xmpp.c',
'tests/unittests/xmpp/stub_message.c',
'tests/unittests/ui/stub_ui.c',
'tests/unittests/ui/stub_vcardwin.c',
'tests/unittests/log/stub_log.c',
'tests/unittests/chatlog/stub_chatlog.c',
'tests/unittests/database/stub_database.c',
'tests/unittests/config/stub_accounts.c',
'tests/unittests/config/stub_cafile.c',
'tests/unittests/tools/stub_http_upload.c',
'tests/unittests/tools/stub_http_download.c',
'tests/unittests/tools/stub_aesgcm_download.c',
'tests/unittests/tools/stub_plugin_download.c',
'tests/unittests/helpers.c',
'tests/unittests/xmpp/test_form.c',
'tests/unittests/test_common.c',
'tests/unittests/tools/test_autocomplete.c',
'tests/unittests/xmpp/test_jid.c',
'tests/unittests/tools/test_parser.c',
'tests/unittests/xmpp/test_roster_list.c',
'tests/unittests/xmpp/test_chat_session.c',
'tests/unittests/xmpp/test_contact.c',
'tests/unittests/config/test_preferences.c',
'tests/unittests/event/test_server_events.c',
'tests/unittests/xmpp/test_muc.c',
'tests/unittests/command/test_cmd_presence.c',
'tests/unittests/command/test_cmd_alias.c',
'tests/unittests/command/test_cmd_connect.c',
'tests/unittests/command/test_cmd_rooms.c',
'tests/unittests/command/test_cmd_account.c',
'tests/unittests/command/test_cmd_sub.c',
'tests/unittests/command/test_cmd_bookmark.c',
'tests/unittests/command/test_cmd_otr.c',
'tests/unittests/command/test_cmd_pgp.c',
'tests/unittests/command/test_cmd_join.c',
'tests/unittests/command/test_cmd_roster.c',
'tests/unittests/command/test_cmd_ac.c',
'tests/unittests/command/test_cmd_disconnect.c',
'tests/unittests/plugins/test_callbacks.c',
'tests/unittests/plugins/test_plugins_disco.c',
'tests/unittests/unittests.c',
)
if build_python_api
unittest_sources += files(
'src/plugins/python_plugins.c',
'src/plugins/python_api.c',
)
endif
if build_c_api
unittest_sources += files(
'src/plugins/c_plugins.c',
'src/plugins/c_api.c',
)
endif
if build_pgp
unittest_sources += files(
'tests/unittests/pgp/stub_gpg.c',
'tests/unittests/pgp/stub_ox.c',
)
endif
if build_otr
unittest_sources += files('tests/unittests/otr/stub_otr.c')
endif
if build_omemo
unittest_sources += files('tests/unittests/omemo/stub_omemo.c')
endif
unittests = executable(
'unittests',
unittest_sources,
dependencies: profanity_deps + [cmocka_dep],
include_directories: [inc, include_directories('tests'), include_directories('tests/unittests')],
build_by_default: false,
)
test('unit tests', unittests)
# Functional tests
if stabber_dep.found() and util_dep.found()
build_functionaltests = true
functionaltest_sources = files(
'tests/functionaltests/proftest.c',
'tests/functionaltests/test_connect.c',
'tests/functionaltests/test_ping.c',
'tests/functionaltests/test_rooms.c',
'tests/functionaltests/test_presence.c',
'tests/functionaltests/test_message.c',
'tests/functionaltests/test_chat_session.c',
'tests/functionaltests/test_carbons.c',
'tests/functionaltests/test_receipts.c',
'tests/functionaltests/test_roster.c',
'tests/functionaltests/test_i18n.c',
'tests/functionaltests/test_software.c',
'tests/functionaltests/test_muc.c',
'tests/functionaltests/test_disconnect.c',
'tests/functionaltests/functionaltests.c',
)
functionaltests = executable(
'functionaltests',
functionaltest_sources,
dependencies: [cmocka_dep, stabber_dep, util_dep] + profanity_deps,
include_directories: [inc, include_directories('tests')],
build_by_default: false,
)
test('functional tests', functionaltests, timeout: 1800)
endif
else
warning('cmocka not found, tests will not be built')
endif
endif
lint_and_test = find_program('scripts/lint-and-test.sh', required: false)
if lint_and_test.found()
run_target('doublecheck',
command: [lint_and_test, '--fix-formatting', '--tests']
)
endif
summary({
'Platform': platform,
'Package status': get_option('buildtype'),
'Install themes': get_option('install_themes'),
'Themes path': themes_path,
'Icons path': icons_path,
'Global Python plugins path': global_python_plugins_path,
'Global C plugins path': global_c_plugins_path,
}, section: 'Directories')
summary({
'Notifications': libnotify_dep.found() or have_osxnotify,
'Python plugins': build_python_api,
'C plugins': build_c_api,
'OTR': build_otr,
'PGP': build_pgp,
'OMEMO': build_omemo,
'XScreenSaver': xscrnsaver_dep.length() > 0,
'GTK': gtk_dep.found(),
'GDK Pixbuf': gdk_pixbuf_dep.found(),
'QR Code': qrencode_dep.found(),
}, section: 'Features')
summary({
'Unit tests': build_unittests,
'Functional tests': build_functionaltests,
}, section: 'Testing')

View File

@@ -1,98 +0,0 @@
# Features:
option('notifications',
type: 'feature',
value: 'disabled',
description: 'Enable desktop notifications'
)
option('python-plugins',
type: 'feature',
value: 'disabled',
description: 'Enable Python plugins'
)
option('c-plugins',
type: 'feature',
value: 'disabled',
description: 'Enable C plugins'
)
option('otr',
type: 'feature',
value: 'disabled',
description: 'Enable OTR encryption'
)
option('pgp',
type: 'feature',
value: 'disabled',
description: 'Enable PGP'
)
option('omemo',
type: 'feature',
value: 'disabled',
description: 'Enable OMEMO encryption'
)
option('omemo-backend',
type: 'combo',
choices: ['libsignal', 'libomemo-c'],
value: 'libsignal',
description: 'Select OMEMO backend library'
)
option('xscreensaver',
type: 'feature',
value: 'disabled',
description: 'Use libXScrnSaver to determine idle time'
)
option('icons-and-clipboard',
type: 'feature',
value: 'disabled',
description: 'Enable GTK tray icons and clipboard paste support'
)
option('gdk-pixbuf',
type: 'feature',
value: 'disabled',
description: 'Enable GDK Pixbuf support to scale avatars before uploading'
)
option('omemo-qrcode',
type: 'feature',
value: 'disabled',
description: 'Enable ability to display OMEMO QR code'
)
option('spellcheck',
type: 'feature',
value: 'disabled',
description: 'Enable spellchecking support'
)
# Other:
option('python_framework',
type: 'string',
value: '',
description: 'Set base directory for Python Framework (macOS only)'
)
option('tests',
type: 'boolean',
value: false,
description: 'Build tests'
)
option('install_themes',
type: 'boolean',
value: true,
description: 'Install themes'
)
option('themes_path',
type: 'string',
value: '',
description: 'Custom path for themes installation (empty for default)'
)

View File

@@ -86,7 +86,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0030.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>2.5.0</xmpp:version>
<xmpp:version>2.5rc3</xmpp:version>
<xmpp:since>0.4.5</xmpp:since>
<xmpp:note xml:lang='en'>Use /disco items and /disco info</xmpp:note>
</xmpp:SupportedXep>
@@ -97,7 +97,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0045.html'/>
<xmpp:status>partial</xmpp:status>
<xmpp:version>1.35.2</xmpp:version>
<xmpp:version>?</xmpp:version>
<xmpp:since>0.4.5</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -141,7 +141,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0054.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.3.0</xmpp:version>
<xmpp:version>1.2</xmpp:version>
<xmpp:since>0.14.0</xmpp:since>
</xmpp:SupportedXep>
</implements>
@@ -161,7 +161,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0060.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.30.0</xmpp:version>
<xmpp:version>1.15.8</xmpp:version>
<xmpp:since>0.7.0</xmpp:since>
<xmpp:note xml:lang='en'>Used for OMEMO.</xmpp:note>
</xmpp:SupportedXep>
@@ -174,6 +174,7 @@
<xmpp:status>complete</xmpp:status>
<xmpp:version>2.4</xmpp:version>
<xmpp:since>0.11.0</xmpp:since>
<xmpp:note xml:lang='en'>Only password change. On master also to create an account.</xmpp:note>
</xmpp:SupportedXep>
</implements>
@@ -226,7 +227,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0115.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.6.0</xmpp:version>
<xmpp:version>unknown</xmpp:version>
<xmpp:since>0.4.5</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -259,7 +260,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0184.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.4.0</xmpp:version>
<xmpp:version>1.2</xmpp:version>
<xmpp:since>0.4.7</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -281,7 +282,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0198.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.6.3</xmpp:version>
<xmpp:version>1.6</xmpp:version>
<xmpp:since>0.13.0</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -325,7 +326,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0249.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.2</xmpp:version>
<xmpp:version>1.0</xmpp:version>
<xmpp:since>0.4.5</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -347,7 +348,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0280.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.0.1</xmpp:version>
<xmpp:version>0.12.1</xmpp:version>
<xmpp:since>0.4.7</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -369,7 +370,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0308.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.2.1</xmpp:version>
<xmpp:version>1.2.0</xmpp:version>
<xmpp:since>0.9.0</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -380,7 +381,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0359.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>0.7.0</xmpp:version>
<xmpp:version>0.6.1</xmpp:version>
<xmpp:since>0.8.0</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -391,7 +392,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0363.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.2.0</xmpp:version>
<xmpp:version>1.0.0</xmpp:version>
<xmpp:since>0.5.0</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -435,7 +436,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0377.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>0.4.0</xmpp:version>
<xmpp:version>0.3</xmpp:version>
<xmpp:since>0.11.0</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -457,7 +458,7 @@
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0392.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>1.0.1</xmpp:version>
<xmpp:version>0.7.0</xmpp:version>
<xmpp:since>0.8.0</xmpp:since>
<xmpp:note xml:lang='en'></xmpp:note>
</xmpp:SupportedXep>
@@ -475,24 +476,9 @@
</implements>
<release>
<Version>
<revision>0.17.0</revision>
<created>2026-03-26</created>
<file-release rdf:resource='https://profanity-im.github.io/tarballs/profanity-0.17.0.tar.xz'/>
</Version>
<Version>
<revision>0.16.0</revision>
<created>2026-02-23</created>
<file-release rdf:resource='https://profanity-im.github.io/tarballs/profanity-0.16.0.tar.gz'/>
</Version>
<Version>
<revision>0.15.1</revision>
<created>2025-08-22</created>
<file-release rdf:resource='https://profanity-im.github.io/tarballs/profanity-0.15.1.tar.gz'/>
</Version>
<Version>
<revision>0.15.0</revision>
<created>2025-03-27</created>
<created>2024-03-27</created>
<file-release rdf:resource='https://profanity-im.github.io/tarballs/profanity-0.15.0.tar.gz'/>
</Version>
<Version>

View File

@@ -1,35 +0,0 @@
# Scripts
This directory contains various scripts used for development, CI, and maintenance.
## `lint-and-test.sh`
Central validation script mainly for local development.
- **Purpose:** Runs spelling checks, code formatting, and unit testing.
- **Usage:** `./scripts/lint-and-test.sh [options]`
- **Options:**
- `--fix-formatting`: Automatically apply `clang-format` fixes.
- `--tests`: Run unit tests using Meson.
- `--hook`: Run in "hook mode" (checks only staged files).
- `--install`: Install the script as a git `pre-commit` hook.
## `build-configuration-matrix.sh`
Exhaustive build configuration matrix testing. It ensures that Profanity compiles and passes unit tests across a variety of feature configurations for Meson.
- **Purpose:** Verifies architectural compatibility by testing many combinations of build flags.
- **Usage:** `./scripts/build-configuration-matrix.sh [extra-args]`
- **Extra Arguments:** Any arguments are forwarded directly to the configuration command (`meson setup`).
- **Environment:** Primarily used in CI (GitHub Actions), but can be run locally to verify all configurations.
## `changelog-helper.py`
Generates a sorted changelog from git commits since the last tag.
- **Purpose:** Automates the creation of release notes by parsing Conventional Commit messages.
- **Usage:** `python3 scripts/changelog-helper.py [--pr]`
- **Options:** Use `--pr` to append Pull Request numbers to each entry.
## `check-new-xeps.py`
Checks for updates to XMPP Extension Protocols (XEPs).
- **Purpose:** Compares the versions of XEPs implemented in Profanity (tracked in `profanity.doap`) against the latest versions available at `xmpp.org`.
- **Usage:** `python3 scripts/check-new-xeps.py`

View File

@@ -1,113 +0,0 @@
#!/usr/bin/env bash
# Exhaustive build configuration matrix testing for Profanity
set -e
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
log_content() {
echo
if [ -f "$1" ]; then
echo "Content of $1:"
cat "$1"
else
echo "Log file $1 not found."
fi
}
error_handler() {
ERR_CODE=$?
echo -e "${RED}Error ${ERR_CODE} with command '${BASH_COMMAND}' on line ${BASH_LINENO[0]}. Exiting.${NC}"
for log in build_run/meson-logs/testlog.txt build_valgrind/meson-logs/testlog.txt; do
if [ -f "$log" ]; then
echo "--- Meson Test Log ($log) ---"
cat "$log"
fi
done
exit ${ERR_CODE}
}
trap error_handler ERR
num_cores() {
nproc \
|| sysctl -n hw.ncpu \
|| getconf _NPROCESSORS_ONLN 2>/dev/null \
|| echo 2
}
usage() {
echo "Usage: $0 [extra-args]"
echo ""
echo "Run exhaustive build matrix tests."
echo ""
echo "Extra arguments are passed directly to: meson setup [extra-args]"
exit 0
}
if [[ "$1" == "--help" || "$1" == "-h" ]]; then
usage
fi
# Compatibility with old script that took autotools|meson as first arg
if [[ "$1" == "meson" ]]; then
shift
elif [[ "$1" == "autotools" ]]; then
echo -e "${RED}Error: Autotools is no longer supported.${NC}"
exit 1
fi
ARCH="$(uname | tr '[:upper:]' '[:lower:]')"
EXTRA_ARGS="$*"
# Build Matrix
echo -e "${YELLOW}---> Starting build matrix...${NC}"
tests=(
"-Dnotifications=enabled -Dicons-and-clipboard=enabled -Dotr=enabled -Dpgp=enabled -Domemo=enabled -Dc-plugins=enabled -Dpython-plugins=enabled -Dxscreensaver=enabled -Domemo-qrcode=enabled -Dgdk-pixbuf=enabled"
""
"-Dnotifications=disabled"
"-Dicons-and-clipboard=disabled"
"-Dotr=disabled"
"-Dpgp=disabled"
"-Domemo=disabled -Domemo-qrcode=disabled"
"-Dpgp=disabled -Dotr=disabled"
"-Dpgp=disabled -Dotr=disabled -Domemo=disabled"
"-Dpython-plugins=disabled"
"-Dc-plugins=disabled"
"-Dc-plugins=disabled -Dpython-plugins=disabled"
"-Dxscreensaver=disabled"
"-Dgdk-pixbuf=disabled"
)
BACKEND_OPT=""
if [ -n "${OMEMO_BACKEND}" ]; then
BACKEND_OPT="-Domemo-backend=${OMEMO_BACKEND}"
fi
# Valgrind check (Linux only)
if [[ "$ARCH" == linux* ]]; then
echo -e "${YELLOW}--> Running Valgrind check with full features ${BACKEND_OPT} ${EXTRA_ARGS}${NC}"
rm -rf build_valgrind
meson setup build_valgrind ${tests[0]} ${BACKEND_OPT} -Dtests=true -Db_sanitize=undefined ${EXTRA_ARGS}
meson compile -C build_valgrind
meson test -C build_valgrind "unit tests" --print-errorlogs --wrap=valgrind || echo "Valgrind issues detected"
rm -rf build_valgrind
fi
for features in "${tests[@]}"
do
echo -e "${YELLOW}--> Building with: ${features} ${BACKEND_OPT} ${EXTRA_ARGS}${NC}"
rm -rf build_run
meson setup build_run ${features} ${BACKEND_OPT} -Dtests=true ${EXTRA_ARGS}
meson compile -C build_run
meson test -C build_run "unit tests" --print-errorlogs
./build_run/profanity -v
done
echo -e "${GREEN}Build configuration matrix testing successful!${NC}"

View File

@@ -1,165 +0,0 @@
#!/usr/bin/env python3
# Since we use Conventional Commits
# we can now create our Changelog semi-automatically
import subprocess
import sys
import re
import argparse
from collections import defaultdict
# Configuration for sections and their order
SECTION_CONFIG = [
("fix", "Bug Fixes"),
("feat", "Features"),
("build", "Build System"),
("ci", "CI"),
("docs", "Documentation"),
("perf", "Performance Improvements"),
("refactor", "Refactorings"),
("cleanup", "Cleanup"),
("style", "Style"),
("tests", "Tests"),
("chore", "Chores"),
]
SECTIONS = dict(SECTION_CONFIG)
TYPE_ORDER = [t for t, _ in SECTION_CONFIG]
CORRECTIONS = {
"ests": "tests",
"wleanup": "cleanup",
}
def git_run(args):
"""Run a git command and return stripped output lines."""
try:
result = subprocess.run(["git"] + args, capture_output=True, text=True, check=True)
return [line for line in result.stdout.strip().split('\n') if line]
except subprocess.CalledProcessError:
return []
def get_last_tag():
output = git_run(["describe", "--tags", "--abbrev=0"])
return output[0] if output else None
def get_commits(revision_range):
"""Get list of (hash, subject) tuples."""
lines = git_run(["log", revision_range, "--format=%H %s"])
commits = []
for line in lines:
parts = line.split(' ', 1)
if len(parts) == 2:
commits.append(parts)
return commits
def get_pr_mappings(revision_range):
"""Map commit hashes to PR numbers found in merge commits."""
merge_commits = git_run(["log", revision_range, "--merges", "--format=%H %s"])
pr_map = {}
pr_re = re.compile(r'Merge pull request #(\d+)')
for line in merge_commits:
parts = line.split(' ', 1)
if len(parts) < 2:
continue
m_hash, m_subject = parts
match = pr_re.search(m_subject)
if match:
pr_num = match.group(1)
# Find all commits that are part of this merge branch
branch_commits = git_run(["rev-list", f"{m_hash}^1..{m_hash}^2"])
for b_hash in branch_commits:
pr_map[b_hash] = pr_num
return pr_map
def get_contributors(revision_range):
"""Get sorted list of all unique contributors."""
cmd = ["log", revision_range, "--format=%an%n%(trailers:key=Co-authored-by,valueonly=true)"]
output = git_run(cmd)
contributors = set()
for line in output:
# Remove email part if present: "Name <email@example.com>" -> "Name"
name = line.split('<')[0].strip()
if name:
contributors.add(name)
return sorted(list(contributors))
def format_description(description):
"""Capitalize first letter of description."""
description = description.strip()
if description and description[0].islower():
return description[0].upper() + description[1:]
return description
def main():
parser = argparse.ArgumentParser(description="Generate a sorted changelog from git commits.")
parser.add_argument("--pr", action="store_true", help="Append PR number to each commit.")
args = parser.parse_args()
last_tag = get_last_tag()
if not last_tag:
print("No tags found in the repository.", file=sys.stderr)
revision_range = f"{last_tag}..HEAD" if last_tag else "HEAD"
commits = get_commits(revision_range)
if not commits:
print(f"No commits found since {last_tag if last_tag else 'the beginning'}.")
return
pr_map = get_pr_mappings(revision_range) if args.pr else {}
# Conventional Commit regex: type(scope): description
commit_re = re.compile(r'^(\w+)(?:\(([^)]+)\))?:\s*(.*)$')
grouped = defaultdict(list)
others = []
for c_hash, c_subject in commits:
# Skip merge commits in the output
if c_subject.startswith(("Merge pull request", "Merge branch")):
continue
pr_suffix = f" (#{pr_map[c_hash]})" if c_hash in pr_map else ""
match = commit_re.match(c_subject)
if match:
ctype = match.group(1).lower()
ctype = CORRECTIONS.get(ctype, ctype)
description = format_description(match.group(3))
grouped[ctype].append(f"{description}{pr_suffix}")
else:
others.append(f"{c_subject}{pr_suffix}")
# Output sections in ordered priority
all_types = TYPE_ORDER + sorted([t for t in grouped if t not in TYPE_ORDER])
first = True
for ctype in all_types:
if ctype in grouped:
if not first:
print()
section_name = SECTIONS.get(ctype, ctype.capitalize())
print(f"{section_name}:")
for msg in sorted(grouped[ctype]):
print(f"- {msg}")
first = False
if others:
if not first:
print()
print("Others:")
for msg in sorted(others):
print(f"- {msg}")
# Contributors section
contributors = get_contributors(revision_range)
if contributors:
print("\nContributors:")
for i, name in enumerate(contributors, 1):
print(f"{i}. {name}")
if __name__ == "__main__":
main()

View File

@@ -1,136 +0,0 @@
#!/usr/bin/env python3
import os
import re
import sys
import urllib.request
import xml.etree.ElementTree as ET
from itertools import zip_longest
from typing import Dict, List, Optional
# Namespaces in DOAP
NS = {
"rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
"foaf": "http://xmlns.com/foaf/0.1/",
"doap": "http://usefulinc.com/ns/doap#",
"xmpp": "https://linkmauve.fr/ns/xmpp-doap#",
"schema": "https://schema.org/",
}
def compare_versions(v1: str, v2: str) -> int:
"""
Compare two version strings.
Returns 1 if v2 > v1, -1 if v1 > v2, 0 if equal.
"""
def parse_v(v: str) -> List[int]:
return [int(x) for x in re.split(r"[^0-9]+", v) if x]
parts1 = parse_v(v1)
parts2 = parse_v(v2)
for p1, p2 in zip_longest(parts1, parts2, fillvalue=0):
if p2 > p1:
return 1
if p1 > p2:
return -1
return 0
def find_doap() -> Optional[str]:
"""Try to find profanity.doap in current or parent directory."""
candidates = ["profanity.doap", "../profanity.doap"]
for c in candidates:
if os.path.exists(c):
return c
return None
def get_implemented_xeps(doap_path: str) -> Dict[str, str]:
"""Parse DOAP file and return a map of XEP number to version."""
implemented_xeps: Dict[str, str] = {}
try:
tree = ET.parse(doap_path)
root = tree.getroot()
for implements in root.findall(".//doap:implements", NS):
supported_xep = implements.find(".//xmpp:SupportedXep", NS)
if supported_xep is not None:
xep_res = supported_xep.find(".//xmpp:xep", NS)
version_elem = supported_xep.find(".//xmpp:version", NS)
if xep_res is not None and version_elem is not None:
resource = xep_res.attrib.get(f"{{{NS['rdf']}}}resource", "")
match = re.search(r"xep-(\d+)\.html", resource)
if match:
xep_num = match.group(1)
current_version = version_elem.text.strip() if version_elem.text else ""
implemented_xeps[xep_num] = current_version
except (ET.ParseError, PermissionError) as e:
print(f"Error reading {doap_path}: {e}")
sys.exit(1)
return implemented_xeps
def check_xeps() -> None:
"""Main logic for checking XEP updates."""
doap_path = find_doap()
if not doap_path:
print("Error: Could not find DOAP file.")
sys.exit(1)
implemented_xeps = get_implemented_xeps(doap_path)
if not implemented_xeps:
print("No XEPs found in DOAP file.")
return
print(f"XEPs tracked: {len(implemented_xeps)}")
try:
url = "https://xmpp.org/extensions/xeplist.xml"
with urllib.request.urlopen(url, timeout=15) as response:
xeplist_xml = response.read()
except Exception as e:
print(f"Error fetching xeplist.xml: {e}")
return
try:
xeplist_tree = ET.fromstring(xeplist_xml)
except ET.ParseError as e:
print(f"Error parsing xeplist.xml: {e}")
return
print(f"\n{'XEP':<10} | {'Name':<35} | {'Ours':<8} | {'Latest':<8}")
print("-" * 80)
updates_found = 0
for xep_node in xeplist_tree.findall("xep"):
number_node = xep_node.find("number")
title_node = xep_node.find("title")
last_revision_node = xep_node.find("last-revision")
if number_node is None or title_node is None or last_revision_node is None:
continue
number = (number_node.text or "0").zfill(4)
name = title_node.text or "Unknown"
version_node = last_revision_node.find("version")
if version_node is None or version_node.text is None:
continue
latest_version = version_node.text
if number in implemented_xeps:
old_version = implemented_xeps[number]
if compare_versions(old_version, latest_version) > 0:
print(f"XEP-{number:<4} | {name[:35]:<35} | {old_version:<8} | {latest_version:<8}")
updates_found += 1
if updates_found == 0:
print("All tracked XEPs are up to date.")
if __name__ == "__main__":
check_xeps()

View File

@@ -1,138 +0,0 @@
#!/usr/bin/env bash
# Central linting and testing script for Profanity
set -e
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
# Go to project root
cd "$(dirname "$0")/.."
usage() {
echo "Usage: $0 [options]"
echo ""
echo "Description:"
echo " Code quality checks (spelling, formatting, and unit tests)."
echo " Works with meson and can be used as a git"
echo " pre-commit hook."
echo ""
echo "Options:"
echo " --fix-formatting Apply formatting fixes (default is check only)"
echo " --no-format Skip the formatting check/fix entirely. Use this if your local"
echo " clang-format version produces different results than the CI."
echo " Can also be set via SKIP_FORMAT=1 environment variable."
echo " --tests Run unit tests using Meson (meson test)"
echo " --hook Git hook mode: Checks only staged files for spelling and"
echo " formatting. Does not run tests to ensure fast commits."
echo " --install Install this script as a git pre-commit hook"
echo " --help Show this help message"
}
run_tests() {
local system=$1
echo -e "${YELLOW}---> Running unit tests...${NC}"
if [ "$system" == "meson" ]; then
echo "Using Meson..."
# Uses build_run
meson test -C build_run "unit tests"
fi
}
run_format() {
local mode=$1
local hook_mode=$2
local skip=$3
local files
if [ "$skip" = true ]; then
echo -e "${YELLOW}---> Skipping formatting check.${NC}"
return
fi
if [ "$hook_mode" = true ]; then
echo -e "${YELLOW}---> Checking staged files for formatting...${NC}"
# Only added/modified C files
files=$(git diff --cached --name-only --diff-filter=ACMR | grep -E "\.(c|h)$" || true)
else
echo -e "${YELLOW}---> Checking all files for formatting...${NC}"
files=$(find src tests -name "*.[ch]" || true)
fi
if [ -z "$files" ]; then
echo "No C files to check."
return
fi
if [ "$mode" = "fix" ]; then
clang-format -i $files
echo -e "${GREEN}Formatting applied.${NC}"
else
# --Werror makes it return non-zero on diff
if ! clang-format --dry-run --Werror $files; then
echo -e "${RED}Error: Style violations found. Run '$0 --fix-formatting' to resolve.${NC}"
echo -e "${RED}If this is due to a clang-format version mismatch, use --no-format or SKIP_FORMAT=1.${NC}"
exit 1
fi
echo -e "${GREEN}Style check passed.${NC}"
fi
}
run_spell() {
echo -e "${YELLOW}---> Running spell check...${NC}"
if command -v codespell >/dev/null 2>&1; then
codespell
echo -e "${GREEN}Spell check passed.${NC}"
else
echo -e "${YELLOW}Warning: codespell not found, skipping.${NC}"
fi
}
MODE="check"
BUILD_SYSTEM="none"
HOOK=false
# Support environment variable override
if [[ "$SKIP_FORMAT" == "1" || "$SKIP_FORMAT" == "true" ]]; then
INTERNAL_SKIP_FORMAT=true
else
INTERNAL_SKIP_FORMAT=false
fi
while [[ "$#" -gt 0 ]]; do
case $1 in
--fix-formatting) MODE="fix" ;;
--no-format) INTERNAL_SKIP_FORMAT=true ;;
--tests) BUILD_SYSTEM="meson" ;;
--hook) HOOK=true ;;
--install)
echo "Installing pre-commit hook..."
mkdir -p .git/hooks
echo "#!/usr/bin/env bash" > .git/hooks/pre-commit
echo "./scripts/lint-and-test.sh --hook" >> .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit
echo "Hook installed."
exit 0
;;
--help) usage; exit 0 ;;
*) echo "Unknown parameter: $1"; usage; exit 1 ;;
esac
shift
done
# Always run spell check
run_spell
# Run format check unless skipped
run_format "$MODE" "$HOOK" "$INTERNAL_SKIP_FORMAT"
# Run tests if a build system was specified
if [ "$BUILD_SYSTEM" != "none" ]; then
run_tests "$BUILD_SYSTEM"
fi
echo -e "${GREEN}Validation successful!${NC}"

View File

@@ -186,81 +186,14 @@ ai_json_escape(const gchar* str)
return g_string_free(result, FALSE);
}
/* Keys emitted as fixed payload fields; custom settings must not duplicate them */
static gboolean
_is_reserved_payload_key(const gchar* key)
{
return g_strcmp0(key, "model") == 0 || g_strcmp0(key, "messages") == 0 || g_strcmp0(key, "stream") == 0;
}
/* RFC 8259 scalars (number/true/false/null) may be emitted bare in a JSON payload */
static gboolean
_is_json_bare_token(const gchar* value)
{
if (g_strcmp0(value, "true") == 0 || g_strcmp0(value, "false") == 0 || g_strcmp0(value, "null") == 0)
return TRUE;
return g_regex_match_simple("^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$", value, 0, 0);
}
/**
* Convert a 4-hex-digit sequence at @p to a 16-bit code point.
* Returns -1 on invalid hex.
*/
static int
_hex4_to_int(const gchar* p)
{
int val = 0;
for (int i = 0; i < 4; i++) {
char c = p[i];
val <<= 4;
if (c >= '0' && c <= '9')
val |= c - '0';
else if (c >= 'a' && c <= 'f')
val |= c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
val |= c - 'A' + 10;
else
return -1;
}
return val;
}
/**
* Write a UTF-8 encoding of @cp to @w, advancing @w.
* Returns the updated pointer.
*/
static gchar*
_write_utf8(gchar* w, unsigned int cp)
{
if (cp <= 0x7F) {
*w++ = (char)cp;
} else if (cp <= 0x7FF) {
*w++ = (char)(0xC0 | (cp >> 6));
*w++ = (char)(0x80 | (cp & 0x3F));
} else if (cp <= 0xFFFF) {
*w++ = (char)(0xE0 | (cp >> 12));
*w++ = (char)(0x80 | ((cp >> 6) & 0x3F));
*w++ = (char)(0x80 | (cp & 0x3F));
} else if (cp <= 0x10FFFF) {
*w++ = (char)(0xF0 | (cp >> 18));
*w++ = (char)(0x80 | ((cp >> 12) & 0x3F));
*w++ = (char)(0x80 | ((cp >> 6) & 0x3F));
*w++ = (char)(0x80 | (cp & 0x3F));
}
/* Invalid code point: silently skip */
return w;
}
/* Decode JSON string escapes in [start, end) into a freshly allocated buffer.
* Handles \" \\ \/ \n \t \r \b \f and \uXXXX (including surrogate pairs). */
* Handles \" \\ \/ \n \t \r \b \f. \uXXXX sequences are passed through verbatim
* since the rest of the AI pipeline already deals in UTF-8 byte streams. */
static gchar*
_json_unescape_substring(const gchar* start, const gchar* end)
{
/* Estimate upper bound: each \uXXXX becomes up to 6 UTF-8 bytes. */
gsize max_len = (end - start) * 6 + 1;
gchar* out = g_new0(gchar, max_len);
gchar* out = g_new0(gchar, (end - start) + 1);
gchar* w = out;
for (const gchar* in = start; in < end;) {
if (*in == '\\' && in + 1 < end) {
switch (in[1]) {
@@ -296,64 +229,6 @@ _json_unescape_substring(const gchar* start, const gchar* end)
*w++ = '\f';
in += 2;
break;
case 'u':
/* Handle \uXXXX or surrogate pair \uHHHH\uLLLL */
if (in + 6 > end) {
/* Not enough characters — emit literal */
*w++ = *in++;
break;
}
if (in[2] != '\\' || in[3] != 'u') {
/* Single \uXXXX */
int cp = _hex4_to_int(in + 2);
if (cp < 0) {
/* Invalid hex — emit literal backslash */
*w++ = *in++;
} else if (cp < 0xD800 || cp > 0xDFFF) {
/* Not a surrogate — encode directly */
w = _write_utf8(w, (unsigned int)cp);
in += 6;
} else {
/* High or low surrogate — expect pair */
unsigned int high = (unsigned int)cp;
if ((high >= 0xD800 && high <= 0xDBFF) && in + 12 <= end && in[6] == '\\' && in[7] == 'u') {
/* High surrogate followed by \u */
int low = _hex4_to_int(in + 8);
if (low >= 0xDC00 && low <= 0xDFFF) {
/* Valid surrogate pair */
unsigned int cp2 = (0x10000 + ((high & 0x3FF) << 10)) | (low & 0x3FF);
w = _write_utf8(w, cp2);
in += 12;
} else {
/* Invalid low surrogate — emit replacement */
w = _write_utf8(w, 0xFFFD);
in += 6;
}
} else {
/* Orphan high surrogate or lone low surrogate */
w = _write_utf8(w, 0xFFFD);
in += 6;
}
}
} else {
/* \uHHHH\uLLLL — surrogate pair */
int high = _hex4_to_int(in + 2);
if (high < 0) {
*w++ = *in++;
break;
}
int low = _hex4_to_int(in + 8);
if ((high >= 0xD800 && high <= 0xDBFF) && (low >= 0xDC00 && low <= 0xDFFF)) {
unsigned int cp2 = (0x10000 + ((unsigned int)(high & 0x3FF) << 10)) | (unsigned int)(low & 0x3FF);
w = _write_utf8(w, cp2);
in += 12;
} else {
/* Invalid pair — emit replacement for high */
w = _write_utf8(w, 0xFFFD);
in += 6;
}
}
break;
default:
*w++ = *in++;
break;
@@ -363,9 +238,7 @@ _json_unescape_substring(const gchar* start, const gchar* end)
}
}
*w = '\0';
/* Realloc to exact size */
return g_realloc(out, w - out + 1);
return out;
}
/* Locate "field":"...value..." in json and return the unescaped value.
@@ -408,7 +281,6 @@ ai_provider_new(const gchar* name, const gchar* api_url)
provider->models = NULL;
provider->models_fresh = FALSE;
provider->ref_count = 1;
pthread_mutex_init(&provider->settings_lock, NULL);
return provider;
}
@@ -436,7 +308,6 @@ ai_provider_unref(AIProvider* provider)
g_free(provider->project_id);
g_free(provider->default_model);
g_hash_table_destroy(provider->settings);
pthread_mutex_destroy(&provider->settings_lock);
GList* curr = provider->models;
while (curr) {
@@ -747,44 +618,31 @@ ai_get_provider_default_model(const gchar* provider_name)
return provider->default_model;
}
gboolean
void
ai_set_provider_setting(const gchar* provider_name, const gchar* setting, const gchar* value)
{
if (!provider_name || !setting)
return FALSE;
if (_is_reserved_payload_key(setting)) {
log_warning("Setting '%s' for provider '%s' rejected: reserved payload key", setting, provider_name);
return FALSE;
}
return;
AIProvider* provider = ai_get_provider(provider_name);
if (!provider) {
log_warning("Provider '%s' not found for setting '%s'", provider_name, setting);
return FALSE;
return;
}
/* settings is iterated by the request thread; mutate under settings_lock */
pthread_mutex_lock(&provider->settings_lock);
if (!provider->settings) {
provider->settings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
}
if (value) {
g_hash_table_insert(provider->settings, g_strdup(setting), g_strdup(value));
} else {
g_hash_table_remove(provider->settings, setting);
}
pthread_mutex_unlock(&provider->settings_lock);
if (value) {
prefs_ai_set_setting(provider_name, setting, value);
log_info("Setting '%s' for provider '%s' set to: %s", setting, provider_name, value);
} else {
g_hash_table_remove(provider->settings, setting);
prefs_ai_remove_setting(provider_name, setting);
log_info("Setting '%s' removed for provider '%s'", setting, provider_name);
}
return TRUE;
}
gchar*
@@ -797,10 +655,8 @@ ai_get_provider_setting(const gchar* provider_name, const gchar* setting)
if (!provider || !provider->settings)
return NULL;
pthread_mutex_lock(&provider->settings_lock);
gchar* value = g_strdup(g_hash_table_lookup(provider->settings, setting));
pthread_mutex_unlock(&provider->settings_lock);
return value;
gchar* value = g_hash_table_lookup(provider->settings, setting);
return g_strdup(value);
}
/* ========================================================================
@@ -1468,19 +1324,13 @@ ai_session_switch(AISession* session, const gchar* provider_name,
* This is the thread-safe variant used by _ai_request_thread() which holds
* the session lock while calling it.
*
* Custom provider settings are merged into the payload as additional JSON
* key-value pairs alongside "model" and "messages": scalar values
* (number/true/false/null) are emitted bare, anything else as a JSON string;
* reserved keys (model/messages/stream) are skipped.
*
* @param provider The AI provider (for custom settings)
* @param model The model identifier
* @param history GList of AIMessage* (must be held under session lock)
* @param prompt The new user prompt to append
* @return Newly allocated JSON string (caller must free)
*/
static gchar*
_build_json_payload_from_list(AIProvider* provider, const gchar* model, GList* history, const gchar* prompt)
_build_json_payload_from_list(const gchar* model, GList* history, const gchar* prompt)
{
GString* messages_json = g_string_new("");
GList* curr = history;
@@ -1507,50 +1357,11 @@ _build_json_payload_from_list(AIProvider* provider, const gchar* model, GList* h
g_string_append_printf(messages_json, "{\"role\":\"user\",\"content\":\"%s\"}", escaped_prompt);
auto_gchar gchar* escaped_model = ai_json_escape(model);
/* Build custom settings JSON fragment; settings is mutated on the main
* thread (/ai set custom), so iterate under settings_lock */
GString* custom_json = g_string_new("");
if (provider) {
pthread_mutex_lock(&provider->settings_lock);
if (provider->settings) {
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, provider->settings);
while (g_hash_table_iter_next(&iter, &key, &value)) {
if (_is_reserved_payload_key((gchar*)key)) {
continue; /* fixed payload fields stay authoritative */
}
auto_gchar gchar* escaped_key = ai_json_escape((gchar*)key);
if (custom_json->len > 0) {
g_string_append_c(custom_json, ',');
}
if (_is_json_bare_token((gchar*)value)) {
g_string_append_printf(custom_json, "\"%s\": %s", escaped_key, (gchar*)value);
} else {
/* non-scalar values must be quoted, else the payload is invalid JSON */
auto_gchar gchar* escaped_val = ai_json_escape((gchar*)value);
g_string_append_printf(custom_json, "\"%s\": \"%s\"", escaped_key, escaped_val);
}
}
}
pthread_mutex_unlock(&provider->settings_lock);
}
/* Assemble final payload: model, messages, custom settings, then fixed keys */
gchar* json_payload;
if (custom_json->len > 0) {
json_payload = g_strdup_printf(
"{\"model\":\"%s\",\"messages\":[%s],%s,\"stream\":false}",
escaped_model, messages_json->str, custom_json->str);
} else {
json_payload = g_strdup_printf(
"{\"model\":\"%s\",\"messages\":[%s],\"stream\":false}",
escaped_model, messages_json->str);
}
gchar* json_payload = g_strdup_printf(
"{\"model\":\"%s\",\"input\":[%s],\"stream\":false,\"store\":false}",
escaped_model, messages_json->str);
g_string_free(messages_json, TRUE);
g_string_free(custom_json, TRUE);
return json_payload;
}
@@ -1560,7 +1371,12 @@ ai_parse_response(const gchar* response_json)
if (!response_json || strlen(response_json) == 0)
return NULL;
/* OpenAI /v1/chat/completions: {"choices":[{"message":{"content":"..."}}]} */
/* Perplexity /v1/agent: {"output":[{"content":[{"text":"...","type":"output_text"}]}]}
* Legacy OpenAI: {"choices":[{"message":{"content":"..."}}]} */
gchar* text = _extract_json_string(response_json, "text");
if (text)
return text;
return _extract_json_string(response_json, "content");
}
@@ -1603,10 +1419,10 @@ _ai_request_thread(gpointer data)
* list modifications). We must snapshot all fields atomically.
* ===================================================================== */
pthread_mutex_lock(&session->lock);
auto_gchar gchar* local_provider_name = g_strdup(session->provider_name);
gchar* local_provider_name = g_strdup(session->provider_name);
AIProvider* local_provider = ai_provider_ref(session->provider);
auto_gchar gchar* local_model = g_strdup(session->model);
auto_gchar gchar* local_api_key = g_strdup(session->api_key ? session->api_key : "");
gchar* local_model = g_strdup(session->model);
gchar* local_api_key = g_strdup(session->api_key ? session->api_key : "");
pthread_mutex_unlock(&session->lock);
log_debug("[AI-THREAD] Session: %s/%s", local_provider_name, local_model);
@@ -1618,8 +1434,6 @@ _ai_request_thread(gpointer data)
local_provider_name, local_provider_name);
log_error("AI request failed for %s/%s: %s", local_provider_name, local_model, error_msg);
_aiwin_display_error(user_data, error_msg);
ai_provider_unref(local_provider);
ai_session_unref(session);
g_free(args);
return NULL;
}
@@ -1630,8 +1444,6 @@ _ai_request_thread(gpointer data)
log_error("AI request failed for %s/%s: Failed to initialize curl",
local_provider_name, local_model);
_aiwin_display_error(user_data, "Failed to initialize curl.");
ai_provider_unref(local_provider);
ai_session_unref(session);
g_free(args);
return NULL;
}
@@ -1639,7 +1451,7 @@ _ai_request_thread(gpointer data)
/* Build JSON payload from history + prompt (under lock), then add user message to history */
log_debug("[AI-THREAD] Building JSON payload...");
pthread_mutex_lock(&session->lock);
auto_gchar gchar* json_payload = _build_json_payload_from_list(local_provider, local_model, session->history, prompt);
auto_gchar gchar* json_payload = _build_json_payload_from_list(local_model, session->history, prompt);
/* Add user message to history now (it's in JSON but not yet in history) */
AIMessage* user_msg = g_new0(AIMessage, 1);
@@ -1660,7 +1472,7 @@ _ai_request_thread(gpointer data)
/* Build request URL */
const gchar* api_url = local_provider->api_url;
auto_gchar gchar* request_url = g_strdup_printf("%s%sv1/chat/completions", api_url, g_str_has_suffix(api_url, "/") ? "" : "/");
auto_gchar gchar* request_url = g_strdup_printf("%s%sv1/responses", api_url, g_str_has_suffix(api_url, "/") ? "" : "/");
log_debug("[AI-THREAD] API URL: %s", api_url);
log_debug("[AI-THREAD] API Request URL: %s", request_url);
log_debug("[AI-THREAD] Model: %s", local_model);
@@ -1680,7 +1492,6 @@ _ai_request_thread(gpointer data)
long http_code = 0;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
log_debug("[AI-THREAD] HTTP response code: %ld", http_code);
auto_gchar gchar* response_data = g_steal_pointer(&response.data);
if (res != CURLE_OK) {
auto_gchar gchar* error_msg = g_strdup(curl_easy_strerror(res));
@@ -1689,14 +1500,17 @@ _ai_request_thread(gpointer data)
} else if (http_code >= 400) {
/* Handle HTTP errors */
log_debug("[AI-THREAD] HTTP error response body (%zu bytes): %s",
response.size, response_data);
response.size, response.data ? response.data : "NULL");
/* Try to extract the actual error message from the JSON response */
auto_gchar gchar* parsed_error = ai_parse_error_message(response_data);
auto_gchar gchar* error_msg = parsed_error ? g_strdup_printf("HTTP %ld: %s", http_code, parsed_error) : g_strdup_printf("HTTP %ld: %s", http_code, response_data && strlen(response_data) > 0 ? response_data : "Unknown error");
auto_gchar gchar* parsed_error = ai_parse_error_message(response.data);
auto_gchar gchar* error_msg = parsed_error ? g_strdup_printf("HTTP %ld: %s", http_code, parsed_error) : g_strdup_printf("HTTP %ld: %s", http_code, response.data && strlen(response.data) > 0 ? response.data : "Unknown error");
log_error("AI request failed for %s/%s: %s", local_provider_name, local_model, error_msg);
_aiwin_display_error(user_data, error_msg);
} else {
log_debug("[AI-THREAD] Raw API response (%zu bytes): %s", response.size, response_data);
/* Parse response - transfer ownership to auto_gchar for cleanup */
log_debug("[AI-THREAD] Raw API response (%zu bytes): %s", response.size, response.data ? response.data : "NULL");
auto_gchar gchar* response_data = response.data;
response.data = NULL;
auto_gchar gchar* content = ai_parse_response(response_data);
if (content) {
/* Add assistant response to history (under lock) */
@@ -1717,9 +1531,12 @@ _ai_request_thread(gpointer data)
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
/* Cleanup local copies */
g_free(local_provider_name);
ai_provider_unref(local_provider);
g_free(local_model);
g_free(local_api_key);
ai_session_unref(session);
g_free(args);
return NULL;

View File

@@ -17,15 +17,14 @@ typedef struct ai_message_t
*/
typedef struct ai_provider_t
{
gchar* name; /* Provider name (e.g., "openai", "perplexity") */
gchar* api_url; /* API endpoint URL */
gchar* project_id; /* Optional project ID (for some providers) */
gchar* default_model; /* Default model for this provider */
pthread_mutex_t settings_lock; /* Protects settings (iterated by the request thread) */
GHashTable* settings; /* Extensible per-provider settings (e.g., temperature=0.7) */
GList* models; /* Cached models (gchar*) */
gboolean models_fresh; /* Whether models cache is current */
gint32 ref_count; /* Reference count (atomic) */
gchar* name; /* Provider name (e.g., "openai", "perplexity") */
gchar* api_url; /* API endpoint URL */
gchar* project_id; /* Optional project ID (for some providers) */
gchar* default_model; /* Default model for this provider */
GHashTable* settings; /* Extensible per-provider settings (e.g., tools=enabled, search=disabled) */
GList* models; /* Cached models (gchar*) */
gboolean models_fresh; /* Whether models cache is current */
gint32 ref_count; /* Reference count (atomic) */
} AIProvider;
/**
@@ -143,13 +142,11 @@ const gchar* ai_get_provider_default_model(const gchar* provider_name);
/**
* Set a custom setting for a provider.
* Reserved payload keys (model, messages, stream) are rejected.
* @param provider_name The provider name
* @param setting The setting key (e.g., "temperature")
* @param value The setting value, or NULL to remove
* @return TRUE on success, FALSE on unknown provider or reserved key
* @param setting The setting key (e.g., "tools", "search")
* @param value The setting value
*/
gboolean ai_set_provider_setting(const gchar* provider_name, const gchar* setting, const gchar* value);
void ai_set_provider_setting(const gchar* provider_name, const gchar* setting, const gchar* value);
/**
* Get a custom setting for a provider.
@@ -187,9 +184,9 @@ gboolean ai_models_are_fresh(const gchar* provider_name);
void ai_parse_models_from_json(AIProvider* provider, const gchar* json);
/**
* Extract assistant content from an OpenAI chat-completions response body
* ({"choices":[{"message":{"content":"..."}}]}). Decodes the \" and \n
* escape sequences only.
* Extract assistant content from an LLM response body. Tries Perplexity
* /v1/responses "text" first, falls back to OpenAI "content". Decodes
* the \" and \n escape sequences only.
* @param response_json The JSON body from the provider
* @return Newly allocated content string, or NULL if not found (caller frees)
*/

View File

@@ -1,5 +1,5 @@
/*
* chatlog.c
* log.c
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
@@ -36,81 +36,442 @@
#include "config.h"
#include "chatlog.h"
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/*
* Background message-logging to per-day plain-text files under
* $XDG_DATA_HOME/profanity/chatlogs/ is disabled. These files were never
* read back by the application — history replay reads from the database
* (log_database_get_previous_chat) — so this subsystem only ever wrote to
* disk for users to read with external tools.
*
* All public entry points are kept as no-ops to avoid touching the ~20
* call sites in event/, otr/ and profanity.c until the API itself is
* removed.
*/
#include "glib.h"
#include "glib/gstdio.h"
#include "log.h"
#include "chatlog.h"
#include "common.h"
#include "config/files.h"
#include "config/preferences.h"
#include "xmpp/xmpp.h"
#include "xmpp/muc.h"
static GHashTable* logs;
static GHashTable* groupchat_logs;
struct dated_chat_log
{
gchar* filename;
GDateTime* date;
};
static gboolean _log_roll_needed(struct dated_chat_log* dated_log);
static struct dated_chat_log* _create_chatlog(const char* const other, const char* const login);
static struct dated_chat_log* _create_groupchat_log(const char* const room, const char* const login);
static void _free_chat_log(struct dated_chat_log* dated_log);
static gboolean _key_equals(void* key1, void* key2);
static void _chat_log_chat(const char* const login, const char* const other, const gchar* const msg,
chat_log_direction_t direction, GDateTime* timestamp, const char* const resourcepart);
static void _groupchat_log_chat(const gchar* const login, const gchar* const room, const gchar* const nick,
const gchar* const msg);
void
_chatlog_close(void)
{
g_hash_table_destroy(logs);
g_hash_table_destroy(groupchat_logs);
}
void
chatlog_init(void)
{
log_info("Initialising chat logs");
prof_add_shutdown_routine(_chatlog_close);
logs = g_hash_table_new_full(g_str_hash, (GEqualFunc)_key_equals, free,
(GDestroyNotify)_free_chat_log);
groupchat_logs = g_hash_table_new_full(g_str_hash, (GEqualFunc)_key_equals, free,
(GDestroyNotify)_free_chat_log);
}
void
chat_log_msg_out(const char* const barejid, const char* const msg, const char* const resource)
{
if (prefs_get_boolean(PREF_CHLOG)) {
_chat_log_chat(connection_get_barejid(), barejid, msg, PROF_OUT_LOG, NULL, resource);
}
}
void
chat_log_otr_msg_out(const char* const barejid, const char* const msg, const char* const resource)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
auto_gchar gchar* pref_otr_log = prefs_get_string(PREF_OTR_LOG);
if (strcmp(pref_otr_log, "on") == 0) {
_chat_log_chat(mybarejid, barejid, msg, PROF_OUT_LOG, NULL, resource);
} else if (strcmp(pref_otr_log, "redact") == 0) {
_chat_log_chat(mybarejid, barejid, "[redacted]", PROF_OUT_LOG, NULL, resource);
}
}
}
void
chat_log_pgp_msg_out(const char* const barejid, const char* const msg, const char* const resource)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
auto_gchar gchar* pref_pgp_log = prefs_get_string(PREF_PGP_LOG);
if (strcmp(pref_pgp_log, "on") == 0) {
_chat_log_chat(mybarejid, barejid, msg, PROF_OUT_LOG, NULL, resource);
} else if (strcmp(pref_pgp_log, "redact") == 0) {
_chat_log_chat(mybarejid, barejid, "[redacted]", PROF_OUT_LOG, NULL, resource);
}
}
}
void
chat_log_omemo_msg_out(const char* const barejid, const char* const msg, const char* const resource)
{
}
void
chat_log_msg_in(ProfMessage* message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
auto_gchar gchar* pref_omemo_log = prefs_get_string(PREF_OMEMO_LOG);
if (strcmp(pref_omemo_log, "on") == 0) {
_chat_log_chat(mybarejid, barejid, msg, PROF_OUT_LOG, NULL, resource);
} else if (strcmp(pref_omemo_log, "redact") == 0) {
_chat_log_chat(mybarejid, barejid, "[redacted]", PROF_OUT_LOG, NULL, resource);
}
}
}
void
chat_log_otr_msg_in(ProfMessage* message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
auto_gchar gchar* pref_otr_log = prefs_get_string(PREF_OTR_LOG);
if (message->enc == PROF_MSG_ENC_NONE || (strcmp(pref_otr_log, "on") == 0)) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(mybarejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(mybarejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
}
} else if (strcmp(pref_otr_log, "redact") == 0) {
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, NULL);
}
}
}
}
void
chat_log_pgp_msg_in(ProfMessage* message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
auto_gchar gchar* pref_pgp_log = prefs_get_string(PREF_PGP_LOG);
if (strcmp(pref_pgp_log, "on") == 0) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(mybarejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(mybarejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
}
} else if (strcmp(pref_pgp_log, "redact") == 0) {
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, NULL);
}
}
}
}
void
chat_log_omemo_msg_in(ProfMessage* message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
auto_gchar gchar* pref_omemo_log = prefs_get_string(PREF_OMEMO_LOG);
if (strcmp(pref_omemo_log, "on") == 0) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(mybarejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(mybarejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
}
} else if (strcmp(pref_omemo_log, "redact") == 0) {
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, NULL);
}
}
}
}
void
chat_log_msg_in(ProfMessage* message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(mybarejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(mybarejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
}
}
}
static void
_chat_log_chat(const char* const login, const char* const other, const char* msg,
chat_log_direction_t direction, GDateTime* timestamp, const char* const resourcepart)
{
auto_gchar gchar* pref_dblog = prefs_get_string(PREF_DBLOG);
if (g_strcmp0(pref_dblog, "redact") == 0) {
msg = "[REDACTED]";
}
char* other_name;
GString* other_str = NULL;
if (resourcepart) {
other_str = g_string_new(other);
g_string_append(other_str, "_");
g_string_append(other_str, resourcepart);
other_name = other_str->str;
} else {
other_name = (char*)other;
}
struct dated_chat_log* dated_log = g_hash_table_lookup(logs, other_name);
// no log for user
if (dated_log == NULL) {
dated_log = _create_chatlog(other_name, login);
g_hash_table_insert(logs, strdup(other_name), dated_log);
// log entry exists but file removed
} else if (!g_file_test(dated_log->filename, G_FILE_TEST_EXISTS)) {
dated_log = _create_chatlog(other_name, login);
g_hash_table_replace(logs, strdup(other_name), dated_log);
// log file needs rolling
} else if (_log_roll_needed(dated_log)) {
dated_log = _create_chatlog(other_name, login);
g_hash_table_replace(logs, strdup(other_name), dated_log);
}
if (resourcepart) {
g_string_free(other_str, TRUE);
}
if (timestamp == NULL) {
timestamp = g_date_time_new_now_local();
} else {
g_date_time_ref(timestamp);
}
auto_gchar gchar* date_fmt = g_date_time_format_iso8601(timestamp);
FILE* chatlogp = fopen(dated_log->filename, "a");
g_chmod(dated_log->filename, S_IRUSR | S_IWUSR);
if (chatlogp) {
if (direction == PROF_IN_LOG) {
if (strncmp(msg, "/me ", 4) == 0) {
if (resourcepart) {
fprintf(chatlogp, "%s - *%s %s\n", date_fmt, resourcepart, msg + 4);
} else {
fprintf(chatlogp, "%s - *%s %s\n", date_fmt, other, msg + 4);
}
} else {
if (resourcepart) {
fprintf(chatlogp, "%s - %s: %s\n", date_fmt, resourcepart, msg);
} else {
fprintf(chatlogp, "%s - %s: %s\n", date_fmt, other, msg);
}
}
} else {
if (strncmp(msg, "/me ", 4) == 0) {
fprintf(chatlogp, "%s - *me %s\n", date_fmt, msg + 4);
} else {
fprintf(chatlogp, "%s - me: %s\n", date_fmt, msg);
}
}
fflush(chatlogp);
int result = fclose(chatlogp);
if (result == EOF) {
log_error("Error closing file %s, errno = %d", dated_log->filename, errno);
}
}
g_date_time_unref(timestamp);
}
void
groupchat_log_msg_out(const gchar* const room, const gchar* const msg)
{
if (prefs_get_boolean(PREF_GRLOG)) {
const char* const mynick = muc_nick(room);
_groupchat_log_chat(connection_get_barejid(), room, mynick, msg);
}
}
void
groupchat_log_msg_in(const gchar* const room, const gchar* const nick, const gchar* const msg)
{
if (prefs_get_boolean(PREF_GRLOG)) {
_groupchat_log_chat(connection_get_barejid(), room, nick, msg);
}
}
void
groupchat_log_omemo_msg_out(const gchar* const room, const gchar* const msg)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
auto_gchar gchar* pref_omemo_log = prefs_get_string(PREF_OMEMO_LOG);
const char* const mynick = muc_nick(room);
if (strcmp(pref_omemo_log, "on") == 0) {
_groupchat_log_chat(mybarejid, room, mynick, msg);
} else if (strcmp(pref_omemo_log, "redact") == 0) {
_groupchat_log_chat(mybarejid, room, mynick, "[redacted]");
}
}
}
void
groupchat_log_omemo_msg_in(const gchar* const room, const gchar* const nick, const gchar* const msg)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char* mybarejid = connection_get_barejid();
auto_gchar gchar* pref_omemo_log = prefs_get_string(PREF_OMEMO_LOG);
if (strcmp(pref_omemo_log, "on") == 0) {
_groupchat_log_chat(mybarejid, room, nick, msg);
} else if (strcmp(pref_omemo_log, "redact") == 0) {
_groupchat_log_chat(mybarejid, room, nick, "[redacted]");
}
}
}
void
_groupchat_log_chat(const gchar* const login, const gchar* const room, const gchar* const nick,
const gchar* const msg)
{
struct dated_chat_log* dated_log = g_hash_table_lookup(groupchat_logs, room);
// no log for room
if (dated_log == NULL) {
dated_log = _create_groupchat_log(room, login);
g_hash_table_insert(groupchat_logs, strdup(room), dated_log);
// log exists but needs rolling
} else if (_log_roll_needed(dated_log)) {
dated_log = _create_groupchat_log(room, login);
g_hash_table_replace(logs, strdup(room), dated_log);
}
GDateTime* dt_tmp = g_date_time_new_now_local();
auto_gchar gchar* date_fmt = g_date_time_format_iso8601(dt_tmp);
FILE* grpchatlogp = fopen(dated_log->filename, "a");
g_chmod(dated_log->filename, S_IRUSR | S_IWUSR);
if (grpchatlogp) {
if (strncmp(msg, "/me ", 4) == 0) {
fprintf(grpchatlogp, "%s - *%s %s\n", date_fmt, nick, msg + 4);
} else {
fprintf(grpchatlogp, "%s - %s: %s\n", date_fmt, nick, msg);
}
fflush(grpchatlogp);
int result = fclose(grpchatlogp);
if (result == EOF) {
log_error("Error closing file %s, errno = %d", dated_log->filename, errno);
}
}
g_date_time_unref(dt_tmp);
}
static char*
_get_log_filename(const char* const other, const char* const login, GDateTime* dt, gboolean is_room)
{
auto_gchar gchar* chatlogs_dir = files_file_in_account_data_path(DIR_CHATLOGS, login, is_room ? "rooms" : NULL);
auto_gchar gchar* logfile_name = g_date_time_format(dt, "%Y_%m_%d.log");
auto_char char* other_ = str_replace(other, "@", "_at_");
auto_gchar gchar* logs_path = g_strdup_printf("%s/%s", chatlogs_dir, other_);
gchar* logfile_path = NULL;
if (create_dir(logs_path)) {
logfile_path = g_strdup_printf("%s/%s", logs_path, logfile_name);
}
return logfile_path;
}
static struct dated_chat_log*
_create_chatlog(const char* const other, const char* const login)
{
GDateTime* now = g_date_time_new_now_local();
auto_char char* filename = _get_log_filename(other, login, now, FALSE);
struct dated_chat_log* new_log = malloc(sizeof(struct dated_chat_log));
new_log->filename = strdup(filename);
new_log->date = now;
return new_log;
}
static struct dated_chat_log*
_create_groupchat_log(const char* const room, const char* const login)
{
GDateTime* now = g_date_time_new_now_local();
auto_char char* filename = _get_log_filename(room, login, now, TRUE);
struct dated_chat_log* new_log = malloc(sizeof(struct dated_chat_log));
new_log->filename = strdup(filename);
new_log->date = now;
return new_log;
}
static gboolean
_log_roll_needed(struct dated_chat_log* dated_log)
{
gboolean result = FALSE;
GDateTime* now = g_date_time_new_now_local();
if (g_date_time_get_day_of_year(dated_log->date) != g_date_time_get_day_of_year(now)) {
result = TRUE;
}
g_date_time_unref(now);
return result;
}
static void
_free_chat_log(struct dated_chat_log* dated_log)
{
if (dated_log) {
if (dated_log->filename) {
g_free(dated_log->filename);
dated_log->filename = NULL;
}
if (dated_log->date) {
g_date_time_unref(dated_log->date);
dated_log->date = NULL;
}
free(dated_log);
}
}
static gboolean
_key_equals(void* key1, void* key2)
{
gchar* str1 = (gchar*)key1;
gchar* str2 = (gchar*)key2;
return (g_strcmp0(str1, str2) == 0);
}

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef CHATLOG_H

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -45,9 +71,7 @@
static char* _sub_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _notify_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _theme_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _spellcheck_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _autoaway_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _autoping_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _autoconnect_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _account_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _who_autocomplete(ProfWin* window, const char* const input, gboolean previous);
@@ -112,7 +136,6 @@ static char* _lastactivity_autocomplete(ProfWin* window, const char* const input
static char* _intype_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _mood_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _strophe_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _stamp_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _adhoc_cmd_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _vcard_autocomplete(ProfWin* window, const char* const input, gboolean previous);
static char* _force_encryption_autocomplete(ProfWin* window, const char* const input, gboolean previous);
@@ -144,7 +167,6 @@ static Autocomplete autoconnect_ac;
static Autocomplete wintitle_ac;
static Autocomplete theme_ac;
static Autocomplete theme_load_ac;
static Autocomplete spellcheck_ac;
static Autocomplete account_ac;
static Autocomplete account_set_ac;
static Autocomplete account_clear_ac;
@@ -275,8 +297,6 @@ static Autocomplete mood_type_ac;
static Autocomplete strophe_ac;
static Autocomplete strophe_sm_ac;
static Autocomplete strophe_verbosity_ac;
static Autocomplete stamp_ac;
static Autocomplete stamp_unset_ac;
static Autocomplete adhoc_cmd_ac;
static Autocomplete lastactivity_ac;
static Autocomplete vcard_ac;
@@ -290,8 +310,6 @@ static Autocomplete vcard_address_type_ac;
static Autocomplete force_encryption_ac;
static Autocomplete force_encryption_policy_ac;
static char* last_filepath_input = NULL;
static Autocomplete* all_acs[] = {
&commands_ac,
&who_room_ac,
@@ -314,7 +332,6 @@ static Autocomplete* all_acs[] = {
&autoconnect_ac,
&wintitle_ac,
&theme_ac,
&spellcheck_ac,
&account_ac,
&account_set_ac,
&account_clear_ac,
@@ -436,8 +453,6 @@ static Autocomplete* all_acs[] = {
&strophe_ac,
&strophe_sm_ac,
&strophe_verbosity_ac,
&stamp_ac,
&stamp_unset_ac,
&adhoc_cmd_ac,
&lastactivity_ac,
&vcard_ac,
@@ -589,11 +604,6 @@ cmd_ac_init(void)
autocomplete_add(theme_ac, "colours");
autocomplete_add(theme_ac, "properties");
autocomplete_add(spellcheck_ac, "on");
autocomplete_add(spellcheck_ac, "off");
autocomplete_add(spellcheck_ac, "list");
autocomplete_add(spellcheck_ac, "lang");
autocomplete_add(disco_ac, "info");
autocomplete_add(disco_ac, "items");
@@ -865,9 +875,8 @@ cmd_ac_init(void)
autocomplete_add(tls_property_ac, "force");
autocomplete_add(tls_property_ac, "allow");
autocomplete_add(tls_property_ac, "trust");
autocomplete_add(tls_property_ac, "direct");
autocomplete_add(tls_property_ac, "disable");
autocomplete_add(tls_property_ac, "legacy");
autocomplete_add(tls_property_ac, "disable");
autocomplete_add(auth_property_ac, "default");
autocomplete_add(auth_property_ac, "legacy");
@@ -1057,7 +1066,6 @@ cmd_ac_init(void)
autocomplete_add(autoping_ac, "set");
autocomplete_add(autoping_ac, "timeout");
autocomplete_add(autoping_ac, "warning");
autocomplete_add(plugins_ac, "install");
autocomplete_add(plugins_ac, "update");
@@ -1124,7 +1132,6 @@ cmd_ac_init(void)
autocomplete_add(statusbar_show_ac, "name");
autocomplete_add(statusbar_show_ac, "number");
autocomplete_add(statusbar_show_ac, "read");
autocomplete_add(statusbar_show_ac, "dbbackend");
autocomplete_add(statusbar_tabmode_ac, "actlist");
autocomplete_add(statusbar_tabmode_ac, "dynamic");
@@ -1139,6 +1146,9 @@ cmd_ac_init(void)
autocomplete_add(status_state_ac, "xa");
autocomplete_add(status_state_ac, "dnd");
autocomplete_add(logging_ac, "chat");
autocomplete_add(logging_ac, "group");
autocomplete_add(privacy_ac, "logging");
autocomplete_add(privacy_ac, "os");
@@ -1224,13 +1234,6 @@ cmd_ac_init(void)
autocomplete_add(strophe_verbosity_ac, "2");
autocomplete_add(strophe_verbosity_ac, "3");
autocomplete_add(stamp_ac, "outgoing");
autocomplete_add(stamp_ac, "incoming");
autocomplete_add(stamp_ac, "unset");
autocomplete_add(stamp_unset_ac, "outgoing");
autocomplete_add(stamp_unset_ac, "incoming");
autocomplete_add(mood_ac, "set");
autocomplete_add(mood_ac, "clear");
autocomplete_add(mood_ac, "on");
@@ -1409,7 +1412,6 @@ cmd_ac_init(void)
g_hash_table_insert(ac_funcs, "/alias", _alias_autocomplete);
g_hash_table_insert(ac_funcs, "/autoaway", _autoaway_autocomplete);
g_hash_table_insert(ac_funcs, "/autoconnect", _autoconnect_autocomplete);
g_hash_table_insert(ac_funcs, "/autoping", _autoping_autocomplete);
g_hash_table_insert(ac_funcs, "/avatar", _avatar_autocomplete);
g_hash_table_insert(ac_funcs, "/ban", _ban_autocomplete);
g_hash_table_insert(ac_funcs, "/blocked", _blocked_autocomplete);
@@ -1461,7 +1463,6 @@ cmd_ac_init(void)
g_hash_table_insert(ac_funcs, "/status", _status_autocomplete);
g_hash_table_insert(ac_funcs, "/statusbar", _statusbar_autocomplete);
g_hash_table_insert(ac_funcs, "/strophe", _strophe_autocomplete);
g_hash_table_insert(ac_funcs, "/stamp", _stamp_autocomplete);
g_hash_table_insert(ac_funcs, "/sub", _sub_autocomplete);
g_hash_table_insert(ac_funcs, "/subject", _subject_autocomplete);
g_hash_table_insert(ac_funcs, "/theme", _theme_autocomplete);
@@ -1606,10 +1607,6 @@ cmd_ac_remove_form_fields(DataForm* form)
char*
cmd_ac_complete(ProfWin* window, const char* const input, gboolean previous)
{
if (!input) {
return NULL;
}
char* found = NULL;
// autocomplete command
if ((strncmp(input, "/", 1) == 0) && (!strchr(input, ' '))) {
@@ -1714,74 +1711,65 @@ cmd_ac_uninit(void)
autocomplete_free(plugins_unload_ac);
autocomplete_free(plugins_reload_ac);
autocomplete_free(script_show_ac);
g_free(last_filepath_input);
last_filepath_input = NULL;
g_hash_table_destroy(ac_funcs);
ac_funcs = NULL;
}
static void
_filepath_item_free(gchar** ptr)
_filepath_item_free(char** ptr)
{
gchar* item = *ptr;
g_free(item);
char* item = *ptr;
free(item);
}
char*
cmd_ac_complete_filepath(const char* const input, char* const startstr, gboolean previous)
{
unsigned int output_off = 0;
char* tmp = NULL;
// strip command
char* inpcp_ptr = (char*)input + strlen(startstr);
while (*inpcp_ptr == ' ') {
inpcp_ptr++;
char* inpcp = (char*)input + strlen(startstr);
while (*inpcp == ' ') {
inpcp++;
}
auto_gchar gchar* inpcp = g_strdup(inpcp_ptr);
if (!inpcp) {
return NULL;
}
inpcp = strdup(inpcp);
// strip quotes
if (inpcp[0] == '"') {
char* last_quote = strrchr(inpcp + 1, '"');
if (last_quote) {
*last_quote = '\0';
if (*inpcp == '"') {
tmp = strrchr(inpcp + 1, '"');
if (tmp) {
*tmp = '\0';
}
gchar* unquoted = g_strdup(inpcp + 1);
g_free(inpcp);
inpcp = unquoted;
tmp = strdup(inpcp + 1);
free(inpcp);
inpcp = tmp;
tmp = NULL;
}
auto_gchar gchar* expanded = get_expanded_path(inpcp);
if (!expanded) {
// expand ~ to $HOME
if (inpcp[0] == '~' && inpcp[1] == '/') {
char* home = getenv("HOME");
if (!home) {
free(inpcp);
return NULL;
}
tmp = g_strdup_printf("%s/%sfoo", home, inpcp + 2);
output_off = strlen(home) + 1;
} else {
tmp = g_strdup_printf("%sfoo", inpcp);
}
free(inpcp);
if (!tmp) {
return NULL;
}
auto_gchar gchar* foofile = g_path_get_basename(expanded);
auto_gchar gchar* directory = g_path_get_dirname(expanded);
char* foofile = strdup(basename(tmp));
char* directory = strdup(dirname(tmp));
g_free(tmp);
// If the input is already a known completion, don't update to allow cycling
if (last_filepath_input && (g_strcmp0(inpcp, last_filepath_input) == 0 || autocomplete_contains(filepath_ac, inpcp))) {
return autocomplete_param_with_ac(input, startstr, filepath_ac, TRUE, previous);
}
// If the input ends with a slash, the basename will be "." or "/"
// In that case, we are looking for all files in that directory
gboolean find_all = FALSE;
size_t inpcp_len = strlen(inpcp);
if (inpcp_len == 0 || inpcp[inpcp_len - 1] == '/') {
find_all = TRUE;
}
char* last_slash = strrchr(inpcp, '/');
auto_gchar gchar* user_dir_part = NULL;
if (last_slash) {
user_dir_part = g_strndup(inpcp, last_slash - inpcp + 1);
} else {
user_dir_part = g_strdup("");
}
GArray* files = g_array_new(TRUE, FALSE, sizeof(gchar*));
GArray* files = g_array_new(TRUE, FALSE, sizeof(char*));
g_array_set_clear_func(files, (GDestroyNotify)_filepath_item_free);
DIR* d = opendir(directory);
@@ -1789,48 +1777,47 @@ cmd_ac_complete_filepath(const char* const input, char* const startstr, gboolean
struct dirent* dir;
while ((dir = readdir(d)) != NULL) {
if (strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0) {
if (strcmp(dir->d_name, ".") == 0) {
continue;
} else if (strcmp(dir->d_name, "..") == 0) {
continue;
} else if (*(dir->d_name) == '.' && *foofile != '.') {
// only show hidden files on explicit request
continue;
}
// check if it matches prefix
if (!find_all && !g_str_has_prefix(dir->d_name, foofile)) {
continue;
char* acstring = NULL;
if (output_off) {
tmp = g_strdup_printf("%s/%s", directory, dir->d_name);
if (tmp) {
acstring = g_strdup_printf("~/%s", tmp + output_off);
g_free(tmp);
}
} else if (strcmp(directory, "/") == 0) {
acstring = g_strdup_printf("/%s", dir->d_name);
} else {
acstring = g_strdup_printf("%s/%s", directory, dir->d_name);
}
if (!acstring) {
g_array_free(files, TRUE);
free(foofile);
free(directory);
return NULL;
}
// only show hidden files on explicit request
if (dir->d_name[0] == '.' && (find_all || foofile[0] != '.')) {
continue;
}
gchar* acstring = g_strdup_printf("%s%s", user_dir_part, dir->d_name);
if (acstring) {
g_array_append_val(files, acstring);
}
g_array_append_val(files, acstring);
}
closedir(d);
}
free(directory);
free(foofile);
autocomplete_update(filepath_ac, (char**)files->data);
g_array_free(files, TRUE);
g_free(last_filepath_input);
last_filepath_input = g_strdup(inpcp);
return autocomplete_param_with_ac(input, startstr, filepath_ac, TRUE, previous);
}
static char*
_spellcheck_autocomplete(ProfWin* window, const char* const input, gboolean previous)
{
char* result = NULL;
result = autocomplete_param_with_ac(input, "/spellcheck", spellcheck_ac, TRUE, previous);
return result;
}
static char*
_cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previous)
{
@@ -1843,7 +1830,7 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
"/vercheck", "/privileges", "/wrap",
"/carbons", "/slashguard", "/mam", "/silence" };
for (size_t i = 0; i < ARRAY_SIZE(boolean_choices); i++) {
for (int i = 0; i < ARRAY_SIZE(boolean_choices); i++) {
result = autocomplete_param_with_func(input, boolean_choices[i], prefs_autocomplete_boolean_choice, previous, NULL);
if (result) {
return result;
@@ -1856,7 +1843,7 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
}
gchar* history_jid_subcmds[] = { "/history verify", "/history export", "/history import" };
for (size_t i = 0; i < ARRAY_SIZE(history_jid_subcmds); i++) {
for (int i = 0; i < ARRAY_SIZE(history_jid_subcmds); i++) {
result = autocomplete_param_with_func(input, history_jid_subcmds[i], roster_barejid_autocomplete, previous, NULL);
if (result) {
return result;
@@ -1868,11 +1855,6 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
return result;
}
result = _spellcheck_autocomplete(window, input, previous);
if (result) {
return result;
}
// autocomplete nickname in chat rooms
if (window->type == WIN_MUC) {
ProfMucWin* mucwin = (ProfMucWin*)window;
@@ -1883,7 +1865,7 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
// Remove quote character before and after names when doing autocomplete
char* unquoted = strip_arg_quotes(input);
for (size_t i = 0; i < ARRAY_SIZE(nick_choices); i++) {
for (int i = 0; i < ARRAY_SIZE(nick_choices); i++) {
result = autocomplete_param_with_ac(unquoted, nick_choices[i], nick_ac, TRUE, previous);
if (result) {
free(unquoted);
@@ -1898,7 +1880,7 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
gchar* contact_choices[] = { "/msg", "/info" };
// Remove quote character before and after names when doing autocomplete
char* unquoted = strip_arg_quotes(input);
for (size_t i = 0; i < ARRAY_SIZE(contact_choices); i++) {
for (int i = 0; i < ARRAY_SIZE(contact_choices); i++) {
result = autocomplete_param_with_func(unquoted, contact_choices[i], roster_contact_autocomplete, previous, NULL);
if (result) {
free(unquoted);
@@ -1913,7 +1895,7 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
free(unquoted);
gchar* resource_choices[] = { "/caps", "/ping" };
for (size_t i = 0; i < ARRAY_SIZE(resource_choices); i++) {
for (int i = 0; i < ARRAY_SIZE(resource_choices); i++) {
result = autocomplete_param_with_func(input, resource_choices[i], roster_fulljid_autocomplete, previous, NULL);
if (result) {
return result;
@@ -1922,7 +1904,7 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
}
gchar* invite_choices[] = { "/join" };
for (size_t i = 0; i < ARRAY_SIZE(invite_choices); i++) {
for (int i = 0; i < ARRAY_SIZE(invite_choices); i++) {
result = autocomplete_param_with_func(input, invite_choices[i], muc_invites_find, previous, NULL);
if (result) {
return result;
@@ -1937,20 +1919,21 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
{ "/prefs", prefs_ac },
{ "/disco", disco_ac },
{ "/room", room_ac },
{ "/autoping", autoping_ac },
{ "/mainwin", winpos_ac },
{ "/inputwin", winpos_ac },
};
for (size_t i = 0; i < ARRAY_SIZE(ac_cmds); i++) {
for (int i = 0; i < ARRAY_SIZE(ac_cmds); i++) {
result = autocomplete_param_with_ac(input, ac_cmds[i].cmd, ac_cmds[i].completer, TRUE, previous);
if (result) {
return result;
}
}
size_t len = strlen(input);
int len = strlen(input);
char parsed[len + 1];
size_t i = 0;
int i = 0;
while (i < len) {
if (input[i] == ' ') {
break;
@@ -1961,8 +1944,7 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
}
parsed[i] = '\0';
char* (*ac_func)(ProfWin*, const char* const, gboolean) = (char* (*)(ProfWin*, const char* const, gboolean))g_hash_table_lookup(ac_funcs, parsed);
char* (*ac_func)(ProfWin*, const char* const, gboolean) = g_hash_table_lookup(ac_funcs, parsed);
if (ac_func) {
result = ac_func(window, input, previous);
if (result) {
@@ -2031,7 +2013,7 @@ _who_autocomplete(ProfWin* window, const char* const input, gboolean previous)
"/who chat", "/who away", "/who xa", "/who dnd", "/who available",
"/who unavailable" };
for (size_t i = 0; i < ARRAY_SIZE(group_commands); i++) {
for (int i = 0; i < ARRAY_SIZE(group_commands); i++) {
result = autocomplete_param_with_func(input, group_commands[i], roster_group_autocomplete, previous, NULL);
if (result) {
return result;
@@ -2353,7 +2335,7 @@ _notify_autocomplete(ProfWin* window, const char* const input, gboolean previous
gchar* boolean_choices1[] = { "/notify room current", "/notify chat current", "/notify typing current",
"/notify room text", "/notify chat text", "/notify room offline" };
for (size_t i = 0; i < ARRAY_SIZE(boolean_choices1); i++) {
for (int i = 0; i < ARRAY_SIZE(boolean_choices1); i++) {
result = autocomplete_param_with_func(input, boolean_choices1[i], prefs_autocomplete_boolean_choice, previous, NULL);
if (result) {
return result;
@@ -2386,7 +2368,7 @@ _notify_autocomplete(ProfWin* window, const char* const input, gboolean previous
}
gchar* boolean_choices2[] = { "/notify invite", "/notify sub", "/notify mention", "/notify trigger" };
for (size_t i = 0; i < ARRAY_SIZE(boolean_choices2); i++) {
for (int i = 0; i < ARRAY_SIZE(boolean_choices2); i++) {
result = autocomplete_param_with_func(input, boolean_choices2[i], prefs_autocomplete_boolean_choice, previous, NULL);
if (result) {
return result;
@@ -3832,7 +3814,7 @@ _account_autocomplete(ProfWin* window, const char* const input, gboolean previou
"/account disable", "/account rename", "/account clear", "/account remove",
"/account default set" };
for (size_t i = 0; i < ARRAY_SIZE(account_choice); i++) {
for (int i = 0; i < ARRAY_SIZE(account_choice); i++) {
found = autocomplete_param_with_func(input, account_choice[i], accounts_find_all, previous, NULL);
if (found) {
return found;
@@ -4097,6 +4079,11 @@ _logging_autocomplete(ProfWin* window, const char* const input, gboolean previou
return result;
}
result = autocomplete_param_with_func(input, "/logging chat", prefs_autocomplete_boolean_choice, previous, NULL);
if (result) {
return result;
}
result = autocomplete_param_with_ac(input, "/logging group", logging_group_ac, TRUE, previous);
return result;
}
@@ -4266,20 +4253,6 @@ _executable_autocomplete(ProfWin* window, const char* const input, gboolean prev
return result;
}
static char*
_autoping_autocomplete(ProfWin* window, const char* const input, gboolean previous)
{
char* result = NULL;
result = autocomplete_param_with_ac(input, "/autoping", autoping_ac, TRUE, previous);
if (result) {
return result;
}
result = autocomplete_param_with_func(input, "/autoping warning", prefs_autocomplete_boolean_choice, previous, NULL);
return result;
}
static char*
_lastactivity_autocomplete(ProfWin* window, const char* const input, gboolean previous)
{
@@ -4358,20 +4331,6 @@ _strophe_autocomplete(ProfWin* window, const char* const input, gboolean previou
return autocomplete_param_with_ac(input, "/strophe", strophe_ac, FALSE, previous);
}
static char*
_stamp_autocomplete(ProfWin* window, const char* const input, gboolean previous)
{
char* result = NULL;
result = autocomplete_param_with_ac(input, "/stamp unset", stamp_unset_ac, TRUE, previous);
if (result) {
return result;
}
result = autocomplete_param_with_ac(input, "/stamp", stamp_ac, TRUE, previous);
return result;
}
static char*
_adhoc_cmd_autocomplete(ProfWin* window, const char* const input, gboolean previous)
{
@@ -4396,7 +4355,7 @@ _vcard_autocomplete(ProfWin* window, const char* const input, gboolean previous)
gboolean is_num = TRUE;
if (num_args >= 2) {
for (size_t i = 0; i < strlen(args[1]); i++) {
for (int i = 0; i < strlen(args[1]); i++) {
if (!isdigit((int)args[1][i])) {
is_num = FALSE;
break;

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef COMMAND_CMD_AC_H

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -79,9 +105,6 @@ static gboolean _cmd_has_tag(Command* pcmd, const char* const tag);
* Command list
*/
#define CMD_TLS_DIRECT "Use direct TLS for the connection. It means TLS handshake is started right after TCP connection is established."
#define CMD_TLS_LEGACY "Alternative keyword for 'direct', which was created when one still thought that 'STARTTLS' is the future."
// clang-format off
static const struct cmd_t command_defs[] = {
{ CMD_PREAMBLE("/help",
@@ -124,7 +147,7 @@ static const struct cmd_t command_defs[] = {
CMD_TAG_CONNECTION)
CMD_SYN(
"/connect [<account>]",
"/connect <account> [server <server>] [port <port>] [tls force|allow|trust|direct|disable|legacy] [auth default|legacy]",
"/connect <account> [server <server>] [port <port>] [tls force|allow|trust|legacy|disable] [auth default|legacy]",
"/connect <server>")
CMD_DESC(
"Login to a chat service. "
@@ -139,9 +162,8 @@ static const struct cmd_t command_defs[] = {
{ "tls force", "Force TLS connection, and fail if one cannot be established, this is default behaviour." },
{ "tls allow", "Use TLS for the connection if it is available." },
{ "tls trust", "Force TLS connection and trust server's certificate." },
{ "tls direct", CMD_TLS_DIRECT },
{ "tls legacy", "Use legacy TLS for the connection. It means server doesn't support STARTTLS and TLS is forced just after TCP connection is established." },
{ "tls disable", "Disable TLS for the connection." },
{ "tls legacy", CMD_TLS_LEGACY },
{ "auth default", "Default authentication process." },
{ "auth legacy", "Allow legacy authentication." })
CMD_EXAMPLES(
@@ -382,17 +404,15 @@ static const struct cmd_t command_defs[] = {
CMD_DESC(
"Manage blocked users (XEP-0191), calling with no arguments shows the current list of blocked users. "
"To blog a certain user in a MUC use the following as jid: room@conference.example.org/spammy-user"
"It is also possible to block and report (XEP-0377) a user with the report-abuse and report-spam commands. "
"For spam reporting, please include the content of the spam message as evidence for the service operator.")
"It is also possible to block and report (XEP-0377) a user with the report-abuse and report-spam commands.")
CMD_ARGS(
{ "add [<jid>]", "Block the specified Jabber ID. If in a chat window and no jid is specified, the current recipient will be blocked." },
{ "remove <jid>", "Remove the specified Jabber ID from the blocked list." },
{ "report-abuse <jid> [<message>]", "Report a user for abuse with an optional description of the behavior." },
{ "report-spam <jid> [<message>]", "Report a user for spam, including the actual spam message as evidence." })
{ "report-abuse <jid> [<message>]", "Report the jid as abuse with an optional message to the service operator." },
{ "report-spam <jid> [<message>]", "Report the jid as spam with an optional message to the service operator." })
CMD_EXAMPLES(
"/blocked add hel@helheim.edda",
"/blocked report-abuse hel@helheim.edda Harassing me in MUC",
"/blocked report-spam spambot@example.com \"You won a free prize!\"",
"/blocked report-spam hel@helheim.edda Very annoying guy",
"/blocked add profanity@rooms.dismail.de/spammy-user")
},
@@ -1269,8 +1289,8 @@ static const struct cmd_t command_defs[] = {
CMD_TAGS(
CMD_TAG_UI)
CMD_SYN(
"/statusbar show name|number|read|dbbackend",
"/statusbar hide name|number|read|dbbackend",
"/statusbar show name|number|read",
"/statusbar hide name|number|read",
"/statusbar maxtabs <value>",
"/statusbar tablen <value>",
"/statusbar tabmode default|dynamic|actlist",
@@ -1288,7 +1308,6 @@ static const struct cmd_t command_defs[] = {
{ "show|hide name", "Show or hide names in tabs." },
{ "show|hide number", "Show or hide numbers in tabs." },
{ "show|hide read", "Show or hide inactive tabs." },
{ "show|hide dbbackend", "Show or hide the database backend indicator [sqlite] or [flatfile]." },
{ "self user|barejid|fulljid", "Show account user name, barejid, fulljid as status bar title." },
{ "self off", "Disable showing self as status bar title." },
{ "chat user|jid", "Show users name, or fulljid. Change needs a redraw/restart to take effect." },
@@ -1453,23 +1472,6 @@ static const struct cmd_t command_defs[] = {
{ "on|off", "Enable or disable splash logo." })
},
{ CMD_PREAMBLE("/spellcheck",
parse_args, 1, 2, &cons_spellcheck_setting)
CMD_MAINFUNC(cmd_spellcheck)
CMD_TAGS(
CMD_TAG_UI)
CMD_SYN(
"/spellcheck on|off",
"/spellcheck list",
"/spellcheck lang <locale>")
CMD_DESC(
"Enable or disable spellchecking, or set the language.")
CMD_ARGS(
{ "on|off", "Enable or disable spellchecking." },
{ "list", "List available dictionaries recognized by Enchant." },
{ "lang <locale>", "Set the spellcheck language (en_US)." })
},
{ CMD_PREAMBLE("/autoconnect",
parse_args, 1, 2, &cons_autoconnect_setting)
CMD_MAINFUNC(cmd_autoconnect)
@@ -1657,14 +1659,23 @@ static const struct cmd_t command_defs[] = {
},
{ CMD_PREAMBLE("/logging",
parse_args, 0, 0, NULL)
parse_args, 2, 3, &cons_logging_setting)
CMD_MAINFUNC(cmd_logging)
CMD_TAGS(
CMD_TAG_CHAT)
CMD_SYN(
"/logging")
"/logging chat|group on|off")
CMD_DESC(
"Deprecated. Use '/history' instead.")
"Configure chat logging. "
"Switch logging on or off. "
"Chat logging will be enabled if /history is set to on. "
"When disabling this option, /history will also be disabled. ")
CMD_ARGS(
{ "chat on|off", "Enable/Disable regular chat logging." },
{ "group on|off", "Enable/Disable groupchat (room) logging." })
CMD_EXAMPLES(
"/logging chat on",
"/logging group off")
},
{ CMD_PREAMBLE("/states",
@@ -1877,16 +1888,15 @@ static const struct cmd_t command_defs[] = {
"/history export [<jid>]",
"/history import [<jid>]")
CMD_DESC(
"Enable or disable chat history. "
"When on, messages are persisted via the active database backend and shown in chat windows. "
"When off, persistence stops and old history is hidden on chat-window open. "
"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 'backend' to show the active database backend. "
"Use 'switch' to change the active database backend at runtime without reconnecting. "
"Use 'verify' to check integrity of stored message history. "
"Use 'export' to copy messages from SQLite to flat-file format, or 'import' to copy from flat-file to SQLite. "
"Both export and import merge with existing data (duplicates are skipped).")
CMD_ARGS(
{ "on|off", "Enable or disable persistence and showing chat history." },
{ "on|off", "Enable or disable showing chat history." },
{ "backend", "Show the name of the active database backend." },
{ "switch sqlite|flatfile", "Switch the active database backend at runtime." },
{ "verify [<jid>]", "Verify integrity of message history. Optionally specify a JID to check only one contact." },
@@ -1964,14 +1974,12 @@ static const struct cmd_t command_defs[] = {
CMD_TAG_CONNECTION)
CMD_SYN(
"/autoping set <seconds>",
"/autoping timeout <seconds>",
"/autoping warning on|off")
"/autoping timeout <seconds>")
CMD_DESC(
"Set the interval between sending ping requests to the server to ensure the connection is kept alive.")
CMD_ARGS(
{ "set <seconds>", "Number of seconds between sending pings, a value of 0 disables autoping." },
{ "timeout <seconds>", "Seconds to wait for autoping responses, after which the connection is considered broken." },
{ "warning on|off", "Enable or disable autoping availability warning." })
{ "timeout <seconds>", "Seconds to wait for autoping responses, after which the connection is considered broken." })
},
{ CMD_PREAMBLE("/ping",
@@ -2078,7 +2086,7 @@ static const struct cmd_t command_defs[] = {
"/account set <account> pgpkeyid <pgpkeyid>",
"/account set <account> startscript <script>",
"/account set <account> clientid \"<name> <version>\"",
"/account set <account> tls force|allow|trust|direct|disable|legacy",
"/account set <account> tls force|allow|trust|legacy|disable",
"/account set <account> auth default|legacy",
"/account set <account> theme <theme>",
"/account set <account> session_alarm <max_sessions>",
@@ -2124,9 +2132,8 @@ static const struct cmd_t command_defs[] = {
{ "set <account> tls force", "Force TLS connection, and fail if one cannot be established, this is default behaviour." },
{ "set <account> tls allow", "Use TLS for the connection if it is available." },
{ "set <account> tls trust", "Force TLS connection and trust server's certificate." },
{ "set <account> tls direct", CMD_TLS_DIRECT },
{ "set <account> tls legacy", "Use legacy TLS for the connection. It means server doesn't support STARTTLS and TLS is forced just after TCP connection is established." },
{ "set <account> tls disable", "Disable TLS for the connection." },
{ "set <account> tls legacy", CMD_TLS_LEGACY },
{ "set <account> auth default", "Use default authentication process." },
{ "set <account> auth legacy", "Allow legacy authentication." },
{ "set <account> theme <theme>", "Set the UI theme for the account." },
@@ -2153,7 +2160,6 @@ static const struct cmd_t command_defs[] = {
"/account set me status dnd",
"/account set me dnd -1",
"/account set me clientid \"Profanity 0.42 (Dev)\"",
"/account set me eval_password \"pass \\\"Test Accounts/my user\\\"\"",
"/account rename me chattyme",
"/account clear me pgpkeyid")
},
@@ -2337,18 +2343,13 @@ static const struct cmd_t command_defs[] = {
"/omemo clear_device_list",
"/omemo qrcode")
CMD_DESC(
"OMEMO commands to manage keys, and perform encryption during chat sessions.\n"
"The title bar will show the OMEMO session status:\n"
"[OMEMO][trusted] - All active devices for the contact are trusted.\n"
"[OMEMO][untrusted] - One or more active devices for the contact are untrusted.\n")
"OMEMO commands to manage keys, and perform encryption during chat sessions.")
CMD_ARGS(
{ "gen", "Generate OMEMO cryptographic materials for current account." },
{ "start [<contact>]", "Start an OMEMO session with contact, or current recipient if omitted." },
{ "end", "End the current OMEMO session." },
{ "log on|off", "Enable or disable plaintext logging of OMEMO encrypted messages." },
{ "log redact", "Log OMEMO encrypted messages, but replace the contents with [redacted]." },
{ "trust [<contact>] <fp>", "Trust a fingerprint for a contact, or current recipient if omitted. If all active devices are trusted, the title bar will show [trusted]. Otherwise, it will show [untrusted]." },
{ "untrust [<contact>] <fp>","Untrust a fingerprint for a contact, or current recipient if omitted." },
{ "fingerprint [<contact>]", "Show contact's fingerprints, or current recipient's if omitted." },
{ "char <char>", "Set the character to be displayed next to OMEMO encrypted messages." },
{ "trustmode manual", "Set the global OMEMO trust mode to manual, OMEMO keys has to be trusted manually." },
@@ -2367,15 +2368,6 @@ static const struct cmd_t command_defs[] = {
"/omemo char *")
},
{ CMD_PREAMBLE("/changes",
parse_args, 0, 0, NULL)
CMD_MAINFUNC(cmd_changes)
CMD_SYN(
"/changes")
CMD_DESC(
"Show changes from saved configuration file.")
},
{ CMD_PREAMBLE("/save",
parse_args, 0, 0, NULL)
CMD_MAINFUNC(cmd_save)
@@ -2434,7 +2426,7 @@ static const struct cmd_t command_defs[] = {
"/stamp unset outgoing|incoming")
CMD_DESC("Set chat window stamp. "
"The format of line in the chat window is: \"<timestamp> <encryption sign> <stamp> <message>\" "
"where <stamp> is \"me:\" for outgoing messages or \"username@server/resource\" for incoming messages. "
"where <stamp> is \"me:\" for incoming messages or \"username@server/resource\" for outgoing messages. "
"This command allows to change <stamp> value.")
CMD_ARGS({ "outgoing", "Set outgoing stamp" },
{ "incoming", "Set incoming stamp"},
@@ -2640,8 +2632,7 @@ static const struct cmd_t command_defs[] = {
CMD_DESC(
"Spawn external editor to edit message. "
"After editing the inputline may appear empty. Press enter to send the text anyways. "
"Use /executable to set your favourite editor. "
"Ctrl-Z in the editor aborts the session and returns to Profanity." )
"Use /executable to set your favourite editor." )
},
{ CMD_PREAMBLE("/correct-editor",
@@ -2675,7 +2666,7 @@ static const struct cmd_t command_defs[] = {
CMD_TAGS(
CMD_TAG_CONNECTION)
CMD_SYN(
"/register <username> <server> [port <port>] [tls force|allow|trust|direct|disable|legacy]")
"/register <username> <server> [port <port>] [tls force|allow|trust|legacy|disable]")
CMD_DESC(
"Register an account on a server.")
CMD_ARGS(
@@ -2685,9 +2676,8 @@ static const struct cmd_t command_defs[] = {
{ "tls force", "Force TLS connection, and fail if one cannot be established. This is the default behavior." },
{ "tls allow", "Use TLS for the connection if it is available." },
{ "tls trust", "Force TLS connection and trust the server's certificate." },
{ "tls direct", CMD_TLS_DIRECT },
{ "tls disable", "Disable TLS for the connection." },
{ "tls legacy", CMD_TLS_LEGACY })
{ "tls legacy", "Use legacy TLS for the connection. This forces TLS just after the TCP connection is established. Use when a server doesn't support STARTTLS." },
{ "tls disable", "Disable TLS for the connection." })
CMD_EXAMPLES(
"/register odin valhalla.edda ",
"/register freyr vanaheimr.edda port 5678",
@@ -2751,7 +2741,7 @@ 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 backend. 'on' uses the SQLite database (default). 'flatfile' stores messages as plain-text files under ~/.local/share/profanity/flatlog/ that can be edited with any text editor. 'off' disables logging entirely. 'redact' keeps logging but replaces every message body with '[REDACTED]'. Note: 'off' may have side effects such as not being able to decrypt OMEMO messages received later via MAM. Backend changes ('on' / 'flatfile') take effect immediately when connected, otherwise on next connect." },
{ "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." },
{ "os on|off", "Choose whether to include the OS name if a user asks for software information (XEP-0092)." }
)
CMD_EXAMPLES(
@@ -2833,7 +2823,7 @@ static const struct cmd_t command_defs[] = {
{ "set provider <name> <url>", "Add or update a provider with custom API endpoint" },
{ "set token <provider> <token>", "Set API token for a provider (e.g., openai, perplexity)" },
{ "set default-model <provider> <model>", "Set default model for a provider" },
{ "set custom <provider> <setting> <value>", "Set provider-level setting (e.g., temperature, max_tokens)" },
{ "set custom <provider> <setting> <value>", "Set provider-level setting (e.g., tools, search)" },
{ "remove provider <name>", "Remove a custom provider" },
{ "providers", "List configured providers with full details" },
{ "start <provider> [<model>]", "Start new AI chat (space-separated, uses defaults if omitted)" },
@@ -2846,7 +2836,7 @@ static const struct cmd_t command_defs[] = {
"/ai set token perplexity pplx-xxx",
"/ai set provider custom https://my-api.com/v1/chat/completions",
"/ai set default-model perplexity sonar",
"/ai set custom perplexity temperature 0.7",
"/ai set custom perplexity tools enabled",
"/ai remove provider custom",
"/ai start",
"/ai start perplexity",
@@ -2895,7 +2885,7 @@ _cmd_index(const Command* cmd)
g_string_free(index_source, TRUE);
GString* index = g_string_new("");
for (guint i = 0; i < g_strv_length(tokens); i++) {
for (int i = 0; i < g_strv_length(tokens); i++) {
index = g_string_append(index, tokens[i]);
index = g_string_append(index, " ");
}
@@ -3072,11 +3062,16 @@ command_docgen(void)
cmds = g_list_insert_sorted(cmds, (gpointer)pcmd, (GCompareFunc)_cmp_command);
}
auto_FILE FILE* toc_fragment = fopen("toc_fragment.html", "w");
auto_FILE FILE* main_fragment = fopen("main_fragment.html", "w");
if (!toc_fragment || !main_fragment) {
log_error("command_docgen(): unable to open html files: %s", g_strerror(errno));
FILE* toc_fragment = fopen("toc_fragment.html", "w");
if (!toc_fragment) {
log_error("command_docgen(): unable to open toc_fragment.html for writing: %s", g_strerror(errno));
g_list_free(cmds);
return;
}
FILE* main_fragment = fopen("main_fragment.html", "w");
if (!main_fragment) {
log_error("command_docgen(): unable to open main_fragment.html for writing: %s", g_strerror(errno));
fclose(toc_fragment);
g_list_free(cmds);
return;
}
@@ -3147,6 +3142,8 @@ command_docgen(void)
fputs("</ul></ul>\n", toc_fragment);
fclose(toc_fragment);
fclose(main_fragment);
printf("\nProcessed %u commands.\n\n", g_list_length(cmds));
g_list_free(cmds);
}

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#ifndef COMMAND_CMD_DEFS_H

File diff suppressed because it is too large Load Diff

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#ifndef COMMAND_CMD_FUNCS_H
@@ -103,7 +129,6 @@ gboolean cmd_bookmark_ignore(ProfWin* window, const char* const command, gchar**
gboolean cmd_roster(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_software(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_splash(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_spellcheck(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_states(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_status_get(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_status_set(ProfWin* window, const char* const command, gchar** args);
@@ -217,7 +242,6 @@ gboolean cmd_omemo_policy(ProfWin* window, const char* const command, gchar** ar
gboolean cmd_omemo_clear_device_list(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_omemo_qrcode(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_changes(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_save(ProfWin* window, const char* const command, gchar** args);
gboolean cmd_reload(ProfWin* window, const char* const command, gchar** args);

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -38,7 +64,6 @@
#include "log.h"
#include "common.h"
#include "config/files.h"
#include "ui/ui.h"
#ifdef HAVE_GIT_VERSION
#include "gitversion.h"
@@ -136,27 +161,20 @@ auto_close_FILE(FILE** fd)
log_error("%s", g_strerror(errno));
}
void
auto_free_gerror(GError** err)
{
if (err == NULL)
return;
PROF_GERROR_FREE(*err);
}
static gboolean
_load_keyfile(prof_keyfile_t* keyfile)
{
auto_gerror GError* error = NULL;
GError* error = NULL;
keyfile->keyfile = g_key_file_new();
if (g_key_file_load_from_file(keyfile->keyfile, keyfile->filename, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error)) {
return TRUE;
} else if (error && error->code != G_FILE_ERROR_NOENT) {
} else if (error->code != G_FILE_ERROR_NOENT) {
log_warning("[Keyfile] error loading %s: %s", keyfile->filename, error->message);
g_error_free(error);
} else {
log_warning("[Keyfile] no such file: %s", keyfile->filename);
g_error_free(error);
}
return FALSE;
}
@@ -194,9 +212,10 @@ load_custom_keyfile(prof_keyfile_t* keyfile, gchar* filename)
gboolean
save_keyfile(prof_keyfile_t* keyfile)
{
auto_gerror GError* error = NULL;
GError* error = NULL;
if (!g_key_file_save_to_file(keyfile->keyfile, keyfile->filename, &error)) {
log_error("[Keyfile]: saving file %s failed! %s", STR_MAYBE_NULL(keyfile->filename), PROF_GERROR_MESSAGE(error));
log_error("[Keyfile]: saving file %s failed! %s", keyfile->filename, error->message);
g_error_free(error);
return FALSE;
}
g_chmod(keyfile->filename, S_IRUSR | S_IWUSR);
@@ -235,8 +254,11 @@ copy_file(const char* const sourcepath, const char* const targetpath, const gboo
{
GFile* source = g_file_new_for_path(sourcepath);
GFile* dest = g_file_new_for_path(targetpath);
GError* error = NULL;
GFileCopyFlags flags = overwrite_existing ? G_FILE_COPY_OVERWRITE : G_FILE_COPY_NONE;
gboolean success = g_file_copy(source, dest, flags, NULL, NULL, NULL, NULL);
gboolean success = g_file_copy(source, dest, flags, NULL, NULL, NULL, &error);
if (error != NULL)
g_error_free(error);
g_object_unref(source);
g_object_unref(dest);
return success;
@@ -294,7 +316,7 @@ str_replace(const char* string, const char* substr,
wr = newstr;
while ((tok = strstr(head, substr))) {
size_t l = g_diff_to_gsize(tok, head);
size_t l = tok - head;
memcpy(wr, head, l);
wr += l;
memcpy(wr, replacement, len_replacement);
@@ -309,103 +331,33 @@ str_replace(const char* string, const char* substr,
return newstr;
}
gsize
g_diff_to_gsize(const void* end, const void* start)
{
if (end < start) {
log_error("g_diff_to_gsize: end < start (%p < %p)", end, start);
return 0;
}
return (gsize)((const char*)end - (const char*)start);
}
gboolean
strtoi_range(const char* str, int* saveptr, int min, int max, gchar** err_msg)
{
char* ptr;
long lval;
int val;
if (str == NULL) {
if (err_msg)
*err_msg = g_strdup_printf("'str' input pointer can not be NULL");
return FALSE;
}
errno = 0;
lval = strtol(str, &ptr, 0);
val = (int)strtol(str, &ptr, 0);
if (errno != 0 || *str == '\0' || *ptr != '\0') {
if (err_msg)
*err_msg = g_strdup_printf("Could not convert \"%s\" to a number.", str);
return FALSE;
} else if (lval < (long)min || lval > (long)max) {
} else if (val < min || val > max) {
if (err_msg)
*err_msg = g_strdup_printf("Value %s out of range. Must be in %d..%d.", str, min, max);
return FALSE;
}
*saveptr = (int)lval;
*saveptr = val;
return TRUE;
}
gboolean
string_matches_one_of(const char* what, const char* is, gboolean is_can_be_null, const char* first, ...)
{
gboolean ret = FALSE;
va_list ap;
const char* cur = first;
if (!is)
return is_can_be_null;
va_start(ap, first);
while (cur != NULL) {
if (g_strcmp0(is, cur) == 0) {
ret = TRUE;
break;
}
cur = va_arg(ap, const char*);
}
va_end(ap);
if (!ret && what) {
cons_show("Invalid %s: '%s'", what, is);
char errmsg[256] = { 0 };
size_t sz = 0;
int s = snprintf(errmsg, sizeof(errmsg) - sz, "%s must be one of:", what);
if (s < 0 || (size_t)s + sz >= sizeof(errmsg))
return ret;
sz += (size_t)s;
cur = first;
va_start(ap, first);
while (cur != NULL) {
const char* next = va_arg(ap, const char*);
if (next) {
s = snprintf(errmsg + sz, sizeof(errmsg) - sz, " '%s',", cur);
} else {
/* remove last ',' */
sz--;
errmsg[sz] = '\0';
s = snprintf(errmsg + sz, sizeof(errmsg) - sz, " or '%s'.", cur);
}
if (s < 0 || (size_t)s + sz >= sizeof(errmsg)) {
log_debug("Error message too long or some other error occurred (%d).", s);
s = -1;
break;
}
sz += (size_t)s;
cur = next;
}
va_end(ap);
if (s > 0)
cons_show("%s", errmsg);
}
return ret;
}
gboolean
valid_tls_policy_option(const char* is)
{
return string_matches_one_of("TLS policy", is, TRUE, "force", "allow", "trust", "disable", "legacy", "direct", NULL);
}
int
utf8_display_len(const char* const str)
{
@@ -428,33 +380,6 @@ utf8_display_len(const char* const str)
return len;
}
/**
* Removes illegal XML 1.0 characters from a string.
*
* This function creates a new string that excludes characters in the range
* U+0000 to U+001F, except for U+0009 (TAB), U+000A (LF), and U+000D (CR).
*/
gchar*
str_xml_sanitize(const char* const str)
{
if (str == NULL) {
return NULL;
}
GString* sanitized = g_string_new_len(NULL, (gssize)strlen(str));
const char* curr = str;
while (*curr != '\0') {
gunichar c = g_utf8_get_char(curr);
if ((c >= 0x20) || (c == 0x09) || (c == 0x0A) || (c == 0x0D)) {
g_string_append_unichar(sanitized, c);
}
curr = g_utf8_next_char(curr);
}
return g_string_free(sanitized, FALSE);
}
char*
release_get_latest(void)
{
@@ -482,15 +407,11 @@ release_get_latest(void)
}
gboolean
release_is_new(const char* const curr_version, const char* const found_version)
release_is_new(char* found_version)
{
if (!curr_version || !found_version) {
return FALSE;
}
int curr_maj, curr_min, curr_patch, found_maj, found_min, found_patch;
int parse_curr = sscanf(curr_version, "%d.%d.%d", &curr_maj, &curr_min,
int parse_curr = sscanf(PACKAGE_VERSION, "%d.%d.%d", &curr_maj, &curr_min,
&curr_patch);
int parse_found = sscanf(found_version, "%d.%d.%d", &found_maj, &found_min,
&found_patch);
@@ -553,32 +474,23 @@ _get_file_or_linked(gchar* loc)
char*
strip_arg_quotes(const char* const input)
{
if (input == NULL) {
return NULL;
}
char* unquoted = strdup(input);
// Unescape and strip quotes
GString* unescaped = g_string_new("");
for (const char* p = input; *p; p++) {
if (*p == '\\' && (*(p + 1) != '\0')) {
p++;
g_string_append_c(unescaped, *p);
} else if (*p == '"') {
// Only strip if it's the first char or preceded by a space
if (p == input || *(p - 1) == ' ') {
continue;
}
// Or if it's the last char
if (*(p + 1) == '\0') {
continue;
}
g_string_append_c(unescaped, *p);
} else {
g_string_append_c(unescaped, *p);
// Remove starting quote if it exists
if (strchr(unquoted, '"')) {
if (strchr(unquoted, ' ') + 1 == strchr(unquoted, '"')) {
memmove(strchr(unquoted, '"'), strchr(unquoted, '"') + 1, strchr(unquoted, '\0') - strchr(unquoted, '"'));
}
}
return g_string_free(unescaped, FALSE);
// Remove ending quote if it exists
if (strchr(unquoted, '"')) {
if (strchr(unquoted, '\0') - 1 == strchr(unquoted, '"')) {
memmove(strchr(unquoted, '"'), strchr(unquoted, '"') + 1, strchr(unquoted, '\0') - strchr(unquoted, '"'));
}
}
return unquoted;
}
gboolean
@@ -602,48 +514,36 @@ is_notify_enabled(void)
GSList*
prof_occurrences(const char* const needle, const char* const haystack, int offset, gboolean whole_word, GSList** result)
{
if (needle == NULL || haystack == NULL || *needle == '\0') {
if (needle == NULL || haystack == NULL) {
return *result;
}
size_t needle_len = strlen(needle);
gchar* p = g_utf8_offset_to_pointer(haystack, offset);
GSList* matches = NULL;
while (p) {
if (g_str_has_prefix(p, needle)) {
do {
gchar* haystack_curr = g_utf8_offset_to_pointer(haystack, offset);
if (g_str_has_prefix(haystack_curr, needle)) {
if (whole_word) {
gunichar before = 0;
gchar* haystack_before_ch = g_utf8_find_prev_char(haystack, p);
gchar* haystack_before_ch = g_utf8_find_prev_char(haystack, haystack_curr);
if (haystack_before_ch) {
before = g_utf8_get_char(haystack_before_ch);
}
gunichar after = 0;
gchar* haystack_after_ch = p + needle_len;
if (*haystack_after_ch != '\0') {
gchar* haystack_after_ch = haystack_curr + strlen(needle);
if (haystack_after_ch[0] != '\0') {
after = g_utf8_get_char(haystack_after_ch);
}
if (!g_unichar_isalnum(before) && !g_unichar_isalnum(after)) {
matches = g_slist_prepend(matches, GINT_TO_POINTER(offset));
*result = g_slist_append(*result, GINT_TO_POINTER(offset));
}
} else {
matches = g_slist_prepend(matches, GINT_TO_POINTER(offset));
*result = g_slist_append(*result, GINT_TO_POINTER(offset));
}
}
if (*p == '\0') {
break;
}
p = g_utf8_next_char(p);
offset++;
}
if (matches) {
*result = g_slist_concat(*result, g_slist_reverse(matches));
}
} while (g_strcmp0(g_utf8_offset_to_pointer(haystack, offset), "\0") != 0);
return *result;
}
@@ -699,19 +599,19 @@ get_file_paths_recursive(const char* path, GSList** contents)
}
}
gchar*
get_random_string(size_t length)
char*
get_random_string(int length)
{
GRand* prng;
gchar* rand;
gchar alphabet[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
char* rand;
char alphabet[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
int endrange = sizeof(alphabet) - 1;
rand = g_malloc0(length + 1);
rand = calloc(length + 1, sizeof(char));
prng = g_rand_new();
for (size_t i = 0; i < length; i++) {
for (int i = 0; i < length; i++) {
rand[i] = alphabet[g_rand_int_range(prng, 0, endrange)];
}
g_rand_free(prng);
@@ -734,7 +634,7 @@ get_mentions(gboolean whole_word, gboolean case_sensitive, const char* const mes
gboolean
call_external(gchar** argv)
{
auto_gerror GError* spawn_error = NULL;
GError* spawn_error;
gboolean is_successful;
GSpawnFlags flags = G_SPAWN_SEARCH_PATH | G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL;
@@ -747,7 +647,9 @@ call_external(gchar** argv)
&spawn_error);
if (!is_successful) {
auto_gchar gchar* cmd = g_strjoinv(" ", argv);
log_error("Spawning '%s' failed with error '%s'", cmd, PROF_GERROR_MESSAGE(spawn_error));
log_error("Spawning '%s' failed with error '%s'", cmd, spawn_error ? spawn_error->message : "Unknown, spawn_error is NULL");
g_error_free(spawn_error);
}
return is_successful;
@@ -758,17 +660,17 @@ call_external(gchar** argv)
*
* This function constructs an argument vector (argv) based on the provided template string, replacing placeholders ("%u" and "%p") with the provided URL and filename, respectively.
*
* @param template_fmt The template string with placeholders.
* @param url The URL to replace "%u" (or NULL to skip).
* @param filename The filename to replace "%p" (or NULL to skip).
* @return The constructed argument vector (argv) as a null-terminated array of strings.
* @param template The template string with placeholders.
* @param url The URL to replace "%u" (or NULL to skip).
* @param filename The filename to replace "%p" (or NULL to skip).
* @return The constructed argument vector (argv) as a null-terminated array of strings.
*
* @note Remember to free the returned argument vector using `auto_gcharv` or `g_strfreev()`.
*/
gchar**
format_call_external_argv(const char* template_fmt, const char* url, const char* filename)
format_call_external_argv(const char* template, const char* url, const char* filename)
{
gchar** argv = g_strsplit(template_fmt, " ", 0);
gchar** argv = g_strsplit(template, " ", 0);
guint num_args = 0;
while (argv[num_args]) {
@@ -777,7 +679,7 @@ format_call_external_argv(const char* template_fmt, const char* url, const char*
argv[num_args] = g_strdup(url);
} else if (0 == g_strcmp0(argv[num_args], "%p") && filename != NULL) {
g_free(argv[num_args]);
argv[num_args] = g_strdup(filename);
argv[num_args] = strdup(filename);
}
num_args++;
}
@@ -809,7 +711,7 @@ _unique_filename(const char* filename)
return unique;
}
static gboolean
static bool
_has_directory_suffix(const char* path)
{
return (g_str_has_suffix(path, ".")
@@ -907,20 +809,6 @@ unique_filename_from_url(const char* url, const char* path)
return unique_filename;
}
/* This returns a timestamp formatted in ISO8601 format.
* Either it returns the current time if `dt` is NULL, or
* it returns the formatted time value passed in `dt`.
*/
gchar*
prof_date_time_format_iso8601(GDateTime* dt)
{
GDateTime* dt_ = (dt == NULL) ? g_date_time_new_now_local() : dt;
gchar* ret = g_date_time_format_iso8601(dt_);
if (dt == NULL)
g_date_time_unref(dt_);
return ret;
}
/* build profanity version string.
* example: 0.13.1dev.master.69d8c1f9
*/

View File

@@ -4,7 +4,36 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
* @file common.h
*
* @brief Common utilities for the project.
*/
#ifndef COMMON_H
@@ -83,22 +112,12 @@ void auto_close_gfd(gint* fd);
void auto_close_FILE(FILE** fd);
void auto_free_gerror(GError** err);
#define auto_gerror __attribute__((__cleanup__(auto_free_gerror)))
#if defined(__OpenBSD__)
#define STR_MAYBE_NULL(p) (p) ?: "(null)"
#else
#define STR_MAYBE_NULL(p) (p)
#endif
#define PROF_GERROR_MESSAGE(err) (err) ? (err)->message : "error message missing"
#define PROF_GERROR_FREE(err) \
do { \
if (err) \
g_error_free(err); \
} while (0)
typedef struct prof_keyfile_t
{
gchar* filename;
@@ -152,21 +171,18 @@ typedef enum {
RESOURCE_XA
} resource_presence_t;
extern gboolean background_mode;
gboolean string_to_verbosity(const char* cmd, int* verbosity, gchar** err_msg);
gboolean create_dir(const char* name);
gboolean copy_file(const char* const src, const char* const target, const gboolean overwrite_existing);
char* str_replace(const char* string, const char* substr, const char* replacement);
gboolean strtoi_range(const char* str, int* saveptr, int min, int max, char** err_msg);
gsize g_diff_to_gsize(const void* end, const void* start);
int utf8_display_len(const char* const str);
gchar* str_xml_sanitize(const char* const str);
gboolean string_matches_one_of(const char* what, const char* is, gboolean is_can_be_null, const char* first, ...) __attribute__((sentinel));
gboolean valid_tls_policy_option(const char* is);
char* release_get_latest(void);
gboolean release_is_new(const char* const curr_version, const char* const found_version);
gboolean release_is_new(char* found_version);
char* strip_arg_quotes(const char* const input);
gboolean is_notify_enabled(void);
@@ -179,18 +195,16 @@ int is_regular_file(const char* path);
int is_dir(const char* path);
void get_file_paths_recursive(const char* directory, GSList** contents);
gchar* get_random_string(size_t length);
char* get_random_string(int length);
gboolean call_external(gchar** argv);
gchar** format_call_external_argv(const char* template_fmt, const char* url, const char* filename);
gchar** format_call_external_argv(const char* template, const char* url, const char* filename);
gchar* unique_filename_from_url(const char* url, const char* path);
gchar* get_expanded_path(const char* path);
char* basename_from_url(const char* url);
gchar* prof_date_time_format_iso8601(GDateTime* dt);
gchar* prof_get_version(void);
void prof_add_shutdown_routine(void (*routine)(void));

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -13,7 +39,6 @@
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <sys/wait.h>
#include <glib.h>
@@ -34,7 +59,7 @@ account_new(gchar* name, gchar* jid, gchar* password, gchar* eval_password, gboo
gchar* startscript, gchar* theme, gchar* tls_policy, gchar* auth_policy,
gchar* client, int max_sessions)
{
ProfAccount* new_account = g_new0(ProfAccount, 1);
ProfAccount* new_account = calloc(1, sizeof(ProfAccount));
new_account->name = name;
@@ -119,13 +144,13 @@ account_new(gchar* name, gchar* jid, gchar* password, gchar* eval_password, gboo
return new_account;
}
gchar*
char*
account_create_connect_jid(ProfAccount* account)
{
if (account->resource) {
return create_fulljid(account->jid, account->resource);
} else {
return g_strdup(account->jid);
return strdup(account->jid);
}
}
@@ -135,41 +160,53 @@ account_eval_password(ProfAccount* account)
assert(account != NULL);
assert(account->eval_password != NULL);
gchar* stdout_buf = NULL;
GError* error = NULL;
gint exit_status = 0;
gchar** argv = NULL;
errno = 0;
if (!g_shell_parse_argv(account->eval_password, NULL, &argv, &error)) {
log_error("Failed to parse `eval_password` command: %s", error->message);
g_error_free(error);
return FALSE;
}
if (!g_spawn_sync(NULL, argv, NULL, G_SPAWN_SEARCH_PATH | G_SPAWN_CHILD_INHERITS_STDIN, NULL, NULL, &stdout_buf, NULL, &exit_status, &error)) {
log_error("Failed to execute `eval_password` command: %s", error->message);
g_strfreev(argv);
g_error_free(error);
return FALSE;
}
g_strfreev(argv);
if (WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == 0) {
account->password = stdout_buf;
g_strstrip(account->password);
if (account->password[0] == '\0') {
log_error("Empty password returned by `eval_password` command.");
g_free(account->password);
account->password = NULL;
return FALSE;
FILE* stream = popen(account->eval_password, "r");
if (stream == NULL) {
const char* errmsg = strerror(errno);
if (errmsg) {
log_error("Could not execute `eval_password` command (%s).",
errmsg);
} else {
log_error("Failed to allocate memory for `eval_password` command.");
}
return TRUE;
} else {
log_error("`eval_password` command failed with status %d", exit_status);
g_free(stdout_buf);
return FALSE;
}
account->password = g_malloc(READ_BUF_SIZE);
if (!account->password) {
log_error("Failed to allocate enough memory to read `eval_password` "
"output.");
return FALSE;
}
account->password = fgets(account->password, READ_BUF_SIZE, stream);
if (!account->password) {
log_error("Failed to read password from stream.");
return FALSE;
}
int exit_status = pclose(stream);
if (exit_status > 0) {
log_error("Command for `eval_password` returned error status (%d).",
exit_status);
return FALSE;
} else if (exit_status < 0) {
log_error("Failed to close stream for `eval_password` command output "
"(%s).",
strerror(errno));
return FALSE;
};
// Remove leading and trailing whitespace from output.
g_strstrip(account->password);
if (!account->password) {
log_error("Empty password returned by `eval_password` command.");
return FALSE;
}
return TRUE;
}
void

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef CONFIG_ACCOUNT_H
@@ -58,7 +84,7 @@ ProfAccount* account_new(gchar* name, gchar* jid, gchar* password, gchar* eval_p
GList* ox_enabled, GList* pgp_enabled, gchar* pgp_keyid,
gchar* startscript, gchar* theme, gchar* tls_policy, gchar* auth_policy,
gchar* client, int max_sessions);
gchar* account_create_connect_jid(ProfAccount* account);
char* account_create_connect_jid(ProfAccount* account);
gboolean account_eval_password(ProfAccount* account);
void account_free(ProfAccount* account);
void account_set_server(ProfAccount* account, const char* server);

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -33,74 +59,7 @@ static GKeyFile* accounts;
static Autocomplete all_ac;
static Autocomplete enabled_ac;
static gchar*
_sanitize_account_name(const char* const name)
{
if (!name) {
return NULL;
}
gchar* sanitized = g_strdup(name);
gchar* p = sanitized;
while (*p) {
// GKeyFile group header forbids these characters.
if (*p == '[' || *p == ']' || *p == '\n' || *p == '\r') {
*p = '_';
}
p++;
}
return sanitized;
}
static gboolean
_accounts_has_group(const char* account_name)
{
if (!account_name || !accounts)
return FALSE;
auto_gchar gchar* sanitized = _sanitize_account_name(account_name);
return g_key_file_has_group(accounts, sanitized);
}
static void
_accounts_save(const char* account_name)
{
prof_keyfile_t current;
if (!load_data_keyfile(&current, FILE_ACCOUNTS)) {
log_error("Could not load accounts");
return;
}
auto_gchar gchar* sanitized = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized)) {
// Remove keys from file that are no longer in memory
gsize nkeys_disk;
auto_gcharv gchar** keys_disk = g_key_file_get_keys(current.keyfile, sanitized, &nkeys_disk, NULL);
if (keys_disk) {
for (gsize j = 0; j < nkeys_disk; ++j) {
if (!g_key_file_has_key(accounts_prof_keyfile.keyfile, sanitized, keys_disk[j], NULL)) {
g_key_file_remove_key(current.keyfile, sanitized, keys_disk[j], NULL);
}
}
}
gsize nkeys;
auto_gcharv gchar** keys = g_key_file_get_keys(accounts_prof_keyfile.keyfile, sanitized, &nkeys, NULL);
if (keys) {
for (gsize j = 0; j < nkeys; ++j) {
auto_gchar gchar* new_value = g_key_file_get_value(accounts_prof_keyfile.keyfile, sanitized, keys[j], NULL);
g_key_file_set_value(current.keyfile, sanitized, keys[j], new_value);
}
}
} else {
g_key_file_remove_group(current.keyfile, sanitized, NULL);
}
save_keyfile(&current);
free_keyfile(&current);
}
static void _save_accounts(void);
static void
_accounts_close(void)
@@ -120,9 +79,7 @@ accounts_load(void)
all_ac = autocomplete_new();
enabled_ac = autocomplete_new();
if (!load_data_keyfile(&accounts_prof_keyfile, FILE_ACCOUNTS)) {
log_error("Could not load accounts");
}
load_data_keyfile(&accounts_prof_keyfile, FILE_ACCOUNTS);
accounts = accounts_prof_keyfile.keyfile;
// create the logins searchable list for autocompletion
@@ -175,58 +132,54 @@ accounts_add(const char* account_name, const char* altdomain, const int port, co
}
}
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
log_error("Can't add account \"%s\", it already exists.", account_name);
if (g_key_file_has_group(accounts, account_name)) {
return;
}
g_key_file_set_boolean(accounts, sanitized_account_name, "enabled", TRUE);
g_key_file_set_string(accounts, sanitized_account_name, "jid", barejid);
g_key_file_set_string(accounts, sanitized_account_name, "resource", resource);
g_key_file_set_boolean(accounts, account_name, "enabled", TRUE);
g_key_file_set_string(accounts, account_name, "jid", barejid);
g_key_file_set_string(accounts, account_name, "resource", resource);
if (altdomain) {
g_key_file_set_string(accounts, sanitized_account_name, "server", altdomain);
g_key_file_set_string(accounts, account_name, "server", altdomain);
}
if (port != 0) {
g_key_file_set_integer(accounts, sanitized_account_name, "port", port);
g_key_file_set_integer(accounts, account_name, "port", port);
}
if (tls_policy) {
g_key_file_set_string(accounts, sanitized_account_name, "tls.policy", tls_policy);
g_key_file_set_string(accounts, account_name, "tls.policy", tls_policy);
}
if (auth_policy) {
g_key_file_set_string(accounts, sanitized_account_name, "auth.policy", auth_policy);
g_key_file_set_string(accounts, account_name, "auth.policy", auth_policy);
}
auto_jid Jid* jidp = jid_create(barejid);
if (jidp->localpart == NULL) {
g_key_file_set_string(accounts, sanitized_account_name, "muc.nick", jidp->domainpart);
g_key_file_set_string(accounts, account_name, "muc.nick", jidp->domainpart);
} else {
g_key_file_set_string(accounts, sanitized_account_name, "muc.nick", jidp->localpart);
g_key_file_set_string(accounts, account_name, "muc.nick", jidp->localpart);
}
g_key_file_set_string(accounts, sanitized_account_name, "presence.last", "online");
g_key_file_set_string(accounts, sanitized_account_name, "presence.login", "online");
g_key_file_set_integer(accounts, sanitized_account_name, "priority.online", 0);
g_key_file_set_integer(accounts, sanitized_account_name, "priority.chat", 0);
g_key_file_set_integer(accounts, sanitized_account_name, "priority.away", 0);
g_key_file_set_integer(accounts, sanitized_account_name, "priority.xa", 0);
g_key_file_set_integer(accounts, sanitized_account_name, "priority.dnd", 0);
g_key_file_set_string(accounts, account_name, "presence.last", "online");
g_key_file_set_string(accounts, account_name, "presence.login", "online");
g_key_file_set_integer(accounts, account_name, "priority.online", 0);
g_key_file_set_integer(accounts, account_name, "priority.chat", 0);
g_key_file_set_integer(accounts, account_name, "priority.away", 0);
g_key_file_set_integer(accounts, account_name, "priority.xa", 0);
g_key_file_set_integer(accounts, account_name, "priority.dnd", 0);
_accounts_save(account_name);
autocomplete_add(all_ac, sanitized_account_name);
autocomplete_add(enabled_ac, sanitized_account_name);
_save_accounts();
autocomplete_add(all_ac, account_name);
autocomplete_add(enabled_ac, account_name);
}
gboolean
int
accounts_remove(const char* account_name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
gboolean r = g_key_file_remove_group(accounts, sanitized_account_name, NULL);
_accounts_save(account_name);
autocomplete_remove(all_ac, sanitized_account_name);
autocomplete_remove(enabled_ac, sanitized_account_name);
int r = g_key_file_remove_group(accounts, account_name, NULL);
_save_accounts();
autocomplete_remove(all_ac, account_name);
autocomplete_remove(enabled_ac, account_name);
return r;
}
@@ -236,123 +189,167 @@ accounts_get_list(void)
return g_key_file_get_groups(accounts, NULL);
}
static GList*
_g_strv_to_glist(gchar** in, gsize length)
{
if (in == NULL)
return NULL;
GList* out = NULL;
for (gsize i = 0; i < length; i++) {
out = g_list_append(out, in[i]);
}
g_free(in);
return out;
}
static GList*
_accounts_get_glist(const gchar* sanitized_account_name,
const gchar* key)
{
gsize length = 0;
gchar** list = g_key_file_get_string_list(accounts, sanitized_account_name, key, &length, NULL);
return _g_strv_to_glist(list, length);
}
ProfAccount*
accounts_get_account(const char* const account_name)
accounts_get_account(const char* const name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (!_accounts_has_group(sanitized_account_name)) {
if (!g_key_file_has_group(accounts, name)) {
return NULL;
} else {
gchar* jid = g_key_file_get_string(accounts, sanitized_account_name, "jid", NULL);
gchar* jid = g_key_file_get_string(accounts, name, "jid", NULL);
// fix accounts that have no jid property by setting to account_name
// fix accounts that have no jid property by setting to name
if (jid == NULL) {
g_key_file_set_string(accounts, sanitized_account_name, "jid", account_name);
_accounts_save(account_name);
g_key_file_set_string(accounts, name, "jid", name);
_save_accounts();
}
gchar* password = g_key_file_get_string(accounts, sanitized_account_name, "password", NULL);
gchar* eval_password = g_key_file_get_string(accounts, sanitized_account_name, "eval_password", NULL);
gboolean enabled = g_key_file_get_boolean(accounts, sanitized_account_name, "enabled", NULL);
gchar* password = g_key_file_get_string(accounts, name, "password", NULL);
gchar* eval_password = g_key_file_get_string(accounts, name, "eval_password", NULL);
gboolean enabled = g_key_file_get_boolean(accounts, name, "enabled", NULL);
gchar* server = g_key_file_get_string(accounts, sanitized_account_name, "server", NULL);
gchar* resource = g_key_file_get_string(accounts, sanitized_account_name, "resource", NULL);
int port = g_key_file_get_integer(accounts, sanitized_account_name, "port", NULL);
gchar* server = g_key_file_get_string(accounts, name, "server", NULL);
gchar* resource = g_key_file_get_string(accounts, name, "resource", NULL);
int port = g_key_file_get_integer(accounts, name, "port", NULL);
gchar* last_presence = g_key_file_get_string(accounts, sanitized_account_name, "presence.last", NULL);
gchar* login_presence = g_key_file_get_string(accounts, sanitized_account_name, "presence.login", NULL);
gchar* last_presence = g_key_file_get_string(accounts, name, "presence.last", NULL);
gchar* login_presence = g_key_file_get_string(accounts, name, "presence.login", NULL);
int priority_online = g_key_file_get_integer(accounts, sanitized_account_name, "priority.online", NULL);
int priority_chat = g_key_file_get_integer(accounts, sanitized_account_name, "priority.chat", NULL);
int priority_away = g_key_file_get_integer(accounts, sanitized_account_name, "priority.away", NULL);
int priority_xa = g_key_file_get_integer(accounts, sanitized_account_name, "priority.xa", NULL);
int priority_dnd = g_key_file_get_integer(accounts, sanitized_account_name, "priority.dnd", NULL);
int priority_online = g_key_file_get_integer(accounts, name, "priority.online", NULL);
int priority_chat = g_key_file_get_integer(accounts, name, "priority.chat", NULL);
int priority_away = g_key_file_get_integer(accounts, name, "priority.away", NULL);
int priority_xa = g_key_file_get_integer(accounts, name, "priority.xa", NULL);
int priority_dnd = g_key_file_get_integer(accounts, name, "priority.dnd", NULL);
gchar* muc_service = NULL;
if (g_key_file_has_key(accounts, sanitized_account_name, "muc.service", NULL)) {
muc_service = g_key_file_get_string(accounts, sanitized_account_name, "muc.service", NULL);
if (g_key_file_has_key(accounts, name, "muc.service", NULL)) {
muc_service = g_key_file_get_string(accounts, name, "muc.service", NULL);
} else {
jabber_conn_status_t conn_status = connection_get_status();
if (conn_status == JABBER_CONNECTED) {
const char* conf_jid = connection_jid_for_feature(XMPP_FEATURE_MUC);
if (conf_jid) {
muc_service = g_strdup(conf_jid);
muc_service = strdup(conf_jid);
}
}
}
gchar* muc_nick = g_key_file_get_string(accounts, sanitized_account_name, "muc.nick", NULL);
gchar* muc_nick = g_key_file_get_string(accounts, name, "muc.nick", NULL);
gchar* otr_policy = g_key_file_get_string(accounts, sanitized_account_name, "otr.policy", NULL);
GList* otr_manual = _accounts_get_glist(sanitized_account_name, "otr.manual");
GList* otr_opportunistic = _accounts_get_glist(sanitized_account_name, "otr.opportunistic");
GList* otr_always = _accounts_get_glist(sanitized_account_name, "otr.always");
gchar* otr_policy = NULL;
if (g_key_file_has_key(accounts, name, "otr.policy", NULL)) {
otr_policy = g_key_file_get_string(accounts, name, "otr.policy", NULL);
}
gchar* omemo_policy = g_key_file_get_string(accounts, sanitized_account_name, "omemo.policy", NULL);
GList* omemo_enabled = _accounts_get_glist(sanitized_account_name, "omemo.enabled");
GList* omemo_disabled = _accounts_get_glist(sanitized_account_name, "omemo.disabled");
gsize length;
GList* otr_manual = NULL;
auto_gcharv gchar** manual = g_key_file_get_string_list(accounts, name, "otr.manual", &length, NULL);
if (manual) {
for (int i = 0; i < length; i++) {
otr_manual = g_list_append(otr_manual, strdup(manual[i]));
}
}
GList* ox_enabled = _accounts_get_glist(sanitized_account_name, "ox.enabled");
GList* otr_opportunistic = NULL;
auto_gcharv gchar** opportunistic = g_key_file_get_string_list(accounts, name, "otr.opportunistic", &length, NULL);
if (opportunistic) {
for (int i = 0; i < length; i++) {
otr_opportunistic = g_list_append(otr_opportunistic, strdup(opportunistic[i]));
}
}
GList* pgp_enabled = _accounts_get_glist(sanitized_account_name, "pgp.enabled");
GList* otr_always = NULL;
auto_gcharv gchar** always = g_key_file_get_string_list(accounts, name, "otr.always", &length, NULL);
if (always) {
for (int i = 0; i < length; i++) {
otr_always = g_list_append(otr_always, strdup(always[i]));
}
}
gchar* pgp_keyid = g_key_file_get_string(accounts, sanitized_account_name, "pgp.keyid", NULL);
gchar* omemo_policy = NULL;
if (g_key_file_has_key(accounts, name, "omemo.policy", NULL)) {
omemo_policy = g_key_file_get_string(accounts, name, "omemo.policy", NULL);
}
gchar* startscript = g_key_file_get_string(accounts, sanitized_account_name, "script.start", NULL);
GList* omemo_enabled = NULL;
auto_gcharv gchar** omemo_enabled_list = g_key_file_get_string_list(accounts, name, "omemo.enabled", &length, NULL);
if (omemo_enabled_list) {
for (int i = 0; i < length; i++) {
omemo_enabled = g_list_append(omemo_enabled, strdup(omemo_enabled_list[i]));
}
}
gchar* client = g_key_file_get_string(accounts, sanitized_account_name, "client.account_name", NULL);
GList* omemo_disabled = NULL;
auto_gcharv gchar** omemo_disabled_list = g_key_file_get_string_list(accounts, name, "omemo.disabled", &length, NULL);
if (omemo_disabled_list) {
for (int i = 0; i < length; i++) {
omemo_disabled = g_list_append(omemo_disabled, strdup(omemo_disabled_list[i]));
}
}
gchar* theme = g_key_file_get_string(accounts, sanitized_account_name, "theme", NULL);
GList* ox_enabled = NULL;
auto_gcharv gchar** ox_enabled_list = g_key_file_get_string_list(accounts, name, "ox.enabled", &length, NULL);
if (ox_enabled_list) {
for (int i = 0; i < length; i++) {
ox_enabled = g_list_append(ox_enabled, strdup(ox_enabled_list[i]));
}
}
gchar* tls_policy = g_key_file_get_string(accounts, sanitized_account_name, "tls.policy", NULL);
if (tls_policy && !valid_tls_policy_option(tls_policy)) {
GList* pgp_enabled = NULL;
auto_gcharv gchar** pgp_enabled_list = g_key_file_get_string_list(accounts, name, "pgp.enabled", &length, NULL);
if (pgp_enabled_list) {
for (int i = 0; i < length; i++) {
pgp_enabled = g_list_append(pgp_enabled, strdup(pgp_enabled_list[i]));
}
}
gchar* pgp_keyid = NULL;
if (g_key_file_has_key(accounts, name, "pgp.keyid", NULL)) {
pgp_keyid = g_key_file_get_string(accounts, name, "pgp.keyid", NULL);
}
gchar* startscript = NULL;
if (g_key_file_has_key(accounts, name, "script.start", NULL)) {
startscript = g_key_file_get_string(accounts, name, "script.start", NULL);
}
gchar* client = NULL;
if (g_key_file_has_key(accounts, name, "client.name", NULL)) {
client = g_key_file_get_string(accounts, name, "client.name", NULL);
}
gchar* theme = NULL;
if (g_key_file_has_key(accounts, name, "theme", NULL)) {
theme = g_key_file_get_string(accounts, name, "theme", NULL);
}
gchar* tls_policy = g_key_file_get_string(accounts, name, "tls.policy", NULL);
if (tls_policy && ((g_strcmp0(tls_policy, "force") != 0) && (g_strcmp0(tls_policy, "allow") != 0) && (g_strcmp0(tls_policy, "trust") != 0) && (g_strcmp0(tls_policy, "disable") != 0) && (g_strcmp0(tls_policy, "legacy") != 0))) {
g_free(tls_policy);
tls_policy = NULL;
}
gchar* auth_policy = g_key_file_get_string(accounts, sanitized_account_name, "auth.policy", NULL);
gchar* auth_policy = g_key_file_get_string(accounts, name, "auth.policy", NULL);
int max_sessions = g_key_file_get_integer(accounts, sanitized_account_name, "max.sessions", 0);
int max_sessions = g_key_file_get_integer(accounts, name, "max.sessions", 0);
return account_new(g_strdup(account_name), jid, password, eval_password, enabled,
server, port, resource, last_presence, login_presence,
priority_online, priority_chat, priority_away, priority_xa,
priority_dnd, muc_service, muc_nick, otr_policy, otr_manual,
otr_opportunistic, otr_always, omemo_policy, omemo_enabled,
omemo_disabled, ox_enabled, pgp_enabled, pgp_keyid,
startscript, theme, tls_policy, auth_policy, client, max_sessions);
ProfAccount* new_account = account_new(g_strdup(name), jid, password, eval_password, enabled,
server, port, resource, last_presence, login_presence,
priority_online, priority_chat, priority_away, priority_xa,
priority_dnd, muc_service, muc_nick, otr_policy, otr_manual,
otr_opportunistic, otr_always, omemo_policy, omemo_enabled,
omemo_disabled, ox_enabled, pgp_enabled, pgp_keyid,
startscript, theme, tls_policy, auth_policy, client, max_sessions);
return new_account;
}
}
gboolean
accounts_enable(const char* const account_name)
accounts_enable(const char* const name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_set_boolean(accounts, sanitized_account_name, "enabled", TRUE);
_accounts_save(account_name);
autocomplete_add(enabled_ac, sanitized_account_name);
if (g_key_file_has_group(accounts, name)) {
g_key_file_set_boolean(accounts, name, "enabled", TRUE);
_save_accounts();
autocomplete_add(enabled_ac, name);
return TRUE;
} else {
return FALSE;
@@ -360,13 +357,12 @@ accounts_enable(const char* const account_name)
}
gboolean
accounts_disable(const char* const account_name)
accounts_disable(const char* const name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_set_boolean(accounts, sanitized_account_name, "enabled", FALSE);
_accounts_save(account_name);
autocomplete_remove(enabled_ac, sanitized_account_name);
if (g_key_file_has_group(accounts, name)) {
g_key_file_set_boolean(accounts, name, "enabled", FALSE);
_save_accounts();
autocomplete_remove(enabled_ac, name);
return TRUE;
} else {
return FALSE;
@@ -376,33 +372,63 @@ accounts_disable(const char* const account_name)
gboolean
accounts_rename(const char* const account_name, const char* const new_name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
auto_gchar gchar* sanitized_new_account_name = _sanitize_account_name(new_name);
if (_accounts_has_group(sanitized_new_account_name)) {
if (g_key_file_has_group(accounts, new_name)) {
return FALSE;
}
if (!_accounts_has_group(sanitized_account_name)) {
if (!g_key_file_has_group(accounts, account_name)) {
return FALSE;
}
gsize nkeys;
auto_gcharv gchar** keys = g_key_file_get_keys(accounts, sanitized_account_name, &nkeys, NULL);
for (gsize i = 0; i < nkeys; i++) {
auto_gchar gchar* new_value = g_key_file_get_value(accounts, sanitized_account_name, keys[i], NULL);
g_key_file_set_value(accounts, sanitized_new_account_name, keys[i], new_value);
// treat all properties as strings for copy
gchar* string_keys[] = {
"enabled",
"jid",
"server",
"port",
"resource",
"password",
"eval_password",
"presence.last",
"presence.laststatus",
"presence.login",
"priority.online",
"priority.chat",
"priority.away",
"priority.xa",
"priority.dnd",
"muc.service",
"muc.nick",
"otr.policy",
"otr.manual",
"otr.opportunistic",
"otr.always",
"omemo.policy",
"omemo.enabled",
"omemo.disabled",
"ox.enabled",
"pgp.enabled",
"pgp.keyid",
"last.activity",
"script.start",
"tls.policy"
};
for (int i = 0; i < ARRAY_SIZE(string_keys); i++) {
auto_gchar gchar* value = g_key_file_get_string(accounts, account_name, string_keys[i], NULL);
if (value) {
g_key_file_set_string(accounts, new_name, string_keys[i], value);
}
}
g_key_file_remove_group(accounts, sanitized_account_name, NULL);
_accounts_save(account_name);
_accounts_save(new_name);
g_key_file_remove_group(accounts, account_name, NULL);
_save_accounts();
autocomplete_remove(all_ac, sanitized_account_name);
autocomplete_remove(enabled_ac, sanitized_account_name);
autocomplete_add(all_ac, sanitized_new_account_name);
if (g_key_file_get_boolean(accounts, sanitized_new_account_name, "enabled", NULL)) {
autocomplete_add(enabled_ac, sanitized_new_account_name);
autocomplete_remove(all_ac, account_name);
autocomplete_add(all_ac, new_name);
if (g_key_file_get_boolean(accounts, new_name, "enabled", NULL)) {
autocomplete_remove(enabled_ac, account_name);
autocomplete_add(enabled_ac, new_name);
}
return TRUE;
@@ -411,7 +437,7 @@ accounts_rename(const char* const account_name, const char* const new_name)
gboolean
accounts_account_exists(const char* const account_name)
{
return _accounts_has_group(account_name);
return g_key_file_has_group(accounts, account_name);
}
void
@@ -419,20 +445,19 @@ accounts_set_jid(const char* const account_name, const char* const value)
{
auto_jid Jid* jid = jid_create(value);
if (jid) {
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_set_string(accounts, sanitized_account_name, "jid", jid->barejid);
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "jid", jid->barejid);
if (jid->resourcepart) {
g_key_file_set_string(accounts, sanitized_account_name, "resource", jid->resourcepart);
g_key_file_set_string(accounts, account_name, "resource", jid->resourcepart);
}
if (jid->localpart == NULL) {
g_key_file_set_string(accounts, sanitized_account_name, "muc.nick", jid->domainpart);
g_key_file_set_string(accounts, account_name, "muc.nick", jid->domainpart);
} else {
g_key_file_set_string(accounts, sanitized_account_name, "muc.nick", jid->localpart);
g_key_file_set_string(accounts, account_name, "muc.nick", jid->localpart);
}
_accounts_save(account_name);
_save_accounts();
}
}
}
@@ -440,10 +465,9 @@ accounts_set_jid(const char* const account_name, const char* const value)
void
accounts_set_server(const char* const account_name, const char* const value)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_set_string(accounts, sanitized_account_name, "server", value);
_accounts_save(account_name);
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "server", value);
_save_accounts();
}
}
@@ -451,41 +475,35 @@ void
accounts_set_port(const char* const account_name, const int value)
{
if (value != 0) {
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_set_integer(accounts, sanitized_account_name, "port", value);
_accounts_save(account_name);
}
g_key_file_set_integer(accounts, account_name, "port", value);
_save_accounts();
}
}
static void
_accounts_set_string_option(const char* account_name, const char* const option, const char* const value)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_set_string(accounts, sanitized_account_name, option, value ?: "");
_accounts_save(account_name);
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, option, value ?: "");
_save_accounts();
}
}
static void
_accounts_set_int_option(const char* account_name, const char* const option, int value)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_set_integer(accounts, sanitized_account_name, option, value);
_accounts_save(account_name);
if (accounts_account_exists(account_name)) {
g_key_file_set_integer(accounts, account_name, option, value);
_save_accounts();
}
}
static void
_accounts_clear_string_option(const char* account_name, const char* const option)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_remove_key(accounts, sanitized_account_name, option, NULL);
_accounts_save(account_name);
if (accounts_account_exists(account_name)) {
g_key_file_remove_key(accounts, account_name, option, NULL);
_save_accounts();
}
}
@@ -522,7 +540,7 @@ accounts_set_script_start(const char* const account_name, const char* const valu
void
accounts_set_client(const char* const account_name, const char* const value)
{
_accounts_set_string_option(account_name, "client.account_name", value);
_accounts_set_string_option(account_name, "client.name", value);
}
void
@@ -576,7 +594,7 @@ accounts_clear_script_start(const char* const account_name)
void
accounts_clear_client(const char* const account_name)
{
_accounts_clear_string_option(account_name, "client.account_name");
_accounts_clear_string_option(account_name, "client.name");
}
void
@@ -612,88 +630,83 @@ accounts_clear_max_sessions(const char* const account_name)
void
accounts_add_otr_policy(const char* const account_name, const char* const contact_jid, const char* const policy)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
if (accounts_account_exists(account_name)) {
GString* key = g_string_new("otr.");
g_string_append(key, policy);
conf_string_list_add(accounts, sanitized_account_name, key->str, contact_jid);
conf_string_list_add(accounts, account_name, key->str, contact_jid);
g_string_free(key, TRUE);
// check for and remove from other lists
if (strcmp(policy, "manual") == 0) {
conf_string_list_remove(accounts, sanitized_account_name, "otr.opportunistic", contact_jid);
conf_string_list_remove(accounts, sanitized_account_name, "otr.always", contact_jid);
conf_string_list_remove(accounts, account_name, "otr.opportunistic", contact_jid);
conf_string_list_remove(accounts, account_name, "otr.always", contact_jid);
}
if (strcmp(policy, "opportunistic") == 0) {
conf_string_list_remove(accounts, sanitized_account_name, "otr.manual", contact_jid);
conf_string_list_remove(accounts, sanitized_account_name, "otr.always", contact_jid);
conf_string_list_remove(accounts, account_name, "otr.manual", contact_jid);
conf_string_list_remove(accounts, account_name, "otr.always", contact_jid);
}
if (strcmp(policy, "always") == 0) {
conf_string_list_remove(accounts, sanitized_account_name, "otr.opportunistic", contact_jid);
conf_string_list_remove(accounts, sanitized_account_name, "otr.manual", contact_jid);
conf_string_list_remove(accounts, account_name, "otr.opportunistic", contact_jid);
conf_string_list_remove(accounts, account_name, "otr.manual", contact_jid);
}
_accounts_save(account_name);
_save_accounts();
}
}
void
accounts_add_omemo_state(const char* const account_name, const char* const contact_jid, gboolean enabled)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
if (accounts_account_exists(account_name)) {
if (enabled) {
conf_string_list_add(accounts, sanitized_account_name, "omemo.enabled", contact_jid);
conf_string_list_remove(accounts, sanitized_account_name, "omemo.disabled", contact_jid);
conf_string_list_add(accounts, account_name, "omemo.enabled", contact_jid);
conf_string_list_remove(accounts, account_name, "omemo.disabled", contact_jid);
} else {
conf_string_list_add(accounts, sanitized_account_name, "omemo.disabled", contact_jid);
conf_string_list_remove(accounts, sanitized_account_name, "omemo.enabled", contact_jid);
conf_string_list_add(accounts, account_name, "omemo.disabled", contact_jid);
conf_string_list_remove(accounts, account_name, "omemo.enabled", contact_jid);
}
_accounts_save(account_name);
_save_accounts();
}
}
void
accounts_add_ox_state(const char* const account_name, const char* const contact_jid, gboolean enabled)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
if (accounts_account_exists(account_name)) {
if (enabled) {
conf_string_list_add(accounts, sanitized_account_name, "ox.enabled", contact_jid);
conf_string_list_add(accounts, account_name, "ox.enabled", contact_jid);
} else {
conf_string_list_remove(accounts, sanitized_account_name, "ox.enabled", contact_jid);
conf_string_list_remove(accounts, account_name, "ox.enabled", contact_jid);
}
_accounts_save(account_name);
_save_accounts();
}
}
void
accounts_add_pgp_state(const char* const account_name, const char* const contact_jid, gboolean enabled)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
if (accounts_account_exists(account_name)) {
if (enabled) {
conf_string_list_add(accounts, sanitized_account_name, "pgp.enabled", contact_jid);
conf_string_list_remove(accounts, sanitized_account_name, "pgp.disabled", contact_jid);
conf_string_list_add(accounts, account_name, "pgp.enabled", contact_jid);
conf_string_list_remove(accounts, account_name, "pgp.disabled", contact_jid);
} else {
conf_string_list_add(accounts, sanitized_account_name, "pgp.disabled", contact_jid);
conf_string_list_remove(accounts, sanitized_account_name, "pgp.enabled", contact_jid);
conf_string_list_add(accounts, account_name, "pgp.disabled", contact_jid);
conf_string_list_remove(accounts, account_name, "pgp.enabled", contact_jid);
}
_accounts_save(account_name);
_save_accounts();
}
}
void
accounts_clear_omemo_state(const char* const account_name, const char* const contact_jid)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
conf_string_list_remove(accounts, sanitized_account_name, "omemo.enabled", contact_jid);
conf_string_list_remove(accounts, sanitized_account_name, "omemo.disabled", contact_jid);
_accounts_save(account_name);
if (accounts_account_exists(account_name)) {
conf_string_list_remove(accounts, account_name, "omemo.enabled", contact_jid);
conf_string_list_remove(accounts, account_name, "omemo.disabled", contact_jid);
_save_accounts();
}
}
@@ -766,8 +779,7 @@ accounts_set_priority_dnd(const char* const account_name, const gint value)
void
accounts_set_priority_all(const char* const account_name, const gint value)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
if (accounts_account_exists(account_name)) {
accounts_set_priority_online(account_name, value);
accounts_set_priority_chat(account_name, value);
accounts_set_priority_away(account_name, value);
@@ -781,23 +793,22 @@ accounts_get_priority_for_presence_type(const char* const account_name,
resource_presence_t presence_type)
{
gint result;
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
switch (presence_type) {
case (RESOURCE_ONLINE):
result = g_key_file_get_integer(accounts, sanitized_account_name, "priority.online", NULL);
result = g_key_file_get_integer(accounts, account_name, "priority.online", NULL);
break;
case (RESOURCE_CHAT):
result = g_key_file_get_integer(accounts, sanitized_account_name, "priority.chat", NULL);
result = g_key_file_get_integer(accounts, account_name, "priority.chat", NULL);
break;
case (RESOURCE_AWAY):
result = g_key_file_get_integer(accounts, sanitized_account_name, "priority.away", NULL);
result = g_key_file_get_integer(accounts, account_name, "priority.away", NULL);
break;
case (RESOURCE_XA):
result = g_key_file_get_integer(accounts, sanitized_account_name, "priority.xa", NULL);
result = g_key_file_get_integer(accounts, account_name, "priority.xa", NULL);
break;
default:
result = g_key_file_get_integer(accounts, sanitized_account_name, "priority.dnd", NULL);
result = g_key_file_get_integer(accounts, account_name, "priority.dnd", NULL);
break;
}
@@ -822,8 +833,7 @@ accounts_set_last_status(const char* const account_name, const char* const value
void
accounts_set_last_activity(const char* const account_name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
if (accounts_account_exists(account_name)) {
GDateTime* nowdt = g_date_time_new_now_utc();
GTimeVal nowtv;
gboolean res = g_date_time_to_timeval(nowdt, &nowtv);
@@ -831,8 +841,8 @@ accounts_set_last_activity(const char* const account_name)
if (res) {
auto_char char* timestr = g_time_val_to_iso8601(&nowtv);
g_key_file_set_string(accounts, sanitized_account_name, "last.activity", timestr);
_accounts_save(account_name);
g_key_file_set_string(accounts, account_name, "last.activity", timestr);
_save_accounts();
}
}
}
@@ -840,9 +850,8 @@ accounts_set_last_activity(const char* const account_name)
gchar*
accounts_get_last_activity(const char* const account_name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
return g_key_file_get_string(accounts, sanitized_account_name, "last.activity", NULL);
if (accounts_account_exists(account_name)) {
return g_key_file_get_string(accounts, account_name, "last.activity", NULL);
} else {
return NULL;
}
@@ -851,30 +860,27 @@ accounts_get_last_activity(const char* const account_name)
gchar*
accounts_get_resource(const char* const account_name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (!_accounts_has_group(sanitized_account_name)) {
if (!accounts_account_exists(account_name)) {
return NULL;
}
return g_key_file_get_string(accounts, sanitized_account_name, "resource", NULL);
return g_key_file_get_string(accounts, account_name, "resource", NULL);
}
int
accounts_get_max_sessions(const char* const account_name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (!_accounts_has_group(sanitized_account_name)) {
if (!accounts_account_exists(account_name)) {
return 0;
}
return g_key_file_get_integer(accounts, sanitized_account_name, "max.sessions", 0);
return g_key_file_get_integer(accounts, account_name, "max.sessions", 0);
}
void
accounts_set_login_presence(const char* const account_name, const char* const value)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
if (_accounts_has_group(sanitized_account_name)) {
g_key_file_set_string(accounts, sanitized_account_name, "presence.login", value);
_accounts_save(account_name);
if (accounts_account_exists(account_name)) {
g_key_file_set_string(accounts, account_name, "presence.login", value);
_save_accounts();
}
}
@@ -882,8 +888,7 @@ resource_presence_t
accounts_get_last_presence(const char* const account_name)
{
resource_presence_t result;
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
auto_gchar gchar* setting = g_key_file_get_string(accounts, sanitized_account_name, "presence.last", NULL);
auto_gchar gchar* setting = g_key_file_get_string(accounts, account_name, "presence.last", NULL);
if (setting == NULL || (strcmp(setting, "online") == 0)) {
result = RESOURCE_ONLINE;
@@ -907,16 +912,14 @@ accounts_get_last_presence(const char* const account_name)
char*
accounts_get_last_status(const char* const account_name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
return g_key_file_get_string(accounts, sanitized_account_name, "presence.laststatus", NULL);
return g_key_file_get_string(accounts, account_name, "presence.laststatus", NULL);
}
resource_presence_t
accounts_get_login_presence(const char* const account_name)
{
resource_presence_t result;
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
auto_gchar gchar* setting = g_key_file_get_string(accounts, sanitized_account_name, "presence.login", NULL);
auto_gchar gchar* setting = g_key_file_get_string(accounts, account_name, "presence.login", NULL);
if (setting == NULL || (strcmp(setting, "online") == 0)) {
result = RESOURCE_ONLINE;
@@ -941,8 +944,7 @@ accounts_get_login_presence(const char* const account_name)
char*
accounts_get_login_status(const char* const account_name)
{
auto_gchar gchar* sanitized_account_name = _sanitize_account_name(account_name);
auto_gchar gchar* setting = g_key_file_get_string(accounts, sanitized_account_name, "presence.login", NULL);
auto_gchar gchar* setting = g_key_file_get_string(accounts, account_name, "presence.login", NULL);
gchar* status = NULL;
if (g_strcmp0(setting, "last") == 0) {
@@ -951,3 +953,9 @@ accounts_get_login_status(const char* const account_name)
return status;
}
static void
_save_accounts(void)
{
save_keyfile(&accounts_prof_keyfile);
}

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef CONFIG_ACCOUNTS_H
@@ -22,7 +48,7 @@ char* accounts_find_enabled(const char* const prefix, gboolean previous, void* c
void accounts_reset_all_search(void);
void accounts_reset_enabled_search(void);
void accounts_add(const char* jid, const char* altdomain, const int port, const char* const tls_policy, const char* const auth_policy);
gboolean accounts_remove(const char* jid);
int accounts_remove(const char* jid);
gchar** accounts_get_list(void);
ProfAccount* accounts_get_account(const char* const name);
gboolean accounts_enable(const char* const name);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2022 Steffen Jaeckel <jaeckel-floss@eyet-services.de>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -27,7 +53,8 @@ _cafile_name(void)
if (!create_dir(certs_dir)) {
return NULL;
}
return g_strdup_printf("%s/CAfile.pem", certs_dir);
gchar* filename = g_strdup_printf("%s/CAfile.pem", certs_dir);
return filename;
}
void
@@ -43,25 +70,21 @@ cafile_add(const TLSCertificate* cert)
auto_gchar gchar* contents = NULL;
auto_gchar gchar* new_contents = NULL;
gsize length;
auto_gerror GError* glib_error = NULL;
GError* glib_error = NULL;
if (g_file_test(cafile, G_FILE_TEST_EXISTS)) {
if (!g_file_get_contents(cafile, &contents, &length, &glib_error)) {
log_error("[CAfile] could not read from %s: %s", cafile, PROF_GERROR_MESSAGE(glib_error));
log_error("[CAfile] could not read from %s: %s", cafile, glib_error ? glib_error->message : "No GLib error given");
return;
}
if (strstr(contents, cert->fingerprint)) {
log_debug("[CAfile] fingerprint %s already stored", cert->fingerprint);
return;
}
if (strstr(contents, cert->fingerprint_sha1)) {
log_debug("[CAfile] fingerprint %s already stored", cert->fingerprint_sha1);
return;
}
}
const char* header = "# Profanity CAfile\n# DO NOT EDIT - this file is automatically generated";
new_contents = g_strdup_printf("%s\n# %s\n%s", contents ? contents : header, cert->fingerprint, cert->pem);
new_contents = g_strdup_printf("%s\n\n# %s\n%s", contents ? contents : header, cert->fingerprint, cert->pem);
if (!g_file_set_contents(cafile, new_contents, -1, &glib_error))
log_error("[CAfile] could not write to %s: %s", cafile, PROF_GERROR_MESSAGE(glib_error));
log_error("[CAfile] could not write to %s: %s", cafile, glib_error ? glib_error->message : "No GLib error given");
}
gchar*

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2022 Steffen Jaeckel <jaeckel-floss@eyet-services.de>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef CONFIG_CAFILE_H

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2019 Aurelien Aptel <aurelien.aptel@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -33,7 +59,7 @@ static struct color_pair_cache
{
struct
{
short fg, bg;
int16_t fg, bg;
}* pairs;
int size;
int capacity;
@@ -315,18 +341,14 @@ color_distance(const struct color_def* a, const struct color_def* b)
return h * h + s * s + l * l;
}
/* Indices into the 256-colour palette and ncurses palette IDs are
* 16-bit (the size_t-or-short distinction in ncurses init_pair).
* Use `short` end-to-end so the caller boundaries don't need casts.
*/
static short
static int
find_closest_col(int h, int s, int l)
{
struct color_def a = { (uint16_t)h, (uint8_t)s, (uint8_t)l, NULL };
short min = 0;
struct color_def a = { h, s, l };
int min = 0;
int dmin = color_distance(&a, &color_names[0]);
for (short i = 1; i < COLOR_NAME_SIZE; i++) {
for (int i = 1; i < COLOR_NAME_SIZE; i++) {
int d = color_distance(&a, &color_names[i]);
if (d < dmin) {
dmin = d;
@@ -336,8 +358,8 @@ find_closest_col(int h, int s, int l)
return min;
}
static short
find_col(const char* col_name, size_t n)
static int
find_col(const char* col_name, int n)
{
char name[32] = { 0 };
@@ -349,7 +371,7 @@ find_col(const char* col_name, size_t n)
if (n >= sizeof(name)) {
/* truncate */
log_error("Color: <%s,%zu> bigger than %zu", col_name, n, sizeof(name));
log_error("Color: <%s,%d> bigger than %zu", col_name, n, sizeof(name));
n = sizeof(name) - 1;
}
memcpy(name, col_name, n);
@@ -358,7 +380,7 @@ find_col(const char* col_name, size_t n)
return -1;
}
for (short i = 0; i < COLOR_NAME_SIZE; i++) {
for (int i = 0; i < COLOR_NAME_SIZE; i++) {
if (g_ascii_strcasecmp(name, color_names[i].name) == 0) {
return i;
}
@@ -367,13 +389,13 @@ find_col(const char* col_name, size_t n)
return COL_ERR;
}
static short
static int
color_hash(const char* str, color_profile profile)
{
GChecksum* cs = NULL;
guint8 buf[256] = { 0 };
gsize len = 256;
short rc = -1; /* default ncurse color */
int rc = -1; /* default ncurse color */
cs = g_checksum_new(G_CHECKSUM_SHA1);
if (!cs)
@@ -442,7 +464,7 @@ color_pair_cache_reset(void)
}
static int
_color_pair_cache_get(short fg, short bg)
_color_pair_cache_get(int fg, int bg)
{
if (COLORS < 256) {
if (fg > 7 || bg > 7) {
@@ -467,13 +489,10 @@ _color_pair_cache_get(short fg, short bg)
}
int i = cache.size;
// TODO: init_pair uses 15-bit palette indices. Terminals exposing
// extended colour palettes (>32767) need init_extended_pair here.
// Upstream-inherited limitation.
cache.pairs[i].fg = fg;
cache.pairs[i].bg = bg;
/* (re-)define the new pair in curses */
init_pair((short)i, fg, bg);
init_pair(i, fg, bg);
cache.size++;
@@ -492,8 +511,8 @@ _color_pair_cache_get(short fg, short bg)
int
color_pair_cache_hash_str(const char* str, color_profile profile)
{
short fg = color_hash(str, profile);
short bg = -1;
int fg = color_hash(str, profile);
int bg = -1;
auto_char char* bkgnd = theme_get_bkgnd();
if (bkgnd) {
@@ -513,7 +532,7 @@ int
color_pair_cache_get(const char* pair_name)
{
const char* sep;
short fg, bg;
int fg, bg;
sep = strchr(pair_name, '_');
if (!sep) {
@@ -521,7 +540,7 @@ color_pair_cache_get(const char* pair_name)
return -1;
}
fg = find_col(pair_name, (size_t)(sep - pair_name));
fg = find_col(pair_name, sep - pair_name);
bg = find_col(sep + 1, strlen(sep));
if (fg == COL_ERR || bg == COL_ERR) {
log_error("Color: bad color name %s", pair_name);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2019 Aurelien Aptel <aurelien.aptel@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef _COLOR_H_

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -40,7 +66,9 @@ conf_string_list_add(GKeyFile* keyfile, const char* const group, const char* con
// Add item to the existing list
const gchar** new_list = g_new(const gchar*, length + 2);
memcpy(new_list, list, sizeof(list[0]) * length);
for (gsize i = 0; i < length; ++i) {
new_list[i] = list[i];
}
new_list[length] = item;
new_list[length + 1] = NULL;
@@ -61,28 +89,33 @@ conf_string_list_remove(GKeyFile* keyfile, const char* const group, const char*
return FALSE;
}
gsize new_length = 0;
const gchar** new_list = g_new(const gchar*, length + 1);
GList* glist = NULL;
gboolean deleted = FALSE;
for (gsize i = 0; i < length; i++) {
for (int i = 0; i < length; i++) {
if (strcmp(list[i], item) == 0) {
deleted = TRUE;
continue;
}
new_list[new_length++] = list[i];
glist = g_list_append(glist, strdup(list[i]));
}
new_list[new_length] = NULL;
if (deleted) {
if (new_length == 0) {
if (g_list_length(glist) == 0) {
g_key_file_remove_key(keyfile, group, key, NULL);
} else {
g_key_file_set_string_list(keyfile, group, key, new_list, new_length);
const gchar* new_list[g_list_length(glist) + 1];
int i = 0;
for (GList* curr = glist; curr; curr = g_list_next(curr)) {
new_list[i++] = curr->data;
}
new_list[i] = NULL;
g_key_file_set_string_list(keyfile, group, key, new_list, g_list_length(glist));
}
}
g_free(new_list);
g_list_free_full(glist, g_free);
return deleted;
}

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef CONFIG_CONFLISTS_H

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2020 - 2026 Michael Vetter <jubalh@iodoru.org>
* 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2018 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2018 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#ifndef CONFIG_FILES_H

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -23,7 +49,6 @@
#include "tools/autocomplete.h"
#include "config/files.h"
#include "config/conflists.h"
#include "ui/ui.h"
// preference groups refer to the sections in .profrc or theme files
// for example [ui] but not [colours] which is handled in theme.c
@@ -41,7 +66,6 @@
#define PREF_GROUP_MUC "muc"
#define PREF_GROUP_PLUGINS "plugins"
#define PREF_GROUP_EXECUTABLES "executables"
#define PREF_GROUP_SPELLCHECK "spellcheck"
#define PREF_GROUP_AI "ai"
#define PREF_GROUP_AI_PREFIX "ai/" /* per-provider subsection prefix: [ai/<provider>] */
#define PREF_AI_SETTING_PREFIX "setting." /* per-provider custom setting key prefix */
@@ -56,10 +80,10 @@ static Autocomplete boolean_choice_ac;
static Autocomplete room_trigger_ac;
static void _save_prefs(void);
static const gchar* _get_group(preference_t pref);
static const gchar* _get_key(preference_t pref);
static const char* _get_group(preference_t pref);
static const char* _get_key(preference_t pref);
static gboolean _get_default_boolean(preference_t pref);
static gchar* _get_default_string(preference_t pref);
static char* _get_default_string(preference_t pref);
static void
_prefs_load(void)
@@ -68,7 +92,7 @@ _prefs_load(void)
log_maxsize = g_key_file_get_integer(prefs, PREF_GROUP_LOGGING, "maxsize", &err);
if (err) {
log_maxsize = 0;
PROF_GERROR_FREE(err);
g_error_free(err);
}
// move pre 0.5.0 autoaway.time to autoaway.awaytime
@@ -88,7 +112,7 @@ _prefs_load(void)
// migrate pre 0.5.0 time settings
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time", NULL)) {
auto_gchar gchar* time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time", NULL);
gchar* val = time ? time : "off";
char* val = time ? time : "off";
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.console", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.chat", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.muc", val);
@@ -157,7 +181,7 @@ _prefs_load(void)
if (values && !g_key_file_has_key(prefs, PREF_GROUP_EXECUTABLES, "url.open.cmd", NULL)) {
// First value in array is `require_save` option -- we ignore that
// one as there is no such option anymore.
gchar* executable = values[1];
char* executable = values[1];
g_key_file_set_string(prefs, PREF_GROUP_EXECUTABLES, "url.open.cmd", executable);
g_key_file_set_comment(prefs, PREF_GROUP_EXECUTABLES, "url.open.cmd", " Migrated from url.open.cmd[DEF]. `require_save` option has been removed in v0.10 and was discarded.", NULL);
@@ -294,7 +318,7 @@ _prefs_load(void)
gsize len = 0;
auto_gcharv gchar** triggers = g_key_file_get_string_list(prefs, PREF_GROUP_NOTIFICATIONS, "room.trigger.list", &len, NULL);
for (gsize i = 0; i < len; i++) {
for (int i = 0; i < len; i++) {
autocomplete_add(room_trigger_ac, triggers[i]);
}
}
@@ -316,7 +340,7 @@ prefs_reload(void)
}
void
prefs_load(const gchar* config_file)
prefs_load(const char* config_file)
{
if (config_file == NULL) {
load_config_keyfile(&prefs_prof_keyfile, FILE_PROFRC);
@@ -328,77 +352,6 @@ prefs_load(const gchar* config_file)
_prefs_load();
}
static void
prefs_changes_print(const gchar* key, const gchar* newval, const gchar* oldval, gboolean* banner_shown)
{
#define PREFS_CHANGES_FORMAT_STRING "%-32s | %-20s | %-20s"
if (!*banner_shown) {
cons_show(PREFS_CHANGES_FORMAT_STRING, "Key", "New value", "Old value");
*banner_shown = TRUE;
}
cons_show(PREFS_CHANGES_FORMAT_STRING, key, newval, oldval);
#undef PREFS_CHANGES_FORMAT_STRING
}
void
prefs_changes(void)
{
const gchar* undef = "";
prof_keyfile_t saved;
if (!load_custom_keyfile(&saved, g_strdup(prefs_prof_keyfile.filename)))
return;
gsize ngroups, nsavedgroups, g;
auto_gcharv gchar** groups = g_key_file_get_groups(prefs_prof_keyfile.keyfile, &ngroups);
gboolean banner_shown = FALSE;
for (g = 0; g < ngroups; ++g) {
gsize nkeys, k;
gboolean saved_has_group = g_key_file_has_group(saved.keyfile, groups[g]);
auto_gcharv gchar** keys = g_key_file_get_keys(prefs_prof_keyfile.keyfile, groups[g], &nkeys, NULL);
for (k = 0; k < nkeys; ++k) {
auto_gerror GError* err = NULL;
auto_gchar gchar* full_key = g_strdup_printf("%s.%s", groups[g], keys[k]);
auto_gchar gchar* new_value = g_key_file_get_value(prefs_prof_keyfile.keyfile, groups[g], keys[k], &err);
if (err || !new_value) {
cons_show_error("%s: New value (%s) error: %s", full_key, STR_MAYBE_NULL(new_value), PROF_GERROR_MESSAGE(err));
continue;
}
if (!saved_has_group
|| !g_key_file_has_key(saved.keyfile, groups[g], keys[k], NULL)) {
prefs_changes_print(full_key, new_value, undef, &banner_shown);
continue;
}
auto_gchar gchar* old_value = g_key_file_get_value(saved.keyfile, groups[g], keys[k], &err);
if (err || !old_value) {
cons_show_error("%s: Old value (%s) error: %s", full_key, STR_MAYBE_NULL(old_value), PROF_GERROR_MESSAGE(err));
continue;
}
if (!g_str_equal(old_value, new_value)) {
prefs_changes_print(full_key, new_value, old_value, &banner_shown);
}
}
}
auto_gcharv gchar** savedgroups = g_key_file_get_groups(saved.keyfile, &nsavedgroups);
for (g = 0; g < nsavedgroups; ++g) {
gsize nkeys, k;
auto_gcharv gchar** keys = g_key_file_get_keys(saved.keyfile, savedgroups[g], &nkeys, NULL);
for (k = 0; k < nkeys; ++k) {
if (g_key_file_has_key(prefs_prof_keyfile.keyfile, savedgroups[g], keys[k], NULL))
continue;
auto_gerror GError* err = NULL;
auto_gchar gchar* full_key = g_strdup_printf("%s.%s", groups[g], keys[k]);
auto_gchar gchar* old_value = g_key_file_get_value(saved.keyfile, groups[g], keys[k], &err);
if (err || !old_value) {
cons_show_error("%s: Old value (%s) error: %s", full_key, STR_MAYBE_NULL(old_value), PROF_GERROR_MESSAGE(err));
continue;
}
prefs_changes_print(full_key, undef, old_value, &banner_shown);
}
}
free_keyfile(&saved);
if (!banner_shown)
cons_show("No changes to saved preferences.");
}
void
prefs_save(void)
{
@@ -415,7 +368,7 @@ prefs_close(void)
}
gchar*
prefs_autocomplete_boolean_choice(const gchar* const prefix, gboolean previous, void* context)
prefs_autocomplete_boolean_choice(const char* const prefix, gboolean previous, void* context)
{
return autocomplete_complete(boolean_choice_ac, prefix, TRUE, previous);
}
@@ -427,7 +380,7 @@ prefs_reset_boolean_choice(void)
}
gchar*
prefs_autocomplete_room_trigger(const gchar* const prefix, gboolean previous, void* context)
prefs_autocomplete_room_trigger(const char* const prefix, gboolean previous, void* context)
{
return autocomplete_complete(room_trigger_ac, prefix, TRUE, previous);
}
@@ -453,7 +406,7 @@ prefs_do_chat_notify(gboolean current_win)
}
GList*
prefs_message_get_triggers(const gchar* const message)
prefs_message_get_triggers(const char* const message)
{
GList* result = NULL;
@@ -461,7 +414,7 @@ prefs_message_get_triggers(const gchar* const message)
gsize len = 0;
auto_gcharv gchar** triggers = g_key_file_get_string_list(prefs, PREF_GROUP_NOTIFICATIONS, "room.trigger.list", &len, NULL);
for (gsize i = 0; i < len; i++) {
for (int i = 0; i < len; i++) {
auto_gchar gchar* trigger_lower = g_utf8_strdown(triggers[i], -1);
if (g_strrstr(message_lower, trigger_lower)) {
result = g_list_append(result, strdup(triggers[i]));
@@ -472,8 +425,8 @@ prefs_message_get_triggers(const gchar* const message)
}
gboolean
prefs_do_room_notify(gboolean current_win, const gchar* const roomjid, const gchar* const mynick,
const gchar* const theirnick, const gchar* const message, gboolean mention, gboolean trigger_found)
prefs_do_room_notify(gboolean current_win, const char* const roomjid, const char* const mynick,
const char* const theirnick, const char* const message, gboolean mention, gboolean trigger_found)
{
if (g_strcmp0(mynick, theirnick) == 0) {
return FALSE;
@@ -522,7 +475,7 @@ prefs_do_room_notify(gboolean current_win, const gchar* const roomjid, const gch
}
gboolean
prefs_do_room_notify_mention(const gchar* const roomjid, int unread, gboolean mention, gboolean trigger)
prefs_do_room_notify_mention(const char* const roomjid, int unread, gboolean mention, gboolean trigger)
{
gboolean notify_room = FALSE;
if (g_key_file_has_key(prefs, roomjid, "notify", NULL)) {
@@ -558,61 +511,61 @@ prefs_do_room_notify_mention(const gchar* const roomjid, int unread, gboolean me
}
void
prefs_set_room_notify(const gchar* const roomjid, gboolean value)
prefs_set_room_notify(const char* const roomjid, gboolean value)
{
g_key_file_set_boolean(prefs, roomjid, "notify", value);
}
void
prefs_set_room_notify_mention(const gchar* const roomjid, gboolean value)
prefs_set_room_notify_mention(const char* const roomjid, gboolean value)
{
g_key_file_set_boolean(prefs, roomjid, "notify.mention", value);
}
void
prefs_set_room_notify_trigger(const gchar* const roomjid, gboolean value)
prefs_set_room_notify_trigger(const char* const roomjid, gboolean value)
{
g_key_file_set_boolean(prefs, roomjid, "notify.trigger", value);
}
gboolean
prefs_has_room_notify(const gchar* const roomjid)
prefs_has_room_notify(const char* const roomjid)
{
return g_key_file_has_key(prefs, roomjid, "notify", NULL);
}
gboolean
prefs_has_room_notify_mention(const gchar* const roomjid)
prefs_has_room_notify_mention(const char* const roomjid)
{
return g_key_file_has_key(prefs, roomjid, "notify.mention", NULL);
}
gboolean
prefs_has_room_notify_trigger(const gchar* const roomjid)
prefs_has_room_notify_trigger(const char* const roomjid)
{
return g_key_file_has_key(prefs, roomjid, "notify.trigger", NULL);
}
gboolean
prefs_get_room_notify(const gchar* const roomjid)
prefs_get_room_notify(const char* const roomjid)
{
return g_key_file_get_boolean(prefs, roomjid, "notify", NULL);
}
gboolean
prefs_get_room_notify_mention(const gchar* const roomjid)
prefs_get_room_notify_mention(const char* const roomjid)
{
return g_key_file_get_boolean(prefs, roomjid, "notify.mention", NULL);
}
gboolean
prefs_get_room_notify_trigger(const gchar* const roomjid)
prefs_get_room_notify_trigger(const char* const roomjid)
{
return g_key_file_get_boolean(prefs, roomjid, "notify.trigger", NULL);
}
gboolean
prefs_reset_room_notify(const gchar* const roomjid)
prefs_reset_room_notify(const char* const roomjid)
{
if (g_key_file_has_group(prefs, roomjid)) {
g_key_file_remove_group(prefs, roomjid, NULL);
@@ -625,8 +578,8 @@ prefs_reset_room_notify(const gchar* const roomjid)
gboolean
prefs_get_boolean(preference_t pref)
{
const gchar* group = _get_group(pref);
const gchar* key = _get_key(pref);
const char* group = _get_group(pref);
const char* key = _get_key(pref);
gboolean def = _get_default_boolean(pref);
if (!g_key_file_has_key(prefs, group, key, NULL)) {
@@ -639,8 +592,8 @@ prefs_get_boolean(preference_t pref)
void
prefs_set_boolean(preference_t pref, gboolean value)
{
const gchar* group = _get_group(pref);
const gchar* key = _get_key(pref);
const char* group = _get_group(pref);
const char* key = _get_key(pref);
g_key_file_set_boolean(prefs, group, key, value);
}
@@ -655,9 +608,9 @@ prefs_set_boolean(preference_t pref, gboolean value)
gchar*
prefs_get_string(preference_t pref)
{
const gchar* group = _get_group(pref);
const gchar* key = _get_key(pref);
gchar* def = _get_default_string(pref);
const char* group = _get_group(pref);
const char* key = _get_key(pref);
char* def = _get_default_string(pref);
gchar* result = g_key_file_get_string(prefs, group, key, NULL);
@@ -684,9 +637,9 @@ prefs_get_string(preference_t pref)
gchar*
prefs_get_string_with_locale(preference_t pref, gchar* locale)
{
const gchar* group = _get_group(pref);
const gchar* key = _get_key(pref);
gchar* def = _get_default_string(pref);
const char* group = _get_group(pref);
const char* key = _get_key(pref);
char* def = _get_default_string(pref);
gchar* result = g_key_file_get_locale_string(prefs, group, key, locale, NULL);
@@ -715,8 +668,8 @@ prefs_get_string_with_locale(preference_t pref, gchar* locale)
void
prefs_set_string(preference_t pref, const gchar* new_value)
{
const gchar* group = _get_group(pref);
const gchar* key = _get_key(pref);
const char* group = _get_group(pref);
const char* key = _get_key(pref);
if (new_value == NULL) {
g_key_file_remove_key(prefs, group, key, NULL);
} else {
@@ -725,10 +678,10 @@ prefs_set_string(preference_t pref, const gchar* new_value)
}
void
prefs_set_string_with_option(preference_t pref, gchar* option, gchar* value)
prefs_set_string_with_option(preference_t pref, char* option, char* value)
{
const gchar* group = _get_group(pref);
const gchar* key = _get_key(pref);
const char* group = _get_group(pref);
const char* key = _get_key(pref);
if (value == NULL) {
g_key_file_remove_key(prefs, group, key, NULL);
} else {
@@ -737,10 +690,10 @@ prefs_set_string_with_option(preference_t pref, gchar* option, gchar* value)
}
void
prefs_set_string_list_with_option(preference_t pref, gchar* option, const gchar* const* values)
prefs_set_string_list_with_option(preference_t pref, char* option, const gchar* const* values)
{
const gchar* group = _get_group(pref);
const gchar* key = _get_key(pref);
const char* group = _get_group(pref);
const char* key = _get_key(pref);
if (values == NULL || *values == NULL) {
if (g_strcmp0(option, "*") == 0) {
g_key_file_set_string_list(prefs, group, key, NULL, 0);
@@ -760,11 +713,11 @@ prefs_set_string_list_with_option(preference_t pref, gchar* option, const gchar*
}
}
gchar*
char*
prefs_get_tls_certpath(void)
{
const gchar* group = _get_group(PREF_TLS_CERTPATH);
const gchar* key = _get_key(PREF_TLS_CERTPATH);
const char* group = _get_group(PREF_TLS_CERTPATH);
const char* key = _get_key(PREF_TLS_CERTPATH);
auto_gchar gchar* setting = g_key_file_get_string(prefs, group, key, NULL);
@@ -792,7 +745,7 @@ prefs_get_tls_certpath(void)
return NULL;
}
gchar* result = g_strdup(setting);
char* result = strdup(setting);
return result;
}
@@ -996,14 +949,14 @@ prefs_get_plugins(void)
}
void
prefs_add_plugin(const gchar* const name)
prefs_add_plugin(const char* const name)
{
conf_string_list_add(prefs, PREF_GROUP_PLUGINS, "load", name);
_save_prefs();
}
void
prefs_remove_plugin(const gchar* const name)
prefs_remove_plugin(const char* const name)
{
conf_string_list_remove(prefs, PREF_GROUP_PLUGINS, "load", name);
_save_prefs();
@@ -1037,7 +990,7 @@ prefs_get_occupants_char(void)
}
void
prefs_set_occupants_char(gchar* ch)
prefs_set_occupants_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "occupants.char", ch);
@@ -1082,7 +1035,7 @@ prefs_get_occupants_header_char(void)
}
void
prefs_set_occupants_header_char(gchar* ch)
prefs_set_occupants_header_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "occupants.header.char", ch);
@@ -1116,7 +1069,7 @@ prefs_get_roster_size(void)
}
static gchar*
_prefs_get_encryption_char(const gchar* const ch, const gchar* const pref_group, const gchar* const key)
_prefs_get_encryption_char(const char* const ch, const char* const pref_group, const char* const key)
{
gchar* result = NULL;
@@ -1131,7 +1084,7 @@ _prefs_get_encryption_char(const gchar* const ch, const gchar* const pref_group,
}
static gboolean
_prefs_set_encryption_char(const gchar* const ch, const gchar* const pref_group, const gchar* const key)
_prefs_set_encryption_char(const char* const ch, const char* const pref_group, const char* const key)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, pref_group, key, ch);
@@ -1149,7 +1102,7 @@ prefs_get_otr_char(void)
}
gboolean
prefs_set_otr_char(gchar* ch)
prefs_set_otr_char(char* ch)
{
return _prefs_set_encryption_char(ch, PREF_GROUP_OTR, "otr.char");
}
@@ -1161,7 +1114,7 @@ prefs_get_pgp_char(void)
}
gboolean
prefs_set_pgp_char(gchar* ch)
prefs_set_pgp_char(char* ch)
{
return _prefs_set_encryption_char(ch, PREF_GROUP_PGP, "pgp.char");
}
@@ -1173,7 +1126,7 @@ prefs_get_ox_char(void)
}
gboolean
prefs_set_ox_char(gchar* ch)
prefs_set_ox_char(char* ch)
{
return _prefs_set_encryption_char(ch, PREF_GROUP_OX, "ox.char");
}
@@ -1185,7 +1138,7 @@ prefs_get_omemo_char(void)
}
gboolean
prefs_set_omemo_char(gchar* ch)
prefs_set_omemo_char(char* ch)
{
return _prefs_set_encryption_char(ch, PREF_GROUP_OMEMO, "omemo.char");
}
@@ -1197,7 +1150,7 @@ prefs_get_roster_header_char(void)
}
void
prefs_set_roster_header_char(gchar* ch)
prefs_set_roster_header_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "roster.header.char", ch);
@@ -1219,7 +1172,7 @@ prefs_get_roster_contact_char(void)
}
void
prefs_set_roster_contact_char(gchar* ch)
prefs_set_roster_contact_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "roster.contact.char", ch);
@@ -1241,7 +1194,7 @@ prefs_get_roster_resource_char(void)
}
void
prefs_set_roster_resource_char(gchar* ch)
prefs_set_roster_resource_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "roster.resource.char", ch);
@@ -1263,7 +1216,7 @@ prefs_get_roster_private_char(void)
}
void
prefs_set_roster_private_char(gchar* ch)
prefs_set_roster_private_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "roster.private.char", ch);
@@ -1285,7 +1238,7 @@ prefs_get_roster_room_char(void)
}
void
prefs_set_roster_room_char(gchar* ch)
prefs_set_roster_room_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "roster.rooms.char", ch);
@@ -1307,7 +1260,7 @@ prefs_get_roster_room_private_char(void)
}
void
prefs_set_roster_room_private_char(gchar* ch)
prefs_set_roster_room_private_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "roster.rooms.private.char", ch);
@@ -1394,7 +1347,7 @@ prefs_get_correction_char(void)
}
void
prefs_set_correction_char(gchar* ch)
prefs_set_correction_char(char* ch)
{
if (g_utf8_strlen(ch, 4) == 1) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "correction.char", ch);
@@ -1404,7 +1357,7 @@ prefs_set_correction_char(gchar* ch)
}
gboolean
prefs_add_room_notify_trigger(const gchar* const text)
prefs_add_room_notify_trigger(const char* const text)
{
gboolean res = conf_string_list_add(prefs, PREF_GROUP_NOTIFICATIONS, "room.trigger.list", text);
@@ -1416,7 +1369,7 @@ prefs_add_room_notify_trigger(const gchar* const text)
}
gboolean
prefs_remove_room_notify_trigger(const gchar* const text)
prefs_remove_room_notify_trigger(const char* const text)
{
gboolean res = conf_string_list_remove(prefs, PREF_GROUP_NOTIFICATIONS, "room.trigger.list", text);
_save_prefs();
@@ -1435,7 +1388,7 @@ prefs_get_room_notify_triggers(void)
gsize len = 0;
auto_gcharv gchar** triggers = g_key_file_get_string_list(prefs, PREF_GROUP_NOTIFICATIONS, "room.trigger.list", &len, NULL);
for (gsize i = 0; i < len; i++) {
for (int i = 0; i < len; i++) {
result = g_list_append(result, strdup(triggers[i]));
}
@@ -1445,7 +1398,7 @@ prefs_get_room_notify_triggers(void)
ProfWinPlacement*
prefs_create_profwin_placement(int titlebar, int mainwin, int statusbar, int inputwin)
{
ProfWinPlacement* placement = g_new0(ProfWinPlacement, 1);
ProfWinPlacement* placement = malloc(sizeof(ProfWinPlacement));
placement->titlebar_pos = titlebar;
placement->mainwin_pos = mainwin;
placement->statusbar_pos = statusbar;
@@ -1736,7 +1689,7 @@ prefs_inputwin_pos_down(void)
}
gboolean
prefs_add_alias(const gchar* const name, const gchar* const value)
prefs_add_alias(const char* const name, const char* const value)
{
if (g_key_file_has_key(prefs, PREF_GROUP_ALIAS, name, NULL)) {
return FALSE;
@@ -1747,13 +1700,13 @@ prefs_add_alias(const gchar* const name, const gchar* const value)
}
gchar*
prefs_get_alias(const gchar* const name)
prefs_get_alias(const char* const name)
{
return g_key_file_get_string(prefs, PREF_GROUP_ALIAS, name, NULL);
}
gboolean
prefs_remove_alias(const gchar* const name)
prefs_remove_alias(const char* const name)
{
if (!g_key_file_has_key(prefs, PREF_GROUP_ALIAS, name, NULL)) {
return FALSE;
@@ -1782,14 +1735,14 @@ prefs_get_aliases(void)
gsize len;
auto_gcharv gchar** keys = g_key_file_get_keys(prefs, PREF_GROUP_ALIAS, &len, NULL);
for (gsize i = 0; i < len; i++) {
gchar* name = keys[i];
for (int i = 0; i < len; i++) {
char* name = keys[i];
auto_gchar gchar* value = g_key_file_get_string(prefs, PREF_GROUP_ALIAS, name, NULL);
if (value) {
ProfAlias* alias = g_new0(struct prof_alias_t, 1);
alias->name = g_strdup(name);
alias->value = g_strdup(value);
ProfAlias* alias = malloc(sizeof(struct prof_alias_t));
alias->name = strdup(name);
alias->value = strdup(value);
result = g_list_insert_sorted(result, alias, (GCompareFunc)_alias_cmp);
}
@@ -1802,9 +1755,9 @@ prefs_get_aliases(void)
void
_free_alias(ProfAlias* alias)
{
GFREE_SET_NULL(alias->name);
GFREE_SET_NULL(alias->value);
GFREE_SET_NULL(alias);
FREE_SET_NULL(alias->name);
FREE_SET_NULL(alias->value);
FREE_SET_NULL(alias);
}
void
@@ -2182,7 +2135,7 @@ prefs_free_ai_settings(GList* settings)
// get the preference group for a specific preference
// for example the PREF_BEEP setting ("beep" in .profrc, see _get_key) belongs
// to the [ui] section.
static const gchar*
static const char*
_get_group(preference_t pref)
{
switch (pref) {
@@ -2255,7 +2208,6 @@ _get_group(preference_t pref)
case PREF_STATUSBAR_SHOW_NAME:
case PREF_STATUSBAR_SHOW_NUMBER:
case PREF_STATUSBAR_SHOW_READ:
case PREF_STATUSBAR_SHOW_DBBACKEND:
case PREF_STATUSBAR_SELF:
case PREF_STATUSBAR_CHAT:
case PREF_STATUSBAR_ROOM_TITLE:
@@ -2290,7 +2242,6 @@ _get_group(preference_t pref)
case PREF_TRAY:
case PREF_TRAY_READ:
case PREF_ADV_NOTIFY_DISCO_OR_VERSION:
case PREF_AUTOPING_WARNING:
return PREF_GROUP_NOTIFICATIONS;
case PREF_DBLOG:
case PREF_CHLOG:
@@ -2340,9 +2291,6 @@ _get_group(preference_t pref)
return PREF_GROUP_OMEMO;
case PREF_OX_LOG:
return PREF_GROUP_OX;
case PREF_SPELLCHECK_ENABLE:
case PREF_SPELLCHECK_LANG:
return PREF_GROUP_SPELLCHECK;
case PREF_AI_PROVIDER:
case PREF_AI_API_KEY:
return PREF_GROUP_AI;
@@ -2353,7 +2301,7 @@ _get_group(preference_t pref)
// get the key used in .profrc for the preference
// for example the PREF_AUTOAWAY_MODE maps to "autoaway.mode" in .profrc
static const gchar*
static const char*
_get_key(preference_t pref)
{
switch (pref) {
@@ -2587,8 +2535,6 @@ _get_key(preference_t pref)
return "statusbar.show.number";
case PREF_STATUSBAR_SHOW_READ:
return "statusbar.show.read";
case PREF_STATUSBAR_SHOW_DBBACKEND:
return "statusbar.show.dbbackend";
case PREF_STATUSBAR_SELF:
return "statusbar.self";
case PREF_STATUSBAR_CHAT:
@@ -2643,12 +2589,6 @@ _get_key(preference_t pref)
return "force-encryption.enabled";
case PREF_FORCE_ENCRYPTION_MODE:
return "force-encryption.policy";
case PREF_SPELLCHECK_ENABLE:
return "enabled";
case PREF_SPELLCHECK_LANG:
return "lang";
case PREF_AUTOPING_WARNING:
return "autoping.warning";
default:
return NULL;
}
@@ -2688,7 +2628,6 @@ _get_default_boolean(preference_t pref)
case PREF_ROOM_LIST_CACHE:
case PREF_STATUSBAR_SHOW_NUMBER:
case PREF_STATUSBAR_SHOW_READ:
case PREF_STATUSBAR_SHOW_DBBACKEND:
case PREF_REVEAL_OS:
case PREF_CORRECTION_ALLOW:
case PREF_RECEIPTS_SEND:
@@ -2702,9 +2641,7 @@ _get_default_boolean(preference_t pref)
case PREF_MOOD:
case PREF_STROPHE_SM_ENABLED:
case PREF_STROPHE_SM_RESEND:
case PREF_AUTOPING_WARNING:
return TRUE;
case PREF_SPELLCHECK_ENABLE:
case PREF_PGP_PUBKEY_AUTOIMPORT:
case PREF_FORCE_ENCRYPTION:
default:
@@ -2714,7 +2651,7 @@ _get_default_boolean(preference_t pref)
// the default setting for a string type preference
// if it is not specified in .profrc
static gchar*
static char*
_get_default_string(preference_t pref)
{
switch (pref) {
@@ -2815,8 +2752,6 @@ _get_default_string(preference_t pref)
return "on";
case PREF_FORCE_ENCRYPTION_MODE:
return "resend-to-confirm";
case PREF_SPELLCHECK_LANG:
return "en_US";
case PREF_AI_PROVIDER:
return "openai";
case PREF_AI_API_KEY:

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#ifndef CONFIG_PREFERENCES_H
@@ -136,7 +162,6 @@ typedef enum {
PREF_STATUSBAR_SHOW_NAME,
PREF_STATUSBAR_SHOW_NUMBER,
PREF_STATUSBAR_SHOW_READ,
PREF_STATUSBAR_SHOW_DBBACKEND,
PREF_STATUSBAR_SELF,
PREF_STATUSBAR_CHAT,
PREF_STATUSBAR_ROOM_TITLE,
@@ -166,10 +191,7 @@ typedef enum {
PREF_VCARD_PHOTO_CMD,
PREF_STATUSBAR_TABMODE,
PREF_FORCE_ENCRYPTION,
PREF_FORCE_ENCRYPTION_MODE,
PREF_SPELLCHECK_ENABLE,
PREF_SPELLCHECK_LANG,
PREF_AUTOPING_WARNING
PREF_FORCE_ENCRYPTION_MODE
} preference_t;
typedef struct prof_alias_t
@@ -186,16 +208,15 @@ typedef struct prof_winplacement_t
int inputwin_pos;
} ProfWinPlacement;
void prefs_load(const gchar* config_file);
void prefs_changes(void);
void prefs_load(const char* config_file);
void prefs_save(void);
void prefs_close(void);
void prefs_reload(void);
gchar* prefs_autocomplete_boolean_choice(const gchar* const prefix, gboolean previous, void* context);
gchar* prefs_autocomplete_boolean_choice(const char* const prefix, gboolean previous, void* context);
void prefs_reset_boolean_choice(void);
gchar* prefs_autocomplete_room_trigger(const gchar* const prefix, gboolean previous, void* context);
gchar* prefs_autocomplete_room_trigger(const char* const prefix, gboolean previous, void* context);
void prefs_reset_room_trigger_ac(void);
gint prefs_get_gone(void);
@@ -232,42 +253,42 @@ gint prefs_get_autoxa_time(void);
void prefs_set_autoxa_time(gint value);
gchar** prefs_get_plugins(void);
void prefs_add_plugin(const gchar* const name);
void prefs_remove_plugin(const gchar* const name);
void prefs_add_plugin(const char* const name);
void prefs_remove_plugin(const char* const name);
gchar* prefs_get_otr_char(void);
gboolean prefs_set_otr_char(gchar* ch);
gboolean prefs_set_otr_char(char* ch);
gchar* prefs_get_pgp_char(void);
gboolean prefs_set_pgp_char(gchar* ch);
gboolean prefs_set_pgp_char(char* ch);
gchar* prefs_get_omemo_char(void);
gboolean prefs_set_omemo_char(gchar* ch);
gboolean prefs_set_omemo_char(char* ch);
// XEP-0373: OpenPGP for XMPP
char* prefs_get_ox_char(void);
gboolean prefs_set_ox_char(gchar* ch);
gboolean prefs_set_ox_char(char* ch);
gchar* prefs_get_roster_header_char(void);
void prefs_set_roster_header_char(gchar* ch);
void prefs_set_roster_header_char(char* ch);
void prefs_clear_roster_header_char(void);
gchar* prefs_get_roster_contact_char(void);
void prefs_set_roster_contact_char(gchar* ch);
void prefs_set_roster_contact_char(char* ch);
void prefs_clear_roster_contact_char(void);
gchar* prefs_get_roster_resource_char(void);
void prefs_set_roster_resource_char(gchar* ch);
void prefs_set_roster_resource_char(char* ch);
void prefs_clear_roster_resource_char(void);
gchar* prefs_get_roster_private_char(void);
void prefs_set_roster_private_char(gchar* ch);
void prefs_set_roster_private_char(char* ch);
void prefs_clear_roster_private_char(void);
gchar* prefs_get_roster_room_char(void);
void prefs_set_roster_room_char(gchar* ch);
void prefs_set_roster_room_char(char* ch);
void prefs_clear_roster_room_char(void);
gchar* prefs_get_roster_room_private_char(void);
void prefs_set_roster_room_private_char(gchar* ch);
void prefs_set_roster_room_private_char(char* ch);
void prefs_clear_roster_room_private_char(void);
gchar* prefs_get_occupants_char(void);
void prefs_set_occupants_char(gchar* ch);
void prefs_set_occupants_char(char* ch);
void prefs_clear_occupants_char(void);
gchar* prefs_get_occupants_header_char(void);
void prefs_set_occupants_header_char(gchar* ch);
void prefs_set_occupants_header_char(char* ch);
void prefs_clear_occupants_header_char(void);
gint prefs_get_roster_contact_indent(void);
@@ -280,21 +301,21 @@ gint prefs_get_occupants_indent(void);
void prefs_set_occupants_indent(gint value);
gchar* prefs_get_correction_char(void);
void prefs_set_correction_char(gchar* ch);
void prefs_set_correction_char(char* ch);
void prefs_add_login(const gchar* jid);
void prefs_add_login(const char* jid);
void prefs_set_tray_timer(gint value);
gint prefs_get_tray_timer(void);
gboolean prefs_add_alias(const gchar* const name, const gchar* const value);
gboolean prefs_remove_alias(const gchar* const name);
gchar* prefs_get_alias(const gchar* const name);
gboolean prefs_add_alias(const char* const name, const char* const value);
gboolean prefs_remove_alias(const char* const name);
gchar* prefs_get_alias(const char* const name);
GList* prefs_get_aliases(void);
void prefs_free_aliases(GList* aliases);
gboolean prefs_add_room_notify_trigger(const gchar* const text);
gboolean prefs_remove_room_notify_trigger(const gchar* const text);
gboolean prefs_add_room_notify_trigger(const char* const text);
gboolean prefs_remove_room_notify_trigger(const char* const text);
GList* prefs_get_room_notify_triggers(void);
ProfWinPlacement* prefs_get_win_placement(void);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef CONFIG_SCRIPTS_H

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -91,7 +117,6 @@ theme_init(const char* const theme_name)
g_hash_table_insert(defaults, strdup("mention"), strdup("yellow"));
g_hash_table_insert(defaults, strdup("trigger"), strdup("yellow"));
g_hash_table_insert(defaults, strdup("input.text"), strdup("default"));
g_hash_table_insert(defaults, strdup("input.misspelled"), strdup("red"));
g_hash_table_insert(defaults, strdup("main.time"), strdup("default"));
g_hash_table_insert(defaults, strdup("titlebar.text"), strdup("white"));
g_hash_table_insert(defaults, strdup("titlebar.brackets"), strdup("cyan"));
@@ -508,7 +533,7 @@ _theme_find(const char* const theme_name)
g_string_append(path, "/");
g_string_append(path, theme_name);
if (!g_file_test(path->str, G_FILE_TEST_EXISTS)) {
g_string_free(path, TRUE);
g_string_free(path, true);
path = NULL;
}
}
@@ -642,17 +667,25 @@ _theme_prep_fgnd(char* setting, GString* lookup_str, gboolean* bold)
}
}
gchar*
char*
theme_get_string(char* str)
{
gchar* res = g_key_file_get_string(theme, "colours", str, NULL);
if (!res) {
return g_strdup(g_hash_table_lookup(defaults, str));
return strdup(g_hash_table_lookup(defaults, str));
} else {
return res;
}
}
void
theme_free_string(char* str)
{
if (str) {
g_free(str);
}
}
int
theme_hash_attrs(const char* str)
{
@@ -715,9 +748,6 @@ theme_attrs(theme_item_t attrs)
case THEME_INPUT_TEXT:
_theme_prep_fgnd("input.text", lookup_str, &bold);
break;
case THEME_INPUT_MISSPELLED:
_theme_prep_fgnd("input.misspelled", lookup_str, &bold);
break;
case THEME_TIME:
_theme_prep_fgnd("main.time", lookup_str, &bold);
break;

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef CONFIG_THEME_H
@@ -27,7 +53,6 @@ typedef enum {
THEME_MENTION,
THEME_TRIGGER,
THEME_INPUT_TEXT,
THEME_INPUT_MISSPELLED,
THEME_TIME,
THEME_TITLE_TEXT,
THEME_TITLE_BRACKET,
@@ -127,6 +152,7 @@ void theme_close(void);
int theme_hash_attrs(const char* str);
int theme_attrs(theme_item_t attrs);
char* theme_get_string(char* str);
void theme_free_string(char* str);
theme_item_t theme_main_presence_attrs(const char* const presence);
theme_item_t theme_roster_unread_presence_attrs(const char* const presence);
theme_item_t theme_roster_active_presence_attrs(const char* const presence);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -28,7 +54,7 @@ static void _save_tlscerts(void);
static Autocomplete certs_ac;
static gchar* current_fp;
static char* current_fp;
static void
_tlscerts_close(void)
@@ -36,7 +62,7 @@ _tlscerts_close(void)
free_keyfile(&tlscerts_prof_keyfile);
tlscerts = NULL;
g_free(current_fp);
free(current_fp);
current_fp = NULL;
autocomplete_free(certs_ac);
@@ -56,7 +82,7 @@ tlscerts_init(void)
gsize len = 0;
auto_gcharv gchar** groups = g_key_file_get_groups(tlscerts, &len);
for (guint i = 0; i < g_strv_length(groups); i++) {
for (int i = 0; i < g_strv_length(groups); i++) {
autocomplete_add(certs_ac, groups[i]);
}
@@ -64,116 +90,33 @@ tlscerts_init(void)
}
void
tlscerts_set_current(const TLSCertificate* cert)
tlscerts_set_current(const char* const fp)
{
if (current_fp) {
g_free(current_fp);
free(current_fp);
}
current_fp = g_strdup(cert->fingerprint);
current_fp = strdup(fp);
}
gboolean
tlscerts_current_fingerprint_equals(const TLSCertificate* cert)
char*
tlscerts_get_current(void)
{
return g_strcmp0(current_fp, cert->fingerprint) == 0;
return current_fp;
}
void
tlscerts_clear_current(void)
{
if (current_fp) {
g_free(current_fp);
free(current_fp);
current_fp = NULL;
}
}
gboolean
tlscerts_exists(const TLSCertificate* cert)
tlscerts_exists(const char* const fingerprint)
{
return g_key_file_has_group(tlscerts, cert->fingerprint);
}
#define _name_to_tlscert_name(in, cert, which) \
do { \
_name_to_tlscert_name_(in, &cert->which, #which); \
} while (0)
static void
_name_to_tlscert_name_(const char* in, tls_cert_name_t* out, const char* name);
static TLSCertificate*
_tlscerts_new(gchar* fingerprint_sha1, int version, gchar* serialnumber, gchar* subjectname,
gchar* issuername, gchar* notbefore, gchar* notafter,
gchar* key_alg, gchar* signature_alg, gchar* pem,
gchar* fingerprint_sha256, gchar* pubkey_fingerprint)
{
TLSCertificate* cert = g_new0(TLSCertificate, 1);
if (fingerprint_sha256 && fingerprint_sha1) {
cert->fingerprint_sha256 = fingerprint_sha256;
cert->fingerprint_sha1 = fingerprint_sha1;
cert->fingerprint = cert->fingerprint_sha256;
} else {
if (fingerprint_sha256) {
size_t s = strlen(fingerprint_sha256);
switch (s) {
case 40:
cert->fingerprint_sha1 = fingerprint_sha256;
cert->fingerprint = cert->fingerprint_sha1;
break;
case 64:
cert->fingerprint_sha256 = fingerprint_sha256;
cert->fingerprint = cert->fingerprint_sha256;
break;
default:
log_error("fingerprint_sha256 of length %zu unexpected: %s", s, fingerprint_sha256);
}
} else {
cert->fingerprint_sha1 = fingerprint_sha1;
cert->fingerprint = cert->fingerprint_sha1;
}
}
cert->version = version;
cert->serialnumber = serialnumber;
cert->subjectname = subjectname;
cert->issuername = issuername;
cert->notbefore = notbefore;
cert->notafter = notafter;
cert->key_alg = key_alg;
cert->signature_alg = signature_alg;
cert->pem = pem;
cert->pubkey_fingerprint = pubkey_fingerprint;
/* Do this check after assigning all values, in order to not leak them,
* even though the situation is most likely already FUBAR */
if (!fingerprint_sha256 && !fingerprint_sha1) {
log_error("No TLSCertificate w/o fingerprint");
tlscerts_free(cert);
return NULL;
}
_name_to_tlscert_name(subjectname, cert, subject);
_name_to_tlscert_name(issuername, cert, issuer);
return cert;
}
static TLSCertificate*
_get_TLSCertificate(const gchar* fingerprint)
{
int version = g_key_file_get_integer(tlscerts, fingerprint, "version", NULL);
gchar* serialnumber = g_key_file_get_string(tlscerts, fingerprint, "serialnumber", NULL);
gchar* subjectname = g_key_file_get_string(tlscerts, fingerprint, "subjectname", NULL);
gchar* issuername = g_key_file_get_string(tlscerts, fingerprint, "issuername", NULL);
gchar* notbefore = g_key_file_get_string(tlscerts, fingerprint, "start", NULL);
gchar* notafter = g_key_file_get_string(tlscerts, fingerprint, "end", NULL);
gchar* keyalg = g_key_file_get_string(tlscerts, fingerprint, "keyalg", NULL);
gchar* signaturealg = g_key_file_get_string(tlscerts, fingerprint, "signaturealg", NULL);
gchar* fingerprint_sha1 = g_key_file_get_string(tlscerts, fingerprint, "fingerprint_sha1", NULL);
gchar* pubkey_fingerprint = g_key_file_get_string(tlscerts, fingerprint, "pubkey_fingerprint", NULL);
return _tlscerts_new(fingerprint_sha1, version, serialnumber, subjectname, issuername, notbefore,
notafter, keyalg, signaturealg, NULL, g_strdup(fingerprint), pubkey_fingerprint);
return g_key_file_has_group(tlscerts, fingerprint);
}
GList*
@@ -183,81 +126,125 @@ tlscerts_list(void)
gsize len = 0;
auto_gcharv gchar** groups = g_key_file_get_groups(tlscerts, &len);
for (gsize i = 0; i < len; i++) {
res = g_list_append(res, _get_TLSCertificate(groups[i]));
for (int i = 0; i < g_strv_length(groups); i++) {
char* fingerprint = strdup(groups[i]);
int version = g_key_file_get_integer(tlscerts, fingerprint, "version", NULL);
auto_gchar gchar* serialnumber = g_key_file_get_string(tlscerts, fingerprint, "serialnumber", NULL);
auto_gchar gchar* subjectname = g_key_file_get_string(tlscerts, fingerprint, "subjectname", NULL);
auto_gchar gchar* issuername = g_key_file_get_string(tlscerts, fingerprint, "issuername", NULL);
auto_gchar gchar* notbefore = g_key_file_get_string(tlscerts, fingerprint, "start", NULL);
auto_gchar gchar* notafter = g_key_file_get_string(tlscerts, fingerprint, "end", NULL);
auto_gchar gchar* keyalg = g_key_file_get_string(tlscerts, fingerprint, "keyalg", NULL);
auto_gchar gchar* signaturealg = g_key_file_get_string(tlscerts, fingerprint, "signaturealg", NULL);
TLSCertificate* cert = tlscerts_new(fingerprint, version, serialnumber, subjectname, issuername, notbefore,
notafter, keyalg, signaturealg, NULL);
res = g_list_append(res, cert);
}
return res;
}
static void
_name_to_tlscert_name_(const char* in, tls_cert_name_t* out, const char* name)
TLSCertificate*
tlscerts_new(const char* const fingerprint, int version, const char* const serialnumber, const char* const subjectname,
const char* const issuername, const char* const notbefore, const char* const notafter,
const char* const key_alg, const char* const signature_alg, const char* const pem)
{
auto_gcharv gchar** fields = g_strsplit(in, "/", 0);
const guint fields_num = g_strv_length(fields);
for (guint i = 0; i < fields_num; i++) {
TLSCertificate* cert = calloc(1, sizeof(TLSCertificate));
if (fingerprint) {
cert->fingerprint = strdup(fingerprint);
}
cert->version = version;
if (serialnumber) {
cert->serialnumber = strdup(serialnumber);
}
if (subjectname) {
cert->subjectname = strdup(subjectname);
}
if (issuername) {
cert->issuername = strdup(issuername);
}
if (notbefore) {
cert->notbefore = strdup(notbefore);
}
if (notafter) {
cert->notafter = strdup(notafter);
}
if (key_alg) {
cert->key_alg = strdup(key_alg);
}
if (signature_alg) {
cert->signature_alg = strdup(signature_alg);
}
if (pem) {
cert->pem = strdup(pem);
}
auto_gcharv gchar** fields = g_strsplit(subjectname, "/", 0);
for (int i = 0; i < g_strv_length(fields); i++) {
auto_gcharv gchar** keyval = g_strsplit(fields[i], "=", 2);
if (g_strv_length(keyval) == 2) {
#define tls_cert_name_set(which) \
do { \
if (out->which) { \
log_warning("%s." #which " already set, skip %s", name, keyval[1]); \
continue; \
} \
out->which = g_strdup(keyval[1]); \
} while (0)
if ((g_strcmp0(keyval[0], "C") == 0) || (g_strcmp0(keyval[0], "countryName") == 0)) {
tls_cert_name_set(country);
cert->subject_country = strdup(keyval[1]);
}
if ((g_strcmp0(keyval[0], "ST") == 0) || (g_strcmp0(keyval[0], "stateOrProvinceName") == 0)) {
tls_cert_name_set(state);
cert->subject_state = strdup(keyval[1]);
}
if (g_strcmp0(keyval[0], "dnQualifier") == 0) {
tls_cert_name_set(distinguishedname);
cert->subject_distinguishedname = strdup(keyval[1]);
}
if (g_strcmp0(keyval[0], "serialnumber") == 0) {
tls_cert_name_set(serialnumber);
cert->subject_serialnumber = strdup(keyval[1]);
}
if ((g_strcmp0(keyval[0], "CN") == 0) || (g_strcmp0(keyval[0], "commonName") == 0)) {
tls_cert_name_set(commonname);
cert->subject_commonname = strdup(keyval[1]);
}
if ((g_strcmp0(keyval[0], "O") == 0) || (g_strcmp0(keyval[0], "organizationName") == 0)) {
tls_cert_name_set(organisation);
cert->subject_organisation = strdup(keyval[1]);
}
if ((g_strcmp0(keyval[0], "OU") == 0) || (g_strcmp0(keyval[0], "organizationalUnitName") == 0)) {
tls_cert_name_set(organisation_unit);
cert->subject_organisation_unit = strdup(keyval[1]);
}
if (g_strcmp0(keyval[0], "emailAddress") == 0) {
tls_cert_name_set(email);
cert->subject_email = strdup(keyval[1]);
}
#undef tls_cert_name_set
}
}
}
TLSCertificate*
tlscerts_new(const char* fingerprint_sha1, int version, const char* serialnumber, const char* subjectname,
const char* issuername, const char* notbefore, const char* notafter,
const char* key_alg, const char* signature_alg, const char* pem,
const char* fingerprint_sha256, const char* pubkey_fingerprint)
{
return _tlscerts_new(g_strdup(fingerprint_sha1), version, g_strdup(serialnumber), g_strdup(subjectname),
g_strdup(issuername), g_strdup(notbefore), g_strdup(notafter),
g_strdup(key_alg), g_strdup(signature_alg), g_strdup(pem),
g_strdup(fingerprint_sha256), g_strdup(pubkey_fingerprint));
}
auto_gcharv gchar** fields2 = g_strsplit(issuername, "/", 0);
for (int i = 0; i < g_strv_length(fields2); i++) {
auto_gcharv gchar** keyval = g_strsplit(fields2[i], "=", 2);
if (g_strv_length(keyval) == 2) {
if ((g_strcmp0(keyval[0], "C") == 0) || (g_strcmp0(keyval[0], "countryName") == 0)) {
cert->issuer_country = strdup(keyval[1]);
}
if ((g_strcmp0(keyval[0], "ST") == 0) || (g_strcmp0(keyval[0], "stateOrProvinceName") == 0)) {
cert->issuer_state = strdup(keyval[1]);
}
if (g_strcmp0(keyval[0], "dnQualifier") == 0) {
cert->issuer_distinguishedname = strdup(keyval[1]);
}
if (g_strcmp0(keyval[0], "serialnumber") == 0) {
cert->issuer_serialnumber = strdup(keyval[1]);
}
if ((g_strcmp0(keyval[0], "CN") == 0) || (g_strcmp0(keyval[0], "commonName") == 0)) {
cert->issuer_commonname = strdup(keyval[1]);
}
if ((g_strcmp0(keyval[0], "O") == 0) || (g_strcmp0(keyval[0], "organizationName") == 0)) {
cert->issuer_organisation = strdup(keyval[1]);
}
if ((g_strcmp0(keyval[0], "OU") == 0) || (g_strcmp0(keyval[0], "organizationalUnitName") == 0)) {
cert->issuer_organisation_unit = strdup(keyval[1]);
}
if (g_strcmp0(keyval[0], "emailAddress") == 0) {
cert->issuer_email = strdup(keyval[1]);
}
}
}
static void
_checked_g_key_file_set_string(GKeyFile* key_file,
const gchar* group_name,
const gchar* key,
const gchar* string)
{
if (string == NULL)
return;
g_key_file_set_string(key_file, group_name, key, string);
return cert;
}
void
@@ -274,21 +261,33 @@ tlscerts_add(const TLSCertificate* cert)
autocomplete_add(certs_ac, cert->fingerprint);
g_key_file_set_integer(tlscerts, cert->fingerprint, "version", cert->version);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "serialnumber", cert->serialnumber);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "subjectname", cert->subjectname);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "issuername", cert->issuername);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "start", cert->notbefore);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "end", cert->notafter);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "keyalg", cert->key_alg);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "signaturealg", cert->signature_alg);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "fingerprint_sha1", cert->fingerprint_sha1);
_checked_g_key_file_set_string(tlscerts, cert->fingerprint, "pubkey_fingerprint", cert->pubkey_fingerprint);
if (cert->serialnumber) {
g_key_file_set_string(tlscerts, cert->fingerprint, "serialnumber", cert->serialnumber);
}
if (cert->subjectname) {
g_key_file_set_string(tlscerts, cert->fingerprint, "subjectname", cert->subjectname);
}
if (cert->issuername) {
g_key_file_set_string(tlscerts, cert->fingerprint, "issuername", cert->issuername);
}
if (cert->notbefore) {
g_key_file_set_string(tlscerts, cert->fingerprint, "start", cert->notbefore);
}
if (cert->notafter) {
g_key_file_set_string(tlscerts, cert->fingerprint, "end", cert->notafter);
}
if (cert->key_alg) {
g_key_file_set_string(tlscerts, cert->fingerprint, "keyalg", cert->key_alg);
}
if (cert->signature_alg) {
g_key_file_set_string(tlscerts, cert->fingerprint, "signaturealg", cert->signature_alg);
}
_save_tlscerts();
}
gboolean
tlscerts_revoke(const char* fingerprint)
tlscerts_revoke(const char* const fingerprint)
{
gboolean result = g_key_file_remove_group(tlscerts, fingerprint, NULL);
if (result) {
@@ -301,24 +300,28 @@ tlscerts_revoke(const char* fingerprint)
}
TLSCertificate*
tlscerts_get_trusted(const gchar* fingerprint)
tlscerts_get_trusted(const char* const fingerprint)
{
if (!g_key_file_has_group(tlscerts, fingerprint)) {
gsize len = 0;
auto_gcharv gchar** groups = g_key_file_get_groups(tlscerts, &len);
for (gsize i = 0; i < len; i++) {
auto_gchar gchar* fingerprint_sha1 = g_key_file_get_string(tlscerts, groups[i], "fingerprint_sha1", NULL);
if (g_strcmp0(fingerprint, fingerprint_sha1) == 0) {
return _get_TLSCertificate(fingerprint_sha1);
}
}
return NULL;
}
return _get_TLSCertificate(fingerprint);
int version = g_key_file_get_integer(tlscerts, fingerprint, "version", NULL);
auto_gchar gchar* serialnumber = g_key_file_get_string(tlscerts, fingerprint, "serialnumber", NULL);
auto_gchar gchar* subjectname = g_key_file_get_string(tlscerts, fingerprint, "subjectname", NULL);
auto_gchar gchar* issuername = g_key_file_get_string(tlscerts, fingerprint, "issuername", NULL);
auto_gchar gchar* notbefore = g_key_file_get_string(tlscerts, fingerprint, "start", NULL);
auto_gchar gchar* notafter = g_key_file_get_string(tlscerts, fingerprint, "end", NULL);
auto_gchar gchar* keyalg = g_key_file_get_string(tlscerts, fingerprint, "keyalg", NULL);
auto_gchar gchar* signaturealg = g_key_file_get_string(tlscerts, fingerprint, "signaturealg", NULL);
TLSCertificate* cert = tlscerts_new(fingerprint, version, serialnumber, subjectname, issuername, notbefore,
notafter, keyalg, signaturealg, NULL);
return cert;
}
char*
tlscerts_complete(const char* prefix, gboolean previous, void* context)
tlscerts_complete(const char* const prefix, gboolean previous, void* context)
{
return autocomplete_complete(certs_ac, prefix, TRUE, previous);
}
@@ -329,37 +332,40 @@ tlscerts_reset_ac(void)
autocomplete_reset(certs_ac);
}
static void
_tls_cert_name_free(tls_cert_name_t* name)
{
g_free(name->country);
g_free(name->state);
g_free(name->distinguishedname);
g_free(name->serialnumber);
g_free(name->commonname);
g_free(name->organisation);
g_free(name->organisation_unit);
g_free(name->email);
}
void
tlscerts_free(TLSCertificate* cert)
{
if (cert) {
_tls_cert_name_free(&cert->subject);
_tls_cert_name_free(&cert->issuer);
free(cert->serialnumber);
g_free(cert->pubkey_fingerprint);
g_free(cert->pem);
g_free(cert->signature_alg);
g_free(cert->key_alg);
g_free(cert->notafter);
g_free(cert->notbefore);
g_free(cert->issuername);
g_free(cert->subjectname);
g_free(cert->serialnumber);
g_free(cert->fingerprint_sha1);
g_free(cert->fingerprint_sha256);
free(cert->subjectname);
free(cert->subject_country);
free(cert->subject_state);
free(cert->subject_distinguishedname);
free(cert->subject_serialnumber);
free(cert->subject_commonname);
free(cert->subject_organisation);
free(cert->subject_organisation_unit);
free(cert->subject_email);
free(cert->issuername);
free(cert->issuer_country);
free(cert->issuer_state);
free(cert->issuer_distinguishedname);
free(cert->issuer_serialnumber);
free(cert->issuer_commonname);
free(cert->issuer_organisation);
free(cert->issuer_organisation_unit);
free(cert->issuer_email);
free(cert->notbefore);
free(cert->notafter);
free(cert->fingerprint);
free(cert->key_alg);
free(cert->signature_alg);
free(cert->pem);
free(cert);
}

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef CONFIG_TLSCERTS_H
@@ -12,63 +38,61 @@
#include <glib.h>
typedef struct tls_cert_name_t
{
gchar* country;
gchar* state;
gchar* distinguishedname;
gchar* serialnumber;
gchar* commonname;
gchar* organisation;
gchar* organisation_unit;
gchar* email;
} tls_cert_name_t;
typedef struct tls_cert_t
{
int version;
const gchar* fingerprint;
gchar* serialnumber;
gchar* subjectname;
tls_cert_name_t subject;
gchar* issuername;
tls_cert_name_t issuer;
gchar* notbefore;
gchar* notafter;
gchar* fingerprint_sha1;
gchar* fingerprint_sha256;
gchar* key_alg;
gchar* signature_alg;
gchar* pem;
gchar* pubkey_fingerprint;
char* serialnumber;
char* subjectname;
char* subject_country;
char* subject_state;
char* subject_distinguishedname;
char* subject_serialnumber;
char* subject_commonname;
char* subject_organisation;
char* subject_organisation_unit;
char* subject_email;
char* issuername;
char* issuer_country;
char* issuer_state;
char* issuer_distinguishedname;
char* issuer_serialnumber;
char* issuer_commonname;
char* issuer_organisation;
char* issuer_organisation_unit;
char* issuer_email;
char* notbefore;
char* notafter;
char* fingerprint;
char* key_alg;
char* signature_alg;
char* pem;
} TLSCertificate;
void tlscerts_init(void);
TLSCertificate* tlscerts_new(const char* fingerprint_sha1, int version, const char* serialnumber, const char* subjectname,
const char* issuername, const char* notbefore, const char* notafter,
const char* key_alg, const char* signature_alg, const char* pem,
const char* fingerprint_sha256, const char* pubkey_fingerprint);
TLSCertificate* tlscerts_new(const char* const fingerprint, int version, const char* const serialnumber, const char* const subjectname,
const char* const issuername, const char* const notbefore, const char* const notafter,
const char* const key_alg, const char* const signature_alg, const char* const pem);
void tlscerts_set_current(const TLSCertificate* cert);
void tlscerts_set_current(const char* const fp);
gboolean tlscerts_current_fingerprint_equals(const TLSCertificate* cert);
char* tlscerts_get_current(void);
void tlscerts_clear_current(void);
gboolean tlscerts_exists(const TLSCertificate* cert);
gboolean tlscerts_exists(const char* const fingerprint);
void tlscerts_add(const TLSCertificate* cert);
gboolean tlscerts_revoke(const char* fingerprint);
gboolean tlscerts_revoke(const char* const fingerprint);
TLSCertificate* tlscerts_get_trusted(const char* fingerprint);
TLSCertificate* tlscerts_get_trusted(const char* const fingerprint);
void tlscerts_free(TLSCertificate* cert);
GList* tlscerts_list(void);
char* tlscerts_complete(const char* prefix, gboolean previous, void* context);
char* tlscerts_complete(const char* const prefix, gboolean previous, void* context);
void tlscerts_reset_ac(void);

View File

@@ -61,22 +61,6 @@ integrity_issue_free(integrity_issue_t* issue)
}
}
gboolean
log_database_can_recover_messages(void)
{
if (!active_db_backend) {
return FALSE;
}
auto_gchar gchar* pref_dblog = prefs_get_string(PREF_DBLOG);
if (g_strcmp0(pref_dblog, "off") == 0) {
return FALSE;
}
if (g_strcmp0(pref_dblog, "redact") == 0) {
return FALSE;
}
return TRUE;
}
gboolean
log_database_init(ProfAccount* account)
{

View File

@@ -2,9 +2,35 @@
* database.h
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2020 - 2026 Michael Vetter <jubalh@iodoru.org>
* 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#ifndef DATABASE_H
@@ -83,9 +109,6 @@ ProfMessage* log_database_get_limits_info(const gchar* const contact_barejid, gb
void log_database_close(void);
GSList* log_database_verify_integrity(const gchar* const contact_barejid);
// FALSE if no backend, or PREF_DBLOG is "off" / "redact".
gboolean log_database_can_recover_messages(void);
// Cross-backend export/import (requires HAVE_SQLITE)
#ifdef HAVE_SQLITE
int log_database_export_to_flatfile(const gchar* const contact_jid);

View File

@@ -282,7 +282,7 @@ _export_one_contact(const char* contact)
gchar* key = _make_dedup_key(pl->stanza_id, pl->timestamp_str, pl->from_jid, pl->message);
g_hash_table_add(seen_keys, key);
}
int existing_count = (int)g_slist_length(existing);
int existing_count = g_slist_length(existing);
// 2. Query SQLite for this contact — get ALL messages via direct SQL
GSList* sqlite_lines = db_sqlite_get_all_chat(contact);
@@ -581,7 +581,7 @@ log_database_import_from_flatfile(const gchar* const contact_jid)
// Wrap in a transaction for atomicity and performance
int contact_imported = 0;
int contact_skipped = 0;
int total_lines = (int)g_slist_length(ff_lines);
int total_lines = g_slist_length(ff_lines);
db_sqlite_begin_transaction();
gboolean import_ok = TRUE;

View File

@@ -88,8 +88,9 @@ _ff_cache_line_ids(ff_contact_state_t* state, const char* line)
return;
// Split metadata on unescaped '|'
auto_gchar gchar* meta_str = g_strndup(bracket + 1, g_diff_to_gsize(close, bracket + 1));
char* meta_str = g_strndup(bracket + 1, close - bracket - 1);
char** parts = ff_split_meta(meta_str);
g_free(meta_str);
char* stanza_id = NULL;
char* archive_id = NULL;
@@ -111,9 +112,9 @@ _ff_cache_line_ids(ff_contact_state_t* state, const char* line)
const char* sender_start = close + 2;
const char* colonspace = ff_find_unescaped_colonspace(sender_start);
if (colonspace) {
const char* slash = memchr(sender_start, '/', g_diff_to_gsize(colonspace, sender_start));
const char* slash = memchr(sender_start, '/', colonspace - sender_start);
const char* jid_end = slash ? slash : colonspace;
from_jid = g_strndup(sender_start, g_diff_to_gsize(jid_end, sender_start));
from_jid = g_strndup(sender_start, jid_end - sender_start);
}
}
@@ -140,13 +141,15 @@ _ff_maybe_index_line(ff_contact_state_t* state, const char* buf, off_t pos)
if (!space)
return;
auto_gchar gchar* ts_str = g_strndup(buf, g_diff_to_gsize(space, buf));
char* ts_str = g_strndup(buf, space - buf);
GDateTime* dt = g_date_time_new_from_iso8601(ts_str, NULL);
if (!dt) {
log_warning("flatfile: unparsable timestamp in %s at offset %ld: %s",
state->filepath, (long)pos, ts_str);
g_free(ts_str);
return;
}
g_free(ts_str);
if (state->n_entries >= state->cap_entries) {
state->cap_entries = state->cap_entries ? state->cap_entries * 2 : 64;
@@ -771,7 +774,7 @@ _flatfile_get_previous_chat(const gchar* const contact_barejid, const gchar* sta
// For "last N messages": back up from read_to using index
if (!from_start) {
size_t margin_entries = (MESSAGES_TO_RETRIEVE * 3) / FF_INDEX_STEP + 2;
int margin_entries = (MESSAGES_TO_RETRIEVE * 3) / FF_INDEX_STEP + 2;
// Find index entry closest to (but before) read_to
size_t entry_idx = 0;
@@ -781,7 +784,7 @@ _flatfile_get_previous_chat(const gchar* const contact_barejid, const gchar* sta
entry_idx = i;
}
size_t start_entry = entry_idx > margin_entries
size_t start_entry = entry_idx > (size_t)margin_entries
? entry_idx - margin_entries
: 0;
off_t backed = state->entries[start_entry].byte_offset;

View File

@@ -553,7 +553,7 @@ ff_split_meta(const char* meta)
continue;
}
if (*p == '|' || *p == '\0') {
g_ptr_array_add(arr, g_strndup(start, g_diff_to_gsize(p, start)));
g_ptr_array_add(arr, g_strndup(start, p - start));
if (*p == '\0')
break;
start = p + 1;
@@ -710,7 +710,7 @@ ff_parse_line(const char* line)
if (bracket_start && first_space && first_space < bracket_start) {
// Standard format with metadata: {timestamp} [{meta}] {sender}: {msg}
result->timestamp_str = g_strndup(work, g_diff_to_gsize(first_space, work));
result->timestamp_str = g_strndup(work, first_space - work);
// Parse metadata section [...]
const char* bracket_end = ff_find_unescaped_char(bracket_start + 1, ']');
@@ -721,7 +721,7 @@ ff_parse_line(const char* line)
return NULL;
}
auto_gchar gchar* meta_content = g_strndup(bracket_start + 1, g_diff_to_gsize(bracket_end, bracket_start + 1));
auto_gchar gchar* meta_content = g_strndup(bracket_start + 1, bracket_end - bracket_start - 1);
char** parts = ff_split_meta(meta_content);
if (parts) {
_ff_parse_meta_parts(parts, result);
@@ -736,12 +736,12 @@ ff_parse_line(const char* line)
// Find first *unescaped* ': ' which separates sender from message.
const char* colon = ff_find_unescaped_colonspace(after_meta);
if (colon) {
auto_gchar gchar* raw_sender = g_strndup(after_meta, g_diff_to_gsize(colon, after_meta));
auto_gchar gchar* raw_sender = g_strndup(after_meta, colon - after_meta);
// Split sender into jid/resource, then unescape resource
char* slash = strchr(raw_sender, '/');
if (slash) {
result->from_jid = g_strndup(raw_sender, g_diff_to_gsize(slash, raw_sender));
result->from_jid = g_strndup(raw_sender, slash - raw_sender);
result->from_resource = ff_unescape_sender_resource(slash + 1);
} else {
result->from_jid = g_strdup(raw_sender);
@@ -755,7 +755,7 @@ ff_parse_line(const char* line)
}
} else if (first_space) {
// Legacy/simple format without metadata: {timestamp} - {sender}: {msg}
result->timestamp_str = g_strndup(work, g_diff_to_gsize(first_space, work));
result->timestamp_str = g_strndup(work, first_space - work);
result->type = g_strdup("chat");
result->enc = g_strdup("none");
@@ -767,10 +767,10 @@ ff_parse_line(const char* line)
char* colon = strstr(rest, ": ");
if (colon) {
char* sender = g_strndup(rest, g_diff_to_gsize(colon, rest));
char* sender = g_strndup(rest, colon - rest);
char* slash = strchr(sender, '/');
if (slash) {
result->from_jid = g_strndup(sender, g_diff_to_gsize(slash, sender));
result->from_jid = g_strndup(sender, slash - sender);
result->from_resource = g_strdup(slash + 1);
} else {
result->from_jid = g_strdup(sender);

View File

@@ -211,13 +211,9 @@ _first_pass(FILE* fp, const char* basename,
if (pl->stanza_id && pl->stanza_id[0] != '\0') {
if (g_hash_table_contains(seen_stanza_ids, pl->stanza_id)) {
// Older clients (Pidgin, Adium, even early Profanity)
// sometimes reuse client-generated stanza-ids across
// distinct messages, so a collision is not a real
// integrity defect — log it for diagnostics but don't
// surface it through /history verify.
log_debug("flatfile verify: duplicate stanza-id \"%s\" at %s:%d",
pl->stanza_id, basename, lineno);
*issues = g_slist_prepend(*issues,
_issue_new(INTEGRITY_WARNING, basename, lineno,
g_strdup_printf("Duplicate stanza-id \"%s\"", pl->stanza_id)));
} else {
g_hash_table_insert(seen_stanza_ids, g_strdup(pl->stanza_id), GINT_TO_POINTER(lineno));
}
@@ -306,13 +302,7 @@ _verify_contact_dir(const char* cdir_path, GSList** issues)
return;
}
// Reconstruct the contact JID from the directory name so issue reports
// identify which contact the problem belongs to (every contact has its
// own history.log, so the bare filename is ambiguous).
auto_gchar gchar* dir_name = g_path_get_basename(cdir_path);
auto_gcharv gchar** parts = g_strsplit(dir_name, "_at_", -1);
auto_gchar gchar* contact_jid = g_strjoinv("@", parts);
auto_gchar gchar* basename = g_strdup_printf("%s/history.log", contact_jid);
const char* basename = "history.log";
_check_permissions(filepath, basename, issues);

View File

@@ -61,10 +61,9 @@ 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 _migrate_to_v3(void);
static gboolean _check_available_space_for_db_migration(char* path_to_db);
static const int latest_version = 3;
static const int latest_version = 2;
gboolean
db_sqlite_is_open(void)
@@ -188,7 +187,7 @@ _sqlite_init(ProfAccount* account)
"`timestamp` TEXT, "
"`type` TEXT, "
"`stanza_id` TEXT, "
"`archive_id` TEXT UNIQUE, "
"`archive_id` TEXT, "
"`encryption` TEXT, "
"`marked_read` INTEGER, "
"`replace_id` TEXT, "
@@ -229,14 +228,8 @@ _sqlite_init(ProfAccount* account)
}
if (db_version == -1) {
auto_sqlite char* init_version_query = sqlite3_mprintf(
"INSERT INTO `DbVersion` (`version`) VALUES (%d) ON CONFLICT(`version`) DO NOTHING",
latest_version);
if (!init_version_query) {
log_error("OOM allocating initial DbVersion insert query");
goto out;
}
if (SQLITE_OK != sqlite3_exec(g_chatlog_database, init_version_query, NULL, 0, &err_msg)) {
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();
@@ -253,10 +246,6 @@ _sqlite_init(ProfAccount* account)
cons_show_error("Database Initialization Error: Unable to migrate database to version 2. Please, check error logs for details.");
goto out;
}
if (db_version < 3 && (!_check_available_space_for_db_migration(filename) || !_migrate_to_v3())) {
cons_show_error("Database Initialization Error: Unable to migrate database to version 3. Please, check error logs for details.");
goto out;
}
cons_show("Database schema migration was successful.");
}
@@ -477,36 +466,23 @@ _sqlite_verify_integrity(const gchar* const contact_barejid)
sqlite3_finalize(stmt);
}
// Check timestamp ordering, restricted to consecutive rows belonging
// to the same conversation pair so adjacency does not span unrelated
// contacts. Adjacent rows by id from different conversations are
// legitimately out-of-order and should not be reported.
// 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`, A.`from_jid`, A.`to_jid`, B.`id`, B.`timestamp` "
"FROM `ChatLogs` A "
"JOIN `ChatLogs` B ON B.`from_jid` = A.`from_jid` AND B.`to_jid` = A.`to_jid` "
" AND B.`id` > A.`id` "
"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)) "
"AND NOT EXISTS (SELECT 1 FROM `ChatLogs` C "
" WHERE C.`from_jid` = A.`from_jid` AND C.`to_jid` = A.`to_jid` "
" AND C.`id` > A.`id` AND C.`id` < B.`id`) "
"LIMIT 50",
contact_barejid, myjid->barejid, myjid->barejid, contact_barejid);
} else {
query = sqlite3_mprintf(
"SELECT A.`id`, A.`timestamp`, A.`from_jid`, A.`to_jid`, B.`id`, B.`timestamp` "
"FROM `ChatLogs` A "
"JOIN `ChatLogs` B ON B.`from_jid` = A.`from_jid` AND B.`to_jid` = A.`to_jid` "
" AND B.`id` > A.`id` "
"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 NOT EXISTS (SELECT 1 FROM `ChatLogs` C "
" WHERE C.`from_jid` = A.`from_jid` AND C.`to_jid` = A.`to_jid` "
" AND C.`id` > A.`id` AND C.`id` < B.`id`) "
"LIMIT 50");
}
@@ -514,19 +490,15 @@ _sqlite_verify_integrity(const gchar* const contact_barejid)
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);
const char* from_a = (const char*)sqlite3_column_text(stmt, 2);
const char* to_a = (const char*)sqlite3_column_text(stmt, 3);
int id_b = sqlite3_column_int(stmt, 4);
const char* ts_b = (const char*)sqlite3_column_text(stmt, 5);
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_printf("%s↔%s/chatlog.db",
from_a ? from_a : "?", to_a ? to_a : "?");
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");
id_a, ts_a ? ts_a : "NULL", id_b, ts_b ? ts_b : "NULL");
issues = g_slist_append(issues, issue);
}
sqlite3_finalize(stmt);
@@ -534,7 +506,7 @@ _sqlite_verify_integrity(const gchar* const contact_barejid)
// Check broken LMC references
auto_sqlite char* lmc_query = sqlite3_mprintf(
"SELECT A.`id`, A.`replaces_db_id`, A.`from_jid`, A.`to_jid` FROM `ChatLogs` A "
"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");
@@ -543,13 +515,10 @@ _sqlite_verify_integrity(const gchar* const contact_barejid)
while (sqlite3_step(stmt) == SQLITE_ROW) {
int id = sqlite3_column_int(stmt, 0);
int replaces_id = sqlite3_column_int(stmt, 1);
const char* from = (const char*)sqlite3_column_text(stmt, 2);
const char* to = (const char*)sqlite3_column_text(stmt, 3);
integrity_issue_t* issue = g_malloc0(sizeof(integrity_issue_t));
issue->level = INTEGRITY_ERROR;
issue->file = g_strdup_printf("%s↔%s/chatlog.db",
from ? from : "?", to ? to : "?");
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);
@@ -810,8 +779,7 @@ _migrate_to_v2(void)
"replace_id = COALESCE(NULLIF(replace_id, ''), NULL), "
"type = COALESCE(NULLIF(type, ''), NULL), "
"encryption = COALESCE(NULLIF(encryption, ''), NULL);",
"DELETE FROM `DbVersion`;",
"INSERT INTO `DbVersion` (`version`) VALUES (2);",
"UPDATE `DbVersion` SET `version` = 2;",
"END TRANSACTION"
};
@@ -841,82 +809,6 @@ cleanup:
return FALSE;
}
static gboolean
_migrate_to_v3(void)
{
char* err_msg = NULL;
const char* sql_statements[] = {
"BEGIN TRANSACTION",
"CREATE TABLE `ChatLogs_v3_migration` ("
"`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 UNIQUE, "
"`encryption` TEXT, "
"`marked_read` INTEGER, "
"`replace_id` TEXT, "
"`replaces_db_id` INTEGER, "
"`replaced_by_db_id` INTEGER)",
"INSERT INTO `ChatLogs_v3_migration` "
"SELECT * FROM `ChatLogs` "
"WHERE `archive_id` IS NULL "
"UNION ALL "
"SELECT * FROM (SELECT * FROM `ChatLogs` WHERE `archive_id` IS NOT NULL GROUP BY `archive_id`)",
"DROP TABLE `ChatLogs` ",
"ALTER TABLE `ChatLogs_v3_migration` RENAME TO `ChatLogs` ",
"CREATE INDEX ChatLogs_timestamp_IDX ON `ChatLogs` (`timestamp`)",
"CREATE INDEX ChatLogs_to_from_jid_IDX ON `ChatLogs` (`to_jid`, `from_jid`)",
"CREATE TRIGGER 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;",
"DELETE FROM `DbVersion`;",
"INSERT INTO `DbVersion` (`version`) VALUES (3);",
"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_v3() 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)
{

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -94,7 +120,7 @@ cl_ev_reconnect(void)
void
cl_ev_presence_send(const resource_presence_t presence_type, const int idle_secs)
{
auto_gchar gchar* signed_status = NULL;
auto_char char* signed_status = NULL;
#ifdef HAVE_LIBGPGME
ProfAccount* account = accounts_get_account(session_get_account_name());
@@ -113,19 +139,9 @@ cl_ev_send_msg_correct(ProfChatWin* chatwin, const char* const msg, const char*
chat_state_active(chatwin->state);
gboolean request_receipt = prefs_get_boolean(PREF_RECEIPTS_REQUEST);
if (request_receipt) {
auto_char char* jid = chat_session_get_jid(chatwin->barejid);
EntityCapabilities* caps = caps_lookup(jid);
if (caps != NULL) {
GSList* found = g_slist_find_custom(caps->features, XMPP_FEATURE_RECEIPTS, (GCompareFunc)g_strcmp0);
request_receipt = (found != NULL);
caps_destroy(caps);
}
}
auto_char char* plugin_msg = plugins_pre_chat_message_send(chatwin->barejid, msg);
auto_gchar gchar* sanitized_msg = str_xml_sanitize(plugin_msg ?: msg);
const char* message = sanitized_msg;
const char* const message = plugin_msg ?: msg;
char* replace_id = NULL;
if (correct_last_msg) {
@@ -187,8 +203,7 @@ void
cl_ev_send_muc_msg_corrected(ProfMucWin* mucwin, const char* const msg, const char* const oob_url, gboolean correct_last_msg)
{
auto_char char* plugin_msg = plugins_pre_room_message_send(mucwin->roomjid, msg);
auto_gchar gchar* sanitized_msg = str_xml_sanitize(plugin_msg ?: msg);
const char* message = sanitized_msg;
const char* const message = plugin_msg ?: msg;
char* replace_id = NULL;
if (correct_last_msg) {
@@ -229,8 +244,7 @@ cl_ev_send_priv_msg(ProfPrivateWin* privwin, const char* const msg, const char*
privwin_message_left_room(privwin);
} else {
auto_char char* plugin_msg = plugins_pre_priv_message_send(privwin->fulljid, msg);
auto_gchar gchar* sanitized_msg = str_xml_sanitize(plugin_msg ?: msg);
const char* message = sanitized_msg;
const char* const message = plugin_msg ?: msg;
auto_jid Jid* jidp = jid_create(privwin->fulljid);
auto_char char* id = message_send_private(privwin->fulljid, message, oob_url);
@@ -287,6 +301,12 @@ cl_ev_send_ai_msg(ProfAiWin* aiwin, const char* const message, const char* const
return;
}
/* Reset paged flag before printing user message.
* If the user scrolled up to view history, paged=1 would suppress
* the message in _win_printf(). Reset it here so the message displays. */
aiwin->window.layout->paged = 0;
aiwin->window.layout->unread_msg = 0;
// Display user message in AI window.
win_print_outgoing(&aiwin->window, ">>", id, NULL, message);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef EVENT_CLIENT_EVENTS_H

View File

@@ -2,9 +2,35 @@
* common.c
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"

View File

@@ -2,16 +2,40 @@
* common.h
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#ifndef EVENT_COMMON_H
#define EVENT_COMMON_H
#include "glib.h"
void ev_disconnect_cleanup(void);
void ev_inc_connection_counter(void);
void ev_reset_connection_counter(void);

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -60,10 +86,6 @@ void
sv_ev_login_account_success(char* account_name, gboolean secured)
{
ProfAccount* account = accounts_get_account(account_name);
if (!account) {
log_error("Could not find account: %s", account_name);
return;
}
bookmark_ignore_on_connect(account->jid);
@@ -81,9 +103,7 @@ sv_ev_login_account_success(char* account_name, gboolean secured)
omemo_on_connect(account);
#endif
if (!log_database_init(account)) {
log_error("Failed to initialize database for account: %s", account->jid);
}
log_database_init(account);
vcard_user_refresh();
avatar_pep_subscribe();
@@ -156,7 +176,7 @@ sv_ev_roster_received(void)
GDateTime* lastdt = g_date_time_new_from_timeval_utc(&lasttv);
GTimeSpan diff_micros = g_date_time_difference(nowdt, lastdt);
diff_secs = (int)((diff_micros / 1000) / 1000);
diff_secs = (diff_micros / 1000) / 1000;
g_date_time_unref(lastdt);
}
g_date_time_unref(nowdt);
@@ -341,7 +361,7 @@ sv_ev_room_message(ProfMessage* message)
status_bar_active(num, WIN_MUC, mucwin->roomjid);
if ((g_strcmp0(mynick, message->from_jid->resourcepart) != 0) && (prefs_get_boolean(PREF_BEEP))) {
ui_beep();
beep();
}
// not currently on groupchat window
@@ -349,7 +369,7 @@ sv_ev_room_message(ProfMessage* message)
status_bar_new(num, WIN_MUC, mucwin->roomjid);
if ((g_strcmp0(mynick, message->from_jid->resourcepart) != 0) && (prefs_get_boolean(PREF_FLASH))) {
ui_flash();
flash();
}
cons_show_incoming_room_message(message->from_jid->resourcepart, mucwin->roomjid, num, mention, triggers, mucwin->unread, window);
@@ -567,8 +587,6 @@ _sv_ev_incoming_omemo(ProfChatWin* chatwin, gboolean new_win, ProfMessage* messa
chat_log_omemo_msg_in(message);
}
chatwin->pgp_recv = FALSE;
wins_omemo_trust_changed(chatwin->barejid);
#endif
}
@@ -578,9 +596,6 @@ _sv_ev_incoming_plain(ProfChatWin* chatwin, gboolean new_win, ProfMessage* messa
if (message->body) {
message->enc = PROF_MSG_ENC_NONE;
message->plain = strdup(message->body);
if (message->plain == NULL) {
return;
}
_clean_incoming_message(message);
chatwin_incoming_msg(chatwin, message, new_win);
log_database_add_incoming(message);
@@ -1135,13 +1150,14 @@ int
sv_ev_certfail(const char* const errormsg, const TLSCertificate* cert)
{
// check profanity trusted certs
if (tlscerts_exists(cert)) {
if (tlscerts_exists(cert->fingerprint)) {
cafile_add(cert);
return 1;
}
// check current cert
if (tlscerts_current_fingerprint_equals(cert)) {
char* current_fp = tlscerts_get_current();
if (current_fp && g_strcmp0(current_fp, cert->fingerprint) == 0) {
return 1;
}
@@ -1172,11 +1188,11 @@ sv_ev_certfail(const char* const errormsg, const TLSCertificate* cert)
if (g_strcmp0(cmd, "/tls allow") == 0) {
cons_show("Continuing with connection.");
tlscerts_set_current(cert);
tlscerts_set_current(cert->fingerprint);
return 1;
} else if (g_strcmp0(cmd, "/tls always") == 0) {
cons_show("Adding %s to trusted certificates.", cert->fingerprint);
if (!tlscerts_exists(cert)) {
if (!tlscerts_exists(cert->fingerprint)) {
tlscerts_add(cert);
cafile_add(cert);
}
@@ -1287,10 +1303,6 @@ sv_ev_bookmark_autojoin(Bookmark* bookmark)
static void
_cut(ProfMessage* message, const char* cut)
{
if (message->plain == NULL) {
return;
}
if (strstr(message->plain, cut)) {
auto_gcharv gchar** split = g_strsplit(message->plain, cut, -1);
free(message->plain);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef EVENT_SERVER_EVENTS_H

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2018 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2018 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -34,7 +60,6 @@ static FILE* logp;
static gchar* mainlogfile = NULL;
static gboolean user_provided_log = FALSE;
static log_level_t level_filter;
static pid_t prof_pid;
static int stderr_inited;
static log_level_t stderr_level;
@@ -50,8 +75,6 @@ enum {
static void
_rotate_log_file(void)
{
if (!mainlogfile)
return;
auto_gchar gchar* log_file = g_strdup(mainlogfile);
size_t len = strlen(log_file);
auto_gchar gchar* log_file_new = malloc(len + 5);
@@ -175,8 +198,6 @@ log_init(log_level_t filter, const char* const log_file)
logp = fopen(mainlogfile, "a");
g_chmod(mainlogfile, S_IRUSR | S_IWUSR);
prof_pid = getpid();
}
const gchar*
@@ -204,11 +225,14 @@ log_close(void)
static void
_log_msg(log_level_t level, const char* const area, const char* const msg)
{
GDateTime* dt = g_date_time_new_now_local();
char* level_str = _log_abbreviation_string_from_level(level);
auto_gchar gchar* date_fmt = prof_date_time_format_iso8601(NULL);
auto_gchar gchar* date_fmt = g_date_time_format_iso8601(dt);
fprintf(logp, "%s: %08d: %s: %s: %s\n", date_fmt, prof_pid, area, level_str, msg);
fprintf(logp, "%s: %s: %s: %s\n", date_fmt, area, level_str, msg);
g_date_time_unref(dt);
fflush(logp);
@@ -335,6 +359,11 @@ log_stderr_init(log_level_t level)
if (rc != 0)
goto err;
close(STDERR_FILENO);
rc = dup2(stderr_pipe[1], STDERR_FILENO);
if (rc < 0)
goto err_close;
rc = log_stderr_nonblock_set(stderr_pipe[0])
?: log_stderr_nonblock_set(stderr_pipe[1]);
if (rc != 0)
@@ -342,22 +371,15 @@ log_stderr_init(log_level_t level)
stderr_buf = malloc(STDERR_BUFSIZE);
stderr_msg = g_string_sized_new(STDERR_BUFSIZE);
stderr_level = level;
stderr_inited = 1;
prof_add_shutdown_routine(_log_stderr_close);
if (stderr_buf == NULL || stderr_msg == NULL) {
errno = ENOMEM;
goto err_free;
}
if (dup2(stderr_pipe[1], STDERR_FILENO) < 0)
goto err_free;
// fd 2 now owns the pipe write end; release the original.
close(stderr_pipe[1]);
stderr_pipe[1] = STDERR_FILENO;
stderr_level = level;
stderr_inited = 1;
prof_add_shutdown_routine(_log_stderr_close);
return;
err_free:

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef LOG_H

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2019 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -52,7 +78,7 @@ main(int argc, char** argv)
GOptionEntry entries[] = {
{ "version", 'v', 0, G_OPTION_ARG_NONE, &version, "Show version information", NULL },
{ "account", 'a', 0, G_OPTION_ARG_STRING, &account_name, "Auto connect to an account on startup", NULL },
{ "account", 'a', 0, G_OPTION_ARG_STRING, &account_name, "Auto connect to an account on startup" },
{ "log", 'l', 0, G_OPTION_ARG_STRING, &log, "Set logging levels, DEBUG, INFO, WARN (default), ERROR", "LEVEL" },
{ "config", 'c', 0, G_OPTION_ARG_STRING, &config_file, "Use an alternative configuration file", NULL },
{ "logfile", 'f', 0, G_OPTION_ARG_STRING, &log_file, "Specify log file", NULL },
@@ -67,9 +93,9 @@ main(int argc, char** argv)
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, entries, NULL);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_print("%s\n", PROF_GERROR_MESSAGE(error));
g_print("%s\n", error->message);
g_option_context_free(context);
PROF_GERROR_FREE(error);
g_error_free(error);
return 1;
}
@@ -81,7 +107,7 @@ main(int argc, char** argv)
// lets use fixed email instead of PACKAGE_BUGREPORT
g_print("Copyright (C) 2012 - 2019 James Booth <boothj5web@gmail.com>.\n");
g_print("Copyright (C) 2019 - 2026 Michael Vetter <jubalh@iodoru.org>.\n");
g_print("Copyright (C) 2019 - 2025 Michael Vetter <jubalh@iodoru.org>.\n");
g_print("License GPLv3+: GNU GPL version 3 or later <https://www.gnu.org/licenses/gpl.html>\n");
g_print("\n");
g_print("This is free software; you are free to change and redistribute it.\n");

View File

@@ -4,18 +4,39 @@
*
* Copyright (C) 2019 Paul Fariello <paul@fariello.eu>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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 <assert.h>
#ifdef HAVE_LIBOMEMO_C
#include <omemo/signal_protocol.h>
#include <omemo/signal_protocol_types.h>
#else
#include <signal/signal_protocol.h>
#include <signal/signal_protocol_types.h>
#endif
#include "log.h"
#include "omemo/omemo.h"
@@ -233,7 +254,7 @@ omemo_decrypt_func(signal_buffer** output, int cipher, const uint8_t* key, size_
{
int ret = SG_SUCCESS;
gcry_cipher_hd_t hd;
unsigned char* plaintext = NULL;
unsigned char* plaintext;
size_t plaintext_len;
int mode;
int algo;
@@ -268,13 +289,6 @@ omemo_decrypt_func(signal_buffer** output, int cipher, const uint8_t* key, size_
}
plaintext_len = ciphertext_len;
// PKCS#5/PKCS#7 padding requires at least one byte of plaintext;
// reject malformed empty ciphertext before any plaintext[len - 1]
// access could underflow / read out-of-bounds.
if (plaintext_len == 0) {
ret = SG_ERR_INVAL;
goto out;
}
plaintext = malloc(plaintext_len);
gcry_cipher_decrypt(hd, plaintext, plaintext_len, ciphertext, ciphertext_len);
@@ -286,12 +300,6 @@ omemo_decrypt_func(signal_buffer** output, int cipher, const uint8_t* key, size_
assert(FALSE);
}
// padding byte must address bytes that exist in plaintext.
if (padding == 0 || (size_t)padding > plaintext_len) {
ret = SG_ERR_UNKNOWN;
goto out;
}
for (int i = 0; i < padding; i++) {
if (plaintext[plaintext_len - 1 - i] != padding) {
ret = SG_ERR_UNKNOWN;
@@ -381,7 +389,7 @@ out:
gcry_error_t
aes256gcm_crypt_file(FILE* in, FILE* out, off_t file_size,
unsigned char key[], unsigned char nonce[], gboolean encrypt)
unsigned char key[], unsigned char nonce[], bool encrypt)
{
if (!gcry_control(GCRYCTL_INITIALIZATION_FINISHED_P)) {
@@ -414,7 +422,7 @@ aes256gcm_crypt_file(FILE* in, FILE* out, off_t file_size,
unsigned char buffer[AES256_GCM_BUFFER_SIZE];
size_t bytes = 0;
int bytes = 0;
off_t bytes_read = 0, bytes_available = 0, read_size = 0;
while (bytes_read < file_size) {
bytes_available = file_size - bytes_read;
@@ -429,8 +437,8 @@ aes256gcm_crypt_file(FILE* in, FILE* out, off_t file_size,
read_size = AES256_GCM_BUFFER_SIZE;
}
bytes = fread(buffer, 1, (size_t)read_size, in);
bytes_read += (off_t)bytes;
bytes = fread(buffer, 1, read_size, in);
bytes_read += bytes;
if (encrypt) {
res = gcry_cipher_encrypt(hd, buffer, bytes, NULL, 0);

View File

@@ -4,18 +4,37 @@
*
* Copyright (C) 2019 Paul Fariello <paul@fariello.eu>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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 <stdio.h>
#include <stdbool.h>
#include "config.h"
#ifdef HAVE_LIBOMEMO_C
#include <omemo/signal_protocol_types.h>
#else
#include <signal/signal_protocol_types.h>
#endif
#include <gcrypt.h>
#define AES128_GCM_KEY_LENGTH 16
@@ -166,7 +185,7 @@ int aes128gcm_decrypt(unsigned char* plaintext,
const unsigned char* const key, const unsigned char* const tag);
gcry_error_t aes256gcm_crypt_file(FILE* in, FILE* out, off_t file_size,
unsigned char key[], unsigned char nonce[], gboolean encrypt);
unsigned char key[], unsigned char nonce[], bool encrypt);
char* aes256gcm_create_secure_fragment(unsigned char* key,
unsigned char* nonce);

File diff suppressed because it is too large Load Diff

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2019 Paul Fariello <paul@fariello.eu>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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 <glib.h>
#include <gcrypt.h>
@@ -59,9 +85,6 @@ void omemo_trust(const char* const jid, const char* const fingerprint);
void omemo_untrust(const char* const jid, const char* const fingerprint);
GList* omemo_known_device_identities(const char* const jid);
gboolean omemo_is_trusted_identity(const char* const jid, const char* const fingerprint);
gboolean omemo_is_jid_trusted(const char* const jid);
GList* omemo_get_jid_untrusted_fingerprints(const char* const jid);
gboolean omemo_is_device_active(const char* const jid, const char* const fingerprint);
char* omemo_fingerprint_autocomplete(const char* const search_str, gboolean previous, void* context);
void omemo_fingerprint_autocomplete_reset(void);
gboolean omemo_automatic_start(const char* const recipient);
@@ -72,9 +95,8 @@ void omemo_start_muc_sessions(const char* const roomjid);
void omemo_start_device_session(const char* const jid, uint32_t device_id, GList* prekeys, uint32_t signed_prekey_id, const unsigned char* const signed_prekey, size_t signed_prekey_len, const unsigned char* const signature, size_t signature_len, const unsigned char* const identity_key, size_t identity_key_len);
gboolean omemo_loaded(void);
char* omemo_on_message_send(ProfWin* win, const char* const message, gboolean request_receipt, gboolean muc, const char* const replace_id);
char* omemo_on_message_recv(const char* const from, uint32_t sid, const unsigned char* const iv, size_t iv_len, GList* keys, const unsigned char* const payload, size_t payload_len, gboolean muc, gboolean* trusted, omemo_error_t* error) __attribute__((nonnull(9, 10)));
char* omemo_on_message_recv(const char* const from, uint32_t sid, const unsigned char* const iv, size_t iv_len, GList* keys, const unsigned char* const payload, size_t payload_len, gboolean muc, gboolean* trusted);
char* omemo_encrypt_file(FILE* in, FILE* out, off_t file_size, int* gcry_res);
gcry_error_t omemo_decrypt_file(FILE* in, FILE* out, off_t file_size, const char* fragment);

View File

@@ -4,17 +4,38 @@
*
* Copyright (C) 2019 Paul Fariello <paul@fariello.eu>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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 <glib.h>
#include "config.h"
#ifdef HAVE_LIBOMEMO_C
#include <omemo/signal_protocol.h>
#else
#include <signal/signal_protocol.h>
#endif
#include "config.h"
#include "log.h"
#include "omemo/omemo.h"
#include "omemo/store.h"

View File

@@ -4,15 +4,37 @@
*
* Copyright (C) 2019 Paul Fariello <paul@fariello.eu>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
#ifdef HAVE_LIBOMEMO_C
#include <omemo/signal_protocol.h>
#else
#include <signal/signal_protocol.h>
#endif
#include "config.h"
#define OMEMO_STORE_GROUP_IDENTITY "identity"
#define OMEMO_STORE_GROUP_PREKEYS "prekeys"
@@ -28,7 +50,7 @@ typedef struct
signal_buffer* private;
uint32_t registration_id;
GHashTable* trusted;
gboolean recv;
bool recv;
} identity_key_store_t;
GHashTable* session_store_new(void);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -270,16 +296,14 @@ otr_on_message_recv(const char* const barejid, const char* const resource, const
// check for OTR whitespace (opportunistic or always)
if (policy == PROF_OTRPOLICY_OPPORTUNISTIC || policy == PROF_OTRPOLICY_ALWAYS) {
if (whitespace_base) {
char* tag_position = whitespace_base + strlen(OTRL_MESSAGE_TAG_BASE);
if (strncmp(tag_position, OTRL_MESSAGE_TAG_V2, strlen(OTRL_MESSAGE_TAG_V2)) == 0 || strncmp(tag_position, OTRL_MESSAGE_TAG_V1, strlen(OTRL_MESSAGE_TAG_V1)) == 0) {
if (strstr(message, OTRL_MESSAGE_TAG_V2) || strstr(message, OTRL_MESSAGE_TAG_V1)) {
// Remove whitespace pattern for proper display in UI
// Handle both BASE+TAGV1/2(16+8) and BASE+TAGV1+TAGV2(16+8+8)
int tag_length = 24;
if (strstr(message, OTRL_MESSAGE_TAG_V2) && strstr(message, OTRL_MESSAGE_TAG_V1)) {
tag_length = 32;
}
// Move the rest of the message (with NUL) over the tag.
memmove(whitespace_base, whitespace_base + tag_length, strlen(whitespace_base + tag_length) + 1);
memmove(whitespace_base, whitespace_base + tag_length, tag_length);
char* otr_query_message = otr_start_query();
cons_show("OTR Whitespace pattern detected. Attempting to start OTR session…");
free(message_send_chat_otr(barejid, otr_query_message, FALSE, NULL));
@@ -637,9 +661,11 @@ otr_get_policy(const char* const recipient)
prof_otrpolicy_t result = PROF_OTRPOLICY_MANUAL;
if (g_strcmp0(account->otr_policy, "manual") == 0) {
result = PROF_OTRPOLICY_MANUAL;
} else if (g_strcmp0(account->otr_policy, "opportunistic") == 0) {
}
if (g_strcmp0(account->otr_policy, "opportunistic") == 0) {
result = PROF_OTRPOLICY_OPPORTUNISTIC;
} else if (g_strcmp0(account->otr_policy, "always") == 0) {
}
if (g_strcmp0(account->otr_policy, "always") == 0) {
result = PROF_OTRPOLICY_ALWAYS;
}
account_free(account);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef OTR_OTR_H

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef OTR_OTRLIB_H

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
* Copyright (C) 2018 - 2026 Michael Vetter <jubalh@iodoru.org>
* Copyright (C) 2018 - 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -40,28 +66,27 @@ static GHashTable* pubkeys;
static prof_keyfile_t pubkeys_prof_keyfile;
static GKeyFile* pubkeyfile;
static gchar* passphrase;
static gchar* passphrase_attempt;
static char* passphrase;
static char* passphrase_attempt;
static Autocomplete key_ac;
static gchar* _remove_header_footer(gchar* str, const char* const footer);
static gchar* _add_header_footer(const gchar* const str, const char* const header, const char* const footer);
static gchar* _gpgme_data_to_char(gpgme_data_t data);
static char* _remove_header_footer(char* str, const char* const footer);
static char* _add_header_footer(const char* const str, const char* const header, const char* const footer);
static char* _gpgme_data_to_char(gpgme_data_t data);
static void _save_pubkeys(void);
static ProfPGPKey* _gpgme_key_to_ProfPGPKey(gpgme_key_t key);
static const gchar* _gpgme_key_get_email(gpgme_key_t key);
void
_p_gpg_free_pubkeyid(ProfPGPPubKeyId* pubkeyid)
{
if (pubkeyid) {
g_free(pubkeyid->id);
free(pubkeyid->id);
}
g_free(pubkeyid);
free(pubkeyid);
}
static gpgme_error_t
static gpgme_error_t*
_p_gpg_passphrase_cb(void* hook, const char* uid_hint, const char* passphrase_info, int prev_was_bad, int fd)
{
if (passphrase) {
@@ -69,21 +94,21 @@ _p_gpg_passphrase_cb(void* hook, const char* uid_hint, const char* passphrase_in
} else {
GString* pass_term = g_string_new("");
auto_gchar gchar* password = ui_ask_pgp_passphrase(uid_hint, prev_was_bad);
auto_char char* password = ui_ask_pgp_passphrase(uid_hint, prev_was_bad);
if (password) {
g_string_append(pass_term, password);
}
g_string_append(pass_term, "\n");
if (passphrase_attempt) {
g_free(passphrase_attempt);
free(passphrase_attempt);
}
passphrase_attempt = g_string_free(pass_term, FALSE);
gpgme_io_write(fd, passphrase_attempt, strlen(passphrase_attempt));
}
return GPG_ERR_NO_ERROR;
return 0;
}
static void
@@ -101,11 +126,13 @@ _p_gpg_close(void)
key_ac = NULL;
if (passphrase) {
GFREE_SET_NULL(passphrase);
free(passphrase);
passphrase = NULL;
}
if (passphrase_attempt) {
GFREE_SET_NULL(passphrase_attempt);
free(passphrase_attempt);
passphrase_attempt = NULL;
}
}
@@ -129,7 +156,7 @@ p_gpg_init(void)
}
void
p_gpg_on_connect(const gchar* const barejid)
p_gpg_on_connect(const char* const barejid)
{
gchar* pubsloc = files_file_in_account_data_path(DIR_PGP, barejid, "pubkeys");
if (!pubsloc) {
@@ -152,13 +179,13 @@ p_gpg_on_connect(const gchar* const barejid)
return;
}
for (gsize i = 0; i < len; i++) {
for (int i = 0; i < len; i++) {
GError* gerr = NULL;
gchar* jid = jids[i];
auto_gchar gchar* keyid = g_key_file_get_string(pubkeyfile, jid, "keyid", &gerr);
if (gerr) {
log_error("Error loading PGP key id for %s", jid);
PROF_GERROR_FREE(gerr);
g_error_free(gerr);
} else {
gpgme_key_t key = NULL;
error = gpgme_get_key(ctx, keyid, &key, 0);
@@ -167,10 +194,10 @@ p_gpg_on_connect(const gchar* const barejid)
continue;
}
ProfPGPPubKeyId* pubkeyid = g_new0(ProfPGPPubKeyId, 1);
pubkeyid->id = g_strdup(keyid);
ProfPGPPubKeyId* pubkeyid = malloc(sizeof(ProfPGPPubKeyId));
pubkeyid->id = strdup(keyid);
pubkeyid->received = FALSE;
g_hash_table_replace(pubkeys, g_strdup(jid), pubkeyid);
g_hash_table_replace(pubkeys, strdup(jid), pubkeyid);
gpgme_key_unref(key);
}
}
@@ -189,7 +216,7 @@ p_gpg_on_disconnect(void)
}
gboolean
p_gpg_addkey(const gchar* const jid, const gchar* const keyid)
p_gpg_addkey(const char* const jid, const char* const keyid)
{
gpgme_ctx_t ctx;
gpgme_error_t error = gpgme_new(&ctx);
@@ -212,10 +239,10 @@ p_gpg_addkey(const gchar* const jid, const gchar* const keyid)
_save_pubkeys();
// update in memory pubkeys list
ProfPGPPubKeyId* pubkeyid = g_new0(ProfPGPPubKeyId, 1);
pubkeyid->id = g_strdup(keyid);
ProfPGPPubKeyId* pubkeyid = malloc(sizeof(ProfPGPPubKeyId));
pubkeyid->id = strdup(keyid);
pubkeyid->received = FALSE;
g_hash_table_replace(pubkeys, g_strdup(jid), pubkeyid);
g_hash_table_replace(pubkeys, strdup(jid), pubkeyid);
gpgme_key_unref(key);
return TRUE;
@@ -224,7 +251,7 @@ p_gpg_addkey(const gchar* const jid, const gchar* const keyid)
ProfPGPKey*
p_gpg_key_new(void)
{
ProfPGPKey* p_pgpkey = g_new0(ProfPGPKey, 1);
ProfPGPKey* p_pgpkey = malloc(sizeof(ProfPGPKey));
p_pgpkey->id = NULL;
p_pgpkey->name = NULL;
p_pgpkey->fp = NULL;
@@ -241,10 +268,10 @@ void
p_gpg_free_key(ProfPGPKey* key)
{
if (key) {
g_free(key->id);
g_free(key->name);
g_free(key->fp);
g_free(key);
free(key->id);
free(key->name);
free(key->fp);
free(key);
}
}
@@ -267,7 +294,7 @@ GHashTable*
p_gpg_list_keys(void)
{
gpgme_error_t error;
GHashTable* result = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)p_gpg_free_key);
GHashTable* result = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)p_gpg_free_key);
gpgme_ctx_t ctx;
error = gpgme_new(&ctx);
@@ -285,7 +312,7 @@ p_gpg_list_keys(void)
while (!error) {
ProfPGPKey* p_pgpkey = _gpgme_key_to_ProfPGPKey(key);
if (p_pgpkey != NULL) {
g_hash_table_insert(result, g_strdup(p_pgpkey->name), p_pgpkey);
g_hash_table_insert(result, strdup(p_pgpkey->name), p_pgpkey);
}
gpgme_key_unref(key);
@@ -341,7 +368,7 @@ p_gpg_pubkeys(void)
return pubkeys;
}
const gchar*
const char*
p_gpg_libver(void)
{
if (libversion == NULL) {
@@ -351,14 +378,14 @@ p_gpg_libver(void)
}
gboolean
p_gpg_valid_key(const gchar* const keyid, gchar** err_str)
p_gpg_valid_key(const char* const keyid, char** err_str)
{
gpgme_ctx_t ctx;
gpgme_error_t error = gpgme_new(&ctx);
if (error) {
log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error));
if (err_str) {
*err_str = g_strdup(gpgme_strerror(error));
*err_str = strdup(gpgme_strerror(error));
}
return FALSE;
}
@@ -369,7 +396,7 @@ p_gpg_valid_key(const gchar* const keyid, gchar** err_str)
if (error || key == NULL) {
log_error("GPG: Failed to get key. %s %s", gpgme_strsource(error), gpgme_strerror(error));
if (err_str) {
*err_str = g_strdup(error ? gpgme_strerror(error) : "gpgme didn't return any error, but it didn't return a key");
*err_str = strdup(error ? gpgme_strerror(error) : "gpgme didn't return any error, but it didn't return a key");
}
gpgme_release(ctx);
return FALSE;
@@ -381,14 +408,14 @@ p_gpg_valid_key(const gchar* const keyid, gchar** err_str)
}
gboolean
p_gpg_available(const gchar* const barejid)
p_gpg_available(const char* const barejid)
{
gchar* pubkey = g_hash_table_lookup(pubkeys, barejid);
char* pubkey = g_hash_table_lookup(pubkeys, barejid);
return (pubkey != NULL);
}
void
p_gpg_verify(const gchar* const barejid, const gchar* const sign)
p_gpg_verify(const char* const barejid, const char* const sign)
{
if (!sign) {
return;
@@ -402,7 +429,7 @@ p_gpg_verify(const gchar* const barejid, const gchar* const sign)
return;
}
auto_gchar gchar* sign_with_header_footer = _add_header_footer(sign, PGP_SIGNATURE_HEADER, PGP_SIGNATURE_FOOTER);
auto_char char* sign_with_header_footer = _add_header_footer(sign, PGP_SIGNATURE_HEADER, PGP_SIGNATURE_FOOTER);
gpgme_data_t sign_data;
gpgme_data_new_from_mem(&sign_data, sign_with_header_footer, strlen(sign_with_header_footer), 1);
@@ -428,10 +455,10 @@ p_gpg_verify(const gchar* const barejid, const gchar* const sign)
log_debug("Could not find PGP key with ID %s for %s", result->signatures->fpr, barejid);
} else {
log_debug("Fingerprint found for %s: %s ", barejid, key->subkeys->fpr);
ProfPGPPubKeyId* pubkeyid = g_new0(ProfPGPPubKeyId, 1);
pubkeyid->id = g_strdup(key->subkeys->keyid);
ProfPGPPubKeyId* pubkeyid = malloc(sizeof(ProfPGPPubKeyId));
pubkeyid->id = strdup(key->subkeys->keyid);
pubkeyid->received = TRUE;
g_hash_table_replace(pubkeys, g_strdup(barejid), pubkeyid);
g_hash_table_replace(pubkeys, strdup(barejid), pubkeyid);
}
gpgme_key_unref(key);
@@ -441,8 +468,8 @@ p_gpg_verify(const gchar* const barejid, const gchar* const sign)
gpgme_release(ctx);
}
gchar*
p_gpg_sign(const gchar* const str, const gchar* const fp)
char*
p_gpg_sign(const char* const str, const char* const fp)
{
gpgme_ctx_t ctx;
gpgme_error_t error = gpgme_new(&ctx);
@@ -478,10 +505,6 @@ p_gpg_sign(const gchar* const str, const gchar* const fp)
} else {
str_or_empty = strdup("");
}
if (!str_or_empty) {
log_error("GPG: strdup failed");
return NULL;
}
gpgme_data_t str_data;
gpgme_data_new_from_mem(&str_data, str_or_empty, strlen(str_or_empty), 1);
@@ -499,10 +522,10 @@ p_gpg_sign(const gchar* const str, const gchar* const fp)
return NULL;
}
gchar* result = NULL;
char* result = NULL;
size_t len = 0;
gchar* signed_str = gpgme_data_release_and_get_mem(signed_data, &len);
char* signed_str = gpgme_data_release_and_get_mem(signed_data, &len);
if (signed_str) {
GString* signed_gstr = g_string_new("");
g_string_append_len(signed_gstr, signed_str, len);
@@ -512,22 +535,20 @@ p_gpg_sign(const gchar* const str, const gchar* const fp)
}
if (passphrase_attempt) {
passphrase = g_strdup(passphrase_attempt);
passphrase = strdup(passphrase_attempt);
}
return result;
}
gchar*
p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gchar* const fp, gchar** err)
char*
p_gpg_encrypt(const char* const barejid, const char* const message, const char* const fp)
{
ProfPGPPubKeyId* pubkeyid = g_hash_table_lookup(pubkeys, barejid);
if (!pubkeyid) {
*err = g_strdup("No PGP key found for recipient");
return NULL;
}
if (!pubkeyid->id) {
*err = g_strdup("No key ID found for recipient");
return NULL;
}
@@ -540,7 +561,6 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
gpgme_ctx_t ctx;
gpgme_error_t error = gpgme_new(&ctx);
if (error) {
*err = g_strdup_printf("Failed to create GPGME context: %s %s", gpgme_strsource(error), gpgme_strerror(error));
log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error));
return NULL;
}
@@ -548,7 +568,6 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
gpgme_key_t receiver_key;
error = gpgme_get_key(ctx, pubkeyid->id, &receiver_key, 0);
if (error || receiver_key == NULL) {
*err = g_strdup_printf("Failed to get receiver key '%s': %s %s", pubkeyid->id, gpgme_strsource(error), gpgme_strerror(error));
log_error("GPG: Failed to get receiver_key. %s %s", gpgme_strsource(error), gpgme_strerror(error));
gpgme_release(ctx);
return NULL;
@@ -558,10 +577,8 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
gpgme_key_t sender_key = NULL;
error = gpgme_get_key(ctx, fp, &sender_key, 0);
if (error || sender_key == NULL) {
*err = g_strdup_printf("Failed to get sender key '%s': %s %s", fp, gpgme_strsource(error), gpgme_strerror(error));
log_error("GPG: Failed to get sender_key. %s %s", gpgme_strsource(error), gpgme_strerror(error));
gpgme_release(ctx);
gpgme_key_unref(receiver_key);
return NULL;
}
keys[1] = sender_key;
@@ -580,8 +597,7 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
gpgme_key_unref(sender_key);
if (error) {
*err = g_strdup_printf("Encryption failed: (%s) %s", gpgme_strsource(error), gpgme_strerror(error));
log_error("GPG: Failed to encrypt message. (%s) %s", gpgme_strsource(error), gpgme_strerror(error));
log_error("GPG: Failed to encrypt message. %s %s", gpgme_strsource(error), gpgme_strerror(error));
return NULL;
}
@@ -600,8 +616,8 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
return result;
}
gchar*
p_gpg_decrypt(const gchar* const cipher)
char*
p_gpg_decrypt(const char* const cipher)
{
gpgme_ctx_t ctx;
gpgme_error_t error = gpgme_new(&ctx);
@@ -613,7 +629,7 @@ p_gpg_decrypt(const gchar* const cipher)
gpgme_set_passphrase_cb(ctx, (gpgme_passphrase_cb_t)_p_gpg_passphrase_cb, NULL);
auto_gchar gchar* cipher_with_headers = _add_header_footer(cipher, PGP_MESSAGE_HEADER, PGP_MESSAGE_FOOTER);
auto_char char* cipher_with_headers = _add_header_footer(cipher, PGP_MESSAGE_HEADER, PGP_MESSAGE_FOOTER);
gpgme_data_t cipher_data;
gpgme_data_new_from_mem(&cipher_data, cipher_with_headers, strlen(cipher_with_headers), 1);
@@ -639,9 +655,11 @@ p_gpg_decrypt(const gchar* const cipher)
error = gpgme_get_key(ctx, recipient->keyid, &key, 1);
if (!error && key) {
const gchar* addr = _gpgme_key_get_email(key);
if (addr) {
g_string_append(recipients_str, addr);
for (gpgme_user_id_t uid = key->uids; uid != NULL; uid = uid->next) {
if (uid->email) {
g_string_append(recipients_str, uid->email);
break;
}
}
gpgme_key_unref(key);
} else if (error) {
@@ -662,7 +680,7 @@ p_gpg_decrypt(const gchar* const cipher)
gpgme_release(ctx);
if (passphrase_attempt) {
passphrase = g_strdup(passphrase_attempt);
passphrase = strdup(passphrase_attempt);
}
return _gpgme_data_to_char(plain_data);
@@ -674,8 +692,8 @@ p_gpg_free_decrypted(char* decrypted)
g_free(decrypted);
}
gchar*
p_gpg_autocomplete_key(const gchar* const search_str, gboolean previous, void* context)
char*
p_gpg_autocomplete_key(const char* const search_str, gboolean previous, void* context)
{
return autocomplete_complete(key_ac, search_str, TRUE, previous);
}
@@ -686,16 +704,16 @@ p_gpg_autocomplete_key_reset(void)
autocomplete_reset(key_ac);
}
gchar*
p_gpg_format_fp_str(gchar* fp)
char*
p_gpg_format_fp_str(char* fp)
{
if (!fp) {
return NULL;
}
GString* format = g_string_new("");
size_t len = strlen(fp);
for (size_t i = 0; i < len; i++) {
int len = strlen(fp);
for (int i = 0; i < len; i++) {
g_string_append_c(format, fp[i]);
if (((i + 1) % 4 == 0) && (i + 1 < len)) {
g_string_append_c(format, ' ');
@@ -710,12 +728,12 @@ p_gpg_format_fp_str(gchar* fp)
*
* @param keyid The key ID for which to retrieve the public key data.
* If the key ID is empty or NULL, returns NULL.
* @return The public key data as a null-terminated gchar* string allocated using malloc.
* @return The public key data as a null-terminated char* string allocated using malloc.
* The returned string should be freed by the caller.
* Returns NULL on error, and errors are written to the error log.
*/
gchar*
p_gpg_get_pubkey(const gchar* keyid)
char*
p_gpg_get_pubkey(const char* keyid)
{
if (!keyid || *keyid == '\0') {
return NULL;
@@ -759,18 +777,18 @@ cleanup:
* @return TRUE if the buffer has the expected header and footer of an armored public key, FALSE otherwise.
*/
gboolean
p_gpg_is_public_key_format(const gchar* buffer)
p_gpg_is_public_key_format(const char* buffer)
{
if (buffer == NULL || buffer[0] == '\0') {
return false;
}
const gchar* headerPos = strstr(buffer, PGP_PUBLIC_KEY_HEADER);
const char* headerPos = strstr(buffer, PGP_PUBLIC_KEY_HEADER);
if (headerPos == NULL) {
return false;
}
const gchar* footerPos = strstr(buffer, PGP_PUBLIC_KEY_FOOTER);
const char* footerPos = strstr(buffer, PGP_PUBLIC_KEY_FOOTER);
return (footerPos != NULL && footerPos > headerPos);
}
@@ -785,7 +803,7 @@ p_gpg_is_public_key_format(const gchar* buffer)
* by calling p_gpg_free_key() to avoid resource leaks.
*/
ProfPGPKey*
p_gpg_import_pubkey(const gchar* buffer)
p_gpg_import_pubkey(const char* buffer)
{
gpgme_ctx_t ctx;
ProfPGPKey* result = NULL;
@@ -855,9 +873,9 @@ _gpgme_key_to_ProfPGPKey(gpgme_key_t key)
ProfPGPKey* p_pgpkey = p_gpg_key_new();
gpgme_subkey_t sub = key->subkeys;
p_pgpkey->id = g_strdup(sub->keyid);
p_pgpkey->name = g_strdup(key->uids->uid);
p_pgpkey->fp = g_strdup(sub->fpr);
p_pgpkey->id = strdup(sub->keyid);
p_pgpkey->name = strdup(key->uids->uid);
p_pgpkey->fp = strdup(sub->fpr);
while (sub) {
if (sub->can_encrypt)
@@ -874,40 +892,6 @@ _gpgme_key_to_ProfPGPKey(gpgme_key_t key)
return p_pgpkey;
}
/**
* Extract the first email address from a gpgme_key_t object.
* This function provides backwards compatibility for both old and new GPGME versions.
* - GPGME < 2.0.0: Uses gpgme_key_get_string_attr (if available)
* - GPGME >= 2.0.0: Uses modern key->uids->email API
*
* @param key The gpgme_key_t object to extract email from.
* @return The first email address found in the key's user IDs, or NULL if none found.
* The returned string should not be freed as it points to internal gpgme memory.
*/
static const gchar*
_gpgme_key_get_email(gpgme_key_t key)
{
if (!key) {
return NULL;
}
#ifdef GPGME_ATTR_EMAIL
/* Use deprecated function if available (GPGME < 2.0.0) */
return gpgme_key_get_string_attr(key, GPGME_ATTR_EMAIL, NULL, 0);
#else
/* Use modern API for GPGME >= 2.0.0 */
gpgme_user_id_t uid = key->uids;
while (uid) {
if (uid->email && strlen(uid->email) > 0) {
return uid->email;
}
uid = uid->next;
}
return NULL;
#endif
}
/**
* Convert a gpgme_data_t object to a null-terminated char* string.
*
@@ -915,7 +899,7 @@ _gpgme_key_get_email(gpgme_key_t key)
* @return The converted string allocated using malloc, which should be freed by the caller.
* If an error occurs or the data is empty, NULL is returned and errors are written to the error log.
*/
static gchar*
static char*
_gpgme_data_to_char(gpgme_data_t data)
{
size_t buffer_size = 0;
@@ -926,13 +910,16 @@ _gpgme_data_to_char(gpgme_data_t data)
return NULL;
}
gchar* buffer = g_strndup(gpgme_buffer, buffer_size);
char* buffer = malloc(buffer_size + 1);
memcpy(buffer, gpgme_buffer, buffer_size);
buffer[buffer_size] = '\0';
gpgme_free(gpgme_buffer);
return buffer;
}
static gchar*
_remove_header_footer(gchar* str, const char* const footer)
static char*
_remove_header_footer(char* str, const char* const footer)
{
int pos = 0;
int newlines = 0;
@@ -948,15 +935,15 @@ _remove_header_footer(gchar* str, const char* const footer)
}
}
gchar* stripped = g_strdup(&str[pos]);
gchar* footer_start = g_strrstr(stripped, footer);
char* stripped = strdup(&str[pos]);
char* footer_start = g_strrstr(stripped, footer);
footer_start[0] = '\0';
return stripped;
}
static gchar*
_add_header_footer(const gchar* const str, const char* const header, const char* const footer)
static char*
_add_header_footer(const char* const str, const char* const header, const char* const footer)
{
return g_strdup_printf("%s\n\n%s\n%s", header, str, footer);
}

View File

@@ -4,19 +4,43 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef PGP_GPG_H
#define PGP_GPG_H
#include "glib.h"
typedef struct pgp_key_t
{
gchar* id;
gchar* name;
gchar* fp;
char* id;
char* name;
char* fp;
gboolean encrypt;
gboolean sign;
gboolean certify;
@@ -26,31 +50,31 @@ typedef struct pgp_key_t
typedef struct pgp_pubkeyid_t
{
gchar* id;
char* id;
gboolean received;
} ProfPGPPubKeyId;
void p_gpg_init(void);
void p_gpg_on_connect(const gchar* const barejid);
void p_gpg_on_connect(const char* const barejid);
void p_gpg_on_disconnect(void);
GHashTable* p_gpg_list_keys(void);
void p_gpg_free_keys(GHashTable* keys);
gboolean p_gpg_addkey(const gchar* const jid, const gchar* const keyid);
gboolean p_gpg_addkey(const char* const jid, const char* const keyid);
GHashTable* p_gpg_pubkeys(void);
gboolean p_gpg_valid_key(const gchar* const keyid, gchar** err_str);
gboolean p_gpg_available(const gchar* const barejid);
const gchar* p_gpg_libver(void);
gchar* p_gpg_sign(const gchar* const str, const gchar* const fp);
void p_gpg_verify(const gchar* const barejid, const gchar* const sign);
gchar* p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gchar* const fp, gchar** err);
gchar* p_gpg_decrypt(const gchar* const cipher);
void p_gpg_free_decrypted(gchar* decrypted);
gchar* p_gpg_autocomplete_key(const gchar* const search_str, gboolean previous, void* context);
gboolean p_gpg_valid_key(const char* const keyid, char** err_str);
gboolean p_gpg_available(const char* const barejid);
const char* p_gpg_libver(void);
char* p_gpg_sign(const char* const str, const char* const fp);
void p_gpg_verify(const char* const barejid, const char* const sign);
char* p_gpg_encrypt(const char* const barejid, const char* const message, const char* const fp);
char* p_gpg_decrypt(const char* const cipher);
void p_gpg_free_decrypted(char* decrypted);
char* p_gpg_autocomplete_key(const char* const search_str, gboolean previous, void* context);
void p_gpg_autocomplete_key_reset(void);
gchar* p_gpg_format_fp_str(gchar* fp);
gchar* p_gpg_get_pubkey(const gchar* const keyid);
gboolean p_gpg_is_public_key_format(const gchar* buffer);
ProfPGPKey* p_gpg_import_pubkey(const gchar* buffer);
char* p_gpg_format_fp_str(char* fp);
char* p_gpg_get_pubkey(const char* const keyid);
gboolean p_gpg_is_public_key_format(const char* buffer);
ProfPGPKey* p_gpg_import_pubkey(const char* buffer);
ProfPGPKey* p_gpg_key_new(void);
void p_gpg_free_key(ProfPGPKey* key);

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2020 Stefan Kropp <stefan@debxwoody.de>
* Copyright (C) 2020 - 2026 Michael Vetter <jubalh@iodoru.org>
* 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#include "config.h"
@@ -59,7 +85,6 @@ 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) {
@@ -120,16 +145,10 @@ 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) {
@@ -146,6 +165,13 @@ 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));
@@ -159,73 +185,64 @@ 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 (recp[0] == NULL) {
if (error != 0) {
cons_show_error("Can't find OX key for %s", xmpp_jid_me);
log_error("OX: Key not found for %s.", xmpp_jid_me);
goto cleanup;
log_error("OX: Key not found for %s. Error: %s", xmpp_jid_me, gpgme_strerror(error));
return NULL;
}
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));
goto cleanup;
return NULL;
}
// lookup key of recipient
recp[1] = _ox_key_lookup(recipient_barejid, FALSE);
if (recp[1] == NULL) {
if (error != 0) {
cons_show_error("Can't find OX key for %s", xmpp_jid_recipient);
log_error("OX: Key not found for %s.", xmpp_jid_recipient);
goto cleanup;
log_error("OX: Key not found for %s. Error: %s", xmpp_jid_recipient, gpgme_strerror(error));
return NULL;
}
recp[2] = NULL;
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);
}
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);
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));
goto cleanup;
return NULL;
}
error = gpgme_data_new(&cipher);
if (error != 0) {
log_error("OX: %s", gpgme_strerror(error));
goto cleanup;
return NULL;
}
error = gpgme_op_encrypt_sign(ctx, recp, flags, plain, cipher);
if (error != 0) {
log_error("OX: %s", gpgme_strerror(error));
goto cleanup;
return NULL;
}
size_t len;
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);
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);
return result;
}
@@ -296,7 +313,6 @@ _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;
}
}
@@ -305,7 +321,6 @@ _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);
@@ -347,13 +362,6 @@ _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())) {
@@ -362,6 +370,7 @@ 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) {
@@ -378,19 +387,25 @@ 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;
encrypted = g_base64_decode(base64, &s);
guchar* 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));
goto cleanup;
return NULL;
}
error = gpgme_data_new(&plain);
if (error != 0) {
log_error("OX: %s", gpgme_strerror(error));
goto cleanup;
return NULL;
}
error = gpgme_op_decrypt_verify(ctx, cipher, plain);
@@ -398,28 +413,17 @@ 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) {
goto cleanup;
return NULL;
}
}
size_t len;
plain_str = gpgme_data_release_and_get_mem(plain, &len);
plain = NULL; // Already released by gpgme_data_release_and_get_mem
char* plain_str = gpgme_data_release_and_get_mem(plain, &len);
char* result = NULL;
if (plain_str) {
result = strndup(plain_str, len);
}
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;
}
@@ -451,33 +455,30 @@ p_ox_gpg_readkey(const char* const filename, char** key, char** fp)
{
log_info("PX: Read OpenPGP Key from file %s", filename);
GError* gerr = NULL;
GError* error = 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,
&gerr);
&error);
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));
goto cleanup;
return;
}
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));
goto cleanup;
return;
}
gpgme_set_armor(ctx, 0);
@@ -485,54 +486,49 @@ 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));
goto cleanup;
return;
}
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));
goto cleanup;
return;
}
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));
goto cleanup;
return;
}
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");
goto cleanup;
return;
}
if (gkey->revoked || gkey->expired || gkey->disabled || gkey->invalid || gkey->secret) {
log_error("OX: Read OpenPGP key from file: Key is not valid");
goto cleanup;
return;
}
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", gerr->message);
g_error_free(gerr);
log_error("OX: Read OpenPGP key from file: Unable to read file: %s", error->message);
}
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
@@ -540,26 +536,22 @@ 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 = NULL;
gpgme_data_t gpgme_data = 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));
result = FALSE;
goto cleanup;
return FALSE;
}
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));
result = FALSE;
goto cleanup;
return FALSE;
}
gpgme_set_armor(ctx, 0);
@@ -567,26 +559,18 @@ p_ox_gpg_import(char* base64_public_key)
gpgme_set_offline(ctx, 1);
gpgme_set_keylist_mode(ctx, GPGME_KEYLIST_MODE_LOCAL);
error = gpgme_data_new_from_mem(&gpgme_data, (gchar*)key, size, 0);
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_from_mem %s", gpgme_strerror(error));
result = FALSE;
goto cleanup;
log_error("OX: Read OpenPGP key from file: gpgme_data_new %s", gpgme_strerror(error));
return FALSE;
}
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;
}
cleanup:
if (key)
g_free(key);
if (gpgme_data)
gpgme_data_release(gpgme_data);
if (ctx)
gpgme_release(ctx);
return result;
return TRUE;
}

View File

@@ -3,9 +3,35 @@
* vim: expandtab:ts=4:sts=4:sw=4
*
* Copyright (C) 2020 Stefan Kropp <stefan@debxwoody.de>
* Copyright (C) 2020 - 2026 Michael Vetter <jubalh@iodoru.org>
* 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.
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
*/
#ifndef PGP_OX_H

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -86,29 +112,29 @@ api_register_command(const char* const plugin_name, const char* command_name, in
char** synopsis, const char* description, char* arguments[][2], char** examples,
void* callback, void (*callback_exec)(PluginCommand* command, gchar** args), void (*callback_destroy)(void* callback))
{
PluginCommand* command = g_new0(PluginCommand, 1);
command->command_name = g_strdup(command_name);
PluginCommand* command = calloc(1, sizeof(PluginCommand));
command->command_name = strdup(command_name);
command->min_args = min_args;
command->max_args = max_args;
command->callback = callback;
command->callback_exec = callback_exec;
command->callback_destroy = callback_destroy;
CommandHelp* help = g_new0(CommandHelp, 1);
CommandHelp* help = calloc(1, sizeof(CommandHelp));
int i;
for (i = 0; synopsis[i] != NULL; i++) {
help->synopsis[i] = g_strdup(synopsis[i]);
help->synopsis[i] = strdup(synopsis[i]);
}
help->desc = g_strdup(description);
help->desc = strdup(description);
for (i = 0; arguments[i][0] != NULL; i++) {
help->args[i][0] = g_strdup(arguments[i][0]);
help->args[i][1] = g_strdup(arguments[i][1]);
help->args[i][0] = strdup(arguments[i][0]);
help->args[i][1] = strdup(arguments[i][1]);
}
for (i = 0; examples[i] != NULL; i++) {
help->examples[i] = g_strdup(examples[i]);
help->examples[i] = strdup(examples[i]);
}
command->help = help;
@@ -120,7 +146,7 @@ void
api_register_timed(const char* const plugin_name, void* callback, int interval_seconds,
void (*callback_exec)(PluginTimedFunction* timed_function), void (*callback_destroy)(void* callback))
{
PluginTimedFunction* timed_function = g_new0(PluginTimedFunction, 1);
PluginTimedFunction* timed_function = malloc(sizeof(PluginTimedFunction));
timed_function->callback = callback;
timed_function->callback_exec = callback_exec;
timed_function->callback_destroy = callback_destroy;
@@ -208,7 +234,7 @@ api_get_current_nick(void)
ProfMucWin* mucwin = (ProfMucWin*)current;
assert(mucwin->memcheck == PROFMUCWIN_MEMCHECK);
const char* const nick = muc_nick(mucwin->roomjid);
return nick ? g_strdup(nick) : NULL;
return nick ? strdup(nick) : NULL;
} else {
return NULL;
}
@@ -217,7 +243,7 @@ api_get_current_nick(void)
char*
api_get_name_from_roster(const char* barejid)
{
return g_strdup(roster_get_display_name(barejid));
return strdup(roster_get_display_name(barejid));
}
char*
@@ -235,22 +261,14 @@ api_get_current_occupants(void)
assert(mucwin->memcheck == PROFMUCWIN_MEMCHECK);
GList* occupants_list = muc_roster(mucwin->roomjid);
char** result = malloc((g_list_length(occupants_list) + 1) * sizeof(char*));
if (result == NULL) {
g_list_free(occupants_list);
return NULL;
}
GList* curr = occupants_list;
int i = 0;
while (curr) {
Occupant* occupant = curr->data;
result[i++] = g_strdup(occupant->nick);
result[i++] = strdup(occupant->nick);
curr = g_list_next(curr);
}
result[i] = NULL;
g_list_free(occupants_list);
return result;
} else {
return NULL;
@@ -273,7 +291,7 @@ api_get_room_nick(const char* barejid)
{
const char* const nick = muc_nick(barejid);
return nick ? g_strdup(nick) : NULL;
return nick ? strdup(nick) : NULL;
}
void
@@ -321,7 +339,7 @@ api_win_create(
return;
}
PluginWindowCallback* window = g_new0(PluginWindowCallback, 1);
PluginWindowCallback* window = malloc(sizeof(PluginWindowCallback));
window->callback = callback;
window->callback_exec = callback_exec;
window->callback_destroy = callback_destroy;
@@ -475,7 +493,7 @@ api_incoming_message(const char* const barejid, const char* const resource, cons
{
ProfMessage* message = message_init();
message->from_jid = jid_create_from_bare_and_resource(barejid, resource);
message->plain = g_strdup(plain);
message->plain = strdup(plain);
sv_ev_incoming_message(message);

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef PLUGINS_API_H

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -49,14 +75,14 @@ autocompleters_add(const char* const plugin_name, const char* key, char** items)
} else {
Autocomplete new_ac = autocomplete_new();
autocomplete_add_all(new_ac, items);
g_hash_table_insert(key_to_ac, g_strdup(key), new_ac);
g_hash_table_insert(key_to_ac, strdup(key), new_ac);
}
} else {
key_to_ac = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)autocomplete_free);
Autocomplete new_ac = autocomplete_new();
autocomplete_add_all(new_ac, items);
g_hash_table_insert(key_to_ac, g_strdup(key), new_ac);
g_hash_table_insert(plugin_to_acs, g_strdup(plugin_name), key_to_ac);
g_hash_table_insert(key_to_ac, strdup(key), new_ac);
g_hash_table_insert(plugin_to_acs, strdup(plugin_name), key_to_ac);
}
}
@@ -97,11 +123,11 @@ autocompleters_filepath_add(const char* const plugin_name, const char* prefix)
{
GHashTable* prefixes = g_hash_table_lookup(plugin_to_filepath_acs, plugin_name);
if (prefixes) {
g_hash_table_add(prefixes, g_strdup(prefix));
g_hash_table_add(prefixes, strdup(prefix));
} else {
prefixes = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
g_hash_table_add(prefixes, g_strdup(prefix));
g_hash_table_insert(plugin_to_filepath_acs, g_strdup(plugin_name), prefixes);
g_hash_table_add(prefixes, strdup(prefix));
g_hash_table_insert(plugin_to_filepath_acs, strdup(plugin_name), prefixes);
}
}

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef PLUGINS_AUTOCOMPLETERS_H

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -68,7 +94,7 @@ c_api_register_command(const char* filename, const char* command_name, int min_a
auto_char char* plugin_name = _c_plugin_name(filename);
log_debug("Register command %s for %s", command_name, plugin_name);
CommandWrapper* wrapper = g_new0(CommandWrapper, 1);
CommandWrapper* wrapper = malloc(sizeof(CommandWrapper));
wrapper->func = callback;
api_register_command(plugin_name, command_name, min_args, max_args, synopsis,
description, arguments, examples, wrapper, c_command_callback, free);
@@ -80,7 +106,7 @@ c_api_register_timed(const char* filename, void (*callback)(void), int interval_
auto_char char* plugin_name = _c_plugin_name(filename);
log_debug("Register timed for %s", plugin_name);
TimedWrapper* wrapper = g_new0(TimedWrapper, 1);
TimedWrapper* wrapper = malloc(sizeof(TimedWrapper));
wrapper->func = callback;
api_register_timed(plugin_name, wrapper, interval_seconds, c_timed_callback, free);
}
@@ -222,7 +248,7 @@ c_api_win_create(const char* filename, char* tag, void (*callback)(char* tag, ch
{
auto_char char* plugin_name = _c_plugin_name(filename);
WindowWrapper* wrapper = g_new0(WindowWrapper, 1);
WindowWrapper* wrapper = malloc(sizeof(WindowWrapper));
wrapper->func = callback;
api_win_create(plugin_name, tag, wrapper, c_window_callback, free);
}
@@ -506,8 +532,7 @@ c_api_init(void)
static char*
_c_plugin_name(const char* filename)
{
size_t flen = strlen(filename);
auto_gchar gchar* name = g_strndup(filename, flen > 0 ? flen - 1 : 0);
auto_gchar gchar* name = g_strndup(filename, strlen(filename) - 1);
gchar* result = g_strdup_printf("%sso", name);
return result;

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef PLUGINS_C_API_H

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -52,8 +78,8 @@ c_plugin_create(const char* const filename)
return NULL;
}
plugin = g_new0(ProfPlugin, 1);
plugin->name = g_strdup(filename);
plugin = malloc(sizeof(ProfPlugin));
plugin->name = strdup(filename);
plugin->lang = LANG_C;
plugin->module = handle;
plugin->init_func = c_init_hook;

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef PLUGINS_C_PLUGINS_H

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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"
@@ -113,9 +139,9 @@ _free_timed_function_list(GList* timed_functions)
void
callbacks_init(void)
{
p_commands = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_free_command_hash);
p_timed_functions = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_free_timed_function_list);
p_window_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_free_window_callbacks);
p_commands = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_free_command_hash);
p_timed_functions = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_free_timed_function_list);
p_window_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_free_window_callbacks);
}
void
@@ -165,11 +191,11 @@ callbacks_add_command(const char* const plugin_name, PluginCommand* command)
{
GHashTable* command_hash = g_hash_table_lookup(p_commands, plugin_name);
if (command_hash) {
g_hash_table_insert(command_hash, g_strdup(command->command_name), command);
g_hash_table_insert(command_hash, strdup(command->command_name), command);
} else {
command_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_free_command);
g_hash_table_insert(command_hash, g_strdup(command->command_name), command);
g_hash_table_insert(p_commands, g_strdup(plugin_name), command_hash);
command_hash = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_free_command);
g_hash_table_insert(command_hash, strdup(command->command_name), command);
g_hash_table_insert(p_commands, strdup(plugin_name), command_hash);
}
cmd_ac_add(command->command_name);
cmd_ac_add_help(&command->command_name[1]);
@@ -184,7 +210,7 @@ callbacks_add_timed(const char* const plugin_name, PluginTimedFunction* timed_fu
timed_function_list = g_list_append(timed_function_list, timed_function);
} else {
timed_function_list = g_list_append(timed_function_list, timed_function);
g_hash_table_insert(p_timed_functions, g_strdup(plugin_name), timed_function_list);
g_hash_table_insert(p_timed_functions, strdup(plugin_name), timed_function_list);
}
}
@@ -216,11 +242,11 @@ callbacks_add_window_handler(const char* const plugin_name, const char* tag, Plu
{
GHashTable* window_callbacks = g_hash_table_lookup(p_window_callbacks, plugin_name);
if (window_callbacks) {
g_hash_table_insert(window_callbacks, g_strdup(tag), window_callback);
g_hash_table_insert(window_callbacks, strdup(tag), window_callback);
} else {
window_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)_free_window_callback);
g_hash_table_insert(window_callbacks, g_strdup(tag), window_callback);
g_hash_table_insert(p_window_callbacks, g_strdup(plugin_name), window_callbacks);
window_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, free, (GDestroyNotify)_free_window_callback);
g_hash_table_insert(window_callbacks, strdup(tag), window_callback);
g_hash_table_insert(p_window_callbacks, strdup(plugin_name), window_callbacks);
}
}

View File

@@ -4,7 +4,33 @@
*
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
*
* SPDX-License-Identifier: GPL-3.0-or-later WITH OpenSSL-exception
* 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.
*
*/
#ifndef PLUGINS_CALLBACKS_H

Some files were not shown because too many files have changed in this diff Show More