Fix some Coverity false positives

configure.ac

@@ -1221,19 +1221,6 @@ AC_RUN_IFELSE([AC_LANG_PROGRAM([[
               [AC_MSG_ERROR([strerror() is not C99-compliant])],
               [AC_MSG_ERROR([strerror() is not C99-compliant])])
 
-AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>]], [[
-    const char *s = "some-command-line-arg";
-    char *name = NULL;
-    int n = sscanf(s, "%ms", &name);
-    return n != 1;
-                               ]])],
-              [have_sscanf_m="yes"],
-              [have_sscanf_m="no"],
-              [have_sscanf_m="no"])
-AS_IF([test x"$have_sscanf_m" = x"yes"],
-      [AC_DEFINE([HAVE_SSCANF_M], [1],
-                 [Define to 1 if sscanf %m modifier is available])])
-
 AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include <time.h>]], [[
     char s[200];
     time_t t;
@@ -1292,31 +1279,41 @@ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <signal.h>]], [[sighandler_t *f;]]
 dnl ========================================================================
 dnl   ncurses
 dnl ========================================================================
-dnl
-dnl A few OSes (e.g. Linux) deliver a default "ncurses" alongside "curses".
-dnl Many non-Linux deliver "curses"; sites may add "ncurses".
-dnl
-dnl However, the source-code recommendation for both is to #include "curses.h"
-dnl (i.e. "ncurses" still wants the include to be simple, no-'n', "curses.h").
-dnl
-dnl ncurses takes precedence.
-dnl
-AC_CHECK_HEADERS([curses.h curses/curses.h ncurses.h ncurses/ncurses.h])
+
+found_ncurses_header=0
+
+m4_foreach(
+    [header], [[ncurses.h], [ncurses/ncurses.h]],
+    [AS_IF(
+        [test "$found_ncurses_header" -eq 0],
+        [AC_CHECK_HEADER(
+            header,
+            [
+                found_ncurses_header=1
+                AC_DEFINE([PCMK__NCURSES_H], [<header>], [Ncurses header file])
+            ]
+        )]
+    )]
+)
 
 save_LIBS="$LIBS"
-found_curses=0
-CURSES_LIBS=""
+found_ncurses=0
+NCURSES_LIBS=""
 LIBS=""
-AC_SEARCH_LIBS([printw], [ncurses curses],
-               [test "$ac_cv_search_printw" = "none required" || CURSES_LIBS="$LIBS"
-                found_curses=1],
-               [found_curses=0])
+AC_SEARCH_LIBS(
+    [printw], [ncurses],
+    [
+        test "$ac_cv_search_printw" = "none required" || NCURSES_LIBS="$LIBS"
+        found_ncurses=1
+    ],
+    [found_ncurses=0]
+)
 LIBS="$save_LIBS"
 
 dnl Check for printw() prototype compatibility
-AS_IF([test $found_curses -eq 1 && cc_supports_flag -Wcast-qual], [
+AS_IF([test $found_ncurses -eq 1 && cc_supports_flag -Wcast-qual], [
     ac_save_LIBS="$LIBS"
-    LIBS="$CURSES_LIBS"
+    LIBS="$NCURSES_LIBS"
 
     # avoid broken test because of hardened build environment in Fedora 23+
     # - https://fedoraproject.org/wiki/Changes/Harden_All_Packages
@@ -1325,31 +1322,26 @@ AS_IF([test $found_curses -eq 1 && cc_supports_flag -Wcast-qual], [
           [cc_temp_flags "-Wcast-qual $WERROR -fPIC"],
           [cc_temp_flags "-Wcast-qual $WERROR"])
 
-    AC_MSG_CHECKING([whether curses library is compatible])
+    AC_MSG_CHECKING([whether ncurses library is compatible])
     AC_LINK_IFELSE(
-        [AC_LANG_PROGRAM([
-#if defined(HAVE_NCURSES_H)
-#  include <ncurses.h>
-#elif defined(HAVE_NCURSES_NCURSES_H)
-#  include <ncurses/ncurses.h>
-#elif defined(HAVE_CURSES_H)
-#  include <curses.h>
-#elif defined(HAVE_CURSES_CURSES_H)
-#  include <curses/curses.h>
-#endif
-                         ],
-                         [printw((const char *)"Test");]
+        [AC_LANG_PROGRAM(
+            [
+                #ifdef PCMK__NCURSES_H
+                #include PCMK__NCURSES_H
+                #endif
+            ],
+            [printw((NCURSES_CONST char *) "Test");]
         )],
         [AC_MSG_RESULT([yes])
          PCMK_FEATURES="$PCMK_FEATURES ncurses"
         ],
         [
-            found_curses=0
-            CURSES_LIBS=""
+            found_ncurses=0
+            NCURSES_LIBS=""
             AC_MSG_RESULT([no])
-            AC_MSG_WARN(m4_normalize([Disabling curses because the printw()
-                                      function of your (n)curses library is old.
-                                      If you wish to enable curses, update to a
+            AC_MSG_WARN(m4_normalize([Disabling ncurses because the printw()
+                                      function of your ncurses library is old.
+                                      If you wish to enable ncurses, update to a
                                       newer version (ncurses 5.4 or later is
                                       recommended, available from
                                       https://invisible-island.net/ncurses/)
@@ -1361,8 +1353,9 @@ AS_IF([test $found_curses -eq 1 && cc_supports_flag -Wcast-qual], [
     cc_restore_flags
 ])
 
-AC_DEFINE_UNQUOTED([PCMK__ENABLE_CURSES], [$found_curses], [have ncurses library])
-AC_SUBST(CURSES_LIBS)
+AC_DEFINE_UNQUOTED([PCMK__ENABLE_CURSES], [$found_ncurses],
+                   [have ncurses library])
+AC_SUBST(NCURSES_LIBS)
 
 dnl ========================================================================
 dnl    Profiling and GProf

daemons/controld/controld_alerts.c

@@ -71,7 +71,7 @@ crmd_alert_fencing_op(stonith_event_t * e)
 }
 
 void
-crmd_alert_resource_op(const char *node, lrmd_event_data_t * op)
+crmd_alert_resource_op(const char *node, const lrmd_event_data_t *op)
 {
     lrm_state_t *lrm_state;
 

daemons/controld/controld_alerts.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2024 the Pacemaker project contributors
+ * Copyright 2015-2026 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
@@ -19,6 +19,6 @@
 void crmd_unpack_alerts(xmlNode *alerts);
 void crmd_alert_node_event(pcmk__node_status_t *node);
 void crmd_alert_fencing_op(stonith_event_t *e);
-void crmd_alert_resource_op(const char *node, lrmd_event_data_t *op);
+void crmd_alert_resource_op(const char *node, const lrmd_event_data_t *op);
 
 #endif

daemons/controld/controld_cib.c

@@ -518,7 +518,7 @@ build_parameter_list(const lrmd_event_data_t *op,
 }
 
 static void
-append_restart_list(lrmd_event_data_t *op, struct ra_metadata_s *metadata,
+append_restart_list(const lrmd_event_data_t *op, struct ra_metadata_s *metadata,
                     xmlNode *update, const char *version)
 {
     GString *list = NULL;
@@ -576,7 +576,7 @@ append_restart_list(lrmd_event_data_t *op, struct ra_metadata_s *metadata,
 }
 
 static void
-append_secure_list(lrmd_event_data_t *op, struct ra_metadata_s *metadata,
+append_secure_list(const lrmd_event_data_t *op, struct ra_metadata_s *metadata,
                    xmlNode *update, const char *version)
 {
     GString *list = NULL;
@@ -753,7 +753,7 @@ cib_rsc_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void *use
  * until it is active there again after the node comes back up.
  */
 static bool
-should_preserve_lock(lrmd_event_data_t *op)
+should_preserve_lock(const lrmd_event_data_t *op)
 {
     if (!pcmk__is_set(controld_globals.flags, controld_shutdown_lock_enabled)) {
         return false;

daemons/controld/controld_execd.c

@@ -152,7 +152,8 @@ history_free(void *data)
 }
 
 static void
-update_history_cache(lrm_state_t * lrm_state, lrmd_rsc_info_t * rsc, lrmd_event_data_t * op)
+update_history_cache(lrm_state_t *lrm_state, lrmd_rsc_info_t *rsc,
+                     const lrmd_event_data_t *op)
 {
     int target_rc = 0;
     rsc_history_t *entry = NULL;
@@ -269,7 +270,7 @@ send_task_ok_ack(const lrm_state_t *lrm_state, const ha_msg_input_t *input,
 }
 
 static inline const char *
-op_node_name(lrmd_event_data_t *op)
+op_node_name(const lrmd_event_data_t *op)
 {
     return pcmk__s(op->remote_nodename,
                    controld_globals.cluster->priv->node_name);
@@ -1728,11 +1729,13 @@ controld_ack_event_directly(const char *to_host, const char *to_sys,
     pcmk__node_status_t *peer = NULL;
 
     CRM_CHECK(op != NULL, return);
+
     if (op->rsc_id == NULL) {
-        // op->rsc_id is a (const char *) but lrmd_free_event() frees it
-        pcmk__assert(rsc_id != NULL);
         op->rsc_id = pcmk__str_copy(rsc_id);
     }
+
+    pcmk__assert(op->rsc_id != NULL);
+
     if (to_sys == NULL) {
         to_sys = CRM_SYSTEM_TENGINE;
     }

daemons/controld/controld_execd_state.c

@@ -55,31 +55,28 @@ free_recurring_op(void *value)
 static gboolean
 fail_pending_op(void *key, void *value, void *user_data)
 {
-    lrmd_event_data_t event = { 0, };
     lrm_state_t *lrm_state = user_data;
     active_op_t *op = value;
+    lrmd_event_data_t *event = lrmd_new_event(op->rsc_id, op->op_type,
+                                              op->interval_ms);
 
     pcmk__trace("Pre-emptively failing " PCMK__OP_FMT " on %s (call=%s, %s)",
                 op->rsc_id, op->op_type, op->interval_ms,
                 lrm_state->node_name, (const char *) key, op->user_data);
 
-    event.type = lrmd_event_exec_complete;
-    event.rsc_id = op->rsc_id;
-    event.op_type = op->op_type;
-    event.user_data = op->user_data;
-    event.timeout = 0;
-    event.interval_ms = op->interval_ms;
-    lrmd__set_result(&event, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_NOT_CONNECTED,
+    event->type = lrmd_event_exec_complete;
+    event->user_data = pcmk__str_copy(op->user_data);
+    lrmd__set_result(event, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_NOT_CONNECTED,
                      "Action was pending when executor connection was dropped");
-    event.t_run = op->start_time;
-    event.t_rcchange = op->start_time;
+    event->t_run = op->start_time;
+    event->t_rcchange = op->start_time;
 
-    event.call_id = op->call_id;
-    event.remote_nodename = lrm_state->node_name;
-    event.params = op->params;
+    event->call_id = op->call_id;
+    event->remote_nodename = pcmk__str_copy(lrm_state->node_name);
+    event->params = op->params;
 
-    process_lrm_event(lrm_state, &event, op, NULL);
-    lrmd__reset_result(&event);
+    process_lrm_event(lrm_state, event, op, NULL);
+    lrmd_free_event(event);
     return TRUE;
 }
 

daemons/controld/controld_remote_ra.c

@@ -399,26 +399,24 @@ check_remote_node_state(const remote_ra_cmd_t *cmd)
 static void
 report_remote_ra_result(remote_ra_cmd_t * cmd)
 {
-    lrmd_event_data_t op = { 0, };
+    lrmd_event_data_t *event = lrmd_new_event(cmd->rsc_id, cmd->action,
+                                              cmd->interval_ms);
 
     check_remote_node_state(cmd);
 
-    op.type = lrmd_event_exec_complete;
-    op.rsc_id = cmd->rsc_id;
-    op.op_type = cmd->action;
-    op.user_data = cmd->userdata;
-    op.timeout = cmd->timeout;
-    op.interval_ms = cmd->interval_ms;
-    op.t_run = cmd->start_time;
-    op.t_rcchange = cmd->start_time;
+    event->type = lrmd_event_exec_complete;
+    event->user_data = pcmk__str_copy(cmd->userdata);
+    event->timeout = cmd->timeout;
+    event->t_run = cmd->start_time;
+    event->t_rcchange = cmd->start_time;
 
-    lrmd__set_result(&op, cmd->result.exit_status, cmd->result.execution_status,
-                     cmd->result.exit_reason);
+    lrmd__set_result(event, cmd->result.exit_status,
+                     cmd->result.execution_status, cmd->result.exit_reason);
 
     if (pcmk__is_set(cmd->status, cmd_reported_success)
         && !pcmk__result_ok(&(cmd->result))) {
 
-        op.t_rcchange = time(NULL);
+        event->t_rcchange = time(NULL);
         /* This edge case will likely never ever occur, but if it does the
          * result is that a failure will not be processed correctly. This is only
          * remotely possible because we are able to detect a connection resource's tcp
@@ -428,27 +426,25 @@ report_remote_ra_result(remote_ra_cmd_t * cmd)
          * basically, we are not guaranteed that the first successful monitor op and
          * a subsequent failed monitor op will not occur in the same timestamp. We have to
          * make it look like the operations occurred at separate times though. */
-        if (op.t_rcchange == op.t_run) {
-            op.t_rcchange++;
+        if (event->t_rcchange == event->t_run) {
+            event->t_rcchange++;
         }
     }
 
     if (cmd->params) {
         lrmd_key_value_t *tmp;
 
-        op.params = pcmk__strkey_table(free, free);
+        event->params = pcmk__strkey_table(free, free);
         for (tmp = cmd->params; tmp; tmp = tmp->next) {
-            pcmk__insert_dup(op.params, tmp->key, tmp->value);
+            pcmk__insert_dup(event->params, tmp->key, tmp->value);
         }
 
     }
-    op.call_id = cmd->call_id;
-    op.remote_nodename = cmd->owner;
+    event->call_id = cmd->call_id;
+    event->remote_nodename = pcmk__str_copy(cmd->owner);
 
-    lrm_op_callback(&op);
-
-    g_clear_pointer(&op.params, g_hash_table_destroy);
-    lrmd__reset_result(&op);
+    lrm_op_callback(event);
+    lrmd_free_event(event);
 }
 
 /*!
@@ -562,22 +558,21 @@ monitor_timeout_cb(void *data)
 static void
 synthesize_lrmd_success(lrm_state_t *lrm_state, const char *rsc_id, const char *op_type)
 {
-    lrmd_event_data_t op = { 0, };
+    lrmd_event_data_t *event = NULL;
 
     if (lrm_state == NULL) {
         /* if lrm_state not given assume local */
         lrm_state = controld_get_executor_state(NULL, false);
     }
     pcmk__assert(lrm_state != NULL);
 
-    op.type = lrmd_event_exec_complete;
-    op.rsc_id = rsc_id;
-    op.op_type = op_type;
-    op.t_run = time(NULL);
-    op.t_rcchange = op.t_run;
-    op.call_id = generate_callid();
-    lrmd__set_result(&op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
-    process_lrm_event(lrm_state, &op, NULL, NULL);
+    event = lrmd_new_event(rsc_id, op_type, 0);
+    event->type = lrmd_event_exec_complete;
+    event->t_run = time(NULL);
+    event->t_rcchange = event->t_run;
+    event->call_id = generate_callid();
+    lrmd__set_result(event, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
+    process_lrm_event(lrm_state, event, NULL, NULL);
 }
 
 void

daemons/execd/execd_commands.c

@@ -1017,8 +1017,8 @@ action_complete(svc_action_t * action)
 #endif
 
 finalize:
-    pcmk__set_result_output(&(cmd->result), services__grab_stdout(action),
-                            services__grab_stderr(action));
+    cmd->result.action_stdout = pcmk__str_copy(action->stdout_data);
+    cmd->result.action_stderr = pcmk__str_copy(action->stderr_data);
     cmd_finalize(cmd, rsc);
 }