Fix some Coverity false positives

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(gpointer 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);
@@ -1725,11 +1726,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(gpointer value)
 static gboolean
 fail_pending_op(gpointer key, gpointer value, gpointer 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(gpointer 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

@@ -1015,8 +1015,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);
 }
 

daemons/fenced/fenced_commands.c

@@ -1953,40 +1953,6 @@ fenced_unregister_level(xmlNode *msg, pcmk__action_result_t *result)
     pcmk__set_result(result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
 }
 
-static char *
-list_to_string(GList *list, const char *delim, gboolean terminate_with_delim)
-{
-    int max = g_list_length(list);
-    size_t delim_len = delim?strlen(delim):0;
-    size_t alloc_size = 1 + (max?((max-1+(terminate_with_delim?1:0))*delim_len):0);
-    char *rv;
-
-    char *pos = NULL;
-    const char *lead_delim = "";
-
-    for (const GList *iter = list; iter != NULL; iter = iter->next) {
-        const char *value = (const char *) iter->data;
-
-        alloc_size += strlen(value);
-    }
-
-    rv = pcmk__assert_alloc(alloc_size, sizeof(char));
-    pos = rv;
-
-    for (const GList *iter = list; iter != NULL; iter = iter->next) {
-        const char *value = (const char *) iter->data;
-
-        pos = &pos[sprintf(pos, "%s%s", lead_delim, value)];
-        lead_delim = delim;
-    }
-
-    if ((max != 0) && terminate_with_delim) {
-        sprintf(pos, "%s", delim);
-    }
-
-    return rv;
-}
-
 /*!
  * \internal
  * \brief Execute a fence agent action directly (and asynchronously)
@@ -2028,17 +1994,25 @@ execute_agent_action(xmlNode *msg, pcmk__action_result_t *result)
         if (fencing_watchdog_timeout_ms <= 0) {
             pcmk__set_result(result, CRM_EX_ERROR, PCMK_EXEC_NO_FENCE_DEVICE,
                              "Watchdog fence device not configured");
-            return;
+        }
+
+        if (pcmk__str_eq(action, PCMK_ACTION_LIST, pcmk__str_none)) {
+            GString *buf = g_string_sized_new(64);
+
+            for (const GList *iter = stonith_watchdog_targets; iter != NULL;
+                 iter = iter->next) {
+
+                g_string_append(buf, iter->data);
+                g_string_append_c(buf, '\n');
+            }
 
-        } else if (pcmk__str_eq(action, PCMK_ACTION_LIST, pcmk__str_none)) {
             pcmk__set_result(result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
-            pcmk__set_result_output(result,
-                                    list_to_string(stonith_watchdog_targets,
-                                                   "\n", TRUE),
-                                    NULL);
+            result->action_stdout = pcmk__str_copy(buf->str);
+            g_string_free(buf, TRUE);
             return;
+        }
 
-        } else if (pcmk__str_eq(action, PCMK_ACTION_MONITOR, pcmk__str_none)) {
+        if (pcmk__str_eq(action, PCMK_ACTION_MONITOR, pcmk__str_none)) {
             pcmk__set_result(result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
             return;
         }
@@ -2052,9 +2026,11 @@ execute_agent_action(xmlNode *msg, pcmk__action_result_t *result)
         pcmk__format_result(result, CRM_EX_ERROR, PCMK_EXEC_NO_FENCE_DEVICE,
                             "'%s' not found", id);
         return;
+    }
+
+    if (!pcmk__is_set(device->flags, fenced_df_api_registered)
+        && pcmk__str_eq(action, PCMK_ACTION_MONITOR, pcmk__str_none)) {
 
-    } else if (!pcmk__is_set(device->flags, fenced_df_api_registered)
-               && (strcmp(action, PCMK_ACTION_MONITOR) == 0)) {
         // Monitors may run only on "started" (API-registered) devices
         pcmk__info("Ignoring API '%s' action request because device %s not "
                    "active",

daemons/fenced/fenced_history.c

@@ -284,10 +284,9 @@ stonith_xml_history_to_list(const xmlNode *history)
         }
         pcmk__set_result(&op->result, exit_status, execution_status,
                          pcmk__xe_get(xml_op, PCMK_XA_EXIT_REASON));
-        pcmk__set_result_output(&op->result,
-                                pcmk__xe_get_copy(xml_op, PCMK__XA_ST_OUTPUT),
-                                NULL);
 
+        op->result.action_stdout = pcmk__xe_get_copy(xml_op,
+                                                     PCMK__XA_ST_OUTPUT);
 
         g_hash_table_replace(rv, id, op);
         CRM_LOG_ASSERT(g_hash_table_lookup(rv, id) != NULL);

include/crm/common/actions.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2004-2025 the Pacemaker project contributors
+ * Copyright 2004-2026 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
@@ -77,7 +77,7 @@ gboolean decode_transition_magic(const char *magic, char **uuid,
 
 // @COMPAT Either these shouldn't be in libcrmcommon or lrmd_event_data_t should
 int rsc_op_expected_rc(const lrmd_event_data_t *event);
-gboolean did_rsc_op_fail(lrmd_event_data_t *event, int target_rc);
+gboolean did_rsc_op_fail(const lrmd_event_data_t *event, int target_rc);
 
 bool crm_op_needs_metadata(const char *rsc_class, const char *op);
 

include/crm/common/alerts_internal.h

@@ -80,7 +80,6 @@ enum pcmk__alert_keys_e {
 
 extern const char *pcmk__alert_keys[PCMK__ALERT_INTERNAL_KEY_MAX];
 
-pcmk__alert_t *pcmk__dup_alert(const pcmk__alert_t *entry);
 pcmk__alert_t *pcmk__alert_new(const char *id, const char *path);
 void pcmk__free_alert(pcmk__alert_t *entry);
 void pcmk__add_alert_key(GHashTable *table, enum pcmk__alert_keys_e name,

include/crm/common/results_internal.h

@@ -78,9 +78,6 @@ void pcmk__format_result(pcmk__action_result_t *result, int exit_status,
                          enum pcmk_exec_status exec_status,
                          const char *format, ...) G_GNUC_PRINTF(4, 5);
 
-void pcmk__set_result_output(pcmk__action_result_t *result,
-                             char *out, char *err);
-
 void pcmk__reset_result(pcmk__action_result_t *result);
 
 void pcmk__copy_result(const pcmk__action_result_t *src,