
#include "fdiskP.h"


/**
 * SECTION: label
 * @title: Label
 * @short_description: disk label (PT) specific data and functions
 *
 * The fdisk_new_context() initializes all label drivers, and allocate
 * per-label specific data struct. This concept allows to store label specific
 * settings to the label driver independently on the currently active label
 * driver. Note that label struct cannot be deallocated, so there is no
 * reference counting for fdisk_label objects. All is destroyed by
 * fdisk_unref_context() only.
 *
 * Anyway, all label drives share in-memory first sector. The function
 * fdisk_create_disklabel() overwrites this in-memory sector. But it's possible that
 * label driver also uses another buffers, for example GPT reads more sectors
 * from the device.
 *
 * All label operations are in-memory only, except fdisk_write_disklabel().
 *
 * All functions that use "struct fdisk_context" rather than "struct
 * fdisk_label" use the currently active label driver.
 */


int fdisk_probe_labels(struct fdisk_context *cxt)
{
	size_t i;

	cxt->label = NULL;

	for (i = 0; i < cxt->nlabels; i++) {
		struct fdisk_label *lb = cxt->labels[i];
		struct fdisk_label *org = fdisk_get_label(cxt, NULL);
		int rc;

		if (!lb->op->probe)
			continue;
		if (lb->disabled) {
			DBG(CXT, ul_debugobj(cxt, "%s: disabled -- ignore", lb->name));
			continue;
		}
		DBG(CXT, ul_debugobj(cxt, "probing for %s", lb->name));

		cxt->label = lb;
		rc = lb->op->probe(cxt);
		cxt->label = org;

		if (rc != 1) {
			if (lb->op->deinit)
				lb->op->deinit(lb);	/* for sure */
			continue;
		}

		__fdisk_switch_label(cxt, lb);
		return 0;
	}

	DBG(CXT, ul_debugobj(cxt, "no label found"));
	return 1; /* not found */
}

/**
 * fdisk_label_get_name:
 * @lb: label
 *
 * Returns: label name
 */
const char *fdisk_label_get_name(const struct fdisk_label *lb)
{
	return lb ? lb->name : NULL;
}

/**
 * fdisk_label_is_labeltype:
 * @lb: label
 *
 * Returns: FDISK_DISKLABEL_*.
 */
int fdisk_label_get_type(const struct fdisk_label *lb)
{
	return lb->id;
}

/**
 * fdisk_label_require_geometry:
 * @lb: label
 *
 * Returns: 1 if label requires CHS geometry
 */
int fdisk_label_require_geometry(const struct fdisk_label *lb)
{
	assert(lb);

	return lb->flags & FDISK_LABEL_FL_REQUIRE_GEOMETRY ? 1 : 0;
}

/**
 * fdisk_label_get_fields_ids
 * @lb: label (or NULL for the current label)
 * @cxt: context
 * @ids: returns allocated array with FDISK_FIELD_* IDs
 * @nids: returns number of items in fields
 *
 * This function returns the default fields for the label.
 *
 * Note that the set of the default fields depends on fdisk_enable_details()
 * function. If the details are enabled then this function usually returns more
 * fields.
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_label_get_fields_ids(
		const struct fdisk_label *lb,
		struct fdisk_context *cxt,
		int **ids, size_t *nids)
{
	size_t i, n;
	int *c;

	if (!cxt || (!lb && !cxt->label))
		return -EINVAL;

	lb = cxt->label;
	if (!lb->fields || !lb->nfields)
		return -ENOSYS;
	c = calloc(lb->nfields, sizeof(int));
	if (!c)
		return -ENOMEM;
	for (n = 0, i = 0; i < lb->nfields; i++) {
		int id = lb->fields[i].id;

		if ((fdisk_is_details(cxt) &&
				(lb->fields[i].flags & FDISK_FIELDFL_EYECANDY))
		     || (!fdisk_is_details(cxt) &&
				(lb->fields[i].flags & FDISK_FIELDFL_DETAIL))
		     || (id == FDISK_FIELD_SECTORS &&
			         fdisk_use_cylinders(cxt))
		     || (id == FDISK_FIELD_CYLINDERS &&
			         !fdisk_use_cylinders(cxt)))
			continue;

		c[n++] = id;
	}
	if (ids)
		*ids = c;
	else
		free(c);
	if (nids)
		*nids = n;
	return 0;
}

/**
 * fdisk_label_get_fields_ids_all
 * @lb: label (or NULL for the current label)
 * @cxt: context
 * @ids: returns allocated array with FDISK_FIELD_* IDs
 * @nids: returns number of items in fields
 *
 * This function returns all fields for the label.
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_label_get_fields_ids_all(
		const struct fdisk_label *lb,
		struct fdisk_context *cxt,
		int **ids, size_t *nids)
{
	size_t i, n;
	int *c;

	if (!cxt || (!lb && !cxt->label))
		return -EINVAL;

	lb = cxt->label;
	if (!lb->fields || !lb->nfields)
		return -ENOSYS;
	c = calloc(lb->nfields, sizeof(int));
	if (!c)
		return -ENOMEM;
	for (n = 0, i = 0; i < lb->nfields; i++)
		c[n++] = lb->fields[i].id;
	if (ids)
		*ids = c;
	else
		free(c);
	if (nids)
		*nids = n;
	return 0;
}

/**
 * fdisk_label_get_field:
 * @lb: label
 * @id: FDISK_FIELD_*
 *
 * The field struct describes data stored in struct fdisk_partition. The info
 * about data is usable for example to generate human readable output (e.g.
 * fdisk 'p'rint command). See fdisk_partition_to_string() and fdisk code.
 *
 * Returns: pointer to static instance of the field.
 */
const struct fdisk_field *fdisk_label_get_field(const struct fdisk_label *lb, int id)
{
	size_t i;

	assert(lb);
	assert(id > 0);

	for (i = 0; i < lb->nfields; i++) {
		if (lb->fields[i].id == id)
			return &lb->fields[i];
	}

	return NULL;
}

/**
 * fdisk_label_get_field_by_name
 * @lb: label
 * @name: field name
 *
 * Returns: pointer to static instance of the field.
 */
const struct fdisk_field *fdisk_label_get_field_by_name(
				const struct fdisk_label *lb,
				const char *name)
{
	size_t i;

	assert(lb);
	assert(name);

	for (i = 0; i < lb->nfields; i++) {
		if (lb->fields[i].name && strcasecmp(lb->fields[i].name, name) == 0)
			return &lb->fields[i];
	}

	return NULL;
}

/**
 * fdisk_write_disklabel:
 * @cxt: fdisk context
 *
 * Write in-memory changes to disk. Be careful!
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_write_disklabel(struct fdisk_context *cxt)
{
	if (!cxt || !cxt->label || cxt->readonly)
		return -EINVAL;
	if (!cxt->label->op->write)
		return -ENOSYS;

	fdisk_do_wipe(cxt);
	return cxt->label->op->write(cxt);
}

/**
 * fdisk_verify_disklabel:
 * @cxt: fdisk context
 *
 * Verifies the partition table.
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_verify_disklabel(struct fdisk_context *cxt)
{
	if (!cxt || !cxt->label)
		return -EINVAL;
	if (!cxt->label->op->verify)
		return -ENOSYS;
	if (fdisk_missing_geometry(cxt))
		return -EINVAL;

	return cxt->label->op->verify(cxt);
}

/**
 * fdisk_list_disklabel:
 * @cxt: fdisk context
 *
 * Lists details about disklabel, but no partitions.
 *
 * This function is based on fdisk_get_disklabel_item() and prints all label
 * specific information by ASK interface (FDISK_ASKTYPE_INFO, aka fdisk_info()).
 * The function requires enabled "details" by fdisk_enable_details().
 *
 * It's recommended to use fdisk_get_disklabel_item() if you need better
 * control on output and formatting.
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_list_disklabel(struct fdisk_context *cxt)
{
	int id = 0, rc = 0;
	struct fdisk_labelitem item = { .id = id };

	if (!cxt || !cxt->label)
		return -EINVAL;

	if (!cxt->display_details)
		return 0;

	/* List all label items */
	do {
		/* rc: < 0 error, 0 success, 1 unknown item, 2 out of range */
		rc = fdisk_get_disklabel_item(cxt, id++, &item);
		if (rc != 0)
			continue;
		switch (item.type) {
		case 'j':
			fdisk_info(cxt, "%s: %ju", item.name, item.data.num64);
			break;
		case 's':
			if (item.data.str && item.name)
				fdisk_info(cxt, "%s: %s", item.name, item.data.str);
			break;
		}
		fdisk_reset_labelitem(&item);
	} while (rc == 0 || rc == 1);

	return rc < 0 ? rc : 0;
}

/**
 * fdisk_create_disklabel:
 * @cxt: fdisk context
 * @name: label name
 *
 * Creates a new disk label of type @name. If @name is NULL, then it will
 * create a default system label type, either SUN or DOS. The function
 * automatically switches the current label driver to @name. The function
 * fdisk_get_label() returns the current label driver.
 *
 * The function modifies in-memory data only.
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_create_disklabel(struct fdisk_context *cxt, const char *name)
{
	int haslabel = 0;
	struct fdisk_label *lb;

	if (!cxt)
		return -EINVAL;

	if (!name) { /* use default label creation */
#ifdef __sparc__
		name = "sun";
#else
		name = "dos";
#endif
	}

	if (cxt->label) {
		fdisk_deinit_label(cxt->label);
		haslabel = 1;
	}

	lb = fdisk_get_label(cxt, name);
	if (!lb || lb->disabled)
		return -EINVAL;

	if (!haslabel || (lb && cxt->label != lb))
		fdisk_check_collisions(cxt);

	if (!lb->op->create)
		return -ENOSYS;

	__fdisk_switch_label(cxt, lb);
	assert(cxt->label == lb);

	if (haslabel && !cxt->parent)
		fdisk_reset_device_properties(cxt);

	DBG(CXT, ul_debugobj(cxt, "create a new %s label", lb->name));
	return lb->op->create(cxt);
}

/**
 * fdisk_locate_disklabel:
 * @cxt: context
 * @n: N item
 * @name: return item name
 * @offset: return offset where is item
 * @size: of the item
 *
 * Locate disklabel and returns info about @n item of the label. For example
 * GPT is composed from two items, PMBR and GPT, n=0 return offset to PMBR and n=1
 * return offset to GPT. For more details see 'D' expert fdisk command.
 *
 * Returns: 0 on success, <0 on error, 1 no more items.
 */
int fdisk_locate_disklabel(struct fdisk_context *cxt, int n, const char **name,
			   uint64_t *offset, size_t *size)
{
	if (!cxt || !cxt->label)
		return -EINVAL;
	if (!cxt->label->op->locate)
		return -ENOSYS;

	DBG(CXT, ul_debugobj(cxt, "locating %d chunk of %s.", n, cxt->label->name));
	return cxt->label->op->locate(cxt, n, name, offset, size);
}


/**
 * fdisk_get_disklabel_id:
 * @cxt: fdisk context
 * @id: returns pointer to allocated string (MBR Id or GPT dirk UUID)
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_get_disklabel_id(struct fdisk_context *cxt, char **id)
{
	struct fdisk_labelitem item = FDISK_LABELITEM_INIT;
	int rc;

	if (!cxt || !cxt->label || !id)
		return -EINVAL;

	DBG(CXT, ul_debugobj(cxt, "asking for disk %s ID", cxt->label->name));

	rc = fdisk_get_disklabel_item(cxt, FDISK_LABELITEM_ID, &item);
	if (rc == 0) {
		*id = item.data.str;
		item.data.str = NULL;
	}
	fdisk_reset_labelitem(&item);
	if (rc > 0)
		rc = 0;
	return rc;
}

/**
 * fdisk_get_disklabel_item:
 * @cxt: fdisk context
 * @id: item ID (FDISK_LABELITEM_* or *_LABELITEM_*)
 * @item: specifies and returns the item
 *
 * Note that @id is always in range 0..N. It's fine to use the function in loop
 * until it returns error or 2, the result in @item should be ignored when
 * function returns 1. Don't forget to use fdisk_reset_labelitem() or fdisk_unref_labelitem().
 *
 * Returns: 0 on success, < 0 on error, 1 on unsupported item, 2 id out of range
 */
int fdisk_get_disklabel_item(struct fdisk_context *cxt, int id, struct fdisk_labelitem *item)
{
	if (!cxt || !cxt->label || !item)
		return -EINVAL;

	fdisk_reset_labelitem(item);
	item->id = id;
	DBG(CXT, ul_debugobj(cxt, "asking for disk %s item %d", cxt->label->name, item->id));

	if (!cxt->label->op->get_item)
		return -ENOSYS;

	return cxt->label->op->get_item(cxt, item);
}

/**
 * fdisk_set_disklabel_id:
 * @cxt: fdisk context
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_set_disklabel_id(struct fdisk_context *cxt)
{
	if (!cxt || !cxt->label)
		return -EINVAL;
	if (!cxt->label->op->set_id)
		return -ENOSYS;

	DBG(CXT, ul_debugobj(cxt, "setting %s disk ID", cxt->label->name));
	return cxt->label->op->set_id(cxt);
}

/**
 * fdisk_set_partition_type:
 * @cxt: fdisk context
 * @partnum: partition number
 * @t: new type
 *
 * Returns: 0 on success, < 0 on error.
 */
int fdisk_set_partition_type(struct fdisk_context *cxt,
			     size_t partnum,
			     struct fdisk_parttype *t)
{
	if (!cxt || !cxt->label || !t)
		return -EINVAL;


	if (cxt->label->op->set_part) {
		struct fdisk_partition *pa = fdisk_new_partition();
		int rc;

		if (!pa)
			return -ENOMEM;
		fdisk_partition_set_type(pa, t);

		DBG(CXT, ul_debugobj(cxt, "partition: %zd: set type", partnum));
		rc = cxt->label->op->set_part(cxt, partnum, pa);
		fdisk_unref_partition(pa);
		return rc;
	}

	return -ENOSYS;
}


/**
 * fdisk_toggle_partition_flag:
 * @cxt: fdisk context
 * @partnum: partition number
 * @flag: flag ID
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_toggle_partition_flag(struct fdisk_context *cxt,
			       size_t partnum,
			       unsigned long flag)
{
	int rc;

	if (!cxt || !cxt->label)
		return -EINVAL;
	if (!cxt->label->op->part_toggle_flag)
		return -ENOSYS;

	rc = cxt->label->op->part_toggle_flag(cxt, partnum, flag);

	DBG(CXT, ul_debugobj(cxt, "partition: %zd: toggle: 0x%04lx [rc=%d]", partnum, flag, rc));
	return rc;
}

/**
 * fdisk_reorder_partitions
 * @cxt: fdisk context
 *
 * Sort partitions according to the partition start sector.
 *
 * Returns: 0 on success, 1 reorder unnecessary, otherwise a corresponding error.
 */
int fdisk_reorder_partitions(struct fdisk_context *cxt)
{
	if (!cxt || !cxt->label)
		return -EINVAL;
	if (!cxt->label->op->reorder)
		return -ENOSYS;

	return cxt->label->op->reorder(cxt);
}

/*
 * Resets the current used label driver to initial state
 */
void fdisk_deinit_label(struct fdisk_label *lb)
{
	assert(lb);

	/* private label information */
	if (lb->op->deinit)
		lb->op->deinit(lb);
}

/**
 * fdisk_label_set_changed:
 * @lb: label
 * @changed: 0/1
 *
 * Marks in-memory data as changed, to force fdisk_write_disklabel() to write
 * to device. This should be unnecessary by default, the library keeps track
 * about changes.
 */
void fdisk_label_set_changed(struct fdisk_label *lb, int changed)
{
	assert(lb);
	lb->changed = changed ? 1 : 0;
}

/**
 * fdisk_label_is_changed:
 * @lb: label
 *
 * Returns: 1 if in-memory data has been changed.
 */
int fdisk_label_is_changed(const struct fdisk_label *lb)
{
	assert(lb);
	return lb ? lb->changed : 0;
}

/**
 * fdisk_label_set_disabled:
 * @lb: label
 * @disabled: 0 or 1
 *
 * Mark label as disabled, then libfdisk is going to ignore the label when
 * probe device for labels.
 */
void fdisk_label_set_disabled(struct fdisk_label *lb, int disabled)
{
	assert(lb);

	DBG(LABEL, ul_debug("%s label %s",
				lb->name,
				disabled ? "DISABLED" : "ENABLED"));
	lb->disabled = disabled ? 1 : 0;
}

/**
 * fdisk_label_is_disabled:
 * @lb: label
 *
 * Returns: 1 if label driver disabled.
 */
int fdisk_label_is_disabled(const struct fdisk_label *lb)
{
	assert(lb);
	return lb ? lb->disabled : 0;
}

/**
 * fdisk_label_get_geomrange_sectors:
 * @lb: label
 * @mi: minimal number
 * @ma: maximal number
 *
 * The function provides minimal and maximal geometry supported for the label,
 * if no range defined by library than returns -ENOSYS.
 *
 * Since: 2.32
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_label_get_geomrange_sectors(const struct fdisk_label *lb,
					fdisk_sector_t *mi, fdisk_sector_t *ma)
{
	if (!lb || lb->geom_min.sectors == 0)
		return -ENOSYS;
	if (mi)
		*mi = lb->geom_min.sectors;
	if (ma)
		*ma = lb->geom_max.sectors;
	return 0;
}

/**
 * fdisk_label_get_geomrange_heads:
 * @lb: label
 * @mi: minimal number
 * @ma: maximal number
 *
 * The function provides minimal and maximal geometry supported for the label,
 * if no range defined by library than returns -ENOSYS.
 *
 * Since: 2.32
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_label_get_geomrange_heads(const struct fdisk_label *lb,
					unsigned int *mi, unsigned int *ma)
{
	if (!lb || lb->geom_min.heads == 0)
		return -ENOSYS;
	if (mi)
		*mi = lb->geom_min.heads;
	if (ma)
		*ma = lb->geom_max.heads;
	return 0;
}

/**
 * fdisk_label_get_geomrange_cylinders:
 * @lb: label
 * @mi: minimal number
 * @ma: maximal number
 *
 * The function provides minimal and maximal geometry supported for the label,
 * if no range defined by library than returns -ENOSYS.
 *
 * Since: 2.32
 *
 * Returns: 0 on success, otherwise, a corresponding error.
 */
int fdisk_label_get_geomrange_cylinders(const struct fdisk_label *lb,
					fdisk_sector_t *mi, fdisk_sector_t *ma)
{
	if (!lb || lb->geom_min.cylinders == 0)
		return -ENOSYS;
	if (mi)
		*mi = lb->geom_min.cylinders;
	if (ma)
		*ma = lb->geom_max.cylinders;
	return 0;
}

