/*

 * Copyright (C) 2016  Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 * Author: Vratislav Podzimek <vpodzime@redhat.com>

 */

#include <string.h>

#include <parted/parted.h>

#include <ctype.h>

#include <stdlib.h>

#include <math.h>

#include <inttypes.h>

#include <unistd.h>

#include <sys/file.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <linux/fs.h>

#include <blockdev/utils.h>

#include <part_err.h>

#include "part.h"

#include "check_deps.h"

/**

 * SECTION: part

 * @short_description: plugin for operations with partition tables

 * @title: Part

 * @include: part.h

 *

 * A plugin for operations with partition tables. Currently supported table

 * (disk label) types are MBR and GPT. See the functions below to get an

 * overview of which operations are supported. If there's anything missing,

 * please don't hesitate to report it as this plugin (just like all the others)

 * is subject to future development and enhancements.

 *

 * This particular implementation of the part plugin uses libparted for

 * manipulations of both the MBR and GPT disk label types together with the

 * sgdisk utility for some extra GPT-specific features libparted doesn't

 * support. In the future, there's likely to be another implementation of this

 * plugin based on libfdisk which provides full support for both MBR and GPT

 * tables (and possibly some others).

 */

/**

 * bd_part_error_quark: (skip)

 */

GQuark bd_part_error_quark (void)

{

    return g_quark_from_static_string ("g-bd-part-error-quark");

}

BDPartSpec* bd_part_spec_copy (BDPartSpec *data) {

    if (data == NULL)

        return NULL;

    BDPartSpec *ret = g_new0 (BDPartSpec, 1);

    ret->path = g_strdup (data->path);

    ret->name = g_strdup (data->name);

    ret->type_guid = g_strdup (data->type_guid);

    ret->type = data->type;

    ret->start = data->start;

    ret->size = data->size;

    return ret;

}

void bd_part_spec_free (BDPartSpec *data) {

    if (data == NULL)

        return;

    g_free (data->path);

    g_free (data->name);

    g_free (data->type_guid);

    g_free (data);

}

BDPartDiskSpec* bd_part_disk_spec_copy (BDPartDiskSpec *data) {

    if (data == NULL)

        return NULL;

    BDPartDiskSpec *ret = g_new0 (BDPartDiskSpec, 1);

    ret->path = g_strdup (data->path);

    ret->table_type = data->table_type;

    ret->size = data->size;

    ret->sector_size = data->sector_size;

    ret->flags = data->flags;

    return ret;

}

void bd_part_disk_spec_free (BDPartDiskSpec *data) {

    if (data == NULL)

        return;

    g_free (data->path);

    g_free (data);

}

/**

 * set_parted_error: (skip)

 *

 * Set error from the parted error stored in 'error_msg'. In case there is none,

 * the error is set up with an empty string. Otherwise it is set up with the

 * parted's error message and is a subject to later g_prefix_error() call.

 *

 * Returns: whether there was some message from parted or not

 */

static gboolean set_parted_error (GError **error, BDPartError type) {

    gchar *error_msg = NULL;

    error_msg = bd_get_error_msg ();

    if (error_msg) {

        g_set_error (error, BD_PART_ERROR, type,

                     " (%s)", error_msg);

        g_free (error_msg);

        error_msg = NULL;

        return TRUE;

    } else {

        g_set_error_literal (error, BD_PART_ERROR, type, "");

        return FALSE;

    }

}

static volatile guint avail_deps = 0;

static GMutex deps_check_lock;

#define DEPS_SGDISK 0

#define DEPS_SGDISK_MASK (1 << DEPS_SGDISK)

#define DEPS_SFDISK 1

#define DEPS_SFDISK_MASK (1 << DEPS_SFDISK)

#define DEPS_LAST 2

static const UtilDep deps[DEPS_LAST] = {

    {"sgdisk", "0.8.6", NULL, "GPT fdisk \\(sgdisk\\) version ([\\d\\.]+)"},

    {"sfdisk", NULL, NULL, NULL},

};

/**

 * bd_part_check_deps:

 *

 * Returns: whether the plugin's runtime dependencies are satisfied or not

 *

 * Function checking plugin's runtime dependencies.

 *

 */

gboolean bd_part_check_deps (void) {

    GError *error = NULL;

    guint i = 0;

    gboolean status = FALSE;

    gboolean ret = TRUE;

    for (i=0; i < DEPS_LAST; i++) {

        status = bd_utils_check_util_version (deps[i].name, deps[i].version,

                                              deps[i].ver_arg, deps[i].ver_regexp, &error);

        if (!status)

            g_warning ("%s", error->message);

        else

            g_atomic_int_or (&avail_deps, 1 << i);

        g_clear_error (&error);

        ret = ret && status;

    }

    if (!ret)

        g_warning("Cannot load the part plugin");

    return ret;

}

/**

 * bd_part_init:

 *

 * Initializes the plugin. **This function is called automatically by the

 * library's initialization functions.**

 *

 */

gboolean bd_part_init (void) {

    ped_exception_set_handler ((PedExceptionHandler*) bd_exc_handler);

    return TRUE;

}

/**

 * bd_part_close:

 *

 * Cleans up after the plugin. **This function is called automatically by the

 * library's functions that unload it.**

 *

 */

void bd_part_close (void) {

    ped_exception_set_handler (NULL);

}

/**

 * bd_part_is_tech_avail:

 * @tech: the queried tech

 * @mode: a bit mask of queried modes of operation (#BDPartTechMode) for @tech

 * @error: (out): place to store error (details about why the @tech-@mode combination is not available)

 *

 * Returns: whether the @tech-@mode combination is available -- supported by the

 *          plugin implementation and having all the runtime dependencies available

 */

gboolean bd_part_is_tech_avail (BDPartTech tech, guint64 mode, GError **error) {

    switch (tech) {

    case BD_PART_TECH_MBR:

        /* all MBR-mode combinations are supported by this implementation of the

         * plugin, nothing extra is needed */

        return TRUE;

    case BD_PART_TECH_GPT:

        if (mode & (BD_PART_TECH_MODE_MODIFY_PART|BD_PART_TECH_MODE_QUERY_PART))

            return check_deps (&avail_deps, DEPS_SGDISK_MASK|DEPS_SFDISK_MASK,

                               deps, DEPS_LAST, &deps_check_lock, error);

        else

            return TRUE;

    default:

        g_set_error (error, BD_PART_ERROR, BD_PART_ERROR_TECH_UNAVAIL, "Unknown technology");

        return FALSE;

    }

}

static const gchar *table_type_str[BD_PART_TABLE_UNDEF] = {"msdos", "gpt"};

static gboolean disk_commit (PedDisk *disk, const gchar *path, GError **error) {

    gint ret = 0;

    gint dev_fd = 0;

    guint num_tries = 1;

    /* XXX: try to grab a lock for the device so that udev doesn't step in

       between the two operations we need to perform (see below) with its

       BLKRRPART ioctl() call which makes the device busy */

    dev_fd = open (disk->dev->path, O_RDONLY|O_CLOEXEC);

    if (dev_fd >= 0) {

        ret = flock (dev_fd, LOCK_SH|LOCK_NB);

        while ((ret != 0) && (num_tries <= 5)) {

            g_usleep (100 * 1000); /* microseconds */

            ret = flock (dev_fd, LOCK_SH|LOCK_NB);

            num_tries++;

        }

    }

    /* Just continue even in case we don't get the lock, there's still a

       chance things will just work. If not, an error will be reported

       anyway with no harm. */

    /* XXX: Sometimes it happens that when we try to commit the partition table

       to disk below, libparted kills the process due to the

       assert(disk->dev->open_count > 0). This looks like a bug to me, but we

       have no reproducer for it. Let's just try to (re)open the device in such

       cases. It is later closed by the ped_device_destroy() call. */

    if (disk->dev->open_count <= 0)

        ped_device_open (disk->dev);

    ret = ped_disk_commit_to_dev (disk);

    if (ret == 0) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to commit changes to device '%s'", path);

        if (dev_fd >= 0)

            close (dev_fd);

        return FALSE;

    }

    ret = ped_disk_commit_to_os (disk);

    if (ret == 0) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to inform OS about changes on the '%s' device", path);

        if (dev_fd >= 0)

            close (dev_fd);

        return FALSE;

    }

    if (dev_fd >= 0)

        close (dev_fd);

    return TRUE;

}

/**

 * bd_part_create_table:

 * @disk: path of the disk block device to create partition table on

 * @type: type of the partition table to create

 * @ignore_existing: whether to ignore/overwrite the existing table or not

 *                   (reports an error if %FALSE and there's some table on @disk)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether the partition table was successfully created or not

 *

 * Tech category: %BD_PART_TECH_MODE_CREATE_TABLE + the tech according to @type

 */

gboolean bd_part_create_table (const gchar *disk, BDPartTableType type, gboolean ignore_existing, GError **error) {

    PedDevice *dev = NULL;

    PedDisk *ped_disk = NULL;

    PedDiskType *disk_type = NULL;

    gboolean ret = FALSE;

    guint64 progress_id = 0;

    gchar *msg = NULL;

    msg = g_strdup_printf ("Starting creation of a new partition table on '%s'", disk);

    progress_id = bd_utils_report_started (msg);

    g_free (msg);

    dev = ped_device_get (disk);

    if (!dev) {

        set_parted_error (error, BD_PART_ERROR_INVAL);

        g_prefix_error (error, "Device '%s' invalid or not existing", disk);

        bd_utils_report_finished (progress_id, (*error)->message);

        return FALSE;

    }

    if (!ignore_existing) {

        ped_disk = ped_disk_new (dev);

        if (ped_disk) {

            /* no parted error */

            g_set_error (error, BD_PART_ERROR, BD_PART_ERROR_EXISTS,

                         "Device '%s' already contains a partition table", disk);

            ped_disk_destroy (ped_disk);

            ped_device_destroy (dev);

            bd_utils_report_finished (progress_id, (*error)->message);

            return FALSE;

        }

    }

    disk_type = ped_disk_type_get (table_type_str[type]);

    ped_disk = ped_disk_new_fresh (dev, disk_type);

    if (!ped_disk) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to create a new partition table of type '%s' on device '%s'",

                        table_type_str[type], disk);

        ped_device_destroy (dev);

        bd_utils_report_finished (progress_id, (*error)->message);

        return FALSE;

    }

    /* commit changes to disk */

    ret = disk_commit (ped_disk, disk, error);

    ped_disk_destroy (ped_disk);

    ped_device_destroy (dev);

    bd_utils_report_finished (progress_id, "Completed");

    /* just return what we got (error may be set) */

    return ret;

}

static gchar* get_part_type_guid_and_gpt_flags (const gchar *device, int part_num, guint64 *flags, GError **error) {

    const gchar *args[4] = {"sgdisk", NULL, device, NULL};

    gchar *output = NULL;

    gchar **lines = NULL;

    gchar **line_p = NULL;

    gchar *guid_line = NULL;

    gchar *attrs_line = NULL;

    gchar *guid_start = NULL;

    gchar *attrs_start = NULL;

    guint64 flags_mask = 0;

    gboolean success = FALSE;

    gchar *space = NULL;

    gchar *ret = NULL;

    if (!check_deps (&avail_deps, DEPS_SGDISK_MASK, deps, DEPS_LAST, &deps_check_lock, error))

        return FALSE;

    args[1] = g_strdup_printf ("-i%d", part_num);

    success = bd_utils_exec_and_capture_output (args, NULL, &output, error);

    g_free ((gchar *) args[1]);

    if (!success)

        return FALSE;

    lines = g_strsplit (output, "\n", 0);

    g_free (output);

    for (line_p=lines; *line_p && (!guid_line || !attrs_line); line_p++) {

        if (g_str_has_prefix (*line_p, "Partition GUID code: "))

            guid_line = *line_p;

        else if (g_str_has_prefix (*line_p, "Attribute flags: "))

            attrs_line = *line_p;

    }

    if (!guid_line && !attrs_line) {

        g_strfreev (lines);

        return NULL;

    }

    if (guid_line) {

        guid_start = guid_line + 21; /* strlen("Partition GUID...") */

        space = strchr (guid_start, ' '); /* find the first space after the GUID */

        if (space)

            *space = '\0';

        ret = g_strdup (guid_start);

    }

    if (attrs_line) {

        attrs_start = attrs_line + 17; /* strlen("Attribute flags: ") */

        flags_mask = strtoull (attrs_start, NULL, 16);

        if (flags_mask & 1) /* 1 << 0 */

            *flags |= BD_PART_FLAG_GPT_SYSTEM_PART;

        if (flags_mask & 4) /* 1 << 2 */

            *flags |= BD_PART_FLAG_LEGACY_BOOT;

        if (flags_mask & 0x1000000000000000) /* 1 << 60 */

            *flags |= BD_PART_FLAG_GPT_READ_ONLY;

        if (flags_mask & 0x4000000000000000) /* 1 << 62 */

            *flags |= BD_PART_FLAG_GPT_HIDDEN;

        if (flags_mask & 0x8000000000000000) /* 1 << 63 */

            *flags |= BD_PART_FLAG_GPT_NO_AUTOMOUNT;

    }

    g_strfreev (lines);

    return ret;

}

static BDPartSpec* get_part_spec (PedDevice *dev, PedDisk *disk, PedPartition *part, GError **error) {

    BDPartSpec *ret = NULL;

    PedPartitionFlag flag = PED_PARTITION_FIRST_FLAG;

    ret = g_new0 (BDPartSpec, 1);

    /* the no-partition "partitions" have num equal to -1 which never really

       creates a valid block device path, so let's just not set path to

       nonsense */

    if (part->num != -1) {

        if (isdigit (dev->path[strlen(dev->path) - 1]))

            ret->path = g_strdup_printf ("%sp%d", dev->path, part->num);

        else

            ret->path = g_strdup_printf ("%s%d", dev->path, part->num);

    }

    if (ped_partition_is_active (part) && disk->type->features & PED_DISK_TYPE_PARTITION_NAME)

        ret->name = g_strdup (ped_partition_get_name (part));

    if (g_strcmp0 (disk->type->name, "gpt") == 0) {

        ret->type_guid = get_part_type_guid_and_gpt_flags (dev->path, part->num, &(ret->flags), error);

        if (!ret->type_guid && *error) {

            bd_part_spec_free (ret);

            return NULL;

        }

    }

    ret->type = (BDPartType) part->type;

    ret->start = part->geom.start * dev->sector_size;

    ret->size = part->geom.length * dev->sector_size;

    for (flag=PED_PARTITION_FIRST_FLAG; flag

        /* beware of partition types that segfault when asked for flags */

        if ((part->type <= PED_PARTITION_EXTENDED) &&

            ped_partition_is_flag_available (part, flag) && ped_partition_get_flag (part, flag))

            /* our flags are 1s shifted to the bit determined by parted's flags

             * (i.e. 1 << 3 instead of 3, etc.) */

            ret->flags = ret->flags | (1 << flag);

    }

    return ret;

}

/**

 * bd_part_get_part_spec:

 * @disk: disk to remove the partition from

 * @part: partition to get spec for

 * @error: (out): place to store error (if any)

 *

 * Returns: (transfer full): spec of the @part partition from @disk or %NULL in case of error

 *

 * Tech category: %BD_PART_TECH_MODE_QUERY_PART + the tech according to the partition table type

 */

BDPartSpec* bd_part_get_part_spec (const gchar *disk, const gchar *part, GError **error) {

    PedDevice *dev = NULL;

    PedDisk *ped_disk = NULL;

    PedPartition *ped_part = NULL;

    const gchar *part_num_str = NULL;

    gint part_num = 0;

    BDPartSpec *ret = NULL;

    if (!part || (part && (*part == '\0'))) {

        g_set_error (error, BD_PART_ERROR, BD_PART_ERROR_INVAL,

                     "Invalid partition path given: '%s'", part);

        return NULL;

    }

    dev = ped_device_get (disk);

    if (!dev) {

        set_parted_error (error, BD_PART_ERROR_INVAL);

        g_prefix_error (error, "Device '%s' invalid or not existing", disk);

        return NULL;

    }

    ped_disk = ped_disk_new (dev);

    if (!ped_disk) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to read partition table on device '%s'", disk);

        ped_device_destroy (dev);

        return NULL;

    }

    part_num_str = part + (strlen (part) - 1);

    while (isdigit (*part_num_str) || (*part_num_str == '-')) {

        part_num_str--;

    }

    part_num_str++;

    part_num = atoi (part_num_str);

    if (part_num == 0) {

        g_set_error (error, BD_PART_ERROR, BD_PART_ERROR_INVAL,

                     "Invalid partition path given: '%s'. Cannot extract partition number", part);

        ped_disk_destroy (ped_disk);

        ped_device_destroy (dev);

        return NULL;

    }

    ped_part = ped_disk_get_partition (ped_disk, part_num);

    if (!ped_part) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to get partition '%d' on device '%s'", part_num, disk);

        ped_disk_destroy (ped_disk);

        ped_device_destroy (dev);

        return NULL;

    }

    ret = get_part_spec (dev, ped_disk, ped_part, error);

    /* the partition gets destroyed together with the disk */

    ped_disk_destroy (ped_disk);

    ped_device_destroy (dev);

    return ret;

}

/**

 * bd_part_get_part_by_pos:

 * @disk: disk to remove the partition from

 * @position: position (in bytes) determining the partition

 * @error: (out): place to store error (if any)

 *

 * Returns: (transfer full): spec of the partition from @disk spanning over the @position or %NULL if no such

 *          partition exists or in case of error (@error is set)

 *

 * Tech category: %BD_PART_TECH_MODE_QUERY_PART + the tech according to the partition table type

 */

BDPartSpec* bd_part_get_part_by_pos (const gchar *disk, guint64 position, GError **error) {

    PedDevice *dev = NULL;

    PedDisk *ped_disk = NULL;

    PedPartition *ped_part = NULL;

    BDPartSpec *ret = NULL;

    PedSector sector = 0;

    dev = ped_device_get (disk);

    if (!dev) {

        set_parted_error (error, BD_PART_ERROR_INVAL);

        g_prefix_error (error, "Device '%s' invalid or not existing", disk);

        return NULL;

    }

    ped_disk = ped_disk_new (dev);

    if (!ped_disk) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to read partition table on device '%s'", disk);

        ped_device_destroy (dev);

        return NULL;

    }

    sector = (PedSector) (position / dev->sector_size);

    ped_part = ped_disk_get_partition_by_sector (ped_disk, sector);

    if (!ped_part) {

        if (set_parted_error (error, BD_PART_ERROR_FAIL))

            g_prefix_error (error, "Failed to get partition at position %"G_GUINT64_FORMAT" (device '%s')",

                            position, disk);

        else

            /* no such partition, but no error */

            g_clear_error (error);

        ped_disk_destroy (ped_disk);

        ped_device_destroy (dev);

        return NULL;

    }

    ret = get_part_spec (dev, ped_disk, ped_part, error);

    /* the partition gets destroyed together with the disk */

    ped_disk_destroy (ped_disk);

    ped_device_destroy (dev);

    return ret;

}

/**

 * bd_part_get_disk_spec:

 * @disk: disk to get information about

 * @error: (out): place to store error (if any)

 *

 * Returns: (transfer full): information about the given @disk or %NULL (in case of error)

 *

 * Tech category: %BD_PART_TECH_MODE_QUERY_TABLE + the tech according to the partition table type

 */

BDPartDiskSpec* bd_part_get_disk_spec (const gchar *disk, GError **error) {

    PedDevice *dev = NULL;

    BDPartDiskSpec *ret = NULL;

    PedConstraint *constr = NULL;

    PedDisk *ped_disk = NULL;

    BDPartTableType type = BD_PART_TABLE_UNDEF;

    gboolean found = FALSE;

    dev = ped_device_get (disk);

    if (!dev) {

        set_parted_error (error, BD_PART_ERROR_INVAL);

        g_prefix_error (error, "Device '%s' invalid or not existing", disk);

        return NULL;

    }

    ret = g_new0 (BDPartDiskSpec, 1);

    ret->path = g_strdup (dev->path);

    ret->sector_size = (guint64) dev->sector_size;

    constr = ped_device_get_constraint (dev);

    ret->size = (constr->max_size - 1) * dev->sector_size;

    ped_constraint_destroy (constr);

    ped_disk = ped_disk_new (dev);

    if (ped_disk) {

        for (type=BD_PART_TABLE_MSDOS; !found && type < BD_PART_TABLE_UNDEF; type++) {

            if (g_strcmp0 (ped_disk->type->name, table_type_str[type]) == 0) {

                ret->table_type = type;

                found = TRUE;

            }

        }

        if (!found)

            ret->table_type = BD_PART_TABLE_UNDEF;

        if (ped_disk_is_flag_available (ped_disk, PED_DISK_GPT_PMBR_BOOT) &&

            ped_disk_get_flag (ped_disk, PED_DISK_GPT_PMBR_BOOT))

            ret->flags = BD_PART_DISK_FLAG_GPT_PMBR_BOOT;

        ped_disk_destroy (ped_disk);

    } else {

        ret->table_type = BD_PART_TABLE_UNDEF;

        ret->flags = 0;

    }

    ped_device_destroy (dev);

    return ret;

}

static BDPartSpec** get_disk_parts (const gchar *disk, guint64 incl, guint64 excl, gboolean incl_normal, GError **error) {

    PedDevice *dev = NULL;

    PedDisk *ped_disk = NULL;

    PedPartition *ped_part = NULL;

    guint num_parts = 0;

    BDPartSpec **ret = NULL;

    guint i = 0;

    dev = ped_device_get (disk);

    if (!dev) {

        set_parted_error (error, BD_PART_ERROR_INVAL);

        g_prefix_error (error, "Device '%s' invalid or not existing", disk);

        return NULL;

    }

    ped_disk = ped_disk_new (dev);

    if (!ped_disk) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to read partition table on device '%s'", disk);

        ped_device_destroy (dev);

        return NULL;

    }

    /* count the partitions we care about */

    ped_part = ped_disk_next_partition (ped_disk, NULL);

    while (ped_part) {

        if (((ped_part->type & incl) && !(ped_part->type & excl)) ||

            ((ped_part->type == 0) && incl_normal))

            num_parts++;

        ped_part = ped_disk_next_partition (ped_disk, ped_part);

    }

    ret = g_new0 (BDPartSpec*, num_parts + 1);

    i = 0;

    ped_part = ped_disk_next_partition (ped_disk, NULL);

    while (ped_part) {

        if (((ped_part->type & incl) && !(ped_part->type & excl)) ||

            ((ped_part->type == 0) && incl_normal))

            ret[i++] = get_part_spec (dev, ped_disk, ped_part, error);

        ped_part = ped_disk_next_partition (ped_disk, ped_part);

    }

    ret[i] = NULL;

    ped_disk_destroy (ped_disk);

    ped_device_destroy (dev);

    return ret;

}

/**

 * bd_part_get_disk_parts:

 * @disk: disk to get information about partitions for

 * @error: (out): place to store error (if any)

 *

 * Returns: (transfer full) (array zero-terminated=1): specs of the partitions from @disk or %NULL in case of error

 *

 * Tech category: %BD_PART_TECH_MODE_QUERY_TABLE + the tech according to the partition table type

 */

BDPartSpec** bd_part_get_disk_parts (const gchar *disk, GError **error) {

    return get_disk_parts (disk, BD_PART_TYPE_NORMAL|BD_PART_TYPE_LOGICAL|BD_PART_TYPE_EXTENDED,

                           BD_PART_TYPE_FREESPACE|BD_PART_TYPE_METADATA|BD_PART_TYPE_PROTECTED, TRUE, error);

}

/**

 * bd_part_get_disk_free_regions:

 * @disk: disk to get free regions for

 * @error: (out): place to store error (if any)

 *

 * Returns: (transfer full) (array zero-terminated=1): specs of the free regions from @disk or %NULL in case of error

 *

 * Tech category: %BD_PART_TECH_MODE_QUERY_TABLE + the tech according to the partition table type

 */

BDPartSpec** bd_part_get_disk_free_regions (const gchar *disk, GError **error) {

    return get_disk_parts (disk, BD_PART_TYPE_FREESPACE, 0, FALSE, error);

}

/**

 * bd_part_get_best_free_region:

 * @disk: disk to get the best free region for

 * @type: type of the partition that is planned to be added

 * @size: size of the partition to be added

 * @error: (out): place to store error (if any)

 *

 * Returns: (transfer full): spec of the best free region on @disk for a new partition of type @type

 *                           with the size of @size or %NULL if there is none such region or if

 *                           there was an error (@error gets populated)

 *

 * Note: For the @type %BD_PART_TYPE_NORMAL, the smallest possible space that *is not* in an extended partition

 *       is found. For the @type %BD_PART_TYPE_LOGICAL, the smallest possible space that *is* in an extended

 *       partition is found. For %BD_PART_TYPE_EXTENDED, the biggest possible space is found as long as there

 *       is no other extended partition (there can only be one).

 *

 * Tech category: %BD_PART_TECH_MODE_QUERY_TABLE + the tech according to the partition table type

 */

BDPartSpec* bd_part_get_best_free_region (const gchar *disk, BDPartType type, guint64 size, GError **error) {

    BDPartSpec **free_regs = NULL;

    BDPartSpec **free_reg_p = NULL;

    BDPartSpec *ret = NULL;

    free_regs = bd_part_get_disk_free_regions (disk, error);

    if (!free_regs)

        /* error should be populated */

        return NULL;

    if (!(*free_regs)) {

        /* no free regions */

        g_free (free_regs);

        return NULL;

    }

    if (type == BD_PART_TYPE_NORMAL) {

        for (free_reg_p=free_regs; *free_reg_p; free_reg_p++) {

            /* check if it has enough space and is not inside an extended partition */

            if ((*free_reg_p)->size > size && !((*free_reg_p)->type & BD_PART_TYPE_LOGICAL))

                /* if it is the first that would fit or if it is smaller than

                   what we found earlier, it is a better match */

                if (!ret || ((*free_reg_p)->size < ret->size))

                    ret = *free_reg_p;

        }

    } else if (type == BD_PART_TYPE_EXTENDED) {

        for (free_reg_p=free_regs; *free_reg_p; free_reg_p++) {

            /* if there already is an extended partition, there cannot be another one */

            if ((*free_reg_p)->type & BD_PART_TYPE_LOGICAL) {

                for (free_reg_p=free_regs; *free_reg_p; free_reg_p++)

                    bd_part_spec_free (*free_reg_p);

                g_free (free_regs);

                return NULL;

            }

            /* check if it has enough space */

            if ((*free_reg_p)->size > size)

                /* if it is the first that would fit or if it is bigger than

                   what we found earlier, it is a better match */

                if (!ret || ((*free_reg_p)->size > ret->size))

                    ret = *free_reg_p;

        }

    } else if (type == BD_PART_TYPE_LOGICAL) {

        for (free_reg_p=free_regs; *free_reg_p; free_reg_p++) {

            /* check if it has enough space and is inside an extended partition */

            if ((*free_reg_p)->size > size && ((*free_reg_p)->type & BD_PART_TYPE_LOGICAL))

                /* if it is the first that would fit or if it is smaller than

                   what we found earlier, it is a better match */

                if (!ret || ((*free_reg_p)->size < ret->size))

                    ret = *free_reg_p;

        }

    }

    /* free all the other specs and return the best one */

    for (free_reg_p=free_regs; *free_reg_p; free_reg_p++)

        if (*free_reg_p != ret)

            bd_part_spec_free (*free_reg_p);

    g_free (free_regs);

    return ret;

}

static PedConstraint* prepare_alignment_constraint (PedDevice *dev, PedDisk *disk, BDPartAlign align, gint *orig_flag_state) {

    if (align == BD_PART_ALIGN_OPTIMAL) {

        /* cylinder alignment does really weird things when turned on, let's not

           deal with it in 21st century (the flag is reset back in the end) */

        if (ped_disk_is_flag_available (disk, PED_DISK_CYLINDER_ALIGNMENT)) {

            *orig_flag_state = ped_disk_get_flag (disk, PED_DISK_CYLINDER_ALIGNMENT);

            ped_disk_set_flag (disk, PED_DISK_CYLINDER_ALIGNMENT, 0);

        }

        return ped_device_get_optimal_aligned_constraint (dev);

    } else if (align == BD_PART_ALIGN_MINIMAL)

        return ped_device_get_minimal_aligned_constraint (dev);

    else

        return NULL;

}

static void finish_alignment_constraint (PedDisk *disk, gint orig_flag_state) {

    if (ped_disk_is_flag_available (disk, PED_DISK_CYLINDER_ALIGNMENT)) {

        ped_disk_set_flag (disk, PED_DISK_CYLINDER_ALIGNMENT, orig_flag_state);

    }

}

static gboolean resize_part (PedPartition *part, PedDevice *dev, PedDisk *disk, guint64 size, BDPartAlign align, GError **error) {

    PedConstraint *constr = NULL;

    PedGeometry *geom;

    gint orig_flag_state = 0;

    PedSector start;

    PedSector end;

    PedSector max_end;

    PedSector new_size = 0;

    gint status = 0;

    PedSector tolerance = 0;

    /* It should be possible to pass the whole drive size a partition size,

     * so -1 MiB for the first partition alignment,

     * -1 MiB for creating this here as a logial partition

     * and -1 MiB for end alingment.

     * But only if the caller doesn't request no alignment which also means

     * they strictly care about precise numbers. */

    if (align != BD_PART_ALIGN_NONE)

        tolerance = (PedSector) (4 MiB /  dev->sector_size);

    constr = prepare_alignment_constraint (dev, disk, align, &orig_flag_state);

    start = part->geom.start;

    if (!constr)

        constr = ped_constraint_any (dev);

    geom = ped_disk_get_max_partition_geometry (disk, part, constr);

    if (!ped_geometry_set_start (geom, start)) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to set partition start on device '%s'", dev->path);

        ped_constraint_destroy (constr);

        ped_geometry_destroy (geom);

        finish_alignment_constraint (disk, orig_flag_state);

        return FALSE;

    }

    if (size == 0) {

        new_size = geom->length;

    } else {

        new_size = (size + dev->sector_size - 1) / dev->sector_size;

    }

    /* If the maximum partition geometry is smaller than the requested size, but

       the difference is acceptable, just adapt the size. */

    if (new_size > geom->length && (new_size - geom->length) < tolerance)

        new_size = geom->length;

    max_end = geom->end;

    ped_geometry_destroy (geom);

    geom = ped_geometry_new (dev, start, new_size);

    if (!geom) {

        set_parted_error (error, BD_PART_ERROR_FAIL);

        g_prefix_error (error, "Failed to create geometry for partition on device '%s'", dev->path);

        ped_constraint_destroy (constr);

        finish_alignment_constraint (disk, orig_flag_state);

        return FALSE;

    }

    if (size != 0) {

        end = ped_alignment_align_up (constr->end_align, constr->end_range, geom->end);

        if (end > max_end && end < max_end + tolerance) {

            end = max_end;

        }

    } else {

        end = geom->end;