libfdisk: final parttype API cleanup

Signed-off-by: Karel Zak <kzak@redhat.com>

diff --git a/disk-utils/cfdisk.c b/disk-utils/cfdisk.c
index e38052591b1bfcdb3114ef0400c16bd0d5446f1c..5b33af871f9cc63028e9f61c9d11bab918277f7a 100644 (file)
--- a/disk-utils/cfdisk.c
+++ b/disk-utils/cfdisk.c
@@ -1509,9 +1509,9 @@ static struct fdisk_parttype *ui_get_parttype(struct cfdisk *cf,
 {
        struct cfdisk_menuitem *d, *cm;
        size_t i = 0, nitems, idx = 0;
-       struct fdisk_parttype *types, *t = NULL;
+       struct fdisk_parttype *t = NULL;
        struct fdisk_label *lb;
-       int has_typestr = 0;
+       int codetypes = 0;
 
        DBG(UI, ul_debug("asking for parttype."));
 
@@ -1519,27 +1519,28 @@ static struct fdisk_parttype *ui_get_parttype(struct cfdisk *cf,
 
        /* create cfdisk menu according to label types, note that the
         * last cm[] item has to be empty -- so nitems + 1 */
-       if (fdisk_label_get_parttypes(lb, &types, &nitems) || !nitems)
+       nitems = fdisk_label_get_nparttypes(lb);
+       if (!nitems)
                return NULL;
 
        cm = xcalloc(nitems + 1, sizeof(struct cfdisk_menuitem));
        if (!cm)
                return NULL;
 
-       has_typestr = fdisk_label_is_parttype_string(lb);
+       codetypes = fdisk_label_has_code_parttypes(lb);
 
        for (i = 0; i < nitems; i++) {
-               struct fdisk_parttype *x = &types[i];
+               const struct fdisk_parttype *x = fdisk_label_get_parttype(lb, i);
                char *name;
 
-               if (!x || !x->name)
-                       continue;
-               cm[i].userdata = x;
-               if (!has_typestr)
-                       xasprintf(&name, "%2x %s", x->type, _(x->name));
+               cm[i].userdata = (void *) x;
+               if (codetypes)
+                       xasprintf(&name, "%2x %s",
+                               fdisk_parttype_get_code(x),
+                               _(fdisk_parttype_get_name(x)));
                else {
-                       name = (char *) _(x->name);
-                       cm[i].desc = x->typestr;
+                       name = (char *) _(fdisk_parttype_get_name(x));
+                       cm[i].desc = fdisk_parttype_get_string(x);
                }
                cm[i].name = name;
                if (x == cur)
@@ -1579,7 +1580,7 @@ static struct fdisk_parttype *ui_get_parttype(struct cfdisk *cf,
 
 done:
        menu_pop(cf);
-       if (!has_typestr) {
+       if (codetypes) {
                for (i = 0; i < nitems; i++)
                        free((char *) cm[i].name);
        }

diff --git a/disk-utils/fdisk.c b/disk-utils/fdisk.c
index 6883b6c41d28ffe6527dbf9bdfd001dcff4bdf14..3b9431af3d85fb33b8b35cc93d95703004608f02 100644 (file)
--- a/disk-utils/fdisk.c
+++ b/disk-utils/fdisk.c
@@ -354,12 +354,15 @@ int ask_callback(struct fdisk_context *cxt, struct fdisk_ask *ask,
 struct fdisk_parttype *ask_partition_type(struct fdisk_context *cxt)
 {
        const char *q;
-       struct fdisk_label *lb = fdisk_get_label(cxt, NULL);
+       struct fdisk_label *lb;
+
+       assert(cxt);
+       lb = fdisk_get_label(cxt, NULL);
 
-       if (!cxt || !cxt->label || !cxt->label->nparttypes)
+       if (!lb)
                return NULL;
 
-        q = fdisk_label_is_parttype_string(lb) ?
+        q = fdisk_label_has_code_parttypes(lb) ?
                _("Partition type (type L to list all types): ") :
                _("Hex code (type L to list all codes): ");
        do {
@@ -372,7 +375,7 @@ struct fdisk_parttype *ask_partition_type(struct fdisk_context *cxt)
                if (buf[1] == '\0' && toupper(*buf) == 'L')
                        list_partition_types(cxt);
                else if (*buf)
-                       return fdisk_parse_parttype(cxt, buf);
+                       return fdisk_label_parse_parttype(lb, buf);
         } while (1);
 
        return NULL;
@@ -380,16 +383,18 @@ struct fdisk_parttype *ask_partition_type(struct fdisk_context *cxt)
 
 void list_partition_types(struct fdisk_context *cxt)
 {
-       struct fdisk_parttype *types;
        size_t ntypes = 0;
+       struct fdisk_label *lb = fdisk_get_label(cxt, NULL);
 
-       if (!cxt || !cxt->label || !cxt->label->parttypes)
+       assert(cxt);
+       lb = fdisk_get_label(cxt, NULL);
+       if (!lb)
+               return;
+       ntypes = fdisk_label_get_nparttypes(lb);
+       if (!ntypes)
                return;
 
-       types = cxt->label->parttypes;
-       ntypes = cxt->label->nparttypes;
-
-       if (types[0].typestr == NULL) {
+       if (fdisk_label_has_code_parttypes(lb)) {
                /*
                 * Prints in 4 columns in format <hex> <name>
                 */
@@ -397,8 +402,6 @@ void list_partition_types(struct fdisk_context *cxt)
                int i;
 
                size = ntypes;
-               if (types[ntypes - 1].name == NULL)
-                       size--;
 
                for (i = 3; i >= 0; i--)
                        last[3 - i] = done += (size + i - done) / (i + 1);
@@ -408,16 +411,19 @@ void list_partition_types(struct fdisk_context *cxt)
                        #define NAME_WIDTH 15
                        char name[NAME_WIDTH * MB_LEN_MAX];
                        size_t width = NAME_WIDTH;
-                       struct fdisk_parttype *t = &types[next];
+                       const struct fdisk_parttype *t = fdisk_label_get_parttype(lb, next);
                        size_t ret;
 
                        if (t->name) {
-                               printf("%c%2x  ", i ? ' ' : '\n', t->type);
-                               ret = mbsalign(_(t->name), name, sizeof(name),
-                                                     &width, MBS_ALIGN_LEFT, 0);
+                               printf("%c%2x  ", i ? ' ' : '\n',
+                                               fdisk_parttype_get_code(t));
+                               ret = mbsalign(_(fdisk_parttype_get_name(t)),
+                                               name, sizeof(name),
+                                               &width, MBS_ALIGN_LEFT, 0);
 
                                if (ret == (size_t)-1 || ret >= sizeof(name))
-                                       printf("%-15.15s", _(t->name));
+                                       printf("%-15.15s",
+                                               _(fdisk_parttype_get_name(t)));
                                else
                                        fputs(name, stdout);
                        }
@@ -433,13 +439,13 @@ void list_partition_types(struct fdisk_context *cxt)
                /*
                 * Prints 1 column in format <idx> <name> <typestr>
                 */
-               struct fdisk_parttype *t;
                size_t i;
 
-               for (i = 0, t = types; t && i < ntypes; t++, i++) {
-                       if (t->name)
-                               printf("%3zu %-30s %s\n", i + 1,
-                                               t->name, t->typestr);
+               for (i = 0; i < ntypes; i++) {
+                       const struct fdisk_parttype *t = fdisk_label_get_parttype(lb, i);
+                       printf("%3zu %-30s %s\n", i + 1,
+                                       fdisk_parttype_get_name(t),
+                                       fdisk_parttype_get_string(t));
                }
        }
        putchar('\n');
@@ -492,7 +498,7 @@ void change_partition_type(struct fdisk_context *cxt)
        if (fdisk_set_partition_type(cxt, i, t) == 0)
                fdisk_sinfo(cxt, FDISK_INFO_SUCCESS,
                        _("Changed type of partition '%s' to '%s'."),
-                       old, t ? t->name : _("Unknown"));
+                       old, t ? fdisk_parttype_get_name(t) : _("Unknown"));
        else
                fdisk_info(cxt,
                        _("Type of partition %zu is unchanged: %s."),

diff --git a/libfdisk/src/bsd.c b/libfdisk/src/bsd.c
index 55996cc25a43d1b1359a641b7dea826fdbd02cc0..6dddd3d71ec1167dc5de4b90d7b99c7525895e90 100644 (file)
--- a/libfdisk/src/bsd.c
+++ b/libfdisk/src/bsd.c
@@ -110,7 +110,7 @@ static struct fdisk_parttype *bsd_partition_parttype(
                struct bsd_partition *p)
 {
        struct fdisk_parttype *t
-                       = fdisk_get_parttype_from_code(cxt, p->p_fstype);
+               = fdisk_label_get_parttype_from_code(cxt->label, p->p_fstype);
        return t ? : fdisk_new_unknown_parttype(p->p_fstype, NULL);
 }
 
@@ -838,14 +838,14 @@ static int bsd_set_parttype(
        struct bsd_partition *p;
        struct bsd_disklabel *d = self_disklabel(cxt);
 
-       if (partnum >= d->d_npartitions || !t || t->type > UINT8_MAX)
+       if (partnum >= d->d_npartitions || !t || t->code > UINT8_MAX)
                return -EINVAL;
 
        p = &d->d_partitions[partnum];
-       if (t->type == p->p_fstype)
+       if (t->code == p->p_fstype)
                return 0;
 
-       p->p_fstype = t->type;
+       p->p_fstype = t->code;
        fdisk_label_set_changed(cxt->label, 1);
        return 0;
 }
@@ -912,7 +912,7 @@ struct fdisk_label *fdisk_new_bsd_label(struct fdisk_context *cxt)
        lb->id = FDISK_DISKLABEL_BSD;
        lb->op = &bsd_operations;
        lb->parttypes = bsd_fstypes;
-       lb->nparttypes = ARRAY_SIZE(bsd_fstypes);
+       lb->nparttypes = ARRAY_SIZE(bsd_fstypes) - 1;
 
        lb->fields = bsd_fields;
        lb->nfields = ARRAY_SIZE(bsd_fields);

diff --git a/libfdisk/src/dos.c b/libfdisk/src/dos.c
index 2533f0c9ba6c3b18eb079813e804b2db3b33a18d..c0360893a27612886edaee5116861a2b2c59038c 100644 (file)
--- a/libfdisk/src/dos.c
+++ b/libfdisk/src/dos.c
@@ -128,7 +128,7 @@ static struct fdisk_parttype *dos_partition_parttype(
                struct dos_partition *p)
 {
        struct fdisk_parttype *t
-                       = fdisk_get_parttype_from_code(cxt, p->sys_ind);
+               = fdisk_label_get_parttype_from_code(cxt->label, p->sys_ind);
        return t ? : fdisk_new_unknown_parttype(p->sys_ind, NULL);
 }
 
@@ -811,7 +811,8 @@ static void set_partition(struct fdisk_context *cxt,
        dos_partition_set_size(p, stop - start + 1);
 
        if (!doext) {
-               struct fdisk_parttype *t = fdisk_get_parttype_from_code(cxt, sysid);
+               struct fdisk_parttype *t =
+                       fdisk_label_get_parttype_from_code(cxt->label, sysid);
                fdisk_info_new_partition(cxt, i + 1, start, stop, t);
        }
        if (is_dos_compatible(cxt) && (start/(cxt->geom.sectors*cxt->geom.heads) > 1023))
@@ -930,7 +931,7 @@ static int add_partition(struct fdisk_context *cxt, size_t n,
 
        DBG(LABEL, ul_debug("DOS: adding partition %zu", n));
 
-       sys = pa && pa->type ? pa->type->type : MBR_LINUX_DATA_PARTITION;
+       sys = pa && pa->type ? pa->type->code : MBR_LINUX_DATA_PARTITION;
 
        if (is_used_partition(p)) {
                fdisk_warnx(cxt, _("Partition %zu is already defined.  "
@@ -1451,7 +1452,7 @@ static int dos_add_partition(struct fdisk_context *cxt,
                                struct fdisk_partition xpa = { .type = NULL };
                                struct fdisk_parttype *t;
 
-                               t = fdisk_get_parttype_from_code(cxt,
+                               t = fdisk_label_get_parttype_from_code(cxt->label,
                                                MBR_DOS_EXTENDED_PARTITION);
                                if (!pa)
                                        pa = &xpa;
@@ -1587,28 +1588,28 @@ static int dos_set_parttype(
        assert(cxt->label);
        assert(fdisk_is_label(cxt, DOS));
 
-       if (partnum >= cxt->label->nparts_max || !t || t->type > UINT8_MAX)
+       if (partnum >= cxt->label->nparts_max || !t || t->code > UINT8_MAX)
                return -EINVAL;
 
        p = self_partition(cxt, partnum);
-       if (t->type == p->sys_ind)
+       if (t->code == p->sys_ind)
                return 0;
 
-       if (IS_EXTENDED(p->sys_ind) || IS_EXTENDED(t->type)) {
+       if (IS_EXTENDED(p->sys_ind) || IS_EXTENDED(t->code)) {
                fdisk_warnx(cxt, _("You cannot change a partition into an "
                        "extended one or vice versa. Delete it first."));
                return -EINVAL;
        }
 
-       if (is_dos_partition(t->type) || is_dos_partition(p->sys_ind))
+       if (is_dos_partition(t->code) || is_dos_partition(p->sys_ind))
            fdisk_info(cxt, _("If you have created or modified any DOS 6.x "
                "partitions, please see the fdisk documentation for additional "
                "information."));
 
-       if (!t->type)
+       if (!t->code)
                fdisk_warnx(cxt, _("Type 0 means free space to many systems. "
                                   "Having partitions of type 0 is probably unwise."));
-       p->sys_ind = t->type;
+       p->sys_ind = t->code;
 
        partition_set_changed(cxt, partnum, 1);
        return 0;
@@ -2046,7 +2047,7 @@ struct fdisk_label *fdisk_new_dos_label(struct fdisk_context *cxt)
        lb->id = FDISK_DISKLABEL_DOS;
        lb->op = &dos_operations;
        lb->parttypes = dos_parttypes;
-       lb->nparttypes = ARRAY_SIZE(dos_parttypes);
+       lb->nparttypes = ARRAY_SIZE(dos_parttypes) - 1;
        lb->fields = dos_fields;
        lb->nfields = ARRAY_SIZE(dos_fields);
 

diff --git a/libfdisk/src/fdiskP.h b/libfdisk/src/fdiskP.h
index 8d70c4ce031e6e5d48412dbc18209c52a51a30e6..46adc058a39358b6a907b30257e8e11d23c6b7ba 100644 (file)
--- a/libfdisk/src/fdiskP.h
+++ b/libfdisk/src/fdiskP.h
@@ -94,7 +94,7 @@ struct fdisk_iter {
  * Partition types
  */
 struct fdisk_parttype {
-       unsigned int    type;           /* type as number or zero */
+       unsigned int    code;           /* type as number or zero */
        const char      *name;          /* description */
        char            *typestr;       /* type as string or NULL */
 

diff --git a/libfdisk/src/gpt.c b/libfdisk/src/gpt.c
index 2df5d8e47982a425fcf73e674401adf39b4733f4..27e41ba2692dae9997d01a1d64bac064f94bbdc9 100644 (file)
--- a/libfdisk/src/gpt.c
+++ b/libfdisk/src/gpt.c
@@ -321,7 +321,7 @@ static struct fdisk_parttype *gpt_partition_parttype(
        char str[37];
 
        guid_to_string(&e->type, str);
-       t = fdisk_get_parttype_from_string(cxt, str);
+       t = fdisk_label_get_parttype_from_string(cxt->label, str);
        return t ? : fdisk_new_unknown_parttype(0, str);
 }
 

diff --git a/libfdisk/src/label.c b/libfdisk/src/label.c
index 7cd48d66a6d4749cd6e5f33a2d69477200a20403..c8691b6db34eb3382cd22236ca86bb31ab973c1f 100644 (file)
--- a/libfdisk/src/label.c
+++ b/libfdisk/src/label.c
@@ -53,43 +53,6 @@ const char *fdisk_label_get_name(struct fdisk_label *lb)
        return lb ? lb->name : NULL;
 }
 
-/**
- * fdisk_label_get_parttypes:
- * @lb: label
- * @types: returns array with supported partition types
- * @ntypes: returns number of types
- *
- * Returns: 0 on success, <0 on error.
- */
-int fdisk_label_get_parttypes(struct fdisk_label *lb,
-                                struct fdisk_parttype **types,
-                                size_t *ntypes)
-{
-       if (!lb)
-               return -EINVAL;
-       if (types)
-               *types = lb->parttypes;
-       if (ntypes)
-               *ntypes = lb->nparttypes;
-       return 0;
-}
-
-/**
- * fdisk_label_is_parttype_string:
- * @lb: label
- *
- * Returns: 1 if the label uses strings as partition type
- *          identifiers (e.g. GPT UUIDS) or 0.
- */
-int fdisk_label_is_parttype_string(struct fdisk_label *lb)
-{
-       assert(lb);
-
-       if (lb->parttypes && lb->parttypes[0].typestr)
-               return 1;
-       return 0;
-}
-
 /**
  * fdisk_label_require_geometry:
  * @lb: label

diff --git a/libfdisk/src/libfdisk.h b/libfdisk/src/libfdisk.h
index cf65ddaee06ff617578263985514e3aad690289f..c63060c14e10bbf395eef44db9ebfa8ba1233ce1 100644 (file)
--- a/libfdisk/src/libfdisk.h
+++ b/libfdisk/src/libfdisk.h
@@ -121,16 +121,27 @@ sector_t fdisk_get_nsectors(struct fdisk_context *cxt);
 const char *fdisk_get_devname(struct fdisk_context *cxt);
 
 /* parttype.c */
-extern struct fdisk_parttype *fdisk_get_parttype_from_code(struct fdisk_context *cxt,
-                                unsigned int code);
-extern struct fdisk_parttype *fdisk_get_parttype_from_string(struct fdisk_context *cxt,
-                                const char *str);
-extern struct fdisk_parttype *fdisk_parse_parttype(struct fdisk_context *cxt, const char *str);
-
-extern struct fdisk_parttype *fdisk_new_unknown_parttype(unsigned int type, const char *typestr);
-extern void fdisk_free_parttype(struct fdisk_parttype *type);
-
-extern int fdisk_is_parttype_string(struct fdisk_context *cxt);
+const struct fdisk_parttype *fdisk_label_get_parttype(struct fdisk_label *lb, size_t n);
+size_t fdisk_label_get_nparttypes(struct fdisk_label *lb);
+
+int fdisk_label_has_code_parttypes(struct fdisk_label *lb);
+struct fdisk_parttype *fdisk_label_get_parttype_from_code(
+                               struct fdisk_label *lb,
+                               unsigned int code);
+
+struct fdisk_parttype *fdisk_label_get_parttype_from_string(
+                               struct fdisk_label *lb,
+                               const char *str);
+struct fdisk_parttype *fdisk_new_unknown_parttype(unsigned int code,
+                                                 const char *typestr);
+struct fdisk_parttype *fdisk_label_parse_parttype(
+                               struct fdisk_label *lb,
+                               const char *str);
+void fdisk_free_parttype(struct fdisk_parttype *t);
+
+const char *fdisk_parttype_get_string(const struct fdisk_parttype *t);
+unsigned int fdisk_parttype_get_code(const struct fdisk_parttype *t);
+const char *fdisk_parttype_get_name(const struct fdisk_parttype *t);
 
 /* label.c */
 enum {
@@ -179,11 +190,6 @@ extern int fdisk_delete_partition(struct fdisk_context *cxt, size_t partnum);
 extern int fdisk_set_partition_type(struct fdisk_context *cxt, size_t partnum,
                             struct fdisk_parttype *t);
 
-extern int fdisk_label_get_parttypes(struct fdisk_label *lb,
-                                struct fdisk_parttype **types,
-                                size_t *ntypes);
-extern int fdisk_label_is_parttype_string(struct fdisk_label *lb);
-
 extern int fdisk_label_get_fields_ids(
                        struct fdisk_label *lb,
                        struct fdisk_context *cxt,

diff --git a/libfdisk/src/partition.c b/libfdisk/src/partition.c
index 3cb271cca5c869f4dcd4e8248a0e9d5645f85222..5136e534be4f54d38d5832c5115762a4c14b11d8 100644 (file)
--- a/libfdisk/src/partition.c
+++ b/libfdisk/src/partition.c
@@ -389,10 +389,10 @@ int fdisk_partition_to_string(struct fdisk_partition *pa,
                p = pa->type && pa->type->name ? strdup(pa->type->name) : NULL;
                break;
        case FDISK_FIELD_TYPEID:
-               if (pa->type && pa->type->typestr)
-                       rc = asprintf(&p, "%s", pa->type->typestr);
+               if (pa->type && fdisk_parttype_get_string(pa->type))
+                       rc = asprintf(&p, "%s", fdisk_parttype_get_string(pa->type));
                else if (pa->type)
-                       rc = asprintf(&p, "%x", pa->type->type);
+                       rc = asprintf(&p, "%x", fdisk_parttype_get_code(pa->type));
                break;
        case FDISK_FIELD_UUID:
                p = pa->uuid ? strdup(pa->uuid) : NULL;

diff --git a/libfdisk/src/parttype.c b/libfdisk/src/parttype.c
index 5d6f5d00ce340175370c019692a1537a5d95d289..caf205a84e39a5b02e39708b228947dea6255b57 100644 (file)
--- a/libfdisk/src/parttype.c
+++ b/libfdisk/src/parttype.c
@@ -5,68 +5,117 @@
 
 #include "fdiskP.h"
 
+
+/**
+ * fdisk_label_get_nparttypes:
+ * @lb: label
+ *
+ * Returns: number of types supported by label.
+ */
+size_t fdisk_label_get_nparttypes(struct fdisk_label *lb)
+{
+       if (!lb)
+               return 0;
+       return lb->nparttypes;
+}
+
+/**
+ * fdisk_label_get_parttype:
+ * @lb: label
+ * @n: number
+ *
+ * Returns: return parttype
+ */
+const struct fdisk_parttype *fdisk_label_get_parttype(struct fdisk_label *lb, size_t n)
+{
+       if (!lb || n >= lb->nparttypes)
+               return NULL;
+       return &lb->parttypes[n];
+}
+
 /**
- * fdisk_get_parttype_from_code:
- * @cxt: fdisk context
+ * fdisk_label_has_code_parttypes:
+ * @lb: label
+ *
+ * Returns: 1 if the label uses code as partition type
+ *          identifiers (e.g. MBR) or 0.
+ */
+int fdisk_label_has_code_parttypes(struct fdisk_label *lb)
+{
+       assert(lb);
+
+       if (lb->parttypes && lb->parttypes[0].typestr)
+               return 0;
+       return 1;
+}
+
+
+/**
+ * fdisk_label_get_parttype_from_code:
+ * @lb: label
  * @code: code to search for
  *
  * Search in lable-specific table of supported partition types by code.
  *
- * Returns partition type or NULL upon failure or invalid @code.
+ * Returns: partition type or NULL upon failure or invalid @code.
  */
-struct fdisk_parttype *fdisk_get_parttype_from_code(
-                               struct fdisk_context *cxt,
+struct fdisk_parttype *fdisk_label_get_parttype_from_code(
+                               struct fdisk_label *lb,
                                unsigned int code)
 {
        size_t i;
 
-       if (!cxt->label->nparttypes)
+       assert(lb);
+
+       if (!lb->nparttypes)
                return NULL;
 
-       for (i = 0; i < cxt->label->nparttypes; i++)
-               if (cxt->label->parttypes[i].type == code)
-                       return &cxt->label->parttypes[i];
+       for (i = 0; i < lb->nparttypes; i++)
+               if (lb->parttypes[i].code == code)
+                       return &lb->parttypes[i];
 
        return NULL;
 }
 
 /**
- * fdisk_get_parttype_from_string:
- * @cxt: fdisk context
+ * fdisk_label_get_parttype_from_string:
+ * @lb: label
  * @str: string to search for
  *
  * Search in lable-specific table of supported partition types by typestr.
  *
- * Returns partition type or NULL upon failure or invalid @str.
+ * Returns: partition type or NULL upon failure or invalid @str.
  */
-struct fdisk_parttype *fdisk_get_parttype_from_string(
-                               struct fdisk_context *cxt,
+struct fdisk_parttype *fdisk_label_get_parttype_from_string(
+                               struct fdisk_label *lb,
                                const char *str)
 {
        size_t i;
 
-       if (!cxt->label->nparttypes)
+       assert(lb);
+
+       if (!lb->nparttypes)
                return NULL;
 
-       for (i = 0; i < cxt->label->nparttypes; i++)
-               if (cxt->label->parttypes[i].typestr
-                   &&strcasecmp(cxt->label->parttypes[i].typestr, str) == 0)
-                       return &cxt->label->parttypes[i];
+       for (i = 0; i < lb->nparttypes; i++)
+               if (lb->parttypes[i].typestr
+                   && strcasecmp(lb->parttypes[i].typestr, str) == 0)
+                       return &lb->parttypes[i];
 
        return NULL;
 }
 
 /**
  * fdisk_new_unknown_parttype:
- * @type: type as number
+ * @code: type as number
  * @typestr: type as string
 
  * Allocates new 'unknown' partition type. Use fdisk_free_parttype() to
  * deallocate.
  *
- * Returns newly allocated partition type, or NULL upon failure.
+ * Returns: newly allocated partition type, or NULL upon failure.
  */
-struct fdisk_parttype *fdisk_new_unknown_parttype(unsigned int type,
+struct fdisk_parttype *fdisk_new_unknown_parttype(unsigned int code,
                                                  const char *typestr)
 {
        struct fdisk_parttype *t;
@@ -83,7 +132,7 @@ struct fdisk_parttype *fdisk_new_unknown_parttype(unsigned int type,
                }
        }
        t->name = _("unknown");
-       t->type = type;
+       t->code = code;
        t->flags |= FDISK_PARTTYPE_UNKNOWN | FDISK_PARTTYPE_ALLOCATED;
 
        DBG(PARTTYPE, ul_debugobj(t, "allocated new unknown type"));
@@ -91,28 +140,30 @@ struct fdisk_parttype *fdisk_new_unknown_parttype(unsigned int type,
 }
 
 /**
- * fdisk_parse_parttype:
- * @cxt: fdisk context
+ * fdisk_label_parse_parttype:
+ * @lb: label
  * @str: string to parse from
  *
- * Returns pointer to static table of the partition types, or newly allocated
+ * Returns: pointer to static table of the partition types, or newly allocated
  * partition type for unknown types. It's safe to call fdisk_free_parttype()
  * for all results.
  */
-struct fdisk_parttype *fdisk_parse_parttype(
-                               struct fdisk_context *cxt,
+struct fdisk_parttype *fdisk_label_parse_parttype(
+                               struct fdisk_label *lb,
                                const char *str)
 {
        struct fdisk_parttype *types, *ret;
        unsigned int code = 0;
        char *typestr = NULL, *end = NULL;
 
-       if (!cxt->label->nparttypes)
+       assert(lb);
+
+       if (!lb->nparttypes)
                return NULL;
 
-       DBG(CXT, ul_debugobj(cxt, "parsing '%s' partition type", str));
+       DBG(LABEL, ul_debugobj(lb, "parsing '%s' partition type", str));
 
-       types = cxt->label->parttypes;
+       types = lb->parttypes;
 
        if (types[0].typestr == NULL && isxdigit(*str)) {
 
@@ -120,17 +171,17 @@ struct fdisk_parttype *fdisk_parse_parttype(
                code = strtol(str, &end, 16);
 
                if (errno || *end != '\0') {
-                       DBG(CXT, ul_debugobj(cxt, "parsing failed: %m"));
+                       DBG(LABEL, ul_debugobj(lb, "parsing failed: %m"));
                        return NULL;
                }
-               ret = fdisk_get_parttype_from_code(cxt, code);
+               ret = fdisk_label_get_parttype_from_code(lb, code);
                if (ret)
                        goto done;
        } else {
                int i;
 
                /* maybe specified by type string (e.g. UUID) */
-               ret = fdisk_get_parttype_from_string(cxt, str);
+               ret = fdisk_label_get_parttype_from_string(lb, str);
                if (ret)
                        goto done;
 
@@ -138,7 +189,7 @@ struct fdisk_parttype *fdisk_parse_parttype(
                errno = 0;
                i = strtol(str, &end, 0);
                if (errno == 0 && *end == '\0' && i > 0
-                   && i - 1 < (int) cxt->label->nparttypes) {
+                   && i - 1 < (int) lb->nparttypes) {
                        ret = &types[i - 1];
                        goto done;
                }
@@ -146,7 +197,7 @@ struct fdisk_parttype *fdisk_parse_parttype(
 
        ret = fdisk_new_unknown_parttype(code, typestr);
 done:
-       DBG(PARTTYPE, ul_debugobj(ret, "returns '%s' partition type", ret->name));
+       DBG(PARTTYPE, ul_debugobj(ret, "returns parsed '%s' partition type", ret->name));
        return ret;
 }
 
@@ -165,4 +216,23 @@ void fdisk_free_parttype(struct fdisk_parttype *t)
        }
 }
 
+const char *fdisk_parttype_get_string(const struct fdisk_parttype *t)
+{
+       assert(t);
+       return t->typestr && *t->typestr ? t->typestr : NULL;
+}
+
+unsigned int fdisk_parttype_get_code(const struct fdisk_parttype *t)
+{
+       assert(t);
+       return t->code;
+}
+
+const char *fdisk_parttype_get_name(const struct fdisk_parttype *t)
+{
+       assert(t);
+       return t->name;
+}
+
+
 

diff --git a/libfdisk/src/sgi.c b/libfdisk/src/sgi.c
index fef9234cb72a5594a8daa4a87dfdfb8d540fe5a5..bf23017782bef7a4ae653f0d44bac1447b9a0e5a 100644 (file)
--- a/libfdisk/src/sgi.c
+++ b/libfdisk/src/sgi.c
@@ -308,7 +308,7 @@ static struct fdisk_parttype *sgi_get_parttype(struct fdisk_context *cxt, size_t
        if (n >= cxt->label->nparts_max)
                return NULL;
 
-       t = fdisk_get_parttype_from_code(cxt, sgi_get_sysid(cxt, n));
+       t = fdisk_label_get_parttype_from_code(cxt->label, sgi_get_sysid(cxt, n));
        return t ? : fdisk_new_unknown_parttype(sgi_get_sysid(cxt, n), NULL);
 }
 
@@ -329,7 +329,7 @@ static int sgi_get_partition(struct fdisk_context *cxt, size_t n, struct fdisk_p
        pa->start = start;
        pa->end = start + len - (len ? 1 : 0);
 
-       if (pa->type && pa->type->type == SGI_TYPE_ENTIRE_DISK)
+       if (pa->type && pa->type->code == SGI_TYPE_ENTIRE_DISK)
                pa->wholedisk = 1;
 
        pa->attrs = sgi_get_swappartition(cxt) == (int) n ? "swap" :
@@ -707,7 +707,8 @@ static int sgi_set_partition(struct fdisk_context *cxt, size_t i,
        if (sgi_gaps(cxt) < 0)  /* rebuild freelist */
                fdisk_warnx(cxt, _("Partition overlap on the disk."));
        if (length) {
-               struct fdisk_parttype *t = fdisk_get_parttype_from_code(cxt, sys);
+               struct fdisk_parttype *t =
+                               fdisk_label_get_parttype_from_code(cxt->label, sys);
                fdisk_info_new_partition(cxt, i + 1, start, start + length, t);
        }
 
@@ -764,7 +765,7 @@ static int sgi_add_partition(struct fdisk_context *cxt,
        char mesg[256];
        unsigned int first = 0, last = 0;
        struct fdisk_ask *ask;
-       int sys = pa && pa->type ? pa->type->type : SGI_TYPE_XFS;
+       int sys = pa && pa->type ? pa->type->code : SGI_TYPE_XFS;
        int rc;
        size_t n;
 
@@ -1003,7 +1004,7 @@ static int sgi_set_parttype(struct fdisk_context *cxt,
 {
        struct sgi_disklabel *sgilabel;
 
-       if (i >= cxt->label->nparts_max || !t || t->type > UINT32_MAX)
+       if (i >= cxt->label->nparts_max || !t || t->code > UINT32_MAX)
                return -EINVAL;
 
        if (sgi_get_num_sectors(cxt, i) == 0)   /* caught already before, ... */ {
@@ -1011,13 +1012,13 @@ static int sgi_set_parttype(struct fdisk_context *cxt,
                return -EINVAL;
        }
 
-       if ((i == 10 && t->type != SGI_TYPE_ENTIRE_DISK)
-           || (i == 8 && t->type != 0))
+       if ((i == 10 && t->code != SGI_TYPE_ENTIRE_DISK)
+           || (i == 8 && t->code != 0))
                fdisk_info(cxt, _("Consider leaving partition 9 as volume header (0), "
                                  "and partition 11 as entire volume (6), "
                                  "as IRIX expects it."));
 
-       if (((t->type != SGI_TYPE_ENTIRE_DISK) && (t->type != SGI_TYPE_VOLHDR))
+       if (((t->code != SGI_TYPE_ENTIRE_DISK) && (t->code != SGI_TYPE_VOLHDR))
            && (sgi_get_start_sector(cxt, i) < 1)) {
                int yes = 0;
                fdisk_ask_yesno(cxt,
@@ -1031,7 +1032,7 @@ static int sgi_set_parttype(struct fdisk_context *cxt,
        }
 
        sgilabel = self_disklabel(cxt);
-       sgilabel->partitions[i].type = cpu_to_be32(t->type);
+       sgilabel->partitions[i].type = cpu_to_be32(t->code);
        return 0;
 }
 
@@ -1129,7 +1130,7 @@ struct fdisk_label *fdisk_new_sgi_label(struct fdisk_context *cxt)
        lb->id = FDISK_DISKLABEL_SGI;
        lb->op = &sgi_operations;
        lb->parttypes = sgi_parttypes;
-       lb->nparttypes = ARRAY_SIZE(sgi_parttypes);
+       lb->nparttypes = ARRAY_SIZE(sgi_parttypes) - 1;
        lb->fields = sgi_fields;
        lb->nfields = ARRAY_SIZE(sgi_fields);
 

diff --git a/libfdisk/src/sun.c b/libfdisk/src/sun.c
index 7ea399378ca9e62b509a6b77d1903d22ccd786c1..9a00c65dab9407dad80eba79e9602ae004c54a7c 100644 (file)
--- a/libfdisk/src/sun.c
+++ b/libfdisk/src/sun.c
@@ -72,7 +72,8 @@ static void set_sun_partition(struct fdisk_context *cxt, size_t i,
                uint32_t start,uint32_t stop, uint16_t sysid)
 {
        struct sun_disklabel *sunlabel = self_disklabel(cxt);
-       struct fdisk_parttype *t = fdisk_get_parttype_from_code(cxt, sysid);
+       struct fdisk_parttype *t =
+                       fdisk_label_get_parttype_from_code(cxt->label, sysid);
 
        sunlabel->vtoc.infos[i].id = cpu_to_be16(sysid);
        sunlabel->vtoc.infos[i].flags = cpu_to_be16(0);
@@ -481,7 +482,7 @@ static int sun_add_partition(
        struct sun_info *info;
        uint32_t start, stop, stop2;
        int whole_disk = 0;
-       int sys = pa && pa->type ? pa->type->type : SUN_TAG_LINUX_NATIVE;
+       int sys = pa && pa->type ? pa->type->code : SUN_TAG_LINUX_NATIVE;
        int rc;
        size_t n;
 
@@ -753,7 +754,8 @@ static struct fdisk_parttype *sun_get_parttype(
        if (n >= cxt->label->nparts_max)
                return NULL;
 
-       t = fdisk_get_parttype_from_code(cxt, be16_to_cpu(sunlabel->vtoc.infos[n].id));
+       t = fdisk_label_get_parttype_from_code(cxt->label,
+                       be16_to_cpu(sunlabel->vtoc.infos[n].id));
        return t ? : fdisk_new_unknown_parttype(be16_to_cpu(sunlabel->vtoc.infos[n].id), NULL);
 }
 
@@ -786,7 +788,7 @@ static int sun_get_partition(struct fdisk_context *cxt, size_t n,
        len = be32_to_cpu(part->num_sectors);
 
        pa->type = sun_get_parttype(cxt, n);
-       if (pa->type && pa->type->type == SUN_TAG_WHOLEDISK)
+       if (pa->type && pa->type->code == SUN_TAG_WHOLEDISK)
                pa->wholedisk = 1;
 
        if (flags & SUN_FLAG_UNMNT || flags & SUN_FLAG_RONLY) {
@@ -929,17 +931,17 @@ static int sun_set_parttype(
 
        sunlabel = self_disklabel(cxt);
 
-       if (i >= cxt->label->nparts_max || !t || t->type > UINT16_MAX)
+       if (i >= cxt->label->nparts_max || !t || t->code > UINT16_MAX)
                return -EINVAL;
 
-       if (i == 2 && t->type != SUN_TAG_WHOLEDISK)
+       if (i == 2 && t->code != SUN_TAG_WHOLEDISK)
                fdisk_info(cxt, _("Consider leaving partition 3 as Whole disk (5),\n"
                         "as SunOS/Solaris expects it and even Linux likes it.\n"));
 
        part = &sunlabel->partitions[i];
        info = &sunlabel->vtoc.infos[i];
 
-       if (t->type == SUN_TAG_LINUX_SWAP && !part->start_cylinder) {
+       if (t->code == SUN_TAG_LINUX_SWAP && !part->start_cylinder) {
            int yes, rc;
            rc = fdisk_ask_yesno(cxt,
              _("It is highly recommended that the partition at offset 0\n"
@@ -952,7 +954,7 @@ static int sun_set_parttype(
                    return 1;
        }
 
-       switch (t->type) {
+       switch (t->code) {
        case SUN_TAG_SWAP:
        case SUN_TAG_LINUX_SWAP:
                /* swaps are not mountable by default */
@@ -964,7 +966,7 @@ static int sun_set_parttype(
                info->flags &= ~cpu_to_be16(SUN_FLAG_UNMNT);
                break;
        }
-       info->id = cpu_to_be16(t->type);
+       info->id = cpu_to_be16(t->code);
        return 0;
 }
 
@@ -1045,7 +1047,7 @@ struct fdisk_label *fdisk_new_sun_label(struct fdisk_context *cxt)
        lb->id = FDISK_DISKLABEL_SUN;
        lb->op = &sun_operations;
        lb->parttypes = sun_parttypes;
-       lb->nparttypes = ARRAY_SIZE(sun_parttypes);
+       lb->nparttypes = ARRAY_SIZE(sun_parttypes) - 1;
        lb->fields = sun_fields;
        lb->nfields = ARRAY_SIZE(sun_fields);
        lb->flags |= FDISK_LABEL_FL_REQUIRE_GEOMETRY;