/*
 * Copyright 2009-2026 the Pacemaker project contributors
 *
 * The version control history for this file may have further details.
 *
 * This source code is licensed under the GNU General Public License version 2
 * or later (GPLv2+) WITHOUT ANY WARRANTY.
 */

#include <crm_internal.h>

#include <sys/param.h>
#include <stdbool.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/utsname.h>

#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <ctype.h>
#include <regex.h>

#include <libxml/tree.h>                // xmlNode

#include <crm/crm.h>
#include <crm/common/ipc.h>
#include <crm/cluster/internal.h>

#include <crm/stonith-ng.h>
#include <crm/fencing/internal.h>
#include <crm/common/xml.h>

#include <crm/common/util.h>
#include <pacemaker-fenced.h>

#define TIMEOUT_MULTIPLY_FACTOR 1.2

/* When one fencer queries its peers for devices able to handle a fencing
 * request, each peer will reply with a list of such devices available to it.
 * Each reply will be parsed into a peer_device_info_t, with each device's
 * information kept in a device_properties_t.
 */

typedef struct {
    /* Whether access to this device has been verified */
    gboolean verified;

    /* The remaining members are indexed by the operation's "phase" */

    /* Whether this device has been executed in each phase */
    gboolean executed[st_phase_max];
    /* Whether this device is disallowed from executing in each phase */
    gboolean disallowed[st_phase_max];
    /* Action-specific timeout for each phase */
    int custom_action_timeout[st_phase_max];
    /* Action-specific maximum random delay for each phase */
    int delay_max[st_phase_max];
    /* Action-specific base delay for each phase */
    int delay_base[st_phase_max];
    /* Group of enum st_device_flags */
    uint32_t device_support_flags;
} device_properties_t;

typedef struct {
    /* Name of peer that sent this result */
    char *host;
    /* Only try peers for non-topology based operations once */
    gboolean tried;
    /* Number of entries in the devices table */
    int ndevices;
    /* Devices available to this host that are capable of fencing the target */
    GHashTable *devices;
} peer_device_info_t;

GHashTable *stonith_remote_op_list = NULL;

extern xmlNode *stonith_create_op(int call_id, const char *token, const char *op, xmlNode * data,
                                  int call_options);

static void request_peer_fencing(remote_fencing_op_t *op,
                                 peer_device_info_t *peer);
static void finalize_op(remote_fencing_op_t *op, xmlNode *data, bool dup);
static void report_timeout_period(remote_fencing_op_t * op, int op_timeout);
static int get_op_total_timeout(const remote_fencing_op_t *op,
                                const peer_device_info_t *chosen_peer);

static gint
sort_strings(gconstpointer a, gconstpointer b)
{
    return strcmp(a, b);
}

static void
free_remote_query(gpointer data)
{
    if (data != NULL) {
        peer_device_info_t *peer = data;

        g_hash_table_destroy(peer->devices);
        free(peer->host);
        free(peer);
    }
}

void
free_stonith_remote_op_list(void)
{
    g_clear_pointer(&stonith_remote_op_list, g_hash_table_destroy);
}

struct peer_count_data {
    const remote_fencing_op_t *op;
    gboolean verified_only;
    uint32_t support_action_only;
    int count;
};

/*!
 * \internal
 * \brief Increment a counter if a device has not been executed yet
 *
 * \param[in]     key        Device ID (ignored)
 * \param[in]     value      Device properties
 * \param[in,out] user_data  Peer count data
 */
static void
count_peer_device(gpointer key, gpointer value, gpointer user_data)
{
    device_properties_t *props = (device_properties_t*)value;
    struct peer_count_data *data = user_data;

    if (!props->executed[data->op->phase]
        && (!data->verified_only || props->verified)
        && ((data->support_action_only == fenced_df_none)
            || pcmk__is_set(props->device_support_flags,
                           data->support_action_only))) {
        ++(data->count);
    }
}

/*!
 * \internal
 * \brief Check the number of available devices in a peer's query results
 *
 * \param[in] op             Operation that results are for
 * \param[in] peer           Peer to count
 * \param[in] verified_only  Whether to count only verified devices
 * \param[in] support_action_only Whether to count only devices that support action
 *
 * \return Number of devices available to peer that were not already executed
 */
static int
count_peer_devices(const remote_fencing_op_t *op,
                   const peer_device_info_t *peer, gboolean verified_only, uint32_t support_on_action_only)
{
    struct peer_count_data data;

    data.op = op;
    data.verified_only = verified_only;
    data.support_action_only = support_on_action_only;
    data.count = 0;
    if (peer) {
        g_hash_table_foreach(peer->devices, count_peer_device, &data);
    }
    return data.count;
}

/*!
 * \internal
 * \brief Search for a device in a query result
 *
 * \param[in] op      Operation that result is for
 * \param[in] peer    Query result for a peer
 * \param[in] device  Device ID to search for
 *
 * \return Device properties if found, NULL otherwise
 */
static device_properties_t *
find_peer_device(const remote_fencing_op_t *op, const peer_device_info_t *peer,
                 const char *device, uint32_t support_action_only)
{
    device_properties_t *props = g_hash_table_lookup(peer->devices, device);

    if (props == NULL) {
        return NULL;
    }
    if ((support_action_only != fenced_df_none)
        && !pcmk__is_set(props->device_support_flags, support_action_only)) {
        return NULL;
    }
    if (props->executed[op->phase] || props->disallowed[op->phase]) {
        return NULL;
    }
    return props;
}

/*!
 * \internal
 * \brief Find a device in a peer's device list and mark it as executed
 *
 * \param[in]     op                     Operation that peer result is for
 * \param[in,out] peer                   Peer with results to search
 * \param[in]     device                 ID of device to mark as done
 * \param[in]     verified_devices_only  Only consider verified devices
 *
 * \return TRUE if device was found and marked, FALSE otherwise
 */
static gboolean
grab_peer_device(const remote_fencing_op_t *op, peer_device_info_t *peer,
                 const char *device, gboolean verified_devices_only)
{
    device_properties_t *props = find_peer_device(op, peer, device,
                                                  fenced_support_flag(op->action));

    if ((props == NULL) || (verified_devices_only && !props->verified)) {
        return FALSE;
    }

    pcmk__trace("Removing %s from %s (%d remaining)", device, peer->host,
                count_peer_devices(op, peer, FALSE, fenced_df_none));
    props->executed[op->phase] = TRUE;
    return TRUE;
}

static void
clear_remote_op_timers(remote_fencing_op_t * op)
{
    if (op->query_timer) {
        g_source_remove(op->query_timer);
        op->query_timer = 0;
    }
    if (op->op_timer_total) {
        g_source_remove(op->op_timer_total);
        op->op_timer_total = 0;
    }
    if (op->op_timer_one) {
        g_source_remove(op->op_timer_one);
        op->op_timer_one = 0;
    }
}

static void
free_remote_op(gpointer data)
{
    remote_fencing_op_t *op = data;

    pcmk__log_xml_debug(op->request, "Destroying");

    clear_remote_op_timers(op);

    free(op->id);
    free(op->action);
    free(op->delegate);
    free(op->target);
    free(op->client_id);
    free(op->client_name);
    free(op->originator);

    g_list_free_full(op->query_results, free_remote_query);
    g_clear_pointer(&op->request, pcmk__xml_free);
    g_list_free_full(op->devices_list, free);
    g_list_free_full(op->automatic_list, free);
    g_list_free(op->duplicates);

    pcmk__reset_result(&op->result);
    free(op);
}

void
init_stonith_remote_op_hash_table(GHashTable **table)
{
    if (*table == NULL) {
        *table = pcmk__strkey_table(NULL, free_remote_op);
    }
}

/*!
 * \internal
 * \brief Return an operation's originally requested action (before any remap)
 *
 * \param[in] op  Operation to check
 *
 * \return Operation's original action
 */
static const char *
op_requested_action(const remote_fencing_op_t *op)
{
    return ((op->phase > st_phase_requested)? PCMK_ACTION_REBOOT : op->action);
}

/*!
 * \internal
 * \brief Remap a "reboot" operation to the "off" phase
 *
 * \param[in,out] op      Operation to remap
 */
static void
op_phase_off(remote_fencing_op_t *op)
{
    pcmk__info("Remapping multiple-device reboot targeting %s to 'off' "
               QB_XS " id=%.8s",
               op->target, op->id);
    op->phase = st_phase_off;

    /* Happily, "off" and "on" are shorter than "reboot", so we can reuse the
     * memory allocation at each phase.
     */
    strcpy(op->action, PCMK_ACTION_OFF);
}

/*!
 * \internal
 * \brief Advance a remapped reboot operation to the "on" phase
 *
 * \param[in,out] op  Operation to remap
 */
static void
op_phase_on(remote_fencing_op_t *op)
{
    GList *iter = NULL;

    pcmk__info("Remapped 'off' targeting %s complete, remapping to 'on' for "
               "%s " QB_XS " id=%.8s",
               op->target, op->client_name, op->id);
    op->phase = st_phase_on;
    strcpy(op->action, PCMK_ACTION_ON);

    /* Skip devices with automatic unfencing, because the cluster will handle it
     * when the node rejoins.
     */
    for (iter = op->automatic_list; iter != NULL; iter = iter->next) {
        GList *match = g_list_find_custom(op->devices_list, iter->data,
                                            sort_strings);

        if (match) {
            op->devices_list = g_list_remove(op->devices_list, match->data);
        }
    }
    g_list_free_full(op->automatic_list, free);
    op->automatic_list = NULL;

    /* Rewind device list pointer */
    op->devices = op->devices_list;
}

/*!
 * \internal
 * \brief Reset a remapped reboot operation
 *
 * \param[in,out] op  Operation to reset
 */
static void
undo_op_remap(remote_fencing_op_t *op)
{
    if (op->phase > 0) {
        pcmk__info("Undoing remap of reboot targeting %s for %s "
                   QB_XS " id=%.8s",
                   op->target, op->client_name, op->id);
        op->phase = st_phase_requested;
        strcpy(op->action, PCMK_ACTION_REBOOT);
    }
}

/*!
 * \internal
 * \brief Create notification data XML for a fencing operation result
 *
 * \param[in,out] parent  Parent XML element for newly created element
 * \param[in]     op      Fencer operation that completed
 *
 * \return Newly created XML to add as notification data
 * \note The caller is responsible for freeing the result.
 */
static xmlNode *
fencing_result2xml(xmlNode *parent, const remote_fencing_op_t *op)
{
    xmlNode *notify_data = pcmk__xe_create(parent, PCMK__XE_ST_NOTIFY_FENCE);

    pcmk__xe_set_int(notify_data, PCMK_XA_STATE, op->state);
    pcmk__xe_set(notify_data, PCMK__XA_ST_TARGET, op->target);
    pcmk__xe_set(notify_data, PCMK__XA_ST_DEVICE_ACTION, op->action);
    pcmk__xe_set(notify_data, PCMK__XA_ST_DELEGATE, op->delegate);
    pcmk__xe_set(notify_data, PCMK__XA_ST_REMOTE_OP, op->id);
    pcmk__xe_set(notify_data, PCMK__XA_ST_ORIGIN, op->originator);
    pcmk__xe_set(notify_data, PCMK__XA_ST_CLIENTID, op->client_id);
    pcmk__xe_set(notify_data, PCMK__XA_ST_CLIENTNAME, op->client_name);

    return notify_data;
}

/*!
 * \internal
 * \brief Broadcast a fence result notification to all CPG peers
 *
 * \param[in] op         Fencer operation that completed
 * \param[in] op_merged  Whether this operation is a duplicate of another
 */
void
fenced_broadcast_op_result(const remote_fencing_op_t *op, bool op_merged)
{
    static int count = 0;
    xmlNode *bcast = pcmk__xe_create(NULL, PCMK__XE_ST_REPLY);
    xmlNode *wrapper = NULL;
    xmlNode *notify_data = NULL;

    count++;
    pcmk__trace("Broadcasting result to peers");
    pcmk__xe_set(bcast, PCMK__XA_T, PCMK__VALUE_ST_NOTIFY);
    pcmk__xe_set(bcast, PCMK__XA_SUBT, PCMK__VALUE_BROADCAST);
    pcmk__xe_set(bcast, PCMK__XA_ST_OP, STONITH_OP_NOTIFY);
    pcmk__xe_set_int(bcast, PCMK_XA_COUNT, count);

    if (op_merged) {
        pcmk__xe_set_bool(bcast, PCMK__XA_ST_OP_MERGED, true);
    }

    wrapper = pcmk__xe_create(bcast, PCMK__XE_ST_CALLDATA);
    notify_data = fencing_result2xml(wrapper, op);
    stonith__xe_set_result(notify_data, &op->result);

    pcmk__cluster_send_message(NULL, pcmk_ipc_fenced, bcast);
    pcmk__xml_free(bcast);
}

/*!
 * \internal
 * \brief Reply to a local request originator and notify all subscribed clients
 *
 * \param[in,out] op    Fencer operation that completed
 * \param[in,out] data  Top-level XML to add notification to
 */
static void
handle_local_reply_and_notify(remote_fencing_op_t *op, xmlNode *data)
{
    xmlNode *notify_data = NULL;
    xmlNode *reply = NULL;
    pcmk__client_t *client = NULL;

    if (op->notify_sent == TRUE) {
        /* nothing to do */
        return;
    }

    /* Do notification with a clean data object */
    pcmk__xe_set_int(data, PCMK_XA_STATE, op->state);
    pcmk__xe_set(data, PCMK__XA_ST_TARGET, op->target);
    pcmk__xe_set(data, PCMK__XA_ST_OP, op->action);

    reply = fenced_construct_reply(op->request, data, &op->result);
    pcmk__xe_set(reply, PCMK__XA_ST_DELEGATE, op->delegate);

    /* Send fencing OP reply to local client that initiated fencing */
    client = pcmk__find_client_by_id(op->client_id);
    if (client == NULL) {
        pcmk__trace("Skipping reply to %s: no longer a client", op->client_id);
    } else {
        do_local_reply(reply, client, op->call_options);
    }

    /* bcast to all local clients that the fencing operation happend */
    notify_data = fencing_result2xml(NULL, op);
    fenced_send_notification(PCMK__VALUE_ST_NOTIFY_FENCE, &op->result,
                             notify_data);
    pcmk__xml_free(notify_data);
    fenced_send_notification(PCMK__VALUE_ST_NOTIFY_HISTORY, NULL, NULL);

    /* mark this op as having notify's already sent */
    op->notify_sent = TRUE;
    pcmk__xml_free(reply);
}

/*!
 * \internal
 * \brief Finalize all duplicates of a given fencer operation
 *
 * \param[in,out] op    Fencer operation that completed
 * \param[in,out] data  Top-level XML to add notification to
 */
static void
finalize_op_duplicates(remote_fencing_op_t *op, xmlNode *data)
{
    for (GList *iter = op->duplicates; iter != NULL; iter = iter->next) {
        remote_fencing_op_t *other = iter->data;

        if (other->state == st_duplicate) {
            other->state = op->state;
            pcmk__debug("Performing duplicate notification for %s@%s: %s "
                        QB_XS " id=%.8s",
                        other->client_name, other->originator,
                        pcmk_exec_status_str(op->result.execution_status),
                        other->id);
            pcmk__copy_result(&op->result, &other->result);
            finalize_op(other, data, true);

        } else {
            // Possible if (for example) it timed out already
            pcmk__err("Skipping duplicate notification for %s@%s "
                      QB_XS " state=%s id=%.8s",
                      other->client_name, other->originator,
                      stonith__op_state_text(other->state), other->id);
        }
    }
}

static char *
delegate_from_xml(xmlNode *xml)
{
    xmlNode *match = pcmk__xpath_find_one(xml->doc,
                                          "//*[@" PCMK__XA_ST_DELEGATE "]",
                                          PCMK__LOG_NEVER);

    if (match == NULL) {
        return pcmk__xe_get_copy(xml, PCMK__XA_SRC);
    } else {
        return pcmk__xe_get_copy(match, PCMK__XA_ST_DELEGATE);
    }
}

/*!
 * \internal
 * \brief Finalize a peer fencing operation
 *
 * Clean up after a fencing operation completes. This function has two code
 * paths: the executioner uses it to broadcast the result to CPG peers, and then
 * each peer (including the executioner) uses it to process that broadcast and
 * notify its IPC clients of the result.
 *
 * \param[in,out] op      Fencer operation that completed
 * \param[in,out] data    If not NULL, XML reply of last delegated operation
 * \param[in]     dup     Whether this operation is a duplicate of another
 *                        (in which case, do not broadcast the result)
 *
 *  \note The operation result should be set before calling this function.
 */
static void
finalize_op(remote_fencing_op_t *op, xmlNode *data, bool dup)
{
    int level = LOG_ERR;
    const char *subt = NULL;
    xmlNode *local_data = NULL;
    gboolean op_merged = FALSE;

    CRM_CHECK((op != NULL), return);

    // This is a no-op if timers have already been cleared
    clear_remote_op_timers(op);

    if (op->notify_sent) {
        // Most likely, this is a timed-out action that eventually completed
        pcmk__notice("Operation '%s'%s%s by %s for %s@%s%s: Result arrived too "
                     "late " QB_XS " id=%.8s",
                     op->action, (op->target? " targeting " : ""),
                     pcmk__s(op->target, ""),
                     pcmk__s(op->delegate, "unknown node"), op->client_name,
                     op->originator, (op_merged? " (merged)" : ""), op->id);
        return;
    }

    set_fencing_completed(op);
    undo_op_remap(op);

    if (data == NULL) {
        data = pcmk__xe_create(NULL, "remote-op");
        local_data = data;

    } else if (op->delegate == NULL) {
        switch (op->result.execution_status) {
            case PCMK_EXEC_NO_FENCE_DEVICE:
                break;

            case PCMK_EXEC_INVALID:
                if (op->result.exit_status != CRM_EX_EXPIRED) {
                    op->delegate = delegate_from_xml(data);
                }
                break;

            default:
                op->delegate = delegate_from_xml(data);
                break;
        }
    }

    if (dup || (pcmk__xe_get(data, PCMK__XA_ST_OP_MERGED) != NULL)) {
        op_merged = true;
    }

    /* Tell everyone the operation is done, we will continue
     * with doing the local notifications once we receive
     * the broadcast back. */
    subt = pcmk__xe_get(data, PCMK__XA_SUBT);
    if (!dup && !pcmk__str_eq(subt, PCMK__VALUE_BROADCAST, pcmk__str_none)) {
        /* Defer notification until the bcast message arrives */
        fenced_broadcast_op_result(op, op_merged);
        pcmk__xml_free(local_data);
        return;
    }

    if (pcmk__result_ok(&op->result) || dup
        || !pcmk__str_eq(op->originator, fenced_get_local_node(),
                         pcmk__str_casei)) {
        level = LOG_NOTICE;
    }
    do_crm_log(level, "Operation '%s'%s%s by %s for %s@%s%s: %s (%s%s%s) "
               QB_XS " id=%.8s", op->action, (op->target? " targeting " : ""),
               (op->target? op->target : ""),
               (op->delegate? op->delegate : "unknown node"),
               op->client_name, op->originator,
               (op_merged? " (merged)" : ""),
               crm_exit_str(op->result.exit_status),
               pcmk_exec_status_str(op->result.execution_status),
               ((op->result.exit_reason == NULL)? "" : ": "),
               ((op->result.exit_reason == NULL)? "" : op->result.exit_reason),
               op->id);

    handle_local_reply_and_notify(op, data);

    if (!dup) {
        finalize_op_duplicates(op, data);
    }

    /* Free non-essential parts of the record
     * Keep the record around so we can query the history
     */
    g_list_free_full(op->query_results, free_remote_query);
    op->query_results = NULL;

    g_clear_pointer(&op->request, pcmk__xml_free);
    pcmk__xml_free(local_data);
}

/*!
 * \internal
 * \brief Finalize a watchdog fencer op after the waiting time expires
 *
 * \param[in,out] userdata  Fencer operation that completed
 *
 * \return G_SOURCE_REMOVE (which tells glib not to restart timer)
 */
static gboolean
remote_op_watchdog_done(gpointer userdata)
{
    remote_fencing_op_t *op = userdata;

    op->op_timer_one = 0;

    pcmk__notice("Self-fencing (%s) by %s for %s assumed complete "
                 QB_XS " id=%.8s",
                 op->action, op->target, op->client_name, op->id);
    op->state = st_done;
    pcmk__set_result(&op->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
    finalize_op(op, NULL, false);
    return G_SOURCE_REMOVE;
}

static gboolean
remote_op_timeout_one(gpointer userdata)
{
    remote_fencing_op_t *op = userdata;

    op->op_timer_one = 0;

    pcmk__notice("Peer's '%s' action targeting %s for client %s timed out "
                 QB_XS " id=%.8s",
                 op->action, op->target, op->client_name, op->id);
    pcmk__set_result(&op->result, CRM_EX_ERROR, PCMK_EXEC_TIMEOUT,
                     "Peer did not return fence result within timeout");

    // The requested delay has been applied for the first device
    if (op->client_delay > 0) {
        op->client_delay = 0;
        pcmk__trace("Try another device for '%s' action targeting %s for "
                    "client %s without delay " QB_XS " id=%.8s",
                    op->action, op->target, op->client_name, op->id);
    }

    // Try another device, if appropriate
    request_peer_fencing(op, NULL);
    return G_SOURCE_REMOVE;
}

/*!
 * \internal
 * \brief Finalize a remote fencer operation that timed out
 *
 * \param[in,out] op      Fencer operation that timed out
 * \param[in]     reason  Readable description of what step timed out
 */
static void
finalize_timed_out_op(remote_fencing_op_t *op, const char *reason)
{
    pcmk__debug("Action '%s' targeting %s for client %s timed out "
                QB_XS " id=%.8s",
                op->action, op->target, op->client_name, op->id);

    if (op->phase == st_phase_on) {
        /* A remapped reboot operation timed out in the "on" phase, but the
         * "off" phase completed successfully, so quit trying any further
         * devices, and return success.
         */
        op->state = st_done;
        pcmk__set_result(&op->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
    } else {
        op->state = st_failed;
        pcmk__set_result(&op->result, CRM_EX_ERROR, PCMK_EXEC_TIMEOUT, reason);
    }
    finalize_op(op, NULL, false);
}

/*!
 * \internal
 * \brief Finalize a remote fencer operation that timed out
 *
 * \param[in,out] userdata  Fencer operation that timed out
 *
 * \return G_SOURCE_REMOVE (which tells glib not to restart timer)
 */
static gboolean
remote_op_timeout(gpointer userdata)
{
    remote_fencing_op_t *op = userdata;

    op->op_timer_total = 0;

    if (op->state == st_done) {
        pcmk__debug("Action '%s' targeting %s for client %s already completed "
                    QB_XS " id=%.8s",
                    op->action, op->target, op->client_name, op->id);
    } else {
        finalize_timed_out_op(userdata, "Fencing did not complete within a "
                                        "total timeout based on the "
                                        "configured timeout and retries for "
                                        "any devices attempted");
    }
    return G_SOURCE_REMOVE;
}

static gboolean
remote_op_query_timeout(gpointer data)
{
    remote_fencing_op_t *op = data;

    op->query_timer = 0;

    if (op->state == st_done) {
        pcmk__debug("Operation %.8s targeting %s already completed", op->id,
                    op->target);

    } else if (op->state == st_exec) {
        pcmk__debug("Operation %.8s targeting %s already in progress", op->id,
                    op->target);

    } else if (op->query_results) {
        // Query succeeded, so attempt the actual fencing
        pcmk__debug("Query %.8s targeting %s complete (state=%s)",
                    op->id, op->target, stonith__op_state_text(op->state));
        request_peer_fencing(op, NULL);

    } else {
        pcmk__debug("Query %.8s targeting %s timed out (state=%s)",
                    op->id, op->target, stonith__op_state_text(op->state));
        finalize_timed_out_op(op,
                              "No capable peers replied to device query within "
                              "timeout");
    }

    return G_SOURCE_REMOVE;
}

static gboolean
topology_is_empty(stonith_topology_t *tp)
{
    int i;

    if (tp == NULL) {
        return TRUE;
    }

    for (i = 0; i < ST__LEVEL_COUNT; i++) {
        if (tp->levels[i] != NULL) {
            return FALSE;
        }
    }
    return TRUE;
}

/*!
 * \internal
 * \brief Add a device to an operation's automatic unfencing list
 *
 * \param[in,out] op      Operation to modify
 * \param[in]     device  Device ID to add
 */
static void
add_required_device(remote_fencing_op_t *op, const char *device)
{
    GList *match  = g_list_find_custom(op->automatic_list, device,
                                         sort_strings);

    if (!match) {
        op->automatic_list = g_list_prepend(op->automatic_list,
                                            pcmk__str_copy(device));
    }
}

/*!
 * \internal
 * \brief Remove a device from the automatic unfencing list
 *
 * \param[in,out] op      Operation to modify
 * \param[in]     device  Device ID to remove
 */
static void
remove_required_device(remote_fencing_op_t *op, const char *device)
{
    GList *match = g_list_find_custom(op->automatic_list, device,
                                        sort_strings);

    if (match) {
        op->automatic_list = g_list_remove(op->automatic_list, match->data);
    }
}

/* deep copy the device list */
static void
set_op_device_list(remote_fencing_op_t * op, GList *devices)
{
    GList *lpc = NULL;

    g_list_free_full(op->devices_list, free);
    op->devices_list = NULL;

    for (lpc = devices; lpc != NULL; lpc = lpc->next) {
        const char *device = lpc->data;

        op->devices_list = g_list_append(op->devices_list,
                                         pcmk__str_copy(device));
    }
    op->devices = op->devices_list;
}

/*!
 * \internal
 * \brief Check whether a node matches a topology target
 *
 * \param[in] tp    Topology table entry to check
 * \param[in] node  Name of node to check
 *
 * \return TRUE if node matches topology target
 */
static gboolean
topology_matches(const stonith_topology_t *tp, const char *node)
{
    regex_t r_patt;

    CRM_CHECK(node && tp && tp->target, return FALSE);
    switch (tp->kind) {
        case fenced_target_by_attribute:
            /* This level targets by attribute, so tp->target is a NAME=VALUE pair
             * of a permanent attribute applied to targeted nodes. The test below
             * relies on the locally cached copy of the CIB, so if fencing needs to
             * be done before the initial CIB is received or after a malformed CIB
             * is received, then the topology will be unable to be used.
             */
            if (node_has_attr(node, tp->target_attribute, tp->target_value)) {
                pcmk__notice("Matched %s with %s by attribute", node,
                             tp->target);
                return TRUE;
            }
            break;

        case fenced_target_by_pattern:
            /* This level targets node names matching a pattern, so tp->target
             * (and tp->target_pattern) is a regular expression.
             */
            if (regcomp(&r_patt, tp->target_pattern, REG_EXTENDED|REG_NOSUB)) {
                pcmk__info("Bad regex '%s' for fencing level", tp->target);
            } else {
                int status = regexec(&r_patt, node, 0, NULL, 0);

                regfree(&r_patt);
                if (status == 0) {
                    pcmk__notice("Matched %s with %s by name", node,
                                 tp->target);
                    return TRUE;
                }
            }
            break;

        case fenced_target_by_name:
            pcmk__trace("Testing %s against %s", node, tp->target);
            return pcmk__str_eq(tp->target, node, pcmk__str_casei);

        default:
            break;
    }
    pcmk__trace("No match for %s with %s", node, tp->target);
    return FALSE;
}

stonith_topology_t *
find_topology_for_host(const char *host) 
{
    GHashTableIter tIter;
    stonith_topology_t *tp = g_hash_table_lookup(topology, host);

    if(tp != NULL) {
        pcmk__trace("Found %s for %s in %u entries", tp->target, host,
                    g_hash_table_size(topology));
        return tp;
    }

    g_hash_table_iter_init(&tIter, topology);
    while (g_hash_table_iter_next(&tIter, NULL, (gpointer *) & tp)) {
        if (topology_matches(tp, host)) {
            pcmk__trace("Found %s for %s in %u entries", tp->target, host,
                        g_hash_table_size(topology));
            return tp;
        }
    }

    pcmk__trace("No matches for %s in %u topology entries", host,
                g_hash_table_size(topology));
    return NULL;
}

/*!
 * \internal
 * \brief Set fencing operation's device list to target's next topology level
 *
 * \param[in,out] op        Remote fencing operation to modify
 * \param[in]     empty_ok  If true, an operation without a target (i.e.
 *                          queries) or a target without a topology will get a
 *                          pcmk_rc_ok return value instead of ENODEV
 *
 * \return Standard Pacemaker return value
 */
static int
advance_topology_level(remote_fencing_op_t *op, bool empty_ok)
{
    stonith_topology_t *tp = NULL;

    if (op->target) {
        tp = find_topology_for_host(op->target);
    }
    if (topology_is_empty(tp)) {
        return empty_ok? pcmk_rc_ok : ENODEV;
    }

    pcmk__assert(tp->levels != NULL);

    stonith__set_call_options(op->call_options, op->id, st_opt_topology);

    /* This is a new level, so undo any remapping left over from previous */
    undo_op_remap(op);

    do {
        op->level++;

    } while (op->level < ST__LEVEL_COUNT && tp->levels[op->level] == NULL);

    if (op->level < ST__LEVEL_COUNT) {
        pcmk__trace("Attempting fencing level %d targeting %s (%d devices) for "
                    "client %s@%s (id=%.8s)",
                    op->level, op->target, g_list_length(tp->levels[op->level]),
                    op->client_name, op->originator, op->id);
        set_op_device_list(op, tp->levels[op->level]);

        // The requested delay has been applied for the first fencing level
        if ((op->level > 1) && (op->client_delay > 0)) {
            op->client_delay = 0;
        }

        if ((g_list_next(op->devices_list) != NULL)
            && pcmk__str_eq(op->action, PCMK_ACTION_REBOOT, pcmk__str_none)) {
            /* A reboot has been requested for a topology level with multiple
             * devices. Instead of rebooting the devices sequentially, we will
             * turn them all off, then turn them all on again. (Think about
             * switched power outlets for redundant power supplies.)
             */
            op_phase_off(op);
        }
        return pcmk_rc_ok;
    }

    pcmk__info("All %sfencing options targeting %s for client %s@%s failed "
               QB_XS " id=%.8s",
               ((fencing_watchdog_timeout_ms > 0) ? "non-watchdog " : ""),
               op->target, op->client_name, op->originator, op->id);
    return ENODEV;
}

/*!
 * \internal
 * \brief If fencing operation is a duplicate, merge it into the other one
 *
 * \param[in,out] op  Fencing operation to check
 */
static void
merge_duplicates(remote_fencing_op_t *op)
{
    GHashTableIter iter;
    remote_fencing_op_t *other = NULL;

    time_t now = time(NULL);

    g_hash_table_iter_init(&iter, stonith_remote_op_list);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&other)) {
        const char *other_action = op_requested_action(other);
        pcmk__node_status_t *node = NULL;

        if (!strcmp(op->id, other->id)) {
            continue; // Don't compare against self
        }
        if (other->state > st_exec) {
            pcmk__trace("%.8s not duplicate of %.8s: not in progress", op->id,
                        other->id);
            continue;
        }
        if (!pcmk__str_eq(op->target, other->target, pcmk__str_casei)) {
            pcmk__trace("%.8s not duplicate of %.8s: node %s vs. %s", op->id,
                        other->id, op->target, other->target);
            continue;
        }
        if (!pcmk__str_eq(op->action, other_action, pcmk__str_none)) {
            pcmk__trace("%.8s not duplicate of %.8s: action %s vs. %s", op->id,
                        other->id, op->action, other_action);
            continue;
        }
        if (pcmk__str_eq(op->client_name, other->client_name, pcmk__str_casei)) {
            pcmk__trace("%.8s not duplicate of %.8s: same client %s", op->id,
                        other->id, op->client_name);
            continue;
        }
        if (pcmk__str_eq(other->target, other->originator, pcmk__str_casei)) {
            pcmk__trace("%.8s not duplicate of %.8s: self-fencing for %s",
                        op->id, other->id, other->target);
            continue;
        }

        node = pcmk__get_node(0, other->originator, NULL,
                              pcmk__node_search_cluster_member);

        if (!fencing_peer_active(node)) {
            pcmk__notice("Failing action '%s' targeting %s originating from "
                         "client %s@%s: Originator is dead " QB_XS " id=%.8s",
                         other->action, other->target, other->client_name,
                         other->originator, other->id);
            pcmk__trace("%.8s not duplicate of %.8s: originator dead", op->id,
                        other->id);
            other->state = st_failed;
            continue;
        }
        if ((other->total_timeout > 0)
            && (now > (other->total_timeout + other->created))) {
            pcmk__trace("%.8s not duplicate of %.8s: old (%lld vs. %lld + %ds)",
                        op->id, other->id, (long long) now,
                        (long long) other->created, other->total_timeout);
            continue;
        }

        /* There is another in-flight request to fence the same host
         * Piggyback on that instead.  If it fails, so do we.
         */
        other->duplicates = g_list_append(other->duplicates, op);
        if (other->total_timeout == 0) {
            other->total_timeout = op->total_timeout =
                TIMEOUT_MULTIPLY_FACTOR * get_op_total_timeout(op, NULL);
            pcmk__trace("Best guess as to timeout used for %.8s: %ds",
                        other->id, other->total_timeout);
        }
        pcmk__notice("Merging fencing action '%s' targeting %s originating "
                     "from client %s with identical request from %s@%s "
                     QB_XS " original=%.8s duplicate=%.8s total_timeout=%ds",
                     op->action, op->target, op->client_name,
                     other->client_name, other->originator,
                     op->id, other->id, other->total_timeout);
        report_timeout_period(op, other->total_timeout);
        op->state = st_duplicate;
    }
}

static uint32_t fencing_active_peers(void)
{
    uint32_t count = 0;
    pcmk__node_status_t *entry = NULL;
    GHashTableIter gIter;

    g_hash_table_iter_init(&gIter, pcmk__peer_cache);
    while (g_hash_table_iter_next(&gIter, NULL, (void **)&entry)) {
        if(fencing_peer_active(entry)) {
            count++;
        }
    }
    return count;
}

/*!
 * \internal
 * \brief Process a manual confirmation of a pending fence action
 *
 * \param[in]     client  IPC client that sent confirmation
 * \param[in,out] msg     Request XML with manual confirmation
 *
 * \return Standard Pacemaker return code
 */
int
fenced_handle_manual_confirmation(const pcmk__client_t *client, xmlNode *msg)
{
    remote_fencing_op_t *op = NULL;
    xmlNode *dev = pcmk__xpath_find_one(msg->doc,
                                        "//*[@" PCMK__XA_ST_TARGET "]",
                                        LOG_ERR);

    CRM_CHECK(dev != NULL, return EPROTO);

    pcmk__notice("Received manual confirmation that %s has been fenced",
                 pcmk__s(pcmk__xe_get(dev, PCMK__XA_ST_TARGET),
                         "unknown target"));
    op = initiate_remote_stonith_op(client, msg, TRUE);
    if (op == NULL) {
        return EPROTO;
    }
    op->state = st_done;
    op->delegate = pcmk__str_copy("a human");

    // For the fencer's purposes, the fencing operation is done
    pcmk__set_result(&op->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
    finalize_op(op, msg, false);

    /* For the requester's purposes, the operation is still pending. The
     * actual result will be sent asynchronously via the operation's done_cb().
     */
    return EINPROGRESS;
}

/*!
 * \internal
 * \brief Create a new remote stonith operation
 *
 * \param[in] client   ID of local stonith client that initiated the operation
 * \param[in] request  The request from the client that started the operation
 * \param[in] peer     TRUE if this operation is owned by another stonith peer
 *                     (an operation owned by one peer is stored on all peers,
 *                     but only the owner executes it; all nodes get the results
 *                     once the owner finishes execution)
 */
void *
create_remote_stonith_op(const char *client, xmlNode *request, gboolean peer)
{
    remote_fencing_op_t *op = NULL;
    xmlNode *dev = pcmk__xpath_find_one(request->doc,
                                        "//*[@" PCMK__XA_ST_TARGET "]",
                                        PCMK__LOG_NEVER);
    int rc = pcmk_rc_ok;
    const char *operation = NULL;

    CRM_CHECK(dev != NULL, return NULL);

    init_stonith_remote_op_hash_table(&stonith_remote_op_list);

    /* If this operation is owned by another node, check to make
     * sure we haven't already created this operation. */
    if (peer) {
        const char *op_id = pcmk__xe_get(dev, PCMK__XA_ST_REMOTE_OP);

        CRM_CHECK(op_id != NULL, return NULL);

        op = g_hash_table_lookup(stonith_remote_op_list, op_id);
        if (op) {
            pcmk__debug("Reusing existing remote fencing op %.8s for %s", op_id,
                        pcmk__s(client, "unknown client"));
            return op;
        }
    }

    op = pcmk__assert_alloc(1, sizeof(remote_fencing_op_t));

    pcmk__xe_get_int(request, PCMK__XA_ST_TIMEOUT, &(op->base_timeout));

    // Value -1 means disable any static/random fencing delays
    pcmk__xe_get_int(request, PCMK__XA_ST_DELAY, &(op->client_delay));

    if (peer) {
        op->id = pcmk__xe_get_copy(dev, PCMK__XA_ST_REMOTE_OP);
    } else {
        op->id = pcmk__generate_uuid();
    }

    g_hash_table_replace(stonith_remote_op_list, op->id, op);

    op->state = st_query;
    op->replies_expected = fencing_active_peers();
    op->action = pcmk__xe_get_copy(dev, PCMK__XA_ST_DEVICE_ACTION);

    /* The node initiating the stonith operation. If an operation is relayed,
     * this is the last node the operation lands on. When in standalone mode,
     * origin is the ID of the client that originated the operation.
     *
     * Or may be the name of the function that created the operation.
     */
    op->originator = pcmk__xe_get_copy(dev, PCMK__XA_ST_ORIGIN);
    if (op->originator == NULL) {
        /* Local or relayed request */
        op->originator = pcmk__str_copy(fenced_get_local_node());
    }

    // Delegate may not be set
    op->delegate = pcmk__xe_get_copy(dev, PCMK__XA_ST_DELEGATE);
    op->created = time(NULL);

    CRM_LOG_ASSERT(client != NULL);
    op->client_id = pcmk__str_copy(client);

    /* For a RELAY operation, set fenced on the client. */
    operation = pcmk__xe_get(request, PCMK__XA_ST_OP);

    if (pcmk__str_eq(operation, STONITH_OP_RELAY, pcmk__str_none)) {
        op->client_name = pcmk__assert_asprintf("%s.%lu", crm_system_name,
                                                (unsigned long) getpid());
    } else {
        op->client_name = pcmk__xe_get_copy(request, PCMK__XA_ST_CLIENTNAME);
    }

    op->target = pcmk__xe_get_copy(dev, PCMK__XA_ST_TARGET);

    // @TODO Figure out how to avoid copying XML here
    op->request = pcmk__xml_copy(NULL, request);

    rc = pcmk__xe_get_flags(request, PCMK__XA_ST_CALLOPT, &(op->call_options),
                            0U);
    if (rc != pcmk_rc_ok) {
        pcmk__warn("Couldn't parse options from request %s: %s", op->id,
                   pcmk_rc_str(rc));
    }

    pcmk__xe_get_int(request, PCMK__XA_ST_CALLID, &(op->client_callid));

    pcmk__trace("%s new fencing op %s ('%s' targeting %s for client %s, base "
                "timeout %ds, %u %s expected)",
                (peer? "Recorded" : "Generated"), op->id, op->action,
                op->target, op->client_name, op->base_timeout,
                op->replies_expected,
                pcmk__plural_alt(op->replies_expected, "reply", "replies"));

    if (op->call_options & st_opt_cs_nodeid) {
        int nodeid;
        pcmk__node_status_t *node = NULL;

        pcmk__scan_min_int(op->target, &nodeid, 0);
        node = pcmk__search_node_caches(nodeid, NULL, NULL,
                                        pcmk__node_search_any
                                        |pcmk__node_search_cluster_cib);

        /* Ensure the conversion only happens once */
        stonith__clear_call_options(op->call_options, op->id, st_opt_cs_nodeid);

        if ((node != NULL) && (node->name != NULL)) {
            pcmk__str_update(&(op->target), node->name);

        } else {
            pcmk__warn("Could not expand nodeid '%s' into a host name",
                       op->target);
        }
    }

    /* check to see if this is a duplicate operation of another in-flight operation */
    merge_duplicates(op);

    if (op->state != st_duplicate) {
        /* kick history readers */
        fenced_send_notification(PCMK__VALUE_ST_NOTIFY_HISTORY, NULL, NULL);
    }

    /* safe to trim as long as that doesn't touch pending ops */
    stonith_fence_history_trim();

    return op;
}

/*!
 * \internal
 * \brief Create a peer fencing operation from a request, and initiate it
 *
 * \param[in] client     IPC client that made request (NULL to get from request)
 * \param[in] request    Request XML
 * \param[in] manual_ack Whether this is a manual action confirmation
 *
 * \return Newly created operation on success, otherwise NULL
 */
remote_fencing_op_t *
initiate_remote_stonith_op(const pcmk__client_t *client, xmlNode *request,
                           gboolean manual_ack)
{
    int query_timeout = 0;
    xmlNode *query = NULL;
    const char *client_id = NULL;
    remote_fencing_op_t *op = NULL;
    const char *relay_op_id = NULL;
    const char *operation = NULL;

    if (client) {
        client_id = client->id;
    } else {
        client_id = pcmk__xe_get(request, PCMK__XA_ST_CLIENTID);
    }

    CRM_LOG_ASSERT(client_id != NULL);
    op = create_remote_stonith_op(client_id, request, FALSE);
    op->owner = TRUE;
    if (manual_ack) {
        return op;
    }

    CRM_CHECK(op->action, return NULL);

    if (advance_topology_level(op, true) != pcmk_rc_ok) {
        op->state = st_failed;
    }

    switch (op->state) {
        case st_failed:
            // advance_topology_level() exhausted levels
            pcmk__set_result(&op->result, CRM_EX_ERROR, PCMK_EXEC_ERROR,
                             "All topology levels failed");
            pcmk__warn("Could not request peer fencing (%s) targeting %s "
                       QB_XS " id=%.8s",
                       op->action, op->target, op->id);
            finalize_op(op, NULL, false);
            return op;

        case st_duplicate:
            pcmk__info("Requesting peer fencing (%s) targeting %s (duplicate) "
                       QB_XS " id=%.8s",
                       op->action, op->target, op->id);
            return op;

        default:
            pcmk__notice("Requesting peer fencing (%s) targeting %s "
                         QB_XS " id=%.8s state=%s base_timeout=%ds",
                         op->action, op->target, op->id,
                         stonith__op_state_text(op->state), op->base_timeout);
    }

    query = stonith_create_op(op->client_callid, op->id, STONITH_OP_QUERY,
                              NULL, op->call_options);

    pcmk__xe_set(query, PCMK__XA_ST_REMOTE_OP, op->id);
    pcmk__xe_set(query, PCMK__XA_ST_TARGET, op->target);
    pcmk__xe_set(query, PCMK__XA_ST_DEVICE_ACTION, op_requested_action(op));
    pcmk__xe_set(query, PCMK__XA_ST_ORIGIN, op->originator);
    pcmk__xe_set(query, PCMK__XA_ST_CLIENTID, op->client_id);
    pcmk__xe_set(query, PCMK__XA_ST_CLIENTNAME, op->client_name);
    pcmk__xe_set_int(query, PCMK__XA_ST_TIMEOUT, op->base_timeout);

    /* In case of RELAY operation, RELAY information is added to the query to delete the original operation of RELAY. */
    operation = pcmk__xe_get(request, PCMK__XA_ST_OP);
    if (pcmk__str_eq(operation, STONITH_OP_RELAY, pcmk__str_none)) {
        relay_op_id = pcmk__xe_get(request, PCMK__XA_ST_REMOTE_OP);
        if (relay_op_id) {
            pcmk__xe_set(query, PCMK__XA_ST_REMOTE_OP_RELAY, relay_op_id);
        }
    }

    pcmk__cluster_send_message(NULL, pcmk_ipc_fenced, query);
    pcmk__xml_free(query);

    query_timeout = op->base_timeout * TIMEOUT_MULTIPLY_FACTOR;
    op->query_timer = pcmk__create_timer((1000 * query_timeout), remote_op_query_timeout, op);

    return op;
}

enum find_best_peer_options {
    /*! Skip checking the target peer for capable fencing devices */
    FIND_PEER_SKIP_TARGET = 0x0001,
    /*! Only check the target peer for capable fencing devices */
    FIND_PEER_TARGET_ONLY = 0x0002,
    /*! Skip peers and devices that are not verified */
    FIND_PEER_VERIFIED_ONLY = 0x0004,
};

static bool
is_watchdog_fencing(const remote_fencing_op_t *op, const char *device)
{
    return ((fencing_watchdog_timeout_ms > 0)
            // Only an explicit mismatch is considered not a watchdog fencing.
            && pcmk__str_eq(device, STONITH_WATCHDOG_ID, pcmk__str_null_matches)
            && pcmk__is_fencing_action(op->action)
            && node_does_watchdog_fencing(op->target));
}

static peer_device_info_t *
find_best_peer(const char *device, remote_fencing_op_t * op, enum find_best_peer_options options)
{
    GList *iter = NULL;
    gboolean verified_devices_only = (options & FIND_PEER_VERIFIED_ONLY) ? TRUE : FALSE;

    if ((device == NULL) && pcmk__is_set(op->call_options, st_opt_topology)) {
        return NULL;
    }

    for (iter = op->query_results; iter != NULL; iter = iter->next) {
        peer_device_info_t *peer = iter->data;

        pcmk__trace("Testing result from %s targeting %s with %d device%s: %d "
                    "%x",
                    peer->host, op->target, peer->ndevices,
                    pcmk__plural_s(peer->ndevices), peer->tried, options);
        if ((options & FIND_PEER_SKIP_TARGET) && pcmk__str_eq(peer->host, op->target, pcmk__str_casei)) {
            continue;
        }
        if ((options & FIND_PEER_TARGET_ONLY) && !pcmk__str_eq(peer->host, op->target, pcmk__str_casei)) {
            continue;
        }

        if (pcmk__is_set(op->call_options, st_opt_topology)) {
            if (grab_peer_device(op, peer, device, verified_devices_only)) {
                return peer;
            }

        } else if (!peer->tried
                   && count_peer_devices(op, peer, verified_devices_only,
                                         fenced_support_flag(op->action))) {
            /* No topology: Use the current best peer */
            pcmk__trace("Simple fencing");
            return peer;
        }
    }

    return NULL;
}

static peer_device_info_t *
stonith_choose_peer(remote_fencing_op_t * op)
{
    const char *device = NULL;
    peer_device_info_t *peer = NULL;
    uint32_t active = fencing_active_peers();

    do {
        if (op->devices) {
            device = op->devices->data;
            pcmk__trace("Checking for someone to fence (%s) %s using %s",
                        op->action, op->target, device);
        } else {
            pcmk__trace("Checking for someone to fence (%s) %s", op->action,
                        op->target);
        }

        /* Best choice is a peer other than the target with verified access */
        peer = find_best_peer(device, op, FIND_PEER_SKIP_TARGET|FIND_PEER_VERIFIED_ONLY);
        if (peer) {
            pcmk__trace("Found verified peer %s for %s", peer->host,
                        pcmk__s(device, "<any>"));
            return peer;
        }

        if(op->query_timer != 0 && op->replies < QB_MIN(op->replies_expected, active)) {
            pcmk__trace("Waiting before looking for unverified devices to "
                        "fence %s",
                        op->target);
            return NULL;
        }

        /* If no other peer has verified access, next best is unverified access */
        peer = find_best_peer(device, op, FIND_PEER_SKIP_TARGET);
        if (peer) {
            pcmk__trace("Found best unverified peer %s", peer->host);
            return peer;
        }

        /* If no other peer can do it, last option is self-fencing
         * (which is never allowed for the "on" phase of a remapped reboot)
         */
        if (op->phase != st_phase_on) {
            peer = find_best_peer(device, op, FIND_PEER_TARGET_ONLY);
            if (peer) {
                pcmk__trace("%s will fence itself", peer->host);
                return peer;
            }
        }

        /* Try the next fencing level if there is one (unless we're in the "on"
         * phase of a remapped "reboot", because we ignore errors in that case)
         */
    } while ((op->phase != st_phase_on)
             && pcmk__is_set(op->call_options, st_opt_topology)
             && (advance_topology_level(op, false) == pcmk_rc_ok));

    /* With a simple watchdog fencing configuration without a topology,
     * "device" is NULL here. Consider it should be done with watchdog fencing.
     */
    if (is_watchdog_fencing(op, device)) {
        pcmk__info("Couldn't contact watchdog-fencing target-node (%s)",
                   op->target);
        /* check_watchdog_fencing_and_wait will log additional info */
    } else {
        pcmk__notice("Couldn't find anyone to fence (%s) %s using %s",
                     op->action, op->target, pcmk__s(device, "any device"));
    }
    return NULL;
}

static int
valid_fencing_timeout(int specified_timeout, bool action_specific,
                      const remote_fencing_op_t *op, const char *device)
{
    int timeout = specified_timeout;

    if (!is_watchdog_fencing(op, device)) {
        return timeout;
    }

    timeout = (int) QB_MIN(QB_MAX(specified_timeout,
                                  pcmk__timeout_ms2s(fencing_watchdog_timeout_ms)),
                           INT_MAX);

    if (timeout > specified_timeout) {
        if (action_specific) {
            pcmk__warn("pcmk_%s_timeout %ds for %s is too short (must be >= "
                       PCMK_OPT_FENCING_WATCHDOG_TIMEOUT " %ds), using %ds "
                       "instead",
                       op->action, specified_timeout,
                       pcmk__s(device, "watchdog"), timeout, timeout);

        } else {
            pcmk__warn("Fencing timeout %ds is too short (must be >= "
                       PCMK_OPT_FENCING_WATCHDOG_TIMEOUT " %ds), using %ds "
                       "instead",
                       specified_timeout, timeout, timeout);
        }
    }

    return timeout;
}

static int
get_device_timeout(const remote_fencing_op_t *op,
                   const peer_device_info_t *peer, const char *device,
                   bool with_delay)
{
    int timeout = valid_fencing_timeout(op->base_timeout, false, op, device);
    device_properties_t *props;

    if (!peer || !device) {
        return timeout;
    }

    props = g_hash_table_lookup(peer->devices, device);
    if (!props) {
        return timeout;
    }

    if (props->custom_action_timeout[op->phase]) {
        timeout = valid_fencing_timeout(props->custom_action_timeout[op->phase],
                                        true, op, device);
    }

    // op->client_delay < 0 means disable any static/random fencing delays
    if (with_delay && (op->client_delay >= 0)) {
        // delay_base is eventually limited by delay_max
        timeout += (props->delay_max[op->phase] > 0 ?
                    props->delay_max[op->phase] : props->delay_base[op->phase]);
    }

    return timeout;
}

struct timeout_data {
    const remote_fencing_op_t *op;
    const peer_device_info_t *peer;
    int total_timeout;
};

/*!
 * \internal
 * \brief Add timeout to a total if device has not been executed yet
 *
 * \param[in]     key        GHashTable key (device ID)
 * \param[in]     value      GHashTable value (device properties)
 * \param[in,out] user_data  Timeout data
 */
static void
add_device_timeout(gpointer key, gpointer value, gpointer user_data)
{
    const char *device_id = key;
    device_properties_t *props = value;
    struct timeout_data *timeout = user_data;

    if (!props->executed[timeout->op->phase]
        && !props->disallowed[timeout->op->phase]) {
        timeout->total_timeout += get_device_timeout(timeout->op, timeout->peer,
                                                     device_id, true);
    }
}

static int
get_peer_timeout(const remote_fencing_op_t *op, const peer_device_info_t *peer)
{
    struct timeout_data timeout;

    timeout.op = op;
    timeout.peer = peer;
    timeout.total_timeout = 0;

    g_hash_table_foreach(peer->devices, add_device_timeout, &timeout);

    return (timeout.total_timeout? timeout.total_timeout : op->base_timeout);
}

static int
get_op_total_timeout(const remote_fencing_op_t *op,
                     const peer_device_info_t *chosen_peer)
{
    long long total_timeout = 0;
    stonith_topology_t *tp = find_topology_for_host(op->target);

    if (pcmk__is_set(op->call_options, st_opt_topology) && (tp != NULL)) {
        int i;
        GList *device_list = NULL;
        GList *iter = NULL;
        GList *auto_list = NULL;

        if (pcmk__str_eq(op->action, PCMK_ACTION_ON, pcmk__str_none)
            && (op->automatic_list != NULL)) {
            auto_list = g_list_copy(op->automatic_list);
        }

        /* Yep, this looks scary, nested loops all over the place.
         * Here is what is going on.
         * Loop1: Iterate through fencing levels.
         * Loop2: If a fencing level has devices, loop through each device
         * Loop3: For each device in a fencing level, see what peer owns it
         *        and what that peer has reported the timeout is for the device.
         */
        for (i = 0; i < ST__LEVEL_COUNT; i++) {
            if (!tp->levels[i]) {
                continue;
            }
            for (device_list = tp->levels[i]; device_list; device_list = device_list->next) {
                bool found = false;

                for (iter = op->query_results; iter != NULL; iter = iter->next) {
                    const peer_device_info_t *peer = iter->data;

                    if (auto_list) {
                        GList *match = g_list_find_custom(auto_list, device_list->data,
                                        sort_strings);
                        if (match) {
                            auto_list = g_list_remove(auto_list, match->data);
                        }
                    }

                    if (find_peer_device(op, peer, device_list->data,
                                         fenced_support_flag(op->action))) {
                        total_timeout += get_device_timeout(op, peer,
                                                            device_list->data,
                                                            true);
                        found = true;
                        break;
                    }
                }               /* End Loop3: match device with peer that owns device, find device's timeout period */

                /* in case of watchdog-device we add the timeout to the budget
                   if didn't get a reply
                 */
                if (!found && is_watchdog_fencing(op, device_list->data)) {
                    total_timeout += pcmk__timeout_ms2s(fencing_watchdog_timeout_ms);
                }
            }                   /* End Loop2: iterate through devices at a specific level */
        }                       /*End Loop1: iterate through fencing levels */

        //Add only exists automatic_list device timeout
        if (auto_list) {
            for (iter = auto_list; iter != NULL; iter = iter->next) {
                GList *iter2 = NULL;

                for (iter2 = op->query_results; iter2 != NULL; iter2 = iter2->next) {
                    peer_device_info_t *peer = iter2->data;
                    if (find_peer_device(op, peer, iter->data,
                                         fenced_df_supports_on)) {
                        total_timeout += get_device_timeout(op, peer,
                                                            iter->data, true);
                        break;
                    }
                }
            }
        }

        g_list_free(auto_list);

    } else if (chosen_peer) {
        total_timeout = get_peer_timeout(op, chosen_peer);

    } else {
        total_timeout = valid_fencing_timeout(op->base_timeout, false, op,
                                              NULL);
    }

    if (total_timeout <= 0) {
        total_timeout = op->base_timeout;
    }

    /* Take any requested fencing delay into account to prevent it from eating
     * up the total timeout.
     */
    if (op->client_delay > 0) {
        total_timeout += op->client_delay;
    }
    return (int) QB_MIN(total_timeout, INT_MAX);
}

static void
report_timeout_period(remote_fencing_op_t * op, int op_timeout)
{
    GList *iter = NULL;
    xmlNode *update = NULL;
    const char *client_node = NULL;
    const char *client_id = NULL;
    const char *call_id = NULL;

    if (op->call_options & st_opt_sync_call) {
        /* There is no reason to report the timeout for a synchronous call. It
         * is impossible to use the reported timeout to do anything when the client
         * is blocking for the response.  This update is only important for
         * async calls that require a callback to report the results in. */
        return;
    } else if (!op->request) {
        return;
    }

    pcmk__trace("Reporting timeout for %s (id=%.8s)", op->client_name, op->id);
    client_node = pcmk__xe_get(op->request, PCMK__XA_ST_CLIENTNODE);
    call_id = pcmk__xe_get(op->request, PCMK__XA_ST_CALLID);
    client_id = pcmk__xe_get(op->request, PCMK__XA_ST_CLIENTID);
    if (!client_node || !call_id || !client_id) {
        return;
    }

    if (pcmk__str_eq(client_node, fenced_get_local_node(), pcmk__str_casei)) {
        // Client is connected to this node, so send update directly to them
        do_stonith_async_timeout_update(client_id, call_id, op_timeout);
        return;
    }

    /* The client is connected to another node, relay this update to them */
    update = stonith_create_op(op->client_callid, op->id, STONITH_OP_TIMEOUT_UPDATE, NULL, 0);
    pcmk__xe_set(update, PCMK__XA_ST_REMOTE_OP, op->id);
    pcmk__xe_set(update, PCMK__XA_ST_CLIENTID, client_id);
    pcmk__xe_set(update, PCMK__XA_ST_CALLID, call_id);
    pcmk__xe_set_int(update, PCMK__XA_ST_TIMEOUT, op_timeout);

    pcmk__cluster_send_message(pcmk__get_node(0, client_node, NULL,
                                              pcmk__node_search_cluster_member),
                               pcmk_ipc_fenced, update);

    pcmk__xml_free(update);

    for (iter = op->duplicates; iter != NULL; iter = iter->next) {
        remote_fencing_op_t *dup = iter->data;

        pcmk__trace("Reporting timeout for duplicate %.8s to client %s",
                    dup->id, dup->client_name);
        report_timeout_period(iter->data, op_timeout);
    }
}

/*!
 * \internal
 * \brief Advance an operation to the next device in its topology
 *
 * \param[in,out] op      Fencer operation to advance
 * \param[in]     device  ID of device that just completed
 * \param[in,out] msg     If not NULL, XML reply of last delegated operation
 */
static void
advance_topology_device_in_level(remote_fencing_op_t *op, const char *device,
                                 xmlNode *msg)
{
    /* Advance to the next device at this topology level, if any */
    if (op->devices) {
        op->devices = op->devices->next;
    }

    /* Handle automatic unfencing if an "on" action was requested */
    if ((op->phase == st_phase_requested)
        && pcmk__str_eq(op->action, PCMK_ACTION_ON, pcmk__str_none)) {
        /* If the device we just executed was required, it's not anymore */
        remove_required_device(op, device);

        /* If there are no more devices at this topology level, run through any
         * remaining devices with automatic unfencing
         */
        if (op->devices == NULL) {
            op->devices = op->automatic_list;
        }
    }

    if ((op->devices == NULL) && (op->phase == st_phase_off)) {
        /* We're done with this level and with required devices, but we had
         * remapped "reboot" to "off", so start over with "on". If any devices
         * need to be turned back on, op->devices will be non-NULL after this.
         */
        op_phase_on(op);
    }

    // This function is only called if the previous device succeeded
    pcmk__set_result(&op->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);

    if (op->devices) {
        /* Necessary devices remain, so execute the next one */
        pcmk__trace("Next targeting %s on behalf of %s@%s", op->target,
                    op->client_name, op->originator);

        // The requested delay has been applied for the first device
        if (op->client_delay > 0) {
            op->client_delay = 0;
        }

        request_peer_fencing(op, NULL);
    } else {
        /* We're done with all devices and phases, so finalize operation */
        pcmk__trace("Marking complex fencing op targeting %s as complete",
                    op->target);
        op->state = st_done;
        finalize_op(op, msg, false);
    }
}

static gboolean
check_watchdog_fencing_and_wait(remote_fencing_op_t * op)
{
    if (node_does_watchdog_fencing(op->target)) {
        guint timeout_ms = QB_MIN(fencing_watchdog_timeout_ms, UINT_MAX);

        pcmk__notice("Waiting %s for %s to self-fence (%s) for client %s "
                     QB_XS " id=%.8s",
                     pcmk__readable_interval(timeout_ms), op->target,
                     op->action, op->client_name, op->id);

        if (op->op_timer_one) {
            g_source_remove(op->op_timer_one);
        }
        op->op_timer_one = pcmk__create_timer(timeout_ms, remote_op_watchdog_done,
                                              op);
        return TRUE;
    } else {
        pcmk__debug("Skipping fallback to watchdog-fencing as %s is not in "
                    "host-list",
                    op->target);
    }
    return FALSE;
}

/*!
 * \internal
 * \brief Ask a peer to execute a fencing operation
 *
 * \param[in,out] op      Fencing operation to be executed
 * \param[in,out] peer    If NULL or topology is in use, choose best peer to
 *                        execute the fencing, otherwise use this peer
 */
static void
request_peer_fencing(remote_fencing_op_t *op, peer_device_info_t *peer)
{
    const char *device = NULL;
    int timeout;

    CRM_CHECK(op != NULL, return);

    pcmk__trace("Action %.8s targeting %s for %s is %s", op->id, op->target,
                op->client_name, stonith__op_state_text(op->state));

    if ((op->phase == st_phase_on) && (op->devices != NULL)) {
        /* We are in the "on" phase of a remapped topology reboot. If this
         * device has pcmk_reboot_action="off", or doesn't support the "on"
         * action, skip it.
         *
         * We can't check device properties at this point because we haven't
         * chosen a peer for this stage yet. Instead, we check the local node's
         * knowledge about the device. If different versions of the fence agent
         * are installed on different nodes, there's a chance this could be
         * mistaken, but the worst that could happen is we don't try turning the
         * node back on when we should.
         */
        device = op->devices->data;
        if (pcmk__str_eq(fenced_device_reboot_action(device), PCMK_ACTION_OFF,
                         pcmk__str_none)) {
            pcmk__info("Not turning %s back on using %s because the device is "
                       "configured to stay off (pcmk_reboot_action='off')",
                       op->target, device);
            advance_topology_device_in_level(op, device, NULL);
            return;
        }
        if (!fenced_device_supports_on(device)) {
            pcmk__info("Not turning %s back on using %s because the agent "
                       "doesn't support 'on'",
                       op->target, device);
            advance_topology_device_in_level(op, device, NULL);
            return;
        }
    }

    timeout = op->base_timeout;
    if ((peer == NULL) && !pcmk__is_set(op->call_options, st_opt_topology)) {
        peer = stonith_choose_peer(op);
    }

    if (!op->op_timer_total) {
        op->total_timeout = TIMEOUT_MULTIPLY_FACTOR * get_op_total_timeout(op, peer);
        op->op_timer_total = pcmk__create_timer(1000 * op->total_timeout, remote_op_timeout, op);
        report_timeout_period(op, op->total_timeout);
        pcmk__info("Total timeout set to %ds for peer's fencing targeting %s "
                   "for %s " QB_XS " id=%.8s",
                   op->total_timeout, op->target, op->client_name, op->id);
    }

    if (pcmk__is_set(op->call_options, st_opt_topology)
        && (op->devices != NULL)) {
        /* Ignore the caller's peer preference if topology is in use, because
         * that peer might not have access to the required device. With
         * topology, stonith_choose_peer() removes the device from further
         * consideration, so the timeout must be calculated beforehand.
         *
         * @TODO Basing the total timeout on the caller's preferred peer (above)
         *       is less than ideal.
         */
        peer = stonith_choose_peer(op);

        device = op->devices->data;
        /* Fencing timeout sent to peer takes no delay into account.
         * The peer will add a dedicated timer for any delay upon
         * schedule_stonith_command().
         */
        timeout = get_device_timeout(op, peer, device, false);
    }

    if (peer) {
        int timeout_one = 0;
        xmlNode *remote_op = stonith_create_op(op->client_callid, op->id, STONITH_OP_FENCE, NULL, 0);
        const pcmk__node_status_t *peer_node =
            pcmk__get_node(0, peer->host, NULL,
                           pcmk__node_search_cluster_member);

        if (op->client_delay > 0) {
           /* Take requested fencing delay into account to prevent it from
            * eating up the timeout.
            */
            timeout_one = TIMEOUT_MULTIPLY_FACTOR * op->client_delay;
        }

        pcmk__xe_set(remote_op, PCMK__XA_ST_REMOTE_OP, op->id);
        pcmk__xe_set(remote_op, PCMK__XA_ST_TARGET, op->target);
        pcmk__xe_set(remote_op, PCMK__XA_ST_DEVICE_ACTION, op->action);
        pcmk__xe_set(remote_op, PCMK__XA_ST_ORIGIN, op->originator);
        pcmk__xe_set(remote_op, PCMK__XA_ST_CLIENTID, op->client_id);
        pcmk__xe_set(remote_op, PCMK__XA_ST_CLIENTNAME, op->client_name);
        pcmk__xe_set_int(remote_op, PCMK__XA_ST_TIMEOUT, timeout);
        pcmk__xe_set_int(remote_op, PCMK__XA_ST_CALLOPT, op->call_options);
        pcmk__xe_set_int(remote_op, PCMK__XA_ST_DELAY, op->client_delay);

        if (device) {
            timeout_one += TIMEOUT_MULTIPLY_FACTOR *
                           get_device_timeout(op, peer, device, true);
            pcmk__notice("Requesting that %s perform '%s' action targeting %s "
                         "using %s " QB_XS " for client %s (%ds)",
                         peer->host, op->action, op->target, device,
                         op->client_name, timeout_one);
            pcmk__xe_set(remote_op, PCMK__XA_ST_DEVICE_ID, device);

        } else {
            timeout_one += TIMEOUT_MULTIPLY_FACTOR * get_peer_timeout(op, peer);
            pcmk__notice("Requesting that %s perform '%s' action targeting %s "
                         QB_XS " for client %s (%ds, %s)",
                         peer->host, op->action, op->target, op->client_name,
                         timeout_one,
                         pcmk__readable_interval(fencing_watchdog_timeout_ms));
        }

        op->state = st_exec;
        if (op->op_timer_one) {
            g_source_remove(op->op_timer_one);
            op->op_timer_one = 0;
        }

        if (!is_watchdog_fencing(op, device)
            || !check_watchdog_fencing_and_wait(op)) {

            /* Some thoughts about self-fencing cases reaching this point:
               - Actually check in check_watchdog_fencing_and_wait
                 shouldn't fail if STONITH_WATCHDOG_ID is
                 chosen as fencing-device and it being present implies
                 watchdog-fencing is enabled anyway
               - If watchdog-fencing is disabled either in general or for
                 a specific target - detected in check_watchdog_fencing_and_wait -
                 for some other kind of self-fencing we can't expect
                 a success answer but timeout is fine if the node doesn't
                 come back in between
               - Delicate might be the case where we have watchdog-fencing
                 enabled for a node but the watchdog-fencing-device isn't
                 explicitly chosen for self-fencing. Local scheduler execution
                 in sbd might detect the node as unclean and lead to timely
                 self-fencing. Otherwise the selection of
                 PCMK_OPT_FENCING_WATCHDOG_TIMEOUT at least is questionable.
             */

            /* coming here we're not waiting for watchdog timeout -
               thus engage timer with timout evaluated before */
            op->op_timer_one = pcmk__create_timer((1000 * timeout_one), remote_op_timeout_one, op);
        }

        pcmk__cluster_send_message(peer_node, pcmk_ipc_fenced, remote_op);
        peer->tried = TRUE;
        pcmk__xml_free(remote_op);
        return;

    } else if (op->phase == st_phase_on) {
        /* A remapped "on" cannot be executed, but the node was already
         * turned off successfully, so ignore the error and continue.
         */
        pcmk__warn("Ignoring %s 'on' failure (no capable peers) targeting %s "
                   "after successful 'off'",
                   device, op->target);
        advance_topology_device_in_level(op, device, NULL);
        return;

    } else if (op->owner == FALSE) {
        pcmk__err("Fencing (%s) targeting %s for client %s is not ours to "
                  "control",
                  op->action, op->target, op->client_name);

    } else if (op->query_timer == 0) {
        /* We've exhausted all available peers */
        pcmk__info("No remaining peers capable of fencing (%s) %s for client "
                   "%s " QB_XS " state=%s",
                   op->action, op->target, op->client_name,
                   stonith__op_state_text(op->state));
        CRM_CHECK(op->state < st_done, return);
        finalize_timed_out_op(op, "All nodes failed, or are unable, to "
                                  "fence target");

    } else if(op->replies >= op->replies_expected || op->replies >= fencing_active_peers()) {
        /* if the operation never left the query state,
         * but we have all the expected replies, then no devices
         * are available to execute the fencing operation. */

        if (is_watchdog_fencing(op, device)
            && check_watchdog_fencing_and_wait(op)) {
            /* Consider a watchdog fencing targeting an offline node executing
             * once it starts waiting for the target to self-fence. So that when
             * the query timer pops, remote_op_query_timeout() considers the
             * fencing already in progress.
             */
            op->state = st_exec;
            return;
        }

        if (op->state == st_query) {
            pcmk__info("No peers (out of %d) have devices capable of fencing "
                       "(%s) %s for client %s " QB_XS " state=%s",
                       op->replies, op->action, op->target, op->client_name,
                       stonith__op_state_text(op->state));

            pcmk__reset_result(&op->result);
            pcmk__set_result(&op->result, CRM_EX_ERROR,
                             PCMK_EXEC_NO_FENCE_DEVICE, NULL);
        } else {
            if (pcmk__is_set(op->call_options, st_opt_topology)) {
                pcmk__reset_result(&op->result);
                pcmk__set_result(&op->result, CRM_EX_ERROR,
                                 PCMK_EXEC_NO_FENCE_DEVICE, NULL);
            }
            /* ... else use existing result from previous failed attempt
             * (topology is not in use, and no devices remain to be attempted).
             * Overwriting the result with PCMK_EXEC_NO_FENCE_DEVICE would
             * prevent finalize_op() from setting the correct delegate if
             * needed.
             */

            pcmk__info("No peers (out of %d) are capable of fencing (%s) %s "
                       "for client %s " QB_XS " state=%s",
                       op->replies, op->action, op->target, op->client_name,
                       stonith__op_state_text(op->state));
        }

        op->state = st_failed;
        finalize_op(op, NULL, false);

    } else {
        pcmk__info("Waiting for additional peers capable of fencing (%s) "
                   "%s%s%s for client %s " QB_XS " id=%.8s",
                   op->action, op->target, ((device != NULL)? " using " : ""),
                   pcmk__s(device, ""), op->client_name, op->id);
    }
}

/*!
 * \internal
 * \brief Comparison function for sorting query results
 *
 * \param[in] a  GList item to compare
 * \param[in] b  GList item to compare
 *
 * \return Per the glib documentation, "a negative integer if the first value
 *         comes before the second, 0 if they are equal, or a positive integer
 *         if the first value comes after the second."
 */
static gint
sort_peers(gconstpointer a, gconstpointer b)
{
    const peer_device_info_t *peer_a = a;
    const peer_device_info_t *peer_b = b;

    return (peer_b->ndevices - peer_a->ndevices);
}

/*!
 * \internal
 * \brief Determine if all the devices in the topology are found or not
 *
 * \param[in] op  Fencing operation with topology to check
 */
static gboolean
all_topology_devices_found(const remote_fencing_op_t *op)
{
    GList *device = NULL;
    GList *iter = NULL;
    device_properties_t *match = NULL;
    stonith_topology_t *tp = NULL;
    gboolean skip_target = FALSE;
    int i;

    tp = find_topology_for_host(op->target);
    if (!tp) {
        return FALSE;
    }
    if (pcmk__is_fencing_action(op->action)) {
        /* Don't count the devices on the target node if we are killing
         * the target node. */
        skip_target = TRUE;
    }

    for (i = 0; i < ST__LEVEL_COUNT; i++) {
        for (device = tp->levels[i]; device; device = device->next) {
            match = NULL;
            for (iter = op->query_results; iter && !match; iter = iter->next) {
                peer_device_info_t *peer = iter->data;

                if (skip_target && pcmk__str_eq(peer->host, op->target, pcmk__str_casei)) {
                    continue;
                }
                match = find_peer_device(op, peer, device->data,
                                         fenced_df_none);
            }
            if (!match) {
                return FALSE;
            }
        }
    }

    return TRUE;
}

/*!
 * \internal
 * \brief Parse action-specific device properties from XML
 *
 * \param[in]     xml     XML element containing the properties
 * \param[in]     peer    Name of peer that sent XML (for logs)
 * \param[in]     device  Device ID (for logs)
 * \param[in]     action  Action the properties relate to (for logs)
 * \param[in,out] op      Fencing operation that properties are being parsed for
 * \param[in]     phase   Phase the properties relate to
 * \param[in,out] props   Device properties to update
 */
static void
parse_action_specific(const xmlNode *xml, const char *peer, const char *device,
                      const char *action, remote_fencing_op_t *op,
                      enum st_remap_phase phase, device_properties_t *props)
{
    props->custom_action_timeout[phase] = 0;
    pcmk__xe_get_int(xml, PCMK__XA_ST_ACTION_TIMEOUT,
                     &props->custom_action_timeout[phase]);
    if (props->custom_action_timeout[phase]) {
        pcmk__trace("Peer %s with device %s returned %s action timeout %ds",
                    peer, device, action, props->custom_action_timeout[phase]);
    }

    props->delay_max[phase] = 0;
    pcmk__xe_get_int(xml, PCMK__XA_ST_DELAY_MAX, &props->delay_max[phase]);
    if (props->delay_max[phase]) {
        pcmk__trace("Peer %s with device %s returned maximum of random delay "
                    "%ds for %s",
                    peer, device, props->delay_max[phase], action);
    }

    props->delay_base[phase] = 0;
    pcmk__xe_get_int(xml, PCMK__XA_ST_DELAY_BASE, &props->delay_base[phase]);
    if (props->delay_base[phase]) {
        pcmk__trace("Peer %s with device %s returned base delay %ds for %s",
                    peer, device, props->delay_base[phase], action);
    }

    /* Handle devices with automatic unfencing */
    if (pcmk__str_eq(action, PCMK_ACTION_ON, pcmk__str_none)) {
        int required = 0;

        pcmk__xe_get_int(xml, PCMK__XA_ST_REQUIRED, &required);
        if (required) {
            pcmk__trace("Peer %s requires device %s to execute for action %s",
                        peer, device, action);
            add_required_device(op, device);
        }
    }

    /* If a reboot is remapped to off+on, it's possible that a node is allowed
     * to perform one action but not another.
     */
    if (pcmk__xe_attr_is_true(xml, PCMK__XA_ST_ACTION_DISALLOWED)) {
        props->disallowed[phase] = TRUE;
        pcmk__trace("Peer %s is disallowed from executing %s for device %s",
                    peer, action, device);
    }
}

/*!
 * \internal
 * \brief Parse one device's properties from peer's XML query reply
 *
 * \param[in]     xml       XML node containing device properties
 * \param[in,out] op        Operation that query and reply relate to
 * \param[in,out] peer      Peer's device information
 * \param[in]     device    ID of device being parsed
 */
static void
add_device_properties(const xmlNode *xml, remote_fencing_op_t *op,
                      peer_device_info_t *peer, const char *device)
{
    xmlNode *child;
    int verified = 0;
    device_properties_t *props =
        pcmk__assert_alloc(1, sizeof(device_properties_t));
    int rc = pcmk_rc_ok;

    /* Add a new entry to this peer's devices list */
    g_hash_table_insert(peer->devices, pcmk__str_copy(device), props);

    /* Peers with verified (monitored) access will be preferred */
    pcmk__xe_get_int(xml, PCMK__XA_ST_MONITOR_VERIFIED, &verified);
    if (verified) {
        pcmk__trace("Peer %s has confirmed a verified device %s", peer->host,
                    device);
        props->verified = TRUE;
    }

    // Nodes <2.1.5 won't set this, so assume unfencing in that case
    rc = pcmk__xe_get_flags(xml, PCMK__XA_ST_DEVICE_SUPPORT_FLAGS,
                            &(props->device_support_flags),
                            fenced_df_supports_on);
    if (rc != pcmk_rc_ok) {
        pcmk__warn("Couldn't determine device support for %s "
                   "(assuming unfencing): %s",
                   device, pcmk_rc_str(rc));
    }

    /* Parse action-specific device properties */
    parse_action_specific(xml, peer->host, device, op_requested_action(op),
                          op, st_phase_requested, props);
    for (child = pcmk__xe_first_child(xml, NULL, NULL, NULL); child != NULL;
         child = pcmk__xe_next(child, NULL)) {
        /* Replies for "reboot" operations will include the action-specific
         * values for "off" and "on" in child elements, just in case the reboot
         * winds up getting remapped.
         */
        if (pcmk__str_eq(pcmk__xe_id(child), PCMK_ACTION_OFF, pcmk__str_none)) {
            parse_action_specific(child, peer->host, device, PCMK_ACTION_OFF,
                                  op, st_phase_off, props);

        } else if (pcmk__str_eq(pcmk__xe_id(child), PCMK_ACTION_ON,
                                pcmk__str_none)) {
            parse_action_specific(child, peer->host, device, PCMK_ACTION_ON,
                                  op, st_phase_on, props);
        }
    }
}

/*!
 * \internal
 * \brief Parse a peer's XML query reply and add it to operation's results
 *
 * \param[in,out] op        Operation that query and reply relate to
 * \param[in]     host      Name of peer that sent this reply
 * \param[in]     ndevices  Number of devices expected in reply
 * \param[in]     xml       XML node containing device list
 *
 * \return Newly allocated result structure with parsed reply
 */
static peer_device_info_t *
add_result(remote_fencing_op_t *op, const char *host, int ndevices,
           const xmlNode *xml)
{
    peer_device_info_t *peer = pcmk__assert_alloc(1,
                                                  sizeof(peer_device_info_t));
    xmlNode *child;

    peer->host = pcmk__str_copy(host);
    peer->devices = pcmk__strkey_table(free, free);

    /* Each child element describes one capable device available to the peer */
    for (child = pcmk__xe_first_child(xml, NULL, NULL, NULL); child != NULL;
         child = pcmk__xe_next(child, NULL)) {
        const char *device = pcmk__xe_id(child);

        if (device) {
            add_device_properties(child, op, peer, device);
        }
    }

    peer->ndevices = g_hash_table_size(peer->devices);
    CRM_CHECK(ndevices == peer->ndevices,
              pcmk__err("Query claimed to have %d device%s but %d found",
                        ndevices, pcmk__plural_s(ndevices), peer->ndevices));

    op->query_results = g_list_insert_sorted(op->query_results, peer, sort_peers);
    return peer;
}

/*!
 * \internal
 * \brief Handle a peer's reply to our fencing query
 *
 * Parse a query result from XML and store it in the remote operation
 * table, and when enough replies have been received, issue a fencing request.
 *
 * \param[in] msg  XML reply received
 *
 * \return pcmk_ok on success, -errno on error
 *
 * \note See initiate_remote_stonith_op() for how the XML query was initially
 *       formed, and stonith_query() for how the peer formed its XML reply.
 */
int
process_remote_stonith_query(xmlNode *msg)
{
    int ndevices = 0;
    gboolean host_is_target = FALSE;
    gboolean have_all_replies = FALSE;
    const char *id = NULL;
    const char *host = NULL;
    remote_fencing_op_t *op = NULL;
    peer_device_info_t *peer = NULL;
    uint32_t replies_expected;
    xmlNode *dev = pcmk__xpath_find_one(msg->doc,
                                        "//*[@" PCMK__XA_ST_REMOTE_OP "]",
                                        LOG_ERR);

    CRM_CHECK(dev != NULL, return -EPROTO);

    id = pcmk__xe_get(dev, PCMK__XA_ST_REMOTE_OP);
    CRM_CHECK(id != NULL, return -EPROTO);

    dev = pcmk__xpath_find_one(msg->doc,
                               "//*[@" PCMK__XA_ST_AVAILABLE_DEVICES "]",
                               LOG_ERR);
    CRM_CHECK(dev != NULL, return -EPROTO);
    pcmk__xe_get_int(dev, PCMK__XA_ST_AVAILABLE_DEVICES, &ndevices);

    op = g_hash_table_lookup(stonith_remote_op_list, id);
    if (op == NULL) {
        pcmk__debug("Received query reply for unknown or expired operation %s",
                    id);
        return -EOPNOTSUPP;
    }

    replies_expected = fencing_active_peers();
    if (op->replies_expected < replies_expected) {
        replies_expected = op->replies_expected;
    }
    if ((++op->replies >= replies_expected) && (op->state == st_query)) {
        have_all_replies = TRUE;
    }
    host = pcmk__xe_get(msg, PCMK__XA_SRC);
    host_is_target = pcmk__str_eq(host, op->target, pcmk__str_casei);

    pcmk__info("Query result %d of %d from %s for %s/%s (%d device%s) %s",
               op->replies, replies_expected, host, op->target, op->action,
               ndevices, pcmk__plural_s(ndevices), id);
    if (ndevices > 0) {
        peer = add_result(op, host, ndevices, dev);
    }

    pcmk__set_result(&op->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);

    if (pcmk__is_set(op->call_options, st_opt_topology)) {
        /* If we start the fencing before all the topology results are in,
         * it is possible fencing levels will be skipped because of the missing
         * query results. */
        if (op->state == st_query && all_topology_devices_found(op)) {
            /* All the query results are in for the topology, start the fencing ops. */
            pcmk__trace("All topology devices found");
            request_peer_fencing(op, peer);

        } else if (have_all_replies) {
            pcmk__info("All topology query replies have arrived, continuing "
                       "(%d expected/%d received) ",
                       replies_expected, op->replies);
            request_peer_fencing(op, NULL);
        }

    } else if (op->state == st_query) {
        int nverified = count_peer_devices(op, peer, TRUE,
                                           fenced_support_flag(op->action));

        /* We have a result for a non-topology fencing op that looks promising,
         * go ahead and start fencing before query timeout */
        if ((peer != NULL) && !host_is_target && nverified) {
            /* we have a verified device living on a peer that is not the target */
            pcmk__trace("Found %d verified device%s", nverified,
                        pcmk__plural_s(nverified));
            request_peer_fencing(op, peer);

        } else if (have_all_replies) {
            pcmk__info("All query replies have arrived, continuing (%d "
                       "expected/%d received) ",
                       replies_expected, op->replies);
            request_peer_fencing(op, NULL);

        } else {
            pcmk__trace("Waiting for more peer results before launching "
                        "fencing operation");
        }

    } else if ((peer != NULL) && (op->state == st_done)) {
        pcmk__info("Discarding query result from %s (%d device%s): Operation "
                   "is %s",
                   peer->host, peer->ndevices, pcmk__plural_s(peer->ndevices),
                   stonith__op_state_text(op->state));
    }

    return pcmk_ok;
}

/*!
 * \internal
 * \brief Handle a peer's reply to a fencing request
 *
 * Parse a fencing reply from XML, and either finalize the operation
 * or attempt another device as appropriate.
 *
 * \param[in] msg  XML reply received
 */
void
fenced_process_fencing_reply(xmlNode *msg)
{
    const char *id = NULL;
    const char *device = NULL;
    remote_fencing_op_t *op = NULL;
    xmlNode *dev = pcmk__xpath_find_one(msg->doc,
                                        "//*[@" PCMK__XA_ST_REMOTE_OP "]",
                                        LOG_ERR);
    pcmk__action_result_t result = PCMK__UNKNOWN_RESULT;

    CRM_CHECK(dev != NULL, return);

    id = pcmk__xe_get(dev, PCMK__XA_ST_REMOTE_OP);
    CRM_CHECK(id != NULL, return);

    dev = stonith__find_xe_with_result(msg);
    CRM_CHECK(dev != NULL, return);

    stonith__xe_get_result(dev, &result);

    device = pcmk__xe_get(dev, PCMK__XA_ST_DEVICE_ID);

    if (stonith_remote_op_list) {
        op = g_hash_table_lookup(stonith_remote_op_list, id);
    }

    if ((op == NULL) && pcmk__result_ok(&result)) {
        /* Record successful fencing operations */
        const char *client_id = pcmk__xe_get(dev, PCMK__XA_ST_CLIENTID);

        op = create_remote_stonith_op(client_id, dev, TRUE);
    }

    if (op == NULL) {
        /* Could be for an event that began before we started */
        /* TODO: Record the op for later querying */
        pcmk__info("Received peer result of unknown or expired operation %s",
                   id);
        pcmk__reset_result(&result);
        return;
    }

    pcmk__reset_result(&op->result);
    op->result = result; // The operation takes ownership of the result

    if (op->devices && device && !pcmk__str_eq(op->devices->data, device, pcmk__str_casei)) {
        pcmk__err("Received outdated reply for device %s (instead of %s) to "
                  "fence (%s) %s. Operation already timed out at peer level.",
                  device, (const char *) op->devices->data, op->action,
                  op->target);
        return;
    }

    if (pcmk__str_eq(pcmk__xe_get(msg, PCMK__XA_SUBT), PCMK__VALUE_BROADCAST,
                     pcmk__str_none)) {

        if (pcmk__result_ok(&op->result)) {
            op->state = st_done;
        } else {
            op->state = st_failed;
        }
        finalize_op(op, msg, false);
        return;

    } else if (!pcmk__str_eq(op->originator, fenced_get_local_node(),
                             pcmk__str_casei)) {
        /* If this isn't a remote level broadcast, and we are not the
         * originator of the operation, we should not be receiving this msg. */
        pcmk__err("Received non-broadcast fencing result for operation %.8s we "
                  "do not own (device %s targeting %s)",
                  op->id, device, op->target);
        return;
    }

    if (pcmk__is_set(op->call_options, st_opt_topology)) {
        const char *device = NULL;
        const char *reason = op->result.exit_reason;

        /* We own the op, and it is complete. broadcast the result to all nodes
         * and notify our local clients. */
        if (op->state == st_done) {
            finalize_op(op, msg, false);
            return;
        }

        device = pcmk__xe_get(msg, PCMK__XA_ST_DEVICE_ID);

        if ((op->phase == 2) && !pcmk__result_ok(&op->result)) {
            /* A remapped "on" failed, but the node was already turned off
             * successfully, so ignore the error and continue.
             */
            pcmk__warn("Ignoring %s 'on' failure (%s%s%s) targeting %s after "
                       "successful 'off'",
                       device,
                       pcmk_exec_status_str(op->result.execution_status),
                       ((reason != NULL)? ": " : ""), pcmk__s(reason, ""),
                       op->target);
            pcmk__set_result(&op->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
        } else {
            pcmk__notice("Action '%s' targeting %s%s%s on behalf of %s@%s: "
                         "%s%s%s%s",
                         op->action, op->target,
                         ((device == NULL)? "" : " using "),
                         pcmk__s(device, ""), op->client_name, op->originator,
                         pcmk_exec_status_str(op->result.execution_status),
                         ((reason != NULL)? " (" : ""), pcmk__s(reason, ""),
                         ((reason != NULL)? ")" : ""));
        }

        if (pcmk__result_ok(&op->result)) {
            /* An operation completed successfully. Try another device if
             * necessary, otherwise mark the operation as done. */
            advance_topology_device_in_level(op, device, msg);
            return;
        } else {
            /* This device failed, time to try another topology level. If no other
             * levels are available, mark this operation as failed and report results. */
            if (advance_topology_level(op, false) != pcmk_rc_ok) {
                op->state = st_failed;
                finalize_op(op, msg, false);
                return;
            }
        }

    } else if (pcmk__result_ok(&op->result) && (op->devices == NULL)) {
        op->state = st_done;
        finalize_op(op, msg, false);
        return;

    } else if ((op->result.execution_status == PCMK_EXEC_TIMEOUT)
               && (op->devices == NULL)) {
        /* If the operation timed out don't bother retrying other peers. */
        op->state = st_failed;
        finalize_op(op, msg, false);
        return;

    } else {
        /* fall-through and attempt other fencing action using another peer */
    }

    /* Retry on failure */
    pcmk__trace("Next for %s on behalf of %s@%s (result was: %s)", op->target,
                op->originator, op->client_name,
                pcmk_exec_status_str(op->result.execution_status));
    request_peer_fencing(op, NULL);
}

gboolean
stonith_check_fence_tolerance(int tolerance, const char *target, const char *action)
{
    GHashTableIter iter;
    time_t now = time(NULL);
    remote_fencing_op_t *rop = NULL;

    if (tolerance <= 0 || !stonith_remote_op_list || target == NULL ||
        action == NULL) {
        return FALSE;
    }

    g_hash_table_iter_init(&iter, stonith_remote_op_list);
    while (g_hash_table_iter_next(&iter, NULL, (void **)&rop)) {
        if (strcmp(rop->target, target) != 0) {
            continue;
        } else if (rop->state != st_done) {
            continue;
        /* We don't have to worry about remapped reboots here
         * because if state is done, any remapping has been undone
         */
        } else if (strcmp(rop->action, action) != 0) {
            continue;
        } else if ((rop->completed + tolerance) < now) {
            continue;
        }

        pcmk__notice("Target %s was fenced (%s) less than %ds ago by %s on "
                     "behalf of %s",
                     target, action, tolerance, rop->delegate, rop->originator);
        return TRUE;
    }
    return FALSE;
}
