/*
 * Copyright (c) 2011 Alex Hornung <alex@alexhornung.com>.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Adam Hamsik.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include <sys/types.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <dev/disk/dm/netbsd-dm.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#include <libprop/proplib.h>
#include "libdm.h"

struct dm_task {
        int                     task_type;
        int                     was_enoent;
        prop_dictionary_t       dict;
        void                    *data_buffer;
};

struct dm_cmd {
        int             task_type;
        const char      *dm_cmd;
        uint32_t        cmd_version[3];
};

struct dm_cmd dm_cmds[] = {
        { DM_DEVICE_REMOVE,             "remove",       {4, 0, 0} },
        { DM_DEVICE_REMOVE_ALL,         "remove_all",   {4, 0, 0} },
        { DM_DEVICE_CREATE,             "create",       {4, 0, 0} },
        { DM_DEVICE_RELOAD,             "reload",       {4, 0, 0} },
        { DM_DEVICE_RESUME,             "resume",       {4, 0, 0} },
        { DM_DEVICE_SUSPEND,            "suspend",      {4, 0, 0} },
        { DM_DEVICE_CLEAR,              "clear",        {4, 0, 0} },
        { DM_DEVICE_LIST_VERSIONS,      "targets",      {4, 1, 0} },
        { DM_DEVICE_STATUS,             "status",       {4, 0, 0} },
        { DM_DEVICE_TABLE,              "table",        {4, 0, 0} },
        { DM_DEVICE_INFO,               "info",         {4, 0, 0} },
        { DM_DEVICE_DEPS,               "deps",         {4, 0, 0} },
        { DM_DEVICE_VERSION,            "version",      {4, 0, 0} },
        { DM_DEVICE_TARGET_MSG,         "message",      {4, 2, 0} },
        { DM_DEVICE_RENAME,             "rename",       {4, 0, 0} },
        { DM_DEVICE_LIST,               "names",        {4, 0, 0} },
        { 0,                            NULL,           {0, 0, 0} }
};

#define _LOG_DEBUG      0
#define _LOG_WARN       5
#define _LOG_ERR        10

static void _stderr_log(int level, const char *file,
    int line, const char *fmt, ...)
{
        const char *prefix;
        __va_list ap;

        switch (level) {
        case _LOG_DEBUG:
                prefix = "debug: ";
                break;
        case _LOG_WARN:
                prefix = "warning: ";
                break;
        case _LOG_ERR:
                prefix = "error: ";
                break;
        default:
                prefix = "";
        }

        fprintf(stderr, "libdm %s:%d: ", file, line);
        fprintf(stderr, "%s", prefix);

        __va_start(ap, fmt);
        vfprintf(stderr, fmt, ap);
        __va_end(ap);

        fprintf(stderr, "\n");

        return;
}

static dm_error_func_t dm_log = _stderr_log;

struct dm_task *
dm_task_create(int task_type)
{
        struct dm_task *dmt;
        struct dm_cmd *cmd = NULL;
        const char *task_cmd = NULL;
        prop_array_t pa;
        uint32_t flags = DM_EXISTS_FLAG;
        int i;

        for (i = 0; dm_cmds[i].dm_cmd != NULL; i++) {
                if (dm_cmds[i].task_type == task_type) {
                        cmd = &dm_cmds[i];
                        task_cmd = dm_cmds[i].dm_cmd;
                        break;
                }
        }

        if (task_cmd == NULL)
                return NULL;

        if (task_type == DM_DEVICE_TABLE)
                flags |= DM_STATUS_TABLE_FLAG;

        if (task_type == DM_DEVICE_SUSPEND)
                flags |= DM_SUSPEND_FLAG;

        if ((dmt = malloc(sizeof(*dmt))) == NULL)
                return NULL;

        memset(dmt, 0, sizeof(*dmt));

        dmt->task_type = task_type;
        dmt->was_enoent = 0;

        if ((dmt->dict = prop_dictionary_create()) == NULL)
                goto err;

        if ((pa = prop_array_create_with_capacity(3)) == NULL)
                goto err;

        if (!prop_array_add_uint32(pa, cmd->cmd_version[0])) {
                prop_object_release(pa);
                goto err;
        }

        if (!prop_array_add_uint32(pa, cmd->cmd_version[1])) {
                prop_object_release(pa);
                goto err;
        }

        if (!prop_array_add_uint32(pa, cmd->cmd_version[2])) {
                prop_object_release(pa);
                goto err;
        }

        if (!prop_dictionary_set(dmt->dict, DM_IOCTL_VERSION, pa)) {
                prop_object_release(pa);
                goto err;
        }

        prop_object_release(pa);

        if (!prop_dictionary_set_cstring(dmt->dict, DM_IOCTL_COMMAND,
            task_cmd))
                goto err;

        if (!prop_dictionary_set_uint32(dmt->dict, DM_IOCTL_FLAGS, flags))
                goto err;

        if ((pa = prop_array_create_with_capacity(5)) == NULL)
                goto err;

        if (!prop_dictionary_set(dmt->dict, DM_IOCTL_CMD_DATA, pa)) {
                prop_object_release(pa);
                goto err;
        }

        prop_object_release(pa);

        return dmt;
        /* NOT REACHED */

err:
        if (dmt->dict != NULL)
                prop_object_release(dmt->dict);
        if (dmt)
                free(dmt);

        return NULL;
}


void
dm_task_destroy(struct dm_task *dmt)
{
        if (dmt) {
                if (dmt->data_buffer)
                        free(dmt->data_buffer);

                if (dmt->dict) {
                        prop_object_release(dmt->dict);
                        dmt->dict = NULL;
                }

                free(dmt);
        }
}

int
dm_task_run(struct dm_task *dmt)
{
        struct dm_task *dmt_internal = NULL;
        prop_dictionary_t ret_pd = NULL;
        prop_array_t pa;
        int error;
        int fd;
        int need_unroll = 0;

        if ((fd = open("/dev/mapper/control", O_RDWR)) < -1)
                goto err;

        pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA);
        if ((dmt->task_type == DM_DEVICE_CREATE) && (pa != NULL) &&
            (prop_array_count(pa) > 0)) {
                /*
                 * Magic to separate a combined DM_DEVICE_CREATE+RELOAD int
                 * a DM_DEVICE_CREATE and a RELOAD with target table.
                 */

                if ((dmt_internal = dm_task_create(DM_DEVICE_CREATE)) == NULL)
                        goto err;
                if (!dm_task_set_name(dmt_internal, dm_task_get_name(dmt)))
                        goto err;
                if (!dm_task_set_uuid(dmt_internal, dm_task_get_uuid(dmt)))
                        goto err;
                if (!dm_task_run(dmt_internal))
                        goto err;
                dm_task_destroy(dmt_internal);
                dmt_internal = NULL;

                if (!prop_dictionary_set_cstring_nocopy(dmt->dict,
                    DM_IOCTL_COMMAND, "reload"))
                        goto unroll;
                dmt->task_type = DM_DEVICE_RELOAD;
                if ((error = prop_dictionary_sendrecv_ioctl(dmt->dict, fd,
                    NETBSD_DM_IOCTL, &ret_pd)) != 0) {
                        dm_log(_LOG_ERR, __FILE__, __LINE__, "ioctl failed: %d",
                            error);
                        goto unroll;
                }

                if (!prop_dictionary_set_cstring_nocopy(dmt->dict,
                    DM_IOCTL_COMMAND, "resume"))
                        goto unroll;
                dmt->task_type = DM_DEVICE_RESUME;
                /* Remove superfluous stuff */
                prop_dictionary_remove(dmt->dict, DM_IOCTL_CMD_DATA);

                need_unroll = 1;
        }

        if ((error = prop_dictionary_sendrecv_ioctl(dmt->dict, fd,
            NETBSD_DM_IOCTL, &ret_pd)) != 0) {
                if (((error == ENOENT) &&
                    ((dmt->task_type == DM_DEVICE_INFO) ||
                    (dmt->task_type == DM_DEVICE_STATUS)))) {
                        dmt->was_enoent = 1;
                        ret_pd = NULL;
                } else {
                        dm_log(_LOG_ERR, __FILE__, __LINE__, "ioctl failed: %d",
                            error);
                        if (need_unroll)
                                goto unroll;
                        else
                                goto err;
                }
        }

        if (ret_pd)
                prop_object_retain(ret_pd);

        prop_object_release(dmt->dict);
        dmt->dict = ret_pd;

        return 1;
        /* NOT REACHED */

unroll:
        prop_dictionary_remove(dmt->dict, DM_IOCTL_CMD_DATA);

        if (!prop_dictionary_set_cstring_nocopy(dmt->dict, DM_IOCTL_COMMAND,
            "remove")) {
                dm_log(_LOG_ERR, __FILE__, __LINE__, "couldn't unroll changes "
                    "in dm_task_run");
                goto err;
        }

        if ((error = prop_dictionary_sendrecv_ioctl(dmt->dict, fd,
            NETBSD_DM_IOCTL, &ret_pd)) != 0) {
                dm_log(_LOG_ERR, __FILE__, __LINE__, "ioctl failed: %d",
                    error);
                goto unroll;
        }
        dmt->task_type = DM_DEVICE_REMOVE;
        dm_task_run(dmt);

err:
        if (fd >= 0)
                close(fd);

        if (dmt_internal)
                dm_task_destroy(dmt_internal);

        return 0;
}

int
dm_task_set_name(struct dm_task *dmt, const char *name)
{
        return prop_dictionary_set_cstring(dmt->dict, DM_IOCTL_NAME,
            __DECONST(char *, name));
}


const char *
dm_task_get_name(struct dm_task *dmt)
{
        const char *name = NULL;

        prop_dictionary_get_cstring_nocopy(dmt->dict, DM_IOCTL_NAME, &name);

        return name;
}

int
dm_task_set_newname(struct dm_task *dmt, const char *newname)
{
        return prop_dictionary_set_cstring(dmt->dict, DM_DEV_NEWNAME,
            __DECONST(char *, newname));
}

int
dm_task_set_major(struct dm_task *dmt __unused, int major __unused)
{
        return 1;
}

int
dm_task_set_minor(struct dm_task *dmt, int minor)
{
        return prop_dictionary_set_int32(dmt->dict, DM_IOCTL_MINOR, minor);
}

int
dm_task_get_minor(struct dm_task *dmt)
{
        int minor = 0;

        minor = prop_dictionary_get_int32(dmt->dict, DM_IOCTL_MINOR, &minor);

        return minor;
}

int
dm_task_set_uuid(struct dm_task *dmt, const char *uuid)
{
        return prop_dictionary_set_cstring(dmt->dict, DM_IOCTL_UUID,
            __DECONST(char *,uuid));
}

const char *
dm_task_get_uuid(struct dm_task *dmt)
{
        const char *uuid = NULL;

        prop_dictionary_get_cstring_nocopy(dmt->dict, DM_IOCTL_UUID, &uuid);

        return uuid;
}

int
dm_task_add_target(struct dm_task *dmt, uint64_t start, size_t size,
    const char *target, const char *params)
{
        prop_dictionary_t target_dict = NULL;
        prop_array_t pa = NULL;

        if ((pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA)) == NULL)
                return 0;

        if ((target_dict = prop_dictionary_create()) == NULL)
                return 0;

        if (!prop_dictionary_set_uint64(target_dict, DM_TABLE_START, start))
                goto err;

        if (!prop_dictionary_set_uint64(target_dict, DM_TABLE_LENGTH, size))
                goto err;

        if (!prop_dictionary_set_cstring(target_dict, DM_TABLE_TYPE, target))
                goto err;

        if (!prop_dictionary_set_cstring(target_dict, DM_TABLE_PARAMS, params))
                goto err;

        if (!prop_array_add(pa, target_dict))
                goto err;

        prop_object_release(target_dict);

        return 1;
        /* NOT REACHED */

err:
        prop_object_release(target_dict);
        return 0;
}

int
dm_task_set_sector(struct dm_task *dmt, uint64_t sector)
{
        return prop_dictionary_set_uint64(dmt->dict, DM_MESSAGE_SECTOR,
            sector);
}

int
dm_task_set_message(struct dm_task *dmt, const char *msg)
{
        return prop_dictionary_set_cstring(dmt->dict, DM_MESSAGE_STR, msg);
}

int
dm_task_set_ro(struct dm_task *dmt)
{
        uint32_t flags = 0;

        prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_FLAGS, &flags);
        flags |= DM_READONLY_FLAG;

        return prop_dictionary_set_uint32(dmt->dict, DM_IOCTL_FLAGS, flags);
}

int
dm_task_no_open_count(struct dm_task *dmt __unused)
{
        /*
         * nothing else needed, since we don't have performance problems when
         * getting the open count.
         */
        return 1;
}

int
dm_task_query_inactive_table(struct dm_task *dmt)
{
        uint32_t flags = 0;

        prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_FLAGS, &flags);
        flags |= DM_QUERY_INACTIVE_TABLE_FLAG;

        return prop_dictionary_set_uint32(dmt->dict, DM_IOCTL_FLAGS, flags);
}

int
dm_task_set_read_ahead(struct dm_task *dmt __unused,
    uint32_t read_ahead __unused)
{
        /* We don't support readahead */
        return 1;
}

int
dm_task_get_read_ahead(struct dm_task *dmt __unused, uint32_t *read_ahead)
{
        *read_ahead = 0;

        return 1;
}

int
dm_task_secure_data(struct dm_task *dmt)
{
        /* XXX: needs kernel support */
        uint32_t flags = 0;

        prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_FLAGS, &flags);
        flags |= DM_SECURE_DATA_FLAG;

        return prop_dictionary_set_uint32(dmt->dict, DM_IOCTL_FLAGS, flags);
}

int
dm_task_get_info(struct dm_task *dmt, struct dm_info *dmi)
{
        uint32_t flags = 0;

        memset(dmi, 0, sizeof(struct dm_info));

        /* Hack due to the way Linux dm works */
        if (dmt->was_enoent) {
                dmi->exists = 0;
                return 1;
                /* NOT REACHED */
        }

        if (!prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_FLAGS,
            &flags))
                return 0;

        prop_dictionary_get_int32(dmt->dict, DM_IOCTL_OPEN, &dmi->open_count);

        prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_TARGET_COUNT,
            &dmi->target_count);

        prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_EVENT, &dmi->event_nr);

        prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_MINOR, &dmi->minor);

        dmi->major = dm_get_major();

        dmi->read_only = (flags & DM_READONLY_FLAG);
        dmi->exists = (flags & DM_EXISTS_FLAG);
        dmi->suspended = (flags & DM_SUSPEND_FLAG);
        dmi->live_table = (flags & DM_ACTIVE_PRESENT_FLAG);
        dmi->inactive_table = (flags & DM_INACTIVE_PRESENT_FLAG);

        return 1;
}

int
dm_task_get_driver_version(struct dm_task *dmt, char *ver, size_t ver_sz)
{
        prop_array_t pa_ver;
        uint32_t maj = 0, min = 0, patch = 0;

        if ((pa_ver = prop_dictionary_get(dmt->dict, DM_IOCTL_VERSION)) == NULL)
                return 0;

        if (!prop_array_get_uint32(pa_ver, 0, &maj))
                return 0;

        if (!prop_array_get_uint32(pa_ver, 1, &min))
                return 0;

        if (!prop_array_get_uint32(pa_ver, 2, &patch))
                return 0;

        snprintf(ver, ver_sz, "%u.%u.%u", maj, min, patch);

        return 1;
}

struct dm_deps *
dm_task_get_deps(struct dm_task *dmt)
{
        prop_object_iterator_t iter;
        prop_array_t pa;
        prop_object_t po;
        struct dm_deps *deps;

        unsigned int count;
        int i;

        if ((pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA)) == NULL)
                return NULL;

        count = prop_array_count(pa);

        if (dmt->data_buffer != NULL)
                free(dmt->data_buffer);

        if ((dmt->data_buffer = malloc(sizeof(struct dm_deps) +
            (count * sizeof(uint64_t)))) == NULL)
                return NULL;

        if ((iter = prop_array_iterator(pa)) == NULL)
                return NULL;

        deps = (struct dm_deps *)dmt->data_buffer;
        memset(deps, 0, sizeof(struct dm_deps) + (count * sizeof(uint64_t)));
        i = 0;
        while ((po = prop_object_iterator_next(iter)) != NULL)
                deps->deps[i++] = prop_number_unsigned_integer_value(po);

        deps->count = (uint32_t)count;

        prop_object_iterator_release(iter);

        return deps;
}

struct dm_versions *
dm_task_get_versions(struct dm_task *dmt)
{
        prop_object_iterator_t iter;
        prop_dictionary_t target_dict;
        prop_array_t pa, pa_ver;
        struct dm_versions *vers;

        unsigned int count;
        int i, j;

        if ((pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA)) == NULL)
                return NULL;

        count = prop_array_count(pa);

        if (dmt->data_buffer != NULL)
                free(dmt->data_buffer);

        if ((dmt->data_buffer = malloc(sizeof(struct dm_versions) * count))
            == NULL)
                return NULL;

        if ((iter = prop_array_iterator(pa)) == NULL)
                return NULL;

        vers = (struct dm_versions *)dmt->data_buffer;
        memset(vers, 0, sizeof(struct dm_versions) * count);
        i = 0;
        while ((target_dict = prop_object_iterator_next(iter)) != NULL) {
                vers[i].next = sizeof(struct dm_versions);
                prop_dictionary_get_cstring_nocopy(target_dict,
                    DM_TARGETS_NAME, &vers[i].name);

                pa_ver = prop_dictionary_get(target_dict, DM_TARGETS_VERSION);
                for (j = 0; j < 3; j++)
                        prop_array_get_uint32(pa_ver, j, &vers[i].version[j]);

                ++i;
        }

        /* Finish the array */
        vers[i-1].next = 0;

        prop_object_iterator_release(iter);

        return (struct dm_versions *)dmt->data_buffer;
}

struct dm_names *
dm_task_get_names(struct dm_task *dmt)
{
        prop_object_iterator_t iter;
        prop_dictionary_t devs_dict;
        prop_array_t pa;
        struct dm_names *names;

        unsigned int count;
        int i;

        if ((pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA)) == NULL)
                return NULL;

        count = prop_array_count(pa);

        if (dmt->data_buffer != NULL)
                free(dmt->data_buffer);

        if ((dmt->data_buffer = malloc(sizeof(struct dm_names) * count))
            == NULL)
                return NULL;

        if ((iter = prop_array_iterator(pa)) == NULL)
                return NULL;

        names = (struct dm_names *)dmt->data_buffer;
        memset(names, 0, sizeof(struct dm_names) * count);
        i = 0;
        while ((devs_dict = prop_object_iterator_next(iter)) != NULL) {
                names[i].next = sizeof(struct dm_names);

                prop_dictionary_get_cstring_nocopy(devs_dict,
                    DM_DEV_NAME, &names[i].name);

                prop_dictionary_get_uint64(devs_dict, DM_DEV_DEV,
                    &names[i].dev);

                ++i;
        }

        /* Finish the array */
        names[i-1].next = 0;

        prop_object_iterator_release(iter);

        return (struct dm_names *)dmt->data_buffer;
}

int
dm_task_update_nodes(void)
{

        /* nothing else needed */
        return 1;
}

void *
dm_get_next_target(struct dm_task *dmt, void *cur, uint64_t *startp,
    uint64_t *lengthp, char **target_type, char **params)
{
        prop_object_iterator_t  iter;
        prop_dictionary_t target_dict;
        prop_array_t pa;
        uint64_t ulength;
        unsigned int count;

        if ((pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA)) == NULL)
                return NULL;

        count = prop_array_count(pa);

        if (cur == NULL) {
                if ((iter = prop_array_iterator(pa)) == NULL)
                        return NULL;
        } else {
                iter = (prop_object_iterator_t)cur;
        }

        /* Get the next target dict */
        if ((target_dict = prop_object_iterator_next(iter)) == NULL) {
                /* If there are no more target dicts, release the iterator */
                goto err;
        }

        if (!prop_dictionary_get_cstring_nocopy(target_dict, DM_TABLE_TYPE,
            (const char **)target_type))
                goto err;

        /*
         * Ugly __DECONST and (const char **) casts due to the linux prototype
         * of this function.
         */
        *params = __DECONST(char *, "");
        prop_dictionary_get_cstring_nocopy(target_dict, DM_TABLE_PARAMS,
            (const char **)params);

        if (!prop_dictionary_get_uint64(target_dict, DM_TABLE_START, startp))
                goto err;

        if (!prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH, &ulength))
                goto err;

        *lengthp = (size_t)ulength;

        /* If we are at the last element, make sure we return NULL */
        if (target_dict == prop_array_get(pa, count-1))
                goto err;

        return (void *)iter;
        /* NOT REACHED */

err:
        if (iter != NULL)
                prop_object_iterator_release(iter);

        return NULL;
}

uint32_t
dm_get_major(void)
{
        struct stat sb;

        if (stat("/dev/mapper/control", &sb) < 0)
                return 0;

        return (uint32_t)major(sb.st_dev);
}

int
dm_is_dm_major(uint32_t major)
{
        return (major == dm_get_major());
}

const char *
dm_dir(void)
{
        return "/dev/mapper";
}

void
dm_udev_set_sync_support(int sync_udev __unused)
{
        return;
}

int
dm_task_set_cookie(struct dm_task *dmt __unused, uint32_t *cookie __unused,
    uint16_t udev_flags __unused)
{
        return 1;
}

int
dm_udev_wait(uint32_t cookie __unused)
{
        return 1;
}

void
dm_lib_release(void)
{
        return;
}

int
dm_log_init(dm_error_func_t fn)
{
        if (fn)
                dm_log = fn;
        return 1;
}

int
dm_log_init_verbose(int verbose __unused)
{
        return 1;
}

/* XXX: unused in kernel */
int
dm_task_set_uid(struct dm_task *dmt, uid_t uid)
{
        return prop_dictionary_set_uint32(dmt->dict, DM_DEV_UID,
            (uint32_t)uid);
}

int
dm_task_set_gid(struct dm_task *dmt, gid_t gid)
{
        return prop_dictionary_set_uint32(dmt->dict, DM_DEV_GID,
            (uint32_t)gid);
}

int
dm_task_set_mode(struct dm_task *dmt, mode_t mode)
{
        return prop_dictionary_set_uint32(dmt->dict, DM_DEV_MODE,
            (uint32_t)mode);
}

int
dm_task_no_flush(struct dm_task *dmt __unused)
{
        uint32_t flags = 0;

        prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_FLAGS, &flags);
        flags |= DM_NOFLUSH_FLAG;

        return prop_dictionary_set_uint32(dmt->dict, DM_IOCTL_FLAGS, flags);
}

int
dm_task_skip_lockfs(struct dm_task *dmt __unused)
{
        uint32_t flags = 0;

        prop_dictionary_get_uint32(dmt->dict, DM_IOCTL_FLAGS, &flags);
        flags |= DM_SKIP_LOCKFS_FLAG;

        return prop_dictionary_set_uint32(dmt->dict, DM_IOCTL_FLAGS, flags);
}

int dm_task_set_geometry(struct dm_task *dmt __unused,
    const char *cylinders __unused, const char *heads __unused,
    const char *sectors __unused, const char *start __unused)
{
        return 1;
}

/*****************************************************************************/
/********************** DragonFly-specific extensions ************************/
/*****************************************************************************/
void *
dm_get_next_version(struct dm_task *dmt, void *cur, const char **target_type,
    uint32_t *target_ver)
{
        prop_object_iterator_t iter;
        prop_dictionary_t target_dict;
        prop_array_t pa, pa_ver;
        unsigned int count;
        int j;

        if ((pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA)) == NULL)
                return NULL;

        count = prop_array_count(pa);

        if (cur == NULL) {
                if ((iter = prop_array_iterator(pa)) == NULL)
                        return NULL;
        } else {
                iter = (prop_object_iterator_t)cur;
        }

        /* Get the next target dict */
        if ((target_dict = prop_object_iterator_next(iter)) == NULL) {
                /* If there are no more target dicts, release the iterator */
                goto err;
        }

        if (!prop_dictionary_get_cstring_nocopy(target_dict, DM_TARGETS_NAME,
            target_type))
                goto err;

        if ((pa_ver = prop_dictionary_get(target_dict, DM_TARGETS_VERSION))
            == NULL)
                goto err;

        for (j = 0; j < 3; j++) {
                if (!prop_array_get_uint32(pa_ver, j, &target_ver[j]))
                        goto err;
        }

        /* If we are at the last element, make sure we return NULL */
        if (target_dict == prop_array_get(pa, count-1))
                goto err;

        return (void *)iter;
        /* NOT REACHED */

err:
        if (iter != NULL)
                prop_object_iterator_release(iter);

        return NULL;
}

void *
dm_get_next_dep(struct dm_task *dmt, void *cur, uint64_t *dep)
{
        prop_object_iterator_t iter;
        prop_object_t po;
        prop_array_t pa;
        unsigned int count;

        *dep = 0;

        if ((pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA)) == NULL)
                return NULL;

        count = prop_array_count(pa);

        if (cur == NULL) {
                if ((iter = prop_array_iterator(pa)) == NULL)
                        return NULL;
        } else {
                iter = (prop_object_iterator_t)cur;
        }

        /* Get the next target dict */
        if ((po = prop_object_iterator_next(iter)) == NULL) {
                /* If there are no more target dicts, release the iterator */
                goto err;
        }

        *dep = prop_number_unsigned_integer_value(po);

        /* If we are at the last element, make sure we return NULL */
        if (po == prop_array_get(pa, count-1))
                goto err;

        return (void *)iter;
        /* NOT REACHED */

err:
        if (iter != NULL)
                prop_object_iterator_release(iter);

        return NULL;
}

void *
dm_get_next_name(struct dm_task *dmt, void *cur, const char **name,
    uint64_t *dev)
{
        prop_object_iterator_t iter;
        prop_dictionary_t devs_dict;
        prop_array_t pa;
        unsigned int count;

        if ((pa = prop_dictionary_get(dmt->dict, DM_IOCTL_CMD_DATA)) == NULL)
                return NULL;

        count = prop_array_count(pa);


        if (cur == NULL) {
                if ((iter = prop_array_iterator(pa)) == NULL)
                        return NULL;
        } else {
                iter = (prop_object_iterator_t)cur;
        }

        /* Get the next dev dict */
        if ((devs_dict = prop_object_iterator_next(iter)) == NULL) {
                /* If there are no more dev dicts, release the iterator */
                goto err;
        }

        if (!prop_dictionary_get_cstring_nocopy(devs_dict, DM_DEV_NAME, name))
                goto err;

        if (!prop_dictionary_get_uint64(devs_dict, DM_DEV_DEV, dev))
                goto err;

        /* If we are at the last element, make sure we return NULL */
        if (devs_dict == prop_array_get(pa, count-1))
                goto err;

        return (void *)iter;
        /* NOT REACHED */

err:
        if (iter != NULL)
                prop_object_iterator_release(iter);

        return NULL;

}