Adding upstream version 3.6.upstream/3.6upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 586 insertions, 0 deletions

diff --git a/libparted/unit.c b/libparted/unit.c
new file mode 100644
index 0000000..a63b98d
--- /dev/null
+++ b/libparted/unit.c
@@ -0,0 +1,586 @@
+/*
+    libparted - a library for manipulating disk partitions
+    Copyright (C) 2005, 2007, 2009-2014, 2019-2023 Free Software Foundation,
+    Inc.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/** \file unit.c */
+
+/**
+ * \addtogroup PedUnit
+ *
+ * \brief The PedUnit module provides a standard mechanism for describing
+ * and parsing locations within devices in human-friendly plain text.
+ *
+ * Internally, libparted uses PedSector (which is typedef'ed to be long long
+ * in <parted/device.h>) to describe device locations such as the start and
+ * end of partitions.  However, sector numbers are often long and unintuitive.
+ * For example, my extended partition starts at sector 208845.  PedUnit allows
+ * this location to be represented in more intutitive ways, including "106Mb",
+ * "0Gb" and "0%", as well as "208845s".  PedUnit aims to provide facilities
+ * to provide a consistent system for describing device locations all
+ * throughout libparted.
+ *
+ * PedUnit provides two basic services: converting a PedSector into a text
+ * representation, and parsing a text representation into a PedSector.
+ * PedUnit currently supports these units:
+ *
+ * 	sectors, bytes, kilobytes, megabytes, gigabytes, terabytes, compact,
+ * 	cylinder and percent.
+ *
+ * PedUnit has a global variable that contains the default unit for all
+ * conversions.
+ *
+ * @{
+ */
+
+
+
+
+#include <config.h>
+#include <parted/parted.h>
+#include <parted/debug.h>
+#include <parted/unit.h>
+
+#include <ctype.h>
+#include <stdio.h>
+#include <float.h>
+
+#define N_(String) String
+#if ENABLE_NLS
+#  include <libintl.h>
+#  define _(String) dgettext (PACKAGE, String)
+#else
+#  define _(String) (String)
+#endif /* ENABLE_NLS */
+
+
+static PedUnit default_unit = PED_UNIT_COMPACT;
+static const char* unit_names[] = {
+	"s",
+	"B",
+	"kB",
+	"MB",
+	"GB",
+	"TB",
+	"compact",
+	"cyl",
+	"chs",
+	"%",
+	"kiB",
+	"MiB",
+	"GiB",
+	"TiB"
+};
+
+
+/**
+ * \brief Set the default \p unit used by subsequent calls to the PedUnit API.
+ *
+ * In particular, this affects how locations inside error messages
+ * (exceptions) are displayed.
+ */
+void
+ped_unit_set_default (PedUnit unit)
+{
+	default_unit = unit;
+}
+
+
+/**
+ * \brief Get the current default unit.
+ */
+PedUnit _GL_ATTRIBUTE_PURE
+ped_unit_get_default ()
+{
+	return default_unit;
+}
+
+/**
+ * Get the byte size of a given \p unit.
+ */
+long long
+ped_unit_get_size (const PedDevice* dev, PedUnit unit)
+{
+	PedSector cyl_size = dev->bios_geom.heads * dev->bios_geom.sectors;
+
+	switch (unit) {
+		case PED_UNIT_SECTOR:	return dev->sector_size;
+		case PED_UNIT_BYTE:	return 1;
+		case PED_UNIT_KILOBYTE:	return PED_KILOBYTE_SIZE;
+		case PED_UNIT_MEGABYTE:	return PED_MEGABYTE_SIZE;
+		case PED_UNIT_GIGABYTE:	return PED_GIGABYTE_SIZE;
+		case PED_UNIT_TERABYTE:	return PED_TERABYTE_SIZE;
+		case PED_UNIT_KIBIBYTE:	return PED_KIBIBYTE_SIZE;
+		case PED_UNIT_MEBIBYTE:	return PED_MEBIBYTE_SIZE;
+		case PED_UNIT_GIBIBYTE:	return PED_GIBIBYTE_SIZE;
+		case PED_UNIT_TEBIBYTE:	return PED_TEBIBYTE_SIZE;
+		case PED_UNIT_CYLINDER:	return cyl_size * dev->sector_size;
+		case PED_UNIT_CHS:	return dev->sector_size;
+
+		case PED_UNIT_PERCENT:
+			return dev->length * dev->sector_size / 100;
+
+		case PED_UNIT_COMPACT:
+			ped_exception_throw (
+				PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+				_("Cannot get unit size for special unit "
+				  "'COMPACT'."));
+			return 0;
+	}
+
+	/* never reached */
+	PED_ASSERT(0);
+	return 0;
+}
+
+/**
+ * Get a textual (non-internationalized) representation of a \p unit.
+ *
+ * For example, the textual representation of PED_UNIT_SECTOR is "s".
+ */
+const char*
+ped_unit_get_name (PedUnit unit)
+{
+	return unit_names[unit];
+}
+
+/**
+ * Get a unit based on its textual representation: \p unit_name.
+ *
+ * For example, ped_unit_get_by_name("Mb") returns PED_UNIT_MEGABYTE.
+ */
+PedUnit
+ped_unit_get_by_name (const char* unit_name)
+{
+	PedUnit unit;
+	for (unit = PED_UNIT_FIRST; unit <= PED_UNIT_LAST; unit++) {
+		if (!strcasecmp (unit_names[unit], unit_name))
+			return unit;
+	}
+	return -1;
+}
+
+static char*
+ped_strdup (const char *str)
+{
+	char *result;
+	result = ped_malloc (strlen (str) + 1);
+	if (!result)
+		return NULL;
+	strcpy (result, str);
+	return result;
+}
+
+/**
+ * \brief Get a string that describes the location of the \p byte on
+ * device \p dev.
+ *
+ * The string is described with the desired \p unit.
+ * The returned string must be freed with free().
+ */
+char*
+ped_unit_format_custom_byte (const PedDevice* dev, PedSector byte, PedUnit unit)
+{
+	char buf[100];
+	PedSector sector = byte / dev->sector_size;
+	double d, w;
+	int p;
+
+	PED_ASSERT (dev != NULL);
+
+	/* CHS has a special comma-separated format. */
+	if (unit == PED_UNIT_CHS) {
+		const PedCHSGeometry *chs = &dev->bios_geom;
+		snprintf (buf, 100, "%lld,%lld,%lld",
+			  sector / chs->sectors / chs->heads,
+			  (sector / chs->sectors) % chs->heads,
+			  sector % chs->sectors);
+		return ped_strdup (buf);
+	}
+
+	/* Cylinders, sectors and bytes should be rounded down... */
+	if (unit == PED_UNIT_CYLINDER
+	    || unit == PED_UNIT_SECTOR
+	    || unit == PED_UNIT_BYTE) {
+		snprintf (buf, 100, "%lld%s",
+			  byte / ped_unit_get_size (dev, unit),
+			  ped_unit_get_name (unit));
+		return ped_strdup (buf);
+	}
+
+        if (unit == PED_UNIT_COMPACT) {
+                if (byte >= 10LL * PED_TERABYTE_SIZE)
+                        unit = PED_UNIT_TERABYTE;
+                else if (byte >= 10LL * PED_GIGABYTE_SIZE)
+                        unit = PED_UNIT_GIGABYTE;
+                else if (byte >= 10LL * PED_MEGABYTE_SIZE)
+                        unit = PED_UNIT_MEGABYTE;
+                else if (byte >= 10LL * PED_KILOBYTE_SIZE)
+                        unit = PED_UNIT_KILOBYTE;
+                else
+                        unit = PED_UNIT_BYTE;
+	}
+
+	/* IEEE754 says that 100.5 has to be rounded to 100 (by printf) */
+	/* but 101.5 has to be rounded to 102... so we multiply by 1+E. */
+	/* This just divide by 2 the natural IEEE754 extended precision */
+	/* and won't cause any trouble before 1000 TB */
+	d = ((double)byte / ped_unit_get_size (dev, unit))
+	    * (1. + DBL_EPSILON);
+	w = d + ( (d < 10. ) ? 0.005 :
+		  (d < 100.) ? 0.05  :
+			       0.5  );
+	p = (w < 10. ) ? 2 :
+	    (w < 100.) ? 1 :
+			 0 ;
+
+#ifdef __BEOS__
+	snprintf (buf, 100, "%.*f%s", p, d, ped_unit_get_name(unit));
+#else
+	snprintf (buf, 100, "%1$.*2$f%3$s", d, p, ped_unit_get_name (unit));
+#endif
+
+	return ped_strdup (buf);
+}
+
+/**
+ * \brief Get a string that describes the location of the \p byte on
+ * device \p dev.
+ *
+ * The string is described with the default unit, which is set
+ * by ped_unit_set_default().
+ * The returned string must be freed with free().
+ */
+char*
+ped_unit_format_byte (const PedDevice* dev, PedSector byte)
+{
+	PED_ASSERT (dev != NULL);
+	return ped_unit_format_custom_byte (dev, byte, default_unit);
+}
+
+/**
+ * \brief Get a string that describes the location \p sector on device \p dev.
+ *
+ * The string is described with the desired \p unit.
+ * The returned string must be freed with free().
+ */
+char*
+ped_unit_format_custom (const PedDevice* dev, PedSector sector, PedUnit unit)
+{
+	PED_ASSERT (dev != NULL);
+	return ped_unit_format_custom_byte(dev, sector*dev->sector_size, unit);
+}
+
+/**
+ * \brief Get a string that describes the location \p sector on device \p dev.
+ *
+ * The string is described with the default unit, which is set
+ * by ped_unit_set_default().
+ * The returned string must be freed with free().
+ */
+char*
+ped_unit_format (const PedDevice* dev, PedSector sector)
+{
+	PED_ASSERT (dev != NULL);
+	return ped_unit_format_custom_byte (dev, sector * dev->sector_size,
+					    default_unit);
+}
+
+/**
+ * If \p str contains a valid description of a location on \p dev,
+ * then \p *sector is modified to describe the location and a geometry
+ * is created in \p *range describing a 2 units large area centered on
+ * \p *sector.  If the \p range as described here would be partially outside
+ * the device \p dev, the geometry returned is the intersection between the
+ * former and the whole	device geometry.  If no units are specified, then the
+ * default unit is assumed.
+ *
+ * \return \c 1 if \p str is a valid location description, \c 0 otherwise
+ */
+int
+ped_unit_parse (const char* str, const PedDevice* dev, PedSector *sector,
+		PedGeometry** range)
+{
+	return ped_unit_parse_custom (str, dev, default_unit, sector, range);
+}
+
+/* Inefficiently removes all spaces from a string, in-place. */
+static void
+strip_string (char* str)
+{
+	int i;
+
+	for (i = 0; str[i] != 0; i++) {
+		if (isspace (str[i])) {
+			int j;
+			for (j = i + 1; str[j] != 0; j++)
+				str[j - 1] = str[j];
+		}
+	}
+}
+
+
+/* Find non-number suffix.  Eg: find_suffix("32Mb") returns a pointer to
+ * "Mb". */
+static char* _GL_ATTRIBUTE_PURE
+find_suffix (const char* str)
+{
+	while (str[0] != 0 && (isdigit (str[0]) || strchr(",.-", str[0])))
+		str++;
+	return (char *) str;
+}
+
+static void
+remove_punct (char* str)
+{
+	int i = 0;
+
+	for (i = 0; str[i]; i++) {
+		if (ispunct (str[i]))
+			str[i] = ' ';
+	}
+}
+
+static int _GL_ATTRIBUTE_PURE
+is_chs (const char* str)
+{
+	int punct_count = 0;
+	int i = 0;
+
+	for (i = 0; str[i]; i++)
+		punct_count += ispunct (str[i]) != 0;
+	return punct_count == 2;
+}
+
+static int
+parse_chs (const char* str, const PedDevice* dev, PedSector* sector,
+		PedGeometry** range)
+{
+	PedSector cyl_size = dev->bios_geom.heads * dev->bios_geom.sectors;
+	PedCHSGeometry chs;
+
+	char* copy = ped_strdup (str);
+	if (!copy)
+		return 0;
+	strip_string (copy);
+	remove_punct (copy);
+
+	if (sscanf (copy, "%d %d %d",
+		    &chs.cylinders, &chs.heads, &chs.sectors) != 3) {
+		ped_exception_throw (
+				PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+				_("\"%s\" has invalid syntax for locations."),
+				copy);
+		goto error_free_copy;
+	}
+
+	if (chs.heads >= dev->bios_geom.heads) {
+		ped_exception_throw (
+				PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+				_("The maximum head value is %d."),
+				dev->bios_geom.heads - 1);
+		goto error_free_copy;
+	}
+	if (chs.sectors >= dev->bios_geom.sectors) {
+		ped_exception_throw (
+				PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+				_("The maximum sector value is %d."),
+				dev->bios_geom.sectors - 1);
+		goto error_free_copy;
+	}
+
+	*sector = 1LL * chs.cylinders * cyl_size
+		+ chs.heads * dev->bios_geom.sectors
+		+ chs.sectors;
+
+	if (*sector >= dev->length) {
+		ped_exception_throw (
+				PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+				_("The location %s is outside of the "
+				  "device %s."),
+				str, dev->path);
+		goto error_free_copy;
+	}
+	if (range)
+		*range = ped_geometry_new (dev, *sector, 1);
+	free (copy);
+	return !range || *range != NULL;
+
+error_free_copy:
+	free (copy);
+	*sector = 0;
+	if (range)
+		*range = NULL;
+	return 0;
+}
+
+static PedSector
+clip (const PedDevice* dev, PedSector sector)
+{
+	if (sector < 0)
+		return 0;
+	if (sector > dev->length - 1)
+		return dev->length - 1;
+	return sector;
+}
+
+static PedGeometry*
+geometry_from_centre_radius (const PedDevice* dev,
+                             PedSector sector, PedSector radius)
+{
+	PedSector start = clip (dev, sector - radius);
+	PedSector end = clip (dev, sector + radius);
+	if (sector - end > radius || start - sector > radius)
+		return NULL;
+	return ped_geometry_new (dev, start, end - start + 1);
+}
+
+static PedUnit
+parse_unit_suffix (const char* suffix, PedUnit suggested_unit)
+{
+	if (strlen (suffix) > 1 && tolower (suffix[1]) == 'i') {
+		switch (tolower (suffix[0])) {
+			case 'k': return PED_UNIT_KIBIBYTE;
+			case 'm': return PED_UNIT_MEBIBYTE;
+			case 'g': return PED_UNIT_GIBIBYTE;
+			case 't': return PED_UNIT_TEBIBYTE;
+		}
+	} else if (strlen (suffix) > 0) {
+		switch (tolower (suffix[0])) {
+			case 's': return PED_UNIT_SECTOR;
+			case 'b': return PED_UNIT_BYTE;
+			case 'k': return PED_UNIT_KILOBYTE;
+			case 'm': return PED_UNIT_MEGABYTE;
+			case 'g': return PED_UNIT_GIGABYTE;
+			case 't': return PED_UNIT_TERABYTE;
+			case 'c': return PED_UNIT_CYLINDER;
+			case '%': return PED_UNIT_PERCENT;
+		}
+	}
+
+	if (suggested_unit == PED_UNIT_COMPACT) {
+		if (default_unit == PED_UNIT_COMPACT)
+			return PED_UNIT_MEGABYTE;
+		else
+			return default_unit;
+	}
+
+	return suggested_unit;
+}
+
+/**
+ * If \p str contains a valid description of a location on \p dev, then
+ * \p *sector is modified to describe the location and a geometry is created
+ * in \p *range describing a 2 units large area centered on \p *sector.  If the
+ * \p range as described here would be partially outside the device \p dev, the
+ * geometry returned is the intersection between the former and the whole
+ * device geometry.  If no units are specified, then the default unit is
+ * assumed.
+ *
+ * \throws PED_EXCEPTION_ERROR if \p str contains invalid description of a
+ * location
+ * \throws PED_EXCEPTION_ERROR if location described by \p str
+ * is outside of the device \p dev->path
+ *
+ * \return \c 1 if \p str is a valid location description, \c 0 otherwise.
+ */
+int
+ped_unit_parse_custom (const char* str, const PedDevice* dev, PedUnit unit,
+		       PedSector* sector, PedGeometry** range)
+{
+	char*     copy;
+	char*     suffix;
+	double    num;
+	long long unit_size;
+	PedSector radius;
+
+	if (is_chs (str))
+		return parse_chs (str, dev, sector, range);
+
+	copy = ped_strdup (str);
+	if (!copy)
+		goto error;
+	strip_string (copy);
+
+	suffix = find_suffix (copy);
+	unit = parse_unit_suffix (suffix, unit);
+	suffix[0] = 0;
+
+	if (sscanf (copy, "%lf", &num) != 1) {
+		ped_exception_throw (
+				PED_EXCEPTION_ERROR,
+				PED_EXCEPTION_CANCEL,
+				_("Invalid number."));
+		goto error_free_copy;
+	}
+        if (num > 0 && num < 1) {
+            ped_exception_throw (
+                    PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+                    _("Use a smaller unit instead of a value < 1"));
+            goto error_free_copy;
+        }
+
+	unit_size = ped_unit_get_size (dev, unit);
+	switch (unit) {
+		/* If the user specifies the address using IEC units e.g., 4MiB, as in
+		   parted -s -- $dev mklabel gpt mkpart P-NAME 4MiB -34s
+		   do not use size of the unit as the range.  Rather, presume that they
+		   are specifying precisely the starting or ending number,
+		   and treat "4MiB" just as we would treat "4194304B".  */
+		case PED_UNIT_KIBIBYTE:
+		case PED_UNIT_MEBIBYTE:
+		case PED_UNIT_GIBIBYTE:
+		case PED_UNIT_TEBIBYTE:
+			radius = 0;
+			break;
+		default:
+			radius = (ped_div_round_up (unit_size, dev->sector_size) / 2) - 1;
+			if (radius < 0)
+				radius = 0;
+	}
+
+	*sector = num * unit_size / dev->sector_size;
+	/* negative numbers count from the end */
+	if (copy[0] == '-')
+		*sector += dev->length;
+	if (range) {
+		*range = geometry_from_centre_radius (dev, *sector, radius);
+		if (!*range) {
+			ped_exception_throw (
+				PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
+				_("The location %s is outside of the "
+				  "device %s."),
+				str, dev->path);
+			goto error_free_copy;
+		}
+	}
+	*sector = clip (dev, *sector);
+
+	free (copy);
+	return 1;
+
+error_free_copy:
+	free (copy);
+error:
+	*sector = 0;
+	if (range)
+		*range = NULL;
+	return 0;
+}
+
+
+/** @} */