/*

 * Copyright 2004-2019 the Pacemaker project contributors

 *

 * The version control history for this file may have further details.

 *

 * This source code is licensed under the GNU Lesser General Public License

 * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.

 */

#include <crm_internal.h>

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <stdbool.h>

#include <string.h>

#include <ctype.h>

#include <libgen.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <glib.h>

#include <crm/crm.h>

#include <crm/stonith-ng.h>

#include <crm/fencing/internal.h>

#include <crm/msg_xml.h>

#include <crm/common/xml.h>

#include <crm/common/mainloop.h>

#if SUPPORT_CIBSECRETS

#  include <crm/common/cib_secrets.h>

#endif

CRM_TRACE_INIT_DATA(stonith);

struct stonith_action_s {

    /*! user defined data */

    char *agent;

    char *action;

    char *victim;

    GHashTable *args;

    int timeout;

    int async;

    void *userdata;

    void (*done_cb) (GPid pid, gint status, const char *output, gpointer user_data);

    void (*fork_cb) (GPid pid, gpointer user_data);

    svc_action_t *svc_action;

    /*! internal timing information */

    time_t initial_start_time;

    int tries;

    int remaining_timeout;

    int max_retries;

    /* device output data */

    GPid pid;

    int rc;

    char *output;

    char *error;

};

typedef struct stonith_private_s {

    char *token;

    crm_ipc_t *ipc;

    mainloop_io_t *source;

    GHashTable *stonith_op_callback_table;

    GList *notify_list;

    int notify_refcnt;

    bool notify_deletes;

    void (*op_callback) (stonith_t * st, stonith_callback_data_t * data);

} stonith_private_t;

typedef struct stonith_notify_client_s {

    const char *event;

    const char *obj_id;         /* implement one day */

    const char *obj_type;       /* implement one day */

    void (*notify) (stonith_t * st, stonith_event_t * e);

    bool delete;

} stonith_notify_client_t;

typedef struct stonith_callback_client_s {

    void (*callback) (stonith_t * st, stonith_callback_data_t * data);

    const char *id;

    void *user_data;

    gboolean only_success;

    gboolean allow_timeout_updates;

    struct timer_rec_s *timer;

} stonith_callback_client_t;

struct notify_blob_s {

    stonith_t *stonith;

    xmlNode *xml;

};

struct timer_rec_s {

    int call_id;

    int timeout;

    guint ref;

    stonith_t *stonith;

};

typedef int (*stonith_op_t) (const char *, int, const char *, xmlNode *,

                             xmlNode *, xmlNode *, xmlNode **, xmlNode **);

bool stonith_dispatch(stonith_t * st);

xmlNode *stonith_create_op(int call_id, const char *token, const char *op, xmlNode * data,

                           int call_options);

static int stonith_send_command(stonith_t *stonith, const char *op,

                                xmlNode *data, xmlNode **output_data,

                                int call_options, int timeout);

static void stonith_connection_destroy(gpointer user_data);

static void stonith_send_notification(gpointer data, gpointer user_data);

static int internal_stonith_action_execute(stonith_action_t * action);

static void log_action(stonith_action_t *action, pid_t pid);

/*!

 * \brief Get agent namespace by name

 *

 * \param[in] namespace_s  Name of namespace as string

 *

 * \return Namespace as enum value

 */

enum stonith_namespace

stonith_text2namespace(const char *namespace_s)

{

    if ((namespace_s == NULL) || !strcmp(namespace_s, "any")) {

        return st_namespace_any;

    } else if (!strcmp(namespace_s, "redhat")

               || !strcmp(namespace_s, "stonith-ng")) {

        return st_namespace_rhcs;

    } else if (!strcmp(namespace_s, "internal")) {

        return st_namespace_internal;

    } else if (!strcmp(namespace_s, "heartbeat")) {

        return st_namespace_lha;

    }

    return st_namespace_invalid;

}

/*!

 * \brief Get agent namespace name

 *

 * \param[in] namespace  Namespace as enum value

 *

 * \return Namespace name as string

 */

const char *

stonith_namespace2text(enum stonith_namespace st_namespace)

{

    switch (st_namespace) {

        case st_namespace_any:      return "any";

        case st_namespace_rhcs:     return "stonith-ng";

        case st_namespace_internal: return "internal";

        case st_namespace_lha:      return "heartbeat";

        default:                    break;

    }

    return "unsupported";

}

/*!

 * \brief Determine namespace of a fence agent

 *

 * \param[in] agent        Fence agent type

 * \param[in] namespace_s  Name of agent namespace as string, if known

 *

 * \return Namespace of specified agent, as enum value

 */

enum stonith_namespace

stonith_get_namespace(const char *agent, const char *namespace_s)

{

    if (safe_str_eq(namespace_s, "internal")) {

        return st_namespace_internal;

    }

    if (stonith__agent_is_rhcs(agent)) {

        return st_namespace_rhcs;

    }

#if HAVE_STONITH_STONITH_H

    if (stonith__agent_is_lha(agent)) {

        return st_namespace_lha;

    }

#endif

    crm_err("Unknown fence agent: %s", agent);

    return st_namespace_invalid;

}

static void

log_action(stonith_action_t *action, pid_t pid)

{

    if (action->output) {

        /* Logging the whole string confuses syslog when the string is xml */

        char *prefix = crm_strdup_printf("%s[%d] stdout:", action->agent, pid);

        crm_log_output(LOG_TRACE, prefix, action->output);

        free(prefix);

    }

    if (action->error) {

        /* Logging the whole string confuses syslog when the string is xml */

        char *prefix = crm_strdup_printf("%s[%d] stderr:", action->agent, pid);

        crm_log_output(LOG_WARNING, prefix, action->error);

        free(prefix);

    }

}

/* when cycling through the list we don't want to delete items

   so just mark them and when we know nobody is using the list

   loop over it to remove the marked items

 */

static void

foreach_notify_entry (stonith_private_t *private,

                GFunc func,

                gpointer user_data)

{

    private->notify_refcnt++;

    g_list_foreach(private->notify_list, func, user_data);

    private->notify_refcnt--;

    if ((private->notify_refcnt == 0) &&

        private->notify_deletes) {

        GList *list_item = private->notify_list;

        private->notify_deletes = FALSE;

        while (list_item != NULL)

        {

            stonith_notify_client_t *list_client = list_item->data;

            GList *next = g_list_next(list_item);

            if (list_client->delete) {

                free(list_client);

                private->notify_list =

                    g_list_delete_link(private->notify_list, list_item);

            }

            list_item = next;

        }

    }

}

static void

stonith_connection_destroy(gpointer user_data)

{

    stonith_t *stonith = user_data;

    stonith_private_t *native = NULL;

    struct notify_blob_s blob;

    crm_trace("Sending destroyed notification");

    blob.stonith = stonith;

    blob.xml = create_xml_node(NULL, "notify");

    native = stonith->st_private;

    native->ipc = NULL;

    native->source = NULL;

    free(native->token); native->token = NULL;

    stonith->state = stonith_disconnected;

    crm_xml_add(blob.xml, F_TYPE, T_STONITH_NOTIFY);

    crm_xml_add(blob.xml, F_SUBTYPE, T_STONITH_NOTIFY_DISCONNECT);

    foreach_notify_entry(native, stonith_send_notification, &blob;;

    free_xml(blob.xml);

}

xmlNode *

create_device_registration_xml(const char *id, enum stonith_namespace namespace,

                               const char *agent, stonith_key_value_t *params,

                               const char *rsc_provides)

{

    xmlNode *data = create_xml_node(NULL, F_STONITH_DEVICE);

    xmlNode *args = create_xml_node(data, XML_TAG_ATTRS);

#if HAVE_STONITH_STONITH_H

    if (namespace == st_namespace_any) {

        namespace = stonith_get_namespace(agent, NULL);

    }

    if (namespace == st_namespace_lha) {

        hash2field((gpointer) "plugin", (gpointer) agent, args);

        agent = "fence_legacy";

    }

#endif

    crm_xml_add(data, XML_ATTR_ID, id);

    crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);

    crm_xml_add(data, "agent", agent);

    if ((namespace != st_namespace_any) && (namespace != st_namespace_invalid)) {

        crm_xml_add(data, "namespace", stonith_namespace2text(namespace));

    }

    if (rsc_provides) {

        crm_xml_add(data, "rsc_provides", rsc_provides);

    }

    for (; params; params = params->next) {

        hash2field((gpointer) params->key, (gpointer) params->value, args);

    }

    return data;

}

static int

stonith_api_register_device(stonith_t * st, int call_options,

                            const char *id, const char *namespace, const char *agent,

                            stonith_key_value_t * params)

{

    int rc = 0;

    xmlNode *data = NULL;

    data = create_device_registration_xml(id, stonith_text2namespace(namespace),

                                          agent, params, NULL);

    rc = stonith_send_command(st, STONITH_OP_DEVICE_ADD, data, NULL, call_options, 0);

    free_xml(data);

    return rc;

}

static int

stonith_api_remove_device(stonith_t * st, int call_options, const char *name)

{

    int rc = 0;

    xmlNode *data = NULL;

    data = create_xml_node(NULL, F_STONITH_DEVICE);

    crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);

    crm_xml_add(data, XML_ATTR_ID, name);

    rc = stonith_send_command(st, STONITH_OP_DEVICE_DEL, data, NULL, call_options, 0);

    free_xml(data);

    return rc;

}

static int

stonith_api_remove_level_full(stonith_t *st, int options,

                              const char *node, const char *pattern,

                              const char *attr, const char *value, int level)

{

    int rc = 0;

    xmlNode *data = NULL;

    CRM_CHECK(node || pattern || (attr && value), return -EINVAL);

    data = create_xml_node(NULL, XML_TAG_FENCING_LEVEL);

    crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);

    if (node) {

        crm_xml_add(data, XML_ATTR_STONITH_TARGET, node);

    } else if (pattern) {

        crm_xml_add(data, XML_ATTR_STONITH_TARGET_PATTERN, pattern);

    } else {

        crm_xml_add(data, XML_ATTR_STONITH_TARGET_ATTRIBUTE, attr);

        crm_xml_add(data, XML_ATTR_STONITH_TARGET_VALUE, value);

    }

    crm_xml_add_int(data, XML_ATTR_STONITH_INDEX, level);

    rc = stonith_send_command(st, STONITH_OP_LEVEL_DEL, data, NULL, options, 0);

    free_xml(data);

    return rc;

}

static int

stonith_api_remove_level(stonith_t * st, int options, const char *node, int level)

{

    return stonith_api_remove_level_full(st, options, node,

                                         NULL, NULL, NULL, level);

}

/*!

 * \internal

 * \brief Create XML for fence topology level registration request

 *

 * \param[in] node        If not NULL, target level by this node name

 * \param[in] pattern     If not NULL, target by node name using this regex

 * \param[in] attr        If not NULL, target by this node attribute

 * \param[in] value       If not NULL, target by this node attribute value

 * \param[in] level       Index number of level to register

 * \param[in] device_list List of devices in level

 *

 * \return Newly allocated XML tree on success, NULL otherwise

 *

 * \note The caller should set only one of node, pattern or attr/value.

 */

xmlNode *

create_level_registration_xml(const char *node, const char *pattern,

                              const char *attr, const char *value,

                              int level, stonith_key_value_t *device_list)

{

    int len = 0;

    char *list = NULL;

    xmlNode *data;

    CRM_CHECK(node || pattern || (attr && value), return NULL);

    data = create_xml_node(NULL, XML_TAG_FENCING_LEVEL);

    CRM_CHECK(data, return NULL);

    crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);

    crm_xml_add_int(data, XML_ATTR_ID, level);

    crm_xml_add_int(data, XML_ATTR_STONITH_INDEX, level);

    if (node) {

        crm_xml_add(data, XML_ATTR_STONITH_TARGET, node);

    } else if (pattern) {

        crm_xml_add(data, XML_ATTR_STONITH_TARGET_PATTERN, pattern);

    } else {

        crm_xml_add(data, XML_ATTR_STONITH_TARGET_ATTRIBUTE, attr);

        crm_xml_add(data, XML_ATTR_STONITH_TARGET_VALUE, value);

    }

    for (; device_list; device_list = device_list->next) {

        int adding = strlen(device_list->value);

        if(list) {

            adding++;                                      /* +1 space */

        }

        crm_trace("Adding %s (%dc) at offset %d", device_list->value, adding, len);

        list = realloc_safe(list, len + adding + 1);       /* +1 EOS */

        if (list == NULL) {

            crm_perror(LOG_CRIT, "Could not create device list");

            free_xml(data);

            return NULL;

        }

        sprintf(list + len, "%s%s", len?",":"", device_list->value);

        len += adding;

    }

    crm_xml_add(data, XML_ATTR_STONITH_DEVICES, list);

    free(list);

    return data;

}

static int

stonith_api_register_level_full(stonith_t * st, int options, const char *node,

                                const char *pattern,

                                const char *attr, const char *value,

                                int level, stonith_key_value_t *device_list)

{

    int rc = 0;

    xmlNode *data = create_level_registration_xml(node, pattern, attr, value,

                                                  level, device_list);

    CRM_CHECK(data != NULL, return -EINVAL);

    rc = stonith_send_command(st, STONITH_OP_LEVEL_ADD, data, NULL, options, 0);

    free_xml(data);

    return rc;

}

static int

stonith_api_register_level(stonith_t * st, int options, const char *node, int level,

                           stonith_key_value_t * device_list)

{

    return stonith_api_register_level_full(st, options, node, NULL, NULL, NULL,

                                           level, device_list);

}

static void

append_arg(const char *key, const char *value, GHashTable **args)

{

    CRM_CHECK(key != NULL, return);

    CRM_CHECK(value != NULL, return);

    CRM_CHECK(args != NULL, return);

    if (strstr(key, "pcmk_")) {

        return;

    } else if (strstr(key, CRM_META)) {

        return;

    } else if (safe_str_eq(key, "crm_feature_set")) {

        return;

    }

    if (!*args) {

        *args = crm_str_table_new();

    }

    CRM_CHECK(*args != NULL, return);

    crm_trace("Appending: %s=%s", key, value);

    g_hash_table_replace(*args, strdup(key), strdup(value));

}

static void

append_config_arg(gpointer key, gpointer value, gpointer user_data)

{

    /* The fencer will filter action out when it registers the device,

     * but ignore it here just in case any other library callers

     * fail to do so.

     */

    if (safe_str_neq(key, STONITH_ATTR_ACTION_OP)) {

        append_arg(key, value, user_data);

        return;

    }

}

static GHashTable *

make_args(const char *agent, const char *action, const char *victim, uint32_t victim_nodeid, GHashTable * device_args,

          GHashTable * port_map)

{

    char buffer[512];

    GHashTable *arg_list = NULL;

    const char *value = NULL;

    CRM_CHECK(action != NULL, return NULL);

    snprintf(buffer, sizeof(buffer), "pcmk_%s_action", action);

    if (device_args) {

        value = g_hash_table_lookup(device_args, buffer);

    }

    if (value) {

        crm_debug("Substituting action '%s' for requested operation '%s'", value, action);

        action = value;

    }

    append_arg(STONITH_ATTR_ACTION_OP, action, &arg_list);

    if (victim && device_args) {

        const char *alias = victim;

        const char *param = g_hash_table_lookup(device_args, STONITH_ATTR_HOSTARG);

        if (port_map && g_hash_table_lookup(port_map, victim)) {

            alias = g_hash_table_lookup(port_map, victim);

        }

        /* Always supply the node's name, too:

         * https://github.com/ClusterLabs/fence-agents/blob/master/doc/FenceAgentAPI.md

         */

        append_arg("nodename", victim, &arg_list);

        if (victim_nodeid) {

            char nodeid_str[33] = { 0, };

            if (snprintf(nodeid_str, 33, "%u", (unsigned int)victim_nodeid)) {

                crm_info("For stonith action (%s) for victim %s, adding nodeid (%s) to parameters",

                         action, victim, nodeid_str);

                append_arg("nodeid", nodeid_str, &arg_list);

            }

        }

        /* Check if we need to supply the victim in any other form */

        if(safe_str_eq(agent, "fence_legacy")) {

            value = agent;

        } else if (param == NULL) {

            param = "port";

            value = g_hash_table_lookup(device_args, param);

        } else if (safe_str_eq(param, "none")) {

            value = param;      /* Nothing more to do */

        } else {

            value = g_hash_table_lookup(device_args, param);

        }

        /* Don't overwrite explictly set values for $param */

        if (value == NULL || safe_str_eq(value, "dynamic")) {

            crm_debug("Performing '%s' action targeting '%s' as '%s=%s'", action, victim, param,

                      alias);

            append_arg(param, alias, &arg_list);

        }

    }

    if (device_args) {

        g_hash_table_foreach(device_args, append_config_arg, &arg_list);

    }

    return arg_list;

}

/*!

 * \internal

 * \brief Free all memory used by a stonith action

 *

 * \param[in,out] action  Action to free

 */

void

stonith__destroy_action(stonith_action_t *action)

{

    if (action) {

        free(action->agent);

        if (action->args) {

            g_hash_table_destroy(action->args);

        }

        free(action->action);

        free(action->victim);

        if (action->svc_action) {

            services_action_free(action->svc_action);

        }

        free(action->output);

        free(action->error);

        free(action);

    }

}

/*!

 * \internal

 * \brief Get the result of an executed stonith action

 *

 * \param[in,out] action        Executed action

 * \param[out]    rc            Where to store result code (or NULL)

 * \param[out]    output        Where to store standard output (or NULL)

 * \param[out]    error_output  Where to store standard error output (or NULL)

 *

 * \note If output or error_output is not NULL, the caller is responsible for

 *       freeing the memory.

 */

void

stonith__action_result(stonith_action_t *action, int *rc, char **output,

                       char **error_output)

{

    if (rc) {

        *rc = pcmk_ok;

    }

    if (output) {

        *output = NULL;

    }

    if (error_output) {

        *error_output = NULL;

    }

    if (action != NULL) {

        if (rc) {

            *rc = action->rc;

        }

        if (output && action->output) {

            *output = action->output;

            action->output = NULL; // hand off memory management to caller

        }

        if (error_output && action->error) {

            *error_output = action->error;

            action->error = NULL; // hand off memory management to caller

        }

    }

}

#define FAILURE_MAX_RETRIES 2

stonith_action_t *

stonith_action_create(const char *agent,

                      const char *_action,

                      const char *victim,

                      uint32_t victim_nodeid,

                      int timeout, GHashTable * device_args, GHashTable * port_map)

{

    stonith_action_t *action;

    action = calloc(1, sizeof(stonith_action_t));

    action->args = make_args(agent, _action, victim, victim_nodeid, device_args, port_map);

    crm_debug("Preparing '%s' action for %s using agent %s",

              _action, (victim? victim : "no target"), agent);

    action->agent = strdup(agent);

    action->action = strdup(_action);

    if (victim) {

        action->victim = strdup(victim);

    }

    action->timeout = action->remaining_timeout = timeout;

    action->max_retries = FAILURE_MAX_RETRIES;

    if (device_args) {

        char buffer[512];

        const char *value = NULL;

        snprintf(buffer, sizeof(buffer), "pcmk_%s_retries", _action);

        value = g_hash_table_lookup(device_args, buffer);

        if (value) {

            action->max_retries = atoi(value);

        }

    }

    return action;

}

static gboolean

update_remaining_timeout(stonith_action_t * action)

{

    int diff = time(NULL) - action->initial_start_time;

    if (action->tries >= action->max_retries) {

        crm_info("Attempted to execute agent %s (%s) the maximum number of times (%d) allowed",

                 action->agent, action->action, action->max_retries);

        action->remaining_timeout = 0;

    } else if ((action->rc != -ETIME) && diff < (action->timeout * 0.7)) {

        /* only set remaining timeout period if there is 30%

         * or greater of the original timeout period left */

        action->remaining_timeout = action->timeout - diff;

    } else {

        action->remaining_timeout = 0;

    }

    return action->remaining_timeout ? TRUE : FALSE;

}

static int

svc_action_to_errno(svc_action_t *svc_action) {

    int rv = pcmk_ok;

    if (svc_action->rc > 0) {

        /* Try to provide a useful error code based on the fence agent's

            * error output.

            */

        if (svc_action->rc == PCMK_OCF_TIMEOUT) {

            rv = -ETIME;

        } else if (svc_action->stderr_data == NULL) {

            rv = -ENODATA;

        } else if (strstr(svc_action->stderr_data, "imed out")) {

            /* Some agents have their own internal timeouts */

            rv = -ETIME;

        } else if (strstr(svc_action->stderr_data, "Unrecognised action")) {

            rv = -EOPNOTSUPP;

        } else {

            rv = -pcmk_err_generic;

        }

    }

    return rv;

}

static void

stonith_action_async_done(svc_action_t *svc_action)

{

    stonith_action_t *action = (stonith_action_t *) svc_action->cb_data;

    action->rc = svc_action_to_errno(svc_action);

    action->output = svc_action->stdout_data;

    svc_action->stdout_data = NULL;

    action->error = svc_action->stderr_data;

    svc_action->stderr_data = NULL;

    svc_action->params = NULL;

    crm_debug("Child process %d performing action '%s' exited with rc %d",

                action->pid, action->action, svc_action->rc);

    log_action(action, action->pid);

    if (action->rc != pcmk_ok && update_remaining_timeout(action)) {

        int rc = internal_stonith_action_execute(action);

        if (rc == pcmk_ok) {

            return;

        }

    }

    if (action->done_cb) {

        action->done_cb(action->pid, action->rc, action->output, action->userdata);

    }

    action->svc_action = NULL; // don't remove our caller

    stonith__destroy_action(action);

}

static void

stonith_action_async_forked(svc_action_t *svc_action)

{

    stonith_action_t *action = (stonith_action_t *) svc_action->cb_data;

    action->pid = svc_action->pid;

    action->svc_action = svc_action;

    if (action->fork_cb) {

        (action->fork_cb) (svc_action->pid, action->userdata);

    }

    crm_trace("Child process %d performing action '%s' successfully forked",

              action->pid, action->action);

}

static int

internal_stonith_action_execute(stonith_action_t * action)

{

    int rc = -EPROTO;

    int is_retry = 0;

    svc_action_t *svc_action = NULL;

    static int stonith_sequence = 0;

    char *buffer = NULL;

    if (!action->tries) {

        action->initial_start_time = time(NULL);

    }

    action->tries++;

    if (action->tries > 1) {

        crm_info("Attempt %d to execute %s (%s). remaining timeout is %d",

                 action->tries, action->agent, action->action, action->remaining_timeout);

        is_retry = 1;

    }

    if (action->args == NULL || action->agent == NULL)

        goto fail;

    buffer = crm_strdup_printf(RH_STONITH_DIR "/%s", basename(action->agent));

    svc_action = services_action_create_generic(buffer, NULL);

    free(buffer);

    svc_action->timeout = 1000 * action->remaining_timeout;

    svc_action->standard = strdup(PCMK_RESOURCE_CLASS_STONITH);

    svc_action->id = crm_strdup_printf("%s_%s_%d", basename(action->agent),

                                       action->action, action->tries);

    svc_action->agent = strdup(action->agent);

    svc_action->sequence = stonith_sequence++;

    svc_action->params = action->args;

    svc_action->cb_data = (void *) action;

    set_bit(svc_action->flags, SVC_ACTION_NON_BLOCKED);

    /* keep retries from executing out of control and free previous results */

    if (is_retry) {

        free(action->output);

        action->output = NULL;

        free(action->error);

        action->error = NULL;

        sleep(1);

    }

    if (action->async) {

        /* async */

        if(services_action_async_fork_notify(svc_action,

            &stonith_action_async_done,

            &stonith_action_async_forked) == FALSE) {

            services_action_free(svc_action);

            svc_action = NULL;

        } else {

            rc = 0;

        }

    } else {

        /* sync */

        if (services_action_sync(svc_action)) {

            rc = 0;

            action->rc = svc_action_to_errno(svc_action);

            action->output = svc_action->stdout_data;

            svc_action->stdout_data = NULL;

            action->error = svc_action->stderr_data;

            svc_action->stderr_data = NULL;

        } else {

            action->rc = -ECONNABORTED;

            rc = action->rc;

        }

        svc_action->params = NULL;

        services_action_free(svc_action);

    }

  fail:

    return rc;

}

/*!

 * \internal

 * \brief Kick off execution of an async stonith action

 *

 * \param[in,out] action        Action to be executed

 * \param[in,out] userdata      Datapointer to be passed to callbacks

 * \param[in]     done          Callback to notify action has failed/succeeded

 * \param[in]     fork_callback Callback to notify successful fork of child

 *

 * \return pcmk_ok if ownership of action has been taken, -errno otherwise

 */

int

stonith_action_execute_async(stonith_action_t * action,

                             void *userdata,

                             void (*done) (GPid pid, int rc, const char *output,

                                           gpointer user_data),

                             void (*fork_cb) (GPid pid, gpointer user_data))

{

    if (!action) {

        return -EINVAL;

    }

    action->userdata = userdata;