/** BEGIN COPYRIGHT BLOCK
 * Copyright (C) 2009 Red Hat, Inc.
 * All rights reserved.
 *
 * License: GPL (version 3 or any later version).
 * See LICENSE for details.
 * END COPYRIGHT BLOCK **/

#include "slapi-plugin.h"

#define FAIL_PLUGIN_SUBSYSTEM "plugin-fail-plugin"

static Slapi_PluginDesc pdesc = {
    "FAIL", "389 TEST", "1.0",
    "Plugin failure plugin"};
/*
 *
 * This plugin triggers a failute when it is called for the configured
 * plugin type and operation. It returns the specified error or by default
 * operations error.
 *
 * An example configuration is:
 *
dn: cn=Plugin Failure,cn=plugins,cn=config
objectClass: top
objectClass: nsSlapdPlugin
objectClass: extensibleObject
cn: Plugin Failure
nsslapd-pluginPath: /home/lkrispen/scripts/examples/plugin-fail
nsslapd-pluginInitfunc: fail_init
nsslapd-pluginType: object
nsslapd-pluginEnabled: on
nsslapd-plugin-fail-type: betxnpostoperation
nsslapd-plugin-fail-op: modrdn
nsslapd-plugin-fail-err: 80
nsslapd-pluginId: FAIL
nsslapd-pluginVersion: 1.0
nsslapd-pluginVendor: 389 TEST
nsslapd-pluginDescription: Plugin failure plugin
 *
 */

#define FAIL_PLUGIN_TYPE "nsslapd-plugin-fail-type"
#define FAIL_PLUGIN_OP "nsslapd-plugin-fail-op"
#define FAIL_PLUGIN_ERR "nsslapd-plugin-fail-err"

#define FAIL_PLUGIN_TYPE_PREOP 0x01
#define FAIL_PLUGIN_TYPE_POSTOP 0x02
#define FAIL_PLUGIN_TYPE_BE_PREOP 0x04
#define FAIL_PLUGIN_TYPE_BE_POSTOP 0x08
#define FAIL_PLUGIN_TYPE_BE_TXN_PREOP 0x10
#define FAIL_PLUGIN_TYPE_BE_TXN_POSTOP 0x20

#define FAIL_PLUGIN_OP_SRCH 0x01
#define FAIL_PLUGIN_OP_ADD 0x02
#define FAIL_PLUGIN_OP_MODIFY 0x04
#define FAIL_PLUGIN_OP_MODRDN 0x08
#define FAIL_PLUGIN_OP_DELETE 0x10

static int fail_plugin_type = 0;
static int fail_plugin_op = 0;
static int fail_plugin_error = LDAP_OPERATIONS_ERROR;

static int fail_return(int call_type, int call_op);
static int fail_decode_type(char *attr);
static int fail_decode_op(char *attr);

static int fail_preop_init(Slapi_PBlock *pb);
static int fail_preop_search(Slapi_PBlock *pb);
static int fail_preop_add(Slapi_PBlock *pb);
static int fail_preop_modify(Slapi_PBlock *pb);
static int fail_preop_modrdn(Slapi_PBlock *pb);
static int fail_preop_delete(Slapi_PBlock *pb);

static int fail_postop_init(Slapi_PBlock *pb);
static int fail_postop_search(Slapi_PBlock *pb);
static int fail_postop_add(Slapi_PBlock *pb);
static int fail_postop_modify(Slapi_PBlock *pb);
static int fail_postop_modrdn(Slapi_PBlock *pb);
static int fail_postop_delete(Slapi_PBlock *pb);

static int fail_bepreop_init(Slapi_PBlock *pb);
static int fail_bepreop_add(Slapi_PBlock *pb);
static int fail_bepreop_modify(Slapi_PBlock *pb);
static int fail_bepreop_modrdn(Slapi_PBlock *pb);
static int fail_bepreop_delete(Slapi_PBlock *pb);

static int fail_bepostop_init(Slapi_PBlock *pb);
static int fail_bepostop_add(Slapi_PBlock *pb);
static int fail_bepostop_modify(Slapi_PBlock *pb);
static int fail_bepostop_modrdn(Slapi_PBlock *pb);
static int fail_bepostop_delete(Slapi_PBlock *pb);

static int fail_betxnpreop_init(Slapi_PBlock *pb);
static int fail_betxnpreop_add(Slapi_PBlock *pb);
static int fail_betxnpreop_modify(Slapi_PBlock *pb);
static int fail_betxnpreop_modrdn(Slapi_PBlock *pb);
static int fail_betxnpreop_delete(Slapi_PBlock *pb);

static int fail_betxnpostop_init(Slapi_PBlock *pb);
static int fail_betxnpostop_add(Slapi_PBlock *pb);
static int fail_betxnpostop_modify(Slapi_PBlock *pb);
static int fail_betxnpostop_modrdn(Slapi_PBlock *pb);
static int fail_betxnpostop_delete(Slapi_PBlock *pb);

static int fail_start(Slapi_PBlock *pb);
static int fail_close(Slapi_PBlock *pb);

static int fail_return(int call_type, int call_op)
{
    int rc = LDAP_SUCCESS;

    if (call_type == fail_plugin_type &&
        call_op == fail_plugin_op) {
        rc = fail_plugin_error;
    }
    return rc;
}

static int fail_decode_type(char *attr)
{
    int type = 0;

    if (0 == strcasecmp(attr,"preop")) {
        type = FAIL_PLUGIN_TYPE_PREOP;
    } else if (0 == strcasecmp(attr,"postop")) {
        type = FAIL_PLUGIN_TYPE_POSTOP;
    } else if (0 == strcasecmp(attr,"bepreoperation")) {
        type = FAIL_PLUGIN_TYPE_BE_PREOP;
    } else if (0 == strcasecmp(attr,"bepostoperation")) {
        type = FAIL_PLUGIN_TYPE_BE_POSTOP;
    } else if (0 == strcasecmp(attr,"betxnpreoperation")) {
        type = FAIL_PLUGIN_TYPE_BE_TXN_PREOP;
    } else if (0 == strcasecmp(attr,"betxnpostoperation")) {
        type = FAIL_PLUGIN_TYPE_BE_TXN_POSTOP;
    }

    return type;

}

static int fail_decode_op(char *attr)
{
    int op = 0;

    if (0 == strcasecmp(attr,"search")) {
        op = FAIL_PLUGIN_OP_SRCH;
    } else if (0 == strcasecmp(attr,"add")) {
        op = FAIL_PLUGIN_OP_ADD;
    } else if (0 == strcasecmp(attr,"modify")) {
        op = FAIL_PLUGIN_OP_MODIFY;
    } else if (0 == strcasecmp(attr,"modrdn")) {
        op = FAIL_PLUGIN_OP_MODRDN;
    } else if (0 == strcasecmp(attr,"delete")) {
        op = FAIL_PLUGIN_OP_DELETE;
    }

    return op;
}

int
fail_init(Slapi_PBlock *pb)
{
    int rc = 0;
    void *identity = NULL;
    Slapi_Entry *plugin_entry = NULL;
    int is_betxn = 0;
    const char *plugintype;

    slapi_log_error(SLAPI_LOG_TRACE, FAIL_PLUGIN_SUBSYSTEM,
                  "--> fail_init\n");

    slapi_pblock_get(pb, SLAPI_PLUGIN_IDENTITY, &identity);


    /* slapi_register_plugin always returns SUCCESS (0) */
    if (slapi_pblock_set(pb, SLAPI_PLUGIN_VERSION,
                         SLAPI_PLUGIN_VERSION_01) != 0 ||
        slapi_pblock_set(pb, SLAPI_PLUGIN_DESCRIPTION,
                         (void *)&pdesc) != 0 ) {
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_init - Failed to register version & description\n");
        rc = -1;
        goto bail;
    }
    if (slapi_pblock_set(pb, SLAPI_PLUGIN_START_FN,
                         (void *)fail_start) != 0 ||
        slapi_pblock_set(pb, SLAPI_PLUGIN_CLOSE_FN,
                         (void *)fail_close) != 0) {
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_init - Failed to register close callback & task\n");
        rc = -1;
        goto bail;
    }

    if ((slapi_pblock_get(pb, SLAPI_PLUGIN_CONFIG_ENTRY, &plugin_entry) == 0) &&
        plugin_entry) {
        int err;
        char *str = NULL;
        err = slapi_entry_attr_get_int(plugin_entry, FAIL_PLUGIN_ERR);
        if (err) {
            fail_plugin_error = err;
        }
        str = slapi_entry_attr_get_charptr(plugin_entry, FAIL_PLUGIN_TYPE);
        if (str) {
            fail_plugin_type = fail_decode_type(str);
            slapi_ch_free_string(&str);
            str = NULL;
        }
        str = slapi_entry_attr_get_charptr(plugin_entry, FAIL_PLUGIN_OP);
        if (str) {
            fail_plugin_op = fail_decode_op(str);
            slapi_ch_free_string(&str);
            str = NULL;
        }
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_init - failing all plugin calls of type (%d) for (%d) operations with error: %d\n",
                      fail_plugin_type, fail_plugin_op, fail_plugin_error);
    }
    
    plugintype = "preoperation";
    rc = slapi_register_plugin(plugintype, 1 /* Enabled */,
                               "fail_preop_init", fail_preop_init,
                               "FAIL preoperation plugin", NULL, identity);
    plugintype = "postoperation";
    rc = slapi_register_plugin(plugintype, 1 /* Enabled */,
                               "fail_postop_init", fail_postop_init,
                               "FAIL postperation plugin", NULL, identity);

    plugintype = "bepreoperation";
    rc |= slapi_register_plugin(plugintype, 1 /* Enabled */,
                                "fail_bepreop_init", fail_bepreop_init,
                                "FAIL bepreoperation plugin", NULL, identity);
    plugintype = "bepostoperation";
    rc |= slapi_register_plugin(plugintype, 1 /* Enabled */,
                                "fail_bepostop_init", fail_bepostop_init,
                                "FAIL bepostoperation plugin", NULL, identity);

    plugintype = "betxnpreoperation";
    rc |= slapi_register_plugin(plugintype, 1 /* Enabled */,
                                "fail_betxnpreop_init", fail_betxnpreop_init,
                                "FAIL betxnpreoperation plugin", NULL, identity);
    plugintype = "betxnpostoperation";
    rc |= slapi_register_plugin(plugintype, 1 /* Enabled */,
                                "fail_betxnpostop_init", fail_betxnpostop_init,
                                "FAIL beitxnpostoperation plugin", NULL, identity);
bail:
    slapi_log_error(SLAPI_LOG_TRACE, FAIL_PLUGIN_SUBSYSTEM,
                  "<-- fail_init\n");
    return rc;
}

static int
fail_preop_init(Slapi_PBlock *pb)
{
    int rc = SLAPI_PLUGIN_SUCCESS;

    if ((slapi_pblock_set(pb, SLAPI_PLUGIN_PRE_SEARCH_FN, (void *)fail_preop_search) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_PRE_ADD_FN, (void *)fail_preop_add) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_PRE_MODIFY_FN, (void *)fail_preop_modify) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_PRE_MODRDN_FN, (void *)fail_preop_modrdn) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_PRE_DELETE_FN, (void *)fail_preop_delete) != 0)) {
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_preop_init - Failed to register preop plugin\n");
        rc = SLAPI_PLUGIN_FAILURE;
    }

    return rc;
}

static int
fail_postop_init(Slapi_PBlock *pb)
{
    int rc = SLAPI_PLUGIN_SUCCESS;

    if ((slapi_pblock_set(pb, SLAPI_PLUGIN_POST_SEARCH_FN, (void *)fail_postop_search) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_POST_ADD_FN, (void *)fail_postop_add) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_POST_MODIFY_FN, (void *)fail_postop_modify) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_POST_MODRDN_FN, (void *)fail_postop_modrdn) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_POST_DELETE_FN, (void *)fail_postop_delete) != 0)) {
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_postop_init - Failed to register preop plugin\n");
        rc = SLAPI_PLUGIN_FAILURE;
    }

    return rc;
}

static int
fail_bepreop_init(Slapi_PBlock *pb)
{
    int rc = SLAPI_PLUGIN_SUCCESS;
    if ((slapi_pblock_set(pb, SLAPI_PLUGIN_BE_PRE_ADD_FN, (void *)fail_bepreop_add) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_PRE_MODIFY_FN, (void *)fail_bepreop_modify) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_PRE_MODRDN_FN, (void *)fail_bepreop_modrdn) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_PRE_DELETE_FN, (void *)fail_bepreop_delete) != 0)) {
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_bepreop_init - Failed to register bepreop plugin\n");
        rc = SLAPI_PLUGIN_FAILURE;
    }

    return rc;
}

static int
fail_bepostop_init(Slapi_PBlock *pb)
{
    int rc = SLAPI_PLUGIN_SUCCESS;
    if ((slapi_pblock_set(pb, SLAPI_PLUGIN_BE_POST_ADD_FN, (void *)fail_bepostop_add) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_POST_DELETE_FN, (void *)fail_bepostop_delete) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_POST_MODIFY_FN, (void *)fail_bepostop_modify) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_POST_MODRDN_FN, (void *)fail_bepostop_modrdn) != 0)) {
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_bepostop_init - Failed to register bepostop plugin\n");
        rc = SLAPI_PLUGIN_FAILURE;
    }

    return rc;
}

static int
fail_betxnpreop_init(Slapi_PBlock *pb)
{
    int rc = SLAPI_PLUGIN_SUCCESS;
    int preadd = SLAPI_PLUGIN_BE_TXN_PRE_ADD_FN;
    int predel = SLAPI_PLUGIN_BE_TXN_PRE_DELETE_TOMBSTONE_FN;

    if ((slapi_pblock_set(pb, preadd, (void *)fail_betxnpreop_add) != 0) ||
        (slapi_pblock_set(pb, predel, (void *)fail_betxnpreop_delete) != 0)) {
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_betxnpreop_init - Failed to register betxnpreop plugin\n");
        rc = SLAPI_PLUGIN_FAILURE;
    }

    return rc;
}

static int
fail_betxnpostop_init(Slapi_PBlock *pb)
{
    int rc = SLAPI_PLUGIN_SUCCESS;

    if ((slapi_pblock_set(pb, SLAPI_PLUGIN_BE_TXN_POST_ADD_FN, (void *)fail_betxnpostop_add) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_TXN_POST_DELETE_FN, (void *)fail_betxnpostop_delete) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_TXN_POST_MODIFY_FN, (void *)fail_betxnpostop_modify) != 0) ||
        (slapi_pblock_set(pb, SLAPI_PLUGIN_BE_TXN_POST_MODRDN_FN, (void *)fail_betxnpostop_modrdn) != 0)) {
        slapi_log_error(SLAPI_LOG_ERR, FAIL_PLUGIN_SUBSYSTEM,
                      "fail_bepostop_init - Failed to register bepostop plugin\n");
        rc = SLAPI_PLUGIN_FAILURE;
    }

    return rc;
}

static int
fail_start(Slapi_PBlock *pb)
{
    int rc = SLAPI_PLUGIN_SUCCESS;

    slapi_log_error(SLAPI_LOG_TRACE, FAIL_PLUGIN_SUBSYSTEM, "--> fail_start\n");


bail:
    slapi_log_error(SLAPI_LOG_TRACE, FAIL_PLUGIN_SUBSYSTEM,
                  "<-- fail_start (rc: %d)\n", rc);
    return rc;
}

static int
fail_close(Slapi_PBlock *pb __attribute__((unused)))
{
    slapi_log_error(SLAPI_LOG_TRACE, FAIL_PLUGIN_SUBSYSTEM, "--> fail_close\n");

    slapi_log_error(SLAPI_LOG_TRACE, FAIL_PLUGIN_SUBSYSTEM, "<-- fail_close\n");

    return SLAPI_PLUGIN_SUCCESS;
}

/* ============================= preop ============================== */ 
static int
fail_preop_delete(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_PREOP,FAIL_PLUGIN_OP_DELETE);
}

static int
fail_preop_search(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_PREOP,FAIL_PLUGIN_OP_SRCH);
}

static int
fail_preop_add(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_PREOP,FAIL_PLUGIN_OP_ADD);
}

static int
fail_preop_modify(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_PREOP,FAIL_PLUGIN_OP_MODIFY);
}

static int
fail_preop_modrdn(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_PREOP,FAIL_PLUGIN_OP_MODRDN);
}

/* ============================= postop ============================== */ 
static int
fail_postop_search(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_POSTOP,FAIL_PLUGIN_OP_SRCH);
}

static int
fail_postop_add(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_POSTOP,FAIL_PLUGIN_OP_ADD);
}

static int
fail_postop_modify(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_POSTOP,FAIL_PLUGIN_OP_MODIFY);
}

static int
fail_postop_modrdn(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_POSTOP,FAIL_PLUGIN_OP_MODRDN);
}

static int
fail_postop_delete(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_POSTOP,FAIL_PLUGIN_OP_DELETE);
}

/* ============================= be preop ============================== */ 
static int
fail_bepreop_add(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_PREOP,FAIL_PLUGIN_OP_ADD);
}

static int
fail_bepreop_modify(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_PREOP,FAIL_PLUGIN_OP_MODIFY);
}

static int
fail_bepreop_modrdn(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_PREOP,FAIL_PLUGIN_OP_MODRDN);
}

static int
fail_bepreop_delete(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_PREOP,FAIL_PLUGIN_OP_DELETE);
}

/* ============================= be postop ============================== */ 
static int
fail_bepostop_add(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_POSTOP,FAIL_PLUGIN_OP_ADD);
}

static int
fail_bepostop_modify(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_POSTOP,FAIL_PLUGIN_OP_MODIFY);
}

static int
fail_bepostop_modrdn(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_POSTOP,FAIL_PLUGIN_OP_MODRDN);
}

static int
fail_bepostop_delete(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_POSTOP,FAIL_PLUGIN_OP_DELETE);
}

/* ============================= be txn preop ============================== */ 
static int
fail_betxnpreop_add(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_TXN_PREOP,FAIL_PLUGIN_OP_ADD);
}

static int
fail_betxnpreop_modify(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_TXN_PREOP,FAIL_PLUGIN_OP_MODIFY);
}

static int
fail_betxnpreop_modrdn(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_TXN_PREOP,FAIL_PLUGIN_OP_MODRDN);
}

static int
fail_betxnpreop_delete(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_TXN_PREOP,FAIL_PLUGIN_OP_DELETE);
}

/* ============================= be txn postop ============================== */ 
static int
fail_betxnpostop_add(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_TXN_POSTOP,FAIL_PLUGIN_OP_ADD);
}

static int
fail_betxnpostop_modify(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_TXN_POSTOP,FAIL_PLUGIN_OP_MODIFY);
}

static int
fail_betxnpostop_modrdn(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_TXN_POSTOP,FAIL_PLUGIN_OP_MODRDN);
}

static int
fail_betxnpostop_delete(Slapi_PBlock *pb)
{
    return fail_return(FAIL_PLUGIN_TYPE_BE_TXN_POSTOP,FAIL_PLUGIN_OP_DELETE);
}